From ca7c56d86b1452d6dc31b8e698c2663d385ba897 Mon Sep 17 00:00:00 2001 From: Frank Denis Date: Thu, 26 May 2022 15:42:18 +0200 Subject: [PATCH] Generate code for the scalar field of standard curves fiat-crypto is already used for arithmetic on scalars, at least by the Zig standard library and in Rust (p384_rs, being merged into the p384 crate as we speak). So it may be useful to pregenerate and test this in fiat-crypto. This change adds support for the curve25519, p256, secp256k1 and p384 scalar fields. --- Makefile | 11 +- fiat-amd64/gentest.py | 6 +- fiat-bedrock2/src/curve25519_scalar_32.c | 4976 + fiat-bedrock2/src/curve25519_scalar_64.c | 1984 + fiat-bedrock2/src/p256_scalar_32.c | 5562 + fiat-bedrock2/src/p256_scalar_64.c | 2163 + fiat-bedrock2/src/p384_scalar_32.c | 11823 + fiat-bedrock2/src/p384_scalar_64.c | 3867 + fiat-bedrock2/src/secp256k1_scalar_32.c | 5871 + fiat-bedrock2/src/secp256k1_scalar_64.c | 2175 + fiat-c/src/curve25519_scalar_32.c | 5046 + fiat-c/src/curve25519_scalar_64.c | 2049 + fiat-c/src/p256_scalar_32.c | 5558 + fiat-c/src/p256_scalar_64.c | 2215 + fiat-c/src/p384_scalar_32.c | 11725 + fiat-c/src/p384_scalar_64.c | 3924 + fiat-c/src/secp256k1_scalar_32.c | 5849 + fiat-c/src/secp256k1_scalar_64.c | 2234 + .../32/curve25519scalar/curve25519scalar.go | 4657 + fiat-go/32/p256scalar/p256scalar.go | 5171 + fiat-go/32/p384scalar/p384scalar.go | 11206 + fiat-go/32/secp256k1scalar/secp256k1scalar.go | 5462 + .../64/curve25519scalar/curve25519scalar.go | 1723 + fiat-go/64/p256scalar/p256scalar.go | 1890 + fiat-go/64/p384scalar/p384scalar.go | 3502 + fiat-go/64/secp256k1scalar/secp256k1scalar.go | 1910 + fiat-java/src/FiatCurve25519Scalar.java | 4845 + fiat-java/src/FiatP256Scalar.java | 5359 + fiat-java/src/FiatP384Scalar.java | 11426 + fiat-java/src/FiatSecp256K1Scalar.java | 5650 + fiat-json/src/curve25519_scalar_32.json | 74132 ++++++ fiat-json/src/curve25519_scalar_64.json | 26554 +++ fiat-json/src/p256_scalar_32.json | 82238 +++++++ fiat-json/src/p256_scalar_64.json | 29169 +++ fiat-json/src/p384_scalar_32.json | 180117 +++++++++++++++ fiat-json/src/p384_scalar_64.json | 55884 +++++ fiat-json/src/secp256k1_scalar_32.json | 86988 +++++++ fiat-json/src/secp256k1_scalar_64.json | 29414 +++ fiat-rust/src/curve25519_scalar_32.rs | 4796 + fiat-rust/src/curve25519_scalar_64.rs | 1830 + fiat-rust/src/lib.rs | 8 + fiat-rust/src/p256_scalar_32.rs | 5310 + fiat-rust/src/p256_scalar_64.rs | 1997 + fiat-rust/src/p384_scalar_32.rs | 11377 + fiat-rust/src/p384_scalar_64.rs | 3625 + fiat-rust/src/secp256k1_scalar_32.rs | 5601 + fiat-rust/src/secp256k1_scalar_64.rs | 2017 + fiat-zig/src/curve25519_scalar_32.zig | 4822 + fiat-zig/src/curve25519_scalar_64.zig | 1856 + fiat-zig/src/p256_scalar_32.zig | 5336 + fiat-zig/src/p256_scalar_64.zig | 2023 + fiat-zig/src/p384_scalar_32.zig | 11403 + fiat-zig/src/p384_scalar_64.zig | 3651 + fiat-zig/src/secp256k1_scalar_32.zig | 5627 + fiat-zig/src/secp256k1_scalar_64.zig | 2043 + 55 files changed, 777653 insertions(+), 4 deletions(-) create mode 100644 fiat-bedrock2/src/curve25519_scalar_32.c create mode 100644 fiat-bedrock2/src/curve25519_scalar_64.c create mode 100644 fiat-bedrock2/src/p256_scalar_32.c create mode 100644 fiat-bedrock2/src/p256_scalar_64.c create mode 100644 fiat-bedrock2/src/p384_scalar_32.c create mode 100644 fiat-bedrock2/src/p384_scalar_64.c create mode 100644 fiat-bedrock2/src/secp256k1_scalar_32.c create mode 100644 fiat-bedrock2/src/secp256k1_scalar_64.c create mode 100644 fiat-c/src/curve25519_scalar_32.c create mode 100644 fiat-c/src/curve25519_scalar_64.c create mode 100644 fiat-c/src/p256_scalar_32.c create mode 100644 fiat-c/src/p256_scalar_64.c create mode 100644 fiat-c/src/p384_scalar_32.c create mode 100644 fiat-c/src/p384_scalar_64.c create mode 100644 fiat-c/src/secp256k1_scalar_32.c create mode 100644 fiat-c/src/secp256k1_scalar_64.c create mode 100644 fiat-go/32/curve25519scalar/curve25519scalar.go create mode 100644 fiat-go/32/p256scalar/p256scalar.go create mode 100644 fiat-go/32/p384scalar/p384scalar.go create mode 100644 fiat-go/32/secp256k1scalar/secp256k1scalar.go create mode 100644 fiat-go/64/curve25519scalar/curve25519scalar.go create mode 100644 fiat-go/64/p256scalar/p256scalar.go create mode 100644 fiat-go/64/p384scalar/p384scalar.go create mode 100644 fiat-go/64/secp256k1scalar/secp256k1scalar.go create mode 100644 fiat-java/src/FiatCurve25519Scalar.java create mode 100644 fiat-java/src/FiatP256Scalar.java create mode 100644 fiat-java/src/FiatP384Scalar.java create mode 100644 fiat-java/src/FiatSecp256K1Scalar.java create mode 100644 fiat-json/src/curve25519_scalar_32.json create mode 100644 fiat-json/src/curve25519_scalar_64.json create mode 100644 fiat-json/src/p256_scalar_32.json create mode 100644 fiat-json/src/p256_scalar_64.json create mode 100644 fiat-json/src/p384_scalar_32.json create mode 100644 fiat-json/src/p384_scalar_64.json create mode 100644 fiat-json/src/secp256k1_scalar_32.json create mode 100644 fiat-json/src/secp256k1_scalar_64.json create mode 100644 fiat-rust/src/curve25519_scalar_32.rs create mode 100644 fiat-rust/src/curve25519_scalar_64.rs create mode 100644 fiat-rust/src/p256_scalar_32.rs create mode 100644 fiat-rust/src/p256_scalar_64.rs create mode 100644 fiat-rust/src/p384_scalar_32.rs create mode 100644 fiat-rust/src/p384_scalar_64.rs create mode 100644 fiat-rust/src/secp256k1_scalar_32.rs create mode 100644 fiat-rust/src/secp256k1_scalar_64.rs create mode 100644 fiat-zig/src/curve25519_scalar_32.zig create mode 100644 fiat-zig/src/curve25519_scalar_64.zig create mode 100644 fiat-zig/src/p256_scalar_32.zig create mode 100644 fiat-zig/src/p256_scalar_64.zig create mode 100644 fiat-zig/src/p384_scalar_32.zig create mode 100644 fiat-zig/src/p384_scalar_64.zig create mode 100644 fiat-zig/src/secp256k1_scalar_32.zig create mode 100644 fiat-zig/src/secp256k1_scalar_64.zig diff --git a/Makefile b/Makefile index 3a89476c43..bab29eae5b 100644 --- a/Makefile +++ b/Makefile @@ -226,8 +226,7 @@ ZIG_DIR := fiat-zig/src/ # Java only really supports 32-bit builds, because we have neither 64x64->64x64 multiplication, nor uint128 # Java also requires that class names match file names -# from https://stackoverflow.com/q/42925485/377022 -to_title_case = $(shell echo '$(1)' | sed 's/.*/\L&/; s/[a-z]*/\u&/g') +to_title_case = $(shell echo '$(1)' | awk '{split($$0,w,"");u=1;for(i=1;i<=length(w);i++){c=tolower(w[i]);if(u)c=toupper(c);u=0;if(c~/[a-zA-Z0-9]/)printf("%s",c);if(c~/[^a-zA-Z]/)u=1;}}') empty= space=$(empty) $(empty) JAVA_RENAME = $(foreach i,$(patsubst %_32,%,$(filter %_32,$(1))),Fiat$(subst $(space),,$(call to_title_case,$(subst _, ,$(i))))) @@ -293,8 +292,14 @@ $(foreach bw,64 32,$(eval $(call add_curve_keys,p384_$(bw),WORD_BY_WORD_MONTGOME $(foreach bw,64 32,$(eval $(call add_curve_keys,p224_$(bw),WORD_BY_WORD_MONTGOMERY,'p224',$(bw),'2^224 - 2^96 + 1',$(WORD_BY_WORD_MONTGOMERY_FUNCTIONS),WORD_BY_WORD_MONTGOMERY))) $(foreach bw,64,$(eval $(call add_curve_keys,p434_$(bw),WORD_BY_WORD_MONTGOMERY,'p434',$(bw),'2^216 * 3^137 - 1',$(WORD_BY_WORD_MONTGOMERY_FUNCTIONS),WORD_BY_WORD_MONTGOMERY))) # 32 is a bit too heavy +$(foreach bw,64 32,$(eval $(call add_curve_keys,curve25519_scalar_$(bw),WORD_BY_WORD_MONTGOMERY,'25519_scalar',$(bw),'2^252 + 27742317777372353535851937790883648493',$(WORD_BY_WORD_MONTGOMERY_FUNCTIONS),WORD_BY_WORD_MONTGOMERY))) +$(foreach bw,64 32,$(eval $(call add_curve_keys,p256_scalar_$(bw),WORD_BY_WORD_MONTGOMERY,'p256_scalar',$(bw),'2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247',$(WORD_BY_WORD_MONTGOMERY_FUNCTIONS),WORD_BY_WORD_MONTGOMERY))) +$(foreach bw,64 32,$(eval $(call add_curve_keys,p384_scalar_$(bw),WORD_BY_WORD_MONTGOMERY,'p384_scalar',$(bw),'2^384 - 1388124618062372383947042015309946732620727252194336364173',$(WORD_BY_WORD_MONTGOMERY_FUNCTIONS),WORD_BY_WORD_MONTGOMERY))) +$(foreach bw,64 32,$(eval $(call add_curve_keys,secp256k1_scalar_$(bw),WORD_BY_WORD_MONTGOMERY,'secp256k1_scalar',$(bw),'2^256 - 432420386565659656852420866394968145599',$(WORD_BY_WORD_MONTGOMERY_FUNCTIONS),WORD_BY_WORD_MONTGOMERY))) + # Files taking 30s or less -LITE_BASE_FILES := curve25519_64 poly1305_64 poly1305_32 p256_64 secp256k1_64 p384_64 p224_32 p434_64 p448_solinas_64 secp256k1_32 p256_32 p448_solinas_32 +LITE_BASE_FILES := curve25519_64 poly1305_64 poly1305_32 p256_64 secp256k1_64 p384_64 p224_32 p434_64 p448_solinas_64 secp256k1_32 p256_32 p448_solinas_32 \ + curve25519_scalar_64 p256_scalar_64 secp256k1_scalar_64 p384_scalar_64 secp256k1_scalar_32 p256_scalar_32 EXTRA_C_FILES := inversion/c/*_test.c diff --git a/fiat-amd64/gentest.py b/fiat-amd64/gentest.py index aa913d8042..7b441b04ee 100755 --- a/fiat-amd64/gentest.py +++ b/fiat-amd64/gentest.py @@ -20,11 +20,15 @@ def removeprefix(s, prefix): poly1305=('3', '2^130 - 5')) montgomeryprimes = dict( + curve25519_scalar='2^252 + 27742317777372353535851937790883648493', p224='2^224 - 2^96 + 1', p256='2^256 - 2^224 + 2^192 + 2^96 - 1', + p256_scalar='2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247', p384='2^384 - 2^128 - 2^96 + 2^32 - 1', + p384_scalar='2^384 - 1388124618062372383947042015309946732620727252194336364173', p434='2^216 * 3^137 - 1', - secp256k1='2^256 - 2^32 - 977') + secp256k1='2^256 - 2^32 - 977', + secp256k1_scalar='2^256 - 432420386565659656852420866394968145599') output_makefile = ('--makefile' in sys.argv[1:]) asm_files = tuple(i for i in sys.argv[1:] if i not in ('--makefile',)) diff --git a/fiat-bedrock2/src/curve25519_scalar_32.c b/fiat-bedrock2/src/curve25519_scalar_32.c new file mode 100644 index 0000000000..5928d002f7 --- /dev/null +++ b/fiat-bedrock2/src/curve25519_scalar_32.c @@ -0,0 +1,4976 @@ +/* Autogenerated: 'src/ExtractionOCaml/bedrock2_word_by_word_montgomery' --lang bedrock2 --static --no-wide-int --widen-carry --widen-bytes --split-multiret --no-select --no-field-element-typedefs 25519_scalar 32 '2^252 + 27742317777372353535851937790883648493' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: 25519_scalar */ +/* machine_wordsize = 32 (from "32") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed (from "2^252 + 27742317777372353535851937790883648493") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +#include + +// We use memcpy to work around -fstrict-aliasing. +// A plain memcpy is enough on clang 10, but not on gcc 10, which fails +// to infer the bounds on an integer loaded by memcpy. +// Adding a range mask after memcpy in turn makes slower code in clang. +// Loading individual bytes, shifting them together, and or-ing is fast +// on clang and sometimes on GCC, but other times GCC inlines individual +// byte operations without reconstructing wider accesses. +// The little-endian idiom below seems fast in gcc 9+ and clang 10. +static __attribute__((always_inline)) inline uintptr_t +_br2_load(uintptr_t a, uintptr_t sz) { + switch (sz) { + case 1: { uint8_t r = 0; memcpy(&r, (void*)a, 1); return r; } + case 2: { uint16_t r = 0; memcpy(&r, (void*)a, 2); return r; } + case 4: { uint32_t r = 0; memcpy(&r, (void*)a, 4); return r; } + case 8: { uint64_t r = 0; memcpy(&r, (void*)a, 8); return r; } + default: __builtin_unreachable(); + } +} + +static __attribute__((always_inline)) inline void +_br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) { + memcpy((void*)a, &v, sz); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_25519_scalar_mul(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x1, x2, x3, x4, x5, x6, x7, x0, x23, x36, x39, x41, x37, x42, x34, x43, x45, x46, x35, x47, x32, x48, x50, x51, x33, x52, x30, x53, x55, x56, x31, x57, x28, x58, x60, x61, x29, x62, x26, x63, x65, x66, x27, x67, x24, x68, x70, x71, x25, x73, x80, x83, x85, x81, x86, x78, x87, x89, x90, x79, x91, x76, x92, x94, x95, x77, x82, x97, x38, x98, x40, x99, x84, x100, x102, x103, x44, x104, x88, x105, x107, x108, x49, x109, x93, x110, x112, x113, x54, x114, x96, x115, x117, x118, x59, x120, x64, x122, x69, x123, x74, x124, x126, x127, x72, x128, x75, x129, x131, x16, x145, x148, x150, x146, x151, x143, x152, x154, x155, x144, x156, x141, x157, x159, x160, x142, x161, x139, x162, x164, x165, x140, x166, x137, x167, x169, x170, x138, x171, x135, x172, x174, x175, x136, x176, x133, x177, x179, x180, x134, x147, x101, x183, x106, x184, x149, x185, x187, x188, x111, x189, x153, x190, x192, x193, x116, x194, x158, x195, x197, x198, x119, x199, x163, x200, x202, x203, x121, x204, x168, x205, x207, x208, x125, x209, x173, x210, x212, x213, x130, x214, x178, x215, x217, x218, x132, x219, x181, x220, x222, x224, x231, x234, x236, x232, x237, x229, x238, x240, x241, x230, x242, x227, x243, x245, x246, x228, x233, x248, x182, x249, x186, x250, x235, x251, x253, x254, x191, x255, x239, x256, x258, x259, x196, x260, x244, x261, x263, x264, x201, x265, x247, x266, x268, x269, x206, x271, x211, x273, x216, x274, x225, x275, x277, x278, x221, x279, x226, x280, x282, x283, x223, x17, x297, x300, x302, x298, x303, x295, x304, x306, x307, x296, x308, x293, x309, x311, x312, x294, x313, x291, x314, x316, x317, x292, x318, x289, x319, x321, x322, x290, x323, x287, x324, x326, x327, x288, x328, x285, x329, x331, x332, x286, x299, x252, x335, x257, x336, x301, x337, x339, x340, x262, x341, x305, x342, x344, x345, x267, x346, x310, x347, x349, x350, x270, x351, x315, x352, x354, x355, x272, x356, x320, x357, x359, x360, x276, x361, x325, x362, x364, x365, x281, x366, x330, x367, x369, x370, x284, x371, x333, x372, x374, x376, x383, x386, x388, x384, x389, x381, x390, x392, x393, x382, x394, x379, x395, x397, x398, x380, x385, x400, x334, x401, x338, x402, x387, x403, x405, x406, x343, x407, x391, x408, x410, x411, x348, x412, x396, x413, x415, x416, x353, x417, x399, x418, x420, x421, x358, x423, x363, x425, x368, x426, x377, x427, x429, x430, x373, x431, x378, x432, x434, x435, x375, x18, x449, x452, x454, x450, x455, x447, x456, x458, x459, x448, x460, x445, x461, x463, x464, x446, x465, x443, x466, x468, x469, x444, x470, x441, x471, x473, x474, x442, x475, x439, x476, x478, x479, x440, x480, x437, x481, x483, x484, x438, x451, x404, x487, x409, x488, x453, x489, x491, x492, x414, x493, x457, x494, x496, x497, x419, x498, x462, x499, x501, x502, x422, x503, x467, x504, x506, x507, x424, x508, x472, x509, x511, x512, x428, x513, x477, x514, x516, x517, x433, x518, x482, x519, x521, x522, x436, x523, x485, x524, x526, x528, x535, x538, x540, x536, x541, x533, x542, x544, x545, x534, x546, x531, x547, x549, x550, x532, x537, x552, x486, x553, x490, x554, x539, x555, x557, x558, x495, x559, x543, x560, x562, x563, x500, x564, x548, x565, x567, x568, x505, x569, x551, x570, x572, x573, x510, x575, x515, x577, x520, x578, x529, x579, x581, x582, x525, x583, x530, x584, x586, x587, x527, x19, x601, x604, x606, x602, x607, x599, x608, x610, x611, x600, x612, x597, x613, x615, x616, x598, x617, x595, x618, x620, x621, x596, x622, x593, x623, x625, x626, x594, x627, x591, x628, x630, x631, x592, x632, x589, x633, x635, x636, x590, x603, x556, x639, x561, x640, x605, x641, x643, x644, x566, x645, x609, x646, x648, x649, x571, x650, x614, x651, x653, x654, x574, x655, x619, x656, x658, x659, x576, x660, x624, x661, x663, x664, x580, x665, x629, x666, x668, x669, x585, x670, x634, x671, x673, x674, x588, x675, x637, x676, x678, x680, x687, x690, x692, x688, x693, x685, x694, x696, x697, x686, x698, x683, x699, x701, x702, x684, x689, x704, x638, x705, x642, x706, x691, x707, x709, x710, x647, x711, x695, x712, x714, x715, x652, x716, x700, x717, x719, x720, x657, x721, x703, x722, x724, x725, x662, x727, x667, x729, x672, x730, x681, x731, x733, x734, x677, x735, x682, x736, x738, x739, x679, x20, x753, x756, x758, x754, x759, x751, x760, x762, x763, x752, x764, x749, x765, x767, x768, x750, x769, x747, x770, x772, x773, x748, x774, x745, x775, x777, x778, x746, x779, x743, x780, x782, x783, x744, x784, x741, x785, x787, x788, x742, x755, x708, x791, x713, x792, x757, x793, x795, x796, x718, x797, x761, x798, x800, x801, x723, x802, x766, x803, x805, x806, x726, x807, x771, x808, x810, x811, x728, x812, x776, x813, x815, x816, x732, x817, x781, x818, x820, x821, x737, x822, x786, x823, x825, x826, x740, x827, x789, x828, x830, x832, x839, x842, x844, x840, x845, x837, x846, x848, x849, x838, x850, x835, x851, x853, x854, x836, x841, x856, x790, x857, x794, x858, x843, x859, x861, x862, x799, x863, x847, x864, x866, x867, x804, x868, x852, x869, x871, x872, x809, x873, x855, x874, x876, x877, x814, x879, x819, x881, x824, x882, x833, x883, x885, x886, x829, x887, x834, x888, x890, x891, x831, x21, x905, x908, x910, x906, x911, x903, x912, x914, x915, x904, x916, x901, x917, x919, x920, x902, x921, x899, x922, x924, x925, x900, x926, x897, x927, x929, x930, x898, x931, x895, x932, x934, x935, x896, x936, x893, x937, x939, x940, x894, x907, x860, x943, x865, x944, x909, x945, x947, x948, x870, x949, x913, x950, x952, x953, x875, x954, x918, x955, x957, x958, x878, x959, x923, x960, x962, x963, x880, x964, x928, x965, x967, x968, x884, x969, x933, x970, x972, x973, x889, x974, x938, x975, x977, x978, x892, x979, x941, x980, x982, x984, x991, x994, x996, x992, x997, x989, x998, x1000, x1001, x990, x1002, x987, x1003, x1005, x1006, x988, x993, x1008, x942, x1009, x946, x1010, x995, x1011, x1013, x1014, x951, x1015, x999, x1016, x1018, x1019, x956, x1020, x1004, x1021, x1023, x1024, x961, x1025, x1007, x1026, x1028, x1029, x966, x1031, x971, x1033, x976, x1034, x985, x1035, x1037, x1038, x981, x1039, x986, x1040, x1042, x1043, x983, x15, x14, x13, x12, x11, x10, x9, x22, x8, x1057, x1060, x1062, x1058, x1063, x1055, x1064, x1066, x1067, x1056, x1068, x1053, x1069, x1071, x1072, x1054, x1073, x1051, x1074, x1076, x1077, x1052, x1078, x1049, x1079, x1081, x1082, x1050, x1083, x1047, x1084, x1086, x1087, x1048, x1088, x1045, x1089, x1091, x1092, x1046, x1059, x1012, x1095, x1017, x1096, x1061, x1097, x1099, x1100, x1022, x1101, x1065, x1102, x1104, x1105, x1027, x1106, x1070, x1107, x1109, x1110, x1030, x1111, x1075, x1112, x1114, x1115, x1032, x1116, x1080, x1117, x1119, x1120, x1036, x1121, x1085, x1122, x1124, x1125, x1041, x1126, x1090, x1127, x1129, x1130, x1044, x1131, x1093, x1132, x1134, x1136, x1143, x1146, x1148, x1144, x1149, x1141, x1150, x1152, x1153, x1142, x1154, x1139, x1155, x1157, x1158, x1140, x1145, x1160, x1094, x1161, x1098, x1162, x1147, x1163, x1165, x1166, x1103, x1167, x1151, x1168, x1170, x1171, x1108, x1172, x1156, x1173, x1175, x1176, x1113, x1177, x1159, x1178, x1180, x1181, x1118, x1183, x1123, x1185, x1128, x1186, x1137, x1187, x1189, x1190, x1133, x1191, x1138, x1192, x1194, x1195, x1135, x1198, x1199, x1200, x1202, x1203, x1204, x1205, x1207, x1208, x1209, x1210, x1212, x1213, x1215, x1217, x1219, x1220, x1221, x1223, x1224, x1196, x1225, x1164, x1227, x1197, x1228, x1169, x1230, x1201, x1231, x1174, x1233, x1206, x1234, x1179, x1236, x1211, x1237, x1182, x1239, x1214, x1240, x1184, x1242, x1216, x1243, x1188, x1245, x1218, x1246, x1226, x1193, x1248, x1222, x1249, x1229, x1232, x1235, x1238, x1241, x1244, x1247, x1250, x1251, x1252, x1253, x1254, x1255, x1256, x1257, x1258; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = x1; + x17 = x2; + x18 = x3; + x19 = x4; + x20 = x5; + x21 = x6; + x22 = x7; + x23 = x0; + x24 = (x23)*(x15); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x15))>>32 : ((__uint128_t)(x23)*(x15))>>64); + x26 = (x23)*(x14); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x14))>>32 : ((__uint128_t)(x23)*(x14))>>64); + x28 = (x23)*(x13); + x29 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x13))>>32 : ((__uint128_t)(x23)*(x13))>>64); + x30 = (x23)*(x12); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x12))>>32 : ((__uint128_t)(x23)*(x12))>>64); + x32 = (x23)*(x11); + x33 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x11))>>32 : ((__uint128_t)(x23)*(x11))>>64); + x34 = (x23)*(x10); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x10))>>32 : ((__uint128_t)(x23)*(x10))>>64); + x36 = (x23)*(x9); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x9))>>32 : ((__uint128_t)(x23)*(x9))>>64); + x38 = (x23)*(x8); + x39 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x8))>>32 : ((__uint128_t)(x23)*(x8))>>64); + x40 = (x39)+(x36); + x41 = (uintptr_t)((x40)<(x39)); + x42 = (x41)+(x37); + x43 = (uintptr_t)((x42)<(x37)); + x44 = (x42)+(x34); + x45 = (uintptr_t)((x44)<(x34)); + x46 = (x43)+(x45); + x47 = (x46)+(x35); + x48 = (uintptr_t)((x47)<(x35)); + x49 = (x47)+(x32); + x50 = (uintptr_t)((x49)<(x32)); + x51 = (x48)+(x50); + x52 = (x51)+(x33); + x53 = (uintptr_t)((x52)<(x33)); + x54 = (x52)+(x30); + x55 = (uintptr_t)((x54)<(x30)); + x56 = (x53)+(x55); + x57 = (x56)+(x31); + x58 = (uintptr_t)((x57)<(x31)); + x59 = (x57)+(x28); + x60 = (uintptr_t)((x59)<(x28)); + x61 = (x58)+(x60); + x62 = (x61)+(x29); + x63 = (uintptr_t)((x62)<(x29)); + x64 = (x62)+(x26); + x65 = (uintptr_t)((x64)<(x26)); + x66 = (x63)+(x65); + x67 = (x66)+(x27); + x68 = (uintptr_t)((x67)<(x27)); + x69 = (x67)+(x24); + x70 = (uintptr_t)((x69)<(x24)); + x71 = (x68)+(x70); + x72 = (x71)+(x25); + x73 = (x38)*((uintptr_t)307527195ULL); + x74 = (x73)*((uintptr_t)268435456ULL); + x75 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)268435456ULL))>>64); + x76 = (x73)*((uintptr_t)350157278ULL); + x77 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)350157278ULL))>>64); + x78 = (x73)*((uintptr_t)2734136534ULL); + x79 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)2734136534ULL))>>64); + x80 = (x73)*((uintptr_t)1477600026ULL); + x81 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)1477600026ULL))>>64); + x82 = (x73)*((uintptr_t)1559614445ULL); + x83 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)1559614445ULL))>>64); + x84 = (x83)+(x80); + x85 = (uintptr_t)((x84)<(x83)); + x86 = (x85)+(x81); + x87 = (uintptr_t)((x86)<(x81)); + x88 = (x86)+(x78); + x89 = (uintptr_t)((x88)<(x78)); + x90 = (x87)+(x89); + x91 = (x90)+(x79); + x92 = (uintptr_t)((x91)<(x79)); + x93 = (x91)+(x76); + x94 = (uintptr_t)((x93)<(x76)); + x95 = (x92)+(x94); + x96 = (x95)+(x77); + x97 = (x38)+(x82); + x98 = (uintptr_t)((x97)<(x38)); + x99 = (x98)+(x40); + x100 = (uintptr_t)((x99)<(x40)); + x101 = (x99)+(x84); + x102 = (uintptr_t)((x101)<(x84)); + x103 = (x100)+(x102); + x104 = (x103)+(x44); + x105 = (uintptr_t)((x104)<(x44)); + x106 = (x104)+(x88); + x107 = (uintptr_t)((x106)<(x88)); + x108 = (x105)+(x107); + x109 = (x108)+(x49); + x110 = (uintptr_t)((x109)<(x49)); + x111 = (x109)+(x93); + x112 = (uintptr_t)((x111)<(x93)); + x113 = (x110)+(x112); + x114 = (x113)+(x54); + x115 = (uintptr_t)((x114)<(x54)); + x116 = (x114)+(x96); + x117 = (uintptr_t)((x116)<(x96)); + x118 = (x115)+(x117); + x119 = (x118)+(x59); + x120 = (uintptr_t)((x119)<(x59)); + x121 = (x120)+(x64); + x122 = (uintptr_t)((x121)<(x64)); + x123 = (x122)+(x69); + x124 = (uintptr_t)((x123)<(x69)); + x125 = (x123)+(x74); + x126 = (uintptr_t)((x125)<(x74)); + x127 = (x124)+(x126); + x128 = (x127)+(x72); + x129 = (uintptr_t)((x128)<(x72)); + x130 = (x128)+(x75); + x131 = (uintptr_t)((x130)<(x75)); + x132 = (x129)+(x131); + x133 = (x16)*(x15); + x134 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x15))>>32 : ((__uint128_t)(x16)*(x15))>>64); + x135 = (x16)*(x14); + x136 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x14))>>32 : ((__uint128_t)(x16)*(x14))>>64); + x137 = (x16)*(x13); + x138 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x13))>>32 : ((__uint128_t)(x16)*(x13))>>64); + x139 = (x16)*(x12); + x140 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x12))>>32 : ((__uint128_t)(x16)*(x12))>>64); + x141 = (x16)*(x11); + x142 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x11))>>32 : ((__uint128_t)(x16)*(x11))>>64); + x143 = (x16)*(x10); + x144 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x10))>>32 : ((__uint128_t)(x16)*(x10))>>64); + x145 = (x16)*(x9); + x146 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x9))>>32 : ((__uint128_t)(x16)*(x9))>>64); + x147 = (x16)*(x8); + x148 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x8))>>32 : ((__uint128_t)(x16)*(x8))>>64); + x149 = (x148)+(x145); + x150 = (uintptr_t)((x149)<(x148)); + x151 = (x150)+(x146); + x152 = (uintptr_t)((x151)<(x146)); + x153 = (x151)+(x143); + x154 = (uintptr_t)((x153)<(x143)); + x155 = (x152)+(x154); + x156 = (x155)+(x144); + x157 = (uintptr_t)((x156)<(x144)); + x158 = (x156)+(x141); + x159 = (uintptr_t)((x158)<(x141)); + x160 = (x157)+(x159); + x161 = (x160)+(x142); + x162 = (uintptr_t)((x161)<(x142)); + x163 = (x161)+(x139); + x164 = (uintptr_t)((x163)<(x139)); + x165 = (x162)+(x164); + x166 = (x165)+(x140); + x167 = (uintptr_t)((x166)<(x140)); + x168 = (x166)+(x137); + x169 = (uintptr_t)((x168)<(x137)); + x170 = (x167)+(x169); + x171 = (x170)+(x138); + x172 = (uintptr_t)((x171)<(x138)); + x173 = (x171)+(x135); + x174 = (uintptr_t)((x173)<(x135)); + x175 = (x172)+(x174); + x176 = (x175)+(x136); + x177 = (uintptr_t)((x176)<(x136)); + x178 = (x176)+(x133); + x179 = (uintptr_t)((x178)<(x133)); + x180 = (x177)+(x179); + x181 = (x180)+(x134); + x182 = (x101)+(x147); + x183 = (uintptr_t)((x182)<(x101)); + x184 = (x183)+(x106); + x185 = (uintptr_t)((x184)<(x106)); + x186 = (x184)+(x149); + x187 = (uintptr_t)((x186)<(x149)); + x188 = (x185)+(x187); + x189 = (x188)+(x111); + x190 = (uintptr_t)((x189)<(x111)); + x191 = (x189)+(x153); + x192 = (uintptr_t)((x191)<(x153)); + x193 = (x190)+(x192); + x194 = (x193)+(x116); + x195 = (uintptr_t)((x194)<(x116)); + x196 = (x194)+(x158); + x197 = (uintptr_t)((x196)<(x158)); + x198 = (x195)+(x197); + x199 = (x198)+(x119); + x200 = (uintptr_t)((x199)<(x119)); + x201 = (x199)+(x163); + x202 = (uintptr_t)((x201)<(x163)); + x203 = (x200)+(x202); + x204 = (x203)+(x121); + x205 = (uintptr_t)((x204)<(x121)); + x206 = (x204)+(x168); + x207 = (uintptr_t)((x206)<(x168)); + x208 = (x205)+(x207); + x209 = (x208)+(x125); + x210 = (uintptr_t)((x209)<(x125)); + x211 = (x209)+(x173); + x212 = (uintptr_t)((x211)<(x173)); + x213 = (x210)+(x212); + x214 = (x213)+(x130); + x215 = (uintptr_t)((x214)<(x130)); + x216 = (x214)+(x178); + x217 = (uintptr_t)((x216)<(x178)); + x218 = (x215)+(x217); + x219 = (x218)+(x132); + x220 = (uintptr_t)((x219)<(x132)); + x221 = (x219)+(x181); + x222 = (uintptr_t)((x221)<(x181)); + x223 = (x220)+(x222); + x224 = (x182)*((uintptr_t)307527195ULL); + x225 = (x224)*((uintptr_t)268435456ULL); + x226 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x224)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x224)*((uintptr_t)268435456ULL))>>64); + x227 = (x224)*((uintptr_t)350157278ULL); + x228 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x224)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x224)*((uintptr_t)350157278ULL))>>64); + x229 = (x224)*((uintptr_t)2734136534ULL); + x230 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x224)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x224)*((uintptr_t)2734136534ULL))>>64); + x231 = (x224)*((uintptr_t)1477600026ULL); + x232 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x224)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x224)*((uintptr_t)1477600026ULL))>>64); + x233 = (x224)*((uintptr_t)1559614445ULL); + x234 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x224)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x224)*((uintptr_t)1559614445ULL))>>64); + x235 = (x234)+(x231); + x236 = (uintptr_t)((x235)<(x234)); + x237 = (x236)+(x232); + x238 = (uintptr_t)((x237)<(x232)); + x239 = (x237)+(x229); + x240 = (uintptr_t)((x239)<(x229)); + x241 = (x238)+(x240); + x242 = (x241)+(x230); + x243 = (uintptr_t)((x242)<(x230)); + x244 = (x242)+(x227); + x245 = (uintptr_t)((x244)<(x227)); + x246 = (x243)+(x245); + x247 = (x246)+(x228); + x248 = (x182)+(x233); + x249 = (uintptr_t)((x248)<(x182)); + x250 = (x249)+(x186); + x251 = (uintptr_t)((x250)<(x186)); + x252 = (x250)+(x235); + x253 = (uintptr_t)((x252)<(x235)); + x254 = (x251)+(x253); + x255 = (x254)+(x191); + x256 = (uintptr_t)((x255)<(x191)); + x257 = (x255)+(x239); + x258 = (uintptr_t)((x257)<(x239)); + x259 = (x256)+(x258); + x260 = (x259)+(x196); + x261 = (uintptr_t)((x260)<(x196)); + x262 = (x260)+(x244); + x263 = (uintptr_t)((x262)<(x244)); + x264 = (x261)+(x263); + x265 = (x264)+(x201); + x266 = (uintptr_t)((x265)<(x201)); + x267 = (x265)+(x247); + x268 = (uintptr_t)((x267)<(x247)); + x269 = (x266)+(x268); + x270 = (x269)+(x206); + x271 = (uintptr_t)((x270)<(x206)); + x272 = (x271)+(x211); + x273 = (uintptr_t)((x272)<(x211)); + x274 = (x273)+(x216); + x275 = (uintptr_t)((x274)<(x216)); + x276 = (x274)+(x225); + x277 = (uintptr_t)((x276)<(x225)); + x278 = (x275)+(x277); + x279 = (x278)+(x221); + x280 = (uintptr_t)((x279)<(x221)); + x281 = (x279)+(x226); + x282 = (uintptr_t)((x281)<(x226)); + x283 = (x280)+(x282); + x284 = (x283)+(x223); + x285 = (x17)*(x15); + x286 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x15))>>32 : ((__uint128_t)(x17)*(x15))>>64); + x287 = (x17)*(x14); + x288 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x14))>>32 : ((__uint128_t)(x17)*(x14))>>64); + x289 = (x17)*(x13); + x290 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x13))>>32 : ((__uint128_t)(x17)*(x13))>>64); + x291 = (x17)*(x12); + x292 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x12))>>32 : ((__uint128_t)(x17)*(x12))>>64); + x293 = (x17)*(x11); + x294 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x11))>>32 : ((__uint128_t)(x17)*(x11))>>64); + x295 = (x17)*(x10); + x296 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x10))>>32 : ((__uint128_t)(x17)*(x10))>>64); + x297 = (x17)*(x9); + x298 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x9))>>32 : ((__uint128_t)(x17)*(x9))>>64); + x299 = (x17)*(x8); + x300 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x8))>>32 : ((__uint128_t)(x17)*(x8))>>64); + x301 = (x300)+(x297); + x302 = (uintptr_t)((x301)<(x300)); + x303 = (x302)+(x298); + x304 = (uintptr_t)((x303)<(x298)); + x305 = (x303)+(x295); + x306 = (uintptr_t)((x305)<(x295)); + x307 = (x304)+(x306); + x308 = (x307)+(x296); + x309 = (uintptr_t)((x308)<(x296)); + x310 = (x308)+(x293); + x311 = (uintptr_t)((x310)<(x293)); + x312 = (x309)+(x311); + x313 = (x312)+(x294); + x314 = (uintptr_t)((x313)<(x294)); + x315 = (x313)+(x291); + x316 = (uintptr_t)((x315)<(x291)); + x317 = (x314)+(x316); + x318 = (x317)+(x292); + x319 = (uintptr_t)((x318)<(x292)); + x320 = (x318)+(x289); + x321 = (uintptr_t)((x320)<(x289)); + x322 = (x319)+(x321); + x323 = (x322)+(x290); + x324 = (uintptr_t)((x323)<(x290)); + x325 = (x323)+(x287); + x326 = (uintptr_t)((x325)<(x287)); + x327 = (x324)+(x326); + x328 = (x327)+(x288); + x329 = (uintptr_t)((x328)<(x288)); + x330 = (x328)+(x285); + x331 = (uintptr_t)((x330)<(x285)); + x332 = (x329)+(x331); + x333 = (x332)+(x286); + x334 = (x252)+(x299); + x335 = (uintptr_t)((x334)<(x252)); + x336 = (x335)+(x257); + x337 = (uintptr_t)((x336)<(x257)); + x338 = (x336)+(x301); + x339 = (uintptr_t)((x338)<(x301)); + x340 = (x337)+(x339); + x341 = (x340)+(x262); + x342 = (uintptr_t)((x341)<(x262)); + x343 = (x341)+(x305); + x344 = (uintptr_t)((x343)<(x305)); + x345 = (x342)+(x344); + x346 = (x345)+(x267); + x347 = (uintptr_t)((x346)<(x267)); + x348 = (x346)+(x310); + x349 = (uintptr_t)((x348)<(x310)); + x350 = (x347)+(x349); + x351 = (x350)+(x270); + x352 = (uintptr_t)((x351)<(x270)); + x353 = (x351)+(x315); + x354 = (uintptr_t)((x353)<(x315)); + x355 = (x352)+(x354); + x356 = (x355)+(x272); + x357 = (uintptr_t)((x356)<(x272)); + x358 = (x356)+(x320); + x359 = (uintptr_t)((x358)<(x320)); + x360 = (x357)+(x359); + x361 = (x360)+(x276); + x362 = (uintptr_t)((x361)<(x276)); + x363 = (x361)+(x325); + x364 = (uintptr_t)((x363)<(x325)); + x365 = (x362)+(x364); + x366 = (x365)+(x281); + x367 = (uintptr_t)((x366)<(x281)); + x368 = (x366)+(x330); + x369 = (uintptr_t)((x368)<(x330)); + x370 = (x367)+(x369); + x371 = (x370)+(x284); + x372 = (uintptr_t)((x371)<(x284)); + x373 = (x371)+(x333); + x374 = (uintptr_t)((x373)<(x333)); + x375 = (x372)+(x374); + x376 = (x334)*((uintptr_t)307527195ULL); + x377 = (x376)*((uintptr_t)268435456ULL); + x378 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x376)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x376)*((uintptr_t)268435456ULL))>>64); + x379 = (x376)*((uintptr_t)350157278ULL); + x380 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x376)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x376)*((uintptr_t)350157278ULL))>>64); + x381 = (x376)*((uintptr_t)2734136534ULL); + x382 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x376)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x376)*((uintptr_t)2734136534ULL))>>64); + x383 = (x376)*((uintptr_t)1477600026ULL); + x384 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x376)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x376)*((uintptr_t)1477600026ULL))>>64); + x385 = (x376)*((uintptr_t)1559614445ULL); + x386 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x376)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x376)*((uintptr_t)1559614445ULL))>>64); + x387 = (x386)+(x383); + x388 = (uintptr_t)((x387)<(x386)); + x389 = (x388)+(x384); + x390 = (uintptr_t)((x389)<(x384)); + x391 = (x389)+(x381); + x392 = (uintptr_t)((x391)<(x381)); + x393 = (x390)+(x392); + x394 = (x393)+(x382); + x395 = (uintptr_t)((x394)<(x382)); + x396 = (x394)+(x379); + x397 = (uintptr_t)((x396)<(x379)); + x398 = (x395)+(x397); + x399 = (x398)+(x380); + x400 = (x334)+(x385); + x401 = (uintptr_t)((x400)<(x334)); + x402 = (x401)+(x338); + x403 = (uintptr_t)((x402)<(x338)); + x404 = (x402)+(x387); + x405 = (uintptr_t)((x404)<(x387)); + x406 = (x403)+(x405); + x407 = (x406)+(x343); + x408 = (uintptr_t)((x407)<(x343)); + x409 = (x407)+(x391); + x410 = (uintptr_t)((x409)<(x391)); + x411 = (x408)+(x410); + x412 = (x411)+(x348); + x413 = (uintptr_t)((x412)<(x348)); + x414 = (x412)+(x396); + x415 = (uintptr_t)((x414)<(x396)); + x416 = (x413)+(x415); + x417 = (x416)+(x353); + x418 = (uintptr_t)((x417)<(x353)); + x419 = (x417)+(x399); + x420 = (uintptr_t)((x419)<(x399)); + x421 = (x418)+(x420); + x422 = (x421)+(x358); + x423 = (uintptr_t)((x422)<(x358)); + x424 = (x423)+(x363); + x425 = (uintptr_t)((x424)<(x363)); + x426 = (x425)+(x368); + x427 = (uintptr_t)((x426)<(x368)); + x428 = (x426)+(x377); + x429 = (uintptr_t)((x428)<(x377)); + x430 = (x427)+(x429); + x431 = (x430)+(x373); + x432 = (uintptr_t)((x431)<(x373)); + x433 = (x431)+(x378); + x434 = (uintptr_t)((x433)<(x378)); + x435 = (x432)+(x434); + x436 = (x435)+(x375); + x437 = (x18)*(x15); + x438 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x15))>>32 : ((__uint128_t)(x18)*(x15))>>64); + x439 = (x18)*(x14); + x440 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x14))>>32 : ((__uint128_t)(x18)*(x14))>>64); + x441 = (x18)*(x13); + x442 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x13))>>32 : ((__uint128_t)(x18)*(x13))>>64); + x443 = (x18)*(x12); + x444 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x12))>>32 : ((__uint128_t)(x18)*(x12))>>64); + x445 = (x18)*(x11); + x446 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x11))>>32 : ((__uint128_t)(x18)*(x11))>>64); + x447 = (x18)*(x10); + x448 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x10))>>32 : ((__uint128_t)(x18)*(x10))>>64); + x449 = (x18)*(x9); + x450 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x9))>>32 : ((__uint128_t)(x18)*(x9))>>64); + x451 = (x18)*(x8); + x452 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x8))>>32 : ((__uint128_t)(x18)*(x8))>>64); + x453 = (x452)+(x449); + x454 = (uintptr_t)((x453)<(x452)); + x455 = (x454)+(x450); + x456 = (uintptr_t)((x455)<(x450)); + x457 = (x455)+(x447); + x458 = (uintptr_t)((x457)<(x447)); + x459 = (x456)+(x458); + x460 = (x459)+(x448); + x461 = (uintptr_t)((x460)<(x448)); + x462 = (x460)+(x445); + x463 = (uintptr_t)((x462)<(x445)); + x464 = (x461)+(x463); + x465 = (x464)+(x446); + x466 = (uintptr_t)((x465)<(x446)); + x467 = (x465)+(x443); + x468 = (uintptr_t)((x467)<(x443)); + x469 = (x466)+(x468); + x470 = (x469)+(x444); + x471 = (uintptr_t)((x470)<(x444)); + x472 = (x470)+(x441); + x473 = (uintptr_t)((x472)<(x441)); + x474 = (x471)+(x473); + x475 = (x474)+(x442); + x476 = (uintptr_t)((x475)<(x442)); + x477 = (x475)+(x439); + x478 = (uintptr_t)((x477)<(x439)); + x479 = (x476)+(x478); + x480 = (x479)+(x440); + x481 = (uintptr_t)((x480)<(x440)); + x482 = (x480)+(x437); + x483 = (uintptr_t)((x482)<(x437)); + x484 = (x481)+(x483); + x485 = (x484)+(x438); + x486 = (x404)+(x451); + x487 = (uintptr_t)((x486)<(x404)); + x488 = (x487)+(x409); + x489 = (uintptr_t)((x488)<(x409)); + x490 = (x488)+(x453); + x491 = (uintptr_t)((x490)<(x453)); + x492 = (x489)+(x491); + x493 = (x492)+(x414); + x494 = (uintptr_t)((x493)<(x414)); + x495 = (x493)+(x457); + x496 = (uintptr_t)((x495)<(x457)); + x497 = (x494)+(x496); + x498 = (x497)+(x419); + x499 = (uintptr_t)((x498)<(x419)); + x500 = (x498)+(x462); + x501 = (uintptr_t)((x500)<(x462)); + x502 = (x499)+(x501); + x503 = (x502)+(x422); + x504 = (uintptr_t)((x503)<(x422)); + x505 = (x503)+(x467); + x506 = (uintptr_t)((x505)<(x467)); + x507 = (x504)+(x506); + x508 = (x507)+(x424); + x509 = (uintptr_t)((x508)<(x424)); + x510 = (x508)+(x472); + x511 = (uintptr_t)((x510)<(x472)); + x512 = (x509)+(x511); + x513 = (x512)+(x428); + x514 = (uintptr_t)((x513)<(x428)); + x515 = (x513)+(x477); + x516 = (uintptr_t)((x515)<(x477)); + x517 = (x514)+(x516); + x518 = (x517)+(x433); + x519 = (uintptr_t)((x518)<(x433)); + x520 = (x518)+(x482); + x521 = (uintptr_t)((x520)<(x482)); + x522 = (x519)+(x521); + x523 = (x522)+(x436); + x524 = (uintptr_t)((x523)<(x436)); + x525 = (x523)+(x485); + x526 = (uintptr_t)((x525)<(x485)); + x527 = (x524)+(x526); + x528 = (x486)*((uintptr_t)307527195ULL); + x529 = (x528)*((uintptr_t)268435456ULL); + x530 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x528)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x528)*((uintptr_t)268435456ULL))>>64); + x531 = (x528)*((uintptr_t)350157278ULL); + x532 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x528)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x528)*((uintptr_t)350157278ULL))>>64); + x533 = (x528)*((uintptr_t)2734136534ULL); + x534 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x528)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x528)*((uintptr_t)2734136534ULL))>>64); + x535 = (x528)*((uintptr_t)1477600026ULL); + x536 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x528)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x528)*((uintptr_t)1477600026ULL))>>64); + x537 = (x528)*((uintptr_t)1559614445ULL); + x538 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x528)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x528)*((uintptr_t)1559614445ULL))>>64); + x539 = (x538)+(x535); + x540 = (uintptr_t)((x539)<(x538)); + x541 = (x540)+(x536); + x542 = (uintptr_t)((x541)<(x536)); + x543 = (x541)+(x533); + x544 = (uintptr_t)((x543)<(x533)); + x545 = (x542)+(x544); + x546 = (x545)+(x534); + x547 = (uintptr_t)((x546)<(x534)); + x548 = (x546)+(x531); + x549 = (uintptr_t)((x548)<(x531)); + x550 = (x547)+(x549); + x551 = (x550)+(x532); + x552 = (x486)+(x537); + x553 = (uintptr_t)((x552)<(x486)); + x554 = (x553)+(x490); + x555 = (uintptr_t)((x554)<(x490)); + x556 = (x554)+(x539); + x557 = (uintptr_t)((x556)<(x539)); + x558 = (x555)+(x557); + x559 = (x558)+(x495); + x560 = (uintptr_t)((x559)<(x495)); + x561 = (x559)+(x543); + x562 = (uintptr_t)((x561)<(x543)); + x563 = (x560)+(x562); + x564 = (x563)+(x500); + x565 = (uintptr_t)((x564)<(x500)); + x566 = (x564)+(x548); + x567 = (uintptr_t)((x566)<(x548)); + x568 = (x565)+(x567); + x569 = (x568)+(x505); + x570 = (uintptr_t)((x569)<(x505)); + x571 = (x569)+(x551); + x572 = (uintptr_t)((x571)<(x551)); + x573 = (x570)+(x572); + x574 = (x573)+(x510); + x575 = (uintptr_t)((x574)<(x510)); + x576 = (x575)+(x515); + x577 = (uintptr_t)((x576)<(x515)); + x578 = (x577)+(x520); + x579 = (uintptr_t)((x578)<(x520)); + x580 = (x578)+(x529); + x581 = (uintptr_t)((x580)<(x529)); + x582 = (x579)+(x581); + x583 = (x582)+(x525); + x584 = (uintptr_t)((x583)<(x525)); + x585 = (x583)+(x530); + x586 = (uintptr_t)((x585)<(x530)); + x587 = (x584)+(x586); + x588 = (x587)+(x527); + x589 = (x19)*(x15); + x590 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x15))>>32 : ((__uint128_t)(x19)*(x15))>>64); + x591 = (x19)*(x14); + x592 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x14))>>32 : ((__uint128_t)(x19)*(x14))>>64); + x593 = (x19)*(x13); + x594 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x13))>>32 : ((__uint128_t)(x19)*(x13))>>64); + x595 = (x19)*(x12); + x596 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x12))>>32 : ((__uint128_t)(x19)*(x12))>>64); + x597 = (x19)*(x11); + x598 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x11))>>32 : ((__uint128_t)(x19)*(x11))>>64); + x599 = (x19)*(x10); + x600 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x10))>>32 : ((__uint128_t)(x19)*(x10))>>64); + x601 = (x19)*(x9); + x602 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x9))>>32 : ((__uint128_t)(x19)*(x9))>>64); + x603 = (x19)*(x8); + x604 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x8))>>32 : ((__uint128_t)(x19)*(x8))>>64); + x605 = (x604)+(x601); + x606 = (uintptr_t)((x605)<(x604)); + x607 = (x606)+(x602); + x608 = (uintptr_t)((x607)<(x602)); + x609 = (x607)+(x599); + x610 = (uintptr_t)((x609)<(x599)); + x611 = (x608)+(x610); + x612 = (x611)+(x600); + x613 = (uintptr_t)((x612)<(x600)); + x614 = (x612)+(x597); + x615 = (uintptr_t)((x614)<(x597)); + x616 = (x613)+(x615); + x617 = (x616)+(x598); + x618 = (uintptr_t)((x617)<(x598)); + x619 = (x617)+(x595); + x620 = (uintptr_t)((x619)<(x595)); + x621 = (x618)+(x620); + x622 = (x621)+(x596); + x623 = (uintptr_t)((x622)<(x596)); + x624 = (x622)+(x593); + x625 = (uintptr_t)((x624)<(x593)); + x626 = (x623)+(x625); + x627 = (x626)+(x594); + x628 = (uintptr_t)((x627)<(x594)); + x629 = (x627)+(x591); + x630 = (uintptr_t)((x629)<(x591)); + x631 = (x628)+(x630); + x632 = (x631)+(x592); + x633 = (uintptr_t)((x632)<(x592)); + x634 = (x632)+(x589); + x635 = (uintptr_t)((x634)<(x589)); + x636 = (x633)+(x635); + x637 = (x636)+(x590); + x638 = (x556)+(x603); + x639 = (uintptr_t)((x638)<(x556)); + x640 = (x639)+(x561); + x641 = (uintptr_t)((x640)<(x561)); + x642 = (x640)+(x605); + x643 = (uintptr_t)((x642)<(x605)); + x644 = (x641)+(x643); + x645 = (x644)+(x566); + x646 = (uintptr_t)((x645)<(x566)); + x647 = (x645)+(x609); + x648 = (uintptr_t)((x647)<(x609)); + x649 = (x646)+(x648); + x650 = (x649)+(x571); + x651 = (uintptr_t)((x650)<(x571)); + x652 = (x650)+(x614); + x653 = (uintptr_t)((x652)<(x614)); + x654 = (x651)+(x653); + x655 = (x654)+(x574); + x656 = (uintptr_t)((x655)<(x574)); + x657 = (x655)+(x619); + x658 = (uintptr_t)((x657)<(x619)); + x659 = (x656)+(x658); + x660 = (x659)+(x576); + x661 = (uintptr_t)((x660)<(x576)); + x662 = (x660)+(x624); + x663 = (uintptr_t)((x662)<(x624)); + x664 = (x661)+(x663); + x665 = (x664)+(x580); + x666 = (uintptr_t)((x665)<(x580)); + x667 = (x665)+(x629); + x668 = (uintptr_t)((x667)<(x629)); + x669 = (x666)+(x668); + x670 = (x669)+(x585); + x671 = (uintptr_t)((x670)<(x585)); + x672 = (x670)+(x634); + x673 = (uintptr_t)((x672)<(x634)); + x674 = (x671)+(x673); + x675 = (x674)+(x588); + x676 = (uintptr_t)((x675)<(x588)); + x677 = (x675)+(x637); + x678 = (uintptr_t)((x677)<(x637)); + x679 = (x676)+(x678); + x680 = (x638)*((uintptr_t)307527195ULL); + x681 = (x680)*((uintptr_t)268435456ULL); + x682 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x680)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x680)*((uintptr_t)268435456ULL))>>64); + x683 = (x680)*((uintptr_t)350157278ULL); + x684 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x680)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x680)*((uintptr_t)350157278ULL))>>64); + x685 = (x680)*((uintptr_t)2734136534ULL); + x686 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x680)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x680)*((uintptr_t)2734136534ULL))>>64); + x687 = (x680)*((uintptr_t)1477600026ULL); + x688 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x680)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x680)*((uintptr_t)1477600026ULL))>>64); + x689 = (x680)*((uintptr_t)1559614445ULL); + x690 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x680)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x680)*((uintptr_t)1559614445ULL))>>64); + x691 = (x690)+(x687); + x692 = (uintptr_t)((x691)<(x690)); + x693 = (x692)+(x688); + x694 = (uintptr_t)((x693)<(x688)); + x695 = (x693)+(x685); + x696 = (uintptr_t)((x695)<(x685)); + x697 = (x694)+(x696); + x698 = (x697)+(x686); + x699 = (uintptr_t)((x698)<(x686)); + x700 = (x698)+(x683); + x701 = (uintptr_t)((x700)<(x683)); + x702 = (x699)+(x701); + x703 = (x702)+(x684); + x704 = (x638)+(x689); + x705 = (uintptr_t)((x704)<(x638)); + x706 = (x705)+(x642); + x707 = (uintptr_t)((x706)<(x642)); + x708 = (x706)+(x691); + x709 = (uintptr_t)((x708)<(x691)); + x710 = (x707)+(x709); + x711 = (x710)+(x647); + x712 = (uintptr_t)((x711)<(x647)); + x713 = (x711)+(x695); + x714 = (uintptr_t)((x713)<(x695)); + x715 = (x712)+(x714); + x716 = (x715)+(x652); + x717 = (uintptr_t)((x716)<(x652)); + x718 = (x716)+(x700); + x719 = (uintptr_t)((x718)<(x700)); + x720 = (x717)+(x719); + x721 = (x720)+(x657); + x722 = (uintptr_t)((x721)<(x657)); + x723 = (x721)+(x703); + x724 = (uintptr_t)((x723)<(x703)); + x725 = (x722)+(x724); + x726 = (x725)+(x662); + x727 = (uintptr_t)((x726)<(x662)); + x728 = (x727)+(x667); + x729 = (uintptr_t)((x728)<(x667)); + x730 = (x729)+(x672); + x731 = (uintptr_t)((x730)<(x672)); + x732 = (x730)+(x681); + x733 = (uintptr_t)((x732)<(x681)); + x734 = (x731)+(x733); + x735 = (x734)+(x677); + x736 = (uintptr_t)((x735)<(x677)); + x737 = (x735)+(x682); + x738 = (uintptr_t)((x737)<(x682)); + x739 = (x736)+(x738); + x740 = (x739)+(x679); + x741 = (x20)*(x15); + x742 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x15))>>32 : ((__uint128_t)(x20)*(x15))>>64); + x743 = (x20)*(x14); + x744 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x14))>>32 : ((__uint128_t)(x20)*(x14))>>64); + x745 = (x20)*(x13); + x746 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x13))>>32 : ((__uint128_t)(x20)*(x13))>>64); + x747 = (x20)*(x12); + x748 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x12))>>32 : ((__uint128_t)(x20)*(x12))>>64); + x749 = (x20)*(x11); + x750 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x11))>>32 : ((__uint128_t)(x20)*(x11))>>64); + x751 = (x20)*(x10); + x752 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x10))>>32 : ((__uint128_t)(x20)*(x10))>>64); + x753 = (x20)*(x9); + x754 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x9))>>32 : ((__uint128_t)(x20)*(x9))>>64); + x755 = (x20)*(x8); + x756 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x8))>>32 : ((__uint128_t)(x20)*(x8))>>64); + x757 = (x756)+(x753); + x758 = (uintptr_t)((x757)<(x756)); + x759 = (x758)+(x754); + x760 = (uintptr_t)((x759)<(x754)); + x761 = (x759)+(x751); + x762 = (uintptr_t)((x761)<(x751)); + x763 = (x760)+(x762); + x764 = (x763)+(x752); + x765 = (uintptr_t)((x764)<(x752)); + x766 = (x764)+(x749); + x767 = (uintptr_t)((x766)<(x749)); + x768 = (x765)+(x767); + x769 = (x768)+(x750); + x770 = (uintptr_t)((x769)<(x750)); + x771 = (x769)+(x747); + x772 = (uintptr_t)((x771)<(x747)); + x773 = (x770)+(x772); + x774 = (x773)+(x748); + x775 = (uintptr_t)((x774)<(x748)); + x776 = (x774)+(x745); + x777 = (uintptr_t)((x776)<(x745)); + x778 = (x775)+(x777); + x779 = (x778)+(x746); + x780 = (uintptr_t)((x779)<(x746)); + x781 = (x779)+(x743); + x782 = (uintptr_t)((x781)<(x743)); + x783 = (x780)+(x782); + x784 = (x783)+(x744); + x785 = (uintptr_t)((x784)<(x744)); + x786 = (x784)+(x741); + x787 = (uintptr_t)((x786)<(x741)); + x788 = (x785)+(x787); + x789 = (x788)+(x742); + x790 = (x708)+(x755); + x791 = (uintptr_t)((x790)<(x708)); + x792 = (x791)+(x713); + x793 = (uintptr_t)((x792)<(x713)); + x794 = (x792)+(x757); + x795 = (uintptr_t)((x794)<(x757)); + x796 = (x793)+(x795); + x797 = (x796)+(x718); + x798 = (uintptr_t)((x797)<(x718)); + x799 = (x797)+(x761); + x800 = (uintptr_t)((x799)<(x761)); + x801 = (x798)+(x800); + x802 = (x801)+(x723); + x803 = (uintptr_t)((x802)<(x723)); + x804 = (x802)+(x766); + x805 = (uintptr_t)((x804)<(x766)); + x806 = (x803)+(x805); + x807 = (x806)+(x726); + x808 = (uintptr_t)((x807)<(x726)); + x809 = (x807)+(x771); + x810 = (uintptr_t)((x809)<(x771)); + x811 = (x808)+(x810); + x812 = (x811)+(x728); + x813 = (uintptr_t)((x812)<(x728)); + x814 = (x812)+(x776); + x815 = (uintptr_t)((x814)<(x776)); + x816 = (x813)+(x815); + x817 = (x816)+(x732); + x818 = (uintptr_t)((x817)<(x732)); + x819 = (x817)+(x781); + x820 = (uintptr_t)((x819)<(x781)); + x821 = (x818)+(x820); + x822 = (x821)+(x737); + x823 = (uintptr_t)((x822)<(x737)); + x824 = (x822)+(x786); + x825 = (uintptr_t)((x824)<(x786)); + x826 = (x823)+(x825); + x827 = (x826)+(x740); + x828 = (uintptr_t)((x827)<(x740)); + x829 = (x827)+(x789); + x830 = (uintptr_t)((x829)<(x789)); + x831 = (x828)+(x830); + x832 = (x790)*((uintptr_t)307527195ULL); + x833 = (x832)*((uintptr_t)268435456ULL); + x834 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x832)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x832)*((uintptr_t)268435456ULL))>>64); + x835 = (x832)*((uintptr_t)350157278ULL); + x836 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x832)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x832)*((uintptr_t)350157278ULL))>>64); + x837 = (x832)*((uintptr_t)2734136534ULL); + x838 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x832)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x832)*((uintptr_t)2734136534ULL))>>64); + x839 = (x832)*((uintptr_t)1477600026ULL); + x840 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x832)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x832)*((uintptr_t)1477600026ULL))>>64); + x841 = (x832)*((uintptr_t)1559614445ULL); + x842 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x832)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x832)*((uintptr_t)1559614445ULL))>>64); + x843 = (x842)+(x839); + x844 = (uintptr_t)((x843)<(x842)); + x845 = (x844)+(x840); + x846 = (uintptr_t)((x845)<(x840)); + x847 = (x845)+(x837); + x848 = (uintptr_t)((x847)<(x837)); + x849 = (x846)+(x848); + x850 = (x849)+(x838); + x851 = (uintptr_t)((x850)<(x838)); + x852 = (x850)+(x835); + x853 = (uintptr_t)((x852)<(x835)); + x854 = (x851)+(x853); + x855 = (x854)+(x836); + x856 = (x790)+(x841); + x857 = (uintptr_t)((x856)<(x790)); + x858 = (x857)+(x794); + x859 = (uintptr_t)((x858)<(x794)); + x860 = (x858)+(x843); + x861 = (uintptr_t)((x860)<(x843)); + x862 = (x859)+(x861); + x863 = (x862)+(x799); + x864 = (uintptr_t)((x863)<(x799)); + x865 = (x863)+(x847); + x866 = (uintptr_t)((x865)<(x847)); + x867 = (x864)+(x866); + x868 = (x867)+(x804); + x869 = (uintptr_t)((x868)<(x804)); + x870 = (x868)+(x852); + x871 = (uintptr_t)((x870)<(x852)); + x872 = (x869)+(x871); + x873 = (x872)+(x809); + x874 = (uintptr_t)((x873)<(x809)); + x875 = (x873)+(x855); + x876 = (uintptr_t)((x875)<(x855)); + x877 = (x874)+(x876); + x878 = (x877)+(x814); + x879 = (uintptr_t)((x878)<(x814)); + x880 = (x879)+(x819); + x881 = (uintptr_t)((x880)<(x819)); + x882 = (x881)+(x824); + x883 = (uintptr_t)((x882)<(x824)); + x884 = (x882)+(x833); + x885 = (uintptr_t)((x884)<(x833)); + x886 = (x883)+(x885); + x887 = (x886)+(x829); + x888 = (uintptr_t)((x887)<(x829)); + x889 = (x887)+(x834); + x890 = (uintptr_t)((x889)<(x834)); + x891 = (x888)+(x890); + x892 = (x891)+(x831); + x893 = (x21)*(x15); + x894 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x15))>>32 : ((__uint128_t)(x21)*(x15))>>64); + x895 = (x21)*(x14); + x896 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x14))>>32 : ((__uint128_t)(x21)*(x14))>>64); + x897 = (x21)*(x13); + x898 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x13))>>32 : ((__uint128_t)(x21)*(x13))>>64); + x899 = (x21)*(x12); + x900 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x12))>>32 : ((__uint128_t)(x21)*(x12))>>64); + x901 = (x21)*(x11); + x902 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x11))>>32 : ((__uint128_t)(x21)*(x11))>>64); + x903 = (x21)*(x10); + x904 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x10))>>32 : ((__uint128_t)(x21)*(x10))>>64); + x905 = (x21)*(x9); + x906 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x9))>>32 : ((__uint128_t)(x21)*(x9))>>64); + x907 = (x21)*(x8); + x908 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x8))>>32 : ((__uint128_t)(x21)*(x8))>>64); + x909 = (x908)+(x905); + x910 = (uintptr_t)((x909)<(x908)); + x911 = (x910)+(x906); + x912 = (uintptr_t)((x911)<(x906)); + x913 = (x911)+(x903); + x914 = (uintptr_t)((x913)<(x903)); + x915 = (x912)+(x914); + x916 = (x915)+(x904); + x917 = (uintptr_t)((x916)<(x904)); + x918 = (x916)+(x901); + x919 = (uintptr_t)((x918)<(x901)); + x920 = (x917)+(x919); + x921 = (x920)+(x902); + x922 = (uintptr_t)((x921)<(x902)); + x923 = (x921)+(x899); + x924 = (uintptr_t)((x923)<(x899)); + x925 = (x922)+(x924); + x926 = (x925)+(x900); + x927 = (uintptr_t)((x926)<(x900)); + x928 = (x926)+(x897); + x929 = (uintptr_t)((x928)<(x897)); + x930 = (x927)+(x929); + x931 = (x930)+(x898); + x932 = (uintptr_t)((x931)<(x898)); + x933 = (x931)+(x895); + x934 = (uintptr_t)((x933)<(x895)); + x935 = (x932)+(x934); + x936 = (x935)+(x896); + x937 = (uintptr_t)((x936)<(x896)); + x938 = (x936)+(x893); + x939 = (uintptr_t)((x938)<(x893)); + x940 = (x937)+(x939); + x941 = (x940)+(x894); + x942 = (x860)+(x907); + x943 = (uintptr_t)((x942)<(x860)); + x944 = (x943)+(x865); + x945 = (uintptr_t)((x944)<(x865)); + x946 = (x944)+(x909); + x947 = (uintptr_t)((x946)<(x909)); + x948 = (x945)+(x947); + x949 = (x948)+(x870); + x950 = (uintptr_t)((x949)<(x870)); + x951 = (x949)+(x913); + x952 = (uintptr_t)((x951)<(x913)); + x953 = (x950)+(x952); + x954 = (x953)+(x875); + x955 = (uintptr_t)((x954)<(x875)); + x956 = (x954)+(x918); + x957 = (uintptr_t)((x956)<(x918)); + x958 = (x955)+(x957); + x959 = (x958)+(x878); + x960 = (uintptr_t)((x959)<(x878)); + x961 = (x959)+(x923); + x962 = (uintptr_t)((x961)<(x923)); + x963 = (x960)+(x962); + x964 = (x963)+(x880); + x965 = (uintptr_t)((x964)<(x880)); + x966 = (x964)+(x928); + x967 = (uintptr_t)((x966)<(x928)); + x968 = (x965)+(x967); + x969 = (x968)+(x884); + x970 = (uintptr_t)((x969)<(x884)); + x971 = (x969)+(x933); + x972 = (uintptr_t)((x971)<(x933)); + x973 = (x970)+(x972); + x974 = (x973)+(x889); + x975 = (uintptr_t)((x974)<(x889)); + x976 = (x974)+(x938); + x977 = (uintptr_t)((x976)<(x938)); + x978 = (x975)+(x977); + x979 = (x978)+(x892); + x980 = (uintptr_t)((x979)<(x892)); + x981 = (x979)+(x941); + x982 = (uintptr_t)((x981)<(x941)); + x983 = (x980)+(x982); + x984 = (x942)*((uintptr_t)307527195ULL); + x985 = (x984)*((uintptr_t)268435456ULL); + x986 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)268435456ULL))>>64); + x987 = (x984)*((uintptr_t)350157278ULL); + x988 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)350157278ULL))>>64); + x989 = (x984)*((uintptr_t)2734136534ULL); + x990 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)2734136534ULL))>>64); + x991 = (x984)*((uintptr_t)1477600026ULL); + x992 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)1477600026ULL))>>64); + x993 = (x984)*((uintptr_t)1559614445ULL); + x994 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)1559614445ULL))>>64); + x995 = (x994)+(x991); + x996 = (uintptr_t)((x995)<(x994)); + x997 = (x996)+(x992); + x998 = (uintptr_t)((x997)<(x992)); + x999 = (x997)+(x989); + x1000 = (uintptr_t)((x999)<(x989)); + x1001 = (x998)+(x1000); + x1002 = (x1001)+(x990); + x1003 = (uintptr_t)((x1002)<(x990)); + x1004 = (x1002)+(x987); + x1005 = (uintptr_t)((x1004)<(x987)); + x1006 = (x1003)+(x1005); + x1007 = (x1006)+(x988); + x1008 = (x942)+(x993); + x1009 = (uintptr_t)((x1008)<(x942)); + x1010 = (x1009)+(x946); + x1011 = (uintptr_t)((x1010)<(x946)); + x1012 = (x1010)+(x995); + x1013 = (uintptr_t)((x1012)<(x995)); + x1014 = (x1011)+(x1013); + x1015 = (x1014)+(x951); + x1016 = (uintptr_t)((x1015)<(x951)); + x1017 = (x1015)+(x999); + x1018 = (uintptr_t)((x1017)<(x999)); + x1019 = (x1016)+(x1018); + x1020 = (x1019)+(x956); + x1021 = (uintptr_t)((x1020)<(x956)); + x1022 = (x1020)+(x1004); + x1023 = (uintptr_t)((x1022)<(x1004)); + x1024 = (x1021)+(x1023); + x1025 = (x1024)+(x961); + x1026 = (uintptr_t)((x1025)<(x961)); + x1027 = (x1025)+(x1007); + x1028 = (uintptr_t)((x1027)<(x1007)); + x1029 = (x1026)+(x1028); + x1030 = (x1029)+(x966); + x1031 = (uintptr_t)((x1030)<(x966)); + x1032 = (x1031)+(x971); + x1033 = (uintptr_t)((x1032)<(x971)); + x1034 = (x1033)+(x976); + x1035 = (uintptr_t)((x1034)<(x976)); + x1036 = (x1034)+(x985); + x1037 = (uintptr_t)((x1036)<(x985)); + x1038 = (x1035)+(x1037); + x1039 = (x1038)+(x981); + x1040 = (uintptr_t)((x1039)<(x981)); + x1041 = (x1039)+(x986); + x1042 = (uintptr_t)((x1041)<(x986)); + x1043 = (x1040)+(x1042); + x1044 = (x1043)+(x983); + x1045 = (x22)*(x15); + x1046 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x15))>>32 : ((__uint128_t)(x22)*(x15))>>64); + x1047 = (x22)*(x14); + x1048 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x14))>>32 : ((__uint128_t)(x22)*(x14))>>64); + x1049 = (x22)*(x13); + x1050 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x13))>>32 : ((__uint128_t)(x22)*(x13))>>64); + x1051 = (x22)*(x12); + x1052 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x12))>>32 : ((__uint128_t)(x22)*(x12))>>64); + x1053 = (x22)*(x11); + x1054 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x11))>>32 : ((__uint128_t)(x22)*(x11))>>64); + x1055 = (x22)*(x10); + x1056 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x10))>>32 : ((__uint128_t)(x22)*(x10))>>64); + x1057 = (x22)*(x9); + x1058 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x9))>>32 : ((__uint128_t)(x22)*(x9))>>64); + x1059 = (x22)*(x8); + x1060 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x8))>>32 : ((__uint128_t)(x22)*(x8))>>64); + x1061 = (x1060)+(x1057); + x1062 = (uintptr_t)((x1061)<(x1060)); + x1063 = (x1062)+(x1058); + x1064 = (uintptr_t)((x1063)<(x1058)); + x1065 = (x1063)+(x1055); + x1066 = (uintptr_t)((x1065)<(x1055)); + x1067 = (x1064)+(x1066); + x1068 = (x1067)+(x1056); + x1069 = (uintptr_t)((x1068)<(x1056)); + x1070 = (x1068)+(x1053); + x1071 = (uintptr_t)((x1070)<(x1053)); + x1072 = (x1069)+(x1071); + x1073 = (x1072)+(x1054); + x1074 = (uintptr_t)((x1073)<(x1054)); + x1075 = (x1073)+(x1051); + x1076 = (uintptr_t)((x1075)<(x1051)); + x1077 = (x1074)+(x1076); + x1078 = (x1077)+(x1052); + x1079 = (uintptr_t)((x1078)<(x1052)); + x1080 = (x1078)+(x1049); + x1081 = (uintptr_t)((x1080)<(x1049)); + x1082 = (x1079)+(x1081); + x1083 = (x1082)+(x1050); + x1084 = (uintptr_t)((x1083)<(x1050)); + x1085 = (x1083)+(x1047); + x1086 = (uintptr_t)((x1085)<(x1047)); + x1087 = (x1084)+(x1086); + x1088 = (x1087)+(x1048); + x1089 = (uintptr_t)((x1088)<(x1048)); + x1090 = (x1088)+(x1045); + x1091 = (uintptr_t)((x1090)<(x1045)); + x1092 = (x1089)+(x1091); + x1093 = (x1092)+(x1046); + x1094 = (x1012)+(x1059); + x1095 = (uintptr_t)((x1094)<(x1012)); + x1096 = (x1095)+(x1017); + x1097 = (uintptr_t)((x1096)<(x1017)); + x1098 = (x1096)+(x1061); + x1099 = (uintptr_t)((x1098)<(x1061)); + x1100 = (x1097)+(x1099); + x1101 = (x1100)+(x1022); + x1102 = (uintptr_t)((x1101)<(x1022)); + x1103 = (x1101)+(x1065); + x1104 = (uintptr_t)((x1103)<(x1065)); + x1105 = (x1102)+(x1104); + x1106 = (x1105)+(x1027); + x1107 = (uintptr_t)((x1106)<(x1027)); + x1108 = (x1106)+(x1070); + x1109 = (uintptr_t)((x1108)<(x1070)); + x1110 = (x1107)+(x1109); + x1111 = (x1110)+(x1030); + x1112 = (uintptr_t)((x1111)<(x1030)); + x1113 = (x1111)+(x1075); + x1114 = (uintptr_t)((x1113)<(x1075)); + x1115 = (x1112)+(x1114); + x1116 = (x1115)+(x1032); + x1117 = (uintptr_t)((x1116)<(x1032)); + x1118 = (x1116)+(x1080); + x1119 = (uintptr_t)((x1118)<(x1080)); + x1120 = (x1117)+(x1119); + x1121 = (x1120)+(x1036); + x1122 = (uintptr_t)((x1121)<(x1036)); + x1123 = (x1121)+(x1085); + x1124 = (uintptr_t)((x1123)<(x1085)); + x1125 = (x1122)+(x1124); + x1126 = (x1125)+(x1041); + x1127 = (uintptr_t)((x1126)<(x1041)); + x1128 = (x1126)+(x1090); + x1129 = (uintptr_t)((x1128)<(x1090)); + x1130 = (x1127)+(x1129); + x1131 = (x1130)+(x1044); + x1132 = (uintptr_t)((x1131)<(x1044)); + x1133 = (x1131)+(x1093); + x1134 = (uintptr_t)((x1133)<(x1093)); + x1135 = (x1132)+(x1134); + x1136 = (x1094)*((uintptr_t)307527195ULL); + x1137 = (x1136)*((uintptr_t)268435456ULL); + x1138 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1136)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x1136)*((uintptr_t)268435456ULL))>>64); + x1139 = (x1136)*((uintptr_t)350157278ULL); + x1140 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1136)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x1136)*((uintptr_t)350157278ULL))>>64); + x1141 = (x1136)*((uintptr_t)2734136534ULL); + x1142 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1136)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x1136)*((uintptr_t)2734136534ULL))>>64); + x1143 = (x1136)*((uintptr_t)1477600026ULL); + x1144 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1136)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x1136)*((uintptr_t)1477600026ULL))>>64); + x1145 = (x1136)*((uintptr_t)1559614445ULL); + x1146 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1136)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x1136)*((uintptr_t)1559614445ULL))>>64); + x1147 = (x1146)+(x1143); + x1148 = (uintptr_t)((x1147)<(x1146)); + x1149 = (x1148)+(x1144); + x1150 = (uintptr_t)((x1149)<(x1144)); + x1151 = (x1149)+(x1141); + x1152 = (uintptr_t)((x1151)<(x1141)); + x1153 = (x1150)+(x1152); + x1154 = (x1153)+(x1142); + x1155 = (uintptr_t)((x1154)<(x1142)); + x1156 = (x1154)+(x1139); + x1157 = (uintptr_t)((x1156)<(x1139)); + x1158 = (x1155)+(x1157); + x1159 = (x1158)+(x1140); + x1160 = (x1094)+(x1145); + x1161 = (uintptr_t)((x1160)<(x1094)); + x1162 = (x1161)+(x1098); + x1163 = (uintptr_t)((x1162)<(x1098)); + x1164 = (x1162)+(x1147); + x1165 = (uintptr_t)((x1164)<(x1147)); + x1166 = (x1163)+(x1165); + x1167 = (x1166)+(x1103); + x1168 = (uintptr_t)((x1167)<(x1103)); + x1169 = (x1167)+(x1151); + x1170 = (uintptr_t)((x1169)<(x1151)); + x1171 = (x1168)+(x1170); + x1172 = (x1171)+(x1108); + x1173 = (uintptr_t)((x1172)<(x1108)); + x1174 = (x1172)+(x1156); + x1175 = (uintptr_t)((x1174)<(x1156)); + x1176 = (x1173)+(x1175); + x1177 = (x1176)+(x1113); + x1178 = (uintptr_t)((x1177)<(x1113)); + x1179 = (x1177)+(x1159); + x1180 = (uintptr_t)((x1179)<(x1159)); + x1181 = (x1178)+(x1180); + x1182 = (x1181)+(x1118); + x1183 = (uintptr_t)((x1182)<(x1118)); + x1184 = (x1183)+(x1123); + x1185 = (uintptr_t)((x1184)<(x1123)); + x1186 = (x1185)+(x1128); + x1187 = (uintptr_t)((x1186)<(x1128)); + x1188 = (x1186)+(x1137); + x1189 = (uintptr_t)((x1188)<(x1137)); + x1190 = (x1187)+(x1189); + x1191 = (x1190)+(x1133); + x1192 = (uintptr_t)((x1191)<(x1133)); + x1193 = (x1191)+(x1138); + x1194 = (uintptr_t)((x1193)<(x1138)); + x1195 = (x1192)+(x1194); + x1196 = (x1195)+(x1135); + x1197 = (x1164)-((uintptr_t)1559614445ULL); + x1198 = (uintptr_t)((x1164)<(x1197)); + x1199 = (x1169)-((uintptr_t)1477600026ULL); + x1200 = (uintptr_t)((x1169)<(x1199)); + x1201 = (x1199)-(x1198); + x1202 = (uintptr_t)((x1199)<(x1201)); + x1203 = (x1200)+(x1202); + x1204 = (x1174)-((uintptr_t)2734136534ULL); + x1205 = (uintptr_t)((x1174)<(x1204)); + x1206 = (x1204)-(x1203); + x1207 = (uintptr_t)((x1204)<(x1206)); + x1208 = (x1205)+(x1207); + x1209 = (x1179)-((uintptr_t)350157278ULL); + x1210 = (uintptr_t)((x1179)<(x1209)); + x1211 = (x1209)-(x1208); + x1212 = (uintptr_t)((x1209)<(x1211)); + x1213 = (x1210)+(x1212); + x1214 = (x1182)-(x1213); + x1215 = (uintptr_t)((x1182)<(x1214)); + x1216 = (x1184)-(x1215); + x1217 = (uintptr_t)((x1184)<(x1216)); + x1218 = (x1188)-(x1217); + x1219 = (uintptr_t)((x1188)<(x1218)); + x1220 = (x1193)-((uintptr_t)268435456ULL); + x1221 = (uintptr_t)((x1193)<(x1220)); + x1222 = (x1220)-(x1219); + x1223 = (uintptr_t)((x1220)<(x1222)); + x1224 = (x1221)+(x1223); + x1225 = (x1196)-(x1224); + x1226 = (uintptr_t)((x1196)<(x1225)); + x1227 = ((uintptr_t)-1ULL)+((uintptr_t)((x1226)==((uintptr_t)0ULL))); + x1228 = (x1227)^((uintptr_t)4294967295ULL); + x1229 = ((x1164)&(x1227))|((x1197)&(x1228)); + x1230 = ((uintptr_t)-1ULL)+((uintptr_t)((x1226)==((uintptr_t)0ULL))); + x1231 = (x1230)^((uintptr_t)4294967295ULL); + x1232 = ((x1169)&(x1230))|((x1201)&(x1231)); + x1233 = ((uintptr_t)-1ULL)+((uintptr_t)((x1226)==((uintptr_t)0ULL))); + x1234 = (x1233)^((uintptr_t)4294967295ULL); + x1235 = ((x1174)&(x1233))|((x1206)&(x1234)); + x1236 = ((uintptr_t)-1ULL)+((uintptr_t)((x1226)==((uintptr_t)0ULL))); + x1237 = (x1236)^((uintptr_t)4294967295ULL); + x1238 = ((x1179)&(x1236))|((x1211)&(x1237)); + x1239 = ((uintptr_t)-1ULL)+((uintptr_t)((x1226)==((uintptr_t)0ULL))); + x1240 = (x1239)^((uintptr_t)4294967295ULL); + x1241 = ((x1182)&(x1239))|((x1214)&(x1240)); + x1242 = ((uintptr_t)-1ULL)+((uintptr_t)((x1226)==((uintptr_t)0ULL))); + x1243 = (x1242)^((uintptr_t)4294967295ULL); + x1244 = ((x1184)&(x1242))|((x1216)&(x1243)); + x1245 = ((uintptr_t)-1ULL)+((uintptr_t)((x1226)==((uintptr_t)0ULL))); + x1246 = (x1245)^((uintptr_t)4294967295ULL); + x1247 = ((x1188)&(x1245))|((x1218)&(x1246)); + x1248 = ((uintptr_t)-1ULL)+((uintptr_t)((x1226)==((uintptr_t)0ULL))); + x1249 = (x1248)^((uintptr_t)4294967295ULL); + x1250 = ((x1193)&(x1248))|((x1222)&(x1249)); + x1251 = x1229; + x1252 = x1232; + x1253 = x1235; + x1254 = x1238; + x1255 = x1241; + x1256 = x1244; + x1257 = x1247; + x1258 = x1250; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x1251, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1252, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1253, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x1254, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x1255, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x1256, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x1257, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x1258, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_mul(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_25519_scalar_mul((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_25519_scalar_square(uintptr_t out0, uintptr_t in0) { + uintptr_t x15, x28, x31, x33, x29, x34, x26, x35, x37, x38, x27, x39, x24, x40, x42, x43, x25, x44, x22, x45, x47, x48, x23, x49, x20, x50, x52, x53, x21, x54, x18, x55, x57, x58, x19, x59, x16, x60, x62, x63, x17, x65, x72, x75, x77, x73, x78, x70, x79, x81, x82, x71, x83, x68, x84, x86, x87, x69, x74, x89, x30, x90, x32, x91, x76, x92, x94, x95, x36, x96, x80, x97, x99, x100, x41, x101, x85, x102, x104, x105, x46, x106, x88, x107, x109, x110, x51, x112, x56, x114, x61, x115, x66, x116, x118, x119, x64, x120, x67, x121, x123, x8, x137, x140, x142, x138, x143, x135, x144, x146, x147, x136, x148, x133, x149, x151, x152, x134, x153, x131, x154, x156, x157, x132, x158, x129, x159, x161, x162, x130, x163, x127, x164, x166, x167, x128, x168, x125, x169, x171, x172, x126, x139, x93, x175, x98, x176, x141, x177, x179, x180, x103, x181, x145, x182, x184, x185, x108, x186, x150, x187, x189, x190, x111, x191, x155, x192, x194, x195, x113, x196, x160, x197, x199, x200, x117, x201, x165, x202, x204, x205, x122, x206, x170, x207, x209, x210, x124, x211, x173, x212, x214, x216, x223, x226, x228, x224, x229, x221, x230, x232, x233, x222, x234, x219, x235, x237, x238, x220, x225, x240, x174, x241, x178, x242, x227, x243, x245, x246, x183, x247, x231, x248, x250, x251, x188, x252, x236, x253, x255, x256, x193, x257, x239, x258, x260, x261, x198, x263, x203, x265, x208, x266, x217, x267, x269, x270, x213, x271, x218, x272, x274, x275, x215, x9, x289, x292, x294, x290, x295, x287, x296, x298, x299, x288, x300, x285, x301, x303, x304, x286, x305, x283, x306, x308, x309, x284, x310, x281, x311, x313, x314, x282, x315, x279, x316, x318, x319, x280, x320, x277, x321, x323, x324, x278, x291, x244, x327, x249, x328, x293, x329, x331, x332, x254, x333, x297, x334, x336, x337, x259, x338, x302, x339, x341, x342, x262, x343, x307, x344, x346, x347, x264, x348, x312, x349, x351, x352, x268, x353, x317, x354, x356, x357, x273, x358, x322, x359, x361, x362, x276, x363, x325, x364, x366, x368, x375, x378, x380, x376, x381, x373, x382, x384, x385, x374, x386, x371, x387, x389, x390, x372, x377, x392, x326, x393, x330, x394, x379, x395, x397, x398, x335, x399, x383, x400, x402, x403, x340, x404, x388, x405, x407, x408, x345, x409, x391, x410, x412, x413, x350, x415, x355, x417, x360, x418, x369, x419, x421, x422, x365, x423, x370, x424, x426, x427, x367, x10, x441, x444, x446, x442, x447, x439, x448, x450, x451, x440, x452, x437, x453, x455, x456, x438, x457, x435, x458, x460, x461, x436, x462, x433, x463, x465, x466, x434, x467, x431, x468, x470, x471, x432, x472, x429, x473, x475, x476, x430, x443, x396, x479, x401, x480, x445, x481, x483, x484, x406, x485, x449, x486, x488, x489, x411, x490, x454, x491, x493, x494, x414, x495, x459, x496, x498, x499, x416, x500, x464, x501, x503, x504, x420, x505, x469, x506, x508, x509, x425, x510, x474, x511, x513, x514, x428, x515, x477, x516, x518, x520, x527, x530, x532, x528, x533, x525, x534, x536, x537, x526, x538, x523, x539, x541, x542, x524, x529, x544, x478, x545, x482, x546, x531, x547, x549, x550, x487, x551, x535, x552, x554, x555, x492, x556, x540, x557, x559, x560, x497, x561, x543, x562, x564, x565, x502, x567, x507, x569, x512, x570, x521, x571, x573, x574, x517, x575, x522, x576, x578, x579, x519, x11, x593, x596, x598, x594, x599, x591, x600, x602, x603, x592, x604, x589, x605, x607, x608, x590, x609, x587, x610, x612, x613, x588, x614, x585, x615, x617, x618, x586, x619, x583, x620, x622, x623, x584, x624, x581, x625, x627, x628, x582, x595, x548, x631, x553, x632, x597, x633, x635, x636, x558, x637, x601, x638, x640, x641, x563, x642, x606, x643, x645, x646, x566, x647, x611, x648, x650, x651, x568, x652, x616, x653, x655, x656, x572, x657, x621, x658, x660, x661, x577, x662, x626, x663, x665, x666, x580, x667, x629, x668, x670, x672, x679, x682, x684, x680, x685, x677, x686, x688, x689, x678, x690, x675, x691, x693, x694, x676, x681, x696, x630, x697, x634, x698, x683, x699, x701, x702, x639, x703, x687, x704, x706, x707, x644, x708, x692, x709, x711, x712, x649, x713, x695, x714, x716, x717, x654, x719, x659, x721, x664, x722, x673, x723, x725, x726, x669, x727, x674, x728, x730, x731, x671, x12, x745, x748, x750, x746, x751, x743, x752, x754, x755, x744, x756, x741, x757, x759, x760, x742, x761, x739, x762, x764, x765, x740, x766, x737, x767, x769, x770, x738, x771, x735, x772, x774, x775, x736, x776, x733, x777, x779, x780, x734, x747, x700, x783, x705, x784, x749, x785, x787, x788, x710, x789, x753, x790, x792, x793, x715, x794, x758, x795, x797, x798, x718, x799, x763, x800, x802, x803, x720, x804, x768, x805, x807, x808, x724, x809, x773, x810, x812, x813, x729, x814, x778, x815, x817, x818, x732, x819, x781, x820, x822, x824, x831, x834, x836, x832, x837, x829, x838, x840, x841, x830, x842, x827, x843, x845, x846, x828, x833, x848, x782, x849, x786, x850, x835, x851, x853, x854, x791, x855, x839, x856, x858, x859, x796, x860, x844, x861, x863, x864, x801, x865, x847, x866, x868, x869, x806, x871, x811, x873, x816, x874, x825, x875, x877, x878, x821, x879, x826, x880, x882, x883, x823, x13, x897, x900, x902, x898, x903, x895, x904, x906, x907, x896, x908, x893, x909, x911, x912, x894, x913, x891, x914, x916, x917, x892, x918, x889, x919, x921, x922, x890, x923, x887, x924, x926, x927, x888, x928, x885, x929, x931, x932, x886, x899, x852, x935, x857, x936, x901, x937, x939, x940, x862, x941, x905, x942, x944, x945, x867, x946, x910, x947, x949, x950, x870, x951, x915, x952, x954, x955, x872, x956, x920, x957, x959, x960, x876, x961, x925, x962, x964, x965, x881, x966, x930, x967, x969, x970, x884, x971, x933, x972, x974, x976, x983, x986, x988, x984, x989, x981, x990, x992, x993, x982, x994, x979, x995, x997, x998, x980, x985, x1000, x934, x1001, x938, x1002, x987, x1003, x1005, x1006, x943, x1007, x991, x1008, x1010, x1011, x948, x1012, x996, x1013, x1015, x1016, x953, x1017, x999, x1018, x1020, x1021, x958, x1023, x963, x1025, x968, x1026, x977, x1027, x1029, x1030, x973, x1031, x978, x1032, x1034, x1035, x975, x7, x6, x5, x4, x3, x2, x1, x14, x0, x1049, x1052, x1054, x1050, x1055, x1047, x1056, x1058, x1059, x1048, x1060, x1045, x1061, x1063, x1064, x1046, x1065, x1043, x1066, x1068, x1069, x1044, x1070, x1041, x1071, x1073, x1074, x1042, x1075, x1039, x1076, x1078, x1079, x1040, x1080, x1037, x1081, x1083, x1084, x1038, x1051, x1004, x1087, x1009, x1088, x1053, x1089, x1091, x1092, x1014, x1093, x1057, x1094, x1096, x1097, x1019, x1098, x1062, x1099, x1101, x1102, x1022, x1103, x1067, x1104, x1106, x1107, x1024, x1108, x1072, x1109, x1111, x1112, x1028, x1113, x1077, x1114, x1116, x1117, x1033, x1118, x1082, x1119, x1121, x1122, x1036, x1123, x1085, x1124, x1126, x1128, x1135, x1138, x1140, x1136, x1141, x1133, x1142, x1144, x1145, x1134, x1146, x1131, x1147, x1149, x1150, x1132, x1137, x1152, x1086, x1153, x1090, x1154, x1139, x1155, x1157, x1158, x1095, x1159, x1143, x1160, x1162, x1163, x1100, x1164, x1148, x1165, x1167, x1168, x1105, x1169, x1151, x1170, x1172, x1173, x1110, x1175, x1115, x1177, x1120, x1178, x1129, x1179, x1181, x1182, x1125, x1183, x1130, x1184, x1186, x1187, x1127, x1190, x1191, x1192, x1194, x1195, x1196, x1197, x1199, x1200, x1201, x1202, x1204, x1205, x1207, x1209, x1211, x1212, x1213, x1215, x1216, x1188, x1217, x1156, x1219, x1189, x1220, x1161, x1222, x1193, x1223, x1166, x1225, x1198, x1226, x1171, x1228, x1203, x1229, x1174, x1231, x1206, x1232, x1176, x1234, x1208, x1235, x1180, x1237, x1210, x1238, x1218, x1185, x1240, x1214, x1241, x1221, x1224, x1227, x1230, x1233, x1236, x1239, x1242, x1243, x1244, x1245, x1246, x1247, x1248, x1249, x1250; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x1; + x9 = x2; + x10 = x3; + x11 = x4; + x12 = x5; + x13 = x6; + x14 = x7; + x15 = x0; + x16 = (x15)*(x7); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x7))>>32 : ((__uint128_t)(x15)*(x7))>>64); + x18 = (x15)*(x6); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x6))>>32 : ((__uint128_t)(x15)*(x6))>>64); + x20 = (x15)*(x5); + x21 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x5))>>32 : ((__uint128_t)(x15)*(x5))>>64); + x22 = (x15)*(x4); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x4))>>32 : ((__uint128_t)(x15)*(x4))>>64); + x24 = (x15)*(x3); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x3))>>32 : ((__uint128_t)(x15)*(x3))>>64); + x26 = (x15)*(x2); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x2))>>32 : ((__uint128_t)(x15)*(x2))>>64); + x28 = (x15)*(x1); + x29 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x1))>>32 : ((__uint128_t)(x15)*(x1))>>64); + x30 = (x15)*(x0); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x0))>>32 : ((__uint128_t)(x15)*(x0))>>64); + x32 = (x31)+(x28); + x33 = (uintptr_t)((x32)<(x31)); + x34 = (x33)+(x29); + x35 = (uintptr_t)((x34)<(x29)); + x36 = (x34)+(x26); + x37 = (uintptr_t)((x36)<(x26)); + x38 = (x35)+(x37); + x39 = (x38)+(x27); + x40 = (uintptr_t)((x39)<(x27)); + x41 = (x39)+(x24); + x42 = (uintptr_t)((x41)<(x24)); + x43 = (x40)+(x42); + x44 = (x43)+(x25); + x45 = (uintptr_t)((x44)<(x25)); + x46 = (x44)+(x22); + x47 = (uintptr_t)((x46)<(x22)); + x48 = (x45)+(x47); + x49 = (x48)+(x23); + x50 = (uintptr_t)((x49)<(x23)); + x51 = (x49)+(x20); + x52 = (uintptr_t)((x51)<(x20)); + x53 = (x50)+(x52); + x54 = (x53)+(x21); + x55 = (uintptr_t)((x54)<(x21)); + x56 = (x54)+(x18); + x57 = (uintptr_t)((x56)<(x18)); + x58 = (x55)+(x57); + x59 = (x58)+(x19); + x60 = (uintptr_t)((x59)<(x19)); + x61 = (x59)+(x16); + x62 = (uintptr_t)((x61)<(x16)); + x63 = (x60)+(x62); + x64 = (x63)+(x17); + x65 = (x30)*((uintptr_t)307527195ULL); + x66 = (x65)*((uintptr_t)268435456ULL); + x67 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)268435456ULL))>>64); + x68 = (x65)*((uintptr_t)350157278ULL); + x69 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)350157278ULL))>>64); + x70 = (x65)*((uintptr_t)2734136534ULL); + x71 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)2734136534ULL))>>64); + x72 = (x65)*((uintptr_t)1477600026ULL); + x73 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)1477600026ULL))>>64); + x74 = (x65)*((uintptr_t)1559614445ULL); + x75 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)1559614445ULL))>>64); + x76 = (x75)+(x72); + x77 = (uintptr_t)((x76)<(x75)); + x78 = (x77)+(x73); + x79 = (uintptr_t)((x78)<(x73)); + x80 = (x78)+(x70); + x81 = (uintptr_t)((x80)<(x70)); + x82 = (x79)+(x81); + x83 = (x82)+(x71); + x84 = (uintptr_t)((x83)<(x71)); + x85 = (x83)+(x68); + x86 = (uintptr_t)((x85)<(x68)); + x87 = (x84)+(x86); + x88 = (x87)+(x69); + x89 = (x30)+(x74); + x90 = (uintptr_t)((x89)<(x30)); + x91 = (x90)+(x32); + x92 = (uintptr_t)((x91)<(x32)); + x93 = (x91)+(x76); + x94 = (uintptr_t)((x93)<(x76)); + x95 = (x92)+(x94); + x96 = (x95)+(x36); + x97 = (uintptr_t)((x96)<(x36)); + x98 = (x96)+(x80); + x99 = (uintptr_t)((x98)<(x80)); + x100 = (x97)+(x99); + x101 = (x100)+(x41); + x102 = (uintptr_t)((x101)<(x41)); + x103 = (x101)+(x85); + x104 = (uintptr_t)((x103)<(x85)); + x105 = (x102)+(x104); + x106 = (x105)+(x46); + x107 = (uintptr_t)((x106)<(x46)); + x108 = (x106)+(x88); + x109 = (uintptr_t)((x108)<(x88)); + x110 = (x107)+(x109); + x111 = (x110)+(x51); + x112 = (uintptr_t)((x111)<(x51)); + x113 = (x112)+(x56); + x114 = (uintptr_t)((x113)<(x56)); + x115 = (x114)+(x61); + x116 = (uintptr_t)((x115)<(x61)); + x117 = (x115)+(x66); + x118 = (uintptr_t)((x117)<(x66)); + x119 = (x116)+(x118); + x120 = (x119)+(x64); + x121 = (uintptr_t)((x120)<(x64)); + x122 = (x120)+(x67); + x123 = (uintptr_t)((x122)<(x67)); + x124 = (x121)+(x123); + x125 = (x8)*(x7); + x126 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x7))>>32 : ((__uint128_t)(x8)*(x7))>>64); + x127 = (x8)*(x6); + x128 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x6))>>32 : ((__uint128_t)(x8)*(x6))>>64); + x129 = (x8)*(x5); + x130 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x5))>>32 : ((__uint128_t)(x8)*(x5))>>64); + x131 = (x8)*(x4); + x132 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x4))>>32 : ((__uint128_t)(x8)*(x4))>>64); + x133 = (x8)*(x3); + x134 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x3))>>32 : ((__uint128_t)(x8)*(x3))>>64); + x135 = (x8)*(x2); + x136 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x2))>>32 : ((__uint128_t)(x8)*(x2))>>64); + x137 = (x8)*(x1); + x138 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x1))>>32 : ((__uint128_t)(x8)*(x1))>>64); + x139 = (x8)*(x0); + x140 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x0))>>32 : ((__uint128_t)(x8)*(x0))>>64); + x141 = (x140)+(x137); + x142 = (uintptr_t)((x141)<(x140)); + x143 = (x142)+(x138); + x144 = (uintptr_t)((x143)<(x138)); + x145 = (x143)+(x135); + x146 = (uintptr_t)((x145)<(x135)); + x147 = (x144)+(x146); + x148 = (x147)+(x136); + x149 = (uintptr_t)((x148)<(x136)); + x150 = (x148)+(x133); + x151 = (uintptr_t)((x150)<(x133)); + x152 = (x149)+(x151); + x153 = (x152)+(x134); + x154 = (uintptr_t)((x153)<(x134)); + x155 = (x153)+(x131); + x156 = (uintptr_t)((x155)<(x131)); + x157 = (x154)+(x156); + x158 = (x157)+(x132); + x159 = (uintptr_t)((x158)<(x132)); + x160 = (x158)+(x129); + x161 = (uintptr_t)((x160)<(x129)); + x162 = (x159)+(x161); + x163 = (x162)+(x130); + x164 = (uintptr_t)((x163)<(x130)); + x165 = (x163)+(x127); + x166 = (uintptr_t)((x165)<(x127)); + x167 = (x164)+(x166); + x168 = (x167)+(x128); + x169 = (uintptr_t)((x168)<(x128)); + x170 = (x168)+(x125); + x171 = (uintptr_t)((x170)<(x125)); + x172 = (x169)+(x171); + x173 = (x172)+(x126); + x174 = (x93)+(x139); + x175 = (uintptr_t)((x174)<(x93)); + x176 = (x175)+(x98); + x177 = (uintptr_t)((x176)<(x98)); + x178 = (x176)+(x141); + x179 = (uintptr_t)((x178)<(x141)); + x180 = (x177)+(x179); + x181 = (x180)+(x103); + x182 = (uintptr_t)((x181)<(x103)); + x183 = (x181)+(x145); + x184 = (uintptr_t)((x183)<(x145)); + x185 = (x182)+(x184); + x186 = (x185)+(x108); + x187 = (uintptr_t)((x186)<(x108)); + x188 = (x186)+(x150); + x189 = (uintptr_t)((x188)<(x150)); + x190 = (x187)+(x189); + x191 = (x190)+(x111); + x192 = (uintptr_t)((x191)<(x111)); + x193 = (x191)+(x155); + x194 = (uintptr_t)((x193)<(x155)); + x195 = (x192)+(x194); + x196 = (x195)+(x113); + x197 = (uintptr_t)((x196)<(x113)); + x198 = (x196)+(x160); + x199 = (uintptr_t)((x198)<(x160)); + x200 = (x197)+(x199); + x201 = (x200)+(x117); + x202 = (uintptr_t)((x201)<(x117)); + x203 = (x201)+(x165); + x204 = (uintptr_t)((x203)<(x165)); + x205 = (x202)+(x204); + x206 = (x205)+(x122); + x207 = (uintptr_t)((x206)<(x122)); + x208 = (x206)+(x170); + x209 = (uintptr_t)((x208)<(x170)); + x210 = (x207)+(x209); + x211 = (x210)+(x124); + x212 = (uintptr_t)((x211)<(x124)); + x213 = (x211)+(x173); + x214 = (uintptr_t)((x213)<(x173)); + x215 = (x212)+(x214); + x216 = (x174)*((uintptr_t)307527195ULL); + x217 = (x216)*((uintptr_t)268435456ULL); + x218 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x216)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x216)*((uintptr_t)268435456ULL))>>64); + x219 = (x216)*((uintptr_t)350157278ULL); + x220 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x216)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x216)*((uintptr_t)350157278ULL))>>64); + x221 = (x216)*((uintptr_t)2734136534ULL); + x222 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x216)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x216)*((uintptr_t)2734136534ULL))>>64); + x223 = (x216)*((uintptr_t)1477600026ULL); + x224 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x216)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x216)*((uintptr_t)1477600026ULL))>>64); + x225 = (x216)*((uintptr_t)1559614445ULL); + x226 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x216)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x216)*((uintptr_t)1559614445ULL))>>64); + x227 = (x226)+(x223); + x228 = (uintptr_t)((x227)<(x226)); + x229 = (x228)+(x224); + x230 = (uintptr_t)((x229)<(x224)); + x231 = (x229)+(x221); + x232 = (uintptr_t)((x231)<(x221)); + x233 = (x230)+(x232); + x234 = (x233)+(x222); + x235 = (uintptr_t)((x234)<(x222)); + x236 = (x234)+(x219); + x237 = (uintptr_t)((x236)<(x219)); + x238 = (x235)+(x237); + x239 = (x238)+(x220); + x240 = (x174)+(x225); + x241 = (uintptr_t)((x240)<(x174)); + x242 = (x241)+(x178); + x243 = (uintptr_t)((x242)<(x178)); + x244 = (x242)+(x227); + x245 = (uintptr_t)((x244)<(x227)); + x246 = (x243)+(x245); + x247 = (x246)+(x183); + x248 = (uintptr_t)((x247)<(x183)); + x249 = (x247)+(x231); + x250 = (uintptr_t)((x249)<(x231)); + x251 = (x248)+(x250); + x252 = (x251)+(x188); + x253 = (uintptr_t)((x252)<(x188)); + x254 = (x252)+(x236); + x255 = (uintptr_t)((x254)<(x236)); + x256 = (x253)+(x255); + x257 = (x256)+(x193); + x258 = (uintptr_t)((x257)<(x193)); + x259 = (x257)+(x239); + x260 = (uintptr_t)((x259)<(x239)); + x261 = (x258)+(x260); + x262 = (x261)+(x198); + x263 = (uintptr_t)((x262)<(x198)); + x264 = (x263)+(x203); + x265 = (uintptr_t)((x264)<(x203)); + x266 = (x265)+(x208); + x267 = (uintptr_t)((x266)<(x208)); + x268 = (x266)+(x217); + x269 = (uintptr_t)((x268)<(x217)); + x270 = (x267)+(x269); + x271 = (x270)+(x213); + x272 = (uintptr_t)((x271)<(x213)); + x273 = (x271)+(x218); + x274 = (uintptr_t)((x273)<(x218)); + x275 = (x272)+(x274); + x276 = (x275)+(x215); + x277 = (x9)*(x7); + x278 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x7))>>32 : ((__uint128_t)(x9)*(x7))>>64); + x279 = (x9)*(x6); + x280 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x6))>>32 : ((__uint128_t)(x9)*(x6))>>64); + x281 = (x9)*(x5); + x282 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x5))>>32 : ((__uint128_t)(x9)*(x5))>>64); + x283 = (x9)*(x4); + x284 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x4))>>32 : ((__uint128_t)(x9)*(x4))>>64); + x285 = (x9)*(x3); + x286 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x3))>>32 : ((__uint128_t)(x9)*(x3))>>64); + x287 = (x9)*(x2); + x288 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x2))>>32 : ((__uint128_t)(x9)*(x2))>>64); + x289 = (x9)*(x1); + x290 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x1))>>32 : ((__uint128_t)(x9)*(x1))>>64); + x291 = (x9)*(x0); + x292 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x0))>>32 : ((__uint128_t)(x9)*(x0))>>64); + x293 = (x292)+(x289); + x294 = (uintptr_t)((x293)<(x292)); + x295 = (x294)+(x290); + x296 = (uintptr_t)((x295)<(x290)); + x297 = (x295)+(x287); + x298 = (uintptr_t)((x297)<(x287)); + x299 = (x296)+(x298); + x300 = (x299)+(x288); + x301 = (uintptr_t)((x300)<(x288)); + x302 = (x300)+(x285); + x303 = (uintptr_t)((x302)<(x285)); + x304 = (x301)+(x303); + x305 = (x304)+(x286); + x306 = (uintptr_t)((x305)<(x286)); + x307 = (x305)+(x283); + x308 = (uintptr_t)((x307)<(x283)); + x309 = (x306)+(x308); + x310 = (x309)+(x284); + x311 = (uintptr_t)((x310)<(x284)); + x312 = (x310)+(x281); + x313 = (uintptr_t)((x312)<(x281)); + x314 = (x311)+(x313); + x315 = (x314)+(x282); + x316 = (uintptr_t)((x315)<(x282)); + x317 = (x315)+(x279); + x318 = (uintptr_t)((x317)<(x279)); + x319 = (x316)+(x318); + x320 = (x319)+(x280); + x321 = (uintptr_t)((x320)<(x280)); + x322 = (x320)+(x277); + x323 = (uintptr_t)((x322)<(x277)); + x324 = (x321)+(x323); + x325 = (x324)+(x278); + x326 = (x244)+(x291); + x327 = (uintptr_t)((x326)<(x244)); + x328 = (x327)+(x249); + x329 = (uintptr_t)((x328)<(x249)); + x330 = (x328)+(x293); + x331 = (uintptr_t)((x330)<(x293)); + x332 = (x329)+(x331); + x333 = (x332)+(x254); + x334 = (uintptr_t)((x333)<(x254)); + x335 = (x333)+(x297); + x336 = (uintptr_t)((x335)<(x297)); + x337 = (x334)+(x336); + x338 = (x337)+(x259); + x339 = (uintptr_t)((x338)<(x259)); + x340 = (x338)+(x302); + x341 = (uintptr_t)((x340)<(x302)); + x342 = (x339)+(x341); + x343 = (x342)+(x262); + x344 = (uintptr_t)((x343)<(x262)); + x345 = (x343)+(x307); + x346 = (uintptr_t)((x345)<(x307)); + x347 = (x344)+(x346); + x348 = (x347)+(x264); + x349 = (uintptr_t)((x348)<(x264)); + x350 = (x348)+(x312); + x351 = (uintptr_t)((x350)<(x312)); + x352 = (x349)+(x351); + x353 = (x352)+(x268); + x354 = (uintptr_t)((x353)<(x268)); + x355 = (x353)+(x317); + x356 = (uintptr_t)((x355)<(x317)); + x357 = (x354)+(x356); + x358 = (x357)+(x273); + x359 = (uintptr_t)((x358)<(x273)); + x360 = (x358)+(x322); + x361 = (uintptr_t)((x360)<(x322)); + x362 = (x359)+(x361); + x363 = (x362)+(x276); + x364 = (uintptr_t)((x363)<(x276)); + x365 = (x363)+(x325); + x366 = (uintptr_t)((x365)<(x325)); + x367 = (x364)+(x366); + x368 = (x326)*((uintptr_t)307527195ULL); + x369 = (x368)*((uintptr_t)268435456ULL); + x370 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x368)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x368)*((uintptr_t)268435456ULL))>>64); + x371 = (x368)*((uintptr_t)350157278ULL); + x372 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x368)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x368)*((uintptr_t)350157278ULL))>>64); + x373 = (x368)*((uintptr_t)2734136534ULL); + x374 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x368)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x368)*((uintptr_t)2734136534ULL))>>64); + x375 = (x368)*((uintptr_t)1477600026ULL); + x376 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x368)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x368)*((uintptr_t)1477600026ULL))>>64); + x377 = (x368)*((uintptr_t)1559614445ULL); + x378 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x368)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x368)*((uintptr_t)1559614445ULL))>>64); + x379 = (x378)+(x375); + x380 = (uintptr_t)((x379)<(x378)); + x381 = (x380)+(x376); + x382 = (uintptr_t)((x381)<(x376)); + x383 = (x381)+(x373); + x384 = (uintptr_t)((x383)<(x373)); + x385 = (x382)+(x384); + x386 = (x385)+(x374); + x387 = (uintptr_t)((x386)<(x374)); + x388 = (x386)+(x371); + x389 = (uintptr_t)((x388)<(x371)); + x390 = (x387)+(x389); + x391 = (x390)+(x372); + x392 = (x326)+(x377); + x393 = (uintptr_t)((x392)<(x326)); + x394 = (x393)+(x330); + x395 = (uintptr_t)((x394)<(x330)); + x396 = (x394)+(x379); + x397 = (uintptr_t)((x396)<(x379)); + x398 = (x395)+(x397); + x399 = (x398)+(x335); + x400 = (uintptr_t)((x399)<(x335)); + x401 = (x399)+(x383); + x402 = (uintptr_t)((x401)<(x383)); + x403 = (x400)+(x402); + x404 = (x403)+(x340); + x405 = (uintptr_t)((x404)<(x340)); + x406 = (x404)+(x388); + x407 = (uintptr_t)((x406)<(x388)); + x408 = (x405)+(x407); + x409 = (x408)+(x345); + x410 = (uintptr_t)((x409)<(x345)); + x411 = (x409)+(x391); + x412 = (uintptr_t)((x411)<(x391)); + x413 = (x410)+(x412); + x414 = (x413)+(x350); + x415 = (uintptr_t)((x414)<(x350)); + x416 = (x415)+(x355); + x417 = (uintptr_t)((x416)<(x355)); + x418 = (x417)+(x360); + x419 = (uintptr_t)((x418)<(x360)); + x420 = (x418)+(x369); + x421 = (uintptr_t)((x420)<(x369)); + x422 = (x419)+(x421); + x423 = (x422)+(x365); + x424 = (uintptr_t)((x423)<(x365)); + x425 = (x423)+(x370); + x426 = (uintptr_t)((x425)<(x370)); + x427 = (x424)+(x426); + x428 = (x427)+(x367); + x429 = (x10)*(x7); + x430 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x7))>>32 : ((__uint128_t)(x10)*(x7))>>64); + x431 = (x10)*(x6); + x432 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x6))>>32 : ((__uint128_t)(x10)*(x6))>>64); + x433 = (x10)*(x5); + x434 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x5))>>32 : ((__uint128_t)(x10)*(x5))>>64); + x435 = (x10)*(x4); + x436 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x4))>>32 : ((__uint128_t)(x10)*(x4))>>64); + x437 = (x10)*(x3); + x438 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x3))>>32 : ((__uint128_t)(x10)*(x3))>>64); + x439 = (x10)*(x2); + x440 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x2))>>32 : ((__uint128_t)(x10)*(x2))>>64); + x441 = (x10)*(x1); + x442 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x1))>>32 : ((__uint128_t)(x10)*(x1))>>64); + x443 = (x10)*(x0); + x444 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x0))>>32 : ((__uint128_t)(x10)*(x0))>>64); + x445 = (x444)+(x441); + x446 = (uintptr_t)((x445)<(x444)); + x447 = (x446)+(x442); + x448 = (uintptr_t)((x447)<(x442)); + x449 = (x447)+(x439); + x450 = (uintptr_t)((x449)<(x439)); + x451 = (x448)+(x450); + x452 = (x451)+(x440); + x453 = (uintptr_t)((x452)<(x440)); + x454 = (x452)+(x437); + x455 = (uintptr_t)((x454)<(x437)); + x456 = (x453)+(x455); + x457 = (x456)+(x438); + x458 = (uintptr_t)((x457)<(x438)); + x459 = (x457)+(x435); + x460 = (uintptr_t)((x459)<(x435)); + x461 = (x458)+(x460); + x462 = (x461)+(x436); + x463 = (uintptr_t)((x462)<(x436)); + x464 = (x462)+(x433); + x465 = (uintptr_t)((x464)<(x433)); + x466 = (x463)+(x465); + x467 = (x466)+(x434); + x468 = (uintptr_t)((x467)<(x434)); + x469 = (x467)+(x431); + x470 = (uintptr_t)((x469)<(x431)); + x471 = (x468)+(x470); + x472 = (x471)+(x432); + x473 = (uintptr_t)((x472)<(x432)); + x474 = (x472)+(x429); + x475 = (uintptr_t)((x474)<(x429)); + x476 = (x473)+(x475); + x477 = (x476)+(x430); + x478 = (x396)+(x443); + x479 = (uintptr_t)((x478)<(x396)); + x480 = (x479)+(x401); + x481 = (uintptr_t)((x480)<(x401)); + x482 = (x480)+(x445); + x483 = (uintptr_t)((x482)<(x445)); + x484 = (x481)+(x483); + x485 = (x484)+(x406); + x486 = (uintptr_t)((x485)<(x406)); + x487 = (x485)+(x449); + x488 = (uintptr_t)((x487)<(x449)); + x489 = (x486)+(x488); + x490 = (x489)+(x411); + x491 = (uintptr_t)((x490)<(x411)); + x492 = (x490)+(x454); + x493 = (uintptr_t)((x492)<(x454)); + x494 = (x491)+(x493); + x495 = (x494)+(x414); + x496 = (uintptr_t)((x495)<(x414)); + x497 = (x495)+(x459); + x498 = (uintptr_t)((x497)<(x459)); + x499 = (x496)+(x498); + x500 = (x499)+(x416); + x501 = (uintptr_t)((x500)<(x416)); + x502 = (x500)+(x464); + x503 = (uintptr_t)((x502)<(x464)); + x504 = (x501)+(x503); + x505 = (x504)+(x420); + x506 = (uintptr_t)((x505)<(x420)); + x507 = (x505)+(x469); + x508 = (uintptr_t)((x507)<(x469)); + x509 = (x506)+(x508); + x510 = (x509)+(x425); + x511 = (uintptr_t)((x510)<(x425)); + x512 = (x510)+(x474); + x513 = (uintptr_t)((x512)<(x474)); + x514 = (x511)+(x513); + x515 = (x514)+(x428); + x516 = (uintptr_t)((x515)<(x428)); + x517 = (x515)+(x477); + x518 = (uintptr_t)((x517)<(x477)); + x519 = (x516)+(x518); + x520 = (x478)*((uintptr_t)307527195ULL); + x521 = (x520)*((uintptr_t)268435456ULL); + x522 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x520)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x520)*((uintptr_t)268435456ULL))>>64); + x523 = (x520)*((uintptr_t)350157278ULL); + x524 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x520)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x520)*((uintptr_t)350157278ULL))>>64); + x525 = (x520)*((uintptr_t)2734136534ULL); + x526 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x520)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x520)*((uintptr_t)2734136534ULL))>>64); + x527 = (x520)*((uintptr_t)1477600026ULL); + x528 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x520)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x520)*((uintptr_t)1477600026ULL))>>64); + x529 = (x520)*((uintptr_t)1559614445ULL); + x530 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x520)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x520)*((uintptr_t)1559614445ULL))>>64); + x531 = (x530)+(x527); + x532 = (uintptr_t)((x531)<(x530)); + x533 = (x532)+(x528); + x534 = (uintptr_t)((x533)<(x528)); + x535 = (x533)+(x525); + x536 = (uintptr_t)((x535)<(x525)); + x537 = (x534)+(x536); + x538 = (x537)+(x526); + x539 = (uintptr_t)((x538)<(x526)); + x540 = (x538)+(x523); + x541 = (uintptr_t)((x540)<(x523)); + x542 = (x539)+(x541); + x543 = (x542)+(x524); + x544 = (x478)+(x529); + x545 = (uintptr_t)((x544)<(x478)); + x546 = (x545)+(x482); + x547 = (uintptr_t)((x546)<(x482)); + x548 = (x546)+(x531); + x549 = (uintptr_t)((x548)<(x531)); + x550 = (x547)+(x549); + x551 = (x550)+(x487); + x552 = (uintptr_t)((x551)<(x487)); + x553 = (x551)+(x535); + x554 = (uintptr_t)((x553)<(x535)); + x555 = (x552)+(x554); + x556 = (x555)+(x492); + x557 = (uintptr_t)((x556)<(x492)); + x558 = (x556)+(x540); + x559 = (uintptr_t)((x558)<(x540)); + x560 = (x557)+(x559); + x561 = (x560)+(x497); + x562 = (uintptr_t)((x561)<(x497)); + x563 = (x561)+(x543); + x564 = (uintptr_t)((x563)<(x543)); + x565 = (x562)+(x564); + x566 = (x565)+(x502); + x567 = (uintptr_t)((x566)<(x502)); + x568 = (x567)+(x507); + x569 = (uintptr_t)((x568)<(x507)); + x570 = (x569)+(x512); + x571 = (uintptr_t)((x570)<(x512)); + x572 = (x570)+(x521); + x573 = (uintptr_t)((x572)<(x521)); + x574 = (x571)+(x573); + x575 = (x574)+(x517); + x576 = (uintptr_t)((x575)<(x517)); + x577 = (x575)+(x522); + x578 = (uintptr_t)((x577)<(x522)); + x579 = (x576)+(x578); + x580 = (x579)+(x519); + x581 = (x11)*(x7); + x582 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x7))>>32 : ((__uint128_t)(x11)*(x7))>>64); + x583 = (x11)*(x6); + x584 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x6))>>32 : ((__uint128_t)(x11)*(x6))>>64); + x585 = (x11)*(x5); + x586 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x5))>>32 : ((__uint128_t)(x11)*(x5))>>64); + x587 = (x11)*(x4); + x588 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x4))>>32 : ((__uint128_t)(x11)*(x4))>>64); + x589 = (x11)*(x3); + x590 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x3))>>32 : ((__uint128_t)(x11)*(x3))>>64); + x591 = (x11)*(x2); + x592 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x2))>>32 : ((__uint128_t)(x11)*(x2))>>64); + x593 = (x11)*(x1); + x594 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x1))>>32 : ((__uint128_t)(x11)*(x1))>>64); + x595 = (x11)*(x0); + x596 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x0))>>32 : ((__uint128_t)(x11)*(x0))>>64); + x597 = (x596)+(x593); + x598 = (uintptr_t)((x597)<(x596)); + x599 = (x598)+(x594); + x600 = (uintptr_t)((x599)<(x594)); + x601 = (x599)+(x591); + x602 = (uintptr_t)((x601)<(x591)); + x603 = (x600)+(x602); + x604 = (x603)+(x592); + x605 = (uintptr_t)((x604)<(x592)); + x606 = (x604)+(x589); + x607 = (uintptr_t)((x606)<(x589)); + x608 = (x605)+(x607); + x609 = (x608)+(x590); + x610 = (uintptr_t)((x609)<(x590)); + x611 = (x609)+(x587); + x612 = (uintptr_t)((x611)<(x587)); + x613 = (x610)+(x612); + x614 = (x613)+(x588); + x615 = (uintptr_t)((x614)<(x588)); + x616 = (x614)+(x585); + x617 = (uintptr_t)((x616)<(x585)); + x618 = (x615)+(x617); + x619 = (x618)+(x586); + x620 = (uintptr_t)((x619)<(x586)); + x621 = (x619)+(x583); + x622 = (uintptr_t)((x621)<(x583)); + x623 = (x620)+(x622); + x624 = (x623)+(x584); + x625 = (uintptr_t)((x624)<(x584)); + x626 = (x624)+(x581); + x627 = (uintptr_t)((x626)<(x581)); + x628 = (x625)+(x627); + x629 = (x628)+(x582); + x630 = (x548)+(x595); + x631 = (uintptr_t)((x630)<(x548)); + x632 = (x631)+(x553); + x633 = (uintptr_t)((x632)<(x553)); + x634 = (x632)+(x597); + x635 = (uintptr_t)((x634)<(x597)); + x636 = (x633)+(x635); + x637 = (x636)+(x558); + x638 = (uintptr_t)((x637)<(x558)); + x639 = (x637)+(x601); + x640 = (uintptr_t)((x639)<(x601)); + x641 = (x638)+(x640); + x642 = (x641)+(x563); + x643 = (uintptr_t)((x642)<(x563)); + x644 = (x642)+(x606); + x645 = (uintptr_t)((x644)<(x606)); + x646 = (x643)+(x645); + x647 = (x646)+(x566); + x648 = (uintptr_t)((x647)<(x566)); + x649 = (x647)+(x611); + x650 = (uintptr_t)((x649)<(x611)); + x651 = (x648)+(x650); + x652 = (x651)+(x568); + x653 = (uintptr_t)((x652)<(x568)); + x654 = (x652)+(x616); + x655 = (uintptr_t)((x654)<(x616)); + x656 = (x653)+(x655); + x657 = (x656)+(x572); + x658 = (uintptr_t)((x657)<(x572)); + x659 = (x657)+(x621); + x660 = (uintptr_t)((x659)<(x621)); + x661 = (x658)+(x660); + x662 = (x661)+(x577); + x663 = (uintptr_t)((x662)<(x577)); + x664 = (x662)+(x626); + x665 = (uintptr_t)((x664)<(x626)); + x666 = (x663)+(x665); + x667 = (x666)+(x580); + x668 = (uintptr_t)((x667)<(x580)); + x669 = (x667)+(x629); + x670 = (uintptr_t)((x669)<(x629)); + x671 = (x668)+(x670); + x672 = (x630)*((uintptr_t)307527195ULL); + x673 = (x672)*((uintptr_t)268435456ULL); + x674 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)268435456ULL))>>64); + x675 = (x672)*((uintptr_t)350157278ULL); + x676 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)350157278ULL))>>64); + x677 = (x672)*((uintptr_t)2734136534ULL); + x678 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)2734136534ULL))>>64); + x679 = (x672)*((uintptr_t)1477600026ULL); + x680 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)1477600026ULL))>>64); + x681 = (x672)*((uintptr_t)1559614445ULL); + x682 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)1559614445ULL))>>64); + x683 = (x682)+(x679); + x684 = (uintptr_t)((x683)<(x682)); + x685 = (x684)+(x680); + x686 = (uintptr_t)((x685)<(x680)); + x687 = (x685)+(x677); + x688 = (uintptr_t)((x687)<(x677)); + x689 = (x686)+(x688); + x690 = (x689)+(x678); + x691 = (uintptr_t)((x690)<(x678)); + x692 = (x690)+(x675); + x693 = (uintptr_t)((x692)<(x675)); + x694 = (x691)+(x693); + x695 = (x694)+(x676); + x696 = (x630)+(x681); + x697 = (uintptr_t)((x696)<(x630)); + x698 = (x697)+(x634); + x699 = (uintptr_t)((x698)<(x634)); + x700 = (x698)+(x683); + x701 = (uintptr_t)((x700)<(x683)); + x702 = (x699)+(x701); + x703 = (x702)+(x639); + x704 = (uintptr_t)((x703)<(x639)); + x705 = (x703)+(x687); + x706 = (uintptr_t)((x705)<(x687)); + x707 = (x704)+(x706); + x708 = (x707)+(x644); + x709 = (uintptr_t)((x708)<(x644)); + x710 = (x708)+(x692); + x711 = (uintptr_t)((x710)<(x692)); + x712 = (x709)+(x711); + x713 = (x712)+(x649); + x714 = (uintptr_t)((x713)<(x649)); + x715 = (x713)+(x695); + x716 = (uintptr_t)((x715)<(x695)); + x717 = (x714)+(x716); + x718 = (x717)+(x654); + x719 = (uintptr_t)((x718)<(x654)); + x720 = (x719)+(x659); + x721 = (uintptr_t)((x720)<(x659)); + x722 = (x721)+(x664); + x723 = (uintptr_t)((x722)<(x664)); + x724 = (x722)+(x673); + x725 = (uintptr_t)((x724)<(x673)); + x726 = (x723)+(x725); + x727 = (x726)+(x669); + x728 = (uintptr_t)((x727)<(x669)); + x729 = (x727)+(x674); + x730 = (uintptr_t)((x729)<(x674)); + x731 = (x728)+(x730); + x732 = (x731)+(x671); + x733 = (x12)*(x7); + x734 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x7))>>32 : ((__uint128_t)(x12)*(x7))>>64); + x735 = (x12)*(x6); + x736 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x6))>>32 : ((__uint128_t)(x12)*(x6))>>64); + x737 = (x12)*(x5); + x738 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x5))>>32 : ((__uint128_t)(x12)*(x5))>>64); + x739 = (x12)*(x4); + x740 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x4))>>32 : ((__uint128_t)(x12)*(x4))>>64); + x741 = (x12)*(x3); + x742 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x3))>>32 : ((__uint128_t)(x12)*(x3))>>64); + x743 = (x12)*(x2); + x744 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x2))>>32 : ((__uint128_t)(x12)*(x2))>>64); + x745 = (x12)*(x1); + x746 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x1))>>32 : ((__uint128_t)(x12)*(x1))>>64); + x747 = (x12)*(x0); + x748 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x0))>>32 : ((__uint128_t)(x12)*(x0))>>64); + x749 = (x748)+(x745); + x750 = (uintptr_t)((x749)<(x748)); + x751 = (x750)+(x746); + x752 = (uintptr_t)((x751)<(x746)); + x753 = (x751)+(x743); + x754 = (uintptr_t)((x753)<(x743)); + x755 = (x752)+(x754); + x756 = (x755)+(x744); + x757 = (uintptr_t)((x756)<(x744)); + x758 = (x756)+(x741); + x759 = (uintptr_t)((x758)<(x741)); + x760 = (x757)+(x759); + x761 = (x760)+(x742); + x762 = (uintptr_t)((x761)<(x742)); + x763 = (x761)+(x739); + x764 = (uintptr_t)((x763)<(x739)); + x765 = (x762)+(x764); + x766 = (x765)+(x740); + x767 = (uintptr_t)((x766)<(x740)); + x768 = (x766)+(x737); + x769 = (uintptr_t)((x768)<(x737)); + x770 = (x767)+(x769); + x771 = (x770)+(x738); + x772 = (uintptr_t)((x771)<(x738)); + x773 = (x771)+(x735); + x774 = (uintptr_t)((x773)<(x735)); + x775 = (x772)+(x774); + x776 = (x775)+(x736); + x777 = (uintptr_t)((x776)<(x736)); + x778 = (x776)+(x733); + x779 = (uintptr_t)((x778)<(x733)); + x780 = (x777)+(x779); + x781 = (x780)+(x734); + x782 = (x700)+(x747); + x783 = (uintptr_t)((x782)<(x700)); + x784 = (x783)+(x705); + x785 = (uintptr_t)((x784)<(x705)); + x786 = (x784)+(x749); + x787 = (uintptr_t)((x786)<(x749)); + x788 = (x785)+(x787); + x789 = (x788)+(x710); + x790 = (uintptr_t)((x789)<(x710)); + x791 = (x789)+(x753); + x792 = (uintptr_t)((x791)<(x753)); + x793 = (x790)+(x792); + x794 = (x793)+(x715); + x795 = (uintptr_t)((x794)<(x715)); + x796 = (x794)+(x758); + x797 = (uintptr_t)((x796)<(x758)); + x798 = (x795)+(x797); + x799 = (x798)+(x718); + x800 = (uintptr_t)((x799)<(x718)); + x801 = (x799)+(x763); + x802 = (uintptr_t)((x801)<(x763)); + x803 = (x800)+(x802); + x804 = (x803)+(x720); + x805 = (uintptr_t)((x804)<(x720)); + x806 = (x804)+(x768); + x807 = (uintptr_t)((x806)<(x768)); + x808 = (x805)+(x807); + x809 = (x808)+(x724); + x810 = (uintptr_t)((x809)<(x724)); + x811 = (x809)+(x773); + x812 = (uintptr_t)((x811)<(x773)); + x813 = (x810)+(x812); + x814 = (x813)+(x729); + x815 = (uintptr_t)((x814)<(x729)); + x816 = (x814)+(x778); + x817 = (uintptr_t)((x816)<(x778)); + x818 = (x815)+(x817); + x819 = (x818)+(x732); + x820 = (uintptr_t)((x819)<(x732)); + x821 = (x819)+(x781); + x822 = (uintptr_t)((x821)<(x781)); + x823 = (x820)+(x822); + x824 = (x782)*((uintptr_t)307527195ULL); + x825 = (x824)*((uintptr_t)268435456ULL); + x826 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x824)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x824)*((uintptr_t)268435456ULL))>>64); + x827 = (x824)*((uintptr_t)350157278ULL); + x828 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x824)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x824)*((uintptr_t)350157278ULL))>>64); + x829 = (x824)*((uintptr_t)2734136534ULL); + x830 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x824)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x824)*((uintptr_t)2734136534ULL))>>64); + x831 = (x824)*((uintptr_t)1477600026ULL); + x832 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x824)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x824)*((uintptr_t)1477600026ULL))>>64); + x833 = (x824)*((uintptr_t)1559614445ULL); + x834 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x824)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x824)*((uintptr_t)1559614445ULL))>>64); + x835 = (x834)+(x831); + x836 = (uintptr_t)((x835)<(x834)); + x837 = (x836)+(x832); + x838 = (uintptr_t)((x837)<(x832)); + x839 = (x837)+(x829); + x840 = (uintptr_t)((x839)<(x829)); + x841 = (x838)+(x840); + x842 = (x841)+(x830); + x843 = (uintptr_t)((x842)<(x830)); + x844 = (x842)+(x827); + x845 = (uintptr_t)((x844)<(x827)); + x846 = (x843)+(x845); + x847 = (x846)+(x828); + x848 = (x782)+(x833); + x849 = (uintptr_t)((x848)<(x782)); + x850 = (x849)+(x786); + x851 = (uintptr_t)((x850)<(x786)); + x852 = (x850)+(x835); + x853 = (uintptr_t)((x852)<(x835)); + x854 = (x851)+(x853); + x855 = (x854)+(x791); + x856 = (uintptr_t)((x855)<(x791)); + x857 = (x855)+(x839); + x858 = (uintptr_t)((x857)<(x839)); + x859 = (x856)+(x858); + x860 = (x859)+(x796); + x861 = (uintptr_t)((x860)<(x796)); + x862 = (x860)+(x844); + x863 = (uintptr_t)((x862)<(x844)); + x864 = (x861)+(x863); + x865 = (x864)+(x801); + x866 = (uintptr_t)((x865)<(x801)); + x867 = (x865)+(x847); + x868 = (uintptr_t)((x867)<(x847)); + x869 = (x866)+(x868); + x870 = (x869)+(x806); + x871 = (uintptr_t)((x870)<(x806)); + x872 = (x871)+(x811); + x873 = (uintptr_t)((x872)<(x811)); + x874 = (x873)+(x816); + x875 = (uintptr_t)((x874)<(x816)); + x876 = (x874)+(x825); + x877 = (uintptr_t)((x876)<(x825)); + x878 = (x875)+(x877); + x879 = (x878)+(x821); + x880 = (uintptr_t)((x879)<(x821)); + x881 = (x879)+(x826); + x882 = (uintptr_t)((x881)<(x826)); + x883 = (x880)+(x882); + x884 = (x883)+(x823); + x885 = (x13)*(x7); + x886 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x7))>>32 : ((__uint128_t)(x13)*(x7))>>64); + x887 = (x13)*(x6); + x888 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x6))>>32 : ((__uint128_t)(x13)*(x6))>>64); + x889 = (x13)*(x5); + x890 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x5))>>32 : ((__uint128_t)(x13)*(x5))>>64); + x891 = (x13)*(x4); + x892 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x4))>>32 : ((__uint128_t)(x13)*(x4))>>64); + x893 = (x13)*(x3); + x894 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x3))>>32 : ((__uint128_t)(x13)*(x3))>>64); + x895 = (x13)*(x2); + x896 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x2))>>32 : ((__uint128_t)(x13)*(x2))>>64); + x897 = (x13)*(x1); + x898 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x1))>>32 : ((__uint128_t)(x13)*(x1))>>64); + x899 = (x13)*(x0); + x900 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x0))>>32 : ((__uint128_t)(x13)*(x0))>>64); + x901 = (x900)+(x897); + x902 = (uintptr_t)((x901)<(x900)); + x903 = (x902)+(x898); + x904 = (uintptr_t)((x903)<(x898)); + x905 = (x903)+(x895); + x906 = (uintptr_t)((x905)<(x895)); + x907 = (x904)+(x906); + x908 = (x907)+(x896); + x909 = (uintptr_t)((x908)<(x896)); + x910 = (x908)+(x893); + x911 = (uintptr_t)((x910)<(x893)); + x912 = (x909)+(x911); + x913 = (x912)+(x894); + x914 = (uintptr_t)((x913)<(x894)); + x915 = (x913)+(x891); + x916 = (uintptr_t)((x915)<(x891)); + x917 = (x914)+(x916); + x918 = (x917)+(x892); + x919 = (uintptr_t)((x918)<(x892)); + x920 = (x918)+(x889); + x921 = (uintptr_t)((x920)<(x889)); + x922 = (x919)+(x921); + x923 = (x922)+(x890); + x924 = (uintptr_t)((x923)<(x890)); + x925 = (x923)+(x887); + x926 = (uintptr_t)((x925)<(x887)); + x927 = (x924)+(x926); + x928 = (x927)+(x888); + x929 = (uintptr_t)((x928)<(x888)); + x930 = (x928)+(x885); + x931 = (uintptr_t)((x930)<(x885)); + x932 = (x929)+(x931); + x933 = (x932)+(x886); + x934 = (x852)+(x899); + x935 = (uintptr_t)((x934)<(x852)); + x936 = (x935)+(x857); + x937 = (uintptr_t)((x936)<(x857)); + x938 = (x936)+(x901); + x939 = (uintptr_t)((x938)<(x901)); + x940 = (x937)+(x939); + x941 = (x940)+(x862); + x942 = (uintptr_t)((x941)<(x862)); + x943 = (x941)+(x905); + x944 = (uintptr_t)((x943)<(x905)); + x945 = (x942)+(x944); + x946 = (x945)+(x867); + x947 = (uintptr_t)((x946)<(x867)); + x948 = (x946)+(x910); + x949 = (uintptr_t)((x948)<(x910)); + x950 = (x947)+(x949); + x951 = (x950)+(x870); + x952 = (uintptr_t)((x951)<(x870)); + x953 = (x951)+(x915); + x954 = (uintptr_t)((x953)<(x915)); + x955 = (x952)+(x954); + x956 = (x955)+(x872); + x957 = (uintptr_t)((x956)<(x872)); + x958 = (x956)+(x920); + x959 = (uintptr_t)((x958)<(x920)); + x960 = (x957)+(x959); + x961 = (x960)+(x876); + x962 = (uintptr_t)((x961)<(x876)); + x963 = (x961)+(x925); + x964 = (uintptr_t)((x963)<(x925)); + x965 = (x962)+(x964); + x966 = (x965)+(x881); + x967 = (uintptr_t)((x966)<(x881)); + x968 = (x966)+(x930); + x969 = (uintptr_t)((x968)<(x930)); + x970 = (x967)+(x969); + x971 = (x970)+(x884); + x972 = (uintptr_t)((x971)<(x884)); + x973 = (x971)+(x933); + x974 = (uintptr_t)((x973)<(x933)); + x975 = (x972)+(x974); + x976 = (x934)*((uintptr_t)307527195ULL); + x977 = (x976)*((uintptr_t)268435456ULL); + x978 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x976)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x976)*((uintptr_t)268435456ULL))>>64); + x979 = (x976)*((uintptr_t)350157278ULL); + x980 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x976)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x976)*((uintptr_t)350157278ULL))>>64); + x981 = (x976)*((uintptr_t)2734136534ULL); + x982 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x976)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x976)*((uintptr_t)2734136534ULL))>>64); + x983 = (x976)*((uintptr_t)1477600026ULL); + x984 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x976)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x976)*((uintptr_t)1477600026ULL))>>64); + x985 = (x976)*((uintptr_t)1559614445ULL); + x986 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x976)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x976)*((uintptr_t)1559614445ULL))>>64); + x987 = (x986)+(x983); + x988 = (uintptr_t)((x987)<(x986)); + x989 = (x988)+(x984); + x990 = (uintptr_t)((x989)<(x984)); + x991 = (x989)+(x981); + x992 = (uintptr_t)((x991)<(x981)); + x993 = (x990)+(x992); + x994 = (x993)+(x982); + x995 = (uintptr_t)((x994)<(x982)); + x996 = (x994)+(x979); + x997 = (uintptr_t)((x996)<(x979)); + x998 = (x995)+(x997); + x999 = (x998)+(x980); + x1000 = (x934)+(x985); + x1001 = (uintptr_t)((x1000)<(x934)); + x1002 = (x1001)+(x938); + x1003 = (uintptr_t)((x1002)<(x938)); + x1004 = (x1002)+(x987); + x1005 = (uintptr_t)((x1004)<(x987)); + x1006 = (x1003)+(x1005); + x1007 = (x1006)+(x943); + x1008 = (uintptr_t)((x1007)<(x943)); + x1009 = (x1007)+(x991); + x1010 = (uintptr_t)((x1009)<(x991)); + x1011 = (x1008)+(x1010); + x1012 = (x1011)+(x948); + x1013 = (uintptr_t)((x1012)<(x948)); + x1014 = (x1012)+(x996); + x1015 = (uintptr_t)((x1014)<(x996)); + x1016 = (x1013)+(x1015); + x1017 = (x1016)+(x953); + x1018 = (uintptr_t)((x1017)<(x953)); + x1019 = (x1017)+(x999); + x1020 = (uintptr_t)((x1019)<(x999)); + x1021 = (x1018)+(x1020); + x1022 = (x1021)+(x958); + x1023 = (uintptr_t)((x1022)<(x958)); + x1024 = (x1023)+(x963); + x1025 = (uintptr_t)((x1024)<(x963)); + x1026 = (x1025)+(x968); + x1027 = (uintptr_t)((x1026)<(x968)); + x1028 = (x1026)+(x977); + x1029 = (uintptr_t)((x1028)<(x977)); + x1030 = (x1027)+(x1029); + x1031 = (x1030)+(x973); + x1032 = (uintptr_t)((x1031)<(x973)); + x1033 = (x1031)+(x978); + x1034 = (uintptr_t)((x1033)<(x978)); + x1035 = (x1032)+(x1034); + x1036 = (x1035)+(x975); + x1037 = (x14)*(x7); + x1038 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x7))>>32 : ((__uint128_t)(x14)*(x7))>>64); + x1039 = (x14)*(x6); + x1040 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x6))>>32 : ((__uint128_t)(x14)*(x6))>>64); + x1041 = (x14)*(x5); + x1042 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x5))>>32 : ((__uint128_t)(x14)*(x5))>>64); + x1043 = (x14)*(x4); + x1044 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x4))>>32 : ((__uint128_t)(x14)*(x4))>>64); + x1045 = (x14)*(x3); + x1046 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x3))>>32 : ((__uint128_t)(x14)*(x3))>>64); + x1047 = (x14)*(x2); + x1048 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x2))>>32 : ((__uint128_t)(x14)*(x2))>>64); + x1049 = (x14)*(x1); + x1050 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x1))>>32 : ((__uint128_t)(x14)*(x1))>>64); + x1051 = (x14)*(x0); + x1052 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x0))>>32 : ((__uint128_t)(x14)*(x0))>>64); + x1053 = (x1052)+(x1049); + x1054 = (uintptr_t)((x1053)<(x1052)); + x1055 = (x1054)+(x1050); + x1056 = (uintptr_t)((x1055)<(x1050)); + x1057 = (x1055)+(x1047); + x1058 = (uintptr_t)((x1057)<(x1047)); + x1059 = (x1056)+(x1058); + x1060 = (x1059)+(x1048); + x1061 = (uintptr_t)((x1060)<(x1048)); + x1062 = (x1060)+(x1045); + x1063 = (uintptr_t)((x1062)<(x1045)); + x1064 = (x1061)+(x1063); + x1065 = (x1064)+(x1046); + x1066 = (uintptr_t)((x1065)<(x1046)); + x1067 = (x1065)+(x1043); + x1068 = (uintptr_t)((x1067)<(x1043)); + x1069 = (x1066)+(x1068); + x1070 = (x1069)+(x1044); + x1071 = (uintptr_t)((x1070)<(x1044)); + x1072 = (x1070)+(x1041); + x1073 = (uintptr_t)((x1072)<(x1041)); + x1074 = (x1071)+(x1073); + x1075 = (x1074)+(x1042); + x1076 = (uintptr_t)((x1075)<(x1042)); + x1077 = (x1075)+(x1039); + x1078 = (uintptr_t)((x1077)<(x1039)); + x1079 = (x1076)+(x1078); + x1080 = (x1079)+(x1040); + x1081 = (uintptr_t)((x1080)<(x1040)); + x1082 = (x1080)+(x1037); + x1083 = (uintptr_t)((x1082)<(x1037)); + x1084 = (x1081)+(x1083); + x1085 = (x1084)+(x1038); + x1086 = (x1004)+(x1051); + x1087 = (uintptr_t)((x1086)<(x1004)); + x1088 = (x1087)+(x1009); + x1089 = (uintptr_t)((x1088)<(x1009)); + x1090 = (x1088)+(x1053); + x1091 = (uintptr_t)((x1090)<(x1053)); + x1092 = (x1089)+(x1091); + x1093 = (x1092)+(x1014); + x1094 = (uintptr_t)((x1093)<(x1014)); + x1095 = (x1093)+(x1057); + x1096 = (uintptr_t)((x1095)<(x1057)); + x1097 = (x1094)+(x1096); + x1098 = (x1097)+(x1019); + x1099 = (uintptr_t)((x1098)<(x1019)); + x1100 = (x1098)+(x1062); + x1101 = (uintptr_t)((x1100)<(x1062)); + x1102 = (x1099)+(x1101); + x1103 = (x1102)+(x1022); + x1104 = (uintptr_t)((x1103)<(x1022)); + x1105 = (x1103)+(x1067); + x1106 = (uintptr_t)((x1105)<(x1067)); + x1107 = (x1104)+(x1106); + x1108 = (x1107)+(x1024); + x1109 = (uintptr_t)((x1108)<(x1024)); + x1110 = (x1108)+(x1072); + x1111 = (uintptr_t)((x1110)<(x1072)); + x1112 = (x1109)+(x1111); + x1113 = (x1112)+(x1028); + x1114 = (uintptr_t)((x1113)<(x1028)); + x1115 = (x1113)+(x1077); + x1116 = (uintptr_t)((x1115)<(x1077)); + x1117 = (x1114)+(x1116); + x1118 = (x1117)+(x1033); + x1119 = (uintptr_t)((x1118)<(x1033)); + x1120 = (x1118)+(x1082); + x1121 = (uintptr_t)((x1120)<(x1082)); + x1122 = (x1119)+(x1121); + x1123 = (x1122)+(x1036); + x1124 = (uintptr_t)((x1123)<(x1036)); + x1125 = (x1123)+(x1085); + x1126 = (uintptr_t)((x1125)<(x1085)); + x1127 = (x1124)+(x1126); + x1128 = (x1086)*((uintptr_t)307527195ULL); + x1129 = (x1128)*((uintptr_t)268435456ULL); + x1130 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1128)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x1128)*((uintptr_t)268435456ULL))>>64); + x1131 = (x1128)*((uintptr_t)350157278ULL); + x1132 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1128)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x1128)*((uintptr_t)350157278ULL))>>64); + x1133 = (x1128)*((uintptr_t)2734136534ULL); + x1134 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1128)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x1128)*((uintptr_t)2734136534ULL))>>64); + x1135 = (x1128)*((uintptr_t)1477600026ULL); + x1136 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1128)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x1128)*((uintptr_t)1477600026ULL))>>64); + x1137 = (x1128)*((uintptr_t)1559614445ULL); + x1138 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1128)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x1128)*((uintptr_t)1559614445ULL))>>64); + x1139 = (x1138)+(x1135); + x1140 = (uintptr_t)((x1139)<(x1138)); + x1141 = (x1140)+(x1136); + x1142 = (uintptr_t)((x1141)<(x1136)); + x1143 = (x1141)+(x1133); + x1144 = (uintptr_t)((x1143)<(x1133)); + x1145 = (x1142)+(x1144); + x1146 = (x1145)+(x1134); + x1147 = (uintptr_t)((x1146)<(x1134)); + x1148 = (x1146)+(x1131); + x1149 = (uintptr_t)((x1148)<(x1131)); + x1150 = (x1147)+(x1149); + x1151 = (x1150)+(x1132); + x1152 = (x1086)+(x1137); + x1153 = (uintptr_t)((x1152)<(x1086)); + x1154 = (x1153)+(x1090); + x1155 = (uintptr_t)((x1154)<(x1090)); + x1156 = (x1154)+(x1139); + x1157 = (uintptr_t)((x1156)<(x1139)); + x1158 = (x1155)+(x1157); + x1159 = (x1158)+(x1095); + x1160 = (uintptr_t)((x1159)<(x1095)); + x1161 = (x1159)+(x1143); + x1162 = (uintptr_t)((x1161)<(x1143)); + x1163 = (x1160)+(x1162); + x1164 = (x1163)+(x1100); + x1165 = (uintptr_t)((x1164)<(x1100)); + x1166 = (x1164)+(x1148); + x1167 = (uintptr_t)((x1166)<(x1148)); + x1168 = (x1165)+(x1167); + x1169 = (x1168)+(x1105); + x1170 = (uintptr_t)((x1169)<(x1105)); + x1171 = (x1169)+(x1151); + x1172 = (uintptr_t)((x1171)<(x1151)); + x1173 = (x1170)+(x1172); + x1174 = (x1173)+(x1110); + x1175 = (uintptr_t)((x1174)<(x1110)); + x1176 = (x1175)+(x1115); + x1177 = (uintptr_t)((x1176)<(x1115)); + x1178 = (x1177)+(x1120); + x1179 = (uintptr_t)((x1178)<(x1120)); + x1180 = (x1178)+(x1129); + x1181 = (uintptr_t)((x1180)<(x1129)); + x1182 = (x1179)+(x1181); + x1183 = (x1182)+(x1125); + x1184 = (uintptr_t)((x1183)<(x1125)); + x1185 = (x1183)+(x1130); + x1186 = (uintptr_t)((x1185)<(x1130)); + x1187 = (x1184)+(x1186); + x1188 = (x1187)+(x1127); + x1189 = (x1156)-((uintptr_t)1559614445ULL); + x1190 = (uintptr_t)((x1156)<(x1189)); + x1191 = (x1161)-((uintptr_t)1477600026ULL); + x1192 = (uintptr_t)((x1161)<(x1191)); + x1193 = (x1191)-(x1190); + x1194 = (uintptr_t)((x1191)<(x1193)); + x1195 = (x1192)+(x1194); + x1196 = (x1166)-((uintptr_t)2734136534ULL); + x1197 = (uintptr_t)((x1166)<(x1196)); + x1198 = (x1196)-(x1195); + x1199 = (uintptr_t)((x1196)<(x1198)); + x1200 = (x1197)+(x1199); + x1201 = (x1171)-((uintptr_t)350157278ULL); + x1202 = (uintptr_t)((x1171)<(x1201)); + x1203 = (x1201)-(x1200); + x1204 = (uintptr_t)((x1201)<(x1203)); + x1205 = (x1202)+(x1204); + x1206 = (x1174)-(x1205); + x1207 = (uintptr_t)((x1174)<(x1206)); + x1208 = (x1176)-(x1207); + x1209 = (uintptr_t)((x1176)<(x1208)); + x1210 = (x1180)-(x1209); + x1211 = (uintptr_t)((x1180)<(x1210)); + x1212 = (x1185)-((uintptr_t)268435456ULL); + x1213 = (uintptr_t)((x1185)<(x1212)); + x1214 = (x1212)-(x1211); + x1215 = (uintptr_t)((x1212)<(x1214)); + x1216 = (x1213)+(x1215); + x1217 = (x1188)-(x1216); + x1218 = (uintptr_t)((x1188)<(x1217)); + x1219 = ((uintptr_t)-1ULL)+((uintptr_t)((x1218)==((uintptr_t)0ULL))); + x1220 = (x1219)^((uintptr_t)4294967295ULL); + x1221 = ((x1156)&(x1219))|((x1189)&(x1220)); + x1222 = ((uintptr_t)-1ULL)+((uintptr_t)((x1218)==((uintptr_t)0ULL))); + x1223 = (x1222)^((uintptr_t)4294967295ULL); + x1224 = ((x1161)&(x1222))|((x1193)&(x1223)); + x1225 = ((uintptr_t)-1ULL)+((uintptr_t)((x1218)==((uintptr_t)0ULL))); + x1226 = (x1225)^((uintptr_t)4294967295ULL); + x1227 = ((x1166)&(x1225))|((x1198)&(x1226)); + x1228 = ((uintptr_t)-1ULL)+((uintptr_t)((x1218)==((uintptr_t)0ULL))); + x1229 = (x1228)^((uintptr_t)4294967295ULL); + x1230 = ((x1171)&(x1228))|((x1203)&(x1229)); + x1231 = ((uintptr_t)-1ULL)+((uintptr_t)((x1218)==((uintptr_t)0ULL))); + x1232 = (x1231)^((uintptr_t)4294967295ULL); + x1233 = ((x1174)&(x1231))|((x1206)&(x1232)); + x1234 = ((uintptr_t)-1ULL)+((uintptr_t)((x1218)==((uintptr_t)0ULL))); + x1235 = (x1234)^((uintptr_t)4294967295ULL); + x1236 = ((x1176)&(x1234))|((x1208)&(x1235)); + x1237 = ((uintptr_t)-1ULL)+((uintptr_t)((x1218)==((uintptr_t)0ULL))); + x1238 = (x1237)^((uintptr_t)4294967295ULL); + x1239 = ((x1180)&(x1237))|((x1210)&(x1238)); + x1240 = ((uintptr_t)-1ULL)+((uintptr_t)((x1218)==((uintptr_t)0ULL))); + x1241 = (x1240)^((uintptr_t)4294967295ULL); + x1242 = ((x1185)&(x1240))|((x1214)&(x1241)); + x1243 = x1221; + x1244 = x1224; + x1245 = x1227; + x1246 = x1230; + x1247 = x1233; + x1248 = x1236; + x1249 = x1239; + x1250 = x1242; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x1243, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1244, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1245, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x1246, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x1247, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x1248, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x1249, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x1250, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_square(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_25519_scalar_square((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_25519_scalar_add(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x8, x0, x17, x1, x9, x19, x2, x10, x21, x3, x11, x23, x4, x12, x25, x5, x13, x27, x6, x14, x29, x7, x15, x33, x35, x37, x31, x42, x16, x45, x32, x46, x18, x48, x34, x49, x20, x51, x36, x52, x22, x54, x38, x55, x24, x57, x39, x58, x26, x60, x40, x61, x28, x63, x41, x64, x44, x30, x66, x43, x67, x47, x50, x53, x56, x59, x62, x65, x68, x69, x70, x71, x72, x73, x74, x75, x76; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = (x0)+(x8); + x17 = ((uintptr_t)((x16)<(x0)))+(x1); + x18 = (x17)+(x9); + x19 = (((uintptr_t)((x17)<(x1)))+((uintptr_t)((x18)<(x9))))+(x2); + x20 = (x19)+(x10); + x21 = (((uintptr_t)((x19)<(x2)))+((uintptr_t)((x20)<(x10))))+(x3); + x22 = (x21)+(x11); + x23 = (((uintptr_t)((x21)<(x3)))+((uintptr_t)((x22)<(x11))))+(x4); + x24 = (x23)+(x12); + x25 = (((uintptr_t)((x23)<(x4)))+((uintptr_t)((x24)<(x12))))+(x5); + x26 = (x25)+(x13); + x27 = (((uintptr_t)((x25)<(x5)))+((uintptr_t)((x26)<(x13))))+(x6); + x28 = (x27)+(x14); + x29 = (((uintptr_t)((x27)<(x6)))+((uintptr_t)((x28)<(x14))))+(x7); + x30 = (x29)+(x15); + x31 = ((uintptr_t)((x29)<(x7)))+((uintptr_t)((x30)<(x15))); + x32 = (x16)-((uintptr_t)1559614445ULL); + x33 = (x18)-((uintptr_t)1477600026ULL); + x34 = (x33)-((uintptr_t)((x16)<(x32))); + x35 = (x20)-((uintptr_t)2734136534ULL); + x36 = (x35)-(((uintptr_t)((x18)<(x33)))+((uintptr_t)((x33)<(x34)))); + x37 = (x22)-((uintptr_t)350157278ULL); + x38 = (x37)-(((uintptr_t)((x20)<(x35)))+((uintptr_t)((x35)<(x36)))); + x39 = (x24)-(((uintptr_t)((x22)<(x37)))+((uintptr_t)((x37)<(x38)))); + x40 = (x26)-((uintptr_t)((x24)<(x39))); + x41 = (x28)-((uintptr_t)((x26)<(x40))); + x42 = (x30)-((uintptr_t)268435456ULL); + x43 = (x42)-((uintptr_t)((x28)<(x41))); + x44 = (uintptr_t)((x31)<((x31)-(((uintptr_t)((x30)<(x42)))+((uintptr_t)((x42)<(x43)))))); + x45 = ((uintptr_t)-1ULL)+((uintptr_t)((x44)==((uintptr_t)0ULL))); + x46 = (x45)^((uintptr_t)4294967295ULL); + x47 = ((x16)&(x45))|((x32)&(x46)); + x48 = ((uintptr_t)-1ULL)+((uintptr_t)((x44)==((uintptr_t)0ULL))); + x49 = (x48)^((uintptr_t)4294967295ULL); + x50 = ((x18)&(x48))|((x34)&(x49)); + x51 = ((uintptr_t)-1ULL)+((uintptr_t)((x44)==((uintptr_t)0ULL))); + x52 = (x51)^((uintptr_t)4294967295ULL); + x53 = ((x20)&(x51))|((x36)&(x52)); + x54 = ((uintptr_t)-1ULL)+((uintptr_t)((x44)==((uintptr_t)0ULL))); + x55 = (x54)^((uintptr_t)4294967295ULL); + x56 = ((x22)&(x54))|((x38)&(x55)); + x57 = ((uintptr_t)-1ULL)+((uintptr_t)((x44)==((uintptr_t)0ULL))); + x58 = (x57)^((uintptr_t)4294967295ULL); + x59 = ((x24)&(x57))|((x39)&(x58)); + x60 = ((uintptr_t)-1ULL)+((uintptr_t)((x44)==((uintptr_t)0ULL))); + x61 = (x60)^((uintptr_t)4294967295ULL); + x62 = ((x26)&(x60))|((x40)&(x61)); + x63 = ((uintptr_t)-1ULL)+((uintptr_t)((x44)==((uintptr_t)0ULL))); + x64 = (x63)^((uintptr_t)4294967295ULL); + x65 = ((x28)&(x63))|((x41)&(x64)); + x66 = ((uintptr_t)-1ULL)+((uintptr_t)((x44)==((uintptr_t)0ULL))); + x67 = (x66)^((uintptr_t)4294967295ULL); + x68 = ((x30)&(x66))|((x43)&(x67)); + x69 = x47; + x70 = x50; + x71 = x53; + x72 = x56; + x73 = x59; + x74 = x62; + x75 = x65; + x76 = x68; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x69, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x70, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x71, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x72, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x73, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x74, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x75, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x76, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_add(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_25519_scalar_add((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_25519_scalar_sub(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x8, x9, x0, x10, x1, x17, x11, x2, x19, x12, x3, x21, x13, x4, x23, x14, x5, x25, x15, x6, x27, x7, x29, x16, x33, x18, x35, x20, x37, x22, x24, x26, x28, x30, x31, x32, x34, x36, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = (x0)-(x8); + x17 = (x1)-(x9); + x18 = (x17)-((uintptr_t)((x0)<(x16))); + x19 = (x2)-(x10); + x20 = (x19)-(((uintptr_t)((x1)<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = (x3)-(x11); + x22 = (x21)-(((uintptr_t)((x2)<(x19)))+((uintptr_t)((x19)<(x20)))); + x23 = (x4)-(x12); + x24 = (x23)-(((uintptr_t)((x3)<(x21)))+((uintptr_t)((x21)<(x22)))); + x25 = (x5)-(x13); + x26 = (x25)-(((uintptr_t)((x4)<(x23)))+((uintptr_t)((x23)<(x24)))); + x27 = (x6)-(x14); + x28 = (x27)-(((uintptr_t)((x5)<(x25)))+((uintptr_t)((x25)<(x26)))); + x29 = (x7)-(x15); + x30 = (x29)-(((uintptr_t)((x6)<(x27)))+((uintptr_t)((x27)<(x28)))); + x31 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)((x7)<(x29)))+((uintptr_t)((x29)<(x30))))==((uintptr_t)0ULL))); + x32 = (x16)+((x31)&((uintptr_t)1559614445ULL)); + x33 = ((uintptr_t)((x32)<(x16)))+(x18); + x34 = (x33)+((x31)&((uintptr_t)1477600026ULL)); + x35 = (((uintptr_t)((x33)<(x18)))+((uintptr_t)((x34)<((x31)&((uintptr_t)1477600026ULL)))))+(x20); + x36 = (x35)+((x31)&((uintptr_t)2734136534ULL)); + x37 = (((uintptr_t)((x35)<(x20)))+((uintptr_t)((x36)<((x31)&((uintptr_t)2734136534ULL)))))+(x22); + x38 = (x37)+((x31)&((uintptr_t)350157278ULL)); + x39 = (((uintptr_t)((x37)<(x22)))+((uintptr_t)((x38)<((x31)&((uintptr_t)350157278ULL)))))+(x24); + x40 = ((uintptr_t)((x39)<(x24)))+(x26); + x41 = ((uintptr_t)((x40)<(x26)))+(x28); + x42 = (((uintptr_t)((x41)<(x28)))+(x30))+((x31)&((uintptr_t)268435456ULL)); + x43 = x32; + x44 = x34; + x45 = x36; + x46 = x38; + x47 = x39; + x48 = x40; + x49 = x41; + x50 = x42; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x43, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x44, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x45, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x46, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x47, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x48, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x49, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x50, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_sub(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_25519_scalar_sub((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_25519_scalar_opp(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x1, x2, x9, x3, x11, x4, x13, x5, x15, x6, x17, x7, x19, x21, x8, x25, x10, x27, x12, x29, x14, x16, x18, x20, x22, x23, x24, x26, x28, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = ((uintptr_t)0ULL)-(x0); + x9 = ((uintptr_t)0ULL)-(x1); + x10 = (x9)-((uintptr_t)(((uintptr_t)0ULL)<(x8))); + x11 = ((uintptr_t)0ULL)-(x2); + x12 = (x11)-(((uintptr_t)(((uintptr_t)0ULL)<(x9)))+((uintptr_t)((x9)<(x10)))); + x13 = ((uintptr_t)0ULL)-(x3); + x14 = (x13)-(((uintptr_t)(((uintptr_t)0ULL)<(x11)))+((uintptr_t)((x11)<(x12)))); + x15 = ((uintptr_t)0ULL)-(x4); + x16 = (x15)-(((uintptr_t)(((uintptr_t)0ULL)<(x13)))+((uintptr_t)((x13)<(x14)))); + x17 = ((uintptr_t)0ULL)-(x5); + x18 = (x17)-(((uintptr_t)(((uintptr_t)0ULL)<(x15)))+((uintptr_t)((x15)<(x16)))); + x19 = ((uintptr_t)0ULL)-(x6); + x20 = (x19)-(((uintptr_t)(((uintptr_t)0ULL)<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = ((uintptr_t)0ULL)-(x7); + x22 = (x21)-(((uintptr_t)(((uintptr_t)0ULL)<(x19)))+((uintptr_t)((x19)<(x20)))); + x23 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)(((uintptr_t)0ULL)<(x21)))+((uintptr_t)((x21)<(x22))))==((uintptr_t)0ULL))); + x24 = (x8)+((x23)&((uintptr_t)1559614445ULL)); + x25 = ((uintptr_t)((x24)<(x8)))+(x10); + x26 = (x25)+((x23)&((uintptr_t)1477600026ULL)); + x27 = (((uintptr_t)((x25)<(x10)))+((uintptr_t)((x26)<((x23)&((uintptr_t)1477600026ULL)))))+(x12); + x28 = (x27)+((x23)&((uintptr_t)2734136534ULL)); + x29 = (((uintptr_t)((x27)<(x12)))+((uintptr_t)((x28)<((x23)&((uintptr_t)2734136534ULL)))))+(x14); + x30 = (x29)+((x23)&((uintptr_t)350157278ULL)); + x31 = (((uintptr_t)((x29)<(x14)))+((uintptr_t)((x30)<((x23)&((uintptr_t)350157278ULL)))))+(x16); + x32 = ((uintptr_t)((x31)<(x16)))+(x18); + x33 = ((uintptr_t)((x32)<(x18)))+(x20); + x34 = (((uintptr_t)((x33)<(x20)))+(x22))+((x23)&((uintptr_t)268435456ULL)); + x35 = x24; + x36 = x26; + x37 = x28; + x38 = x30; + x39 = x31; + x40 = x32; + x41 = x33; + x42 = x34; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x35, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x36, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x37, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x38, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x39, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x40, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x41, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x42, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_opp(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_25519_scalar_opp((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_25519_scalar_from_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x17, x19, x16, x14, x21, x15, x12, x9, x8, x18, x20, x22, x1, x24, x25, x26, x39, x41, x38, x36, x43, x37, x34, x28, x46, x29, x40, x48, x30, x42, x50, x31, x27, x23, x13, x44, x32, x11, x2, x47, x49, x51, x66, x68, x65, x63, x70, x64, x61, x55, x73, x56, x67, x75, x57, x69, x77, x58, x52, x45, x35, x71, x59, x54, x33, x3, x74, x76, x78, x94, x96, x93, x91, x98, x92, x89, x86, x82, x101, x83, x95, x103, x84, x97, x105, x85, x79, x72, x62, x99, x107, x10, x100, x90, x53, x80, x111, x81, x60, x87, x4, x102, x104, x106, x108, x109, x110, x112, x130, x132, x129, x127, x134, x128, x125, x122, x114, x137, x115, x131, x139, x116, x133, x141, x117, x135, x143, x118, x136, x126, x119, x120, x147, x121, x113, x88, x123, x5, x138, x140, x142, x144, x145, x146, x148, x166, x168, x165, x163, x170, x164, x161, x158, x150, x173, x151, x167, x175, x152, x169, x177, x153, x171, x179, x154, x172, x162, x155, x156, x183, x157, x149, x124, x159, x6, x174, x176, x178, x180, x181, x182, x184, x202, x204, x201, x199, x206, x200, x197, x194, x186, x209, x187, x203, x211, x188, x205, x213, x189, x207, x215, x190, x208, x198, x191, x192, x219, x193, x185, x160, x195, x7, x210, x212, x214, x216, x217, x218, x220, x237, x239, x236, x234, x241, x235, x232, x222, x244, x223, x238, x246, x224, x240, x248, x225, x242, x250, x226, x243, x233, x227, x228, x254, x229, x221, x196, x231, x230, x258, x260, x262, x267, x245, x270, x257, x271, x247, x273, x259, x274, x249, x276, x261, x277, x251, x279, x263, x280, x252, x282, x264, x283, x253, x285, x265, x286, x255, x288, x266, x289, x269, x256, x291, x268, x292, x272, x275, x278, x281, x284, x287, x290, x293, x294, x295, x296, x297, x298, x299, x300, x301; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x0; + x9 = (x8)*((uintptr_t)307527195ULL); + x10 = (x9)*((uintptr_t)268435456ULL); + x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)268435456ULL))>>64); + x12 = (x9)*((uintptr_t)350157278ULL); + x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)350157278ULL))>>64); + x14 = (x9)*((uintptr_t)2734136534ULL); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)2734136534ULL))>>64); + x16 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)1477600026ULL))>>64); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)1559614445ULL))>>64); + x18 = (x17)+((x9)*((uintptr_t)1477600026ULL)); + x19 = ((uintptr_t)((x18)<(x17)))+(x16); + x20 = (x19)+(x14); + x21 = (((uintptr_t)((x19)<(x16)))+((uintptr_t)((x20)<(x14))))+(x15); + x22 = (x21)+(x12); + x23 = ((uintptr_t)((x21)<(x15)))+((uintptr_t)((x22)<(x12))); + x24 = ((uintptr_t)(((x8)+((x9)*((uintptr_t)1559614445ULL)))<(x8)))+(x18); + x25 = ((uintptr_t)((x24)<(x18)))+(x20); + x26 = ((uintptr_t)((x25)<(x20)))+(x22); + x27 = (uintptr_t)((x26)<(x22)); + x28 = (x24)+(x1); + x29 = ((uintptr_t)((x28)<(x24)))+(x25); + x30 = ((uintptr_t)((x29)<(x25)))+(x26); + x31 = (uintptr_t)((x30)<(x26)); + x32 = (x28)*((uintptr_t)307527195ULL); + x33 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x32)*((uintptr_t)268435456ULL))>>64); + x34 = (x32)*((uintptr_t)350157278ULL); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x32)*((uintptr_t)350157278ULL))>>64); + x36 = (x32)*((uintptr_t)2734136534ULL); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x32)*((uintptr_t)2734136534ULL))>>64); + x38 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x32)*((uintptr_t)1477600026ULL))>>64); + x39 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x32)*((uintptr_t)1559614445ULL))>>64); + x40 = (x39)+((x32)*((uintptr_t)1477600026ULL)); + x41 = ((uintptr_t)((x40)<(x39)))+(x38); + x42 = (x41)+(x36); + x43 = (((uintptr_t)((x41)<(x38)))+((uintptr_t)((x42)<(x36))))+(x37); + x44 = (x43)+(x34); + x45 = ((uintptr_t)((x43)<(x37)))+((uintptr_t)((x44)<(x34))); + x46 = ((uintptr_t)(((x28)+((x32)*((uintptr_t)1559614445ULL)))<(x28)))+(x29); + x47 = (x46)+(x40); + x48 = (((uintptr_t)((x46)<(x29)))+((uintptr_t)((x47)<(x40))))+(x30); + x49 = (x48)+(x42); + x50 = (((uintptr_t)((x48)<(x30)))+((uintptr_t)((x49)<(x42))))+((x31)+((x27)+((x23)+(x13)))); + x51 = (x50)+(x44); + x52 = ((uintptr_t)((x50)<((x31)+((x27)+((x23)+(x13))))))+((uintptr_t)((x51)<(x44))); + x53 = (x11)+((x32)*((uintptr_t)268435456ULL)); + x54 = (uintptr_t)((x53)<(x11)); + x55 = (x47)+(x2); + x56 = ((uintptr_t)((x55)<(x47)))+(x49); + x57 = ((uintptr_t)((x56)<(x49)))+(x51); + x58 = (uintptr_t)((x57)<(x51)); + x59 = (x55)*((uintptr_t)307527195ULL); + x60 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x59)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x59)*((uintptr_t)268435456ULL))>>64); + x61 = (x59)*((uintptr_t)350157278ULL); + x62 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x59)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x59)*((uintptr_t)350157278ULL))>>64); + x63 = (x59)*((uintptr_t)2734136534ULL); + x64 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x59)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x59)*((uintptr_t)2734136534ULL))>>64); + x65 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x59)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x59)*((uintptr_t)1477600026ULL))>>64); + x66 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x59)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x59)*((uintptr_t)1559614445ULL))>>64); + x67 = (x66)+((x59)*((uintptr_t)1477600026ULL)); + x68 = ((uintptr_t)((x67)<(x66)))+(x65); + x69 = (x68)+(x63); + x70 = (((uintptr_t)((x68)<(x65)))+((uintptr_t)((x69)<(x63))))+(x64); + x71 = (x70)+(x61); + x72 = ((uintptr_t)((x70)<(x64)))+((uintptr_t)((x71)<(x61))); + x73 = ((uintptr_t)(((x55)+((x59)*((uintptr_t)1559614445ULL)))<(x55)))+(x56); + x74 = (x73)+(x67); + x75 = (((uintptr_t)((x73)<(x56)))+((uintptr_t)((x74)<(x67))))+(x57); + x76 = (x75)+(x69); + x77 = (((uintptr_t)((x75)<(x57)))+((uintptr_t)((x76)<(x69))))+((x58)+((x52)+((x45)+(x35)))); + x78 = (x77)+(x71); + x79 = ((uintptr_t)((x77)<((x58)+((x52)+((x45)+(x35))))))+((uintptr_t)((x78)<(x71))); + x80 = ((x54)+(x33))+((x59)*((uintptr_t)268435456ULL)); + x81 = (uintptr_t)((x80)<((x54)+(x33))); + x82 = (x74)+(x3); + x83 = ((uintptr_t)((x82)<(x74)))+(x76); + x84 = ((uintptr_t)((x83)<(x76)))+(x78); + x85 = (uintptr_t)((x84)<(x78)); + x86 = (x82)*((uintptr_t)307527195ULL); + x87 = (x86)*((uintptr_t)268435456ULL); + x88 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x86)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x86)*((uintptr_t)268435456ULL))>>64); + x89 = (x86)*((uintptr_t)350157278ULL); + x90 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x86)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x86)*((uintptr_t)350157278ULL))>>64); + x91 = (x86)*((uintptr_t)2734136534ULL); + x92 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x86)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x86)*((uintptr_t)2734136534ULL))>>64); + x93 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x86)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x86)*((uintptr_t)1477600026ULL))>>64); + x94 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x86)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x86)*((uintptr_t)1559614445ULL))>>64); + x95 = (x94)+((x86)*((uintptr_t)1477600026ULL)); + x96 = ((uintptr_t)((x95)<(x94)))+(x93); + x97 = (x96)+(x91); + x98 = (((uintptr_t)((x96)<(x93)))+((uintptr_t)((x97)<(x91))))+(x92); + x99 = (x98)+(x89); + x100 = ((uintptr_t)((x98)<(x92)))+((uintptr_t)((x99)<(x89))); + x101 = ((uintptr_t)(((x82)+((x86)*((uintptr_t)1559614445ULL)))<(x82)))+(x83); + x102 = (x101)+(x95); + x103 = (((uintptr_t)((x101)<(x83)))+((uintptr_t)((x102)<(x95))))+(x84); + x104 = (x103)+(x97); + x105 = (((uintptr_t)((x103)<(x84)))+((uintptr_t)((x104)<(x97))))+((x85)+((x79)+((x72)+(x62)))); + x106 = (x105)+(x99); + x107 = (((uintptr_t)((x105)<((x85)+((x79)+((x72)+(x62))))))+((uintptr_t)((x106)<(x99))))+(x10); + x108 = (x107)+((x100)+(x90)); + x109 = (((uintptr_t)((x107)<(x10)))+((uintptr_t)((x108)<((x100)+(x90)))))+(x53); + x110 = ((uintptr_t)((x109)<(x53)))+(x80); + x111 = ((uintptr_t)((x110)<(x80)))+((x81)+(x60)); + x112 = (x111)+(x87); + x113 = ((uintptr_t)((x111)<((x81)+(x60))))+((uintptr_t)((x112)<(x87))); + x114 = (x102)+(x4); + x115 = ((uintptr_t)((x114)<(x102)))+(x104); + x116 = ((uintptr_t)((x115)<(x104)))+(x106); + x117 = ((uintptr_t)((x116)<(x106)))+(x108); + x118 = ((uintptr_t)((x117)<(x108)))+(x109); + x119 = ((uintptr_t)((x118)<(x109)))+(x110); + x120 = ((uintptr_t)((x119)<(x110)))+(x112); + x121 = (uintptr_t)((x120)<(x112)); + x122 = (x114)*((uintptr_t)307527195ULL); + x123 = (x122)*((uintptr_t)268435456ULL); + x124 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x122)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x122)*((uintptr_t)268435456ULL))>>64); + x125 = (x122)*((uintptr_t)350157278ULL); + x126 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x122)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x122)*((uintptr_t)350157278ULL))>>64); + x127 = (x122)*((uintptr_t)2734136534ULL); + x128 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x122)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x122)*((uintptr_t)2734136534ULL))>>64); + x129 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x122)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x122)*((uintptr_t)1477600026ULL))>>64); + x130 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x122)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x122)*((uintptr_t)1559614445ULL))>>64); + x131 = (x130)+((x122)*((uintptr_t)1477600026ULL)); + x132 = ((uintptr_t)((x131)<(x130)))+(x129); + x133 = (x132)+(x127); + x134 = (((uintptr_t)((x132)<(x129)))+((uintptr_t)((x133)<(x127))))+(x128); + x135 = (x134)+(x125); + x136 = ((uintptr_t)((x134)<(x128)))+((uintptr_t)((x135)<(x125))); + x137 = ((uintptr_t)(((x114)+((x122)*((uintptr_t)1559614445ULL)))<(x114)))+(x115); + x138 = (x137)+(x131); + x139 = (((uintptr_t)((x137)<(x115)))+((uintptr_t)((x138)<(x131))))+(x116); + x140 = (x139)+(x133); + x141 = (((uintptr_t)((x139)<(x116)))+((uintptr_t)((x140)<(x133))))+(x117); + x142 = (x141)+(x135); + x143 = (((uintptr_t)((x141)<(x117)))+((uintptr_t)((x142)<(x135))))+(x118); + x144 = (x143)+((x136)+(x126)); + x145 = (((uintptr_t)((x143)<(x118)))+((uintptr_t)((x144)<((x136)+(x126)))))+(x119); + x146 = ((uintptr_t)((x145)<(x119)))+(x120); + x147 = ((uintptr_t)((x146)<(x120)))+((x121)+((x113)+(x88))); + x148 = (x147)+(x123); + x149 = ((uintptr_t)((x147)<((x121)+((x113)+(x88)))))+((uintptr_t)((x148)<(x123))); + x150 = (x138)+(x5); + x151 = ((uintptr_t)((x150)<(x138)))+(x140); + x152 = ((uintptr_t)((x151)<(x140)))+(x142); + x153 = ((uintptr_t)((x152)<(x142)))+(x144); + x154 = ((uintptr_t)((x153)<(x144)))+(x145); + x155 = ((uintptr_t)((x154)<(x145)))+(x146); + x156 = ((uintptr_t)((x155)<(x146)))+(x148); + x157 = (uintptr_t)((x156)<(x148)); + x158 = (x150)*((uintptr_t)307527195ULL); + x159 = (x158)*((uintptr_t)268435456ULL); + x160 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x158)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x158)*((uintptr_t)268435456ULL))>>64); + x161 = (x158)*((uintptr_t)350157278ULL); + x162 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x158)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x158)*((uintptr_t)350157278ULL))>>64); + x163 = (x158)*((uintptr_t)2734136534ULL); + x164 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x158)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x158)*((uintptr_t)2734136534ULL))>>64); + x165 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x158)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x158)*((uintptr_t)1477600026ULL))>>64); + x166 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x158)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x158)*((uintptr_t)1559614445ULL))>>64); + x167 = (x166)+((x158)*((uintptr_t)1477600026ULL)); + x168 = ((uintptr_t)((x167)<(x166)))+(x165); + x169 = (x168)+(x163); + x170 = (((uintptr_t)((x168)<(x165)))+((uintptr_t)((x169)<(x163))))+(x164); + x171 = (x170)+(x161); + x172 = ((uintptr_t)((x170)<(x164)))+((uintptr_t)((x171)<(x161))); + x173 = ((uintptr_t)(((x150)+((x158)*((uintptr_t)1559614445ULL)))<(x150)))+(x151); + x174 = (x173)+(x167); + x175 = (((uintptr_t)((x173)<(x151)))+((uintptr_t)((x174)<(x167))))+(x152); + x176 = (x175)+(x169); + x177 = (((uintptr_t)((x175)<(x152)))+((uintptr_t)((x176)<(x169))))+(x153); + x178 = (x177)+(x171); + x179 = (((uintptr_t)((x177)<(x153)))+((uintptr_t)((x178)<(x171))))+(x154); + x180 = (x179)+((x172)+(x162)); + x181 = (((uintptr_t)((x179)<(x154)))+((uintptr_t)((x180)<((x172)+(x162)))))+(x155); + x182 = ((uintptr_t)((x181)<(x155)))+(x156); + x183 = ((uintptr_t)((x182)<(x156)))+((x157)+((x149)+(x124))); + x184 = (x183)+(x159); + x185 = ((uintptr_t)((x183)<((x157)+((x149)+(x124)))))+((uintptr_t)((x184)<(x159))); + x186 = (x174)+(x6); + x187 = ((uintptr_t)((x186)<(x174)))+(x176); + x188 = ((uintptr_t)((x187)<(x176)))+(x178); + x189 = ((uintptr_t)((x188)<(x178)))+(x180); + x190 = ((uintptr_t)((x189)<(x180)))+(x181); + x191 = ((uintptr_t)((x190)<(x181)))+(x182); + x192 = ((uintptr_t)((x191)<(x182)))+(x184); + x193 = (uintptr_t)((x192)<(x184)); + x194 = (x186)*((uintptr_t)307527195ULL); + x195 = (x194)*((uintptr_t)268435456ULL); + x196 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x194)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x194)*((uintptr_t)268435456ULL))>>64); + x197 = (x194)*((uintptr_t)350157278ULL); + x198 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x194)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x194)*((uintptr_t)350157278ULL))>>64); + x199 = (x194)*((uintptr_t)2734136534ULL); + x200 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x194)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x194)*((uintptr_t)2734136534ULL))>>64); + x201 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x194)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x194)*((uintptr_t)1477600026ULL))>>64); + x202 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x194)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x194)*((uintptr_t)1559614445ULL))>>64); + x203 = (x202)+((x194)*((uintptr_t)1477600026ULL)); + x204 = ((uintptr_t)((x203)<(x202)))+(x201); + x205 = (x204)+(x199); + x206 = (((uintptr_t)((x204)<(x201)))+((uintptr_t)((x205)<(x199))))+(x200); + x207 = (x206)+(x197); + x208 = ((uintptr_t)((x206)<(x200)))+((uintptr_t)((x207)<(x197))); + x209 = ((uintptr_t)(((x186)+((x194)*((uintptr_t)1559614445ULL)))<(x186)))+(x187); + x210 = (x209)+(x203); + x211 = (((uintptr_t)((x209)<(x187)))+((uintptr_t)((x210)<(x203))))+(x188); + x212 = (x211)+(x205); + x213 = (((uintptr_t)((x211)<(x188)))+((uintptr_t)((x212)<(x205))))+(x189); + x214 = (x213)+(x207); + x215 = (((uintptr_t)((x213)<(x189)))+((uintptr_t)((x214)<(x207))))+(x190); + x216 = (x215)+((x208)+(x198)); + x217 = (((uintptr_t)((x215)<(x190)))+((uintptr_t)((x216)<((x208)+(x198)))))+(x191); + x218 = ((uintptr_t)((x217)<(x191)))+(x192); + x219 = ((uintptr_t)((x218)<(x192)))+((x193)+((x185)+(x160))); + x220 = (x219)+(x195); + x221 = ((uintptr_t)((x219)<((x193)+((x185)+(x160)))))+((uintptr_t)((x220)<(x195))); + x222 = (x210)+(x7); + x223 = ((uintptr_t)((x222)<(x210)))+(x212); + x224 = ((uintptr_t)((x223)<(x212)))+(x214); + x225 = ((uintptr_t)((x224)<(x214)))+(x216); + x226 = ((uintptr_t)((x225)<(x216)))+(x217); + x227 = ((uintptr_t)((x226)<(x217)))+(x218); + x228 = ((uintptr_t)((x227)<(x218)))+(x220); + x229 = (uintptr_t)((x228)<(x220)); + x230 = (x222)*((uintptr_t)307527195ULL); + x231 = (x230)*((uintptr_t)268435456ULL); + x232 = (x230)*((uintptr_t)350157278ULL); + x233 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x230)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x230)*((uintptr_t)350157278ULL))>>64); + x234 = (x230)*((uintptr_t)2734136534ULL); + x235 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x230)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x230)*((uintptr_t)2734136534ULL))>>64); + x236 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x230)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x230)*((uintptr_t)1477600026ULL))>>64); + x237 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x230)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x230)*((uintptr_t)1559614445ULL))>>64); + x238 = (x237)+((x230)*((uintptr_t)1477600026ULL)); + x239 = ((uintptr_t)((x238)<(x237)))+(x236); + x240 = (x239)+(x234); + x241 = (((uintptr_t)((x239)<(x236)))+((uintptr_t)((x240)<(x234))))+(x235); + x242 = (x241)+(x232); + x243 = ((uintptr_t)((x241)<(x235)))+((uintptr_t)((x242)<(x232))); + x244 = ((uintptr_t)(((x222)+((x230)*((uintptr_t)1559614445ULL)))<(x222)))+(x223); + x245 = (x244)+(x238); + x246 = (((uintptr_t)((x244)<(x223)))+((uintptr_t)((x245)<(x238))))+(x224); + x247 = (x246)+(x240); + x248 = (((uintptr_t)((x246)<(x224)))+((uintptr_t)((x247)<(x240))))+(x225); + x249 = (x248)+(x242); + x250 = (((uintptr_t)((x248)<(x225)))+((uintptr_t)((x249)<(x242))))+(x226); + x251 = (x250)+((x243)+(x233)); + x252 = (((uintptr_t)((x250)<(x226)))+((uintptr_t)((x251)<((x243)+(x233)))))+(x227); + x253 = ((uintptr_t)((x252)<(x227)))+(x228); + x254 = ((uintptr_t)((x253)<(x228)))+((x229)+((x221)+(x196))); + x255 = (x254)+(x231); + x256 = (((uintptr_t)((x254)<((x229)+((x221)+(x196)))))+((uintptr_t)((x255)<(x231))))+((uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x230)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x230)*((uintptr_t)268435456ULL))>>64)); + x257 = (x245)-((uintptr_t)1559614445ULL); + x258 = (x247)-((uintptr_t)1477600026ULL); + x259 = (x258)-((uintptr_t)((x245)<(x257))); + x260 = (x249)-((uintptr_t)2734136534ULL); + x261 = (x260)-(((uintptr_t)((x247)<(x258)))+((uintptr_t)((x258)<(x259)))); + x262 = (x251)-((uintptr_t)350157278ULL); + x263 = (x262)-(((uintptr_t)((x249)<(x260)))+((uintptr_t)((x260)<(x261)))); + x264 = (x252)-(((uintptr_t)((x251)<(x262)))+((uintptr_t)((x262)<(x263)))); + x265 = (x253)-((uintptr_t)((x252)<(x264))); + x266 = (x255)-((uintptr_t)((x253)<(x265))); + x267 = (x256)-((uintptr_t)268435456ULL); + x268 = (x267)-((uintptr_t)((x255)<(x266))); + x269 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(((uintptr_t)((x256)<(x267)))+((uintptr_t)((x267)<(x268)))))); + x270 = ((uintptr_t)-1ULL)+((uintptr_t)((x269)==((uintptr_t)0ULL))); + x271 = (x270)^((uintptr_t)4294967295ULL); + x272 = ((x245)&(x270))|((x257)&(x271)); + x273 = ((uintptr_t)-1ULL)+((uintptr_t)((x269)==((uintptr_t)0ULL))); + x274 = (x273)^((uintptr_t)4294967295ULL); + x275 = ((x247)&(x273))|((x259)&(x274)); + x276 = ((uintptr_t)-1ULL)+((uintptr_t)((x269)==((uintptr_t)0ULL))); + x277 = (x276)^((uintptr_t)4294967295ULL); + x278 = ((x249)&(x276))|((x261)&(x277)); + x279 = ((uintptr_t)-1ULL)+((uintptr_t)((x269)==((uintptr_t)0ULL))); + x280 = (x279)^((uintptr_t)4294967295ULL); + x281 = ((x251)&(x279))|((x263)&(x280)); + x282 = ((uintptr_t)-1ULL)+((uintptr_t)((x269)==((uintptr_t)0ULL))); + x283 = (x282)^((uintptr_t)4294967295ULL); + x284 = ((x252)&(x282))|((x264)&(x283)); + x285 = ((uintptr_t)-1ULL)+((uintptr_t)((x269)==((uintptr_t)0ULL))); + x286 = (x285)^((uintptr_t)4294967295ULL); + x287 = ((x253)&(x285))|((x265)&(x286)); + x288 = ((uintptr_t)-1ULL)+((uintptr_t)((x269)==((uintptr_t)0ULL))); + x289 = (x288)^((uintptr_t)4294967295ULL); + x290 = ((x255)&(x288))|((x266)&(x289)); + x291 = ((uintptr_t)-1ULL)+((uintptr_t)((x269)==((uintptr_t)0ULL))); + x292 = (x291)^((uintptr_t)4294967295ULL); + x293 = ((x256)&(x291))|((x268)&(x292)); + x294 = x272; + x295 = x275; + x296 = x278; + x297 = x281; + x298 = x284; + x299 = x287; + x300 = x290; + x301 = x293; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x294, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x295, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x296, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x297, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x298, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x299, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x300, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x301, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_from_montgomery(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_25519_scalar_from_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_25519_scalar_to_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x1, x2, x3, x4, x5, x6, x7, x0, x15, x30, x32, x28, x26, x34, x27, x24, x36, x25, x22, x38, x23, x20, x40, x21, x18, x42, x19, x16, x53, x55, x52, x50, x57, x51, x48, x45, x29, x60, x31, x54, x62, x33, x56, x64, x35, x58, x66, x37, x59, x49, x39, x41, x70, x43, x46, x86, x88, x85, x83, x90, x84, x81, x92, x82, x79, x94, x80, x77, x96, x78, x75, x98, x76, x73, x8, x61, x102, x63, x87, x104, x65, x89, x106, x67, x91, x108, x68, x93, x110, x69, x95, x112, x71, x97, x114, x72, x44, x17, x47, x99, x125, x127, x124, x122, x129, x123, x120, x117, x101, x132, x103, x126, x134, x105, x128, x136, x107, x130, x138, x109, x131, x121, x111, x113, x142, x115, x118, x158, x160, x157, x155, x162, x156, x153, x164, x154, x151, x166, x152, x149, x168, x150, x147, x170, x148, x145, x9, x133, x174, x135, x159, x176, x137, x161, x178, x139, x163, x180, x140, x165, x182, x141, x167, x184, x143, x169, x186, x144, x116, x100, x74, x119, x171, x197, x199, x196, x194, x201, x195, x192, x189, x173, x204, x175, x198, x206, x177, x200, x208, x179, x202, x210, x181, x203, x193, x183, x185, x214, x187, x190, x230, x232, x229, x227, x234, x228, x225, x236, x226, x223, x238, x224, x221, x240, x222, x219, x242, x220, x217, x10, x205, x246, x207, x231, x248, x209, x233, x250, x211, x235, x252, x212, x237, x254, x213, x239, x256, x215, x241, x258, x216, x188, x172, x146, x191, x243, x269, x271, x268, x266, x273, x267, x264, x261, x245, x276, x247, x270, x278, x249, x272, x280, x251, x274, x282, x253, x275, x265, x255, x257, x286, x259, x262, x302, x304, x301, x299, x306, x300, x297, x308, x298, x295, x310, x296, x293, x312, x294, x291, x314, x292, x289, x11, x277, x318, x279, x303, x320, x281, x305, x322, x283, x307, x324, x284, x309, x326, x285, x311, x328, x287, x313, x330, x288, x260, x244, x218, x263, x315, x341, x343, x340, x338, x345, x339, x336, x333, x317, x348, x319, x342, x350, x321, x344, x352, x323, x346, x354, x325, x347, x337, x327, x329, x358, x331, x334, x374, x376, x373, x371, x378, x372, x369, x380, x370, x367, x382, x368, x365, x384, x366, x363, x386, x364, x361, x12, x349, x390, x351, x375, x392, x353, x377, x394, x355, x379, x396, x356, x381, x398, x357, x383, x400, x359, x385, x402, x360, x332, x316, x290, x335, x387, x413, x415, x412, x410, x417, x411, x408, x405, x389, x420, x391, x414, x422, x393, x416, x424, x395, x418, x426, x397, x419, x409, x399, x401, x430, x403, x406, x446, x448, x445, x443, x450, x444, x441, x452, x442, x439, x454, x440, x437, x456, x438, x435, x458, x436, x433, x13, x421, x462, x423, x447, x464, x425, x449, x466, x427, x451, x468, x428, x453, x470, x429, x455, x472, x431, x457, x474, x432, x404, x388, x362, x407, x459, x485, x487, x484, x482, x489, x483, x480, x477, x461, x492, x463, x486, x494, x465, x488, x496, x467, x490, x498, x469, x491, x481, x471, x473, x502, x475, x478, x517, x519, x516, x514, x521, x515, x512, x523, x513, x510, x525, x511, x508, x527, x509, x506, x493, x532, x495, x518, x534, x497, x520, x536, x499, x522, x538, x500, x524, x540, x501, x526, x542, x503, x528, x553, x555, x552, x550, x557, x551, x548, x531, x560, x533, x554, x562, x535, x556, x564, x537, x558, x566, x539, x559, x549, x541, x543, x570, x547, x544, x504, x476, x460, x434, x479, x545, x529, x507, x530, x505, x14, x546, x574, x576, x578, x583, x561, x586, x573, x587, x563, x589, x575, x590, x565, x592, x577, x593, x567, x595, x579, x596, x568, x598, x580, x599, x569, x601, x581, x602, x571, x604, x582, x605, x585, x572, x607, x584, x608, x588, x591, x594, x597, x600, x603, x606, x609, x610, x611, x612, x613, x614, x615, x616, x617; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x1; + x9 = x2; + x10 = x3; + x11 = x4; + x12 = x5; + x13 = x6; + x14 = x7; + x15 = x0; + x16 = (x15)*((uintptr_t)60375323ULL); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)60375323ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)60375323ULL))>>64); + x18 = (x15)*((uintptr_t)2083559997ULL); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)2083559997ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)2083559997ULL))>>64); + x20 = (x15)*((uintptr_t)3471602642ULL); + x21 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)3471602642ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)3471602642ULL))>>64); + x22 = (x15)*((uintptr_t)401981029ULL); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)401981029ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)401981029ULL))>>64); + x24 = (x15)*((uintptr_t)3490585511ULL); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)3490585511ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)3490585511ULL))>>64); + x26 = (x15)*((uintptr_t)1753584455ULL); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)1753584455ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)1753584455ULL))>>64); + x28 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)2751861219ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)2751861219ULL))>>64); + x29 = (x15)*((uintptr_t)1151078145ULL); + x30 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)1151078145ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)1151078145ULL))>>64); + x31 = (x30)+((x15)*((uintptr_t)2751861219ULL)); + x32 = ((uintptr_t)((x31)<(x30)))+(x28); + x33 = (x32)+(x26); + x34 = (((uintptr_t)((x32)<(x28)))+((uintptr_t)((x33)<(x26))))+(x27); + x35 = (x34)+(x24); + x36 = (((uintptr_t)((x34)<(x27)))+((uintptr_t)((x35)<(x24))))+(x25); + x37 = (x36)+(x22); + x38 = (((uintptr_t)((x36)<(x25)))+((uintptr_t)((x37)<(x22))))+(x23); + x39 = (x38)+(x20); + x40 = (((uintptr_t)((x38)<(x23)))+((uintptr_t)((x39)<(x20))))+(x21); + x41 = (x40)+(x18); + x42 = (((uintptr_t)((x40)<(x21)))+((uintptr_t)((x41)<(x18))))+(x19); + x43 = (x42)+(x16); + x44 = ((uintptr_t)((x42)<(x19)))+((uintptr_t)((x43)<(x16))); + x45 = (x29)*((uintptr_t)307527195ULL); + x46 = (x45)*((uintptr_t)268435456ULL); + x47 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)268435456ULL))>>64); + x48 = (x45)*((uintptr_t)350157278ULL); + x49 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)350157278ULL))>>64); + x50 = (x45)*((uintptr_t)2734136534ULL); + x51 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)2734136534ULL))>>64); + x52 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)1477600026ULL))>>64); + x53 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)1559614445ULL))>>64); + x54 = (x53)+((x45)*((uintptr_t)1477600026ULL)); + x55 = ((uintptr_t)((x54)<(x53)))+(x52); + x56 = (x55)+(x50); + x57 = (((uintptr_t)((x55)<(x52)))+((uintptr_t)((x56)<(x50))))+(x51); + x58 = (x57)+(x48); + x59 = ((uintptr_t)((x57)<(x51)))+((uintptr_t)((x58)<(x48))); + x60 = ((uintptr_t)(((x29)+((x45)*((uintptr_t)1559614445ULL)))<(x29)))+(x31); + x61 = (x60)+(x54); + x62 = (((uintptr_t)((x60)<(x31)))+((uintptr_t)((x61)<(x54))))+(x33); + x63 = (x62)+(x56); + x64 = (((uintptr_t)((x62)<(x33)))+((uintptr_t)((x63)<(x56))))+(x35); + x65 = (x64)+(x58); + x66 = (((uintptr_t)((x64)<(x35)))+((uintptr_t)((x65)<(x58))))+(x37); + x67 = (x66)+((x59)+(x49)); + x68 = (((uintptr_t)((x66)<(x37)))+((uintptr_t)((x67)<((x59)+(x49)))))+(x39); + x69 = ((uintptr_t)((x68)<(x39)))+(x41); + x70 = ((uintptr_t)((x69)<(x41)))+(x43); + x71 = (x70)+(x46); + x72 = ((uintptr_t)((x70)<(x43)))+((uintptr_t)((x71)<(x46))); + x73 = (x8)*((uintptr_t)60375323ULL); + x74 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)60375323ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)60375323ULL))>>64); + x75 = (x8)*((uintptr_t)2083559997ULL); + x76 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)2083559997ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)2083559997ULL))>>64); + x77 = (x8)*((uintptr_t)3471602642ULL); + x78 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)3471602642ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)3471602642ULL))>>64); + x79 = (x8)*((uintptr_t)401981029ULL); + x80 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)401981029ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)401981029ULL))>>64); + x81 = (x8)*((uintptr_t)3490585511ULL); + x82 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)3490585511ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)3490585511ULL))>>64); + x83 = (x8)*((uintptr_t)1753584455ULL); + x84 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)1753584455ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)1753584455ULL))>>64); + x85 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)2751861219ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)2751861219ULL))>>64); + x86 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)1151078145ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)1151078145ULL))>>64); + x87 = (x86)+((x8)*((uintptr_t)2751861219ULL)); + x88 = ((uintptr_t)((x87)<(x86)))+(x85); + x89 = (x88)+(x83); + x90 = (((uintptr_t)((x88)<(x85)))+((uintptr_t)((x89)<(x83))))+(x84); + x91 = (x90)+(x81); + x92 = (((uintptr_t)((x90)<(x84)))+((uintptr_t)((x91)<(x81))))+(x82); + x93 = (x92)+(x79); + x94 = (((uintptr_t)((x92)<(x82)))+((uintptr_t)((x93)<(x79))))+(x80); + x95 = (x94)+(x77); + x96 = (((uintptr_t)((x94)<(x80)))+((uintptr_t)((x95)<(x77))))+(x78); + x97 = (x96)+(x75); + x98 = (((uintptr_t)((x96)<(x78)))+((uintptr_t)((x97)<(x75))))+(x76); + x99 = (x98)+(x73); + x100 = ((uintptr_t)((x98)<(x76)))+((uintptr_t)((x99)<(x73))); + x101 = (x61)+((x8)*((uintptr_t)1151078145ULL)); + x102 = ((uintptr_t)((x101)<(x61)))+(x63); + x103 = (x102)+(x87); + x104 = (((uintptr_t)((x102)<(x63)))+((uintptr_t)((x103)<(x87))))+(x65); + x105 = (x104)+(x89); + x106 = (((uintptr_t)((x104)<(x65)))+((uintptr_t)((x105)<(x89))))+(x67); + x107 = (x106)+(x91); + x108 = (((uintptr_t)((x106)<(x67)))+((uintptr_t)((x107)<(x91))))+(x68); + x109 = (x108)+(x93); + x110 = (((uintptr_t)((x108)<(x68)))+((uintptr_t)((x109)<(x93))))+(x69); + x111 = (x110)+(x95); + x112 = (((uintptr_t)((x110)<(x69)))+((uintptr_t)((x111)<(x95))))+(x71); + x113 = (x112)+(x97); + x114 = (((uintptr_t)((x112)<(x71)))+((uintptr_t)((x113)<(x97))))+(((x72)+((x44)+(x17)))+(x47)); + x115 = (x114)+(x99); + x116 = ((uintptr_t)((x114)<(((x72)+((x44)+(x17)))+(x47))))+((uintptr_t)((x115)<(x99))); + x117 = (x101)*((uintptr_t)307527195ULL); + x118 = (x117)*((uintptr_t)268435456ULL); + x119 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x117)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x117)*((uintptr_t)268435456ULL))>>64); + x120 = (x117)*((uintptr_t)350157278ULL); + x121 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x117)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x117)*((uintptr_t)350157278ULL))>>64); + x122 = (x117)*((uintptr_t)2734136534ULL); + x123 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x117)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x117)*((uintptr_t)2734136534ULL))>>64); + x124 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x117)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x117)*((uintptr_t)1477600026ULL))>>64); + x125 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x117)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x117)*((uintptr_t)1559614445ULL))>>64); + x126 = (x125)+((x117)*((uintptr_t)1477600026ULL)); + x127 = ((uintptr_t)((x126)<(x125)))+(x124); + x128 = (x127)+(x122); + x129 = (((uintptr_t)((x127)<(x124)))+((uintptr_t)((x128)<(x122))))+(x123); + x130 = (x129)+(x120); + x131 = ((uintptr_t)((x129)<(x123)))+((uintptr_t)((x130)<(x120))); + x132 = ((uintptr_t)(((x101)+((x117)*((uintptr_t)1559614445ULL)))<(x101)))+(x103); + x133 = (x132)+(x126); + x134 = (((uintptr_t)((x132)<(x103)))+((uintptr_t)((x133)<(x126))))+(x105); + x135 = (x134)+(x128); + x136 = (((uintptr_t)((x134)<(x105)))+((uintptr_t)((x135)<(x128))))+(x107); + x137 = (x136)+(x130); + x138 = (((uintptr_t)((x136)<(x107)))+((uintptr_t)((x137)<(x130))))+(x109); + x139 = (x138)+((x131)+(x121)); + x140 = (((uintptr_t)((x138)<(x109)))+((uintptr_t)((x139)<((x131)+(x121)))))+(x111); + x141 = ((uintptr_t)((x140)<(x111)))+(x113); + x142 = ((uintptr_t)((x141)<(x113)))+(x115); + x143 = (x142)+(x118); + x144 = ((uintptr_t)((x142)<(x115)))+((uintptr_t)((x143)<(x118))); + x145 = (x9)*((uintptr_t)60375323ULL); + x146 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)60375323ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)60375323ULL))>>64); + x147 = (x9)*((uintptr_t)2083559997ULL); + x148 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)2083559997ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)2083559997ULL))>>64); + x149 = (x9)*((uintptr_t)3471602642ULL); + x150 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)3471602642ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)3471602642ULL))>>64); + x151 = (x9)*((uintptr_t)401981029ULL); + x152 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)401981029ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)401981029ULL))>>64); + x153 = (x9)*((uintptr_t)3490585511ULL); + x154 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)3490585511ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)3490585511ULL))>>64); + x155 = (x9)*((uintptr_t)1753584455ULL); + x156 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)1753584455ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)1753584455ULL))>>64); + x157 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)2751861219ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)2751861219ULL))>>64); + x158 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)1151078145ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)1151078145ULL))>>64); + x159 = (x158)+((x9)*((uintptr_t)2751861219ULL)); + x160 = ((uintptr_t)((x159)<(x158)))+(x157); + x161 = (x160)+(x155); + x162 = (((uintptr_t)((x160)<(x157)))+((uintptr_t)((x161)<(x155))))+(x156); + x163 = (x162)+(x153); + x164 = (((uintptr_t)((x162)<(x156)))+((uintptr_t)((x163)<(x153))))+(x154); + x165 = (x164)+(x151); + x166 = (((uintptr_t)((x164)<(x154)))+((uintptr_t)((x165)<(x151))))+(x152); + x167 = (x166)+(x149); + x168 = (((uintptr_t)((x166)<(x152)))+((uintptr_t)((x167)<(x149))))+(x150); + x169 = (x168)+(x147); + x170 = (((uintptr_t)((x168)<(x150)))+((uintptr_t)((x169)<(x147))))+(x148); + x171 = (x170)+(x145); + x172 = ((uintptr_t)((x170)<(x148)))+((uintptr_t)((x171)<(x145))); + x173 = (x133)+((x9)*((uintptr_t)1151078145ULL)); + x174 = ((uintptr_t)((x173)<(x133)))+(x135); + x175 = (x174)+(x159); + x176 = (((uintptr_t)((x174)<(x135)))+((uintptr_t)((x175)<(x159))))+(x137); + x177 = (x176)+(x161); + x178 = (((uintptr_t)((x176)<(x137)))+((uintptr_t)((x177)<(x161))))+(x139); + x179 = (x178)+(x163); + x180 = (((uintptr_t)((x178)<(x139)))+((uintptr_t)((x179)<(x163))))+(x140); + x181 = (x180)+(x165); + x182 = (((uintptr_t)((x180)<(x140)))+((uintptr_t)((x181)<(x165))))+(x141); + x183 = (x182)+(x167); + x184 = (((uintptr_t)((x182)<(x141)))+((uintptr_t)((x183)<(x167))))+(x143); + x185 = (x184)+(x169); + x186 = (((uintptr_t)((x184)<(x143)))+((uintptr_t)((x185)<(x169))))+(((x144)+((x116)+((x100)+(x74))))+(x119)); + x187 = (x186)+(x171); + x188 = ((uintptr_t)((x186)<(((x144)+((x116)+((x100)+(x74))))+(x119))))+((uintptr_t)((x187)<(x171))); + x189 = (x173)*((uintptr_t)307527195ULL); + x190 = (x189)*((uintptr_t)268435456ULL); + x191 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x189)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x189)*((uintptr_t)268435456ULL))>>64); + x192 = (x189)*((uintptr_t)350157278ULL); + x193 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x189)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x189)*((uintptr_t)350157278ULL))>>64); + x194 = (x189)*((uintptr_t)2734136534ULL); + x195 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x189)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x189)*((uintptr_t)2734136534ULL))>>64); + x196 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x189)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x189)*((uintptr_t)1477600026ULL))>>64); + x197 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x189)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x189)*((uintptr_t)1559614445ULL))>>64); + x198 = (x197)+((x189)*((uintptr_t)1477600026ULL)); + x199 = ((uintptr_t)((x198)<(x197)))+(x196); + x200 = (x199)+(x194); + x201 = (((uintptr_t)((x199)<(x196)))+((uintptr_t)((x200)<(x194))))+(x195); + x202 = (x201)+(x192); + x203 = ((uintptr_t)((x201)<(x195)))+((uintptr_t)((x202)<(x192))); + x204 = ((uintptr_t)(((x173)+((x189)*((uintptr_t)1559614445ULL)))<(x173)))+(x175); + x205 = (x204)+(x198); + x206 = (((uintptr_t)((x204)<(x175)))+((uintptr_t)((x205)<(x198))))+(x177); + x207 = (x206)+(x200); + x208 = (((uintptr_t)((x206)<(x177)))+((uintptr_t)((x207)<(x200))))+(x179); + x209 = (x208)+(x202); + x210 = (((uintptr_t)((x208)<(x179)))+((uintptr_t)((x209)<(x202))))+(x181); + x211 = (x210)+((x203)+(x193)); + x212 = (((uintptr_t)((x210)<(x181)))+((uintptr_t)((x211)<((x203)+(x193)))))+(x183); + x213 = ((uintptr_t)((x212)<(x183)))+(x185); + x214 = ((uintptr_t)((x213)<(x185)))+(x187); + x215 = (x214)+(x190); + x216 = ((uintptr_t)((x214)<(x187)))+((uintptr_t)((x215)<(x190))); + x217 = (x10)*((uintptr_t)60375323ULL); + x218 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)60375323ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)60375323ULL))>>64); + x219 = (x10)*((uintptr_t)2083559997ULL); + x220 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)2083559997ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)2083559997ULL))>>64); + x221 = (x10)*((uintptr_t)3471602642ULL); + x222 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)3471602642ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)3471602642ULL))>>64); + x223 = (x10)*((uintptr_t)401981029ULL); + x224 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)401981029ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)401981029ULL))>>64); + x225 = (x10)*((uintptr_t)3490585511ULL); + x226 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)3490585511ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)3490585511ULL))>>64); + x227 = (x10)*((uintptr_t)1753584455ULL); + x228 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)1753584455ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)1753584455ULL))>>64); + x229 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)2751861219ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)2751861219ULL))>>64); + x230 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)1151078145ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)1151078145ULL))>>64); + x231 = (x230)+((x10)*((uintptr_t)2751861219ULL)); + x232 = ((uintptr_t)((x231)<(x230)))+(x229); + x233 = (x232)+(x227); + x234 = (((uintptr_t)((x232)<(x229)))+((uintptr_t)((x233)<(x227))))+(x228); + x235 = (x234)+(x225); + x236 = (((uintptr_t)((x234)<(x228)))+((uintptr_t)((x235)<(x225))))+(x226); + x237 = (x236)+(x223); + x238 = (((uintptr_t)((x236)<(x226)))+((uintptr_t)((x237)<(x223))))+(x224); + x239 = (x238)+(x221); + x240 = (((uintptr_t)((x238)<(x224)))+((uintptr_t)((x239)<(x221))))+(x222); + x241 = (x240)+(x219); + x242 = (((uintptr_t)((x240)<(x222)))+((uintptr_t)((x241)<(x219))))+(x220); + x243 = (x242)+(x217); + x244 = ((uintptr_t)((x242)<(x220)))+((uintptr_t)((x243)<(x217))); + x245 = (x205)+((x10)*((uintptr_t)1151078145ULL)); + x246 = ((uintptr_t)((x245)<(x205)))+(x207); + x247 = (x246)+(x231); + x248 = (((uintptr_t)((x246)<(x207)))+((uintptr_t)((x247)<(x231))))+(x209); + x249 = (x248)+(x233); + x250 = (((uintptr_t)((x248)<(x209)))+((uintptr_t)((x249)<(x233))))+(x211); + x251 = (x250)+(x235); + x252 = (((uintptr_t)((x250)<(x211)))+((uintptr_t)((x251)<(x235))))+(x212); + x253 = (x252)+(x237); + x254 = (((uintptr_t)((x252)<(x212)))+((uintptr_t)((x253)<(x237))))+(x213); + x255 = (x254)+(x239); + x256 = (((uintptr_t)((x254)<(x213)))+((uintptr_t)((x255)<(x239))))+(x215); + x257 = (x256)+(x241); + x258 = (((uintptr_t)((x256)<(x215)))+((uintptr_t)((x257)<(x241))))+(((x216)+((x188)+((x172)+(x146))))+(x191)); + x259 = (x258)+(x243); + x260 = ((uintptr_t)((x258)<(((x216)+((x188)+((x172)+(x146))))+(x191))))+((uintptr_t)((x259)<(x243))); + x261 = (x245)*((uintptr_t)307527195ULL); + x262 = (x261)*((uintptr_t)268435456ULL); + x263 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x261)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x261)*((uintptr_t)268435456ULL))>>64); + x264 = (x261)*((uintptr_t)350157278ULL); + x265 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x261)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x261)*((uintptr_t)350157278ULL))>>64); + x266 = (x261)*((uintptr_t)2734136534ULL); + x267 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x261)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x261)*((uintptr_t)2734136534ULL))>>64); + x268 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x261)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x261)*((uintptr_t)1477600026ULL))>>64); + x269 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x261)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x261)*((uintptr_t)1559614445ULL))>>64); + x270 = (x269)+((x261)*((uintptr_t)1477600026ULL)); + x271 = ((uintptr_t)((x270)<(x269)))+(x268); + x272 = (x271)+(x266); + x273 = (((uintptr_t)((x271)<(x268)))+((uintptr_t)((x272)<(x266))))+(x267); + x274 = (x273)+(x264); + x275 = ((uintptr_t)((x273)<(x267)))+((uintptr_t)((x274)<(x264))); + x276 = ((uintptr_t)(((x245)+((x261)*((uintptr_t)1559614445ULL)))<(x245)))+(x247); + x277 = (x276)+(x270); + x278 = (((uintptr_t)((x276)<(x247)))+((uintptr_t)((x277)<(x270))))+(x249); + x279 = (x278)+(x272); + x280 = (((uintptr_t)((x278)<(x249)))+((uintptr_t)((x279)<(x272))))+(x251); + x281 = (x280)+(x274); + x282 = (((uintptr_t)((x280)<(x251)))+((uintptr_t)((x281)<(x274))))+(x253); + x283 = (x282)+((x275)+(x265)); + x284 = (((uintptr_t)((x282)<(x253)))+((uintptr_t)((x283)<((x275)+(x265)))))+(x255); + x285 = ((uintptr_t)((x284)<(x255)))+(x257); + x286 = ((uintptr_t)((x285)<(x257)))+(x259); + x287 = (x286)+(x262); + x288 = ((uintptr_t)((x286)<(x259)))+((uintptr_t)((x287)<(x262))); + x289 = (x11)*((uintptr_t)60375323ULL); + x290 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)60375323ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)60375323ULL))>>64); + x291 = (x11)*((uintptr_t)2083559997ULL); + x292 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)2083559997ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)2083559997ULL))>>64); + x293 = (x11)*((uintptr_t)3471602642ULL); + x294 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)3471602642ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)3471602642ULL))>>64); + x295 = (x11)*((uintptr_t)401981029ULL); + x296 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)401981029ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)401981029ULL))>>64); + x297 = (x11)*((uintptr_t)3490585511ULL); + x298 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)3490585511ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)3490585511ULL))>>64); + x299 = (x11)*((uintptr_t)1753584455ULL); + x300 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)1753584455ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)1753584455ULL))>>64); + x301 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)2751861219ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)2751861219ULL))>>64); + x302 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)1151078145ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)1151078145ULL))>>64); + x303 = (x302)+((x11)*((uintptr_t)2751861219ULL)); + x304 = ((uintptr_t)((x303)<(x302)))+(x301); + x305 = (x304)+(x299); + x306 = (((uintptr_t)((x304)<(x301)))+((uintptr_t)((x305)<(x299))))+(x300); + x307 = (x306)+(x297); + x308 = (((uintptr_t)((x306)<(x300)))+((uintptr_t)((x307)<(x297))))+(x298); + x309 = (x308)+(x295); + x310 = (((uintptr_t)((x308)<(x298)))+((uintptr_t)((x309)<(x295))))+(x296); + x311 = (x310)+(x293); + x312 = (((uintptr_t)((x310)<(x296)))+((uintptr_t)((x311)<(x293))))+(x294); + x313 = (x312)+(x291); + x314 = (((uintptr_t)((x312)<(x294)))+((uintptr_t)((x313)<(x291))))+(x292); + x315 = (x314)+(x289); + x316 = ((uintptr_t)((x314)<(x292)))+((uintptr_t)((x315)<(x289))); + x317 = (x277)+((x11)*((uintptr_t)1151078145ULL)); + x318 = ((uintptr_t)((x317)<(x277)))+(x279); + x319 = (x318)+(x303); + x320 = (((uintptr_t)((x318)<(x279)))+((uintptr_t)((x319)<(x303))))+(x281); + x321 = (x320)+(x305); + x322 = (((uintptr_t)((x320)<(x281)))+((uintptr_t)((x321)<(x305))))+(x283); + x323 = (x322)+(x307); + x324 = (((uintptr_t)((x322)<(x283)))+((uintptr_t)((x323)<(x307))))+(x284); + x325 = (x324)+(x309); + x326 = (((uintptr_t)((x324)<(x284)))+((uintptr_t)((x325)<(x309))))+(x285); + x327 = (x326)+(x311); + x328 = (((uintptr_t)((x326)<(x285)))+((uintptr_t)((x327)<(x311))))+(x287); + x329 = (x328)+(x313); + x330 = (((uintptr_t)((x328)<(x287)))+((uintptr_t)((x329)<(x313))))+(((x288)+((x260)+((x244)+(x218))))+(x263)); + x331 = (x330)+(x315); + x332 = ((uintptr_t)((x330)<(((x288)+((x260)+((x244)+(x218))))+(x263))))+((uintptr_t)((x331)<(x315))); + x333 = (x317)*((uintptr_t)307527195ULL); + x334 = (x333)*((uintptr_t)268435456ULL); + x335 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)268435456ULL))>>64); + x336 = (x333)*((uintptr_t)350157278ULL); + x337 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)350157278ULL))>>64); + x338 = (x333)*((uintptr_t)2734136534ULL); + x339 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)2734136534ULL))>>64); + x340 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)1477600026ULL))>>64); + x341 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)1559614445ULL))>>64); + x342 = (x341)+((x333)*((uintptr_t)1477600026ULL)); + x343 = ((uintptr_t)((x342)<(x341)))+(x340); + x344 = (x343)+(x338); + x345 = (((uintptr_t)((x343)<(x340)))+((uintptr_t)((x344)<(x338))))+(x339); + x346 = (x345)+(x336); + x347 = ((uintptr_t)((x345)<(x339)))+((uintptr_t)((x346)<(x336))); + x348 = ((uintptr_t)(((x317)+((x333)*((uintptr_t)1559614445ULL)))<(x317)))+(x319); + x349 = (x348)+(x342); + x350 = (((uintptr_t)((x348)<(x319)))+((uintptr_t)((x349)<(x342))))+(x321); + x351 = (x350)+(x344); + x352 = (((uintptr_t)((x350)<(x321)))+((uintptr_t)((x351)<(x344))))+(x323); + x353 = (x352)+(x346); + x354 = (((uintptr_t)((x352)<(x323)))+((uintptr_t)((x353)<(x346))))+(x325); + x355 = (x354)+((x347)+(x337)); + x356 = (((uintptr_t)((x354)<(x325)))+((uintptr_t)((x355)<((x347)+(x337)))))+(x327); + x357 = ((uintptr_t)((x356)<(x327)))+(x329); + x358 = ((uintptr_t)((x357)<(x329)))+(x331); + x359 = (x358)+(x334); + x360 = ((uintptr_t)((x358)<(x331)))+((uintptr_t)((x359)<(x334))); + x361 = (x12)*((uintptr_t)60375323ULL); + x362 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)60375323ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)60375323ULL))>>64); + x363 = (x12)*((uintptr_t)2083559997ULL); + x364 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)2083559997ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)2083559997ULL))>>64); + x365 = (x12)*((uintptr_t)3471602642ULL); + x366 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)3471602642ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)3471602642ULL))>>64); + x367 = (x12)*((uintptr_t)401981029ULL); + x368 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)401981029ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)401981029ULL))>>64); + x369 = (x12)*((uintptr_t)3490585511ULL); + x370 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)3490585511ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)3490585511ULL))>>64); + x371 = (x12)*((uintptr_t)1753584455ULL); + x372 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)1753584455ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)1753584455ULL))>>64); + x373 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)2751861219ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)2751861219ULL))>>64); + x374 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)1151078145ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)1151078145ULL))>>64); + x375 = (x374)+((x12)*((uintptr_t)2751861219ULL)); + x376 = ((uintptr_t)((x375)<(x374)))+(x373); + x377 = (x376)+(x371); + x378 = (((uintptr_t)((x376)<(x373)))+((uintptr_t)((x377)<(x371))))+(x372); + x379 = (x378)+(x369); + x380 = (((uintptr_t)((x378)<(x372)))+((uintptr_t)((x379)<(x369))))+(x370); + x381 = (x380)+(x367); + x382 = (((uintptr_t)((x380)<(x370)))+((uintptr_t)((x381)<(x367))))+(x368); + x383 = (x382)+(x365); + x384 = (((uintptr_t)((x382)<(x368)))+((uintptr_t)((x383)<(x365))))+(x366); + x385 = (x384)+(x363); + x386 = (((uintptr_t)((x384)<(x366)))+((uintptr_t)((x385)<(x363))))+(x364); + x387 = (x386)+(x361); + x388 = ((uintptr_t)((x386)<(x364)))+((uintptr_t)((x387)<(x361))); + x389 = (x349)+((x12)*((uintptr_t)1151078145ULL)); + x390 = ((uintptr_t)((x389)<(x349)))+(x351); + x391 = (x390)+(x375); + x392 = (((uintptr_t)((x390)<(x351)))+((uintptr_t)((x391)<(x375))))+(x353); + x393 = (x392)+(x377); + x394 = (((uintptr_t)((x392)<(x353)))+((uintptr_t)((x393)<(x377))))+(x355); + x395 = (x394)+(x379); + x396 = (((uintptr_t)((x394)<(x355)))+((uintptr_t)((x395)<(x379))))+(x356); + x397 = (x396)+(x381); + x398 = (((uintptr_t)((x396)<(x356)))+((uintptr_t)((x397)<(x381))))+(x357); + x399 = (x398)+(x383); + x400 = (((uintptr_t)((x398)<(x357)))+((uintptr_t)((x399)<(x383))))+(x359); + x401 = (x400)+(x385); + x402 = (((uintptr_t)((x400)<(x359)))+((uintptr_t)((x401)<(x385))))+(((x360)+((x332)+((x316)+(x290))))+(x335)); + x403 = (x402)+(x387); + x404 = ((uintptr_t)((x402)<(((x360)+((x332)+((x316)+(x290))))+(x335))))+((uintptr_t)((x403)<(x387))); + x405 = (x389)*((uintptr_t)307527195ULL); + x406 = (x405)*((uintptr_t)268435456ULL); + x407 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)268435456ULL))>>64); + x408 = (x405)*((uintptr_t)350157278ULL); + x409 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)350157278ULL))>>64); + x410 = (x405)*((uintptr_t)2734136534ULL); + x411 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)2734136534ULL))>>64); + x412 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)1477600026ULL))>>64); + x413 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)1559614445ULL))>>64); + x414 = (x413)+((x405)*((uintptr_t)1477600026ULL)); + x415 = ((uintptr_t)((x414)<(x413)))+(x412); + x416 = (x415)+(x410); + x417 = (((uintptr_t)((x415)<(x412)))+((uintptr_t)((x416)<(x410))))+(x411); + x418 = (x417)+(x408); + x419 = ((uintptr_t)((x417)<(x411)))+((uintptr_t)((x418)<(x408))); + x420 = ((uintptr_t)(((x389)+((x405)*((uintptr_t)1559614445ULL)))<(x389)))+(x391); + x421 = (x420)+(x414); + x422 = (((uintptr_t)((x420)<(x391)))+((uintptr_t)((x421)<(x414))))+(x393); + x423 = (x422)+(x416); + x424 = (((uintptr_t)((x422)<(x393)))+((uintptr_t)((x423)<(x416))))+(x395); + x425 = (x424)+(x418); + x426 = (((uintptr_t)((x424)<(x395)))+((uintptr_t)((x425)<(x418))))+(x397); + x427 = (x426)+((x419)+(x409)); + x428 = (((uintptr_t)((x426)<(x397)))+((uintptr_t)((x427)<((x419)+(x409)))))+(x399); + x429 = ((uintptr_t)((x428)<(x399)))+(x401); + x430 = ((uintptr_t)((x429)<(x401)))+(x403); + x431 = (x430)+(x406); + x432 = ((uintptr_t)((x430)<(x403)))+((uintptr_t)((x431)<(x406))); + x433 = (x13)*((uintptr_t)60375323ULL); + x434 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)60375323ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)60375323ULL))>>64); + x435 = (x13)*((uintptr_t)2083559997ULL); + x436 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)2083559997ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)2083559997ULL))>>64); + x437 = (x13)*((uintptr_t)3471602642ULL); + x438 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)3471602642ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)3471602642ULL))>>64); + x439 = (x13)*((uintptr_t)401981029ULL); + x440 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)401981029ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)401981029ULL))>>64); + x441 = (x13)*((uintptr_t)3490585511ULL); + x442 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)3490585511ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)3490585511ULL))>>64); + x443 = (x13)*((uintptr_t)1753584455ULL); + x444 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)1753584455ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)1753584455ULL))>>64); + x445 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)2751861219ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)2751861219ULL))>>64); + x446 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)1151078145ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)1151078145ULL))>>64); + x447 = (x446)+((x13)*((uintptr_t)2751861219ULL)); + x448 = ((uintptr_t)((x447)<(x446)))+(x445); + x449 = (x448)+(x443); + x450 = (((uintptr_t)((x448)<(x445)))+((uintptr_t)((x449)<(x443))))+(x444); + x451 = (x450)+(x441); + x452 = (((uintptr_t)((x450)<(x444)))+((uintptr_t)((x451)<(x441))))+(x442); + x453 = (x452)+(x439); + x454 = (((uintptr_t)((x452)<(x442)))+((uintptr_t)((x453)<(x439))))+(x440); + x455 = (x454)+(x437); + x456 = (((uintptr_t)((x454)<(x440)))+((uintptr_t)((x455)<(x437))))+(x438); + x457 = (x456)+(x435); + x458 = (((uintptr_t)((x456)<(x438)))+((uintptr_t)((x457)<(x435))))+(x436); + x459 = (x458)+(x433); + x460 = ((uintptr_t)((x458)<(x436)))+((uintptr_t)((x459)<(x433))); + x461 = (x421)+((x13)*((uintptr_t)1151078145ULL)); + x462 = ((uintptr_t)((x461)<(x421)))+(x423); + x463 = (x462)+(x447); + x464 = (((uintptr_t)((x462)<(x423)))+((uintptr_t)((x463)<(x447))))+(x425); + x465 = (x464)+(x449); + x466 = (((uintptr_t)((x464)<(x425)))+((uintptr_t)((x465)<(x449))))+(x427); + x467 = (x466)+(x451); + x468 = (((uintptr_t)((x466)<(x427)))+((uintptr_t)((x467)<(x451))))+(x428); + x469 = (x468)+(x453); + x470 = (((uintptr_t)((x468)<(x428)))+((uintptr_t)((x469)<(x453))))+(x429); + x471 = (x470)+(x455); + x472 = (((uintptr_t)((x470)<(x429)))+((uintptr_t)((x471)<(x455))))+(x431); + x473 = (x472)+(x457); + x474 = (((uintptr_t)((x472)<(x431)))+((uintptr_t)((x473)<(x457))))+(((x432)+((x404)+((x388)+(x362))))+(x407)); + x475 = (x474)+(x459); + x476 = ((uintptr_t)((x474)<(((x432)+((x404)+((x388)+(x362))))+(x407))))+((uintptr_t)((x475)<(x459))); + x477 = (x461)*((uintptr_t)307527195ULL); + x478 = (x477)*((uintptr_t)268435456ULL); + x479 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x477)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x477)*((uintptr_t)268435456ULL))>>64); + x480 = (x477)*((uintptr_t)350157278ULL); + x481 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x477)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x477)*((uintptr_t)350157278ULL))>>64); + x482 = (x477)*((uintptr_t)2734136534ULL); + x483 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x477)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x477)*((uintptr_t)2734136534ULL))>>64); + x484 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x477)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x477)*((uintptr_t)1477600026ULL))>>64); + x485 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x477)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x477)*((uintptr_t)1559614445ULL))>>64); + x486 = (x485)+((x477)*((uintptr_t)1477600026ULL)); + x487 = ((uintptr_t)((x486)<(x485)))+(x484); + x488 = (x487)+(x482); + x489 = (((uintptr_t)((x487)<(x484)))+((uintptr_t)((x488)<(x482))))+(x483); + x490 = (x489)+(x480); + x491 = ((uintptr_t)((x489)<(x483)))+((uintptr_t)((x490)<(x480))); + x492 = ((uintptr_t)(((x461)+((x477)*((uintptr_t)1559614445ULL)))<(x461)))+(x463); + x493 = (x492)+(x486); + x494 = (((uintptr_t)((x492)<(x463)))+((uintptr_t)((x493)<(x486))))+(x465); + x495 = (x494)+(x488); + x496 = (((uintptr_t)((x494)<(x465)))+((uintptr_t)((x495)<(x488))))+(x467); + x497 = (x496)+(x490); + x498 = (((uintptr_t)((x496)<(x467)))+((uintptr_t)((x497)<(x490))))+(x469); + x499 = (x498)+((x491)+(x481)); + x500 = (((uintptr_t)((x498)<(x469)))+((uintptr_t)((x499)<((x491)+(x481)))))+(x471); + x501 = ((uintptr_t)((x500)<(x471)))+(x473); + x502 = ((uintptr_t)((x501)<(x473)))+(x475); + x503 = (x502)+(x478); + x504 = ((uintptr_t)((x502)<(x475)))+((uintptr_t)((x503)<(x478))); + x505 = (x14)*((uintptr_t)60375323ULL); + x506 = (x14)*((uintptr_t)2083559997ULL); + x507 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)2083559997ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)2083559997ULL))>>64); + x508 = (x14)*((uintptr_t)3471602642ULL); + x509 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)3471602642ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)3471602642ULL))>>64); + x510 = (x14)*((uintptr_t)401981029ULL); + x511 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)401981029ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)401981029ULL))>>64); + x512 = (x14)*((uintptr_t)3490585511ULL); + x513 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)3490585511ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)3490585511ULL))>>64); + x514 = (x14)*((uintptr_t)1753584455ULL); + x515 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)1753584455ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)1753584455ULL))>>64); + x516 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)2751861219ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)2751861219ULL))>>64); + x517 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)1151078145ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)1151078145ULL))>>64); + x518 = (x517)+((x14)*((uintptr_t)2751861219ULL)); + x519 = ((uintptr_t)((x518)<(x517)))+(x516); + x520 = (x519)+(x514); + x521 = (((uintptr_t)((x519)<(x516)))+((uintptr_t)((x520)<(x514))))+(x515); + x522 = (x521)+(x512); + x523 = (((uintptr_t)((x521)<(x515)))+((uintptr_t)((x522)<(x512))))+(x513); + x524 = (x523)+(x510); + x525 = (((uintptr_t)((x523)<(x513)))+((uintptr_t)((x524)<(x510))))+(x511); + x526 = (x525)+(x508); + x527 = (((uintptr_t)((x525)<(x511)))+((uintptr_t)((x526)<(x508))))+(x509); + x528 = (x527)+(x506); + x529 = (((uintptr_t)((x527)<(x509)))+((uintptr_t)((x528)<(x506))))+(x507); + x530 = (x529)+(x505); + x531 = (x493)+((x14)*((uintptr_t)1151078145ULL)); + x532 = ((uintptr_t)((x531)<(x493)))+(x495); + x533 = (x532)+(x518); + x534 = (((uintptr_t)((x532)<(x495)))+((uintptr_t)((x533)<(x518))))+(x497); + x535 = (x534)+(x520); + x536 = (((uintptr_t)((x534)<(x497)))+((uintptr_t)((x535)<(x520))))+(x499); + x537 = (x536)+(x522); + x538 = (((uintptr_t)((x536)<(x499)))+((uintptr_t)((x537)<(x522))))+(x500); + x539 = (x538)+(x524); + x540 = (((uintptr_t)((x538)<(x500)))+((uintptr_t)((x539)<(x524))))+(x501); + x541 = (x540)+(x526); + x542 = (((uintptr_t)((x540)<(x501)))+((uintptr_t)((x541)<(x526))))+(x503); + x543 = (x542)+(x528); + x544 = (((uintptr_t)((x542)<(x503)))+((uintptr_t)((x543)<(x528))))+(((x504)+((x476)+((x460)+(x434))))+(x479)); + x545 = (x544)+(x530); + x546 = (x531)*((uintptr_t)307527195ULL); + x547 = (x546)*((uintptr_t)268435456ULL); + x548 = (x546)*((uintptr_t)350157278ULL); + x549 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x546)*((uintptr_t)350157278ULL))>>32 : ((__uint128_t)(x546)*((uintptr_t)350157278ULL))>>64); + x550 = (x546)*((uintptr_t)2734136534ULL); + x551 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x546)*((uintptr_t)2734136534ULL))>>32 : ((__uint128_t)(x546)*((uintptr_t)2734136534ULL))>>64); + x552 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x546)*((uintptr_t)1477600026ULL))>>32 : ((__uint128_t)(x546)*((uintptr_t)1477600026ULL))>>64); + x553 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x546)*((uintptr_t)1559614445ULL))>>32 : ((__uint128_t)(x546)*((uintptr_t)1559614445ULL))>>64); + x554 = (x553)+((x546)*((uintptr_t)1477600026ULL)); + x555 = ((uintptr_t)((x554)<(x553)))+(x552); + x556 = (x555)+(x550); + x557 = (((uintptr_t)((x555)<(x552)))+((uintptr_t)((x556)<(x550))))+(x551); + x558 = (x557)+(x548); + x559 = ((uintptr_t)((x557)<(x551)))+((uintptr_t)((x558)<(x548))); + x560 = ((uintptr_t)(((x531)+((x546)*((uintptr_t)1559614445ULL)))<(x531)))+(x533); + x561 = (x560)+(x554); + x562 = (((uintptr_t)((x560)<(x533)))+((uintptr_t)((x561)<(x554))))+(x535); + x563 = (x562)+(x556); + x564 = (((uintptr_t)((x562)<(x535)))+((uintptr_t)((x563)<(x556))))+(x537); + x565 = (x564)+(x558); + x566 = (((uintptr_t)((x564)<(x537)))+((uintptr_t)((x565)<(x558))))+(x539); + x567 = (x566)+((x559)+(x549)); + x568 = (((uintptr_t)((x566)<(x539)))+((uintptr_t)((x567)<((x559)+(x549)))))+(x541); + x569 = ((uintptr_t)((x568)<(x541)))+(x543); + x570 = ((uintptr_t)((x569)<(x543)))+(x545); + x571 = (x570)+(x547); + x572 = ((((uintptr_t)((x570)<(x545)))+((uintptr_t)((x571)<(x547))))+((((uintptr_t)((x544)<(((x504)+((x476)+((x460)+(x434))))+(x479))))+((uintptr_t)((x545)<(x530))))+((((uintptr_t)((x529)<(x507)))+((uintptr_t)((x530)<(x505))))+((uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)60375323ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)60375323ULL))>>64)))))+((uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x546)*((uintptr_t)268435456ULL))>>32 : ((__uint128_t)(x546)*((uintptr_t)268435456ULL))>>64)); + x573 = (x561)-((uintptr_t)1559614445ULL); + x574 = (x563)-((uintptr_t)1477600026ULL); + x575 = (x574)-((uintptr_t)((x561)<(x573))); + x576 = (x565)-((uintptr_t)2734136534ULL); + x577 = (x576)-(((uintptr_t)((x563)<(x574)))+((uintptr_t)((x574)<(x575)))); + x578 = (x567)-((uintptr_t)350157278ULL); + x579 = (x578)-(((uintptr_t)((x565)<(x576)))+((uintptr_t)((x576)<(x577)))); + x580 = (x568)-(((uintptr_t)((x567)<(x578)))+((uintptr_t)((x578)<(x579)))); + x581 = (x569)-((uintptr_t)((x568)<(x580))); + x582 = (x571)-((uintptr_t)((x569)<(x581))); + x583 = (x572)-((uintptr_t)268435456ULL); + x584 = (x583)-((uintptr_t)((x571)<(x582))); + x585 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(((uintptr_t)((x572)<(x583)))+((uintptr_t)((x583)<(x584)))))); + x586 = ((uintptr_t)-1ULL)+((uintptr_t)((x585)==((uintptr_t)0ULL))); + x587 = (x586)^((uintptr_t)4294967295ULL); + x588 = ((x561)&(x586))|((x573)&(x587)); + x589 = ((uintptr_t)-1ULL)+((uintptr_t)((x585)==((uintptr_t)0ULL))); + x590 = (x589)^((uintptr_t)4294967295ULL); + x591 = ((x563)&(x589))|((x575)&(x590)); + x592 = ((uintptr_t)-1ULL)+((uintptr_t)((x585)==((uintptr_t)0ULL))); + x593 = (x592)^((uintptr_t)4294967295ULL); + x594 = ((x565)&(x592))|((x577)&(x593)); + x595 = ((uintptr_t)-1ULL)+((uintptr_t)((x585)==((uintptr_t)0ULL))); + x596 = (x595)^((uintptr_t)4294967295ULL); + x597 = ((x567)&(x595))|((x579)&(x596)); + x598 = ((uintptr_t)-1ULL)+((uintptr_t)((x585)==((uintptr_t)0ULL))); + x599 = (x598)^((uintptr_t)4294967295ULL); + x600 = ((x568)&(x598))|((x580)&(x599)); + x601 = ((uintptr_t)-1ULL)+((uintptr_t)((x585)==((uintptr_t)0ULL))); + x602 = (x601)^((uintptr_t)4294967295ULL); + x603 = ((x569)&(x601))|((x581)&(x602)); + x604 = ((uintptr_t)-1ULL)+((uintptr_t)((x585)==((uintptr_t)0ULL))); + x605 = (x604)^((uintptr_t)4294967295ULL); + x606 = ((x571)&(x604))|((x582)&(x605)); + x607 = ((uintptr_t)-1ULL)+((uintptr_t)((x585)==((uintptr_t)0ULL))); + x608 = (x607)^((uintptr_t)4294967295ULL); + x609 = ((x572)&(x607))|((x584)&(x608)); + x610 = x588; + x611 = x591; + x612 = x594; + x613 = x597; + x614 = x600; + x615 = x603; + x616 = x606; + x617 = x609; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x610, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x611, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x612, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x613, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x614, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x615, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x616, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x617, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_to_montgomery(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_25519_scalar_to_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffff] + */ +static +uintptr_t internal_fiat_25519_scalar_nonzero(uintptr_t in0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8, out0, x9; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = (x0)|((x1)|((x2)|((x3)|((x4)|((x5)|((x6)|(x7))))))); + x9 = x8; + out0 = x9; + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_nonzero(uint32_t* out1, const uint32_t arg1[8]) { + *out1 = (uint32_t)internal_fiat_25519_scalar_nonzero((uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0x1] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_25519_scalar_selectznz(uintptr_t out0, uintptr_t in0, uintptr_t in1, uintptr_t in2) { + uintptr_t x8, x16, x0, x17, x9, x19, x1, x20, x10, x22, x2, x23, x11, x25, x3, x26, x12, x28, x4, x29, x13, x31, x5, x32, x14, x34, x6, x35, x15, x37, x7, x38, x18, x21, x24, x27, x30, x33, x36, x39, x40, x41, x42, x43, x44, x45, x46, x47; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x9 = _br2_load((in2)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x10 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x11 = _br2_load((in2)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x12 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in2)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x14 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x15 = _br2_load((in2)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x17 = (x16)^((uintptr_t)4294967295ULL); + x18 = ((x8)&(x16))|((x0)&(x17)); + x19 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x20 = (x19)^((uintptr_t)4294967295ULL); + x21 = ((x9)&(x19))|((x1)&(x20)); + x22 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x23 = (x22)^((uintptr_t)4294967295ULL); + x24 = ((x10)&(x22))|((x2)&(x23)); + x25 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x26 = (x25)^((uintptr_t)4294967295ULL); + x27 = ((x11)&(x25))|((x3)&(x26)); + x28 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x29 = (x28)^((uintptr_t)4294967295ULL); + x30 = ((x12)&(x28))|((x4)&(x29)); + x31 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x32 = (x31)^((uintptr_t)4294967295ULL); + x33 = ((x13)&(x31))|((x5)&(x32)); + x34 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x35 = (x34)^((uintptr_t)4294967295ULL); + x36 = ((x14)&(x34))|((x6)&(x35)); + x37 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x38 = (x37)^((uintptr_t)4294967295ULL); + x39 = ((x15)&(x37))|((x7)&(x38)); + x40 = x18; + x41 = x21; + x42 = x24; + x43 = x27; + x44 = x30; + x45 = x33; + x46 = x36; + x47 = x39; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x40, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x41, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x42, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x43, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x44, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x45, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x46, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x47, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_selectznz(uint32_t out1[8], uint8_t arg1, const uint32_t arg2[8], const uint32_t arg3[8]) { + internal_fiat_25519_scalar_selectznz((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0x1fffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] + */ +static +void internal_fiat_25519_scalar_to_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x7, x6, x5, x4, x3, x2, x1, x0, x15, x17, x19, x14, x23, x25, x13, x29, x31, x12, x35, x37, x11, x41, x43, x10, x47, x49, x9, x53, x55, x8, x59, x61, x16, x18, x20, x21, x22, x24, x26, x27, x28, x30, x32, x33, x34, x36, x38, x39, x40, x42, x44, x45, x46, x48, x50, x51, x52, x54, x56, x57, x58, x60, x62, x63, x64, x65, x66, x67, x68, x69, x70, x71, x72, x73, x74, x75, x76, x77, x78, x79, x80, x81, x82, x83, x84, x85, x86, x87, x88, x89, x90, x91, x92, x93, x94, x95; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x7; + x9 = x6; + x10 = x5; + x11 = x4; + x12 = x3; + x13 = x2; + x14 = x1; + x15 = x0; + x16 = (x15)&((uintptr_t)255ULL); + x17 = (x15)>>((uintptr_t)8ULL); + x18 = (x17)&((uintptr_t)255ULL); + x19 = (x17)>>((uintptr_t)8ULL); + x20 = (x19)&((uintptr_t)255ULL); + x21 = (x19)>>((uintptr_t)8ULL); + x22 = (x14)&((uintptr_t)255ULL); + x23 = (x14)>>((uintptr_t)8ULL); + x24 = (x23)&((uintptr_t)255ULL); + x25 = (x23)>>((uintptr_t)8ULL); + x26 = (x25)&((uintptr_t)255ULL); + x27 = (x25)>>((uintptr_t)8ULL); + x28 = (x13)&((uintptr_t)255ULL); + x29 = (x13)>>((uintptr_t)8ULL); + x30 = (x29)&((uintptr_t)255ULL); + x31 = (x29)>>((uintptr_t)8ULL); + x32 = (x31)&((uintptr_t)255ULL); + x33 = (x31)>>((uintptr_t)8ULL); + x34 = (x12)&((uintptr_t)255ULL); + x35 = (x12)>>((uintptr_t)8ULL); + x36 = (x35)&((uintptr_t)255ULL); + x37 = (x35)>>((uintptr_t)8ULL); + x38 = (x37)&((uintptr_t)255ULL); + x39 = (x37)>>((uintptr_t)8ULL); + x40 = (x11)&((uintptr_t)255ULL); + x41 = (x11)>>((uintptr_t)8ULL); + x42 = (x41)&((uintptr_t)255ULL); + x43 = (x41)>>((uintptr_t)8ULL); + x44 = (x43)&((uintptr_t)255ULL); + x45 = (x43)>>((uintptr_t)8ULL); + x46 = (x10)&((uintptr_t)255ULL); + x47 = (x10)>>((uintptr_t)8ULL); + x48 = (x47)&((uintptr_t)255ULL); + x49 = (x47)>>((uintptr_t)8ULL); + x50 = (x49)&((uintptr_t)255ULL); + x51 = (x49)>>((uintptr_t)8ULL); + x52 = (x9)&((uintptr_t)255ULL); + x53 = (x9)>>((uintptr_t)8ULL); + x54 = (x53)&((uintptr_t)255ULL); + x55 = (x53)>>((uintptr_t)8ULL); + x56 = (x55)&((uintptr_t)255ULL); + x57 = (x55)>>((uintptr_t)8ULL); + x58 = (x8)&((uintptr_t)255ULL); + x59 = (x8)>>((uintptr_t)8ULL); + x60 = (x59)&((uintptr_t)255ULL); + x61 = (x59)>>((uintptr_t)8ULL); + x62 = (x61)&((uintptr_t)255ULL); + x63 = (x61)>>((uintptr_t)8ULL); + x64 = x16; + x65 = x18; + x66 = x20; + x67 = x21; + x68 = x22; + x69 = x24; + x70 = x26; + x71 = x27; + x72 = x28; + x73 = x30; + x74 = x32; + x75 = x33; + x76 = x34; + x77 = x36; + x78 = x38; + x79 = x39; + x80 = x40; + x81 = x42; + x82 = x44; + x83 = x45; + x84 = x46; + x85 = x48; + x86 = x50; + x87 = x51; + x88 = x52; + x89 = x54; + x90 = x56; + x91 = x57; + x92 = x58; + x93 = x60; + x94 = x62; + x95 = x63; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x64, 1); + _br2_store((out0)+((uintptr_t)1ULL), x65, 1); + _br2_store((out0)+((uintptr_t)2ULL), x66, 1); + _br2_store((out0)+((uintptr_t)3ULL), x67, 1); + _br2_store((out0)+((uintptr_t)4ULL), x68, 1); + _br2_store((out0)+((uintptr_t)5ULL), x69, 1); + _br2_store((out0)+((uintptr_t)6ULL), x70, 1); + _br2_store((out0)+((uintptr_t)7ULL), x71, 1); + _br2_store((out0)+((uintptr_t)8ULL), x72, 1); + _br2_store((out0)+((uintptr_t)9ULL), x73, 1); + _br2_store((out0)+((uintptr_t)10ULL), x74, 1); + _br2_store((out0)+((uintptr_t)11ULL), x75, 1); + _br2_store((out0)+((uintptr_t)12ULL), x76, 1); + _br2_store((out0)+((uintptr_t)13ULL), x77, 1); + _br2_store((out0)+((uintptr_t)14ULL), x78, 1); + _br2_store((out0)+((uintptr_t)15ULL), x79, 1); + _br2_store((out0)+((uintptr_t)16ULL), x80, 1); + _br2_store((out0)+((uintptr_t)17ULL), x81, 1); + _br2_store((out0)+((uintptr_t)18ULL), x82, 1); + _br2_store((out0)+((uintptr_t)19ULL), x83, 1); + _br2_store((out0)+((uintptr_t)20ULL), x84, 1); + _br2_store((out0)+((uintptr_t)21ULL), x85, 1); + _br2_store((out0)+((uintptr_t)22ULL), x86, 1); + _br2_store((out0)+((uintptr_t)23ULL), x87, 1); + _br2_store((out0)+((uintptr_t)24ULL), x88, 1); + _br2_store((out0)+((uintptr_t)25ULL), x89, 1); + _br2_store((out0)+((uintptr_t)26ULL), x90, 1); + _br2_store((out0)+((uintptr_t)27ULL), x91, 1); + _br2_store((out0)+((uintptr_t)28ULL), x92, 1); + _br2_store((out0)+((uintptr_t)29ULL), x93, 1); + _br2_store((out0)+((uintptr_t)30ULL), x94, 1); + _br2_store((out0)+((uintptr_t)31ULL), x95, 1); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_to_bytes(uint8_t out1[32], const uint32_t arg1[8]) { + internal_fiat_25519_scalar_to_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0x1fffffff]] + */ +static +void internal_fiat_25519_scalar_from_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x31, x30, x29, x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x12, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0, x62, x63, x61, x64, x60, x65, x58, x59, x57, x67, x56, x68, x54, x55, x53, x70, x52, x71, x50, x51, x49, x73, x48, x74, x46, x47, x45, x76, x44, x77, x42, x43, x41, x79, x40, x80, x38, x39, x37, x82, x36, x83, x34, x35, x33, x85, x32, x86, x66, x69, x72, x75, x78, x81, x84, x87, x88, x89, x90, x91, x92, x93, x94, x95; + x0 = _br2_load((in0)+((uintptr_t)0ULL), 1); + x1 = _br2_load((in0)+((uintptr_t)1ULL), 1); + x2 = _br2_load((in0)+((uintptr_t)2ULL), 1); + x3 = _br2_load((in0)+((uintptr_t)3ULL), 1); + x4 = _br2_load((in0)+((uintptr_t)4ULL), 1); + x5 = _br2_load((in0)+((uintptr_t)5ULL), 1); + x6 = _br2_load((in0)+((uintptr_t)6ULL), 1); + x7 = _br2_load((in0)+((uintptr_t)7ULL), 1); + x8 = _br2_load((in0)+((uintptr_t)8ULL), 1); + x9 = _br2_load((in0)+((uintptr_t)9ULL), 1); + x10 = _br2_load((in0)+((uintptr_t)10ULL), 1); + x11 = _br2_load((in0)+((uintptr_t)11ULL), 1); + x12 = _br2_load((in0)+((uintptr_t)12ULL), 1); + x13 = _br2_load((in0)+((uintptr_t)13ULL), 1); + x14 = _br2_load((in0)+((uintptr_t)14ULL), 1); + x15 = _br2_load((in0)+((uintptr_t)15ULL), 1); + x16 = _br2_load((in0)+((uintptr_t)16ULL), 1); + x17 = _br2_load((in0)+((uintptr_t)17ULL), 1); + x18 = _br2_load((in0)+((uintptr_t)18ULL), 1); + x19 = _br2_load((in0)+((uintptr_t)19ULL), 1); + x20 = _br2_load((in0)+((uintptr_t)20ULL), 1); + x21 = _br2_load((in0)+((uintptr_t)21ULL), 1); + x22 = _br2_load((in0)+((uintptr_t)22ULL), 1); + x23 = _br2_load((in0)+((uintptr_t)23ULL), 1); + x24 = _br2_load((in0)+((uintptr_t)24ULL), 1); + x25 = _br2_load((in0)+((uintptr_t)25ULL), 1); + x26 = _br2_load((in0)+((uintptr_t)26ULL), 1); + x27 = _br2_load((in0)+((uintptr_t)27ULL), 1); + x28 = _br2_load((in0)+((uintptr_t)28ULL), 1); + x29 = _br2_load((in0)+((uintptr_t)29ULL), 1); + x30 = _br2_load((in0)+((uintptr_t)30ULL), 1); + x31 = _br2_load((in0)+((uintptr_t)31ULL), 1); + /*skip*/ + /*skip*/ + x32 = (x31)<<((uintptr_t)24ULL); + x33 = (x30)<<((uintptr_t)16ULL); + x34 = (x29)<<((uintptr_t)8ULL); + x35 = x28; + x36 = (x27)<<((uintptr_t)24ULL); + x37 = (x26)<<((uintptr_t)16ULL); + x38 = (x25)<<((uintptr_t)8ULL); + x39 = x24; + x40 = (x23)<<((uintptr_t)24ULL); + x41 = (x22)<<((uintptr_t)16ULL); + x42 = (x21)<<((uintptr_t)8ULL); + x43 = x20; + x44 = (x19)<<((uintptr_t)24ULL); + x45 = (x18)<<((uintptr_t)16ULL); + x46 = (x17)<<((uintptr_t)8ULL); + x47 = x16; + x48 = (x15)<<((uintptr_t)24ULL); + x49 = (x14)<<((uintptr_t)16ULL); + x50 = (x13)<<((uintptr_t)8ULL); + x51 = x12; + x52 = (x11)<<((uintptr_t)24ULL); + x53 = (x10)<<((uintptr_t)16ULL); + x54 = (x9)<<((uintptr_t)8ULL); + x55 = x8; + x56 = (x7)<<((uintptr_t)24ULL); + x57 = (x6)<<((uintptr_t)16ULL); + x58 = (x5)<<((uintptr_t)8ULL); + x59 = x4; + x60 = (x3)<<((uintptr_t)24ULL); + x61 = (x2)<<((uintptr_t)16ULL); + x62 = (x1)<<((uintptr_t)8ULL); + x63 = x0; + x64 = (x62)+(x63); + x65 = (x61)+(x64); + x66 = (x60)+(x65); + x67 = (x58)+(x59); + x68 = (x57)+(x67); + x69 = (x56)+(x68); + x70 = (x54)+(x55); + x71 = (x53)+(x70); + x72 = (x52)+(x71); + x73 = (x50)+(x51); + x74 = (x49)+(x73); + x75 = (x48)+(x74); + x76 = (x46)+(x47); + x77 = (x45)+(x76); + x78 = (x44)+(x77); + x79 = (x42)+(x43); + x80 = (x41)+(x79); + x81 = (x40)+(x80); + x82 = (x38)+(x39); + x83 = (x37)+(x82); + x84 = (x36)+(x83); + x85 = (x34)+(x35); + x86 = (x33)+(x85); + x87 = (x32)+(x86); + x88 = x66; + x89 = x69; + x90 = x72; + x91 = x75; + x92 = x78; + x93 = x81; + x94 = x84; + x95 = x87; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x88, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x89, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x90, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x91, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x92, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x93, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x94, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x95, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_from_bytes(uint32_t out1[8], const uint8_t arg1[32]) { + internal_fiat_25519_scalar_from_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_25519_scalar_set_one(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7; + /*skip*/ + x0 = (uintptr_t)2375587101ULL; + x1 = (uintptr_t)3605803380ULL; + x2 = (uintptr_t)1937624944ULL; + x3 = (uintptr_t)3337575412ULL; + x4 = (uintptr_t)4294967294ULL; + x5 = (uintptr_t)4294967295ULL; + x6 = (uintptr_t)4294967295ULL; + x7 = (uintptr_t)268435455ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x7, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_set_one(uint32_t out1[8]) { + internal_fiat_25519_scalar_set_one((uintptr_t)out1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_25519_scalar_msat(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8; + /*skip*/ + x0 = (uintptr_t)1559614445ULL; + x1 = (uintptr_t)1477600026ULL; + x2 = (uintptr_t)2734136534ULL; + x3 = (uintptr_t)350157278ULL; + x4 = (uintptr_t)0ULL; + x5 = (uintptr_t)0ULL; + x6 = (uintptr_t)0ULL; + x7 = (uintptr_t)268435456ULL; + x8 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x7, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x8, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_msat(uint32_t out1[9]) { + internal_fiat_25519_scalar_msat((uintptr_t)out1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0xffffffff] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffff] + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +uintptr_t internal_fiat_25519_scalar_divstep(uintptr_t out1, uintptr_t out2, uintptr_t out3, uintptr_t out4, uintptr_t in0, uintptr_t in1, uintptr_t in2, uintptr_t in3, uintptr_t in4) { + uintptr_t x34, x36, x37, x38, x40, x41, x43, x44, x46, x47, x49, x50, x52, x53, x55, x56, x58, x59, x61, x62, x64, x65, x0, x68, x1, x70, x2, x72, x3, x74, x4, x76, x5, x78, x6, x80, x7, x82, x8, x67, x84, x9, x85, x69, x87, x10, x88, x71, x90, x11, x91, x73, x93, x12, x94, x75, x96, x13, x97, x77, x99, x14, x100, x79, x102, x15, x103, x81, x105, x16, x106, x83, x108, x17, x109, x111, x112, x114, x115, x117, x118, x120, x121, x123, x124, x126, x127, x129, x130, x132, x133, x136, x137, x138, x140, x141, x142, x143, x145, x146, x147, x148, x150, x151, x152, x153, x155, x156, x157, x158, x160, x161, x162, x163, x165, x166, x167, x168, x170, x173, x174, x175, x177, x178, x179, x180, x182, x183, x184, x185, x187, x188, x190, x192, x194, x195, x196, x198, x199, x171, x200, x25, x24, x23, x22, x21, x20, x19, x18, x210, x208, x211, x213, x214, x207, x215, x217, x218, x206, x219, x221, x222, x205, x223, x225, x226, x204, x227, x229, x230, x203, x231, x233, x234, x202, x235, x237, x238, x209, x241, x212, x242, x243, x245, x246, x216, x247, x248, x250, x251, x220, x252, x253, x255, x256, x224, x258, x228, x260, x232, x262, x236, x263, x239, x240, x265, x26, x266, x244, x268, x27, x269, x249, x271, x28, x272, x254, x274, x29, x275, x257, x277, x30, x278, x259, x280, x31, x281, x261, x283, x32, x284, x35, x264, x286, x33, x287, x290, x291, x293, x294, x296, x297, x299, x300, x302, x303, x305, x306, x308, x309, x311, x312, x314, x315, x292, x86, x318, x89, x319, x295, x320, x322, x323, x92, x324, x298, x325, x327, x328, x95, x329, x301, x330, x332, x333, x98, x334, x304, x335, x337, x338, x101, x339, x307, x340, x342, x343, x104, x344, x310, x345, x347, x348, x107, x349, x313, x350, x352, x353, x110, x354, x316, x113, x356, x357, x116, x359, x360, x119, x362, x363, x122, x365, x366, x125, x368, x369, x128, x371, x372, x131, x374, x375, x289, x134, x377, x378, x358, x267, x381, x270, x382, x361, x383, x385, x386, x273, x387, x364, x388, x390, x391, x276, x392, x367, x393, x395, x396, x279, x397, x370, x398, x400, x401, x282, x402, x373, x403, x405, x406, x285, x407, x376, x408, x410, x411, x288, x412, x379, x413, x415, x418, x419, x420, x422, x423, x424, x425, x427, x428, x429, x430, x432, x433, x435, x437, x439, x440, x441, x443, x444, x416, x445, x39, x317, x321, x326, x331, x336, x341, x346, x351, x355, x135, x457, x172, x458, x139, x460, x176, x461, x144, x463, x181, x464, x149, x466, x186, x467, x154, x469, x189, x470, x159, x472, x191, x473, x164, x475, x193, x476, x201, x169, x478, x197, x479, x380, x481, x417, x482, x384, x484, x421, x485, x389, x487, x426, x488, x394, x490, x431, x491, x399, x493, x434, x494, x404, x496, x436, x497, x409, x499, x438, x500, x446, x414, x502, x442, x503, x447, x42, x45, x48, x51, x54, x57, x60, x63, x66, x448, x449, x450, x451, x452, x453, x454, x455, x456, x459, x462, x465, x468, x471, x474, x477, x480, x483, x486, x489, x492, x495, x498, x501, x504, out0, x505, x506, x507, x508, x509, x510, x511, x512, x513, x514, x515, x516, x517, x518, x519, x520, x521, x522, x523, x524, x525, x526, x527, x528, x529, x530, x531, x532, x533, x534, x535, x536, x537, x538, x539; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + /*skip*/ + x9 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x10 = _br2_load((in2)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x11 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x12 = _br2_load((in2)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x13 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x14 = _br2_load((in2)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x15 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x16 = _br2_load((in2)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x17 = _br2_load((in2)+((uintptr_t)32ULL), sizeof(uintptr_t)); + /*skip*/ + x18 = _br2_load((in3)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x19 = _br2_load((in3)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x20 = _br2_load((in3)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x21 = _br2_load((in3)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x22 = _br2_load((in3)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x23 = _br2_load((in3)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x24 = _br2_load((in3)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x25 = _br2_load((in3)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x26 = _br2_load((in4)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x27 = _br2_load((in4)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x28 = _br2_load((in4)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x29 = _br2_load((in4)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x30 = _br2_load((in4)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x31 = _br2_load((in4)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x32 = _br2_load((in4)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x33 = _br2_load((in4)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x34 = ((in0)^((uintptr_t)4294967295ULL))+((uintptr_t)1ULL); + x35 = ((x34)>>((uintptr_t)31ULL))&((x9)&((uintptr_t)1ULL)); + x36 = ((in0)^((uintptr_t)4294967295ULL))+((uintptr_t)1ULL); + x37 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x38 = (x37)^((uintptr_t)4294967295ULL); + x39 = ((x36)&(x37))|((in0)&(x38)); + x40 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x41 = (x40)^((uintptr_t)4294967295ULL); + x42 = ((x9)&(x40))|((x0)&(x41)); + x43 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x44 = (x43)^((uintptr_t)4294967295ULL); + x45 = ((x10)&(x43))|((x1)&(x44)); + x46 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x47 = (x46)^((uintptr_t)4294967295ULL); + x48 = ((x11)&(x46))|((x2)&(x47)); + x49 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x50 = (x49)^((uintptr_t)4294967295ULL); + x51 = ((x12)&(x49))|((x3)&(x50)); + x52 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x53 = (x52)^((uintptr_t)4294967295ULL); + x54 = ((x13)&(x52))|((x4)&(x53)); + x55 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x56 = (x55)^((uintptr_t)4294967295ULL); + x57 = ((x14)&(x55))|((x5)&(x56)); + x58 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x59 = (x58)^((uintptr_t)4294967295ULL); + x60 = ((x15)&(x58))|((x6)&(x59)); + x61 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x62 = (x61)^((uintptr_t)4294967295ULL); + x63 = ((x16)&(x61))|((x7)&(x62)); + x64 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x65 = (x64)^((uintptr_t)4294967295ULL); + x66 = ((x17)&(x64))|((x8)&(x65)); + x67 = ((uintptr_t)1ULL)+((x0)^((uintptr_t)4294967295ULL)); + x68 = (uintptr_t)((x67)<((uintptr_t)1ULL)); + x69 = (x68)+((x1)^((uintptr_t)4294967295ULL)); + x70 = (uintptr_t)((x69)<((x1)^((uintptr_t)4294967295ULL))); + x71 = (x70)+((x2)^((uintptr_t)4294967295ULL)); + x72 = (uintptr_t)((x71)<((x2)^((uintptr_t)4294967295ULL))); + x73 = (x72)+((x3)^((uintptr_t)4294967295ULL)); + x74 = (uintptr_t)((x73)<((x3)^((uintptr_t)4294967295ULL))); + x75 = (x74)+((x4)^((uintptr_t)4294967295ULL)); + x76 = (uintptr_t)((x75)<((x4)^((uintptr_t)4294967295ULL))); + x77 = (x76)+((x5)^((uintptr_t)4294967295ULL)); + x78 = (uintptr_t)((x77)<((x5)^((uintptr_t)4294967295ULL))); + x79 = (x78)+((x6)^((uintptr_t)4294967295ULL)); + x80 = (uintptr_t)((x79)<((x6)^((uintptr_t)4294967295ULL))); + x81 = (x80)+((x7)^((uintptr_t)4294967295ULL)); + x82 = (uintptr_t)((x81)<((x7)^((uintptr_t)4294967295ULL))); + x83 = (x82)+((x8)^((uintptr_t)4294967295ULL)); + x84 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x85 = (x84)^((uintptr_t)4294967295ULL); + x86 = ((x67)&(x84))|((x9)&(x85)); + x87 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x88 = (x87)^((uintptr_t)4294967295ULL); + x89 = ((x69)&(x87))|((x10)&(x88)); + x90 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x91 = (x90)^((uintptr_t)4294967295ULL); + x92 = ((x71)&(x90))|((x11)&(x91)); + x93 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x94 = (x93)^((uintptr_t)4294967295ULL); + x95 = ((x73)&(x93))|((x12)&(x94)); + x96 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x97 = (x96)^((uintptr_t)4294967295ULL); + x98 = ((x75)&(x96))|((x13)&(x97)); + x99 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x100 = (x99)^((uintptr_t)4294967295ULL); + x101 = ((x77)&(x99))|((x14)&(x100)); + x102 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x103 = (x102)^((uintptr_t)4294967295ULL); + x104 = ((x79)&(x102))|((x15)&(x103)); + x105 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x106 = (x105)^((uintptr_t)4294967295ULL); + x107 = ((x81)&(x105))|((x16)&(x106)); + x108 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x109 = (x108)^((uintptr_t)4294967295ULL); + x110 = ((x83)&(x108))|((x17)&(x109)); + x111 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x112 = (x111)^((uintptr_t)4294967295ULL); + x113 = ((x26)&(x111))|((x18)&(x112)); + x114 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x115 = (x114)^((uintptr_t)4294967295ULL); + x116 = ((x27)&(x114))|((x19)&(x115)); + x117 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x118 = (x117)^((uintptr_t)4294967295ULL); + x119 = ((x28)&(x117))|((x20)&(x118)); + x120 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x121 = (x120)^((uintptr_t)4294967295ULL); + x122 = ((x29)&(x120))|((x21)&(x121)); + x123 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x124 = (x123)^((uintptr_t)4294967295ULL); + x125 = ((x30)&(x123))|((x22)&(x124)); + x126 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x127 = (x126)^((uintptr_t)4294967295ULL); + x128 = ((x31)&(x126))|((x23)&(x127)); + x129 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x130 = (x129)^((uintptr_t)4294967295ULL); + x131 = ((x32)&(x129))|((x24)&(x130)); + x132 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x133 = (x132)^((uintptr_t)4294967295ULL); + x134 = ((x33)&(x132))|((x25)&(x133)); + x135 = (x113)+(x113); + x136 = (uintptr_t)((x135)<(x113)); + x137 = (x136)+(x116); + x138 = (uintptr_t)((x137)<(x116)); + x139 = (x137)+(x116); + x140 = (uintptr_t)((x139)<(x116)); + x141 = (x138)+(x140); + x142 = (x141)+(x119); + x143 = (uintptr_t)((x142)<(x119)); + x144 = (x142)+(x119); + x145 = (uintptr_t)((x144)<(x119)); + x146 = (x143)+(x145); + x147 = (x146)+(x122); + x148 = (uintptr_t)((x147)<(x122)); + x149 = (x147)+(x122); + x150 = (uintptr_t)((x149)<(x122)); + x151 = (x148)+(x150); + x152 = (x151)+(x125); + x153 = (uintptr_t)((x152)<(x125)); + x154 = (x152)+(x125); + x155 = (uintptr_t)((x154)<(x125)); + x156 = (x153)+(x155); + x157 = (x156)+(x128); + x158 = (uintptr_t)((x157)<(x128)); + x159 = (x157)+(x128); + x160 = (uintptr_t)((x159)<(x128)); + x161 = (x158)+(x160); + x162 = (x161)+(x131); + x163 = (uintptr_t)((x162)<(x131)); + x164 = (x162)+(x131); + x165 = (uintptr_t)((x164)<(x131)); + x166 = (x163)+(x165); + x167 = (x166)+(x134); + x168 = (uintptr_t)((x167)<(x134)); + x169 = (x167)+(x134); + x170 = (uintptr_t)((x169)<(x134)); + x171 = (x168)+(x170); + x172 = (x135)-((uintptr_t)1559614445ULL); + x173 = (uintptr_t)((x135)<(x172)); + x174 = (x139)-((uintptr_t)1477600026ULL); + x175 = (uintptr_t)((x139)<(x174)); + x176 = (x174)-(x173); + x177 = (uintptr_t)((x174)<(x176)); + x178 = (x175)+(x177); + x179 = (x144)-((uintptr_t)2734136534ULL); + x180 = (uintptr_t)((x144)<(x179)); + x181 = (x179)-(x178); + x182 = (uintptr_t)((x179)<(x181)); + x183 = (x180)+(x182); + x184 = (x149)-((uintptr_t)350157278ULL); + x185 = (uintptr_t)((x149)<(x184)); + x186 = (x184)-(x183); + x187 = (uintptr_t)((x184)<(x186)); + x188 = (x185)+(x187); + x189 = (x154)-(x188); + x190 = (uintptr_t)((x154)<(x189)); + x191 = (x159)-(x190); + x192 = (uintptr_t)((x159)<(x191)); + x193 = (x164)-(x192); + x194 = (uintptr_t)((x164)<(x193)); + x195 = (x169)-((uintptr_t)268435456ULL); + x196 = (uintptr_t)((x169)<(x195)); + x197 = (x195)-(x194); + x198 = (uintptr_t)((x195)<(x197)); + x199 = (x196)+(x198); + x200 = (x171)-(x199); + x201 = (uintptr_t)((x171)<(x200)); + x202 = x25; + x203 = x24; + x204 = x23; + x205 = x22; + x206 = x21; + x207 = x20; + x208 = x19; + x209 = x18; + x210 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x209))); + x211 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x208))); + x212 = (((uintptr_t)0ULL)-(x208))-(x210); + x213 = (uintptr_t)((((uintptr_t)0ULL)-(x208))<(x212)); + x214 = (x211)+(x213); + x215 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x207))); + x216 = (((uintptr_t)0ULL)-(x207))-(x214); + x217 = (uintptr_t)((((uintptr_t)0ULL)-(x207))<(x216)); + x218 = (x215)+(x217); + x219 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x206))); + x220 = (((uintptr_t)0ULL)-(x206))-(x218); + x221 = (uintptr_t)((((uintptr_t)0ULL)-(x206))<(x220)); + x222 = (x219)+(x221); + x223 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x205))); + x224 = (((uintptr_t)0ULL)-(x205))-(x222); + x225 = (uintptr_t)((((uintptr_t)0ULL)-(x205))<(x224)); + x226 = (x223)+(x225); + x227 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x204))); + x228 = (((uintptr_t)0ULL)-(x204))-(x226); + x229 = (uintptr_t)((((uintptr_t)0ULL)-(x204))<(x228)); + x230 = (x227)+(x229); + x231 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x203))); + x232 = (((uintptr_t)0ULL)-(x203))-(x230); + x233 = (uintptr_t)((((uintptr_t)0ULL)-(x203))<(x232)); + x234 = (x231)+(x233); + x235 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x202))); + x236 = (((uintptr_t)0ULL)-(x202))-(x234); + x237 = (uintptr_t)((((uintptr_t)0ULL)-(x202))<(x236)); + x238 = (x235)+(x237); + x239 = ((uintptr_t)-1ULL)+((uintptr_t)((x238)==((uintptr_t)0ULL))); + x240 = (((uintptr_t)0ULL)-(x209))+((x239)&((uintptr_t)1559614445ULL)); + x241 = (uintptr_t)((x240)<(((uintptr_t)0ULL)-(x209))); + x242 = (x241)+(x212); + x243 = (uintptr_t)((x242)<(x212)); + x244 = (x242)+((x239)&((uintptr_t)1477600026ULL)); + x245 = (uintptr_t)((x244)<((x239)&((uintptr_t)1477600026ULL))); + x246 = (x243)+(x245); + x247 = (x246)+(x216); + x248 = (uintptr_t)((x247)<(x216)); + x249 = (x247)+((x239)&((uintptr_t)2734136534ULL)); + x250 = (uintptr_t)((x249)<((x239)&((uintptr_t)2734136534ULL))); + x251 = (x248)+(x250); + x252 = (x251)+(x220); + x253 = (uintptr_t)((x252)<(x220)); + x254 = (x252)+((x239)&((uintptr_t)350157278ULL)); + x255 = (uintptr_t)((x254)<((x239)&((uintptr_t)350157278ULL))); + x256 = (x253)+(x255); + x257 = (x256)+(x224); + x258 = (uintptr_t)((x257)<(x224)); + x259 = (x258)+(x228); + x260 = (uintptr_t)((x259)<(x228)); + x261 = (x260)+(x232); + x262 = (uintptr_t)((x261)<(x232)); + x263 = (x262)+(x236); + x264 = (x263)+((x239)&((uintptr_t)268435456ULL)); + x265 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x266 = (x265)^((uintptr_t)4294967295ULL); + x267 = ((x240)&(x265))|((x26)&(x266)); + x268 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x269 = (x268)^((uintptr_t)4294967295ULL); + x270 = ((x244)&(x268))|((x27)&(x269)); + x271 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x272 = (x271)^((uintptr_t)4294967295ULL); + x273 = ((x249)&(x271))|((x28)&(x272)); + x274 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x275 = (x274)^((uintptr_t)4294967295ULL); + x276 = ((x254)&(x274))|((x29)&(x275)); + x277 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x278 = (x277)^((uintptr_t)4294967295ULL); + x279 = ((x257)&(x277))|((x30)&(x278)); + x280 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x281 = (x280)^((uintptr_t)4294967295ULL); + x282 = ((x259)&(x280))|((x31)&(x281)); + x283 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x284 = (x283)^((uintptr_t)4294967295ULL); + x285 = ((x261)&(x283))|((x32)&(x284)); + x286 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x287 = (x286)^((uintptr_t)4294967295ULL); + x288 = ((x264)&(x286))|((x33)&(x287)); + x289 = (x86)&((uintptr_t)1ULL); + x290 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x291 = (x290)^((uintptr_t)4294967295ULL); + x292 = ((x42)&(x290))|(((uintptr_t)0ULL)&(x291)); + x293 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x294 = (x293)^((uintptr_t)4294967295ULL); + x295 = ((x45)&(x293))|(((uintptr_t)0ULL)&(x294)); + x296 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x297 = (x296)^((uintptr_t)4294967295ULL); + x298 = ((x48)&(x296))|(((uintptr_t)0ULL)&(x297)); + x299 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x300 = (x299)^((uintptr_t)4294967295ULL); + x301 = ((x51)&(x299))|(((uintptr_t)0ULL)&(x300)); + x302 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x303 = (x302)^((uintptr_t)4294967295ULL); + x304 = ((x54)&(x302))|(((uintptr_t)0ULL)&(x303)); + x305 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x306 = (x305)^((uintptr_t)4294967295ULL); + x307 = ((x57)&(x305))|(((uintptr_t)0ULL)&(x306)); + x308 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x309 = (x308)^((uintptr_t)4294967295ULL); + x310 = ((x60)&(x308))|(((uintptr_t)0ULL)&(x309)); + x311 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x312 = (x311)^((uintptr_t)4294967295ULL); + x313 = ((x63)&(x311))|(((uintptr_t)0ULL)&(x312)); + x314 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x315 = (x314)^((uintptr_t)4294967295ULL); + x316 = ((x66)&(x314))|(((uintptr_t)0ULL)&(x315)); + x317 = (x86)+(x292); + x318 = (uintptr_t)((x317)<(x86)); + x319 = (x318)+(x89); + x320 = (uintptr_t)((x319)<(x89)); + x321 = (x319)+(x295); + x322 = (uintptr_t)((x321)<(x295)); + x323 = (x320)+(x322); + x324 = (x323)+(x92); + x325 = (uintptr_t)((x324)<(x92)); + x326 = (x324)+(x298); + x327 = (uintptr_t)((x326)<(x298)); + x328 = (x325)+(x327); + x329 = (x328)+(x95); + x330 = (uintptr_t)((x329)<(x95)); + x331 = (x329)+(x301); + x332 = (uintptr_t)((x331)<(x301)); + x333 = (x330)+(x332); + x334 = (x333)+(x98); + x335 = (uintptr_t)((x334)<(x98)); + x336 = (x334)+(x304); + x337 = (uintptr_t)((x336)<(x304)); + x338 = (x335)+(x337); + x339 = (x338)+(x101); + x340 = (uintptr_t)((x339)<(x101)); + x341 = (x339)+(x307); + x342 = (uintptr_t)((x341)<(x307)); + x343 = (x340)+(x342); + x344 = (x343)+(x104); + x345 = (uintptr_t)((x344)<(x104)); + x346 = (x344)+(x310); + x347 = (uintptr_t)((x346)<(x310)); + x348 = (x345)+(x347); + x349 = (x348)+(x107); + x350 = (uintptr_t)((x349)<(x107)); + x351 = (x349)+(x313); + x352 = (uintptr_t)((x351)<(x313)); + x353 = (x350)+(x352); + x354 = (x353)+(x110); + x355 = (x354)+(x316); + x356 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x357 = (x356)^((uintptr_t)4294967295ULL); + x358 = ((x113)&(x356))|(((uintptr_t)0ULL)&(x357)); + x359 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x360 = (x359)^((uintptr_t)4294967295ULL); + x361 = ((x116)&(x359))|(((uintptr_t)0ULL)&(x360)); + x362 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x363 = (x362)^((uintptr_t)4294967295ULL); + x364 = ((x119)&(x362))|(((uintptr_t)0ULL)&(x363)); + x365 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x366 = (x365)^((uintptr_t)4294967295ULL); + x367 = ((x122)&(x365))|(((uintptr_t)0ULL)&(x366)); + x368 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x369 = (x368)^((uintptr_t)4294967295ULL); + x370 = ((x125)&(x368))|(((uintptr_t)0ULL)&(x369)); + x371 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x372 = (x371)^((uintptr_t)4294967295ULL); + x373 = ((x128)&(x371))|(((uintptr_t)0ULL)&(x372)); + x374 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x375 = (x374)^((uintptr_t)4294967295ULL); + x376 = ((x131)&(x374))|(((uintptr_t)0ULL)&(x375)); + x377 = ((uintptr_t)-1ULL)+((uintptr_t)((x289)==((uintptr_t)0ULL))); + x378 = (x377)^((uintptr_t)4294967295ULL); + x379 = ((x134)&(x377))|(((uintptr_t)0ULL)&(x378)); + x380 = (x267)+(x358); + x381 = (uintptr_t)((x380)<(x267)); + x382 = (x381)+(x270); + x383 = (uintptr_t)((x382)<(x270)); + x384 = (x382)+(x361); + x385 = (uintptr_t)((x384)<(x361)); + x386 = (x383)+(x385); + x387 = (x386)+(x273); + x388 = (uintptr_t)((x387)<(x273)); + x389 = (x387)+(x364); + x390 = (uintptr_t)((x389)<(x364)); + x391 = (x388)+(x390); + x392 = (x391)+(x276); + x393 = (uintptr_t)((x392)<(x276)); + x394 = (x392)+(x367); + x395 = (uintptr_t)((x394)<(x367)); + x396 = (x393)+(x395); + x397 = (x396)+(x279); + x398 = (uintptr_t)((x397)<(x279)); + x399 = (x397)+(x370); + x400 = (uintptr_t)((x399)<(x370)); + x401 = (x398)+(x400); + x402 = (x401)+(x282); + x403 = (uintptr_t)((x402)<(x282)); + x404 = (x402)+(x373); + x405 = (uintptr_t)((x404)<(x373)); + x406 = (x403)+(x405); + x407 = (x406)+(x285); + x408 = (uintptr_t)((x407)<(x285)); + x409 = (x407)+(x376); + x410 = (uintptr_t)((x409)<(x376)); + x411 = (x408)+(x410); + x412 = (x411)+(x288); + x413 = (uintptr_t)((x412)<(x288)); + x414 = (x412)+(x379); + x415 = (uintptr_t)((x414)<(x379)); + x416 = (x413)+(x415); + x417 = (x380)-((uintptr_t)1559614445ULL); + x418 = (uintptr_t)((x380)<(x417)); + x419 = (x384)-((uintptr_t)1477600026ULL); + x420 = (uintptr_t)((x384)<(x419)); + x421 = (x419)-(x418); + x422 = (uintptr_t)((x419)<(x421)); + x423 = (x420)+(x422); + x424 = (x389)-((uintptr_t)2734136534ULL); + x425 = (uintptr_t)((x389)<(x424)); + x426 = (x424)-(x423); + x427 = (uintptr_t)((x424)<(x426)); + x428 = (x425)+(x427); + x429 = (x394)-((uintptr_t)350157278ULL); + x430 = (uintptr_t)((x394)<(x429)); + x431 = (x429)-(x428); + x432 = (uintptr_t)((x429)<(x431)); + x433 = (x430)+(x432); + x434 = (x399)-(x433); + x435 = (uintptr_t)((x399)<(x434)); + x436 = (x404)-(x435); + x437 = (uintptr_t)((x404)<(x436)); + x438 = (x409)-(x437); + x439 = (uintptr_t)((x409)<(x438)); + x440 = (x414)-((uintptr_t)268435456ULL); + x441 = (uintptr_t)((x414)<(x440)); + x442 = (x440)-(x439); + x443 = (uintptr_t)((x440)<(x442)); + x444 = (x441)+(x443); + x445 = (x416)-(x444); + x446 = (uintptr_t)((x416)<(x445)); + x447 = (x39)+((uintptr_t)1ULL); + x448 = ((x317)>>((uintptr_t)1ULL))|((x321)<<((uintptr_t)31ULL)); + x449 = ((x321)>>((uintptr_t)1ULL))|((x326)<<((uintptr_t)31ULL)); + x450 = ((x326)>>((uintptr_t)1ULL))|((x331)<<((uintptr_t)31ULL)); + x451 = ((x331)>>((uintptr_t)1ULL))|((x336)<<((uintptr_t)31ULL)); + x452 = ((x336)>>((uintptr_t)1ULL))|((x341)<<((uintptr_t)31ULL)); + x453 = ((x341)>>((uintptr_t)1ULL))|((x346)<<((uintptr_t)31ULL)); + x454 = ((x346)>>((uintptr_t)1ULL))|((x351)<<((uintptr_t)31ULL)); + x455 = ((x351)>>((uintptr_t)1ULL))|((x355)<<((uintptr_t)31ULL)); + x456 = ((x355)&((uintptr_t)2147483648ULL))|((x355)>>((uintptr_t)1ULL)); + x457 = ((uintptr_t)-1ULL)+((uintptr_t)((x201)==((uintptr_t)0ULL))); + x458 = (x457)^((uintptr_t)4294967295ULL); + x459 = ((x135)&(x457))|((x172)&(x458)); + x460 = ((uintptr_t)-1ULL)+((uintptr_t)((x201)==((uintptr_t)0ULL))); + x461 = (x460)^((uintptr_t)4294967295ULL); + x462 = ((x139)&(x460))|((x176)&(x461)); + x463 = ((uintptr_t)-1ULL)+((uintptr_t)((x201)==((uintptr_t)0ULL))); + x464 = (x463)^((uintptr_t)4294967295ULL); + x465 = ((x144)&(x463))|((x181)&(x464)); + x466 = ((uintptr_t)-1ULL)+((uintptr_t)((x201)==((uintptr_t)0ULL))); + x467 = (x466)^((uintptr_t)4294967295ULL); + x468 = ((x149)&(x466))|((x186)&(x467)); + x469 = ((uintptr_t)-1ULL)+((uintptr_t)((x201)==((uintptr_t)0ULL))); + x470 = (x469)^((uintptr_t)4294967295ULL); + x471 = ((x154)&(x469))|((x189)&(x470)); + x472 = ((uintptr_t)-1ULL)+((uintptr_t)((x201)==((uintptr_t)0ULL))); + x473 = (x472)^((uintptr_t)4294967295ULL); + x474 = ((x159)&(x472))|((x191)&(x473)); + x475 = ((uintptr_t)-1ULL)+((uintptr_t)((x201)==((uintptr_t)0ULL))); + x476 = (x475)^((uintptr_t)4294967295ULL); + x477 = ((x164)&(x475))|((x193)&(x476)); + x478 = ((uintptr_t)-1ULL)+((uintptr_t)((x201)==((uintptr_t)0ULL))); + x479 = (x478)^((uintptr_t)4294967295ULL); + x480 = ((x169)&(x478))|((x197)&(x479)); + x481 = ((uintptr_t)-1ULL)+((uintptr_t)((x446)==((uintptr_t)0ULL))); + x482 = (x481)^((uintptr_t)4294967295ULL); + x483 = ((x380)&(x481))|((x417)&(x482)); + x484 = ((uintptr_t)-1ULL)+((uintptr_t)((x446)==((uintptr_t)0ULL))); + x485 = (x484)^((uintptr_t)4294967295ULL); + x486 = ((x384)&(x484))|((x421)&(x485)); + x487 = ((uintptr_t)-1ULL)+((uintptr_t)((x446)==((uintptr_t)0ULL))); + x488 = (x487)^((uintptr_t)4294967295ULL); + x489 = ((x389)&(x487))|((x426)&(x488)); + x490 = ((uintptr_t)-1ULL)+((uintptr_t)((x446)==((uintptr_t)0ULL))); + x491 = (x490)^((uintptr_t)4294967295ULL); + x492 = ((x394)&(x490))|((x431)&(x491)); + x493 = ((uintptr_t)-1ULL)+((uintptr_t)((x446)==((uintptr_t)0ULL))); + x494 = (x493)^((uintptr_t)4294967295ULL); + x495 = ((x399)&(x493))|((x434)&(x494)); + x496 = ((uintptr_t)-1ULL)+((uintptr_t)((x446)==((uintptr_t)0ULL))); + x497 = (x496)^((uintptr_t)4294967295ULL); + x498 = ((x404)&(x496))|((x436)&(x497)); + x499 = ((uintptr_t)-1ULL)+((uintptr_t)((x446)==((uintptr_t)0ULL))); + x500 = (x499)^((uintptr_t)4294967295ULL); + x501 = ((x409)&(x499))|((x438)&(x500)); + x502 = ((uintptr_t)-1ULL)+((uintptr_t)((x446)==((uintptr_t)0ULL))); + x503 = (x502)^((uintptr_t)4294967295ULL); + x504 = ((x414)&(x502))|((x442)&(x503)); + x505 = x447; + x506 = x42; + x507 = x45; + x508 = x48; + x509 = x51; + x510 = x54; + x511 = x57; + x512 = x60; + x513 = x63; + x514 = x66; + /*skip*/ + x515 = x448; + x516 = x449; + x517 = x450; + x518 = x451; + x519 = x452; + x520 = x453; + x521 = x454; + x522 = x455; + x523 = x456; + /*skip*/ + x524 = x459; + x525 = x462; + x526 = x465; + x527 = x468; + x528 = x471; + x529 = x474; + x530 = x477; + x531 = x480; + /*skip*/ + x532 = x483; + x533 = x486; + x534 = x489; + x535 = x492; + x536 = x495; + x537 = x498; + x538 = x501; + x539 = x504; + /*skip*/ + out0 = x505; + _br2_store((out1)+((uintptr_t)0ULL), x506, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)4ULL), x507, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)8ULL), x508, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)12ULL), x509, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)16ULL), x510, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)20ULL), x511, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)24ULL), x512, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)28ULL), x513, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)32ULL), x514, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out2)+((uintptr_t)0ULL), x515, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)4ULL), x516, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)8ULL), x517, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)12ULL), x518, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)16ULL), x519, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)20ULL), x520, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)24ULL), x521, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)28ULL), x522, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)32ULL), x523, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out3)+((uintptr_t)0ULL), x524, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)4ULL), x525, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)8ULL), x526, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)12ULL), x527, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)16ULL), x528, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)20ULL), x529, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)24ULL), x530, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)28ULL), x531, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out4)+((uintptr_t)0ULL), x532, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)4ULL), x533, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)8ULL), x534, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)12ULL), x535, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)16ULL), x536, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)20ULL), x537, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)24ULL), x538, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)28ULL), x539, sizeof(uintptr_t)); + /*skip*/ + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_divstep(uint32_t* out1, uint32_t out2[9], uint32_t out3[9], uint32_t out4[8], uint32_t out5[8], uint32_t arg1, const uint32_t arg2[9], const uint32_t arg3[9], const uint32_t arg4[8], const uint32_t arg5[8]) { + *out1 = (uint32_t)internal_fiat_25519_scalar_divstep((uintptr_t)out2, (uintptr_t)out3, (uintptr_t)out4, (uintptr_t)out5, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3, (uintptr_t)arg4, (uintptr_t)arg5); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_25519_scalar_divstep_precomp(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7; + /*skip*/ + x0 = (uintptr_t)916966290ULL; + x1 = (uintptr_t)3607820356ULL; + x2 = (uintptr_t)2964894041ULL; + x3 = (uintptr_t)1601292664ULL; + x4 = (uintptr_t)1955888922ULL; + x5 = (uintptr_t)3882713449ULL; + x6 = (uintptr_t)4053001471ULL; + x7 = (uintptr_t)26881334ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x7, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_divstep_precomp(uint32_t out1[8]) { + internal_fiat_25519_scalar_divstep_precomp((uintptr_t)out1); +} diff --git a/fiat-bedrock2/src/curve25519_scalar_64.c b/fiat-bedrock2/src/curve25519_scalar_64.c new file mode 100644 index 0000000000..39d8f8a4fe --- /dev/null +++ b/fiat-bedrock2/src/curve25519_scalar_64.c @@ -0,0 +1,1984 @@ +/* Autogenerated: 'src/ExtractionOCaml/bedrock2_word_by_word_montgomery' --lang bedrock2 --static --no-wide-int --widen-carry --widen-bytes --split-multiret --no-select --no-field-element-typedefs 25519_scalar 64 '2^252 + 27742317777372353535851937790883648493' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: 25519_scalar */ +/* machine_wordsize = 64 (from "64") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed (from "2^252 + 27742317777372353535851937790883648493") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +#include + +// We use memcpy to work around -fstrict-aliasing. +// A plain memcpy is enough on clang 10, but not on gcc 10, which fails +// to infer the bounds on an integer loaded by memcpy. +// Adding a range mask after memcpy in turn makes slower code in clang. +// Loading individual bytes, shifting them together, and or-ing is fast +// on clang and sometimes on GCC, but other times GCC inlines individual +// byte operations without reconstructing wider accesses. +// The little-endian idiom below seems fast in gcc 9+ and clang 10. +static __attribute__((always_inline)) inline uintptr_t +_br2_load(uintptr_t a, uintptr_t sz) { + switch (sz) { + case 1: { uint8_t r = 0; memcpy(&r, (void*)a, 1); return r; } + case 2: { uint16_t r = 0; memcpy(&r, (void*)a, 2); return r; } + case 4: { uint32_t r = 0; memcpy(&r, (void*)a, 4); return r; } + case 8: { uint64_t r = 0; memcpy(&r, (void*)a, 8); return r; } + default: __builtin_unreachable(); + } +} + +static __attribute__((always_inline)) inline void +_br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) { + memcpy((void*)a, &v, sz); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_25519_scalar_mul(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x1, x2, x3, x0, x11, x16, x19, x21, x17, x22, x14, x23, x25, x26, x15, x27, x12, x28, x30, x31, x13, x33, x36, x39, x41, x37, x38, x43, x18, x44, x20, x45, x40, x46, x48, x49, x24, x50, x42, x51, x53, x54, x29, x55, x34, x56, x58, x59, x32, x60, x35, x61, x63, x8, x69, x72, x74, x70, x75, x67, x76, x78, x79, x68, x80, x65, x81, x83, x84, x66, x71, x47, x87, x52, x88, x73, x89, x91, x92, x57, x93, x77, x94, x96, x97, x62, x98, x82, x99, x101, x102, x64, x103, x85, x104, x106, x108, x111, x114, x116, x112, x113, x118, x86, x119, x90, x120, x115, x121, x123, x124, x95, x125, x117, x126, x128, x129, x100, x130, x109, x131, x133, x134, x105, x135, x110, x136, x138, x139, x107, x9, x145, x148, x150, x146, x151, x143, x152, x154, x155, x144, x156, x141, x157, x159, x160, x142, x147, x122, x163, x127, x164, x149, x165, x167, x168, x132, x169, x153, x170, x172, x173, x137, x174, x158, x175, x177, x178, x140, x179, x161, x180, x182, x184, x187, x190, x192, x188, x189, x194, x162, x195, x166, x196, x191, x197, x199, x200, x171, x201, x193, x202, x204, x205, x176, x206, x185, x207, x209, x210, x181, x211, x186, x212, x214, x215, x183, x7, x6, x5, x10, x4, x221, x224, x226, x222, x227, x219, x228, x230, x231, x220, x232, x217, x233, x235, x236, x218, x223, x198, x239, x203, x240, x225, x241, x243, x244, x208, x245, x229, x246, x248, x249, x213, x250, x234, x251, x253, x254, x216, x255, x237, x256, x258, x260, x263, x266, x268, x264, x265, x270, x238, x271, x242, x272, x267, x273, x275, x276, x247, x277, x269, x278, x280, x281, x252, x282, x261, x283, x285, x286, x257, x287, x262, x288, x290, x291, x259, x294, x295, x296, x298, x299, x301, x302, x303, x305, x306, x292, x307, x274, x309, x293, x310, x279, x312, x297, x313, x284, x315, x300, x316, x308, x289, x318, x304, x319, x311, x314, x317, x320, x321, x322, x323, x324; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x1; + x9 = x2; + x10 = x3; + x11 = x0; + x12 = (x11)*(x7); + x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x7))>>32 : ((__uint128_t)(x11)*(x7))>>64); + x14 = (x11)*(x6); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x6))>>32 : ((__uint128_t)(x11)*(x6))>>64); + x16 = (x11)*(x5); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x5))>>32 : ((__uint128_t)(x11)*(x5))>>64); + x18 = (x11)*(x4); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x4))>>32 : ((__uint128_t)(x11)*(x4))>>64); + x20 = (x19)+(x16); + x21 = (uintptr_t)((x20)<(x19)); + x22 = (x21)+(x17); + x23 = (uintptr_t)((x22)<(x17)); + x24 = (x22)+(x14); + x25 = (uintptr_t)((x24)<(x14)); + x26 = (x23)+(x25); + x27 = (x26)+(x15); + x28 = (uintptr_t)((x27)<(x15)); + x29 = (x27)+(x12); + x30 = (uintptr_t)((x29)<(x12)); + x31 = (x28)+(x30); + x32 = (x31)+(x13); + x33 = (x18)*((uintptr_t)15183074304973897243ULL); + x34 = (x33)*((uintptr_t)1152921504606846976ULL); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)1152921504606846976ULL))>>64); + x36 = (x33)*((uintptr_t)1503914060200516822ULL); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)1503914060200516822ULL))>>64); + x38 = (x33)*((uintptr_t)6346243789798364141ULL); + x39 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)6346243789798364141ULL))>>64); + x40 = (x39)+(x36); + x41 = (uintptr_t)((x40)<(x39)); + x42 = (x41)+(x37); + x43 = (x18)+(x38); + x44 = (uintptr_t)((x43)<(x18)); + x45 = (x44)+(x20); + x46 = (uintptr_t)((x45)<(x20)); + x47 = (x45)+(x40); + x48 = (uintptr_t)((x47)<(x40)); + x49 = (x46)+(x48); + x50 = (x49)+(x24); + x51 = (uintptr_t)((x50)<(x24)); + x52 = (x50)+(x42); + x53 = (uintptr_t)((x52)<(x42)); + x54 = (x51)+(x53); + x55 = (x54)+(x29); + x56 = (uintptr_t)((x55)<(x29)); + x57 = (x55)+(x34); + x58 = (uintptr_t)((x57)<(x34)); + x59 = (x56)+(x58); + x60 = (x59)+(x32); + x61 = (uintptr_t)((x60)<(x32)); + x62 = (x60)+(x35); + x63 = (uintptr_t)((x62)<(x35)); + x64 = (x61)+(x63); + x65 = (x8)*(x7); + x66 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x7))>>32 : ((__uint128_t)(x8)*(x7))>>64); + x67 = (x8)*(x6); + x68 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x6))>>32 : ((__uint128_t)(x8)*(x6))>>64); + x69 = (x8)*(x5); + x70 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x5))>>32 : ((__uint128_t)(x8)*(x5))>>64); + x71 = (x8)*(x4); + x72 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x4))>>32 : ((__uint128_t)(x8)*(x4))>>64); + x73 = (x72)+(x69); + x74 = (uintptr_t)((x73)<(x72)); + x75 = (x74)+(x70); + x76 = (uintptr_t)((x75)<(x70)); + x77 = (x75)+(x67); + x78 = (uintptr_t)((x77)<(x67)); + x79 = (x76)+(x78); + x80 = (x79)+(x68); + x81 = (uintptr_t)((x80)<(x68)); + x82 = (x80)+(x65); + x83 = (uintptr_t)((x82)<(x65)); + x84 = (x81)+(x83); + x85 = (x84)+(x66); + x86 = (x47)+(x71); + x87 = (uintptr_t)((x86)<(x47)); + x88 = (x87)+(x52); + x89 = (uintptr_t)((x88)<(x52)); + x90 = (x88)+(x73); + x91 = (uintptr_t)((x90)<(x73)); + x92 = (x89)+(x91); + x93 = (x92)+(x57); + x94 = (uintptr_t)((x93)<(x57)); + x95 = (x93)+(x77); + x96 = (uintptr_t)((x95)<(x77)); + x97 = (x94)+(x96); + x98 = (x97)+(x62); + x99 = (uintptr_t)((x98)<(x62)); + x100 = (x98)+(x82); + x101 = (uintptr_t)((x100)<(x82)); + x102 = (x99)+(x101); + x103 = (x102)+(x64); + x104 = (uintptr_t)((x103)<(x64)); + x105 = (x103)+(x85); + x106 = (uintptr_t)((x105)<(x85)); + x107 = (x104)+(x106); + x108 = (x86)*((uintptr_t)15183074304973897243ULL); + x109 = (x108)*((uintptr_t)1152921504606846976ULL); + x110 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x108)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x108)*((uintptr_t)1152921504606846976ULL))>>64); + x111 = (x108)*((uintptr_t)1503914060200516822ULL); + x112 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x108)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x108)*((uintptr_t)1503914060200516822ULL))>>64); + x113 = (x108)*((uintptr_t)6346243789798364141ULL); + x114 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x108)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x108)*((uintptr_t)6346243789798364141ULL))>>64); + x115 = (x114)+(x111); + x116 = (uintptr_t)((x115)<(x114)); + x117 = (x116)+(x112); + x118 = (x86)+(x113); + x119 = (uintptr_t)((x118)<(x86)); + x120 = (x119)+(x90); + x121 = (uintptr_t)((x120)<(x90)); + x122 = (x120)+(x115); + x123 = (uintptr_t)((x122)<(x115)); + x124 = (x121)+(x123); + x125 = (x124)+(x95); + x126 = (uintptr_t)((x125)<(x95)); + x127 = (x125)+(x117); + x128 = (uintptr_t)((x127)<(x117)); + x129 = (x126)+(x128); + x130 = (x129)+(x100); + x131 = (uintptr_t)((x130)<(x100)); + x132 = (x130)+(x109); + x133 = (uintptr_t)((x132)<(x109)); + x134 = (x131)+(x133); + x135 = (x134)+(x105); + x136 = (uintptr_t)((x135)<(x105)); + x137 = (x135)+(x110); + x138 = (uintptr_t)((x137)<(x110)); + x139 = (x136)+(x138); + x140 = (x139)+(x107); + x141 = (x9)*(x7); + x142 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x7))>>32 : ((__uint128_t)(x9)*(x7))>>64); + x143 = (x9)*(x6); + x144 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x6))>>32 : ((__uint128_t)(x9)*(x6))>>64); + x145 = (x9)*(x5); + x146 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x5))>>32 : ((__uint128_t)(x9)*(x5))>>64); + x147 = (x9)*(x4); + x148 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x4))>>32 : ((__uint128_t)(x9)*(x4))>>64); + x149 = (x148)+(x145); + x150 = (uintptr_t)((x149)<(x148)); + x151 = (x150)+(x146); + x152 = (uintptr_t)((x151)<(x146)); + x153 = (x151)+(x143); + x154 = (uintptr_t)((x153)<(x143)); + x155 = (x152)+(x154); + x156 = (x155)+(x144); + x157 = (uintptr_t)((x156)<(x144)); + x158 = (x156)+(x141); + x159 = (uintptr_t)((x158)<(x141)); + x160 = (x157)+(x159); + x161 = (x160)+(x142); + x162 = (x122)+(x147); + x163 = (uintptr_t)((x162)<(x122)); + x164 = (x163)+(x127); + x165 = (uintptr_t)((x164)<(x127)); + x166 = (x164)+(x149); + x167 = (uintptr_t)((x166)<(x149)); + x168 = (x165)+(x167); + x169 = (x168)+(x132); + x170 = (uintptr_t)((x169)<(x132)); + x171 = (x169)+(x153); + x172 = (uintptr_t)((x171)<(x153)); + x173 = (x170)+(x172); + x174 = (x173)+(x137); + x175 = (uintptr_t)((x174)<(x137)); + x176 = (x174)+(x158); + x177 = (uintptr_t)((x176)<(x158)); + x178 = (x175)+(x177); + x179 = (x178)+(x140); + x180 = (uintptr_t)((x179)<(x140)); + x181 = (x179)+(x161); + x182 = (uintptr_t)((x181)<(x161)); + x183 = (x180)+(x182); + x184 = (x162)*((uintptr_t)15183074304973897243ULL); + x185 = (x184)*((uintptr_t)1152921504606846976ULL); + x186 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x184)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x184)*((uintptr_t)1152921504606846976ULL))>>64); + x187 = (x184)*((uintptr_t)1503914060200516822ULL); + x188 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x184)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x184)*((uintptr_t)1503914060200516822ULL))>>64); + x189 = (x184)*((uintptr_t)6346243789798364141ULL); + x190 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x184)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x184)*((uintptr_t)6346243789798364141ULL))>>64); + x191 = (x190)+(x187); + x192 = (uintptr_t)((x191)<(x190)); + x193 = (x192)+(x188); + x194 = (x162)+(x189); + x195 = (uintptr_t)((x194)<(x162)); + x196 = (x195)+(x166); + x197 = (uintptr_t)((x196)<(x166)); + x198 = (x196)+(x191); + x199 = (uintptr_t)((x198)<(x191)); + x200 = (x197)+(x199); + x201 = (x200)+(x171); + x202 = (uintptr_t)((x201)<(x171)); + x203 = (x201)+(x193); + x204 = (uintptr_t)((x203)<(x193)); + x205 = (x202)+(x204); + x206 = (x205)+(x176); + x207 = (uintptr_t)((x206)<(x176)); + x208 = (x206)+(x185); + x209 = (uintptr_t)((x208)<(x185)); + x210 = (x207)+(x209); + x211 = (x210)+(x181); + x212 = (uintptr_t)((x211)<(x181)); + x213 = (x211)+(x186); + x214 = (uintptr_t)((x213)<(x186)); + x215 = (x212)+(x214); + x216 = (x215)+(x183); + x217 = (x10)*(x7); + x218 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x7))>>32 : ((__uint128_t)(x10)*(x7))>>64); + x219 = (x10)*(x6); + x220 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x6))>>32 : ((__uint128_t)(x10)*(x6))>>64); + x221 = (x10)*(x5); + x222 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x5))>>32 : ((__uint128_t)(x10)*(x5))>>64); + x223 = (x10)*(x4); + x224 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x4))>>32 : ((__uint128_t)(x10)*(x4))>>64); + x225 = (x224)+(x221); + x226 = (uintptr_t)((x225)<(x224)); + x227 = (x226)+(x222); + x228 = (uintptr_t)((x227)<(x222)); + x229 = (x227)+(x219); + x230 = (uintptr_t)((x229)<(x219)); + x231 = (x228)+(x230); + x232 = (x231)+(x220); + x233 = (uintptr_t)((x232)<(x220)); + x234 = (x232)+(x217); + x235 = (uintptr_t)((x234)<(x217)); + x236 = (x233)+(x235); + x237 = (x236)+(x218); + x238 = (x198)+(x223); + x239 = (uintptr_t)((x238)<(x198)); + x240 = (x239)+(x203); + x241 = (uintptr_t)((x240)<(x203)); + x242 = (x240)+(x225); + x243 = (uintptr_t)((x242)<(x225)); + x244 = (x241)+(x243); + x245 = (x244)+(x208); + x246 = (uintptr_t)((x245)<(x208)); + x247 = (x245)+(x229); + x248 = (uintptr_t)((x247)<(x229)); + x249 = (x246)+(x248); + x250 = (x249)+(x213); + x251 = (uintptr_t)((x250)<(x213)); + x252 = (x250)+(x234); + x253 = (uintptr_t)((x252)<(x234)); + x254 = (x251)+(x253); + x255 = (x254)+(x216); + x256 = (uintptr_t)((x255)<(x216)); + x257 = (x255)+(x237); + x258 = (uintptr_t)((x257)<(x237)); + x259 = (x256)+(x258); + x260 = (x238)*((uintptr_t)15183074304973897243ULL); + x261 = (x260)*((uintptr_t)1152921504606846976ULL); + x262 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x260)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x260)*((uintptr_t)1152921504606846976ULL))>>64); + x263 = (x260)*((uintptr_t)1503914060200516822ULL); + x264 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x260)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x260)*((uintptr_t)1503914060200516822ULL))>>64); + x265 = (x260)*((uintptr_t)6346243789798364141ULL); + x266 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x260)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x260)*((uintptr_t)6346243789798364141ULL))>>64); + x267 = (x266)+(x263); + x268 = (uintptr_t)((x267)<(x266)); + x269 = (x268)+(x264); + x270 = (x238)+(x265); + x271 = (uintptr_t)((x270)<(x238)); + x272 = (x271)+(x242); + x273 = (uintptr_t)((x272)<(x242)); + x274 = (x272)+(x267); + x275 = (uintptr_t)((x274)<(x267)); + x276 = (x273)+(x275); + x277 = (x276)+(x247); + x278 = (uintptr_t)((x277)<(x247)); + x279 = (x277)+(x269); + x280 = (uintptr_t)((x279)<(x269)); + x281 = (x278)+(x280); + x282 = (x281)+(x252); + x283 = (uintptr_t)((x282)<(x252)); + x284 = (x282)+(x261); + x285 = (uintptr_t)((x284)<(x261)); + x286 = (x283)+(x285); + x287 = (x286)+(x257); + x288 = (uintptr_t)((x287)<(x257)); + x289 = (x287)+(x262); + x290 = (uintptr_t)((x289)<(x262)); + x291 = (x288)+(x290); + x292 = (x291)+(x259); + x293 = (x274)-((uintptr_t)6346243789798364141ULL); + x294 = (uintptr_t)((x274)<(x293)); + x295 = (x279)-((uintptr_t)1503914060200516822ULL); + x296 = (uintptr_t)((x279)<(x295)); + x297 = (x295)-(x294); + x298 = (uintptr_t)((x295)<(x297)); + x299 = (x296)+(x298); + x300 = (x284)-(x299); + x301 = (uintptr_t)((x284)<(x300)); + x302 = (x289)-((uintptr_t)1152921504606846976ULL); + x303 = (uintptr_t)((x289)<(x302)); + x304 = (x302)-(x301); + x305 = (uintptr_t)((x302)<(x304)); + x306 = (x303)+(x305); + x307 = (x292)-(x306); + x308 = (uintptr_t)((x292)<(x307)); + x309 = ((uintptr_t)-1ULL)+((uintptr_t)((x308)==((uintptr_t)0ULL))); + x310 = (x309)^((uintptr_t)18446744073709551615ULL); + x311 = ((x274)&(x309))|((x293)&(x310)); + x312 = ((uintptr_t)-1ULL)+((uintptr_t)((x308)==((uintptr_t)0ULL))); + x313 = (x312)^((uintptr_t)18446744073709551615ULL); + x314 = ((x279)&(x312))|((x297)&(x313)); + x315 = ((uintptr_t)-1ULL)+((uintptr_t)((x308)==((uintptr_t)0ULL))); + x316 = (x315)^((uintptr_t)18446744073709551615ULL); + x317 = ((x284)&(x315))|((x300)&(x316)); + x318 = ((uintptr_t)-1ULL)+((uintptr_t)((x308)==((uintptr_t)0ULL))); + x319 = (x318)^((uintptr_t)18446744073709551615ULL); + x320 = ((x289)&(x318))|((x304)&(x319)); + x321 = x311; + x322 = x314; + x323 = x317; + x324 = x320; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x321, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x322, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x323, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x324, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_mul(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_25519_scalar_mul((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_25519_scalar_square(uintptr_t out0, uintptr_t in0) { + uintptr_t x7, x12, x15, x17, x13, x18, x10, x19, x21, x22, x11, x23, x8, x24, x26, x27, x9, x29, x32, x35, x37, x33, x34, x39, x14, x40, x16, x41, x36, x42, x44, x45, x20, x46, x38, x47, x49, x50, x25, x51, x30, x52, x54, x55, x28, x56, x31, x57, x59, x4, x65, x68, x70, x66, x71, x63, x72, x74, x75, x64, x76, x61, x77, x79, x80, x62, x67, x43, x83, x48, x84, x69, x85, x87, x88, x53, x89, x73, x90, x92, x93, x58, x94, x78, x95, x97, x98, x60, x99, x81, x100, x102, x104, x107, x110, x112, x108, x109, x114, x82, x115, x86, x116, x111, x117, x119, x120, x91, x121, x113, x122, x124, x125, x96, x126, x105, x127, x129, x130, x101, x131, x106, x132, x134, x135, x103, x5, x141, x144, x146, x142, x147, x139, x148, x150, x151, x140, x152, x137, x153, x155, x156, x138, x143, x118, x159, x123, x160, x145, x161, x163, x164, x128, x165, x149, x166, x168, x169, x133, x170, x154, x171, x173, x174, x136, x175, x157, x176, x178, x180, x183, x186, x188, x184, x185, x190, x158, x191, x162, x192, x187, x193, x195, x196, x167, x197, x189, x198, x200, x201, x172, x202, x181, x203, x205, x206, x177, x207, x182, x208, x210, x211, x179, x3, x2, x1, x6, x0, x217, x220, x222, x218, x223, x215, x224, x226, x227, x216, x228, x213, x229, x231, x232, x214, x219, x194, x235, x199, x236, x221, x237, x239, x240, x204, x241, x225, x242, x244, x245, x209, x246, x230, x247, x249, x250, x212, x251, x233, x252, x254, x256, x259, x262, x264, x260, x261, x266, x234, x267, x238, x268, x263, x269, x271, x272, x243, x273, x265, x274, x276, x277, x248, x278, x257, x279, x281, x282, x253, x283, x258, x284, x286, x287, x255, x290, x291, x292, x294, x295, x297, x298, x299, x301, x302, x288, x303, x270, x305, x289, x306, x275, x308, x293, x309, x280, x311, x296, x312, x304, x285, x314, x300, x315, x307, x310, x313, x316, x317, x318, x319, x320; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x1; + x5 = x2; + x6 = x3; + x7 = x0; + x8 = (x7)*(x3); + x9 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x3))>>32 : ((__uint128_t)(x7)*(x3))>>64); + x10 = (x7)*(x2); + x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x2))>>32 : ((__uint128_t)(x7)*(x2))>>64); + x12 = (x7)*(x1); + x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x1))>>32 : ((__uint128_t)(x7)*(x1))>>64); + x14 = (x7)*(x0); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x0))>>32 : ((__uint128_t)(x7)*(x0))>>64); + x16 = (x15)+(x12); + x17 = (uintptr_t)((x16)<(x15)); + x18 = (x17)+(x13); + x19 = (uintptr_t)((x18)<(x13)); + x20 = (x18)+(x10); + x21 = (uintptr_t)((x20)<(x10)); + x22 = (x19)+(x21); + x23 = (x22)+(x11); + x24 = (uintptr_t)((x23)<(x11)); + x25 = (x23)+(x8); + x26 = (uintptr_t)((x25)<(x8)); + x27 = (x24)+(x26); + x28 = (x27)+(x9); + x29 = (x14)*((uintptr_t)15183074304973897243ULL); + x30 = (x29)*((uintptr_t)1152921504606846976ULL); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x29)*((uintptr_t)1152921504606846976ULL))>>64); + x32 = (x29)*((uintptr_t)1503914060200516822ULL); + x33 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x29)*((uintptr_t)1503914060200516822ULL))>>64); + x34 = (x29)*((uintptr_t)6346243789798364141ULL); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x29)*((uintptr_t)6346243789798364141ULL))>>64); + x36 = (x35)+(x32); + x37 = (uintptr_t)((x36)<(x35)); + x38 = (x37)+(x33); + x39 = (x14)+(x34); + x40 = (uintptr_t)((x39)<(x14)); + x41 = (x40)+(x16); + x42 = (uintptr_t)((x41)<(x16)); + x43 = (x41)+(x36); + x44 = (uintptr_t)((x43)<(x36)); + x45 = (x42)+(x44); + x46 = (x45)+(x20); + x47 = (uintptr_t)((x46)<(x20)); + x48 = (x46)+(x38); + x49 = (uintptr_t)((x48)<(x38)); + x50 = (x47)+(x49); + x51 = (x50)+(x25); + x52 = (uintptr_t)((x51)<(x25)); + x53 = (x51)+(x30); + x54 = (uintptr_t)((x53)<(x30)); + x55 = (x52)+(x54); + x56 = (x55)+(x28); + x57 = (uintptr_t)((x56)<(x28)); + x58 = (x56)+(x31); + x59 = (uintptr_t)((x58)<(x31)); + x60 = (x57)+(x59); + x61 = (x4)*(x3); + x62 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*(x3))>>32 : ((__uint128_t)(x4)*(x3))>>64); + x63 = (x4)*(x2); + x64 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*(x2))>>32 : ((__uint128_t)(x4)*(x2))>>64); + x65 = (x4)*(x1); + x66 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*(x1))>>32 : ((__uint128_t)(x4)*(x1))>>64); + x67 = (x4)*(x0); + x68 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*(x0))>>32 : ((__uint128_t)(x4)*(x0))>>64); + x69 = (x68)+(x65); + x70 = (uintptr_t)((x69)<(x68)); + x71 = (x70)+(x66); + x72 = (uintptr_t)((x71)<(x66)); + x73 = (x71)+(x63); + x74 = (uintptr_t)((x73)<(x63)); + x75 = (x72)+(x74); + x76 = (x75)+(x64); + x77 = (uintptr_t)((x76)<(x64)); + x78 = (x76)+(x61); + x79 = (uintptr_t)((x78)<(x61)); + x80 = (x77)+(x79); + x81 = (x80)+(x62); + x82 = (x43)+(x67); + x83 = (uintptr_t)((x82)<(x43)); + x84 = (x83)+(x48); + x85 = (uintptr_t)((x84)<(x48)); + x86 = (x84)+(x69); + x87 = (uintptr_t)((x86)<(x69)); + x88 = (x85)+(x87); + x89 = (x88)+(x53); + x90 = (uintptr_t)((x89)<(x53)); + x91 = (x89)+(x73); + x92 = (uintptr_t)((x91)<(x73)); + x93 = (x90)+(x92); + x94 = (x93)+(x58); + x95 = (uintptr_t)((x94)<(x58)); + x96 = (x94)+(x78); + x97 = (uintptr_t)((x96)<(x78)); + x98 = (x95)+(x97); + x99 = (x98)+(x60); + x100 = (uintptr_t)((x99)<(x60)); + x101 = (x99)+(x81); + x102 = (uintptr_t)((x101)<(x81)); + x103 = (x100)+(x102); + x104 = (x82)*((uintptr_t)15183074304973897243ULL); + x105 = (x104)*((uintptr_t)1152921504606846976ULL); + x106 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x104)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x104)*((uintptr_t)1152921504606846976ULL))>>64); + x107 = (x104)*((uintptr_t)1503914060200516822ULL); + x108 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x104)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x104)*((uintptr_t)1503914060200516822ULL))>>64); + x109 = (x104)*((uintptr_t)6346243789798364141ULL); + x110 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x104)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x104)*((uintptr_t)6346243789798364141ULL))>>64); + x111 = (x110)+(x107); + x112 = (uintptr_t)((x111)<(x110)); + x113 = (x112)+(x108); + x114 = (x82)+(x109); + x115 = (uintptr_t)((x114)<(x82)); + x116 = (x115)+(x86); + x117 = (uintptr_t)((x116)<(x86)); + x118 = (x116)+(x111); + x119 = (uintptr_t)((x118)<(x111)); + x120 = (x117)+(x119); + x121 = (x120)+(x91); + x122 = (uintptr_t)((x121)<(x91)); + x123 = (x121)+(x113); + x124 = (uintptr_t)((x123)<(x113)); + x125 = (x122)+(x124); + x126 = (x125)+(x96); + x127 = (uintptr_t)((x126)<(x96)); + x128 = (x126)+(x105); + x129 = (uintptr_t)((x128)<(x105)); + x130 = (x127)+(x129); + x131 = (x130)+(x101); + x132 = (uintptr_t)((x131)<(x101)); + x133 = (x131)+(x106); + x134 = (uintptr_t)((x133)<(x106)); + x135 = (x132)+(x134); + x136 = (x135)+(x103); + x137 = (x5)*(x3); + x138 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*(x3))>>32 : ((__uint128_t)(x5)*(x3))>>64); + x139 = (x5)*(x2); + x140 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*(x2))>>32 : ((__uint128_t)(x5)*(x2))>>64); + x141 = (x5)*(x1); + x142 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*(x1))>>32 : ((__uint128_t)(x5)*(x1))>>64); + x143 = (x5)*(x0); + x144 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*(x0))>>32 : ((__uint128_t)(x5)*(x0))>>64); + x145 = (x144)+(x141); + x146 = (uintptr_t)((x145)<(x144)); + x147 = (x146)+(x142); + x148 = (uintptr_t)((x147)<(x142)); + x149 = (x147)+(x139); + x150 = (uintptr_t)((x149)<(x139)); + x151 = (x148)+(x150); + x152 = (x151)+(x140); + x153 = (uintptr_t)((x152)<(x140)); + x154 = (x152)+(x137); + x155 = (uintptr_t)((x154)<(x137)); + x156 = (x153)+(x155); + x157 = (x156)+(x138); + x158 = (x118)+(x143); + x159 = (uintptr_t)((x158)<(x118)); + x160 = (x159)+(x123); + x161 = (uintptr_t)((x160)<(x123)); + x162 = (x160)+(x145); + x163 = (uintptr_t)((x162)<(x145)); + x164 = (x161)+(x163); + x165 = (x164)+(x128); + x166 = (uintptr_t)((x165)<(x128)); + x167 = (x165)+(x149); + x168 = (uintptr_t)((x167)<(x149)); + x169 = (x166)+(x168); + x170 = (x169)+(x133); + x171 = (uintptr_t)((x170)<(x133)); + x172 = (x170)+(x154); + x173 = (uintptr_t)((x172)<(x154)); + x174 = (x171)+(x173); + x175 = (x174)+(x136); + x176 = (uintptr_t)((x175)<(x136)); + x177 = (x175)+(x157); + x178 = (uintptr_t)((x177)<(x157)); + x179 = (x176)+(x178); + x180 = (x158)*((uintptr_t)15183074304973897243ULL); + x181 = (x180)*((uintptr_t)1152921504606846976ULL); + x182 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x180)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x180)*((uintptr_t)1152921504606846976ULL))>>64); + x183 = (x180)*((uintptr_t)1503914060200516822ULL); + x184 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x180)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x180)*((uintptr_t)1503914060200516822ULL))>>64); + x185 = (x180)*((uintptr_t)6346243789798364141ULL); + x186 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x180)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x180)*((uintptr_t)6346243789798364141ULL))>>64); + x187 = (x186)+(x183); + x188 = (uintptr_t)((x187)<(x186)); + x189 = (x188)+(x184); + x190 = (x158)+(x185); + x191 = (uintptr_t)((x190)<(x158)); + x192 = (x191)+(x162); + x193 = (uintptr_t)((x192)<(x162)); + x194 = (x192)+(x187); + x195 = (uintptr_t)((x194)<(x187)); + x196 = (x193)+(x195); + x197 = (x196)+(x167); + x198 = (uintptr_t)((x197)<(x167)); + x199 = (x197)+(x189); + x200 = (uintptr_t)((x199)<(x189)); + x201 = (x198)+(x200); + x202 = (x201)+(x172); + x203 = (uintptr_t)((x202)<(x172)); + x204 = (x202)+(x181); + x205 = (uintptr_t)((x204)<(x181)); + x206 = (x203)+(x205); + x207 = (x206)+(x177); + x208 = (uintptr_t)((x207)<(x177)); + x209 = (x207)+(x182); + x210 = (uintptr_t)((x209)<(x182)); + x211 = (x208)+(x210); + x212 = (x211)+(x179); + x213 = (x6)*(x3); + x214 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x3))>>32 : ((__uint128_t)(x6)*(x3))>>64); + x215 = (x6)*(x2); + x216 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x2))>>32 : ((__uint128_t)(x6)*(x2))>>64); + x217 = (x6)*(x1); + x218 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x1))>>32 : ((__uint128_t)(x6)*(x1))>>64); + x219 = (x6)*(x0); + x220 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x0))>>32 : ((__uint128_t)(x6)*(x0))>>64); + x221 = (x220)+(x217); + x222 = (uintptr_t)((x221)<(x220)); + x223 = (x222)+(x218); + x224 = (uintptr_t)((x223)<(x218)); + x225 = (x223)+(x215); + x226 = (uintptr_t)((x225)<(x215)); + x227 = (x224)+(x226); + x228 = (x227)+(x216); + x229 = (uintptr_t)((x228)<(x216)); + x230 = (x228)+(x213); + x231 = (uintptr_t)((x230)<(x213)); + x232 = (x229)+(x231); + x233 = (x232)+(x214); + x234 = (x194)+(x219); + x235 = (uintptr_t)((x234)<(x194)); + x236 = (x235)+(x199); + x237 = (uintptr_t)((x236)<(x199)); + x238 = (x236)+(x221); + x239 = (uintptr_t)((x238)<(x221)); + x240 = (x237)+(x239); + x241 = (x240)+(x204); + x242 = (uintptr_t)((x241)<(x204)); + x243 = (x241)+(x225); + x244 = (uintptr_t)((x243)<(x225)); + x245 = (x242)+(x244); + x246 = (x245)+(x209); + x247 = (uintptr_t)((x246)<(x209)); + x248 = (x246)+(x230); + x249 = (uintptr_t)((x248)<(x230)); + x250 = (x247)+(x249); + x251 = (x250)+(x212); + x252 = (uintptr_t)((x251)<(x212)); + x253 = (x251)+(x233); + x254 = (uintptr_t)((x253)<(x233)); + x255 = (x252)+(x254); + x256 = (x234)*((uintptr_t)15183074304973897243ULL); + x257 = (x256)*((uintptr_t)1152921504606846976ULL); + x258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x256)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x256)*((uintptr_t)1152921504606846976ULL))>>64); + x259 = (x256)*((uintptr_t)1503914060200516822ULL); + x260 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x256)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x256)*((uintptr_t)1503914060200516822ULL))>>64); + x261 = (x256)*((uintptr_t)6346243789798364141ULL); + x262 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x256)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x256)*((uintptr_t)6346243789798364141ULL))>>64); + x263 = (x262)+(x259); + x264 = (uintptr_t)((x263)<(x262)); + x265 = (x264)+(x260); + x266 = (x234)+(x261); + x267 = (uintptr_t)((x266)<(x234)); + x268 = (x267)+(x238); + x269 = (uintptr_t)((x268)<(x238)); + x270 = (x268)+(x263); + x271 = (uintptr_t)((x270)<(x263)); + x272 = (x269)+(x271); + x273 = (x272)+(x243); + x274 = (uintptr_t)((x273)<(x243)); + x275 = (x273)+(x265); + x276 = (uintptr_t)((x275)<(x265)); + x277 = (x274)+(x276); + x278 = (x277)+(x248); + x279 = (uintptr_t)((x278)<(x248)); + x280 = (x278)+(x257); + x281 = (uintptr_t)((x280)<(x257)); + x282 = (x279)+(x281); + x283 = (x282)+(x253); + x284 = (uintptr_t)((x283)<(x253)); + x285 = (x283)+(x258); + x286 = (uintptr_t)((x285)<(x258)); + x287 = (x284)+(x286); + x288 = (x287)+(x255); + x289 = (x270)-((uintptr_t)6346243789798364141ULL); + x290 = (uintptr_t)((x270)<(x289)); + x291 = (x275)-((uintptr_t)1503914060200516822ULL); + x292 = (uintptr_t)((x275)<(x291)); + x293 = (x291)-(x290); + x294 = (uintptr_t)((x291)<(x293)); + x295 = (x292)+(x294); + x296 = (x280)-(x295); + x297 = (uintptr_t)((x280)<(x296)); + x298 = (x285)-((uintptr_t)1152921504606846976ULL); + x299 = (uintptr_t)((x285)<(x298)); + x300 = (x298)-(x297); + x301 = (uintptr_t)((x298)<(x300)); + x302 = (x299)+(x301); + x303 = (x288)-(x302); + x304 = (uintptr_t)((x288)<(x303)); + x305 = ((uintptr_t)-1ULL)+((uintptr_t)((x304)==((uintptr_t)0ULL))); + x306 = (x305)^((uintptr_t)18446744073709551615ULL); + x307 = ((x270)&(x305))|((x289)&(x306)); + x308 = ((uintptr_t)-1ULL)+((uintptr_t)((x304)==((uintptr_t)0ULL))); + x309 = (x308)^((uintptr_t)18446744073709551615ULL); + x310 = ((x275)&(x308))|((x293)&(x309)); + x311 = ((uintptr_t)-1ULL)+((uintptr_t)((x304)==((uintptr_t)0ULL))); + x312 = (x311)^((uintptr_t)18446744073709551615ULL); + x313 = ((x280)&(x311))|((x296)&(x312)); + x314 = ((uintptr_t)-1ULL)+((uintptr_t)((x304)==((uintptr_t)0ULL))); + x315 = (x314)^((uintptr_t)18446744073709551615ULL); + x316 = ((x285)&(x314))|((x300)&(x315)); + x317 = x307; + x318 = x310; + x319 = x313; + x320 = x316; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x317, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x318, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x319, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x320, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_square(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_25519_scalar_square((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_25519_scalar_add(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x4, x0, x9, x1, x5, x11, x2, x6, x13, x3, x7, x17, x15, x20, x8, x23, x16, x24, x10, x26, x18, x27, x12, x29, x19, x30, x22, x14, x32, x21, x33, x25, x28, x31, x34, x35, x36, x37, x38; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = (x0)+(x4); + x9 = ((uintptr_t)((x8)<(x0)))+(x1); + x10 = (x9)+(x5); + x11 = (((uintptr_t)((x9)<(x1)))+((uintptr_t)((x10)<(x5))))+(x2); + x12 = (x11)+(x6); + x13 = (((uintptr_t)((x11)<(x2)))+((uintptr_t)((x12)<(x6))))+(x3); + x14 = (x13)+(x7); + x15 = ((uintptr_t)((x13)<(x3)))+((uintptr_t)((x14)<(x7))); + x16 = (x8)-((uintptr_t)6346243789798364141ULL); + x17 = (x10)-((uintptr_t)1503914060200516822ULL); + x18 = (x17)-((uintptr_t)((x8)<(x16))); + x19 = (x12)-(((uintptr_t)((x10)<(x17)))+((uintptr_t)((x17)<(x18)))); + x20 = (x14)-((uintptr_t)1152921504606846976ULL); + x21 = (x20)-((uintptr_t)((x12)<(x19))); + x22 = (uintptr_t)((x15)<((x15)-(((uintptr_t)((x14)<(x20)))+((uintptr_t)((x20)<(x21)))))); + x23 = ((uintptr_t)-1ULL)+((uintptr_t)((x22)==((uintptr_t)0ULL))); + x24 = (x23)^((uintptr_t)18446744073709551615ULL); + x25 = ((x8)&(x23))|((x16)&(x24)); + x26 = ((uintptr_t)-1ULL)+((uintptr_t)((x22)==((uintptr_t)0ULL))); + x27 = (x26)^((uintptr_t)18446744073709551615ULL); + x28 = ((x10)&(x26))|((x18)&(x27)); + x29 = ((uintptr_t)-1ULL)+((uintptr_t)((x22)==((uintptr_t)0ULL))); + x30 = (x29)^((uintptr_t)18446744073709551615ULL); + x31 = ((x12)&(x29))|((x19)&(x30)); + x32 = ((uintptr_t)-1ULL)+((uintptr_t)((x22)==((uintptr_t)0ULL))); + x33 = (x32)^((uintptr_t)18446744073709551615ULL); + x34 = ((x14)&(x32))|((x21)&(x33)); + x35 = x25; + x36 = x28; + x37 = x31; + x38 = x34; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x35, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x36, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x37, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x38, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_add(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_25519_scalar_add((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_25519_scalar_sub(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x4, x5, x0, x6, x1, x9, x7, x2, x11, x3, x13, x8, x17, x10, x12, x14, x15, x16, x18, x19, x20, x21, x22, x23, x24; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = (x0)-(x4); + x9 = (x1)-(x5); + x10 = (x9)-((uintptr_t)((x0)<(x8))); + x11 = (x2)-(x6); + x12 = (x11)-(((uintptr_t)((x1)<(x9)))+((uintptr_t)((x9)<(x10)))); + x13 = (x3)-(x7); + x14 = (x13)-(((uintptr_t)((x2)<(x11)))+((uintptr_t)((x11)<(x12)))); + x15 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)((x3)<(x13)))+((uintptr_t)((x13)<(x14))))==((uintptr_t)0ULL))); + x16 = (x8)+((x15)&((uintptr_t)6346243789798364141ULL)); + x17 = ((uintptr_t)((x16)<(x8)))+(x10); + x18 = (x17)+((x15)&((uintptr_t)1503914060200516822ULL)); + x19 = (((uintptr_t)((x17)<(x10)))+((uintptr_t)((x18)<((x15)&((uintptr_t)1503914060200516822ULL)))))+(x12); + x20 = (((uintptr_t)((x19)<(x12)))+(x14))+((x15)&((uintptr_t)1152921504606846976ULL)); + x21 = x16; + x22 = x18; + x23 = x19; + x24 = x20; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x21, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x22, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x23, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x24, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_sub(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_25519_scalar_sub((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_25519_scalar_opp(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x1, x2, x5, x3, x7, x9, x4, x13, x6, x8, x10, x11, x12, x14, x15, x16, x17, x18, x19, x20; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = ((uintptr_t)0ULL)-(x0); + x5 = ((uintptr_t)0ULL)-(x1); + x6 = (x5)-((uintptr_t)(((uintptr_t)0ULL)<(x4))); + x7 = ((uintptr_t)0ULL)-(x2); + x8 = (x7)-(((uintptr_t)(((uintptr_t)0ULL)<(x5)))+((uintptr_t)((x5)<(x6)))); + x9 = ((uintptr_t)0ULL)-(x3); + x10 = (x9)-(((uintptr_t)(((uintptr_t)0ULL)<(x7)))+((uintptr_t)((x7)<(x8)))); + x11 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)(((uintptr_t)0ULL)<(x9)))+((uintptr_t)((x9)<(x10))))==((uintptr_t)0ULL))); + x12 = (x4)+((x11)&((uintptr_t)6346243789798364141ULL)); + x13 = ((uintptr_t)((x12)<(x4)))+(x6); + x14 = (x13)+((x11)&((uintptr_t)1503914060200516822ULL)); + x15 = (((uintptr_t)((x13)<(x6)))+((uintptr_t)((x14)<((x11)&((uintptr_t)1503914060200516822ULL)))))+(x8); + x16 = (((uintptr_t)((x15)<(x8)))+(x10))+((x11)&((uintptr_t)1152921504606846976ULL)); + x17 = x12; + x18 = x14; + x19 = x15; + x20 = x16; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x17, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x18, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x19, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x20, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_opp(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_25519_scalar_opp((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_25519_scalar_from_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x9, x5, x4, x10, x1, x12, x20, x16, x14, x23, x15, x13, x11, x8, x21, x25, x6, x22, x19, x27, x7, x17, x2, x24, x26, x28, x38, x34, x30, x41, x31, x39, x43, x32, x40, x37, x45, x33, x29, x18, x35, x3, x42, x44, x46, x55, x48, x58, x49, x56, x60, x50, x57, x54, x62, x51, x47, x36, x53, x52, x66, x69, x59, x72, x65, x73, x61, x75, x67, x76, x63, x78, x68, x79, x71, x64, x81, x70, x82, x74, x77, x80, x83, x84, x85, x86, x87; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x0; + x5 = (x4)*((uintptr_t)15183074304973897243ULL); + x6 = (x5)*((uintptr_t)1152921504606846976ULL); + x7 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)1152921504606846976ULL))>>64); + x8 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)1503914060200516822ULL))>>64); + x9 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)6346243789798364141ULL))>>64); + x10 = (x9)+((x5)*((uintptr_t)1503914060200516822ULL)); + x11 = (uintptr_t)((x10)<(x9)); + x12 = ((uintptr_t)(((x4)+((x5)*((uintptr_t)6346243789798364141ULL)))<(x4)))+(x10); + x13 = (uintptr_t)((x12)<(x10)); + x14 = (x12)+(x1); + x15 = (uintptr_t)((x14)<(x12)); + x16 = (x14)*((uintptr_t)15183074304973897243ULL); + x17 = (x16)*((uintptr_t)1152921504606846976ULL); + x18 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)1152921504606846976ULL))>>64); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)1503914060200516822ULL))>>64); + x20 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)6346243789798364141ULL))>>64); + x21 = (x20)+((x16)*((uintptr_t)1503914060200516822ULL)); + x22 = (uintptr_t)((x21)<(x20)); + x23 = ((uintptr_t)(((x14)+((x16)*((uintptr_t)6346243789798364141ULL)))<(x14)))+((x15)+((x13)+((x11)+(x8)))); + x24 = (x23)+(x21); + x25 = (((uintptr_t)((x23)<((x15)+((x13)+((x11)+(x8))))))+((uintptr_t)((x24)<(x21))))+(x6); + x26 = (x25)+((x22)+(x19)); + x27 = (((uintptr_t)((x25)<(x6)))+((uintptr_t)((x26)<((x22)+(x19)))))+(x7); + x28 = (x27)+(x17); + x29 = ((uintptr_t)((x27)<(x7)))+((uintptr_t)((x28)<(x17))); + x30 = (x24)+(x2); + x31 = ((uintptr_t)((x30)<(x24)))+(x26); + x32 = ((uintptr_t)((x31)<(x26)))+(x28); + x33 = (uintptr_t)((x32)<(x28)); + x34 = (x30)*((uintptr_t)15183074304973897243ULL); + x35 = (x34)*((uintptr_t)1152921504606846976ULL); + x36 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x34)*((uintptr_t)1152921504606846976ULL))>>64); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x34)*((uintptr_t)1503914060200516822ULL))>>64); + x38 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x34)*((uintptr_t)6346243789798364141ULL))>>64); + x39 = (x38)+((x34)*((uintptr_t)1503914060200516822ULL)); + x40 = (uintptr_t)((x39)<(x38)); + x41 = ((uintptr_t)(((x30)+((x34)*((uintptr_t)6346243789798364141ULL)))<(x30)))+(x31); + x42 = (x41)+(x39); + x43 = (((uintptr_t)((x41)<(x31)))+((uintptr_t)((x42)<(x39))))+(x32); + x44 = (x43)+((x40)+(x37)); + x45 = (((uintptr_t)((x43)<(x32)))+((uintptr_t)((x44)<((x40)+(x37)))))+((x33)+((x29)+(x18))); + x46 = (x45)+(x35); + x47 = ((uintptr_t)((x45)<((x33)+((x29)+(x18)))))+((uintptr_t)((x46)<(x35))); + x48 = (x42)+(x3); + x49 = ((uintptr_t)((x48)<(x42)))+(x44); + x50 = ((uintptr_t)((x49)<(x44)))+(x46); + x51 = (uintptr_t)((x50)<(x46)); + x52 = (x48)*((uintptr_t)15183074304973897243ULL); + x53 = (x52)*((uintptr_t)1152921504606846976ULL); + x54 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x52)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x52)*((uintptr_t)1503914060200516822ULL))>>64); + x55 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x52)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x52)*((uintptr_t)6346243789798364141ULL))>>64); + x56 = (x55)+((x52)*((uintptr_t)1503914060200516822ULL)); + x57 = (uintptr_t)((x56)<(x55)); + x58 = ((uintptr_t)(((x48)+((x52)*((uintptr_t)6346243789798364141ULL)))<(x48)))+(x49); + x59 = (x58)+(x56); + x60 = (((uintptr_t)((x58)<(x49)))+((uintptr_t)((x59)<(x56))))+(x50); + x61 = (x60)+((x57)+(x54)); + x62 = (((uintptr_t)((x60)<(x50)))+((uintptr_t)((x61)<((x57)+(x54)))))+((x51)+((x47)+(x36))); + x63 = (x62)+(x53); + x64 = (((uintptr_t)((x62)<((x51)+((x47)+(x36)))))+((uintptr_t)((x63)<(x53))))+((uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x52)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x52)*((uintptr_t)1152921504606846976ULL))>>64)); + x65 = (x59)-((uintptr_t)6346243789798364141ULL); + x66 = (x61)-((uintptr_t)1503914060200516822ULL); + x67 = (x66)-((uintptr_t)((x59)<(x65))); + x68 = (x63)-(((uintptr_t)((x61)<(x66)))+((uintptr_t)((x66)<(x67)))); + x69 = (x64)-((uintptr_t)1152921504606846976ULL); + x70 = (x69)-((uintptr_t)((x63)<(x68))); + x71 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(((uintptr_t)((x64)<(x69)))+((uintptr_t)((x69)<(x70)))))); + x72 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x73 = (x72)^((uintptr_t)18446744073709551615ULL); + x74 = ((x59)&(x72))|((x65)&(x73)); + x75 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x76 = (x75)^((uintptr_t)18446744073709551615ULL); + x77 = ((x61)&(x75))|((x67)&(x76)); + x78 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x79 = (x78)^((uintptr_t)18446744073709551615ULL); + x80 = ((x63)&(x78))|((x68)&(x79)); + x81 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x82 = (x81)^((uintptr_t)18446744073709551615ULL); + x83 = ((x64)&(x81))|((x70)&(x82)); + x84 = x74; + x85 = x77; + x86 = x80; + x87 = x83; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x84, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x85, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x86, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x87, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_from_montgomery(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_25519_scalar_from_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_25519_scalar_to_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x1, x2, x3, x0, x7, x14, x16, x12, x10, x18, x11, x8, x25, x21, x13, x28, x15, x26, x30, x17, x27, x24, x32, x19, x22, x40, x42, x39, x37, x44, x38, x35, x4, x29, x48, x31, x41, x50, x33, x43, x52, x34, x20, x9, x23, x45, x59, x55, x47, x62, x49, x60, x64, x51, x61, x58, x66, x53, x56, x74, x76, x73, x71, x78, x72, x69, x5, x63, x82, x65, x75, x84, x67, x77, x86, x68, x54, x46, x36, x57, x79, x93, x89, x81, x96, x83, x94, x98, x85, x95, x92, x100, x87, x90, x107, x109, x106, x104, x97, x114, x99, x108, x116, x101, x110, x123, x113, x126, x115, x124, x128, x117, x125, x122, x130, x121, x118, x102, x88, x80, x70, x91, x119, x111, x105, x112, x103, x6, x120, x134, x137, x127, x140, x133, x141, x129, x143, x135, x144, x131, x146, x136, x147, x139, x132, x149, x138, x150, x142, x145, x148, x151, x152, x153, x154, x155; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x1; + x5 = x2; + x6 = x3; + x7 = x0; + x8 = (x7)*((uintptr_t)259310039853996605ULL); + x9 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)259310039853996605ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)259310039853996605ULL))>>64); + x10 = (x7)*((uintptr_t)14910419812499177061ULL); + x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)14910419812499177061ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)14910419812499177061ULL))>>64); + x12 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)14991950615390032711ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)14991950615390032711ULL))>>64); + x13 = (x7)*((uintptr_t)11819153939886771969ULL); + x14 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)11819153939886771969ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)11819153939886771969ULL))>>64); + x15 = (x14)+((x7)*((uintptr_t)14991950615390032711ULL)); + x16 = ((uintptr_t)((x15)<(x14)))+(x12); + x17 = (x16)+(x10); + x18 = (((uintptr_t)((x16)<(x12)))+((uintptr_t)((x17)<(x10))))+(x11); + x19 = (x18)+(x8); + x20 = ((uintptr_t)((x18)<(x11)))+((uintptr_t)((x19)<(x8))); + x21 = (x13)*((uintptr_t)15183074304973897243ULL); + x22 = (x21)*((uintptr_t)1152921504606846976ULL); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)1152921504606846976ULL))>>64); + x24 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)1503914060200516822ULL))>>64); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)6346243789798364141ULL))>>64); + x26 = (x25)+((x21)*((uintptr_t)1503914060200516822ULL)); + x27 = (uintptr_t)((x26)<(x25)); + x28 = ((uintptr_t)(((x13)+((x21)*((uintptr_t)6346243789798364141ULL)))<(x13)))+(x15); + x29 = (x28)+(x26); + x30 = (((uintptr_t)((x28)<(x15)))+((uintptr_t)((x29)<(x26))))+(x17); + x31 = (x30)+((x27)+(x24)); + x32 = (((uintptr_t)((x30)<(x17)))+((uintptr_t)((x31)<((x27)+(x24)))))+(x19); + x33 = (x32)+(x22); + x34 = ((uintptr_t)((x32)<(x19)))+((uintptr_t)((x33)<(x22))); + x35 = (x4)*((uintptr_t)259310039853996605ULL); + x36 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*((uintptr_t)259310039853996605ULL))>>32 : ((__uint128_t)(x4)*((uintptr_t)259310039853996605ULL))>>64); + x37 = (x4)*((uintptr_t)14910419812499177061ULL); + x38 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*((uintptr_t)14910419812499177061ULL))>>32 : ((__uint128_t)(x4)*((uintptr_t)14910419812499177061ULL))>>64); + x39 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*((uintptr_t)14991950615390032711ULL))>>32 : ((__uint128_t)(x4)*((uintptr_t)14991950615390032711ULL))>>64); + x40 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*((uintptr_t)11819153939886771969ULL))>>32 : ((__uint128_t)(x4)*((uintptr_t)11819153939886771969ULL))>>64); + x41 = (x40)+((x4)*((uintptr_t)14991950615390032711ULL)); + x42 = ((uintptr_t)((x41)<(x40)))+(x39); + x43 = (x42)+(x37); + x44 = (((uintptr_t)((x42)<(x39)))+((uintptr_t)((x43)<(x37))))+(x38); + x45 = (x44)+(x35); + x46 = ((uintptr_t)((x44)<(x38)))+((uintptr_t)((x45)<(x35))); + x47 = (x29)+((x4)*((uintptr_t)11819153939886771969ULL)); + x48 = ((uintptr_t)((x47)<(x29)))+(x31); + x49 = (x48)+(x41); + x50 = (((uintptr_t)((x48)<(x31)))+((uintptr_t)((x49)<(x41))))+(x33); + x51 = (x50)+(x43); + x52 = (((uintptr_t)((x50)<(x33)))+((uintptr_t)((x51)<(x43))))+(((x34)+((x20)+(x9)))+(x23)); + x53 = (x52)+(x45); + x54 = ((uintptr_t)((x52)<(((x34)+((x20)+(x9)))+(x23))))+((uintptr_t)((x53)<(x45))); + x55 = (x47)*((uintptr_t)15183074304973897243ULL); + x56 = (x55)*((uintptr_t)1152921504606846976ULL); + x57 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x55)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x55)*((uintptr_t)1152921504606846976ULL))>>64); + x58 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x55)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x55)*((uintptr_t)1503914060200516822ULL))>>64); + x59 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x55)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x55)*((uintptr_t)6346243789798364141ULL))>>64); + x60 = (x59)+((x55)*((uintptr_t)1503914060200516822ULL)); + x61 = (uintptr_t)((x60)<(x59)); + x62 = ((uintptr_t)(((x47)+((x55)*((uintptr_t)6346243789798364141ULL)))<(x47)))+(x49); + x63 = (x62)+(x60); + x64 = (((uintptr_t)((x62)<(x49)))+((uintptr_t)((x63)<(x60))))+(x51); + x65 = (x64)+((x61)+(x58)); + x66 = (((uintptr_t)((x64)<(x51)))+((uintptr_t)((x65)<((x61)+(x58)))))+(x53); + x67 = (x66)+(x56); + x68 = ((uintptr_t)((x66)<(x53)))+((uintptr_t)((x67)<(x56))); + x69 = (x5)*((uintptr_t)259310039853996605ULL); + x70 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)259310039853996605ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)259310039853996605ULL))>>64); + x71 = (x5)*((uintptr_t)14910419812499177061ULL); + x72 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)14910419812499177061ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)14910419812499177061ULL))>>64); + x73 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)14991950615390032711ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)14991950615390032711ULL))>>64); + x74 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)11819153939886771969ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)11819153939886771969ULL))>>64); + x75 = (x74)+((x5)*((uintptr_t)14991950615390032711ULL)); + x76 = ((uintptr_t)((x75)<(x74)))+(x73); + x77 = (x76)+(x71); + x78 = (((uintptr_t)((x76)<(x73)))+((uintptr_t)((x77)<(x71))))+(x72); + x79 = (x78)+(x69); + x80 = ((uintptr_t)((x78)<(x72)))+((uintptr_t)((x79)<(x69))); + x81 = (x63)+((x5)*((uintptr_t)11819153939886771969ULL)); + x82 = ((uintptr_t)((x81)<(x63)))+(x65); + x83 = (x82)+(x75); + x84 = (((uintptr_t)((x82)<(x65)))+((uintptr_t)((x83)<(x75))))+(x67); + x85 = (x84)+(x77); + x86 = (((uintptr_t)((x84)<(x67)))+((uintptr_t)((x85)<(x77))))+(((x68)+((x54)+((x46)+(x36))))+(x57)); + x87 = (x86)+(x79); + x88 = ((uintptr_t)((x86)<(((x68)+((x54)+((x46)+(x36))))+(x57))))+((uintptr_t)((x87)<(x79))); + x89 = (x81)*((uintptr_t)15183074304973897243ULL); + x90 = (x89)*((uintptr_t)1152921504606846976ULL); + x91 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x89)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x89)*((uintptr_t)1152921504606846976ULL))>>64); + x92 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x89)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x89)*((uintptr_t)1503914060200516822ULL))>>64); + x93 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x89)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x89)*((uintptr_t)6346243789798364141ULL))>>64); + x94 = (x93)+((x89)*((uintptr_t)1503914060200516822ULL)); + x95 = (uintptr_t)((x94)<(x93)); + x96 = ((uintptr_t)(((x81)+((x89)*((uintptr_t)6346243789798364141ULL)))<(x81)))+(x83); + x97 = (x96)+(x94); + x98 = (((uintptr_t)((x96)<(x83)))+((uintptr_t)((x97)<(x94))))+(x85); + x99 = (x98)+((x95)+(x92)); + x100 = (((uintptr_t)((x98)<(x85)))+((uintptr_t)((x99)<((x95)+(x92)))))+(x87); + x101 = (x100)+(x90); + x102 = ((uintptr_t)((x100)<(x87)))+((uintptr_t)((x101)<(x90))); + x103 = (x6)*((uintptr_t)259310039853996605ULL); + x104 = (x6)*((uintptr_t)14910419812499177061ULL); + x105 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)14910419812499177061ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)14910419812499177061ULL))>>64); + x106 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)14991950615390032711ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)14991950615390032711ULL))>>64); + x107 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)11819153939886771969ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)11819153939886771969ULL))>>64); + x108 = (x107)+((x6)*((uintptr_t)14991950615390032711ULL)); + x109 = ((uintptr_t)((x108)<(x107)))+(x106); + x110 = (x109)+(x104); + x111 = (((uintptr_t)((x109)<(x106)))+((uintptr_t)((x110)<(x104))))+(x105); + x112 = (x111)+(x103); + x113 = (x97)+((x6)*((uintptr_t)11819153939886771969ULL)); + x114 = ((uintptr_t)((x113)<(x97)))+(x99); + x115 = (x114)+(x108); + x116 = (((uintptr_t)((x114)<(x99)))+((uintptr_t)((x115)<(x108))))+(x101); + x117 = (x116)+(x110); + x118 = (((uintptr_t)((x116)<(x101)))+((uintptr_t)((x117)<(x110))))+(((x102)+((x88)+((x80)+(x70))))+(x91)); + x119 = (x118)+(x112); + x120 = (x113)*((uintptr_t)15183074304973897243ULL); + x121 = (x120)*((uintptr_t)1152921504606846976ULL); + x122 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x120)*((uintptr_t)1503914060200516822ULL))>>32 : ((__uint128_t)(x120)*((uintptr_t)1503914060200516822ULL))>>64); + x123 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x120)*((uintptr_t)6346243789798364141ULL))>>32 : ((__uint128_t)(x120)*((uintptr_t)6346243789798364141ULL))>>64); + x124 = (x123)+((x120)*((uintptr_t)1503914060200516822ULL)); + x125 = (uintptr_t)((x124)<(x123)); + x126 = ((uintptr_t)(((x113)+((x120)*((uintptr_t)6346243789798364141ULL)))<(x113)))+(x115); + x127 = (x126)+(x124); + x128 = (((uintptr_t)((x126)<(x115)))+((uintptr_t)((x127)<(x124))))+(x117); + x129 = (x128)+((x125)+(x122)); + x130 = (((uintptr_t)((x128)<(x117)))+((uintptr_t)((x129)<((x125)+(x122)))))+(x119); + x131 = (x130)+(x121); + x132 = ((((uintptr_t)((x130)<(x119)))+((uintptr_t)((x131)<(x121))))+((((uintptr_t)((x118)<(((x102)+((x88)+((x80)+(x70))))+(x91))))+((uintptr_t)((x119)<(x112))))+((((uintptr_t)((x111)<(x105)))+((uintptr_t)((x112)<(x103))))+((uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)259310039853996605ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)259310039853996605ULL))>>64)))))+((uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x120)*((uintptr_t)1152921504606846976ULL))>>32 : ((__uint128_t)(x120)*((uintptr_t)1152921504606846976ULL))>>64)); + x133 = (x127)-((uintptr_t)6346243789798364141ULL); + x134 = (x129)-((uintptr_t)1503914060200516822ULL); + x135 = (x134)-((uintptr_t)((x127)<(x133))); + x136 = (x131)-(((uintptr_t)((x129)<(x134)))+((uintptr_t)((x134)<(x135)))); + x137 = (x132)-((uintptr_t)1152921504606846976ULL); + x138 = (x137)-((uintptr_t)((x131)<(x136))); + x139 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(((uintptr_t)((x132)<(x137)))+((uintptr_t)((x137)<(x138)))))); + x140 = ((uintptr_t)-1ULL)+((uintptr_t)((x139)==((uintptr_t)0ULL))); + x141 = (x140)^((uintptr_t)18446744073709551615ULL); + x142 = ((x127)&(x140))|((x133)&(x141)); + x143 = ((uintptr_t)-1ULL)+((uintptr_t)((x139)==((uintptr_t)0ULL))); + x144 = (x143)^((uintptr_t)18446744073709551615ULL); + x145 = ((x129)&(x143))|((x135)&(x144)); + x146 = ((uintptr_t)-1ULL)+((uintptr_t)((x139)==((uintptr_t)0ULL))); + x147 = (x146)^((uintptr_t)18446744073709551615ULL); + x148 = ((x131)&(x146))|((x136)&(x147)); + x149 = ((uintptr_t)-1ULL)+((uintptr_t)((x139)==((uintptr_t)0ULL))); + x150 = (x149)^((uintptr_t)18446744073709551615ULL); + x151 = ((x132)&(x149))|((x138)&(x150)); + x152 = x142; + x153 = x145; + x154 = x148; + x155 = x151; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x152, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x153, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x154, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x155, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_to_montgomery(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_25519_scalar_to_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffffffffffff] + */ +static +uintptr_t internal_fiat_25519_scalar_nonzero(uintptr_t in0) { + uintptr_t x0, x1, x2, x3, x4, out0, x5; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = (x0)|((x1)|((x2)|(x3))); + x5 = x4; + out0 = x5; + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_nonzero(uint64_t* out1, const uint64_t arg1[4]) { + *out1 = (uint64_t)internal_fiat_25519_scalar_nonzero((uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0x1] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_25519_scalar_selectznz(uintptr_t out0, uintptr_t in0, uintptr_t in1, uintptr_t in2) { + uintptr_t x4, x8, x0, x9, x5, x11, x1, x12, x6, x14, x2, x15, x7, x17, x3, x18, x10, x13, x16, x19, x20, x21, x22, x23; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x5 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x6 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x7 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x9 = (x8)^((uintptr_t)18446744073709551615ULL); + x10 = ((x4)&(x8))|((x0)&(x9)); + x11 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x12 = (x11)^((uintptr_t)18446744073709551615ULL); + x13 = ((x5)&(x11))|((x1)&(x12)); + x14 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x15 = (x14)^((uintptr_t)18446744073709551615ULL); + x16 = ((x6)&(x14))|((x2)&(x15)); + x17 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x18 = (x17)^((uintptr_t)18446744073709551615ULL); + x19 = ((x7)&(x17))|((x3)&(x18)); + x20 = x10; + x21 = x13; + x22 = x16; + x23 = x19; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x20, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x21, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x22, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x23, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_selectznz(uint64_t out1[4], uint8_t arg1, const uint64_t arg2[4], const uint64_t arg3[4]) { + internal_fiat_25519_scalar_selectznz((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1fffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] + */ +static +void internal_fiat_25519_scalar_to_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x3, x2, x1, x0, x7, x9, x11, x13, x15, x17, x19, x6, x23, x25, x27, x29, x31, x33, x5, x37, x39, x41, x43, x45, x47, x4, x51, x53, x55, x57, x59, x61, x8, x10, x12, x14, x16, x18, x20, x21, x22, x24, x26, x28, x30, x32, x34, x35, x36, x38, x40, x42, x44, x46, x48, x49, x50, x52, x54, x56, x58, x60, x62, x63, x64, x65, x66, x67, x68, x69, x70, x71, x72, x73, x74, x75, x76, x77, x78, x79, x80, x81, x82, x83, x84, x85, x86, x87, x88, x89, x90, x91, x92, x93, x94, x95; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x3; + x5 = x2; + x6 = x1; + x7 = x0; + x8 = (x7)&((uintptr_t)255ULL); + x9 = (x7)>>((uintptr_t)8ULL); + x10 = (x9)&((uintptr_t)255ULL); + x11 = (x9)>>((uintptr_t)8ULL); + x12 = (x11)&((uintptr_t)255ULL); + x13 = (x11)>>((uintptr_t)8ULL); + x14 = (x13)&((uintptr_t)255ULL); + x15 = (x13)>>((uintptr_t)8ULL); + x16 = (x15)&((uintptr_t)255ULL); + x17 = (x15)>>((uintptr_t)8ULL); + x18 = (x17)&((uintptr_t)255ULL); + x19 = (x17)>>((uintptr_t)8ULL); + x20 = (x19)&((uintptr_t)255ULL); + x21 = (x19)>>((uintptr_t)8ULL); + x22 = (x6)&((uintptr_t)255ULL); + x23 = (x6)>>((uintptr_t)8ULL); + x24 = (x23)&((uintptr_t)255ULL); + x25 = (x23)>>((uintptr_t)8ULL); + x26 = (x25)&((uintptr_t)255ULL); + x27 = (x25)>>((uintptr_t)8ULL); + x28 = (x27)&((uintptr_t)255ULL); + x29 = (x27)>>((uintptr_t)8ULL); + x30 = (x29)&((uintptr_t)255ULL); + x31 = (x29)>>((uintptr_t)8ULL); + x32 = (x31)&((uintptr_t)255ULL); + x33 = (x31)>>((uintptr_t)8ULL); + x34 = (x33)&((uintptr_t)255ULL); + x35 = (x33)>>((uintptr_t)8ULL); + x36 = (x5)&((uintptr_t)255ULL); + x37 = (x5)>>((uintptr_t)8ULL); + x38 = (x37)&((uintptr_t)255ULL); + x39 = (x37)>>((uintptr_t)8ULL); + x40 = (x39)&((uintptr_t)255ULL); + x41 = (x39)>>((uintptr_t)8ULL); + x42 = (x41)&((uintptr_t)255ULL); + x43 = (x41)>>((uintptr_t)8ULL); + x44 = (x43)&((uintptr_t)255ULL); + x45 = (x43)>>((uintptr_t)8ULL); + x46 = (x45)&((uintptr_t)255ULL); + x47 = (x45)>>((uintptr_t)8ULL); + x48 = (x47)&((uintptr_t)255ULL); + x49 = (x47)>>((uintptr_t)8ULL); + x50 = (x4)&((uintptr_t)255ULL); + x51 = (x4)>>((uintptr_t)8ULL); + x52 = (x51)&((uintptr_t)255ULL); + x53 = (x51)>>((uintptr_t)8ULL); + x54 = (x53)&((uintptr_t)255ULL); + x55 = (x53)>>((uintptr_t)8ULL); + x56 = (x55)&((uintptr_t)255ULL); + x57 = (x55)>>((uintptr_t)8ULL); + x58 = (x57)&((uintptr_t)255ULL); + x59 = (x57)>>((uintptr_t)8ULL); + x60 = (x59)&((uintptr_t)255ULL); + x61 = (x59)>>((uintptr_t)8ULL); + x62 = (x61)&((uintptr_t)255ULL); + x63 = (x61)>>((uintptr_t)8ULL); + x64 = x8; + x65 = x10; + x66 = x12; + x67 = x14; + x68 = x16; + x69 = x18; + x70 = x20; + x71 = x21; + x72 = x22; + x73 = x24; + x74 = x26; + x75 = x28; + x76 = x30; + x77 = x32; + x78 = x34; + x79 = x35; + x80 = x36; + x81 = x38; + x82 = x40; + x83 = x42; + x84 = x44; + x85 = x46; + x86 = x48; + x87 = x49; + x88 = x50; + x89 = x52; + x90 = x54; + x91 = x56; + x92 = x58; + x93 = x60; + x94 = x62; + x95 = x63; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x64, 1); + _br2_store((out0)+((uintptr_t)1ULL), x65, 1); + _br2_store((out0)+((uintptr_t)2ULL), x66, 1); + _br2_store((out0)+((uintptr_t)3ULL), x67, 1); + _br2_store((out0)+((uintptr_t)4ULL), x68, 1); + _br2_store((out0)+((uintptr_t)5ULL), x69, 1); + _br2_store((out0)+((uintptr_t)6ULL), x70, 1); + _br2_store((out0)+((uintptr_t)7ULL), x71, 1); + _br2_store((out0)+((uintptr_t)8ULL), x72, 1); + _br2_store((out0)+((uintptr_t)9ULL), x73, 1); + _br2_store((out0)+((uintptr_t)10ULL), x74, 1); + _br2_store((out0)+((uintptr_t)11ULL), x75, 1); + _br2_store((out0)+((uintptr_t)12ULL), x76, 1); + _br2_store((out0)+((uintptr_t)13ULL), x77, 1); + _br2_store((out0)+((uintptr_t)14ULL), x78, 1); + _br2_store((out0)+((uintptr_t)15ULL), x79, 1); + _br2_store((out0)+((uintptr_t)16ULL), x80, 1); + _br2_store((out0)+((uintptr_t)17ULL), x81, 1); + _br2_store((out0)+((uintptr_t)18ULL), x82, 1); + _br2_store((out0)+((uintptr_t)19ULL), x83, 1); + _br2_store((out0)+((uintptr_t)20ULL), x84, 1); + _br2_store((out0)+((uintptr_t)21ULL), x85, 1); + _br2_store((out0)+((uintptr_t)22ULL), x86, 1); + _br2_store((out0)+((uintptr_t)23ULL), x87, 1); + _br2_store((out0)+((uintptr_t)24ULL), x88, 1); + _br2_store((out0)+((uintptr_t)25ULL), x89, 1); + _br2_store((out0)+((uintptr_t)26ULL), x90, 1); + _br2_store((out0)+((uintptr_t)27ULL), x91, 1); + _br2_store((out0)+((uintptr_t)28ULL), x92, 1); + _br2_store((out0)+((uintptr_t)29ULL), x93, 1); + _br2_store((out0)+((uintptr_t)30ULL), x94, 1); + _br2_store((out0)+((uintptr_t)31ULL), x95, 1); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_to_bytes(uint8_t out1[32], const uint64_t arg1[4]) { + internal_fiat_25519_scalar_to_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1fffffffffffffff]] + */ +static +void internal_fiat_25519_scalar_from_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x31, x30, x29, x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x12, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0, x62, x63, x61, x64, x60, x65, x59, x66, x58, x67, x57, x68, x56, x69, x54, x55, x53, x71, x52, x72, x51, x73, x50, x74, x49, x75, x48, x76, x46, x47, x45, x78, x44, x79, x43, x80, x42, x81, x41, x82, x40, x83, x38, x39, x37, x85, x36, x86, x35, x87, x34, x88, x33, x89, x32, x90, x70, x77, x84, x91, x92, x93, x94, x95; + x0 = _br2_load((in0)+((uintptr_t)0ULL), 1); + x1 = _br2_load((in0)+((uintptr_t)1ULL), 1); + x2 = _br2_load((in0)+((uintptr_t)2ULL), 1); + x3 = _br2_load((in0)+((uintptr_t)3ULL), 1); + x4 = _br2_load((in0)+((uintptr_t)4ULL), 1); + x5 = _br2_load((in0)+((uintptr_t)5ULL), 1); + x6 = _br2_load((in0)+((uintptr_t)6ULL), 1); + x7 = _br2_load((in0)+((uintptr_t)7ULL), 1); + x8 = _br2_load((in0)+((uintptr_t)8ULL), 1); + x9 = _br2_load((in0)+((uintptr_t)9ULL), 1); + x10 = _br2_load((in0)+((uintptr_t)10ULL), 1); + x11 = _br2_load((in0)+((uintptr_t)11ULL), 1); + x12 = _br2_load((in0)+((uintptr_t)12ULL), 1); + x13 = _br2_load((in0)+((uintptr_t)13ULL), 1); + x14 = _br2_load((in0)+((uintptr_t)14ULL), 1); + x15 = _br2_load((in0)+((uintptr_t)15ULL), 1); + x16 = _br2_load((in0)+((uintptr_t)16ULL), 1); + x17 = _br2_load((in0)+((uintptr_t)17ULL), 1); + x18 = _br2_load((in0)+((uintptr_t)18ULL), 1); + x19 = _br2_load((in0)+((uintptr_t)19ULL), 1); + x20 = _br2_load((in0)+((uintptr_t)20ULL), 1); + x21 = _br2_load((in0)+((uintptr_t)21ULL), 1); + x22 = _br2_load((in0)+((uintptr_t)22ULL), 1); + x23 = _br2_load((in0)+((uintptr_t)23ULL), 1); + x24 = _br2_load((in0)+((uintptr_t)24ULL), 1); + x25 = _br2_load((in0)+((uintptr_t)25ULL), 1); + x26 = _br2_load((in0)+((uintptr_t)26ULL), 1); + x27 = _br2_load((in0)+((uintptr_t)27ULL), 1); + x28 = _br2_load((in0)+((uintptr_t)28ULL), 1); + x29 = _br2_load((in0)+((uintptr_t)29ULL), 1); + x30 = _br2_load((in0)+((uintptr_t)30ULL), 1); + x31 = _br2_load((in0)+((uintptr_t)31ULL), 1); + /*skip*/ + /*skip*/ + x32 = (x31)<<((uintptr_t)56ULL); + x33 = (x30)<<((uintptr_t)48ULL); + x34 = (x29)<<((uintptr_t)40ULL); + x35 = (x28)<<((uintptr_t)32ULL); + x36 = (x27)<<((uintptr_t)24ULL); + x37 = (x26)<<((uintptr_t)16ULL); + x38 = (x25)<<((uintptr_t)8ULL); + x39 = x24; + x40 = (x23)<<((uintptr_t)56ULL); + x41 = (x22)<<((uintptr_t)48ULL); + x42 = (x21)<<((uintptr_t)40ULL); + x43 = (x20)<<((uintptr_t)32ULL); + x44 = (x19)<<((uintptr_t)24ULL); + x45 = (x18)<<((uintptr_t)16ULL); + x46 = (x17)<<((uintptr_t)8ULL); + x47 = x16; + x48 = (x15)<<((uintptr_t)56ULL); + x49 = (x14)<<((uintptr_t)48ULL); + x50 = (x13)<<((uintptr_t)40ULL); + x51 = (x12)<<((uintptr_t)32ULL); + x52 = (x11)<<((uintptr_t)24ULL); + x53 = (x10)<<((uintptr_t)16ULL); + x54 = (x9)<<((uintptr_t)8ULL); + x55 = x8; + x56 = (x7)<<((uintptr_t)56ULL); + x57 = (x6)<<((uintptr_t)48ULL); + x58 = (x5)<<((uintptr_t)40ULL); + x59 = (x4)<<((uintptr_t)32ULL); + x60 = (x3)<<((uintptr_t)24ULL); + x61 = (x2)<<((uintptr_t)16ULL); + x62 = (x1)<<((uintptr_t)8ULL); + x63 = x0; + x64 = (x62)+(x63); + x65 = (x61)+(x64); + x66 = (x60)+(x65); + x67 = (x59)+(x66); + x68 = (x58)+(x67); + x69 = (x57)+(x68); + x70 = (x56)+(x69); + x71 = (x54)+(x55); + x72 = (x53)+(x71); + x73 = (x52)+(x72); + x74 = (x51)+(x73); + x75 = (x50)+(x74); + x76 = (x49)+(x75); + x77 = (x48)+(x76); + x78 = (x46)+(x47); + x79 = (x45)+(x78); + x80 = (x44)+(x79); + x81 = (x43)+(x80); + x82 = (x42)+(x81); + x83 = (x41)+(x82); + x84 = (x40)+(x83); + x85 = (x38)+(x39); + x86 = (x37)+(x85); + x87 = (x36)+(x86); + x88 = (x35)+(x87); + x89 = (x34)+(x88); + x90 = (x33)+(x89); + x91 = (x32)+(x90); + x92 = x70; + x93 = x77; + x94 = x84; + x95 = x91; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x92, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x93, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x94, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x95, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_from_bytes(uint64_t out1[4], const uint8_t arg1[32]) { + internal_fiat_25519_scalar_from_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_25519_scalar_set_one(uintptr_t out0) { + uintptr_t x0, x1, x2, x3; + /*skip*/ + x0 = (uintptr_t)15486807595281847581ULL; + x1 = (uintptr_t)14334777244411350896ULL; + x2 = (uintptr_t)18446744073709551614ULL; + x3 = (uintptr_t)1152921504606846975ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_set_one(uint64_t out1[4]) { + internal_fiat_25519_scalar_set_one((uintptr_t)out1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_25519_scalar_msat(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4; + /*skip*/ + x0 = (uintptr_t)6346243789798364141ULL; + x1 = (uintptr_t)1503914060200516822ULL; + x2 = (uintptr_t)0ULL; + x3 = (uintptr_t)1152921504606846976ULL; + x4 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x4, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_msat(uint64_t out1[5]) { + internal_fiat_25519_scalar_msat((uintptr_t)out1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0xffffffffffffffff] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffffffffffff] + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +uintptr_t internal_fiat_25519_scalar_divstep(uintptr_t out1, uintptr_t out2, uintptr_t out3, uintptr_t out4, uintptr_t in0, uintptr_t in1, uintptr_t in2, uintptr_t in3, uintptr_t in4) { + uintptr_t x18, x20, x21, x22, x24, x25, x27, x28, x30, x31, x33, x34, x36, x37, x0, x40, x1, x42, x2, x44, x3, x46, x4, x39, x48, x5, x49, x41, x51, x6, x52, x43, x54, x7, x55, x45, x57, x8, x58, x47, x60, x9, x61, x63, x64, x66, x67, x69, x70, x72, x73, x76, x77, x78, x80, x81, x82, x83, x85, x86, x87, x88, x90, x93, x94, x95, x97, x98, x100, x101, x102, x104, x105, x91, x106, x13, x12, x11, x10, x112, x110, x113, x115, x116, x109, x117, x119, x120, x108, x121, x123, x124, x111, x127, x114, x128, x129, x131, x132, x118, x134, x122, x135, x125, x126, x137, x14, x138, x130, x140, x15, x141, x133, x143, x16, x144, x19, x136, x146, x17, x147, x150, x151, x153, x154, x156, x157, x159, x160, x162, x163, x152, x50, x166, x53, x167, x155, x168, x170, x171, x56, x172, x158, x173, x175, x176, x59, x177, x161, x178, x180, x181, x62, x182, x164, x65, x184, x185, x68, x187, x188, x71, x190, x191, x149, x74, x193, x194, x186, x139, x197, x142, x198, x189, x199, x201, x202, x145, x203, x192, x204, x206, x207, x148, x208, x195, x209, x211, x214, x215, x216, x218, x219, x221, x222, x223, x225, x226, x212, x227, x23, x165, x169, x174, x179, x183, x75, x235, x92, x236, x79, x238, x96, x239, x84, x241, x99, x242, x107, x89, x244, x103, x245, x196, x247, x213, x248, x200, x250, x217, x251, x205, x253, x220, x254, x228, x210, x256, x224, x257, x229, x26, x29, x32, x35, x38, x230, x231, x232, x233, x234, x237, x240, x243, x246, x249, x252, x255, x258, out0, x259, x260, x261, x262, x263, x264, x265, x266, x267, x268, x269, x270, x271, x272, x273, x274, x275, x276, x277; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + /*skip*/ + x5 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x6 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x7 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x8 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x9 = _br2_load((in2)+((uintptr_t)32ULL), sizeof(uintptr_t)); + /*skip*/ + x10 = _br2_load((in3)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x11 = _br2_load((in3)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x12 = _br2_load((in3)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in3)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x14 = _br2_load((in4)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x15 = _br2_load((in4)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x16 = _br2_load((in4)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x17 = _br2_load((in4)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x18 = ((in0)^((uintptr_t)18446744073709551615ULL))+((uintptr_t)1ULL); + x19 = ((x18)>>((uintptr_t)63ULL))&((x5)&((uintptr_t)1ULL)); + x20 = ((in0)^((uintptr_t)18446744073709551615ULL))+((uintptr_t)1ULL); + x21 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x22 = (x21)^((uintptr_t)18446744073709551615ULL); + x23 = ((x20)&(x21))|((in0)&(x22)); + x24 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x25 = (x24)^((uintptr_t)18446744073709551615ULL); + x26 = ((x5)&(x24))|((x0)&(x25)); + x27 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x28 = (x27)^((uintptr_t)18446744073709551615ULL); + x29 = ((x6)&(x27))|((x1)&(x28)); + x30 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x31 = (x30)^((uintptr_t)18446744073709551615ULL); + x32 = ((x7)&(x30))|((x2)&(x31)); + x33 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x34 = (x33)^((uintptr_t)18446744073709551615ULL); + x35 = ((x8)&(x33))|((x3)&(x34)); + x36 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x37 = (x36)^((uintptr_t)18446744073709551615ULL); + x38 = ((x9)&(x36))|((x4)&(x37)); + x39 = ((uintptr_t)1ULL)+((x0)^((uintptr_t)18446744073709551615ULL)); + x40 = (uintptr_t)((x39)<((uintptr_t)1ULL)); + x41 = (x40)+((x1)^((uintptr_t)18446744073709551615ULL)); + x42 = (uintptr_t)((x41)<((x1)^((uintptr_t)18446744073709551615ULL))); + x43 = (x42)+((x2)^((uintptr_t)18446744073709551615ULL)); + x44 = (uintptr_t)((x43)<((x2)^((uintptr_t)18446744073709551615ULL))); + x45 = (x44)+((x3)^((uintptr_t)18446744073709551615ULL)); + x46 = (uintptr_t)((x45)<((x3)^((uintptr_t)18446744073709551615ULL))); + x47 = (x46)+((x4)^((uintptr_t)18446744073709551615ULL)); + x48 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x49 = (x48)^((uintptr_t)18446744073709551615ULL); + x50 = ((x39)&(x48))|((x5)&(x49)); + x51 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x52 = (x51)^((uintptr_t)18446744073709551615ULL); + x53 = ((x41)&(x51))|((x6)&(x52)); + x54 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x55 = (x54)^((uintptr_t)18446744073709551615ULL); + x56 = ((x43)&(x54))|((x7)&(x55)); + x57 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x58 = (x57)^((uintptr_t)18446744073709551615ULL); + x59 = ((x45)&(x57))|((x8)&(x58)); + x60 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x61 = (x60)^((uintptr_t)18446744073709551615ULL); + x62 = ((x47)&(x60))|((x9)&(x61)); + x63 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x64 = (x63)^((uintptr_t)18446744073709551615ULL); + x65 = ((x14)&(x63))|((x10)&(x64)); + x66 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x67 = (x66)^((uintptr_t)18446744073709551615ULL); + x68 = ((x15)&(x66))|((x11)&(x67)); + x69 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x70 = (x69)^((uintptr_t)18446744073709551615ULL); + x71 = ((x16)&(x69))|((x12)&(x70)); + x72 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x73 = (x72)^((uintptr_t)18446744073709551615ULL); + x74 = ((x17)&(x72))|((x13)&(x73)); + x75 = (x65)+(x65); + x76 = (uintptr_t)((x75)<(x65)); + x77 = (x76)+(x68); + x78 = (uintptr_t)((x77)<(x68)); + x79 = (x77)+(x68); + x80 = (uintptr_t)((x79)<(x68)); + x81 = (x78)+(x80); + x82 = (x81)+(x71); + x83 = (uintptr_t)((x82)<(x71)); + x84 = (x82)+(x71); + x85 = (uintptr_t)((x84)<(x71)); + x86 = (x83)+(x85); + x87 = (x86)+(x74); + x88 = (uintptr_t)((x87)<(x74)); + x89 = (x87)+(x74); + x90 = (uintptr_t)((x89)<(x74)); + x91 = (x88)+(x90); + x92 = (x75)-((uintptr_t)6346243789798364141ULL); + x93 = (uintptr_t)((x75)<(x92)); + x94 = (x79)-((uintptr_t)1503914060200516822ULL); + x95 = (uintptr_t)((x79)<(x94)); + x96 = (x94)-(x93); + x97 = (uintptr_t)((x94)<(x96)); + x98 = (x95)+(x97); + x99 = (x84)-(x98); + x100 = (uintptr_t)((x84)<(x99)); + x101 = (x89)-((uintptr_t)1152921504606846976ULL); + x102 = (uintptr_t)((x89)<(x101)); + x103 = (x101)-(x100); + x104 = (uintptr_t)((x101)<(x103)); + x105 = (x102)+(x104); + x106 = (x91)-(x105); + x107 = (uintptr_t)((x91)<(x106)); + x108 = x13; + x109 = x12; + x110 = x11; + x111 = x10; + x112 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x111))); + x113 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x110))); + x114 = (((uintptr_t)0ULL)-(x110))-(x112); + x115 = (uintptr_t)((((uintptr_t)0ULL)-(x110))<(x114)); + x116 = (x113)+(x115); + x117 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x109))); + x118 = (((uintptr_t)0ULL)-(x109))-(x116); + x119 = (uintptr_t)((((uintptr_t)0ULL)-(x109))<(x118)); + x120 = (x117)+(x119); + x121 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x108))); + x122 = (((uintptr_t)0ULL)-(x108))-(x120); + x123 = (uintptr_t)((((uintptr_t)0ULL)-(x108))<(x122)); + x124 = (x121)+(x123); + x125 = ((uintptr_t)-1ULL)+((uintptr_t)((x124)==((uintptr_t)0ULL))); + x126 = (((uintptr_t)0ULL)-(x111))+((x125)&((uintptr_t)6346243789798364141ULL)); + x127 = (uintptr_t)((x126)<(((uintptr_t)0ULL)-(x111))); + x128 = (x127)+(x114); + x129 = (uintptr_t)((x128)<(x114)); + x130 = (x128)+((x125)&((uintptr_t)1503914060200516822ULL)); + x131 = (uintptr_t)((x130)<((x125)&((uintptr_t)1503914060200516822ULL))); + x132 = (x129)+(x131); + x133 = (x132)+(x118); + x134 = (uintptr_t)((x133)<(x118)); + x135 = (x134)+(x122); + x136 = (x135)+((x125)&((uintptr_t)1152921504606846976ULL)); + x137 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x138 = (x137)^((uintptr_t)18446744073709551615ULL); + x139 = ((x126)&(x137))|((x14)&(x138)); + x140 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x141 = (x140)^((uintptr_t)18446744073709551615ULL); + x142 = ((x130)&(x140))|((x15)&(x141)); + x143 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x144 = (x143)^((uintptr_t)18446744073709551615ULL); + x145 = ((x133)&(x143))|((x16)&(x144)); + x146 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x147 = (x146)^((uintptr_t)18446744073709551615ULL); + x148 = ((x136)&(x146))|((x17)&(x147)); + x149 = (x50)&((uintptr_t)1ULL); + x150 = ((uintptr_t)-1ULL)+((uintptr_t)((x149)==((uintptr_t)0ULL))); + x151 = (x150)^((uintptr_t)18446744073709551615ULL); + x152 = ((x26)&(x150))|(((uintptr_t)0ULL)&(x151)); + x153 = ((uintptr_t)-1ULL)+((uintptr_t)((x149)==((uintptr_t)0ULL))); + x154 = (x153)^((uintptr_t)18446744073709551615ULL); + x155 = ((x29)&(x153))|(((uintptr_t)0ULL)&(x154)); + x156 = ((uintptr_t)-1ULL)+((uintptr_t)((x149)==((uintptr_t)0ULL))); + x157 = (x156)^((uintptr_t)18446744073709551615ULL); + x158 = ((x32)&(x156))|(((uintptr_t)0ULL)&(x157)); + x159 = ((uintptr_t)-1ULL)+((uintptr_t)((x149)==((uintptr_t)0ULL))); + x160 = (x159)^((uintptr_t)18446744073709551615ULL); + x161 = ((x35)&(x159))|(((uintptr_t)0ULL)&(x160)); + x162 = ((uintptr_t)-1ULL)+((uintptr_t)((x149)==((uintptr_t)0ULL))); + x163 = (x162)^((uintptr_t)18446744073709551615ULL); + x164 = ((x38)&(x162))|(((uintptr_t)0ULL)&(x163)); + x165 = (x50)+(x152); + x166 = (uintptr_t)((x165)<(x50)); + x167 = (x166)+(x53); + x168 = (uintptr_t)((x167)<(x53)); + x169 = (x167)+(x155); + x170 = (uintptr_t)((x169)<(x155)); + x171 = (x168)+(x170); + x172 = (x171)+(x56); + x173 = (uintptr_t)((x172)<(x56)); + x174 = (x172)+(x158); + x175 = (uintptr_t)((x174)<(x158)); + x176 = (x173)+(x175); + x177 = (x176)+(x59); + x178 = (uintptr_t)((x177)<(x59)); + x179 = (x177)+(x161); + x180 = (uintptr_t)((x179)<(x161)); + x181 = (x178)+(x180); + x182 = (x181)+(x62); + x183 = (x182)+(x164); + x184 = ((uintptr_t)-1ULL)+((uintptr_t)((x149)==((uintptr_t)0ULL))); + x185 = (x184)^((uintptr_t)18446744073709551615ULL); + x186 = ((x65)&(x184))|(((uintptr_t)0ULL)&(x185)); + x187 = ((uintptr_t)-1ULL)+((uintptr_t)((x149)==((uintptr_t)0ULL))); + x188 = (x187)^((uintptr_t)18446744073709551615ULL); + x189 = ((x68)&(x187))|(((uintptr_t)0ULL)&(x188)); + x190 = ((uintptr_t)-1ULL)+((uintptr_t)((x149)==((uintptr_t)0ULL))); + x191 = (x190)^((uintptr_t)18446744073709551615ULL); + x192 = ((x71)&(x190))|(((uintptr_t)0ULL)&(x191)); + x193 = ((uintptr_t)-1ULL)+((uintptr_t)((x149)==((uintptr_t)0ULL))); + x194 = (x193)^((uintptr_t)18446744073709551615ULL); + x195 = ((x74)&(x193))|(((uintptr_t)0ULL)&(x194)); + x196 = (x139)+(x186); + x197 = (uintptr_t)((x196)<(x139)); + x198 = (x197)+(x142); + x199 = (uintptr_t)((x198)<(x142)); + x200 = (x198)+(x189); + x201 = (uintptr_t)((x200)<(x189)); + x202 = (x199)+(x201); + x203 = (x202)+(x145); + x204 = (uintptr_t)((x203)<(x145)); + x205 = (x203)+(x192); + x206 = (uintptr_t)((x205)<(x192)); + x207 = (x204)+(x206); + x208 = (x207)+(x148); + x209 = (uintptr_t)((x208)<(x148)); + x210 = (x208)+(x195); + x211 = (uintptr_t)((x210)<(x195)); + x212 = (x209)+(x211); + x213 = (x196)-((uintptr_t)6346243789798364141ULL); + x214 = (uintptr_t)((x196)<(x213)); + x215 = (x200)-((uintptr_t)1503914060200516822ULL); + x216 = (uintptr_t)((x200)<(x215)); + x217 = (x215)-(x214); + x218 = (uintptr_t)((x215)<(x217)); + x219 = (x216)+(x218); + x220 = (x205)-(x219); + x221 = (uintptr_t)((x205)<(x220)); + x222 = (x210)-((uintptr_t)1152921504606846976ULL); + x223 = (uintptr_t)((x210)<(x222)); + x224 = (x222)-(x221); + x225 = (uintptr_t)((x222)<(x224)); + x226 = (x223)+(x225); + x227 = (x212)-(x226); + x228 = (uintptr_t)((x212)<(x227)); + x229 = (x23)+((uintptr_t)1ULL); + x230 = ((x165)>>((uintptr_t)1ULL))|((x169)<<((uintptr_t)63ULL)); + x231 = ((x169)>>((uintptr_t)1ULL))|((x174)<<((uintptr_t)63ULL)); + x232 = ((x174)>>((uintptr_t)1ULL))|((x179)<<((uintptr_t)63ULL)); + x233 = ((x179)>>((uintptr_t)1ULL))|((x183)<<((uintptr_t)63ULL)); + x234 = ((x183)&((uintptr_t)9223372036854775808ULL))|((x183)>>((uintptr_t)1ULL)); + x235 = ((uintptr_t)-1ULL)+((uintptr_t)((x107)==((uintptr_t)0ULL))); + x236 = (x235)^((uintptr_t)18446744073709551615ULL); + x237 = ((x75)&(x235))|((x92)&(x236)); + x238 = ((uintptr_t)-1ULL)+((uintptr_t)((x107)==((uintptr_t)0ULL))); + x239 = (x238)^((uintptr_t)18446744073709551615ULL); + x240 = ((x79)&(x238))|((x96)&(x239)); + x241 = ((uintptr_t)-1ULL)+((uintptr_t)((x107)==((uintptr_t)0ULL))); + x242 = (x241)^((uintptr_t)18446744073709551615ULL); + x243 = ((x84)&(x241))|((x99)&(x242)); + x244 = ((uintptr_t)-1ULL)+((uintptr_t)((x107)==((uintptr_t)0ULL))); + x245 = (x244)^((uintptr_t)18446744073709551615ULL); + x246 = ((x89)&(x244))|((x103)&(x245)); + x247 = ((uintptr_t)-1ULL)+((uintptr_t)((x228)==((uintptr_t)0ULL))); + x248 = (x247)^((uintptr_t)18446744073709551615ULL); + x249 = ((x196)&(x247))|((x213)&(x248)); + x250 = ((uintptr_t)-1ULL)+((uintptr_t)((x228)==((uintptr_t)0ULL))); + x251 = (x250)^((uintptr_t)18446744073709551615ULL); + x252 = ((x200)&(x250))|((x217)&(x251)); + x253 = ((uintptr_t)-1ULL)+((uintptr_t)((x228)==((uintptr_t)0ULL))); + x254 = (x253)^((uintptr_t)18446744073709551615ULL); + x255 = ((x205)&(x253))|((x220)&(x254)); + x256 = ((uintptr_t)-1ULL)+((uintptr_t)((x228)==((uintptr_t)0ULL))); + x257 = (x256)^((uintptr_t)18446744073709551615ULL); + x258 = ((x210)&(x256))|((x224)&(x257)); + x259 = x229; + x260 = x26; + x261 = x29; + x262 = x32; + x263 = x35; + x264 = x38; + /*skip*/ + x265 = x230; + x266 = x231; + x267 = x232; + x268 = x233; + x269 = x234; + /*skip*/ + x270 = x237; + x271 = x240; + x272 = x243; + x273 = x246; + /*skip*/ + x274 = x249; + x275 = x252; + x276 = x255; + x277 = x258; + /*skip*/ + out0 = x259; + _br2_store((out1)+((uintptr_t)0ULL), x260, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)8ULL), x261, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)16ULL), x262, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)24ULL), x263, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)32ULL), x264, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out2)+((uintptr_t)0ULL), x265, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)8ULL), x266, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)16ULL), x267, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)24ULL), x268, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)32ULL), x269, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out3)+((uintptr_t)0ULL), x270, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)8ULL), x271, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)16ULL), x272, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)24ULL), x273, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out4)+((uintptr_t)0ULL), x274, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)8ULL), x275, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)16ULL), x276, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)24ULL), x277, sizeof(uintptr_t)); + /*skip*/ + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_divstep(uint64_t* out1, uint64_t out2[5], uint64_t out3[5], uint64_t out4[4], uint64_t out5[4], uint64_t arg1, const uint64_t arg2[5], const uint64_t arg3[5], const uint64_t arg4[4], const uint64_t arg5[4]) { + *out1 = (uint64_t)internal_fiat_25519_scalar_divstep((uintptr_t)out2, (uintptr_t)out3, (uintptr_t)out4, (uintptr_t)out5, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3, (uintptr_t)arg4, (uintptr_t)arg5); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_25519_scalar_divstep_precomp(uintptr_t out0) { + uintptr_t x0, x1, x2, x3; + /*skip*/ + x0 = (uintptr_t)15495470439780043666ULL; + x1 = (uintptr_t)6877499626169610585ULL; + x2 = (uintptr_t)16676127285150252826ULL; + x3 = (uintptr_t)115454454455854335ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_25519_scalar_divstep_precomp(uint64_t out1[4]) { + internal_fiat_25519_scalar_divstep_precomp((uintptr_t)out1); +} diff --git a/fiat-bedrock2/src/p256_scalar_32.c b/fiat-bedrock2/src/p256_scalar_32.c new file mode 100644 index 0000000000..89f353593f --- /dev/null +++ b/fiat-bedrock2/src/p256_scalar_32.c @@ -0,0 +1,5562 @@ +/* Autogenerated: 'src/ExtractionOCaml/bedrock2_word_by_word_montgomery' --lang bedrock2 --static --no-wide-int --widen-carry --widen-bytes --split-multiret --no-select --no-field-element-typedefs p256_scalar 32 '2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: p256_scalar */ +/* machine_wordsize = 32 (from "32") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 (from "2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +#include + +// We use memcpy to work around -fstrict-aliasing. +// A plain memcpy is enough on clang 10, but not on gcc 10, which fails +// to infer the bounds on an integer loaded by memcpy. +// Adding a range mask after memcpy in turn makes slower code in clang. +// Loading individual bytes, shifting them together, and or-ing is fast +// on clang and sometimes on GCC, but other times GCC inlines individual +// byte operations without reconstructing wider accesses. +// The little-endian idiom below seems fast in gcc 9+ and clang 10. +static __attribute__((always_inline)) inline uintptr_t +_br2_load(uintptr_t a, uintptr_t sz) { + switch (sz) { + case 1: { uint8_t r = 0; memcpy(&r, (void*)a, 1); return r; } + case 2: { uint16_t r = 0; memcpy(&r, (void*)a, 2); return r; } + case 4: { uint32_t r = 0; memcpy(&r, (void*)a, 4); return r; } + case 8: { uint64_t r = 0; memcpy(&r, (void*)a, 8); return r; } + default: __builtin_unreachable(); + } +} + +static __attribute__((always_inline)) inline void +_br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) { + memcpy((void*)a, &v, sz); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p256_scalar_mul(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x1, x2, x3, x4, x5, x6, x7, x0, x23, x36, x39, x41, x37, x42, x34, x43, x45, x46, x35, x47, x32, x48, x50, x51, x33, x52, x30, x53, x55, x56, x31, x57, x28, x58, x60, x61, x29, x62, x26, x63, x65, x66, x27, x67, x24, x68, x70, x71, x25, x73, x84, x87, x89, x85, x90, x82, x91, x93, x94, x83, x95, x80, x96, x98, x99, x81, x100, x78, x101, x103, x104, x79, x105, x76, x106, x108, x109, x77, x86, x111, x38, x112, x40, x113, x88, x114, x116, x117, x44, x118, x92, x119, x121, x122, x49, x123, x97, x124, x126, x127, x54, x128, x102, x129, x131, x132, x59, x133, x107, x134, x136, x137, x64, x138, x110, x139, x141, x142, x69, x143, x74, x144, x146, x147, x72, x148, x75, x149, x151, x16, x165, x168, x170, x166, x171, x163, x172, x174, x175, x164, x176, x161, x177, x179, x180, x162, x181, x159, x182, x184, x185, x160, x186, x157, x187, x189, x190, x158, x191, x155, x192, x194, x195, x156, x196, x153, x197, x199, x200, x154, x167, x115, x203, x120, x204, x169, x205, x207, x208, x125, x209, x173, x210, x212, x213, x130, x214, x178, x215, x217, x218, x135, x219, x183, x220, x222, x223, x140, x224, x188, x225, x227, x228, x145, x229, x193, x230, x232, x233, x150, x234, x198, x235, x237, x238, x152, x239, x201, x240, x242, x244, x255, x258, x260, x256, x261, x253, x262, x264, x265, x254, x266, x251, x267, x269, x270, x252, x271, x249, x272, x274, x275, x250, x276, x247, x277, x279, x280, x248, x257, x282, x202, x283, x206, x284, x259, x285, x287, x288, x211, x289, x263, x290, x292, x293, x216, x294, x268, x295, x297, x298, x221, x299, x273, x300, x302, x303, x226, x304, x278, x305, x307, x308, x231, x309, x281, x310, x312, x313, x236, x314, x245, x315, x317, x318, x241, x319, x246, x320, x322, x323, x243, x17, x337, x340, x342, x338, x343, x335, x344, x346, x347, x336, x348, x333, x349, x351, x352, x334, x353, x331, x354, x356, x357, x332, x358, x329, x359, x361, x362, x330, x363, x327, x364, x366, x367, x328, x368, x325, x369, x371, x372, x326, x339, x286, x375, x291, x376, x341, x377, x379, x380, x296, x381, x345, x382, x384, x385, x301, x386, x350, x387, x389, x390, x306, x391, x355, x392, x394, x395, x311, x396, x360, x397, x399, x400, x316, x401, x365, x402, x404, x405, x321, x406, x370, x407, x409, x410, x324, x411, x373, x412, x414, x416, x427, x430, x432, x428, x433, x425, x434, x436, x437, x426, x438, x423, x439, x441, x442, x424, x443, x421, x444, x446, x447, x422, x448, x419, x449, x451, x452, x420, x429, x454, x374, x455, x378, x456, x431, x457, x459, x460, x383, x461, x435, x462, x464, x465, x388, x466, x440, x467, x469, x470, x393, x471, x445, x472, x474, x475, x398, x476, x450, x477, x479, x480, x403, x481, x453, x482, x484, x485, x408, x486, x417, x487, x489, x490, x413, x491, x418, x492, x494, x495, x415, x18, x509, x512, x514, x510, x515, x507, x516, x518, x519, x508, x520, x505, x521, x523, x524, x506, x525, x503, x526, x528, x529, x504, x530, x501, x531, x533, x534, x502, x535, x499, x536, x538, x539, x500, x540, x497, x541, x543, x544, x498, x511, x458, x547, x463, x548, x513, x549, x551, x552, x468, x553, x517, x554, x556, x557, x473, x558, x522, x559, x561, x562, x478, x563, x527, x564, x566, x567, x483, x568, x532, x569, x571, x572, x488, x573, x537, x574, x576, x577, x493, x578, x542, x579, x581, x582, x496, x583, x545, x584, x586, x588, x599, x602, x604, x600, x605, x597, x606, x608, x609, x598, x610, x595, x611, x613, x614, x596, x615, x593, x616, x618, x619, x594, x620, x591, x621, x623, x624, x592, x601, x626, x546, x627, x550, x628, x603, x629, x631, x632, x555, x633, x607, x634, x636, x637, x560, x638, x612, x639, x641, x642, x565, x643, x617, x644, x646, x647, x570, x648, x622, x649, x651, x652, x575, x653, x625, x654, x656, x657, x580, x658, x589, x659, x661, x662, x585, x663, x590, x664, x666, x667, x587, x19, x681, x684, x686, x682, x687, x679, x688, x690, x691, x680, x692, x677, x693, x695, x696, x678, x697, x675, x698, x700, x701, x676, x702, x673, x703, x705, x706, x674, x707, x671, x708, x710, x711, x672, x712, x669, x713, x715, x716, x670, x683, x630, x719, x635, x720, x685, x721, x723, x724, x640, x725, x689, x726, x728, x729, x645, x730, x694, x731, x733, x734, x650, x735, x699, x736, x738, x739, x655, x740, x704, x741, x743, x744, x660, x745, x709, x746, x748, x749, x665, x750, x714, x751, x753, x754, x668, x755, x717, x756, x758, x760, x771, x774, x776, x772, x777, x769, x778, x780, x781, x770, x782, x767, x783, x785, x786, x768, x787, x765, x788, x790, x791, x766, x792, x763, x793, x795, x796, x764, x773, x798, x718, x799, x722, x800, x775, x801, x803, x804, x727, x805, x779, x806, x808, x809, x732, x810, x784, x811, x813, x814, x737, x815, x789, x816, x818, x819, x742, x820, x794, x821, x823, x824, x747, x825, x797, x826, x828, x829, x752, x830, x761, x831, x833, x834, x757, x835, x762, x836, x838, x839, x759, x20, x853, x856, x858, x854, x859, x851, x860, x862, x863, x852, x864, x849, x865, x867, x868, x850, x869, x847, x870, x872, x873, x848, x874, x845, x875, x877, x878, x846, x879, x843, x880, x882, x883, x844, x884, x841, x885, x887, x888, x842, x855, x802, x891, x807, x892, x857, x893, x895, x896, x812, x897, x861, x898, x900, x901, x817, x902, x866, x903, x905, x906, x822, x907, x871, x908, x910, x911, x827, x912, x876, x913, x915, x916, x832, x917, x881, x918, x920, x921, x837, x922, x886, x923, x925, x926, x840, x927, x889, x928, x930, x932, x943, x946, x948, x944, x949, x941, x950, x952, x953, x942, x954, x939, x955, x957, x958, x940, x959, x937, x960, x962, x963, x938, x964, x935, x965, x967, x968, x936, x945, x970, x890, x971, x894, x972, x947, x973, x975, x976, x899, x977, x951, x978, x980, x981, x904, x982, x956, x983, x985, x986, x909, x987, x961, x988, x990, x991, x914, x992, x966, x993, x995, x996, x919, x997, x969, x998, x1000, x1001, x924, x1002, x933, x1003, x1005, x1006, x929, x1007, x934, x1008, x1010, x1011, x931, x21, x1025, x1028, x1030, x1026, x1031, x1023, x1032, x1034, x1035, x1024, x1036, x1021, x1037, x1039, x1040, x1022, x1041, x1019, x1042, x1044, x1045, x1020, x1046, x1017, x1047, x1049, x1050, x1018, x1051, x1015, x1052, x1054, x1055, x1016, x1056, x1013, x1057, x1059, x1060, x1014, x1027, x974, x1063, x979, x1064, x1029, x1065, x1067, x1068, x984, x1069, x1033, x1070, x1072, x1073, x989, x1074, x1038, x1075, x1077, x1078, x994, x1079, x1043, x1080, x1082, x1083, x999, x1084, x1048, x1085, x1087, x1088, x1004, x1089, x1053, x1090, x1092, x1093, x1009, x1094, x1058, x1095, x1097, x1098, x1012, x1099, x1061, x1100, x1102, x1104, x1115, x1118, x1120, x1116, x1121, x1113, x1122, x1124, x1125, x1114, x1126, x1111, x1127, x1129, x1130, x1112, x1131, x1109, x1132, x1134, x1135, x1110, x1136, x1107, x1137, x1139, x1140, x1108, x1117, x1142, x1062, x1143, x1066, x1144, x1119, x1145, x1147, x1148, x1071, x1149, x1123, x1150, x1152, x1153, x1076, x1154, x1128, x1155, x1157, x1158, x1081, x1159, x1133, x1160, x1162, x1163, x1086, x1164, x1138, x1165, x1167, x1168, x1091, x1169, x1141, x1170, x1172, x1173, x1096, x1174, x1105, x1175, x1177, x1178, x1101, x1179, x1106, x1180, x1182, x1183, x1103, x15, x14, x13, x12, x11, x10, x9, x22, x8, x1197, x1200, x1202, x1198, x1203, x1195, x1204, x1206, x1207, x1196, x1208, x1193, x1209, x1211, x1212, x1194, x1213, x1191, x1214, x1216, x1217, x1192, x1218, x1189, x1219, x1221, x1222, x1190, x1223, x1187, x1224, x1226, x1227, x1188, x1228, x1185, x1229, x1231, x1232, x1186, x1199, x1146, x1235, x1151, x1236, x1201, x1237, x1239, x1240, x1156, x1241, x1205, x1242, x1244, x1245, x1161, x1246, x1210, x1247, x1249, x1250, x1166, x1251, x1215, x1252, x1254, x1255, x1171, x1256, x1220, x1257, x1259, x1260, x1176, x1261, x1225, x1262, x1264, x1265, x1181, x1266, x1230, x1267, x1269, x1270, x1184, x1271, x1233, x1272, x1274, x1276, x1287, x1290, x1292, x1288, x1293, x1285, x1294, x1296, x1297, x1286, x1298, x1283, x1299, x1301, x1302, x1284, x1303, x1281, x1304, x1306, x1307, x1282, x1308, x1279, x1309, x1311, x1312, x1280, x1289, x1314, x1234, x1315, x1238, x1316, x1291, x1317, x1319, x1320, x1243, x1321, x1295, x1322, x1324, x1325, x1248, x1326, x1300, x1327, x1329, x1330, x1253, x1331, x1305, x1332, x1334, x1335, x1258, x1336, x1310, x1337, x1339, x1340, x1263, x1341, x1313, x1342, x1344, x1345, x1268, x1346, x1277, x1347, x1349, x1350, x1273, x1351, x1278, x1352, x1354, x1355, x1275, x1358, x1359, x1360, x1362, x1363, x1364, x1365, x1367, x1368, x1369, x1370, x1372, x1373, x1374, x1375, x1377, x1378, x1379, x1380, x1382, x1383, x1385, x1386, x1387, x1389, x1390, x1356, x1391, x1318, x1393, x1357, x1394, x1323, x1396, x1361, x1397, x1328, x1399, x1366, x1400, x1333, x1402, x1371, x1403, x1338, x1405, x1376, x1406, x1343, x1408, x1381, x1409, x1348, x1411, x1384, x1412, x1392, x1353, x1414, x1388, x1415, x1395, x1398, x1401, x1404, x1407, x1410, x1413, x1416, x1417, x1418, x1419, x1420, x1421, x1422, x1423, x1424; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = x1; + x17 = x2; + x18 = x3; + x19 = x4; + x20 = x5; + x21 = x6; + x22 = x7; + x23 = x0; + x24 = (x23)*(x15); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x15))>>32 : ((__uint128_t)(x23)*(x15))>>64); + x26 = (x23)*(x14); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x14))>>32 : ((__uint128_t)(x23)*(x14))>>64); + x28 = (x23)*(x13); + x29 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x13))>>32 : ((__uint128_t)(x23)*(x13))>>64); + x30 = (x23)*(x12); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x12))>>32 : ((__uint128_t)(x23)*(x12))>>64); + x32 = (x23)*(x11); + x33 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x11))>>32 : ((__uint128_t)(x23)*(x11))>>64); + x34 = (x23)*(x10); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x10))>>32 : ((__uint128_t)(x23)*(x10))>>64); + x36 = (x23)*(x9); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x9))>>32 : ((__uint128_t)(x23)*(x9))>>64); + x38 = (x23)*(x8); + x39 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x8))>>32 : ((__uint128_t)(x23)*(x8))>>64); + x40 = (x39)+(x36); + x41 = (uintptr_t)((x40)<(x39)); + x42 = (x41)+(x37); + x43 = (uintptr_t)((x42)<(x37)); + x44 = (x42)+(x34); + x45 = (uintptr_t)((x44)<(x34)); + x46 = (x43)+(x45); + x47 = (x46)+(x35); + x48 = (uintptr_t)((x47)<(x35)); + x49 = (x47)+(x32); + x50 = (uintptr_t)((x49)<(x32)); + x51 = (x48)+(x50); + x52 = (x51)+(x33); + x53 = (uintptr_t)((x52)<(x33)); + x54 = (x52)+(x30); + x55 = (uintptr_t)((x54)<(x30)); + x56 = (x53)+(x55); + x57 = (x56)+(x31); + x58 = (uintptr_t)((x57)<(x31)); + x59 = (x57)+(x28); + x60 = (uintptr_t)((x59)<(x28)); + x61 = (x58)+(x60); + x62 = (x61)+(x29); + x63 = (uintptr_t)((x62)<(x29)); + x64 = (x62)+(x26); + x65 = (uintptr_t)((x64)<(x26)); + x66 = (x63)+(x65); + x67 = (x66)+(x27); + x68 = (uintptr_t)((x67)<(x27)); + x69 = (x67)+(x24); + x70 = (uintptr_t)((x69)<(x24)); + x71 = (x68)+(x70); + x72 = (x71)+(x25); + x73 = (x38)*((uintptr_t)3993025615ULL); + x74 = (x73)*((uintptr_t)4294967295ULL); + x75 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)4294967295ULL))>>64); + x76 = (x73)*((uintptr_t)4294967295ULL); + x77 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)4294967295ULL))>>64); + x78 = (x73)*((uintptr_t)4294967295ULL); + x79 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)4294967295ULL))>>64); + x80 = (x73)*((uintptr_t)3169254061ULL); + x81 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)3169254061ULL))>>64); + x82 = (x73)*((uintptr_t)2803342980ULL); + x83 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)2803342980ULL))>>64); + x84 = (x73)*((uintptr_t)4089039554ULL); + x85 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)4089039554ULL))>>64); + x86 = (x73)*((uintptr_t)4234356049ULL); + x87 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)4234356049ULL))>>64); + x88 = (x87)+(x84); + x89 = (uintptr_t)((x88)<(x87)); + x90 = (x89)+(x85); + x91 = (uintptr_t)((x90)<(x85)); + x92 = (x90)+(x82); + x93 = (uintptr_t)((x92)<(x82)); + x94 = (x91)+(x93); + x95 = (x94)+(x83); + x96 = (uintptr_t)((x95)<(x83)); + x97 = (x95)+(x80); + x98 = (uintptr_t)((x97)<(x80)); + x99 = (x96)+(x98); + x100 = (x99)+(x81); + x101 = (uintptr_t)((x100)<(x81)); + x102 = (x100)+(x78); + x103 = (uintptr_t)((x102)<(x78)); + x104 = (x101)+(x103); + x105 = (x104)+(x79); + x106 = (uintptr_t)((x105)<(x79)); + x107 = (x105)+(x76); + x108 = (uintptr_t)((x107)<(x76)); + x109 = (x106)+(x108); + x110 = (x109)+(x77); + x111 = (x38)+(x86); + x112 = (uintptr_t)((x111)<(x38)); + x113 = (x112)+(x40); + x114 = (uintptr_t)((x113)<(x40)); + x115 = (x113)+(x88); + x116 = (uintptr_t)((x115)<(x88)); + x117 = (x114)+(x116); + x118 = (x117)+(x44); + x119 = (uintptr_t)((x118)<(x44)); + x120 = (x118)+(x92); + x121 = (uintptr_t)((x120)<(x92)); + x122 = (x119)+(x121); + x123 = (x122)+(x49); + x124 = (uintptr_t)((x123)<(x49)); + x125 = (x123)+(x97); + x126 = (uintptr_t)((x125)<(x97)); + x127 = (x124)+(x126); + x128 = (x127)+(x54); + x129 = (uintptr_t)((x128)<(x54)); + x130 = (x128)+(x102); + x131 = (uintptr_t)((x130)<(x102)); + x132 = (x129)+(x131); + x133 = (x132)+(x59); + x134 = (uintptr_t)((x133)<(x59)); + x135 = (x133)+(x107); + x136 = (uintptr_t)((x135)<(x107)); + x137 = (x134)+(x136); + x138 = (x137)+(x64); + x139 = (uintptr_t)((x138)<(x64)); + x140 = (x138)+(x110); + x141 = (uintptr_t)((x140)<(x110)); + x142 = (x139)+(x141); + x143 = (x142)+(x69); + x144 = (uintptr_t)((x143)<(x69)); + x145 = (x143)+(x74); + x146 = (uintptr_t)((x145)<(x74)); + x147 = (x144)+(x146); + x148 = (x147)+(x72); + x149 = (uintptr_t)((x148)<(x72)); + x150 = (x148)+(x75); + x151 = (uintptr_t)((x150)<(x75)); + x152 = (x149)+(x151); + x153 = (x16)*(x15); + x154 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x15))>>32 : ((__uint128_t)(x16)*(x15))>>64); + x155 = (x16)*(x14); + x156 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x14))>>32 : ((__uint128_t)(x16)*(x14))>>64); + x157 = (x16)*(x13); + x158 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x13))>>32 : ((__uint128_t)(x16)*(x13))>>64); + x159 = (x16)*(x12); + x160 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x12))>>32 : ((__uint128_t)(x16)*(x12))>>64); + x161 = (x16)*(x11); + x162 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x11))>>32 : ((__uint128_t)(x16)*(x11))>>64); + x163 = (x16)*(x10); + x164 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x10))>>32 : ((__uint128_t)(x16)*(x10))>>64); + x165 = (x16)*(x9); + x166 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x9))>>32 : ((__uint128_t)(x16)*(x9))>>64); + x167 = (x16)*(x8); + x168 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x8))>>32 : ((__uint128_t)(x16)*(x8))>>64); + x169 = (x168)+(x165); + x170 = (uintptr_t)((x169)<(x168)); + x171 = (x170)+(x166); + x172 = (uintptr_t)((x171)<(x166)); + x173 = (x171)+(x163); + x174 = (uintptr_t)((x173)<(x163)); + x175 = (x172)+(x174); + x176 = (x175)+(x164); + x177 = (uintptr_t)((x176)<(x164)); + x178 = (x176)+(x161); + x179 = (uintptr_t)((x178)<(x161)); + x180 = (x177)+(x179); + x181 = (x180)+(x162); + x182 = (uintptr_t)((x181)<(x162)); + x183 = (x181)+(x159); + x184 = (uintptr_t)((x183)<(x159)); + x185 = (x182)+(x184); + x186 = (x185)+(x160); + x187 = (uintptr_t)((x186)<(x160)); + x188 = (x186)+(x157); + x189 = (uintptr_t)((x188)<(x157)); + x190 = (x187)+(x189); + x191 = (x190)+(x158); + x192 = (uintptr_t)((x191)<(x158)); + x193 = (x191)+(x155); + x194 = (uintptr_t)((x193)<(x155)); + x195 = (x192)+(x194); + x196 = (x195)+(x156); + x197 = (uintptr_t)((x196)<(x156)); + x198 = (x196)+(x153); + x199 = (uintptr_t)((x198)<(x153)); + x200 = (x197)+(x199); + x201 = (x200)+(x154); + x202 = (x115)+(x167); + x203 = (uintptr_t)((x202)<(x115)); + x204 = (x203)+(x120); + x205 = (uintptr_t)((x204)<(x120)); + x206 = (x204)+(x169); + x207 = (uintptr_t)((x206)<(x169)); + x208 = (x205)+(x207); + x209 = (x208)+(x125); + x210 = (uintptr_t)((x209)<(x125)); + x211 = (x209)+(x173); + x212 = (uintptr_t)((x211)<(x173)); + x213 = (x210)+(x212); + x214 = (x213)+(x130); + x215 = (uintptr_t)((x214)<(x130)); + x216 = (x214)+(x178); + x217 = (uintptr_t)((x216)<(x178)); + x218 = (x215)+(x217); + x219 = (x218)+(x135); + x220 = (uintptr_t)((x219)<(x135)); + x221 = (x219)+(x183); + x222 = (uintptr_t)((x221)<(x183)); + x223 = (x220)+(x222); + x224 = (x223)+(x140); + x225 = (uintptr_t)((x224)<(x140)); + x226 = (x224)+(x188); + x227 = (uintptr_t)((x226)<(x188)); + x228 = (x225)+(x227); + x229 = (x228)+(x145); + x230 = (uintptr_t)((x229)<(x145)); + x231 = (x229)+(x193); + x232 = (uintptr_t)((x231)<(x193)); + x233 = (x230)+(x232); + x234 = (x233)+(x150); + x235 = (uintptr_t)((x234)<(x150)); + x236 = (x234)+(x198); + x237 = (uintptr_t)((x236)<(x198)); + x238 = (x235)+(x237); + x239 = (x238)+(x152); + x240 = (uintptr_t)((x239)<(x152)); + x241 = (x239)+(x201); + x242 = (uintptr_t)((x241)<(x201)); + x243 = (x240)+(x242); + x244 = (x202)*((uintptr_t)3993025615ULL); + x245 = (x244)*((uintptr_t)4294967295ULL); + x246 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x244)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x244)*((uintptr_t)4294967295ULL))>>64); + x247 = (x244)*((uintptr_t)4294967295ULL); + x248 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x244)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x244)*((uintptr_t)4294967295ULL))>>64); + x249 = (x244)*((uintptr_t)4294967295ULL); + x250 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x244)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x244)*((uintptr_t)4294967295ULL))>>64); + x251 = (x244)*((uintptr_t)3169254061ULL); + x252 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x244)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x244)*((uintptr_t)3169254061ULL))>>64); + x253 = (x244)*((uintptr_t)2803342980ULL); + x254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x244)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x244)*((uintptr_t)2803342980ULL))>>64); + x255 = (x244)*((uintptr_t)4089039554ULL); + x256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x244)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x244)*((uintptr_t)4089039554ULL))>>64); + x257 = (x244)*((uintptr_t)4234356049ULL); + x258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x244)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x244)*((uintptr_t)4234356049ULL))>>64); + x259 = (x258)+(x255); + x260 = (uintptr_t)((x259)<(x258)); + x261 = (x260)+(x256); + x262 = (uintptr_t)((x261)<(x256)); + x263 = (x261)+(x253); + x264 = (uintptr_t)((x263)<(x253)); + x265 = (x262)+(x264); + x266 = (x265)+(x254); + x267 = (uintptr_t)((x266)<(x254)); + x268 = (x266)+(x251); + x269 = (uintptr_t)((x268)<(x251)); + x270 = (x267)+(x269); + x271 = (x270)+(x252); + x272 = (uintptr_t)((x271)<(x252)); + x273 = (x271)+(x249); + x274 = (uintptr_t)((x273)<(x249)); + x275 = (x272)+(x274); + x276 = (x275)+(x250); + x277 = (uintptr_t)((x276)<(x250)); + x278 = (x276)+(x247); + x279 = (uintptr_t)((x278)<(x247)); + x280 = (x277)+(x279); + x281 = (x280)+(x248); + x282 = (x202)+(x257); + x283 = (uintptr_t)((x282)<(x202)); + x284 = (x283)+(x206); + x285 = (uintptr_t)((x284)<(x206)); + x286 = (x284)+(x259); + x287 = (uintptr_t)((x286)<(x259)); + x288 = (x285)+(x287); + x289 = (x288)+(x211); + x290 = (uintptr_t)((x289)<(x211)); + x291 = (x289)+(x263); + x292 = (uintptr_t)((x291)<(x263)); + x293 = (x290)+(x292); + x294 = (x293)+(x216); + x295 = (uintptr_t)((x294)<(x216)); + x296 = (x294)+(x268); + x297 = (uintptr_t)((x296)<(x268)); + x298 = (x295)+(x297); + x299 = (x298)+(x221); + x300 = (uintptr_t)((x299)<(x221)); + x301 = (x299)+(x273); + x302 = (uintptr_t)((x301)<(x273)); + x303 = (x300)+(x302); + x304 = (x303)+(x226); + x305 = (uintptr_t)((x304)<(x226)); + x306 = (x304)+(x278); + x307 = (uintptr_t)((x306)<(x278)); + x308 = (x305)+(x307); + x309 = (x308)+(x231); + x310 = (uintptr_t)((x309)<(x231)); + x311 = (x309)+(x281); + x312 = (uintptr_t)((x311)<(x281)); + x313 = (x310)+(x312); + x314 = (x313)+(x236); + x315 = (uintptr_t)((x314)<(x236)); + x316 = (x314)+(x245); + x317 = (uintptr_t)((x316)<(x245)); + x318 = (x315)+(x317); + x319 = (x318)+(x241); + x320 = (uintptr_t)((x319)<(x241)); + x321 = (x319)+(x246); + x322 = (uintptr_t)((x321)<(x246)); + x323 = (x320)+(x322); + x324 = (x323)+(x243); + x325 = (x17)*(x15); + x326 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x15))>>32 : ((__uint128_t)(x17)*(x15))>>64); + x327 = (x17)*(x14); + x328 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x14))>>32 : ((__uint128_t)(x17)*(x14))>>64); + x329 = (x17)*(x13); + x330 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x13))>>32 : ((__uint128_t)(x17)*(x13))>>64); + x331 = (x17)*(x12); + x332 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x12))>>32 : ((__uint128_t)(x17)*(x12))>>64); + x333 = (x17)*(x11); + x334 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x11))>>32 : ((__uint128_t)(x17)*(x11))>>64); + x335 = (x17)*(x10); + x336 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x10))>>32 : ((__uint128_t)(x17)*(x10))>>64); + x337 = (x17)*(x9); + x338 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x9))>>32 : ((__uint128_t)(x17)*(x9))>>64); + x339 = (x17)*(x8); + x340 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x8))>>32 : ((__uint128_t)(x17)*(x8))>>64); + x341 = (x340)+(x337); + x342 = (uintptr_t)((x341)<(x340)); + x343 = (x342)+(x338); + x344 = (uintptr_t)((x343)<(x338)); + x345 = (x343)+(x335); + x346 = (uintptr_t)((x345)<(x335)); + x347 = (x344)+(x346); + x348 = (x347)+(x336); + x349 = (uintptr_t)((x348)<(x336)); + x350 = (x348)+(x333); + x351 = (uintptr_t)((x350)<(x333)); + x352 = (x349)+(x351); + x353 = (x352)+(x334); + x354 = (uintptr_t)((x353)<(x334)); + x355 = (x353)+(x331); + x356 = (uintptr_t)((x355)<(x331)); + x357 = (x354)+(x356); + x358 = (x357)+(x332); + x359 = (uintptr_t)((x358)<(x332)); + x360 = (x358)+(x329); + x361 = (uintptr_t)((x360)<(x329)); + x362 = (x359)+(x361); + x363 = (x362)+(x330); + x364 = (uintptr_t)((x363)<(x330)); + x365 = (x363)+(x327); + x366 = (uintptr_t)((x365)<(x327)); + x367 = (x364)+(x366); + x368 = (x367)+(x328); + x369 = (uintptr_t)((x368)<(x328)); + x370 = (x368)+(x325); + x371 = (uintptr_t)((x370)<(x325)); + x372 = (x369)+(x371); + x373 = (x372)+(x326); + x374 = (x286)+(x339); + x375 = (uintptr_t)((x374)<(x286)); + x376 = (x375)+(x291); + x377 = (uintptr_t)((x376)<(x291)); + x378 = (x376)+(x341); + x379 = (uintptr_t)((x378)<(x341)); + x380 = (x377)+(x379); + x381 = (x380)+(x296); + x382 = (uintptr_t)((x381)<(x296)); + x383 = (x381)+(x345); + x384 = (uintptr_t)((x383)<(x345)); + x385 = (x382)+(x384); + x386 = (x385)+(x301); + x387 = (uintptr_t)((x386)<(x301)); + x388 = (x386)+(x350); + x389 = (uintptr_t)((x388)<(x350)); + x390 = (x387)+(x389); + x391 = (x390)+(x306); + x392 = (uintptr_t)((x391)<(x306)); + x393 = (x391)+(x355); + x394 = (uintptr_t)((x393)<(x355)); + x395 = (x392)+(x394); + x396 = (x395)+(x311); + x397 = (uintptr_t)((x396)<(x311)); + x398 = (x396)+(x360); + x399 = (uintptr_t)((x398)<(x360)); + x400 = (x397)+(x399); + x401 = (x400)+(x316); + x402 = (uintptr_t)((x401)<(x316)); + x403 = (x401)+(x365); + x404 = (uintptr_t)((x403)<(x365)); + x405 = (x402)+(x404); + x406 = (x405)+(x321); + x407 = (uintptr_t)((x406)<(x321)); + x408 = (x406)+(x370); + x409 = (uintptr_t)((x408)<(x370)); + x410 = (x407)+(x409); + x411 = (x410)+(x324); + x412 = (uintptr_t)((x411)<(x324)); + x413 = (x411)+(x373); + x414 = (uintptr_t)((x413)<(x373)); + x415 = (x412)+(x414); + x416 = (x374)*((uintptr_t)3993025615ULL); + x417 = (x416)*((uintptr_t)4294967295ULL); + x418 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)4294967295ULL))>>64); + x419 = (x416)*((uintptr_t)4294967295ULL); + x420 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)4294967295ULL))>>64); + x421 = (x416)*((uintptr_t)4294967295ULL); + x422 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)4294967295ULL))>>64); + x423 = (x416)*((uintptr_t)3169254061ULL); + x424 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)3169254061ULL))>>64); + x425 = (x416)*((uintptr_t)2803342980ULL); + x426 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)2803342980ULL))>>64); + x427 = (x416)*((uintptr_t)4089039554ULL); + x428 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)4089039554ULL))>>64); + x429 = (x416)*((uintptr_t)4234356049ULL); + x430 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)4234356049ULL))>>64); + x431 = (x430)+(x427); + x432 = (uintptr_t)((x431)<(x430)); + x433 = (x432)+(x428); + x434 = (uintptr_t)((x433)<(x428)); + x435 = (x433)+(x425); + x436 = (uintptr_t)((x435)<(x425)); + x437 = (x434)+(x436); + x438 = (x437)+(x426); + x439 = (uintptr_t)((x438)<(x426)); + x440 = (x438)+(x423); + x441 = (uintptr_t)((x440)<(x423)); + x442 = (x439)+(x441); + x443 = (x442)+(x424); + x444 = (uintptr_t)((x443)<(x424)); + x445 = (x443)+(x421); + x446 = (uintptr_t)((x445)<(x421)); + x447 = (x444)+(x446); + x448 = (x447)+(x422); + x449 = (uintptr_t)((x448)<(x422)); + x450 = (x448)+(x419); + x451 = (uintptr_t)((x450)<(x419)); + x452 = (x449)+(x451); + x453 = (x452)+(x420); + x454 = (x374)+(x429); + x455 = (uintptr_t)((x454)<(x374)); + x456 = (x455)+(x378); + x457 = (uintptr_t)((x456)<(x378)); + x458 = (x456)+(x431); + x459 = (uintptr_t)((x458)<(x431)); + x460 = (x457)+(x459); + x461 = (x460)+(x383); + x462 = (uintptr_t)((x461)<(x383)); + x463 = (x461)+(x435); + x464 = (uintptr_t)((x463)<(x435)); + x465 = (x462)+(x464); + x466 = (x465)+(x388); + x467 = (uintptr_t)((x466)<(x388)); + x468 = (x466)+(x440); + x469 = (uintptr_t)((x468)<(x440)); + x470 = (x467)+(x469); + x471 = (x470)+(x393); + x472 = (uintptr_t)((x471)<(x393)); + x473 = (x471)+(x445); + x474 = (uintptr_t)((x473)<(x445)); + x475 = (x472)+(x474); + x476 = (x475)+(x398); + x477 = (uintptr_t)((x476)<(x398)); + x478 = (x476)+(x450); + x479 = (uintptr_t)((x478)<(x450)); + x480 = (x477)+(x479); + x481 = (x480)+(x403); + x482 = (uintptr_t)((x481)<(x403)); + x483 = (x481)+(x453); + x484 = (uintptr_t)((x483)<(x453)); + x485 = (x482)+(x484); + x486 = (x485)+(x408); + x487 = (uintptr_t)((x486)<(x408)); + x488 = (x486)+(x417); + x489 = (uintptr_t)((x488)<(x417)); + x490 = (x487)+(x489); + x491 = (x490)+(x413); + x492 = (uintptr_t)((x491)<(x413)); + x493 = (x491)+(x418); + x494 = (uintptr_t)((x493)<(x418)); + x495 = (x492)+(x494); + x496 = (x495)+(x415); + x497 = (x18)*(x15); + x498 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x15))>>32 : ((__uint128_t)(x18)*(x15))>>64); + x499 = (x18)*(x14); + x500 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x14))>>32 : ((__uint128_t)(x18)*(x14))>>64); + x501 = (x18)*(x13); + x502 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x13))>>32 : ((__uint128_t)(x18)*(x13))>>64); + x503 = (x18)*(x12); + x504 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x12))>>32 : ((__uint128_t)(x18)*(x12))>>64); + x505 = (x18)*(x11); + x506 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x11))>>32 : ((__uint128_t)(x18)*(x11))>>64); + x507 = (x18)*(x10); + x508 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x10))>>32 : ((__uint128_t)(x18)*(x10))>>64); + x509 = (x18)*(x9); + x510 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x9))>>32 : ((__uint128_t)(x18)*(x9))>>64); + x511 = (x18)*(x8); + x512 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x8))>>32 : ((__uint128_t)(x18)*(x8))>>64); + x513 = (x512)+(x509); + x514 = (uintptr_t)((x513)<(x512)); + x515 = (x514)+(x510); + x516 = (uintptr_t)((x515)<(x510)); + x517 = (x515)+(x507); + x518 = (uintptr_t)((x517)<(x507)); + x519 = (x516)+(x518); + x520 = (x519)+(x508); + x521 = (uintptr_t)((x520)<(x508)); + x522 = (x520)+(x505); + x523 = (uintptr_t)((x522)<(x505)); + x524 = (x521)+(x523); + x525 = (x524)+(x506); + x526 = (uintptr_t)((x525)<(x506)); + x527 = (x525)+(x503); + x528 = (uintptr_t)((x527)<(x503)); + x529 = (x526)+(x528); + x530 = (x529)+(x504); + x531 = (uintptr_t)((x530)<(x504)); + x532 = (x530)+(x501); + x533 = (uintptr_t)((x532)<(x501)); + x534 = (x531)+(x533); + x535 = (x534)+(x502); + x536 = (uintptr_t)((x535)<(x502)); + x537 = (x535)+(x499); + x538 = (uintptr_t)((x537)<(x499)); + x539 = (x536)+(x538); + x540 = (x539)+(x500); + x541 = (uintptr_t)((x540)<(x500)); + x542 = (x540)+(x497); + x543 = (uintptr_t)((x542)<(x497)); + x544 = (x541)+(x543); + x545 = (x544)+(x498); + x546 = (x458)+(x511); + x547 = (uintptr_t)((x546)<(x458)); + x548 = (x547)+(x463); + x549 = (uintptr_t)((x548)<(x463)); + x550 = (x548)+(x513); + x551 = (uintptr_t)((x550)<(x513)); + x552 = (x549)+(x551); + x553 = (x552)+(x468); + x554 = (uintptr_t)((x553)<(x468)); + x555 = (x553)+(x517); + x556 = (uintptr_t)((x555)<(x517)); + x557 = (x554)+(x556); + x558 = (x557)+(x473); + x559 = (uintptr_t)((x558)<(x473)); + x560 = (x558)+(x522); + x561 = (uintptr_t)((x560)<(x522)); + x562 = (x559)+(x561); + x563 = (x562)+(x478); + x564 = (uintptr_t)((x563)<(x478)); + x565 = (x563)+(x527); + x566 = (uintptr_t)((x565)<(x527)); + x567 = (x564)+(x566); + x568 = (x567)+(x483); + x569 = (uintptr_t)((x568)<(x483)); + x570 = (x568)+(x532); + x571 = (uintptr_t)((x570)<(x532)); + x572 = (x569)+(x571); + x573 = (x572)+(x488); + x574 = (uintptr_t)((x573)<(x488)); + x575 = (x573)+(x537); + x576 = (uintptr_t)((x575)<(x537)); + x577 = (x574)+(x576); + x578 = (x577)+(x493); + x579 = (uintptr_t)((x578)<(x493)); + x580 = (x578)+(x542); + x581 = (uintptr_t)((x580)<(x542)); + x582 = (x579)+(x581); + x583 = (x582)+(x496); + x584 = (uintptr_t)((x583)<(x496)); + x585 = (x583)+(x545); + x586 = (uintptr_t)((x585)<(x545)); + x587 = (x584)+(x586); + x588 = (x546)*((uintptr_t)3993025615ULL); + x589 = (x588)*((uintptr_t)4294967295ULL); + x590 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x588)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x588)*((uintptr_t)4294967295ULL))>>64); + x591 = (x588)*((uintptr_t)4294967295ULL); + x592 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x588)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x588)*((uintptr_t)4294967295ULL))>>64); + x593 = (x588)*((uintptr_t)4294967295ULL); + x594 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x588)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x588)*((uintptr_t)4294967295ULL))>>64); + x595 = (x588)*((uintptr_t)3169254061ULL); + x596 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x588)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x588)*((uintptr_t)3169254061ULL))>>64); + x597 = (x588)*((uintptr_t)2803342980ULL); + x598 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x588)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x588)*((uintptr_t)2803342980ULL))>>64); + x599 = (x588)*((uintptr_t)4089039554ULL); + x600 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x588)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x588)*((uintptr_t)4089039554ULL))>>64); + x601 = (x588)*((uintptr_t)4234356049ULL); + x602 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x588)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x588)*((uintptr_t)4234356049ULL))>>64); + x603 = (x602)+(x599); + x604 = (uintptr_t)((x603)<(x602)); + x605 = (x604)+(x600); + x606 = (uintptr_t)((x605)<(x600)); + x607 = (x605)+(x597); + x608 = (uintptr_t)((x607)<(x597)); + x609 = (x606)+(x608); + x610 = (x609)+(x598); + x611 = (uintptr_t)((x610)<(x598)); + x612 = (x610)+(x595); + x613 = (uintptr_t)((x612)<(x595)); + x614 = (x611)+(x613); + x615 = (x614)+(x596); + x616 = (uintptr_t)((x615)<(x596)); + x617 = (x615)+(x593); + x618 = (uintptr_t)((x617)<(x593)); + x619 = (x616)+(x618); + x620 = (x619)+(x594); + x621 = (uintptr_t)((x620)<(x594)); + x622 = (x620)+(x591); + x623 = (uintptr_t)((x622)<(x591)); + x624 = (x621)+(x623); + x625 = (x624)+(x592); + x626 = (x546)+(x601); + x627 = (uintptr_t)((x626)<(x546)); + x628 = (x627)+(x550); + x629 = (uintptr_t)((x628)<(x550)); + x630 = (x628)+(x603); + x631 = (uintptr_t)((x630)<(x603)); + x632 = (x629)+(x631); + x633 = (x632)+(x555); + x634 = (uintptr_t)((x633)<(x555)); + x635 = (x633)+(x607); + x636 = (uintptr_t)((x635)<(x607)); + x637 = (x634)+(x636); + x638 = (x637)+(x560); + x639 = (uintptr_t)((x638)<(x560)); + x640 = (x638)+(x612); + x641 = (uintptr_t)((x640)<(x612)); + x642 = (x639)+(x641); + x643 = (x642)+(x565); + x644 = (uintptr_t)((x643)<(x565)); + x645 = (x643)+(x617); + x646 = (uintptr_t)((x645)<(x617)); + x647 = (x644)+(x646); + x648 = (x647)+(x570); + x649 = (uintptr_t)((x648)<(x570)); + x650 = (x648)+(x622); + x651 = (uintptr_t)((x650)<(x622)); + x652 = (x649)+(x651); + x653 = (x652)+(x575); + x654 = (uintptr_t)((x653)<(x575)); + x655 = (x653)+(x625); + x656 = (uintptr_t)((x655)<(x625)); + x657 = (x654)+(x656); + x658 = (x657)+(x580); + x659 = (uintptr_t)((x658)<(x580)); + x660 = (x658)+(x589); + x661 = (uintptr_t)((x660)<(x589)); + x662 = (x659)+(x661); + x663 = (x662)+(x585); + x664 = (uintptr_t)((x663)<(x585)); + x665 = (x663)+(x590); + x666 = (uintptr_t)((x665)<(x590)); + x667 = (x664)+(x666); + x668 = (x667)+(x587); + x669 = (x19)*(x15); + x670 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x15))>>32 : ((__uint128_t)(x19)*(x15))>>64); + x671 = (x19)*(x14); + x672 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x14))>>32 : ((__uint128_t)(x19)*(x14))>>64); + x673 = (x19)*(x13); + x674 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x13))>>32 : ((__uint128_t)(x19)*(x13))>>64); + x675 = (x19)*(x12); + x676 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x12))>>32 : ((__uint128_t)(x19)*(x12))>>64); + x677 = (x19)*(x11); + x678 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x11))>>32 : ((__uint128_t)(x19)*(x11))>>64); + x679 = (x19)*(x10); + x680 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x10))>>32 : ((__uint128_t)(x19)*(x10))>>64); + x681 = (x19)*(x9); + x682 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x9))>>32 : ((__uint128_t)(x19)*(x9))>>64); + x683 = (x19)*(x8); + x684 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x8))>>32 : ((__uint128_t)(x19)*(x8))>>64); + x685 = (x684)+(x681); + x686 = (uintptr_t)((x685)<(x684)); + x687 = (x686)+(x682); + x688 = (uintptr_t)((x687)<(x682)); + x689 = (x687)+(x679); + x690 = (uintptr_t)((x689)<(x679)); + x691 = (x688)+(x690); + x692 = (x691)+(x680); + x693 = (uintptr_t)((x692)<(x680)); + x694 = (x692)+(x677); + x695 = (uintptr_t)((x694)<(x677)); + x696 = (x693)+(x695); + x697 = (x696)+(x678); + x698 = (uintptr_t)((x697)<(x678)); + x699 = (x697)+(x675); + x700 = (uintptr_t)((x699)<(x675)); + x701 = (x698)+(x700); + x702 = (x701)+(x676); + x703 = (uintptr_t)((x702)<(x676)); + x704 = (x702)+(x673); + x705 = (uintptr_t)((x704)<(x673)); + x706 = (x703)+(x705); + x707 = (x706)+(x674); + x708 = (uintptr_t)((x707)<(x674)); + x709 = (x707)+(x671); + x710 = (uintptr_t)((x709)<(x671)); + x711 = (x708)+(x710); + x712 = (x711)+(x672); + x713 = (uintptr_t)((x712)<(x672)); + x714 = (x712)+(x669); + x715 = (uintptr_t)((x714)<(x669)); + x716 = (x713)+(x715); + x717 = (x716)+(x670); + x718 = (x630)+(x683); + x719 = (uintptr_t)((x718)<(x630)); + x720 = (x719)+(x635); + x721 = (uintptr_t)((x720)<(x635)); + x722 = (x720)+(x685); + x723 = (uintptr_t)((x722)<(x685)); + x724 = (x721)+(x723); + x725 = (x724)+(x640); + x726 = (uintptr_t)((x725)<(x640)); + x727 = (x725)+(x689); + x728 = (uintptr_t)((x727)<(x689)); + x729 = (x726)+(x728); + x730 = (x729)+(x645); + x731 = (uintptr_t)((x730)<(x645)); + x732 = (x730)+(x694); + x733 = (uintptr_t)((x732)<(x694)); + x734 = (x731)+(x733); + x735 = (x734)+(x650); + x736 = (uintptr_t)((x735)<(x650)); + x737 = (x735)+(x699); + x738 = (uintptr_t)((x737)<(x699)); + x739 = (x736)+(x738); + x740 = (x739)+(x655); + x741 = (uintptr_t)((x740)<(x655)); + x742 = (x740)+(x704); + x743 = (uintptr_t)((x742)<(x704)); + x744 = (x741)+(x743); + x745 = (x744)+(x660); + x746 = (uintptr_t)((x745)<(x660)); + x747 = (x745)+(x709); + x748 = (uintptr_t)((x747)<(x709)); + x749 = (x746)+(x748); + x750 = (x749)+(x665); + x751 = (uintptr_t)((x750)<(x665)); + x752 = (x750)+(x714); + x753 = (uintptr_t)((x752)<(x714)); + x754 = (x751)+(x753); + x755 = (x754)+(x668); + x756 = (uintptr_t)((x755)<(x668)); + x757 = (x755)+(x717); + x758 = (uintptr_t)((x757)<(x717)); + x759 = (x756)+(x758); + x760 = (x718)*((uintptr_t)3993025615ULL); + x761 = (x760)*((uintptr_t)4294967295ULL); + x762 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x760)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x760)*((uintptr_t)4294967295ULL))>>64); + x763 = (x760)*((uintptr_t)4294967295ULL); + x764 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x760)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x760)*((uintptr_t)4294967295ULL))>>64); + x765 = (x760)*((uintptr_t)4294967295ULL); + x766 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x760)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x760)*((uintptr_t)4294967295ULL))>>64); + x767 = (x760)*((uintptr_t)3169254061ULL); + x768 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x760)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x760)*((uintptr_t)3169254061ULL))>>64); + x769 = (x760)*((uintptr_t)2803342980ULL); + x770 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x760)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x760)*((uintptr_t)2803342980ULL))>>64); + x771 = (x760)*((uintptr_t)4089039554ULL); + x772 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x760)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x760)*((uintptr_t)4089039554ULL))>>64); + x773 = (x760)*((uintptr_t)4234356049ULL); + x774 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x760)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x760)*((uintptr_t)4234356049ULL))>>64); + x775 = (x774)+(x771); + x776 = (uintptr_t)((x775)<(x774)); + x777 = (x776)+(x772); + x778 = (uintptr_t)((x777)<(x772)); + x779 = (x777)+(x769); + x780 = (uintptr_t)((x779)<(x769)); + x781 = (x778)+(x780); + x782 = (x781)+(x770); + x783 = (uintptr_t)((x782)<(x770)); + x784 = (x782)+(x767); + x785 = (uintptr_t)((x784)<(x767)); + x786 = (x783)+(x785); + x787 = (x786)+(x768); + x788 = (uintptr_t)((x787)<(x768)); + x789 = (x787)+(x765); + x790 = (uintptr_t)((x789)<(x765)); + x791 = (x788)+(x790); + x792 = (x791)+(x766); + x793 = (uintptr_t)((x792)<(x766)); + x794 = (x792)+(x763); + x795 = (uintptr_t)((x794)<(x763)); + x796 = (x793)+(x795); + x797 = (x796)+(x764); + x798 = (x718)+(x773); + x799 = (uintptr_t)((x798)<(x718)); + x800 = (x799)+(x722); + x801 = (uintptr_t)((x800)<(x722)); + x802 = (x800)+(x775); + x803 = (uintptr_t)((x802)<(x775)); + x804 = (x801)+(x803); + x805 = (x804)+(x727); + x806 = (uintptr_t)((x805)<(x727)); + x807 = (x805)+(x779); + x808 = (uintptr_t)((x807)<(x779)); + x809 = (x806)+(x808); + x810 = (x809)+(x732); + x811 = (uintptr_t)((x810)<(x732)); + x812 = (x810)+(x784); + x813 = (uintptr_t)((x812)<(x784)); + x814 = (x811)+(x813); + x815 = (x814)+(x737); + x816 = (uintptr_t)((x815)<(x737)); + x817 = (x815)+(x789); + x818 = (uintptr_t)((x817)<(x789)); + x819 = (x816)+(x818); + x820 = (x819)+(x742); + x821 = (uintptr_t)((x820)<(x742)); + x822 = (x820)+(x794); + x823 = (uintptr_t)((x822)<(x794)); + x824 = (x821)+(x823); + x825 = (x824)+(x747); + x826 = (uintptr_t)((x825)<(x747)); + x827 = (x825)+(x797); + x828 = (uintptr_t)((x827)<(x797)); + x829 = (x826)+(x828); + x830 = (x829)+(x752); + x831 = (uintptr_t)((x830)<(x752)); + x832 = (x830)+(x761); + x833 = (uintptr_t)((x832)<(x761)); + x834 = (x831)+(x833); + x835 = (x834)+(x757); + x836 = (uintptr_t)((x835)<(x757)); + x837 = (x835)+(x762); + x838 = (uintptr_t)((x837)<(x762)); + x839 = (x836)+(x838); + x840 = (x839)+(x759); + x841 = (x20)*(x15); + x842 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x15))>>32 : ((__uint128_t)(x20)*(x15))>>64); + x843 = (x20)*(x14); + x844 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x14))>>32 : ((__uint128_t)(x20)*(x14))>>64); + x845 = (x20)*(x13); + x846 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x13))>>32 : ((__uint128_t)(x20)*(x13))>>64); + x847 = (x20)*(x12); + x848 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x12))>>32 : ((__uint128_t)(x20)*(x12))>>64); + x849 = (x20)*(x11); + x850 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x11))>>32 : ((__uint128_t)(x20)*(x11))>>64); + x851 = (x20)*(x10); + x852 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x10))>>32 : ((__uint128_t)(x20)*(x10))>>64); + x853 = (x20)*(x9); + x854 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x9))>>32 : ((__uint128_t)(x20)*(x9))>>64); + x855 = (x20)*(x8); + x856 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x8))>>32 : ((__uint128_t)(x20)*(x8))>>64); + x857 = (x856)+(x853); + x858 = (uintptr_t)((x857)<(x856)); + x859 = (x858)+(x854); + x860 = (uintptr_t)((x859)<(x854)); + x861 = (x859)+(x851); + x862 = (uintptr_t)((x861)<(x851)); + x863 = (x860)+(x862); + x864 = (x863)+(x852); + x865 = (uintptr_t)((x864)<(x852)); + x866 = (x864)+(x849); + x867 = (uintptr_t)((x866)<(x849)); + x868 = (x865)+(x867); + x869 = (x868)+(x850); + x870 = (uintptr_t)((x869)<(x850)); + x871 = (x869)+(x847); + x872 = (uintptr_t)((x871)<(x847)); + x873 = (x870)+(x872); + x874 = (x873)+(x848); + x875 = (uintptr_t)((x874)<(x848)); + x876 = (x874)+(x845); + x877 = (uintptr_t)((x876)<(x845)); + x878 = (x875)+(x877); + x879 = (x878)+(x846); + x880 = (uintptr_t)((x879)<(x846)); + x881 = (x879)+(x843); + x882 = (uintptr_t)((x881)<(x843)); + x883 = (x880)+(x882); + x884 = (x883)+(x844); + x885 = (uintptr_t)((x884)<(x844)); + x886 = (x884)+(x841); + x887 = (uintptr_t)((x886)<(x841)); + x888 = (x885)+(x887); + x889 = (x888)+(x842); + x890 = (x802)+(x855); + x891 = (uintptr_t)((x890)<(x802)); + x892 = (x891)+(x807); + x893 = (uintptr_t)((x892)<(x807)); + x894 = (x892)+(x857); + x895 = (uintptr_t)((x894)<(x857)); + x896 = (x893)+(x895); + x897 = (x896)+(x812); + x898 = (uintptr_t)((x897)<(x812)); + x899 = (x897)+(x861); + x900 = (uintptr_t)((x899)<(x861)); + x901 = (x898)+(x900); + x902 = (x901)+(x817); + x903 = (uintptr_t)((x902)<(x817)); + x904 = (x902)+(x866); + x905 = (uintptr_t)((x904)<(x866)); + x906 = (x903)+(x905); + x907 = (x906)+(x822); + x908 = (uintptr_t)((x907)<(x822)); + x909 = (x907)+(x871); + x910 = (uintptr_t)((x909)<(x871)); + x911 = (x908)+(x910); + x912 = (x911)+(x827); + x913 = (uintptr_t)((x912)<(x827)); + x914 = (x912)+(x876); + x915 = (uintptr_t)((x914)<(x876)); + x916 = (x913)+(x915); + x917 = (x916)+(x832); + x918 = (uintptr_t)((x917)<(x832)); + x919 = (x917)+(x881); + x920 = (uintptr_t)((x919)<(x881)); + x921 = (x918)+(x920); + x922 = (x921)+(x837); + x923 = (uintptr_t)((x922)<(x837)); + x924 = (x922)+(x886); + x925 = (uintptr_t)((x924)<(x886)); + x926 = (x923)+(x925); + x927 = (x926)+(x840); + x928 = (uintptr_t)((x927)<(x840)); + x929 = (x927)+(x889); + x930 = (uintptr_t)((x929)<(x889)); + x931 = (x928)+(x930); + x932 = (x890)*((uintptr_t)3993025615ULL); + x933 = (x932)*((uintptr_t)4294967295ULL); + x934 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x932)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x932)*((uintptr_t)4294967295ULL))>>64); + x935 = (x932)*((uintptr_t)4294967295ULL); + x936 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x932)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x932)*((uintptr_t)4294967295ULL))>>64); + x937 = (x932)*((uintptr_t)4294967295ULL); + x938 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x932)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x932)*((uintptr_t)4294967295ULL))>>64); + x939 = (x932)*((uintptr_t)3169254061ULL); + x940 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x932)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x932)*((uintptr_t)3169254061ULL))>>64); + x941 = (x932)*((uintptr_t)2803342980ULL); + x942 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x932)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x932)*((uintptr_t)2803342980ULL))>>64); + x943 = (x932)*((uintptr_t)4089039554ULL); + x944 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x932)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x932)*((uintptr_t)4089039554ULL))>>64); + x945 = (x932)*((uintptr_t)4234356049ULL); + x946 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x932)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x932)*((uintptr_t)4234356049ULL))>>64); + x947 = (x946)+(x943); + x948 = (uintptr_t)((x947)<(x946)); + x949 = (x948)+(x944); + x950 = (uintptr_t)((x949)<(x944)); + x951 = (x949)+(x941); + x952 = (uintptr_t)((x951)<(x941)); + x953 = (x950)+(x952); + x954 = (x953)+(x942); + x955 = (uintptr_t)((x954)<(x942)); + x956 = (x954)+(x939); + x957 = (uintptr_t)((x956)<(x939)); + x958 = (x955)+(x957); + x959 = (x958)+(x940); + x960 = (uintptr_t)((x959)<(x940)); + x961 = (x959)+(x937); + x962 = (uintptr_t)((x961)<(x937)); + x963 = (x960)+(x962); + x964 = (x963)+(x938); + x965 = (uintptr_t)((x964)<(x938)); + x966 = (x964)+(x935); + x967 = (uintptr_t)((x966)<(x935)); + x968 = (x965)+(x967); + x969 = (x968)+(x936); + x970 = (x890)+(x945); + x971 = (uintptr_t)((x970)<(x890)); + x972 = (x971)+(x894); + x973 = (uintptr_t)((x972)<(x894)); + x974 = (x972)+(x947); + x975 = (uintptr_t)((x974)<(x947)); + x976 = (x973)+(x975); + x977 = (x976)+(x899); + x978 = (uintptr_t)((x977)<(x899)); + x979 = (x977)+(x951); + x980 = (uintptr_t)((x979)<(x951)); + x981 = (x978)+(x980); + x982 = (x981)+(x904); + x983 = (uintptr_t)((x982)<(x904)); + x984 = (x982)+(x956); + x985 = (uintptr_t)((x984)<(x956)); + x986 = (x983)+(x985); + x987 = (x986)+(x909); + x988 = (uintptr_t)((x987)<(x909)); + x989 = (x987)+(x961); + x990 = (uintptr_t)((x989)<(x961)); + x991 = (x988)+(x990); + x992 = (x991)+(x914); + x993 = (uintptr_t)((x992)<(x914)); + x994 = (x992)+(x966); + x995 = (uintptr_t)((x994)<(x966)); + x996 = (x993)+(x995); + x997 = (x996)+(x919); + x998 = (uintptr_t)((x997)<(x919)); + x999 = (x997)+(x969); + x1000 = (uintptr_t)((x999)<(x969)); + x1001 = (x998)+(x1000); + x1002 = (x1001)+(x924); + x1003 = (uintptr_t)((x1002)<(x924)); + x1004 = (x1002)+(x933); + x1005 = (uintptr_t)((x1004)<(x933)); + x1006 = (x1003)+(x1005); + x1007 = (x1006)+(x929); + x1008 = (uintptr_t)((x1007)<(x929)); + x1009 = (x1007)+(x934); + x1010 = (uintptr_t)((x1009)<(x934)); + x1011 = (x1008)+(x1010); + x1012 = (x1011)+(x931); + x1013 = (x21)*(x15); + x1014 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x15))>>32 : ((__uint128_t)(x21)*(x15))>>64); + x1015 = (x21)*(x14); + x1016 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x14))>>32 : ((__uint128_t)(x21)*(x14))>>64); + x1017 = (x21)*(x13); + x1018 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x13))>>32 : ((__uint128_t)(x21)*(x13))>>64); + x1019 = (x21)*(x12); + x1020 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x12))>>32 : ((__uint128_t)(x21)*(x12))>>64); + x1021 = (x21)*(x11); + x1022 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x11))>>32 : ((__uint128_t)(x21)*(x11))>>64); + x1023 = (x21)*(x10); + x1024 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x10))>>32 : ((__uint128_t)(x21)*(x10))>>64); + x1025 = (x21)*(x9); + x1026 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x9))>>32 : ((__uint128_t)(x21)*(x9))>>64); + x1027 = (x21)*(x8); + x1028 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x8))>>32 : ((__uint128_t)(x21)*(x8))>>64); + x1029 = (x1028)+(x1025); + x1030 = (uintptr_t)((x1029)<(x1028)); + x1031 = (x1030)+(x1026); + x1032 = (uintptr_t)((x1031)<(x1026)); + x1033 = (x1031)+(x1023); + x1034 = (uintptr_t)((x1033)<(x1023)); + x1035 = (x1032)+(x1034); + x1036 = (x1035)+(x1024); + x1037 = (uintptr_t)((x1036)<(x1024)); + x1038 = (x1036)+(x1021); + x1039 = (uintptr_t)((x1038)<(x1021)); + x1040 = (x1037)+(x1039); + x1041 = (x1040)+(x1022); + x1042 = (uintptr_t)((x1041)<(x1022)); + x1043 = (x1041)+(x1019); + x1044 = (uintptr_t)((x1043)<(x1019)); + x1045 = (x1042)+(x1044); + x1046 = (x1045)+(x1020); + x1047 = (uintptr_t)((x1046)<(x1020)); + x1048 = (x1046)+(x1017); + x1049 = (uintptr_t)((x1048)<(x1017)); + x1050 = (x1047)+(x1049); + x1051 = (x1050)+(x1018); + x1052 = (uintptr_t)((x1051)<(x1018)); + x1053 = (x1051)+(x1015); + x1054 = (uintptr_t)((x1053)<(x1015)); + x1055 = (x1052)+(x1054); + x1056 = (x1055)+(x1016); + x1057 = (uintptr_t)((x1056)<(x1016)); + x1058 = (x1056)+(x1013); + x1059 = (uintptr_t)((x1058)<(x1013)); + x1060 = (x1057)+(x1059); + x1061 = (x1060)+(x1014); + x1062 = (x974)+(x1027); + x1063 = (uintptr_t)((x1062)<(x974)); + x1064 = (x1063)+(x979); + x1065 = (uintptr_t)((x1064)<(x979)); + x1066 = (x1064)+(x1029); + x1067 = (uintptr_t)((x1066)<(x1029)); + x1068 = (x1065)+(x1067); + x1069 = (x1068)+(x984); + x1070 = (uintptr_t)((x1069)<(x984)); + x1071 = (x1069)+(x1033); + x1072 = (uintptr_t)((x1071)<(x1033)); + x1073 = (x1070)+(x1072); + x1074 = (x1073)+(x989); + x1075 = (uintptr_t)((x1074)<(x989)); + x1076 = (x1074)+(x1038); + x1077 = (uintptr_t)((x1076)<(x1038)); + x1078 = (x1075)+(x1077); + x1079 = (x1078)+(x994); + x1080 = (uintptr_t)((x1079)<(x994)); + x1081 = (x1079)+(x1043); + x1082 = (uintptr_t)((x1081)<(x1043)); + x1083 = (x1080)+(x1082); + x1084 = (x1083)+(x999); + x1085 = (uintptr_t)((x1084)<(x999)); + x1086 = (x1084)+(x1048); + x1087 = (uintptr_t)((x1086)<(x1048)); + x1088 = (x1085)+(x1087); + x1089 = (x1088)+(x1004); + x1090 = (uintptr_t)((x1089)<(x1004)); + x1091 = (x1089)+(x1053); + x1092 = (uintptr_t)((x1091)<(x1053)); + x1093 = (x1090)+(x1092); + x1094 = (x1093)+(x1009); + x1095 = (uintptr_t)((x1094)<(x1009)); + x1096 = (x1094)+(x1058); + x1097 = (uintptr_t)((x1096)<(x1058)); + x1098 = (x1095)+(x1097); + x1099 = (x1098)+(x1012); + x1100 = (uintptr_t)((x1099)<(x1012)); + x1101 = (x1099)+(x1061); + x1102 = (uintptr_t)((x1101)<(x1061)); + x1103 = (x1100)+(x1102); + x1104 = (x1062)*((uintptr_t)3993025615ULL); + x1105 = (x1104)*((uintptr_t)4294967295ULL); + x1106 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1104)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1104)*((uintptr_t)4294967295ULL))>>64); + x1107 = (x1104)*((uintptr_t)4294967295ULL); + x1108 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1104)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1104)*((uintptr_t)4294967295ULL))>>64); + x1109 = (x1104)*((uintptr_t)4294967295ULL); + x1110 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1104)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1104)*((uintptr_t)4294967295ULL))>>64); + x1111 = (x1104)*((uintptr_t)3169254061ULL); + x1112 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1104)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x1104)*((uintptr_t)3169254061ULL))>>64); + x1113 = (x1104)*((uintptr_t)2803342980ULL); + x1114 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1104)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x1104)*((uintptr_t)2803342980ULL))>>64); + x1115 = (x1104)*((uintptr_t)4089039554ULL); + x1116 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1104)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x1104)*((uintptr_t)4089039554ULL))>>64); + x1117 = (x1104)*((uintptr_t)4234356049ULL); + x1118 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1104)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x1104)*((uintptr_t)4234356049ULL))>>64); + x1119 = (x1118)+(x1115); + x1120 = (uintptr_t)((x1119)<(x1118)); + x1121 = (x1120)+(x1116); + x1122 = (uintptr_t)((x1121)<(x1116)); + x1123 = (x1121)+(x1113); + x1124 = (uintptr_t)((x1123)<(x1113)); + x1125 = (x1122)+(x1124); + x1126 = (x1125)+(x1114); + x1127 = (uintptr_t)((x1126)<(x1114)); + x1128 = (x1126)+(x1111); + x1129 = (uintptr_t)((x1128)<(x1111)); + x1130 = (x1127)+(x1129); + x1131 = (x1130)+(x1112); + x1132 = (uintptr_t)((x1131)<(x1112)); + x1133 = (x1131)+(x1109); + x1134 = (uintptr_t)((x1133)<(x1109)); + x1135 = (x1132)+(x1134); + x1136 = (x1135)+(x1110); + x1137 = (uintptr_t)((x1136)<(x1110)); + x1138 = (x1136)+(x1107); + x1139 = (uintptr_t)((x1138)<(x1107)); + x1140 = (x1137)+(x1139); + x1141 = (x1140)+(x1108); + x1142 = (x1062)+(x1117); + x1143 = (uintptr_t)((x1142)<(x1062)); + x1144 = (x1143)+(x1066); + x1145 = (uintptr_t)((x1144)<(x1066)); + x1146 = (x1144)+(x1119); + x1147 = (uintptr_t)((x1146)<(x1119)); + x1148 = (x1145)+(x1147); + x1149 = (x1148)+(x1071); + x1150 = (uintptr_t)((x1149)<(x1071)); + x1151 = (x1149)+(x1123); + x1152 = (uintptr_t)((x1151)<(x1123)); + x1153 = (x1150)+(x1152); + x1154 = (x1153)+(x1076); + x1155 = (uintptr_t)((x1154)<(x1076)); + x1156 = (x1154)+(x1128); + x1157 = (uintptr_t)((x1156)<(x1128)); + x1158 = (x1155)+(x1157); + x1159 = (x1158)+(x1081); + x1160 = (uintptr_t)((x1159)<(x1081)); + x1161 = (x1159)+(x1133); + x1162 = (uintptr_t)((x1161)<(x1133)); + x1163 = (x1160)+(x1162); + x1164 = (x1163)+(x1086); + x1165 = (uintptr_t)((x1164)<(x1086)); + x1166 = (x1164)+(x1138); + x1167 = (uintptr_t)((x1166)<(x1138)); + x1168 = (x1165)+(x1167); + x1169 = (x1168)+(x1091); + x1170 = (uintptr_t)((x1169)<(x1091)); + x1171 = (x1169)+(x1141); + x1172 = (uintptr_t)((x1171)<(x1141)); + x1173 = (x1170)+(x1172); + x1174 = (x1173)+(x1096); + x1175 = (uintptr_t)((x1174)<(x1096)); + x1176 = (x1174)+(x1105); + x1177 = (uintptr_t)((x1176)<(x1105)); + x1178 = (x1175)+(x1177); + x1179 = (x1178)+(x1101); + x1180 = (uintptr_t)((x1179)<(x1101)); + x1181 = (x1179)+(x1106); + x1182 = (uintptr_t)((x1181)<(x1106)); + x1183 = (x1180)+(x1182); + x1184 = (x1183)+(x1103); + x1185 = (x22)*(x15); + x1186 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x15))>>32 : ((__uint128_t)(x22)*(x15))>>64); + x1187 = (x22)*(x14); + x1188 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x14))>>32 : ((__uint128_t)(x22)*(x14))>>64); + x1189 = (x22)*(x13); + x1190 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x13))>>32 : ((__uint128_t)(x22)*(x13))>>64); + x1191 = (x22)*(x12); + x1192 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x12))>>32 : ((__uint128_t)(x22)*(x12))>>64); + x1193 = (x22)*(x11); + x1194 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x11))>>32 : ((__uint128_t)(x22)*(x11))>>64); + x1195 = (x22)*(x10); + x1196 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x10))>>32 : ((__uint128_t)(x22)*(x10))>>64); + x1197 = (x22)*(x9); + x1198 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x9))>>32 : ((__uint128_t)(x22)*(x9))>>64); + x1199 = (x22)*(x8); + x1200 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x8))>>32 : ((__uint128_t)(x22)*(x8))>>64); + x1201 = (x1200)+(x1197); + x1202 = (uintptr_t)((x1201)<(x1200)); + x1203 = (x1202)+(x1198); + x1204 = (uintptr_t)((x1203)<(x1198)); + x1205 = (x1203)+(x1195); + x1206 = (uintptr_t)((x1205)<(x1195)); + x1207 = (x1204)+(x1206); + x1208 = (x1207)+(x1196); + x1209 = (uintptr_t)((x1208)<(x1196)); + x1210 = (x1208)+(x1193); + x1211 = (uintptr_t)((x1210)<(x1193)); + x1212 = (x1209)+(x1211); + x1213 = (x1212)+(x1194); + x1214 = (uintptr_t)((x1213)<(x1194)); + x1215 = (x1213)+(x1191); + x1216 = (uintptr_t)((x1215)<(x1191)); + x1217 = (x1214)+(x1216); + x1218 = (x1217)+(x1192); + x1219 = (uintptr_t)((x1218)<(x1192)); + x1220 = (x1218)+(x1189); + x1221 = (uintptr_t)((x1220)<(x1189)); + x1222 = (x1219)+(x1221); + x1223 = (x1222)+(x1190); + x1224 = (uintptr_t)((x1223)<(x1190)); + x1225 = (x1223)+(x1187); + x1226 = (uintptr_t)((x1225)<(x1187)); + x1227 = (x1224)+(x1226); + x1228 = (x1227)+(x1188); + x1229 = (uintptr_t)((x1228)<(x1188)); + x1230 = (x1228)+(x1185); + x1231 = (uintptr_t)((x1230)<(x1185)); + x1232 = (x1229)+(x1231); + x1233 = (x1232)+(x1186); + x1234 = (x1146)+(x1199); + x1235 = (uintptr_t)((x1234)<(x1146)); + x1236 = (x1235)+(x1151); + x1237 = (uintptr_t)((x1236)<(x1151)); + x1238 = (x1236)+(x1201); + x1239 = (uintptr_t)((x1238)<(x1201)); + x1240 = (x1237)+(x1239); + x1241 = (x1240)+(x1156); + x1242 = (uintptr_t)((x1241)<(x1156)); + x1243 = (x1241)+(x1205); + x1244 = (uintptr_t)((x1243)<(x1205)); + x1245 = (x1242)+(x1244); + x1246 = (x1245)+(x1161); + x1247 = (uintptr_t)((x1246)<(x1161)); + x1248 = (x1246)+(x1210); + x1249 = (uintptr_t)((x1248)<(x1210)); + x1250 = (x1247)+(x1249); + x1251 = (x1250)+(x1166); + x1252 = (uintptr_t)((x1251)<(x1166)); + x1253 = (x1251)+(x1215); + x1254 = (uintptr_t)((x1253)<(x1215)); + x1255 = (x1252)+(x1254); + x1256 = (x1255)+(x1171); + x1257 = (uintptr_t)((x1256)<(x1171)); + x1258 = (x1256)+(x1220); + x1259 = (uintptr_t)((x1258)<(x1220)); + x1260 = (x1257)+(x1259); + x1261 = (x1260)+(x1176); + x1262 = (uintptr_t)((x1261)<(x1176)); + x1263 = (x1261)+(x1225); + x1264 = (uintptr_t)((x1263)<(x1225)); + x1265 = (x1262)+(x1264); + x1266 = (x1265)+(x1181); + x1267 = (uintptr_t)((x1266)<(x1181)); + x1268 = (x1266)+(x1230); + x1269 = (uintptr_t)((x1268)<(x1230)); + x1270 = (x1267)+(x1269); + x1271 = (x1270)+(x1184); + x1272 = (uintptr_t)((x1271)<(x1184)); + x1273 = (x1271)+(x1233); + x1274 = (uintptr_t)((x1273)<(x1233)); + x1275 = (x1272)+(x1274); + x1276 = (x1234)*((uintptr_t)3993025615ULL); + x1277 = (x1276)*((uintptr_t)4294967295ULL); + x1278 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1276)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1276)*((uintptr_t)4294967295ULL))>>64); + x1279 = (x1276)*((uintptr_t)4294967295ULL); + x1280 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1276)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1276)*((uintptr_t)4294967295ULL))>>64); + x1281 = (x1276)*((uintptr_t)4294967295ULL); + x1282 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1276)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1276)*((uintptr_t)4294967295ULL))>>64); + x1283 = (x1276)*((uintptr_t)3169254061ULL); + x1284 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1276)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x1276)*((uintptr_t)3169254061ULL))>>64); + x1285 = (x1276)*((uintptr_t)2803342980ULL); + x1286 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1276)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x1276)*((uintptr_t)2803342980ULL))>>64); + x1287 = (x1276)*((uintptr_t)4089039554ULL); + x1288 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1276)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x1276)*((uintptr_t)4089039554ULL))>>64); + x1289 = (x1276)*((uintptr_t)4234356049ULL); + x1290 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1276)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x1276)*((uintptr_t)4234356049ULL))>>64); + x1291 = (x1290)+(x1287); + x1292 = (uintptr_t)((x1291)<(x1290)); + x1293 = (x1292)+(x1288); + x1294 = (uintptr_t)((x1293)<(x1288)); + x1295 = (x1293)+(x1285); + x1296 = (uintptr_t)((x1295)<(x1285)); + x1297 = (x1294)+(x1296); + x1298 = (x1297)+(x1286); + x1299 = (uintptr_t)((x1298)<(x1286)); + x1300 = (x1298)+(x1283); + x1301 = (uintptr_t)((x1300)<(x1283)); + x1302 = (x1299)+(x1301); + x1303 = (x1302)+(x1284); + x1304 = (uintptr_t)((x1303)<(x1284)); + x1305 = (x1303)+(x1281); + x1306 = (uintptr_t)((x1305)<(x1281)); + x1307 = (x1304)+(x1306); + x1308 = (x1307)+(x1282); + x1309 = (uintptr_t)((x1308)<(x1282)); + x1310 = (x1308)+(x1279); + x1311 = (uintptr_t)((x1310)<(x1279)); + x1312 = (x1309)+(x1311); + x1313 = (x1312)+(x1280); + x1314 = (x1234)+(x1289); + x1315 = (uintptr_t)((x1314)<(x1234)); + x1316 = (x1315)+(x1238); + x1317 = (uintptr_t)((x1316)<(x1238)); + x1318 = (x1316)+(x1291); + x1319 = (uintptr_t)((x1318)<(x1291)); + x1320 = (x1317)+(x1319); + x1321 = (x1320)+(x1243); + x1322 = (uintptr_t)((x1321)<(x1243)); + x1323 = (x1321)+(x1295); + x1324 = (uintptr_t)((x1323)<(x1295)); + x1325 = (x1322)+(x1324); + x1326 = (x1325)+(x1248); + x1327 = (uintptr_t)((x1326)<(x1248)); + x1328 = (x1326)+(x1300); + x1329 = (uintptr_t)((x1328)<(x1300)); + x1330 = (x1327)+(x1329); + x1331 = (x1330)+(x1253); + x1332 = (uintptr_t)((x1331)<(x1253)); + x1333 = (x1331)+(x1305); + x1334 = (uintptr_t)((x1333)<(x1305)); + x1335 = (x1332)+(x1334); + x1336 = (x1335)+(x1258); + x1337 = (uintptr_t)((x1336)<(x1258)); + x1338 = (x1336)+(x1310); + x1339 = (uintptr_t)((x1338)<(x1310)); + x1340 = (x1337)+(x1339); + x1341 = (x1340)+(x1263); + x1342 = (uintptr_t)((x1341)<(x1263)); + x1343 = (x1341)+(x1313); + x1344 = (uintptr_t)((x1343)<(x1313)); + x1345 = (x1342)+(x1344); + x1346 = (x1345)+(x1268); + x1347 = (uintptr_t)((x1346)<(x1268)); + x1348 = (x1346)+(x1277); + x1349 = (uintptr_t)((x1348)<(x1277)); + x1350 = (x1347)+(x1349); + x1351 = (x1350)+(x1273); + x1352 = (uintptr_t)((x1351)<(x1273)); + x1353 = (x1351)+(x1278); + x1354 = (uintptr_t)((x1353)<(x1278)); + x1355 = (x1352)+(x1354); + x1356 = (x1355)+(x1275); + x1357 = (x1318)-((uintptr_t)4234356049ULL); + x1358 = (uintptr_t)((x1318)<(x1357)); + x1359 = (x1323)-((uintptr_t)4089039554ULL); + x1360 = (uintptr_t)((x1323)<(x1359)); + x1361 = (x1359)-(x1358); + x1362 = (uintptr_t)((x1359)<(x1361)); + x1363 = (x1360)+(x1362); + x1364 = (x1328)-((uintptr_t)2803342980ULL); + x1365 = (uintptr_t)((x1328)<(x1364)); + x1366 = (x1364)-(x1363); + x1367 = (uintptr_t)((x1364)<(x1366)); + x1368 = (x1365)+(x1367); + x1369 = (x1333)-((uintptr_t)3169254061ULL); + x1370 = (uintptr_t)((x1333)<(x1369)); + x1371 = (x1369)-(x1368); + x1372 = (uintptr_t)((x1369)<(x1371)); + x1373 = (x1370)+(x1372); + x1374 = (x1338)-((uintptr_t)4294967295ULL); + x1375 = (uintptr_t)((x1338)<(x1374)); + x1376 = (x1374)-(x1373); + x1377 = (uintptr_t)((x1374)<(x1376)); + x1378 = (x1375)+(x1377); + x1379 = (x1343)-((uintptr_t)4294967295ULL); + x1380 = (uintptr_t)((x1343)<(x1379)); + x1381 = (x1379)-(x1378); + x1382 = (uintptr_t)((x1379)<(x1381)); + x1383 = (x1380)+(x1382); + x1384 = (x1348)-(x1383); + x1385 = (uintptr_t)((x1348)<(x1384)); + x1386 = (x1353)-((uintptr_t)4294967295ULL); + x1387 = (uintptr_t)((x1353)<(x1386)); + x1388 = (x1386)-(x1385); + x1389 = (uintptr_t)((x1386)<(x1388)); + x1390 = (x1387)+(x1389); + x1391 = (x1356)-(x1390); + x1392 = (uintptr_t)((x1356)<(x1391)); + x1393 = ((uintptr_t)-1ULL)+((uintptr_t)((x1392)==((uintptr_t)0ULL))); + x1394 = (x1393)^((uintptr_t)4294967295ULL); + x1395 = ((x1318)&(x1393))|((x1357)&(x1394)); + x1396 = ((uintptr_t)-1ULL)+((uintptr_t)((x1392)==((uintptr_t)0ULL))); + x1397 = (x1396)^((uintptr_t)4294967295ULL); + x1398 = ((x1323)&(x1396))|((x1361)&(x1397)); + x1399 = ((uintptr_t)-1ULL)+((uintptr_t)((x1392)==((uintptr_t)0ULL))); + x1400 = (x1399)^((uintptr_t)4294967295ULL); + x1401 = ((x1328)&(x1399))|((x1366)&(x1400)); + x1402 = ((uintptr_t)-1ULL)+((uintptr_t)((x1392)==((uintptr_t)0ULL))); + x1403 = (x1402)^((uintptr_t)4294967295ULL); + x1404 = ((x1333)&(x1402))|((x1371)&(x1403)); + x1405 = ((uintptr_t)-1ULL)+((uintptr_t)((x1392)==((uintptr_t)0ULL))); + x1406 = (x1405)^((uintptr_t)4294967295ULL); + x1407 = ((x1338)&(x1405))|((x1376)&(x1406)); + x1408 = ((uintptr_t)-1ULL)+((uintptr_t)((x1392)==((uintptr_t)0ULL))); + x1409 = (x1408)^((uintptr_t)4294967295ULL); + x1410 = ((x1343)&(x1408))|((x1381)&(x1409)); + x1411 = ((uintptr_t)-1ULL)+((uintptr_t)((x1392)==((uintptr_t)0ULL))); + x1412 = (x1411)^((uintptr_t)4294967295ULL); + x1413 = ((x1348)&(x1411))|((x1384)&(x1412)); + x1414 = ((uintptr_t)-1ULL)+((uintptr_t)((x1392)==((uintptr_t)0ULL))); + x1415 = (x1414)^((uintptr_t)4294967295ULL); + x1416 = ((x1353)&(x1414))|((x1388)&(x1415)); + x1417 = x1395; + x1418 = x1398; + x1419 = x1401; + x1420 = x1404; + x1421 = x1407; + x1422 = x1410; + x1423 = x1413; + x1424 = x1416; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x1417, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1418, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1419, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x1420, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x1421, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x1422, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x1423, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x1424, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_mul(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_p256_scalar_mul((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p256_scalar_square(uintptr_t out0, uintptr_t in0) { + uintptr_t x15, x28, x31, x33, x29, x34, x26, x35, x37, x38, x27, x39, x24, x40, x42, x43, x25, x44, x22, x45, x47, x48, x23, x49, x20, x50, x52, x53, x21, x54, x18, x55, x57, x58, x19, x59, x16, x60, x62, x63, x17, x65, x76, x79, x81, x77, x82, x74, x83, x85, x86, x75, x87, x72, x88, x90, x91, x73, x92, x70, x93, x95, x96, x71, x97, x68, x98, x100, x101, x69, x78, x103, x30, x104, x32, x105, x80, x106, x108, x109, x36, x110, x84, x111, x113, x114, x41, x115, x89, x116, x118, x119, x46, x120, x94, x121, x123, x124, x51, x125, x99, x126, x128, x129, x56, x130, x102, x131, x133, x134, x61, x135, x66, x136, x138, x139, x64, x140, x67, x141, x143, x8, x157, x160, x162, x158, x163, x155, x164, x166, x167, x156, x168, x153, x169, x171, x172, x154, x173, x151, x174, x176, x177, x152, x178, x149, x179, x181, x182, x150, x183, x147, x184, x186, x187, x148, x188, x145, x189, x191, x192, x146, x159, x107, x195, x112, x196, x161, x197, x199, x200, x117, x201, x165, x202, x204, x205, x122, x206, x170, x207, x209, x210, x127, x211, x175, x212, x214, x215, x132, x216, x180, x217, x219, x220, x137, x221, x185, x222, x224, x225, x142, x226, x190, x227, x229, x230, x144, x231, x193, x232, x234, x236, x247, x250, x252, x248, x253, x245, x254, x256, x257, x246, x258, x243, x259, x261, x262, x244, x263, x241, x264, x266, x267, x242, x268, x239, x269, x271, x272, x240, x249, x274, x194, x275, x198, x276, x251, x277, x279, x280, x203, x281, x255, x282, x284, x285, x208, x286, x260, x287, x289, x290, x213, x291, x265, x292, x294, x295, x218, x296, x270, x297, x299, x300, x223, x301, x273, x302, x304, x305, x228, x306, x237, x307, x309, x310, x233, x311, x238, x312, x314, x315, x235, x9, x329, x332, x334, x330, x335, x327, x336, x338, x339, x328, x340, x325, x341, x343, x344, x326, x345, x323, x346, x348, x349, x324, x350, x321, x351, x353, x354, x322, x355, x319, x356, x358, x359, x320, x360, x317, x361, x363, x364, x318, x331, x278, x367, x283, x368, x333, x369, x371, x372, x288, x373, x337, x374, x376, x377, x293, x378, x342, x379, x381, x382, x298, x383, x347, x384, x386, x387, x303, x388, x352, x389, x391, x392, x308, x393, x357, x394, x396, x397, x313, x398, x362, x399, x401, x402, x316, x403, x365, x404, x406, x408, x419, x422, x424, x420, x425, x417, x426, x428, x429, x418, x430, x415, x431, x433, x434, x416, x435, x413, x436, x438, x439, x414, x440, x411, x441, x443, x444, x412, x421, x446, x366, x447, x370, x448, x423, x449, x451, x452, x375, x453, x427, x454, x456, x457, x380, x458, x432, x459, x461, x462, x385, x463, x437, x464, x466, x467, x390, x468, x442, x469, x471, x472, x395, x473, x445, x474, x476, x477, x400, x478, x409, x479, x481, x482, x405, x483, x410, x484, x486, x487, x407, x10, x501, x504, x506, x502, x507, x499, x508, x510, x511, x500, x512, x497, x513, x515, x516, x498, x517, x495, x518, x520, x521, x496, x522, x493, x523, x525, x526, x494, x527, x491, x528, x530, x531, x492, x532, x489, x533, x535, x536, x490, x503, x450, x539, x455, x540, x505, x541, x543, x544, x460, x545, x509, x546, x548, x549, x465, x550, x514, x551, x553, x554, x470, x555, x519, x556, x558, x559, x475, x560, x524, x561, x563, x564, x480, x565, x529, x566, x568, x569, x485, x570, x534, x571, x573, x574, x488, x575, x537, x576, x578, x580, x591, x594, x596, x592, x597, x589, x598, x600, x601, x590, x602, x587, x603, x605, x606, x588, x607, x585, x608, x610, x611, x586, x612, x583, x613, x615, x616, x584, x593, x618, x538, x619, x542, x620, x595, x621, x623, x624, x547, x625, x599, x626, x628, x629, x552, x630, x604, x631, x633, x634, x557, x635, x609, x636, x638, x639, x562, x640, x614, x641, x643, x644, x567, x645, x617, x646, x648, x649, x572, x650, x581, x651, x653, x654, x577, x655, x582, x656, x658, x659, x579, x11, x673, x676, x678, x674, x679, x671, x680, x682, x683, x672, x684, x669, x685, x687, x688, x670, x689, x667, x690, x692, x693, x668, x694, x665, x695, x697, x698, x666, x699, x663, x700, x702, x703, x664, x704, x661, x705, x707, x708, x662, x675, x622, x711, x627, x712, x677, x713, x715, x716, x632, x717, x681, x718, x720, x721, x637, x722, x686, x723, x725, x726, x642, x727, x691, x728, x730, x731, x647, x732, x696, x733, x735, x736, x652, x737, x701, x738, x740, x741, x657, x742, x706, x743, x745, x746, x660, x747, x709, x748, x750, x752, x763, x766, x768, x764, x769, x761, x770, x772, x773, x762, x774, x759, x775, x777, x778, x760, x779, x757, x780, x782, x783, x758, x784, x755, x785, x787, x788, x756, x765, x790, x710, x791, x714, x792, x767, x793, x795, x796, x719, x797, x771, x798, x800, x801, x724, x802, x776, x803, x805, x806, x729, x807, x781, x808, x810, x811, x734, x812, x786, x813, x815, x816, x739, x817, x789, x818, x820, x821, x744, x822, x753, x823, x825, x826, x749, x827, x754, x828, x830, x831, x751, x12, x845, x848, x850, x846, x851, x843, x852, x854, x855, x844, x856, x841, x857, x859, x860, x842, x861, x839, x862, x864, x865, x840, x866, x837, x867, x869, x870, x838, x871, x835, x872, x874, x875, x836, x876, x833, x877, x879, x880, x834, x847, x794, x883, x799, x884, x849, x885, x887, x888, x804, x889, x853, x890, x892, x893, x809, x894, x858, x895, x897, x898, x814, x899, x863, x900, x902, x903, x819, x904, x868, x905, x907, x908, x824, x909, x873, x910, x912, x913, x829, x914, x878, x915, x917, x918, x832, x919, x881, x920, x922, x924, x935, x938, x940, x936, x941, x933, x942, x944, x945, x934, x946, x931, x947, x949, x950, x932, x951, x929, x952, x954, x955, x930, x956, x927, x957, x959, x960, x928, x937, x962, x882, x963, x886, x964, x939, x965, x967, x968, x891, x969, x943, x970, x972, x973, x896, x974, x948, x975, x977, x978, x901, x979, x953, x980, x982, x983, x906, x984, x958, x985, x987, x988, x911, x989, x961, x990, x992, x993, x916, x994, x925, x995, x997, x998, x921, x999, x926, x1000, x1002, x1003, x923, x13, x1017, x1020, x1022, x1018, x1023, x1015, x1024, x1026, x1027, x1016, x1028, x1013, x1029, x1031, x1032, x1014, x1033, x1011, x1034, x1036, x1037, x1012, x1038, x1009, x1039, x1041, x1042, x1010, x1043, x1007, x1044, x1046, x1047, x1008, x1048, x1005, x1049, x1051, x1052, x1006, x1019, x966, x1055, x971, x1056, x1021, x1057, x1059, x1060, x976, x1061, x1025, x1062, x1064, x1065, x981, x1066, x1030, x1067, x1069, x1070, x986, x1071, x1035, x1072, x1074, x1075, x991, x1076, x1040, x1077, x1079, x1080, x996, x1081, x1045, x1082, x1084, x1085, x1001, x1086, x1050, x1087, x1089, x1090, x1004, x1091, x1053, x1092, x1094, x1096, x1107, x1110, x1112, x1108, x1113, x1105, x1114, x1116, x1117, x1106, x1118, x1103, x1119, x1121, x1122, x1104, x1123, x1101, x1124, x1126, x1127, x1102, x1128, x1099, x1129, x1131, x1132, x1100, x1109, x1134, x1054, x1135, x1058, x1136, x1111, x1137, x1139, x1140, x1063, x1141, x1115, x1142, x1144, x1145, x1068, x1146, x1120, x1147, x1149, x1150, x1073, x1151, x1125, x1152, x1154, x1155, x1078, x1156, x1130, x1157, x1159, x1160, x1083, x1161, x1133, x1162, x1164, x1165, x1088, x1166, x1097, x1167, x1169, x1170, x1093, x1171, x1098, x1172, x1174, x1175, x1095, x7, x6, x5, x4, x3, x2, x1, x14, x0, x1189, x1192, x1194, x1190, x1195, x1187, x1196, x1198, x1199, x1188, x1200, x1185, x1201, x1203, x1204, x1186, x1205, x1183, x1206, x1208, x1209, x1184, x1210, x1181, x1211, x1213, x1214, x1182, x1215, x1179, x1216, x1218, x1219, x1180, x1220, x1177, x1221, x1223, x1224, x1178, x1191, x1138, x1227, x1143, x1228, x1193, x1229, x1231, x1232, x1148, x1233, x1197, x1234, x1236, x1237, x1153, x1238, x1202, x1239, x1241, x1242, x1158, x1243, x1207, x1244, x1246, x1247, x1163, x1248, x1212, x1249, x1251, x1252, x1168, x1253, x1217, x1254, x1256, x1257, x1173, x1258, x1222, x1259, x1261, x1262, x1176, x1263, x1225, x1264, x1266, x1268, x1279, x1282, x1284, x1280, x1285, x1277, x1286, x1288, x1289, x1278, x1290, x1275, x1291, x1293, x1294, x1276, x1295, x1273, x1296, x1298, x1299, x1274, x1300, x1271, x1301, x1303, x1304, x1272, x1281, x1306, x1226, x1307, x1230, x1308, x1283, x1309, x1311, x1312, x1235, x1313, x1287, x1314, x1316, x1317, x1240, x1318, x1292, x1319, x1321, x1322, x1245, x1323, x1297, x1324, x1326, x1327, x1250, x1328, x1302, x1329, x1331, x1332, x1255, x1333, x1305, x1334, x1336, x1337, x1260, x1338, x1269, x1339, x1341, x1342, x1265, x1343, x1270, x1344, x1346, x1347, x1267, x1350, x1351, x1352, x1354, x1355, x1356, x1357, x1359, x1360, x1361, x1362, x1364, x1365, x1366, x1367, x1369, x1370, x1371, x1372, x1374, x1375, x1377, x1378, x1379, x1381, x1382, x1348, x1383, x1310, x1385, x1349, x1386, x1315, x1388, x1353, x1389, x1320, x1391, x1358, x1392, x1325, x1394, x1363, x1395, x1330, x1397, x1368, x1398, x1335, x1400, x1373, x1401, x1340, x1403, x1376, x1404, x1384, x1345, x1406, x1380, x1407, x1387, x1390, x1393, x1396, x1399, x1402, x1405, x1408, x1409, x1410, x1411, x1412, x1413, x1414, x1415, x1416; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x1; + x9 = x2; + x10 = x3; + x11 = x4; + x12 = x5; + x13 = x6; + x14 = x7; + x15 = x0; + x16 = (x15)*(x7); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x7))>>32 : ((__uint128_t)(x15)*(x7))>>64); + x18 = (x15)*(x6); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x6))>>32 : ((__uint128_t)(x15)*(x6))>>64); + x20 = (x15)*(x5); + x21 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x5))>>32 : ((__uint128_t)(x15)*(x5))>>64); + x22 = (x15)*(x4); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x4))>>32 : ((__uint128_t)(x15)*(x4))>>64); + x24 = (x15)*(x3); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x3))>>32 : ((__uint128_t)(x15)*(x3))>>64); + x26 = (x15)*(x2); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x2))>>32 : ((__uint128_t)(x15)*(x2))>>64); + x28 = (x15)*(x1); + x29 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x1))>>32 : ((__uint128_t)(x15)*(x1))>>64); + x30 = (x15)*(x0); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x0))>>32 : ((__uint128_t)(x15)*(x0))>>64); + x32 = (x31)+(x28); + x33 = (uintptr_t)((x32)<(x31)); + x34 = (x33)+(x29); + x35 = (uintptr_t)((x34)<(x29)); + x36 = (x34)+(x26); + x37 = (uintptr_t)((x36)<(x26)); + x38 = (x35)+(x37); + x39 = (x38)+(x27); + x40 = (uintptr_t)((x39)<(x27)); + x41 = (x39)+(x24); + x42 = (uintptr_t)((x41)<(x24)); + x43 = (x40)+(x42); + x44 = (x43)+(x25); + x45 = (uintptr_t)((x44)<(x25)); + x46 = (x44)+(x22); + x47 = (uintptr_t)((x46)<(x22)); + x48 = (x45)+(x47); + x49 = (x48)+(x23); + x50 = (uintptr_t)((x49)<(x23)); + x51 = (x49)+(x20); + x52 = (uintptr_t)((x51)<(x20)); + x53 = (x50)+(x52); + x54 = (x53)+(x21); + x55 = (uintptr_t)((x54)<(x21)); + x56 = (x54)+(x18); + x57 = (uintptr_t)((x56)<(x18)); + x58 = (x55)+(x57); + x59 = (x58)+(x19); + x60 = (uintptr_t)((x59)<(x19)); + x61 = (x59)+(x16); + x62 = (uintptr_t)((x61)<(x16)); + x63 = (x60)+(x62); + x64 = (x63)+(x17); + x65 = (x30)*((uintptr_t)3993025615ULL); + x66 = (x65)*((uintptr_t)4294967295ULL); + x67 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)4294967295ULL))>>64); + x68 = (x65)*((uintptr_t)4294967295ULL); + x69 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)4294967295ULL))>>64); + x70 = (x65)*((uintptr_t)4294967295ULL); + x71 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)4294967295ULL))>>64); + x72 = (x65)*((uintptr_t)3169254061ULL); + x73 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)3169254061ULL))>>64); + x74 = (x65)*((uintptr_t)2803342980ULL); + x75 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)2803342980ULL))>>64); + x76 = (x65)*((uintptr_t)4089039554ULL); + x77 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)4089039554ULL))>>64); + x78 = (x65)*((uintptr_t)4234356049ULL); + x79 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)4234356049ULL))>>64); + x80 = (x79)+(x76); + x81 = (uintptr_t)((x80)<(x79)); + x82 = (x81)+(x77); + x83 = (uintptr_t)((x82)<(x77)); + x84 = (x82)+(x74); + x85 = (uintptr_t)((x84)<(x74)); + x86 = (x83)+(x85); + x87 = (x86)+(x75); + x88 = (uintptr_t)((x87)<(x75)); + x89 = (x87)+(x72); + x90 = (uintptr_t)((x89)<(x72)); + x91 = (x88)+(x90); + x92 = (x91)+(x73); + x93 = (uintptr_t)((x92)<(x73)); + x94 = (x92)+(x70); + x95 = (uintptr_t)((x94)<(x70)); + x96 = (x93)+(x95); + x97 = (x96)+(x71); + x98 = (uintptr_t)((x97)<(x71)); + x99 = (x97)+(x68); + x100 = (uintptr_t)((x99)<(x68)); + x101 = (x98)+(x100); + x102 = (x101)+(x69); + x103 = (x30)+(x78); + x104 = (uintptr_t)((x103)<(x30)); + x105 = (x104)+(x32); + x106 = (uintptr_t)((x105)<(x32)); + x107 = (x105)+(x80); + x108 = (uintptr_t)((x107)<(x80)); + x109 = (x106)+(x108); + x110 = (x109)+(x36); + x111 = (uintptr_t)((x110)<(x36)); + x112 = (x110)+(x84); + x113 = (uintptr_t)((x112)<(x84)); + x114 = (x111)+(x113); + x115 = (x114)+(x41); + x116 = (uintptr_t)((x115)<(x41)); + x117 = (x115)+(x89); + x118 = (uintptr_t)((x117)<(x89)); + x119 = (x116)+(x118); + x120 = (x119)+(x46); + x121 = (uintptr_t)((x120)<(x46)); + x122 = (x120)+(x94); + x123 = (uintptr_t)((x122)<(x94)); + x124 = (x121)+(x123); + x125 = (x124)+(x51); + x126 = (uintptr_t)((x125)<(x51)); + x127 = (x125)+(x99); + x128 = (uintptr_t)((x127)<(x99)); + x129 = (x126)+(x128); + x130 = (x129)+(x56); + x131 = (uintptr_t)((x130)<(x56)); + x132 = (x130)+(x102); + x133 = (uintptr_t)((x132)<(x102)); + x134 = (x131)+(x133); + x135 = (x134)+(x61); + x136 = (uintptr_t)((x135)<(x61)); + x137 = (x135)+(x66); + x138 = (uintptr_t)((x137)<(x66)); + x139 = (x136)+(x138); + x140 = (x139)+(x64); + x141 = (uintptr_t)((x140)<(x64)); + x142 = (x140)+(x67); + x143 = (uintptr_t)((x142)<(x67)); + x144 = (x141)+(x143); + x145 = (x8)*(x7); + x146 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x7))>>32 : ((__uint128_t)(x8)*(x7))>>64); + x147 = (x8)*(x6); + x148 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x6))>>32 : ((__uint128_t)(x8)*(x6))>>64); + x149 = (x8)*(x5); + x150 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x5))>>32 : ((__uint128_t)(x8)*(x5))>>64); + x151 = (x8)*(x4); + x152 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x4))>>32 : ((__uint128_t)(x8)*(x4))>>64); + x153 = (x8)*(x3); + x154 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x3))>>32 : ((__uint128_t)(x8)*(x3))>>64); + x155 = (x8)*(x2); + x156 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x2))>>32 : ((__uint128_t)(x8)*(x2))>>64); + x157 = (x8)*(x1); + x158 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x1))>>32 : ((__uint128_t)(x8)*(x1))>>64); + x159 = (x8)*(x0); + x160 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x0))>>32 : ((__uint128_t)(x8)*(x0))>>64); + x161 = (x160)+(x157); + x162 = (uintptr_t)((x161)<(x160)); + x163 = (x162)+(x158); + x164 = (uintptr_t)((x163)<(x158)); + x165 = (x163)+(x155); + x166 = (uintptr_t)((x165)<(x155)); + x167 = (x164)+(x166); + x168 = (x167)+(x156); + x169 = (uintptr_t)((x168)<(x156)); + x170 = (x168)+(x153); + x171 = (uintptr_t)((x170)<(x153)); + x172 = (x169)+(x171); + x173 = (x172)+(x154); + x174 = (uintptr_t)((x173)<(x154)); + x175 = (x173)+(x151); + x176 = (uintptr_t)((x175)<(x151)); + x177 = (x174)+(x176); + x178 = (x177)+(x152); + x179 = (uintptr_t)((x178)<(x152)); + x180 = (x178)+(x149); + x181 = (uintptr_t)((x180)<(x149)); + x182 = (x179)+(x181); + x183 = (x182)+(x150); + x184 = (uintptr_t)((x183)<(x150)); + x185 = (x183)+(x147); + x186 = (uintptr_t)((x185)<(x147)); + x187 = (x184)+(x186); + x188 = (x187)+(x148); + x189 = (uintptr_t)((x188)<(x148)); + x190 = (x188)+(x145); + x191 = (uintptr_t)((x190)<(x145)); + x192 = (x189)+(x191); + x193 = (x192)+(x146); + x194 = (x107)+(x159); + x195 = (uintptr_t)((x194)<(x107)); + x196 = (x195)+(x112); + x197 = (uintptr_t)((x196)<(x112)); + x198 = (x196)+(x161); + x199 = (uintptr_t)((x198)<(x161)); + x200 = (x197)+(x199); + x201 = (x200)+(x117); + x202 = (uintptr_t)((x201)<(x117)); + x203 = (x201)+(x165); + x204 = (uintptr_t)((x203)<(x165)); + x205 = (x202)+(x204); + x206 = (x205)+(x122); + x207 = (uintptr_t)((x206)<(x122)); + x208 = (x206)+(x170); + x209 = (uintptr_t)((x208)<(x170)); + x210 = (x207)+(x209); + x211 = (x210)+(x127); + x212 = (uintptr_t)((x211)<(x127)); + x213 = (x211)+(x175); + x214 = (uintptr_t)((x213)<(x175)); + x215 = (x212)+(x214); + x216 = (x215)+(x132); + x217 = (uintptr_t)((x216)<(x132)); + x218 = (x216)+(x180); + x219 = (uintptr_t)((x218)<(x180)); + x220 = (x217)+(x219); + x221 = (x220)+(x137); + x222 = (uintptr_t)((x221)<(x137)); + x223 = (x221)+(x185); + x224 = (uintptr_t)((x223)<(x185)); + x225 = (x222)+(x224); + x226 = (x225)+(x142); + x227 = (uintptr_t)((x226)<(x142)); + x228 = (x226)+(x190); + x229 = (uintptr_t)((x228)<(x190)); + x230 = (x227)+(x229); + x231 = (x230)+(x144); + x232 = (uintptr_t)((x231)<(x144)); + x233 = (x231)+(x193); + x234 = (uintptr_t)((x233)<(x193)); + x235 = (x232)+(x234); + x236 = (x194)*((uintptr_t)3993025615ULL); + x237 = (x236)*((uintptr_t)4294967295ULL); + x238 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x236)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x236)*((uintptr_t)4294967295ULL))>>64); + x239 = (x236)*((uintptr_t)4294967295ULL); + x240 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x236)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x236)*((uintptr_t)4294967295ULL))>>64); + x241 = (x236)*((uintptr_t)4294967295ULL); + x242 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x236)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x236)*((uintptr_t)4294967295ULL))>>64); + x243 = (x236)*((uintptr_t)3169254061ULL); + x244 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x236)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x236)*((uintptr_t)3169254061ULL))>>64); + x245 = (x236)*((uintptr_t)2803342980ULL); + x246 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x236)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x236)*((uintptr_t)2803342980ULL))>>64); + x247 = (x236)*((uintptr_t)4089039554ULL); + x248 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x236)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x236)*((uintptr_t)4089039554ULL))>>64); + x249 = (x236)*((uintptr_t)4234356049ULL); + x250 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x236)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x236)*((uintptr_t)4234356049ULL))>>64); + x251 = (x250)+(x247); + x252 = (uintptr_t)((x251)<(x250)); + x253 = (x252)+(x248); + x254 = (uintptr_t)((x253)<(x248)); + x255 = (x253)+(x245); + x256 = (uintptr_t)((x255)<(x245)); + x257 = (x254)+(x256); + x258 = (x257)+(x246); + x259 = (uintptr_t)((x258)<(x246)); + x260 = (x258)+(x243); + x261 = (uintptr_t)((x260)<(x243)); + x262 = (x259)+(x261); + x263 = (x262)+(x244); + x264 = (uintptr_t)((x263)<(x244)); + x265 = (x263)+(x241); + x266 = (uintptr_t)((x265)<(x241)); + x267 = (x264)+(x266); + x268 = (x267)+(x242); + x269 = (uintptr_t)((x268)<(x242)); + x270 = (x268)+(x239); + x271 = (uintptr_t)((x270)<(x239)); + x272 = (x269)+(x271); + x273 = (x272)+(x240); + x274 = (x194)+(x249); + x275 = (uintptr_t)((x274)<(x194)); + x276 = (x275)+(x198); + x277 = (uintptr_t)((x276)<(x198)); + x278 = (x276)+(x251); + x279 = (uintptr_t)((x278)<(x251)); + x280 = (x277)+(x279); + x281 = (x280)+(x203); + x282 = (uintptr_t)((x281)<(x203)); + x283 = (x281)+(x255); + x284 = (uintptr_t)((x283)<(x255)); + x285 = (x282)+(x284); + x286 = (x285)+(x208); + x287 = (uintptr_t)((x286)<(x208)); + x288 = (x286)+(x260); + x289 = (uintptr_t)((x288)<(x260)); + x290 = (x287)+(x289); + x291 = (x290)+(x213); + x292 = (uintptr_t)((x291)<(x213)); + x293 = (x291)+(x265); + x294 = (uintptr_t)((x293)<(x265)); + x295 = (x292)+(x294); + x296 = (x295)+(x218); + x297 = (uintptr_t)((x296)<(x218)); + x298 = (x296)+(x270); + x299 = (uintptr_t)((x298)<(x270)); + x300 = (x297)+(x299); + x301 = (x300)+(x223); + x302 = (uintptr_t)((x301)<(x223)); + x303 = (x301)+(x273); + x304 = (uintptr_t)((x303)<(x273)); + x305 = (x302)+(x304); + x306 = (x305)+(x228); + x307 = (uintptr_t)((x306)<(x228)); + x308 = (x306)+(x237); + x309 = (uintptr_t)((x308)<(x237)); + x310 = (x307)+(x309); + x311 = (x310)+(x233); + x312 = (uintptr_t)((x311)<(x233)); + x313 = (x311)+(x238); + x314 = (uintptr_t)((x313)<(x238)); + x315 = (x312)+(x314); + x316 = (x315)+(x235); + x317 = (x9)*(x7); + x318 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x7))>>32 : ((__uint128_t)(x9)*(x7))>>64); + x319 = (x9)*(x6); + x320 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x6))>>32 : ((__uint128_t)(x9)*(x6))>>64); + x321 = (x9)*(x5); + x322 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x5))>>32 : ((__uint128_t)(x9)*(x5))>>64); + x323 = (x9)*(x4); + x324 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x4))>>32 : ((__uint128_t)(x9)*(x4))>>64); + x325 = (x9)*(x3); + x326 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x3))>>32 : ((__uint128_t)(x9)*(x3))>>64); + x327 = (x9)*(x2); + x328 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x2))>>32 : ((__uint128_t)(x9)*(x2))>>64); + x329 = (x9)*(x1); + x330 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x1))>>32 : ((__uint128_t)(x9)*(x1))>>64); + x331 = (x9)*(x0); + x332 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x0))>>32 : ((__uint128_t)(x9)*(x0))>>64); + x333 = (x332)+(x329); + x334 = (uintptr_t)((x333)<(x332)); + x335 = (x334)+(x330); + x336 = (uintptr_t)((x335)<(x330)); + x337 = (x335)+(x327); + x338 = (uintptr_t)((x337)<(x327)); + x339 = (x336)+(x338); + x340 = (x339)+(x328); + x341 = (uintptr_t)((x340)<(x328)); + x342 = (x340)+(x325); + x343 = (uintptr_t)((x342)<(x325)); + x344 = (x341)+(x343); + x345 = (x344)+(x326); + x346 = (uintptr_t)((x345)<(x326)); + x347 = (x345)+(x323); + x348 = (uintptr_t)((x347)<(x323)); + x349 = (x346)+(x348); + x350 = (x349)+(x324); + x351 = (uintptr_t)((x350)<(x324)); + x352 = (x350)+(x321); + x353 = (uintptr_t)((x352)<(x321)); + x354 = (x351)+(x353); + x355 = (x354)+(x322); + x356 = (uintptr_t)((x355)<(x322)); + x357 = (x355)+(x319); + x358 = (uintptr_t)((x357)<(x319)); + x359 = (x356)+(x358); + x360 = (x359)+(x320); + x361 = (uintptr_t)((x360)<(x320)); + x362 = (x360)+(x317); + x363 = (uintptr_t)((x362)<(x317)); + x364 = (x361)+(x363); + x365 = (x364)+(x318); + x366 = (x278)+(x331); + x367 = (uintptr_t)((x366)<(x278)); + x368 = (x367)+(x283); + x369 = (uintptr_t)((x368)<(x283)); + x370 = (x368)+(x333); + x371 = (uintptr_t)((x370)<(x333)); + x372 = (x369)+(x371); + x373 = (x372)+(x288); + x374 = (uintptr_t)((x373)<(x288)); + x375 = (x373)+(x337); + x376 = (uintptr_t)((x375)<(x337)); + x377 = (x374)+(x376); + x378 = (x377)+(x293); + x379 = (uintptr_t)((x378)<(x293)); + x380 = (x378)+(x342); + x381 = (uintptr_t)((x380)<(x342)); + x382 = (x379)+(x381); + x383 = (x382)+(x298); + x384 = (uintptr_t)((x383)<(x298)); + x385 = (x383)+(x347); + x386 = (uintptr_t)((x385)<(x347)); + x387 = (x384)+(x386); + x388 = (x387)+(x303); + x389 = (uintptr_t)((x388)<(x303)); + x390 = (x388)+(x352); + x391 = (uintptr_t)((x390)<(x352)); + x392 = (x389)+(x391); + x393 = (x392)+(x308); + x394 = (uintptr_t)((x393)<(x308)); + x395 = (x393)+(x357); + x396 = (uintptr_t)((x395)<(x357)); + x397 = (x394)+(x396); + x398 = (x397)+(x313); + x399 = (uintptr_t)((x398)<(x313)); + x400 = (x398)+(x362); + x401 = (uintptr_t)((x400)<(x362)); + x402 = (x399)+(x401); + x403 = (x402)+(x316); + x404 = (uintptr_t)((x403)<(x316)); + x405 = (x403)+(x365); + x406 = (uintptr_t)((x405)<(x365)); + x407 = (x404)+(x406); + x408 = (x366)*((uintptr_t)3993025615ULL); + x409 = (x408)*((uintptr_t)4294967295ULL); + x410 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x408)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x408)*((uintptr_t)4294967295ULL))>>64); + x411 = (x408)*((uintptr_t)4294967295ULL); + x412 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x408)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x408)*((uintptr_t)4294967295ULL))>>64); + x413 = (x408)*((uintptr_t)4294967295ULL); + x414 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x408)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x408)*((uintptr_t)4294967295ULL))>>64); + x415 = (x408)*((uintptr_t)3169254061ULL); + x416 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x408)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x408)*((uintptr_t)3169254061ULL))>>64); + x417 = (x408)*((uintptr_t)2803342980ULL); + x418 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x408)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x408)*((uintptr_t)2803342980ULL))>>64); + x419 = (x408)*((uintptr_t)4089039554ULL); + x420 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x408)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x408)*((uintptr_t)4089039554ULL))>>64); + x421 = (x408)*((uintptr_t)4234356049ULL); + x422 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x408)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x408)*((uintptr_t)4234356049ULL))>>64); + x423 = (x422)+(x419); + x424 = (uintptr_t)((x423)<(x422)); + x425 = (x424)+(x420); + x426 = (uintptr_t)((x425)<(x420)); + x427 = (x425)+(x417); + x428 = (uintptr_t)((x427)<(x417)); + x429 = (x426)+(x428); + x430 = (x429)+(x418); + x431 = (uintptr_t)((x430)<(x418)); + x432 = (x430)+(x415); + x433 = (uintptr_t)((x432)<(x415)); + x434 = (x431)+(x433); + x435 = (x434)+(x416); + x436 = (uintptr_t)((x435)<(x416)); + x437 = (x435)+(x413); + x438 = (uintptr_t)((x437)<(x413)); + x439 = (x436)+(x438); + x440 = (x439)+(x414); + x441 = (uintptr_t)((x440)<(x414)); + x442 = (x440)+(x411); + x443 = (uintptr_t)((x442)<(x411)); + x444 = (x441)+(x443); + x445 = (x444)+(x412); + x446 = (x366)+(x421); + x447 = (uintptr_t)((x446)<(x366)); + x448 = (x447)+(x370); + x449 = (uintptr_t)((x448)<(x370)); + x450 = (x448)+(x423); + x451 = (uintptr_t)((x450)<(x423)); + x452 = (x449)+(x451); + x453 = (x452)+(x375); + x454 = (uintptr_t)((x453)<(x375)); + x455 = (x453)+(x427); + x456 = (uintptr_t)((x455)<(x427)); + x457 = (x454)+(x456); + x458 = (x457)+(x380); + x459 = (uintptr_t)((x458)<(x380)); + x460 = (x458)+(x432); + x461 = (uintptr_t)((x460)<(x432)); + x462 = (x459)+(x461); + x463 = (x462)+(x385); + x464 = (uintptr_t)((x463)<(x385)); + x465 = (x463)+(x437); + x466 = (uintptr_t)((x465)<(x437)); + x467 = (x464)+(x466); + x468 = (x467)+(x390); + x469 = (uintptr_t)((x468)<(x390)); + x470 = (x468)+(x442); + x471 = (uintptr_t)((x470)<(x442)); + x472 = (x469)+(x471); + x473 = (x472)+(x395); + x474 = (uintptr_t)((x473)<(x395)); + x475 = (x473)+(x445); + x476 = (uintptr_t)((x475)<(x445)); + x477 = (x474)+(x476); + x478 = (x477)+(x400); + x479 = (uintptr_t)((x478)<(x400)); + x480 = (x478)+(x409); + x481 = (uintptr_t)((x480)<(x409)); + x482 = (x479)+(x481); + x483 = (x482)+(x405); + x484 = (uintptr_t)((x483)<(x405)); + x485 = (x483)+(x410); + x486 = (uintptr_t)((x485)<(x410)); + x487 = (x484)+(x486); + x488 = (x487)+(x407); + x489 = (x10)*(x7); + x490 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x7))>>32 : ((__uint128_t)(x10)*(x7))>>64); + x491 = (x10)*(x6); + x492 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x6))>>32 : ((__uint128_t)(x10)*(x6))>>64); + x493 = (x10)*(x5); + x494 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x5))>>32 : ((__uint128_t)(x10)*(x5))>>64); + x495 = (x10)*(x4); + x496 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x4))>>32 : ((__uint128_t)(x10)*(x4))>>64); + x497 = (x10)*(x3); + x498 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x3))>>32 : ((__uint128_t)(x10)*(x3))>>64); + x499 = (x10)*(x2); + x500 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x2))>>32 : ((__uint128_t)(x10)*(x2))>>64); + x501 = (x10)*(x1); + x502 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x1))>>32 : ((__uint128_t)(x10)*(x1))>>64); + x503 = (x10)*(x0); + x504 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x0))>>32 : ((__uint128_t)(x10)*(x0))>>64); + x505 = (x504)+(x501); + x506 = (uintptr_t)((x505)<(x504)); + x507 = (x506)+(x502); + x508 = (uintptr_t)((x507)<(x502)); + x509 = (x507)+(x499); + x510 = (uintptr_t)((x509)<(x499)); + x511 = (x508)+(x510); + x512 = (x511)+(x500); + x513 = (uintptr_t)((x512)<(x500)); + x514 = (x512)+(x497); + x515 = (uintptr_t)((x514)<(x497)); + x516 = (x513)+(x515); + x517 = (x516)+(x498); + x518 = (uintptr_t)((x517)<(x498)); + x519 = (x517)+(x495); + x520 = (uintptr_t)((x519)<(x495)); + x521 = (x518)+(x520); + x522 = (x521)+(x496); + x523 = (uintptr_t)((x522)<(x496)); + x524 = (x522)+(x493); + x525 = (uintptr_t)((x524)<(x493)); + x526 = (x523)+(x525); + x527 = (x526)+(x494); + x528 = (uintptr_t)((x527)<(x494)); + x529 = (x527)+(x491); + x530 = (uintptr_t)((x529)<(x491)); + x531 = (x528)+(x530); + x532 = (x531)+(x492); + x533 = (uintptr_t)((x532)<(x492)); + x534 = (x532)+(x489); + x535 = (uintptr_t)((x534)<(x489)); + x536 = (x533)+(x535); + x537 = (x536)+(x490); + x538 = (x450)+(x503); + x539 = (uintptr_t)((x538)<(x450)); + x540 = (x539)+(x455); + x541 = (uintptr_t)((x540)<(x455)); + x542 = (x540)+(x505); + x543 = (uintptr_t)((x542)<(x505)); + x544 = (x541)+(x543); + x545 = (x544)+(x460); + x546 = (uintptr_t)((x545)<(x460)); + x547 = (x545)+(x509); + x548 = (uintptr_t)((x547)<(x509)); + x549 = (x546)+(x548); + x550 = (x549)+(x465); + x551 = (uintptr_t)((x550)<(x465)); + x552 = (x550)+(x514); + x553 = (uintptr_t)((x552)<(x514)); + x554 = (x551)+(x553); + x555 = (x554)+(x470); + x556 = (uintptr_t)((x555)<(x470)); + x557 = (x555)+(x519); + x558 = (uintptr_t)((x557)<(x519)); + x559 = (x556)+(x558); + x560 = (x559)+(x475); + x561 = (uintptr_t)((x560)<(x475)); + x562 = (x560)+(x524); + x563 = (uintptr_t)((x562)<(x524)); + x564 = (x561)+(x563); + x565 = (x564)+(x480); + x566 = (uintptr_t)((x565)<(x480)); + x567 = (x565)+(x529); + x568 = (uintptr_t)((x567)<(x529)); + x569 = (x566)+(x568); + x570 = (x569)+(x485); + x571 = (uintptr_t)((x570)<(x485)); + x572 = (x570)+(x534); + x573 = (uintptr_t)((x572)<(x534)); + x574 = (x571)+(x573); + x575 = (x574)+(x488); + x576 = (uintptr_t)((x575)<(x488)); + x577 = (x575)+(x537); + x578 = (uintptr_t)((x577)<(x537)); + x579 = (x576)+(x578); + x580 = (x538)*((uintptr_t)3993025615ULL); + x581 = (x580)*((uintptr_t)4294967295ULL); + x582 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x580)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x580)*((uintptr_t)4294967295ULL))>>64); + x583 = (x580)*((uintptr_t)4294967295ULL); + x584 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x580)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x580)*((uintptr_t)4294967295ULL))>>64); + x585 = (x580)*((uintptr_t)4294967295ULL); + x586 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x580)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x580)*((uintptr_t)4294967295ULL))>>64); + x587 = (x580)*((uintptr_t)3169254061ULL); + x588 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x580)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x580)*((uintptr_t)3169254061ULL))>>64); + x589 = (x580)*((uintptr_t)2803342980ULL); + x590 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x580)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x580)*((uintptr_t)2803342980ULL))>>64); + x591 = (x580)*((uintptr_t)4089039554ULL); + x592 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x580)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x580)*((uintptr_t)4089039554ULL))>>64); + x593 = (x580)*((uintptr_t)4234356049ULL); + x594 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x580)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x580)*((uintptr_t)4234356049ULL))>>64); + x595 = (x594)+(x591); + x596 = (uintptr_t)((x595)<(x594)); + x597 = (x596)+(x592); + x598 = (uintptr_t)((x597)<(x592)); + x599 = (x597)+(x589); + x600 = (uintptr_t)((x599)<(x589)); + x601 = (x598)+(x600); + x602 = (x601)+(x590); + x603 = (uintptr_t)((x602)<(x590)); + x604 = (x602)+(x587); + x605 = (uintptr_t)((x604)<(x587)); + x606 = (x603)+(x605); + x607 = (x606)+(x588); + x608 = (uintptr_t)((x607)<(x588)); + x609 = (x607)+(x585); + x610 = (uintptr_t)((x609)<(x585)); + x611 = (x608)+(x610); + x612 = (x611)+(x586); + x613 = (uintptr_t)((x612)<(x586)); + x614 = (x612)+(x583); + x615 = (uintptr_t)((x614)<(x583)); + x616 = (x613)+(x615); + x617 = (x616)+(x584); + x618 = (x538)+(x593); + x619 = (uintptr_t)((x618)<(x538)); + x620 = (x619)+(x542); + x621 = (uintptr_t)((x620)<(x542)); + x622 = (x620)+(x595); + x623 = (uintptr_t)((x622)<(x595)); + x624 = (x621)+(x623); + x625 = (x624)+(x547); + x626 = (uintptr_t)((x625)<(x547)); + x627 = (x625)+(x599); + x628 = (uintptr_t)((x627)<(x599)); + x629 = (x626)+(x628); + x630 = (x629)+(x552); + x631 = (uintptr_t)((x630)<(x552)); + x632 = (x630)+(x604); + x633 = (uintptr_t)((x632)<(x604)); + x634 = (x631)+(x633); + x635 = (x634)+(x557); + x636 = (uintptr_t)((x635)<(x557)); + x637 = (x635)+(x609); + x638 = (uintptr_t)((x637)<(x609)); + x639 = (x636)+(x638); + x640 = (x639)+(x562); + x641 = (uintptr_t)((x640)<(x562)); + x642 = (x640)+(x614); + x643 = (uintptr_t)((x642)<(x614)); + x644 = (x641)+(x643); + x645 = (x644)+(x567); + x646 = (uintptr_t)((x645)<(x567)); + x647 = (x645)+(x617); + x648 = (uintptr_t)((x647)<(x617)); + x649 = (x646)+(x648); + x650 = (x649)+(x572); + x651 = (uintptr_t)((x650)<(x572)); + x652 = (x650)+(x581); + x653 = (uintptr_t)((x652)<(x581)); + x654 = (x651)+(x653); + x655 = (x654)+(x577); + x656 = (uintptr_t)((x655)<(x577)); + x657 = (x655)+(x582); + x658 = (uintptr_t)((x657)<(x582)); + x659 = (x656)+(x658); + x660 = (x659)+(x579); + x661 = (x11)*(x7); + x662 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x7))>>32 : ((__uint128_t)(x11)*(x7))>>64); + x663 = (x11)*(x6); + x664 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x6))>>32 : ((__uint128_t)(x11)*(x6))>>64); + x665 = (x11)*(x5); + x666 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x5))>>32 : ((__uint128_t)(x11)*(x5))>>64); + x667 = (x11)*(x4); + x668 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x4))>>32 : ((__uint128_t)(x11)*(x4))>>64); + x669 = (x11)*(x3); + x670 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x3))>>32 : ((__uint128_t)(x11)*(x3))>>64); + x671 = (x11)*(x2); + x672 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x2))>>32 : ((__uint128_t)(x11)*(x2))>>64); + x673 = (x11)*(x1); + x674 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x1))>>32 : ((__uint128_t)(x11)*(x1))>>64); + x675 = (x11)*(x0); + x676 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x0))>>32 : ((__uint128_t)(x11)*(x0))>>64); + x677 = (x676)+(x673); + x678 = (uintptr_t)((x677)<(x676)); + x679 = (x678)+(x674); + x680 = (uintptr_t)((x679)<(x674)); + x681 = (x679)+(x671); + x682 = (uintptr_t)((x681)<(x671)); + x683 = (x680)+(x682); + x684 = (x683)+(x672); + x685 = (uintptr_t)((x684)<(x672)); + x686 = (x684)+(x669); + x687 = (uintptr_t)((x686)<(x669)); + x688 = (x685)+(x687); + x689 = (x688)+(x670); + x690 = (uintptr_t)((x689)<(x670)); + x691 = (x689)+(x667); + x692 = (uintptr_t)((x691)<(x667)); + x693 = (x690)+(x692); + x694 = (x693)+(x668); + x695 = (uintptr_t)((x694)<(x668)); + x696 = (x694)+(x665); + x697 = (uintptr_t)((x696)<(x665)); + x698 = (x695)+(x697); + x699 = (x698)+(x666); + x700 = (uintptr_t)((x699)<(x666)); + x701 = (x699)+(x663); + x702 = (uintptr_t)((x701)<(x663)); + x703 = (x700)+(x702); + x704 = (x703)+(x664); + x705 = (uintptr_t)((x704)<(x664)); + x706 = (x704)+(x661); + x707 = (uintptr_t)((x706)<(x661)); + x708 = (x705)+(x707); + x709 = (x708)+(x662); + x710 = (x622)+(x675); + x711 = (uintptr_t)((x710)<(x622)); + x712 = (x711)+(x627); + x713 = (uintptr_t)((x712)<(x627)); + x714 = (x712)+(x677); + x715 = (uintptr_t)((x714)<(x677)); + x716 = (x713)+(x715); + x717 = (x716)+(x632); + x718 = (uintptr_t)((x717)<(x632)); + x719 = (x717)+(x681); + x720 = (uintptr_t)((x719)<(x681)); + x721 = (x718)+(x720); + x722 = (x721)+(x637); + x723 = (uintptr_t)((x722)<(x637)); + x724 = (x722)+(x686); + x725 = (uintptr_t)((x724)<(x686)); + x726 = (x723)+(x725); + x727 = (x726)+(x642); + x728 = (uintptr_t)((x727)<(x642)); + x729 = (x727)+(x691); + x730 = (uintptr_t)((x729)<(x691)); + x731 = (x728)+(x730); + x732 = (x731)+(x647); + x733 = (uintptr_t)((x732)<(x647)); + x734 = (x732)+(x696); + x735 = (uintptr_t)((x734)<(x696)); + x736 = (x733)+(x735); + x737 = (x736)+(x652); + x738 = (uintptr_t)((x737)<(x652)); + x739 = (x737)+(x701); + x740 = (uintptr_t)((x739)<(x701)); + x741 = (x738)+(x740); + x742 = (x741)+(x657); + x743 = (uintptr_t)((x742)<(x657)); + x744 = (x742)+(x706); + x745 = (uintptr_t)((x744)<(x706)); + x746 = (x743)+(x745); + x747 = (x746)+(x660); + x748 = (uintptr_t)((x747)<(x660)); + x749 = (x747)+(x709); + x750 = (uintptr_t)((x749)<(x709)); + x751 = (x748)+(x750); + x752 = (x710)*((uintptr_t)3993025615ULL); + x753 = (x752)*((uintptr_t)4294967295ULL); + x754 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x752)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x752)*((uintptr_t)4294967295ULL))>>64); + x755 = (x752)*((uintptr_t)4294967295ULL); + x756 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x752)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x752)*((uintptr_t)4294967295ULL))>>64); + x757 = (x752)*((uintptr_t)4294967295ULL); + x758 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x752)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x752)*((uintptr_t)4294967295ULL))>>64); + x759 = (x752)*((uintptr_t)3169254061ULL); + x760 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x752)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x752)*((uintptr_t)3169254061ULL))>>64); + x761 = (x752)*((uintptr_t)2803342980ULL); + x762 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x752)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x752)*((uintptr_t)2803342980ULL))>>64); + x763 = (x752)*((uintptr_t)4089039554ULL); + x764 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x752)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x752)*((uintptr_t)4089039554ULL))>>64); + x765 = (x752)*((uintptr_t)4234356049ULL); + x766 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x752)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x752)*((uintptr_t)4234356049ULL))>>64); + x767 = (x766)+(x763); + x768 = (uintptr_t)((x767)<(x766)); + x769 = (x768)+(x764); + x770 = (uintptr_t)((x769)<(x764)); + x771 = (x769)+(x761); + x772 = (uintptr_t)((x771)<(x761)); + x773 = (x770)+(x772); + x774 = (x773)+(x762); + x775 = (uintptr_t)((x774)<(x762)); + x776 = (x774)+(x759); + x777 = (uintptr_t)((x776)<(x759)); + x778 = (x775)+(x777); + x779 = (x778)+(x760); + x780 = (uintptr_t)((x779)<(x760)); + x781 = (x779)+(x757); + x782 = (uintptr_t)((x781)<(x757)); + x783 = (x780)+(x782); + x784 = (x783)+(x758); + x785 = (uintptr_t)((x784)<(x758)); + x786 = (x784)+(x755); + x787 = (uintptr_t)((x786)<(x755)); + x788 = (x785)+(x787); + x789 = (x788)+(x756); + x790 = (x710)+(x765); + x791 = (uintptr_t)((x790)<(x710)); + x792 = (x791)+(x714); + x793 = (uintptr_t)((x792)<(x714)); + x794 = (x792)+(x767); + x795 = (uintptr_t)((x794)<(x767)); + x796 = (x793)+(x795); + x797 = (x796)+(x719); + x798 = (uintptr_t)((x797)<(x719)); + x799 = (x797)+(x771); + x800 = (uintptr_t)((x799)<(x771)); + x801 = (x798)+(x800); + x802 = (x801)+(x724); + x803 = (uintptr_t)((x802)<(x724)); + x804 = (x802)+(x776); + x805 = (uintptr_t)((x804)<(x776)); + x806 = (x803)+(x805); + x807 = (x806)+(x729); + x808 = (uintptr_t)((x807)<(x729)); + x809 = (x807)+(x781); + x810 = (uintptr_t)((x809)<(x781)); + x811 = (x808)+(x810); + x812 = (x811)+(x734); + x813 = (uintptr_t)((x812)<(x734)); + x814 = (x812)+(x786); + x815 = (uintptr_t)((x814)<(x786)); + x816 = (x813)+(x815); + x817 = (x816)+(x739); + x818 = (uintptr_t)((x817)<(x739)); + x819 = (x817)+(x789); + x820 = (uintptr_t)((x819)<(x789)); + x821 = (x818)+(x820); + x822 = (x821)+(x744); + x823 = (uintptr_t)((x822)<(x744)); + x824 = (x822)+(x753); + x825 = (uintptr_t)((x824)<(x753)); + x826 = (x823)+(x825); + x827 = (x826)+(x749); + x828 = (uintptr_t)((x827)<(x749)); + x829 = (x827)+(x754); + x830 = (uintptr_t)((x829)<(x754)); + x831 = (x828)+(x830); + x832 = (x831)+(x751); + x833 = (x12)*(x7); + x834 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x7))>>32 : ((__uint128_t)(x12)*(x7))>>64); + x835 = (x12)*(x6); + x836 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x6))>>32 : ((__uint128_t)(x12)*(x6))>>64); + x837 = (x12)*(x5); + x838 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x5))>>32 : ((__uint128_t)(x12)*(x5))>>64); + x839 = (x12)*(x4); + x840 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x4))>>32 : ((__uint128_t)(x12)*(x4))>>64); + x841 = (x12)*(x3); + x842 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x3))>>32 : ((__uint128_t)(x12)*(x3))>>64); + x843 = (x12)*(x2); + x844 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x2))>>32 : ((__uint128_t)(x12)*(x2))>>64); + x845 = (x12)*(x1); + x846 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x1))>>32 : ((__uint128_t)(x12)*(x1))>>64); + x847 = (x12)*(x0); + x848 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x0))>>32 : ((__uint128_t)(x12)*(x0))>>64); + x849 = (x848)+(x845); + x850 = (uintptr_t)((x849)<(x848)); + x851 = (x850)+(x846); + x852 = (uintptr_t)((x851)<(x846)); + x853 = (x851)+(x843); + x854 = (uintptr_t)((x853)<(x843)); + x855 = (x852)+(x854); + x856 = (x855)+(x844); + x857 = (uintptr_t)((x856)<(x844)); + x858 = (x856)+(x841); + x859 = (uintptr_t)((x858)<(x841)); + x860 = (x857)+(x859); + x861 = (x860)+(x842); + x862 = (uintptr_t)((x861)<(x842)); + x863 = (x861)+(x839); + x864 = (uintptr_t)((x863)<(x839)); + x865 = (x862)+(x864); + x866 = (x865)+(x840); + x867 = (uintptr_t)((x866)<(x840)); + x868 = (x866)+(x837); + x869 = (uintptr_t)((x868)<(x837)); + x870 = (x867)+(x869); + x871 = (x870)+(x838); + x872 = (uintptr_t)((x871)<(x838)); + x873 = (x871)+(x835); + x874 = (uintptr_t)((x873)<(x835)); + x875 = (x872)+(x874); + x876 = (x875)+(x836); + x877 = (uintptr_t)((x876)<(x836)); + x878 = (x876)+(x833); + x879 = (uintptr_t)((x878)<(x833)); + x880 = (x877)+(x879); + x881 = (x880)+(x834); + x882 = (x794)+(x847); + x883 = (uintptr_t)((x882)<(x794)); + x884 = (x883)+(x799); + x885 = (uintptr_t)((x884)<(x799)); + x886 = (x884)+(x849); + x887 = (uintptr_t)((x886)<(x849)); + x888 = (x885)+(x887); + x889 = (x888)+(x804); + x890 = (uintptr_t)((x889)<(x804)); + x891 = (x889)+(x853); + x892 = (uintptr_t)((x891)<(x853)); + x893 = (x890)+(x892); + x894 = (x893)+(x809); + x895 = (uintptr_t)((x894)<(x809)); + x896 = (x894)+(x858); + x897 = (uintptr_t)((x896)<(x858)); + x898 = (x895)+(x897); + x899 = (x898)+(x814); + x900 = (uintptr_t)((x899)<(x814)); + x901 = (x899)+(x863); + x902 = (uintptr_t)((x901)<(x863)); + x903 = (x900)+(x902); + x904 = (x903)+(x819); + x905 = (uintptr_t)((x904)<(x819)); + x906 = (x904)+(x868); + x907 = (uintptr_t)((x906)<(x868)); + x908 = (x905)+(x907); + x909 = (x908)+(x824); + x910 = (uintptr_t)((x909)<(x824)); + x911 = (x909)+(x873); + x912 = (uintptr_t)((x911)<(x873)); + x913 = (x910)+(x912); + x914 = (x913)+(x829); + x915 = (uintptr_t)((x914)<(x829)); + x916 = (x914)+(x878); + x917 = (uintptr_t)((x916)<(x878)); + x918 = (x915)+(x917); + x919 = (x918)+(x832); + x920 = (uintptr_t)((x919)<(x832)); + x921 = (x919)+(x881); + x922 = (uintptr_t)((x921)<(x881)); + x923 = (x920)+(x922); + x924 = (x882)*((uintptr_t)3993025615ULL); + x925 = (x924)*((uintptr_t)4294967295ULL); + x926 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x924)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x924)*((uintptr_t)4294967295ULL))>>64); + x927 = (x924)*((uintptr_t)4294967295ULL); + x928 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x924)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x924)*((uintptr_t)4294967295ULL))>>64); + x929 = (x924)*((uintptr_t)4294967295ULL); + x930 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x924)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x924)*((uintptr_t)4294967295ULL))>>64); + x931 = (x924)*((uintptr_t)3169254061ULL); + x932 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x924)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x924)*((uintptr_t)3169254061ULL))>>64); + x933 = (x924)*((uintptr_t)2803342980ULL); + x934 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x924)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x924)*((uintptr_t)2803342980ULL))>>64); + x935 = (x924)*((uintptr_t)4089039554ULL); + x936 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x924)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x924)*((uintptr_t)4089039554ULL))>>64); + x937 = (x924)*((uintptr_t)4234356049ULL); + x938 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x924)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x924)*((uintptr_t)4234356049ULL))>>64); + x939 = (x938)+(x935); + x940 = (uintptr_t)((x939)<(x938)); + x941 = (x940)+(x936); + x942 = (uintptr_t)((x941)<(x936)); + x943 = (x941)+(x933); + x944 = (uintptr_t)((x943)<(x933)); + x945 = (x942)+(x944); + x946 = (x945)+(x934); + x947 = (uintptr_t)((x946)<(x934)); + x948 = (x946)+(x931); + x949 = (uintptr_t)((x948)<(x931)); + x950 = (x947)+(x949); + x951 = (x950)+(x932); + x952 = (uintptr_t)((x951)<(x932)); + x953 = (x951)+(x929); + x954 = (uintptr_t)((x953)<(x929)); + x955 = (x952)+(x954); + x956 = (x955)+(x930); + x957 = (uintptr_t)((x956)<(x930)); + x958 = (x956)+(x927); + x959 = (uintptr_t)((x958)<(x927)); + x960 = (x957)+(x959); + x961 = (x960)+(x928); + x962 = (x882)+(x937); + x963 = (uintptr_t)((x962)<(x882)); + x964 = (x963)+(x886); + x965 = (uintptr_t)((x964)<(x886)); + x966 = (x964)+(x939); + x967 = (uintptr_t)((x966)<(x939)); + x968 = (x965)+(x967); + x969 = (x968)+(x891); + x970 = (uintptr_t)((x969)<(x891)); + x971 = (x969)+(x943); + x972 = (uintptr_t)((x971)<(x943)); + x973 = (x970)+(x972); + x974 = (x973)+(x896); + x975 = (uintptr_t)((x974)<(x896)); + x976 = (x974)+(x948); + x977 = (uintptr_t)((x976)<(x948)); + x978 = (x975)+(x977); + x979 = (x978)+(x901); + x980 = (uintptr_t)((x979)<(x901)); + x981 = (x979)+(x953); + x982 = (uintptr_t)((x981)<(x953)); + x983 = (x980)+(x982); + x984 = (x983)+(x906); + x985 = (uintptr_t)((x984)<(x906)); + x986 = (x984)+(x958); + x987 = (uintptr_t)((x986)<(x958)); + x988 = (x985)+(x987); + x989 = (x988)+(x911); + x990 = (uintptr_t)((x989)<(x911)); + x991 = (x989)+(x961); + x992 = (uintptr_t)((x991)<(x961)); + x993 = (x990)+(x992); + x994 = (x993)+(x916); + x995 = (uintptr_t)((x994)<(x916)); + x996 = (x994)+(x925); + x997 = (uintptr_t)((x996)<(x925)); + x998 = (x995)+(x997); + x999 = (x998)+(x921); + x1000 = (uintptr_t)((x999)<(x921)); + x1001 = (x999)+(x926); + x1002 = (uintptr_t)((x1001)<(x926)); + x1003 = (x1000)+(x1002); + x1004 = (x1003)+(x923); + x1005 = (x13)*(x7); + x1006 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x7))>>32 : ((__uint128_t)(x13)*(x7))>>64); + x1007 = (x13)*(x6); + x1008 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x6))>>32 : ((__uint128_t)(x13)*(x6))>>64); + x1009 = (x13)*(x5); + x1010 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x5))>>32 : ((__uint128_t)(x13)*(x5))>>64); + x1011 = (x13)*(x4); + x1012 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x4))>>32 : ((__uint128_t)(x13)*(x4))>>64); + x1013 = (x13)*(x3); + x1014 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x3))>>32 : ((__uint128_t)(x13)*(x3))>>64); + x1015 = (x13)*(x2); + x1016 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x2))>>32 : ((__uint128_t)(x13)*(x2))>>64); + x1017 = (x13)*(x1); + x1018 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x1))>>32 : ((__uint128_t)(x13)*(x1))>>64); + x1019 = (x13)*(x0); + x1020 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x0))>>32 : ((__uint128_t)(x13)*(x0))>>64); + x1021 = (x1020)+(x1017); + x1022 = (uintptr_t)((x1021)<(x1020)); + x1023 = (x1022)+(x1018); + x1024 = (uintptr_t)((x1023)<(x1018)); + x1025 = (x1023)+(x1015); + x1026 = (uintptr_t)((x1025)<(x1015)); + x1027 = (x1024)+(x1026); + x1028 = (x1027)+(x1016); + x1029 = (uintptr_t)((x1028)<(x1016)); + x1030 = (x1028)+(x1013); + x1031 = (uintptr_t)((x1030)<(x1013)); + x1032 = (x1029)+(x1031); + x1033 = (x1032)+(x1014); + x1034 = (uintptr_t)((x1033)<(x1014)); + x1035 = (x1033)+(x1011); + x1036 = (uintptr_t)((x1035)<(x1011)); + x1037 = (x1034)+(x1036); + x1038 = (x1037)+(x1012); + x1039 = (uintptr_t)((x1038)<(x1012)); + x1040 = (x1038)+(x1009); + x1041 = (uintptr_t)((x1040)<(x1009)); + x1042 = (x1039)+(x1041); + x1043 = (x1042)+(x1010); + x1044 = (uintptr_t)((x1043)<(x1010)); + x1045 = (x1043)+(x1007); + x1046 = (uintptr_t)((x1045)<(x1007)); + x1047 = (x1044)+(x1046); + x1048 = (x1047)+(x1008); + x1049 = (uintptr_t)((x1048)<(x1008)); + x1050 = (x1048)+(x1005); + x1051 = (uintptr_t)((x1050)<(x1005)); + x1052 = (x1049)+(x1051); + x1053 = (x1052)+(x1006); + x1054 = (x966)+(x1019); + x1055 = (uintptr_t)((x1054)<(x966)); + x1056 = (x1055)+(x971); + x1057 = (uintptr_t)((x1056)<(x971)); + x1058 = (x1056)+(x1021); + x1059 = (uintptr_t)((x1058)<(x1021)); + x1060 = (x1057)+(x1059); + x1061 = (x1060)+(x976); + x1062 = (uintptr_t)((x1061)<(x976)); + x1063 = (x1061)+(x1025); + x1064 = (uintptr_t)((x1063)<(x1025)); + x1065 = (x1062)+(x1064); + x1066 = (x1065)+(x981); + x1067 = (uintptr_t)((x1066)<(x981)); + x1068 = (x1066)+(x1030); + x1069 = (uintptr_t)((x1068)<(x1030)); + x1070 = (x1067)+(x1069); + x1071 = (x1070)+(x986); + x1072 = (uintptr_t)((x1071)<(x986)); + x1073 = (x1071)+(x1035); + x1074 = (uintptr_t)((x1073)<(x1035)); + x1075 = (x1072)+(x1074); + x1076 = (x1075)+(x991); + x1077 = (uintptr_t)((x1076)<(x991)); + x1078 = (x1076)+(x1040); + x1079 = (uintptr_t)((x1078)<(x1040)); + x1080 = (x1077)+(x1079); + x1081 = (x1080)+(x996); + x1082 = (uintptr_t)((x1081)<(x996)); + x1083 = (x1081)+(x1045); + x1084 = (uintptr_t)((x1083)<(x1045)); + x1085 = (x1082)+(x1084); + x1086 = (x1085)+(x1001); + x1087 = (uintptr_t)((x1086)<(x1001)); + x1088 = (x1086)+(x1050); + x1089 = (uintptr_t)((x1088)<(x1050)); + x1090 = (x1087)+(x1089); + x1091 = (x1090)+(x1004); + x1092 = (uintptr_t)((x1091)<(x1004)); + x1093 = (x1091)+(x1053); + x1094 = (uintptr_t)((x1093)<(x1053)); + x1095 = (x1092)+(x1094); + x1096 = (x1054)*((uintptr_t)3993025615ULL); + x1097 = (x1096)*((uintptr_t)4294967295ULL); + x1098 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1096)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1096)*((uintptr_t)4294967295ULL))>>64); + x1099 = (x1096)*((uintptr_t)4294967295ULL); + x1100 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1096)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1096)*((uintptr_t)4294967295ULL))>>64); + x1101 = (x1096)*((uintptr_t)4294967295ULL); + x1102 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1096)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1096)*((uintptr_t)4294967295ULL))>>64); + x1103 = (x1096)*((uintptr_t)3169254061ULL); + x1104 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1096)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x1096)*((uintptr_t)3169254061ULL))>>64); + x1105 = (x1096)*((uintptr_t)2803342980ULL); + x1106 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1096)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x1096)*((uintptr_t)2803342980ULL))>>64); + x1107 = (x1096)*((uintptr_t)4089039554ULL); + x1108 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1096)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x1096)*((uintptr_t)4089039554ULL))>>64); + x1109 = (x1096)*((uintptr_t)4234356049ULL); + x1110 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1096)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x1096)*((uintptr_t)4234356049ULL))>>64); + x1111 = (x1110)+(x1107); + x1112 = (uintptr_t)((x1111)<(x1110)); + x1113 = (x1112)+(x1108); + x1114 = (uintptr_t)((x1113)<(x1108)); + x1115 = (x1113)+(x1105); + x1116 = (uintptr_t)((x1115)<(x1105)); + x1117 = (x1114)+(x1116); + x1118 = (x1117)+(x1106); + x1119 = (uintptr_t)((x1118)<(x1106)); + x1120 = (x1118)+(x1103); + x1121 = (uintptr_t)((x1120)<(x1103)); + x1122 = (x1119)+(x1121); + x1123 = (x1122)+(x1104); + x1124 = (uintptr_t)((x1123)<(x1104)); + x1125 = (x1123)+(x1101); + x1126 = (uintptr_t)((x1125)<(x1101)); + x1127 = (x1124)+(x1126); + x1128 = (x1127)+(x1102); + x1129 = (uintptr_t)((x1128)<(x1102)); + x1130 = (x1128)+(x1099); + x1131 = (uintptr_t)((x1130)<(x1099)); + x1132 = (x1129)+(x1131); + x1133 = (x1132)+(x1100); + x1134 = (x1054)+(x1109); + x1135 = (uintptr_t)((x1134)<(x1054)); + x1136 = (x1135)+(x1058); + x1137 = (uintptr_t)((x1136)<(x1058)); + x1138 = (x1136)+(x1111); + x1139 = (uintptr_t)((x1138)<(x1111)); + x1140 = (x1137)+(x1139); + x1141 = (x1140)+(x1063); + x1142 = (uintptr_t)((x1141)<(x1063)); + x1143 = (x1141)+(x1115); + x1144 = (uintptr_t)((x1143)<(x1115)); + x1145 = (x1142)+(x1144); + x1146 = (x1145)+(x1068); + x1147 = (uintptr_t)((x1146)<(x1068)); + x1148 = (x1146)+(x1120); + x1149 = (uintptr_t)((x1148)<(x1120)); + x1150 = (x1147)+(x1149); + x1151 = (x1150)+(x1073); + x1152 = (uintptr_t)((x1151)<(x1073)); + x1153 = (x1151)+(x1125); + x1154 = (uintptr_t)((x1153)<(x1125)); + x1155 = (x1152)+(x1154); + x1156 = (x1155)+(x1078); + x1157 = (uintptr_t)((x1156)<(x1078)); + x1158 = (x1156)+(x1130); + x1159 = (uintptr_t)((x1158)<(x1130)); + x1160 = (x1157)+(x1159); + x1161 = (x1160)+(x1083); + x1162 = (uintptr_t)((x1161)<(x1083)); + x1163 = (x1161)+(x1133); + x1164 = (uintptr_t)((x1163)<(x1133)); + x1165 = (x1162)+(x1164); + x1166 = (x1165)+(x1088); + x1167 = (uintptr_t)((x1166)<(x1088)); + x1168 = (x1166)+(x1097); + x1169 = (uintptr_t)((x1168)<(x1097)); + x1170 = (x1167)+(x1169); + x1171 = (x1170)+(x1093); + x1172 = (uintptr_t)((x1171)<(x1093)); + x1173 = (x1171)+(x1098); + x1174 = (uintptr_t)((x1173)<(x1098)); + x1175 = (x1172)+(x1174); + x1176 = (x1175)+(x1095); + x1177 = (x14)*(x7); + x1178 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x7))>>32 : ((__uint128_t)(x14)*(x7))>>64); + x1179 = (x14)*(x6); + x1180 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x6))>>32 : ((__uint128_t)(x14)*(x6))>>64); + x1181 = (x14)*(x5); + x1182 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x5))>>32 : ((__uint128_t)(x14)*(x5))>>64); + x1183 = (x14)*(x4); + x1184 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x4))>>32 : ((__uint128_t)(x14)*(x4))>>64); + x1185 = (x14)*(x3); + x1186 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x3))>>32 : ((__uint128_t)(x14)*(x3))>>64); + x1187 = (x14)*(x2); + x1188 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x2))>>32 : ((__uint128_t)(x14)*(x2))>>64); + x1189 = (x14)*(x1); + x1190 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x1))>>32 : ((__uint128_t)(x14)*(x1))>>64); + x1191 = (x14)*(x0); + x1192 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x0))>>32 : ((__uint128_t)(x14)*(x0))>>64); + x1193 = (x1192)+(x1189); + x1194 = (uintptr_t)((x1193)<(x1192)); + x1195 = (x1194)+(x1190); + x1196 = (uintptr_t)((x1195)<(x1190)); + x1197 = (x1195)+(x1187); + x1198 = (uintptr_t)((x1197)<(x1187)); + x1199 = (x1196)+(x1198); + x1200 = (x1199)+(x1188); + x1201 = (uintptr_t)((x1200)<(x1188)); + x1202 = (x1200)+(x1185); + x1203 = (uintptr_t)((x1202)<(x1185)); + x1204 = (x1201)+(x1203); + x1205 = (x1204)+(x1186); + x1206 = (uintptr_t)((x1205)<(x1186)); + x1207 = (x1205)+(x1183); + x1208 = (uintptr_t)((x1207)<(x1183)); + x1209 = (x1206)+(x1208); + x1210 = (x1209)+(x1184); + x1211 = (uintptr_t)((x1210)<(x1184)); + x1212 = (x1210)+(x1181); + x1213 = (uintptr_t)((x1212)<(x1181)); + x1214 = (x1211)+(x1213); + x1215 = (x1214)+(x1182); + x1216 = (uintptr_t)((x1215)<(x1182)); + x1217 = (x1215)+(x1179); + x1218 = (uintptr_t)((x1217)<(x1179)); + x1219 = (x1216)+(x1218); + x1220 = (x1219)+(x1180); + x1221 = (uintptr_t)((x1220)<(x1180)); + x1222 = (x1220)+(x1177); + x1223 = (uintptr_t)((x1222)<(x1177)); + x1224 = (x1221)+(x1223); + x1225 = (x1224)+(x1178); + x1226 = (x1138)+(x1191); + x1227 = (uintptr_t)((x1226)<(x1138)); + x1228 = (x1227)+(x1143); + x1229 = (uintptr_t)((x1228)<(x1143)); + x1230 = (x1228)+(x1193); + x1231 = (uintptr_t)((x1230)<(x1193)); + x1232 = (x1229)+(x1231); + x1233 = (x1232)+(x1148); + x1234 = (uintptr_t)((x1233)<(x1148)); + x1235 = (x1233)+(x1197); + x1236 = (uintptr_t)((x1235)<(x1197)); + x1237 = (x1234)+(x1236); + x1238 = (x1237)+(x1153); + x1239 = (uintptr_t)((x1238)<(x1153)); + x1240 = (x1238)+(x1202); + x1241 = (uintptr_t)((x1240)<(x1202)); + x1242 = (x1239)+(x1241); + x1243 = (x1242)+(x1158); + x1244 = (uintptr_t)((x1243)<(x1158)); + x1245 = (x1243)+(x1207); + x1246 = (uintptr_t)((x1245)<(x1207)); + x1247 = (x1244)+(x1246); + x1248 = (x1247)+(x1163); + x1249 = (uintptr_t)((x1248)<(x1163)); + x1250 = (x1248)+(x1212); + x1251 = (uintptr_t)((x1250)<(x1212)); + x1252 = (x1249)+(x1251); + x1253 = (x1252)+(x1168); + x1254 = (uintptr_t)((x1253)<(x1168)); + x1255 = (x1253)+(x1217); + x1256 = (uintptr_t)((x1255)<(x1217)); + x1257 = (x1254)+(x1256); + x1258 = (x1257)+(x1173); + x1259 = (uintptr_t)((x1258)<(x1173)); + x1260 = (x1258)+(x1222); + x1261 = (uintptr_t)((x1260)<(x1222)); + x1262 = (x1259)+(x1261); + x1263 = (x1262)+(x1176); + x1264 = (uintptr_t)((x1263)<(x1176)); + x1265 = (x1263)+(x1225); + x1266 = (uintptr_t)((x1265)<(x1225)); + x1267 = (x1264)+(x1266); + x1268 = (x1226)*((uintptr_t)3993025615ULL); + x1269 = (x1268)*((uintptr_t)4294967295ULL); + x1270 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1268)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1268)*((uintptr_t)4294967295ULL))>>64); + x1271 = (x1268)*((uintptr_t)4294967295ULL); + x1272 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1268)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1268)*((uintptr_t)4294967295ULL))>>64); + x1273 = (x1268)*((uintptr_t)4294967295ULL); + x1274 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1268)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1268)*((uintptr_t)4294967295ULL))>>64); + x1275 = (x1268)*((uintptr_t)3169254061ULL); + x1276 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1268)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x1268)*((uintptr_t)3169254061ULL))>>64); + x1277 = (x1268)*((uintptr_t)2803342980ULL); + x1278 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1268)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x1268)*((uintptr_t)2803342980ULL))>>64); + x1279 = (x1268)*((uintptr_t)4089039554ULL); + x1280 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1268)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x1268)*((uintptr_t)4089039554ULL))>>64); + x1281 = (x1268)*((uintptr_t)4234356049ULL); + x1282 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1268)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x1268)*((uintptr_t)4234356049ULL))>>64); + x1283 = (x1282)+(x1279); + x1284 = (uintptr_t)((x1283)<(x1282)); + x1285 = (x1284)+(x1280); + x1286 = (uintptr_t)((x1285)<(x1280)); + x1287 = (x1285)+(x1277); + x1288 = (uintptr_t)((x1287)<(x1277)); + x1289 = (x1286)+(x1288); + x1290 = (x1289)+(x1278); + x1291 = (uintptr_t)((x1290)<(x1278)); + x1292 = (x1290)+(x1275); + x1293 = (uintptr_t)((x1292)<(x1275)); + x1294 = (x1291)+(x1293); + x1295 = (x1294)+(x1276); + x1296 = (uintptr_t)((x1295)<(x1276)); + x1297 = (x1295)+(x1273); + x1298 = (uintptr_t)((x1297)<(x1273)); + x1299 = (x1296)+(x1298); + x1300 = (x1299)+(x1274); + x1301 = (uintptr_t)((x1300)<(x1274)); + x1302 = (x1300)+(x1271); + x1303 = (uintptr_t)((x1302)<(x1271)); + x1304 = (x1301)+(x1303); + x1305 = (x1304)+(x1272); + x1306 = (x1226)+(x1281); + x1307 = (uintptr_t)((x1306)<(x1226)); + x1308 = (x1307)+(x1230); + x1309 = (uintptr_t)((x1308)<(x1230)); + x1310 = (x1308)+(x1283); + x1311 = (uintptr_t)((x1310)<(x1283)); + x1312 = (x1309)+(x1311); + x1313 = (x1312)+(x1235); + x1314 = (uintptr_t)((x1313)<(x1235)); + x1315 = (x1313)+(x1287); + x1316 = (uintptr_t)((x1315)<(x1287)); + x1317 = (x1314)+(x1316); + x1318 = (x1317)+(x1240); + x1319 = (uintptr_t)((x1318)<(x1240)); + x1320 = (x1318)+(x1292); + x1321 = (uintptr_t)((x1320)<(x1292)); + x1322 = (x1319)+(x1321); + x1323 = (x1322)+(x1245); + x1324 = (uintptr_t)((x1323)<(x1245)); + x1325 = (x1323)+(x1297); + x1326 = (uintptr_t)((x1325)<(x1297)); + x1327 = (x1324)+(x1326); + x1328 = (x1327)+(x1250); + x1329 = (uintptr_t)((x1328)<(x1250)); + x1330 = (x1328)+(x1302); + x1331 = (uintptr_t)((x1330)<(x1302)); + x1332 = (x1329)+(x1331); + x1333 = (x1332)+(x1255); + x1334 = (uintptr_t)((x1333)<(x1255)); + x1335 = (x1333)+(x1305); + x1336 = (uintptr_t)((x1335)<(x1305)); + x1337 = (x1334)+(x1336); + x1338 = (x1337)+(x1260); + x1339 = (uintptr_t)((x1338)<(x1260)); + x1340 = (x1338)+(x1269); + x1341 = (uintptr_t)((x1340)<(x1269)); + x1342 = (x1339)+(x1341); + x1343 = (x1342)+(x1265); + x1344 = (uintptr_t)((x1343)<(x1265)); + x1345 = (x1343)+(x1270); + x1346 = (uintptr_t)((x1345)<(x1270)); + x1347 = (x1344)+(x1346); + x1348 = (x1347)+(x1267); + x1349 = (x1310)-((uintptr_t)4234356049ULL); + x1350 = (uintptr_t)((x1310)<(x1349)); + x1351 = (x1315)-((uintptr_t)4089039554ULL); + x1352 = (uintptr_t)((x1315)<(x1351)); + x1353 = (x1351)-(x1350); + x1354 = (uintptr_t)((x1351)<(x1353)); + x1355 = (x1352)+(x1354); + x1356 = (x1320)-((uintptr_t)2803342980ULL); + x1357 = (uintptr_t)((x1320)<(x1356)); + x1358 = (x1356)-(x1355); + x1359 = (uintptr_t)((x1356)<(x1358)); + x1360 = (x1357)+(x1359); + x1361 = (x1325)-((uintptr_t)3169254061ULL); + x1362 = (uintptr_t)((x1325)<(x1361)); + x1363 = (x1361)-(x1360); + x1364 = (uintptr_t)((x1361)<(x1363)); + x1365 = (x1362)+(x1364); + x1366 = (x1330)-((uintptr_t)4294967295ULL); + x1367 = (uintptr_t)((x1330)<(x1366)); + x1368 = (x1366)-(x1365); + x1369 = (uintptr_t)((x1366)<(x1368)); + x1370 = (x1367)+(x1369); + x1371 = (x1335)-((uintptr_t)4294967295ULL); + x1372 = (uintptr_t)((x1335)<(x1371)); + x1373 = (x1371)-(x1370); + x1374 = (uintptr_t)((x1371)<(x1373)); + x1375 = (x1372)+(x1374); + x1376 = (x1340)-(x1375); + x1377 = (uintptr_t)((x1340)<(x1376)); + x1378 = (x1345)-((uintptr_t)4294967295ULL); + x1379 = (uintptr_t)((x1345)<(x1378)); + x1380 = (x1378)-(x1377); + x1381 = (uintptr_t)((x1378)<(x1380)); + x1382 = (x1379)+(x1381); + x1383 = (x1348)-(x1382); + x1384 = (uintptr_t)((x1348)<(x1383)); + x1385 = ((uintptr_t)-1ULL)+((uintptr_t)((x1384)==((uintptr_t)0ULL))); + x1386 = (x1385)^((uintptr_t)4294967295ULL); + x1387 = ((x1310)&(x1385))|((x1349)&(x1386)); + x1388 = ((uintptr_t)-1ULL)+((uintptr_t)((x1384)==((uintptr_t)0ULL))); + x1389 = (x1388)^((uintptr_t)4294967295ULL); + x1390 = ((x1315)&(x1388))|((x1353)&(x1389)); + x1391 = ((uintptr_t)-1ULL)+((uintptr_t)((x1384)==((uintptr_t)0ULL))); + x1392 = (x1391)^((uintptr_t)4294967295ULL); + x1393 = ((x1320)&(x1391))|((x1358)&(x1392)); + x1394 = ((uintptr_t)-1ULL)+((uintptr_t)((x1384)==((uintptr_t)0ULL))); + x1395 = (x1394)^((uintptr_t)4294967295ULL); + x1396 = ((x1325)&(x1394))|((x1363)&(x1395)); + x1397 = ((uintptr_t)-1ULL)+((uintptr_t)((x1384)==((uintptr_t)0ULL))); + x1398 = (x1397)^((uintptr_t)4294967295ULL); + x1399 = ((x1330)&(x1397))|((x1368)&(x1398)); + x1400 = ((uintptr_t)-1ULL)+((uintptr_t)((x1384)==((uintptr_t)0ULL))); + x1401 = (x1400)^((uintptr_t)4294967295ULL); + x1402 = ((x1335)&(x1400))|((x1373)&(x1401)); + x1403 = ((uintptr_t)-1ULL)+((uintptr_t)((x1384)==((uintptr_t)0ULL))); + x1404 = (x1403)^((uintptr_t)4294967295ULL); + x1405 = ((x1340)&(x1403))|((x1376)&(x1404)); + x1406 = ((uintptr_t)-1ULL)+((uintptr_t)((x1384)==((uintptr_t)0ULL))); + x1407 = (x1406)^((uintptr_t)4294967295ULL); + x1408 = ((x1345)&(x1406))|((x1380)&(x1407)); + x1409 = x1387; + x1410 = x1390; + x1411 = x1393; + x1412 = x1396; + x1413 = x1399; + x1414 = x1402; + x1415 = x1405; + x1416 = x1408; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x1409, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1410, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1411, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x1412, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x1413, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x1414, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x1415, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x1416, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_square(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_p256_scalar_square((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p256_scalar_add(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x8, x0, x17, x1, x9, x19, x2, x10, x21, x3, x11, x23, x4, x12, x25, x5, x13, x27, x6, x14, x29, x7, x15, x33, x35, x37, x39, x41, x31, x44, x16, x47, x32, x48, x18, x50, x34, x51, x20, x53, x36, x54, x22, x56, x38, x57, x24, x59, x40, x60, x26, x62, x42, x63, x28, x65, x43, x66, x46, x30, x68, x45, x69, x49, x52, x55, x58, x61, x64, x67, x70, x71, x72, x73, x74, x75, x76, x77, x78; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = (x0)+(x8); + x17 = ((uintptr_t)((x16)<(x0)))+(x1); + x18 = (x17)+(x9); + x19 = (((uintptr_t)((x17)<(x1)))+((uintptr_t)((x18)<(x9))))+(x2); + x20 = (x19)+(x10); + x21 = (((uintptr_t)((x19)<(x2)))+((uintptr_t)((x20)<(x10))))+(x3); + x22 = (x21)+(x11); + x23 = (((uintptr_t)((x21)<(x3)))+((uintptr_t)((x22)<(x11))))+(x4); + x24 = (x23)+(x12); + x25 = (((uintptr_t)((x23)<(x4)))+((uintptr_t)((x24)<(x12))))+(x5); + x26 = (x25)+(x13); + x27 = (((uintptr_t)((x25)<(x5)))+((uintptr_t)((x26)<(x13))))+(x6); + x28 = (x27)+(x14); + x29 = (((uintptr_t)((x27)<(x6)))+((uintptr_t)((x28)<(x14))))+(x7); + x30 = (x29)+(x15); + x31 = ((uintptr_t)((x29)<(x7)))+((uintptr_t)((x30)<(x15))); + x32 = (x16)-((uintptr_t)4234356049ULL); + x33 = (x18)-((uintptr_t)4089039554ULL); + x34 = (x33)-((uintptr_t)((x16)<(x32))); + x35 = (x20)-((uintptr_t)2803342980ULL); + x36 = (x35)-(((uintptr_t)((x18)<(x33)))+((uintptr_t)((x33)<(x34)))); + x37 = (x22)-((uintptr_t)3169254061ULL); + x38 = (x37)-(((uintptr_t)((x20)<(x35)))+((uintptr_t)((x35)<(x36)))); + x39 = (x24)-((uintptr_t)4294967295ULL); + x40 = (x39)-(((uintptr_t)((x22)<(x37)))+((uintptr_t)((x37)<(x38)))); + x41 = (x26)-((uintptr_t)4294967295ULL); + x42 = (x41)-(((uintptr_t)((x24)<(x39)))+((uintptr_t)((x39)<(x40)))); + x43 = (x28)-(((uintptr_t)((x26)<(x41)))+((uintptr_t)((x41)<(x42)))); + x44 = (x30)-((uintptr_t)4294967295ULL); + x45 = (x44)-((uintptr_t)((x28)<(x43))); + x46 = (uintptr_t)((x31)<((x31)-(((uintptr_t)((x30)<(x44)))+((uintptr_t)((x44)<(x45)))))); + x47 = ((uintptr_t)-1ULL)+((uintptr_t)((x46)==((uintptr_t)0ULL))); + x48 = (x47)^((uintptr_t)4294967295ULL); + x49 = ((x16)&(x47))|((x32)&(x48)); + x50 = ((uintptr_t)-1ULL)+((uintptr_t)((x46)==((uintptr_t)0ULL))); + x51 = (x50)^((uintptr_t)4294967295ULL); + x52 = ((x18)&(x50))|((x34)&(x51)); + x53 = ((uintptr_t)-1ULL)+((uintptr_t)((x46)==((uintptr_t)0ULL))); + x54 = (x53)^((uintptr_t)4294967295ULL); + x55 = ((x20)&(x53))|((x36)&(x54)); + x56 = ((uintptr_t)-1ULL)+((uintptr_t)((x46)==((uintptr_t)0ULL))); + x57 = (x56)^((uintptr_t)4294967295ULL); + x58 = ((x22)&(x56))|((x38)&(x57)); + x59 = ((uintptr_t)-1ULL)+((uintptr_t)((x46)==((uintptr_t)0ULL))); + x60 = (x59)^((uintptr_t)4294967295ULL); + x61 = ((x24)&(x59))|((x40)&(x60)); + x62 = ((uintptr_t)-1ULL)+((uintptr_t)((x46)==((uintptr_t)0ULL))); + x63 = (x62)^((uintptr_t)4294967295ULL); + x64 = ((x26)&(x62))|((x42)&(x63)); + x65 = ((uintptr_t)-1ULL)+((uintptr_t)((x46)==((uintptr_t)0ULL))); + x66 = (x65)^((uintptr_t)4294967295ULL); + x67 = ((x28)&(x65))|((x43)&(x66)); + x68 = ((uintptr_t)-1ULL)+((uintptr_t)((x46)==((uintptr_t)0ULL))); + x69 = (x68)^((uintptr_t)4294967295ULL); + x70 = ((x30)&(x68))|((x45)&(x69)); + x71 = x49; + x72 = x52; + x73 = x55; + x74 = x58; + x75 = x61; + x76 = x64; + x77 = x67; + x78 = x70; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x71, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x72, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x73, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x74, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x75, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x76, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x77, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x78, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_add(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_p256_scalar_add((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p256_scalar_sub(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x8, x9, x0, x10, x1, x17, x11, x2, x19, x12, x3, x21, x13, x4, x23, x14, x5, x25, x15, x6, x27, x7, x29, x16, x33, x18, x35, x20, x37, x22, x39, x24, x41, x26, x28, x30, x31, x32, x34, x36, x38, x40, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = (x0)-(x8); + x17 = (x1)-(x9); + x18 = (x17)-((uintptr_t)((x0)<(x16))); + x19 = (x2)-(x10); + x20 = (x19)-(((uintptr_t)((x1)<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = (x3)-(x11); + x22 = (x21)-(((uintptr_t)((x2)<(x19)))+((uintptr_t)((x19)<(x20)))); + x23 = (x4)-(x12); + x24 = (x23)-(((uintptr_t)((x3)<(x21)))+((uintptr_t)((x21)<(x22)))); + x25 = (x5)-(x13); + x26 = (x25)-(((uintptr_t)((x4)<(x23)))+((uintptr_t)((x23)<(x24)))); + x27 = (x6)-(x14); + x28 = (x27)-(((uintptr_t)((x5)<(x25)))+((uintptr_t)((x25)<(x26)))); + x29 = (x7)-(x15); + x30 = (x29)-(((uintptr_t)((x6)<(x27)))+((uintptr_t)((x27)<(x28)))); + x31 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)((x7)<(x29)))+((uintptr_t)((x29)<(x30))))==((uintptr_t)0ULL))); + x32 = (x16)+((x31)&((uintptr_t)4234356049ULL)); + x33 = ((uintptr_t)((x32)<(x16)))+(x18); + x34 = (x33)+((x31)&((uintptr_t)4089039554ULL)); + x35 = (((uintptr_t)((x33)<(x18)))+((uintptr_t)((x34)<((x31)&((uintptr_t)4089039554ULL)))))+(x20); + x36 = (x35)+((x31)&((uintptr_t)2803342980ULL)); + x37 = (((uintptr_t)((x35)<(x20)))+((uintptr_t)((x36)<((x31)&((uintptr_t)2803342980ULL)))))+(x22); + x38 = (x37)+((x31)&((uintptr_t)3169254061ULL)); + x39 = (((uintptr_t)((x37)<(x22)))+((uintptr_t)((x38)<((x31)&((uintptr_t)3169254061ULL)))))+(x24); + x40 = (x39)+(x31); + x41 = (((uintptr_t)((x39)<(x24)))+((uintptr_t)((x40)<(x31))))+(x26); + x42 = (x41)+(x31); + x43 = (((uintptr_t)((x41)<(x26)))+((uintptr_t)((x42)<(x31))))+(x28); + x44 = (((uintptr_t)((x43)<(x28)))+(x30))+(x31); + x45 = x32; + x46 = x34; + x47 = x36; + x48 = x38; + x49 = x40; + x50 = x42; + x51 = x43; + x52 = x44; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x45, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x46, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x47, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x48, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x49, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x50, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x51, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x52, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_sub(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_p256_scalar_sub((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p256_scalar_opp(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x1, x2, x9, x3, x11, x4, x13, x5, x15, x6, x17, x7, x19, x21, x8, x25, x10, x27, x12, x29, x14, x31, x16, x33, x18, x20, x22, x23, x24, x26, x28, x30, x32, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = ((uintptr_t)0ULL)-(x0); + x9 = ((uintptr_t)0ULL)-(x1); + x10 = (x9)-((uintptr_t)(((uintptr_t)0ULL)<(x8))); + x11 = ((uintptr_t)0ULL)-(x2); + x12 = (x11)-(((uintptr_t)(((uintptr_t)0ULL)<(x9)))+((uintptr_t)((x9)<(x10)))); + x13 = ((uintptr_t)0ULL)-(x3); + x14 = (x13)-(((uintptr_t)(((uintptr_t)0ULL)<(x11)))+((uintptr_t)((x11)<(x12)))); + x15 = ((uintptr_t)0ULL)-(x4); + x16 = (x15)-(((uintptr_t)(((uintptr_t)0ULL)<(x13)))+((uintptr_t)((x13)<(x14)))); + x17 = ((uintptr_t)0ULL)-(x5); + x18 = (x17)-(((uintptr_t)(((uintptr_t)0ULL)<(x15)))+((uintptr_t)((x15)<(x16)))); + x19 = ((uintptr_t)0ULL)-(x6); + x20 = (x19)-(((uintptr_t)(((uintptr_t)0ULL)<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = ((uintptr_t)0ULL)-(x7); + x22 = (x21)-(((uintptr_t)(((uintptr_t)0ULL)<(x19)))+((uintptr_t)((x19)<(x20)))); + x23 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)(((uintptr_t)0ULL)<(x21)))+((uintptr_t)((x21)<(x22))))==((uintptr_t)0ULL))); + x24 = (x8)+((x23)&((uintptr_t)4234356049ULL)); + x25 = ((uintptr_t)((x24)<(x8)))+(x10); + x26 = (x25)+((x23)&((uintptr_t)4089039554ULL)); + x27 = (((uintptr_t)((x25)<(x10)))+((uintptr_t)((x26)<((x23)&((uintptr_t)4089039554ULL)))))+(x12); + x28 = (x27)+((x23)&((uintptr_t)2803342980ULL)); + x29 = (((uintptr_t)((x27)<(x12)))+((uintptr_t)((x28)<((x23)&((uintptr_t)2803342980ULL)))))+(x14); + x30 = (x29)+((x23)&((uintptr_t)3169254061ULL)); + x31 = (((uintptr_t)((x29)<(x14)))+((uintptr_t)((x30)<((x23)&((uintptr_t)3169254061ULL)))))+(x16); + x32 = (x31)+(x23); + x33 = (((uintptr_t)((x31)<(x16)))+((uintptr_t)((x32)<(x23))))+(x18); + x34 = (x33)+(x23); + x35 = (((uintptr_t)((x33)<(x18)))+((uintptr_t)((x34)<(x23))))+(x20); + x36 = (((uintptr_t)((x35)<(x20)))+(x22))+(x23); + x37 = x24; + x38 = x26; + x39 = x28; + x40 = x30; + x41 = x32; + x42 = x34; + x43 = x35; + x44 = x36; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x37, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x38, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x39, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x40, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x41, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x42, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x43, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x44, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_opp(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_p256_scalar_opp((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p256_scalar_from_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x21, x23, x20, x18, x25, x19, x16, x27, x17, x14, x29, x15, x12, x9, x8, x22, x24, x26, x28, x30, x31, x13, x10, x1, x32, x33, x34, x35, x36, x37, x38, x39, x11, x61, x63, x60, x58, x65, x59, x56, x67, x57, x54, x69, x55, x52, x49, x40, x72, x41, x62, x74, x42, x64, x76, x43, x66, x78, x44, x68, x80, x45, x70, x82, x46, x71, x53, x84, x47, x50, x86, x48, x51, x2, x73, x75, x77, x79, x81, x83, x85, x87, x110, x112, x109, x107, x114, x108, x105, x116, x106, x103, x118, x104, x101, x98, x89, x121, x90, x111, x123, x91, x113, x125, x92, x115, x127, x93, x117, x129, x94, x119, x131, x95, x120, x102, x133, x96, x99, x135, x97, x88, x100, x3, x122, x124, x126, x128, x130, x132, x134, x136, x159, x161, x158, x156, x163, x157, x154, x165, x155, x152, x167, x153, x150, x147, x138, x170, x139, x160, x172, x140, x162, x174, x141, x164, x176, x142, x166, x178, x143, x168, x180, x144, x169, x151, x182, x145, x148, x184, x146, x137, x149, x4, x171, x173, x175, x177, x179, x181, x183, x185, x208, x210, x207, x205, x212, x206, x203, x214, x204, x201, x216, x202, x199, x196, x187, x219, x188, x209, x221, x189, x211, x223, x190, x213, x225, x191, x215, x227, x192, x217, x229, x193, x218, x200, x231, x194, x197, x233, x195, x186, x198, x5, x220, x222, x224, x226, x228, x230, x232, x234, x257, x259, x256, x254, x261, x255, x252, x263, x253, x250, x265, x251, x248, x245, x236, x268, x237, x258, x270, x238, x260, x272, x239, x262, x274, x240, x264, x276, x241, x266, x278, x242, x267, x249, x280, x243, x246, x282, x244, x235, x247, x6, x269, x271, x273, x275, x277, x279, x281, x283, x306, x308, x305, x303, x310, x304, x301, x312, x302, x299, x314, x300, x297, x294, x285, x317, x286, x307, x319, x287, x309, x321, x288, x311, x323, x289, x313, x325, x290, x315, x327, x291, x316, x298, x329, x292, x295, x331, x293, x284, x296, x7, x318, x320, x322, x324, x326, x328, x330, x332, x355, x357, x354, x352, x359, x353, x350, x361, x351, x348, x363, x349, x346, x343, x334, x366, x335, x356, x368, x336, x358, x370, x337, x360, x372, x338, x362, x374, x339, x364, x376, x340, x365, x347, x378, x341, x344, x380, x342, x333, x345, x384, x386, x388, x390, x392, x382, x395, x367, x398, x383, x399, x369, x401, x385, x402, x371, x404, x387, x405, x373, x407, x389, x408, x375, x410, x391, x411, x377, x413, x393, x414, x379, x416, x394, x417, x397, x381, x419, x396, x420, x400, x403, x406, x409, x412, x415, x418, x421, x422, x423, x424, x425, x426, x427, x428, x429; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x0; + x9 = (x8)*((uintptr_t)3993025615ULL); + x10 = (x9)*((uintptr_t)4294967295ULL); + x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)4294967295ULL))>>64); + x12 = (x9)*((uintptr_t)4294967295ULL); + x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)4294967295ULL))>>64); + x14 = (x9)*((uintptr_t)4294967295ULL); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)4294967295ULL))>>64); + x16 = (x9)*((uintptr_t)3169254061ULL); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)3169254061ULL))>>64); + x18 = (x9)*((uintptr_t)2803342980ULL); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)2803342980ULL))>>64); + x20 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)4089039554ULL))>>64); + x21 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)4234356049ULL))>>64); + x22 = (x21)+((x9)*((uintptr_t)4089039554ULL)); + x23 = ((uintptr_t)((x22)<(x21)))+(x20); + x24 = (x23)+(x18); + x25 = (((uintptr_t)((x23)<(x20)))+((uintptr_t)((x24)<(x18))))+(x19); + x26 = (x25)+(x16); + x27 = (((uintptr_t)((x25)<(x19)))+((uintptr_t)((x26)<(x16))))+(x17); + x28 = (x27)+(x14); + x29 = (((uintptr_t)((x27)<(x17)))+((uintptr_t)((x28)<(x14))))+(x15); + x30 = (x29)+(x12); + x31 = ((uintptr_t)((x29)<(x15)))+((uintptr_t)((x30)<(x12))); + x32 = ((uintptr_t)(((x8)+((x9)*((uintptr_t)4234356049ULL)))<(x8)))+(x22); + x33 = ((uintptr_t)((x32)<(x22)))+(x24); + x34 = ((uintptr_t)((x33)<(x24)))+(x26); + x35 = ((uintptr_t)((x34)<(x26)))+(x28); + x36 = ((uintptr_t)((x35)<(x28)))+(x30); + x37 = ((uintptr_t)((x36)<(x30)))+((x31)+(x13)); + x38 = ((uintptr_t)((x37)<((x31)+(x13))))+(x10); + x39 = (uintptr_t)((x38)<(x10)); + x40 = (x32)+(x1); + x41 = ((uintptr_t)((x40)<(x32)))+(x33); + x42 = ((uintptr_t)((x41)<(x33)))+(x34); + x43 = ((uintptr_t)((x42)<(x34)))+(x35); + x44 = ((uintptr_t)((x43)<(x35)))+(x36); + x45 = ((uintptr_t)((x44)<(x36)))+(x37); + x46 = ((uintptr_t)((x45)<(x37)))+(x38); + x47 = ((uintptr_t)((x46)<(x38)))+((x39)+(x11)); + x48 = (uintptr_t)((x47)<((x39)+(x11))); + x49 = (x40)*((uintptr_t)3993025615ULL); + x50 = (x49)*((uintptr_t)4294967295ULL); + x51 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x49)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x49)*((uintptr_t)4294967295ULL))>>64); + x52 = (x49)*((uintptr_t)4294967295ULL); + x53 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x49)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x49)*((uintptr_t)4294967295ULL))>>64); + x54 = (x49)*((uintptr_t)4294967295ULL); + x55 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x49)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x49)*((uintptr_t)4294967295ULL))>>64); + x56 = (x49)*((uintptr_t)3169254061ULL); + x57 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x49)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x49)*((uintptr_t)3169254061ULL))>>64); + x58 = (x49)*((uintptr_t)2803342980ULL); + x59 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x49)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x49)*((uintptr_t)2803342980ULL))>>64); + x60 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x49)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x49)*((uintptr_t)4089039554ULL))>>64); + x61 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x49)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x49)*((uintptr_t)4234356049ULL))>>64); + x62 = (x61)+((x49)*((uintptr_t)4089039554ULL)); + x63 = ((uintptr_t)((x62)<(x61)))+(x60); + x64 = (x63)+(x58); + x65 = (((uintptr_t)((x63)<(x60)))+((uintptr_t)((x64)<(x58))))+(x59); + x66 = (x65)+(x56); + x67 = (((uintptr_t)((x65)<(x59)))+((uintptr_t)((x66)<(x56))))+(x57); + x68 = (x67)+(x54); + x69 = (((uintptr_t)((x67)<(x57)))+((uintptr_t)((x68)<(x54))))+(x55); + x70 = (x69)+(x52); + x71 = ((uintptr_t)((x69)<(x55)))+((uintptr_t)((x70)<(x52))); + x72 = ((uintptr_t)(((x40)+((x49)*((uintptr_t)4234356049ULL)))<(x40)))+(x41); + x73 = (x72)+(x62); + x74 = (((uintptr_t)((x72)<(x41)))+((uintptr_t)((x73)<(x62))))+(x42); + x75 = (x74)+(x64); + x76 = (((uintptr_t)((x74)<(x42)))+((uintptr_t)((x75)<(x64))))+(x43); + x77 = (x76)+(x66); + x78 = (((uintptr_t)((x76)<(x43)))+((uintptr_t)((x77)<(x66))))+(x44); + x79 = (x78)+(x68); + x80 = (((uintptr_t)((x78)<(x44)))+((uintptr_t)((x79)<(x68))))+(x45); + x81 = (x80)+(x70); + x82 = (((uintptr_t)((x80)<(x45)))+((uintptr_t)((x81)<(x70))))+(x46); + x83 = (x82)+((x71)+(x53)); + x84 = (((uintptr_t)((x82)<(x46)))+((uintptr_t)((x83)<((x71)+(x53)))))+(x47); + x85 = (x84)+(x50); + x86 = (((uintptr_t)((x84)<(x47)))+((uintptr_t)((x85)<(x50))))+(x48); + x87 = (x86)+(x51); + x88 = ((uintptr_t)((x86)<(x48)))+((uintptr_t)((x87)<(x51))); + x89 = (x73)+(x2); + x90 = ((uintptr_t)((x89)<(x73)))+(x75); + x91 = ((uintptr_t)((x90)<(x75)))+(x77); + x92 = ((uintptr_t)((x91)<(x77)))+(x79); + x93 = ((uintptr_t)((x92)<(x79)))+(x81); + x94 = ((uintptr_t)((x93)<(x81)))+(x83); + x95 = ((uintptr_t)((x94)<(x83)))+(x85); + x96 = ((uintptr_t)((x95)<(x85)))+(x87); + x97 = (uintptr_t)((x96)<(x87)); + x98 = (x89)*((uintptr_t)3993025615ULL); + x99 = (x98)*((uintptr_t)4294967295ULL); + x100 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x98)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x98)*((uintptr_t)4294967295ULL))>>64); + x101 = (x98)*((uintptr_t)4294967295ULL); + x102 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x98)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x98)*((uintptr_t)4294967295ULL))>>64); + x103 = (x98)*((uintptr_t)4294967295ULL); + x104 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x98)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x98)*((uintptr_t)4294967295ULL))>>64); + x105 = (x98)*((uintptr_t)3169254061ULL); + x106 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x98)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x98)*((uintptr_t)3169254061ULL))>>64); + x107 = (x98)*((uintptr_t)2803342980ULL); + x108 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x98)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x98)*((uintptr_t)2803342980ULL))>>64); + x109 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x98)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x98)*((uintptr_t)4089039554ULL))>>64); + x110 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x98)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x98)*((uintptr_t)4234356049ULL))>>64); + x111 = (x110)+((x98)*((uintptr_t)4089039554ULL)); + x112 = ((uintptr_t)((x111)<(x110)))+(x109); + x113 = (x112)+(x107); + x114 = (((uintptr_t)((x112)<(x109)))+((uintptr_t)((x113)<(x107))))+(x108); + x115 = (x114)+(x105); + x116 = (((uintptr_t)((x114)<(x108)))+((uintptr_t)((x115)<(x105))))+(x106); + x117 = (x116)+(x103); + x118 = (((uintptr_t)((x116)<(x106)))+((uintptr_t)((x117)<(x103))))+(x104); + x119 = (x118)+(x101); + x120 = ((uintptr_t)((x118)<(x104)))+((uintptr_t)((x119)<(x101))); + x121 = ((uintptr_t)(((x89)+((x98)*((uintptr_t)4234356049ULL)))<(x89)))+(x90); + x122 = (x121)+(x111); + x123 = (((uintptr_t)((x121)<(x90)))+((uintptr_t)((x122)<(x111))))+(x91); + x124 = (x123)+(x113); + x125 = (((uintptr_t)((x123)<(x91)))+((uintptr_t)((x124)<(x113))))+(x92); + x126 = (x125)+(x115); + x127 = (((uintptr_t)((x125)<(x92)))+((uintptr_t)((x126)<(x115))))+(x93); + x128 = (x127)+(x117); + x129 = (((uintptr_t)((x127)<(x93)))+((uintptr_t)((x128)<(x117))))+(x94); + x130 = (x129)+(x119); + x131 = (((uintptr_t)((x129)<(x94)))+((uintptr_t)((x130)<(x119))))+(x95); + x132 = (x131)+((x120)+(x102)); + x133 = (((uintptr_t)((x131)<(x95)))+((uintptr_t)((x132)<((x120)+(x102)))))+(x96); + x134 = (x133)+(x99); + x135 = (((uintptr_t)((x133)<(x96)))+((uintptr_t)((x134)<(x99))))+((x97)+(x88)); + x136 = (x135)+(x100); + x137 = ((uintptr_t)((x135)<((x97)+(x88))))+((uintptr_t)((x136)<(x100))); + x138 = (x122)+(x3); + x139 = ((uintptr_t)((x138)<(x122)))+(x124); + x140 = ((uintptr_t)((x139)<(x124)))+(x126); + x141 = ((uintptr_t)((x140)<(x126)))+(x128); + x142 = ((uintptr_t)((x141)<(x128)))+(x130); + x143 = ((uintptr_t)((x142)<(x130)))+(x132); + x144 = ((uintptr_t)((x143)<(x132)))+(x134); + x145 = ((uintptr_t)((x144)<(x134)))+(x136); + x146 = (uintptr_t)((x145)<(x136)); + x147 = (x138)*((uintptr_t)3993025615ULL); + x148 = (x147)*((uintptr_t)4294967295ULL); + x149 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)4294967295ULL))>>64); + x150 = (x147)*((uintptr_t)4294967295ULL); + x151 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)4294967295ULL))>>64); + x152 = (x147)*((uintptr_t)4294967295ULL); + x153 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)4294967295ULL))>>64); + x154 = (x147)*((uintptr_t)3169254061ULL); + x155 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)3169254061ULL))>>64); + x156 = (x147)*((uintptr_t)2803342980ULL); + x157 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)2803342980ULL))>>64); + x158 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)4089039554ULL))>>64); + x159 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)4234356049ULL))>>64); + x160 = (x159)+((x147)*((uintptr_t)4089039554ULL)); + x161 = ((uintptr_t)((x160)<(x159)))+(x158); + x162 = (x161)+(x156); + x163 = (((uintptr_t)((x161)<(x158)))+((uintptr_t)((x162)<(x156))))+(x157); + x164 = (x163)+(x154); + x165 = (((uintptr_t)((x163)<(x157)))+((uintptr_t)((x164)<(x154))))+(x155); + x166 = (x165)+(x152); + x167 = (((uintptr_t)((x165)<(x155)))+((uintptr_t)((x166)<(x152))))+(x153); + x168 = (x167)+(x150); + x169 = ((uintptr_t)((x167)<(x153)))+((uintptr_t)((x168)<(x150))); + x170 = ((uintptr_t)(((x138)+((x147)*((uintptr_t)4234356049ULL)))<(x138)))+(x139); + x171 = (x170)+(x160); + x172 = (((uintptr_t)((x170)<(x139)))+((uintptr_t)((x171)<(x160))))+(x140); + x173 = (x172)+(x162); + x174 = (((uintptr_t)((x172)<(x140)))+((uintptr_t)((x173)<(x162))))+(x141); + x175 = (x174)+(x164); + x176 = (((uintptr_t)((x174)<(x141)))+((uintptr_t)((x175)<(x164))))+(x142); + x177 = (x176)+(x166); + x178 = (((uintptr_t)((x176)<(x142)))+((uintptr_t)((x177)<(x166))))+(x143); + x179 = (x178)+(x168); + x180 = (((uintptr_t)((x178)<(x143)))+((uintptr_t)((x179)<(x168))))+(x144); + x181 = (x180)+((x169)+(x151)); + x182 = (((uintptr_t)((x180)<(x144)))+((uintptr_t)((x181)<((x169)+(x151)))))+(x145); + x183 = (x182)+(x148); + x184 = (((uintptr_t)((x182)<(x145)))+((uintptr_t)((x183)<(x148))))+((x146)+(x137)); + x185 = (x184)+(x149); + x186 = ((uintptr_t)((x184)<((x146)+(x137))))+((uintptr_t)((x185)<(x149))); + x187 = (x171)+(x4); + x188 = ((uintptr_t)((x187)<(x171)))+(x173); + x189 = ((uintptr_t)((x188)<(x173)))+(x175); + x190 = ((uintptr_t)((x189)<(x175)))+(x177); + x191 = ((uintptr_t)((x190)<(x177)))+(x179); + x192 = ((uintptr_t)((x191)<(x179)))+(x181); + x193 = ((uintptr_t)((x192)<(x181)))+(x183); + x194 = ((uintptr_t)((x193)<(x183)))+(x185); + x195 = (uintptr_t)((x194)<(x185)); + x196 = (x187)*((uintptr_t)3993025615ULL); + x197 = (x196)*((uintptr_t)4294967295ULL); + x198 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x196)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x196)*((uintptr_t)4294967295ULL))>>64); + x199 = (x196)*((uintptr_t)4294967295ULL); + x200 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x196)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x196)*((uintptr_t)4294967295ULL))>>64); + x201 = (x196)*((uintptr_t)4294967295ULL); + x202 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x196)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x196)*((uintptr_t)4294967295ULL))>>64); + x203 = (x196)*((uintptr_t)3169254061ULL); + x204 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x196)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x196)*((uintptr_t)3169254061ULL))>>64); + x205 = (x196)*((uintptr_t)2803342980ULL); + x206 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x196)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x196)*((uintptr_t)2803342980ULL))>>64); + x207 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x196)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x196)*((uintptr_t)4089039554ULL))>>64); + x208 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x196)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x196)*((uintptr_t)4234356049ULL))>>64); + x209 = (x208)+((x196)*((uintptr_t)4089039554ULL)); + x210 = ((uintptr_t)((x209)<(x208)))+(x207); + x211 = (x210)+(x205); + x212 = (((uintptr_t)((x210)<(x207)))+((uintptr_t)((x211)<(x205))))+(x206); + x213 = (x212)+(x203); + x214 = (((uintptr_t)((x212)<(x206)))+((uintptr_t)((x213)<(x203))))+(x204); + x215 = (x214)+(x201); + x216 = (((uintptr_t)((x214)<(x204)))+((uintptr_t)((x215)<(x201))))+(x202); + x217 = (x216)+(x199); + x218 = ((uintptr_t)((x216)<(x202)))+((uintptr_t)((x217)<(x199))); + x219 = ((uintptr_t)(((x187)+((x196)*((uintptr_t)4234356049ULL)))<(x187)))+(x188); + x220 = (x219)+(x209); + x221 = (((uintptr_t)((x219)<(x188)))+((uintptr_t)((x220)<(x209))))+(x189); + x222 = (x221)+(x211); + x223 = (((uintptr_t)((x221)<(x189)))+((uintptr_t)((x222)<(x211))))+(x190); + x224 = (x223)+(x213); + x225 = (((uintptr_t)((x223)<(x190)))+((uintptr_t)((x224)<(x213))))+(x191); + x226 = (x225)+(x215); + x227 = (((uintptr_t)((x225)<(x191)))+((uintptr_t)((x226)<(x215))))+(x192); + x228 = (x227)+(x217); + x229 = (((uintptr_t)((x227)<(x192)))+((uintptr_t)((x228)<(x217))))+(x193); + x230 = (x229)+((x218)+(x200)); + x231 = (((uintptr_t)((x229)<(x193)))+((uintptr_t)((x230)<((x218)+(x200)))))+(x194); + x232 = (x231)+(x197); + x233 = (((uintptr_t)((x231)<(x194)))+((uintptr_t)((x232)<(x197))))+((x195)+(x186)); + x234 = (x233)+(x198); + x235 = ((uintptr_t)((x233)<((x195)+(x186))))+((uintptr_t)((x234)<(x198))); + x236 = (x220)+(x5); + x237 = ((uintptr_t)((x236)<(x220)))+(x222); + x238 = ((uintptr_t)((x237)<(x222)))+(x224); + x239 = ((uintptr_t)((x238)<(x224)))+(x226); + x240 = ((uintptr_t)((x239)<(x226)))+(x228); + x241 = ((uintptr_t)((x240)<(x228)))+(x230); + x242 = ((uintptr_t)((x241)<(x230)))+(x232); + x243 = ((uintptr_t)((x242)<(x232)))+(x234); + x244 = (uintptr_t)((x243)<(x234)); + x245 = (x236)*((uintptr_t)3993025615ULL); + x246 = (x245)*((uintptr_t)4294967295ULL); + x247 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x245)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x245)*((uintptr_t)4294967295ULL))>>64); + x248 = (x245)*((uintptr_t)4294967295ULL); + x249 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x245)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x245)*((uintptr_t)4294967295ULL))>>64); + x250 = (x245)*((uintptr_t)4294967295ULL); + x251 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x245)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x245)*((uintptr_t)4294967295ULL))>>64); + x252 = (x245)*((uintptr_t)3169254061ULL); + x253 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x245)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x245)*((uintptr_t)3169254061ULL))>>64); + x254 = (x245)*((uintptr_t)2803342980ULL); + x255 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x245)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x245)*((uintptr_t)2803342980ULL))>>64); + x256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x245)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x245)*((uintptr_t)4089039554ULL))>>64); + x257 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x245)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x245)*((uintptr_t)4234356049ULL))>>64); + x258 = (x257)+((x245)*((uintptr_t)4089039554ULL)); + x259 = ((uintptr_t)((x258)<(x257)))+(x256); + x260 = (x259)+(x254); + x261 = (((uintptr_t)((x259)<(x256)))+((uintptr_t)((x260)<(x254))))+(x255); + x262 = (x261)+(x252); + x263 = (((uintptr_t)((x261)<(x255)))+((uintptr_t)((x262)<(x252))))+(x253); + x264 = (x263)+(x250); + x265 = (((uintptr_t)((x263)<(x253)))+((uintptr_t)((x264)<(x250))))+(x251); + x266 = (x265)+(x248); + x267 = ((uintptr_t)((x265)<(x251)))+((uintptr_t)((x266)<(x248))); + x268 = ((uintptr_t)(((x236)+((x245)*((uintptr_t)4234356049ULL)))<(x236)))+(x237); + x269 = (x268)+(x258); + x270 = (((uintptr_t)((x268)<(x237)))+((uintptr_t)((x269)<(x258))))+(x238); + x271 = (x270)+(x260); + x272 = (((uintptr_t)((x270)<(x238)))+((uintptr_t)((x271)<(x260))))+(x239); + x273 = (x272)+(x262); + x274 = (((uintptr_t)((x272)<(x239)))+((uintptr_t)((x273)<(x262))))+(x240); + x275 = (x274)+(x264); + x276 = (((uintptr_t)((x274)<(x240)))+((uintptr_t)((x275)<(x264))))+(x241); + x277 = (x276)+(x266); + x278 = (((uintptr_t)((x276)<(x241)))+((uintptr_t)((x277)<(x266))))+(x242); + x279 = (x278)+((x267)+(x249)); + x280 = (((uintptr_t)((x278)<(x242)))+((uintptr_t)((x279)<((x267)+(x249)))))+(x243); + x281 = (x280)+(x246); + x282 = (((uintptr_t)((x280)<(x243)))+((uintptr_t)((x281)<(x246))))+((x244)+(x235)); + x283 = (x282)+(x247); + x284 = ((uintptr_t)((x282)<((x244)+(x235))))+((uintptr_t)((x283)<(x247))); + x285 = (x269)+(x6); + x286 = ((uintptr_t)((x285)<(x269)))+(x271); + x287 = ((uintptr_t)((x286)<(x271)))+(x273); + x288 = ((uintptr_t)((x287)<(x273)))+(x275); + x289 = ((uintptr_t)((x288)<(x275)))+(x277); + x290 = ((uintptr_t)((x289)<(x277)))+(x279); + x291 = ((uintptr_t)((x290)<(x279)))+(x281); + x292 = ((uintptr_t)((x291)<(x281)))+(x283); + x293 = (uintptr_t)((x292)<(x283)); + x294 = (x285)*((uintptr_t)3993025615ULL); + x295 = (x294)*((uintptr_t)4294967295ULL); + x296 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x294)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x294)*((uintptr_t)4294967295ULL))>>64); + x297 = (x294)*((uintptr_t)4294967295ULL); + x298 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x294)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x294)*((uintptr_t)4294967295ULL))>>64); + x299 = (x294)*((uintptr_t)4294967295ULL); + x300 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x294)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x294)*((uintptr_t)4294967295ULL))>>64); + x301 = (x294)*((uintptr_t)3169254061ULL); + x302 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x294)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x294)*((uintptr_t)3169254061ULL))>>64); + x303 = (x294)*((uintptr_t)2803342980ULL); + x304 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x294)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x294)*((uintptr_t)2803342980ULL))>>64); + x305 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x294)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x294)*((uintptr_t)4089039554ULL))>>64); + x306 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x294)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x294)*((uintptr_t)4234356049ULL))>>64); + x307 = (x306)+((x294)*((uintptr_t)4089039554ULL)); + x308 = ((uintptr_t)((x307)<(x306)))+(x305); + x309 = (x308)+(x303); + x310 = (((uintptr_t)((x308)<(x305)))+((uintptr_t)((x309)<(x303))))+(x304); + x311 = (x310)+(x301); + x312 = (((uintptr_t)((x310)<(x304)))+((uintptr_t)((x311)<(x301))))+(x302); + x313 = (x312)+(x299); + x314 = (((uintptr_t)((x312)<(x302)))+((uintptr_t)((x313)<(x299))))+(x300); + x315 = (x314)+(x297); + x316 = ((uintptr_t)((x314)<(x300)))+((uintptr_t)((x315)<(x297))); + x317 = ((uintptr_t)(((x285)+((x294)*((uintptr_t)4234356049ULL)))<(x285)))+(x286); + x318 = (x317)+(x307); + x319 = (((uintptr_t)((x317)<(x286)))+((uintptr_t)((x318)<(x307))))+(x287); + x320 = (x319)+(x309); + x321 = (((uintptr_t)((x319)<(x287)))+((uintptr_t)((x320)<(x309))))+(x288); + x322 = (x321)+(x311); + x323 = (((uintptr_t)((x321)<(x288)))+((uintptr_t)((x322)<(x311))))+(x289); + x324 = (x323)+(x313); + x325 = (((uintptr_t)((x323)<(x289)))+((uintptr_t)((x324)<(x313))))+(x290); + x326 = (x325)+(x315); + x327 = (((uintptr_t)((x325)<(x290)))+((uintptr_t)((x326)<(x315))))+(x291); + x328 = (x327)+((x316)+(x298)); + x329 = (((uintptr_t)((x327)<(x291)))+((uintptr_t)((x328)<((x316)+(x298)))))+(x292); + x330 = (x329)+(x295); + x331 = (((uintptr_t)((x329)<(x292)))+((uintptr_t)((x330)<(x295))))+((x293)+(x284)); + x332 = (x331)+(x296); + x333 = ((uintptr_t)((x331)<((x293)+(x284))))+((uintptr_t)((x332)<(x296))); + x334 = (x318)+(x7); + x335 = ((uintptr_t)((x334)<(x318)))+(x320); + x336 = ((uintptr_t)((x335)<(x320)))+(x322); + x337 = ((uintptr_t)((x336)<(x322)))+(x324); + x338 = ((uintptr_t)((x337)<(x324)))+(x326); + x339 = ((uintptr_t)((x338)<(x326)))+(x328); + x340 = ((uintptr_t)((x339)<(x328)))+(x330); + x341 = ((uintptr_t)((x340)<(x330)))+(x332); + x342 = (uintptr_t)((x341)<(x332)); + x343 = (x334)*((uintptr_t)3993025615ULL); + x344 = (x343)*((uintptr_t)4294967295ULL); + x345 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x343)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x343)*((uintptr_t)4294967295ULL))>>64); + x346 = (x343)*((uintptr_t)4294967295ULL); + x347 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x343)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x343)*((uintptr_t)4294967295ULL))>>64); + x348 = (x343)*((uintptr_t)4294967295ULL); + x349 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x343)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x343)*((uintptr_t)4294967295ULL))>>64); + x350 = (x343)*((uintptr_t)3169254061ULL); + x351 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x343)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x343)*((uintptr_t)3169254061ULL))>>64); + x352 = (x343)*((uintptr_t)2803342980ULL); + x353 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x343)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x343)*((uintptr_t)2803342980ULL))>>64); + x354 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x343)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x343)*((uintptr_t)4089039554ULL))>>64); + x355 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x343)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x343)*((uintptr_t)4234356049ULL))>>64); + x356 = (x355)+((x343)*((uintptr_t)4089039554ULL)); + x357 = ((uintptr_t)((x356)<(x355)))+(x354); + x358 = (x357)+(x352); + x359 = (((uintptr_t)((x357)<(x354)))+((uintptr_t)((x358)<(x352))))+(x353); + x360 = (x359)+(x350); + x361 = (((uintptr_t)((x359)<(x353)))+((uintptr_t)((x360)<(x350))))+(x351); + x362 = (x361)+(x348); + x363 = (((uintptr_t)((x361)<(x351)))+((uintptr_t)((x362)<(x348))))+(x349); + x364 = (x363)+(x346); + x365 = ((uintptr_t)((x363)<(x349)))+((uintptr_t)((x364)<(x346))); + x366 = ((uintptr_t)(((x334)+((x343)*((uintptr_t)4234356049ULL)))<(x334)))+(x335); + x367 = (x366)+(x356); + x368 = (((uintptr_t)((x366)<(x335)))+((uintptr_t)((x367)<(x356))))+(x336); + x369 = (x368)+(x358); + x370 = (((uintptr_t)((x368)<(x336)))+((uintptr_t)((x369)<(x358))))+(x337); + x371 = (x370)+(x360); + x372 = (((uintptr_t)((x370)<(x337)))+((uintptr_t)((x371)<(x360))))+(x338); + x373 = (x372)+(x362); + x374 = (((uintptr_t)((x372)<(x338)))+((uintptr_t)((x373)<(x362))))+(x339); + x375 = (x374)+(x364); + x376 = (((uintptr_t)((x374)<(x339)))+((uintptr_t)((x375)<(x364))))+(x340); + x377 = (x376)+((x365)+(x347)); + x378 = (((uintptr_t)((x376)<(x340)))+((uintptr_t)((x377)<((x365)+(x347)))))+(x341); + x379 = (x378)+(x344); + x380 = (((uintptr_t)((x378)<(x341)))+((uintptr_t)((x379)<(x344))))+((x342)+(x333)); + x381 = (x380)+(x345); + x382 = ((uintptr_t)((x380)<((x342)+(x333))))+((uintptr_t)((x381)<(x345))); + x383 = (x367)-((uintptr_t)4234356049ULL); + x384 = (x369)-((uintptr_t)4089039554ULL); + x385 = (x384)-((uintptr_t)((x367)<(x383))); + x386 = (x371)-((uintptr_t)2803342980ULL); + x387 = (x386)-(((uintptr_t)((x369)<(x384)))+((uintptr_t)((x384)<(x385)))); + x388 = (x373)-((uintptr_t)3169254061ULL); + x389 = (x388)-(((uintptr_t)((x371)<(x386)))+((uintptr_t)((x386)<(x387)))); + x390 = (x375)-((uintptr_t)4294967295ULL); + x391 = (x390)-(((uintptr_t)((x373)<(x388)))+((uintptr_t)((x388)<(x389)))); + x392 = (x377)-((uintptr_t)4294967295ULL); + x393 = (x392)-(((uintptr_t)((x375)<(x390)))+((uintptr_t)((x390)<(x391)))); + x394 = (x379)-(((uintptr_t)((x377)<(x392)))+((uintptr_t)((x392)<(x393)))); + x395 = (x381)-((uintptr_t)4294967295ULL); + x396 = (x395)-((uintptr_t)((x379)<(x394))); + x397 = (uintptr_t)((x382)<((x382)-(((uintptr_t)((x381)<(x395)))+((uintptr_t)((x395)<(x396)))))); + x398 = ((uintptr_t)-1ULL)+((uintptr_t)((x397)==((uintptr_t)0ULL))); + x399 = (x398)^((uintptr_t)4294967295ULL); + x400 = ((x367)&(x398))|((x383)&(x399)); + x401 = ((uintptr_t)-1ULL)+((uintptr_t)((x397)==((uintptr_t)0ULL))); + x402 = (x401)^((uintptr_t)4294967295ULL); + x403 = ((x369)&(x401))|((x385)&(x402)); + x404 = ((uintptr_t)-1ULL)+((uintptr_t)((x397)==((uintptr_t)0ULL))); + x405 = (x404)^((uintptr_t)4294967295ULL); + x406 = ((x371)&(x404))|((x387)&(x405)); + x407 = ((uintptr_t)-1ULL)+((uintptr_t)((x397)==((uintptr_t)0ULL))); + x408 = (x407)^((uintptr_t)4294967295ULL); + x409 = ((x373)&(x407))|((x389)&(x408)); + x410 = ((uintptr_t)-1ULL)+((uintptr_t)((x397)==((uintptr_t)0ULL))); + x411 = (x410)^((uintptr_t)4294967295ULL); + x412 = ((x375)&(x410))|((x391)&(x411)); + x413 = ((uintptr_t)-1ULL)+((uintptr_t)((x397)==((uintptr_t)0ULL))); + x414 = (x413)^((uintptr_t)4294967295ULL); + x415 = ((x377)&(x413))|((x393)&(x414)); + x416 = ((uintptr_t)-1ULL)+((uintptr_t)((x397)==((uintptr_t)0ULL))); + x417 = (x416)^((uintptr_t)4294967295ULL); + x418 = ((x379)&(x416))|((x394)&(x417)); + x419 = ((uintptr_t)-1ULL)+((uintptr_t)((x397)==((uintptr_t)0ULL))); + x420 = (x419)^((uintptr_t)4294967295ULL); + x421 = ((x381)&(x419))|((x396)&(x420)); + x422 = x400; + x423 = x403; + x424 = x406; + x425 = x409; + x426 = x412; + x427 = x415; + x428 = x418; + x429 = x421; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x422, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x423, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x424, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x425, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x426, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x427, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x428, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x429, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_from_montgomery(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_p256_scalar_from_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p256_scalar_to_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x1, x2, x3, x4, x5, x6, x7, x0, x15, x30, x32, x28, x26, x34, x27, x24, x36, x25, x22, x38, x23, x20, x40, x21, x18, x42, x19, x16, x57, x59, x56, x54, x61, x55, x52, x63, x53, x50, x65, x51, x48, x45, x29, x68, x31, x58, x70, x33, x60, x72, x35, x62, x74, x37, x64, x76, x39, x66, x78, x41, x67, x49, x80, x43, x46, x82, x44, x17, x47, x98, x100, x97, x95, x102, x96, x93, x104, x94, x91, x106, x92, x89, x108, x90, x87, x110, x88, x85, x8, x69, x114, x71, x99, x116, x73, x101, x118, x75, x103, x120, x77, x105, x122, x79, x107, x124, x81, x109, x126, x83, x111, x141, x143, x140, x138, x145, x139, x136, x147, x137, x134, x149, x135, x132, x129, x113, x152, x115, x142, x154, x117, x144, x156, x119, x146, x158, x121, x148, x160, x123, x150, x162, x125, x151, x133, x164, x127, x130, x166, x128, x84, x112, x86, x131, x182, x184, x181, x179, x186, x180, x177, x188, x178, x175, x190, x176, x173, x192, x174, x171, x194, x172, x169, x9, x153, x198, x155, x183, x200, x157, x185, x202, x159, x187, x204, x161, x189, x206, x163, x191, x208, x165, x193, x210, x167, x195, x225, x227, x224, x222, x229, x223, x220, x231, x221, x218, x233, x219, x216, x213, x197, x236, x199, x226, x238, x201, x228, x240, x203, x230, x242, x205, x232, x244, x207, x234, x246, x209, x235, x217, x248, x211, x214, x250, x212, x168, x196, x170, x215, x266, x268, x265, x263, x270, x264, x261, x272, x262, x259, x274, x260, x257, x276, x258, x255, x278, x256, x253, x10, x237, x282, x239, x267, x284, x241, x269, x286, x243, x271, x288, x245, x273, x290, x247, x275, x292, x249, x277, x294, x251, x279, x309, x311, x308, x306, x313, x307, x304, x315, x305, x302, x317, x303, x300, x297, x281, x320, x283, x310, x322, x285, x312, x324, x287, x314, x326, x289, x316, x328, x291, x318, x330, x293, x319, x301, x332, x295, x298, x334, x296, x252, x280, x254, x299, x350, x352, x349, x347, x354, x348, x345, x356, x346, x343, x358, x344, x341, x360, x342, x339, x362, x340, x337, x11, x321, x366, x323, x351, x368, x325, x353, x370, x327, x355, x372, x329, x357, x374, x331, x359, x376, x333, x361, x378, x335, x363, x393, x395, x392, x390, x397, x391, x388, x399, x389, x386, x401, x387, x384, x381, x365, x404, x367, x394, x406, x369, x396, x408, x371, x398, x410, x373, x400, x412, x375, x402, x414, x377, x403, x385, x416, x379, x382, x418, x380, x336, x364, x338, x383, x434, x436, x433, x431, x438, x432, x429, x440, x430, x427, x442, x428, x425, x444, x426, x423, x446, x424, x421, x12, x405, x450, x407, x435, x452, x409, x437, x454, x411, x439, x456, x413, x441, x458, x415, x443, x460, x417, x445, x462, x419, x447, x477, x479, x476, x474, x481, x475, x472, x483, x473, x470, x485, x471, x468, x465, x449, x488, x451, x478, x490, x453, x480, x492, x455, x482, x494, x457, x484, x496, x459, x486, x498, x461, x487, x469, x500, x463, x466, x502, x464, x420, x448, x422, x467, x518, x520, x517, x515, x522, x516, x513, x524, x514, x511, x526, x512, x509, x528, x510, x507, x530, x508, x505, x13, x489, x534, x491, x519, x536, x493, x521, x538, x495, x523, x540, x497, x525, x542, x499, x527, x544, x501, x529, x546, x503, x531, x561, x563, x560, x558, x565, x559, x556, x567, x557, x554, x569, x555, x552, x549, x533, x572, x535, x562, x574, x537, x564, x576, x539, x566, x578, x541, x568, x580, x543, x570, x582, x545, x571, x553, x584, x547, x550, x586, x548, x504, x532, x506, x551, x602, x604, x601, x599, x606, x600, x597, x608, x598, x595, x610, x596, x593, x612, x594, x591, x614, x592, x589, x14, x573, x618, x575, x603, x620, x577, x605, x622, x579, x607, x624, x581, x609, x626, x583, x611, x628, x585, x613, x630, x587, x615, x645, x647, x644, x642, x649, x643, x640, x651, x641, x638, x653, x639, x636, x633, x617, x656, x619, x646, x658, x621, x648, x660, x623, x650, x662, x625, x652, x664, x627, x654, x666, x629, x655, x637, x668, x631, x634, x670, x632, x588, x616, x590, x635, x674, x676, x678, x680, x682, x672, x685, x657, x688, x673, x689, x659, x691, x675, x692, x661, x694, x677, x695, x663, x697, x679, x698, x665, x700, x681, x701, x667, x703, x683, x704, x669, x706, x684, x707, x687, x671, x709, x686, x710, x690, x693, x696, x699, x702, x705, x708, x711, x712, x713, x714, x715, x716, x717, x718, x719; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x1; + x9 = x2; + x10 = x3; + x11 = x4; + x12 = x5; + x13 = x6; + x14 = x7; + x15 = x0; + x16 = (x15)*((uintptr_t)1726033300ULL); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)1726033300ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)1726033300ULL))>>64); + x18 = (x15)*((uintptr_t)4091106848ULL); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)4091106848ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)4091106848ULL))>>64); + x20 = (x15)*((uintptr_t)675656249ULL); + x21 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)675656249ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)675656249ULL))>>64); + x22 = (x15)*((uintptr_t)728493145ULL); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)728493145ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)728493145ULL))>>64); + x24 = (x15)*((uintptr_t)1184463260ULL); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)1184463260ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)1184463260ULL))>>64); + x26 = (x15)*((uintptr_t)1237151654ULL); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)1237151654ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)1237151654ULL))>>64); + x28 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)2200194197ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)2200194197ULL))>>64); + x29 = (x15)*((uintptr_t)3195661986ULL); + x30 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)3195661986ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)3195661986ULL))>>64); + x31 = (x30)+((x15)*((uintptr_t)2200194197ULL)); + x32 = ((uintptr_t)((x31)<(x30)))+(x28); + x33 = (x32)+(x26); + x34 = (((uintptr_t)((x32)<(x28)))+((uintptr_t)((x33)<(x26))))+(x27); + x35 = (x34)+(x24); + x36 = (((uintptr_t)((x34)<(x27)))+((uintptr_t)((x35)<(x24))))+(x25); + x37 = (x36)+(x22); + x38 = (((uintptr_t)((x36)<(x25)))+((uintptr_t)((x37)<(x22))))+(x23); + x39 = (x38)+(x20); + x40 = (((uintptr_t)((x38)<(x23)))+((uintptr_t)((x39)<(x20))))+(x21); + x41 = (x40)+(x18); + x42 = (((uintptr_t)((x40)<(x21)))+((uintptr_t)((x41)<(x18))))+(x19); + x43 = (x42)+(x16); + x44 = ((uintptr_t)((x42)<(x19)))+((uintptr_t)((x43)<(x16))); + x45 = (x29)*((uintptr_t)3993025615ULL); + x46 = (x45)*((uintptr_t)4294967295ULL); + x47 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)4294967295ULL))>>64); + x48 = (x45)*((uintptr_t)4294967295ULL); + x49 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)4294967295ULL))>>64); + x50 = (x45)*((uintptr_t)4294967295ULL); + x51 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)4294967295ULL))>>64); + x52 = (x45)*((uintptr_t)3169254061ULL); + x53 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)3169254061ULL))>>64); + x54 = (x45)*((uintptr_t)2803342980ULL); + x55 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)2803342980ULL))>>64); + x56 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)4089039554ULL))>>64); + x57 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)4234356049ULL))>>64); + x58 = (x57)+((x45)*((uintptr_t)4089039554ULL)); + x59 = ((uintptr_t)((x58)<(x57)))+(x56); + x60 = (x59)+(x54); + x61 = (((uintptr_t)((x59)<(x56)))+((uintptr_t)((x60)<(x54))))+(x55); + x62 = (x61)+(x52); + x63 = (((uintptr_t)((x61)<(x55)))+((uintptr_t)((x62)<(x52))))+(x53); + x64 = (x63)+(x50); + x65 = (((uintptr_t)((x63)<(x53)))+((uintptr_t)((x64)<(x50))))+(x51); + x66 = (x65)+(x48); + x67 = ((uintptr_t)((x65)<(x51)))+((uintptr_t)((x66)<(x48))); + x68 = ((uintptr_t)(((x29)+((x45)*((uintptr_t)4234356049ULL)))<(x29)))+(x31); + x69 = (x68)+(x58); + x70 = (((uintptr_t)((x68)<(x31)))+((uintptr_t)((x69)<(x58))))+(x33); + x71 = (x70)+(x60); + x72 = (((uintptr_t)((x70)<(x33)))+((uintptr_t)((x71)<(x60))))+(x35); + x73 = (x72)+(x62); + x74 = (((uintptr_t)((x72)<(x35)))+((uintptr_t)((x73)<(x62))))+(x37); + x75 = (x74)+(x64); + x76 = (((uintptr_t)((x74)<(x37)))+((uintptr_t)((x75)<(x64))))+(x39); + x77 = (x76)+(x66); + x78 = (((uintptr_t)((x76)<(x39)))+((uintptr_t)((x77)<(x66))))+(x41); + x79 = (x78)+((x67)+(x49)); + x80 = (((uintptr_t)((x78)<(x41)))+((uintptr_t)((x79)<((x67)+(x49)))))+(x43); + x81 = (x80)+(x46); + x82 = (((uintptr_t)((x80)<(x43)))+((uintptr_t)((x81)<(x46))))+((x44)+(x17)); + x83 = (x82)+(x47); + x84 = ((uintptr_t)((x82)<((x44)+(x17))))+((uintptr_t)((x83)<(x47))); + x85 = (x8)*((uintptr_t)1726033300ULL); + x86 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)1726033300ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)1726033300ULL))>>64); + x87 = (x8)*((uintptr_t)4091106848ULL); + x88 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)4091106848ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)4091106848ULL))>>64); + x89 = (x8)*((uintptr_t)675656249ULL); + x90 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)675656249ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)675656249ULL))>>64); + x91 = (x8)*((uintptr_t)728493145ULL); + x92 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)728493145ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)728493145ULL))>>64); + x93 = (x8)*((uintptr_t)1184463260ULL); + x94 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)1184463260ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)1184463260ULL))>>64); + x95 = (x8)*((uintptr_t)1237151654ULL); + x96 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)1237151654ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)1237151654ULL))>>64); + x97 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)2200194197ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)2200194197ULL))>>64); + x98 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)3195661986ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)3195661986ULL))>>64); + x99 = (x98)+((x8)*((uintptr_t)2200194197ULL)); + x100 = ((uintptr_t)((x99)<(x98)))+(x97); + x101 = (x100)+(x95); + x102 = (((uintptr_t)((x100)<(x97)))+((uintptr_t)((x101)<(x95))))+(x96); + x103 = (x102)+(x93); + x104 = (((uintptr_t)((x102)<(x96)))+((uintptr_t)((x103)<(x93))))+(x94); + x105 = (x104)+(x91); + x106 = (((uintptr_t)((x104)<(x94)))+((uintptr_t)((x105)<(x91))))+(x92); + x107 = (x106)+(x89); + x108 = (((uintptr_t)((x106)<(x92)))+((uintptr_t)((x107)<(x89))))+(x90); + x109 = (x108)+(x87); + x110 = (((uintptr_t)((x108)<(x90)))+((uintptr_t)((x109)<(x87))))+(x88); + x111 = (x110)+(x85); + x112 = ((uintptr_t)((x110)<(x88)))+((uintptr_t)((x111)<(x85))); + x113 = (x69)+((x8)*((uintptr_t)3195661986ULL)); + x114 = ((uintptr_t)((x113)<(x69)))+(x71); + x115 = (x114)+(x99); + x116 = (((uintptr_t)((x114)<(x71)))+((uintptr_t)((x115)<(x99))))+(x73); + x117 = (x116)+(x101); + x118 = (((uintptr_t)((x116)<(x73)))+((uintptr_t)((x117)<(x101))))+(x75); + x119 = (x118)+(x103); + x120 = (((uintptr_t)((x118)<(x75)))+((uintptr_t)((x119)<(x103))))+(x77); + x121 = (x120)+(x105); + x122 = (((uintptr_t)((x120)<(x77)))+((uintptr_t)((x121)<(x105))))+(x79); + x123 = (x122)+(x107); + x124 = (((uintptr_t)((x122)<(x79)))+((uintptr_t)((x123)<(x107))))+(x81); + x125 = (x124)+(x109); + x126 = (((uintptr_t)((x124)<(x81)))+((uintptr_t)((x125)<(x109))))+(x83); + x127 = (x126)+(x111); + x128 = ((uintptr_t)((x126)<(x83)))+((uintptr_t)((x127)<(x111))); + x129 = (x113)*((uintptr_t)3993025615ULL); + x130 = (x129)*((uintptr_t)4294967295ULL); + x131 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x129)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x129)*((uintptr_t)4294967295ULL))>>64); + x132 = (x129)*((uintptr_t)4294967295ULL); + x133 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x129)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x129)*((uintptr_t)4294967295ULL))>>64); + x134 = (x129)*((uintptr_t)4294967295ULL); + x135 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x129)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x129)*((uintptr_t)4294967295ULL))>>64); + x136 = (x129)*((uintptr_t)3169254061ULL); + x137 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x129)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x129)*((uintptr_t)3169254061ULL))>>64); + x138 = (x129)*((uintptr_t)2803342980ULL); + x139 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x129)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x129)*((uintptr_t)2803342980ULL))>>64); + x140 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x129)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x129)*((uintptr_t)4089039554ULL))>>64); + x141 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x129)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x129)*((uintptr_t)4234356049ULL))>>64); + x142 = (x141)+((x129)*((uintptr_t)4089039554ULL)); + x143 = ((uintptr_t)((x142)<(x141)))+(x140); + x144 = (x143)+(x138); + x145 = (((uintptr_t)((x143)<(x140)))+((uintptr_t)((x144)<(x138))))+(x139); + x146 = (x145)+(x136); + x147 = (((uintptr_t)((x145)<(x139)))+((uintptr_t)((x146)<(x136))))+(x137); + x148 = (x147)+(x134); + x149 = (((uintptr_t)((x147)<(x137)))+((uintptr_t)((x148)<(x134))))+(x135); + x150 = (x149)+(x132); + x151 = ((uintptr_t)((x149)<(x135)))+((uintptr_t)((x150)<(x132))); + x152 = ((uintptr_t)(((x113)+((x129)*((uintptr_t)4234356049ULL)))<(x113)))+(x115); + x153 = (x152)+(x142); + x154 = (((uintptr_t)((x152)<(x115)))+((uintptr_t)((x153)<(x142))))+(x117); + x155 = (x154)+(x144); + x156 = (((uintptr_t)((x154)<(x117)))+((uintptr_t)((x155)<(x144))))+(x119); + x157 = (x156)+(x146); + x158 = (((uintptr_t)((x156)<(x119)))+((uintptr_t)((x157)<(x146))))+(x121); + x159 = (x158)+(x148); + x160 = (((uintptr_t)((x158)<(x121)))+((uintptr_t)((x159)<(x148))))+(x123); + x161 = (x160)+(x150); + x162 = (((uintptr_t)((x160)<(x123)))+((uintptr_t)((x161)<(x150))))+(x125); + x163 = (x162)+((x151)+(x133)); + x164 = (((uintptr_t)((x162)<(x125)))+((uintptr_t)((x163)<((x151)+(x133)))))+(x127); + x165 = (x164)+(x130); + x166 = (((uintptr_t)((x164)<(x127)))+((uintptr_t)((x165)<(x130))))+(((x128)+(x84))+((x112)+(x86))); + x167 = (x166)+(x131); + x168 = ((uintptr_t)((x166)<(((x128)+(x84))+((x112)+(x86)))))+((uintptr_t)((x167)<(x131))); + x169 = (x9)*((uintptr_t)1726033300ULL); + x170 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)1726033300ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)1726033300ULL))>>64); + x171 = (x9)*((uintptr_t)4091106848ULL); + x172 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)4091106848ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)4091106848ULL))>>64); + x173 = (x9)*((uintptr_t)675656249ULL); + x174 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)675656249ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)675656249ULL))>>64); + x175 = (x9)*((uintptr_t)728493145ULL); + x176 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)728493145ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)728493145ULL))>>64); + x177 = (x9)*((uintptr_t)1184463260ULL); + x178 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)1184463260ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)1184463260ULL))>>64); + x179 = (x9)*((uintptr_t)1237151654ULL); + x180 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)1237151654ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)1237151654ULL))>>64); + x181 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)2200194197ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)2200194197ULL))>>64); + x182 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)3195661986ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)3195661986ULL))>>64); + x183 = (x182)+((x9)*((uintptr_t)2200194197ULL)); + x184 = ((uintptr_t)((x183)<(x182)))+(x181); + x185 = (x184)+(x179); + x186 = (((uintptr_t)((x184)<(x181)))+((uintptr_t)((x185)<(x179))))+(x180); + x187 = (x186)+(x177); + x188 = (((uintptr_t)((x186)<(x180)))+((uintptr_t)((x187)<(x177))))+(x178); + x189 = (x188)+(x175); + x190 = (((uintptr_t)((x188)<(x178)))+((uintptr_t)((x189)<(x175))))+(x176); + x191 = (x190)+(x173); + x192 = (((uintptr_t)((x190)<(x176)))+((uintptr_t)((x191)<(x173))))+(x174); + x193 = (x192)+(x171); + x194 = (((uintptr_t)((x192)<(x174)))+((uintptr_t)((x193)<(x171))))+(x172); + x195 = (x194)+(x169); + x196 = ((uintptr_t)((x194)<(x172)))+((uintptr_t)((x195)<(x169))); + x197 = (x153)+((x9)*((uintptr_t)3195661986ULL)); + x198 = ((uintptr_t)((x197)<(x153)))+(x155); + x199 = (x198)+(x183); + x200 = (((uintptr_t)((x198)<(x155)))+((uintptr_t)((x199)<(x183))))+(x157); + x201 = (x200)+(x185); + x202 = (((uintptr_t)((x200)<(x157)))+((uintptr_t)((x201)<(x185))))+(x159); + x203 = (x202)+(x187); + x204 = (((uintptr_t)((x202)<(x159)))+((uintptr_t)((x203)<(x187))))+(x161); + x205 = (x204)+(x189); + x206 = (((uintptr_t)((x204)<(x161)))+((uintptr_t)((x205)<(x189))))+(x163); + x207 = (x206)+(x191); + x208 = (((uintptr_t)((x206)<(x163)))+((uintptr_t)((x207)<(x191))))+(x165); + x209 = (x208)+(x193); + x210 = (((uintptr_t)((x208)<(x165)))+((uintptr_t)((x209)<(x193))))+(x167); + x211 = (x210)+(x195); + x212 = ((uintptr_t)((x210)<(x167)))+((uintptr_t)((x211)<(x195))); + x213 = (x197)*((uintptr_t)3993025615ULL); + x214 = (x213)*((uintptr_t)4294967295ULL); + x215 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x213)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x213)*((uintptr_t)4294967295ULL))>>64); + x216 = (x213)*((uintptr_t)4294967295ULL); + x217 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x213)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x213)*((uintptr_t)4294967295ULL))>>64); + x218 = (x213)*((uintptr_t)4294967295ULL); + x219 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x213)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x213)*((uintptr_t)4294967295ULL))>>64); + x220 = (x213)*((uintptr_t)3169254061ULL); + x221 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x213)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x213)*((uintptr_t)3169254061ULL))>>64); + x222 = (x213)*((uintptr_t)2803342980ULL); + x223 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x213)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x213)*((uintptr_t)2803342980ULL))>>64); + x224 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x213)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x213)*((uintptr_t)4089039554ULL))>>64); + x225 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x213)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x213)*((uintptr_t)4234356049ULL))>>64); + x226 = (x225)+((x213)*((uintptr_t)4089039554ULL)); + x227 = ((uintptr_t)((x226)<(x225)))+(x224); + x228 = (x227)+(x222); + x229 = (((uintptr_t)((x227)<(x224)))+((uintptr_t)((x228)<(x222))))+(x223); + x230 = (x229)+(x220); + x231 = (((uintptr_t)((x229)<(x223)))+((uintptr_t)((x230)<(x220))))+(x221); + x232 = (x231)+(x218); + x233 = (((uintptr_t)((x231)<(x221)))+((uintptr_t)((x232)<(x218))))+(x219); + x234 = (x233)+(x216); + x235 = ((uintptr_t)((x233)<(x219)))+((uintptr_t)((x234)<(x216))); + x236 = ((uintptr_t)(((x197)+((x213)*((uintptr_t)4234356049ULL)))<(x197)))+(x199); + x237 = (x236)+(x226); + x238 = (((uintptr_t)((x236)<(x199)))+((uintptr_t)((x237)<(x226))))+(x201); + x239 = (x238)+(x228); + x240 = (((uintptr_t)((x238)<(x201)))+((uintptr_t)((x239)<(x228))))+(x203); + x241 = (x240)+(x230); + x242 = (((uintptr_t)((x240)<(x203)))+((uintptr_t)((x241)<(x230))))+(x205); + x243 = (x242)+(x232); + x244 = (((uintptr_t)((x242)<(x205)))+((uintptr_t)((x243)<(x232))))+(x207); + x245 = (x244)+(x234); + x246 = (((uintptr_t)((x244)<(x207)))+((uintptr_t)((x245)<(x234))))+(x209); + x247 = (x246)+((x235)+(x217)); + x248 = (((uintptr_t)((x246)<(x209)))+((uintptr_t)((x247)<((x235)+(x217)))))+(x211); + x249 = (x248)+(x214); + x250 = (((uintptr_t)((x248)<(x211)))+((uintptr_t)((x249)<(x214))))+(((x212)+(x168))+((x196)+(x170))); + x251 = (x250)+(x215); + x252 = ((uintptr_t)((x250)<(((x212)+(x168))+((x196)+(x170)))))+((uintptr_t)((x251)<(x215))); + x253 = (x10)*((uintptr_t)1726033300ULL); + x254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)1726033300ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)1726033300ULL))>>64); + x255 = (x10)*((uintptr_t)4091106848ULL); + x256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)4091106848ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)4091106848ULL))>>64); + x257 = (x10)*((uintptr_t)675656249ULL); + x258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)675656249ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)675656249ULL))>>64); + x259 = (x10)*((uintptr_t)728493145ULL); + x260 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)728493145ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)728493145ULL))>>64); + x261 = (x10)*((uintptr_t)1184463260ULL); + x262 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)1184463260ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)1184463260ULL))>>64); + x263 = (x10)*((uintptr_t)1237151654ULL); + x264 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)1237151654ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)1237151654ULL))>>64); + x265 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)2200194197ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)2200194197ULL))>>64); + x266 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)3195661986ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)3195661986ULL))>>64); + x267 = (x266)+((x10)*((uintptr_t)2200194197ULL)); + x268 = ((uintptr_t)((x267)<(x266)))+(x265); + x269 = (x268)+(x263); + x270 = (((uintptr_t)((x268)<(x265)))+((uintptr_t)((x269)<(x263))))+(x264); + x271 = (x270)+(x261); + x272 = (((uintptr_t)((x270)<(x264)))+((uintptr_t)((x271)<(x261))))+(x262); + x273 = (x272)+(x259); + x274 = (((uintptr_t)((x272)<(x262)))+((uintptr_t)((x273)<(x259))))+(x260); + x275 = (x274)+(x257); + x276 = (((uintptr_t)((x274)<(x260)))+((uintptr_t)((x275)<(x257))))+(x258); + x277 = (x276)+(x255); + x278 = (((uintptr_t)((x276)<(x258)))+((uintptr_t)((x277)<(x255))))+(x256); + x279 = (x278)+(x253); + x280 = ((uintptr_t)((x278)<(x256)))+((uintptr_t)((x279)<(x253))); + x281 = (x237)+((x10)*((uintptr_t)3195661986ULL)); + x282 = ((uintptr_t)((x281)<(x237)))+(x239); + x283 = (x282)+(x267); + x284 = (((uintptr_t)((x282)<(x239)))+((uintptr_t)((x283)<(x267))))+(x241); + x285 = (x284)+(x269); + x286 = (((uintptr_t)((x284)<(x241)))+((uintptr_t)((x285)<(x269))))+(x243); + x287 = (x286)+(x271); + x288 = (((uintptr_t)((x286)<(x243)))+((uintptr_t)((x287)<(x271))))+(x245); + x289 = (x288)+(x273); + x290 = (((uintptr_t)((x288)<(x245)))+((uintptr_t)((x289)<(x273))))+(x247); + x291 = (x290)+(x275); + x292 = (((uintptr_t)((x290)<(x247)))+((uintptr_t)((x291)<(x275))))+(x249); + x293 = (x292)+(x277); + x294 = (((uintptr_t)((x292)<(x249)))+((uintptr_t)((x293)<(x277))))+(x251); + x295 = (x294)+(x279); + x296 = ((uintptr_t)((x294)<(x251)))+((uintptr_t)((x295)<(x279))); + x297 = (x281)*((uintptr_t)3993025615ULL); + x298 = (x297)*((uintptr_t)4294967295ULL); + x299 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)4294967295ULL))>>64); + x300 = (x297)*((uintptr_t)4294967295ULL); + x301 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)4294967295ULL))>>64); + x302 = (x297)*((uintptr_t)4294967295ULL); + x303 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)4294967295ULL))>>64); + x304 = (x297)*((uintptr_t)3169254061ULL); + x305 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)3169254061ULL))>>64); + x306 = (x297)*((uintptr_t)2803342980ULL); + x307 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)2803342980ULL))>>64); + x308 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)4089039554ULL))>>64); + x309 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)4234356049ULL))>>64); + x310 = (x309)+((x297)*((uintptr_t)4089039554ULL)); + x311 = ((uintptr_t)((x310)<(x309)))+(x308); + x312 = (x311)+(x306); + x313 = (((uintptr_t)((x311)<(x308)))+((uintptr_t)((x312)<(x306))))+(x307); + x314 = (x313)+(x304); + x315 = (((uintptr_t)((x313)<(x307)))+((uintptr_t)((x314)<(x304))))+(x305); + x316 = (x315)+(x302); + x317 = (((uintptr_t)((x315)<(x305)))+((uintptr_t)((x316)<(x302))))+(x303); + x318 = (x317)+(x300); + x319 = ((uintptr_t)((x317)<(x303)))+((uintptr_t)((x318)<(x300))); + x320 = ((uintptr_t)(((x281)+((x297)*((uintptr_t)4234356049ULL)))<(x281)))+(x283); + x321 = (x320)+(x310); + x322 = (((uintptr_t)((x320)<(x283)))+((uintptr_t)((x321)<(x310))))+(x285); + x323 = (x322)+(x312); + x324 = (((uintptr_t)((x322)<(x285)))+((uintptr_t)((x323)<(x312))))+(x287); + x325 = (x324)+(x314); + x326 = (((uintptr_t)((x324)<(x287)))+((uintptr_t)((x325)<(x314))))+(x289); + x327 = (x326)+(x316); + x328 = (((uintptr_t)((x326)<(x289)))+((uintptr_t)((x327)<(x316))))+(x291); + x329 = (x328)+(x318); + x330 = (((uintptr_t)((x328)<(x291)))+((uintptr_t)((x329)<(x318))))+(x293); + x331 = (x330)+((x319)+(x301)); + x332 = (((uintptr_t)((x330)<(x293)))+((uintptr_t)((x331)<((x319)+(x301)))))+(x295); + x333 = (x332)+(x298); + x334 = (((uintptr_t)((x332)<(x295)))+((uintptr_t)((x333)<(x298))))+(((x296)+(x252))+((x280)+(x254))); + x335 = (x334)+(x299); + x336 = ((uintptr_t)((x334)<(((x296)+(x252))+((x280)+(x254)))))+((uintptr_t)((x335)<(x299))); + x337 = (x11)*((uintptr_t)1726033300ULL); + x338 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)1726033300ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)1726033300ULL))>>64); + x339 = (x11)*((uintptr_t)4091106848ULL); + x340 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)4091106848ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)4091106848ULL))>>64); + x341 = (x11)*((uintptr_t)675656249ULL); + x342 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)675656249ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)675656249ULL))>>64); + x343 = (x11)*((uintptr_t)728493145ULL); + x344 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)728493145ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)728493145ULL))>>64); + x345 = (x11)*((uintptr_t)1184463260ULL); + x346 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)1184463260ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)1184463260ULL))>>64); + x347 = (x11)*((uintptr_t)1237151654ULL); + x348 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)1237151654ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)1237151654ULL))>>64); + x349 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)2200194197ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)2200194197ULL))>>64); + x350 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)3195661986ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)3195661986ULL))>>64); + x351 = (x350)+((x11)*((uintptr_t)2200194197ULL)); + x352 = ((uintptr_t)((x351)<(x350)))+(x349); + x353 = (x352)+(x347); + x354 = (((uintptr_t)((x352)<(x349)))+((uintptr_t)((x353)<(x347))))+(x348); + x355 = (x354)+(x345); + x356 = (((uintptr_t)((x354)<(x348)))+((uintptr_t)((x355)<(x345))))+(x346); + x357 = (x356)+(x343); + x358 = (((uintptr_t)((x356)<(x346)))+((uintptr_t)((x357)<(x343))))+(x344); + x359 = (x358)+(x341); + x360 = (((uintptr_t)((x358)<(x344)))+((uintptr_t)((x359)<(x341))))+(x342); + x361 = (x360)+(x339); + x362 = (((uintptr_t)((x360)<(x342)))+((uintptr_t)((x361)<(x339))))+(x340); + x363 = (x362)+(x337); + x364 = ((uintptr_t)((x362)<(x340)))+((uintptr_t)((x363)<(x337))); + x365 = (x321)+((x11)*((uintptr_t)3195661986ULL)); + x366 = ((uintptr_t)((x365)<(x321)))+(x323); + x367 = (x366)+(x351); + x368 = (((uintptr_t)((x366)<(x323)))+((uintptr_t)((x367)<(x351))))+(x325); + x369 = (x368)+(x353); + x370 = (((uintptr_t)((x368)<(x325)))+((uintptr_t)((x369)<(x353))))+(x327); + x371 = (x370)+(x355); + x372 = (((uintptr_t)((x370)<(x327)))+((uintptr_t)((x371)<(x355))))+(x329); + x373 = (x372)+(x357); + x374 = (((uintptr_t)((x372)<(x329)))+((uintptr_t)((x373)<(x357))))+(x331); + x375 = (x374)+(x359); + x376 = (((uintptr_t)((x374)<(x331)))+((uintptr_t)((x375)<(x359))))+(x333); + x377 = (x376)+(x361); + x378 = (((uintptr_t)((x376)<(x333)))+((uintptr_t)((x377)<(x361))))+(x335); + x379 = (x378)+(x363); + x380 = ((uintptr_t)((x378)<(x335)))+((uintptr_t)((x379)<(x363))); + x381 = (x365)*((uintptr_t)3993025615ULL); + x382 = (x381)*((uintptr_t)4294967295ULL); + x383 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x381)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x381)*((uintptr_t)4294967295ULL))>>64); + x384 = (x381)*((uintptr_t)4294967295ULL); + x385 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x381)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x381)*((uintptr_t)4294967295ULL))>>64); + x386 = (x381)*((uintptr_t)4294967295ULL); + x387 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x381)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x381)*((uintptr_t)4294967295ULL))>>64); + x388 = (x381)*((uintptr_t)3169254061ULL); + x389 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x381)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x381)*((uintptr_t)3169254061ULL))>>64); + x390 = (x381)*((uintptr_t)2803342980ULL); + x391 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x381)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x381)*((uintptr_t)2803342980ULL))>>64); + x392 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x381)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x381)*((uintptr_t)4089039554ULL))>>64); + x393 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x381)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x381)*((uintptr_t)4234356049ULL))>>64); + x394 = (x393)+((x381)*((uintptr_t)4089039554ULL)); + x395 = ((uintptr_t)((x394)<(x393)))+(x392); + x396 = (x395)+(x390); + x397 = (((uintptr_t)((x395)<(x392)))+((uintptr_t)((x396)<(x390))))+(x391); + x398 = (x397)+(x388); + x399 = (((uintptr_t)((x397)<(x391)))+((uintptr_t)((x398)<(x388))))+(x389); + x400 = (x399)+(x386); + x401 = (((uintptr_t)((x399)<(x389)))+((uintptr_t)((x400)<(x386))))+(x387); + x402 = (x401)+(x384); + x403 = ((uintptr_t)((x401)<(x387)))+((uintptr_t)((x402)<(x384))); + x404 = ((uintptr_t)(((x365)+((x381)*((uintptr_t)4234356049ULL)))<(x365)))+(x367); + x405 = (x404)+(x394); + x406 = (((uintptr_t)((x404)<(x367)))+((uintptr_t)((x405)<(x394))))+(x369); + x407 = (x406)+(x396); + x408 = (((uintptr_t)((x406)<(x369)))+((uintptr_t)((x407)<(x396))))+(x371); + x409 = (x408)+(x398); + x410 = (((uintptr_t)((x408)<(x371)))+((uintptr_t)((x409)<(x398))))+(x373); + x411 = (x410)+(x400); + x412 = (((uintptr_t)((x410)<(x373)))+((uintptr_t)((x411)<(x400))))+(x375); + x413 = (x412)+(x402); + x414 = (((uintptr_t)((x412)<(x375)))+((uintptr_t)((x413)<(x402))))+(x377); + x415 = (x414)+((x403)+(x385)); + x416 = (((uintptr_t)((x414)<(x377)))+((uintptr_t)((x415)<((x403)+(x385)))))+(x379); + x417 = (x416)+(x382); + x418 = (((uintptr_t)((x416)<(x379)))+((uintptr_t)((x417)<(x382))))+(((x380)+(x336))+((x364)+(x338))); + x419 = (x418)+(x383); + x420 = ((uintptr_t)((x418)<(((x380)+(x336))+((x364)+(x338)))))+((uintptr_t)((x419)<(x383))); + x421 = (x12)*((uintptr_t)1726033300ULL); + x422 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)1726033300ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)1726033300ULL))>>64); + x423 = (x12)*((uintptr_t)4091106848ULL); + x424 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4091106848ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4091106848ULL))>>64); + x425 = (x12)*((uintptr_t)675656249ULL); + x426 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)675656249ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)675656249ULL))>>64); + x427 = (x12)*((uintptr_t)728493145ULL); + x428 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)728493145ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)728493145ULL))>>64); + x429 = (x12)*((uintptr_t)1184463260ULL); + x430 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)1184463260ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)1184463260ULL))>>64); + x431 = (x12)*((uintptr_t)1237151654ULL); + x432 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)1237151654ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)1237151654ULL))>>64); + x433 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)2200194197ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)2200194197ULL))>>64); + x434 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)3195661986ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)3195661986ULL))>>64); + x435 = (x434)+((x12)*((uintptr_t)2200194197ULL)); + x436 = ((uintptr_t)((x435)<(x434)))+(x433); + x437 = (x436)+(x431); + x438 = (((uintptr_t)((x436)<(x433)))+((uintptr_t)((x437)<(x431))))+(x432); + x439 = (x438)+(x429); + x440 = (((uintptr_t)((x438)<(x432)))+((uintptr_t)((x439)<(x429))))+(x430); + x441 = (x440)+(x427); + x442 = (((uintptr_t)((x440)<(x430)))+((uintptr_t)((x441)<(x427))))+(x428); + x443 = (x442)+(x425); + x444 = (((uintptr_t)((x442)<(x428)))+((uintptr_t)((x443)<(x425))))+(x426); + x445 = (x444)+(x423); + x446 = (((uintptr_t)((x444)<(x426)))+((uintptr_t)((x445)<(x423))))+(x424); + x447 = (x446)+(x421); + x448 = ((uintptr_t)((x446)<(x424)))+((uintptr_t)((x447)<(x421))); + x449 = (x405)+((x12)*((uintptr_t)3195661986ULL)); + x450 = ((uintptr_t)((x449)<(x405)))+(x407); + x451 = (x450)+(x435); + x452 = (((uintptr_t)((x450)<(x407)))+((uintptr_t)((x451)<(x435))))+(x409); + x453 = (x452)+(x437); + x454 = (((uintptr_t)((x452)<(x409)))+((uintptr_t)((x453)<(x437))))+(x411); + x455 = (x454)+(x439); + x456 = (((uintptr_t)((x454)<(x411)))+((uintptr_t)((x455)<(x439))))+(x413); + x457 = (x456)+(x441); + x458 = (((uintptr_t)((x456)<(x413)))+((uintptr_t)((x457)<(x441))))+(x415); + x459 = (x458)+(x443); + x460 = (((uintptr_t)((x458)<(x415)))+((uintptr_t)((x459)<(x443))))+(x417); + x461 = (x460)+(x445); + x462 = (((uintptr_t)((x460)<(x417)))+((uintptr_t)((x461)<(x445))))+(x419); + x463 = (x462)+(x447); + x464 = ((uintptr_t)((x462)<(x419)))+((uintptr_t)((x463)<(x447))); + x465 = (x449)*((uintptr_t)3993025615ULL); + x466 = (x465)*((uintptr_t)4294967295ULL); + x467 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x465)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x465)*((uintptr_t)4294967295ULL))>>64); + x468 = (x465)*((uintptr_t)4294967295ULL); + x469 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x465)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x465)*((uintptr_t)4294967295ULL))>>64); + x470 = (x465)*((uintptr_t)4294967295ULL); + x471 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x465)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x465)*((uintptr_t)4294967295ULL))>>64); + x472 = (x465)*((uintptr_t)3169254061ULL); + x473 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x465)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x465)*((uintptr_t)3169254061ULL))>>64); + x474 = (x465)*((uintptr_t)2803342980ULL); + x475 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x465)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x465)*((uintptr_t)2803342980ULL))>>64); + x476 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x465)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x465)*((uintptr_t)4089039554ULL))>>64); + x477 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x465)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x465)*((uintptr_t)4234356049ULL))>>64); + x478 = (x477)+((x465)*((uintptr_t)4089039554ULL)); + x479 = ((uintptr_t)((x478)<(x477)))+(x476); + x480 = (x479)+(x474); + x481 = (((uintptr_t)((x479)<(x476)))+((uintptr_t)((x480)<(x474))))+(x475); + x482 = (x481)+(x472); + x483 = (((uintptr_t)((x481)<(x475)))+((uintptr_t)((x482)<(x472))))+(x473); + x484 = (x483)+(x470); + x485 = (((uintptr_t)((x483)<(x473)))+((uintptr_t)((x484)<(x470))))+(x471); + x486 = (x485)+(x468); + x487 = ((uintptr_t)((x485)<(x471)))+((uintptr_t)((x486)<(x468))); + x488 = ((uintptr_t)(((x449)+((x465)*((uintptr_t)4234356049ULL)))<(x449)))+(x451); + x489 = (x488)+(x478); + x490 = (((uintptr_t)((x488)<(x451)))+((uintptr_t)((x489)<(x478))))+(x453); + x491 = (x490)+(x480); + x492 = (((uintptr_t)((x490)<(x453)))+((uintptr_t)((x491)<(x480))))+(x455); + x493 = (x492)+(x482); + x494 = (((uintptr_t)((x492)<(x455)))+((uintptr_t)((x493)<(x482))))+(x457); + x495 = (x494)+(x484); + x496 = (((uintptr_t)((x494)<(x457)))+((uintptr_t)((x495)<(x484))))+(x459); + x497 = (x496)+(x486); + x498 = (((uintptr_t)((x496)<(x459)))+((uintptr_t)((x497)<(x486))))+(x461); + x499 = (x498)+((x487)+(x469)); + x500 = (((uintptr_t)((x498)<(x461)))+((uintptr_t)((x499)<((x487)+(x469)))))+(x463); + x501 = (x500)+(x466); + x502 = (((uintptr_t)((x500)<(x463)))+((uintptr_t)((x501)<(x466))))+(((x464)+(x420))+((x448)+(x422))); + x503 = (x502)+(x467); + x504 = ((uintptr_t)((x502)<(((x464)+(x420))+((x448)+(x422)))))+((uintptr_t)((x503)<(x467))); + x505 = (x13)*((uintptr_t)1726033300ULL); + x506 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)1726033300ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)1726033300ULL))>>64); + x507 = (x13)*((uintptr_t)4091106848ULL); + x508 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)4091106848ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)4091106848ULL))>>64); + x509 = (x13)*((uintptr_t)675656249ULL); + x510 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)675656249ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)675656249ULL))>>64); + x511 = (x13)*((uintptr_t)728493145ULL); + x512 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)728493145ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)728493145ULL))>>64); + x513 = (x13)*((uintptr_t)1184463260ULL); + x514 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)1184463260ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)1184463260ULL))>>64); + x515 = (x13)*((uintptr_t)1237151654ULL); + x516 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)1237151654ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)1237151654ULL))>>64); + x517 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)2200194197ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)2200194197ULL))>>64); + x518 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)3195661986ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)3195661986ULL))>>64); + x519 = (x518)+((x13)*((uintptr_t)2200194197ULL)); + x520 = ((uintptr_t)((x519)<(x518)))+(x517); + x521 = (x520)+(x515); + x522 = (((uintptr_t)((x520)<(x517)))+((uintptr_t)((x521)<(x515))))+(x516); + x523 = (x522)+(x513); + x524 = (((uintptr_t)((x522)<(x516)))+((uintptr_t)((x523)<(x513))))+(x514); + x525 = (x524)+(x511); + x526 = (((uintptr_t)((x524)<(x514)))+((uintptr_t)((x525)<(x511))))+(x512); + x527 = (x526)+(x509); + x528 = (((uintptr_t)((x526)<(x512)))+((uintptr_t)((x527)<(x509))))+(x510); + x529 = (x528)+(x507); + x530 = (((uintptr_t)((x528)<(x510)))+((uintptr_t)((x529)<(x507))))+(x508); + x531 = (x530)+(x505); + x532 = ((uintptr_t)((x530)<(x508)))+((uintptr_t)((x531)<(x505))); + x533 = (x489)+((x13)*((uintptr_t)3195661986ULL)); + x534 = ((uintptr_t)((x533)<(x489)))+(x491); + x535 = (x534)+(x519); + x536 = (((uintptr_t)((x534)<(x491)))+((uintptr_t)((x535)<(x519))))+(x493); + x537 = (x536)+(x521); + x538 = (((uintptr_t)((x536)<(x493)))+((uintptr_t)((x537)<(x521))))+(x495); + x539 = (x538)+(x523); + x540 = (((uintptr_t)((x538)<(x495)))+((uintptr_t)((x539)<(x523))))+(x497); + x541 = (x540)+(x525); + x542 = (((uintptr_t)((x540)<(x497)))+((uintptr_t)((x541)<(x525))))+(x499); + x543 = (x542)+(x527); + x544 = (((uintptr_t)((x542)<(x499)))+((uintptr_t)((x543)<(x527))))+(x501); + x545 = (x544)+(x529); + x546 = (((uintptr_t)((x544)<(x501)))+((uintptr_t)((x545)<(x529))))+(x503); + x547 = (x546)+(x531); + x548 = ((uintptr_t)((x546)<(x503)))+((uintptr_t)((x547)<(x531))); + x549 = (x533)*((uintptr_t)3993025615ULL); + x550 = (x549)*((uintptr_t)4294967295ULL); + x551 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x549)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x549)*((uintptr_t)4294967295ULL))>>64); + x552 = (x549)*((uintptr_t)4294967295ULL); + x553 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x549)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x549)*((uintptr_t)4294967295ULL))>>64); + x554 = (x549)*((uintptr_t)4294967295ULL); + x555 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x549)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x549)*((uintptr_t)4294967295ULL))>>64); + x556 = (x549)*((uintptr_t)3169254061ULL); + x557 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x549)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x549)*((uintptr_t)3169254061ULL))>>64); + x558 = (x549)*((uintptr_t)2803342980ULL); + x559 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x549)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x549)*((uintptr_t)2803342980ULL))>>64); + x560 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x549)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x549)*((uintptr_t)4089039554ULL))>>64); + x561 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x549)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x549)*((uintptr_t)4234356049ULL))>>64); + x562 = (x561)+((x549)*((uintptr_t)4089039554ULL)); + x563 = ((uintptr_t)((x562)<(x561)))+(x560); + x564 = (x563)+(x558); + x565 = (((uintptr_t)((x563)<(x560)))+((uintptr_t)((x564)<(x558))))+(x559); + x566 = (x565)+(x556); + x567 = (((uintptr_t)((x565)<(x559)))+((uintptr_t)((x566)<(x556))))+(x557); + x568 = (x567)+(x554); + x569 = (((uintptr_t)((x567)<(x557)))+((uintptr_t)((x568)<(x554))))+(x555); + x570 = (x569)+(x552); + x571 = ((uintptr_t)((x569)<(x555)))+((uintptr_t)((x570)<(x552))); + x572 = ((uintptr_t)(((x533)+((x549)*((uintptr_t)4234356049ULL)))<(x533)))+(x535); + x573 = (x572)+(x562); + x574 = (((uintptr_t)((x572)<(x535)))+((uintptr_t)((x573)<(x562))))+(x537); + x575 = (x574)+(x564); + x576 = (((uintptr_t)((x574)<(x537)))+((uintptr_t)((x575)<(x564))))+(x539); + x577 = (x576)+(x566); + x578 = (((uintptr_t)((x576)<(x539)))+((uintptr_t)((x577)<(x566))))+(x541); + x579 = (x578)+(x568); + x580 = (((uintptr_t)((x578)<(x541)))+((uintptr_t)((x579)<(x568))))+(x543); + x581 = (x580)+(x570); + x582 = (((uintptr_t)((x580)<(x543)))+((uintptr_t)((x581)<(x570))))+(x545); + x583 = (x582)+((x571)+(x553)); + x584 = (((uintptr_t)((x582)<(x545)))+((uintptr_t)((x583)<((x571)+(x553)))))+(x547); + x585 = (x584)+(x550); + x586 = (((uintptr_t)((x584)<(x547)))+((uintptr_t)((x585)<(x550))))+(((x548)+(x504))+((x532)+(x506))); + x587 = (x586)+(x551); + x588 = ((uintptr_t)((x586)<(((x548)+(x504))+((x532)+(x506)))))+((uintptr_t)((x587)<(x551))); + x589 = (x14)*((uintptr_t)1726033300ULL); + x590 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)1726033300ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)1726033300ULL))>>64); + x591 = (x14)*((uintptr_t)4091106848ULL); + x592 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)4091106848ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)4091106848ULL))>>64); + x593 = (x14)*((uintptr_t)675656249ULL); + x594 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)675656249ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)675656249ULL))>>64); + x595 = (x14)*((uintptr_t)728493145ULL); + x596 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)728493145ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)728493145ULL))>>64); + x597 = (x14)*((uintptr_t)1184463260ULL); + x598 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)1184463260ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)1184463260ULL))>>64); + x599 = (x14)*((uintptr_t)1237151654ULL); + x600 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)1237151654ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)1237151654ULL))>>64); + x601 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)2200194197ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)2200194197ULL))>>64); + x602 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)3195661986ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)3195661986ULL))>>64); + x603 = (x602)+((x14)*((uintptr_t)2200194197ULL)); + x604 = ((uintptr_t)((x603)<(x602)))+(x601); + x605 = (x604)+(x599); + x606 = (((uintptr_t)((x604)<(x601)))+((uintptr_t)((x605)<(x599))))+(x600); + x607 = (x606)+(x597); + x608 = (((uintptr_t)((x606)<(x600)))+((uintptr_t)((x607)<(x597))))+(x598); + x609 = (x608)+(x595); + x610 = (((uintptr_t)((x608)<(x598)))+((uintptr_t)((x609)<(x595))))+(x596); + x611 = (x610)+(x593); + x612 = (((uintptr_t)((x610)<(x596)))+((uintptr_t)((x611)<(x593))))+(x594); + x613 = (x612)+(x591); + x614 = (((uintptr_t)((x612)<(x594)))+((uintptr_t)((x613)<(x591))))+(x592); + x615 = (x614)+(x589); + x616 = ((uintptr_t)((x614)<(x592)))+((uintptr_t)((x615)<(x589))); + x617 = (x573)+((x14)*((uintptr_t)3195661986ULL)); + x618 = ((uintptr_t)((x617)<(x573)))+(x575); + x619 = (x618)+(x603); + x620 = (((uintptr_t)((x618)<(x575)))+((uintptr_t)((x619)<(x603))))+(x577); + x621 = (x620)+(x605); + x622 = (((uintptr_t)((x620)<(x577)))+((uintptr_t)((x621)<(x605))))+(x579); + x623 = (x622)+(x607); + x624 = (((uintptr_t)((x622)<(x579)))+((uintptr_t)((x623)<(x607))))+(x581); + x625 = (x624)+(x609); + x626 = (((uintptr_t)((x624)<(x581)))+((uintptr_t)((x625)<(x609))))+(x583); + x627 = (x626)+(x611); + x628 = (((uintptr_t)((x626)<(x583)))+((uintptr_t)((x627)<(x611))))+(x585); + x629 = (x628)+(x613); + x630 = (((uintptr_t)((x628)<(x585)))+((uintptr_t)((x629)<(x613))))+(x587); + x631 = (x630)+(x615); + x632 = ((uintptr_t)((x630)<(x587)))+((uintptr_t)((x631)<(x615))); + x633 = (x617)*((uintptr_t)3993025615ULL); + x634 = (x633)*((uintptr_t)4294967295ULL); + x635 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x633)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x633)*((uintptr_t)4294967295ULL))>>64); + x636 = (x633)*((uintptr_t)4294967295ULL); + x637 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x633)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x633)*((uintptr_t)4294967295ULL))>>64); + x638 = (x633)*((uintptr_t)4294967295ULL); + x639 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x633)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x633)*((uintptr_t)4294967295ULL))>>64); + x640 = (x633)*((uintptr_t)3169254061ULL); + x641 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x633)*((uintptr_t)3169254061ULL))>>32 : ((__uint128_t)(x633)*((uintptr_t)3169254061ULL))>>64); + x642 = (x633)*((uintptr_t)2803342980ULL); + x643 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x633)*((uintptr_t)2803342980ULL))>>32 : ((__uint128_t)(x633)*((uintptr_t)2803342980ULL))>>64); + x644 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x633)*((uintptr_t)4089039554ULL))>>32 : ((__uint128_t)(x633)*((uintptr_t)4089039554ULL))>>64); + x645 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x633)*((uintptr_t)4234356049ULL))>>32 : ((__uint128_t)(x633)*((uintptr_t)4234356049ULL))>>64); + x646 = (x645)+((x633)*((uintptr_t)4089039554ULL)); + x647 = ((uintptr_t)((x646)<(x645)))+(x644); + x648 = (x647)+(x642); + x649 = (((uintptr_t)((x647)<(x644)))+((uintptr_t)((x648)<(x642))))+(x643); + x650 = (x649)+(x640); + x651 = (((uintptr_t)((x649)<(x643)))+((uintptr_t)((x650)<(x640))))+(x641); + x652 = (x651)+(x638); + x653 = (((uintptr_t)((x651)<(x641)))+((uintptr_t)((x652)<(x638))))+(x639); + x654 = (x653)+(x636); + x655 = ((uintptr_t)((x653)<(x639)))+((uintptr_t)((x654)<(x636))); + x656 = ((uintptr_t)(((x617)+((x633)*((uintptr_t)4234356049ULL)))<(x617)))+(x619); + x657 = (x656)+(x646); + x658 = (((uintptr_t)((x656)<(x619)))+((uintptr_t)((x657)<(x646))))+(x621); + x659 = (x658)+(x648); + x660 = (((uintptr_t)((x658)<(x621)))+((uintptr_t)((x659)<(x648))))+(x623); + x661 = (x660)+(x650); + x662 = (((uintptr_t)((x660)<(x623)))+((uintptr_t)((x661)<(x650))))+(x625); + x663 = (x662)+(x652); + x664 = (((uintptr_t)((x662)<(x625)))+((uintptr_t)((x663)<(x652))))+(x627); + x665 = (x664)+(x654); + x666 = (((uintptr_t)((x664)<(x627)))+((uintptr_t)((x665)<(x654))))+(x629); + x667 = (x666)+((x655)+(x637)); + x668 = (((uintptr_t)((x666)<(x629)))+((uintptr_t)((x667)<((x655)+(x637)))))+(x631); + x669 = (x668)+(x634); + x670 = (((uintptr_t)((x668)<(x631)))+((uintptr_t)((x669)<(x634))))+(((x632)+(x588))+((x616)+(x590))); + x671 = (x670)+(x635); + x672 = ((uintptr_t)((x670)<(((x632)+(x588))+((x616)+(x590)))))+((uintptr_t)((x671)<(x635))); + x673 = (x657)-((uintptr_t)4234356049ULL); + x674 = (x659)-((uintptr_t)4089039554ULL); + x675 = (x674)-((uintptr_t)((x657)<(x673))); + x676 = (x661)-((uintptr_t)2803342980ULL); + x677 = (x676)-(((uintptr_t)((x659)<(x674)))+((uintptr_t)((x674)<(x675)))); + x678 = (x663)-((uintptr_t)3169254061ULL); + x679 = (x678)-(((uintptr_t)((x661)<(x676)))+((uintptr_t)((x676)<(x677)))); + x680 = (x665)-((uintptr_t)4294967295ULL); + x681 = (x680)-(((uintptr_t)((x663)<(x678)))+((uintptr_t)((x678)<(x679)))); + x682 = (x667)-((uintptr_t)4294967295ULL); + x683 = (x682)-(((uintptr_t)((x665)<(x680)))+((uintptr_t)((x680)<(x681)))); + x684 = (x669)-(((uintptr_t)((x667)<(x682)))+((uintptr_t)((x682)<(x683)))); + x685 = (x671)-((uintptr_t)4294967295ULL); + x686 = (x685)-((uintptr_t)((x669)<(x684))); + x687 = (uintptr_t)((x672)<((x672)-(((uintptr_t)((x671)<(x685)))+((uintptr_t)((x685)<(x686)))))); + x688 = ((uintptr_t)-1ULL)+((uintptr_t)((x687)==((uintptr_t)0ULL))); + x689 = (x688)^((uintptr_t)4294967295ULL); + x690 = ((x657)&(x688))|((x673)&(x689)); + x691 = ((uintptr_t)-1ULL)+((uintptr_t)((x687)==((uintptr_t)0ULL))); + x692 = (x691)^((uintptr_t)4294967295ULL); + x693 = ((x659)&(x691))|((x675)&(x692)); + x694 = ((uintptr_t)-1ULL)+((uintptr_t)((x687)==((uintptr_t)0ULL))); + x695 = (x694)^((uintptr_t)4294967295ULL); + x696 = ((x661)&(x694))|((x677)&(x695)); + x697 = ((uintptr_t)-1ULL)+((uintptr_t)((x687)==((uintptr_t)0ULL))); + x698 = (x697)^((uintptr_t)4294967295ULL); + x699 = ((x663)&(x697))|((x679)&(x698)); + x700 = ((uintptr_t)-1ULL)+((uintptr_t)((x687)==((uintptr_t)0ULL))); + x701 = (x700)^((uintptr_t)4294967295ULL); + x702 = ((x665)&(x700))|((x681)&(x701)); + x703 = ((uintptr_t)-1ULL)+((uintptr_t)((x687)==((uintptr_t)0ULL))); + x704 = (x703)^((uintptr_t)4294967295ULL); + x705 = ((x667)&(x703))|((x683)&(x704)); + x706 = ((uintptr_t)-1ULL)+((uintptr_t)((x687)==((uintptr_t)0ULL))); + x707 = (x706)^((uintptr_t)4294967295ULL); + x708 = ((x669)&(x706))|((x684)&(x707)); + x709 = ((uintptr_t)-1ULL)+((uintptr_t)((x687)==((uintptr_t)0ULL))); + x710 = (x709)^((uintptr_t)4294967295ULL); + x711 = ((x671)&(x709))|((x686)&(x710)); + x712 = x690; + x713 = x693; + x714 = x696; + x715 = x699; + x716 = x702; + x717 = x705; + x718 = x708; + x719 = x711; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x712, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x713, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x714, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x715, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x716, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x717, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x718, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x719, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_to_montgomery(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_p256_scalar_to_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffff] + */ +static +uintptr_t internal_fiat_p256_scalar_nonzero(uintptr_t in0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8, out0, x9; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = (x0)|((x1)|((x2)|((x3)|((x4)|((x5)|((x6)|(x7))))))); + x9 = x8; + out0 = x9; + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_nonzero(uint32_t* out1, const uint32_t arg1[8]) { + *out1 = (uint32_t)internal_fiat_p256_scalar_nonzero((uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0x1] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p256_scalar_selectznz(uintptr_t out0, uintptr_t in0, uintptr_t in1, uintptr_t in2) { + uintptr_t x8, x16, x0, x17, x9, x19, x1, x20, x10, x22, x2, x23, x11, x25, x3, x26, x12, x28, x4, x29, x13, x31, x5, x32, x14, x34, x6, x35, x15, x37, x7, x38, x18, x21, x24, x27, x30, x33, x36, x39, x40, x41, x42, x43, x44, x45, x46, x47; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x9 = _br2_load((in2)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x10 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x11 = _br2_load((in2)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x12 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in2)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x14 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x15 = _br2_load((in2)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x17 = (x16)^((uintptr_t)4294967295ULL); + x18 = ((x8)&(x16))|((x0)&(x17)); + x19 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x20 = (x19)^((uintptr_t)4294967295ULL); + x21 = ((x9)&(x19))|((x1)&(x20)); + x22 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x23 = (x22)^((uintptr_t)4294967295ULL); + x24 = ((x10)&(x22))|((x2)&(x23)); + x25 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x26 = (x25)^((uintptr_t)4294967295ULL); + x27 = ((x11)&(x25))|((x3)&(x26)); + x28 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x29 = (x28)^((uintptr_t)4294967295ULL); + x30 = ((x12)&(x28))|((x4)&(x29)); + x31 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x32 = (x31)^((uintptr_t)4294967295ULL); + x33 = ((x13)&(x31))|((x5)&(x32)); + x34 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x35 = (x34)^((uintptr_t)4294967295ULL); + x36 = ((x14)&(x34))|((x6)&(x35)); + x37 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x38 = (x37)^((uintptr_t)4294967295ULL); + x39 = ((x15)&(x37))|((x7)&(x38)); + x40 = x18; + x41 = x21; + x42 = x24; + x43 = x27; + x44 = x30; + x45 = x33; + x46 = x36; + x47 = x39; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x40, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x41, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x42, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x43, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x44, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x45, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x46, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x47, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_selectznz(uint32_t out1[8], uint8_t arg1, const uint32_t arg2[8], const uint32_t arg3[8]) { + internal_fiat_p256_scalar_selectznz((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static +void internal_fiat_p256_scalar_to_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x7, x6, x5, x4, x3, x2, x1, x0, x15, x17, x19, x14, x23, x25, x13, x29, x31, x12, x35, x37, x11, x41, x43, x10, x47, x49, x9, x53, x55, x8, x59, x61, x16, x18, x20, x21, x22, x24, x26, x27, x28, x30, x32, x33, x34, x36, x38, x39, x40, x42, x44, x45, x46, x48, x50, x51, x52, x54, x56, x57, x58, x60, x62, x63, x64, x65, x66, x67, x68, x69, x70, x71, x72, x73, x74, x75, x76, x77, x78, x79, x80, x81, x82, x83, x84, x85, x86, x87, x88, x89, x90, x91, x92, x93, x94, x95; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x7; + x9 = x6; + x10 = x5; + x11 = x4; + x12 = x3; + x13 = x2; + x14 = x1; + x15 = x0; + x16 = (x15)&((uintptr_t)255ULL); + x17 = (x15)>>((uintptr_t)8ULL); + x18 = (x17)&((uintptr_t)255ULL); + x19 = (x17)>>((uintptr_t)8ULL); + x20 = (x19)&((uintptr_t)255ULL); + x21 = (x19)>>((uintptr_t)8ULL); + x22 = (x14)&((uintptr_t)255ULL); + x23 = (x14)>>((uintptr_t)8ULL); + x24 = (x23)&((uintptr_t)255ULL); + x25 = (x23)>>((uintptr_t)8ULL); + x26 = (x25)&((uintptr_t)255ULL); + x27 = (x25)>>((uintptr_t)8ULL); + x28 = (x13)&((uintptr_t)255ULL); + x29 = (x13)>>((uintptr_t)8ULL); + x30 = (x29)&((uintptr_t)255ULL); + x31 = (x29)>>((uintptr_t)8ULL); + x32 = (x31)&((uintptr_t)255ULL); + x33 = (x31)>>((uintptr_t)8ULL); + x34 = (x12)&((uintptr_t)255ULL); + x35 = (x12)>>((uintptr_t)8ULL); + x36 = (x35)&((uintptr_t)255ULL); + x37 = (x35)>>((uintptr_t)8ULL); + x38 = (x37)&((uintptr_t)255ULL); + x39 = (x37)>>((uintptr_t)8ULL); + x40 = (x11)&((uintptr_t)255ULL); + x41 = (x11)>>((uintptr_t)8ULL); + x42 = (x41)&((uintptr_t)255ULL); + x43 = (x41)>>((uintptr_t)8ULL); + x44 = (x43)&((uintptr_t)255ULL); + x45 = (x43)>>((uintptr_t)8ULL); + x46 = (x10)&((uintptr_t)255ULL); + x47 = (x10)>>((uintptr_t)8ULL); + x48 = (x47)&((uintptr_t)255ULL); + x49 = (x47)>>((uintptr_t)8ULL); + x50 = (x49)&((uintptr_t)255ULL); + x51 = (x49)>>((uintptr_t)8ULL); + x52 = (x9)&((uintptr_t)255ULL); + x53 = (x9)>>((uintptr_t)8ULL); + x54 = (x53)&((uintptr_t)255ULL); + x55 = (x53)>>((uintptr_t)8ULL); + x56 = (x55)&((uintptr_t)255ULL); + x57 = (x55)>>((uintptr_t)8ULL); + x58 = (x8)&((uintptr_t)255ULL); + x59 = (x8)>>((uintptr_t)8ULL); + x60 = (x59)&((uintptr_t)255ULL); + x61 = (x59)>>((uintptr_t)8ULL); + x62 = (x61)&((uintptr_t)255ULL); + x63 = (x61)>>((uintptr_t)8ULL); + x64 = x16; + x65 = x18; + x66 = x20; + x67 = x21; + x68 = x22; + x69 = x24; + x70 = x26; + x71 = x27; + x72 = x28; + x73 = x30; + x74 = x32; + x75 = x33; + x76 = x34; + x77 = x36; + x78 = x38; + x79 = x39; + x80 = x40; + x81 = x42; + x82 = x44; + x83 = x45; + x84 = x46; + x85 = x48; + x86 = x50; + x87 = x51; + x88 = x52; + x89 = x54; + x90 = x56; + x91 = x57; + x92 = x58; + x93 = x60; + x94 = x62; + x95 = x63; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x64, 1); + _br2_store((out0)+((uintptr_t)1ULL), x65, 1); + _br2_store((out0)+((uintptr_t)2ULL), x66, 1); + _br2_store((out0)+((uintptr_t)3ULL), x67, 1); + _br2_store((out0)+((uintptr_t)4ULL), x68, 1); + _br2_store((out0)+((uintptr_t)5ULL), x69, 1); + _br2_store((out0)+((uintptr_t)6ULL), x70, 1); + _br2_store((out0)+((uintptr_t)7ULL), x71, 1); + _br2_store((out0)+((uintptr_t)8ULL), x72, 1); + _br2_store((out0)+((uintptr_t)9ULL), x73, 1); + _br2_store((out0)+((uintptr_t)10ULL), x74, 1); + _br2_store((out0)+((uintptr_t)11ULL), x75, 1); + _br2_store((out0)+((uintptr_t)12ULL), x76, 1); + _br2_store((out0)+((uintptr_t)13ULL), x77, 1); + _br2_store((out0)+((uintptr_t)14ULL), x78, 1); + _br2_store((out0)+((uintptr_t)15ULL), x79, 1); + _br2_store((out0)+((uintptr_t)16ULL), x80, 1); + _br2_store((out0)+((uintptr_t)17ULL), x81, 1); + _br2_store((out0)+((uintptr_t)18ULL), x82, 1); + _br2_store((out0)+((uintptr_t)19ULL), x83, 1); + _br2_store((out0)+((uintptr_t)20ULL), x84, 1); + _br2_store((out0)+((uintptr_t)21ULL), x85, 1); + _br2_store((out0)+((uintptr_t)22ULL), x86, 1); + _br2_store((out0)+((uintptr_t)23ULL), x87, 1); + _br2_store((out0)+((uintptr_t)24ULL), x88, 1); + _br2_store((out0)+((uintptr_t)25ULL), x89, 1); + _br2_store((out0)+((uintptr_t)26ULL), x90, 1); + _br2_store((out0)+((uintptr_t)27ULL), x91, 1); + _br2_store((out0)+((uintptr_t)28ULL), x92, 1); + _br2_store((out0)+((uintptr_t)29ULL), x93, 1); + _br2_store((out0)+((uintptr_t)30ULL), x94, 1); + _br2_store((out0)+((uintptr_t)31ULL), x95, 1); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_to_bytes(uint8_t out1[32], const uint32_t arg1[8]) { + internal_fiat_p256_scalar_to_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p256_scalar_from_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x31, x30, x29, x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x12, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0, x62, x63, x61, x64, x60, x65, x58, x59, x57, x67, x56, x68, x54, x55, x53, x70, x52, x71, x50, x51, x49, x73, x48, x74, x46, x47, x45, x76, x44, x77, x42, x43, x41, x79, x40, x80, x38, x39, x37, x82, x36, x83, x34, x35, x33, x85, x32, x86, x66, x69, x72, x75, x78, x81, x84, x87, x88, x89, x90, x91, x92, x93, x94, x95; + x0 = _br2_load((in0)+((uintptr_t)0ULL), 1); + x1 = _br2_load((in0)+((uintptr_t)1ULL), 1); + x2 = _br2_load((in0)+((uintptr_t)2ULL), 1); + x3 = _br2_load((in0)+((uintptr_t)3ULL), 1); + x4 = _br2_load((in0)+((uintptr_t)4ULL), 1); + x5 = _br2_load((in0)+((uintptr_t)5ULL), 1); + x6 = _br2_load((in0)+((uintptr_t)6ULL), 1); + x7 = _br2_load((in0)+((uintptr_t)7ULL), 1); + x8 = _br2_load((in0)+((uintptr_t)8ULL), 1); + x9 = _br2_load((in0)+((uintptr_t)9ULL), 1); + x10 = _br2_load((in0)+((uintptr_t)10ULL), 1); + x11 = _br2_load((in0)+((uintptr_t)11ULL), 1); + x12 = _br2_load((in0)+((uintptr_t)12ULL), 1); + x13 = _br2_load((in0)+((uintptr_t)13ULL), 1); + x14 = _br2_load((in0)+((uintptr_t)14ULL), 1); + x15 = _br2_load((in0)+((uintptr_t)15ULL), 1); + x16 = _br2_load((in0)+((uintptr_t)16ULL), 1); + x17 = _br2_load((in0)+((uintptr_t)17ULL), 1); + x18 = _br2_load((in0)+((uintptr_t)18ULL), 1); + x19 = _br2_load((in0)+((uintptr_t)19ULL), 1); + x20 = _br2_load((in0)+((uintptr_t)20ULL), 1); + x21 = _br2_load((in0)+((uintptr_t)21ULL), 1); + x22 = _br2_load((in0)+((uintptr_t)22ULL), 1); + x23 = _br2_load((in0)+((uintptr_t)23ULL), 1); + x24 = _br2_load((in0)+((uintptr_t)24ULL), 1); + x25 = _br2_load((in0)+((uintptr_t)25ULL), 1); + x26 = _br2_load((in0)+((uintptr_t)26ULL), 1); + x27 = _br2_load((in0)+((uintptr_t)27ULL), 1); + x28 = _br2_load((in0)+((uintptr_t)28ULL), 1); + x29 = _br2_load((in0)+((uintptr_t)29ULL), 1); + x30 = _br2_load((in0)+((uintptr_t)30ULL), 1); + x31 = _br2_load((in0)+((uintptr_t)31ULL), 1); + /*skip*/ + /*skip*/ + x32 = (x31)<<((uintptr_t)24ULL); + x33 = (x30)<<((uintptr_t)16ULL); + x34 = (x29)<<((uintptr_t)8ULL); + x35 = x28; + x36 = (x27)<<((uintptr_t)24ULL); + x37 = (x26)<<((uintptr_t)16ULL); + x38 = (x25)<<((uintptr_t)8ULL); + x39 = x24; + x40 = (x23)<<((uintptr_t)24ULL); + x41 = (x22)<<((uintptr_t)16ULL); + x42 = (x21)<<((uintptr_t)8ULL); + x43 = x20; + x44 = (x19)<<((uintptr_t)24ULL); + x45 = (x18)<<((uintptr_t)16ULL); + x46 = (x17)<<((uintptr_t)8ULL); + x47 = x16; + x48 = (x15)<<((uintptr_t)24ULL); + x49 = (x14)<<((uintptr_t)16ULL); + x50 = (x13)<<((uintptr_t)8ULL); + x51 = x12; + x52 = (x11)<<((uintptr_t)24ULL); + x53 = (x10)<<((uintptr_t)16ULL); + x54 = (x9)<<((uintptr_t)8ULL); + x55 = x8; + x56 = (x7)<<((uintptr_t)24ULL); + x57 = (x6)<<((uintptr_t)16ULL); + x58 = (x5)<<((uintptr_t)8ULL); + x59 = x4; + x60 = (x3)<<((uintptr_t)24ULL); + x61 = (x2)<<((uintptr_t)16ULL); + x62 = (x1)<<((uintptr_t)8ULL); + x63 = x0; + x64 = (x62)+(x63); + x65 = (x61)+(x64); + x66 = (x60)+(x65); + x67 = (x58)+(x59); + x68 = (x57)+(x67); + x69 = (x56)+(x68); + x70 = (x54)+(x55); + x71 = (x53)+(x70); + x72 = (x52)+(x71); + x73 = (x50)+(x51); + x74 = (x49)+(x73); + x75 = (x48)+(x74); + x76 = (x46)+(x47); + x77 = (x45)+(x76); + x78 = (x44)+(x77); + x79 = (x42)+(x43); + x80 = (x41)+(x79); + x81 = (x40)+(x80); + x82 = (x38)+(x39); + x83 = (x37)+(x82); + x84 = (x36)+(x83); + x85 = (x34)+(x35); + x86 = (x33)+(x85); + x87 = (x32)+(x86); + x88 = x66; + x89 = x69; + x90 = x72; + x91 = x75; + x92 = x78; + x93 = x81; + x94 = x84; + x95 = x87; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x88, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x89, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x90, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x91, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x92, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x93, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x94, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x95, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_from_bytes(uint32_t out1[8], const uint8_t arg1[32]) { + internal_fiat_p256_scalar_from_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p256_scalar_set_one(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7; + /*skip*/ + x0 = (uintptr_t)60611247ULL; + x1 = (uintptr_t)205927741ULL; + x2 = (uintptr_t)1491624315ULL; + x3 = (uintptr_t)1125713234ULL; + x4 = (uintptr_t)0ULL; + x5 = (uintptr_t)0ULL; + x6 = (uintptr_t)4294967295ULL; + x7 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x7, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_set_one(uint32_t out1[8]) { + internal_fiat_p256_scalar_set_one((uintptr_t)out1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p256_scalar_msat(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8; + /*skip*/ + x0 = (uintptr_t)4234356049ULL; + x1 = (uintptr_t)4089039554ULL; + x2 = (uintptr_t)2803342980ULL; + x3 = (uintptr_t)3169254061ULL; + x4 = (uintptr_t)4294967295ULL; + x5 = (uintptr_t)4294967295ULL; + x6 = (uintptr_t)0ULL; + x7 = (uintptr_t)4294967295ULL; + x8 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x7, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x8, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_msat(uint32_t out1[9]) { + internal_fiat_p256_scalar_msat((uintptr_t)out1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0xffffffff] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffff] + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +uintptr_t internal_fiat_p256_scalar_divstep(uintptr_t out1, uintptr_t out2, uintptr_t out3, uintptr_t out4, uintptr_t in0, uintptr_t in1, uintptr_t in2, uintptr_t in3, uintptr_t in4) { + uintptr_t x34, x36, x37, x38, x40, x41, x43, x44, x46, x47, x49, x50, x52, x53, x55, x56, x58, x59, x61, x62, x64, x65, x0, x68, x1, x70, x2, x72, x3, x74, x4, x76, x5, x78, x6, x80, x7, x82, x8, x67, x84, x9, x85, x69, x87, x10, x88, x71, x90, x11, x91, x73, x93, x12, x94, x75, x96, x13, x97, x77, x99, x14, x100, x79, x102, x15, x103, x81, x105, x16, x106, x83, x108, x17, x109, x111, x112, x114, x115, x117, x118, x120, x121, x123, x124, x126, x127, x129, x130, x132, x133, x136, x137, x138, x140, x141, x142, x143, x145, x146, x147, x148, x150, x151, x152, x153, x155, x156, x157, x158, x160, x161, x162, x163, x165, x166, x167, x168, x170, x173, x174, x175, x177, x178, x179, x180, x182, x183, x184, x185, x187, x188, x189, x190, x192, x193, x194, x195, x197, x198, x200, x201, x202, x204, x205, x171, x206, x25, x24, x23, x22, x21, x20, x19, x18, x216, x214, x217, x219, x220, x213, x221, x223, x224, x212, x225, x227, x228, x211, x229, x231, x232, x210, x233, x235, x236, x209, x237, x239, x240, x208, x241, x243, x244, x215, x247, x218, x248, x249, x251, x252, x222, x253, x254, x256, x257, x226, x258, x259, x261, x262, x230, x263, x264, x266, x267, x234, x268, x269, x271, x272, x238, x274, x242, x275, x245, x246, x277, x26, x278, x250, x280, x27, x281, x255, x283, x28, x284, x260, x286, x29, x287, x265, x289, x30, x290, x270, x292, x31, x293, x273, x295, x32, x296, x35, x276, x298, x33, x299, x302, x303, x305, x306, x308, x309, x311, x312, x314, x315, x317, x318, x320, x321, x323, x324, x326, x327, x304, x86, x330, x89, x331, x307, x332, x334, x335, x92, x336, x310, x337, x339, x340, x95, x341, x313, x342, x344, x345, x98, x346, x316, x347, x349, x350, x101, x351, x319, x352, x354, x355, x104, x356, x322, x357, x359, x360, x107, x361, x325, x362, x364, x365, x110, x366, x328, x113, x368, x369, x116, x371, x372, x119, x374, x375, x122, x377, x378, x125, x380, x381, x128, x383, x384, x131, x386, x387, x301, x134, x389, x390, x370, x279, x393, x282, x394, x373, x395, x397, x398, x285, x399, x376, x400, x402, x403, x288, x404, x379, x405, x407, x408, x291, x409, x382, x410, x412, x413, x294, x414, x385, x415, x417, x418, x297, x419, x388, x420, x422, x423, x300, x424, x391, x425, x427, x430, x431, x432, x434, x435, x436, x437, x439, x440, x441, x442, x444, x445, x446, x447, x449, x450, x451, x452, x454, x455, x457, x458, x459, x461, x462, x428, x463, x39, x329, x333, x338, x343, x348, x353, x358, x363, x367, x135, x475, x172, x476, x139, x478, x176, x479, x144, x481, x181, x482, x149, x484, x186, x485, x154, x487, x191, x488, x159, x490, x196, x491, x164, x493, x199, x494, x207, x169, x496, x203, x497, x392, x499, x429, x500, x396, x502, x433, x503, x401, x505, x438, x506, x406, x508, x443, x509, x411, x511, x448, x512, x416, x514, x453, x515, x421, x517, x456, x518, x464, x426, x520, x460, x521, x465, x42, x45, x48, x51, x54, x57, x60, x63, x66, x466, x467, x468, x469, x470, x471, x472, x473, x474, x477, x480, x483, x486, x489, x492, x495, x498, x501, x504, x507, x510, x513, x516, x519, x522, out0, x523, x524, x525, x526, x527, x528, x529, x530, x531, x532, x533, x534, x535, x536, x537, x538, x539, x540, x541, x542, x543, x544, x545, x546, x547, x548, x549, x550, x551, x552, x553, x554, x555, x556, x557; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + /*skip*/ + x9 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x10 = _br2_load((in2)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x11 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x12 = _br2_load((in2)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x13 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x14 = _br2_load((in2)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x15 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x16 = _br2_load((in2)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x17 = _br2_load((in2)+((uintptr_t)32ULL), sizeof(uintptr_t)); + /*skip*/ + x18 = _br2_load((in3)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x19 = _br2_load((in3)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x20 = _br2_load((in3)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x21 = _br2_load((in3)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x22 = _br2_load((in3)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x23 = _br2_load((in3)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x24 = _br2_load((in3)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x25 = _br2_load((in3)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x26 = _br2_load((in4)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x27 = _br2_load((in4)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x28 = _br2_load((in4)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x29 = _br2_load((in4)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x30 = _br2_load((in4)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x31 = _br2_load((in4)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x32 = _br2_load((in4)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x33 = _br2_load((in4)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x34 = ((in0)^((uintptr_t)4294967295ULL))+((uintptr_t)1ULL); + x35 = ((x34)>>((uintptr_t)31ULL))&((x9)&((uintptr_t)1ULL)); + x36 = ((in0)^((uintptr_t)4294967295ULL))+((uintptr_t)1ULL); + x37 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x38 = (x37)^((uintptr_t)4294967295ULL); + x39 = ((x36)&(x37))|((in0)&(x38)); + x40 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x41 = (x40)^((uintptr_t)4294967295ULL); + x42 = ((x9)&(x40))|((x0)&(x41)); + x43 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x44 = (x43)^((uintptr_t)4294967295ULL); + x45 = ((x10)&(x43))|((x1)&(x44)); + x46 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x47 = (x46)^((uintptr_t)4294967295ULL); + x48 = ((x11)&(x46))|((x2)&(x47)); + x49 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x50 = (x49)^((uintptr_t)4294967295ULL); + x51 = ((x12)&(x49))|((x3)&(x50)); + x52 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x53 = (x52)^((uintptr_t)4294967295ULL); + x54 = ((x13)&(x52))|((x4)&(x53)); + x55 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x56 = (x55)^((uintptr_t)4294967295ULL); + x57 = ((x14)&(x55))|((x5)&(x56)); + x58 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x59 = (x58)^((uintptr_t)4294967295ULL); + x60 = ((x15)&(x58))|((x6)&(x59)); + x61 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x62 = (x61)^((uintptr_t)4294967295ULL); + x63 = ((x16)&(x61))|((x7)&(x62)); + x64 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x65 = (x64)^((uintptr_t)4294967295ULL); + x66 = ((x17)&(x64))|((x8)&(x65)); + x67 = ((uintptr_t)1ULL)+((x0)^((uintptr_t)4294967295ULL)); + x68 = (uintptr_t)((x67)<((uintptr_t)1ULL)); + x69 = (x68)+((x1)^((uintptr_t)4294967295ULL)); + x70 = (uintptr_t)((x69)<((x1)^((uintptr_t)4294967295ULL))); + x71 = (x70)+((x2)^((uintptr_t)4294967295ULL)); + x72 = (uintptr_t)((x71)<((x2)^((uintptr_t)4294967295ULL))); + x73 = (x72)+((x3)^((uintptr_t)4294967295ULL)); + x74 = (uintptr_t)((x73)<((x3)^((uintptr_t)4294967295ULL))); + x75 = (x74)+((x4)^((uintptr_t)4294967295ULL)); + x76 = (uintptr_t)((x75)<((x4)^((uintptr_t)4294967295ULL))); + x77 = (x76)+((x5)^((uintptr_t)4294967295ULL)); + x78 = (uintptr_t)((x77)<((x5)^((uintptr_t)4294967295ULL))); + x79 = (x78)+((x6)^((uintptr_t)4294967295ULL)); + x80 = (uintptr_t)((x79)<((x6)^((uintptr_t)4294967295ULL))); + x81 = (x80)+((x7)^((uintptr_t)4294967295ULL)); + x82 = (uintptr_t)((x81)<((x7)^((uintptr_t)4294967295ULL))); + x83 = (x82)+((x8)^((uintptr_t)4294967295ULL)); + x84 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x85 = (x84)^((uintptr_t)4294967295ULL); + x86 = ((x67)&(x84))|((x9)&(x85)); + x87 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x88 = (x87)^((uintptr_t)4294967295ULL); + x89 = ((x69)&(x87))|((x10)&(x88)); + x90 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x91 = (x90)^((uintptr_t)4294967295ULL); + x92 = ((x71)&(x90))|((x11)&(x91)); + x93 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x94 = (x93)^((uintptr_t)4294967295ULL); + x95 = ((x73)&(x93))|((x12)&(x94)); + x96 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x97 = (x96)^((uintptr_t)4294967295ULL); + x98 = ((x75)&(x96))|((x13)&(x97)); + x99 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x100 = (x99)^((uintptr_t)4294967295ULL); + x101 = ((x77)&(x99))|((x14)&(x100)); + x102 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x103 = (x102)^((uintptr_t)4294967295ULL); + x104 = ((x79)&(x102))|((x15)&(x103)); + x105 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x106 = (x105)^((uintptr_t)4294967295ULL); + x107 = ((x81)&(x105))|((x16)&(x106)); + x108 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x109 = (x108)^((uintptr_t)4294967295ULL); + x110 = ((x83)&(x108))|((x17)&(x109)); + x111 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x112 = (x111)^((uintptr_t)4294967295ULL); + x113 = ((x26)&(x111))|((x18)&(x112)); + x114 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x115 = (x114)^((uintptr_t)4294967295ULL); + x116 = ((x27)&(x114))|((x19)&(x115)); + x117 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x118 = (x117)^((uintptr_t)4294967295ULL); + x119 = ((x28)&(x117))|((x20)&(x118)); + x120 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x121 = (x120)^((uintptr_t)4294967295ULL); + x122 = ((x29)&(x120))|((x21)&(x121)); + x123 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x124 = (x123)^((uintptr_t)4294967295ULL); + x125 = ((x30)&(x123))|((x22)&(x124)); + x126 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x127 = (x126)^((uintptr_t)4294967295ULL); + x128 = ((x31)&(x126))|((x23)&(x127)); + x129 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x130 = (x129)^((uintptr_t)4294967295ULL); + x131 = ((x32)&(x129))|((x24)&(x130)); + x132 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x133 = (x132)^((uintptr_t)4294967295ULL); + x134 = ((x33)&(x132))|((x25)&(x133)); + x135 = (x113)+(x113); + x136 = (uintptr_t)((x135)<(x113)); + x137 = (x136)+(x116); + x138 = (uintptr_t)((x137)<(x116)); + x139 = (x137)+(x116); + x140 = (uintptr_t)((x139)<(x116)); + x141 = (x138)+(x140); + x142 = (x141)+(x119); + x143 = (uintptr_t)((x142)<(x119)); + x144 = (x142)+(x119); + x145 = (uintptr_t)((x144)<(x119)); + x146 = (x143)+(x145); + x147 = (x146)+(x122); + x148 = (uintptr_t)((x147)<(x122)); + x149 = (x147)+(x122); + x150 = (uintptr_t)((x149)<(x122)); + x151 = (x148)+(x150); + x152 = (x151)+(x125); + x153 = (uintptr_t)((x152)<(x125)); + x154 = (x152)+(x125); + x155 = (uintptr_t)((x154)<(x125)); + x156 = (x153)+(x155); + x157 = (x156)+(x128); + x158 = (uintptr_t)((x157)<(x128)); + x159 = (x157)+(x128); + x160 = (uintptr_t)((x159)<(x128)); + x161 = (x158)+(x160); + x162 = (x161)+(x131); + x163 = (uintptr_t)((x162)<(x131)); + x164 = (x162)+(x131); + x165 = (uintptr_t)((x164)<(x131)); + x166 = (x163)+(x165); + x167 = (x166)+(x134); + x168 = (uintptr_t)((x167)<(x134)); + x169 = (x167)+(x134); + x170 = (uintptr_t)((x169)<(x134)); + x171 = (x168)+(x170); + x172 = (x135)-((uintptr_t)4234356049ULL); + x173 = (uintptr_t)((x135)<(x172)); + x174 = (x139)-((uintptr_t)4089039554ULL); + x175 = (uintptr_t)((x139)<(x174)); + x176 = (x174)-(x173); + x177 = (uintptr_t)((x174)<(x176)); + x178 = (x175)+(x177); + x179 = (x144)-((uintptr_t)2803342980ULL); + x180 = (uintptr_t)((x144)<(x179)); + x181 = (x179)-(x178); + x182 = (uintptr_t)((x179)<(x181)); + x183 = (x180)+(x182); + x184 = (x149)-((uintptr_t)3169254061ULL); + x185 = (uintptr_t)((x149)<(x184)); + x186 = (x184)-(x183); + x187 = (uintptr_t)((x184)<(x186)); + x188 = (x185)+(x187); + x189 = (x154)-((uintptr_t)4294967295ULL); + x190 = (uintptr_t)((x154)<(x189)); + x191 = (x189)-(x188); + x192 = (uintptr_t)((x189)<(x191)); + x193 = (x190)+(x192); + x194 = (x159)-((uintptr_t)4294967295ULL); + x195 = (uintptr_t)((x159)<(x194)); + x196 = (x194)-(x193); + x197 = (uintptr_t)((x194)<(x196)); + x198 = (x195)+(x197); + x199 = (x164)-(x198); + x200 = (uintptr_t)((x164)<(x199)); + x201 = (x169)-((uintptr_t)4294967295ULL); + x202 = (uintptr_t)((x169)<(x201)); + x203 = (x201)-(x200); + x204 = (uintptr_t)((x201)<(x203)); + x205 = (x202)+(x204); + x206 = (x171)-(x205); + x207 = (uintptr_t)((x171)<(x206)); + x208 = x25; + x209 = x24; + x210 = x23; + x211 = x22; + x212 = x21; + x213 = x20; + x214 = x19; + x215 = x18; + x216 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x215))); + x217 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x214))); + x218 = (((uintptr_t)0ULL)-(x214))-(x216); + x219 = (uintptr_t)((((uintptr_t)0ULL)-(x214))<(x218)); + x220 = (x217)+(x219); + x221 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x213))); + x222 = (((uintptr_t)0ULL)-(x213))-(x220); + x223 = (uintptr_t)((((uintptr_t)0ULL)-(x213))<(x222)); + x224 = (x221)+(x223); + x225 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x212))); + x226 = (((uintptr_t)0ULL)-(x212))-(x224); + x227 = (uintptr_t)((((uintptr_t)0ULL)-(x212))<(x226)); + x228 = (x225)+(x227); + x229 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x211))); + x230 = (((uintptr_t)0ULL)-(x211))-(x228); + x231 = (uintptr_t)((((uintptr_t)0ULL)-(x211))<(x230)); + x232 = (x229)+(x231); + x233 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x210))); + x234 = (((uintptr_t)0ULL)-(x210))-(x232); + x235 = (uintptr_t)((((uintptr_t)0ULL)-(x210))<(x234)); + x236 = (x233)+(x235); + x237 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x209))); + x238 = (((uintptr_t)0ULL)-(x209))-(x236); + x239 = (uintptr_t)((((uintptr_t)0ULL)-(x209))<(x238)); + x240 = (x237)+(x239); + x241 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x208))); + x242 = (((uintptr_t)0ULL)-(x208))-(x240); + x243 = (uintptr_t)((((uintptr_t)0ULL)-(x208))<(x242)); + x244 = (x241)+(x243); + x245 = ((uintptr_t)-1ULL)+((uintptr_t)((x244)==((uintptr_t)0ULL))); + x246 = (((uintptr_t)0ULL)-(x215))+((x245)&((uintptr_t)4234356049ULL)); + x247 = (uintptr_t)((x246)<(((uintptr_t)0ULL)-(x215))); + x248 = (x247)+(x218); + x249 = (uintptr_t)((x248)<(x218)); + x250 = (x248)+((x245)&((uintptr_t)4089039554ULL)); + x251 = (uintptr_t)((x250)<((x245)&((uintptr_t)4089039554ULL))); + x252 = (x249)+(x251); + x253 = (x252)+(x222); + x254 = (uintptr_t)((x253)<(x222)); + x255 = (x253)+((x245)&((uintptr_t)2803342980ULL)); + x256 = (uintptr_t)((x255)<((x245)&((uintptr_t)2803342980ULL))); + x257 = (x254)+(x256); + x258 = (x257)+(x226); + x259 = (uintptr_t)((x258)<(x226)); + x260 = (x258)+((x245)&((uintptr_t)3169254061ULL)); + x261 = (uintptr_t)((x260)<((x245)&((uintptr_t)3169254061ULL))); + x262 = (x259)+(x261); + x263 = (x262)+(x230); + x264 = (uintptr_t)((x263)<(x230)); + x265 = (x263)+(x245); + x266 = (uintptr_t)((x265)<(x245)); + x267 = (x264)+(x266); + x268 = (x267)+(x234); + x269 = (uintptr_t)((x268)<(x234)); + x270 = (x268)+(x245); + x271 = (uintptr_t)((x270)<(x245)); + x272 = (x269)+(x271); + x273 = (x272)+(x238); + x274 = (uintptr_t)((x273)<(x238)); + x275 = (x274)+(x242); + x276 = (x275)+(x245); + x277 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x278 = (x277)^((uintptr_t)4294967295ULL); + x279 = ((x246)&(x277))|((x26)&(x278)); + x280 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x281 = (x280)^((uintptr_t)4294967295ULL); + x282 = ((x250)&(x280))|((x27)&(x281)); + x283 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x284 = (x283)^((uintptr_t)4294967295ULL); + x285 = ((x255)&(x283))|((x28)&(x284)); + x286 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x287 = (x286)^((uintptr_t)4294967295ULL); + x288 = ((x260)&(x286))|((x29)&(x287)); + x289 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x290 = (x289)^((uintptr_t)4294967295ULL); + x291 = ((x265)&(x289))|((x30)&(x290)); + x292 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x293 = (x292)^((uintptr_t)4294967295ULL); + x294 = ((x270)&(x292))|((x31)&(x293)); + x295 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x296 = (x295)^((uintptr_t)4294967295ULL); + x297 = ((x273)&(x295))|((x32)&(x296)); + x298 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x299 = (x298)^((uintptr_t)4294967295ULL); + x300 = ((x276)&(x298))|((x33)&(x299)); + x301 = (x86)&((uintptr_t)1ULL); + x302 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x303 = (x302)^((uintptr_t)4294967295ULL); + x304 = ((x42)&(x302))|(((uintptr_t)0ULL)&(x303)); + x305 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x306 = (x305)^((uintptr_t)4294967295ULL); + x307 = ((x45)&(x305))|(((uintptr_t)0ULL)&(x306)); + x308 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x309 = (x308)^((uintptr_t)4294967295ULL); + x310 = ((x48)&(x308))|(((uintptr_t)0ULL)&(x309)); + x311 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x312 = (x311)^((uintptr_t)4294967295ULL); + x313 = ((x51)&(x311))|(((uintptr_t)0ULL)&(x312)); + x314 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x315 = (x314)^((uintptr_t)4294967295ULL); + x316 = ((x54)&(x314))|(((uintptr_t)0ULL)&(x315)); + x317 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x318 = (x317)^((uintptr_t)4294967295ULL); + x319 = ((x57)&(x317))|(((uintptr_t)0ULL)&(x318)); + x320 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x321 = (x320)^((uintptr_t)4294967295ULL); + x322 = ((x60)&(x320))|(((uintptr_t)0ULL)&(x321)); + x323 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x324 = (x323)^((uintptr_t)4294967295ULL); + x325 = ((x63)&(x323))|(((uintptr_t)0ULL)&(x324)); + x326 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x327 = (x326)^((uintptr_t)4294967295ULL); + x328 = ((x66)&(x326))|(((uintptr_t)0ULL)&(x327)); + x329 = (x86)+(x304); + x330 = (uintptr_t)((x329)<(x86)); + x331 = (x330)+(x89); + x332 = (uintptr_t)((x331)<(x89)); + x333 = (x331)+(x307); + x334 = (uintptr_t)((x333)<(x307)); + x335 = (x332)+(x334); + x336 = (x335)+(x92); + x337 = (uintptr_t)((x336)<(x92)); + x338 = (x336)+(x310); + x339 = (uintptr_t)((x338)<(x310)); + x340 = (x337)+(x339); + x341 = (x340)+(x95); + x342 = (uintptr_t)((x341)<(x95)); + x343 = (x341)+(x313); + x344 = (uintptr_t)((x343)<(x313)); + x345 = (x342)+(x344); + x346 = (x345)+(x98); + x347 = (uintptr_t)((x346)<(x98)); + x348 = (x346)+(x316); + x349 = (uintptr_t)((x348)<(x316)); + x350 = (x347)+(x349); + x351 = (x350)+(x101); + x352 = (uintptr_t)((x351)<(x101)); + x353 = (x351)+(x319); + x354 = (uintptr_t)((x353)<(x319)); + x355 = (x352)+(x354); + x356 = (x355)+(x104); + x357 = (uintptr_t)((x356)<(x104)); + x358 = (x356)+(x322); + x359 = (uintptr_t)((x358)<(x322)); + x360 = (x357)+(x359); + x361 = (x360)+(x107); + x362 = (uintptr_t)((x361)<(x107)); + x363 = (x361)+(x325); + x364 = (uintptr_t)((x363)<(x325)); + x365 = (x362)+(x364); + x366 = (x365)+(x110); + x367 = (x366)+(x328); + x368 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x369 = (x368)^((uintptr_t)4294967295ULL); + x370 = ((x113)&(x368))|(((uintptr_t)0ULL)&(x369)); + x371 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x372 = (x371)^((uintptr_t)4294967295ULL); + x373 = ((x116)&(x371))|(((uintptr_t)0ULL)&(x372)); + x374 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x375 = (x374)^((uintptr_t)4294967295ULL); + x376 = ((x119)&(x374))|(((uintptr_t)0ULL)&(x375)); + x377 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x378 = (x377)^((uintptr_t)4294967295ULL); + x379 = ((x122)&(x377))|(((uintptr_t)0ULL)&(x378)); + x380 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x381 = (x380)^((uintptr_t)4294967295ULL); + x382 = ((x125)&(x380))|(((uintptr_t)0ULL)&(x381)); + x383 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x384 = (x383)^((uintptr_t)4294967295ULL); + x385 = ((x128)&(x383))|(((uintptr_t)0ULL)&(x384)); + x386 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x387 = (x386)^((uintptr_t)4294967295ULL); + x388 = ((x131)&(x386))|(((uintptr_t)0ULL)&(x387)); + x389 = ((uintptr_t)-1ULL)+((uintptr_t)((x301)==((uintptr_t)0ULL))); + x390 = (x389)^((uintptr_t)4294967295ULL); + x391 = ((x134)&(x389))|(((uintptr_t)0ULL)&(x390)); + x392 = (x279)+(x370); + x393 = (uintptr_t)((x392)<(x279)); + x394 = (x393)+(x282); + x395 = (uintptr_t)((x394)<(x282)); + x396 = (x394)+(x373); + x397 = (uintptr_t)((x396)<(x373)); + x398 = (x395)+(x397); + x399 = (x398)+(x285); + x400 = (uintptr_t)((x399)<(x285)); + x401 = (x399)+(x376); + x402 = (uintptr_t)((x401)<(x376)); + x403 = (x400)+(x402); + x404 = (x403)+(x288); + x405 = (uintptr_t)((x404)<(x288)); + x406 = (x404)+(x379); + x407 = (uintptr_t)((x406)<(x379)); + x408 = (x405)+(x407); + x409 = (x408)+(x291); + x410 = (uintptr_t)((x409)<(x291)); + x411 = (x409)+(x382); + x412 = (uintptr_t)((x411)<(x382)); + x413 = (x410)+(x412); + x414 = (x413)+(x294); + x415 = (uintptr_t)((x414)<(x294)); + x416 = (x414)+(x385); + x417 = (uintptr_t)((x416)<(x385)); + x418 = (x415)+(x417); + x419 = (x418)+(x297); + x420 = (uintptr_t)((x419)<(x297)); + x421 = (x419)+(x388); + x422 = (uintptr_t)((x421)<(x388)); + x423 = (x420)+(x422); + x424 = (x423)+(x300); + x425 = (uintptr_t)((x424)<(x300)); + x426 = (x424)+(x391); + x427 = (uintptr_t)((x426)<(x391)); + x428 = (x425)+(x427); + x429 = (x392)-((uintptr_t)4234356049ULL); + x430 = (uintptr_t)((x392)<(x429)); + x431 = (x396)-((uintptr_t)4089039554ULL); + x432 = (uintptr_t)((x396)<(x431)); + x433 = (x431)-(x430); + x434 = (uintptr_t)((x431)<(x433)); + x435 = (x432)+(x434); + x436 = (x401)-((uintptr_t)2803342980ULL); + x437 = (uintptr_t)((x401)<(x436)); + x438 = (x436)-(x435); + x439 = (uintptr_t)((x436)<(x438)); + x440 = (x437)+(x439); + x441 = (x406)-((uintptr_t)3169254061ULL); + x442 = (uintptr_t)((x406)<(x441)); + x443 = (x441)-(x440); + x444 = (uintptr_t)((x441)<(x443)); + x445 = (x442)+(x444); + x446 = (x411)-((uintptr_t)4294967295ULL); + x447 = (uintptr_t)((x411)<(x446)); + x448 = (x446)-(x445); + x449 = (uintptr_t)((x446)<(x448)); + x450 = (x447)+(x449); + x451 = (x416)-((uintptr_t)4294967295ULL); + x452 = (uintptr_t)((x416)<(x451)); + x453 = (x451)-(x450); + x454 = (uintptr_t)((x451)<(x453)); + x455 = (x452)+(x454); + x456 = (x421)-(x455); + x457 = (uintptr_t)((x421)<(x456)); + x458 = (x426)-((uintptr_t)4294967295ULL); + x459 = (uintptr_t)((x426)<(x458)); + x460 = (x458)-(x457); + x461 = (uintptr_t)((x458)<(x460)); + x462 = (x459)+(x461); + x463 = (x428)-(x462); + x464 = (uintptr_t)((x428)<(x463)); + x465 = (x39)+((uintptr_t)1ULL); + x466 = ((x329)>>((uintptr_t)1ULL))|((x333)<<((uintptr_t)31ULL)); + x467 = ((x333)>>((uintptr_t)1ULL))|((x338)<<((uintptr_t)31ULL)); + x468 = ((x338)>>((uintptr_t)1ULL))|((x343)<<((uintptr_t)31ULL)); + x469 = ((x343)>>((uintptr_t)1ULL))|((x348)<<((uintptr_t)31ULL)); + x470 = ((x348)>>((uintptr_t)1ULL))|((x353)<<((uintptr_t)31ULL)); + x471 = ((x353)>>((uintptr_t)1ULL))|((x358)<<((uintptr_t)31ULL)); + x472 = ((x358)>>((uintptr_t)1ULL))|((x363)<<((uintptr_t)31ULL)); + x473 = ((x363)>>((uintptr_t)1ULL))|((x367)<<((uintptr_t)31ULL)); + x474 = ((x367)&((uintptr_t)2147483648ULL))|((x367)>>((uintptr_t)1ULL)); + x475 = ((uintptr_t)-1ULL)+((uintptr_t)((x207)==((uintptr_t)0ULL))); + x476 = (x475)^((uintptr_t)4294967295ULL); + x477 = ((x135)&(x475))|((x172)&(x476)); + x478 = ((uintptr_t)-1ULL)+((uintptr_t)((x207)==((uintptr_t)0ULL))); + x479 = (x478)^((uintptr_t)4294967295ULL); + x480 = ((x139)&(x478))|((x176)&(x479)); + x481 = ((uintptr_t)-1ULL)+((uintptr_t)((x207)==((uintptr_t)0ULL))); + x482 = (x481)^((uintptr_t)4294967295ULL); + x483 = ((x144)&(x481))|((x181)&(x482)); + x484 = ((uintptr_t)-1ULL)+((uintptr_t)((x207)==((uintptr_t)0ULL))); + x485 = (x484)^((uintptr_t)4294967295ULL); + x486 = ((x149)&(x484))|((x186)&(x485)); + x487 = ((uintptr_t)-1ULL)+((uintptr_t)((x207)==((uintptr_t)0ULL))); + x488 = (x487)^((uintptr_t)4294967295ULL); + x489 = ((x154)&(x487))|((x191)&(x488)); + x490 = ((uintptr_t)-1ULL)+((uintptr_t)((x207)==((uintptr_t)0ULL))); + x491 = (x490)^((uintptr_t)4294967295ULL); + x492 = ((x159)&(x490))|((x196)&(x491)); + x493 = ((uintptr_t)-1ULL)+((uintptr_t)((x207)==((uintptr_t)0ULL))); + x494 = (x493)^((uintptr_t)4294967295ULL); + x495 = ((x164)&(x493))|((x199)&(x494)); + x496 = ((uintptr_t)-1ULL)+((uintptr_t)((x207)==((uintptr_t)0ULL))); + x497 = (x496)^((uintptr_t)4294967295ULL); + x498 = ((x169)&(x496))|((x203)&(x497)); + x499 = ((uintptr_t)-1ULL)+((uintptr_t)((x464)==((uintptr_t)0ULL))); + x500 = (x499)^((uintptr_t)4294967295ULL); + x501 = ((x392)&(x499))|((x429)&(x500)); + x502 = ((uintptr_t)-1ULL)+((uintptr_t)((x464)==((uintptr_t)0ULL))); + x503 = (x502)^((uintptr_t)4294967295ULL); + x504 = ((x396)&(x502))|((x433)&(x503)); + x505 = ((uintptr_t)-1ULL)+((uintptr_t)((x464)==((uintptr_t)0ULL))); + x506 = (x505)^((uintptr_t)4294967295ULL); + x507 = ((x401)&(x505))|((x438)&(x506)); + x508 = ((uintptr_t)-1ULL)+((uintptr_t)((x464)==((uintptr_t)0ULL))); + x509 = (x508)^((uintptr_t)4294967295ULL); + x510 = ((x406)&(x508))|((x443)&(x509)); + x511 = ((uintptr_t)-1ULL)+((uintptr_t)((x464)==((uintptr_t)0ULL))); + x512 = (x511)^((uintptr_t)4294967295ULL); + x513 = ((x411)&(x511))|((x448)&(x512)); + x514 = ((uintptr_t)-1ULL)+((uintptr_t)((x464)==((uintptr_t)0ULL))); + x515 = (x514)^((uintptr_t)4294967295ULL); + x516 = ((x416)&(x514))|((x453)&(x515)); + x517 = ((uintptr_t)-1ULL)+((uintptr_t)((x464)==((uintptr_t)0ULL))); + x518 = (x517)^((uintptr_t)4294967295ULL); + x519 = ((x421)&(x517))|((x456)&(x518)); + x520 = ((uintptr_t)-1ULL)+((uintptr_t)((x464)==((uintptr_t)0ULL))); + x521 = (x520)^((uintptr_t)4294967295ULL); + x522 = ((x426)&(x520))|((x460)&(x521)); + x523 = x465; + x524 = x42; + x525 = x45; + x526 = x48; + x527 = x51; + x528 = x54; + x529 = x57; + x530 = x60; + x531 = x63; + x532 = x66; + /*skip*/ + x533 = x466; + x534 = x467; + x535 = x468; + x536 = x469; + x537 = x470; + x538 = x471; + x539 = x472; + x540 = x473; + x541 = x474; + /*skip*/ + x542 = x477; + x543 = x480; + x544 = x483; + x545 = x486; + x546 = x489; + x547 = x492; + x548 = x495; + x549 = x498; + /*skip*/ + x550 = x501; + x551 = x504; + x552 = x507; + x553 = x510; + x554 = x513; + x555 = x516; + x556 = x519; + x557 = x522; + /*skip*/ + out0 = x523; + _br2_store((out1)+((uintptr_t)0ULL), x524, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)4ULL), x525, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)8ULL), x526, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)12ULL), x527, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)16ULL), x528, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)20ULL), x529, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)24ULL), x530, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)28ULL), x531, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)32ULL), x532, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out2)+((uintptr_t)0ULL), x533, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)4ULL), x534, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)8ULL), x535, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)12ULL), x536, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)16ULL), x537, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)20ULL), x538, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)24ULL), x539, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)28ULL), x540, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)32ULL), x541, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out3)+((uintptr_t)0ULL), x542, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)4ULL), x543, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)8ULL), x544, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)12ULL), x545, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)16ULL), x546, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)20ULL), x547, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)24ULL), x548, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)28ULL), x549, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out4)+((uintptr_t)0ULL), x550, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)4ULL), x551, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)8ULL), x552, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)12ULL), x553, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)16ULL), x554, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)20ULL), x555, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)24ULL), x556, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)28ULL), x557, sizeof(uintptr_t)); + /*skip*/ + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_divstep(uint32_t* out1, uint32_t out2[9], uint32_t out3[9], uint32_t out4[8], uint32_t out5[8], uint32_t arg1, const uint32_t arg2[9], const uint32_t arg3[9], const uint32_t arg4[8], const uint32_t arg5[8]) { + *out1 = (uint32_t)internal_fiat_p256_scalar_divstep((uintptr_t)out2, (uintptr_t)out3, (uintptr_t)out4, (uintptr_t)out5, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3, (uintptr_t)arg4, (uintptr_t)arg5); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p256_scalar_divstep_precomp(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7; + /*skip*/ + x0 = (uintptr_t)3086810037ULL; + x1 = (uintptr_t)3610846767ULL; + x2 = (uintptr_t)537347092ULL; + x3 = (uintptr_t)2328295261ULL; + x4 = (uintptr_t)3051602518ULL; + x5 = (uintptr_t)3329501375ULL; + x6 = (uintptr_t)3987189471ULL; + x7 = (uintptr_t)1145660146ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x7, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_divstep_precomp(uint32_t out1[8]) { + internal_fiat_p256_scalar_divstep_precomp((uintptr_t)out1); +} diff --git a/fiat-bedrock2/src/p256_scalar_64.c b/fiat-bedrock2/src/p256_scalar_64.c new file mode 100644 index 0000000000..5f96fc23aa --- /dev/null +++ b/fiat-bedrock2/src/p256_scalar_64.c @@ -0,0 +1,2163 @@ +/* Autogenerated: 'src/ExtractionOCaml/bedrock2_word_by_word_montgomery' --lang bedrock2 --static --no-wide-int --widen-carry --widen-bytes --split-multiret --no-select --no-field-element-typedefs p256_scalar 64 '2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: p256_scalar */ +/* machine_wordsize = 64 (from "64") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 (from "2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +#include + +// We use memcpy to work around -fstrict-aliasing. +// A plain memcpy is enough on clang 10, but not on gcc 10, which fails +// to infer the bounds on an integer loaded by memcpy. +// Adding a range mask after memcpy in turn makes slower code in clang. +// Loading individual bytes, shifting them together, and or-ing is fast +// on clang and sometimes on GCC, but other times GCC inlines individual +// byte operations without reconstructing wider accesses. +// The little-endian idiom below seems fast in gcc 9+ and clang 10. +static __attribute__((always_inline)) inline uintptr_t +_br2_load(uintptr_t a, uintptr_t sz) { + switch (sz) { + case 1: { uint8_t r = 0; memcpy(&r, (void*)a, 1); return r; } + case 2: { uint16_t r = 0; memcpy(&r, (void*)a, 2); return r; } + case 4: { uint32_t r = 0; memcpy(&r, (void*)a, 4); return r; } + case 8: { uint64_t r = 0; memcpy(&r, (void*)a, 8); return r; } + default: __builtin_unreachable(); + } +} + +static __attribute__((always_inline)) inline void +_br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) { + memcpy((void*)a, &v, sz); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p256_scalar_mul(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x1, x2, x3, x0, x11, x16, x19, x21, x17, x22, x14, x23, x25, x26, x15, x27, x12, x28, x30, x31, x13, x33, x38, x41, x43, x39, x44, x36, x45, x47, x48, x37, x49, x34, x50, x52, x53, x35, x40, x55, x18, x56, x20, x57, x42, x58, x60, x61, x24, x62, x46, x63, x65, x66, x29, x67, x51, x68, x70, x71, x32, x72, x54, x73, x75, x8, x81, x84, x86, x82, x87, x79, x88, x90, x91, x80, x92, x77, x93, x95, x96, x78, x83, x59, x99, x64, x100, x85, x101, x103, x104, x69, x105, x89, x106, x108, x109, x74, x110, x94, x111, x113, x114, x76, x115, x97, x116, x118, x120, x125, x128, x130, x126, x131, x123, x132, x134, x135, x124, x136, x121, x137, x139, x140, x122, x127, x142, x98, x143, x102, x144, x129, x145, x147, x148, x107, x149, x133, x150, x152, x153, x112, x154, x138, x155, x157, x158, x117, x159, x141, x160, x162, x163, x119, x9, x169, x172, x174, x170, x175, x167, x176, x178, x179, x168, x180, x165, x181, x183, x184, x166, x171, x146, x187, x151, x188, x173, x189, x191, x192, x156, x193, x177, x194, x196, x197, x161, x198, x182, x199, x201, x202, x164, x203, x185, x204, x206, x208, x213, x216, x218, x214, x219, x211, x220, x222, x223, x212, x224, x209, x225, x227, x228, x210, x215, x230, x186, x231, x190, x232, x217, x233, x235, x236, x195, x237, x221, x238, x240, x241, x200, x242, x226, x243, x245, x246, x205, x247, x229, x248, x250, x251, x207, x7, x6, x5, x10, x4, x257, x260, x262, x258, x263, x255, x264, x266, x267, x256, x268, x253, x269, x271, x272, x254, x259, x234, x275, x239, x276, x261, x277, x279, x280, x244, x281, x265, x282, x284, x285, x249, x286, x270, x287, x289, x290, x252, x291, x273, x292, x294, x296, x301, x304, x306, x302, x307, x299, x308, x310, x311, x300, x312, x297, x313, x315, x316, x298, x303, x318, x274, x319, x278, x320, x305, x321, x323, x324, x283, x325, x309, x326, x328, x329, x288, x330, x314, x331, x333, x334, x293, x335, x317, x336, x338, x339, x295, x342, x343, x344, x346, x347, x348, x349, x351, x352, x353, x354, x356, x357, x340, x358, x322, x360, x341, x361, x327, x363, x345, x364, x332, x366, x350, x367, x359, x337, x369, x355, x370, x362, x365, x368, x371, x372, x373, x374, x375; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x1; + x9 = x2; + x10 = x3; + x11 = x0; + x12 = (x11)*(x7); + x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x7))>>32 : ((__uint128_t)(x11)*(x7))>>64); + x14 = (x11)*(x6); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x6))>>32 : ((__uint128_t)(x11)*(x6))>>64); + x16 = (x11)*(x5); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x5))>>32 : ((__uint128_t)(x11)*(x5))>>64); + x18 = (x11)*(x4); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x4))>>32 : ((__uint128_t)(x11)*(x4))>>64); + x20 = (x19)+(x16); + x21 = (uintptr_t)((x20)<(x19)); + x22 = (x21)+(x17); + x23 = (uintptr_t)((x22)<(x17)); + x24 = (x22)+(x14); + x25 = (uintptr_t)((x24)<(x14)); + x26 = (x23)+(x25); + x27 = (x26)+(x15); + x28 = (uintptr_t)((x27)<(x15)); + x29 = (x27)+(x12); + x30 = (uintptr_t)((x29)<(x12)); + x31 = (x28)+(x30); + x32 = (x31)+(x13); + x33 = (x18)*((uintptr_t)14758798090332847183ULL); + x34 = (x33)*((uintptr_t)18446744069414584320ULL); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)18446744069414584320ULL))>>64); + x36 = (x33)*((uintptr_t)18446744073709551615ULL); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)18446744073709551615ULL))>>64); + x38 = (x33)*((uintptr_t)13611842547513532036ULL); + x39 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)13611842547513532036ULL))>>64); + x40 = (x33)*((uintptr_t)17562291160714782033ULL); + x41 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)17562291160714782033ULL))>>64); + x42 = (x41)+(x38); + x43 = (uintptr_t)((x42)<(x41)); + x44 = (x43)+(x39); + x45 = (uintptr_t)((x44)<(x39)); + x46 = (x44)+(x36); + x47 = (uintptr_t)((x46)<(x36)); + x48 = (x45)+(x47); + x49 = (x48)+(x37); + x50 = (uintptr_t)((x49)<(x37)); + x51 = (x49)+(x34); + x52 = (uintptr_t)((x51)<(x34)); + x53 = (x50)+(x52); + x54 = (x53)+(x35); + x55 = (x18)+(x40); + x56 = (uintptr_t)((x55)<(x18)); + x57 = (x56)+(x20); + x58 = (uintptr_t)((x57)<(x20)); + x59 = (x57)+(x42); + x60 = (uintptr_t)((x59)<(x42)); + x61 = (x58)+(x60); + x62 = (x61)+(x24); + x63 = (uintptr_t)((x62)<(x24)); + x64 = (x62)+(x46); + x65 = (uintptr_t)((x64)<(x46)); + x66 = (x63)+(x65); + x67 = (x66)+(x29); + x68 = (uintptr_t)((x67)<(x29)); + x69 = (x67)+(x51); + x70 = (uintptr_t)((x69)<(x51)); + x71 = (x68)+(x70); + x72 = (x71)+(x32); + x73 = (uintptr_t)((x72)<(x32)); + x74 = (x72)+(x54); + x75 = (uintptr_t)((x74)<(x54)); + x76 = (x73)+(x75); + x77 = (x8)*(x7); + x78 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x7))>>32 : ((__uint128_t)(x8)*(x7))>>64); + x79 = (x8)*(x6); + x80 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x6))>>32 : ((__uint128_t)(x8)*(x6))>>64); + x81 = (x8)*(x5); + x82 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x5))>>32 : ((__uint128_t)(x8)*(x5))>>64); + x83 = (x8)*(x4); + x84 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x4))>>32 : ((__uint128_t)(x8)*(x4))>>64); + x85 = (x84)+(x81); + x86 = (uintptr_t)((x85)<(x84)); + x87 = (x86)+(x82); + x88 = (uintptr_t)((x87)<(x82)); + x89 = (x87)+(x79); + x90 = (uintptr_t)((x89)<(x79)); + x91 = (x88)+(x90); + x92 = (x91)+(x80); + x93 = (uintptr_t)((x92)<(x80)); + x94 = (x92)+(x77); + x95 = (uintptr_t)((x94)<(x77)); + x96 = (x93)+(x95); + x97 = (x96)+(x78); + x98 = (x59)+(x83); + x99 = (uintptr_t)((x98)<(x59)); + x100 = (x99)+(x64); + x101 = (uintptr_t)((x100)<(x64)); + x102 = (x100)+(x85); + x103 = (uintptr_t)((x102)<(x85)); + x104 = (x101)+(x103); + x105 = (x104)+(x69); + x106 = (uintptr_t)((x105)<(x69)); + x107 = (x105)+(x89); + x108 = (uintptr_t)((x107)<(x89)); + x109 = (x106)+(x108); + x110 = (x109)+(x74); + x111 = (uintptr_t)((x110)<(x74)); + x112 = (x110)+(x94); + x113 = (uintptr_t)((x112)<(x94)); + x114 = (x111)+(x113); + x115 = (x114)+(x76); + x116 = (uintptr_t)((x115)<(x76)); + x117 = (x115)+(x97); + x118 = (uintptr_t)((x117)<(x97)); + x119 = (x116)+(x118); + x120 = (x98)*((uintptr_t)14758798090332847183ULL); + x121 = (x120)*((uintptr_t)18446744069414584320ULL); + x122 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x120)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x120)*((uintptr_t)18446744069414584320ULL))>>64); + x123 = (x120)*((uintptr_t)18446744073709551615ULL); + x124 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x120)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x120)*((uintptr_t)18446744073709551615ULL))>>64); + x125 = (x120)*((uintptr_t)13611842547513532036ULL); + x126 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x120)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x120)*((uintptr_t)13611842547513532036ULL))>>64); + x127 = (x120)*((uintptr_t)17562291160714782033ULL); + x128 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x120)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x120)*((uintptr_t)17562291160714782033ULL))>>64); + x129 = (x128)+(x125); + x130 = (uintptr_t)((x129)<(x128)); + x131 = (x130)+(x126); + x132 = (uintptr_t)((x131)<(x126)); + x133 = (x131)+(x123); + x134 = (uintptr_t)((x133)<(x123)); + x135 = (x132)+(x134); + x136 = (x135)+(x124); + x137 = (uintptr_t)((x136)<(x124)); + x138 = (x136)+(x121); + x139 = (uintptr_t)((x138)<(x121)); + x140 = (x137)+(x139); + x141 = (x140)+(x122); + x142 = (x98)+(x127); + x143 = (uintptr_t)((x142)<(x98)); + x144 = (x143)+(x102); + x145 = (uintptr_t)((x144)<(x102)); + x146 = (x144)+(x129); + x147 = (uintptr_t)((x146)<(x129)); + x148 = (x145)+(x147); + x149 = (x148)+(x107); + x150 = (uintptr_t)((x149)<(x107)); + x151 = (x149)+(x133); + x152 = (uintptr_t)((x151)<(x133)); + x153 = (x150)+(x152); + x154 = (x153)+(x112); + x155 = (uintptr_t)((x154)<(x112)); + x156 = (x154)+(x138); + x157 = (uintptr_t)((x156)<(x138)); + x158 = (x155)+(x157); + x159 = (x158)+(x117); + x160 = (uintptr_t)((x159)<(x117)); + x161 = (x159)+(x141); + x162 = (uintptr_t)((x161)<(x141)); + x163 = (x160)+(x162); + x164 = (x163)+(x119); + x165 = (x9)*(x7); + x166 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x7))>>32 : ((__uint128_t)(x9)*(x7))>>64); + x167 = (x9)*(x6); + x168 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x6))>>32 : ((__uint128_t)(x9)*(x6))>>64); + x169 = (x9)*(x5); + x170 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x5))>>32 : ((__uint128_t)(x9)*(x5))>>64); + x171 = (x9)*(x4); + x172 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x4))>>32 : ((__uint128_t)(x9)*(x4))>>64); + x173 = (x172)+(x169); + x174 = (uintptr_t)((x173)<(x172)); + x175 = (x174)+(x170); + x176 = (uintptr_t)((x175)<(x170)); + x177 = (x175)+(x167); + x178 = (uintptr_t)((x177)<(x167)); + x179 = (x176)+(x178); + x180 = (x179)+(x168); + x181 = (uintptr_t)((x180)<(x168)); + x182 = (x180)+(x165); + x183 = (uintptr_t)((x182)<(x165)); + x184 = (x181)+(x183); + x185 = (x184)+(x166); + x186 = (x146)+(x171); + x187 = (uintptr_t)((x186)<(x146)); + x188 = (x187)+(x151); + x189 = (uintptr_t)((x188)<(x151)); + x190 = (x188)+(x173); + x191 = (uintptr_t)((x190)<(x173)); + x192 = (x189)+(x191); + x193 = (x192)+(x156); + x194 = (uintptr_t)((x193)<(x156)); + x195 = (x193)+(x177); + x196 = (uintptr_t)((x195)<(x177)); + x197 = (x194)+(x196); + x198 = (x197)+(x161); + x199 = (uintptr_t)((x198)<(x161)); + x200 = (x198)+(x182); + x201 = (uintptr_t)((x200)<(x182)); + x202 = (x199)+(x201); + x203 = (x202)+(x164); + x204 = (uintptr_t)((x203)<(x164)); + x205 = (x203)+(x185); + x206 = (uintptr_t)((x205)<(x185)); + x207 = (x204)+(x206); + x208 = (x186)*((uintptr_t)14758798090332847183ULL); + x209 = (x208)*((uintptr_t)18446744069414584320ULL); + x210 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x208)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x208)*((uintptr_t)18446744069414584320ULL))>>64); + x211 = (x208)*((uintptr_t)18446744073709551615ULL); + x212 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x208)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x208)*((uintptr_t)18446744073709551615ULL))>>64); + x213 = (x208)*((uintptr_t)13611842547513532036ULL); + x214 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x208)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x208)*((uintptr_t)13611842547513532036ULL))>>64); + x215 = (x208)*((uintptr_t)17562291160714782033ULL); + x216 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x208)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x208)*((uintptr_t)17562291160714782033ULL))>>64); + x217 = (x216)+(x213); + x218 = (uintptr_t)((x217)<(x216)); + x219 = (x218)+(x214); + x220 = (uintptr_t)((x219)<(x214)); + x221 = (x219)+(x211); + x222 = (uintptr_t)((x221)<(x211)); + x223 = (x220)+(x222); + x224 = (x223)+(x212); + x225 = (uintptr_t)((x224)<(x212)); + x226 = (x224)+(x209); + x227 = (uintptr_t)((x226)<(x209)); + x228 = (x225)+(x227); + x229 = (x228)+(x210); + x230 = (x186)+(x215); + x231 = (uintptr_t)((x230)<(x186)); + x232 = (x231)+(x190); + x233 = (uintptr_t)((x232)<(x190)); + x234 = (x232)+(x217); + x235 = (uintptr_t)((x234)<(x217)); + x236 = (x233)+(x235); + x237 = (x236)+(x195); + x238 = (uintptr_t)((x237)<(x195)); + x239 = (x237)+(x221); + x240 = (uintptr_t)((x239)<(x221)); + x241 = (x238)+(x240); + x242 = (x241)+(x200); + x243 = (uintptr_t)((x242)<(x200)); + x244 = (x242)+(x226); + x245 = (uintptr_t)((x244)<(x226)); + x246 = (x243)+(x245); + x247 = (x246)+(x205); + x248 = (uintptr_t)((x247)<(x205)); + x249 = (x247)+(x229); + x250 = (uintptr_t)((x249)<(x229)); + x251 = (x248)+(x250); + x252 = (x251)+(x207); + x253 = (x10)*(x7); + x254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x7))>>32 : ((__uint128_t)(x10)*(x7))>>64); + x255 = (x10)*(x6); + x256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x6))>>32 : ((__uint128_t)(x10)*(x6))>>64); + x257 = (x10)*(x5); + x258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x5))>>32 : ((__uint128_t)(x10)*(x5))>>64); + x259 = (x10)*(x4); + x260 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x4))>>32 : ((__uint128_t)(x10)*(x4))>>64); + x261 = (x260)+(x257); + x262 = (uintptr_t)((x261)<(x260)); + x263 = (x262)+(x258); + x264 = (uintptr_t)((x263)<(x258)); + x265 = (x263)+(x255); + x266 = (uintptr_t)((x265)<(x255)); + x267 = (x264)+(x266); + x268 = (x267)+(x256); + x269 = (uintptr_t)((x268)<(x256)); + x270 = (x268)+(x253); + x271 = (uintptr_t)((x270)<(x253)); + x272 = (x269)+(x271); + x273 = (x272)+(x254); + x274 = (x234)+(x259); + x275 = (uintptr_t)((x274)<(x234)); + x276 = (x275)+(x239); + x277 = (uintptr_t)((x276)<(x239)); + x278 = (x276)+(x261); + x279 = (uintptr_t)((x278)<(x261)); + x280 = (x277)+(x279); + x281 = (x280)+(x244); + x282 = (uintptr_t)((x281)<(x244)); + x283 = (x281)+(x265); + x284 = (uintptr_t)((x283)<(x265)); + x285 = (x282)+(x284); + x286 = (x285)+(x249); + x287 = (uintptr_t)((x286)<(x249)); + x288 = (x286)+(x270); + x289 = (uintptr_t)((x288)<(x270)); + x290 = (x287)+(x289); + x291 = (x290)+(x252); + x292 = (uintptr_t)((x291)<(x252)); + x293 = (x291)+(x273); + x294 = (uintptr_t)((x293)<(x273)); + x295 = (x292)+(x294); + x296 = (x274)*((uintptr_t)14758798090332847183ULL); + x297 = (x296)*((uintptr_t)18446744069414584320ULL); + x298 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x296)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x296)*((uintptr_t)18446744069414584320ULL))>>64); + x299 = (x296)*((uintptr_t)18446744073709551615ULL); + x300 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x296)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x296)*((uintptr_t)18446744073709551615ULL))>>64); + x301 = (x296)*((uintptr_t)13611842547513532036ULL); + x302 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x296)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x296)*((uintptr_t)13611842547513532036ULL))>>64); + x303 = (x296)*((uintptr_t)17562291160714782033ULL); + x304 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x296)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x296)*((uintptr_t)17562291160714782033ULL))>>64); + x305 = (x304)+(x301); + x306 = (uintptr_t)((x305)<(x304)); + x307 = (x306)+(x302); + x308 = (uintptr_t)((x307)<(x302)); + x309 = (x307)+(x299); + x310 = (uintptr_t)((x309)<(x299)); + x311 = (x308)+(x310); + x312 = (x311)+(x300); + x313 = (uintptr_t)((x312)<(x300)); + x314 = (x312)+(x297); + x315 = (uintptr_t)((x314)<(x297)); + x316 = (x313)+(x315); + x317 = (x316)+(x298); + x318 = (x274)+(x303); + x319 = (uintptr_t)((x318)<(x274)); + x320 = (x319)+(x278); + x321 = (uintptr_t)((x320)<(x278)); + x322 = (x320)+(x305); + x323 = (uintptr_t)((x322)<(x305)); + x324 = (x321)+(x323); + x325 = (x324)+(x283); + x326 = (uintptr_t)((x325)<(x283)); + x327 = (x325)+(x309); + x328 = (uintptr_t)((x327)<(x309)); + x329 = (x326)+(x328); + x330 = (x329)+(x288); + x331 = (uintptr_t)((x330)<(x288)); + x332 = (x330)+(x314); + x333 = (uintptr_t)((x332)<(x314)); + x334 = (x331)+(x333); + x335 = (x334)+(x293); + x336 = (uintptr_t)((x335)<(x293)); + x337 = (x335)+(x317); + x338 = (uintptr_t)((x337)<(x317)); + x339 = (x336)+(x338); + x340 = (x339)+(x295); + x341 = (x322)-((uintptr_t)17562291160714782033ULL); + x342 = (uintptr_t)((x322)<(x341)); + x343 = (x327)-((uintptr_t)13611842547513532036ULL); + x344 = (uintptr_t)((x327)<(x343)); + x345 = (x343)-(x342); + x346 = (uintptr_t)((x343)<(x345)); + x347 = (x344)+(x346); + x348 = (x332)-((uintptr_t)18446744073709551615ULL); + x349 = (uintptr_t)((x332)<(x348)); + x350 = (x348)-(x347); + x351 = (uintptr_t)((x348)<(x350)); + x352 = (x349)+(x351); + x353 = (x337)-((uintptr_t)18446744069414584320ULL); + x354 = (uintptr_t)((x337)<(x353)); + x355 = (x353)-(x352); + x356 = (uintptr_t)((x353)<(x355)); + x357 = (x354)+(x356); + x358 = (x340)-(x357); + x359 = (uintptr_t)((x340)<(x358)); + x360 = ((uintptr_t)-1ULL)+((uintptr_t)((x359)==((uintptr_t)0ULL))); + x361 = (x360)^((uintptr_t)18446744073709551615ULL); + x362 = ((x322)&(x360))|((x341)&(x361)); + x363 = ((uintptr_t)-1ULL)+((uintptr_t)((x359)==((uintptr_t)0ULL))); + x364 = (x363)^((uintptr_t)18446744073709551615ULL); + x365 = ((x327)&(x363))|((x345)&(x364)); + x366 = ((uintptr_t)-1ULL)+((uintptr_t)((x359)==((uintptr_t)0ULL))); + x367 = (x366)^((uintptr_t)18446744073709551615ULL); + x368 = ((x332)&(x366))|((x350)&(x367)); + x369 = ((uintptr_t)-1ULL)+((uintptr_t)((x359)==((uintptr_t)0ULL))); + x370 = (x369)^((uintptr_t)18446744073709551615ULL); + x371 = ((x337)&(x369))|((x355)&(x370)); + x372 = x362; + x373 = x365; + x374 = x368; + x375 = x371; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x372, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x373, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x374, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x375, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_mul(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_p256_scalar_mul((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p256_scalar_square(uintptr_t out0, uintptr_t in0) { + uintptr_t x7, x12, x15, x17, x13, x18, x10, x19, x21, x22, x11, x23, x8, x24, x26, x27, x9, x29, x34, x37, x39, x35, x40, x32, x41, x43, x44, x33, x45, x30, x46, x48, x49, x31, x36, x51, x14, x52, x16, x53, x38, x54, x56, x57, x20, x58, x42, x59, x61, x62, x25, x63, x47, x64, x66, x67, x28, x68, x50, x69, x71, x4, x77, x80, x82, x78, x83, x75, x84, x86, x87, x76, x88, x73, x89, x91, x92, x74, x79, x55, x95, x60, x96, x81, x97, x99, x100, x65, x101, x85, x102, x104, x105, x70, x106, x90, x107, x109, x110, x72, x111, x93, x112, x114, x116, x121, x124, x126, x122, x127, x119, x128, x130, x131, x120, x132, x117, x133, x135, x136, x118, x123, x138, x94, x139, x98, x140, x125, x141, x143, x144, x103, x145, x129, x146, x148, x149, x108, x150, x134, x151, x153, x154, x113, x155, x137, x156, x158, x159, x115, x5, x165, x168, x170, x166, x171, x163, x172, x174, x175, x164, x176, x161, x177, x179, x180, x162, x167, x142, x183, x147, x184, x169, x185, x187, x188, x152, x189, x173, x190, x192, x193, x157, x194, x178, x195, x197, x198, x160, x199, x181, x200, x202, x204, x209, x212, x214, x210, x215, x207, x216, x218, x219, x208, x220, x205, x221, x223, x224, x206, x211, x226, x182, x227, x186, x228, x213, x229, x231, x232, x191, x233, x217, x234, x236, x237, x196, x238, x222, x239, x241, x242, x201, x243, x225, x244, x246, x247, x203, x3, x2, x1, x6, x0, x253, x256, x258, x254, x259, x251, x260, x262, x263, x252, x264, x249, x265, x267, x268, x250, x255, x230, x271, x235, x272, x257, x273, x275, x276, x240, x277, x261, x278, x280, x281, x245, x282, x266, x283, x285, x286, x248, x287, x269, x288, x290, x292, x297, x300, x302, x298, x303, x295, x304, x306, x307, x296, x308, x293, x309, x311, x312, x294, x299, x314, x270, x315, x274, x316, x301, x317, x319, x320, x279, x321, x305, x322, x324, x325, x284, x326, x310, x327, x329, x330, x289, x331, x313, x332, x334, x335, x291, x338, x339, x340, x342, x343, x344, x345, x347, x348, x349, x350, x352, x353, x336, x354, x318, x356, x337, x357, x323, x359, x341, x360, x328, x362, x346, x363, x355, x333, x365, x351, x366, x358, x361, x364, x367, x368, x369, x370, x371; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x1; + x5 = x2; + x6 = x3; + x7 = x0; + x8 = (x7)*(x3); + x9 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x3))>>32 : ((__uint128_t)(x7)*(x3))>>64); + x10 = (x7)*(x2); + x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x2))>>32 : ((__uint128_t)(x7)*(x2))>>64); + x12 = (x7)*(x1); + x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x1))>>32 : ((__uint128_t)(x7)*(x1))>>64); + x14 = (x7)*(x0); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x0))>>32 : ((__uint128_t)(x7)*(x0))>>64); + x16 = (x15)+(x12); + x17 = (uintptr_t)((x16)<(x15)); + x18 = (x17)+(x13); + x19 = (uintptr_t)((x18)<(x13)); + x20 = (x18)+(x10); + x21 = (uintptr_t)((x20)<(x10)); + x22 = (x19)+(x21); + x23 = (x22)+(x11); + x24 = (uintptr_t)((x23)<(x11)); + x25 = (x23)+(x8); + x26 = (uintptr_t)((x25)<(x8)); + x27 = (x24)+(x26); + x28 = (x27)+(x9); + x29 = (x14)*((uintptr_t)14758798090332847183ULL); + x30 = (x29)*((uintptr_t)18446744069414584320ULL); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x29)*((uintptr_t)18446744069414584320ULL))>>64); + x32 = (x29)*((uintptr_t)18446744073709551615ULL); + x33 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x29)*((uintptr_t)18446744073709551615ULL))>>64); + x34 = (x29)*((uintptr_t)13611842547513532036ULL); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x29)*((uintptr_t)13611842547513532036ULL))>>64); + x36 = (x29)*((uintptr_t)17562291160714782033ULL); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x29)*((uintptr_t)17562291160714782033ULL))>>64); + x38 = (x37)+(x34); + x39 = (uintptr_t)((x38)<(x37)); + x40 = (x39)+(x35); + x41 = (uintptr_t)((x40)<(x35)); + x42 = (x40)+(x32); + x43 = (uintptr_t)((x42)<(x32)); + x44 = (x41)+(x43); + x45 = (x44)+(x33); + x46 = (uintptr_t)((x45)<(x33)); + x47 = (x45)+(x30); + x48 = (uintptr_t)((x47)<(x30)); + x49 = (x46)+(x48); + x50 = (x49)+(x31); + x51 = (x14)+(x36); + x52 = (uintptr_t)((x51)<(x14)); + x53 = (x52)+(x16); + x54 = (uintptr_t)((x53)<(x16)); + x55 = (x53)+(x38); + x56 = (uintptr_t)((x55)<(x38)); + x57 = (x54)+(x56); + x58 = (x57)+(x20); + x59 = (uintptr_t)((x58)<(x20)); + x60 = (x58)+(x42); + x61 = (uintptr_t)((x60)<(x42)); + x62 = (x59)+(x61); + x63 = (x62)+(x25); + x64 = (uintptr_t)((x63)<(x25)); + x65 = (x63)+(x47); + x66 = (uintptr_t)((x65)<(x47)); + x67 = (x64)+(x66); + x68 = (x67)+(x28); + x69 = (uintptr_t)((x68)<(x28)); + x70 = (x68)+(x50); + x71 = (uintptr_t)((x70)<(x50)); + x72 = (x69)+(x71); + x73 = (x4)*(x3); + x74 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*(x3))>>32 : ((__uint128_t)(x4)*(x3))>>64); + x75 = (x4)*(x2); + x76 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*(x2))>>32 : ((__uint128_t)(x4)*(x2))>>64); + x77 = (x4)*(x1); + x78 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*(x1))>>32 : ((__uint128_t)(x4)*(x1))>>64); + x79 = (x4)*(x0); + x80 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*(x0))>>32 : ((__uint128_t)(x4)*(x0))>>64); + x81 = (x80)+(x77); + x82 = (uintptr_t)((x81)<(x80)); + x83 = (x82)+(x78); + x84 = (uintptr_t)((x83)<(x78)); + x85 = (x83)+(x75); + x86 = (uintptr_t)((x85)<(x75)); + x87 = (x84)+(x86); + x88 = (x87)+(x76); + x89 = (uintptr_t)((x88)<(x76)); + x90 = (x88)+(x73); + x91 = (uintptr_t)((x90)<(x73)); + x92 = (x89)+(x91); + x93 = (x92)+(x74); + x94 = (x55)+(x79); + x95 = (uintptr_t)((x94)<(x55)); + x96 = (x95)+(x60); + x97 = (uintptr_t)((x96)<(x60)); + x98 = (x96)+(x81); + x99 = (uintptr_t)((x98)<(x81)); + x100 = (x97)+(x99); + x101 = (x100)+(x65); + x102 = (uintptr_t)((x101)<(x65)); + x103 = (x101)+(x85); + x104 = (uintptr_t)((x103)<(x85)); + x105 = (x102)+(x104); + x106 = (x105)+(x70); + x107 = (uintptr_t)((x106)<(x70)); + x108 = (x106)+(x90); + x109 = (uintptr_t)((x108)<(x90)); + x110 = (x107)+(x109); + x111 = (x110)+(x72); + x112 = (uintptr_t)((x111)<(x72)); + x113 = (x111)+(x93); + x114 = (uintptr_t)((x113)<(x93)); + x115 = (x112)+(x114); + x116 = (x94)*((uintptr_t)14758798090332847183ULL); + x117 = (x116)*((uintptr_t)18446744069414584320ULL); + x118 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x116)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x116)*((uintptr_t)18446744069414584320ULL))>>64); + x119 = (x116)*((uintptr_t)18446744073709551615ULL); + x120 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x116)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x116)*((uintptr_t)18446744073709551615ULL))>>64); + x121 = (x116)*((uintptr_t)13611842547513532036ULL); + x122 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x116)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x116)*((uintptr_t)13611842547513532036ULL))>>64); + x123 = (x116)*((uintptr_t)17562291160714782033ULL); + x124 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x116)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x116)*((uintptr_t)17562291160714782033ULL))>>64); + x125 = (x124)+(x121); + x126 = (uintptr_t)((x125)<(x124)); + x127 = (x126)+(x122); + x128 = (uintptr_t)((x127)<(x122)); + x129 = (x127)+(x119); + x130 = (uintptr_t)((x129)<(x119)); + x131 = (x128)+(x130); + x132 = (x131)+(x120); + x133 = (uintptr_t)((x132)<(x120)); + x134 = (x132)+(x117); + x135 = (uintptr_t)((x134)<(x117)); + x136 = (x133)+(x135); + x137 = (x136)+(x118); + x138 = (x94)+(x123); + x139 = (uintptr_t)((x138)<(x94)); + x140 = (x139)+(x98); + x141 = (uintptr_t)((x140)<(x98)); + x142 = (x140)+(x125); + x143 = (uintptr_t)((x142)<(x125)); + x144 = (x141)+(x143); + x145 = (x144)+(x103); + x146 = (uintptr_t)((x145)<(x103)); + x147 = (x145)+(x129); + x148 = (uintptr_t)((x147)<(x129)); + x149 = (x146)+(x148); + x150 = (x149)+(x108); + x151 = (uintptr_t)((x150)<(x108)); + x152 = (x150)+(x134); + x153 = (uintptr_t)((x152)<(x134)); + x154 = (x151)+(x153); + x155 = (x154)+(x113); + x156 = (uintptr_t)((x155)<(x113)); + x157 = (x155)+(x137); + x158 = (uintptr_t)((x157)<(x137)); + x159 = (x156)+(x158); + x160 = (x159)+(x115); + x161 = (x5)*(x3); + x162 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*(x3))>>32 : ((__uint128_t)(x5)*(x3))>>64); + x163 = (x5)*(x2); + x164 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*(x2))>>32 : ((__uint128_t)(x5)*(x2))>>64); + x165 = (x5)*(x1); + x166 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*(x1))>>32 : ((__uint128_t)(x5)*(x1))>>64); + x167 = (x5)*(x0); + x168 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*(x0))>>32 : ((__uint128_t)(x5)*(x0))>>64); + x169 = (x168)+(x165); + x170 = (uintptr_t)((x169)<(x168)); + x171 = (x170)+(x166); + x172 = (uintptr_t)((x171)<(x166)); + x173 = (x171)+(x163); + x174 = (uintptr_t)((x173)<(x163)); + x175 = (x172)+(x174); + x176 = (x175)+(x164); + x177 = (uintptr_t)((x176)<(x164)); + x178 = (x176)+(x161); + x179 = (uintptr_t)((x178)<(x161)); + x180 = (x177)+(x179); + x181 = (x180)+(x162); + x182 = (x142)+(x167); + x183 = (uintptr_t)((x182)<(x142)); + x184 = (x183)+(x147); + x185 = (uintptr_t)((x184)<(x147)); + x186 = (x184)+(x169); + x187 = (uintptr_t)((x186)<(x169)); + x188 = (x185)+(x187); + x189 = (x188)+(x152); + x190 = (uintptr_t)((x189)<(x152)); + x191 = (x189)+(x173); + x192 = (uintptr_t)((x191)<(x173)); + x193 = (x190)+(x192); + x194 = (x193)+(x157); + x195 = (uintptr_t)((x194)<(x157)); + x196 = (x194)+(x178); + x197 = (uintptr_t)((x196)<(x178)); + x198 = (x195)+(x197); + x199 = (x198)+(x160); + x200 = (uintptr_t)((x199)<(x160)); + x201 = (x199)+(x181); + x202 = (uintptr_t)((x201)<(x181)); + x203 = (x200)+(x202); + x204 = (x182)*((uintptr_t)14758798090332847183ULL); + x205 = (x204)*((uintptr_t)18446744069414584320ULL); + x206 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x204)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x204)*((uintptr_t)18446744069414584320ULL))>>64); + x207 = (x204)*((uintptr_t)18446744073709551615ULL); + x208 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x204)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x204)*((uintptr_t)18446744073709551615ULL))>>64); + x209 = (x204)*((uintptr_t)13611842547513532036ULL); + x210 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x204)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x204)*((uintptr_t)13611842547513532036ULL))>>64); + x211 = (x204)*((uintptr_t)17562291160714782033ULL); + x212 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x204)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x204)*((uintptr_t)17562291160714782033ULL))>>64); + x213 = (x212)+(x209); + x214 = (uintptr_t)((x213)<(x212)); + x215 = (x214)+(x210); + x216 = (uintptr_t)((x215)<(x210)); + x217 = (x215)+(x207); + x218 = (uintptr_t)((x217)<(x207)); + x219 = (x216)+(x218); + x220 = (x219)+(x208); + x221 = (uintptr_t)((x220)<(x208)); + x222 = (x220)+(x205); + x223 = (uintptr_t)((x222)<(x205)); + x224 = (x221)+(x223); + x225 = (x224)+(x206); + x226 = (x182)+(x211); + x227 = (uintptr_t)((x226)<(x182)); + x228 = (x227)+(x186); + x229 = (uintptr_t)((x228)<(x186)); + x230 = (x228)+(x213); + x231 = (uintptr_t)((x230)<(x213)); + x232 = (x229)+(x231); + x233 = (x232)+(x191); + x234 = (uintptr_t)((x233)<(x191)); + x235 = (x233)+(x217); + x236 = (uintptr_t)((x235)<(x217)); + x237 = (x234)+(x236); + x238 = (x237)+(x196); + x239 = (uintptr_t)((x238)<(x196)); + x240 = (x238)+(x222); + x241 = (uintptr_t)((x240)<(x222)); + x242 = (x239)+(x241); + x243 = (x242)+(x201); + x244 = (uintptr_t)((x243)<(x201)); + x245 = (x243)+(x225); + x246 = (uintptr_t)((x245)<(x225)); + x247 = (x244)+(x246); + x248 = (x247)+(x203); + x249 = (x6)*(x3); + x250 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x3))>>32 : ((__uint128_t)(x6)*(x3))>>64); + x251 = (x6)*(x2); + x252 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x2))>>32 : ((__uint128_t)(x6)*(x2))>>64); + x253 = (x6)*(x1); + x254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x1))>>32 : ((__uint128_t)(x6)*(x1))>>64); + x255 = (x6)*(x0); + x256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x0))>>32 : ((__uint128_t)(x6)*(x0))>>64); + x257 = (x256)+(x253); + x258 = (uintptr_t)((x257)<(x256)); + x259 = (x258)+(x254); + x260 = (uintptr_t)((x259)<(x254)); + x261 = (x259)+(x251); + x262 = (uintptr_t)((x261)<(x251)); + x263 = (x260)+(x262); + x264 = (x263)+(x252); + x265 = (uintptr_t)((x264)<(x252)); + x266 = (x264)+(x249); + x267 = (uintptr_t)((x266)<(x249)); + x268 = (x265)+(x267); + x269 = (x268)+(x250); + x270 = (x230)+(x255); + x271 = (uintptr_t)((x270)<(x230)); + x272 = (x271)+(x235); + x273 = (uintptr_t)((x272)<(x235)); + x274 = (x272)+(x257); + x275 = (uintptr_t)((x274)<(x257)); + x276 = (x273)+(x275); + x277 = (x276)+(x240); + x278 = (uintptr_t)((x277)<(x240)); + x279 = (x277)+(x261); + x280 = (uintptr_t)((x279)<(x261)); + x281 = (x278)+(x280); + x282 = (x281)+(x245); + x283 = (uintptr_t)((x282)<(x245)); + x284 = (x282)+(x266); + x285 = (uintptr_t)((x284)<(x266)); + x286 = (x283)+(x285); + x287 = (x286)+(x248); + x288 = (uintptr_t)((x287)<(x248)); + x289 = (x287)+(x269); + x290 = (uintptr_t)((x289)<(x269)); + x291 = (x288)+(x290); + x292 = (x270)*((uintptr_t)14758798090332847183ULL); + x293 = (x292)*((uintptr_t)18446744069414584320ULL); + x294 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x292)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x292)*((uintptr_t)18446744069414584320ULL))>>64); + x295 = (x292)*((uintptr_t)18446744073709551615ULL); + x296 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x292)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x292)*((uintptr_t)18446744073709551615ULL))>>64); + x297 = (x292)*((uintptr_t)13611842547513532036ULL); + x298 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x292)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x292)*((uintptr_t)13611842547513532036ULL))>>64); + x299 = (x292)*((uintptr_t)17562291160714782033ULL); + x300 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x292)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x292)*((uintptr_t)17562291160714782033ULL))>>64); + x301 = (x300)+(x297); + x302 = (uintptr_t)((x301)<(x300)); + x303 = (x302)+(x298); + x304 = (uintptr_t)((x303)<(x298)); + x305 = (x303)+(x295); + x306 = (uintptr_t)((x305)<(x295)); + x307 = (x304)+(x306); + x308 = (x307)+(x296); + x309 = (uintptr_t)((x308)<(x296)); + x310 = (x308)+(x293); + x311 = (uintptr_t)((x310)<(x293)); + x312 = (x309)+(x311); + x313 = (x312)+(x294); + x314 = (x270)+(x299); + x315 = (uintptr_t)((x314)<(x270)); + x316 = (x315)+(x274); + x317 = (uintptr_t)((x316)<(x274)); + x318 = (x316)+(x301); + x319 = (uintptr_t)((x318)<(x301)); + x320 = (x317)+(x319); + x321 = (x320)+(x279); + x322 = (uintptr_t)((x321)<(x279)); + x323 = (x321)+(x305); + x324 = (uintptr_t)((x323)<(x305)); + x325 = (x322)+(x324); + x326 = (x325)+(x284); + x327 = (uintptr_t)((x326)<(x284)); + x328 = (x326)+(x310); + x329 = (uintptr_t)((x328)<(x310)); + x330 = (x327)+(x329); + x331 = (x330)+(x289); + x332 = (uintptr_t)((x331)<(x289)); + x333 = (x331)+(x313); + x334 = (uintptr_t)((x333)<(x313)); + x335 = (x332)+(x334); + x336 = (x335)+(x291); + x337 = (x318)-((uintptr_t)17562291160714782033ULL); + x338 = (uintptr_t)((x318)<(x337)); + x339 = (x323)-((uintptr_t)13611842547513532036ULL); + x340 = (uintptr_t)((x323)<(x339)); + x341 = (x339)-(x338); + x342 = (uintptr_t)((x339)<(x341)); + x343 = (x340)+(x342); + x344 = (x328)-((uintptr_t)18446744073709551615ULL); + x345 = (uintptr_t)((x328)<(x344)); + x346 = (x344)-(x343); + x347 = (uintptr_t)((x344)<(x346)); + x348 = (x345)+(x347); + x349 = (x333)-((uintptr_t)18446744069414584320ULL); + x350 = (uintptr_t)((x333)<(x349)); + x351 = (x349)-(x348); + x352 = (uintptr_t)((x349)<(x351)); + x353 = (x350)+(x352); + x354 = (x336)-(x353); + x355 = (uintptr_t)((x336)<(x354)); + x356 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x357 = (x356)^((uintptr_t)18446744073709551615ULL); + x358 = ((x318)&(x356))|((x337)&(x357)); + x359 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x360 = (x359)^((uintptr_t)18446744073709551615ULL); + x361 = ((x323)&(x359))|((x341)&(x360)); + x362 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x363 = (x362)^((uintptr_t)18446744073709551615ULL); + x364 = ((x328)&(x362))|((x346)&(x363)); + x365 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x366 = (x365)^((uintptr_t)18446744073709551615ULL); + x367 = ((x333)&(x365))|((x351)&(x366)); + x368 = x358; + x369 = x361; + x370 = x364; + x371 = x367; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x368, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x369, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x370, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x371, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_square(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_p256_scalar_square((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p256_scalar_add(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x4, x0, x9, x1, x5, x11, x2, x6, x13, x3, x7, x17, x19, x15, x21, x8, x24, x16, x25, x10, x27, x18, x28, x12, x30, x20, x31, x23, x14, x33, x22, x34, x26, x29, x32, x35, x36, x37, x38, x39; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = (x0)+(x4); + x9 = ((uintptr_t)((x8)<(x0)))+(x1); + x10 = (x9)+(x5); + x11 = (((uintptr_t)((x9)<(x1)))+((uintptr_t)((x10)<(x5))))+(x2); + x12 = (x11)+(x6); + x13 = (((uintptr_t)((x11)<(x2)))+((uintptr_t)((x12)<(x6))))+(x3); + x14 = (x13)+(x7); + x15 = ((uintptr_t)((x13)<(x3)))+((uintptr_t)((x14)<(x7))); + x16 = (x8)-((uintptr_t)17562291160714782033ULL); + x17 = (x10)-((uintptr_t)13611842547513532036ULL); + x18 = (x17)-((uintptr_t)((x8)<(x16))); + x19 = (x12)-((uintptr_t)18446744073709551615ULL); + x20 = (x19)-(((uintptr_t)((x10)<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = (x14)-((uintptr_t)18446744069414584320ULL); + x22 = (x21)-(((uintptr_t)((x12)<(x19)))+((uintptr_t)((x19)<(x20)))); + x23 = (uintptr_t)((x15)<((x15)-(((uintptr_t)((x14)<(x21)))+((uintptr_t)((x21)<(x22)))))); + x24 = ((uintptr_t)-1ULL)+((uintptr_t)((x23)==((uintptr_t)0ULL))); + x25 = (x24)^((uintptr_t)18446744073709551615ULL); + x26 = ((x8)&(x24))|((x16)&(x25)); + x27 = ((uintptr_t)-1ULL)+((uintptr_t)((x23)==((uintptr_t)0ULL))); + x28 = (x27)^((uintptr_t)18446744073709551615ULL); + x29 = ((x10)&(x27))|((x18)&(x28)); + x30 = ((uintptr_t)-1ULL)+((uintptr_t)((x23)==((uintptr_t)0ULL))); + x31 = (x30)^((uintptr_t)18446744073709551615ULL); + x32 = ((x12)&(x30))|((x20)&(x31)); + x33 = ((uintptr_t)-1ULL)+((uintptr_t)((x23)==((uintptr_t)0ULL))); + x34 = (x33)^((uintptr_t)18446744073709551615ULL); + x35 = ((x14)&(x33))|((x22)&(x34)); + x36 = x26; + x37 = x29; + x38 = x32; + x39 = x35; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x36, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x37, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x38, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x39, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_add(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_p256_scalar_add((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p256_scalar_sub(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x4, x5, x0, x6, x1, x9, x7, x2, x11, x3, x13, x8, x17, x10, x19, x12, x14, x15, x16, x18, x20, x21, x22, x23, x24, x25; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = (x0)-(x4); + x9 = (x1)-(x5); + x10 = (x9)-((uintptr_t)((x0)<(x8))); + x11 = (x2)-(x6); + x12 = (x11)-(((uintptr_t)((x1)<(x9)))+((uintptr_t)((x9)<(x10)))); + x13 = (x3)-(x7); + x14 = (x13)-(((uintptr_t)((x2)<(x11)))+((uintptr_t)((x11)<(x12)))); + x15 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)((x3)<(x13)))+((uintptr_t)((x13)<(x14))))==((uintptr_t)0ULL))); + x16 = (x8)+((x15)&((uintptr_t)17562291160714782033ULL)); + x17 = ((uintptr_t)((x16)<(x8)))+(x10); + x18 = (x17)+((x15)&((uintptr_t)13611842547513532036ULL)); + x19 = (((uintptr_t)((x17)<(x10)))+((uintptr_t)((x18)<((x15)&((uintptr_t)13611842547513532036ULL)))))+(x12); + x20 = (x19)+(x15); + x21 = ((((uintptr_t)((x19)<(x12)))+((uintptr_t)((x20)<(x15))))+(x14))+((x15)&((uintptr_t)18446744069414584320ULL)); + x22 = x16; + x23 = x18; + x24 = x20; + x25 = x21; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x22, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x23, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x24, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x25, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_sub(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_p256_scalar_sub((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p256_scalar_opp(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x1, x2, x5, x3, x7, x9, x4, x13, x6, x15, x8, x10, x11, x12, x14, x16, x17, x18, x19, x20, x21; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = ((uintptr_t)0ULL)-(x0); + x5 = ((uintptr_t)0ULL)-(x1); + x6 = (x5)-((uintptr_t)(((uintptr_t)0ULL)<(x4))); + x7 = ((uintptr_t)0ULL)-(x2); + x8 = (x7)-(((uintptr_t)(((uintptr_t)0ULL)<(x5)))+((uintptr_t)((x5)<(x6)))); + x9 = ((uintptr_t)0ULL)-(x3); + x10 = (x9)-(((uintptr_t)(((uintptr_t)0ULL)<(x7)))+((uintptr_t)((x7)<(x8)))); + x11 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)(((uintptr_t)0ULL)<(x9)))+((uintptr_t)((x9)<(x10))))==((uintptr_t)0ULL))); + x12 = (x4)+((x11)&((uintptr_t)17562291160714782033ULL)); + x13 = ((uintptr_t)((x12)<(x4)))+(x6); + x14 = (x13)+((x11)&((uintptr_t)13611842547513532036ULL)); + x15 = (((uintptr_t)((x13)<(x6)))+((uintptr_t)((x14)<((x11)&((uintptr_t)13611842547513532036ULL)))))+(x8); + x16 = (x15)+(x11); + x17 = ((((uintptr_t)((x15)<(x8)))+((uintptr_t)((x16)<(x11))))+(x10))+((x11)&((uintptr_t)18446744069414584320ULL)); + x18 = x12; + x19 = x14; + x20 = x16; + x21 = x17; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x18, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x19, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x20, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x21, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_opp(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_p256_scalar_opp((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p256_scalar_from_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x11, x13, x10, x8, x15, x9, x6, x5, x4, x12, x14, x16, x1, x18, x19, x20, x32, x34, x31, x29, x36, x30, x27, x26, x22, x39, x23, x33, x41, x24, x35, x43, x25, x21, x17, x7, x37, x2, x40, x42, x44, x56, x58, x55, x53, x60, x54, x51, x50, x46, x63, x47, x57, x65, x48, x59, x67, x49, x45, x38, x28, x61, x3, x64, x66, x68, x79, x81, x78, x76, x70, x85, x71, x80, x87, x72, x82, x89, x73, x69, x62, x52, x83, x77, x84, x75, x74, x93, x95, x97, x86, x100, x92, x101, x88, x103, x94, x104, x90, x106, x96, x107, x99, x91, x109, x98, x110, x102, x105, x108, x111, x112, x113, x114, x115; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x0; + x5 = (x4)*((uintptr_t)14758798090332847183ULL); + x6 = (x5)*((uintptr_t)18446744069414584320ULL); + x7 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)18446744069414584320ULL))>>64); + x8 = (x5)*((uintptr_t)18446744073709551615ULL); + x9 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)18446744073709551615ULL))>>64); + x10 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)13611842547513532036ULL))>>64); + x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)17562291160714782033ULL))>>64); + x12 = (x11)+((x5)*((uintptr_t)13611842547513532036ULL)); + x13 = ((uintptr_t)((x12)<(x11)))+(x10); + x14 = (x13)+(x8); + x15 = (((uintptr_t)((x13)<(x10)))+((uintptr_t)((x14)<(x8))))+(x9); + x16 = (x15)+(x6); + x17 = ((uintptr_t)((x15)<(x9)))+((uintptr_t)((x16)<(x6))); + x18 = ((uintptr_t)(((x4)+((x5)*((uintptr_t)17562291160714782033ULL)))<(x4)))+(x12); + x19 = ((uintptr_t)((x18)<(x12)))+(x14); + x20 = ((uintptr_t)((x19)<(x14)))+(x16); + x21 = (uintptr_t)((x20)<(x16)); + x22 = (x18)+(x1); + x23 = ((uintptr_t)((x22)<(x18)))+(x19); + x24 = ((uintptr_t)((x23)<(x19)))+(x20); + x25 = (uintptr_t)((x24)<(x20)); + x26 = (x22)*((uintptr_t)14758798090332847183ULL); + x27 = (x26)*((uintptr_t)18446744069414584320ULL); + x28 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x26)*((uintptr_t)18446744069414584320ULL))>>64); + x29 = (x26)*((uintptr_t)18446744073709551615ULL); + x30 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x26)*((uintptr_t)18446744073709551615ULL))>>64); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x26)*((uintptr_t)13611842547513532036ULL))>>64); + x32 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x26)*((uintptr_t)17562291160714782033ULL))>>64); + x33 = (x32)+((x26)*((uintptr_t)13611842547513532036ULL)); + x34 = ((uintptr_t)((x33)<(x32)))+(x31); + x35 = (x34)+(x29); + x36 = (((uintptr_t)((x34)<(x31)))+((uintptr_t)((x35)<(x29))))+(x30); + x37 = (x36)+(x27); + x38 = ((uintptr_t)((x36)<(x30)))+((uintptr_t)((x37)<(x27))); + x39 = ((uintptr_t)(((x22)+((x26)*((uintptr_t)17562291160714782033ULL)))<(x22)))+(x23); + x40 = (x39)+(x33); + x41 = (((uintptr_t)((x39)<(x23)))+((uintptr_t)((x40)<(x33))))+(x24); + x42 = (x41)+(x35); + x43 = (((uintptr_t)((x41)<(x24)))+((uintptr_t)((x42)<(x35))))+((x25)+((x21)+((x17)+(x7)))); + x44 = (x43)+(x37); + x45 = ((uintptr_t)((x43)<((x25)+((x21)+((x17)+(x7))))))+((uintptr_t)((x44)<(x37))); + x46 = (x40)+(x2); + x47 = ((uintptr_t)((x46)<(x40)))+(x42); + x48 = ((uintptr_t)((x47)<(x42)))+(x44); + x49 = (uintptr_t)((x48)<(x44)); + x50 = (x46)*((uintptr_t)14758798090332847183ULL); + x51 = (x50)*((uintptr_t)18446744069414584320ULL); + x52 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x50)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x50)*((uintptr_t)18446744069414584320ULL))>>64); + x53 = (x50)*((uintptr_t)18446744073709551615ULL); + x54 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x50)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x50)*((uintptr_t)18446744073709551615ULL))>>64); + x55 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x50)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x50)*((uintptr_t)13611842547513532036ULL))>>64); + x56 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x50)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x50)*((uintptr_t)17562291160714782033ULL))>>64); + x57 = (x56)+((x50)*((uintptr_t)13611842547513532036ULL)); + x58 = ((uintptr_t)((x57)<(x56)))+(x55); + x59 = (x58)+(x53); + x60 = (((uintptr_t)((x58)<(x55)))+((uintptr_t)((x59)<(x53))))+(x54); + x61 = (x60)+(x51); + x62 = ((uintptr_t)((x60)<(x54)))+((uintptr_t)((x61)<(x51))); + x63 = ((uintptr_t)(((x46)+((x50)*((uintptr_t)17562291160714782033ULL)))<(x46)))+(x47); + x64 = (x63)+(x57); + x65 = (((uintptr_t)((x63)<(x47)))+((uintptr_t)((x64)<(x57))))+(x48); + x66 = (x65)+(x59); + x67 = (((uintptr_t)((x65)<(x48)))+((uintptr_t)((x66)<(x59))))+((x49)+((x45)+((x38)+(x28)))); + x68 = (x67)+(x61); + x69 = ((uintptr_t)((x67)<((x49)+((x45)+((x38)+(x28))))))+((uintptr_t)((x68)<(x61))); + x70 = (x64)+(x3); + x71 = ((uintptr_t)((x70)<(x64)))+(x66); + x72 = ((uintptr_t)((x71)<(x66)))+(x68); + x73 = (uintptr_t)((x72)<(x68)); + x74 = (x70)*((uintptr_t)14758798090332847183ULL); + x75 = (x74)*((uintptr_t)18446744069414584320ULL); + x76 = (x74)*((uintptr_t)18446744073709551615ULL); + x77 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x74)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x74)*((uintptr_t)18446744073709551615ULL))>>64); + x78 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x74)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x74)*((uintptr_t)13611842547513532036ULL))>>64); + x79 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x74)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x74)*((uintptr_t)17562291160714782033ULL))>>64); + x80 = (x79)+((x74)*((uintptr_t)13611842547513532036ULL)); + x81 = ((uintptr_t)((x80)<(x79)))+(x78); + x82 = (x81)+(x76); + x83 = (((uintptr_t)((x81)<(x78)))+((uintptr_t)((x82)<(x76))))+(x77); + x84 = (x83)+(x75); + x85 = ((uintptr_t)(((x70)+((x74)*((uintptr_t)17562291160714782033ULL)))<(x70)))+(x71); + x86 = (x85)+(x80); + x87 = (((uintptr_t)((x85)<(x71)))+((uintptr_t)((x86)<(x80))))+(x72); + x88 = (x87)+(x82); + x89 = (((uintptr_t)((x87)<(x72)))+((uintptr_t)((x88)<(x82))))+((x73)+((x69)+((x62)+(x52)))); + x90 = (x89)+(x84); + x91 = (((uintptr_t)((x89)<((x73)+((x69)+((x62)+(x52))))))+((uintptr_t)((x90)<(x84))))+((((uintptr_t)((x83)<(x77)))+((uintptr_t)((x84)<(x75))))+((uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x74)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x74)*((uintptr_t)18446744069414584320ULL))>>64))); + x92 = (x86)-((uintptr_t)17562291160714782033ULL); + x93 = (x88)-((uintptr_t)13611842547513532036ULL); + x94 = (x93)-((uintptr_t)((x86)<(x92))); + x95 = (x90)-((uintptr_t)18446744073709551615ULL); + x96 = (x95)-(((uintptr_t)((x88)<(x93)))+((uintptr_t)((x93)<(x94)))); + x97 = (x91)-((uintptr_t)18446744069414584320ULL); + x98 = (x97)-(((uintptr_t)((x90)<(x95)))+((uintptr_t)((x95)<(x96)))); + x99 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(((uintptr_t)((x91)<(x97)))+((uintptr_t)((x97)<(x98)))))); + x100 = ((uintptr_t)-1ULL)+((uintptr_t)((x99)==((uintptr_t)0ULL))); + x101 = (x100)^((uintptr_t)18446744073709551615ULL); + x102 = ((x86)&(x100))|((x92)&(x101)); + x103 = ((uintptr_t)-1ULL)+((uintptr_t)((x99)==((uintptr_t)0ULL))); + x104 = (x103)^((uintptr_t)18446744073709551615ULL); + x105 = ((x88)&(x103))|((x94)&(x104)); + x106 = ((uintptr_t)-1ULL)+((uintptr_t)((x99)==((uintptr_t)0ULL))); + x107 = (x106)^((uintptr_t)18446744073709551615ULL); + x108 = ((x90)&(x106))|((x96)&(x107)); + x109 = ((uintptr_t)-1ULL)+((uintptr_t)((x99)==((uintptr_t)0ULL))); + x110 = (x109)^((uintptr_t)18446744073709551615ULL); + x111 = ((x91)&(x109))|((x98)&(x110)); + x112 = x102; + x113 = x105; + x114 = x108; + x115 = x111; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x112, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x113, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x114, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x115, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_from_montgomery(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_p256_scalar_from_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p256_scalar_to_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x1, x2, x3, x0, x7, x14, x16, x12, x10, x18, x11, x8, x27, x29, x26, x24, x31, x25, x22, x21, x13, x34, x15, x28, x36, x17, x30, x38, x19, x32, x40, x20, x9, x33, x23, x48, x50, x47, x45, x52, x46, x43, x4, x35, x56, x37, x49, x58, x39, x51, x60, x41, x53, x69, x71, x68, x66, x73, x67, x64, x63, x55, x76, x57, x70, x78, x59, x72, x80, x61, x74, x82, x62, x42, x54, x44, x75, x65, x90, x92, x89, x87, x94, x88, x85, x5, x77, x98, x79, x91, x100, x81, x93, x102, x83, x95, x111, x113, x110, x108, x115, x109, x106, x105, x97, x118, x99, x112, x120, x101, x114, x122, x103, x116, x124, x104, x84, x96, x86, x117, x107, x132, x134, x131, x129, x136, x130, x127, x6, x119, x140, x121, x133, x142, x123, x135, x144, x125, x137, x153, x155, x152, x150, x157, x151, x148, x147, x139, x160, x141, x154, x162, x143, x156, x164, x145, x158, x166, x146, x126, x138, x128, x159, x149, x170, x172, x168, x174, x161, x177, x169, x178, x163, x180, x171, x181, x165, x183, x173, x184, x176, x167, x186, x175, x187, x179, x182, x185, x188, x189, x190, x191, x192; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x1; + x5 = x2; + x6 = x3; + x7 = x0; + x8 = (x7)*((uintptr_t)7413256579398063648ULL); + x9 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)7413256579398063648ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)7413256579398063648ULL))>>64); + x10 = (x7)*((uintptr_t)2901921493521525849ULL); + x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)2901921493521525849ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)2901921493521525849ULL))>>64); + x12 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)5087230966250696614ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)5087230966250696614ULL))>>64); + x13 = (x7)*((uintptr_t)9449762124159643298ULL); + x14 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)9449762124159643298ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)9449762124159643298ULL))>>64); + x15 = (x14)+((x7)*((uintptr_t)5087230966250696614ULL)); + x16 = ((uintptr_t)((x15)<(x14)))+(x12); + x17 = (x16)+(x10); + x18 = (((uintptr_t)((x16)<(x12)))+((uintptr_t)((x17)<(x10))))+(x11); + x19 = (x18)+(x8); + x20 = ((uintptr_t)((x18)<(x11)))+((uintptr_t)((x19)<(x8))); + x21 = (x13)*((uintptr_t)14758798090332847183ULL); + x22 = (x21)*((uintptr_t)18446744069414584320ULL); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)18446744069414584320ULL))>>64); + x24 = (x21)*((uintptr_t)18446744073709551615ULL); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)18446744073709551615ULL))>>64); + x26 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)13611842547513532036ULL))>>64); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)17562291160714782033ULL))>>64); + x28 = (x27)+((x21)*((uintptr_t)13611842547513532036ULL)); + x29 = ((uintptr_t)((x28)<(x27)))+(x26); + x30 = (x29)+(x24); + x31 = (((uintptr_t)((x29)<(x26)))+((uintptr_t)((x30)<(x24))))+(x25); + x32 = (x31)+(x22); + x33 = ((uintptr_t)((x31)<(x25)))+((uintptr_t)((x32)<(x22))); + x34 = ((uintptr_t)(((x13)+((x21)*((uintptr_t)17562291160714782033ULL)))<(x13)))+(x15); + x35 = (x34)+(x28); + x36 = (((uintptr_t)((x34)<(x15)))+((uintptr_t)((x35)<(x28))))+(x17); + x37 = (x36)+(x30); + x38 = (((uintptr_t)((x36)<(x17)))+((uintptr_t)((x37)<(x30))))+(x19); + x39 = (x38)+(x32); + x40 = (((uintptr_t)((x38)<(x19)))+((uintptr_t)((x39)<(x32))))+((x20)+(x9)); + x41 = (x40)+((x33)+(x23)); + x42 = ((uintptr_t)((x40)<((x20)+(x9))))+((uintptr_t)((x41)<((x33)+(x23)))); + x43 = (x4)*((uintptr_t)7413256579398063648ULL); + x44 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*((uintptr_t)7413256579398063648ULL))>>32 : ((__uint128_t)(x4)*((uintptr_t)7413256579398063648ULL))>>64); + x45 = (x4)*((uintptr_t)2901921493521525849ULL); + x46 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*((uintptr_t)2901921493521525849ULL))>>32 : ((__uint128_t)(x4)*((uintptr_t)2901921493521525849ULL))>>64); + x47 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*((uintptr_t)5087230966250696614ULL))>>32 : ((__uint128_t)(x4)*((uintptr_t)5087230966250696614ULL))>>64); + x48 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*((uintptr_t)9449762124159643298ULL))>>32 : ((__uint128_t)(x4)*((uintptr_t)9449762124159643298ULL))>>64); + x49 = (x48)+((x4)*((uintptr_t)5087230966250696614ULL)); + x50 = ((uintptr_t)((x49)<(x48)))+(x47); + x51 = (x50)+(x45); + x52 = (((uintptr_t)((x50)<(x47)))+((uintptr_t)((x51)<(x45))))+(x46); + x53 = (x52)+(x43); + x54 = ((uintptr_t)((x52)<(x46)))+((uintptr_t)((x53)<(x43))); + x55 = (x35)+((x4)*((uintptr_t)9449762124159643298ULL)); + x56 = ((uintptr_t)((x55)<(x35)))+(x37); + x57 = (x56)+(x49); + x58 = (((uintptr_t)((x56)<(x37)))+((uintptr_t)((x57)<(x49))))+(x39); + x59 = (x58)+(x51); + x60 = (((uintptr_t)((x58)<(x39)))+((uintptr_t)((x59)<(x51))))+(x41); + x61 = (x60)+(x53); + x62 = ((uintptr_t)((x60)<(x41)))+((uintptr_t)((x61)<(x53))); + x63 = (x55)*((uintptr_t)14758798090332847183ULL); + x64 = (x63)*((uintptr_t)18446744069414584320ULL); + x65 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x63)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x63)*((uintptr_t)18446744069414584320ULL))>>64); + x66 = (x63)*((uintptr_t)18446744073709551615ULL); + x67 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x63)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x63)*((uintptr_t)18446744073709551615ULL))>>64); + x68 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x63)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x63)*((uintptr_t)13611842547513532036ULL))>>64); + x69 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x63)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x63)*((uintptr_t)17562291160714782033ULL))>>64); + x70 = (x69)+((x63)*((uintptr_t)13611842547513532036ULL)); + x71 = ((uintptr_t)((x70)<(x69)))+(x68); + x72 = (x71)+(x66); + x73 = (((uintptr_t)((x71)<(x68)))+((uintptr_t)((x72)<(x66))))+(x67); + x74 = (x73)+(x64); + x75 = ((uintptr_t)((x73)<(x67)))+((uintptr_t)((x74)<(x64))); + x76 = ((uintptr_t)(((x55)+((x63)*((uintptr_t)17562291160714782033ULL)))<(x55)))+(x57); + x77 = (x76)+(x70); + x78 = (((uintptr_t)((x76)<(x57)))+((uintptr_t)((x77)<(x70))))+(x59); + x79 = (x78)+(x72); + x80 = (((uintptr_t)((x78)<(x59)))+((uintptr_t)((x79)<(x72))))+(x61); + x81 = (x80)+(x74); + x82 = (((uintptr_t)((x80)<(x61)))+((uintptr_t)((x81)<(x74))))+(((x62)+(x42))+((x54)+(x44))); + x83 = (x82)+((x75)+(x65)); + x84 = ((uintptr_t)((x82)<(((x62)+(x42))+((x54)+(x44)))))+((uintptr_t)((x83)<((x75)+(x65)))); + x85 = (x5)*((uintptr_t)7413256579398063648ULL); + x86 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)7413256579398063648ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)7413256579398063648ULL))>>64); + x87 = (x5)*((uintptr_t)2901921493521525849ULL); + x88 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)2901921493521525849ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)2901921493521525849ULL))>>64); + x89 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)5087230966250696614ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)5087230966250696614ULL))>>64); + x90 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)9449762124159643298ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)9449762124159643298ULL))>>64); + x91 = (x90)+((x5)*((uintptr_t)5087230966250696614ULL)); + x92 = ((uintptr_t)((x91)<(x90)))+(x89); + x93 = (x92)+(x87); + x94 = (((uintptr_t)((x92)<(x89)))+((uintptr_t)((x93)<(x87))))+(x88); + x95 = (x94)+(x85); + x96 = ((uintptr_t)((x94)<(x88)))+((uintptr_t)((x95)<(x85))); + x97 = (x77)+((x5)*((uintptr_t)9449762124159643298ULL)); + x98 = ((uintptr_t)((x97)<(x77)))+(x79); + x99 = (x98)+(x91); + x100 = (((uintptr_t)((x98)<(x79)))+((uintptr_t)((x99)<(x91))))+(x81); + x101 = (x100)+(x93); + x102 = (((uintptr_t)((x100)<(x81)))+((uintptr_t)((x101)<(x93))))+(x83); + x103 = (x102)+(x95); + x104 = ((uintptr_t)((x102)<(x83)))+((uintptr_t)((x103)<(x95))); + x105 = (x97)*((uintptr_t)14758798090332847183ULL); + x106 = (x105)*((uintptr_t)18446744069414584320ULL); + x107 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x105)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x105)*((uintptr_t)18446744069414584320ULL))>>64); + x108 = (x105)*((uintptr_t)18446744073709551615ULL); + x109 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x105)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x105)*((uintptr_t)18446744073709551615ULL))>>64); + x110 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x105)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x105)*((uintptr_t)13611842547513532036ULL))>>64); + x111 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x105)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x105)*((uintptr_t)17562291160714782033ULL))>>64); + x112 = (x111)+((x105)*((uintptr_t)13611842547513532036ULL)); + x113 = ((uintptr_t)((x112)<(x111)))+(x110); + x114 = (x113)+(x108); + x115 = (((uintptr_t)((x113)<(x110)))+((uintptr_t)((x114)<(x108))))+(x109); + x116 = (x115)+(x106); + x117 = ((uintptr_t)((x115)<(x109)))+((uintptr_t)((x116)<(x106))); + x118 = ((uintptr_t)(((x97)+((x105)*((uintptr_t)17562291160714782033ULL)))<(x97)))+(x99); + x119 = (x118)+(x112); + x120 = (((uintptr_t)((x118)<(x99)))+((uintptr_t)((x119)<(x112))))+(x101); + x121 = (x120)+(x114); + x122 = (((uintptr_t)((x120)<(x101)))+((uintptr_t)((x121)<(x114))))+(x103); + x123 = (x122)+(x116); + x124 = (((uintptr_t)((x122)<(x103)))+((uintptr_t)((x123)<(x116))))+(((x104)+(x84))+((x96)+(x86))); + x125 = (x124)+((x117)+(x107)); + x126 = ((uintptr_t)((x124)<(((x104)+(x84))+((x96)+(x86)))))+((uintptr_t)((x125)<((x117)+(x107)))); + x127 = (x6)*((uintptr_t)7413256579398063648ULL); + x128 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)7413256579398063648ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)7413256579398063648ULL))>>64); + x129 = (x6)*((uintptr_t)2901921493521525849ULL); + x130 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)2901921493521525849ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)2901921493521525849ULL))>>64); + x131 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)5087230966250696614ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)5087230966250696614ULL))>>64); + x132 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)9449762124159643298ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)9449762124159643298ULL))>>64); + x133 = (x132)+((x6)*((uintptr_t)5087230966250696614ULL)); + x134 = ((uintptr_t)((x133)<(x132)))+(x131); + x135 = (x134)+(x129); + x136 = (((uintptr_t)((x134)<(x131)))+((uintptr_t)((x135)<(x129))))+(x130); + x137 = (x136)+(x127); + x138 = ((uintptr_t)((x136)<(x130)))+((uintptr_t)((x137)<(x127))); + x139 = (x119)+((x6)*((uintptr_t)9449762124159643298ULL)); + x140 = ((uintptr_t)((x139)<(x119)))+(x121); + x141 = (x140)+(x133); + x142 = (((uintptr_t)((x140)<(x121)))+((uintptr_t)((x141)<(x133))))+(x123); + x143 = (x142)+(x135); + x144 = (((uintptr_t)((x142)<(x123)))+((uintptr_t)((x143)<(x135))))+(x125); + x145 = (x144)+(x137); + x146 = ((uintptr_t)((x144)<(x125)))+((uintptr_t)((x145)<(x137))); + x147 = (x139)*((uintptr_t)14758798090332847183ULL); + x148 = (x147)*((uintptr_t)18446744069414584320ULL); + x149 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)18446744069414584320ULL))>>64); + x150 = (x147)*((uintptr_t)18446744073709551615ULL); + x151 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)18446744073709551615ULL))>>64); + x152 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)13611842547513532036ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)13611842547513532036ULL))>>64); + x153 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)17562291160714782033ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)17562291160714782033ULL))>>64); + x154 = (x153)+((x147)*((uintptr_t)13611842547513532036ULL)); + x155 = ((uintptr_t)((x154)<(x153)))+(x152); + x156 = (x155)+(x150); + x157 = (((uintptr_t)((x155)<(x152)))+((uintptr_t)((x156)<(x150))))+(x151); + x158 = (x157)+(x148); + x159 = ((uintptr_t)((x157)<(x151)))+((uintptr_t)((x158)<(x148))); + x160 = ((uintptr_t)(((x139)+((x147)*((uintptr_t)17562291160714782033ULL)))<(x139)))+(x141); + x161 = (x160)+(x154); + x162 = (((uintptr_t)((x160)<(x141)))+((uintptr_t)((x161)<(x154))))+(x143); + x163 = (x162)+(x156); + x164 = (((uintptr_t)((x162)<(x143)))+((uintptr_t)((x163)<(x156))))+(x145); + x165 = (x164)+(x158); + x166 = (((uintptr_t)((x164)<(x145)))+((uintptr_t)((x165)<(x158))))+(((x146)+(x126))+((x138)+(x128))); + x167 = (x166)+((x159)+(x149)); + x168 = ((uintptr_t)((x166)<(((x146)+(x126))+((x138)+(x128)))))+((uintptr_t)((x167)<((x159)+(x149)))); + x169 = (x161)-((uintptr_t)17562291160714782033ULL); + x170 = (x163)-((uintptr_t)13611842547513532036ULL); + x171 = (x170)-((uintptr_t)((x161)<(x169))); + x172 = (x165)-((uintptr_t)18446744073709551615ULL); + x173 = (x172)-(((uintptr_t)((x163)<(x170)))+((uintptr_t)((x170)<(x171)))); + x174 = (x167)-((uintptr_t)18446744069414584320ULL); + x175 = (x174)-(((uintptr_t)((x165)<(x172)))+((uintptr_t)((x172)<(x173)))); + x176 = (uintptr_t)((x168)<((x168)-(((uintptr_t)((x167)<(x174)))+((uintptr_t)((x174)<(x175)))))); + x177 = ((uintptr_t)-1ULL)+((uintptr_t)((x176)==((uintptr_t)0ULL))); + x178 = (x177)^((uintptr_t)18446744073709551615ULL); + x179 = ((x161)&(x177))|((x169)&(x178)); + x180 = ((uintptr_t)-1ULL)+((uintptr_t)((x176)==((uintptr_t)0ULL))); + x181 = (x180)^((uintptr_t)18446744073709551615ULL); + x182 = ((x163)&(x180))|((x171)&(x181)); + x183 = ((uintptr_t)-1ULL)+((uintptr_t)((x176)==((uintptr_t)0ULL))); + x184 = (x183)^((uintptr_t)18446744073709551615ULL); + x185 = ((x165)&(x183))|((x173)&(x184)); + x186 = ((uintptr_t)-1ULL)+((uintptr_t)((x176)==((uintptr_t)0ULL))); + x187 = (x186)^((uintptr_t)18446744073709551615ULL); + x188 = ((x167)&(x186))|((x175)&(x187)); + x189 = x179; + x190 = x182; + x191 = x185; + x192 = x188; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x189, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x190, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x191, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x192, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_to_montgomery(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_p256_scalar_to_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffffffffffff] + */ +static +uintptr_t internal_fiat_p256_scalar_nonzero(uintptr_t in0) { + uintptr_t x0, x1, x2, x3, x4, out0, x5; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = (x0)|((x1)|((x2)|(x3))); + x5 = x4; + out0 = x5; + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_nonzero(uint64_t* out1, const uint64_t arg1[4]) { + *out1 = (uint64_t)internal_fiat_p256_scalar_nonzero((uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0x1] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p256_scalar_selectznz(uintptr_t out0, uintptr_t in0, uintptr_t in1, uintptr_t in2) { + uintptr_t x4, x8, x0, x9, x5, x11, x1, x12, x6, x14, x2, x15, x7, x17, x3, x18, x10, x13, x16, x19, x20, x21, x22, x23; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x5 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x6 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x7 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x9 = (x8)^((uintptr_t)18446744073709551615ULL); + x10 = ((x4)&(x8))|((x0)&(x9)); + x11 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x12 = (x11)^((uintptr_t)18446744073709551615ULL); + x13 = ((x5)&(x11))|((x1)&(x12)); + x14 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x15 = (x14)^((uintptr_t)18446744073709551615ULL); + x16 = ((x6)&(x14))|((x2)&(x15)); + x17 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x18 = (x17)^((uintptr_t)18446744073709551615ULL); + x19 = ((x7)&(x17))|((x3)&(x18)); + x20 = x10; + x21 = x13; + x22 = x16; + x23 = x19; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x20, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x21, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x22, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x23, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_selectznz(uint64_t out1[4], uint8_t arg1, const uint64_t arg2[4], const uint64_t arg3[4]) { + internal_fiat_p256_scalar_selectznz((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static +void internal_fiat_p256_scalar_to_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x3, x2, x1, x0, x7, x9, x11, x13, x15, x17, x19, x6, x23, x25, x27, x29, x31, x33, x5, x37, x39, x41, x43, x45, x47, x4, x51, x53, x55, x57, x59, x61, x8, x10, x12, x14, x16, x18, x20, x21, x22, x24, x26, x28, x30, x32, x34, x35, x36, x38, x40, x42, x44, x46, x48, x49, x50, x52, x54, x56, x58, x60, x62, x63, x64, x65, x66, x67, x68, x69, x70, x71, x72, x73, x74, x75, x76, x77, x78, x79, x80, x81, x82, x83, x84, x85, x86, x87, x88, x89, x90, x91, x92, x93, x94, x95; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x3; + x5 = x2; + x6 = x1; + x7 = x0; + x8 = (x7)&((uintptr_t)255ULL); + x9 = (x7)>>((uintptr_t)8ULL); + x10 = (x9)&((uintptr_t)255ULL); + x11 = (x9)>>((uintptr_t)8ULL); + x12 = (x11)&((uintptr_t)255ULL); + x13 = (x11)>>((uintptr_t)8ULL); + x14 = (x13)&((uintptr_t)255ULL); + x15 = (x13)>>((uintptr_t)8ULL); + x16 = (x15)&((uintptr_t)255ULL); + x17 = (x15)>>((uintptr_t)8ULL); + x18 = (x17)&((uintptr_t)255ULL); + x19 = (x17)>>((uintptr_t)8ULL); + x20 = (x19)&((uintptr_t)255ULL); + x21 = (x19)>>((uintptr_t)8ULL); + x22 = (x6)&((uintptr_t)255ULL); + x23 = (x6)>>((uintptr_t)8ULL); + x24 = (x23)&((uintptr_t)255ULL); + x25 = (x23)>>((uintptr_t)8ULL); + x26 = (x25)&((uintptr_t)255ULL); + x27 = (x25)>>((uintptr_t)8ULL); + x28 = (x27)&((uintptr_t)255ULL); + x29 = (x27)>>((uintptr_t)8ULL); + x30 = (x29)&((uintptr_t)255ULL); + x31 = (x29)>>((uintptr_t)8ULL); + x32 = (x31)&((uintptr_t)255ULL); + x33 = (x31)>>((uintptr_t)8ULL); + x34 = (x33)&((uintptr_t)255ULL); + x35 = (x33)>>((uintptr_t)8ULL); + x36 = (x5)&((uintptr_t)255ULL); + x37 = (x5)>>((uintptr_t)8ULL); + x38 = (x37)&((uintptr_t)255ULL); + x39 = (x37)>>((uintptr_t)8ULL); + x40 = (x39)&((uintptr_t)255ULL); + x41 = (x39)>>((uintptr_t)8ULL); + x42 = (x41)&((uintptr_t)255ULL); + x43 = (x41)>>((uintptr_t)8ULL); + x44 = (x43)&((uintptr_t)255ULL); + x45 = (x43)>>((uintptr_t)8ULL); + x46 = (x45)&((uintptr_t)255ULL); + x47 = (x45)>>((uintptr_t)8ULL); + x48 = (x47)&((uintptr_t)255ULL); + x49 = (x47)>>((uintptr_t)8ULL); + x50 = (x4)&((uintptr_t)255ULL); + x51 = (x4)>>((uintptr_t)8ULL); + x52 = (x51)&((uintptr_t)255ULL); + x53 = (x51)>>((uintptr_t)8ULL); + x54 = (x53)&((uintptr_t)255ULL); + x55 = (x53)>>((uintptr_t)8ULL); + x56 = (x55)&((uintptr_t)255ULL); + x57 = (x55)>>((uintptr_t)8ULL); + x58 = (x57)&((uintptr_t)255ULL); + x59 = (x57)>>((uintptr_t)8ULL); + x60 = (x59)&((uintptr_t)255ULL); + x61 = (x59)>>((uintptr_t)8ULL); + x62 = (x61)&((uintptr_t)255ULL); + x63 = (x61)>>((uintptr_t)8ULL); + x64 = x8; + x65 = x10; + x66 = x12; + x67 = x14; + x68 = x16; + x69 = x18; + x70 = x20; + x71 = x21; + x72 = x22; + x73 = x24; + x74 = x26; + x75 = x28; + x76 = x30; + x77 = x32; + x78 = x34; + x79 = x35; + x80 = x36; + x81 = x38; + x82 = x40; + x83 = x42; + x84 = x44; + x85 = x46; + x86 = x48; + x87 = x49; + x88 = x50; + x89 = x52; + x90 = x54; + x91 = x56; + x92 = x58; + x93 = x60; + x94 = x62; + x95 = x63; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x64, 1); + _br2_store((out0)+((uintptr_t)1ULL), x65, 1); + _br2_store((out0)+((uintptr_t)2ULL), x66, 1); + _br2_store((out0)+((uintptr_t)3ULL), x67, 1); + _br2_store((out0)+((uintptr_t)4ULL), x68, 1); + _br2_store((out0)+((uintptr_t)5ULL), x69, 1); + _br2_store((out0)+((uintptr_t)6ULL), x70, 1); + _br2_store((out0)+((uintptr_t)7ULL), x71, 1); + _br2_store((out0)+((uintptr_t)8ULL), x72, 1); + _br2_store((out0)+((uintptr_t)9ULL), x73, 1); + _br2_store((out0)+((uintptr_t)10ULL), x74, 1); + _br2_store((out0)+((uintptr_t)11ULL), x75, 1); + _br2_store((out0)+((uintptr_t)12ULL), x76, 1); + _br2_store((out0)+((uintptr_t)13ULL), x77, 1); + _br2_store((out0)+((uintptr_t)14ULL), x78, 1); + _br2_store((out0)+((uintptr_t)15ULL), x79, 1); + _br2_store((out0)+((uintptr_t)16ULL), x80, 1); + _br2_store((out0)+((uintptr_t)17ULL), x81, 1); + _br2_store((out0)+((uintptr_t)18ULL), x82, 1); + _br2_store((out0)+((uintptr_t)19ULL), x83, 1); + _br2_store((out0)+((uintptr_t)20ULL), x84, 1); + _br2_store((out0)+((uintptr_t)21ULL), x85, 1); + _br2_store((out0)+((uintptr_t)22ULL), x86, 1); + _br2_store((out0)+((uintptr_t)23ULL), x87, 1); + _br2_store((out0)+((uintptr_t)24ULL), x88, 1); + _br2_store((out0)+((uintptr_t)25ULL), x89, 1); + _br2_store((out0)+((uintptr_t)26ULL), x90, 1); + _br2_store((out0)+((uintptr_t)27ULL), x91, 1); + _br2_store((out0)+((uintptr_t)28ULL), x92, 1); + _br2_store((out0)+((uintptr_t)29ULL), x93, 1); + _br2_store((out0)+((uintptr_t)30ULL), x94, 1); + _br2_store((out0)+((uintptr_t)31ULL), x95, 1); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_to_bytes(uint8_t out1[32], const uint64_t arg1[4]) { + internal_fiat_p256_scalar_to_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p256_scalar_from_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x31, x30, x29, x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x12, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0, x62, x63, x61, x64, x60, x65, x59, x66, x58, x67, x57, x68, x56, x69, x54, x55, x53, x71, x52, x72, x51, x73, x50, x74, x49, x75, x48, x76, x46, x47, x45, x78, x44, x79, x43, x80, x42, x81, x41, x82, x40, x83, x38, x39, x37, x85, x36, x86, x35, x87, x34, x88, x33, x89, x32, x90, x70, x77, x84, x91, x92, x93, x94, x95; + x0 = _br2_load((in0)+((uintptr_t)0ULL), 1); + x1 = _br2_load((in0)+((uintptr_t)1ULL), 1); + x2 = _br2_load((in0)+((uintptr_t)2ULL), 1); + x3 = _br2_load((in0)+((uintptr_t)3ULL), 1); + x4 = _br2_load((in0)+((uintptr_t)4ULL), 1); + x5 = _br2_load((in0)+((uintptr_t)5ULL), 1); + x6 = _br2_load((in0)+((uintptr_t)6ULL), 1); + x7 = _br2_load((in0)+((uintptr_t)7ULL), 1); + x8 = _br2_load((in0)+((uintptr_t)8ULL), 1); + x9 = _br2_load((in0)+((uintptr_t)9ULL), 1); + x10 = _br2_load((in0)+((uintptr_t)10ULL), 1); + x11 = _br2_load((in0)+((uintptr_t)11ULL), 1); + x12 = _br2_load((in0)+((uintptr_t)12ULL), 1); + x13 = _br2_load((in0)+((uintptr_t)13ULL), 1); + x14 = _br2_load((in0)+((uintptr_t)14ULL), 1); + x15 = _br2_load((in0)+((uintptr_t)15ULL), 1); + x16 = _br2_load((in0)+((uintptr_t)16ULL), 1); + x17 = _br2_load((in0)+((uintptr_t)17ULL), 1); + x18 = _br2_load((in0)+((uintptr_t)18ULL), 1); + x19 = _br2_load((in0)+((uintptr_t)19ULL), 1); + x20 = _br2_load((in0)+((uintptr_t)20ULL), 1); + x21 = _br2_load((in0)+((uintptr_t)21ULL), 1); + x22 = _br2_load((in0)+((uintptr_t)22ULL), 1); + x23 = _br2_load((in0)+((uintptr_t)23ULL), 1); + x24 = _br2_load((in0)+((uintptr_t)24ULL), 1); + x25 = _br2_load((in0)+((uintptr_t)25ULL), 1); + x26 = _br2_load((in0)+((uintptr_t)26ULL), 1); + x27 = _br2_load((in0)+((uintptr_t)27ULL), 1); + x28 = _br2_load((in0)+((uintptr_t)28ULL), 1); + x29 = _br2_load((in0)+((uintptr_t)29ULL), 1); + x30 = _br2_load((in0)+((uintptr_t)30ULL), 1); + x31 = _br2_load((in0)+((uintptr_t)31ULL), 1); + /*skip*/ + /*skip*/ + x32 = (x31)<<((uintptr_t)56ULL); + x33 = (x30)<<((uintptr_t)48ULL); + x34 = (x29)<<((uintptr_t)40ULL); + x35 = (x28)<<((uintptr_t)32ULL); + x36 = (x27)<<((uintptr_t)24ULL); + x37 = (x26)<<((uintptr_t)16ULL); + x38 = (x25)<<((uintptr_t)8ULL); + x39 = x24; + x40 = (x23)<<((uintptr_t)56ULL); + x41 = (x22)<<((uintptr_t)48ULL); + x42 = (x21)<<((uintptr_t)40ULL); + x43 = (x20)<<((uintptr_t)32ULL); + x44 = (x19)<<((uintptr_t)24ULL); + x45 = (x18)<<((uintptr_t)16ULL); + x46 = (x17)<<((uintptr_t)8ULL); + x47 = x16; + x48 = (x15)<<((uintptr_t)56ULL); + x49 = (x14)<<((uintptr_t)48ULL); + x50 = (x13)<<((uintptr_t)40ULL); + x51 = (x12)<<((uintptr_t)32ULL); + x52 = (x11)<<((uintptr_t)24ULL); + x53 = (x10)<<((uintptr_t)16ULL); + x54 = (x9)<<((uintptr_t)8ULL); + x55 = x8; + x56 = (x7)<<((uintptr_t)56ULL); + x57 = (x6)<<((uintptr_t)48ULL); + x58 = (x5)<<((uintptr_t)40ULL); + x59 = (x4)<<((uintptr_t)32ULL); + x60 = (x3)<<((uintptr_t)24ULL); + x61 = (x2)<<((uintptr_t)16ULL); + x62 = (x1)<<((uintptr_t)8ULL); + x63 = x0; + x64 = (x62)+(x63); + x65 = (x61)+(x64); + x66 = (x60)+(x65); + x67 = (x59)+(x66); + x68 = (x58)+(x67); + x69 = (x57)+(x68); + x70 = (x56)+(x69); + x71 = (x54)+(x55); + x72 = (x53)+(x71); + x73 = (x52)+(x72); + x74 = (x51)+(x73); + x75 = (x50)+(x74); + x76 = (x49)+(x75); + x77 = (x48)+(x76); + x78 = (x46)+(x47); + x79 = (x45)+(x78); + x80 = (x44)+(x79); + x81 = (x43)+(x80); + x82 = (x42)+(x81); + x83 = (x41)+(x82); + x84 = (x40)+(x83); + x85 = (x38)+(x39); + x86 = (x37)+(x85); + x87 = (x36)+(x86); + x88 = (x35)+(x87); + x89 = (x34)+(x88); + x90 = (x33)+(x89); + x91 = (x32)+(x90); + x92 = x70; + x93 = x77; + x94 = x84; + x95 = x91; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x92, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x93, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x94, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x95, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_from_bytes(uint64_t out1[4], const uint8_t arg1[32]) { + internal_fiat_p256_scalar_from_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p256_scalar_set_one(uintptr_t out0) { + uintptr_t x0, x1, x2, x3; + /*skip*/ + x0 = (uintptr_t)884452912994769583ULL; + x1 = (uintptr_t)4834901526196019579ULL; + x2 = (uintptr_t)0ULL; + x3 = (uintptr_t)4294967295ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_set_one(uint64_t out1[4]) { + internal_fiat_p256_scalar_set_one((uintptr_t)out1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p256_scalar_msat(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4; + /*skip*/ + x0 = (uintptr_t)17562291160714782033ULL; + x1 = (uintptr_t)13611842547513532036ULL; + x2 = (uintptr_t)18446744073709551615ULL; + x3 = (uintptr_t)18446744069414584320ULL; + x4 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x4, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_msat(uint64_t out1[5]) { + internal_fiat_p256_scalar_msat((uintptr_t)out1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0xffffffffffffffff] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffffffffffff] + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +uintptr_t internal_fiat_p256_scalar_divstep(uintptr_t out1, uintptr_t out2, uintptr_t out3, uintptr_t out4, uintptr_t in0, uintptr_t in1, uintptr_t in2, uintptr_t in3, uintptr_t in4) { + uintptr_t x18, x20, x21, x22, x24, x25, x27, x28, x30, x31, x33, x34, x36, x37, x0, x40, x1, x42, x2, x44, x3, x46, x4, x39, x48, x5, x49, x41, x51, x6, x52, x43, x54, x7, x55, x45, x57, x8, x58, x47, x60, x9, x61, x63, x64, x66, x67, x69, x70, x72, x73, x76, x77, x78, x80, x81, x82, x83, x85, x86, x87, x88, x90, x93, x94, x95, x97, x98, x99, x100, x102, x103, x104, x105, x107, x108, x91, x109, x13, x12, x11, x10, x115, x113, x116, x118, x119, x112, x120, x122, x123, x111, x124, x126, x127, x114, x130, x117, x131, x132, x134, x135, x121, x136, x137, x139, x140, x125, x141, x128, x129, x143, x14, x144, x133, x146, x15, x147, x138, x149, x16, x150, x19, x142, x152, x17, x153, x156, x157, x159, x160, x162, x163, x165, x166, x168, x169, x158, x50, x172, x53, x173, x161, x174, x176, x177, x56, x178, x164, x179, x181, x182, x59, x183, x167, x184, x186, x187, x62, x188, x170, x65, x190, x191, x68, x193, x194, x71, x196, x197, x155, x74, x199, x200, x192, x145, x203, x148, x204, x195, x205, x207, x208, x151, x209, x198, x210, x212, x213, x154, x214, x201, x215, x217, x220, x221, x222, x224, x225, x226, x227, x229, x230, x231, x232, x234, x235, x218, x236, x23, x171, x175, x180, x185, x189, x75, x244, x92, x245, x79, x247, x96, x248, x84, x250, x101, x251, x110, x89, x253, x106, x254, x202, x256, x219, x257, x206, x259, x223, x260, x211, x262, x228, x263, x237, x216, x265, x233, x266, x238, x26, x29, x32, x35, x38, x239, x240, x241, x242, x243, x246, x249, x252, x255, x258, x261, x264, x267, out0, x268, x269, x270, x271, x272, x273, x274, x275, x276, x277, x278, x279, x280, x281, x282, x283, x284, x285, x286; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + /*skip*/ + x5 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x6 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x7 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x8 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x9 = _br2_load((in2)+((uintptr_t)32ULL), sizeof(uintptr_t)); + /*skip*/ + x10 = _br2_load((in3)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x11 = _br2_load((in3)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x12 = _br2_load((in3)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in3)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x14 = _br2_load((in4)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x15 = _br2_load((in4)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x16 = _br2_load((in4)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x17 = _br2_load((in4)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x18 = ((in0)^((uintptr_t)18446744073709551615ULL))+((uintptr_t)1ULL); + x19 = ((x18)>>((uintptr_t)63ULL))&((x5)&((uintptr_t)1ULL)); + x20 = ((in0)^((uintptr_t)18446744073709551615ULL))+((uintptr_t)1ULL); + x21 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x22 = (x21)^((uintptr_t)18446744073709551615ULL); + x23 = ((x20)&(x21))|((in0)&(x22)); + x24 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x25 = (x24)^((uintptr_t)18446744073709551615ULL); + x26 = ((x5)&(x24))|((x0)&(x25)); + x27 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x28 = (x27)^((uintptr_t)18446744073709551615ULL); + x29 = ((x6)&(x27))|((x1)&(x28)); + x30 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x31 = (x30)^((uintptr_t)18446744073709551615ULL); + x32 = ((x7)&(x30))|((x2)&(x31)); + x33 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x34 = (x33)^((uintptr_t)18446744073709551615ULL); + x35 = ((x8)&(x33))|((x3)&(x34)); + x36 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x37 = (x36)^((uintptr_t)18446744073709551615ULL); + x38 = ((x9)&(x36))|((x4)&(x37)); + x39 = ((uintptr_t)1ULL)+((x0)^((uintptr_t)18446744073709551615ULL)); + x40 = (uintptr_t)((x39)<((uintptr_t)1ULL)); + x41 = (x40)+((x1)^((uintptr_t)18446744073709551615ULL)); + x42 = (uintptr_t)((x41)<((x1)^((uintptr_t)18446744073709551615ULL))); + x43 = (x42)+((x2)^((uintptr_t)18446744073709551615ULL)); + x44 = (uintptr_t)((x43)<((x2)^((uintptr_t)18446744073709551615ULL))); + x45 = (x44)+((x3)^((uintptr_t)18446744073709551615ULL)); + x46 = (uintptr_t)((x45)<((x3)^((uintptr_t)18446744073709551615ULL))); + x47 = (x46)+((x4)^((uintptr_t)18446744073709551615ULL)); + x48 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x49 = (x48)^((uintptr_t)18446744073709551615ULL); + x50 = ((x39)&(x48))|((x5)&(x49)); + x51 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x52 = (x51)^((uintptr_t)18446744073709551615ULL); + x53 = ((x41)&(x51))|((x6)&(x52)); + x54 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x55 = (x54)^((uintptr_t)18446744073709551615ULL); + x56 = ((x43)&(x54))|((x7)&(x55)); + x57 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x58 = (x57)^((uintptr_t)18446744073709551615ULL); + x59 = ((x45)&(x57))|((x8)&(x58)); + x60 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x61 = (x60)^((uintptr_t)18446744073709551615ULL); + x62 = ((x47)&(x60))|((x9)&(x61)); + x63 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x64 = (x63)^((uintptr_t)18446744073709551615ULL); + x65 = ((x14)&(x63))|((x10)&(x64)); + x66 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x67 = (x66)^((uintptr_t)18446744073709551615ULL); + x68 = ((x15)&(x66))|((x11)&(x67)); + x69 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x70 = (x69)^((uintptr_t)18446744073709551615ULL); + x71 = ((x16)&(x69))|((x12)&(x70)); + x72 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x73 = (x72)^((uintptr_t)18446744073709551615ULL); + x74 = ((x17)&(x72))|((x13)&(x73)); + x75 = (x65)+(x65); + x76 = (uintptr_t)((x75)<(x65)); + x77 = (x76)+(x68); + x78 = (uintptr_t)((x77)<(x68)); + x79 = (x77)+(x68); + x80 = (uintptr_t)((x79)<(x68)); + x81 = (x78)+(x80); + x82 = (x81)+(x71); + x83 = (uintptr_t)((x82)<(x71)); + x84 = (x82)+(x71); + x85 = (uintptr_t)((x84)<(x71)); + x86 = (x83)+(x85); + x87 = (x86)+(x74); + x88 = (uintptr_t)((x87)<(x74)); + x89 = (x87)+(x74); + x90 = (uintptr_t)((x89)<(x74)); + x91 = (x88)+(x90); + x92 = (x75)-((uintptr_t)17562291160714782033ULL); + x93 = (uintptr_t)((x75)<(x92)); + x94 = (x79)-((uintptr_t)13611842547513532036ULL); + x95 = (uintptr_t)((x79)<(x94)); + x96 = (x94)-(x93); + x97 = (uintptr_t)((x94)<(x96)); + x98 = (x95)+(x97); + x99 = (x84)-((uintptr_t)18446744073709551615ULL); + x100 = (uintptr_t)((x84)<(x99)); + x101 = (x99)-(x98); + x102 = (uintptr_t)((x99)<(x101)); + x103 = (x100)+(x102); + x104 = (x89)-((uintptr_t)18446744069414584320ULL); + x105 = (uintptr_t)((x89)<(x104)); + x106 = (x104)-(x103); + x107 = (uintptr_t)((x104)<(x106)); + x108 = (x105)+(x107); + x109 = (x91)-(x108); + x110 = (uintptr_t)((x91)<(x109)); + x111 = x13; + x112 = x12; + x113 = x11; + x114 = x10; + x115 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x114))); + x116 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x113))); + x117 = (((uintptr_t)0ULL)-(x113))-(x115); + x118 = (uintptr_t)((((uintptr_t)0ULL)-(x113))<(x117)); + x119 = (x116)+(x118); + x120 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x112))); + x121 = (((uintptr_t)0ULL)-(x112))-(x119); + x122 = (uintptr_t)((((uintptr_t)0ULL)-(x112))<(x121)); + x123 = (x120)+(x122); + x124 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x111))); + x125 = (((uintptr_t)0ULL)-(x111))-(x123); + x126 = (uintptr_t)((((uintptr_t)0ULL)-(x111))<(x125)); + x127 = (x124)+(x126); + x128 = ((uintptr_t)-1ULL)+((uintptr_t)((x127)==((uintptr_t)0ULL))); + x129 = (((uintptr_t)0ULL)-(x114))+((x128)&((uintptr_t)17562291160714782033ULL)); + x130 = (uintptr_t)((x129)<(((uintptr_t)0ULL)-(x114))); + x131 = (x130)+(x117); + x132 = (uintptr_t)((x131)<(x117)); + x133 = (x131)+((x128)&((uintptr_t)13611842547513532036ULL)); + x134 = (uintptr_t)((x133)<((x128)&((uintptr_t)13611842547513532036ULL))); + x135 = (x132)+(x134); + x136 = (x135)+(x121); + x137 = (uintptr_t)((x136)<(x121)); + x138 = (x136)+(x128); + x139 = (uintptr_t)((x138)<(x128)); + x140 = (x137)+(x139); + x141 = (x140)+(x125); + x142 = (x141)+((x128)&((uintptr_t)18446744069414584320ULL)); + x143 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x144 = (x143)^((uintptr_t)18446744073709551615ULL); + x145 = ((x129)&(x143))|((x14)&(x144)); + x146 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x147 = (x146)^((uintptr_t)18446744073709551615ULL); + x148 = ((x133)&(x146))|((x15)&(x147)); + x149 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x150 = (x149)^((uintptr_t)18446744073709551615ULL); + x151 = ((x138)&(x149))|((x16)&(x150)); + x152 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x153 = (x152)^((uintptr_t)18446744073709551615ULL); + x154 = ((x142)&(x152))|((x17)&(x153)); + x155 = (x50)&((uintptr_t)1ULL); + x156 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x157 = (x156)^((uintptr_t)18446744073709551615ULL); + x158 = ((x26)&(x156))|(((uintptr_t)0ULL)&(x157)); + x159 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x160 = (x159)^((uintptr_t)18446744073709551615ULL); + x161 = ((x29)&(x159))|(((uintptr_t)0ULL)&(x160)); + x162 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x163 = (x162)^((uintptr_t)18446744073709551615ULL); + x164 = ((x32)&(x162))|(((uintptr_t)0ULL)&(x163)); + x165 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x166 = (x165)^((uintptr_t)18446744073709551615ULL); + x167 = ((x35)&(x165))|(((uintptr_t)0ULL)&(x166)); + x168 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x169 = (x168)^((uintptr_t)18446744073709551615ULL); + x170 = ((x38)&(x168))|(((uintptr_t)0ULL)&(x169)); + x171 = (x50)+(x158); + x172 = (uintptr_t)((x171)<(x50)); + x173 = (x172)+(x53); + x174 = (uintptr_t)((x173)<(x53)); + x175 = (x173)+(x161); + x176 = (uintptr_t)((x175)<(x161)); + x177 = (x174)+(x176); + x178 = (x177)+(x56); + x179 = (uintptr_t)((x178)<(x56)); + x180 = (x178)+(x164); + x181 = (uintptr_t)((x180)<(x164)); + x182 = (x179)+(x181); + x183 = (x182)+(x59); + x184 = (uintptr_t)((x183)<(x59)); + x185 = (x183)+(x167); + x186 = (uintptr_t)((x185)<(x167)); + x187 = (x184)+(x186); + x188 = (x187)+(x62); + x189 = (x188)+(x170); + x190 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x191 = (x190)^((uintptr_t)18446744073709551615ULL); + x192 = ((x65)&(x190))|(((uintptr_t)0ULL)&(x191)); + x193 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x194 = (x193)^((uintptr_t)18446744073709551615ULL); + x195 = ((x68)&(x193))|(((uintptr_t)0ULL)&(x194)); + x196 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x197 = (x196)^((uintptr_t)18446744073709551615ULL); + x198 = ((x71)&(x196))|(((uintptr_t)0ULL)&(x197)); + x199 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x200 = (x199)^((uintptr_t)18446744073709551615ULL); + x201 = ((x74)&(x199))|(((uintptr_t)0ULL)&(x200)); + x202 = (x145)+(x192); + x203 = (uintptr_t)((x202)<(x145)); + x204 = (x203)+(x148); + x205 = (uintptr_t)((x204)<(x148)); + x206 = (x204)+(x195); + x207 = (uintptr_t)((x206)<(x195)); + x208 = (x205)+(x207); + x209 = (x208)+(x151); + x210 = (uintptr_t)((x209)<(x151)); + x211 = (x209)+(x198); + x212 = (uintptr_t)((x211)<(x198)); + x213 = (x210)+(x212); + x214 = (x213)+(x154); + x215 = (uintptr_t)((x214)<(x154)); + x216 = (x214)+(x201); + x217 = (uintptr_t)((x216)<(x201)); + x218 = (x215)+(x217); + x219 = (x202)-((uintptr_t)17562291160714782033ULL); + x220 = (uintptr_t)((x202)<(x219)); + x221 = (x206)-((uintptr_t)13611842547513532036ULL); + x222 = (uintptr_t)((x206)<(x221)); + x223 = (x221)-(x220); + x224 = (uintptr_t)((x221)<(x223)); + x225 = (x222)+(x224); + x226 = (x211)-((uintptr_t)18446744073709551615ULL); + x227 = (uintptr_t)((x211)<(x226)); + x228 = (x226)-(x225); + x229 = (uintptr_t)((x226)<(x228)); + x230 = (x227)+(x229); + x231 = (x216)-((uintptr_t)18446744069414584320ULL); + x232 = (uintptr_t)((x216)<(x231)); + x233 = (x231)-(x230); + x234 = (uintptr_t)((x231)<(x233)); + x235 = (x232)+(x234); + x236 = (x218)-(x235); + x237 = (uintptr_t)((x218)<(x236)); + x238 = (x23)+((uintptr_t)1ULL); + x239 = ((x171)>>((uintptr_t)1ULL))|((x175)<<((uintptr_t)63ULL)); + x240 = ((x175)>>((uintptr_t)1ULL))|((x180)<<((uintptr_t)63ULL)); + x241 = ((x180)>>((uintptr_t)1ULL))|((x185)<<((uintptr_t)63ULL)); + x242 = ((x185)>>((uintptr_t)1ULL))|((x189)<<((uintptr_t)63ULL)); + x243 = ((x189)&((uintptr_t)9223372036854775808ULL))|((x189)>>((uintptr_t)1ULL)); + x244 = ((uintptr_t)-1ULL)+((uintptr_t)((x110)==((uintptr_t)0ULL))); + x245 = (x244)^((uintptr_t)18446744073709551615ULL); + x246 = ((x75)&(x244))|((x92)&(x245)); + x247 = ((uintptr_t)-1ULL)+((uintptr_t)((x110)==((uintptr_t)0ULL))); + x248 = (x247)^((uintptr_t)18446744073709551615ULL); + x249 = ((x79)&(x247))|((x96)&(x248)); + x250 = ((uintptr_t)-1ULL)+((uintptr_t)((x110)==((uintptr_t)0ULL))); + x251 = (x250)^((uintptr_t)18446744073709551615ULL); + x252 = ((x84)&(x250))|((x101)&(x251)); + x253 = ((uintptr_t)-1ULL)+((uintptr_t)((x110)==((uintptr_t)0ULL))); + x254 = (x253)^((uintptr_t)18446744073709551615ULL); + x255 = ((x89)&(x253))|((x106)&(x254)); + x256 = ((uintptr_t)-1ULL)+((uintptr_t)((x237)==((uintptr_t)0ULL))); + x257 = (x256)^((uintptr_t)18446744073709551615ULL); + x258 = ((x202)&(x256))|((x219)&(x257)); + x259 = ((uintptr_t)-1ULL)+((uintptr_t)((x237)==((uintptr_t)0ULL))); + x260 = (x259)^((uintptr_t)18446744073709551615ULL); + x261 = ((x206)&(x259))|((x223)&(x260)); + x262 = ((uintptr_t)-1ULL)+((uintptr_t)((x237)==((uintptr_t)0ULL))); + x263 = (x262)^((uintptr_t)18446744073709551615ULL); + x264 = ((x211)&(x262))|((x228)&(x263)); + x265 = ((uintptr_t)-1ULL)+((uintptr_t)((x237)==((uintptr_t)0ULL))); + x266 = (x265)^((uintptr_t)18446744073709551615ULL); + x267 = ((x216)&(x265))|((x233)&(x266)); + x268 = x238; + x269 = x26; + x270 = x29; + x271 = x32; + x272 = x35; + x273 = x38; + /*skip*/ + x274 = x239; + x275 = x240; + x276 = x241; + x277 = x242; + x278 = x243; + /*skip*/ + x279 = x246; + x280 = x249; + x281 = x252; + x282 = x255; + /*skip*/ + x283 = x258; + x284 = x261; + x285 = x264; + x286 = x267; + /*skip*/ + out0 = x268; + _br2_store((out1)+((uintptr_t)0ULL), x269, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)8ULL), x270, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)16ULL), x271, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)24ULL), x272, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)32ULL), x273, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out2)+((uintptr_t)0ULL), x274, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)8ULL), x275, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)16ULL), x276, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)24ULL), x277, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)32ULL), x278, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out3)+((uintptr_t)0ULL), x279, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)8ULL), x280, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)16ULL), x281, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)24ULL), x282, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out4)+((uintptr_t)0ULL), x283, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)8ULL), x284, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)16ULL), x285, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)24ULL), x286, sizeof(uintptr_t)); + /*skip*/ + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_divstep(uint64_t* out1, uint64_t out2[5], uint64_t out3[5], uint64_t out4[4], uint64_t out5[4], uint64_t arg1, const uint64_t arg2[5], const uint64_t arg3[5], const uint64_t arg4[4], const uint64_t arg5[4]) { + *out1 = (uint64_t)internal_fiat_p256_scalar_divstep((uintptr_t)out2, (uintptr_t)out3, (uintptr_t)out4, (uintptr_t)out5, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3, (uintptr_t)arg4, (uintptr_t)arg5); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p256_scalar_divstep_precomp(uintptr_t out0) { + uintptr_t x0, x1, x2, x3; + /*skip*/ + x0 = (uintptr_t)15508468778219142069ULL; + x1 = (uintptr_t)9999952001964131348ULL; + x2 = (uintptr_t)14300099520663634518ULL; + x3 = (uintptr_t)4920572863387774687ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p256_scalar_divstep_precomp(uint64_t out1[4]) { + internal_fiat_p256_scalar_divstep_precomp((uintptr_t)out1); +} diff --git a/fiat-bedrock2/src/p384_scalar_32.c b/fiat-bedrock2/src/p384_scalar_32.c new file mode 100644 index 0000000000..e58b0939ce --- /dev/null +++ b/fiat-bedrock2/src/p384_scalar_32.c @@ -0,0 +1,11823 @@ +/* Autogenerated: 'src/ExtractionOCaml/bedrock2_word_by_word_montgomery' --lang bedrock2 --static --no-wide-int --widen-carry --widen-bytes --split-multiret --no-select --no-field-element-typedefs p384_scalar 32 '2^384 - 1388124618062372383947042015309946732620727252194336364173' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: p384_scalar */ +/* machine_wordsize = 32 (from "32") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from "2^384 - 1388124618062372383947042015309946732620727252194336364173") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) in */ +/* if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384 */ + +#include +#include + +// We use memcpy to work around -fstrict-aliasing. +// A plain memcpy is enough on clang 10, but not on gcc 10, which fails +// to infer the bounds on an integer loaded by memcpy. +// Adding a range mask after memcpy in turn makes slower code in clang. +// Loading individual bytes, shifting them together, and or-ing is fast +// on clang and sometimes on GCC, but other times GCC inlines individual +// byte operations without reconstructing wider accesses. +// The little-endian idiom below seems fast in gcc 9+ and clang 10. +static __attribute__((always_inline)) inline uintptr_t +_br2_load(uintptr_t a, uintptr_t sz) { + switch (sz) { + case 1: { uint8_t r = 0; memcpy(&r, (void*)a, 1); return r; } + case 2: { uint16_t r = 0; memcpy(&r, (void*)a, 2); return r; } + case 4: { uint32_t r = 0; memcpy(&r, (void*)a, 4); return r; } + case 8: { uint64_t r = 0; memcpy(&r, (void*)a, 8); return r; } + default: __builtin_unreachable(); + } +} + +static __attribute__((always_inline)) inline void +_br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) { + memcpy((void*)a, &v, sz); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p384_scalar_mul(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x0, x35, x56, x59, x61, x57, x62, x54, x63, x65, x66, x55, x67, x52, x68, x70, x71, x53, x72, x50, x73, x75, x76, x51, x77, x48, x78, x80, x81, x49, x82, x46, x83, x85, x86, x47, x87, x44, x88, x90, x91, x45, x92, x42, x93, x95, x96, x43, x97, x40, x98, x100, x101, x41, x102, x38, x103, x105, x106, x39, x107, x36, x108, x110, x111, x37, x113, x134, x137, x139, x135, x140, x132, x141, x143, x144, x133, x145, x130, x146, x148, x149, x131, x150, x128, x151, x153, x154, x129, x155, x126, x156, x158, x159, x127, x160, x124, x161, x163, x164, x125, x165, x122, x166, x168, x169, x123, x170, x120, x171, x173, x174, x121, x175, x118, x176, x178, x179, x119, x180, x116, x181, x183, x184, x117, x185, x114, x186, x188, x189, x115, x136, x191, x58, x192, x60, x193, x138, x194, x196, x197, x64, x198, x142, x199, x201, x202, x69, x203, x147, x204, x206, x207, x74, x208, x152, x209, x211, x212, x79, x213, x157, x214, x216, x217, x84, x218, x162, x219, x221, x222, x89, x223, x167, x224, x226, x227, x94, x228, x172, x229, x231, x232, x99, x233, x177, x234, x236, x237, x104, x238, x182, x239, x241, x242, x109, x243, x187, x244, x246, x247, x112, x248, x190, x249, x251, x24, x273, x276, x278, x274, x279, x271, x280, x282, x283, x272, x284, x269, x285, x287, x288, x270, x289, x267, x290, x292, x293, x268, x294, x265, x295, x297, x298, x266, x299, x263, x300, x302, x303, x264, x304, x261, x305, x307, x308, x262, x309, x259, x310, x312, x313, x260, x314, x257, x315, x317, x318, x258, x319, x255, x320, x322, x323, x256, x324, x253, x325, x327, x328, x254, x275, x195, x331, x200, x332, x277, x333, x335, x336, x205, x337, x281, x338, x340, x341, x210, x342, x286, x343, x345, x346, x215, x347, x291, x348, x350, x351, x220, x352, x296, x353, x355, x356, x225, x357, x301, x358, x360, x361, x230, x362, x306, x363, x365, x366, x235, x367, x311, x368, x370, x371, x240, x372, x316, x373, x375, x376, x245, x377, x321, x378, x380, x381, x250, x382, x326, x383, x385, x386, x252, x387, x329, x388, x390, x392, x413, x416, x418, x414, x419, x411, x420, x422, x423, x412, x424, x409, x425, x427, x428, x410, x429, x407, x430, x432, x433, x408, x434, x405, x435, x437, x438, x406, x439, x403, x440, x442, x443, x404, x444, x401, x445, x447, x448, x402, x449, x399, x450, x452, x453, x400, x454, x397, x455, x457, x458, x398, x459, x395, x460, x462, x463, x396, x464, x393, x465, x467, x468, x394, x415, x470, x330, x471, x334, x472, x417, x473, x475, x476, x339, x477, x421, x478, x480, x481, x344, x482, x426, x483, x485, x486, x349, x487, x431, x488, x490, x491, x354, x492, x436, x493, x495, x496, x359, x497, x441, x498, x500, x501, x364, x502, x446, x503, x505, x506, x369, x507, x451, x508, x510, x511, x374, x512, x456, x513, x515, x516, x379, x517, x461, x518, x520, x521, x384, x522, x466, x523, x525, x526, x389, x527, x469, x528, x530, x531, x391, x25, x553, x556, x558, x554, x559, x551, x560, x562, x563, x552, x564, x549, x565, x567, x568, x550, x569, x547, x570, x572, x573, x548, x574, x545, x575, x577, x578, x546, x579, x543, x580, x582, x583, x544, x584, x541, x585, x587, x588, x542, x589, x539, x590, x592, x593, x540, x594, x537, x595, x597, x598, x538, x599, x535, x600, x602, x603, x536, x604, x533, x605, x607, x608, x534, x555, x474, x611, x479, x612, x557, x613, x615, x616, x484, x617, x561, x618, x620, x621, x489, x622, x566, x623, x625, x626, x494, x627, x571, x628, x630, x631, x499, x632, x576, x633, x635, x636, x504, x637, x581, x638, x640, x641, x509, x642, x586, x643, x645, x646, x514, x647, x591, x648, x650, x651, x519, x652, x596, x653, x655, x656, x524, x657, x601, x658, x660, x661, x529, x662, x606, x663, x665, x666, x532, x667, x609, x668, x670, x672, x693, x696, x698, x694, x699, x691, x700, x702, x703, x692, x704, x689, x705, x707, x708, x690, x709, x687, x710, x712, x713, x688, x714, x685, x715, x717, x718, x686, x719, x683, x720, x722, x723, x684, x724, x681, x725, x727, x728, x682, x729, x679, x730, x732, x733, x680, x734, x677, x735, x737, x738, x678, x739, x675, x740, x742, x743, x676, x744, x673, x745, x747, x748, x674, x695, x750, x610, x751, x614, x752, x697, x753, x755, x756, x619, x757, x701, x758, x760, x761, x624, x762, x706, x763, x765, x766, x629, x767, x711, x768, x770, x771, x634, x772, x716, x773, x775, x776, x639, x777, x721, x778, x780, x781, x644, x782, x726, x783, x785, x786, x649, x787, x731, x788, x790, x791, x654, x792, x736, x793, x795, x796, x659, x797, x741, x798, x800, x801, x664, x802, x746, x803, x805, x806, x669, x807, x749, x808, x810, x811, x671, x26, x833, x836, x838, x834, x839, x831, x840, x842, x843, x832, x844, x829, x845, x847, x848, x830, x849, x827, x850, x852, x853, x828, x854, x825, x855, x857, x858, x826, x859, x823, x860, x862, x863, x824, x864, x821, x865, x867, x868, x822, x869, x819, x870, x872, x873, x820, x874, x817, x875, x877, x878, x818, x879, x815, x880, x882, x883, x816, x884, x813, x885, x887, x888, x814, x835, x754, x891, x759, x892, x837, x893, x895, x896, x764, x897, x841, x898, x900, x901, x769, x902, x846, x903, x905, x906, x774, x907, x851, x908, x910, x911, x779, x912, x856, x913, x915, x916, x784, x917, x861, x918, x920, x921, x789, x922, x866, x923, x925, x926, x794, x927, x871, x928, x930, x931, x799, x932, x876, x933, x935, x936, x804, x937, x881, x938, x940, x941, x809, x942, x886, x943, x945, x946, x812, x947, x889, x948, x950, x952, x973, x976, x978, x974, x979, x971, x980, x982, x983, x972, x984, x969, x985, x987, x988, x970, x989, x967, x990, x992, x993, x968, x994, x965, x995, x997, x998, x966, x999, x963, x1000, x1002, x1003, x964, x1004, x961, x1005, x1007, x1008, x962, x1009, x959, x1010, x1012, x1013, x960, x1014, x957, x1015, x1017, x1018, x958, x1019, x955, x1020, x1022, x1023, x956, x1024, x953, x1025, x1027, x1028, x954, x975, x1030, x890, x1031, x894, x1032, x977, x1033, x1035, x1036, x899, x1037, x981, x1038, x1040, x1041, x904, x1042, x986, x1043, x1045, x1046, x909, x1047, x991, x1048, x1050, x1051, x914, x1052, x996, x1053, x1055, x1056, x919, x1057, x1001, x1058, x1060, x1061, x924, x1062, x1006, x1063, x1065, x1066, x929, x1067, x1011, x1068, x1070, x1071, x934, x1072, x1016, x1073, x1075, x1076, x939, x1077, x1021, x1078, x1080, x1081, x944, x1082, x1026, x1083, x1085, x1086, x949, x1087, x1029, x1088, x1090, x1091, x951, x27, x1113, x1116, x1118, x1114, x1119, x1111, x1120, x1122, x1123, x1112, x1124, x1109, x1125, x1127, x1128, x1110, x1129, x1107, x1130, x1132, x1133, x1108, x1134, x1105, x1135, x1137, x1138, x1106, x1139, x1103, x1140, x1142, x1143, x1104, x1144, x1101, x1145, x1147, x1148, x1102, x1149, x1099, x1150, x1152, x1153, x1100, x1154, x1097, x1155, x1157, x1158, x1098, x1159, x1095, x1160, x1162, x1163, x1096, x1164, x1093, x1165, x1167, x1168, x1094, x1115, x1034, x1171, x1039, x1172, x1117, x1173, x1175, x1176, x1044, x1177, x1121, x1178, x1180, x1181, x1049, x1182, x1126, x1183, x1185, x1186, x1054, x1187, x1131, x1188, x1190, x1191, x1059, x1192, x1136, x1193, x1195, x1196, x1064, x1197, x1141, x1198, x1200, x1201, x1069, x1202, x1146, x1203, x1205, x1206, x1074, x1207, x1151, x1208, x1210, x1211, x1079, x1212, x1156, x1213, x1215, x1216, x1084, x1217, x1161, x1218, x1220, x1221, x1089, x1222, x1166, x1223, x1225, x1226, x1092, x1227, x1169, x1228, x1230, x1232, x1253, x1256, x1258, x1254, x1259, x1251, x1260, x1262, x1263, x1252, x1264, x1249, x1265, x1267, x1268, x1250, x1269, x1247, x1270, x1272, x1273, x1248, x1274, x1245, x1275, x1277, x1278, x1246, x1279, x1243, x1280, x1282, x1283, x1244, x1284, x1241, x1285, x1287, x1288, x1242, x1289, x1239, x1290, x1292, x1293, x1240, x1294, x1237, x1295, x1297, x1298, x1238, x1299, x1235, x1300, x1302, x1303, x1236, x1304, x1233, x1305, x1307, x1308, x1234, x1255, x1310, x1170, x1311, x1174, x1312, x1257, x1313, x1315, x1316, x1179, x1317, x1261, x1318, x1320, x1321, x1184, x1322, x1266, x1323, x1325, x1326, x1189, x1327, x1271, x1328, x1330, x1331, x1194, x1332, x1276, x1333, x1335, x1336, x1199, x1337, x1281, x1338, x1340, x1341, x1204, x1342, x1286, x1343, x1345, x1346, x1209, x1347, x1291, x1348, x1350, x1351, x1214, x1352, x1296, x1353, x1355, x1356, x1219, x1357, x1301, x1358, x1360, x1361, x1224, x1362, x1306, x1363, x1365, x1366, x1229, x1367, x1309, x1368, x1370, x1371, x1231, x28, x1393, x1396, x1398, x1394, x1399, x1391, x1400, x1402, x1403, x1392, x1404, x1389, x1405, x1407, x1408, x1390, x1409, x1387, x1410, x1412, x1413, x1388, x1414, x1385, x1415, x1417, x1418, x1386, x1419, x1383, x1420, x1422, x1423, x1384, x1424, x1381, x1425, x1427, x1428, x1382, x1429, x1379, x1430, x1432, x1433, x1380, x1434, x1377, x1435, x1437, x1438, x1378, x1439, x1375, x1440, x1442, x1443, x1376, x1444, x1373, x1445, x1447, x1448, x1374, x1395, x1314, x1451, x1319, x1452, x1397, x1453, x1455, x1456, x1324, x1457, x1401, x1458, x1460, x1461, x1329, x1462, x1406, x1463, x1465, x1466, x1334, x1467, x1411, x1468, x1470, x1471, x1339, x1472, x1416, x1473, x1475, x1476, x1344, x1477, x1421, x1478, x1480, x1481, x1349, x1482, x1426, x1483, x1485, x1486, x1354, x1487, x1431, x1488, x1490, x1491, x1359, x1492, x1436, x1493, x1495, x1496, x1364, x1497, x1441, x1498, x1500, x1501, x1369, x1502, x1446, x1503, x1505, x1506, x1372, x1507, x1449, x1508, x1510, x1512, x1533, x1536, x1538, x1534, x1539, x1531, x1540, x1542, x1543, x1532, x1544, x1529, x1545, x1547, x1548, x1530, x1549, x1527, x1550, x1552, x1553, x1528, x1554, x1525, x1555, x1557, x1558, x1526, x1559, x1523, x1560, x1562, x1563, x1524, x1564, x1521, x1565, x1567, x1568, x1522, x1569, x1519, x1570, x1572, x1573, x1520, x1574, x1517, x1575, x1577, x1578, x1518, x1579, x1515, x1580, x1582, x1583, x1516, x1584, x1513, x1585, x1587, x1588, x1514, x1535, x1590, x1450, x1591, x1454, x1592, x1537, x1593, x1595, x1596, x1459, x1597, x1541, x1598, x1600, x1601, x1464, x1602, x1546, x1603, x1605, x1606, x1469, x1607, x1551, x1608, x1610, x1611, x1474, x1612, x1556, x1613, x1615, x1616, x1479, x1617, x1561, x1618, x1620, x1621, x1484, x1622, x1566, x1623, x1625, x1626, x1489, x1627, x1571, x1628, x1630, x1631, x1494, x1632, x1576, x1633, x1635, x1636, x1499, x1637, x1581, x1638, x1640, x1641, x1504, x1642, x1586, x1643, x1645, x1646, x1509, x1647, x1589, x1648, x1650, x1651, x1511, x29, x1673, x1676, x1678, x1674, x1679, x1671, x1680, x1682, x1683, x1672, x1684, x1669, x1685, x1687, x1688, x1670, x1689, x1667, x1690, x1692, x1693, x1668, x1694, x1665, x1695, x1697, x1698, x1666, x1699, x1663, x1700, x1702, x1703, x1664, x1704, x1661, x1705, x1707, x1708, x1662, x1709, x1659, x1710, x1712, x1713, x1660, x1714, x1657, x1715, x1717, x1718, x1658, x1719, x1655, x1720, x1722, x1723, x1656, x1724, x1653, x1725, x1727, x1728, x1654, x1675, x1594, x1731, x1599, x1732, x1677, x1733, x1735, x1736, x1604, x1737, x1681, x1738, x1740, x1741, x1609, x1742, x1686, x1743, x1745, x1746, x1614, x1747, x1691, x1748, x1750, x1751, x1619, x1752, x1696, x1753, x1755, x1756, x1624, x1757, x1701, x1758, x1760, x1761, x1629, x1762, x1706, x1763, x1765, x1766, x1634, x1767, x1711, x1768, x1770, x1771, x1639, x1772, x1716, x1773, x1775, x1776, x1644, x1777, x1721, x1778, x1780, x1781, x1649, x1782, x1726, x1783, x1785, x1786, x1652, x1787, x1729, x1788, x1790, x1792, x1813, x1816, x1818, x1814, x1819, x1811, x1820, x1822, x1823, x1812, x1824, x1809, x1825, x1827, x1828, x1810, x1829, x1807, x1830, x1832, x1833, x1808, x1834, x1805, x1835, x1837, x1838, x1806, x1839, x1803, x1840, x1842, x1843, x1804, x1844, x1801, x1845, x1847, x1848, x1802, x1849, x1799, x1850, x1852, x1853, x1800, x1854, x1797, x1855, x1857, x1858, x1798, x1859, x1795, x1860, x1862, x1863, x1796, x1864, x1793, x1865, x1867, x1868, x1794, x1815, x1870, x1730, x1871, x1734, x1872, x1817, x1873, x1875, x1876, x1739, x1877, x1821, x1878, x1880, x1881, x1744, x1882, x1826, x1883, x1885, x1886, x1749, x1887, x1831, x1888, x1890, x1891, x1754, x1892, x1836, x1893, x1895, x1896, x1759, x1897, x1841, x1898, x1900, x1901, x1764, x1902, x1846, x1903, x1905, x1906, x1769, x1907, x1851, x1908, x1910, x1911, x1774, x1912, x1856, x1913, x1915, x1916, x1779, x1917, x1861, x1918, x1920, x1921, x1784, x1922, x1866, x1923, x1925, x1926, x1789, x1927, x1869, x1928, x1930, x1931, x1791, x30, x1953, x1956, x1958, x1954, x1959, x1951, x1960, x1962, x1963, x1952, x1964, x1949, x1965, x1967, x1968, x1950, x1969, x1947, x1970, x1972, x1973, x1948, x1974, x1945, x1975, x1977, x1978, x1946, x1979, x1943, x1980, x1982, x1983, x1944, x1984, x1941, x1985, x1987, x1988, x1942, x1989, x1939, x1990, x1992, x1993, x1940, x1994, x1937, x1995, x1997, x1998, x1938, x1999, x1935, x2000, x2002, x2003, x1936, x2004, x1933, x2005, x2007, x2008, x1934, x1955, x1874, x2011, x1879, x2012, x1957, x2013, x2015, x2016, x1884, x2017, x1961, x2018, x2020, x2021, x1889, x2022, x1966, x2023, x2025, x2026, x1894, x2027, x1971, x2028, x2030, x2031, x1899, x2032, x1976, x2033, x2035, x2036, x1904, x2037, x1981, x2038, x2040, x2041, x1909, x2042, x1986, x2043, x2045, x2046, x1914, x2047, x1991, x2048, x2050, x2051, x1919, x2052, x1996, x2053, x2055, x2056, x1924, x2057, x2001, x2058, x2060, x2061, x1929, x2062, x2006, x2063, x2065, x2066, x1932, x2067, x2009, x2068, x2070, x2072, x2093, x2096, x2098, x2094, x2099, x2091, x2100, x2102, x2103, x2092, x2104, x2089, x2105, x2107, x2108, x2090, x2109, x2087, x2110, x2112, x2113, x2088, x2114, x2085, x2115, x2117, x2118, x2086, x2119, x2083, x2120, x2122, x2123, x2084, x2124, x2081, x2125, x2127, x2128, x2082, x2129, x2079, x2130, x2132, x2133, x2080, x2134, x2077, x2135, x2137, x2138, x2078, x2139, x2075, x2140, x2142, x2143, x2076, x2144, x2073, x2145, x2147, x2148, x2074, x2095, x2150, x2010, x2151, x2014, x2152, x2097, x2153, x2155, x2156, x2019, x2157, x2101, x2158, x2160, x2161, x2024, x2162, x2106, x2163, x2165, x2166, x2029, x2167, x2111, x2168, x2170, x2171, x2034, x2172, x2116, x2173, x2175, x2176, x2039, x2177, x2121, x2178, x2180, x2181, x2044, x2182, x2126, x2183, x2185, x2186, x2049, x2187, x2131, x2188, x2190, x2191, x2054, x2192, x2136, x2193, x2195, x2196, x2059, x2197, x2141, x2198, x2200, x2201, x2064, x2202, x2146, x2203, x2205, x2206, x2069, x2207, x2149, x2208, x2210, x2211, x2071, x31, x2233, x2236, x2238, x2234, x2239, x2231, x2240, x2242, x2243, x2232, x2244, x2229, x2245, x2247, x2248, x2230, x2249, x2227, x2250, x2252, x2253, x2228, x2254, x2225, x2255, x2257, x2258, x2226, x2259, x2223, x2260, x2262, x2263, x2224, x2264, x2221, x2265, x2267, x2268, x2222, x2269, x2219, x2270, x2272, x2273, x2220, x2274, x2217, x2275, x2277, x2278, x2218, x2279, x2215, x2280, x2282, x2283, x2216, x2284, x2213, x2285, x2287, x2288, x2214, x2235, x2154, x2291, x2159, x2292, x2237, x2293, x2295, x2296, x2164, x2297, x2241, x2298, x2300, x2301, x2169, x2302, x2246, x2303, x2305, x2306, x2174, x2307, x2251, x2308, x2310, x2311, x2179, x2312, x2256, x2313, x2315, x2316, x2184, x2317, x2261, x2318, x2320, x2321, x2189, x2322, x2266, x2323, x2325, x2326, x2194, x2327, x2271, x2328, x2330, x2331, x2199, x2332, x2276, x2333, x2335, x2336, x2204, x2337, x2281, x2338, x2340, x2341, x2209, x2342, x2286, x2343, x2345, x2346, x2212, x2347, x2289, x2348, x2350, x2352, x2373, x2376, x2378, x2374, x2379, x2371, x2380, x2382, x2383, x2372, x2384, x2369, x2385, x2387, x2388, x2370, x2389, x2367, x2390, x2392, x2393, x2368, x2394, x2365, x2395, x2397, x2398, x2366, x2399, x2363, x2400, x2402, x2403, x2364, x2404, x2361, x2405, x2407, x2408, x2362, x2409, x2359, x2410, x2412, x2413, x2360, x2414, x2357, x2415, x2417, x2418, x2358, x2419, x2355, x2420, x2422, x2423, x2356, x2424, x2353, x2425, x2427, x2428, x2354, x2375, x2430, x2290, x2431, x2294, x2432, x2377, x2433, x2435, x2436, x2299, x2437, x2381, x2438, x2440, x2441, x2304, x2442, x2386, x2443, x2445, x2446, x2309, x2447, x2391, x2448, x2450, x2451, x2314, x2452, x2396, x2453, x2455, x2456, x2319, x2457, x2401, x2458, x2460, x2461, x2324, x2462, x2406, x2463, x2465, x2466, x2329, x2467, x2411, x2468, x2470, x2471, x2334, x2472, x2416, x2473, x2475, x2476, x2339, x2477, x2421, x2478, x2480, x2481, x2344, x2482, x2426, x2483, x2485, x2486, x2349, x2487, x2429, x2488, x2490, x2491, x2351, x32, x2513, x2516, x2518, x2514, x2519, x2511, x2520, x2522, x2523, x2512, x2524, x2509, x2525, x2527, x2528, x2510, x2529, x2507, x2530, x2532, x2533, x2508, x2534, x2505, x2535, x2537, x2538, x2506, x2539, x2503, x2540, x2542, x2543, x2504, x2544, x2501, x2545, x2547, x2548, x2502, x2549, x2499, x2550, x2552, x2553, x2500, x2554, x2497, x2555, x2557, x2558, x2498, x2559, x2495, x2560, x2562, x2563, x2496, x2564, x2493, x2565, x2567, x2568, x2494, x2515, x2434, x2571, x2439, x2572, x2517, x2573, x2575, x2576, x2444, x2577, x2521, x2578, x2580, x2581, x2449, x2582, x2526, x2583, x2585, x2586, x2454, x2587, x2531, x2588, x2590, x2591, x2459, x2592, x2536, x2593, x2595, x2596, x2464, x2597, x2541, x2598, x2600, x2601, x2469, x2602, x2546, x2603, x2605, x2606, x2474, x2607, x2551, x2608, x2610, x2611, x2479, x2612, x2556, x2613, x2615, x2616, x2484, x2617, x2561, x2618, x2620, x2621, x2489, x2622, x2566, x2623, x2625, x2626, x2492, x2627, x2569, x2628, x2630, x2632, x2653, x2656, x2658, x2654, x2659, x2651, x2660, x2662, x2663, x2652, x2664, x2649, x2665, x2667, x2668, x2650, x2669, x2647, x2670, x2672, x2673, x2648, x2674, x2645, x2675, x2677, x2678, x2646, x2679, x2643, x2680, x2682, x2683, x2644, x2684, x2641, x2685, x2687, x2688, x2642, x2689, x2639, x2690, x2692, x2693, x2640, x2694, x2637, x2695, x2697, x2698, x2638, x2699, x2635, x2700, x2702, x2703, x2636, x2704, x2633, x2705, x2707, x2708, x2634, x2655, x2710, x2570, x2711, x2574, x2712, x2657, x2713, x2715, x2716, x2579, x2717, x2661, x2718, x2720, x2721, x2584, x2722, x2666, x2723, x2725, x2726, x2589, x2727, x2671, x2728, x2730, x2731, x2594, x2732, x2676, x2733, x2735, x2736, x2599, x2737, x2681, x2738, x2740, x2741, x2604, x2742, x2686, x2743, x2745, x2746, x2609, x2747, x2691, x2748, x2750, x2751, x2614, x2752, x2696, x2753, x2755, x2756, x2619, x2757, x2701, x2758, x2760, x2761, x2624, x2762, x2706, x2763, x2765, x2766, x2629, x2767, x2709, x2768, x2770, x2771, x2631, x33, x2793, x2796, x2798, x2794, x2799, x2791, x2800, x2802, x2803, x2792, x2804, x2789, x2805, x2807, x2808, x2790, x2809, x2787, x2810, x2812, x2813, x2788, x2814, x2785, x2815, x2817, x2818, x2786, x2819, x2783, x2820, x2822, x2823, x2784, x2824, x2781, x2825, x2827, x2828, x2782, x2829, x2779, x2830, x2832, x2833, x2780, x2834, x2777, x2835, x2837, x2838, x2778, x2839, x2775, x2840, x2842, x2843, x2776, x2844, x2773, x2845, x2847, x2848, x2774, x2795, x2714, x2851, x2719, x2852, x2797, x2853, x2855, x2856, x2724, x2857, x2801, x2858, x2860, x2861, x2729, x2862, x2806, x2863, x2865, x2866, x2734, x2867, x2811, x2868, x2870, x2871, x2739, x2872, x2816, x2873, x2875, x2876, x2744, x2877, x2821, x2878, x2880, x2881, x2749, x2882, x2826, x2883, x2885, x2886, x2754, x2887, x2831, x2888, x2890, x2891, x2759, x2892, x2836, x2893, x2895, x2896, x2764, x2897, x2841, x2898, x2900, x2901, x2769, x2902, x2846, x2903, x2905, x2906, x2772, x2907, x2849, x2908, x2910, x2912, x2933, x2936, x2938, x2934, x2939, x2931, x2940, x2942, x2943, x2932, x2944, x2929, x2945, x2947, x2948, x2930, x2949, x2927, x2950, x2952, x2953, x2928, x2954, x2925, x2955, x2957, x2958, x2926, x2959, x2923, x2960, x2962, x2963, x2924, x2964, x2921, x2965, x2967, x2968, x2922, x2969, x2919, x2970, x2972, x2973, x2920, x2974, x2917, x2975, x2977, x2978, x2918, x2979, x2915, x2980, x2982, x2983, x2916, x2984, x2913, x2985, x2987, x2988, x2914, x2935, x2990, x2850, x2991, x2854, x2992, x2937, x2993, x2995, x2996, x2859, x2997, x2941, x2998, x3000, x3001, x2864, x3002, x2946, x3003, x3005, x3006, x2869, x3007, x2951, x3008, x3010, x3011, x2874, x3012, x2956, x3013, x3015, x3016, x2879, x3017, x2961, x3018, x3020, x3021, x2884, x3022, x2966, x3023, x3025, x3026, x2889, x3027, x2971, x3028, x3030, x3031, x2894, x3032, x2976, x3033, x3035, x3036, x2899, x3037, x2981, x3038, x3040, x3041, x2904, x3042, x2986, x3043, x3045, x3046, x2909, x3047, x2989, x3048, x3050, x3051, x2911, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x34, x12, x3073, x3076, x3078, x3074, x3079, x3071, x3080, x3082, x3083, x3072, x3084, x3069, x3085, x3087, x3088, x3070, x3089, x3067, x3090, x3092, x3093, x3068, x3094, x3065, x3095, x3097, x3098, x3066, x3099, x3063, x3100, x3102, x3103, x3064, x3104, x3061, x3105, x3107, x3108, x3062, x3109, x3059, x3110, x3112, x3113, x3060, x3114, x3057, x3115, x3117, x3118, x3058, x3119, x3055, x3120, x3122, x3123, x3056, x3124, x3053, x3125, x3127, x3128, x3054, x3075, x2994, x3131, x2999, x3132, x3077, x3133, x3135, x3136, x3004, x3137, x3081, x3138, x3140, x3141, x3009, x3142, x3086, x3143, x3145, x3146, x3014, x3147, x3091, x3148, x3150, x3151, x3019, x3152, x3096, x3153, x3155, x3156, x3024, x3157, x3101, x3158, x3160, x3161, x3029, x3162, x3106, x3163, x3165, x3166, x3034, x3167, x3111, x3168, x3170, x3171, x3039, x3172, x3116, x3173, x3175, x3176, x3044, x3177, x3121, x3178, x3180, x3181, x3049, x3182, x3126, x3183, x3185, x3186, x3052, x3187, x3129, x3188, x3190, x3192, x3213, x3216, x3218, x3214, x3219, x3211, x3220, x3222, x3223, x3212, x3224, x3209, x3225, x3227, x3228, x3210, x3229, x3207, x3230, x3232, x3233, x3208, x3234, x3205, x3235, x3237, x3238, x3206, x3239, x3203, x3240, x3242, x3243, x3204, x3244, x3201, x3245, x3247, x3248, x3202, x3249, x3199, x3250, x3252, x3253, x3200, x3254, x3197, x3255, x3257, x3258, x3198, x3259, x3195, x3260, x3262, x3263, x3196, x3264, x3193, x3265, x3267, x3268, x3194, x3215, x3270, x3130, x3271, x3134, x3272, x3217, x3273, x3275, x3276, x3139, x3277, x3221, x3278, x3280, x3281, x3144, x3282, x3226, x3283, x3285, x3286, x3149, x3287, x3231, x3288, x3290, x3291, x3154, x3292, x3236, x3293, x3295, x3296, x3159, x3297, x3241, x3298, x3300, x3301, x3164, x3302, x3246, x3303, x3305, x3306, x3169, x3307, x3251, x3308, x3310, x3311, x3174, x3312, x3256, x3313, x3315, x3316, x3179, x3317, x3261, x3318, x3320, x3321, x3184, x3322, x3266, x3323, x3325, x3326, x3189, x3327, x3269, x3328, x3330, x3331, x3191, x3334, x3335, x3336, x3338, x3339, x3340, x3341, x3343, x3344, x3345, x3346, x3348, x3349, x3350, x3351, x3353, x3354, x3355, x3356, x3358, x3359, x3360, x3361, x3363, x3364, x3365, x3366, x3368, x3369, x3370, x3371, x3373, x3374, x3375, x3376, x3378, x3379, x3380, x3381, x3383, x3384, x3385, x3386, x3388, x3389, x3332, x3390, x3274, x3392, x3333, x3393, x3279, x3395, x3337, x3396, x3284, x3398, x3342, x3399, x3289, x3401, x3347, x3402, x3294, x3404, x3352, x3405, x3299, x3407, x3357, x3408, x3304, x3410, x3362, x3411, x3309, x3413, x3367, x3414, x3314, x3416, x3372, x3417, x3319, x3419, x3377, x3420, x3324, x3422, x3382, x3423, x3391, x3329, x3425, x3387, x3426, x3394, x3397, x3400, x3403, x3406, x3409, x3412, x3415, x3418, x3421, x3424, x3427, x3428, x3429, x3430, x3431, x3432, x3433, x3434, x3435, x3436, x3437, x3438, x3439; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x9 = _br2_load((in0)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x10 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x11 = _br2_load((in0)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + x12 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x16 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x17 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x18 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x19 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x20 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x21 = _br2_load((in1)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x22 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x23 = _br2_load((in1)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x24 = x1; + x25 = x2; + x26 = x3; + x27 = x4; + x28 = x5; + x29 = x6; + x30 = x7; + x31 = x8; + x32 = x9; + x33 = x10; + x34 = x11; + x35 = x0; + x36 = (x35)*(x23); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x23))>>32 : ((__uint128_t)(x35)*(x23))>>64); + x38 = (x35)*(x22); + x39 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x22))>>32 : ((__uint128_t)(x35)*(x22))>>64); + x40 = (x35)*(x21); + x41 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x21))>>32 : ((__uint128_t)(x35)*(x21))>>64); + x42 = (x35)*(x20); + x43 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x20))>>32 : ((__uint128_t)(x35)*(x20))>>64); + x44 = (x35)*(x19); + x45 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x19))>>32 : ((__uint128_t)(x35)*(x19))>>64); + x46 = (x35)*(x18); + x47 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x18))>>32 : ((__uint128_t)(x35)*(x18))>>64); + x48 = (x35)*(x17); + x49 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x17))>>32 : ((__uint128_t)(x35)*(x17))>>64); + x50 = (x35)*(x16); + x51 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x16))>>32 : ((__uint128_t)(x35)*(x16))>>64); + x52 = (x35)*(x15); + x53 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x15))>>32 : ((__uint128_t)(x35)*(x15))>>64); + x54 = (x35)*(x14); + x55 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x14))>>32 : ((__uint128_t)(x35)*(x14))>>64); + x56 = (x35)*(x13); + x57 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x13))>>32 : ((__uint128_t)(x35)*(x13))>>64); + x58 = (x35)*(x12); + x59 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x12))>>32 : ((__uint128_t)(x35)*(x12))>>64); + x60 = (x59)+(x56); + x61 = (uintptr_t)((x60)<(x59)); + x62 = (x61)+(x57); + x63 = (uintptr_t)((x62)<(x57)); + x64 = (x62)+(x54); + x65 = (uintptr_t)((x64)<(x54)); + x66 = (x63)+(x65); + x67 = (x66)+(x55); + x68 = (uintptr_t)((x67)<(x55)); + x69 = (x67)+(x52); + x70 = (uintptr_t)((x69)<(x52)); + x71 = (x68)+(x70); + x72 = (x71)+(x53); + x73 = (uintptr_t)((x72)<(x53)); + x74 = (x72)+(x50); + x75 = (uintptr_t)((x74)<(x50)); + x76 = (x73)+(x75); + x77 = (x76)+(x51); + x78 = (uintptr_t)((x77)<(x51)); + x79 = (x77)+(x48); + x80 = (uintptr_t)((x79)<(x48)); + x81 = (x78)+(x80); + x82 = (x81)+(x49); + x83 = (uintptr_t)((x82)<(x49)); + x84 = (x82)+(x46); + x85 = (uintptr_t)((x84)<(x46)); + x86 = (x83)+(x85); + x87 = (x86)+(x47); + x88 = (uintptr_t)((x87)<(x47)); + x89 = (x87)+(x44); + x90 = (uintptr_t)((x89)<(x44)); + x91 = (x88)+(x90); + x92 = (x91)+(x45); + x93 = (uintptr_t)((x92)<(x45)); + x94 = (x92)+(x42); + x95 = (uintptr_t)((x94)<(x42)); + x96 = (x93)+(x95); + x97 = (x96)+(x43); + x98 = (uintptr_t)((x97)<(x43)); + x99 = (x97)+(x40); + x100 = (uintptr_t)((x99)<(x40)); + x101 = (x98)+(x100); + x102 = (x101)+(x41); + x103 = (uintptr_t)((x102)<(x41)); + x104 = (x102)+(x38); + x105 = (uintptr_t)((x104)<(x38)); + x106 = (x103)+(x105); + x107 = (x106)+(x39); + x108 = (uintptr_t)((x107)<(x39)); + x109 = (x107)+(x36); + x110 = (uintptr_t)((x109)<(x36)); + x111 = (x108)+(x110); + x112 = (x111)+(x37); + x113 = (x58)*((uintptr_t)3901742149ULL); + x114 = (x113)*((uintptr_t)4294967295ULL); + x115 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x113)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x113)*((uintptr_t)4294967295ULL))>>64); + x116 = (x113)*((uintptr_t)4294967295ULL); + x117 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x113)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x113)*((uintptr_t)4294967295ULL))>>64); + x118 = (x113)*((uintptr_t)4294967295ULL); + x119 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x113)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x113)*((uintptr_t)4294967295ULL))>>64); + x120 = (x113)*((uintptr_t)4294967295ULL); + x121 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x113)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x113)*((uintptr_t)4294967295ULL))>>64); + x122 = (x113)*((uintptr_t)4294967295ULL); + x123 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x113)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x113)*((uintptr_t)4294967295ULL))>>64); + x124 = (x113)*((uintptr_t)4294967295ULL); + x125 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x113)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x113)*((uintptr_t)4294967295ULL))>>64); + x126 = (x113)*((uintptr_t)3345173889ULL); + x127 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x113)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x113)*((uintptr_t)3345173889ULL))>>64); + x128 = (x113)*((uintptr_t)4097256927ULL); + x129 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x113)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x113)*((uintptr_t)4097256927ULL))>>64); + x130 = (x113)*((uintptr_t)1478102450ULL); + x131 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x113)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x113)*((uintptr_t)1478102450ULL))>>64); + x132 = (x113)*((uintptr_t)1219536762ULL); + x133 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x113)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x113)*((uintptr_t)1219536762ULL))>>64); + x134 = (x113)*((uintptr_t)3974895978ULL); + x135 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x113)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x113)*((uintptr_t)3974895978ULL))>>64); + x136 = (x113)*((uintptr_t)3435473267ULL); + x137 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x113)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x113)*((uintptr_t)3435473267ULL))>>64); + x138 = (x137)+(x134); + x139 = (uintptr_t)((x138)<(x137)); + x140 = (x139)+(x135); + x141 = (uintptr_t)((x140)<(x135)); + x142 = (x140)+(x132); + x143 = (uintptr_t)((x142)<(x132)); + x144 = (x141)+(x143); + x145 = (x144)+(x133); + x146 = (uintptr_t)((x145)<(x133)); + x147 = (x145)+(x130); + x148 = (uintptr_t)((x147)<(x130)); + x149 = (x146)+(x148); + x150 = (x149)+(x131); + x151 = (uintptr_t)((x150)<(x131)); + x152 = (x150)+(x128); + x153 = (uintptr_t)((x152)<(x128)); + x154 = (x151)+(x153); + x155 = (x154)+(x129); + x156 = (uintptr_t)((x155)<(x129)); + x157 = (x155)+(x126); + x158 = (uintptr_t)((x157)<(x126)); + x159 = (x156)+(x158); + x160 = (x159)+(x127); + x161 = (uintptr_t)((x160)<(x127)); + x162 = (x160)+(x124); + x163 = (uintptr_t)((x162)<(x124)); + x164 = (x161)+(x163); + x165 = (x164)+(x125); + x166 = (uintptr_t)((x165)<(x125)); + x167 = (x165)+(x122); + x168 = (uintptr_t)((x167)<(x122)); + x169 = (x166)+(x168); + x170 = (x169)+(x123); + x171 = (uintptr_t)((x170)<(x123)); + x172 = (x170)+(x120); + x173 = (uintptr_t)((x172)<(x120)); + x174 = (x171)+(x173); + x175 = (x174)+(x121); + x176 = (uintptr_t)((x175)<(x121)); + x177 = (x175)+(x118); + x178 = (uintptr_t)((x177)<(x118)); + x179 = (x176)+(x178); + x180 = (x179)+(x119); + x181 = (uintptr_t)((x180)<(x119)); + x182 = (x180)+(x116); + x183 = (uintptr_t)((x182)<(x116)); + x184 = (x181)+(x183); + x185 = (x184)+(x117); + x186 = (uintptr_t)((x185)<(x117)); + x187 = (x185)+(x114); + x188 = (uintptr_t)((x187)<(x114)); + x189 = (x186)+(x188); + x190 = (x189)+(x115); + x191 = (x58)+(x136); + x192 = (uintptr_t)((x191)<(x58)); + x193 = (x192)+(x60); + x194 = (uintptr_t)((x193)<(x60)); + x195 = (x193)+(x138); + x196 = (uintptr_t)((x195)<(x138)); + x197 = (x194)+(x196); + x198 = (x197)+(x64); + x199 = (uintptr_t)((x198)<(x64)); + x200 = (x198)+(x142); + x201 = (uintptr_t)((x200)<(x142)); + x202 = (x199)+(x201); + x203 = (x202)+(x69); + x204 = (uintptr_t)((x203)<(x69)); + x205 = (x203)+(x147); + x206 = (uintptr_t)((x205)<(x147)); + x207 = (x204)+(x206); + x208 = (x207)+(x74); + x209 = (uintptr_t)((x208)<(x74)); + x210 = (x208)+(x152); + x211 = (uintptr_t)((x210)<(x152)); + x212 = (x209)+(x211); + x213 = (x212)+(x79); + x214 = (uintptr_t)((x213)<(x79)); + x215 = (x213)+(x157); + x216 = (uintptr_t)((x215)<(x157)); + x217 = (x214)+(x216); + x218 = (x217)+(x84); + x219 = (uintptr_t)((x218)<(x84)); + x220 = (x218)+(x162); + x221 = (uintptr_t)((x220)<(x162)); + x222 = (x219)+(x221); + x223 = (x222)+(x89); + x224 = (uintptr_t)((x223)<(x89)); + x225 = (x223)+(x167); + x226 = (uintptr_t)((x225)<(x167)); + x227 = (x224)+(x226); + x228 = (x227)+(x94); + x229 = (uintptr_t)((x228)<(x94)); + x230 = (x228)+(x172); + x231 = (uintptr_t)((x230)<(x172)); + x232 = (x229)+(x231); + x233 = (x232)+(x99); + x234 = (uintptr_t)((x233)<(x99)); + x235 = (x233)+(x177); + x236 = (uintptr_t)((x235)<(x177)); + x237 = (x234)+(x236); + x238 = (x237)+(x104); + x239 = (uintptr_t)((x238)<(x104)); + x240 = (x238)+(x182); + x241 = (uintptr_t)((x240)<(x182)); + x242 = (x239)+(x241); + x243 = (x242)+(x109); + x244 = (uintptr_t)((x243)<(x109)); + x245 = (x243)+(x187); + x246 = (uintptr_t)((x245)<(x187)); + x247 = (x244)+(x246); + x248 = (x247)+(x112); + x249 = (uintptr_t)((x248)<(x112)); + x250 = (x248)+(x190); + x251 = (uintptr_t)((x250)<(x190)); + x252 = (x249)+(x251); + x253 = (x24)*(x23); + x254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x23))>>32 : ((__uint128_t)(x24)*(x23))>>64); + x255 = (x24)*(x22); + x256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x22))>>32 : ((__uint128_t)(x24)*(x22))>>64); + x257 = (x24)*(x21); + x258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x21))>>32 : ((__uint128_t)(x24)*(x21))>>64); + x259 = (x24)*(x20); + x260 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x20))>>32 : ((__uint128_t)(x24)*(x20))>>64); + x261 = (x24)*(x19); + x262 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x19))>>32 : ((__uint128_t)(x24)*(x19))>>64); + x263 = (x24)*(x18); + x264 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x18))>>32 : ((__uint128_t)(x24)*(x18))>>64); + x265 = (x24)*(x17); + x266 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x17))>>32 : ((__uint128_t)(x24)*(x17))>>64); + x267 = (x24)*(x16); + x268 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x16))>>32 : ((__uint128_t)(x24)*(x16))>>64); + x269 = (x24)*(x15); + x270 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x15))>>32 : ((__uint128_t)(x24)*(x15))>>64); + x271 = (x24)*(x14); + x272 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x14))>>32 : ((__uint128_t)(x24)*(x14))>>64); + x273 = (x24)*(x13); + x274 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x13))>>32 : ((__uint128_t)(x24)*(x13))>>64); + x275 = (x24)*(x12); + x276 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x12))>>32 : ((__uint128_t)(x24)*(x12))>>64); + x277 = (x276)+(x273); + x278 = (uintptr_t)((x277)<(x276)); + x279 = (x278)+(x274); + x280 = (uintptr_t)((x279)<(x274)); + x281 = (x279)+(x271); + x282 = (uintptr_t)((x281)<(x271)); + x283 = (x280)+(x282); + x284 = (x283)+(x272); + x285 = (uintptr_t)((x284)<(x272)); + x286 = (x284)+(x269); + x287 = (uintptr_t)((x286)<(x269)); + x288 = (x285)+(x287); + x289 = (x288)+(x270); + x290 = (uintptr_t)((x289)<(x270)); + x291 = (x289)+(x267); + x292 = (uintptr_t)((x291)<(x267)); + x293 = (x290)+(x292); + x294 = (x293)+(x268); + x295 = (uintptr_t)((x294)<(x268)); + x296 = (x294)+(x265); + x297 = (uintptr_t)((x296)<(x265)); + x298 = (x295)+(x297); + x299 = (x298)+(x266); + x300 = (uintptr_t)((x299)<(x266)); + x301 = (x299)+(x263); + x302 = (uintptr_t)((x301)<(x263)); + x303 = (x300)+(x302); + x304 = (x303)+(x264); + x305 = (uintptr_t)((x304)<(x264)); + x306 = (x304)+(x261); + x307 = (uintptr_t)((x306)<(x261)); + x308 = (x305)+(x307); + x309 = (x308)+(x262); + x310 = (uintptr_t)((x309)<(x262)); + x311 = (x309)+(x259); + x312 = (uintptr_t)((x311)<(x259)); + x313 = (x310)+(x312); + x314 = (x313)+(x260); + x315 = (uintptr_t)((x314)<(x260)); + x316 = (x314)+(x257); + x317 = (uintptr_t)((x316)<(x257)); + x318 = (x315)+(x317); + x319 = (x318)+(x258); + x320 = (uintptr_t)((x319)<(x258)); + x321 = (x319)+(x255); + x322 = (uintptr_t)((x321)<(x255)); + x323 = (x320)+(x322); + x324 = (x323)+(x256); + x325 = (uintptr_t)((x324)<(x256)); + x326 = (x324)+(x253); + x327 = (uintptr_t)((x326)<(x253)); + x328 = (x325)+(x327); + x329 = (x328)+(x254); + x330 = (x195)+(x275); + x331 = (uintptr_t)((x330)<(x195)); + x332 = (x331)+(x200); + x333 = (uintptr_t)((x332)<(x200)); + x334 = (x332)+(x277); + x335 = (uintptr_t)((x334)<(x277)); + x336 = (x333)+(x335); + x337 = (x336)+(x205); + x338 = (uintptr_t)((x337)<(x205)); + x339 = (x337)+(x281); + x340 = (uintptr_t)((x339)<(x281)); + x341 = (x338)+(x340); + x342 = (x341)+(x210); + x343 = (uintptr_t)((x342)<(x210)); + x344 = (x342)+(x286); + x345 = (uintptr_t)((x344)<(x286)); + x346 = (x343)+(x345); + x347 = (x346)+(x215); + x348 = (uintptr_t)((x347)<(x215)); + x349 = (x347)+(x291); + x350 = (uintptr_t)((x349)<(x291)); + x351 = (x348)+(x350); + x352 = (x351)+(x220); + x353 = (uintptr_t)((x352)<(x220)); + x354 = (x352)+(x296); + x355 = (uintptr_t)((x354)<(x296)); + x356 = (x353)+(x355); + x357 = (x356)+(x225); + x358 = (uintptr_t)((x357)<(x225)); + x359 = (x357)+(x301); + x360 = (uintptr_t)((x359)<(x301)); + x361 = (x358)+(x360); + x362 = (x361)+(x230); + x363 = (uintptr_t)((x362)<(x230)); + x364 = (x362)+(x306); + x365 = (uintptr_t)((x364)<(x306)); + x366 = (x363)+(x365); + x367 = (x366)+(x235); + x368 = (uintptr_t)((x367)<(x235)); + x369 = (x367)+(x311); + x370 = (uintptr_t)((x369)<(x311)); + x371 = (x368)+(x370); + x372 = (x371)+(x240); + x373 = (uintptr_t)((x372)<(x240)); + x374 = (x372)+(x316); + x375 = (uintptr_t)((x374)<(x316)); + x376 = (x373)+(x375); + x377 = (x376)+(x245); + x378 = (uintptr_t)((x377)<(x245)); + x379 = (x377)+(x321); + x380 = (uintptr_t)((x379)<(x321)); + x381 = (x378)+(x380); + x382 = (x381)+(x250); + x383 = (uintptr_t)((x382)<(x250)); + x384 = (x382)+(x326); + x385 = (uintptr_t)((x384)<(x326)); + x386 = (x383)+(x385); + x387 = (x386)+(x252); + x388 = (uintptr_t)((x387)<(x252)); + x389 = (x387)+(x329); + x390 = (uintptr_t)((x389)<(x329)); + x391 = (x388)+(x390); + x392 = (x330)*((uintptr_t)3901742149ULL); + x393 = (x392)*((uintptr_t)4294967295ULL); + x394 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x392)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x392)*((uintptr_t)4294967295ULL))>>64); + x395 = (x392)*((uintptr_t)4294967295ULL); + x396 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x392)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x392)*((uintptr_t)4294967295ULL))>>64); + x397 = (x392)*((uintptr_t)4294967295ULL); + x398 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x392)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x392)*((uintptr_t)4294967295ULL))>>64); + x399 = (x392)*((uintptr_t)4294967295ULL); + x400 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x392)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x392)*((uintptr_t)4294967295ULL))>>64); + x401 = (x392)*((uintptr_t)4294967295ULL); + x402 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x392)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x392)*((uintptr_t)4294967295ULL))>>64); + x403 = (x392)*((uintptr_t)4294967295ULL); + x404 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x392)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x392)*((uintptr_t)4294967295ULL))>>64); + x405 = (x392)*((uintptr_t)3345173889ULL); + x406 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x392)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x392)*((uintptr_t)3345173889ULL))>>64); + x407 = (x392)*((uintptr_t)4097256927ULL); + x408 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x392)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x392)*((uintptr_t)4097256927ULL))>>64); + x409 = (x392)*((uintptr_t)1478102450ULL); + x410 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x392)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x392)*((uintptr_t)1478102450ULL))>>64); + x411 = (x392)*((uintptr_t)1219536762ULL); + x412 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x392)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x392)*((uintptr_t)1219536762ULL))>>64); + x413 = (x392)*((uintptr_t)3974895978ULL); + x414 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x392)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x392)*((uintptr_t)3974895978ULL))>>64); + x415 = (x392)*((uintptr_t)3435473267ULL); + x416 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x392)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x392)*((uintptr_t)3435473267ULL))>>64); + x417 = (x416)+(x413); + x418 = (uintptr_t)((x417)<(x416)); + x419 = (x418)+(x414); + x420 = (uintptr_t)((x419)<(x414)); + x421 = (x419)+(x411); + x422 = (uintptr_t)((x421)<(x411)); + x423 = (x420)+(x422); + x424 = (x423)+(x412); + x425 = (uintptr_t)((x424)<(x412)); + x426 = (x424)+(x409); + x427 = (uintptr_t)((x426)<(x409)); + x428 = (x425)+(x427); + x429 = (x428)+(x410); + x430 = (uintptr_t)((x429)<(x410)); + x431 = (x429)+(x407); + x432 = (uintptr_t)((x431)<(x407)); + x433 = (x430)+(x432); + x434 = (x433)+(x408); + x435 = (uintptr_t)((x434)<(x408)); + x436 = (x434)+(x405); + x437 = (uintptr_t)((x436)<(x405)); + x438 = (x435)+(x437); + x439 = (x438)+(x406); + x440 = (uintptr_t)((x439)<(x406)); + x441 = (x439)+(x403); + x442 = (uintptr_t)((x441)<(x403)); + x443 = (x440)+(x442); + x444 = (x443)+(x404); + x445 = (uintptr_t)((x444)<(x404)); + x446 = (x444)+(x401); + x447 = (uintptr_t)((x446)<(x401)); + x448 = (x445)+(x447); + x449 = (x448)+(x402); + x450 = (uintptr_t)((x449)<(x402)); + x451 = (x449)+(x399); + x452 = (uintptr_t)((x451)<(x399)); + x453 = (x450)+(x452); + x454 = (x453)+(x400); + x455 = (uintptr_t)((x454)<(x400)); + x456 = (x454)+(x397); + x457 = (uintptr_t)((x456)<(x397)); + x458 = (x455)+(x457); + x459 = (x458)+(x398); + x460 = (uintptr_t)((x459)<(x398)); + x461 = (x459)+(x395); + x462 = (uintptr_t)((x461)<(x395)); + x463 = (x460)+(x462); + x464 = (x463)+(x396); + x465 = (uintptr_t)((x464)<(x396)); + x466 = (x464)+(x393); + x467 = (uintptr_t)((x466)<(x393)); + x468 = (x465)+(x467); + x469 = (x468)+(x394); + x470 = (x330)+(x415); + x471 = (uintptr_t)((x470)<(x330)); + x472 = (x471)+(x334); + x473 = (uintptr_t)((x472)<(x334)); + x474 = (x472)+(x417); + x475 = (uintptr_t)((x474)<(x417)); + x476 = (x473)+(x475); + x477 = (x476)+(x339); + x478 = (uintptr_t)((x477)<(x339)); + x479 = (x477)+(x421); + x480 = (uintptr_t)((x479)<(x421)); + x481 = (x478)+(x480); + x482 = (x481)+(x344); + x483 = (uintptr_t)((x482)<(x344)); + x484 = (x482)+(x426); + x485 = (uintptr_t)((x484)<(x426)); + x486 = (x483)+(x485); + x487 = (x486)+(x349); + x488 = (uintptr_t)((x487)<(x349)); + x489 = (x487)+(x431); + x490 = (uintptr_t)((x489)<(x431)); + x491 = (x488)+(x490); + x492 = (x491)+(x354); + x493 = (uintptr_t)((x492)<(x354)); + x494 = (x492)+(x436); + x495 = (uintptr_t)((x494)<(x436)); + x496 = (x493)+(x495); + x497 = (x496)+(x359); + x498 = (uintptr_t)((x497)<(x359)); + x499 = (x497)+(x441); + x500 = (uintptr_t)((x499)<(x441)); + x501 = (x498)+(x500); + x502 = (x501)+(x364); + x503 = (uintptr_t)((x502)<(x364)); + x504 = (x502)+(x446); + x505 = (uintptr_t)((x504)<(x446)); + x506 = (x503)+(x505); + x507 = (x506)+(x369); + x508 = (uintptr_t)((x507)<(x369)); + x509 = (x507)+(x451); + x510 = (uintptr_t)((x509)<(x451)); + x511 = (x508)+(x510); + x512 = (x511)+(x374); + x513 = (uintptr_t)((x512)<(x374)); + x514 = (x512)+(x456); + x515 = (uintptr_t)((x514)<(x456)); + x516 = (x513)+(x515); + x517 = (x516)+(x379); + x518 = (uintptr_t)((x517)<(x379)); + x519 = (x517)+(x461); + x520 = (uintptr_t)((x519)<(x461)); + x521 = (x518)+(x520); + x522 = (x521)+(x384); + x523 = (uintptr_t)((x522)<(x384)); + x524 = (x522)+(x466); + x525 = (uintptr_t)((x524)<(x466)); + x526 = (x523)+(x525); + x527 = (x526)+(x389); + x528 = (uintptr_t)((x527)<(x389)); + x529 = (x527)+(x469); + x530 = (uintptr_t)((x529)<(x469)); + x531 = (x528)+(x530); + x532 = (x531)+(x391); + x533 = (x25)*(x23); + x534 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x23))>>32 : ((__uint128_t)(x25)*(x23))>>64); + x535 = (x25)*(x22); + x536 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x22))>>32 : ((__uint128_t)(x25)*(x22))>>64); + x537 = (x25)*(x21); + x538 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x21))>>32 : ((__uint128_t)(x25)*(x21))>>64); + x539 = (x25)*(x20); + x540 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x20))>>32 : ((__uint128_t)(x25)*(x20))>>64); + x541 = (x25)*(x19); + x542 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x19))>>32 : ((__uint128_t)(x25)*(x19))>>64); + x543 = (x25)*(x18); + x544 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x18))>>32 : ((__uint128_t)(x25)*(x18))>>64); + x545 = (x25)*(x17); + x546 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x17))>>32 : ((__uint128_t)(x25)*(x17))>>64); + x547 = (x25)*(x16); + x548 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x16))>>32 : ((__uint128_t)(x25)*(x16))>>64); + x549 = (x25)*(x15); + x550 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x15))>>32 : ((__uint128_t)(x25)*(x15))>>64); + x551 = (x25)*(x14); + x552 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x14))>>32 : ((__uint128_t)(x25)*(x14))>>64); + x553 = (x25)*(x13); + x554 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x13))>>32 : ((__uint128_t)(x25)*(x13))>>64); + x555 = (x25)*(x12); + x556 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x12))>>32 : ((__uint128_t)(x25)*(x12))>>64); + x557 = (x556)+(x553); + x558 = (uintptr_t)((x557)<(x556)); + x559 = (x558)+(x554); + x560 = (uintptr_t)((x559)<(x554)); + x561 = (x559)+(x551); + x562 = (uintptr_t)((x561)<(x551)); + x563 = (x560)+(x562); + x564 = (x563)+(x552); + x565 = (uintptr_t)((x564)<(x552)); + x566 = (x564)+(x549); + x567 = (uintptr_t)((x566)<(x549)); + x568 = (x565)+(x567); + x569 = (x568)+(x550); + x570 = (uintptr_t)((x569)<(x550)); + x571 = (x569)+(x547); + x572 = (uintptr_t)((x571)<(x547)); + x573 = (x570)+(x572); + x574 = (x573)+(x548); + x575 = (uintptr_t)((x574)<(x548)); + x576 = (x574)+(x545); + x577 = (uintptr_t)((x576)<(x545)); + x578 = (x575)+(x577); + x579 = (x578)+(x546); + x580 = (uintptr_t)((x579)<(x546)); + x581 = (x579)+(x543); + x582 = (uintptr_t)((x581)<(x543)); + x583 = (x580)+(x582); + x584 = (x583)+(x544); + x585 = (uintptr_t)((x584)<(x544)); + x586 = (x584)+(x541); + x587 = (uintptr_t)((x586)<(x541)); + x588 = (x585)+(x587); + x589 = (x588)+(x542); + x590 = (uintptr_t)((x589)<(x542)); + x591 = (x589)+(x539); + x592 = (uintptr_t)((x591)<(x539)); + x593 = (x590)+(x592); + x594 = (x593)+(x540); + x595 = (uintptr_t)((x594)<(x540)); + x596 = (x594)+(x537); + x597 = (uintptr_t)((x596)<(x537)); + x598 = (x595)+(x597); + x599 = (x598)+(x538); + x600 = (uintptr_t)((x599)<(x538)); + x601 = (x599)+(x535); + x602 = (uintptr_t)((x601)<(x535)); + x603 = (x600)+(x602); + x604 = (x603)+(x536); + x605 = (uintptr_t)((x604)<(x536)); + x606 = (x604)+(x533); + x607 = (uintptr_t)((x606)<(x533)); + x608 = (x605)+(x607); + x609 = (x608)+(x534); + x610 = (x474)+(x555); + x611 = (uintptr_t)((x610)<(x474)); + x612 = (x611)+(x479); + x613 = (uintptr_t)((x612)<(x479)); + x614 = (x612)+(x557); + x615 = (uintptr_t)((x614)<(x557)); + x616 = (x613)+(x615); + x617 = (x616)+(x484); + x618 = (uintptr_t)((x617)<(x484)); + x619 = (x617)+(x561); + x620 = (uintptr_t)((x619)<(x561)); + x621 = (x618)+(x620); + x622 = (x621)+(x489); + x623 = (uintptr_t)((x622)<(x489)); + x624 = (x622)+(x566); + x625 = (uintptr_t)((x624)<(x566)); + x626 = (x623)+(x625); + x627 = (x626)+(x494); + x628 = (uintptr_t)((x627)<(x494)); + x629 = (x627)+(x571); + x630 = (uintptr_t)((x629)<(x571)); + x631 = (x628)+(x630); + x632 = (x631)+(x499); + x633 = (uintptr_t)((x632)<(x499)); + x634 = (x632)+(x576); + x635 = (uintptr_t)((x634)<(x576)); + x636 = (x633)+(x635); + x637 = (x636)+(x504); + x638 = (uintptr_t)((x637)<(x504)); + x639 = (x637)+(x581); + x640 = (uintptr_t)((x639)<(x581)); + x641 = (x638)+(x640); + x642 = (x641)+(x509); + x643 = (uintptr_t)((x642)<(x509)); + x644 = (x642)+(x586); + x645 = (uintptr_t)((x644)<(x586)); + x646 = (x643)+(x645); + x647 = (x646)+(x514); + x648 = (uintptr_t)((x647)<(x514)); + x649 = (x647)+(x591); + x650 = (uintptr_t)((x649)<(x591)); + x651 = (x648)+(x650); + x652 = (x651)+(x519); + x653 = (uintptr_t)((x652)<(x519)); + x654 = (x652)+(x596); + x655 = (uintptr_t)((x654)<(x596)); + x656 = (x653)+(x655); + x657 = (x656)+(x524); + x658 = (uintptr_t)((x657)<(x524)); + x659 = (x657)+(x601); + x660 = (uintptr_t)((x659)<(x601)); + x661 = (x658)+(x660); + x662 = (x661)+(x529); + x663 = (uintptr_t)((x662)<(x529)); + x664 = (x662)+(x606); + x665 = (uintptr_t)((x664)<(x606)); + x666 = (x663)+(x665); + x667 = (x666)+(x532); + x668 = (uintptr_t)((x667)<(x532)); + x669 = (x667)+(x609); + x670 = (uintptr_t)((x669)<(x609)); + x671 = (x668)+(x670); + x672 = (x610)*((uintptr_t)3901742149ULL); + x673 = (x672)*((uintptr_t)4294967295ULL); + x674 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)4294967295ULL))>>64); + x675 = (x672)*((uintptr_t)4294967295ULL); + x676 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)4294967295ULL))>>64); + x677 = (x672)*((uintptr_t)4294967295ULL); + x678 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)4294967295ULL))>>64); + x679 = (x672)*((uintptr_t)4294967295ULL); + x680 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)4294967295ULL))>>64); + x681 = (x672)*((uintptr_t)4294967295ULL); + x682 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)4294967295ULL))>>64); + x683 = (x672)*((uintptr_t)4294967295ULL); + x684 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)4294967295ULL))>>64); + x685 = (x672)*((uintptr_t)3345173889ULL); + x686 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)3345173889ULL))>>64); + x687 = (x672)*((uintptr_t)4097256927ULL); + x688 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)4097256927ULL))>>64); + x689 = (x672)*((uintptr_t)1478102450ULL); + x690 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)1478102450ULL))>>64); + x691 = (x672)*((uintptr_t)1219536762ULL); + x692 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)1219536762ULL))>>64); + x693 = (x672)*((uintptr_t)3974895978ULL); + x694 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)3974895978ULL))>>64); + x695 = (x672)*((uintptr_t)3435473267ULL); + x696 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x672)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x672)*((uintptr_t)3435473267ULL))>>64); + x697 = (x696)+(x693); + x698 = (uintptr_t)((x697)<(x696)); + x699 = (x698)+(x694); + x700 = (uintptr_t)((x699)<(x694)); + x701 = (x699)+(x691); + x702 = (uintptr_t)((x701)<(x691)); + x703 = (x700)+(x702); + x704 = (x703)+(x692); + x705 = (uintptr_t)((x704)<(x692)); + x706 = (x704)+(x689); + x707 = (uintptr_t)((x706)<(x689)); + x708 = (x705)+(x707); + x709 = (x708)+(x690); + x710 = (uintptr_t)((x709)<(x690)); + x711 = (x709)+(x687); + x712 = (uintptr_t)((x711)<(x687)); + x713 = (x710)+(x712); + x714 = (x713)+(x688); + x715 = (uintptr_t)((x714)<(x688)); + x716 = (x714)+(x685); + x717 = (uintptr_t)((x716)<(x685)); + x718 = (x715)+(x717); + x719 = (x718)+(x686); + x720 = (uintptr_t)((x719)<(x686)); + x721 = (x719)+(x683); + x722 = (uintptr_t)((x721)<(x683)); + x723 = (x720)+(x722); + x724 = (x723)+(x684); + x725 = (uintptr_t)((x724)<(x684)); + x726 = (x724)+(x681); + x727 = (uintptr_t)((x726)<(x681)); + x728 = (x725)+(x727); + x729 = (x728)+(x682); + x730 = (uintptr_t)((x729)<(x682)); + x731 = (x729)+(x679); + x732 = (uintptr_t)((x731)<(x679)); + x733 = (x730)+(x732); + x734 = (x733)+(x680); + x735 = (uintptr_t)((x734)<(x680)); + x736 = (x734)+(x677); + x737 = (uintptr_t)((x736)<(x677)); + x738 = (x735)+(x737); + x739 = (x738)+(x678); + x740 = (uintptr_t)((x739)<(x678)); + x741 = (x739)+(x675); + x742 = (uintptr_t)((x741)<(x675)); + x743 = (x740)+(x742); + x744 = (x743)+(x676); + x745 = (uintptr_t)((x744)<(x676)); + x746 = (x744)+(x673); + x747 = (uintptr_t)((x746)<(x673)); + x748 = (x745)+(x747); + x749 = (x748)+(x674); + x750 = (x610)+(x695); + x751 = (uintptr_t)((x750)<(x610)); + x752 = (x751)+(x614); + x753 = (uintptr_t)((x752)<(x614)); + x754 = (x752)+(x697); + x755 = (uintptr_t)((x754)<(x697)); + x756 = (x753)+(x755); + x757 = (x756)+(x619); + x758 = (uintptr_t)((x757)<(x619)); + x759 = (x757)+(x701); + x760 = (uintptr_t)((x759)<(x701)); + x761 = (x758)+(x760); + x762 = (x761)+(x624); + x763 = (uintptr_t)((x762)<(x624)); + x764 = (x762)+(x706); + x765 = (uintptr_t)((x764)<(x706)); + x766 = (x763)+(x765); + x767 = (x766)+(x629); + x768 = (uintptr_t)((x767)<(x629)); + x769 = (x767)+(x711); + x770 = (uintptr_t)((x769)<(x711)); + x771 = (x768)+(x770); + x772 = (x771)+(x634); + x773 = (uintptr_t)((x772)<(x634)); + x774 = (x772)+(x716); + x775 = (uintptr_t)((x774)<(x716)); + x776 = (x773)+(x775); + x777 = (x776)+(x639); + x778 = (uintptr_t)((x777)<(x639)); + x779 = (x777)+(x721); + x780 = (uintptr_t)((x779)<(x721)); + x781 = (x778)+(x780); + x782 = (x781)+(x644); + x783 = (uintptr_t)((x782)<(x644)); + x784 = (x782)+(x726); + x785 = (uintptr_t)((x784)<(x726)); + x786 = (x783)+(x785); + x787 = (x786)+(x649); + x788 = (uintptr_t)((x787)<(x649)); + x789 = (x787)+(x731); + x790 = (uintptr_t)((x789)<(x731)); + x791 = (x788)+(x790); + x792 = (x791)+(x654); + x793 = (uintptr_t)((x792)<(x654)); + x794 = (x792)+(x736); + x795 = (uintptr_t)((x794)<(x736)); + x796 = (x793)+(x795); + x797 = (x796)+(x659); + x798 = (uintptr_t)((x797)<(x659)); + x799 = (x797)+(x741); + x800 = (uintptr_t)((x799)<(x741)); + x801 = (x798)+(x800); + x802 = (x801)+(x664); + x803 = (uintptr_t)((x802)<(x664)); + x804 = (x802)+(x746); + x805 = (uintptr_t)((x804)<(x746)); + x806 = (x803)+(x805); + x807 = (x806)+(x669); + x808 = (uintptr_t)((x807)<(x669)); + x809 = (x807)+(x749); + x810 = (uintptr_t)((x809)<(x749)); + x811 = (x808)+(x810); + x812 = (x811)+(x671); + x813 = (x26)*(x23); + x814 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x23))>>32 : ((__uint128_t)(x26)*(x23))>>64); + x815 = (x26)*(x22); + x816 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x22))>>32 : ((__uint128_t)(x26)*(x22))>>64); + x817 = (x26)*(x21); + x818 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x21))>>32 : ((__uint128_t)(x26)*(x21))>>64); + x819 = (x26)*(x20); + x820 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x20))>>32 : ((__uint128_t)(x26)*(x20))>>64); + x821 = (x26)*(x19); + x822 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x19))>>32 : ((__uint128_t)(x26)*(x19))>>64); + x823 = (x26)*(x18); + x824 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x18))>>32 : ((__uint128_t)(x26)*(x18))>>64); + x825 = (x26)*(x17); + x826 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x17))>>32 : ((__uint128_t)(x26)*(x17))>>64); + x827 = (x26)*(x16); + x828 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x16))>>32 : ((__uint128_t)(x26)*(x16))>>64); + x829 = (x26)*(x15); + x830 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x15))>>32 : ((__uint128_t)(x26)*(x15))>>64); + x831 = (x26)*(x14); + x832 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x14))>>32 : ((__uint128_t)(x26)*(x14))>>64); + x833 = (x26)*(x13); + x834 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x13))>>32 : ((__uint128_t)(x26)*(x13))>>64); + x835 = (x26)*(x12); + x836 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x12))>>32 : ((__uint128_t)(x26)*(x12))>>64); + x837 = (x836)+(x833); + x838 = (uintptr_t)((x837)<(x836)); + x839 = (x838)+(x834); + x840 = (uintptr_t)((x839)<(x834)); + x841 = (x839)+(x831); + x842 = (uintptr_t)((x841)<(x831)); + x843 = (x840)+(x842); + x844 = (x843)+(x832); + x845 = (uintptr_t)((x844)<(x832)); + x846 = (x844)+(x829); + x847 = (uintptr_t)((x846)<(x829)); + x848 = (x845)+(x847); + x849 = (x848)+(x830); + x850 = (uintptr_t)((x849)<(x830)); + x851 = (x849)+(x827); + x852 = (uintptr_t)((x851)<(x827)); + x853 = (x850)+(x852); + x854 = (x853)+(x828); + x855 = (uintptr_t)((x854)<(x828)); + x856 = (x854)+(x825); + x857 = (uintptr_t)((x856)<(x825)); + x858 = (x855)+(x857); + x859 = (x858)+(x826); + x860 = (uintptr_t)((x859)<(x826)); + x861 = (x859)+(x823); + x862 = (uintptr_t)((x861)<(x823)); + x863 = (x860)+(x862); + x864 = (x863)+(x824); + x865 = (uintptr_t)((x864)<(x824)); + x866 = (x864)+(x821); + x867 = (uintptr_t)((x866)<(x821)); + x868 = (x865)+(x867); + x869 = (x868)+(x822); + x870 = (uintptr_t)((x869)<(x822)); + x871 = (x869)+(x819); + x872 = (uintptr_t)((x871)<(x819)); + x873 = (x870)+(x872); + x874 = (x873)+(x820); + x875 = (uintptr_t)((x874)<(x820)); + x876 = (x874)+(x817); + x877 = (uintptr_t)((x876)<(x817)); + x878 = (x875)+(x877); + x879 = (x878)+(x818); + x880 = (uintptr_t)((x879)<(x818)); + x881 = (x879)+(x815); + x882 = (uintptr_t)((x881)<(x815)); + x883 = (x880)+(x882); + x884 = (x883)+(x816); + x885 = (uintptr_t)((x884)<(x816)); + x886 = (x884)+(x813); + x887 = (uintptr_t)((x886)<(x813)); + x888 = (x885)+(x887); + x889 = (x888)+(x814); + x890 = (x754)+(x835); + x891 = (uintptr_t)((x890)<(x754)); + x892 = (x891)+(x759); + x893 = (uintptr_t)((x892)<(x759)); + x894 = (x892)+(x837); + x895 = (uintptr_t)((x894)<(x837)); + x896 = (x893)+(x895); + x897 = (x896)+(x764); + x898 = (uintptr_t)((x897)<(x764)); + x899 = (x897)+(x841); + x900 = (uintptr_t)((x899)<(x841)); + x901 = (x898)+(x900); + x902 = (x901)+(x769); + x903 = (uintptr_t)((x902)<(x769)); + x904 = (x902)+(x846); + x905 = (uintptr_t)((x904)<(x846)); + x906 = (x903)+(x905); + x907 = (x906)+(x774); + x908 = (uintptr_t)((x907)<(x774)); + x909 = (x907)+(x851); + x910 = (uintptr_t)((x909)<(x851)); + x911 = (x908)+(x910); + x912 = (x911)+(x779); + x913 = (uintptr_t)((x912)<(x779)); + x914 = (x912)+(x856); + x915 = (uintptr_t)((x914)<(x856)); + x916 = (x913)+(x915); + x917 = (x916)+(x784); + x918 = (uintptr_t)((x917)<(x784)); + x919 = (x917)+(x861); + x920 = (uintptr_t)((x919)<(x861)); + x921 = (x918)+(x920); + x922 = (x921)+(x789); + x923 = (uintptr_t)((x922)<(x789)); + x924 = (x922)+(x866); + x925 = (uintptr_t)((x924)<(x866)); + x926 = (x923)+(x925); + x927 = (x926)+(x794); + x928 = (uintptr_t)((x927)<(x794)); + x929 = (x927)+(x871); + x930 = (uintptr_t)((x929)<(x871)); + x931 = (x928)+(x930); + x932 = (x931)+(x799); + x933 = (uintptr_t)((x932)<(x799)); + x934 = (x932)+(x876); + x935 = (uintptr_t)((x934)<(x876)); + x936 = (x933)+(x935); + x937 = (x936)+(x804); + x938 = (uintptr_t)((x937)<(x804)); + x939 = (x937)+(x881); + x940 = (uintptr_t)((x939)<(x881)); + x941 = (x938)+(x940); + x942 = (x941)+(x809); + x943 = (uintptr_t)((x942)<(x809)); + x944 = (x942)+(x886); + x945 = (uintptr_t)((x944)<(x886)); + x946 = (x943)+(x945); + x947 = (x946)+(x812); + x948 = (uintptr_t)((x947)<(x812)); + x949 = (x947)+(x889); + x950 = (uintptr_t)((x949)<(x889)); + x951 = (x948)+(x950); + x952 = (x890)*((uintptr_t)3901742149ULL); + x953 = (x952)*((uintptr_t)4294967295ULL); + x954 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x952)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x952)*((uintptr_t)4294967295ULL))>>64); + x955 = (x952)*((uintptr_t)4294967295ULL); + x956 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x952)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x952)*((uintptr_t)4294967295ULL))>>64); + x957 = (x952)*((uintptr_t)4294967295ULL); + x958 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x952)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x952)*((uintptr_t)4294967295ULL))>>64); + x959 = (x952)*((uintptr_t)4294967295ULL); + x960 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x952)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x952)*((uintptr_t)4294967295ULL))>>64); + x961 = (x952)*((uintptr_t)4294967295ULL); + x962 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x952)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x952)*((uintptr_t)4294967295ULL))>>64); + x963 = (x952)*((uintptr_t)4294967295ULL); + x964 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x952)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x952)*((uintptr_t)4294967295ULL))>>64); + x965 = (x952)*((uintptr_t)3345173889ULL); + x966 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x952)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x952)*((uintptr_t)3345173889ULL))>>64); + x967 = (x952)*((uintptr_t)4097256927ULL); + x968 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x952)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x952)*((uintptr_t)4097256927ULL))>>64); + x969 = (x952)*((uintptr_t)1478102450ULL); + x970 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x952)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x952)*((uintptr_t)1478102450ULL))>>64); + x971 = (x952)*((uintptr_t)1219536762ULL); + x972 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x952)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x952)*((uintptr_t)1219536762ULL))>>64); + x973 = (x952)*((uintptr_t)3974895978ULL); + x974 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x952)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x952)*((uintptr_t)3974895978ULL))>>64); + x975 = (x952)*((uintptr_t)3435473267ULL); + x976 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x952)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x952)*((uintptr_t)3435473267ULL))>>64); + x977 = (x976)+(x973); + x978 = (uintptr_t)((x977)<(x976)); + x979 = (x978)+(x974); + x980 = (uintptr_t)((x979)<(x974)); + x981 = (x979)+(x971); + x982 = (uintptr_t)((x981)<(x971)); + x983 = (x980)+(x982); + x984 = (x983)+(x972); + x985 = (uintptr_t)((x984)<(x972)); + x986 = (x984)+(x969); + x987 = (uintptr_t)((x986)<(x969)); + x988 = (x985)+(x987); + x989 = (x988)+(x970); + x990 = (uintptr_t)((x989)<(x970)); + x991 = (x989)+(x967); + x992 = (uintptr_t)((x991)<(x967)); + x993 = (x990)+(x992); + x994 = (x993)+(x968); + x995 = (uintptr_t)((x994)<(x968)); + x996 = (x994)+(x965); + x997 = (uintptr_t)((x996)<(x965)); + x998 = (x995)+(x997); + x999 = (x998)+(x966); + x1000 = (uintptr_t)((x999)<(x966)); + x1001 = (x999)+(x963); + x1002 = (uintptr_t)((x1001)<(x963)); + x1003 = (x1000)+(x1002); + x1004 = (x1003)+(x964); + x1005 = (uintptr_t)((x1004)<(x964)); + x1006 = (x1004)+(x961); + x1007 = (uintptr_t)((x1006)<(x961)); + x1008 = (x1005)+(x1007); + x1009 = (x1008)+(x962); + x1010 = (uintptr_t)((x1009)<(x962)); + x1011 = (x1009)+(x959); + x1012 = (uintptr_t)((x1011)<(x959)); + x1013 = (x1010)+(x1012); + x1014 = (x1013)+(x960); + x1015 = (uintptr_t)((x1014)<(x960)); + x1016 = (x1014)+(x957); + x1017 = (uintptr_t)((x1016)<(x957)); + x1018 = (x1015)+(x1017); + x1019 = (x1018)+(x958); + x1020 = (uintptr_t)((x1019)<(x958)); + x1021 = (x1019)+(x955); + x1022 = (uintptr_t)((x1021)<(x955)); + x1023 = (x1020)+(x1022); + x1024 = (x1023)+(x956); + x1025 = (uintptr_t)((x1024)<(x956)); + x1026 = (x1024)+(x953); + x1027 = (uintptr_t)((x1026)<(x953)); + x1028 = (x1025)+(x1027); + x1029 = (x1028)+(x954); + x1030 = (x890)+(x975); + x1031 = (uintptr_t)((x1030)<(x890)); + x1032 = (x1031)+(x894); + x1033 = (uintptr_t)((x1032)<(x894)); + x1034 = (x1032)+(x977); + x1035 = (uintptr_t)((x1034)<(x977)); + x1036 = (x1033)+(x1035); + x1037 = (x1036)+(x899); + x1038 = (uintptr_t)((x1037)<(x899)); + x1039 = (x1037)+(x981); + x1040 = (uintptr_t)((x1039)<(x981)); + x1041 = (x1038)+(x1040); + x1042 = (x1041)+(x904); + x1043 = (uintptr_t)((x1042)<(x904)); + x1044 = (x1042)+(x986); + x1045 = (uintptr_t)((x1044)<(x986)); + x1046 = (x1043)+(x1045); + x1047 = (x1046)+(x909); + x1048 = (uintptr_t)((x1047)<(x909)); + x1049 = (x1047)+(x991); + x1050 = (uintptr_t)((x1049)<(x991)); + x1051 = (x1048)+(x1050); + x1052 = (x1051)+(x914); + x1053 = (uintptr_t)((x1052)<(x914)); + x1054 = (x1052)+(x996); + x1055 = (uintptr_t)((x1054)<(x996)); + x1056 = (x1053)+(x1055); + x1057 = (x1056)+(x919); + x1058 = (uintptr_t)((x1057)<(x919)); + x1059 = (x1057)+(x1001); + x1060 = (uintptr_t)((x1059)<(x1001)); + x1061 = (x1058)+(x1060); + x1062 = (x1061)+(x924); + x1063 = (uintptr_t)((x1062)<(x924)); + x1064 = (x1062)+(x1006); + x1065 = (uintptr_t)((x1064)<(x1006)); + x1066 = (x1063)+(x1065); + x1067 = (x1066)+(x929); + x1068 = (uintptr_t)((x1067)<(x929)); + x1069 = (x1067)+(x1011); + x1070 = (uintptr_t)((x1069)<(x1011)); + x1071 = (x1068)+(x1070); + x1072 = (x1071)+(x934); + x1073 = (uintptr_t)((x1072)<(x934)); + x1074 = (x1072)+(x1016); + x1075 = (uintptr_t)((x1074)<(x1016)); + x1076 = (x1073)+(x1075); + x1077 = (x1076)+(x939); + x1078 = (uintptr_t)((x1077)<(x939)); + x1079 = (x1077)+(x1021); + x1080 = (uintptr_t)((x1079)<(x1021)); + x1081 = (x1078)+(x1080); + x1082 = (x1081)+(x944); + x1083 = (uintptr_t)((x1082)<(x944)); + x1084 = (x1082)+(x1026); + x1085 = (uintptr_t)((x1084)<(x1026)); + x1086 = (x1083)+(x1085); + x1087 = (x1086)+(x949); + x1088 = (uintptr_t)((x1087)<(x949)); + x1089 = (x1087)+(x1029); + x1090 = (uintptr_t)((x1089)<(x1029)); + x1091 = (x1088)+(x1090); + x1092 = (x1091)+(x951); + x1093 = (x27)*(x23); + x1094 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x23))>>32 : ((__uint128_t)(x27)*(x23))>>64); + x1095 = (x27)*(x22); + x1096 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x22))>>32 : ((__uint128_t)(x27)*(x22))>>64); + x1097 = (x27)*(x21); + x1098 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x21))>>32 : ((__uint128_t)(x27)*(x21))>>64); + x1099 = (x27)*(x20); + x1100 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x20))>>32 : ((__uint128_t)(x27)*(x20))>>64); + x1101 = (x27)*(x19); + x1102 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x19))>>32 : ((__uint128_t)(x27)*(x19))>>64); + x1103 = (x27)*(x18); + x1104 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x18))>>32 : ((__uint128_t)(x27)*(x18))>>64); + x1105 = (x27)*(x17); + x1106 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x17))>>32 : ((__uint128_t)(x27)*(x17))>>64); + x1107 = (x27)*(x16); + x1108 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x16))>>32 : ((__uint128_t)(x27)*(x16))>>64); + x1109 = (x27)*(x15); + x1110 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x15))>>32 : ((__uint128_t)(x27)*(x15))>>64); + x1111 = (x27)*(x14); + x1112 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x14))>>32 : ((__uint128_t)(x27)*(x14))>>64); + x1113 = (x27)*(x13); + x1114 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x13))>>32 : ((__uint128_t)(x27)*(x13))>>64); + x1115 = (x27)*(x12); + x1116 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x12))>>32 : ((__uint128_t)(x27)*(x12))>>64); + x1117 = (x1116)+(x1113); + x1118 = (uintptr_t)((x1117)<(x1116)); + x1119 = (x1118)+(x1114); + x1120 = (uintptr_t)((x1119)<(x1114)); + x1121 = (x1119)+(x1111); + x1122 = (uintptr_t)((x1121)<(x1111)); + x1123 = (x1120)+(x1122); + x1124 = (x1123)+(x1112); + x1125 = (uintptr_t)((x1124)<(x1112)); + x1126 = (x1124)+(x1109); + x1127 = (uintptr_t)((x1126)<(x1109)); + x1128 = (x1125)+(x1127); + x1129 = (x1128)+(x1110); + x1130 = (uintptr_t)((x1129)<(x1110)); + x1131 = (x1129)+(x1107); + x1132 = (uintptr_t)((x1131)<(x1107)); + x1133 = (x1130)+(x1132); + x1134 = (x1133)+(x1108); + x1135 = (uintptr_t)((x1134)<(x1108)); + x1136 = (x1134)+(x1105); + x1137 = (uintptr_t)((x1136)<(x1105)); + x1138 = (x1135)+(x1137); + x1139 = (x1138)+(x1106); + x1140 = (uintptr_t)((x1139)<(x1106)); + x1141 = (x1139)+(x1103); + x1142 = (uintptr_t)((x1141)<(x1103)); + x1143 = (x1140)+(x1142); + x1144 = (x1143)+(x1104); + x1145 = (uintptr_t)((x1144)<(x1104)); + x1146 = (x1144)+(x1101); + x1147 = (uintptr_t)((x1146)<(x1101)); + x1148 = (x1145)+(x1147); + x1149 = (x1148)+(x1102); + x1150 = (uintptr_t)((x1149)<(x1102)); + x1151 = (x1149)+(x1099); + x1152 = (uintptr_t)((x1151)<(x1099)); + x1153 = (x1150)+(x1152); + x1154 = (x1153)+(x1100); + x1155 = (uintptr_t)((x1154)<(x1100)); + x1156 = (x1154)+(x1097); + x1157 = (uintptr_t)((x1156)<(x1097)); + x1158 = (x1155)+(x1157); + x1159 = (x1158)+(x1098); + x1160 = (uintptr_t)((x1159)<(x1098)); + x1161 = (x1159)+(x1095); + x1162 = (uintptr_t)((x1161)<(x1095)); + x1163 = (x1160)+(x1162); + x1164 = (x1163)+(x1096); + x1165 = (uintptr_t)((x1164)<(x1096)); + x1166 = (x1164)+(x1093); + x1167 = (uintptr_t)((x1166)<(x1093)); + x1168 = (x1165)+(x1167); + x1169 = (x1168)+(x1094); + x1170 = (x1034)+(x1115); + x1171 = (uintptr_t)((x1170)<(x1034)); + x1172 = (x1171)+(x1039); + x1173 = (uintptr_t)((x1172)<(x1039)); + x1174 = (x1172)+(x1117); + x1175 = (uintptr_t)((x1174)<(x1117)); + x1176 = (x1173)+(x1175); + x1177 = (x1176)+(x1044); + x1178 = (uintptr_t)((x1177)<(x1044)); + x1179 = (x1177)+(x1121); + x1180 = (uintptr_t)((x1179)<(x1121)); + x1181 = (x1178)+(x1180); + x1182 = (x1181)+(x1049); + x1183 = (uintptr_t)((x1182)<(x1049)); + x1184 = (x1182)+(x1126); + x1185 = (uintptr_t)((x1184)<(x1126)); + x1186 = (x1183)+(x1185); + x1187 = (x1186)+(x1054); + x1188 = (uintptr_t)((x1187)<(x1054)); + x1189 = (x1187)+(x1131); + x1190 = (uintptr_t)((x1189)<(x1131)); + x1191 = (x1188)+(x1190); + x1192 = (x1191)+(x1059); + x1193 = (uintptr_t)((x1192)<(x1059)); + x1194 = (x1192)+(x1136); + x1195 = (uintptr_t)((x1194)<(x1136)); + x1196 = (x1193)+(x1195); + x1197 = (x1196)+(x1064); + x1198 = (uintptr_t)((x1197)<(x1064)); + x1199 = (x1197)+(x1141); + x1200 = (uintptr_t)((x1199)<(x1141)); + x1201 = (x1198)+(x1200); + x1202 = (x1201)+(x1069); + x1203 = (uintptr_t)((x1202)<(x1069)); + x1204 = (x1202)+(x1146); + x1205 = (uintptr_t)((x1204)<(x1146)); + x1206 = (x1203)+(x1205); + x1207 = (x1206)+(x1074); + x1208 = (uintptr_t)((x1207)<(x1074)); + x1209 = (x1207)+(x1151); + x1210 = (uintptr_t)((x1209)<(x1151)); + x1211 = (x1208)+(x1210); + x1212 = (x1211)+(x1079); + x1213 = (uintptr_t)((x1212)<(x1079)); + x1214 = (x1212)+(x1156); + x1215 = (uintptr_t)((x1214)<(x1156)); + x1216 = (x1213)+(x1215); + x1217 = (x1216)+(x1084); + x1218 = (uintptr_t)((x1217)<(x1084)); + x1219 = (x1217)+(x1161); + x1220 = (uintptr_t)((x1219)<(x1161)); + x1221 = (x1218)+(x1220); + x1222 = (x1221)+(x1089); + x1223 = (uintptr_t)((x1222)<(x1089)); + x1224 = (x1222)+(x1166); + x1225 = (uintptr_t)((x1224)<(x1166)); + x1226 = (x1223)+(x1225); + x1227 = (x1226)+(x1092); + x1228 = (uintptr_t)((x1227)<(x1092)); + x1229 = (x1227)+(x1169); + x1230 = (uintptr_t)((x1229)<(x1169)); + x1231 = (x1228)+(x1230); + x1232 = (x1170)*((uintptr_t)3901742149ULL); + x1233 = (x1232)*((uintptr_t)4294967295ULL); + x1234 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1232)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1232)*((uintptr_t)4294967295ULL))>>64); + x1235 = (x1232)*((uintptr_t)4294967295ULL); + x1236 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1232)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1232)*((uintptr_t)4294967295ULL))>>64); + x1237 = (x1232)*((uintptr_t)4294967295ULL); + x1238 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1232)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1232)*((uintptr_t)4294967295ULL))>>64); + x1239 = (x1232)*((uintptr_t)4294967295ULL); + x1240 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1232)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1232)*((uintptr_t)4294967295ULL))>>64); + x1241 = (x1232)*((uintptr_t)4294967295ULL); + x1242 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1232)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1232)*((uintptr_t)4294967295ULL))>>64); + x1243 = (x1232)*((uintptr_t)4294967295ULL); + x1244 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1232)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1232)*((uintptr_t)4294967295ULL))>>64); + x1245 = (x1232)*((uintptr_t)3345173889ULL); + x1246 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1232)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x1232)*((uintptr_t)3345173889ULL))>>64); + x1247 = (x1232)*((uintptr_t)4097256927ULL); + x1248 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1232)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x1232)*((uintptr_t)4097256927ULL))>>64); + x1249 = (x1232)*((uintptr_t)1478102450ULL); + x1250 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1232)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x1232)*((uintptr_t)1478102450ULL))>>64); + x1251 = (x1232)*((uintptr_t)1219536762ULL); + x1252 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1232)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x1232)*((uintptr_t)1219536762ULL))>>64); + x1253 = (x1232)*((uintptr_t)3974895978ULL); + x1254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1232)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x1232)*((uintptr_t)3974895978ULL))>>64); + x1255 = (x1232)*((uintptr_t)3435473267ULL); + x1256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1232)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x1232)*((uintptr_t)3435473267ULL))>>64); + x1257 = (x1256)+(x1253); + x1258 = (uintptr_t)((x1257)<(x1256)); + x1259 = (x1258)+(x1254); + x1260 = (uintptr_t)((x1259)<(x1254)); + x1261 = (x1259)+(x1251); + x1262 = (uintptr_t)((x1261)<(x1251)); + x1263 = (x1260)+(x1262); + x1264 = (x1263)+(x1252); + x1265 = (uintptr_t)((x1264)<(x1252)); + x1266 = (x1264)+(x1249); + x1267 = (uintptr_t)((x1266)<(x1249)); + x1268 = (x1265)+(x1267); + x1269 = (x1268)+(x1250); + x1270 = (uintptr_t)((x1269)<(x1250)); + x1271 = (x1269)+(x1247); + x1272 = (uintptr_t)((x1271)<(x1247)); + x1273 = (x1270)+(x1272); + x1274 = (x1273)+(x1248); + x1275 = (uintptr_t)((x1274)<(x1248)); + x1276 = (x1274)+(x1245); + x1277 = (uintptr_t)((x1276)<(x1245)); + x1278 = (x1275)+(x1277); + x1279 = (x1278)+(x1246); + x1280 = (uintptr_t)((x1279)<(x1246)); + x1281 = (x1279)+(x1243); + x1282 = (uintptr_t)((x1281)<(x1243)); + x1283 = (x1280)+(x1282); + x1284 = (x1283)+(x1244); + x1285 = (uintptr_t)((x1284)<(x1244)); + x1286 = (x1284)+(x1241); + x1287 = (uintptr_t)((x1286)<(x1241)); + x1288 = (x1285)+(x1287); + x1289 = (x1288)+(x1242); + x1290 = (uintptr_t)((x1289)<(x1242)); + x1291 = (x1289)+(x1239); + x1292 = (uintptr_t)((x1291)<(x1239)); + x1293 = (x1290)+(x1292); + x1294 = (x1293)+(x1240); + x1295 = (uintptr_t)((x1294)<(x1240)); + x1296 = (x1294)+(x1237); + x1297 = (uintptr_t)((x1296)<(x1237)); + x1298 = (x1295)+(x1297); + x1299 = (x1298)+(x1238); + x1300 = (uintptr_t)((x1299)<(x1238)); + x1301 = (x1299)+(x1235); + x1302 = (uintptr_t)((x1301)<(x1235)); + x1303 = (x1300)+(x1302); + x1304 = (x1303)+(x1236); + x1305 = (uintptr_t)((x1304)<(x1236)); + x1306 = (x1304)+(x1233); + x1307 = (uintptr_t)((x1306)<(x1233)); + x1308 = (x1305)+(x1307); + x1309 = (x1308)+(x1234); + x1310 = (x1170)+(x1255); + x1311 = (uintptr_t)((x1310)<(x1170)); + x1312 = (x1311)+(x1174); + x1313 = (uintptr_t)((x1312)<(x1174)); + x1314 = (x1312)+(x1257); + x1315 = (uintptr_t)((x1314)<(x1257)); + x1316 = (x1313)+(x1315); + x1317 = (x1316)+(x1179); + x1318 = (uintptr_t)((x1317)<(x1179)); + x1319 = (x1317)+(x1261); + x1320 = (uintptr_t)((x1319)<(x1261)); + x1321 = (x1318)+(x1320); + x1322 = (x1321)+(x1184); + x1323 = (uintptr_t)((x1322)<(x1184)); + x1324 = (x1322)+(x1266); + x1325 = (uintptr_t)((x1324)<(x1266)); + x1326 = (x1323)+(x1325); + x1327 = (x1326)+(x1189); + x1328 = (uintptr_t)((x1327)<(x1189)); + x1329 = (x1327)+(x1271); + x1330 = (uintptr_t)((x1329)<(x1271)); + x1331 = (x1328)+(x1330); + x1332 = (x1331)+(x1194); + x1333 = (uintptr_t)((x1332)<(x1194)); + x1334 = (x1332)+(x1276); + x1335 = (uintptr_t)((x1334)<(x1276)); + x1336 = (x1333)+(x1335); + x1337 = (x1336)+(x1199); + x1338 = (uintptr_t)((x1337)<(x1199)); + x1339 = (x1337)+(x1281); + x1340 = (uintptr_t)((x1339)<(x1281)); + x1341 = (x1338)+(x1340); + x1342 = (x1341)+(x1204); + x1343 = (uintptr_t)((x1342)<(x1204)); + x1344 = (x1342)+(x1286); + x1345 = (uintptr_t)((x1344)<(x1286)); + x1346 = (x1343)+(x1345); + x1347 = (x1346)+(x1209); + x1348 = (uintptr_t)((x1347)<(x1209)); + x1349 = (x1347)+(x1291); + x1350 = (uintptr_t)((x1349)<(x1291)); + x1351 = (x1348)+(x1350); + x1352 = (x1351)+(x1214); + x1353 = (uintptr_t)((x1352)<(x1214)); + x1354 = (x1352)+(x1296); + x1355 = (uintptr_t)((x1354)<(x1296)); + x1356 = (x1353)+(x1355); + x1357 = (x1356)+(x1219); + x1358 = (uintptr_t)((x1357)<(x1219)); + x1359 = (x1357)+(x1301); + x1360 = (uintptr_t)((x1359)<(x1301)); + x1361 = (x1358)+(x1360); + x1362 = (x1361)+(x1224); + x1363 = (uintptr_t)((x1362)<(x1224)); + x1364 = (x1362)+(x1306); + x1365 = (uintptr_t)((x1364)<(x1306)); + x1366 = (x1363)+(x1365); + x1367 = (x1366)+(x1229); + x1368 = (uintptr_t)((x1367)<(x1229)); + x1369 = (x1367)+(x1309); + x1370 = (uintptr_t)((x1369)<(x1309)); + x1371 = (x1368)+(x1370); + x1372 = (x1371)+(x1231); + x1373 = (x28)*(x23); + x1374 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x23))>>32 : ((__uint128_t)(x28)*(x23))>>64); + x1375 = (x28)*(x22); + x1376 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x22))>>32 : ((__uint128_t)(x28)*(x22))>>64); + x1377 = (x28)*(x21); + x1378 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x21))>>32 : ((__uint128_t)(x28)*(x21))>>64); + x1379 = (x28)*(x20); + x1380 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x20))>>32 : ((__uint128_t)(x28)*(x20))>>64); + x1381 = (x28)*(x19); + x1382 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x19))>>32 : ((__uint128_t)(x28)*(x19))>>64); + x1383 = (x28)*(x18); + x1384 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x18))>>32 : ((__uint128_t)(x28)*(x18))>>64); + x1385 = (x28)*(x17); + x1386 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x17))>>32 : ((__uint128_t)(x28)*(x17))>>64); + x1387 = (x28)*(x16); + x1388 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x16))>>32 : ((__uint128_t)(x28)*(x16))>>64); + x1389 = (x28)*(x15); + x1390 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x15))>>32 : ((__uint128_t)(x28)*(x15))>>64); + x1391 = (x28)*(x14); + x1392 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x14))>>32 : ((__uint128_t)(x28)*(x14))>>64); + x1393 = (x28)*(x13); + x1394 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x13))>>32 : ((__uint128_t)(x28)*(x13))>>64); + x1395 = (x28)*(x12); + x1396 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x12))>>32 : ((__uint128_t)(x28)*(x12))>>64); + x1397 = (x1396)+(x1393); + x1398 = (uintptr_t)((x1397)<(x1396)); + x1399 = (x1398)+(x1394); + x1400 = (uintptr_t)((x1399)<(x1394)); + x1401 = (x1399)+(x1391); + x1402 = (uintptr_t)((x1401)<(x1391)); + x1403 = (x1400)+(x1402); + x1404 = (x1403)+(x1392); + x1405 = (uintptr_t)((x1404)<(x1392)); + x1406 = (x1404)+(x1389); + x1407 = (uintptr_t)((x1406)<(x1389)); + x1408 = (x1405)+(x1407); + x1409 = (x1408)+(x1390); + x1410 = (uintptr_t)((x1409)<(x1390)); + x1411 = (x1409)+(x1387); + x1412 = (uintptr_t)((x1411)<(x1387)); + x1413 = (x1410)+(x1412); + x1414 = (x1413)+(x1388); + x1415 = (uintptr_t)((x1414)<(x1388)); + x1416 = (x1414)+(x1385); + x1417 = (uintptr_t)((x1416)<(x1385)); + x1418 = (x1415)+(x1417); + x1419 = (x1418)+(x1386); + x1420 = (uintptr_t)((x1419)<(x1386)); + x1421 = (x1419)+(x1383); + x1422 = (uintptr_t)((x1421)<(x1383)); + x1423 = (x1420)+(x1422); + x1424 = (x1423)+(x1384); + x1425 = (uintptr_t)((x1424)<(x1384)); + x1426 = (x1424)+(x1381); + x1427 = (uintptr_t)((x1426)<(x1381)); + x1428 = (x1425)+(x1427); + x1429 = (x1428)+(x1382); + x1430 = (uintptr_t)((x1429)<(x1382)); + x1431 = (x1429)+(x1379); + x1432 = (uintptr_t)((x1431)<(x1379)); + x1433 = (x1430)+(x1432); + x1434 = (x1433)+(x1380); + x1435 = (uintptr_t)((x1434)<(x1380)); + x1436 = (x1434)+(x1377); + x1437 = (uintptr_t)((x1436)<(x1377)); + x1438 = (x1435)+(x1437); + x1439 = (x1438)+(x1378); + x1440 = (uintptr_t)((x1439)<(x1378)); + x1441 = (x1439)+(x1375); + x1442 = (uintptr_t)((x1441)<(x1375)); + x1443 = (x1440)+(x1442); + x1444 = (x1443)+(x1376); + x1445 = (uintptr_t)((x1444)<(x1376)); + x1446 = (x1444)+(x1373); + x1447 = (uintptr_t)((x1446)<(x1373)); + x1448 = (x1445)+(x1447); + x1449 = (x1448)+(x1374); + x1450 = (x1314)+(x1395); + x1451 = (uintptr_t)((x1450)<(x1314)); + x1452 = (x1451)+(x1319); + x1453 = (uintptr_t)((x1452)<(x1319)); + x1454 = (x1452)+(x1397); + x1455 = (uintptr_t)((x1454)<(x1397)); + x1456 = (x1453)+(x1455); + x1457 = (x1456)+(x1324); + x1458 = (uintptr_t)((x1457)<(x1324)); + x1459 = (x1457)+(x1401); + x1460 = (uintptr_t)((x1459)<(x1401)); + x1461 = (x1458)+(x1460); + x1462 = (x1461)+(x1329); + x1463 = (uintptr_t)((x1462)<(x1329)); + x1464 = (x1462)+(x1406); + x1465 = (uintptr_t)((x1464)<(x1406)); + x1466 = (x1463)+(x1465); + x1467 = (x1466)+(x1334); + x1468 = (uintptr_t)((x1467)<(x1334)); + x1469 = (x1467)+(x1411); + x1470 = (uintptr_t)((x1469)<(x1411)); + x1471 = (x1468)+(x1470); + x1472 = (x1471)+(x1339); + x1473 = (uintptr_t)((x1472)<(x1339)); + x1474 = (x1472)+(x1416); + x1475 = (uintptr_t)((x1474)<(x1416)); + x1476 = (x1473)+(x1475); + x1477 = (x1476)+(x1344); + x1478 = (uintptr_t)((x1477)<(x1344)); + x1479 = (x1477)+(x1421); + x1480 = (uintptr_t)((x1479)<(x1421)); + x1481 = (x1478)+(x1480); + x1482 = (x1481)+(x1349); + x1483 = (uintptr_t)((x1482)<(x1349)); + x1484 = (x1482)+(x1426); + x1485 = (uintptr_t)((x1484)<(x1426)); + x1486 = (x1483)+(x1485); + x1487 = (x1486)+(x1354); + x1488 = (uintptr_t)((x1487)<(x1354)); + x1489 = (x1487)+(x1431); + x1490 = (uintptr_t)((x1489)<(x1431)); + x1491 = (x1488)+(x1490); + x1492 = (x1491)+(x1359); + x1493 = (uintptr_t)((x1492)<(x1359)); + x1494 = (x1492)+(x1436); + x1495 = (uintptr_t)((x1494)<(x1436)); + x1496 = (x1493)+(x1495); + x1497 = (x1496)+(x1364); + x1498 = (uintptr_t)((x1497)<(x1364)); + x1499 = (x1497)+(x1441); + x1500 = (uintptr_t)((x1499)<(x1441)); + x1501 = (x1498)+(x1500); + x1502 = (x1501)+(x1369); + x1503 = (uintptr_t)((x1502)<(x1369)); + x1504 = (x1502)+(x1446); + x1505 = (uintptr_t)((x1504)<(x1446)); + x1506 = (x1503)+(x1505); + x1507 = (x1506)+(x1372); + x1508 = (uintptr_t)((x1507)<(x1372)); + x1509 = (x1507)+(x1449); + x1510 = (uintptr_t)((x1509)<(x1449)); + x1511 = (x1508)+(x1510); + x1512 = (x1450)*((uintptr_t)3901742149ULL); + x1513 = (x1512)*((uintptr_t)4294967295ULL); + x1514 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1512)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1512)*((uintptr_t)4294967295ULL))>>64); + x1515 = (x1512)*((uintptr_t)4294967295ULL); + x1516 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1512)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1512)*((uintptr_t)4294967295ULL))>>64); + x1517 = (x1512)*((uintptr_t)4294967295ULL); + x1518 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1512)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1512)*((uintptr_t)4294967295ULL))>>64); + x1519 = (x1512)*((uintptr_t)4294967295ULL); + x1520 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1512)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1512)*((uintptr_t)4294967295ULL))>>64); + x1521 = (x1512)*((uintptr_t)4294967295ULL); + x1522 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1512)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1512)*((uintptr_t)4294967295ULL))>>64); + x1523 = (x1512)*((uintptr_t)4294967295ULL); + x1524 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1512)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1512)*((uintptr_t)4294967295ULL))>>64); + x1525 = (x1512)*((uintptr_t)3345173889ULL); + x1526 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1512)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x1512)*((uintptr_t)3345173889ULL))>>64); + x1527 = (x1512)*((uintptr_t)4097256927ULL); + x1528 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1512)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x1512)*((uintptr_t)4097256927ULL))>>64); + x1529 = (x1512)*((uintptr_t)1478102450ULL); + x1530 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1512)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x1512)*((uintptr_t)1478102450ULL))>>64); + x1531 = (x1512)*((uintptr_t)1219536762ULL); + x1532 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1512)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x1512)*((uintptr_t)1219536762ULL))>>64); + x1533 = (x1512)*((uintptr_t)3974895978ULL); + x1534 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1512)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x1512)*((uintptr_t)3974895978ULL))>>64); + x1535 = (x1512)*((uintptr_t)3435473267ULL); + x1536 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1512)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x1512)*((uintptr_t)3435473267ULL))>>64); + x1537 = (x1536)+(x1533); + x1538 = (uintptr_t)((x1537)<(x1536)); + x1539 = (x1538)+(x1534); + x1540 = (uintptr_t)((x1539)<(x1534)); + x1541 = (x1539)+(x1531); + x1542 = (uintptr_t)((x1541)<(x1531)); + x1543 = (x1540)+(x1542); + x1544 = (x1543)+(x1532); + x1545 = (uintptr_t)((x1544)<(x1532)); + x1546 = (x1544)+(x1529); + x1547 = (uintptr_t)((x1546)<(x1529)); + x1548 = (x1545)+(x1547); + x1549 = (x1548)+(x1530); + x1550 = (uintptr_t)((x1549)<(x1530)); + x1551 = (x1549)+(x1527); + x1552 = (uintptr_t)((x1551)<(x1527)); + x1553 = (x1550)+(x1552); + x1554 = (x1553)+(x1528); + x1555 = (uintptr_t)((x1554)<(x1528)); + x1556 = (x1554)+(x1525); + x1557 = (uintptr_t)((x1556)<(x1525)); + x1558 = (x1555)+(x1557); + x1559 = (x1558)+(x1526); + x1560 = (uintptr_t)((x1559)<(x1526)); + x1561 = (x1559)+(x1523); + x1562 = (uintptr_t)((x1561)<(x1523)); + x1563 = (x1560)+(x1562); + x1564 = (x1563)+(x1524); + x1565 = (uintptr_t)((x1564)<(x1524)); + x1566 = (x1564)+(x1521); + x1567 = (uintptr_t)((x1566)<(x1521)); + x1568 = (x1565)+(x1567); + x1569 = (x1568)+(x1522); + x1570 = (uintptr_t)((x1569)<(x1522)); + x1571 = (x1569)+(x1519); + x1572 = (uintptr_t)((x1571)<(x1519)); + x1573 = (x1570)+(x1572); + x1574 = (x1573)+(x1520); + x1575 = (uintptr_t)((x1574)<(x1520)); + x1576 = (x1574)+(x1517); + x1577 = (uintptr_t)((x1576)<(x1517)); + x1578 = (x1575)+(x1577); + x1579 = (x1578)+(x1518); + x1580 = (uintptr_t)((x1579)<(x1518)); + x1581 = (x1579)+(x1515); + x1582 = (uintptr_t)((x1581)<(x1515)); + x1583 = (x1580)+(x1582); + x1584 = (x1583)+(x1516); + x1585 = (uintptr_t)((x1584)<(x1516)); + x1586 = (x1584)+(x1513); + x1587 = (uintptr_t)((x1586)<(x1513)); + x1588 = (x1585)+(x1587); + x1589 = (x1588)+(x1514); + x1590 = (x1450)+(x1535); + x1591 = (uintptr_t)((x1590)<(x1450)); + x1592 = (x1591)+(x1454); + x1593 = (uintptr_t)((x1592)<(x1454)); + x1594 = (x1592)+(x1537); + x1595 = (uintptr_t)((x1594)<(x1537)); + x1596 = (x1593)+(x1595); + x1597 = (x1596)+(x1459); + x1598 = (uintptr_t)((x1597)<(x1459)); + x1599 = (x1597)+(x1541); + x1600 = (uintptr_t)((x1599)<(x1541)); + x1601 = (x1598)+(x1600); + x1602 = (x1601)+(x1464); + x1603 = (uintptr_t)((x1602)<(x1464)); + x1604 = (x1602)+(x1546); + x1605 = (uintptr_t)((x1604)<(x1546)); + x1606 = (x1603)+(x1605); + x1607 = (x1606)+(x1469); + x1608 = (uintptr_t)((x1607)<(x1469)); + x1609 = (x1607)+(x1551); + x1610 = (uintptr_t)((x1609)<(x1551)); + x1611 = (x1608)+(x1610); + x1612 = (x1611)+(x1474); + x1613 = (uintptr_t)((x1612)<(x1474)); + x1614 = (x1612)+(x1556); + x1615 = (uintptr_t)((x1614)<(x1556)); + x1616 = (x1613)+(x1615); + x1617 = (x1616)+(x1479); + x1618 = (uintptr_t)((x1617)<(x1479)); + x1619 = (x1617)+(x1561); + x1620 = (uintptr_t)((x1619)<(x1561)); + x1621 = (x1618)+(x1620); + x1622 = (x1621)+(x1484); + x1623 = (uintptr_t)((x1622)<(x1484)); + x1624 = (x1622)+(x1566); + x1625 = (uintptr_t)((x1624)<(x1566)); + x1626 = (x1623)+(x1625); + x1627 = (x1626)+(x1489); + x1628 = (uintptr_t)((x1627)<(x1489)); + x1629 = (x1627)+(x1571); + x1630 = (uintptr_t)((x1629)<(x1571)); + x1631 = (x1628)+(x1630); + x1632 = (x1631)+(x1494); + x1633 = (uintptr_t)((x1632)<(x1494)); + x1634 = (x1632)+(x1576); + x1635 = (uintptr_t)((x1634)<(x1576)); + x1636 = (x1633)+(x1635); + x1637 = (x1636)+(x1499); + x1638 = (uintptr_t)((x1637)<(x1499)); + x1639 = (x1637)+(x1581); + x1640 = (uintptr_t)((x1639)<(x1581)); + x1641 = (x1638)+(x1640); + x1642 = (x1641)+(x1504); + x1643 = (uintptr_t)((x1642)<(x1504)); + x1644 = (x1642)+(x1586); + x1645 = (uintptr_t)((x1644)<(x1586)); + x1646 = (x1643)+(x1645); + x1647 = (x1646)+(x1509); + x1648 = (uintptr_t)((x1647)<(x1509)); + x1649 = (x1647)+(x1589); + x1650 = (uintptr_t)((x1649)<(x1589)); + x1651 = (x1648)+(x1650); + x1652 = (x1651)+(x1511); + x1653 = (x29)*(x23); + x1654 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x23))>>32 : ((__uint128_t)(x29)*(x23))>>64); + x1655 = (x29)*(x22); + x1656 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x22))>>32 : ((__uint128_t)(x29)*(x22))>>64); + x1657 = (x29)*(x21); + x1658 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x21))>>32 : ((__uint128_t)(x29)*(x21))>>64); + x1659 = (x29)*(x20); + x1660 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x20))>>32 : ((__uint128_t)(x29)*(x20))>>64); + x1661 = (x29)*(x19); + x1662 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x19))>>32 : ((__uint128_t)(x29)*(x19))>>64); + x1663 = (x29)*(x18); + x1664 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x18))>>32 : ((__uint128_t)(x29)*(x18))>>64); + x1665 = (x29)*(x17); + x1666 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x17))>>32 : ((__uint128_t)(x29)*(x17))>>64); + x1667 = (x29)*(x16); + x1668 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x16))>>32 : ((__uint128_t)(x29)*(x16))>>64); + x1669 = (x29)*(x15); + x1670 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x15))>>32 : ((__uint128_t)(x29)*(x15))>>64); + x1671 = (x29)*(x14); + x1672 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x14))>>32 : ((__uint128_t)(x29)*(x14))>>64); + x1673 = (x29)*(x13); + x1674 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x13))>>32 : ((__uint128_t)(x29)*(x13))>>64); + x1675 = (x29)*(x12); + x1676 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x12))>>32 : ((__uint128_t)(x29)*(x12))>>64); + x1677 = (x1676)+(x1673); + x1678 = (uintptr_t)((x1677)<(x1676)); + x1679 = (x1678)+(x1674); + x1680 = (uintptr_t)((x1679)<(x1674)); + x1681 = (x1679)+(x1671); + x1682 = (uintptr_t)((x1681)<(x1671)); + x1683 = (x1680)+(x1682); + x1684 = (x1683)+(x1672); + x1685 = (uintptr_t)((x1684)<(x1672)); + x1686 = (x1684)+(x1669); + x1687 = (uintptr_t)((x1686)<(x1669)); + x1688 = (x1685)+(x1687); + x1689 = (x1688)+(x1670); + x1690 = (uintptr_t)((x1689)<(x1670)); + x1691 = (x1689)+(x1667); + x1692 = (uintptr_t)((x1691)<(x1667)); + x1693 = (x1690)+(x1692); + x1694 = (x1693)+(x1668); + x1695 = (uintptr_t)((x1694)<(x1668)); + x1696 = (x1694)+(x1665); + x1697 = (uintptr_t)((x1696)<(x1665)); + x1698 = (x1695)+(x1697); + x1699 = (x1698)+(x1666); + x1700 = (uintptr_t)((x1699)<(x1666)); + x1701 = (x1699)+(x1663); + x1702 = (uintptr_t)((x1701)<(x1663)); + x1703 = (x1700)+(x1702); + x1704 = (x1703)+(x1664); + x1705 = (uintptr_t)((x1704)<(x1664)); + x1706 = (x1704)+(x1661); + x1707 = (uintptr_t)((x1706)<(x1661)); + x1708 = (x1705)+(x1707); + x1709 = (x1708)+(x1662); + x1710 = (uintptr_t)((x1709)<(x1662)); + x1711 = (x1709)+(x1659); + x1712 = (uintptr_t)((x1711)<(x1659)); + x1713 = (x1710)+(x1712); + x1714 = (x1713)+(x1660); + x1715 = (uintptr_t)((x1714)<(x1660)); + x1716 = (x1714)+(x1657); + x1717 = (uintptr_t)((x1716)<(x1657)); + x1718 = (x1715)+(x1717); + x1719 = (x1718)+(x1658); + x1720 = (uintptr_t)((x1719)<(x1658)); + x1721 = (x1719)+(x1655); + x1722 = (uintptr_t)((x1721)<(x1655)); + x1723 = (x1720)+(x1722); + x1724 = (x1723)+(x1656); + x1725 = (uintptr_t)((x1724)<(x1656)); + x1726 = (x1724)+(x1653); + x1727 = (uintptr_t)((x1726)<(x1653)); + x1728 = (x1725)+(x1727); + x1729 = (x1728)+(x1654); + x1730 = (x1594)+(x1675); + x1731 = (uintptr_t)((x1730)<(x1594)); + x1732 = (x1731)+(x1599); + x1733 = (uintptr_t)((x1732)<(x1599)); + x1734 = (x1732)+(x1677); + x1735 = (uintptr_t)((x1734)<(x1677)); + x1736 = (x1733)+(x1735); + x1737 = (x1736)+(x1604); + x1738 = (uintptr_t)((x1737)<(x1604)); + x1739 = (x1737)+(x1681); + x1740 = (uintptr_t)((x1739)<(x1681)); + x1741 = (x1738)+(x1740); + x1742 = (x1741)+(x1609); + x1743 = (uintptr_t)((x1742)<(x1609)); + x1744 = (x1742)+(x1686); + x1745 = (uintptr_t)((x1744)<(x1686)); + x1746 = (x1743)+(x1745); + x1747 = (x1746)+(x1614); + x1748 = (uintptr_t)((x1747)<(x1614)); + x1749 = (x1747)+(x1691); + x1750 = (uintptr_t)((x1749)<(x1691)); + x1751 = (x1748)+(x1750); + x1752 = (x1751)+(x1619); + x1753 = (uintptr_t)((x1752)<(x1619)); + x1754 = (x1752)+(x1696); + x1755 = (uintptr_t)((x1754)<(x1696)); + x1756 = (x1753)+(x1755); + x1757 = (x1756)+(x1624); + x1758 = (uintptr_t)((x1757)<(x1624)); + x1759 = (x1757)+(x1701); + x1760 = (uintptr_t)((x1759)<(x1701)); + x1761 = (x1758)+(x1760); + x1762 = (x1761)+(x1629); + x1763 = (uintptr_t)((x1762)<(x1629)); + x1764 = (x1762)+(x1706); + x1765 = (uintptr_t)((x1764)<(x1706)); + x1766 = (x1763)+(x1765); + x1767 = (x1766)+(x1634); + x1768 = (uintptr_t)((x1767)<(x1634)); + x1769 = (x1767)+(x1711); + x1770 = (uintptr_t)((x1769)<(x1711)); + x1771 = (x1768)+(x1770); + x1772 = (x1771)+(x1639); + x1773 = (uintptr_t)((x1772)<(x1639)); + x1774 = (x1772)+(x1716); + x1775 = (uintptr_t)((x1774)<(x1716)); + x1776 = (x1773)+(x1775); + x1777 = (x1776)+(x1644); + x1778 = (uintptr_t)((x1777)<(x1644)); + x1779 = (x1777)+(x1721); + x1780 = (uintptr_t)((x1779)<(x1721)); + x1781 = (x1778)+(x1780); + x1782 = (x1781)+(x1649); + x1783 = (uintptr_t)((x1782)<(x1649)); + x1784 = (x1782)+(x1726); + x1785 = (uintptr_t)((x1784)<(x1726)); + x1786 = (x1783)+(x1785); + x1787 = (x1786)+(x1652); + x1788 = (uintptr_t)((x1787)<(x1652)); + x1789 = (x1787)+(x1729); + x1790 = (uintptr_t)((x1789)<(x1729)); + x1791 = (x1788)+(x1790); + x1792 = (x1730)*((uintptr_t)3901742149ULL); + x1793 = (x1792)*((uintptr_t)4294967295ULL); + x1794 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1792)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1792)*((uintptr_t)4294967295ULL))>>64); + x1795 = (x1792)*((uintptr_t)4294967295ULL); + x1796 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1792)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1792)*((uintptr_t)4294967295ULL))>>64); + x1797 = (x1792)*((uintptr_t)4294967295ULL); + x1798 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1792)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1792)*((uintptr_t)4294967295ULL))>>64); + x1799 = (x1792)*((uintptr_t)4294967295ULL); + x1800 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1792)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1792)*((uintptr_t)4294967295ULL))>>64); + x1801 = (x1792)*((uintptr_t)4294967295ULL); + x1802 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1792)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1792)*((uintptr_t)4294967295ULL))>>64); + x1803 = (x1792)*((uintptr_t)4294967295ULL); + x1804 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1792)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1792)*((uintptr_t)4294967295ULL))>>64); + x1805 = (x1792)*((uintptr_t)3345173889ULL); + x1806 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1792)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x1792)*((uintptr_t)3345173889ULL))>>64); + x1807 = (x1792)*((uintptr_t)4097256927ULL); + x1808 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1792)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x1792)*((uintptr_t)4097256927ULL))>>64); + x1809 = (x1792)*((uintptr_t)1478102450ULL); + x1810 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1792)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x1792)*((uintptr_t)1478102450ULL))>>64); + x1811 = (x1792)*((uintptr_t)1219536762ULL); + x1812 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1792)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x1792)*((uintptr_t)1219536762ULL))>>64); + x1813 = (x1792)*((uintptr_t)3974895978ULL); + x1814 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1792)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x1792)*((uintptr_t)3974895978ULL))>>64); + x1815 = (x1792)*((uintptr_t)3435473267ULL); + x1816 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1792)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x1792)*((uintptr_t)3435473267ULL))>>64); + x1817 = (x1816)+(x1813); + x1818 = (uintptr_t)((x1817)<(x1816)); + x1819 = (x1818)+(x1814); + x1820 = (uintptr_t)((x1819)<(x1814)); + x1821 = (x1819)+(x1811); + x1822 = (uintptr_t)((x1821)<(x1811)); + x1823 = (x1820)+(x1822); + x1824 = (x1823)+(x1812); + x1825 = (uintptr_t)((x1824)<(x1812)); + x1826 = (x1824)+(x1809); + x1827 = (uintptr_t)((x1826)<(x1809)); + x1828 = (x1825)+(x1827); + x1829 = (x1828)+(x1810); + x1830 = (uintptr_t)((x1829)<(x1810)); + x1831 = (x1829)+(x1807); + x1832 = (uintptr_t)((x1831)<(x1807)); + x1833 = (x1830)+(x1832); + x1834 = (x1833)+(x1808); + x1835 = (uintptr_t)((x1834)<(x1808)); + x1836 = (x1834)+(x1805); + x1837 = (uintptr_t)((x1836)<(x1805)); + x1838 = (x1835)+(x1837); + x1839 = (x1838)+(x1806); + x1840 = (uintptr_t)((x1839)<(x1806)); + x1841 = (x1839)+(x1803); + x1842 = (uintptr_t)((x1841)<(x1803)); + x1843 = (x1840)+(x1842); + x1844 = (x1843)+(x1804); + x1845 = (uintptr_t)((x1844)<(x1804)); + x1846 = (x1844)+(x1801); + x1847 = (uintptr_t)((x1846)<(x1801)); + x1848 = (x1845)+(x1847); + x1849 = (x1848)+(x1802); + x1850 = (uintptr_t)((x1849)<(x1802)); + x1851 = (x1849)+(x1799); + x1852 = (uintptr_t)((x1851)<(x1799)); + x1853 = (x1850)+(x1852); + x1854 = (x1853)+(x1800); + x1855 = (uintptr_t)((x1854)<(x1800)); + x1856 = (x1854)+(x1797); + x1857 = (uintptr_t)((x1856)<(x1797)); + x1858 = (x1855)+(x1857); + x1859 = (x1858)+(x1798); + x1860 = (uintptr_t)((x1859)<(x1798)); + x1861 = (x1859)+(x1795); + x1862 = (uintptr_t)((x1861)<(x1795)); + x1863 = (x1860)+(x1862); + x1864 = (x1863)+(x1796); + x1865 = (uintptr_t)((x1864)<(x1796)); + x1866 = (x1864)+(x1793); + x1867 = (uintptr_t)((x1866)<(x1793)); + x1868 = (x1865)+(x1867); + x1869 = (x1868)+(x1794); + x1870 = (x1730)+(x1815); + x1871 = (uintptr_t)((x1870)<(x1730)); + x1872 = (x1871)+(x1734); + x1873 = (uintptr_t)((x1872)<(x1734)); + x1874 = (x1872)+(x1817); + x1875 = (uintptr_t)((x1874)<(x1817)); + x1876 = (x1873)+(x1875); + x1877 = (x1876)+(x1739); + x1878 = (uintptr_t)((x1877)<(x1739)); + x1879 = (x1877)+(x1821); + x1880 = (uintptr_t)((x1879)<(x1821)); + x1881 = (x1878)+(x1880); + x1882 = (x1881)+(x1744); + x1883 = (uintptr_t)((x1882)<(x1744)); + x1884 = (x1882)+(x1826); + x1885 = (uintptr_t)((x1884)<(x1826)); + x1886 = (x1883)+(x1885); + x1887 = (x1886)+(x1749); + x1888 = (uintptr_t)((x1887)<(x1749)); + x1889 = (x1887)+(x1831); + x1890 = (uintptr_t)((x1889)<(x1831)); + x1891 = (x1888)+(x1890); + x1892 = (x1891)+(x1754); + x1893 = (uintptr_t)((x1892)<(x1754)); + x1894 = (x1892)+(x1836); + x1895 = (uintptr_t)((x1894)<(x1836)); + x1896 = (x1893)+(x1895); + x1897 = (x1896)+(x1759); + x1898 = (uintptr_t)((x1897)<(x1759)); + x1899 = (x1897)+(x1841); + x1900 = (uintptr_t)((x1899)<(x1841)); + x1901 = (x1898)+(x1900); + x1902 = (x1901)+(x1764); + x1903 = (uintptr_t)((x1902)<(x1764)); + x1904 = (x1902)+(x1846); + x1905 = (uintptr_t)((x1904)<(x1846)); + x1906 = (x1903)+(x1905); + x1907 = (x1906)+(x1769); + x1908 = (uintptr_t)((x1907)<(x1769)); + x1909 = (x1907)+(x1851); + x1910 = (uintptr_t)((x1909)<(x1851)); + x1911 = (x1908)+(x1910); + x1912 = (x1911)+(x1774); + x1913 = (uintptr_t)((x1912)<(x1774)); + x1914 = (x1912)+(x1856); + x1915 = (uintptr_t)((x1914)<(x1856)); + x1916 = (x1913)+(x1915); + x1917 = (x1916)+(x1779); + x1918 = (uintptr_t)((x1917)<(x1779)); + x1919 = (x1917)+(x1861); + x1920 = (uintptr_t)((x1919)<(x1861)); + x1921 = (x1918)+(x1920); + x1922 = (x1921)+(x1784); + x1923 = (uintptr_t)((x1922)<(x1784)); + x1924 = (x1922)+(x1866); + x1925 = (uintptr_t)((x1924)<(x1866)); + x1926 = (x1923)+(x1925); + x1927 = (x1926)+(x1789); + x1928 = (uintptr_t)((x1927)<(x1789)); + x1929 = (x1927)+(x1869); + x1930 = (uintptr_t)((x1929)<(x1869)); + x1931 = (x1928)+(x1930); + x1932 = (x1931)+(x1791); + x1933 = (x30)*(x23); + x1934 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x23))>>32 : ((__uint128_t)(x30)*(x23))>>64); + x1935 = (x30)*(x22); + x1936 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x22))>>32 : ((__uint128_t)(x30)*(x22))>>64); + x1937 = (x30)*(x21); + x1938 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x21))>>32 : ((__uint128_t)(x30)*(x21))>>64); + x1939 = (x30)*(x20); + x1940 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x20))>>32 : ((__uint128_t)(x30)*(x20))>>64); + x1941 = (x30)*(x19); + x1942 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x19))>>32 : ((__uint128_t)(x30)*(x19))>>64); + x1943 = (x30)*(x18); + x1944 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x18))>>32 : ((__uint128_t)(x30)*(x18))>>64); + x1945 = (x30)*(x17); + x1946 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x17))>>32 : ((__uint128_t)(x30)*(x17))>>64); + x1947 = (x30)*(x16); + x1948 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x16))>>32 : ((__uint128_t)(x30)*(x16))>>64); + x1949 = (x30)*(x15); + x1950 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x15))>>32 : ((__uint128_t)(x30)*(x15))>>64); + x1951 = (x30)*(x14); + x1952 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x14))>>32 : ((__uint128_t)(x30)*(x14))>>64); + x1953 = (x30)*(x13); + x1954 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x13))>>32 : ((__uint128_t)(x30)*(x13))>>64); + x1955 = (x30)*(x12); + x1956 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x12))>>32 : ((__uint128_t)(x30)*(x12))>>64); + x1957 = (x1956)+(x1953); + x1958 = (uintptr_t)((x1957)<(x1956)); + x1959 = (x1958)+(x1954); + x1960 = (uintptr_t)((x1959)<(x1954)); + x1961 = (x1959)+(x1951); + x1962 = (uintptr_t)((x1961)<(x1951)); + x1963 = (x1960)+(x1962); + x1964 = (x1963)+(x1952); + x1965 = (uintptr_t)((x1964)<(x1952)); + x1966 = (x1964)+(x1949); + x1967 = (uintptr_t)((x1966)<(x1949)); + x1968 = (x1965)+(x1967); + x1969 = (x1968)+(x1950); + x1970 = (uintptr_t)((x1969)<(x1950)); + x1971 = (x1969)+(x1947); + x1972 = (uintptr_t)((x1971)<(x1947)); + x1973 = (x1970)+(x1972); + x1974 = (x1973)+(x1948); + x1975 = (uintptr_t)((x1974)<(x1948)); + x1976 = (x1974)+(x1945); + x1977 = (uintptr_t)((x1976)<(x1945)); + x1978 = (x1975)+(x1977); + x1979 = (x1978)+(x1946); + x1980 = (uintptr_t)((x1979)<(x1946)); + x1981 = (x1979)+(x1943); + x1982 = (uintptr_t)((x1981)<(x1943)); + x1983 = (x1980)+(x1982); + x1984 = (x1983)+(x1944); + x1985 = (uintptr_t)((x1984)<(x1944)); + x1986 = (x1984)+(x1941); + x1987 = (uintptr_t)((x1986)<(x1941)); + x1988 = (x1985)+(x1987); + x1989 = (x1988)+(x1942); + x1990 = (uintptr_t)((x1989)<(x1942)); + x1991 = (x1989)+(x1939); + x1992 = (uintptr_t)((x1991)<(x1939)); + x1993 = (x1990)+(x1992); + x1994 = (x1993)+(x1940); + x1995 = (uintptr_t)((x1994)<(x1940)); + x1996 = (x1994)+(x1937); + x1997 = (uintptr_t)((x1996)<(x1937)); + x1998 = (x1995)+(x1997); + x1999 = (x1998)+(x1938); + x2000 = (uintptr_t)((x1999)<(x1938)); + x2001 = (x1999)+(x1935); + x2002 = (uintptr_t)((x2001)<(x1935)); + x2003 = (x2000)+(x2002); + x2004 = (x2003)+(x1936); + x2005 = (uintptr_t)((x2004)<(x1936)); + x2006 = (x2004)+(x1933); + x2007 = (uintptr_t)((x2006)<(x1933)); + x2008 = (x2005)+(x2007); + x2009 = (x2008)+(x1934); + x2010 = (x1874)+(x1955); + x2011 = (uintptr_t)((x2010)<(x1874)); + x2012 = (x2011)+(x1879); + x2013 = (uintptr_t)((x2012)<(x1879)); + x2014 = (x2012)+(x1957); + x2015 = (uintptr_t)((x2014)<(x1957)); + x2016 = (x2013)+(x2015); + x2017 = (x2016)+(x1884); + x2018 = (uintptr_t)((x2017)<(x1884)); + x2019 = (x2017)+(x1961); + x2020 = (uintptr_t)((x2019)<(x1961)); + x2021 = (x2018)+(x2020); + x2022 = (x2021)+(x1889); + x2023 = (uintptr_t)((x2022)<(x1889)); + x2024 = (x2022)+(x1966); + x2025 = (uintptr_t)((x2024)<(x1966)); + x2026 = (x2023)+(x2025); + x2027 = (x2026)+(x1894); + x2028 = (uintptr_t)((x2027)<(x1894)); + x2029 = (x2027)+(x1971); + x2030 = (uintptr_t)((x2029)<(x1971)); + x2031 = (x2028)+(x2030); + x2032 = (x2031)+(x1899); + x2033 = (uintptr_t)((x2032)<(x1899)); + x2034 = (x2032)+(x1976); + x2035 = (uintptr_t)((x2034)<(x1976)); + x2036 = (x2033)+(x2035); + x2037 = (x2036)+(x1904); + x2038 = (uintptr_t)((x2037)<(x1904)); + x2039 = (x2037)+(x1981); + x2040 = (uintptr_t)((x2039)<(x1981)); + x2041 = (x2038)+(x2040); + x2042 = (x2041)+(x1909); + x2043 = (uintptr_t)((x2042)<(x1909)); + x2044 = (x2042)+(x1986); + x2045 = (uintptr_t)((x2044)<(x1986)); + x2046 = (x2043)+(x2045); + x2047 = (x2046)+(x1914); + x2048 = (uintptr_t)((x2047)<(x1914)); + x2049 = (x2047)+(x1991); + x2050 = (uintptr_t)((x2049)<(x1991)); + x2051 = (x2048)+(x2050); + x2052 = (x2051)+(x1919); + x2053 = (uintptr_t)((x2052)<(x1919)); + x2054 = (x2052)+(x1996); + x2055 = (uintptr_t)((x2054)<(x1996)); + x2056 = (x2053)+(x2055); + x2057 = (x2056)+(x1924); + x2058 = (uintptr_t)((x2057)<(x1924)); + x2059 = (x2057)+(x2001); + x2060 = (uintptr_t)((x2059)<(x2001)); + x2061 = (x2058)+(x2060); + x2062 = (x2061)+(x1929); + x2063 = (uintptr_t)((x2062)<(x1929)); + x2064 = (x2062)+(x2006); + x2065 = (uintptr_t)((x2064)<(x2006)); + x2066 = (x2063)+(x2065); + x2067 = (x2066)+(x1932); + x2068 = (uintptr_t)((x2067)<(x1932)); + x2069 = (x2067)+(x2009); + x2070 = (uintptr_t)((x2069)<(x2009)); + x2071 = (x2068)+(x2070); + x2072 = (x2010)*((uintptr_t)3901742149ULL); + x2073 = (x2072)*((uintptr_t)4294967295ULL); + x2074 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2072)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2072)*((uintptr_t)4294967295ULL))>>64); + x2075 = (x2072)*((uintptr_t)4294967295ULL); + x2076 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2072)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2072)*((uintptr_t)4294967295ULL))>>64); + x2077 = (x2072)*((uintptr_t)4294967295ULL); + x2078 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2072)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2072)*((uintptr_t)4294967295ULL))>>64); + x2079 = (x2072)*((uintptr_t)4294967295ULL); + x2080 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2072)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2072)*((uintptr_t)4294967295ULL))>>64); + x2081 = (x2072)*((uintptr_t)4294967295ULL); + x2082 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2072)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2072)*((uintptr_t)4294967295ULL))>>64); + x2083 = (x2072)*((uintptr_t)4294967295ULL); + x2084 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2072)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2072)*((uintptr_t)4294967295ULL))>>64); + x2085 = (x2072)*((uintptr_t)3345173889ULL); + x2086 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2072)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x2072)*((uintptr_t)3345173889ULL))>>64); + x2087 = (x2072)*((uintptr_t)4097256927ULL); + x2088 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2072)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x2072)*((uintptr_t)4097256927ULL))>>64); + x2089 = (x2072)*((uintptr_t)1478102450ULL); + x2090 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2072)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x2072)*((uintptr_t)1478102450ULL))>>64); + x2091 = (x2072)*((uintptr_t)1219536762ULL); + x2092 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2072)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x2072)*((uintptr_t)1219536762ULL))>>64); + x2093 = (x2072)*((uintptr_t)3974895978ULL); + x2094 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2072)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x2072)*((uintptr_t)3974895978ULL))>>64); + x2095 = (x2072)*((uintptr_t)3435473267ULL); + x2096 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2072)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x2072)*((uintptr_t)3435473267ULL))>>64); + x2097 = (x2096)+(x2093); + x2098 = (uintptr_t)((x2097)<(x2096)); + x2099 = (x2098)+(x2094); + x2100 = (uintptr_t)((x2099)<(x2094)); + x2101 = (x2099)+(x2091); + x2102 = (uintptr_t)((x2101)<(x2091)); + x2103 = (x2100)+(x2102); + x2104 = (x2103)+(x2092); + x2105 = (uintptr_t)((x2104)<(x2092)); + x2106 = (x2104)+(x2089); + x2107 = (uintptr_t)((x2106)<(x2089)); + x2108 = (x2105)+(x2107); + x2109 = (x2108)+(x2090); + x2110 = (uintptr_t)((x2109)<(x2090)); + x2111 = (x2109)+(x2087); + x2112 = (uintptr_t)((x2111)<(x2087)); + x2113 = (x2110)+(x2112); + x2114 = (x2113)+(x2088); + x2115 = (uintptr_t)((x2114)<(x2088)); + x2116 = (x2114)+(x2085); + x2117 = (uintptr_t)((x2116)<(x2085)); + x2118 = (x2115)+(x2117); + x2119 = (x2118)+(x2086); + x2120 = (uintptr_t)((x2119)<(x2086)); + x2121 = (x2119)+(x2083); + x2122 = (uintptr_t)((x2121)<(x2083)); + x2123 = (x2120)+(x2122); + x2124 = (x2123)+(x2084); + x2125 = (uintptr_t)((x2124)<(x2084)); + x2126 = (x2124)+(x2081); + x2127 = (uintptr_t)((x2126)<(x2081)); + x2128 = (x2125)+(x2127); + x2129 = (x2128)+(x2082); + x2130 = (uintptr_t)((x2129)<(x2082)); + x2131 = (x2129)+(x2079); + x2132 = (uintptr_t)((x2131)<(x2079)); + x2133 = (x2130)+(x2132); + x2134 = (x2133)+(x2080); + x2135 = (uintptr_t)((x2134)<(x2080)); + x2136 = (x2134)+(x2077); + x2137 = (uintptr_t)((x2136)<(x2077)); + x2138 = (x2135)+(x2137); + x2139 = (x2138)+(x2078); + x2140 = (uintptr_t)((x2139)<(x2078)); + x2141 = (x2139)+(x2075); + x2142 = (uintptr_t)((x2141)<(x2075)); + x2143 = (x2140)+(x2142); + x2144 = (x2143)+(x2076); + x2145 = (uintptr_t)((x2144)<(x2076)); + x2146 = (x2144)+(x2073); + x2147 = (uintptr_t)((x2146)<(x2073)); + x2148 = (x2145)+(x2147); + x2149 = (x2148)+(x2074); + x2150 = (x2010)+(x2095); + x2151 = (uintptr_t)((x2150)<(x2010)); + x2152 = (x2151)+(x2014); + x2153 = (uintptr_t)((x2152)<(x2014)); + x2154 = (x2152)+(x2097); + x2155 = (uintptr_t)((x2154)<(x2097)); + x2156 = (x2153)+(x2155); + x2157 = (x2156)+(x2019); + x2158 = (uintptr_t)((x2157)<(x2019)); + x2159 = (x2157)+(x2101); + x2160 = (uintptr_t)((x2159)<(x2101)); + x2161 = (x2158)+(x2160); + x2162 = (x2161)+(x2024); + x2163 = (uintptr_t)((x2162)<(x2024)); + x2164 = (x2162)+(x2106); + x2165 = (uintptr_t)((x2164)<(x2106)); + x2166 = (x2163)+(x2165); + x2167 = (x2166)+(x2029); + x2168 = (uintptr_t)((x2167)<(x2029)); + x2169 = (x2167)+(x2111); + x2170 = (uintptr_t)((x2169)<(x2111)); + x2171 = (x2168)+(x2170); + x2172 = (x2171)+(x2034); + x2173 = (uintptr_t)((x2172)<(x2034)); + x2174 = (x2172)+(x2116); + x2175 = (uintptr_t)((x2174)<(x2116)); + x2176 = (x2173)+(x2175); + x2177 = (x2176)+(x2039); + x2178 = (uintptr_t)((x2177)<(x2039)); + x2179 = (x2177)+(x2121); + x2180 = (uintptr_t)((x2179)<(x2121)); + x2181 = (x2178)+(x2180); + x2182 = (x2181)+(x2044); + x2183 = (uintptr_t)((x2182)<(x2044)); + x2184 = (x2182)+(x2126); + x2185 = (uintptr_t)((x2184)<(x2126)); + x2186 = (x2183)+(x2185); + x2187 = (x2186)+(x2049); + x2188 = (uintptr_t)((x2187)<(x2049)); + x2189 = (x2187)+(x2131); + x2190 = (uintptr_t)((x2189)<(x2131)); + x2191 = (x2188)+(x2190); + x2192 = (x2191)+(x2054); + x2193 = (uintptr_t)((x2192)<(x2054)); + x2194 = (x2192)+(x2136); + x2195 = (uintptr_t)((x2194)<(x2136)); + x2196 = (x2193)+(x2195); + x2197 = (x2196)+(x2059); + x2198 = (uintptr_t)((x2197)<(x2059)); + x2199 = (x2197)+(x2141); + x2200 = (uintptr_t)((x2199)<(x2141)); + x2201 = (x2198)+(x2200); + x2202 = (x2201)+(x2064); + x2203 = (uintptr_t)((x2202)<(x2064)); + x2204 = (x2202)+(x2146); + x2205 = (uintptr_t)((x2204)<(x2146)); + x2206 = (x2203)+(x2205); + x2207 = (x2206)+(x2069); + x2208 = (uintptr_t)((x2207)<(x2069)); + x2209 = (x2207)+(x2149); + x2210 = (uintptr_t)((x2209)<(x2149)); + x2211 = (x2208)+(x2210); + x2212 = (x2211)+(x2071); + x2213 = (x31)*(x23); + x2214 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x23))>>32 : ((__uint128_t)(x31)*(x23))>>64); + x2215 = (x31)*(x22); + x2216 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x22))>>32 : ((__uint128_t)(x31)*(x22))>>64); + x2217 = (x31)*(x21); + x2218 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x21))>>32 : ((__uint128_t)(x31)*(x21))>>64); + x2219 = (x31)*(x20); + x2220 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x20))>>32 : ((__uint128_t)(x31)*(x20))>>64); + x2221 = (x31)*(x19); + x2222 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x19))>>32 : ((__uint128_t)(x31)*(x19))>>64); + x2223 = (x31)*(x18); + x2224 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x18))>>32 : ((__uint128_t)(x31)*(x18))>>64); + x2225 = (x31)*(x17); + x2226 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x17))>>32 : ((__uint128_t)(x31)*(x17))>>64); + x2227 = (x31)*(x16); + x2228 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x16))>>32 : ((__uint128_t)(x31)*(x16))>>64); + x2229 = (x31)*(x15); + x2230 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x15))>>32 : ((__uint128_t)(x31)*(x15))>>64); + x2231 = (x31)*(x14); + x2232 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x14))>>32 : ((__uint128_t)(x31)*(x14))>>64); + x2233 = (x31)*(x13); + x2234 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x13))>>32 : ((__uint128_t)(x31)*(x13))>>64); + x2235 = (x31)*(x12); + x2236 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x12))>>32 : ((__uint128_t)(x31)*(x12))>>64); + x2237 = (x2236)+(x2233); + x2238 = (uintptr_t)((x2237)<(x2236)); + x2239 = (x2238)+(x2234); + x2240 = (uintptr_t)((x2239)<(x2234)); + x2241 = (x2239)+(x2231); + x2242 = (uintptr_t)((x2241)<(x2231)); + x2243 = (x2240)+(x2242); + x2244 = (x2243)+(x2232); + x2245 = (uintptr_t)((x2244)<(x2232)); + x2246 = (x2244)+(x2229); + x2247 = (uintptr_t)((x2246)<(x2229)); + x2248 = (x2245)+(x2247); + x2249 = (x2248)+(x2230); + x2250 = (uintptr_t)((x2249)<(x2230)); + x2251 = (x2249)+(x2227); + x2252 = (uintptr_t)((x2251)<(x2227)); + x2253 = (x2250)+(x2252); + x2254 = (x2253)+(x2228); + x2255 = (uintptr_t)((x2254)<(x2228)); + x2256 = (x2254)+(x2225); + x2257 = (uintptr_t)((x2256)<(x2225)); + x2258 = (x2255)+(x2257); + x2259 = (x2258)+(x2226); + x2260 = (uintptr_t)((x2259)<(x2226)); + x2261 = (x2259)+(x2223); + x2262 = (uintptr_t)((x2261)<(x2223)); + x2263 = (x2260)+(x2262); + x2264 = (x2263)+(x2224); + x2265 = (uintptr_t)((x2264)<(x2224)); + x2266 = (x2264)+(x2221); + x2267 = (uintptr_t)((x2266)<(x2221)); + x2268 = (x2265)+(x2267); + x2269 = (x2268)+(x2222); + x2270 = (uintptr_t)((x2269)<(x2222)); + x2271 = (x2269)+(x2219); + x2272 = (uintptr_t)((x2271)<(x2219)); + x2273 = (x2270)+(x2272); + x2274 = (x2273)+(x2220); + x2275 = (uintptr_t)((x2274)<(x2220)); + x2276 = (x2274)+(x2217); + x2277 = (uintptr_t)((x2276)<(x2217)); + x2278 = (x2275)+(x2277); + x2279 = (x2278)+(x2218); + x2280 = (uintptr_t)((x2279)<(x2218)); + x2281 = (x2279)+(x2215); + x2282 = (uintptr_t)((x2281)<(x2215)); + x2283 = (x2280)+(x2282); + x2284 = (x2283)+(x2216); + x2285 = (uintptr_t)((x2284)<(x2216)); + x2286 = (x2284)+(x2213); + x2287 = (uintptr_t)((x2286)<(x2213)); + x2288 = (x2285)+(x2287); + x2289 = (x2288)+(x2214); + x2290 = (x2154)+(x2235); + x2291 = (uintptr_t)((x2290)<(x2154)); + x2292 = (x2291)+(x2159); + x2293 = (uintptr_t)((x2292)<(x2159)); + x2294 = (x2292)+(x2237); + x2295 = (uintptr_t)((x2294)<(x2237)); + x2296 = (x2293)+(x2295); + x2297 = (x2296)+(x2164); + x2298 = (uintptr_t)((x2297)<(x2164)); + x2299 = (x2297)+(x2241); + x2300 = (uintptr_t)((x2299)<(x2241)); + x2301 = (x2298)+(x2300); + x2302 = (x2301)+(x2169); + x2303 = (uintptr_t)((x2302)<(x2169)); + x2304 = (x2302)+(x2246); + x2305 = (uintptr_t)((x2304)<(x2246)); + x2306 = (x2303)+(x2305); + x2307 = (x2306)+(x2174); + x2308 = (uintptr_t)((x2307)<(x2174)); + x2309 = (x2307)+(x2251); + x2310 = (uintptr_t)((x2309)<(x2251)); + x2311 = (x2308)+(x2310); + x2312 = (x2311)+(x2179); + x2313 = (uintptr_t)((x2312)<(x2179)); + x2314 = (x2312)+(x2256); + x2315 = (uintptr_t)((x2314)<(x2256)); + x2316 = (x2313)+(x2315); + x2317 = (x2316)+(x2184); + x2318 = (uintptr_t)((x2317)<(x2184)); + x2319 = (x2317)+(x2261); + x2320 = (uintptr_t)((x2319)<(x2261)); + x2321 = (x2318)+(x2320); + x2322 = (x2321)+(x2189); + x2323 = (uintptr_t)((x2322)<(x2189)); + x2324 = (x2322)+(x2266); + x2325 = (uintptr_t)((x2324)<(x2266)); + x2326 = (x2323)+(x2325); + x2327 = (x2326)+(x2194); + x2328 = (uintptr_t)((x2327)<(x2194)); + x2329 = (x2327)+(x2271); + x2330 = (uintptr_t)((x2329)<(x2271)); + x2331 = (x2328)+(x2330); + x2332 = (x2331)+(x2199); + x2333 = (uintptr_t)((x2332)<(x2199)); + x2334 = (x2332)+(x2276); + x2335 = (uintptr_t)((x2334)<(x2276)); + x2336 = (x2333)+(x2335); + x2337 = (x2336)+(x2204); + x2338 = (uintptr_t)((x2337)<(x2204)); + x2339 = (x2337)+(x2281); + x2340 = (uintptr_t)((x2339)<(x2281)); + x2341 = (x2338)+(x2340); + x2342 = (x2341)+(x2209); + x2343 = (uintptr_t)((x2342)<(x2209)); + x2344 = (x2342)+(x2286); + x2345 = (uintptr_t)((x2344)<(x2286)); + x2346 = (x2343)+(x2345); + x2347 = (x2346)+(x2212); + x2348 = (uintptr_t)((x2347)<(x2212)); + x2349 = (x2347)+(x2289); + x2350 = (uintptr_t)((x2349)<(x2289)); + x2351 = (x2348)+(x2350); + x2352 = (x2290)*((uintptr_t)3901742149ULL); + x2353 = (x2352)*((uintptr_t)4294967295ULL); + x2354 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2352)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2352)*((uintptr_t)4294967295ULL))>>64); + x2355 = (x2352)*((uintptr_t)4294967295ULL); + x2356 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2352)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2352)*((uintptr_t)4294967295ULL))>>64); + x2357 = (x2352)*((uintptr_t)4294967295ULL); + x2358 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2352)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2352)*((uintptr_t)4294967295ULL))>>64); + x2359 = (x2352)*((uintptr_t)4294967295ULL); + x2360 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2352)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2352)*((uintptr_t)4294967295ULL))>>64); + x2361 = (x2352)*((uintptr_t)4294967295ULL); + x2362 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2352)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2352)*((uintptr_t)4294967295ULL))>>64); + x2363 = (x2352)*((uintptr_t)4294967295ULL); + x2364 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2352)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2352)*((uintptr_t)4294967295ULL))>>64); + x2365 = (x2352)*((uintptr_t)3345173889ULL); + x2366 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2352)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x2352)*((uintptr_t)3345173889ULL))>>64); + x2367 = (x2352)*((uintptr_t)4097256927ULL); + x2368 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2352)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x2352)*((uintptr_t)4097256927ULL))>>64); + x2369 = (x2352)*((uintptr_t)1478102450ULL); + x2370 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2352)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x2352)*((uintptr_t)1478102450ULL))>>64); + x2371 = (x2352)*((uintptr_t)1219536762ULL); + x2372 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2352)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x2352)*((uintptr_t)1219536762ULL))>>64); + x2373 = (x2352)*((uintptr_t)3974895978ULL); + x2374 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2352)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x2352)*((uintptr_t)3974895978ULL))>>64); + x2375 = (x2352)*((uintptr_t)3435473267ULL); + x2376 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2352)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x2352)*((uintptr_t)3435473267ULL))>>64); + x2377 = (x2376)+(x2373); + x2378 = (uintptr_t)((x2377)<(x2376)); + x2379 = (x2378)+(x2374); + x2380 = (uintptr_t)((x2379)<(x2374)); + x2381 = (x2379)+(x2371); + x2382 = (uintptr_t)((x2381)<(x2371)); + x2383 = (x2380)+(x2382); + x2384 = (x2383)+(x2372); + x2385 = (uintptr_t)((x2384)<(x2372)); + x2386 = (x2384)+(x2369); + x2387 = (uintptr_t)((x2386)<(x2369)); + x2388 = (x2385)+(x2387); + x2389 = (x2388)+(x2370); + x2390 = (uintptr_t)((x2389)<(x2370)); + x2391 = (x2389)+(x2367); + x2392 = (uintptr_t)((x2391)<(x2367)); + x2393 = (x2390)+(x2392); + x2394 = (x2393)+(x2368); + x2395 = (uintptr_t)((x2394)<(x2368)); + x2396 = (x2394)+(x2365); + x2397 = (uintptr_t)((x2396)<(x2365)); + x2398 = (x2395)+(x2397); + x2399 = (x2398)+(x2366); + x2400 = (uintptr_t)((x2399)<(x2366)); + x2401 = (x2399)+(x2363); + x2402 = (uintptr_t)((x2401)<(x2363)); + x2403 = (x2400)+(x2402); + x2404 = (x2403)+(x2364); + x2405 = (uintptr_t)((x2404)<(x2364)); + x2406 = (x2404)+(x2361); + x2407 = (uintptr_t)((x2406)<(x2361)); + x2408 = (x2405)+(x2407); + x2409 = (x2408)+(x2362); + x2410 = (uintptr_t)((x2409)<(x2362)); + x2411 = (x2409)+(x2359); + x2412 = (uintptr_t)((x2411)<(x2359)); + x2413 = (x2410)+(x2412); + x2414 = (x2413)+(x2360); + x2415 = (uintptr_t)((x2414)<(x2360)); + x2416 = (x2414)+(x2357); + x2417 = (uintptr_t)((x2416)<(x2357)); + x2418 = (x2415)+(x2417); + x2419 = (x2418)+(x2358); + x2420 = (uintptr_t)((x2419)<(x2358)); + x2421 = (x2419)+(x2355); + x2422 = (uintptr_t)((x2421)<(x2355)); + x2423 = (x2420)+(x2422); + x2424 = (x2423)+(x2356); + x2425 = (uintptr_t)((x2424)<(x2356)); + x2426 = (x2424)+(x2353); + x2427 = (uintptr_t)((x2426)<(x2353)); + x2428 = (x2425)+(x2427); + x2429 = (x2428)+(x2354); + x2430 = (x2290)+(x2375); + x2431 = (uintptr_t)((x2430)<(x2290)); + x2432 = (x2431)+(x2294); + x2433 = (uintptr_t)((x2432)<(x2294)); + x2434 = (x2432)+(x2377); + x2435 = (uintptr_t)((x2434)<(x2377)); + x2436 = (x2433)+(x2435); + x2437 = (x2436)+(x2299); + x2438 = (uintptr_t)((x2437)<(x2299)); + x2439 = (x2437)+(x2381); + x2440 = (uintptr_t)((x2439)<(x2381)); + x2441 = (x2438)+(x2440); + x2442 = (x2441)+(x2304); + x2443 = (uintptr_t)((x2442)<(x2304)); + x2444 = (x2442)+(x2386); + x2445 = (uintptr_t)((x2444)<(x2386)); + x2446 = (x2443)+(x2445); + x2447 = (x2446)+(x2309); + x2448 = (uintptr_t)((x2447)<(x2309)); + x2449 = (x2447)+(x2391); + x2450 = (uintptr_t)((x2449)<(x2391)); + x2451 = (x2448)+(x2450); + x2452 = (x2451)+(x2314); + x2453 = (uintptr_t)((x2452)<(x2314)); + x2454 = (x2452)+(x2396); + x2455 = (uintptr_t)((x2454)<(x2396)); + x2456 = (x2453)+(x2455); + x2457 = (x2456)+(x2319); + x2458 = (uintptr_t)((x2457)<(x2319)); + x2459 = (x2457)+(x2401); + x2460 = (uintptr_t)((x2459)<(x2401)); + x2461 = (x2458)+(x2460); + x2462 = (x2461)+(x2324); + x2463 = (uintptr_t)((x2462)<(x2324)); + x2464 = (x2462)+(x2406); + x2465 = (uintptr_t)((x2464)<(x2406)); + x2466 = (x2463)+(x2465); + x2467 = (x2466)+(x2329); + x2468 = (uintptr_t)((x2467)<(x2329)); + x2469 = (x2467)+(x2411); + x2470 = (uintptr_t)((x2469)<(x2411)); + x2471 = (x2468)+(x2470); + x2472 = (x2471)+(x2334); + x2473 = (uintptr_t)((x2472)<(x2334)); + x2474 = (x2472)+(x2416); + x2475 = (uintptr_t)((x2474)<(x2416)); + x2476 = (x2473)+(x2475); + x2477 = (x2476)+(x2339); + x2478 = (uintptr_t)((x2477)<(x2339)); + x2479 = (x2477)+(x2421); + x2480 = (uintptr_t)((x2479)<(x2421)); + x2481 = (x2478)+(x2480); + x2482 = (x2481)+(x2344); + x2483 = (uintptr_t)((x2482)<(x2344)); + x2484 = (x2482)+(x2426); + x2485 = (uintptr_t)((x2484)<(x2426)); + x2486 = (x2483)+(x2485); + x2487 = (x2486)+(x2349); + x2488 = (uintptr_t)((x2487)<(x2349)); + x2489 = (x2487)+(x2429); + x2490 = (uintptr_t)((x2489)<(x2429)); + x2491 = (x2488)+(x2490); + x2492 = (x2491)+(x2351); + x2493 = (x32)*(x23); + x2494 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x23))>>32 : ((__uint128_t)(x32)*(x23))>>64); + x2495 = (x32)*(x22); + x2496 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x22))>>32 : ((__uint128_t)(x32)*(x22))>>64); + x2497 = (x32)*(x21); + x2498 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x21))>>32 : ((__uint128_t)(x32)*(x21))>>64); + x2499 = (x32)*(x20); + x2500 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x20))>>32 : ((__uint128_t)(x32)*(x20))>>64); + x2501 = (x32)*(x19); + x2502 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x19))>>32 : ((__uint128_t)(x32)*(x19))>>64); + x2503 = (x32)*(x18); + x2504 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x18))>>32 : ((__uint128_t)(x32)*(x18))>>64); + x2505 = (x32)*(x17); + x2506 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x17))>>32 : ((__uint128_t)(x32)*(x17))>>64); + x2507 = (x32)*(x16); + x2508 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x16))>>32 : ((__uint128_t)(x32)*(x16))>>64); + x2509 = (x32)*(x15); + x2510 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x15))>>32 : ((__uint128_t)(x32)*(x15))>>64); + x2511 = (x32)*(x14); + x2512 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x14))>>32 : ((__uint128_t)(x32)*(x14))>>64); + x2513 = (x32)*(x13); + x2514 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x13))>>32 : ((__uint128_t)(x32)*(x13))>>64); + x2515 = (x32)*(x12); + x2516 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x12))>>32 : ((__uint128_t)(x32)*(x12))>>64); + x2517 = (x2516)+(x2513); + x2518 = (uintptr_t)((x2517)<(x2516)); + x2519 = (x2518)+(x2514); + x2520 = (uintptr_t)((x2519)<(x2514)); + x2521 = (x2519)+(x2511); + x2522 = (uintptr_t)((x2521)<(x2511)); + x2523 = (x2520)+(x2522); + x2524 = (x2523)+(x2512); + x2525 = (uintptr_t)((x2524)<(x2512)); + x2526 = (x2524)+(x2509); + x2527 = (uintptr_t)((x2526)<(x2509)); + x2528 = (x2525)+(x2527); + x2529 = (x2528)+(x2510); + x2530 = (uintptr_t)((x2529)<(x2510)); + x2531 = (x2529)+(x2507); + x2532 = (uintptr_t)((x2531)<(x2507)); + x2533 = (x2530)+(x2532); + x2534 = (x2533)+(x2508); + x2535 = (uintptr_t)((x2534)<(x2508)); + x2536 = (x2534)+(x2505); + x2537 = (uintptr_t)((x2536)<(x2505)); + x2538 = (x2535)+(x2537); + x2539 = (x2538)+(x2506); + x2540 = (uintptr_t)((x2539)<(x2506)); + x2541 = (x2539)+(x2503); + x2542 = (uintptr_t)((x2541)<(x2503)); + x2543 = (x2540)+(x2542); + x2544 = (x2543)+(x2504); + x2545 = (uintptr_t)((x2544)<(x2504)); + x2546 = (x2544)+(x2501); + x2547 = (uintptr_t)((x2546)<(x2501)); + x2548 = (x2545)+(x2547); + x2549 = (x2548)+(x2502); + x2550 = (uintptr_t)((x2549)<(x2502)); + x2551 = (x2549)+(x2499); + x2552 = (uintptr_t)((x2551)<(x2499)); + x2553 = (x2550)+(x2552); + x2554 = (x2553)+(x2500); + x2555 = (uintptr_t)((x2554)<(x2500)); + x2556 = (x2554)+(x2497); + x2557 = (uintptr_t)((x2556)<(x2497)); + x2558 = (x2555)+(x2557); + x2559 = (x2558)+(x2498); + x2560 = (uintptr_t)((x2559)<(x2498)); + x2561 = (x2559)+(x2495); + x2562 = (uintptr_t)((x2561)<(x2495)); + x2563 = (x2560)+(x2562); + x2564 = (x2563)+(x2496); + x2565 = (uintptr_t)((x2564)<(x2496)); + x2566 = (x2564)+(x2493); + x2567 = (uintptr_t)((x2566)<(x2493)); + x2568 = (x2565)+(x2567); + x2569 = (x2568)+(x2494); + x2570 = (x2434)+(x2515); + x2571 = (uintptr_t)((x2570)<(x2434)); + x2572 = (x2571)+(x2439); + x2573 = (uintptr_t)((x2572)<(x2439)); + x2574 = (x2572)+(x2517); + x2575 = (uintptr_t)((x2574)<(x2517)); + x2576 = (x2573)+(x2575); + x2577 = (x2576)+(x2444); + x2578 = (uintptr_t)((x2577)<(x2444)); + x2579 = (x2577)+(x2521); + x2580 = (uintptr_t)((x2579)<(x2521)); + x2581 = (x2578)+(x2580); + x2582 = (x2581)+(x2449); + x2583 = (uintptr_t)((x2582)<(x2449)); + x2584 = (x2582)+(x2526); + x2585 = (uintptr_t)((x2584)<(x2526)); + x2586 = (x2583)+(x2585); + x2587 = (x2586)+(x2454); + x2588 = (uintptr_t)((x2587)<(x2454)); + x2589 = (x2587)+(x2531); + x2590 = (uintptr_t)((x2589)<(x2531)); + x2591 = (x2588)+(x2590); + x2592 = (x2591)+(x2459); + x2593 = (uintptr_t)((x2592)<(x2459)); + x2594 = (x2592)+(x2536); + x2595 = (uintptr_t)((x2594)<(x2536)); + x2596 = (x2593)+(x2595); + x2597 = (x2596)+(x2464); + x2598 = (uintptr_t)((x2597)<(x2464)); + x2599 = (x2597)+(x2541); + x2600 = (uintptr_t)((x2599)<(x2541)); + x2601 = (x2598)+(x2600); + x2602 = (x2601)+(x2469); + x2603 = (uintptr_t)((x2602)<(x2469)); + x2604 = (x2602)+(x2546); + x2605 = (uintptr_t)((x2604)<(x2546)); + x2606 = (x2603)+(x2605); + x2607 = (x2606)+(x2474); + x2608 = (uintptr_t)((x2607)<(x2474)); + x2609 = (x2607)+(x2551); + x2610 = (uintptr_t)((x2609)<(x2551)); + x2611 = (x2608)+(x2610); + x2612 = (x2611)+(x2479); + x2613 = (uintptr_t)((x2612)<(x2479)); + x2614 = (x2612)+(x2556); + x2615 = (uintptr_t)((x2614)<(x2556)); + x2616 = (x2613)+(x2615); + x2617 = (x2616)+(x2484); + x2618 = (uintptr_t)((x2617)<(x2484)); + x2619 = (x2617)+(x2561); + x2620 = (uintptr_t)((x2619)<(x2561)); + x2621 = (x2618)+(x2620); + x2622 = (x2621)+(x2489); + x2623 = (uintptr_t)((x2622)<(x2489)); + x2624 = (x2622)+(x2566); + x2625 = (uintptr_t)((x2624)<(x2566)); + x2626 = (x2623)+(x2625); + x2627 = (x2626)+(x2492); + x2628 = (uintptr_t)((x2627)<(x2492)); + x2629 = (x2627)+(x2569); + x2630 = (uintptr_t)((x2629)<(x2569)); + x2631 = (x2628)+(x2630); + x2632 = (x2570)*((uintptr_t)3901742149ULL); + x2633 = (x2632)*((uintptr_t)4294967295ULL); + x2634 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2632)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2632)*((uintptr_t)4294967295ULL))>>64); + x2635 = (x2632)*((uintptr_t)4294967295ULL); + x2636 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2632)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2632)*((uintptr_t)4294967295ULL))>>64); + x2637 = (x2632)*((uintptr_t)4294967295ULL); + x2638 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2632)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2632)*((uintptr_t)4294967295ULL))>>64); + x2639 = (x2632)*((uintptr_t)4294967295ULL); + x2640 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2632)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2632)*((uintptr_t)4294967295ULL))>>64); + x2641 = (x2632)*((uintptr_t)4294967295ULL); + x2642 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2632)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2632)*((uintptr_t)4294967295ULL))>>64); + x2643 = (x2632)*((uintptr_t)4294967295ULL); + x2644 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2632)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2632)*((uintptr_t)4294967295ULL))>>64); + x2645 = (x2632)*((uintptr_t)3345173889ULL); + x2646 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2632)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x2632)*((uintptr_t)3345173889ULL))>>64); + x2647 = (x2632)*((uintptr_t)4097256927ULL); + x2648 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2632)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x2632)*((uintptr_t)4097256927ULL))>>64); + x2649 = (x2632)*((uintptr_t)1478102450ULL); + x2650 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2632)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x2632)*((uintptr_t)1478102450ULL))>>64); + x2651 = (x2632)*((uintptr_t)1219536762ULL); + x2652 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2632)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x2632)*((uintptr_t)1219536762ULL))>>64); + x2653 = (x2632)*((uintptr_t)3974895978ULL); + x2654 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2632)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x2632)*((uintptr_t)3974895978ULL))>>64); + x2655 = (x2632)*((uintptr_t)3435473267ULL); + x2656 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2632)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x2632)*((uintptr_t)3435473267ULL))>>64); + x2657 = (x2656)+(x2653); + x2658 = (uintptr_t)((x2657)<(x2656)); + x2659 = (x2658)+(x2654); + x2660 = (uintptr_t)((x2659)<(x2654)); + x2661 = (x2659)+(x2651); + x2662 = (uintptr_t)((x2661)<(x2651)); + x2663 = (x2660)+(x2662); + x2664 = (x2663)+(x2652); + x2665 = (uintptr_t)((x2664)<(x2652)); + x2666 = (x2664)+(x2649); + x2667 = (uintptr_t)((x2666)<(x2649)); + x2668 = (x2665)+(x2667); + x2669 = (x2668)+(x2650); + x2670 = (uintptr_t)((x2669)<(x2650)); + x2671 = (x2669)+(x2647); + x2672 = (uintptr_t)((x2671)<(x2647)); + x2673 = (x2670)+(x2672); + x2674 = (x2673)+(x2648); + x2675 = (uintptr_t)((x2674)<(x2648)); + x2676 = (x2674)+(x2645); + x2677 = (uintptr_t)((x2676)<(x2645)); + x2678 = (x2675)+(x2677); + x2679 = (x2678)+(x2646); + x2680 = (uintptr_t)((x2679)<(x2646)); + x2681 = (x2679)+(x2643); + x2682 = (uintptr_t)((x2681)<(x2643)); + x2683 = (x2680)+(x2682); + x2684 = (x2683)+(x2644); + x2685 = (uintptr_t)((x2684)<(x2644)); + x2686 = (x2684)+(x2641); + x2687 = (uintptr_t)((x2686)<(x2641)); + x2688 = (x2685)+(x2687); + x2689 = (x2688)+(x2642); + x2690 = (uintptr_t)((x2689)<(x2642)); + x2691 = (x2689)+(x2639); + x2692 = (uintptr_t)((x2691)<(x2639)); + x2693 = (x2690)+(x2692); + x2694 = (x2693)+(x2640); + x2695 = (uintptr_t)((x2694)<(x2640)); + x2696 = (x2694)+(x2637); + x2697 = (uintptr_t)((x2696)<(x2637)); + x2698 = (x2695)+(x2697); + x2699 = (x2698)+(x2638); + x2700 = (uintptr_t)((x2699)<(x2638)); + x2701 = (x2699)+(x2635); + x2702 = (uintptr_t)((x2701)<(x2635)); + x2703 = (x2700)+(x2702); + x2704 = (x2703)+(x2636); + x2705 = (uintptr_t)((x2704)<(x2636)); + x2706 = (x2704)+(x2633); + x2707 = (uintptr_t)((x2706)<(x2633)); + x2708 = (x2705)+(x2707); + x2709 = (x2708)+(x2634); + x2710 = (x2570)+(x2655); + x2711 = (uintptr_t)((x2710)<(x2570)); + x2712 = (x2711)+(x2574); + x2713 = (uintptr_t)((x2712)<(x2574)); + x2714 = (x2712)+(x2657); + x2715 = (uintptr_t)((x2714)<(x2657)); + x2716 = (x2713)+(x2715); + x2717 = (x2716)+(x2579); + x2718 = (uintptr_t)((x2717)<(x2579)); + x2719 = (x2717)+(x2661); + x2720 = (uintptr_t)((x2719)<(x2661)); + x2721 = (x2718)+(x2720); + x2722 = (x2721)+(x2584); + x2723 = (uintptr_t)((x2722)<(x2584)); + x2724 = (x2722)+(x2666); + x2725 = (uintptr_t)((x2724)<(x2666)); + x2726 = (x2723)+(x2725); + x2727 = (x2726)+(x2589); + x2728 = (uintptr_t)((x2727)<(x2589)); + x2729 = (x2727)+(x2671); + x2730 = (uintptr_t)((x2729)<(x2671)); + x2731 = (x2728)+(x2730); + x2732 = (x2731)+(x2594); + x2733 = (uintptr_t)((x2732)<(x2594)); + x2734 = (x2732)+(x2676); + x2735 = (uintptr_t)((x2734)<(x2676)); + x2736 = (x2733)+(x2735); + x2737 = (x2736)+(x2599); + x2738 = (uintptr_t)((x2737)<(x2599)); + x2739 = (x2737)+(x2681); + x2740 = (uintptr_t)((x2739)<(x2681)); + x2741 = (x2738)+(x2740); + x2742 = (x2741)+(x2604); + x2743 = (uintptr_t)((x2742)<(x2604)); + x2744 = (x2742)+(x2686); + x2745 = (uintptr_t)((x2744)<(x2686)); + x2746 = (x2743)+(x2745); + x2747 = (x2746)+(x2609); + x2748 = (uintptr_t)((x2747)<(x2609)); + x2749 = (x2747)+(x2691); + x2750 = (uintptr_t)((x2749)<(x2691)); + x2751 = (x2748)+(x2750); + x2752 = (x2751)+(x2614); + x2753 = (uintptr_t)((x2752)<(x2614)); + x2754 = (x2752)+(x2696); + x2755 = (uintptr_t)((x2754)<(x2696)); + x2756 = (x2753)+(x2755); + x2757 = (x2756)+(x2619); + x2758 = (uintptr_t)((x2757)<(x2619)); + x2759 = (x2757)+(x2701); + x2760 = (uintptr_t)((x2759)<(x2701)); + x2761 = (x2758)+(x2760); + x2762 = (x2761)+(x2624); + x2763 = (uintptr_t)((x2762)<(x2624)); + x2764 = (x2762)+(x2706); + x2765 = (uintptr_t)((x2764)<(x2706)); + x2766 = (x2763)+(x2765); + x2767 = (x2766)+(x2629); + x2768 = (uintptr_t)((x2767)<(x2629)); + x2769 = (x2767)+(x2709); + x2770 = (uintptr_t)((x2769)<(x2709)); + x2771 = (x2768)+(x2770); + x2772 = (x2771)+(x2631); + x2773 = (x33)*(x23); + x2774 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x23))>>32 : ((__uint128_t)(x33)*(x23))>>64); + x2775 = (x33)*(x22); + x2776 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x22))>>32 : ((__uint128_t)(x33)*(x22))>>64); + x2777 = (x33)*(x21); + x2778 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x21))>>32 : ((__uint128_t)(x33)*(x21))>>64); + x2779 = (x33)*(x20); + x2780 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x20))>>32 : ((__uint128_t)(x33)*(x20))>>64); + x2781 = (x33)*(x19); + x2782 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x19))>>32 : ((__uint128_t)(x33)*(x19))>>64); + x2783 = (x33)*(x18); + x2784 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x18))>>32 : ((__uint128_t)(x33)*(x18))>>64); + x2785 = (x33)*(x17); + x2786 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x17))>>32 : ((__uint128_t)(x33)*(x17))>>64); + x2787 = (x33)*(x16); + x2788 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x16))>>32 : ((__uint128_t)(x33)*(x16))>>64); + x2789 = (x33)*(x15); + x2790 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x15))>>32 : ((__uint128_t)(x33)*(x15))>>64); + x2791 = (x33)*(x14); + x2792 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x14))>>32 : ((__uint128_t)(x33)*(x14))>>64); + x2793 = (x33)*(x13); + x2794 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x13))>>32 : ((__uint128_t)(x33)*(x13))>>64); + x2795 = (x33)*(x12); + x2796 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x12))>>32 : ((__uint128_t)(x33)*(x12))>>64); + x2797 = (x2796)+(x2793); + x2798 = (uintptr_t)((x2797)<(x2796)); + x2799 = (x2798)+(x2794); + x2800 = (uintptr_t)((x2799)<(x2794)); + x2801 = (x2799)+(x2791); + x2802 = (uintptr_t)((x2801)<(x2791)); + x2803 = (x2800)+(x2802); + x2804 = (x2803)+(x2792); + x2805 = (uintptr_t)((x2804)<(x2792)); + x2806 = (x2804)+(x2789); + x2807 = (uintptr_t)((x2806)<(x2789)); + x2808 = (x2805)+(x2807); + x2809 = (x2808)+(x2790); + x2810 = (uintptr_t)((x2809)<(x2790)); + x2811 = (x2809)+(x2787); + x2812 = (uintptr_t)((x2811)<(x2787)); + x2813 = (x2810)+(x2812); + x2814 = (x2813)+(x2788); + x2815 = (uintptr_t)((x2814)<(x2788)); + x2816 = (x2814)+(x2785); + x2817 = (uintptr_t)((x2816)<(x2785)); + x2818 = (x2815)+(x2817); + x2819 = (x2818)+(x2786); + x2820 = (uintptr_t)((x2819)<(x2786)); + x2821 = (x2819)+(x2783); + x2822 = (uintptr_t)((x2821)<(x2783)); + x2823 = (x2820)+(x2822); + x2824 = (x2823)+(x2784); + x2825 = (uintptr_t)((x2824)<(x2784)); + x2826 = (x2824)+(x2781); + x2827 = (uintptr_t)((x2826)<(x2781)); + x2828 = (x2825)+(x2827); + x2829 = (x2828)+(x2782); + x2830 = (uintptr_t)((x2829)<(x2782)); + x2831 = (x2829)+(x2779); + x2832 = (uintptr_t)((x2831)<(x2779)); + x2833 = (x2830)+(x2832); + x2834 = (x2833)+(x2780); + x2835 = (uintptr_t)((x2834)<(x2780)); + x2836 = (x2834)+(x2777); + x2837 = (uintptr_t)((x2836)<(x2777)); + x2838 = (x2835)+(x2837); + x2839 = (x2838)+(x2778); + x2840 = (uintptr_t)((x2839)<(x2778)); + x2841 = (x2839)+(x2775); + x2842 = (uintptr_t)((x2841)<(x2775)); + x2843 = (x2840)+(x2842); + x2844 = (x2843)+(x2776); + x2845 = (uintptr_t)((x2844)<(x2776)); + x2846 = (x2844)+(x2773); + x2847 = (uintptr_t)((x2846)<(x2773)); + x2848 = (x2845)+(x2847); + x2849 = (x2848)+(x2774); + x2850 = (x2714)+(x2795); + x2851 = (uintptr_t)((x2850)<(x2714)); + x2852 = (x2851)+(x2719); + x2853 = (uintptr_t)((x2852)<(x2719)); + x2854 = (x2852)+(x2797); + x2855 = (uintptr_t)((x2854)<(x2797)); + x2856 = (x2853)+(x2855); + x2857 = (x2856)+(x2724); + x2858 = (uintptr_t)((x2857)<(x2724)); + x2859 = (x2857)+(x2801); + x2860 = (uintptr_t)((x2859)<(x2801)); + x2861 = (x2858)+(x2860); + x2862 = (x2861)+(x2729); + x2863 = (uintptr_t)((x2862)<(x2729)); + x2864 = (x2862)+(x2806); + x2865 = (uintptr_t)((x2864)<(x2806)); + x2866 = (x2863)+(x2865); + x2867 = (x2866)+(x2734); + x2868 = (uintptr_t)((x2867)<(x2734)); + x2869 = (x2867)+(x2811); + x2870 = (uintptr_t)((x2869)<(x2811)); + x2871 = (x2868)+(x2870); + x2872 = (x2871)+(x2739); + x2873 = (uintptr_t)((x2872)<(x2739)); + x2874 = (x2872)+(x2816); + x2875 = (uintptr_t)((x2874)<(x2816)); + x2876 = (x2873)+(x2875); + x2877 = (x2876)+(x2744); + x2878 = (uintptr_t)((x2877)<(x2744)); + x2879 = (x2877)+(x2821); + x2880 = (uintptr_t)((x2879)<(x2821)); + x2881 = (x2878)+(x2880); + x2882 = (x2881)+(x2749); + x2883 = (uintptr_t)((x2882)<(x2749)); + x2884 = (x2882)+(x2826); + x2885 = (uintptr_t)((x2884)<(x2826)); + x2886 = (x2883)+(x2885); + x2887 = (x2886)+(x2754); + x2888 = (uintptr_t)((x2887)<(x2754)); + x2889 = (x2887)+(x2831); + x2890 = (uintptr_t)((x2889)<(x2831)); + x2891 = (x2888)+(x2890); + x2892 = (x2891)+(x2759); + x2893 = (uintptr_t)((x2892)<(x2759)); + x2894 = (x2892)+(x2836); + x2895 = (uintptr_t)((x2894)<(x2836)); + x2896 = (x2893)+(x2895); + x2897 = (x2896)+(x2764); + x2898 = (uintptr_t)((x2897)<(x2764)); + x2899 = (x2897)+(x2841); + x2900 = (uintptr_t)((x2899)<(x2841)); + x2901 = (x2898)+(x2900); + x2902 = (x2901)+(x2769); + x2903 = (uintptr_t)((x2902)<(x2769)); + x2904 = (x2902)+(x2846); + x2905 = (uintptr_t)((x2904)<(x2846)); + x2906 = (x2903)+(x2905); + x2907 = (x2906)+(x2772); + x2908 = (uintptr_t)((x2907)<(x2772)); + x2909 = (x2907)+(x2849); + x2910 = (uintptr_t)((x2909)<(x2849)); + x2911 = (x2908)+(x2910); + x2912 = (x2850)*((uintptr_t)3901742149ULL); + x2913 = (x2912)*((uintptr_t)4294967295ULL); + x2914 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2912)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2912)*((uintptr_t)4294967295ULL))>>64); + x2915 = (x2912)*((uintptr_t)4294967295ULL); + x2916 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2912)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2912)*((uintptr_t)4294967295ULL))>>64); + x2917 = (x2912)*((uintptr_t)4294967295ULL); + x2918 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2912)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2912)*((uintptr_t)4294967295ULL))>>64); + x2919 = (x2912)*((uintptr_t)4294967295ULL); + x2920 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2912)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2912)*((uintptr_t)4294967295ULL))>>64); + x2921 = (x2912)*((uintptr_t)4294967295ULL); + x2922 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2912)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2912)*((uintptr_t)4294967295ULL))>>64); + x2923 = (x2912)*((uintptr_t)4294967295ULL); + x2924 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2912)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2912)*((uintptr_t)4294967295ULL))>>64); + x2925 = (x2912)*((uintptr_t)3345173889ULL); + x2926 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2912)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x2912)*((uintptr_t)3345173889ULL))>>64); + x2927 = (x2912)*((uintptr_t)4097256927ULL); + x2928 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2912)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x2912)*((uintptr_t)4097256927ULL))>>64); + x2929 = (x2912)*((uintptr_t)1478102450ULL); + x2930 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2912)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x2912)*((uintptr_t)1478102450ULL))>>64); + x2931 = (x2912)*((uintptr_t)1219536762ULL); + x2932 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2912)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x2912)*((uintptr_t)1219536762ULL))>>64); + x2933 = (x2912)*((uintptr_t)3974895978ULL); + x2934 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2912)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x2912)*((uintptr_t)3974895978ULL))>>64); + x2935 = (x2912)*((uintptr_t)3435473267ULL); + x2936 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2912)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x2912)*((uintptr_t)3435473267ULL))>>64); + x2937 = (x2936)+(x2933); + x2938 = (uintptr_t)((x2937)<(x2936)); + x2939 = (x2938)+(x2934); + x2940 = (uintptr_t)((x2939)<(x2934)); + x2941 = (x2939)+(x2931); + x2942 = (uintptr_t)((x2941)<(x2931)); + x2943 = (x2940)+(x2942); + x2944 = (x2943)+(x2932); + x2945 = (uintptr_t)((x2944)<(x2932)); + x2946 = (x2944)+(x2929); + x2947 = (uintptr_t)((x2946)<(x2929)); + x2948 = (x2945)+(x2947); + x2949 = (x2948)+(x2930); + x2950 = (uintptr_t)((x2949)<(x2930)); + x2951 = (x2949)+(x2927); + x2952 = (uintptr_t)((x2951)<(x2927)); + x2953 = (x2950)+(x2952); + x2954 = (x2953)+(x2928); + x2955 = (uintptr_t)((x2954)<(x2928)); + x2956 = (x2954)+(x2925); + x2957 = (uintptr_t)((x2956)<(x2925)); + x2958 = (x2955)+(x2957); + x2959 = (x2958)+(x2926); + x2960 = (uintptr_t)((x2959)<(x2926)); + x2961 = (x2959)+(x2923); + x2962 = (uintptr_t)((x2961)<(x2923)); + x2963 = (x2960)+(x2962); + x2964 = (x2963)+(x2924); + x2965 = (uintptr_t)((x2964)<(x2924)); + x2966 = (x2964)+(x2921); + x2967 = (uintptr_t)((x2966)<(x2921)); + x2968 = (x2965)+(x2967); + x2969 = (x2968)+(x2922); + x2970 = (uintptr_t)((x2969)<(x2922)); + x2971 = (x2969)+(x2919); + x2972 = (uintptr_t)((x2971)<(x2919)); + x2973 = (x2970)+(x2972); + x2974 = (x2973)+(x2920); + x2975 = (uintptr_t)((x2974)<(x2920)); + x2976 = (x2974)+(x2917); + x2977 = (uintptr_t)((x2976)<(x2917)); + x2978 = (x2975)+(x2977); + x2979 = (x2978)+(x2918); + x2980 = (uintptr_t)((x2979)<(x2918)); + x2981 = (x2979)+(x2915); + x2982 = (uintptr_t)((x2981)<(x2915)); + x2983 = (x2980)+(x2982); + x2984 = (x2983)+(x2916); + x2985 = (uintptr_t)((x2984)<(x2916)); + x2986 = (x2984)+(x2913); + x2987 = (uintptr_t)((x2986)<(x2913)); + x2988 = (x2985)+(x2987); + x2989 = (x2988)+(x2914); + x2990 = (x2850)+(x2935); + x2991 = (uintptr_t)((x2990)<(x2850)); + x2992 = (x2991)+(x2854); + x2993 = (uintptr_t)((x2992)<(x2854)); + x2994 = (x2992)+(x2937); + x2995 = (uintptr_t)((x2994)<(x2937)); + x2996 = (x2993)+(x2995); + x2997 = (x2996)+(x2859); + x2998 = (uintptr_t)((x2997)<(x2859)); + x2999 = (x2997)+(x2941); + x3000 = (uintptr_t)((x2999)<(x2941)); + x3001 = (x2998)+(x3000); + x3002 = (x3001)+(x2864); + x3003 = (uintptr_t)((x3002)<(x2864)); + x3004 = (x3002)+(x2946); + x3005 = (uintptr_t)((x3004)<(x2946)); + x3006 = (x3003)+(x3005); + x3007 = (x3006)+(x2869); + x3008 = (uintptr_t)((x3007)<(x2869)); + x3009 = (x3007)+(x2951); + x3010 = (uintptr_t)((x3009)<(x2951)); + x3011 = (x3008)+(x3010); + x3012 = (x3011)+(x2874); + x3013 = (uintptr_t)((x3012)<(x2874)); + x3014 = (x3012)+(x2956); + x3015 = (uintptr_t)((x3014)<(x2956)); + x3016 = (x3013)+(x3015); + x3017 = (x3016)+(x2879); + x3018 = (uintptr_t)((x3017)<(x2879)); + x3019 = (x3017)+(x2961); + x3020 = (uintptr_t)((x3019)<(x2961)); + x3021 = (x3018)+(x3020); + x3022 = (x3021)+(x2884); + x3023 = (uintptr_t)((x3022)<(x2884)); + x3024 = (x3022)+(x2966); + x3025 = (uintptr_t)((x3024)<(x2966)); + x3026 = (x3023)+(x3025); + x3027 = (x3026)+(x2889); + x3028 = (uintptr_t)((x3027)<(x2889)); + x3029 = (x3027)+(x2971); + x3030 = (uintptr_t)((x3029)<(x2971)); + x3031 = (x3028)+(x3030); + x3032 = (x3031)+(x2894); + x3033 = (uintptr_t)((x3032)<(x2894)); + x3034 = (x3032)+(x2976); + x3035 = (uintptr_t)((x3034)<(x2976)); + x3036 = (x3033)+(x3035); + x3037 = (x3036)+(x2899); + x3038 = (uintptr_t)((x3037)<(x2899)); + x3039 = (x3037)+(x2981); + x3040 = (uintptr_t)((x3039)<(x2981)); + x3041 = (x3038)+(x3040); + x3042 = (x3041)+(x2904); + x3043 = (uintptr_t)((x3042)<(x2904)); + x3044 = (x3042)+(x2986); + x3045 = (uintptr_t)((x3044)<(x2986)); + x3046 = (x3043)+(x3045); + x3047 = (x3046)+(x2909); + x3048 = (uintptr_t)((x3047)<(x2909)); + x3049 = (x3047)+(x2989); + x3050 = (uintptr_t)((x3049)<(x2989)); + x3051 = (x3048)+(x3050); + x3052 = (x3051)+(x2911); + x3053 = (x34)*(x23); + x3054 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x23))>>32 : ((__uint128_t)(x34)*(x23))>>64); + x3055 = (x34)*(x22); + x3056 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x22))>>32 : ((__uint128_t)(x34)*(x22))>>64); + x3057 = (x34)*(x21); + x3058 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x21))>>32 : ((__uint128_t)(x34)*(x21))>>64); + x3059 = (x34)*(x20); + x3060 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x20))>>32 : ((__uint128_t)(x34)*(x20))>>64); + x3061 = (x34)*(x19); + x3062 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x19))>>32 : ((__uint128_t)(x34)*(x19))>>64); + x3063 = (x34)*(x18); + x3064 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x18))>>32 : ((__uint128_t)(x34)*(x18))>>64); + x3065 = (x34)*(x17); + x3066 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x17))>>32 : ((__uint128_t)(x34)*(x17))>>64); + x3067 = (x34)*(x16); + x3068 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x16))>>32 : ((__uint128_t)(x34)*(x16))>>64); + x3069 = (x34)*(x15); + x3070 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x15))>>32 : ((__uint128_t)(x34)*(x15))>>64); + x3071 = (x34)*(x14); + x3072 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x14))>>32 : ((__uint128_t)(x34)*(x14))>>64); + x3073 = (x34)*(x13); + x3074 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x13))>>32 : ((__uint128_t)(x34)*(x13))>>64); + x3075 = (x34)*(x12); + x3076 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x12))>>32 : ((__uint128_t)(x34)*(x12))>>64); + x3077 = (x3076)+(x3073); + x3078 = (uintptr_t)((x3077)<(x3076)); + x3079 = (x3078)+(x3074); + x3080 = (uintptr_t)((x3079)<(x3074)); + x3081 = (x3079)+(x3071); + x3082 = (uintptr_t)((x3081)<(x3071)); + x3083 = (x3080)+(x3082); + x3084 = (x3083)+(x3072); + x3085 = (uintptr_t)((x3084)<(x3072)); + x3086 = (x3084)+(x3069); + x3087 = (uintptr_t)((x3086)<(x3069)); + x3088 = (x3085)+(x3087); + x3089 = (x3088)+(x3070); + x3090 = (uintptr_t)((x3089)<(x3070)); + x3091 = (x3089)+(x3067); + x3092 = (uintptr_t)((x3091)<(x3067)); + x3093 = (x3090)+(x3092); + x3094 = (x3093)+(x3068); + x3095 = (uintptr_t)((x3094)<(x3068)); + x3096 = (x3094)+(x3065); + x3097 = (uintptr_t)((x3096)<(x3065)); + x3098 = (x3095)+(x3097); + x3099 = (x3098)+(x3066); + x3100 = (uintptr_t)((x3099)<(x3066)); + x3101 = (x3099)+(x3063); + x3102 = (uintptr_t)((x3101)<(x3063)); + x3103 = (x3100)+(x3102); + x3104 = (x3103)+(x3064); + x3105 = (uintptr_t)((x3104)<(x3064)); + x3106 = (x3104)+(x3061); + x3107 = (uintptr_t)((x3106)<(x3061)); + x3108 = (x3105)+(x3107); + x3109 = (x3108)+(x3062); + x3110 = (uintptr_t)((x3109)<(x3062)); + x3111 = (x3109)+(x3059); + x3112 = (uintptr_t)((x3111)<(x3059)); + x3113 = (x3110)+(x3112); + x3114 = (x3113)+(x3060); + x3115 = (uintptr_t)((x3114)<(x3060)); + x3116 = (x3114)+(x3057); + x3117 = (uintptr_t)((x3116)<(x3057)); + x3118 = (x3115)+(x3117); + x3119 = (x3118)+(x3058); + x3120 = (uintptr_t)((x3119)<(x3058)); + x3121 = (x3119)+(x3055); + x3122 = (uintptr_t)((x3121)<(x3055)); + x3123 = (x3120)+(x3122); + x3124 = (x3123)+(x3056); + x3125 = (uintptr_t)((x3124)<(x3056)); + x3126 = (x3124)+(x3053); + x3127 = (uintptr_t)((x3126)<(x3053)); + x3128 = (x3125)+(x3127); + x3129 = (x3128)+(x3054); + x3130 = (x2994)+(x3075); + x3131 = (uintptr_t)((x3130)<(x2994)); + x3132 = (x3131)+(x2999); + x3133 = (uintptr_t)((x3132)<(x2999)); + x3134 = (x3132)+(x3077); + x3135 = (uintptr_t)((x3134)<(x3077)); + x3136 = (x3133)+(x3135); + x3137 = (x3136)+(x3004); + x3138 = (uintptr_t)((x3137)<(x3004)); + x3139 = (x3137)+(x3081); + x3140 = (uintptr_t)((x3139)<(x3081)); + x3141 = (x3138)+(x3140); + x3142 = (x3141)+(x3009); + x3143 = (uintptr_t)((x3142)<(x3009)); + x3144 = (x3142)+(x3086); + x3145 = (uintptr_t)((x3144)<(x3086)); + x3146 = (x3143)+(x3145); + x3147 = (x3146)+(x3014); + x3148 = (uintptr_t)((x3147)<(x3014)); + x3149 = (x3147)+(x3091); + x3150 = (uintptr_t)((x3149)<(x3091)); + x3151 = (x3148)+(x3150); + x3152 = (x3151)+(x3019); + x3153 = (uintptr_t)((x3152)<(x3019)); + x3154 = (x3152)+(x3096); + x3155 = (uintptr_t)((x3154)<(x3096)); + x3156 = (x3153)+(x3155); + x3157 = (x3156)+(x3024); + x3158 = (uintptr_t)((x3157)<(x3024)); + x3159 = (x3157)+(x3101); + x3160 = (uintptr_t)((x3159)<(x3101)); + x3161 = (x3158)+(x3160); + x3162 = (x3161)+(x3029); + x3163 = (uintptr_t)((x3162)<(x3029)); + x3164 = (x3162)+(x3106); + x3165 = (uintptr_t)((x3164)<(x3106)); + x3166 = (x3163)+(x3165); + x3167 = (x3166)+(x3034); + x3168 = (uintptr_t)((x3167)<(x3034)); + x3169 = (x3167)+(x3111); + x3170 = (uintptr_t)((x3169)<(x3111)); + x3171 = (x3168)+(x3170); + x3172 = (x3171)+(x3039); + x3173 = (uintptr_t)((x3172)<(x3039)); + x3174 = (x3172)+(x3116); + x3175 = (uintptr_t)((x3174)<(x3116)); + x3176 = (x3173)+(x3175); + x3177 = (x3176)+(x3044); + x3178 = (uintptr_t)((x3177)<(x3044)); + x3179 = (x3177)+(x3121); + x3180 = (uintptr_t)((x3179)<(x3121)); + x3181 = (x3178)+(x3180); + x3182 = (x3181)+(x3049); + x3183 = (uintptr_t)((x3182)<(x3049)); + x3184 = (x3182)+(x3126); + x3185 = (uintptr_t)((x3184)<(x3126)); + x3186 = (x3183)+(x3185); + x3187 = (x3186)+(x3052); + x3188 = (uintptr_t)((x3187)<(x3052)); + x3189 = (x3187)+(x3129); + x3190 = (uintptr_t)((x3189)<(x3129)); + x3191 = (x3188)+(x3190); + x3192 = (x3130)*((uintptr_t)3901742149ULL); + x3193 = (x3192)*((uintptr_t)4294967295ULL); + x3194 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3192)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x3192)*((uintptr_t)4294967295ULL))>>64); + x3195 = (x3192)*((uintptr_t)4294967295ULL); + x3196 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3192)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x3192)*((uintptr_t)4294967295ULL))>>64); + x3197 = (x3192)*((uintptr_t)4294967295ULL); + x3198 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3192)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x3192)*((uintptr_t)4294967295ULL))>>64); + x3199 = (x3192)*((uintptr_t)4294967295ULL); + x3200 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3192)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x3192)*((uintptr_t)4294967295ULL))>>64); + x3201 = (x3192)*((uintptr_t)4294967295ULL); + x3202 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3192)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x3192)*((uintptr_t)4294967295ULL))>>64); + x3203 = (x3192)*((uintptr_t)4294967295ULL); + x3204 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3192)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x3192)*((uintptr_t)4294967295ULL))>>64); + x3205 = (x3192)*((uintptr_t)3345173889ULL); + x3206 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3192)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x3192)*((uintptr_t)3345173889ULL))>>64); + x3207 = (x3192)*((uintptr_t)4097256927ULL); + x3208 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3192)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x3192)*((uintptr_t)4097256927ULL))>>64); + x3209 = (x3192)*((uintptr_t)1478102450ULL); + x3210 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3192)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x3192)*((uintptr_t)1478102450ULL))>>64); + x3211 = (x3192)*((uintptr_t)1219536762ULL); + x3212 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3192)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x3192)*((uintptr_t)1219536762ULL))>>64); + x3213 = (x3192)*((uintptr_t)3974895978ULL); + x3214 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3192)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x3192)*((uintptr_t)3974895978ULL))>>64); + x3215 = (x3192)*((uintptr_t)3435473267ULL); + x3216 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3192)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x3192)*((uintptr_t)3435473267ULL))>>64); + x3217 = (x3216)+(x3213); + x3218 = (uintptr_t)((x3217)<(x3216)); + x3219 = (x3218)+(x3214); + x3220 = (uintptr_t)((x3219)<(x3214)); + x3221 = (x3219)+(x3211); + x3222 = (uintptr_t)((x3221)<(x3211)); + x3223 = (x3220)+(x3222); + x3224 = (x3223)+(x3212); + x3225 = (uintptr_t)((x3224)<(x3212)); + x3226 = (x3224)+(x3209); + x3227 = (uintptr_t)((x3226)<(x3209)); + x3228 = (x3225)+(x3227); + x3229 = (x3228)+(x3210); + x3230 = (uintptr_t)((x3229)<(x3210)); + x3231 = (x3229)+(x3207); + x3232 = (uintptr_t)((x3231)<(x3207)); + x3233 = (x3230)+(x3232); + x3234 = (x3233)+(x3208); + x3235 = (uintptr_t)((x3234)<(x3208)); + x3236 = (x3234)+(x3205); + x3237 = (uintptr_t)((x3236)<(x3205)); + x3238 = (x3235)+(x3237); + x3239 = (x3238)+(x3206); + x3240 = (uintptr_t)((x3239)<(x3206)); + x3241 = (x3239)+(x3203); + x3242 = (uintptr_t)((x3241)<(x3203)); + x3243 = (x3240)+(x3242); + x3244 = (x3243)+(x3204); + x3245 = (uintptr_t)((x3244)<(x3204)); + x3246 = (x3244)+(x3201); + x3247 = (uintptr_t)((x3246)<(x3201)); + x3248 = (x3245)+(x3247); + x3249 = (x3248)+(x3202); + x3250 = (uintptr_t)((x3249)<(x3202)); + x3251 = (x3249)+(x3199); + x3252 = (uintptr_t)((x3251)<(x3199)); + x3253 = (x3250)+(x3252); + x3254 = (x3253)+(x3200); + x3255 = (uintptr_t)((x3254)<(x3200)); + x3256 = (x3254)+(x3197); + x3257 = (uintptr_t)((x3256)<(x3197)); + x3258 = (x3255)+(x3257); + x3259 = (x3258)+(x3198); + x3260 = (uintptr_t)((x3259)<(x3198)); + x3261 = (x3259)+(x3195); + x3262 = (uintptr_t)((x3261)<(x3195)); + x3263 = (x3260)+(x3262); + x3264 = (x3263)+(x3196); + x3265 = (uintptr_t)((x3264)<(x3196)); + x3266 = (x3264)+(x3193); + x3267 = (uintptr_t)((x3266)<(x3193)); + x3268 = (x3265)+(x3267); + x3269 = (x3268)+(x3194); + x3270 = (x3130)+(x3215); + x3271 = (uintptr_t)((x3270)<(x3130)); + x3272 = (x3271)+(x3134); + x3273 = (uintptr_t)((x3272)<(x3134)); + x3274 = (x3272)+(x3217); + x3275 = (uintptr_t)((x3274)<(x3217)); + x3276 = (x3273)+(x3275); + x3277 = (x3276)+(x3139); + x3278 = (uintptr_t)((x3277)<(x3139)); + x3279 = (x3277)+(x3221); + x3280 = (uintptr_t)((x3279)<(x3221)); + x3281 = (x3278)+(x3280); + x3282 = (x3281)+(x3144); + x3283 = (uintptr_t)((x3282)<(x3144)); + x3284 = (x3282)+(x3226); + x3285 = (uintptr_t)((x3284)<(x3226)); + x3286 = (x3283)+(x3285); + x3287 = (x3286)+(x3149); + x3288 = (uintptr_t)((x3287)<(x3149)); + x3289 = (x3287)+(x3231); + x3290 = (uintptr_t)((x3289)<(x3231)); + x3291 = (x3288)+(x3290); + x3292 = (x3291)+(x3154); + x3293 = (uintptr_t)((x3292)<(x3154)); + x3294 = (x3292)+(x3236); + x3295 = (uintptr_t)((x3294)<(x3236)); + x3296 = (x3293)+(x3295); + x3297 = (x3296)+(x3159); + x3298 = (uintptr_t)((x3297)<(x3159)); + x3299 = (x3297)+(x3241); + x3300 = (uintptr_t)((x3299)<(x3241)); + x3301 = (x3298)+(x3300); + x3302 = (x3301)+(x3164); + x3303 = (uintptr_t)((x3302)<(x3164)); + x3304 = (x3302)+(x3246); + x3305 = (uintptr_t)((x3304)<(x3246)); + x3306 = (x3303)+(x3305); + x3307 = (x3306)+(x3169); + x3308 = (uintptr_t)((x3307)<(x3169)); + x3309 = (x3307)+(x3251); + x3310 = (uintptr_t)((x3309)<(x3251)); + x3311 = (x3308)+(x3310); + x3312 = (x3311)+(x3174); + x3313 = (uintptr_t)((x3312)<(x3174)); + x3314 = (x3312)+(x3256); + x3315 = (uintptr_t)((x3314)<(x3256)); + x3316 = (x3313)+(x3315); + x3317 = (x3316)+(x3179); + x3318 = (uintptr_t)((x3317)<(x3179)); + x3319 = (x3317)+(x3261); + x3320 = (uintptr_t)((x3319)<(x3261)); + x3321 = (x3318)+(x3320); + x3322 = (x3321)+(x3184); + x3323 = (uintptr_t)((x3322)<(x3184)); + x3324 = (x3322)+(x3266); + x3325 = (uintptr_t)((x3324)<(x3266)); + x3326 = (x3323)+(x3325); + x3327 = (x3326)+(x3189); + x3328 = (uintptr_t)((x3327)<(x3189)); + x3329 = (x3327)+(x3269); + x3330 = (uintptr_t)((x3329)<(x3269)); + x3331 = (x3328)+(x3330); + x3332 = (x3331)+(x3191); + x3333 = (x3274)-((uintptr_t)3435473267ULL); + x3334 = (uintptr_t)((x3274)<(x3333)); + x3335 = (x3279)-((uintptr_t)3974895978ULL); + x3336 = (uintptr_t)((x3279)<(x3335)); + x3337 = (x3335)-(x3334); + x3338 = (uintptr_t)((x3335)<(x3337)); + x3339 = (x3336)+(x3338); + x3340 = (x3284)-((uintptr_t)1219536762ULL); + x3341 = (uintptr_t)((x3284)<(x3340)); + x3342 = (x3340)-(x3339); + x3343 = (uintptr_t)((x3340)<(x3342)); + x3344 = (x3341)+(x3343); + x3345 = (x3289)-((uintptr_t)1478102450ULL); + x3346 = (uintptr_t)((x3289)<(x3345)); + x3347 = (x3345)-(x3344); + x3348 = (uintptr_t)((x3345)<(x3347)); + x3349 = (x3346)+(x3348); + x3350 = (x3294)-((uintptr_t)4097256927ULL); + x3351 = (uintptr_t)((x3294)<(x3350)); + x3352 = (x3350)-(x3349); + x3353 = (uintptr_t)((x3350)<(x3352)); + x3354 = (x3351)+(x3353); + x3355 = (x3299)-((uintptr_t)3345173889ULL); + x3356 = (uintptr_t)((x3299)<(x3355)); + x3357 = (x3355)-(x3354); + x3358 = (uintptr_t)((x3355)<(x3357)); + x3359 = (x3356)+(x3358); + x3360 = (x3304)-((uintptr_t)4294967295ULL); + x3361 = (uintptr_t)((x3304)<(x3360)); + x3362 = (x3360)-(x3359); + x3363 = (uintptr_t)((x3360)<(x3362)); + x3364 = (x3361)+(x3363); + x3365 = (x3309)-((uintptr_t)4294967295ULL); + x3366 = (uintptr_t)((x3309)<(x3365)); + x3367 = (x3365)-(x3364); + x3368 = (uintptr_t)((x3365)<(x3367)); + x3369 = (x3366)+(x3368); + x3370 = (x3314)-((uintptr_t)4294967295ULL); + x3371 = (uintptr_t)((x3314)<(x3370)); + x3372 = (x3370)-(x3369); + x3373 = (uintptr_t)((x3370)<(x3372)); + x3374 = (x3371)+(x3373); + x3375 = (x3319)-((uintptr_t)4294967295ULL); + x3376 = (uintptr_t)((x3319)<(x3375)); + x3377 = (x3375)-(x3374); + x3378 = (uintptr_t)((x3375)<(x3377)); + x3379 = (x3376)+(x3378); + x3380 = (x3324)-((uintptr_t)4294967295ULL); + x3381 = (uintptr_t)((x3324)<(x3380)); + x3382 = (x3380)-(x3379); + x3383 = (uintptr_t)((x3380)<(x3382)); + x3384 = (x3381)+(x3383); + x3385 = (x3329)-((uintptr_t)4294967295ULL); + x3386 = (uintptr_t)((x3329)<(x3385)); + x3387 = (x3385)-(x3384); + x3388 = (uintptr_t)((x3385)<(x3387)); + x3389 = (x3386)+(x3388); + x3390 = (x3332)-(x3389); + x3391 = (uintptr_t)((x3332)<(x3390)); + x3392 = ((uintptr_t)-1ULL)+((uintptr_t)((x3391)==((uintptr_t)0ULL))); + x3393 = (x3392)^((uintptr_t)4294967295ULL); + x3394 = ((x3274)&(x3392))|((x3333)&(x3393)); + x3395 = ((uintptr_t)-1ULL)+((uintptr_t)((x3391)==((uintptr_t)0ULL))); + x3396 = (x3395)^((uintptr_t)4294967295ULL); + x3397 = ((x3279)&(x3395))|((x3337)&(x3396)); + x3398 = ((uintptr_t)-1ULL)+((uintptr_t)((x3391)==((uintptr_t)0ULL))); + x3399 = (x3398)^((uintptr_t)4294967295ULL); + x3400 = ((x3284)&(x3398))|((x3342)&(x3399)); + x3401 = ((uintptr_t)-1ULL)+((uintptr_t)((x3391)==((uintptr_t)0ULL))); + x3402 = (x3401)^((uintptr_t)4294967295ULL); + x3403 = ((x3289)&(x3401))|((x3347)&(x3402)); + x3404 = ((uintptr_t)-1ULL)+((uintptr_t)((x3391)==((uintptr_t)0ULL))); + x3405 = (x3404)^((uintptr_t)4294967295ULL); + x3406 = ((x3294)&(x3404))|((x3352)&(x3405)); + x3407 = ((uintptr_t)-1ULL)+((uintptr_t)((x3391)==((uintptr_t)0ULL))); + x3408 = (x3407)^((uintptr_t)4294967295ULL); + x3409 = ((x3299)&(x3407))|((x3357)&(x3408)); + x3410 = ((uintptr_t)-1ULL)+((uintptr_t)((x3391)==((uintptr_t)0ULL))); + x3411 = (x3410)^((uintptr_t)4294967295ULL); + x3412 = ((x3304)&(x3410))|((x3362)&(x3411)); + x3413 = ((uintptr_t)-1ULL)+((uintptr_t)((x3391)==((uintptr_t)0ULL))); + x3414 = (x3413)^((uintptr_t)4294967295ULL); + x3415 = ((x3309)&(x3413))|((x3367)&(x3414)); + x3416 = ((uintptr_t)-1ULL)+((uintptr_t)((x3391)==((uintptr_t)0ULL))); + x3417 = (x3416)^((uintptr_t)4294967295ULL); + x3418 = ((x3314)&(x3416))|((x3372)&(x3417)); + x3419 = ((uintptr_t)-1ULL)+((uintptr_t)((x3391)==((uintptr_t)0ULL))); + x3420 = (x3419)^((uintptr_t)4294967295ULL); + x3421 = ((x3319)&(x3419))|((x3377)&(x3420)); + x3422 = ((uintptr_t)-1ULL)+((uintptr_t)((x3391)==((uintptr_t)0ULL))); + x3423 = (x3422)^((uintptr_t)4294967295ULL); + x3424 = ((x3324)&(x3422))|((x3382)&(x3423)); + x3425 = ((uintptr_t)-1ULL)+((uintptr_t)((x3391)==((uintptr_t)0ULL))); + x3426 = (x3425)^((uintptr_t)4294967295ULL); + x3427 = ((x3329)&(x3425))|((x3387)&(x3426)); + x3428 = x3394; + x3429 = x3397; + x3430 = x3400; + x3431 = x3403; + x3432 = x3406; + x3433 = x3409; + x3434 = x3412; + x3435 = x3415; + x3436 = x3418; + x3437 = x3421; + x3438 = x3424; + x3439 = x3427; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x3428, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x3429, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x3430, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3431, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x3432, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x3433, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3434, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x3435, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x3436, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)36ULL), x3437, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x3438, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)44ULL), x3439, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_mul(uint32_t out1[12], const uint32_t arg1[12], const uint32_t arg2[12]) { + internal_fiat_p384_scalar_mul((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p384_scalar_square(uintptr_t out0, uintptr_t in0) { + uintptr_t x23, x44, x47, x49, x45, x50, x42, x51, x53, x54, x43, x55, x40, x56, x58, x59, x41, x60, x38, x61, x63, x64, x39, x65, x36, x66, x68, x69, x37, x70, x34, x71, x73, x74, x35, x75, x32, x76, x78, x79, x33, x80, x30, x81, x83, x84, x31, x85, x28, x86, x88, x89, x29, x90, x26, x91, x93, x94, x27, x95, x24, x96, x98, x99, x25, x101, x122, x125, x127, x123, x128, x120, x129, x131, x132, x121, x133, x118, x134, x136, x137, x119, x138, x116, x139, x141, x142, x117, x143, x114, x144, x146, x147, x115, x148, x112, x149, x151, x152, x113, x153, x110, x154, x156, x157, x111, x158, x108, x159, x161, x162, x109, x163, x106, x164, x166, x167, x107, x168, x104, x169, x171, x172, x105, x173, x102, x174, x176, x177, x103, x124, x179, x46, x180, x48, x181, x126, x182, x184, x185, x52, x186, x130, x187, x189, x190, x57, x191, x135, x192, x194, x195, x62, x196, x140, x197, x199, x200, x67, x201, x145, x202, x204, x205, x72, x206, x150, x207, x209, x210, x77, x211, x155, x212, x214, x215, x82, x216, x160, x217, x219, x220, x87, x221, x165, x222, x224, x225, x92, x226, x170, x227, x229, x230, x97, x231, x175, x232, x234, x235, x100, x236, x178, x237, x239, x12, x261, x264, x266, x262, x267, x259, x268, x270, x271, x260, x272, x257, x273, x275, x276, x258, x277, x255, x278, x280, x281, x256, x282, x253, x283, x285, x286, x254, x287, x251, x288, x290, x291, x252, x292, x249, x293, x295, x296, x250, x297, x247, x298, x300, x301, x248, x302, x245, x303, x305, x306, x246, x307, x243, x308, x310, x311, x244, x312, x241, x313, x315, x316, x242, x263, x183, x319, x188, x320, x265, x321, x323, x324, x193, x325, x269, x326, x328, x329, x198, x330, x274, x331, x333, x334, x203, x335, x279, x336, x338, x339, x208, x340, x284, x341, x343, x344, x213, x345, x289, x346, x348, x349, x218, x350, x294, x351, x353, x354, x223, x355, x299, x356, x358, x359, x228, x360, x304, x361, x363, x364, x233, x365, x309, x366, x368, x369, x238, x370, x314, x371, x373, x374, x240, x375, x317, x376, x378, x380, x401, x404, x406, x402, x407, x399, x408, x410, x411, x400, x412, x397, x413, x415, x416, x398, x417, x395, x418, x420, x421, x396, x422, x393, x423, x425, x426, x394, x427, x391, x428, x430, x431, x392, x432, x389, x433, x435, x436, x390, x437, x387, x438, x440, x441, x388, x442, x385, x443, x445, x446, x386, x447, x383, x448, x450, x451, x384, x452, x381, x453, x455, x456, x382, x403, x458, x318, x459, x322, x460, x405, x461, x463, x464, x327, x465, x409, x466, x468, x469, x332, x470, x414, x471, x473, x474, x337, x475, x419, x476, x478, x479, x342, x480, x424, x481, x483, x484, x347, x485, x429, x486, x488, x489, x352, x490, x434, x491, x493, x494, x357, x495, x439, x496, x498, x499, x362, x500, x444, x501, x503, x504, x367, x505, x449, x506, x508, x509, x372, x510, x454, x511, x513, x514, x377, x515, x457, x516, x518, x519, x379, x13, x541, x544, x546, x542, x547, x539, x548, x550, x551, x540, x552, x537, x553, x555, x556, x538, x557, x535, x558, x560, x561, x536, x562, x533, x563, x565, x566, x534, x567, x531, x568, x570, x571, x532, x572, x529, x573, x575, x576, x530, x577, x527, x578, x580, x581, x528, x582, x525, x583, x585, x586, x526, x587, x523, x588, x590, x591, x524, x592, x521, x593, x595, x596, x522, x543, x462, x599, x467, x600, x545, x601, x603, x604, x472, x605, x549, x606, x608, x609, x477, x610, x554, x611, x613, x614, x482, x615, x559, x616, x618, x619, x487, x620, x564, x621, x623, x624, x492, x625, x569, x626, x628, x629, x497, x630, x574, x631, x633, x634, x502, x635, x579, x636, x638, x639, x507, x640, x584, x641, x643, x644, x512, x645, x589, x646, x648, x649, x517, x650, x594, x651, x653, x654, x520, x655, x597, x656, x658, x660, x681, x684, x686, x682, x687, x679, x688, x690, x691, x680, x692, x677, x693, x695, x696, x678, x697, x675, x698, x700, x701, x676, x702, x673, x703, x705, x706, x674, x707, x671, x708, x710, x711, x672, x712, x669, x713, x715, x716, x670, x717, x667, x718, x720, x721, x668, x722, x665, x723, x725, x726, x666, x727, x663, x728, x730, x731, x664, x732, x661, x733, x735, x736, x662, x683, x738, x598, x739, x602, x740, x685, x741, x743, x744, x607, x745, x689, x746, x748, x749, x612, x750, x694, x751, x753, x754, x617, x755, x699, x756, x758, x759, x622, x760, x704, x761, x763, x764, x627, x765, x709, x766, x768, x769, x632, x770, x714, x771, x773, x774, x637, x775, x719, x776, x778, x779, x642, x780, x724, x781, x783, x784, x647, x785, x729, x786, x788, x789, x652, x790, x734, x791, x793, x794, x657, x795, x737, x796, x798, x799, x659, x14, x821, x824, x826, x822, x827, x819, x828, x830, x831, x820, x832, x817, x833, x835, x836, x818, x837, x815, x838, x840, x841, x816, x842, x813, x843, x845, x846, x814, x847, x811, x848, x850, x851, x812, x852, x809, x853, x855, x856, x810, x857, x807, x858, x860, x861, x808, x862, x805, x863, x865, x866, x806, x867, x803, x868, x870, x871, x804, x872, x801, x873, x875, x876, x802, x823, x742, x879, x747, x880, x825, x881, x883, x884, x752, x885, x829, x886, x888, x889, x757, x890, x834, x891, x893, x894, x762, x895, x839, x896, x898, x899, x767, x900, x844, x901, x903, x904, x772, x905, x849, x906, x908, x909, x777, x910, x854, x911, x913, x914, x782, x915, x859, x916, x918, x919, x787, x920, x864, x921, x923, x924, x792, x925, x869, x926, x928, x929, x797, x930, x874, x931, x933, x934, x800, x935, x877, x936, x938, x940, x961, x964, x966, x962, x967, x959, x968, x970, x971, x960, x972, x957, x973, x975, x976, x958, x977, x955, x978, x980, x981, x956, x982, x953, x983, x985, x986, x954, x987, x951, x988, x990, x991, x952, x992, x949, x993, x995, x996, x950, x997, x947, x998, x1000, x1001, x948, x1002, x945, x1003, x1005, x1006, x946, x1007, x943, x1008, x1010, x1011, x944, x1012, x941, x1013, x1015, x1016, x942, x963, x1018, x878, x1019, x882, x1020, x965, x1021, x1023, x1024, x887, x1025, x969, x1026, x1028, x1029, x892, x1030, x974, x1031, x1033, x1034, x897, x1035, x979, x1036, x1038, x1039, x902, x1040, x984, x1041, x1043, x1044, x907, x1045, x989, x1046, x1048, x1049, x912, x1050, x994, x1051, x1053, x1054, x917, x1055, x999, x1056, x1058, x1059, x922, x1060, x1004, x1061, x1063, x1064, x927, x1065, x1009, x1066, x1068, x1069, x932, x1070, x1014, x1071, x1073, x1074, x937, x1075, x1017, x1076, x1078, x1079, x939, x15, x1101, x1104, x1106, x1102, x1107, x1099, x1108, x1110, x1111, x1100, x1112, x1097, x1113, x1115, x1116, x1098, x1117, x1095, x1118, x1120, x1121, x1096, x1122, x1093, x1123, x1125, x1126, x1094, x1127, x1091, x1128, x1130, x1131, x1092, x1132, x1089, x1133, x1135, x1136, x1090, x1137, x1087, x1138, x1140, x1141, x1088, x1142, x1085, x1143, x1145, x1146, x1086, x1147, x1083, x1148, x1150, x1151, x1084, x1152, x1081, x1153, x1155, x1156, x1082, x1103, x1022, x1159, x1027, x1160, x1105, x1161, x1163, x1164, x1032, x1165, x1109, x1166, x1168, x1169, x1037, x1170, x1114, x1171, x1173, x1174, x1042, x1175, x1119, x1176, x1178, x1179, x1047, x1180, x1124, x1181, x1183, x1184, x1052, x1185, x1129, x1186, x1188, x1189, x1057, x1190, x1134, x1191, x1193, x1194, x1062, x1195, x1139, x1196, x1198, x1199, x1067, x1200, x1144, x1201, x1203, x1204, x1072, x1205, x1149, x1206, x1208, x1209, x1077, x1210, x1154, x1211, x1213, x1214, x1080, x1215, x1157, x1216, x1218, x1220, x1241, x1244, x1246, x1242, x1247, x1239, x1248, x1250, x1251, x1240, x1252, x1237, x1253, x1255, x1256, x1238, x1257, x1235, x1258, x1260, x1261, x1236, x1262, x1233, x1263, x1265, x1266, x1234, x1267, x1231, x1268, x1270, x1271, x1232, x1272, x1229, x1273, x1275, x1276, x1230, x1277, x1227, x1278, x1280, x1281, x1228, x1282, x1225, x1283, x1285, x1286, x1226, x1287, x1223, x1288, x1290, x1291, x1224, x1292, x1221, x1293, x1295, x1296, x1222, x1243, x1298, x1158, x1299, x1162, x1300, x1245, x1301, x1303, x1304, x1167, x1305, x1249, x1306, x1308, x1309, x1172, x1310, x1254, x1311, x1313, x1314, x1177, x1315, x1259, x1316, x1318, x1319, x1182, x1320, x1264, x1321, x1323, x1324, x1187, x1325, x1269, x1326, x1328, x1329, x1192, x1330, x1274, x1331, x1333, x1334, x1197, x1335, x1279, x1336, x1338, x1339, x1202, x1340, x1284, x1341, x1343, x1344, x1207, x1345, x1289, x1346, x1348, x1349, x1212, x1350, x1294, x1351, x1353, x1354, x1217, x1355, x1297, x1356, x1358, x1359, x1219, x16, x1381, x1384, x1386, x1382, x1387, x1379, x1388, x1390, x1391, x1380, x1392, x1377, x1393, x1395, x1396, x1378, x1397, x1375, x1398, x1400, x1401, x1376, x1402, x1373, x1403, x1405, x1406, x1374, x1407, x1371, x1408, x1410, x1411, x1372, x1412, x1369, x1413, x1415, x1416, x1370, x1417, x1367, x1418, x1420, x1421, x1368, x1422, x1365, x1423, x1425, x1426, x1366, x1427, x1363, x1428, x1430, x1431, x1364, x1432, x1361, x1433, x1435, x1436, x1362, x1383, x1302, x1439, x1307, x1440, x1385, x1441, x1443, x1444, x1312, x1445, x1389, x1446, x1448, x1449, x1317, x1450, x1394, x1451, x1453, x1454, x1322, x1455, x1399, x1456, x1458, x1459, x1327, x1460, x1404, x1461, x1463, x1464, x1332, x1465, x1409, x1466, x1468, x1469, x1337, x1470, x1414, x1471, x1473, x1474, x1342, x1475, x1419, x1476, x1478, x1479, x1347, x1480, x1424, x1481, x1483, x1484, x1352, x1485, x1429, x1486, x1488, x1489, x1357, x1490, x1434, x1491, x1493, x1494, x1360, x1495, x1437, x1496, x1498, x1500, x1521, x1524, x1526, x1522, x1527, x1519, x1528, x1530, x1531, x1520, x1532, x1517, x1533, x1535, x1536, x1518, x1537, x1515, x1538, x1540, x1541, x1516, x1542, x1513, x1543, x1545, x1546, x1514, x1547, x1511, x1548, x1550, x1551, x1512, x1552, x1509, x1553, x1555, x1556, x1510, x1557, x1507, x1558, x1560, x1561, x1508, x1562, x1505, x1563, x1565, x1566, x1506, x1567, x1503, x1568, x1570, x1571, x1504, x1572, x1501, x1573, x1575, x1576, x1502, x1523, x1578, x1438, x1579, x1442, x1580, x1525, x1581, x1583, x1584, x1447, x1585, x1529, x1586, x1588, x1589, x1452, x1590, x1534, x1591, x1593, x1594, x1457, x1595, x1539, x1596, x1598, x1599, x1462, x1600, x1544, x1601, x1603, x1604, x1467, x1605, x1549, x1606, x1608, x1609, x1472, x1610, x1554, x1611, x1613, x1614, x1477, x1615, x1559, x1616, x1618, x1619, x1482, x1620, x1564, x1621, x1623, x1624, x1487, x1625, x1569, x1626, x1628, x1629, x1492, x1630, x1574, x1631, x1633, x1634, x1497, x1635, x1577, x1636, x1638, x1639, x1499, x17, x1661, x1664, x1666, x1662, x1667, x1659, x1668, x1670, x1671, x1660, x1672, x1657, x1673, x1675, x1676, x1658, x1677, x1655, x1678, x1680, x1681, x1656, x1682, x1653, x1683, x1685, x1686, x1654, x1687, x1651, x1688, x1690, x1691, x1652, x1692, x1649, x1693, x1695, x1696, x1650, x1697, x1647, x1698, x1700, x1701, x1648, x1702, x1645, x1703, x1705, x1706, x1646, x1707, x1643, x1708, x1710, x1711, x1644, x1712, x1641, x1713, x1715, x1716, x1642, x1663, x1582, x1719, x1587, x1720, x1665, x1721, x1723, x1724, x1592, x1725, x1669, x1726, x1728, x1729, x1597, x1730, x1674, x1731, x1733, x1734, x1602, x1735, x1679, x1736, x1738, x1739, x1607, x1740, x1684, x1741, x1743, x1744, x1612, x1745, x1689, x1746, x1748, x1749, x1617, x1750, x1694, x1751, x1753, x1754, x1622, x1755, x1699, x1756, x1758, x1759, x1627, x1760, x1704, x1761, x1763, x1764, x1632, x1765, x1709, x1766, x1768, x1769, x1637, x1770, x1714, x1771, x1773, x1774, x1640, x1775, x1717, x1776, x1778, x1780, x1801, x1804, x1806, x1802, x1807, x1799, x1808, x1810, x1811, x1800, x1812, x1797, x1813, x1815, x1816, x1798, x1817, x1795, x1818, x1820, x1821, x1796, x1822, x1793, x1823, x1825, x1826, x1794, x1827, x1791, x1828, x1830, x1831, x1792, x1832, x1789, x1833, x1835, x1836, x1790, x1837, x1787, x1838, x1840, x1841, x1788, x1842, x1785, x1843, x1845, x1846, x1786, x1847, x1783, x1848, x1850, x1851, x1784, x1852, x1781, x1853, x1855, x1856, x1782, x1803, x1858, x1718, x1859, x1722, x1860, x1805, x1861, x1863, x1864, x1727, x1865, x1809, x1866, x1868, x1869, x1732, x1870, x1814, x1871, x1873, x1874, x1737, x1875, x1819, x1876, x1878, x1879, x1742, x1880, x1824, x1881, x1883, x1884, x1747, x1885, x1829, x1886, x1888, x1889, x1752, x1890, x1834, x1891, x1893, x1894, x1757, x1895, x1839, x1896, x1898, x1899, x1762, x1900, x1844, x1901, x1903, x1904, x1767, x1905, x1849, x1906, x1908, x1909, x1772, x1910, x1854, x1911, x1913, x1914, x1777, x1915, x1857, x1916, x1918, x1919, x1779, x18, x1941, x1944, x1946, x1942, x1947, x1939, x1948, x1950, x1951, x1940, x1952, x1937, x1953, x1955, x1956, x1938, x1957, x1935, x1958, x1960, x1961, x1936, x1962, x1933, x1963, x1965, x1966, x1934, x1967, x1931, x1968, x1970, x1971, x1932, x1972, x1929, x1973, x1975, x1976, x1930, x1977, x1927, x1978, x1980, x1981, x1928, x1982, x1925, x1983, x1985, x1986, x1926, x1987, x1923, x1988, x1990, x1991, x1924, x1992, x1921, x1993, x1995, x1996, x1922, x1943, x1862, x1999, x1867, x2000, x1945, x2001, x2003, x2004, x1872, x2005, x1949, x2006, x2008, x2009, x1877, x2010, x1954, x2011, x2013, x2014, x1882, x2015, x1959, x2016, x2018, x2019, x1887, x2020, x1964, x2021, x2023, x2024, x1892, x2025, x1969, x2026, x2028, x2029, x1897, x2030, x1974, x2031, x2033, x2034, x1902, x2035, x1979, x2036, x2038, x2039, x1907, x2040, x1984, x2041, x2043, x2044, x1912, x2045, x1989, x2046, x2048, x2049, x1917, x2050, x1994, x2051, x2053, x2054, x1920, x2055, x1997, x2056, x2058, x2060, x2081, x2084, x2086, x2082, x2087, x2079, x2088, x2090, x2091, x2080, x2092, x2077, x2093, x2095, x2096, x2078, x2097, x2075, x2098, x2100, x2101, x2076, x2102, x2073, x2103, x2105, x2106, x2074, x2107, x2071, x2108, x2110, x2111, x2072, x2112, x2069, x2113, x2115, x2116, x2070, x2117, x2067, x2118, x2120, x2121, x2068, x2122, x2065, x2123, x2125, x2126, x2066, x2127, x2063, x2128, x2130, x2131, x2064, x2132, x2061, x2133, x2135, x2136, x2062, x2083, x2138, x1998, x2139, x2002, x2140, x2085, x2141, x2143, x2144, x2007, x2145, x2089, x2146, x2148, x2149, x2012, x2150, x2094, x2151, x2153, x2154, x2017, x2155, x2099, x2156, x2158, x2159, x2022, x2160, x2104, x2161, x2163, x2164, x2027, x2165, x2109, x2166, x2168, x2169, x2032, x2170, x2114, x2171, x2173, x2174, x2037, x2175, x2119, x2176, x2178, x2179, x2042, x2180, x2124, x2181, x2183, x2184, x2047, x2185, x2129, x2186, x2188, x2189, x2052, x2190, x2134, x2191, x2193, x2194, x2057, x2195, x2137, x2196, x2198, x2199, x2059, x19, x2221, x2224, x2226, x2222, x2227, x2219, x2228, x2230, x2231, x2220, x2232, x2217, x2233, x2235, x2236, x2218, x2237, x2215, x2238, x2240, x2241, x2216, x2242, x2213, x2243, x2245, x2246, x2214, x2247, x2211, x2248, x2250, x2251, x2212, x2252, x2209, x2253, x2255, x2256, x2210, x2257, x2207, x2258, x2260, x2261, x2208, x2262, x2205, x2263, x2265, x2266, x2206, x2267, x2203, x2268, x2270, x2271, x2204, x2272, x2201, x2273, x2275, x2276, x2202, x2223, x2142, x2279, x2147, x2280, x2225, x2281, x2283, x2284, x2152, x2285, x2229, x2286, x2288, x2289, x2157, x2290, x2234, x2291, x2293, x2294, x2162, x2295, x2239, x2296, x2298, x2299, x2167, x2300, x2244, x2301, x2303, x2304, x2172, x2305, x2249, x2306, x2308, x2309, x2177, x2310, x2254, x2311, x2313, x2314, x2182, x2315, x2259, x2316, x2318, x2319, x2187, x2320, x2264, x2321, x2323, x2324, x2192, x2325, x2269, x2326, x2328, x2329, x2197, x2330, x2274, x2331, x2333, x2334, x2200, x2335, x2277, x2336, x2338, x2340, x2361, x2364, x2366, x2362, x2367, x2359, x2368, x2370, x2371, x2360, x2372, x2357, x2373, x2375, x2376, x2358, x2377, x2355, x2378, x2380, x2381, x2356, x2382, x2353, x2383, x2385, x2386, x2354, x2387, x2351, x2388, x2390, x2391, x2352, x2392, x2349, x2393, x2395, x2396, x2350, x2397, x2347, x2398, x2400, x2401, x2348, x2402, x2345, x2403, x2405, x2406, x2346, x2407, x2343, x2408, x2410, x2411, x2344, x2412, x2341, x2413, x2415, x2416, x2342, x2363, x2418, x2278, x2419, x2282, x2420, x2365, x2421, x2423, x2424, x2287, x2425, x2369, x2426, x2428, x2429, x2292, x2430, x2374, x2431, x2433, x2434, x2297, x2435, x2379, x2436, x2438, x2439, x2302, x2440, x2384, x2441, x2443, x2444, x2307, x2445, x2389, x2446, x2448, x2449, x2312, x2450, x2394, x2451, x2453, x2454, x2317, x2455, x2399, x2456, x2458, x2459, x2322, x2460, x2404, x2461, x2463, x2464, x2327, x2465, x2409, x2466, x2468, x2469, x2332, x2470, x2414, x2471, x2473, x2474, x2337, x2475, x2417, x2476, x2478, x2479, x2339, x20, x2501, x2504, x2506, x2502, x2507, x2499, x2508, x2510, x2511, x2500, x2512, x2497, x2513, x2515, x2516, x2498, x2517, x2495, x2518, x2520, x2521, x2496, x2522, x2493, x2523, x2525, x2526, x2494, x2527, x2491, x2528, x2530, x2531, x2492, x2532, x2489, x2533, x2535, x2536, x2490, x2537, x2487, x2538, x2540, x2541, x2488, x2542, x2485, x2543, x2545, x2546, x2486, x2547, x2483, x2548, x2550, x2551, x2484, x2552, x2481, x2553, x2555, x2556, x2482, x2503, x2422, x2559, x2427, x2560, x2505, x2561, x2563, x2564, x2432, x2565, x2509, x2566, x2568, x2569, x2437, x2570, x2514, x2571, x2573, x2574, x2442, x2575, x2519, x2576, x2578, x2579, x2447, x2580, x2524, x2581, x2583, x2584, x2452, x2585, x2529, x2586, x2588, x2589, x2457, x2590, x2534, x2591, x2593, x2594, x2462, x2595, x2539, x2596, x2598, x2599, x2467, x2600, x2544, x2601, x2603, x2604, x2472, x2605, x2549, x2606, x2608, x2609, x2477, x2610, x2554, x2611, x2613, x2614, x2480, x2615, x2557, x2616, x2618, x2620, x2641, x2644, x2646, x2642, x2647, x2639, x2648, x2650, x2651, x2640, x2652, x2637, x2653, x2655, x2656, x2638, x2657, x2635, x2658, x2660, x2661, x2636, x2662, x2633, x2663, x2665, x2666, x2634, x2667, x2631, x2668, x2670, x2671, x2632, x2672, x2629, x2673, x2675, x2676, x2630, x2677, x2627, x2678, x2680, x2681, x2628, x2682, x2625, x2683, x2685, x2686, x2626, x2687, x2623, x2688, x2690, x2691, x2624, x2692, x2621, x2693, x2695, x2696, x2622, x2643, x2698, x2558, x2699, x2562, x2700, x2645, x2701, x2703, x2704, x2567, x2705, x2649, x2706, x2708, x2709, x2572, x2710, x2654, x2711, x2713, x2714, x2577, x2715, x2659, x2716, x2718, x2719, x2582, x2720, x2664, x2721, x2723, x2724, x2587, x2725, x2669, x2726, x2728, x2729, x2592, x2730, x2674, x2731, x2733, x2734, x2597, x2735, x2679, x2736, x2738, x2739, x2602, x2740, x2684, x2741, x2743, x2744, x2607, x2745, x2689, x2746, x2748, x2749, x2612, x2750, x2694, x2751, x2753, x2754, x2617, x2755, x2697, x2756, x2758, x2759, x2619, x21, x2781, x2784, x2786, x2782, x2787, x2779, x2788, x2790, x2791, x2780, x2792, x2777, x2793, x2795, x2796, x2778, x2797, x2775, x2798, x2800, x2801, x2776, x2802, x2773, x2803, x2805, x2806, x2774, x2807, x2771, x2808, x2810, x2811, x2772, x2812, x2769, x2813, x2815, x2816, x2770, x2817, x2767, x2818, x2820, x2821, x2768, x2822, x2765, x2823, x2825, x2826, x2766, x2827, x2763, x2828, x2830, x2831, x2764, x2832, x2761, x2833, x2835, x2836, x2762, x2783, x2702, x2839, x2707, x2840, x2785, x2841, x2843, x2844, x2712, x2845, x2789, x2846, x2848, x2849, x2717, x2850, x2794, x2851, x2853, x2854, x2722, x2855, x2799, x2856, x2858, x2859, x2727, x2860, x2804, x2861, x2863, x2864, x2732, x2865, x2809, x2866, x2868, x2869, x2737, x2870, x2814, x2871, x2873, x2874, x2742, x2875, x2819, x2876, x2878, x2879, x2747, x2880, x2824, x2881, x2883, x2884, x2752, x2885, x2829, x2886, x2888, x2889, x2757, x2890, x2834, x2891, x2893, x2894, x2760, x2895, x2837, x2896, x2898, x2900, x2921, x2924, x2926, x2922, x2927, x2919, x2928, x2930, x2931, x2920, x2932, x2917, x2933, x2935, x2936, x2918, x2937, x2915, x2938, x2940, x2941, x2916, x2942, x2913, x2943, x2945, x2946, x2914, x2947, x2911, x2948, x2950, x2951, x2912, x2952, x2909, x2953, x2955, x2956, x2910, x2957, x2907, x2958, x2960, x2961, x2908, x2962, x2905, x2963, x2965, x2966, x2906, x2967, x2903, x2968, x2970, x2971, x2904, x2972, x2901, x2973, x2975, x2976, x2902, x2923, x2978, x2838, x2979, x2842, x2980, x2925, x2981, x2983, x2984, x2847, x2985, x2929, x2986, x2988, x2989, x2852, x2990, x2934, x2991, x2993, x2994, x2857, x2995, x2939, x2996, x2998, x2999, x2862, x3000, x2944, x3001, x3003, x3004, x2867, x3005, x2949, x3006, x3008, x3009, x2872, x3010, x2954, x3011, x3013, x3014, x2877, x3015, x2959, x3016, x3018, x3019, x2882, x3020, x2964, x3021, x3023, x3024, x2887, x3025, x2969, x3026, x3028, x3029, x2892, x3030, x2974, x3031, x3033, x3034, x2897, x3035, x2977, x3036, x3038, x3039, x2899, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x22, x0, x3061, x3064, x3066, x3062, x3067, x3059, x3068, x3070, x3071, x3060, x3072, x3057, x3073, x3075, x3076, x3058, x3077, x3055, x3078, x3080, x3081, x3056, x3082, x3053, x3083, x3085, x3086, x3054, x3087, x3051, x3088, x3090, x3091, x3052, x3092, x3049, x3093, x3095, x3096, x3050, x3097, x3047, x3098, x3100, x3101, x3048, x3102, x3045, x3103, x3105, x3106, x3046, x3107, x3043, x3108, x3110, x3111, x3044, x3112, x3041, x3113, x3115, x3116, x3042, x3063, x2982, x3119, x2987, x3120, x3065, x3121, x3123, x3124, x2992, x3125, x3069, x3126, x3128, x3129, x2997, x3130, x3074, x3131, x3133, x3134, x3002, x3135, x3079, x3136, x3138, x3139, x3007, x3140, x3084, x3141, x3143, x3144, x3012, x3145, x3089, x3146, x3148, x3149, x3017, x3150, x3094, x3151, x3153, x3154, x3022, x3155, x3099, x3156, x3158, x3159, x3027, x3160, x3104, x3161, x3163, x3164, x3032, x3165, x3109, x3166, x3168, x3169, x3037, x3170, x3114, x3171, x3173, x3174, x3040, x3175, x3117, x3176, x3178, x3180, x3201, x3204, x3206, x3202, x3207, x3199, x3208, x3210, x3211, x3200, x3212, x3197, x3213, x3215, x3216, x3198, x3217, x3195, x3218, x3220, x3221, x3196, x3222, x3193, x3223, x3225, x3226, x3194, x3227, x3191, x3228, x3230, x3231, x3192, x3232, x3189, x3233, x3235, x3236, x3190, x3237, x3187, x3238, x3240, x3241, x3188, x3242, x3185, x3243, x3245, x3246, x3186, x3247, x3183, x3248, x3250, x3251, x3184, x3252, x3181, x3253, x3255, x3256, x3182, x3203, x3258, x3118, x3259, x3122, x3260, x3205, x3261, x3263, x3264, x3127, x3265, x3209, x3266, x3268, x3269, x3132, x3270, x3214, x3271, x3273, x3274, x3137, x3275, x3219, x3276, x3278, x3279, x3142, x3280, x3224, x3281, x3283, x3284, x3147, x3285, x3229, x3286, x3288, x3289, x3152, x3290, x3234, x3291, x3293, x3294, x3157, x3295, x3239, x3296, x3298, x3299, x3162, x3300, x3244, x3301, x3303, x3304, x3167, x3305, x3249, x3306, x3308, x3309, x3172, x3310, x3254, x3311, x3313, x3314, x3177, x3315, x3257, x3316, x3318, x3319, x3179, x3322, x3323, x3324, x3326, x3327, x3328, x3329, x3331, x3332, x3333, x3334, x3336, x3337, x3338, x3339, x3341, x3342, x3343, x3344, x3346, x3347, x3348, x3349, x3351, x3352, x3353, x3354, x3356, x3357, x3358, x3359, x3361, x3362, x3363, x3364, x3366, x3367, x3368, x3369, x3371, x3372, x3373, x3374, x3376, x3377, x3320, x3378, x3262, x3380, x3321, x3381, x3267, x3383, x3325, x3384, x3272, x3386, x3330, x3387, x3277, x3389, x3335, x3390, x3282, x3392, x3340, x3393, x3287, x3395, x3345, x3396, x3292, x3398, x3350, x3399, x3297, x3401, x3355, x3402, x3302, x3404, x3360, x3405, x3307, x3407, x3365, x3408, x3312, x3410, x3370, x3411, x3379, x3317, x3413, x3375, x3414, x3382, x3385, x3388, x3391, x3394, x3397, x3400, x3403, x3406, x3409, x3412, x3415, x3416, x3417, x3418, x3419, x3420, x3421, x3422, x3423, x3424, x3425, x3426, x3427; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x9 = _br2_load((in0)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x10 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x11 = _br2_load((in0)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x12 = x1; + x13 = x2; + x14 = x3; + x15 = x4; + x16 = x5; + x17 = x6; + x18 = x7; + x19 = x8; + x20 = x9; + x21 = x10; + x22 = x11; + x23 = x0; + x24 = (x23)*(x11); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x11))>>32 : ((__uint128_t)(x23)*(x11))>>64); + x26 = (x23)*(x10); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x10))>>32 : ((__uint128_t)(x23)*(x10))>>64); + x28 = (x23)*(x9); + x29 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x9))>>32 : ((__uint128_t)(x23)*(x9))>>64); + x30 = (x23)*(x8); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x8))>>32 : ((__uint128_t)(x23)*(x8))>>64); + x32 = (x23)*(x7); + x33 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x7))>>32 : ((__uint128_t)(x23)*(x7))>>64); + x34 = (x23)*(x6); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x6))>>32 : ((__uint128_t)(x23)*(x6))>>64); + x36 = (x23)*(x5); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x5))>>32 : ((__uint128_t)(x23)*(x5))>>64); + x38 = (x23)*(x4); + x39 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x4))>>32 : ((__uint128_t)(x23)*(x4))>>64); + x40 = (x23)*(x3); + x41 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x3))>>32 : ((__uint128_t)(x23)*(x3))>>64); + x42 = (x23)*(x2); + x43 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x2))>>32 : ((__uint128_t)(x23)*(x2))>>64); + x44 = (x23)*(x1); + x45 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x1))>>32 : ((__uint128_t)(x23)*(x1))>>64); + x46 = (x23)*(x0); + x47 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x0))>>32 : ((__uint128_t)(x23)*(x0))>>64); + x48 = (x47)+(x44); + x49 = (uintptr_t)((x48)<(x47)); + x50 = (x49)+(x45); + x51 = (uintptr_t)((x50)<(x45)); + x52 = (x50)+(x42); + x53 = (uintptr_t)((x52)<(x42)); + x54 = (x51)+(x53); + x55 = (x54)+(x43); + x56 = (uintptr_t)((x55)<(x43)); + x57 = (x55)+(x40); + x58 = (uintptr_t)((x57)<(x40)); + x59 = (x56)+(x58); + x60 = (x59)+(x41); + x61 = (uintptr_t)((x60)<(x41)); + x62 = (x60)+(x38); + x63 = (uintptr_t)((x62)<(x38)); + x64 = (x61)+(x63); + x65 = (x64)+(x39); + x66 = (uintptr_t)((x65)<(x39)); + x67 = (x65)+(x36); + x68 = (uintptr_t)((x67)<(x36)); + x69 = (x66)+(x68); + x70 = (x69)+(x37); + x71 = (uintptr_t)((x70)<(x37)); + x72 = (x70)+(x34); + x73 = (uintptr_t)((x72)<(x34)); + x74 = (x71)+(x73); + x75 = (x74)+(x35); + x76 = (uintptr_t)((x75)<(x35)); + x77 = (x75)+(x32); + x78 = (uintptr_t)((x77)<(x32)); + x79 = (x76)+(x78); + x80 = (x79)+(x33); + x81 = (uintptr_t)((x80)<(x33)); + x82 = (x80)+(x30); + x83 = (uintptr_t)((x82)<(x30)); + x84 = (x81)+(x83); + x85 = (x84)+(x31); + x86 = (uintptr_t)((x85)<(x31)); + x87 = (x85)+(x28); + x88 = (uintptr_t)((x87)<(x28)); + x89 = (x86)+(x88); + x90 = (x89)+(x29); + x91 = (uintptr_t)((x90)<(x29)); + x92 = (x90)+(x26); + x93 = (uintptr_t)((x92)<(x26)); + x94 = (x91)+(x93); + x95 = (x94)+(x27); + x96 = (uintptr_t)((x95)<(x27)); + x97 = (x95)+(x24); + x98 = (uintptr_t)((x97)<(x24)); + x99 = (x96)+(x98); + x100 = (x99)+(x25); + x101 = (x46)*((uintptr_t)3901742149ULL); + x102 = (x101)*((uintptr_t)4294967295ULL); + x103 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x101)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x101)*((uintptr_t)4294967295ULL))>>64); + x104 = (x101)*((uintptr_t)4294967295ULL); + x105 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x101)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x101)*((uintptr_t)4294967295ULL))>>64); + x106 = (x101)*((uintptr_t)4294967295ULL); + x107 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x101)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x101)*((uintptr_t)4294967295ULL))>>64); + x108 = (x101)*((uintptr_t)4294967295ULL); + x109 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x101)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x101)*((uintptr_t)4294967295ULL))>>64); + x110 = (x101)*((uintptr_t)4294967295ULL); + x111 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x101)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x101)*((uintptr_t)4294967295ULL))>>64); + x112 = (x101)*((uintptr_t)4294967295ULL); + x113 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x101)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x101)*((uintptr_t)4294967295ULL))>>64); + x114 = (x101)*((uintptr_t)3345173889ULL); + x115 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x101)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x101)*((uintptr_t)3345173889ULL))>>64); + x116 = (x101)*((uintptr_t)4097256927ULL); + x117 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x101)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x101)*((uintptr_t)4097256927ULL))>>64); + x118 = (x101)*((uintptr_t)1478102450ULL); + x119 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x101)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x101)*((uintptr_t)1478102450ULL))>>64); + x120 = (x101)*((uintptr_t)1219536762ULL); + x121 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x101)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x101)*((uintptr_t)1219536762ULL))>>64); + x122 = (x101)*((uintptr_t)3974895978ULL); + x123 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x101)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x101)*((uintptr_t)3974895978ULL))>>64); + x124 = (x101)*((uintptr_t)3435473267ULL); + x125 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x101)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x101)*((uintptr_t)3435473267ULL))>>64); + x126 = (x125)+(x122); + x127 = (uintptr_t)((x126)<(x125)); + x128 = (x127)+(x123); + x129 = (uintptr_t)((x128)<(x123)); + x130 = (x128)+(x120); + x131 = (uintptr_t)((x130)<(x120)); + x132 = (x129)+(x131); + x133 = (x132)+(x121); + x134 = (uintptr_t)((x133)<(x121)); + x135 = (x133)+(x118); + x136 = (uintptr_t)((x135)<(x118)); + x137 = (x134)+(x136); + x138 = (x137)+(x119); + x139 = (uintptr_t)((x138)<(x119)); + x140 = (x138)+(x116); + x141 = (uintptr_t)((x140)<(x116)); + x142 = (x139)+(x141); + x143 = (x142)+(x117); + x144 = (uintptr_t)((x143)<(x117)); + x145 = (x143)+(x114); + x146 = (uintptr_t)((x145)<(x114)); + x147 = (x144)+(x146); + x148 = (x147)+(x115); + x149 = (uintptr_t)((x148)<(x115)); + x150 = (x148)+(x112); + x151 = (uintptr_t)((x150)<(x112)); + x152 = (x149)+(x151); + x153 = (x152)+(x113); + x154 = (uintptr_t)((x153)<(x113)); + x155 = (x153)+(x110); + x156 = (uintptr_t)((x155)<(x110)); + x157 = (x154)+(x156); + x158 = (x157)+(x111); + x159 = (uintptr_t)((x158)<(x111)); + x160 = (x158)+(x108); + x161 = (uintptr_t)((x160)<(x108)); + x162 = (x159)+(x161); + x163 = (x162)+(x109); + x164 = (uintptr_t)((x163)<(x109)); + x165 = (x163)+(x106); + x166 = (uintptr_t)((x165)<(x106)); + x167 = (x164)+(x166); + x168 = (x167)+(x107); + x169 = (uintptr_t)((x168)<(x107)); + x170 = (x168)+(x104); + x171 = (uintptr_t)((x170)<(x104)); + x172 = (x169)+(x171); + x173 = (x172)+(x105); + x174 = (uintptr_t)((x173)<(x105)); + x175 = (x173)+(x102); + x176 = (uintptr_t)((x175)<(x102)); + x177 = (x174)+(x176); + x178 = (x177)+(x103); + x179 = (x46)+(x124); + x180 = (uintptr_t)((x179)<(x46)); + x181 = (x180)+(x48); + x182 = (uintptr_t)((x181)<(x48)); + x183 = (x181)+(x126); + x184 = (uintptr_t)((x183)<(x126)); + x185 = (x182)+(x184); + x186 = (x185)+(x52); + x187 = (uintptr_t)((x186)<(x52)); + x188 = (x186)+(x130); + x189 = (uintptr_t)((x188)<(x130)); + x190 = (x187)+(x189); + x191 = (x190)+(x57); + x192 = (uintptr_t)((x191)<(x57)); + x193 = (x191)+(x135); + x194 = (uintptr_t)((x193)<(x135)); + x195 = (x192)+(x194); + x196 = (x195)+(x62); + x197 = (uintptr_t)((x196)<(x62)); + x198 = (x196)+(x140); + x199 = (uintptr_t)((x198)<(x140)); + x200 = (x197)+(x199); + x201 = (x200)+(x67); + x202 = (uintptr_t)((x201)<(x67)); + x203 = (x201)+(x145); + x204 = (uintptr_t)((x203)<(x145)); + x205 = (x202)+(x204); + x206 = (x205)+(x72); + x207 = (uintptr_t)((x206)<(x72)); + x208 = (x206)+(x150); + x209 = (uintptr_t)((x208)<(x150)); + x210 = (x207)+(x209); + x211 = (x210)+(x77); + x212 = (uintptr_t)((x211)<(x77)); + x213 = (x211)+(x155); + x214 = (uintptr_t)((x213)<(x155)); + x215 = (x212)+(x214); + x216 = (x215)+(x82); + x217 = (uintptr_t)((x216)<(x82)); + x218 = (x216)+(x160); + x219 = (uintptr_t)((x218)<(x160)); + x220 = (x217)+(x219); + x221 = (x220)+(x87); + x222 = (uintptr_t)((x221)<(x87)); + x223 = (x221)+(x165); + x224 = (uintptr_t)((x223)<(x165)); + x225 = (x222)+(x224); + x226 = (x225)+(x92); + x227 = (uintptr_t)((x226)<(x92)); + x228 = (x226)+(x170); + x229 = (uintptr_t)((x228)<(x170)); + x230 = (x227)+(x229); + x231 = (x230)+(x97); + x232 = (uintptr_t)((x231)<(x97)); + x233 = (x231)+(x175); + x234 = (uintptr_t)((x233)<(x175)); + x235 = (x232)+(x234); + x236 = (x235)+(x100); + x237 = (uintptr_t)((x236)<(x100)); + x238 = (x236)+(x178); + x239 = (uintptr_t)((x238)<(x178)); + x240 = (x237)+(x239); + x241 = (x12)*(x11); + x242 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x11))>>32 : ((__uint128_t)(x12)*(x11))>>64); + x243 = (x12)*(x10); + x244 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x10))>>32 : ((__uint128_t)(x12)*(x10))>>64); + x245 = (x12)*(x9); + x246 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x9))>>32 : ((__uint128_t)(x12)*(x9))>>64); + x247 = (x12)*(x8); + x248 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x8))>>32 : ((__uint128_t)(x12)*(x8))>>64); + x249 = (x12)*(x7); + x250 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x7))>>32 : ((__uint128_t)(x12)*(x7))>>64); + x251 = (x12)*(x6); + x252 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x6))>>32 : ((__uint128_t)(x12)*(x6))>>64); + x253 = (x12)*(x5); + x254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x5))>>32 : ((__uint128_t)(x12)*(x5))>>64); + x255 = (x12)*(x4); + x256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x4))>>32 : ((__uint128_t)(x12)*(x4))>>64); + x257 = (x12)*(x3); + x258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x3))>>32 : ((__uint128_t)(x12)*(x3))>>64); + x259 = (x12)*(x2); + x260 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x2))>>32 : ((__uint128_t)(x12)*(x2))>>64); + x261 = (x12)*(x1); + x262 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x1))>>32 : ((__uint128_t)(x12)*(x1))>>64); + x263 = (x12)*(x0); + x264 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x0))>>32 : ((__uint128_t)(x12)*(x0))>>64); + x265 = (x264)+(x261); + x266 = (uintptr_t)((x265)<(x264)); + x267 = (x266)+(x262); + x268 = (uintptr_t)((x267)<(x262)); + x269 = (x267)+(x259); + x270 = (uintptr_t)((x269)<(x259)); + x271 = (x268)+(x270); + x272 = (x271)+(x260); + x273 = (uintptr_t)((x272)<(x260)); + x274 = (x272)+(x257); + x275 = (uintptr_t)((x274)<(x257)); + x276 = (x273)+(x275); + x277 = (x276)+(x258); + x278 = (uintptr_t)((x277)<(x258)); + x279 = (x277)+(x255); + x280 = (uintptr_t)((x279)<(x255)); + x281 = (x278)+(x280); + x282 = (x281)+(x256); + x283 = (uintptr_t)((x282)<(x256)); + x284 = (x282)+(x253); + x285 = (uintptr_t)((x284)<(x253)); + x286 = (x283)+(x285); + x287 = (x286)+(x254); + x288 = (uintptr_t)((x287)<(x254)); + x289 = (x287)+(x251); + x290 = (uintptr_t)((x289)<(x251)); + x291 = (x288)+(x290); + x292 = (x291)+(x252); + x293 = (uintptr_t)((x292)<(x252)); + x294 = (x292)+(x249); + x295 = (uintptr_t)((x294)<(x249)); + x296 = (x293)+(x295); + x297 = (x296)+(x250); + x298 = (uintptr_t)((x297)<(x250)); + x299 = (x297)+(x247); + x300 = (uintptr_t)((x299)<(x247)); + x301 = (x298)+(x300); + x302 = (x301)+(x248); + x303 = (uintptr_t)((x302)<(x248)); + x304 = (x302)+(x245); + x305 = (uintptr_t)((x304)<(x245)); + x306 = (x303)+(x305); + x307 = (x306)+(x246); + x308 = (uintptr_t)((x307)<(x246)); + x309 = (x307)+(x243); + x310 = (uintptr_t)((x309)<(x243)); + x311 = (x308)+(x310); + x312 = (x311)+(x244); + x313 = (uintptr_t)((x312)<(x244)); + x314 = (x312)+(x241); + x315 = (uintptr_t)((x314)<(x241)); + x316 = (x313)+(x315); + x317 = (x316)+(x242); + x318 = (x183)+(x263); + x319 = (uintptr_t)((x318)<(x183)); + x320 = (x319)+(x188); + x321 = (uintptr_t)((x320)<(x188)); + x322 = (x320)+(x265); + x323 = (uintptr_t)((x322)<(x265)); + x324 = (x321)+(x323); + x325 = (x324)+(x193); + x326 = (uintptr_t)((x325)<(x193)); + x327 = (x325)+(x269); + x328 = (uintptr_t)((x327)<(x269)); + x329 = (x326)+(x328); + x330 = (x329)+(x198); + x331 = (uintptr_t)((x330)<(x198)); + x332 = (x330)+(x274); + x333 = (uintptr_t)((x332)<(x274)); + x334 = (x331)+(x333); + x335 = (x334)+(x203); + x336 = (uintptr_t)((x335)<(x203)); + x337 = (x335)+(x279); + x338 = (uintptr_t)((x337)<(x279)); + x339 = (x336)+(x338); + x340 = (x339)+(x208); + x341 = (uintptr_t)((x340)<(x208)); + x342 = (x340)+(x284); + x343 = (uintptr_t)((x342)<(x284)); + x344 = (x341)+(x343); + x345 = (x344)+(x213); + x346 = (uintptr_t)((x345)<(x213)); + x347 = (x345)+(x289); + x348 = (uintptr_t)((x347)<(x289)); + x349 = (x346)+(x348); + x350 = (x349)+(x218); + x351 = (uintptr_t)((x350)<(x218)); + x352 = (x350)+(x294); + x353 = (uintptr_t)((x352)<(x294)); + x354 = (x351)+(x353); + x355 = (x354)+(x223); + x356 = (uintptr_t)((x355)<(x223)); + x357 = (x355)+(x299); + x358 = (uintptr_t)((x357)<(x299)); + x359 = (x356)+(x358); + x360 = (x359)+(x228); + x361 = (uintptr_t)((x360)<(x228)); + x362 = (x360)+(x304); + x363 = (uintptr_t)((x362)<(x304)); + x364 = (x361)+(x363); + x365 = (x364)+(x233); + x366 = (uintptr_t)((x365)<(x233)); + x367 = (x365)+(x309); + x368 = (uintptr_t)((x367)<(x309)); + x369 = (x366)+(x368); + x370 = (x369)+(x238); + x371 = (uintptr_t)((x370)<(x238)); + x372 = (x370)+(x314); + x373 = (uintptr_t)((x372)<(x314)); + x374 = (x371)+(x373); + x375 = (x374)+(x240); + x376 = (uintptr_t)((x375)<(x240)); + x377 = (x375)+(x317); + x378 = (uintptr_t)((x377)<(x317)); + x379 = (x376)+(x378); + x380 = (x318)*((uintptr_t)3901742149ULL); + x381 = (x380)*((uintptr_t)4294967295ULL); + x382 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x380)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x380)*((uintptr_t)4294967295ULL))>>64); + x383 = (x380)*((uintptr_t)4294967295ULL); + x384 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x380)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x380)*((uintptr_t)4294967295ULL))>>64); + x385 = (x380)*((uintptr_t)4294967295ULL); + x386 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x380)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x380)*((uintptr_t)4294967295ULL))>>64); + x387 = (x380)*((uintptr_t)4294967295ULL); + x388 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x380)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x380)*((uintptr_t)4294967295ULL))>>64); + x389 = (x380)*((uintptr_t)4294967295ULL); + x390 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x380)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x380)*((uintptr_t)4294967295ULL))>>64); + x391 = (x380)*((uintptr_t)4294967295ULL); + x392 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x380)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x380)*((uintptr_t)4294967295ULL))>>64); + x393 = (x380)*((uintptr_t)3345173889ULL); + x394 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x380)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x380)*((uintptr_t)3345173889ULL))>>64); + x395 = (x380)*((uintptr_t)4097256927ULL); + x396 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x380)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x380)*((uintptr_t)4097256927ULL))>>64); + x397 = (x380)*((uintptr_t)1478102450ULL); + x398 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x380)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x380)*((uintptr_t)1478102450ULL))>>64); + x399 = (x380)*((uintptr_t)1219536762ULL); + x400 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x380)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x380)*((uintptr_t)1219536762ULL))>>64); + x401 = (x380)*((uintptr_t)3974895978ULL); + x402 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x380)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x380)*((uintptr_t)3974895978ULL))>>64); + x403 = (x380)*((uintptr_t)3435473267ULL); + x404 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x380)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x380)*((uintptr_t)3435473267ULL))>>64); + x405 = (x404)+(x401); + x406 = (uintptr_t)((x405)<(x404)); + x407 = (x406)+(x402); + x408 = (uintptr_t)((x407)<(x402)); + x409 = (x407)+(x399); + x410 = (uintptr_t)((x409)<(x399)); + x411 = (x408)+(x410); + x412 = (x411)+(x400); + x413 = (uintptr_t)((x412)<(x400)); + x414 = (x412)+(x397); + x415 = (uintptr_t)((x414)<(x397)); + x416 = (x413)+(x415); + x417 = (x416)+(x398); + x418 = (uintptr_t)((x417)<(x398)); + x419 = (x417)+(x395); + x420 = (uintptr_t)((x419)<(x395)); + x421 = (x418)+(x420); + x422 = (x421)+(x396); + x423 = (uintptr_t)((x422)<(x396)); + x424 = (x422)+(x393); + x425 = (uintptr_t)((x424)<(x393)); + x426 = (x423)+(x425); + x427 = (x426)+(x394); + x428 = (uintptr_t)((x427)<(x394)); + x429 = (x427)+(x391); + x430 = (uintptr_t)((x429)<(x391)); + x431 = (x428)+(x430); + x432 = (x431)+(x392); + x433 = (uintptr_t)((x432)<(x392)); + x434 = (x432)+(x389); + x435 = (uintptr_t)((x434)<(x389)); + x436 = (x433)+(x435); + x437 = (x436)+(x390); + x438 = (uintptr_t)((x437)<(x390)); + x439 = (x437)+(x387); + x440 = (uintptr_t)((x439)<(x387)); + x441 = (x438)+(x440); + x442 = (x441)+(x388); + x443 = (uintptr_t)((x442)<(x388)); + x444 = (x442)+(x385); + x445 = (uintptr_t)((x444)<(x385)); + x446 = (x443)+(x445); + x447 = (x446)+(x386); + x448 = (uintptr_t)((x447)<(x386)); + x449 = (x447)+(x383); + x450 = (uintptr_t)((x449)<(x383)); + x451 = (x448)+(x450); + x452 = (x451)+(x384); + x453 = (uintptr_t)((x452)<(x384)); + x454 = (x452)+(x381); + x455 = (uintptr_t)((x454)<(x381)); + x456 = (x453)+(x455); + x457 = (x456)+(x382); + x458 = (x318)+(x403); + x459 = (uintptr_t)((x458)<(x318)); + x460 = (x459)+(x322); + x461 = (uintptr_t)((x460)<(x322)); + x462 = (x460)+(x405); + x463 = (uintptr_t)((x462)<(x405)); + x464 = (x461)+(x463); + x465 = (x464)+(x327); + x466 = (uintptr_t)((x465)<(x327)); + x467 = (x465)+(x409); + x468 = (uintptr_t)((x467)<(x409)); + x469 = (x466)+(x468); + x470 = (x469)+(x332); + x471 = (uintptr_t)((x470)<(x332)); + x472 = (x470)+(x414); + x473 = (uintptr_t)((x472)<(x414)); + x474 = (x471)+(x473); + x475 = (x474)+(x337); + x476 = (uintptr_t)((x475)<(x337)); + x477 = (x475)+(x419); + x478 = (uintptr_t)((x477)<(x419)); + x479 = (x476)+(x478); + x480 = (x479)+(x342); + x481 = (uintptr_t)((x480)<(x342)); + x482 = (x480)+(x424); + x483 = (uintptr_t)((x482)<(x424)); + x484 = (x481)+(x483); + x485 = (x484)+(x347); + x486 = (uintptr_t)((x485)<(x347)); + x487 = (x485)+(x429); + x488 = (uintptr_t)((x487)<(x429)); + x489 = (x486)+(x488); + x490 = (x489)+(x352); + x491 = (uintptr_t)((x490)<(x352)); + x492 = (x490)+(x434); + x493 = (uintptr_t)((x492)<(x434)); + x494 = (x491)+(x493); + x495 = (x494)+(x357); + x496 = (uintptr_t)((x495)<(x357)); + x497 = (x495)+(x439); + x498 = (uintptr_t)((x497)<(x439)); + x499 = (x496)+(x498); + x500 = (x499)+(x362); + x501 = (uintptr_t)((x500)<(x362)); + x502 = (x500)+(x444); + x503 = (uintptr_t)((x502)<(x444)); + x504 = (x501)+(x503); + x505 = (x504)+(x367); + x506 = (uintptr_t)((x505)<(x367)); + x507 = (x505)+(x449); + x508 = (uintptr_t)((x507)<(x449)); + x509 = (x506)+(x508); + x510 = (x509)+(x372); + x511 = (uintptr_t)((x510)<(x372)); + x512 = (x510)+(x454); + x513 = (uintptr_t)((x512)<(x454)); + x514 = (x511)+(x513); + x515 = (x514)+(x377); + x516 = (uintptr_t)((x515)<(x377)); + x517 = (x515)+(x457); + x518 = (uintptr_t)((x517)<(x457)); + x519 = (x516)+(x518); + x520 = (x519)+(x379); + x521 = (x13)*(x11); + x522 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x11))>>32 : ((__uint128_t)(x13)*(x11))>>64); + x523 = (x13)*(x10); + x524 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x10))>>32 : ((__uint128_t)(x13)*(x10))>>64); + x525 = (x13)*(x9); + x526 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x9))>>32 : ((__uint128_t)(x13)*(x9))>>64); + x527 = (x13)*(x8); + x528 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x8))>>32 : ((__uint128_t)(x13)*(x8))>>64); + x529 = (x13)*(x7); + x530 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x7))>>32 : ((__uint128_t)(x13)*(x7))>>64); + x531 = (x13)*(x6); + x532 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x6))>>32 : ((__uint128_t)(x13)*(x6))>>64); + x533 = (x13)*(x5); + x534 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x5))>>32 : ((__uint128_t)(x13)*(x5))>>64); + x535 = (x13)*(x4); + x536 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x4))>>32 : ((__uint128_t)(x13)*(x4))>>64); + x537 = (x13)*(x3); + x538 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x3))>>32 : ((__uint128_t)(x13)*(x3))>>64); + x539 = (x13)*(x2); + x540 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x2))>>32 : ((__uint128_t)(x13)*(x2))>>64); + x541 = (x13)*(x1); + x542 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x1))>>32 : ((__uint128_t)(x13)*(x1))>>64); + x543 = (x13)*(x0); + x544 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x0))>>32 : ((__uint128_t)(x13)*(x0))>>64); + x545 = (x544)+(x541); + x546 = (uintptr_t)((x545)<(x544)); + x547 = (x546)+(x542); + x548 = (uintptr_t)((x547)<(x542)); + x549 = (x547)+(x539); + x550 = (uintptr_t)((x549)<(x539)); + x551 = (x548)+(x550); + x552 = (x551)+(x540); + x553 = (uintptr_t)((x552)<(x540)); + x554 = (x552)+(x537); + x555 = (uintptr_t)((x554)<(x537)); + x556 = (x553)+(x555); + x557 = (x556)+(x538); + x558 = (uintptr_t)((x557)<(x538)); + x559 = (x557)+(x535); + x560 = (uintptr_t)((x559)<(x535)); + x561 = (x558)+(x560); + x562 = (x561)+(x536); + x563 = (uintptr_t)((x562)<(x536)); + x564 = (x562)+(x533); + x565 = (uintptr_t)((x564)<(x533)); + x566 = (x563)+(x565); + x567 = (x566)+(x534); + x568 = (uintptr_t)((x567)<(x534)); + x569 = (x567)+(x531); + x570 = (uintptr_t)((x569)<(x531)); + x571 = (x568)+(x570); + x572 = (x571)+(x532); + x573 = (uintptr_t)((x572)<(x532)); + x574 = (x572)+(x529); + x575 = (uintptr_t)((x574)<(x529)); + x576 = (x573)+(x575); + x577 = (x576)+(x530); + x578 = (uintptr_t)((x577)<(x530)); + x579 = (x577)+(x527); + x580 = (uintptr_t)((x579)<(x527)); + x581 = (x578)+(x580); + x582 = (x581)+(x528); + x583 = (uintptr_t)((x582)<(x528)); + x584 = (x582)+(x525); + x585 = (uintptr_t)((x584)<(x525)); + x586 = (x583)+(x585); + x587 = (x586)+(x526); + x588 = (uintptr_t)((x587)<(x526)); + x589 = (x587)+(x523); + x590 = (uintptr_t)((x589)<(x523)); + x591 = (x588)+(x590); + x592 = (x591)+(x524); + x593 = (uintptr_t)((x592)<(x524)); + x594 = (x592)+(x521); + x595 = (uintptr_t)((x594)<(x521)); + x596 = (x593)+(x595); + x597 = (x596)+(x522); + x598 = (x462)+(x543); + x599 = (uintptr_t)((x598)<(x462)); + x600 = (x599)+(x467); + x601 = (uintptr_t)((x600)<(x467)); + x602 = (x600)+(x545); + x603 = (uintptr_t)((x602)<(x545)); + x604 = (x601)+(x603); + x605 = (x604)+(x472); + x606 = (uintptr_t)((x605)<(x472)); + x607 = (x605)+(x549); + x608 = (uintptr_t)((x607)<(x549)); + x609 = (x606)+(x608); + x610 = (x609)+(x477); + x611 = (uintptr_t)((x610)<(x477)); + x612 = (x610)+(x554); + x613 = (uintptr_t)((x612)<(x554)); + x614 = (x611)+(x613); + x615 = (x614)+(x482); + x616 = (uintptr_t)((x615)<(x482)); + x617 = (x615)+(x559); + x618 = (uintptr_t)((x617)<(x559)); + x619 = (x616)+(x618); + x620 = (x619)+(x487); + x621 = (uintptr_t)((x620)<(x487)); + x622 = (x620)+(x564); + x623 = (uintptr_t)((x622)<(x564)); + x624 = (x621)+(x623); + x625 = (x624)+(x492); + x626 = (uintptr_t)((x625)<(x492)); + x627 = (x625)+(x569); + x628 = (uintptr_t)((x627)<(x569)); + x629 = (x626)+(x628); + x630 = (x629)+(x497); + x631 = (uintptr_t)((x630)<(x497)); + x632 = (x630)+(x574); + x633 = (uintptr_t)((x632)<(x574)); + x634 = (x631)+(x633); + x635 = (x634)+(x502); + x636 = (uintptr_t)((x635)<(x502)); + x637 = (x635)+(x579); + x638 = (uintptr_t)((x637)<(x579)); + x639 = (x636)+(x638); + x640 = (x639)+(x507); + x641 = (uintptr_t)((x640)<(x507)); + x642 = (x640)+(x584); + x643 = (uintptr_t)((x642)<(x584)); + x644 = (x641)+(x643); + x645 = (x644)+(x512); + x646 = (uintptr_t)((x645)<(x512)); + x647 = (x645)+(x589); + x648 = (uintptr_t)((x647)<(x589)); + x649 = (x646)+(x648); + x650 = (x649)+(x517); + x651 = (uintptr_t)((x650)<(x517)); + x652 = (x650)+(x594); + x653 = (uintptr_t)((x652)<(x594)); + x654 = (x651)+(x653); + x655 = (x654)+(x520); + x656 = (uintptr_t)((x655)<(x520)); + x657 = (x655)+(x597); + x658 = (uintptr_t)((x657)<(x597)); + x659 = (x656)+(x658); + x660 = (x598)*((uintptr_t)3901742149ULL); + x661 = (x660)*((uintptr_t)4294967295ULL); + x662 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x660)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x660)*((uintptr_t)4294967295ULL))>>64); + x663 = (x660)*((uintptr_t)4294967295ULL); + x664 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x660)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x660)*((uintptr_t)4294967295ULL))>>64); + x665 = (x660)*((uintptr_t)4294967295ULL); + x666 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x660)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x660)*((uintptr_t)4294967295ULL))>>64); + x667 = (x660)*((uintptr_t)4294967295ULL); + x668 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x660)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x660)*((uintptr_t)4294967295ULL))>>64); + x669 = (x660)*((uintptr_t)4294967295ULL); + x670 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x660)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x660)*((uintptr_t)4294967295ULL))>>64); + x671 = (x660)*((uintptr_t)4294967295ULL); + x672 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x660)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x660)*((uintptr_t)4294967295ULL))>>64); + x673 = (x660)*((uintptr_t)3345173889ULL); + x674 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x660)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x660)*((uintptr_t)3345173889ULL))>>64); + x675 = (x660)*((uintptr_t)4097256927ULL); + x676 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x660)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x660)*((uintptr_t)4097256927ULL))>>64); + x677 = (x660)*((uintptr_t)1478102450ULL); + x678 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x660)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x660)*((uintptr_t)1478102450ULL))>>64); + x679 = (x660)*((uintptr_t)1219536762ULL); + x680 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x660)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x660)*((uintptr_t)1219536762ULL))>>64); + x681 = (x660)*((uintptr_t)3974895978ULL); + x682 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x660)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x660)*((uintptr_t)3974895978ULL))>>64); + x683 = (x660)*((uintptr_t)3435473267ULL); + x684 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x660)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x660)*((uintptr_t)3435473267ULL))>>64); + x685 = (x684)+(x681); + x686 = (uintptr_t)((x685)<(x684)); + x687 = (x686)+(x682); + x688 = (uintptr_t)((x687)<(x682)); + x689 = (x687)+(x679); + x690 = (uintptr_t)((x689)<(x679)); + x691 = (x688)+(x690); + x692 = (x691)+(x680); + x693 = (uintptr_t)((x692)<(x680)); + x694 = (x692)+(x677); + x695 = (uintptr_t)((x694)<(x677)); + x696 = (x693)+(x695); + x697 = (x696)+(x678); + x698 = (uintptr_t)((x697)<(x678)); + x699 = (x697)+(x675); + x700 = (uintptr_t)((x699)<(x675)); + x701 = (x698)+(x700); + x702 = (x701)+(x676); + x703 = (uintptr_t)((x702)<(x676)); + x704 = (x702)+(x673); + x705 = (uintptr_t)((x704)<(x673)); + x706 = (x703)+(x705); + x707 = (x706)+(x674); + x708 = (uintptr_t)((x707)<(x674)); + x709 = (x707)+(x671); + x710 = (uintptr_t)((x709)<(x671)); + x711 = (x708)+(x710); + x712 = (x711)+(x672); + x713 = (uintptr_t)((x712)<(x672)); + x714 = (x712)+(x669); + x715 = (uintptr_t)((x714)<(x669)); + x716 = (x713)+(x715); + x717 = (x716)+(x670); + x718 = (uintptr_t)((x717)<(x670)); + x719 = (x717)+(x667); + x720 = (uintptr_t)((x719)<(x667)); + x721 = (x718)+(x720); + x722 = (x721)+(x668); + x723 = (uintptr_t)((x722)<(x668)); + x724 = (x722)+(x665); + x725 = (uintptr_t)((x724)<(x665)); + x726 = (x723)+(x725); + x727 = (x726)+(x666); + x728 = (uintptr_t)((x727)<(x666)); + x729 = (x727)+(x663); + x730 = (uintptr_t)((x729)<(x663)); + x731 = (x728)+(x730); + x732 = (x731)+(x664); + x733 = (uintptr_t)((x732)<(x664)); + x734 = (x732)+(x661); + x735 = (uintptr_t)((x734)<(x661)); + x736 = (x733)+(x735); + x737 = (x736)+(x662); + x738 = (x598)+(x683); + x739 = (uintptr_t)((x738)<(x598)); + x740 = (x739)+(x602); + x741 = (uintptr_t)((x740)<(x602)); + x742 = (x740)+(x685); + x743 = (uintptr_t)((x742)<(x685)); + x744 = (x741)+(x743); + x745 = (x744)+(x607); + x746 = (uintptr_t)((x745)<(x607)); + x747 = (x745)+(x689); + x748 = (uintptr_t)((x747)<(x689)); + x749 = (x746)+(x748); + x750 = (x749)+(x612); + x751 = (uintptr_t)((x750)<(x612)); + x752 = (x750)+(x694); + x753 = (uintptr_t)((x752)<(x694)); + x754 = (x751)+(x753); + x755 = (x754)+(x617); + x756 = (uintptr_t)((x755)<(x617)); + x757 = (x755)+(x699); + x758 = (uintptr_t)((x757)<(x699)); + x759 = (x756)+(x758); + x760 = (x759)+(x622); + x761 = (uintptr_t)((x760)<(x622)); + x762 = (x760)+(x704); + x763 = (uintptr_t)((x762)<(x704)); + x764 = (x761)+(x763); + x765 = (x764)+(x627); + x766 = (uintptr_t)((x765)<(x627)); + x767 = (x765)+(x709); + x768 = (uintptr_t)((x767)<(x709)); + x769 = (x766)+(x768); + x770 = (x769)+(x632); + x771 = (uintptr_t)((x770)<(x632)); + x772 = (x770)+(x714); + x773 = (uintptr_t)((x772)<(x714)); + x774 = (x771)+(x773); + x775 = (x774)+(x637); + x776 = (uintptr_t)((x775)<(x637)); + x777 = (x775)+(x719); + x778 = (uintptr_t)((x777)<(x719)); + x779 = (x776)+(x778); + x780 = (x779)+(x642); + x781 = (uintptr_t)((x780)<(x642)); + x782 = (x780)+(x724); + x783 = (uintptr_t)((x782)<(x724)); + x784 = (x781)+(x783); + x785 = (x784)+(x647); + x786 = (uintptr_t)((x785)<(x647)); + x787 = (x785)+(x729); + x788 = (uintptr_t)((x787)<(x729)); + x789 = (x786)+(x788); + x790 = (x789)+(x652); + x791 = (uintptr_t)((x790)<(x652)); + x792 = (x790)+(x734); + x793 = (uintptr_t)((x792)<(x734)); + x794 = (x791)+(x793); + x795 = (x794)+(x657); + x796 = (uintptr_t)((x795)<(x657)); + x797 = (x795)+(x737); + x798 = (uintptr_t)((x797)<(x737)); + x799 = (x796)+(x798); + x800 = (x799)+(x659); + x801 = (x14)*(x11); + x802 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x11))>>32 : ((__uint128_t)(x14)*(x11))>>64); + x803 = (x14)*(x10); + x804 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x10))>>32 : ((__uint128_t)(x14)*(x10))>>64); + x805 = (x14)*(x9); + x806 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x9))>>32 : ((__uint128_t)(x14)*(x9))>>64); + x807 = (x14)*(x8); + x808 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x8))>>32 : ((__uint128_t)(x14)*(x8))>>64); + x809 = (x14)*(x7); + x810 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x7))>>32 : ((__uint128_t)(x14)*(x7))>>64); + x811 = (x14)*(x6); + x812 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x6))>>32 : ((__uint128_t)(x14)*(x6))>>64); + x813 = (x14)*(x5); + x814 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x5))>>32 : ((__uint128_t)(x14)*(x5))>>64); + x815 = (x14)*(x4); + x816 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x4))>>32 : ((__uint128_t)(x14)*(x4))>>64); + x817 = (x14)*(x3); + x818 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x3))>>32 : ((__uint128_t)(x14)*(x3))>>64); + x819 = (x14)*(x2); + x820 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x2))>>32 : ((__uint128_t)(x14)*(x2))>>64); + x821 = (x14)*(x1); + x822 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x1))>>32 : ((__uint128_t)(x14)*(x1))>>64); + x823 = (x14)*(x0); + x824 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x0))>>32 : ((__uint128_t)(x14)*(x0))>>64); + x825 = (x824)+(x821); + x826 = (uintptr_t)((x825)<(x824)); + x827 = (x826)+(x822); + x828 = (uintptr_t)((x827)<(x822)); + x829 = (x827)+(x819); + x830 = (uintptr_t)((x829)<(x819)); + x831 = (x828)+(x830); + x832 = (x831)+(x820); + x833 = (uintptr_t)((x832)<(x820)); + x834 = (x832)+(x817); + x835 = (uintptr_t)((x834)<(x817)); + x836 = (x833)+(x835); + x837 = (x836)+(x818); + x838 = (uintptr_t)((x837)<(x818)); + x839 = (x837)+(x815); + x840 = (uintptr_t)((x839)<(x815)); + x841 = (x838)+(x840); + x842 = (x841)+(x816); + x843 = (uintptr_t)((x842)<(x816)); + x844 = (x842)+(x813); + x845 = (uintptr_t)((x844)<(x813)); + x846 = (x843)+(x845); + x847 = (x846)+(x814); + x848 = (uintptr_t)((x847)<(x814)); + x849 = (x847)+(x811); + x850 = (uintptr_t)((x849)<(x811)); + x851 = (x848)+(x850); + x852 = (x851)+(x812); + x853 = (uintptr_t)((x852)<(x812)); + x854 = (x852)+(x809); + x855 = (uintptr_t)((x854)<(x809)); + x856 = (x853)+(x855); + x857 = (x856)+(x810); + x858 = (uintptr_t)((x857)<(x810)); + x859 = (x857)+(x807); + x860 = (uintptr_t)((x859)<(x807)); + x861 = (x858)+(x860); + x862 = (x861)+(x808); + x863 = (uintptr_t)((x862)<(x808)); + x864 = (x862)+(x805); + x865 = (uintptr_t)((x864)<(x805)); + x866 = (x863)+(x865); + x867 = (x866)+(x806); + x868 = (uintptr_t)((x867)<(x806)); + x869 = (x867)+(x803); + x870 = (uintptr_t)((x869)<(x803)); + x871 = (x868)+(x870); + x872 = (x871)+(x804); + x873 = (uintptr_t)((x872)<(x804)); + x874 = (x872)+(x801); + x875 = (uintptr_t)((x874)<(x801)); + x876 = (x873)+(x875); + x877 = (x876)+(x802); + x878 = (x742)+(x823); + x879 = (uintptr_t)((x878)<(x742)); + x880 = (x879)+(x747); + x881 = (uintptr_t)((x880)<(x747)); + x882 = (x880)+(x825); + x883 = (uintptr_t)((x882)<(x825)); + x884 = (x881)+(x883); + x885 = (x884)+(x752); + x886 = (uintptr_t)((x885)<(x752)); + x887 = (x885)+(x829); + x888 = (uintptr_t)((x887)<(x829)); + x889 = (x886)+(x888); + x890 = (x889)+(x757); + x891 = (uintptr_t)((x890)<(x757)); + x892 = (x890)+(x834); + x893 = (uintptr_t)((x892)<(x834)); + x894 = (x891)+(x893); + x895 = (x894)+(x762); + x896 = (uintptr_t)((x895)<(x762)); + x897 = (x895)+(x839); + x898 = (uintptr_t)((x897)<(x839)); + x899 = (x896)+(x898); + x900 = (x899)+(x767); + x901 = (uintptr_t)((x900)<(x767)); + x902 = (x900)+(x844); + x903 = (uintptr_t)((x902)<(x844)); + x904 = (x901)+(x903); + x905 = (x904)+(x772); + x906 = (uintptr_t)((x905)<(x772)); + x907 = (x905)+(x849); + x908 = (uintptr_t)((x907)<(x849)); + x909 = (x906)+(x908); + x910 = (x909)+(x777); + x911 = (uintptr_t)((x910)<(x777)); + x912 = (x910)+(x854); + x913 = (uintptr_t)((x912)<(x854)); + x914 = (x911)+(x913); + x915 = (x914)+(x782); + x916 = (uintptr_t)((x915)<(x782)); + x917 = (x915)+(x859); + x918 = (uintptr_t)((x917)<(x859)); + x919 = (x916)+(x918); + x920 = (x919)+(x787); + x921 = (uintptr_t)((x920)<(x787)); + x922 = (x920)+(x864); + x923 = (uintptr_t)((x922)<(x864)); + x924 = (x921)+(x923); + x925 = (x924)+(x792); + x926 = (uintptr_t)((x925)<(x792)); + x927 = (x925)+(x869); + x928 = (uintptr_t)((x927)<(x869)); + x929 = (x926)+(x928); + x930 = (x929)+(x797); + x931 = (uintptr_t)((x930)<(x797)); + x932 = (x930)+(x874); + x933 = (uintptr_t)((x932)<(x874)); + x934 = (x931)+(x933); + x935 = (x934)+(x800); + x936 = (uintptr_t)((x935)<(x800)); + x937 = (x935)+(x877); + x938 = (uintptr_t)((x937)<(x877)); + x939 = (x936)+(x938); + x940 = (x878)*((uintptr_t)3901742149ULL); + x941 = (x940)*((uintptr_t)4294967295ULL); + x942 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x940)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x940)*((uintptr_t)4294967295ULL))>>64); + x943 = (x940)*((uintptr_t)4294967295ULL); + x944 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x940)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x940)*((uintptr_t)4294967295ULL))>>64); + x945 = (x940)*((uintptr_t)4294967295ULL); + x946 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x940)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x940)*((uintptr_t)4294967295ULL))>>64); + x947 = (x940)*((uintptr_t)4294967295ULL); + x948 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x940)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x940)*((uintptr_t)4294967295ULL))>>64); + x949 = (x940)*((uintptr_t)4294967295ULL); + x950 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x940)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x940)*((uintptr_t)4294967295ULL))>>64); + x951 = (x940)*((uintptr_t)4294967295ULL); + x952 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x940)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x940)*((uintptr_t)4294967295ULL))>>64); + x953 = (x940)*((uintptr_t)3345173889ULL); + x954 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x940)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x940)*((uintptr_t)3345173889ULL))>>64); + x955 = (x940)*((uintptr_t)4097256927ULL); + x956 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x940)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x940)*((uintptr_t)4097256927ULL))>>64); + x957 = (x940)*((uintptr_t)1478102450ULL); + x958 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x940)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x940)*((uintptr_t)1478102450ULL))>>64); + x959 = (x940)*((uintptr_t)1219536762ULL); + x960 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x940)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x940)*((uintptr_t)1219536762ULL))>>64); + x961 = (x940)*((uintptr_t)3974895978ULL); + x962 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x940)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x940)*((uintptr_t)3974895978ULL))>>64); + x963 = (x940)*((uintptr_t)3435473267ULL); + x964 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x940)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x940)*((uintptr_t)3435473267ULL))>>64); + x965 = (x964)+(x961); + x966 = (uintptr_t)((x965)<(x964)); + x967 = (x966)+(x962); + x968 = (uintptr_t)((x967)<(x962)); + x969 = (x967)+(x959); + x970 = (uintptr_t)((x969)<(x959)); + x971 = (x968)+(x970); + x972 = (x971)+(x960); + x973 = (uintptr_t)((x972)<(x960)); + x974 = (x972)+(x957); + x975 = (uintptr_t)((x974)<(x957)); + x976 = (x973)+(x975); + x977 = (x976)+(x958); + x978 = (uintptr_t)((x977)<(x958)); + x979 = (x977)+(x955); + x980 = (uintptr_t)((x979)<(x955)); + x981 = (x978)+(x980); + x982 = (x981)+(x956); + x983 = (uintptr_t)((x982)<(x956)); + x984 = (x982)+(x953); + x985 = (uintptr_t)((x984)<(x953)); + x986 = (x983)+(x985); + x987 = (x986)+(x954); + x988 = (uintptr_t)((x987)<(x954)); + x989 = (x987)+(x951); + x990 = (uintptr_t)((x989)<(x951)); + x991 = (x988)+(x990); + x992 = (x991)+(x952); + x993 = (uintptr_t)((x992)<(x952)); + x994 = (x992)+(x949); + x995 = (uintptr_t)((x994)<(x949)); + x996 = (x993)+(x995); + x997 = (x996)+(x950); + x998 = (uintptr_t)((x997)<(x950)); + x999 = (x997)+(x947); + x1000 = (uintptr_t)((x999)<(x947)); + x1001 = (x998)+(x1000); + x1002 = (x1001)+(x948); + x1003 = (uintptr_t)((x1002)<(x948)); + x1004 = (x1002)+(x945); + x1005 = (uintptr_t)((x1004)<(x945)); + x1006 = (x1003)+(x1005); + x1007 = (x1006)+(x946); + x1008 = (uintptr_t)((x1007)<(x946)); + x1009 = (x1007)+(x943); + x1010 = (uintptr_t)((x1009)<(x943)); + x1011 = (x1008)+(x1010); + x1012 = (x1011)+(x944); + x1013 = (uintptr_t)((x1012)<(x944)); + x1014 = (x1012)+(x941); + x1015 = (uintptr_t)((x1014)<(x941)); + x1016 = (x1013)+(x1015); + x1017 = (x1016)+(x942); + x1018 = (x878)+(x963); + x1019 = (uintptr_t)((x1018)<(x878)); + x1020 = (x1019)+(x882); + x1021 = (uintptr_t)((x1020)<(x882)); + x1022 = (x1020)+(x965); + x1023 = (uintptr_t)((x1022)<(x965)); + x1024 = (x1021)+(x1023); + x1025 = (x1024)+(x887); + x1026 = (uintptr_t)((x1025)<(x887)); + x1027 = (x1025)+(x969); + x1028 = (uintptr_t)((x1027)<(x969)); + x1029 = (x1026)+(x1028); + x1030 = (x1029)+(x892); + x1031 = (uintptr_t)((x1030)<(x892)); + x1032 = (x1030)+(x974); + x1033 = (uintptr_t)((x1032)<(x974)); + x1034 = (x1031)+(x1033); + x1035 = (x1034)+(x897); + x1036 = (uintptr_t)((x1035)<(x897)); + x1037 = (x1035)+(x979); + x1038 = (uintptr_t)((x1037)<(x979)); + x1039 = (x1036)+(x1038); + x1040 = (x1039)+(x902); + x1041 = (uintptr_t)((x1040)<(x902)); + x1042 = (x1040)+(x984); + x1043 = (uintptr_t)((x1042)<(x984)); + x1044 = (x1041)+(x1043); + x1045 = (x1044)+(x907); + x1046 = (uintptr_t)((x1045)<(x907)); + x1047 = (x1045)+(x989); + x1048 = (uintptr_t)((x1047)<(x989)); + x1049 = (x1046)+(x1048); + x1050 = (x1049)+(x912); + x1051 = (uintptr_t)((x1050)<(x912)); + x1052 = (x1050)+(x994); + x1053 = (uintptr_t)((x1052)<(x994)); + x1054 = (x1051)+(x1053); + x1055 = (x1054)+(x917); + x1056 = (uintptr_t)((x1055)<(x917)); + x1057 = (x1055)+(x999); + x1058 = (uintptr_t)((x1057)<(x999)); + x1059 = (x1056)+(x1058); + x1060 = (x1059)+(x922); + x1061 = (uintptr_t)((x1060)<(x922)); + x1062 = (x1060)+(x1004); + x1063 = (uintptr_t)((x1062)<(x1004)); + x1064 = (x1061)+(x1063); + x1065 = (x1064)+(x927); + x1066 = (uintptr_t)((x1065)<(x927)); + x1067 = (x1065)+(x1009); + x1068 = (uintptr_t)((x1067)<(x1009)); + x1069 = (x1066)+(x1068); + x1070 = (x1069)+(x932); + x1071 = (uintptr_t)((x1070)<(x932)); + x1072 = (x1070)+(x1014); + x1073 = (uintptr_t)((x1072)<(x1014)); + x1074 = (x1071)+(x1073); + x1075 = (x1074)+(x937); + x1076 = (uintptr_t)((x1075)<(x937)); + x1077 = (x1075)+(x1017); + x1078 = (uintptr_t)((x1077)<(x1017)); + x1079 = (x1076)+(x1078); + x1080 = (x1079)+(x939); + x1081 = (x15)*(x11); + x1082 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x11))>>32 : ((__uint128_t)(x15)*(x11))>>64); + x1083 = (x15)*(x10); + x1084 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x10))>>32 : ((__uint128_t)(x15)*(x10))>>64); + x1085 = (x15)*(x9); + x1086 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x9))>>32 : ((__uint128_t)(x15)*(x9))>>64); + x1087 = (x15)*(x8); + x1088 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x8))>>32 : ((__uint128_t)(x15)*(x8))>>64); + x1089 = (x15)*(x7); + x1090 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x7))>>32 : ((__uint128_t)(x15)*(x7))>>64); + x1091 = (x15)*(x6); + x1092 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x6))>>32 : ((__uint128_t)(x15)*(x6))>>64); + x1093 = (x15)*(x5); + x1094 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x5))>>32 : ((__uint128_t)(x15)*(x5))>>64); + x1095 = (x15)*(x4); + x1096 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x4))>>32 : ((__uint128_t)(x15)*(x4))>>64); + x1097 = (x15)*(x3); + x1098 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x3))>>32 : ((__uint128_t)(x15)*(x3))>>64); + x1099 = (x15)*(x2); + x1100 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x2))>>32 : ((__uint128_t)(x15)*(x2))>>64); + x1101 = (x15)*(x1); + x1102 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x1))>>32 : ((__uint128_t)(x15)*(x1))>>64); + x1103 = (x15)*(x0); + x1104 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x0))>>32 : ((__uint128_t)(x15)*(x0))>>64); + x1105 = (x1104)+(x1101); + x1106 = (uintptr_t)((x1105)<(x1104)); + x1107 = (x1106)+(x1102); + x1108 = (uintptr_t)((x1107)<(x1102)); + x1109 = (x1107)+(x1099); + x1110 = (uintptr_t)((x1109)<(x1099)); + x1111 = (x1108)+(x1110); + x1112 = (x1111)+(x1100); + x1113 = (uintptr_t)((x1112)<(x1100)); + x1114 = (x1112)+(x1097); + x1115 = (uintptr_t)((x1114)<(x1097)); + x1116 = (x1113)+(x1115); + x1117 = (x1116)+(x1098); + x1118 = (uintptr_t)((x1117)<(x1098)); + x1119 = (x1117)+(x1095); + x1120 = (uintptr_t)((x1119)<(x1095)); + x1121 = (x1118)+(x1120); + x1122 = (x1121)+(x1096); + x1123 = (uintptr_t)((x1122)<(x1096)); + x1124 = (x1122)+(x1093); + x1125 = (uintptr_t)((x1124)<(x1093)); + x1126 = (x1123)+(x1125); + x1127 = (x1126)+(x1094); + x1128 = (uintptr_t)((x1127)<(x1094)); + x1129 = (x1127)+(x1091); + x1130 = (uintptr_t)((x1129)<(x1091)); + x1131 = (x1128)+(x1130); + x1132 = (x1131)+(x1092); + x1133 = (uintptr_t)((x1132)<(x1092)); + x1134 = (x1132)+(x1089); + x1135 = (uintptr_t)((x1134)<(x1089)); + x1136 = (x1133)+(x1135); + x1137 = (x1136)+(x1090); + x1138 = (uintptr_t)((x1137)<(x1090)); + x1139 = (x1137)+(x1087); + x1140 = (uintptr_t)((x1139)<(x1087)); + x1141 = (x1138)+(x1140); + x1142 = (x1141)+(x1088); + x1143 = (uintptr_t)((x1142)<(x1088)); + x1144 = (x1142)+(x1085); + x1145 = (uintptr_t)((x1144)<(x1085)); + x1146 = (x1143)+(x1145); + x1147 = (x1146)+(x1086); + x1148 = (uintptr_t)((x1147)<(x1086)); + x1149 = (x1147)+(x1083); + x1150 = (uintptr_t)((x1149)<(x1083)); + x1151 = (x1148)+(x1150); + x1152 = (x1151)+(x1084); + x1153 = (uintptr_t)((x1152)<(x1084)); + x1154 = (x1152)+(x1081); + x1155 = (uintptr_t)((x1154)<(x1081)); + x1156 = (x1153)+(x1155); + x1157 = (x1156)+(x1082); + x1158 = (x1022)+(x1103); + x1159 = (uintptr_t)((x1158)<(x1022)); + x1160 = (x1159)+(x1027); + x1161 = (uintptr_t)((x1160)<(x1027)); + x1162 = (x1160)+(x1105); + x1163 = (uintptr_t)((x1162)<(x1105)); + x1164 = (x1161)+(x1163); + x1165 = (x1164)+(x1032); + x1166 = (uintptr_t)((x1165)<(x1032)); + x1167 = (x1165)+(x1109); + x1168 = (uintptr_t)((x1167)<(x1109)); + x1169 = (x1166)+(x1168); + x1170 = (x1169)+(x1037); + x1171 = (uintptr_t)((x1170)<(x1037)); + x1172 = (x1170)+(x1114); + x1173 = (uintptr_t)((x1172)<(x1114)); + x1174 = (x1171)+(x1173); + x1175 = (x1174)+(x1042); + x1176 = (uintptr_t)((x1175)<(x1042)); + x1177 = (x1175)+(x1119); + x1178 = (uintptr_t)((x1177)<(x1119)); + x1179 = (x1176)+(x1178); + x1180 = (x1179)+(x1047); + x1181 = (uintptr_t)((x1180)<(x1047)); + x1182 = (x1180)+(x1124); + x1183 = (uintptr_t)((x1182)<(x1124)); + x1184 = (x1181)+(x1183); + x1185 = (x1184)+(x1052); + x1186 = (uintptr_t)((x1185)<(x1052)); + x1187 = (x1185)+(x1129); + x1188 = (uintptr_t)((x1187)<(x1129)); + x1189 = (x1186)+(x1188); + x1190 = (x1189)+(x1057); + x1191 = (uintptr_t)((x1190)<(x1057)); + x1192 = (x1190)+(x1134); + x1193 = (uintptr_t)((x1192)<(x1134)); + x1194 = (x1191)+(x1193); + x1195 = (x1194)+(x1062); + x1196 = (uintptr_t)((x1195)<(x1062)); + x1197 = (x1195)+(x1139); + x1198 = (uintptr_t)((x1197)<(x1139)); + x1199 = (x1196)+(x1198); + x1200 = (x1199)+(x1067); + x1201 = (uintptr_t)((x1200)<(x1067)); + x1202 = (x1200)+(x1144); + x1203 = (uintptr_t)((x1202)<(x1144)); + x1204 = (x1201)+(x1203); + x1205 = (x1204)+(x1072); + x1206 = (uintptr_t)((x1205)<(x1072)); + x1207 = (x1205)+(x1149); + x1208 = (uintptr_t)((x1207)<(x1149)); + x1209 = (x1206)+(x1208); + x1210 = (x1209)+(x1077); + x1211 = (uintptr_t)((x1210)<(x1077)); + x1212 = (x1210)+(x1154); + x1213 = (uintptr_t)((x1212)<(x1154)); + x1214 = (x1211)+(x1213); + x1215 = (x1214)+(x1080); + x1216 = (uintptr_t)((x1215)<(x1080)); + x1217 = (x1215)+(x1157); + x1218 = (uintptr_t)((x1217)<(x1157)); + x1219 = (x1216)+(x1218); + x1220 = (x1158)*((uintptr_t)3901742149ULL); + x1221 = (x1220)*((uintptr_t)4294967295ULL); + x1222 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1220)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1220)*((uintptr_t)4294967295ULL))>>64); + x1223 = (x1220)*((uintptr_t)4294967295ULL); + x1224 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1220)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1220)*((uintptr_t)4294967295ULL))>>64); + x1225 = (x1220)*((uintptr_t)4294967295ULL); + x1226 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1220)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1220)*((uintptr_t)4294967295ULL))>>64); + x1227 = (x1220)*((uintptr_t)4294967295ULL); + x1228 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1220)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1220)*((uintptr_t)4294967295ULL))>>64); + x1229 = (x1220)*((uintptr_t)4294967295ULL); + x1230 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1220)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1220)*((uintptr_t)4294967295ULL))>>64); + x1231 = (x1220)*((uintptr_t)4294967295ULL); + x1232 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1220)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1220)*((uintptr_t)4294967295ULL))>>64); + x1233 = (x1220)*((uintptr_t)3345173889ULL); + x1234 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1220)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x1220)*((uintptr_t)3345173889ULL))>>64); + x1235 = (x1220)*((uintptr_t)4097256927ULL); + x1236 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1220)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x1220)*((uintptr_t)4097256927ULL))>>64); + x1237 = (x1220)*((uintptr_t)1478102450ULL); + x1238 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1220)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x1220)*((uintptr_t)1478102450ULL))>>64); + x1239 = (x1220)*((uintptr_t)1219536762ULL); + x1240 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1220)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x1220)*((uintptr_t)1219536762ULL))>>64); + x1241 = (x1220)*((uintptr_t)3974895978ULL); + x1242 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1220)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x1220)*((uintptr_t)3974895978ULL))>>64); + x1243 = (x1220)*((uintptr_t)3435473267ULL); + x1244 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1220)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x1220)*((uintptr_t)3435473267ULL))>>64); + x1245 = (x1244)+(x1241); + x1246 = (uintptr_t)((x1245)<(x1244)); + x1247 = (x1246)+(x1242); + x1248 = (uintptr_t)((x1247)<(x1242)); + x1249 = (x1247)+(x1239); + x1250 = (uintptr_t)((x1249)<(x1239)); + x1251 = (x1248)+(x1250); + x1252 = (x1251)+(x1240); + x1253 = (uintptr_t)((x1252)<(x1240)); + x1254 = (x1252)+(x1237); + x1255 = (uintptr_t)((x1254)<(x1237)); + x1256 = (x1253)+(x1255); + x1257 = (x1256)+(x1238); + x1258 = (uintptr_t)((x1257)<(x1238)); + x1259 = (x1257)+(x1235); + x1260 = (uintptr_t)((x1259)<(x1235)); + x1261 = (x1258)+(x1260); + x1262 = (x1261)+(x1236); + x1263 = (uintptr_t)((x1262)<(x1236)); + x1264 = (x1262)+(x1233); + x1265 = (uintptr_t)((x1264)<(x1233)); + x1266 = (x1263)+(x1265); + x1267 = (x1266)+(x1234); + x1268 = (uintptr_t)((x1267)<(x1234)); + x1269 = (x1267)+(x1231); + x1270 = (uintptr_t)((x1269)<(x1231)); + x1271 = (x1268)+(x1270); + x1272 = (x1271)+(x1232); + x1273 = (uintptr_t)((x1272)<(x1232)); + x1274 = (x1272)+(x1229); + x1275 = (uintptr_t)((x1274)<(x1229)); + x1276 = (x1273)+(x1275); + x1277 = (x1276)+(x1230); + x1278 = (uintptr_t)((x1277)<(x1230)); + x1279 = (x1277)+(x1227); + x1280 = (uintptr_t)((x1279)<(x1227)); + x1281 = (x1278)+(x1280); + x1282 = (x1281)+(x1228); + x1283 = (uintptr_t)((x1282)<(x1228)); + x1284 = (x1282)+(x1225); + x1285 = (uintptr_t)((x1284)<(x1225)); + x1286 = (x1283)+(x1285); + x1287 = (x1286)+(x1226); + x1288 = (uintptr_t)((x1287)<(x1226)); + x1289 = (x1287)+(x1223); + x1290 = (uintptr_t)((x1289)<(x1223)); + x1291 = (x1288)+(x1290); + x1292 = (x1291)+(x1224); + x1293 = (uintptr_t)((x1292)<(x1224)); + x1294 = (x1292)+(x1221); + x1295 = (uintptr_t)((x1294)<(x1221)); + x1296 = (x1293)+(x1295); + x1297 = (x1296)+(x1222); + x1298 = (x1158)+(x1243); + x1299 = (uintptr_t)((x1298)<(x1158)); + x1300 = (x1299)+(x1162); + x1301 = (uintptr_t)((x1300)<(x1162)); + x1302 = (x1300)+(x1245); + x1303 = (uintptr_t)((x1302)<(x1245)); + x1304 = (x1301)+(x1303); + x1305 = (x1304)+(x1167); + x1306 = (uintptr_t)((x1305)<(x1167)); + x1307 = (x1305)+(x1249); + x1308 = (uintptr_t)((x1307)<(x1249)); + x1309 = (x1306)+(x1308); + x1310 = (x1309)+(x1172); + x1311 = (uintptr_t)((x1310)<(x1172)); + x1312 = (x1310)+(x1254); + x1313 = (uintptr_t)((x1312)<(x1254)); + x1314 = (x1311)+(x1313); + x1315 = (x1314)+(x1177); + x1316 = (uintptr_t)((x1315)<(x1177)); + x1317 = (x1315)+(x1259); + x1318 = (uintptr_t)((x1317)<(x1259)); + x1319 = (x1316)+(x1318); + x1320 = (x1319)+(x1182); + x1321 = (uintptr_t)((x1320)<(x1182)); + x1322 = (x1320)+(x1264); + x1323 = (uintptr_t)((x1322)<(x1264)); + x1324 = (x1321)+(x1323); + x1325 = (x1324)+(x1187); + x1326 = (uintptr_t)((x1325)<(x1187)); + x1327 = (x1325)+(x1269); + x1328 = (uintptr_t)((x1327)<(x1269)); + x1329 = (x1326)+(x1328); + x1330 = (x1329)+(x1192); + x1331 = (uintptr_t)((x1330)<(x1192)); + x1332 = (x1330)+(x1274); + x1333 = (uintptr_t)((x1332)<(x1274)); + x1334 = (x1331)+(x1333); + x1335 = (x1334)+(x1197); + x1336 = (uintptr_t)((x1335)<(x1197)); + x1337 = (x1335)+(x1279); + x1338 = (uintptr_t)((x1337)<(x1279)); + x1339 = (x1336)+(x1338); + x1340 = (x1339)+(x1202); + x1341 = (uintptr_t)((x1340)<(x1202)); + x1342 = (x1340)+(x1284); + x1343 = (uintptr_t)((x1342)<(x1284)); + x1344 = (x1341)+(x1343); + x1345 = (x1344)+(x1207); + x1346 = (uintptr_t)((x1345)<(x1207)); + x1347 = (x1345)+(x1289); + x1348 = (uintptr_t)((x1347)<(x1289)); + x1349 = (x1346)+(x1348); + x1350 = (x1349)+(x1212); + x1351 = (uintptr_t)((x1350)<(x1212)); + x1352 = (x1350)+(x1294); + x1353 = (uintptr_t)((x1352)<(x1294)); + x1354 = (x1351)+(x1353); + x1355 = (x1354)+(x1217); + x1356 = (uintptr_t)((x1355)<(x1217)); + x1357 = (x1355)+(x1297); + x1358 = (uintptr_t)((x1357)<(x1297)); + x1359 = (x1356)+(x1358); + x1360 = (x1359)+(x1219); + x1361 = (x16)*(x11); + x1362 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x11))>>32 : ((__uint128_t)(x16)*(x11))>>64); + x1363 = (x16)*(x10); + x1364 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x10))>>32 : ((__uint128_t)(x16)*(x10))>>64); + x1365 = (x16)*(x9); + x1366 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x9))>>32 : ((__uint128_t)(x16)*(x9))>>64); + x1367 = (x16)*(x8); + x1368 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x8))>>32 : ((__uint128_t)(x16)*(x8))>>64); + x1369 = (x16)*(x7); + x1370 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x7))>>32 : ((__uint128_t)(x16)*(x7))>>64); + x1371 = (x16)*(x6); + x1372 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x6))>>32 : ((__uint128_t)(x16)*(x6))>>64); + x1373 = (x16)*(x5); + x1374 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x5))>>32 : ((__uint128_t)(x16)*(x5))>>64); + x1375 = (x16)*(x4); + x1376 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x4))>>32 : ((__uint128_t)(x16)*(x4))>>64); + x1377 = (x16)*(x3); + x1378 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x3))>>32 : ((__uint128_t)(x16)*(x3))>>64); + x1379 = (x16)*(x2); + x1380 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x2))>>32 : ((__uint128_t)(x16)*(x2))>>64); + x1381 = (x16)*(x1); + x1382 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x1))>>32 : ((__uint128_t)(x16)*(x1))>>64); + x1383 = (x16)*(x0); + x1384 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x0))>>32 : ((__uint128_t)(x16)*(x0))>>64); + x1385 = (x1384)+(x1381); + x1386 = (uintptr_t)((x1385)<(x1384)); + x1387 = (x1386)+(x1382); + x1388 = (uintptr_t)((x1387)<(x1382)); + x1389 = (x1387)+(x1379); + x1390 = (uintptr_t)((x1389)<(x1379)); + x1391 = (x1388)+(x1390); + x1392 = (x1391)+(x1380); + x1393 = (uintptr_t)((x1392)<(x1380)); + x1394 = (x1392)+(x1377); + x1395 = (uintptr_t)((x1394)<(x1377)); + x1396 = (x1393)+(x1395); + x1397 = (x1396)+(x1378); + x1398 = (uintptr_t)((x1397)<(x1378)); + x1399 = (x1397)+(x1375); + x1400 = (uintptr_t)((x1399)<(x1375)); + x1401 = (x1398)+(x1400); + x1402 = (x1401)+(x1376); + x1403 = (uintptr_t)((x1402)<(x1376)); + x1404 = (x1402)+(x1373); + x1405 = (uintptr_t)((x1404)<(x1373)); + x1406 = (x1403)+(x1405); + x1407 = (x1406)+(x1374); + x1408 = (uintptr_t)((x1407)<(x1374)); + x1409 = (x1407)+(x1371); + x1410 = (uintptr_t)((x1409)<(x1371)); + x1411 = (x1408)+(x1410); + x1412 = (x1411)+(x1372); + x1413 = (uintptr_t)((x1412)<(x1372)); + x1414 = (x1412)+(x1369); + x1415 = (uintptr_t)((x1414)<(x1369)); + x1416 = (x1413)+(x1415); + x1417 = (x1416)+(x1370); + x1418 = (uintptr_t)((x1417)<(x1370)); + x1419 = (x1417)+(x1367); + x1420 = (uintptr_t)((x1419)<(x1367)); + x1421 = (x1418)+(x1420); + x1422 = (x1421)+(x1368); + x1423 = (uintptr_t)((x1422)<(x1368)); + x1424 = (x1422)+(x1365); + x1425 = (uintptr_t)((x1424)<(x1365)); + x1426 = (x1423)+(x1425); + x1427 = (x1426)+(x1366); + x1428 = (uintptr_t)((x1427)<(x1366)); + x1429 = (x1427)+(x1363); + x1430 = (uintptr_t)((x1429)<(x1363)); + x1431 = (x1428)+(x1430); + x1432 = (x1431)+(x1364); + x1433 = (uintptr_t)((x1432)<(x1364)); + x1434 = (x1432)+(x1361); + x1435 = (uintptr_t)((x1434)<(x1361)); + x1436 = (x1433)+(x1435); + x1437 = (x1436)+(x1362); + x1438 = (x1302)+(x1383); + x1439 = (uintptr_t)((x1438)<(x1302)); + x1440 = (x1439)+(x1307); + x1441 = (uintptr_t)((x1440)<(x1307)); + x1442 = (x1440)+(x1385); + x1443 = (uintptr_t)((x1442)<(x1385)); + x1444 = (x1441)+(x1443); + x1445 = (x1444)+(x1312); + x1446 = (uintptr_t)((x1445)<(x1312)); + x1447 = (x1445)+(x1389); + x1448 = (uintptr_t)((x1447)<(x1389)); + x1449 = (x1446)+(x1448); + x1450 = (x1449)+(x1317); + x1451 = (uintptr_t)((x1450)<(x1317)); + x1452 = (x1450)+(x1394); + x1453 = (uintptr_t)((x1452)<(x1394)); + x1454 = (x1451)+(x1453); + x1455 = (x1454)+(x1322); + x1456 = (uintptr_t)((x1455)<(x1322)); + x1457 = (x1455)+(x1399); + x1458 = (uintptr_t)((x1457)<(x1399)); + x1459 = (x1456)+(x1458); + x1460 = (x1459)+(x1327); + x1461 = (uintptr_t)((x1460)<(x1327)); + x1462 = (x1460)+(x1404); + x1463 = (uintptr_t)((x1462)<(x1404)); + x1464 = (x1461)+(x1463); + x1465 = (x1464)+(x1332); + x1466 = (uintptr_t)((x1465)<(x1332)); + x1467 = (x1465)+(x1409); + x1468 = (uintptr_t)((x1467)<(x1409)); + x1469 = (x1466)+(x1468); + x1470 = (x1469)+(x1337); + x1471 = (uintptr_t)((x1470)<(x1337)); + x1472 = (x1470)+(x1414); + x1473 = (uintptr_t)((x1472)<(x1414)); + x1474 = (x1471)+(x1473); + x1475 = (x1474)+(x1342); + x1476 = (uintptr_t)((x1475)<(x1342)); + x1477 = (x1475)+(x1419); + x1478 = (uintptr_t)((x1477)<(x1419)); + x1479 = (x1476)+(x1478); + x1480 = (x1479)+(x1347); + x1481 = (uintptr_t)((x1480)<(x1347)); + x1482 = (x1480)+(x1424); + x1483 = (uintptr_t)((x1482)<(x1424)); + x1484 = (x1481)+(x1483); + x1485 = (x1484)+(x1352); + x1486 = (uintptr_t)((x1485)<(x1352)); + x1487 = (x1485)+(x1429); + x1488 = (uintptr_t)((x1487)<(x1429)); + x1489 = (x1486)+(x1488); + x1490 = (x1489)+(x1357); + x1491 = (uintptr_t)((x1490)<(x1357)); + x1492 = (x1490)+(x1434); + x1493 = (uintptr_t)((x1492)<(x1434)); + x1494 = (x1491)+(x1493); + x1495 = (x1494)+(x1360); + x1496 = (uintptr_t)((x1495)<(x1360)); + x1497 = (x1495)+(x1437); + x1498 = (uintptr_t)((x1497)<(x1437)); + x1499 = (x1496)+(x1498); + x1500 = (x1438)*((uintptr_t)3901742149ULL); + x1501 = (x1500)*((uintptr_t)4294967295ULL); + x1502 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1500)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1500)*((uintptr_t)4294967295ULL))>>64); + x1503 = (x1500)*((uintptr_t)4294967295ULL); + x1504 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1500)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1500)*((uintptr_t)4294967295ULL))>>64); + x1505 = (x1500)*((uintptr_t)4294967295ULL); + x1506 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1500)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1500)*((uintptr_t)4294967295ULL))>>64); + x1507 = (x1500)*((uintptr_t)4294967295ULL); + x1508 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1500)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1500)*((uintptr_t)4294967295ULL))>>64); + x1509 = (x1500)*((uintptr_t)4294967295ULL); + x1510 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1500)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1500)*((uintptr_t)4294967295ULL))>>64); + x1511 = (x1500)*((uintptr_t)4294967295ULL); + x1512 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1500)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1500)*((uintptr_t)4294967295ULL))>>64); + x1513 = (x1500)*((uintptr_t)3345173889ULL); + x1514 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1500)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x1500)*((uintptr_t)3345173889ULL))>>64); + x1515 = (x1500)*((uintptr_t)4097256927ULL); + x1516 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1500)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x1500)*((uintptr_t)4097256927ULL))>>64); + x1517 = (x1500)*((uintptr_t)1478102450ULL); + x1518 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1500)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x1500)*((uintptr_t)1478102450ULL))>>64); + x1519 = (x1500)*((uintptr_t)1219536762ULL); + x1520 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1500)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x1500)*((uintptr_t)1219536762ULL))>>64); + x1521 = (x1500)*((uintptr_t)3974895978ULL); + x1522 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1500)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x1500)*((uintptr_t)3974895978ULL))>>64); + x1523 = (x1500)*((uintptr_t)3435473267ULL); + x1524 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1500)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x1500)*((uintptr_t)3435473267ULL))>>64); + x1525 = (x1524)+(x1521); + x1526 = (uintptr_t)((x1525)<(x1524)); + x1527 = (x1526)+(x1522); + x1528 = (uintptr_t)((x1527)<(x1522)); + x1529 = (x1527)+(x1519); + x1530 = (uintptr_t)((x1529)<(x1519)); + x1531 = (x1528)+(x1530); + x1532 = (x1531)+(x1520); + x1533 = (uintptr_t)((x1532)<(x1520)); + x1534 = (x1532)+(x1517); + x1535 = (uintptr_t)((x1534)<(x1517)); + x1536 = (x1533)+(x1535); + x1537 = (x1536)+(x1518); + x1538 = (uintptr_t)((x1537)<(x1518)); + x1539 = (x1537)+(x1515); + x1540 = (uintptr_t)((x1539)<(x1515)); + x1541 = (x1538)+(x1540); + x1542 = (x1541)+(x1516); + x1543 = (uintptr_t)((x1542)<(x1516)); + x1544 = (x1542)+(x1513); + x1545 = (uintptr_t)((x1544)<(x1513)); + x1546 = (x1543)+(x1545); + x1547 = (x1546)+(x1514); + x1548 = (uintptr_t)((x1547)<(x1514)); + x1549 = (x1547)+(x1511); + x1550 = (uintptr_t)((x1549)<(x1511)); + x1551 = (x1548)+(x1550); + x1552 = (x1551)+(x1512); + x1553 = (uintptr_t)((x1552)<(x1512)); + x1554 = (x1552)+(x1509); + x1555 = (uintptr_t)((x1554)<(x1509)); + x1556 = (x1553)+(x1555); + x1557 = (x1556)+(x1510); + x1558 = (uintptr_t)((x1557)<(x1510)); + x1559 = (x1557)+(x1507); + x1560 = (uintptr_t)((x1559)<(x1507)); + x1561 = (x1558)+(x1560); + x1562 = (x1561)+(x1508); + x1563 = (uintptr_t)((x1562)<(x1508)); + x1564 = (x1562)+(x1505); + x1565 = (uintptr_t)((x1564)<(x1505)); + x1566 = (x1563)+(x1565); + x1567 = (x1566)+(x1506); + x1568 = (uintptr_t)((x1567)<(x1506)); + x1569 = (x1567)+(x1503); + x1570 = (uintptr_t)((x1569)<(x1503)); + x1571 = (x1568)+(x1570); + x1572 = (x1571)+(x1504); + x1573 = (uintptr_t)((x1572)<(x1504)); + x1574 = (x1572)+(x1501); + x1575 = (uintptr_t)((x1574)<(x1501)); + x1576 = (x1573)+(x1575); + x1577 = (x1576)+(x1502); + x1578 = (x1438)+(x1523); + x1579 = (uintptr_t)((x1578)<(x1438)); + x1580 = (x1579)+(x1442); + x1581 = (uintptr_t)((x1580)<(x1442)); + x1582 = (x1580)+(x1525); + x1583 = (uintptr_t)((x1582)<(x1525)); + x1584 = (x1581)+(x1583); + x1585 = (x1584)+(x1447); + x1586 = (uintptr_t)((x1585)<(x1447)); + x1587 = (x1585)+(x1529); + x1588 = (uintptr_t)((x1587)<(x1529)); + x1589 = (x1586)+(x1588); + x1590 = (x1589)+(x1452); + x1591 = (uintptr_t)((x1590)<(x1452)); + x1592 = (x1590)+(x1534); + x1593 = (uintptr_t)((x1592)<(x1534)); + x1594 = (x1591)+(x1593); + x1595 = (x1594)+(x1457); + x1596 = (uintptr_t)((x1595)<(x1457)); + x1597 = (x1595)+(x1539); + x1598 = (uintptr_t)((x1597)<(x1539)); + x1599 = (x1596)+(x1598); + x1600 = (x1599)+(x1462); + x1601 = (uintptr_t)((x1600)<(x1462)); + x1602 = (x1600)+(x1544); + x1603 = (uintptr_t)((x1602)<(x1544)); + x1604 = (x1601)+(x1603); + x1605 = (x1604)+(x1467); + x1606 = (uintptr_t)((x1605)<(x1467)); + x1607 = (x1605)+(x1549); + x1608 = (uintptr_t)((x1607)<(x1549)); + x1609 = (x1606)+(x1608); + x1610 = (x1609)+(x1472); + x1611 = (uintptr_t)((x1610)<(x1472)); + x1612 = (x1610)+(x1554); + x1613 = (uintptr_t)((x1612)<(x1554)); + x1614 = (x1611)+(x1613); + x1615 = (x1614)+(x1477); + x1616 = (uintptr_t)((x1615)<(x1477)); + x1617 = (x1615)+(x1559); + x1618 = (uintptr_t)((x1617)<(x1559)); + x1619 = (x1616)+(x1618); + x1620 = (x1619)+(x1482); + x1621 = (uintptr_t)((x1620)<(x1482)); + x1622 = (x1620)+(x1564); + x1623 = (uintptr_t)((x1622)<(x1564)); + x1624 = (x1621)+(x1623); + x1625 = (x1624)+(x1487); + x1626 = (uintptr_t)((x1625)<(x1487)); + x1627 = (x1625)+(x1569); + x1628 = (uintptr_t)((x1627)<(x1569)); + x1629 = (x1626)+(x1628); + x1630 = (x1629)+(x1492); + x1631 = (uintptr_t)((x1630)<(x1492)); + x1632 = (x1630)+(x1574); + x1633 = (uintptr_t)((x1632)<(x1574)); + x1634 = (x1631)+(x1633); + x1635 = (x1634)+(x1497); + x1636 = (uintptr_t)((x1635)<(x1497)); + x1637 = (x1635)+(x1577); + x1638 = (uintptr_t)((x1637)<(x1577)); + x1639 = (x1636)+(x1638); + x1640 = (x1639)+(x1499); + x1641 = (x17)*(x11); + x1642 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x11))>>32 : ((__uint128_t)(x17)*(x11))>>64); + x1643 = (x17)*(x10); + x1644 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x10))>>32 : ((__uint128_t)(x17)*(x10))>>64); + x1645 = (x17)*(x9); + x1646 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x9))>>32 : ((__uint128_t)(x17)*(x9))>>64); + x1647 = (x17)*(x8); + x1648 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x8))>>32 : ((__uint128_t)(x17)*(x8))>>64); + x1649 = (x17)*(x7); + x1650 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x7))>>32 : ((__uint128_t)(x17)*(x7))>>64); + x1651 = (x17)*(x6); + x1652 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x6))>>32 : ((__uint128_t)(x17)*(x6))>>64); + x1653 = (x17)*(x5); + x1654 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x5))>>32 : ((__uint128_t)(x17)*(x5))>>64); + x1655 = (x17)*(x4); + x1656 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x4))>>32 : ((__uint128_t)(x17)*(x4))>>64); + x1657 = (x17)*(x3); + x1658 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x3))>>32 : ((__uint128_t)(x17)*(x3))>>64); + x1659 = (x17)*(x2); + x1660 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x2))>>32 : ((__uint128_t)(x17)*(x2))>>64); + x1661 = (x17)*(x1); + x1662 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x1))>>32 : ((__uint128_t)(x17)*(x1))>>64); + x1663 = (x17)*(x0); + x1664 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x0))>>32 : ((__uint128_t)(x17)*(x0))>>64); + x1665 = (x1664)+(x1661); + x1666 = (uintptr_t)((x1665)<(x1664)); + x1667 = (x1666)+(x1662); + x1668 = (uintptr_t)((x1667)<(x1662)); + x1669 = (x1667)+(x1659); + x1670 = (uintptr_t)((x1669)<(x1659)); + x1671 = (x1668)+(x1670); + x1672 = (x1671)+(x1660); + x1673 = (uintptr_t)((x1672)<(x1660)); + x1674 = (x1672)+(x1657); + x1675 = (uintptr_t)((x1674)<(x1657)); + x1676 = (x1673)+(x1675); + x1677 = (x1676)+(x1658); + x1678 = (uintptr_t)((x1677)<(x1658)); + x1679 = (x1677)+(x1655); + x1680 = (uintptr_t)((x1679)<(x1655)); + x1681 = (x1678)+(x1680); + x1682 = (x1681)+(x1656); + x1683 = (uintptr_t)((x1682)<(x1656)); + x1684 = (x1682)+(x1653); + x1685 = (uintptr_t)((x1684)<(x1653)); + x1686 = (x1683)+(x1685); + x1687 = (x1686)+(x1654); + x1688 = (uintptr_t)((x1687)<(x1654)); + x1689 = (x1687)+(x1651); + x1690 = (uintptr_t)((x1689)<(x1651)); + x1691 = (x1688)+(x1690); + x1692 = (x1691)+(x1652); + x1693 = (uintptr_t)((x1692)<(x1652)); + x1694 = (x1692)+(x1649); + x1695 = (uintptr_t)((x1694)<(x1649)); + x1696 = (x1693)+(x1695); + x1697 = (x1696)+(x1650); + x1698 = (uintptr_t)((x1697)<(x1650)); + x1699 = (x1697)+(x1647); + x1700 = (uintptr_t)((x1699)<(x1647)); + x1701 = (x1698)+(x1700); + x1702 = (x1701)+(x1648); + x1703 = (uintptr_t)((x1702)<(x1648)); + x1704 = (x1702)+(x1645); + x1705 = (uintptr_t)((x1704)<(x1645)); + x1706 = (x1703)+(x1705); + x1707 = (x1706)+(x1646); + x1708 = (uintptr_t)((x1707)<(x1646)); + x1709 = (x1707)+(x1643); + x1710 = (uintptr_t)((x1709)<(x1643)); + x1711 = (x1708)+(x1710); + x1712 = (x1711)+(x1644); + x1713 = (uintptr_t)((x1712)<(x1644)); + x1714 = (x1712)+(x1641); + x1715 = (uintptr_t)((x1714)<(x1641)); + x1716 = (x1713)+(x1715); + x1717 = (x1716)+(x1642); + x1718 = (x1582)+(x1663); + x1719 = (uintptr_t)((x1718)<(x1582)); + x1720 = (x1719)+(x1587); + x1721 = (uintptr_t)((x1720)<(x1587)); + x1722 = (x1720)+(x1665); + x1723 = (uintptr_t)((x1722)<(x1665)); + x1724 = (x1721)+(x1723); + x1725 = (x1724)+(x1592); + x1726 = (uintptr_t)((x1725)<(x1592)); + x1727 = (x1725)+(x1669); + x1728 = (uintptr_t)((x1727)<(x1669)); + x1729 = (x1726)+(x1728); + x1730 = (x1729)+(x1597); + x1731 = (uintptr_t)((x1730)<(x1597)); + x1732 = (x1730)+(x1674); + x1733 = (uintptr_t)((x1732)<(x1674)); + x1734 = (x1731)+(x1733); + x1735 = (x1734)+(x1602); + x1736 = (uintptr_t)((x1735)<(x1602)); + x1737 = (x1735)+(x1679); + x1738 = (uintptr_t)((x1737)<(x1679)); + x1739 = (x1736)+(x1738); + x1740 = (x1739)+(x1607); + x1741 = (uintptr_t)((x1740)<(x1607)); + x1742 = (x1740)+(x1684); + x1743 = (uintptr_t)((x1742)<(x1684)); + x1744 = (x1741)+(x1743); + x1745 = (x1744)+(x1612); + x1746 = (uintptr_t)((x1745)<(x1612)); + x1747 = (x1745)+(x1689); + x1748 = (uintptr_t)((x1747)<(x1689)); + x1749 = (x1746)+(x1748); + x1750 = (x1749)+(x1617); + x1751 = (uintptr_t)((x1750)<(x1617)); + x1752 = (x1750)+(x1694); + x1753 = (uintptr_t)((x1752)<(x1694)); + x1754 = (x1751)+(x1753); + x1755 = (x1754)+(x1622); + x1756 = (uintptr_t)((x1755)<(x1622)); + x1757 = (x1755)+(x1699); + x1758 = (uintptr_t)((x1757)<(x1699)); + x1759 = (x1756)+(x1758); + x1760 = (x1759)+(x1627); + x1761 = (uintptr_t)((x1760)<(x1627)); + x1762 = (x1760)+(x1704); + x1763 = (uintptr_t)((x1762)<(x1704)); + x1764 = (x1761)+(x1763); + x1765 = (x1764)+(x1632); + x1766 = (uintptr_t)((x1765)<(x1632)); + x1767 = (x1765)+(x1709); + x1768 = (uintptr_t)((x1767)<(x1709)); + x1769 = (x1766)+(x1768); + x1770 = (x1769)+(x1637); + x1771 = (uintptr_t)((x1770)<(x1637)); + x1772 = (x1770)+(x1714); + x1773 = (uintptr_t)((x1772)<(x1714)); + x1774 = (x1771)+(x1773); + x1775 = (x1774)+(x1640); + x1776 = (uintptr_t)((x1775)<(x1640)); + x1777 = (x1775)+(x1717); + x1778 = (uintptr_t)((x1777)<(x1717)); + x1779 = (x1776)+(x1778); + x1780 = (x1718)*((uintptr_t)3901742149ULL); + x1781 = (x1780)*((uintptr_t)4294967295ULL); + x1782 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1780)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1780)*((uintptr_t)4294967295ULL))>>64); + x1783 = (x1780)*((uintptr_t)4294967295ULL); + x1784 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1780)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1780)*((uintptr_t)4294967295ULL))>>64); + x1785 = (x1780)*((uintptr_t)4294967295ULL); + x1786 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1780)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1780)*((uintptr_t)4294967295ULL))>>64); + x1787 = (x1780)*((uintptr_t)4294967295ULL); + x1788 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1780)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1780)*((uintptr_t)4294967295ULL))>>64); + x1789 = (x1780)*((uintptr_t)4294967295ULL); + x1790 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1780)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1780)*((uintptr_t)4294967295ULL))>>64); + x1791 = (x1780)*((uintptr_t)4294967295ULL); + x1792 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1780)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1780)*((uintptr_t)4294967295ULL))>>64); + x1793 = (x1780)*((uintptr_t)3345173889ULL); + x1794 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1780)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x1780)*((uintptr_t)3345173889ULL))>>64); + x1795 = (x1780)*((uintptr_t)4097256927ULL); + x1796 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1780)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x1780)*((uintptr_t)4097256927ULL))>>64); + x1797 = (x1780)*((uintptr_t)1478102450ULL); + x1798 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1780)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x1780)*((uintptr_t)1478102450ULL))>>64); + x1799 = (x1780)*((uintptr_t)1219536762ULL); + x1800 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1780)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x1780)*((uintptr_t)1219536762ULL))>>64); + x1801 = (x1780)*((uintptr_t)3974895978ULL); + x1802 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1780)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x1780)*((uintptr_t)3974895978ULL))>>64); + x1803 = (x1780)*((uintptr_t)3435473267ULL); + x1804 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1780)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x1780)*((uintptr_t)3435473267ULL))>>64); + x1805 = (x1804)+(x1801); + x1806 = (uintptr_t)((x1805)<(x1804)); + x1807 = (x1806)+(x1802); + x1808 = (uintptr_t)((x1807)<(x1802)); + x1809 = (x1807)+(x1799); + x1810 = (uintptr_t)((x1809)<(x1799)); + x1811 = (x1808)+(x1810); + x1812 = (x1811)+(x1800); + x1813 = (uintptr_t)((x1812)<(x1800)); + x1814 = (x1812)+(x1797); + x1815 = (uintptr_t)((x1814)<(x1797)); + x1816 = (x1813)+(x1815); + x1817 = (x1816)+(x1798); + x1818 = (uintptr_t)((x1817)<(x1798)); + x1819 = (x1817)+(x1795); + x1820 = (uintptr_t)((x1819)<(x1795)); + x1821 = (x1818)+(x1820); + x1822 = (x1821)+(x1796); + x1823 = (uintptr_t)((x1822)<(x1796)); + x1824 = (x1822)+(x1793); + x1825 = (uintptr_t)((x1824)<(x1793)); + x1826 = (x1823)+(x1825); + x1827 = (x1826)+(x1794); + x1828 = (uintptr_t)((x1827)<(x1794)); + x1829 = (x1827)+(x1791); + x1830 = (uintptr_t)((x1829)<(x1791)); + x1831 = (x1828)+(x1830); + x1832 = (x1831)+(x1792); + x1833 = (uintptr_t)((x1832)<(x1792)); + x1834 = (x1832)+(x1789); + x1835 = (uintptr_t)((x1834)<(x1789)); + x1836 = (x1833)+(x1835); + x1837 = (x1836)+(x1790); + x1838 = (uintptr_t)((x1837)<(x1790)); + x1839 = (x1837)+(x1787); + x1840 = (uintptr_t)((x1839)<(x1787)); + x1841 = (x1838)+(x1840); + x1842 = (x1841)+(x1788); + x1843 = (uintptr_t)((x1842)<(x1788)); + x1844 = (x1842)+(x1785); + x1845 = (uintptr_t)((x1844)<(x1785)); + x1846 = (x1843)+(x1845); + x1847 = (x1846)+(x1786); + x1848 = (uintptr_t)((x1847)<(x1786)); + x1849 = (x1847)+(x1783); + x1850 = (uintptr_t)((x1849)<(x1783)); + x1851 = (x1848)+(x1850); + x1852 = (x1851)+(x1784); + x1853 = (uintptr_t)((x1852)<(x1784)); + x1854 = (x1852)+(x1781); + x1855 = (uintptr_t)((x1854)<(x1781)); + x1856 = (x1853)+(x1855); + x1857 = (x1856)+(x1782); + x1858 = (x1718)+(x1803); + x1859 = (uintptr_t)((x1858)<(x1718)); + x1860 = (x1859)+(x1722); + x1861 = (uintptr_t)((x1860)<(x1722)); + x1862 = (x1860)+(x1805); + x1863 = (uintptr_t)((x1862)<(x1805)); + x1864 = (x1861)+(x1863); + x1865 = (x1864)+(x1727); + x1866 = (uintptr_t)((x1865)<(x1727)); + x1867 = (x1865)+(x1809); + x1868 = (uintptr_t)((x1867)<(x1809)); + x1869 = (x1866)+(x1868); + x1870 = (x1869)+(x1732); + x1871 = (uintptr_t)((x1870)<(x1732)); + x1872 = (x1870)+(x1814); + x1873 = (uintptr_t)((x1872)<(x1814)); + x1874 = (x1871)+(x1873); + x1875 = (x1874)+(x1737); + x1876 = (uintptr_t)((x1875)<(x1737)); + x1877 = (x1875)+(x1819); + x1878 = (uintptr_t)((x1877)<(x1819)); + x1879 = (x1876)+(x1878); + x1880 = (x1879)+(x1742); + x1881 = (uintptr_t)((x1880)<(x1742)); + x1882 = (x1880)+(x1824); + x1883 = (uintptr_t)((x1882)<(x1824)); + x1884 = (x1881)+(x1883); + x1885 = (x1884)+(x1747); + x1886 = (uintptr_t)((x1885)<(x1747)); + x1887 = (x1885)+(x1829); + x1888 = (uintptr_t)((x1887)<(x1829)); + x1889 = (x1886)+(x1888); + x1890 = (x1889)+(x1752); + x1891 = (uintptr_t)((x1890)<(x1752)); + x1892 = (x1890)+(x1834); + x1893 = (uintptr_t)((x1892)<(x1834)); + x1894 = (x1891)+(x1893); + x1895 = (x1894)+(x1757); + x1896 = (uintptr_t)((x1895)<(x1757)); + x1897 = (x1895)+(x1839); + x1898 = (uintptr_t)((x1897)<(x1839)); + x1899 = (x1896)+(x1898); + x1900 = (x1899)+(x1762); + x1901 = (uintptr_t)((x1900)<(x1762)); + x1902 = (x1900)+(x1844); + x1903 = (uintptr_t)((x1902)<(x1844)); + x1904 = (x1901)+(x1903); + x1905 = (x1904)+(x1767); + x1906 = (uintptr_t)((x1905)<(x1767)); + x1907 = (x1905)+(x1849); + x1908 = (uintptr_t)((x1907)<(x1849)); + x1909 = (x1906)+(x1908); + x1910 = (x1909)+(x1772); + x1911 = (uintptr_t)((x1910)<(x1772)); + x1912 = (x1910)+(x1854); + x1913 = (uintptr_t)((x1912)<(x1854)); + x1914 = (x1911)+(x1913); + x1915 = (x1914)+(x1777); + x1916 = (uintptr_t)((x1915)<(x1777)); + x1917 = (x1915)+(x1857); + x1918 = (uintptr_t)((x1917)<(x1857)); + x1919 = (x1916)+(x1918); + x1920 = (x1919)+(x1779); + x1921 = (x18)*(x11); + x1922 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x11))>>32 : ((__uint128_t)(x18)*(x11))>>64); + x1923 = (x18)*(x10); + x1924 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x10))>>32 : ((__uint128_t)(x18)*(x10))>>64); + x1925 = (x18)*(x9); + x1926 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x9))>>32 : ((__uint128_t)(x18)*(x9))>>64); + x1927 = (x18)*(x8); + x1928 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x8))>>32 : ((__uint128_t)(x18)*(x8))>>64); + x1929 = (x18)*(x7); + x1930 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x7))>>32 : ((__uint128_t)(x18)*(x7))>>64); + x1931 = (x18)*(x6); + x1932 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x6))>>32 : ((__uint128_t)(x18)*(x6))>>64); + x1933 = (x18)*(x5); + x1934 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x5))>>32 : ((__uint128_t)(x18)*(x5))>>64); + x1935 = (x18)*(x4); + x1936 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x4))>>32 : ((__uint128_t)(x18)*(x4))>>64); + x1937 = (x18)*(x3); + x1938 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x3))>>32 : ((__uint128_t)(x18)*(x3))>>64); + x1939 = (x18)*(x2); + x1940 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x2))>>32 : ((__uint128_t)(x18)*(x2))>>64); + x1941 = (x18)*(x1); + x1942 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x1))>>32 : ((__uint128_t)(x18)*(x1))>>64); + x1943 = (x18)*(x0); + x1944 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x0))>>32 : ((__uint128_t)(x18)*(x0))>>64); + x1945 = (x1944)+(x1941); + x1946 = (uintptr_t)((x1945)<(x1944)); + x1947 = (x1946)+(x1942); + x1948 = (uintptr_t)((x1947)<(x1942)); + x1949 = (x1947)+(x1939); + x1950 = (uintptr_t)((x1949)<(x1939)); + x1951 = (x1948)+(x1950); + x1952 = (x1951)+(x1940); + x1953 = (uintptr_t)((x1952)<(x1940)); + x1954 = (x1952)+(x1937); + x1955 = (uintptr_t)((x1954)<(x1937)); + x1956 = (x1953)+(x1955); + x1957 = (x1956)+(x1938); + x1958 = (uintptr_t)((x1957)<(x1938)); + x1959 = (x1957)+(x1935); + x1960 = (uintptr_t)((x1959)<(x1935)); + x1961 = (x1958)+(x1960); + x1962 = (x1961)+(x1936); + x1963 = (uintptr_t)((x1962)<(x1936)); + x1964 = (x1962)+(x1933); + x1965 = (uintptr_t)((x1964)<(x1933)); + x1966 = (x1963)+(x1965); + x1967 = (x1966)+(x1934); + x1968 = (uintptr_t)((x1967)<(x1934)); + x1969 = (x1967)+(x1931); + x1970 = (uintptr_t)((x1969)<(x1931)); + x1971 = (x1968)+(x1970); + x1972 = (x1971)+(x1932); + x1973 = (uintptr_t)((x1972)<(x1932)); + x1974 = (x1972)+(x1929); + x1975 = (uintptr_t)((x1974)<(x1929)); + x1976 = (x1973)+(x1975); + x1977 = (x1976)+(x1930); + x1978 = (uintptr_t)((x1977)<(x1930)); + x1979 = (x1977)+(x1927); + x1980 = (uintptr_t)((x1979)<(x1927)); + x1981 = (x1978)+(x1980); + x1982 = (x1981)+(x1928); + x1983 = (uintptr_t)((x1982)<(x1928)); + x1984 = (x1982)+(x1925); + x1985 = (uintptr_t)((x1984)<(x1925)); + x1986 = (x1983)+(x1985); + x1987 = (x1986)+(x1926); + x1988 = (uintptr_t)((x1987)<(x1926)); + x1989 = (x1987)+(x1923); + x1990 = (uintptr_t)((x1989)<(x1923)); + x1991 = (x1988)+(x1990); + x1992 = (x1991)+(x1924); + x1993 = (uintptr_t)((x1992)<(x1924)); + x1994 = (x1992)+(x1921); + x1995 = (uintptr_t)((x1994)<(x1921)); + x1996 = (x1993)+(x1995); + x1997 = (x1996)+(x1922); + x1998 = (x1862)+(x1943); + x1999 = (uintptr_t)((x1998)<(x1862)); + x2000 = (x1999)+(x1867); + x2001 = (uintptr_t)((x2000)<(x1867)); + x2002 = (x2000)+(x1945); + x2003 = (uintptr_t)((x2002)<(x1945)); + x2004 = (x2001)+(x2003); + x2005 = (x2004)+(x1872); + x2006 = (uintptr_t)((x2005)<(x1872)); + x2007 = (x2005)+(x1949); + x2008 = (uintptr_t)((x2007)<(x1949)); + x2009 = (x2006)+(x2008); + x2010 = (x2009)+(x1877); + x2011 = (uintptr_t)((x2010)<(x1877)); + x2012 = (x2010)+(x1954); + x2013 = (uintptr_t)((x2012)<(x1954)); + x2014 = (x2011)+(x2013); + x2015 = (x2014)+(x1882); + x2016 = (uintptr_t)((x2015)<(x1882)); + x2017 = (x2015)+(x1959); + x2018 = (uintptr_t)((x2017)<(x1959)); + x2019 = (x2016)+(x2018); + x2020 = (x2019)+(x1887); + x2021 = (uintptr_t)((x2020)<(x1887)); + x2022 = (x2020)+(x1964); + x2023 = (uintptr_t)((x2022)<(x1964)); + x2024 = (x2021)+(x2023); + x2025 = (x2024)+(x1892); + x2026 = (uintptr_t)((x2025)<(x1892)); + x2027 = (x2025)+(x1969); + x2028 = (uintptr_t)((x2027)<(x1969)); + x2029 = (x2026)+(x2028); + x2030 = (x2029)+(x1897); + x2031 = (uintptr_t)((x2030)<(x1897)); + x2032 = (x2030)+(x1974); + x2033 = (uintptr_t)((x2032)<(x1974)); + x2034 = (x2031)+(x2033); + x2035 = (x2034)+(x1902); + x2036 = (uintptr_t)((x2035)<(x1902)); + x2037 = (x2035)+(x1979); + x2038 = (uintptr_t)((x2037)<(x1979)); + x2039 = (x2036)+(x2038); + x2040 = (x2039)+(x1907); + x2041 = (uintptr_t)((x2040)<(x1907)); + x2042 = (x2040)+(x1984); + x2043 = (uintptr_t)((x2042)<(x1984)); + x2044 = (x2041)+(x2043); + x2045 = (x2044)+(x1912); + x2046 = (uintptr_t)((x2045)<(x1912)); + x2047 = (x2045)+(x1989); + x2048 = (uintptr_t)((x2047)<(x1989)); + x2049 = (x2046)+(x2048); + x2050 = (x2049)+(x1917); + x2051 = (uintptr_t)((x2050)<(x1917)); + x2052 = (x2050)+(x1994); + x2053 = (uintptr_t)((x2052)<(x1994)); + x2054 = (x2051)+(x2053); + x2055 = (x2054)+(x1920); + x2056 = (uintptr_t)((x2055)<(x1920)); + x2057 = (x2055)+(x1997); + x2058 = (uintptr_t)((x2057)<(x1997)); + x2059 = (x2056)+(x2058); + x2060 = (x1998)*((uintptr_t)3901742149ULL); + x2061 = (x2060)*((uintptr_t)4294967295ULL); + x2062 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2060)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2060)*((uintptr_t)4294967295ULL))>>64); + x2063 = (x2060)*((uintptr_t)4294967295ULL); + x2064 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2060)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2060)*((uintptr_t)4294967295ULL))>>64); + x2065 = (x2060)*((uintptr_t)4294967295ULL); + x2066 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2060)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2060)*((uintptr_t)4294967295ULL))>>64); + x2067 = (x2060)*((uintptr_t)4294967295ULL); + x2068 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2060)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2060)*((uintptr_t)4294967295ULL))>>64); + x2069 = (x2060)*((uintptr_t)4294967295ULL); + x2070 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2060)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2060)*((uintptr_t)4294967295ULL))>>64); + x2071 = (x2060)*((uintptr_t)4294967295ULL); + x2072 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2060)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2060)*((uintptr_t)4294967295ULL))>>64); + x2073 = (x2060)*((uintptr_t)3345173889ULL); + x2074 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2060)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x2060)*((uintptr_t)3345173889ULL))>>64); + x2075 = (x2060)*((uintptr_t)4097256927ULL); + x2076 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2060)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x2060)*((uintptr_t)4097256927ULL))>>64); + x2077 = (x2060)*((uintptr_t)1478102450ULL); + x2078 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2060)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x2060)*((uintptr_t)1478102450ULL))>>64); + x2079 = (x2060)*((uintptr_t)1219536762ULL); + x2080 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2060)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x2060)*((uintptr_t)1219536762ULL))>>64); + x2081 = (x2060)*((uintptr_t)3974895978ULL); + x2082 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2060)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x2060)*((uintptr_t)3974895978ULL))>>64); + x2083 = (x2060)*((uintptr_t)3435473267ULL); + x2084 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2060)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x2060)*((uintptr_t)3435473267ULL))>>64); + x2085 = (x2084)+(x2081); + x2086 = (uintptr_t)((x2085)<(x2084)); + x2087 = (x2086)+(x2082); + x2088 = (uintptr_t)((x2087)<(x2082)); + x2089 = (x2087)+(x2079); + x2090 = (uintptr_t)((x2089)<(x2079)); + x2091 = (x2088)+(x2090); + x2092 = (x2091)+(x2080); + x2093 = (uintptr_t)((x2092)<(x2080)); + x2094 = (x2092)+(x2077); + x2095 = (uintptr_t)((x2094)<(x2077)); + x2096 = (x2093)+(x2095); + x2097 = (x2096)+(x2078); + x2098 = (uintptr_t)((x2097)<(x2078)); + x2099 = (x2097)+(x2075); + x2100 = (uintptr_t)((x2099)<(x2075)); + x2101 = (x2098)+(x2100); + x2102 = (x2101)+(x2076); + x2103 = (uintptr_t)((x2102)<(x2076)); + x2104 = (x2102)+(x2073); + x2105 = (uintptr_t)((x2104)<(x2073)); + x2106 = (x2103)+(x2105); + x2107 = (x2106)+(x2074); + x2108 = (uintptr_t)((x2107)<(x2074)); + x2109 = (x2107)+(x2071); + x2110 = (uintptr_t)((x2109)<(x2071)); + x2111 = (x2108)+(x2110); + x2112 = (x2111)+(x2072); + x2113 = (uintptr_t)((x2112)<(x2072)); + x2114 = (x2112)+(x2069); + x2115 = (uintptr_t)((x2114)<(x2069)); + x2116 = (x2113)+(x2115); + x2117 = (x2116)+(x2070); + x2118 = (uintptr_t)((x2117)<(x2070)); + x2119 = (x2117)+(x2067); + x2120 = (uintptr_t)((x2119)<(x2067)); + x2121 = (x2118)+(x2120); + x2122 = (x2121)+(x2068); + x2123 = (uintptr_t)((x2122)<(x2068)); + x2124 = (x2122)+(x2065); + x2125 = (uintptr_t)((x2124)<(x2065)); + x2126 = (x2123)+(x2125); + x2127 = (x2126)+(x2066); + x2128 = (uintptr_t)((x2127)<(x2066)); + x2129 = (x2127)+(x2063); + x2130 = (uintptr_t)((x2129)<(x2063)); + x2131 = (x2128)+(x2130); + x2132 = (x2131)+(x2064); + x2133 = (uintptr_t)((x2132)<(x2064)); + x2134 = (x2132)+(x2061); + x2135 = (uintptr_t)((x2134)<(x2061)); + x2136 = (x2133)+(x2135); + x2137 = (x2136)+(x2062); + x2138 = (x1998)+(x2083); + x2139 = (uintptr_t)((x2138)<(x1998)); + x2140 = (x2139)+(x2002); + x2141 = (uintptr_t)((x2140)<(x2002)); + x2142 = (x2140)+(x2085); + x2143 = (uintptr_t)((x2142)<(x2085)); + x2144 = (x2141)+(x2143); + x2145 = (x2144)+(x2007); + x2146 = (uintptr_t)((x2145)<(x2007)); + x2147 = (x2145)+(x2089); + x2148 = (uintptr_t)((x2147)<(x2089)); + x2149 = (x2146)+(x2148); + x2150 = (x2149)+(x2012); + x2151 = (uintptr_t)((x2150)<(x2012)); + x2152 = (x2150)+(x2094); + x2153 = (uintptr_t)((x2152)<(x2094)); + x2154 = (x2151)+(x2153); + x2155 = (x2154)+(x2017); + x2156 = (uintptr_t)((x2155)<(x2017)); + x2157 = (x2155)+(x2099); + x2158 = (uintptr_t)((x2157)<(x2099)); + x2159 = (x2156)+(x2158); + x2160 = (x2159)+(x2022); + x2161 = (uintptr_t)((x2160)<(x2022)); + x2162 = (x2160)+(x2104); + x2163 = (uintptr_t)((x2162)<(x2104)); + x2164 = (x2161)+(x2163); + x2165 = (x2164)+(x2027); + x2166 = (uintptr_t)((x2165)<(x2027)); + x2167 = (x2165)+(x2109); + x2168 = (uintptr_t)((x2167)<(x2109)); + x2169 = (x2166)+(x2168); + x2170 = (x2169)+(x2032); + x2171 = (uintptr_t)((x2170)<(x2032)); + x2172 = (x2170)+(x2114); + x2173 = (uintptr_t)((x2172)<(x2114)); + x2174 = (x2171)+(x2173); + x2175 = (x2174)+(x2037); + x2176 = (uintptr_t)((x2175)<(x2037)); + x2177 = (x2175)+(x2119); + x2178 = (uintptr_t)((x2177)<(x2119)); + x2179 = (x2176)+(x2178); + x2180 = (x2179)+(x2042); + x2181 = (uintptr_t)((x2180)<(x2042)); + x2182 = (x2180)+(x2124); + x2183 = (uintptr_t)((x2182)<(x2124)); + x2184 = (x2181)+(x2183); + x2185 = (x2184)+(x2047); + x2186 = (uintptr_t)((x2185)<(x2047)); + x2187 = (x2185)+(x2129); + x2188 = (uintptr_t)((x2187)<(x2129)); + x2189 = (x2186)+(x2188); + x2190 = (x2189)+(x2052); + x2191 = (uintptr_t)((x2190)<(x2052)); + x2192 = (x2190)+(x2134); + x2193 = (uintptr_t)((x2192)<(x2134)); + x2194 = (x2191)+(x2193); + x2195 = (x2194)+(x2057); + x2196 = (uintptr_t)((x2195)<(x2057)); + x2197 = (x2195)+(x2137); + x2198 = (uintptr_t)((x2197)<(x2137)); + x2199 = (x2196)+(x2198); + x2200 = (x2199)+(x2059); + x2201 = (x19)*(x11); + x2202 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x11))>>32 : ((__uint128_t)(x19)*(x11))>>64); + x2203 = (x19)*(x10); + x2204 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x10))>>32 : ((__uint128_t)(x19)*(x10))>>64); + x2205 = (x19)*(x9); + x2206 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x9))>>32 : ((__uint128_t)(x19)*(x9))>>64); + x2207 = (x19)*(x8); + x2208 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x8))>>32 : ((__uint128_t)(x19)*(x8))>>64); + x2209 = (x19)*(x7); + x2210 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x7))>>32 : ((__uint128_t)(x19)*(x7))>>64); + x2211 = (x19)*(x6); + x2212 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x6))>>32 : ((__uint128_t)(x19)*(x6))>>64); + x2213 = (x19)*(x5); + x2214 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x5))>>32 : ((__uint128_t)(x19)*(x5))>>64); + x2215 = (x19)*(x4); + x2216 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x4))>>32 : ((__uint128_t)(x19)*(x4))>>64); + x2217 = (x19)*(x3); + x2218 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x3))>>32 : ((__uint128_t)(x19)*(x3))>>64); + x2219 = (x19)*(x2); + x2220 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x2))>>32 : ((__uint128_t)(x19)*(x2))>>64); + x2221 = (x19)*(x1); + x2222 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x1))>>32 : ((__uint128_t)(x19)*(x1))>>64); + x2223 = (x19)*(x0); + x2224 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x0))>>32 : ((__uint128_t)(x19)*(x0))>>64); + x2225 = (x2224)+(x2221); + x2226 = (uintptr_t)((x2225)<(x2224)); + x2227 = (x2226)+(x2222); + x2228 = (uintptr_t)((x2227)<(x2222)); + x2229 = (x2227)+(x2219); + x2230 = (uintptr_t)((x2229)<(x2219)); + x2231 = (x2228)+(x2230); + x2232 = (x2231)+(x2220); + x2233 = (uintptr_t)((x2232)<(x2220)); + x2234 = (x2232)+(x2217); + x2235 = (uintptr_t)((x2234)<(x2217)); + x2236 = (x2233)+(x2235); + x2237 = (x2236)+(x2218); + x2238 = (uintptr_t)((x2237)<(x2218)); + x2239 = (x2237)+(x2215); + x2240 = (uintptr_t)((x2239)<(x2215)); + x2241 = (x2238)+(x2240); + x2242 = (x2241)+(x2216); + x2243 = (uintptr_t)((x2242)<(x2216)); + x2244 = (x2242)+(x2213); + x2245 = (uintptr_t)((x2244)<(x2213)); + x2246 = (x2243)+(x2245); + x2247 = (x2246)+(x2214); + x2248 = (uintptr_t)((x2247)<(x2214)); + x2249 = (x2247)+(x2211); + x2250 = (uintptr_t)((x2249)<(x2211)); + x2251 = (x2248)+(x2250); + x2252 = (x2251)+(x2212); + x2253 = (uintptr_t)((x2252)<(x2212)); + x2254 = (x2252)+(x2209); + x2255 = (uintptr_t)((x2254)<(x2209)); + x2256 = (x2253)+(x2255); + x2257 = (x2256)+(x2210); + x2258 = (uintptr_t)((x2257)<(x2210)); + x2259 = (x2257)+(x2207); + x2260 = (uintptr_t)((x2259)<(x2207)); + x2261 = (x2258)+(x2260); + x2262 = (x2261)+(x2208); + x2263 = (uintptr_t)((x2262)<(x2208)); + x2264 = (x2262)+(x2205); + x2265 = (uintptr_t)((x2264)<(x2205)); + x2266 = (x2263)+(x2265); + x2267 = (x2266)+(x2206); + x2268 = (uintptr_t)((x2267)<(x2206)); + x2269 = (x2267)+(x2203); + x2270 = (uintptr_t)((x2269)<(x2203)); + x2271 = (x2268)+(x2270); + x2272 = (x2271)+(x2204); + x2273 = (uintptr_t)((x2272)<(x2204)); + x2274 = (x2272)+(x2201); + x2275 = (uintptr_t)((x2274)<(x2201)); + x2276 = (x2273)+(x2275); + x2277 = (x2276)+(x2202); + x2278 = (x2142)+(x2223); + x2279 = (uintptr_t)((x2278)<(x2142)); + x2280 = (x2279)+(x2147); + x2281 = (uintptr_t)((x2280)<(x2147)); + x2282 = (x2280)+(x2225); + x2283 = (uintptr_t)((x2282)<(x2225)); + x2284 = (x2281)+(x2283); + x2285 = (x2284)+(x2152); + x2286 = (uintptr_t)((x2285)<(x2152)); + x2287 = (x2285)+(x2229); + x2288 = (uintptr_t)((x2287)<(x2229)); + x2289 = (x2286)+(x2288); + x2290 = (x2289)+(x2157); + x2291 = (uintptr_t)((x2290)<(x2157)); + x2292 = (x2290)+(x2234); + x2293 = (uintptr_t)((x2292)<(x2234)); + x2294 = (x2291)+(x2293); + x2295 = (x2294)+(x2162); + x2296 = (uintptr_t)((x2295)<(x2162)); + x2297 = (x2295)+(x2239); + x2298 = (uintptr_t)((x2297)<(x2239)); + x2299 = (x2296)+(x2298); + x2300 = (x2299)+(x2167); + x2301 = (uintptr_t)((x2300)<(x2167)); + x2302 = (x2300)+(x2244); + x2303 = (uintptr_t)((x2302)<(x2244)); + x2304 = (x2301)+(x2303); + x2305 = (x2304)+(x2172); + x2306 = (uintptr_t)((x2305)<(x2172)); + x2307 = (x2305)+(x2249); + x2308 = (uintptr_t)((x2307)<(x2249)); + x2309 = (x2306)+(x2308); + x2310 = (x2309)+(x2177); + x2311 = (uintptr_t)((x2310)<(x2177)); + x2312 = (x2310)+(x2254); + x2313 = (uintptr_t)((x2312)<(x2254)); + x2314 = (x2311)+(x2313); + x2315 = (x2314)+(x2182); + x2316 = (uintptr_t)((x2315)<(x2182)); + x2317 = (x2315)+(x2259); + x2318 = (uintptr_t)((x2317)<(x2259)); + x2319 = (x2316)+(x2318); + x2320 = (x2319)+(x2187); + x2321 = (uintptr_t)((x2320)<(x2187)); + x2322 = (x2320)+(x2264); + x2323 = (uintptr_t)((x2322)<(x2264)); + x2324 = (x2321)+(x2323); + x2325 = (x2324)+(x2192); + x2326 = (uintptr_t)((x2325)<(x2192)); + x2327 = (x2325)+(x2269); + x2328 = (uintptr_t)((x2327)<(x2269)); + x2329 = (x2326)+(x2328); + x2330 = (x2329)+(x2197); + x2331 = (uintptr_t)((x2330)<(x2197)); + x2332 = (x2330)+(x2274); + x2333 = (uintptr_t)((x2332)<(x2274)); + x2334 = (x2331)+(x2333); + x2335 = (x2334)+(x2200); + x2336 = (uintptr_t)((x2335)<(x2200)); + x2337 = (x2335)+(x2277); + x2338 = (uintptr_t)((x2337)<(x2277)); + x2339 = (x2336)+(x2338); + x2340 = (x2278)*((uintptr_t)3901742149ULL); + x2341 = (x2340)*((uintptr_t)4294967295ULL); + x2342 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2340)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2340)*((uintptr_t)4294967295ULL))>>64); + x2343 = (x2340)*((uintptr_t)4294967295ULL); + x2344 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2340)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2340)*((uintptr_t)4294967295ULL))>>64); + x2345 = (x2340)*((uintptr_t)4294967295ULL); + x2346 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2340)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2340)*((uintptr_t)4294967295ULL))>>64); + x2347 = (x2340)*((uintptr_t)4294967295ULL); + x2348 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2340)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2340)*((uintptr_t)4294967295ULL))>>64); + x2349 = (x2340)*((uintptr_t)4294967295ULL); + x2350 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2340)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2340)*((uintptr_t)4294967295ULL))>>64); + x2351 = (x2340)*((uintptr_t)4294967295ULL); + x2352 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2340)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2340)*((uintptr_t)4294967295ULL))>>64); + x2353 = (x2340)*((uintptr_t)3345173889ULL); + x2354 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2340)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x2340)*((uintptr_t)3345173889ULL))>>64); + x2355 = (x2340)*((uintptr_t)4097256927ULL); + x2356 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2340)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x2340)*((uintptr_t)4097256927ULL))>>64); + x2357 = (x2340)*((uintptr_t)1478102450ULL); + x2358 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2340)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x2340)*((uintptr_t)1478102450ULL))>>64); + x2359 = (x2340)*((uintptr_t)1219536762ULL); + x2360 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2340)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x2340)*((uintptr_t)1219536762ULL))>>64); + x2361 = (x2340)*((uintptr_t)3974895978ULL); + x2362 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2340)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x2340)*((uintptr_t)3974895978ULL))>>64); + x2363 = (x2340)*((uintptr_t)3435473267ULL); + x2364 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2340)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x2340)*((uintptr_t)3435473267ULL))>>64); + x2365 = (x2364)+(x2361); + x2366 = (uintptr_t)((x2365)<(x2364)); + x2367 = (x2366)+(x2362); + x2368 = (uintptr_t)((x2367)<(x2362)); + x2369 = (x2367)+(x2359); + x2370 = (uintptr_t)((x2369)<(x2359)); + x2371 = (x2368)+(x2370); + x2372 = (x2371)+(x2360); + x2373 = (uintptr_t)((x2372)<(x2360)); + x2374 = (x2372)+(x2357); + x2375 = (uintptr_t)((x2374)<(x2357)); + x2376 = (x2373)+(x2375); + x2377 = (x2376)+(x2358); + x2378 = (uintptr_t)((x2377)<(x2358)); + x2379 = (x2377)+(x2355); + x2380 = (uintptr_t)((x2379)<(x2355)); + x2381 = (x2378)+(x2380); + x2382 = (x2381)+(x2356); + x2383 = (uintptr_t)((x2382)<(x2356)); + x2384 = (x2382)+(x2353); + x2385 = (uintptr_t)((x2384)<(x2353)); + x2386 = (x2383)+(x2385); + x2387 = (x2386)+(x2354); + x2388 = (uintptr_t)((x2387)<(x2354)); + x2389 = (x2387)+(x2351); + x2390 = (uintptr_t)((x2389)<(x2351)); + x2391 = (x2388)+(x2390); + x2392 = (x2391)+(x2352); + x2393 = (uintptr_t)((x2392)<(x2352)); + x2394 = (x2392)+(x2349); + x2395 = (uintptr_t)((x2394)<(x2349)); + x2396 = (x2393)+(x2395); + x2397 = (x2396)+(x2350); + x2398 = (uintptr_t)((x2397)<(x2350)); + x2399 = (x2397)+(x2347); + x2400 = (uintptr_t)((x2399)<(x2347)); + x2401 = (x2398)+(x2400); + x2402 = (x2401)+(x2348); + x2403 = (uintptr_t)((x2402)<(x2348)); + x2404 = (x2402)+(x2345); + x2405 = (uintptr_t)((x2404)<(x2345)); + x2406 = (x2403)+(x2405); + x2407 = (x2406)+(x2346); + x2408 = (uintptr_t)((x2407)<(x2346)); + x2409 = (x2407)+(x2343); + x2410 = (uintptr_t)((x2409)<(x2343)); + x2411 = (x2408)+(x2410); + x2412 = (x2411)+(x2344); + x2413 = (uintptr_t)((x2412)<(x2344)); + x2414 = (x2412)+(x2341); + x2415 = (uintptr_t)((x2414)<(x2341)); + x2416 = (x2413)+(x2415); + x2417 = (x2416)+(x2342); + x2418 = (x2278)+(x2363); + x2419 = (uintptr_t)((x2418)<(x2278)); + x2420 = (x2419)+(x2282); + x2421 = (uintptr_t)((x2420)<(x2282)); + x2422 = (x2420)+(x2365); + x2423 = (uintptr_t)((x2422)<(x2365)); + x2424 = (x2421)+(x2423); + x2425 = (x2424)+(x2287); + x2426 = (uintptr_t)((x2425)<(x2287)); + x2427 = (x2425)+(x2369); + x2428 = (uintptr_t)((x2427)<(x2369)); + x2429 = (x2426)+(x2428); + x2430 = (x2429)+(x2292); + x2431 = (uintptr_t)((x2430)<(x2292)); + x2432 = (x2430)+(x2374); + x2433 = (uintptr_t)((x2432)<(x2374)); + x2434 = (x2431)+(x2433); + x2435 = (x2434)+(x2297); + x2436 = (uintptr_t)((x2435)<(x2297)); + x2437 = (x2435)+(x2379); + x2438 = (uintptr_t)((x2437)<(x2379)); + x2439 = (x2436)+(x2438); + x2440 = (x2439)+(x2302); + x2441 = (uintptr_t)((x2440)<(x2302)); + x2442 = (x2440)+(x2384); + x2443 = (uintptr_t)((x2442)<(x2384)); + x2444 = (x2441)+(x2443); + x2445 = (x2444)+(x2307); + x2446 = (uintptr_t)((x2445)<(x2307)); + x2447 = (x2445)+(x2389); + x2448 = (uintptr_t)((x2447)<(x2389)); + x2449 = (x2446)+(x2448); + x2450 = (x2449)+(x2312); + x2451 = (uintptr_t)((x2450)<(x2312)); + x2452 = (x2450)+(x2394); + x2453 = (uintptr_t)((x2452)<(x2394)); + x2454 = (x2451)+(x2453); + x2455 = (x2454)+(x2317); + x2456 = (uintptr_t)((x2455)<(x2317)); + x2457 = (x2455)+(x2399); + x2458 = (uintptr_t)((x2457)<(x2399)); + x2459 = (x2456)+(x2458); + x2460 = (x2459)+(x2322); + x2461 = (uintptr_t)((x2460)<(x2322)); + x2462 = (x2460)+(x2404); + x2463 = (uintptr_t)((x2462)<(x2404)); + x2464 = (x2461)+(x2463); + x2465 = (x2464)+(x2327); + x2466 = (uintptr_t)((x2465)<(x2327)); + x2467 = (x2465)+(x2409); + x2468 = (uintptr_t)((x2467)<(x2409)); + x2469 = (x2466)+(x2468); + x2470 = (x2469)+(x2332); + x2471 = (uintptr_t)((x2470)<(x2332)); + x2472 = (x2470)+(x2414); + x2473 = (uintptr_t)((x2472)<(x2414)); + x2474 = (x2471)+(x2473); + x2475 = (x2474)+(x2337); + x2476 = (uintptr_t)((x2475)<(x2337)); + x2477 = (x2475)+(x2417); + x2478 = (uintptr_t)((x2477)<(x2417)); + x2479 = (x2476)+(x2478); + x2480 = (x2479)+(x2339); + x2481 = (x20)*(x11); + x2482 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x11))>>32 : ((__uint128_t)(x20)*(x11))>>64); + x2483 = (x20)*(x10); + x2484 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x10))>>32 : ((__uint128_t)(x20)*(x10))>>64); + x2485 = (x20)*(x9); + x2486 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x9))>>32 : ((__uint128_t)(x20)*(x9))>>64); + x2487 = (x20)*(x8); + x2488 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x8))>>32 : ((__uint128_t)(x20)*(x8))>>64); + x2489 = (x20)*(x7); + x2490 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x7))>>32 : ((__uint128_t)(x20)*(x7))>>64); + x2491 = (x20)*(x6); + x2492 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x6))>>32 : ((__uint128_t)(x20)*(x6))>>64); + x2493 = (x20)*(x5); + x2494 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x5))>>32 : ((__uint128_t)(x20)*(x5))>>64); + x2495 = (x20)*(x4); + x2496 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x4))>>32 : ((__uint128_t)(x20)*(x4))>>64); + x2497 = (x20)*(x3); + x2498 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x3))>>32 : ((__uint128_t)(x20)*(x3))>>64); + x2499 = (x20)*(x2); + x2500 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x2))>>32 : ((__uint128_t)(x20)*(x2))>>64); + x2501 = (x20)*(x1); + x2502 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x1))>>32 : ((__uint128_t)(x20)*(x1))>>64); + x2503 = (x20)*(x0); + x2504 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x0))>>32 : ((__uint128_t)(x20)*(x0))>>64); + x2505 = (x2504)+(x2501); + x2506 = (uintptr_t)((x2505)<(x2504)); + x2507 = (x2506)+(x2502); + x2508 = (uintptr_t)((x2507)<(x2502)); + x2509 = (x2507)+(x2499); + x2510 = (uintptr_t)((x2509)<(x2499)); + x2511 = (x2508)+(x2510); + x2512 = (x2511)+(x2500); + x2513 = (uintptr_t)((x2512)<(x2500)); + x2514 = (x2512)+(x2497); + x2515 = (uintptr_t)((x2514)<(x2497)); + x2516 = (x2513)+(x2515); + x2517 = (x2516)+(x2498); + x2518 = (uintptr_t)((x2517)<(x2498)); + x2519 = (x2517)+(x2495); + x2520 = (uintptr_t)((x2519)<(x2495)); + x2521 = (x2518)+(x2520); + x2522 = (x2521)+(x2496); + x2523 = (uintptr_t)((x2522)<(x2496)); + x2524 = (x2522)+(x2493); + x2525 = (uintptr_t)((x2524)<(x2493)); + x2526 = (x2523)+(x2525); + x2527 = (x2526)+(x2494); + x2528 = (uintptr_t)((x2527)<(x2494)); + x2529 = (x2527)+(x2491); + x2530 = (uintptr_t)((x2529)<(x2491)); + x2531 = (x2528)+(x2530); + x2532 = (x2531)+(x2492); + x2533 = (uintptr_t)((x2532)<(x2492)); + x2534 = (x2532)+(x2489); + x2535 = (uintptr_t)((x2534)<(x2489)); + x2536 = (x2533)+(x2535); + x2537 = (x2536)+(x2490); + x2538 = (uintptr_t)((x2537)<(x2490)); + x2539 = (x2537)+(x2487); + x2540 = (uintptr_t)((x2539)<(x2487)); + x2541 = (x2538)+(x2540); + x2542 = (x2541)+(x2488); + x2543 = (uintptr_t)((x2542)<(x2488)); + x2544 = (x2542)+(x2485); + x2545 = (uintptr_t)((x2544)<(x2485)); + x2546 = (x2543)+(x2545); + x2547 = (x2546)+(x2486); + x2548 = (uintptr_t)((x2547)<(x2486)); + x2549 = (x2547)+(x2483); + x2550 = (uintptr_t)((x2549)<(x2483)); + x2551 = (x2548)+(x2550); + x2552 = (x2551)+(x2484); + x2553 = (uintptr_t)((x2552)<(x2484)); + x2554 = (x2552)+(x2481); + x2555 = (uintptr_t)((x2554)<(x2481)); + x2556 = (x2553)+(x2555); + x2557 = (x2556)+(x2482); + x2558 = (x2422)+(x2503); + x2559 = (uintptr_t)((x2558)<(x2422)); + x2560 = (x2559)+(x2427); + x2561 = (uintptr_t)((x2560)<(x2427)); + x2562 = (x2560)+(x2505); + x2563 = (uintptr_t)((x2562)<(x2505)); + x2564 = (x2561)+(x2563); + x2565 = (x2564)+(x2432); + x2566 = (uintptr_t)((x2565)<(x2432)); + x2567 = (x2565)+(x2509); + x2568 = (uintptr_t)((x2567)<(x2509)); + x2569 = (x2566)+(x2568); + x2570 = (x2569)+(x2437); + x2571 = (uintptr_t)((x2570)<(x2437)); + x2572 = (x2570)+(x2514); + x2573 = (uintptr_t)((x2572)<(x2514)); + x2574 = (x2571)+(x2573); + x2575 = (x2574)+(x2442); + x2576 = (uintptr_t)((x2575)<(x2442)); + x2577 = (x2575)+(x2519); + x2578 = (uintptr_t)((x2577)<(x2519)); + x2579 = (x2576)+(x2578); + x2580 = (x2579)+(x2447); + x2581 = (uintptr_t)((x2580)<(x2447)); + x2582 = (x2580)+(x2524); + x2583 = (uintptr_t)((x2582)<(x2524)); + x2584 = (x2581)+(x2583); + x2585 = (x2584)+(x2452); + x2586 = (uintptr_t)((x2585)<(x2452)); + x2587 = (x2585)+(x2529); + x2588 = (uintptr_t)((x2587)<(x2529)); + x2589 = (x2586)+(x2588); + x2590 = (x2589)+(x2457); + x2591 = (uintptr_t)((x2590)<(x2457)); + x2592 = (x2590)+(x2534); + x2593 = (uintptr_t)((x2592)<(x2534)); + x2594 = (x2591)+(x2593); + x2595 = (x2594)+(x2462); + x2596 = (uintptr_t)((x2595)<(x2462)); + x2597 = (x2595)+(x2539); + x2598 = (uintptr_t)((x2597)<(x2539)); + x2599 = (x2596)+(x2598); + x2600 = (x2599)+(x2467); + x2601 = (uintptr_t)((x2600)<(x2467)); + x2602 = (x2600)+(x2544); + x2603 = (uintptr_t)((x2602)<(x2544)); + x2604 = (x2601)+(x2603); + x2605 = (x2604)+(x2472); + x2606 = (uintptr_t)((x2605)<(x2472)); + x2607 = (x2605)+(x2549); + x2608 = (uintptr_t)((x2607)<(x2549)); + x2609 = (x2606)+(x2608); + x2610 = (x2609)+(x2477); + x2611 = (uintptr_t)((x2610)<(x2477)); + x2612 = (x2610)+(x2554); + x2613 = (uintptr_t)((x2612)<(x2554)); + x2614 = (x2611)+(x2613); + x2615 = (x2614)+(x2480); + x2616 = (uintptr_t)((x2615)<(x2480)); + x2617 = (x2615)+(x2557); + x2618 = (uintptr_t)((x2617)<(x2557)); + x2619 = (x2616)+(x2618); + x2620 = (x2558)*((uintptr_t)3901742149ULL); + x2621 = (x2620)*((uintptr_t)4294967295ULL); + x2622 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64); + x2623 = (x2620)*((uintptr_t)4294967295ULL); + x2624 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64); + x2625 = (x2620)*((uintptr_t)4294967295ULL); + x2626 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64); + x2627 = (x2620)*((uintptr_t)4294967295ULL); + x2628 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64); + x2629 = (x2620)*((uintptr_t)4294967295ULL); + x2630 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64); + x2631 = (x2620)*((uintptr_t)4294967295ULL); + x2632 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64); + x2633 = (x2620)*((uintptr_t)3345173889ULL); + x2634 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)3345173889ULL))>>64); + x2635 = (x2620)*((uintptr_t)4097256927ULL); + x2636 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4097256927ULL))>>64); + x2637 = (x2620)*((uintptr_t)1478102450ULL); + x2638 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)1478102450ULL))>>64); + x2639 = (x2620)*((uintptr_t)1219536762ULL); + x2640 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)1219536762ULL))>>64); + x2641 = (x2620)*((uintptr_t)3974895978ULL); + x2642 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)3974895978ULL))>>64); + x2643 = (x2620)*((uintptr_t)3435473267ULL); + x2644 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)3435473267ULL))>>64); + x2645 = (x2644)+(x2641); + x2646 = (uintptr_t)((x2645)<(x2644)); + x2647 = (x2646)+(x2642); + x2648 = (uintptr_t)((x2647)<(x2642)); + x2649 = (x2647)+(x2639); + x2650 = (uintptr_t)((x2649)<(x2639)); + x2651 = (x2648)+(x2650); + x2652 = (x2651)+(x2640); + x2653 = (uintptr_t)((x2652)<(x2640)); + x2654 = (x2652)+(x2637); + x2655 = (uintptr_t)((x2654)<(x2637)); + x2656 = (x2653)+(x2655); + x2657 = (x2656)+(x2638); + x2658 = (uintptr_t)((x2657)<(x2638)); + x2659 = (x2657)+(x2635); + x2660 = (uintptr_t)((x2659)<(x2635)); + x2661 = (x2658)+(x2660); + x2662 = (x2661)+(x2636); + x2663 = (uintptr_t)((x2662)<(x2636)); + x2664 = (x2662)+(x2633); + x2665 = (uintptr_t)((x2664)<(x2633)); + x2666 = (x2663)+(x2665); + x2667 = (x2666)+(x2634); + x2668 = (uintptr_t)((x2667)<(x2634)); + x2669 = (x2667)+(x2631); + x2670 = (uintptr_t)((x2669)<(x2631)); + x2671 = (x2668)+(x2670); + x2672 = (x2671)+(x2632); + x2673 = (uintptr_t)((x2672)<(x2632)); + x2674 = (x2672)+(x2629); + x2675 = (uintptr_t)((x2674)<(x2629)); + x2676 = (x2673)+(x2675); + x2677 = (x2676)+(x2630); + x2678 = (uintptr_t)((x2677)<(x2630)); + x2679 = (x2677)+(x2627); + x2680 = (uintptr_t)((x2679)<(x2627)); + x2681 = (x2678)+(x2680); + x2682 = (x2681)+(x2628); + x2683 = (uintptr_t)((x2682)<(x2628)); + x2684 = (x2682)+(x2625); + x2685 = (uintptr_t)((x2684)<(x2625)); + x2686 = (x2683)+(x2685); + x2687 = (x2686)+(x2626); + x2688 = (uintptr_t)((x2687)<(x2626)); + x2689 = (x2687)+(x2623); + x2690 = (uintptr_t)((x2689)<(x2623)); + x2691 = (x2688)+(x2690); + x2692 = (x2691)+(x2624); + x2693 = (uintptr_t)((x2692)<(x2624)); + x2694 = (x2692)+(x2621); + x2695 = (uintptr_t)((x2694)<(x2621)); + x2696 = (x2693)+(x2695); + x2697 = (x2696)+(x2622); + x2698 = (x2558)+(x2643); + x2699 = (uintptr_t)((x2698)<(x2558)); + x2700 = (x2699)+(x2562); + x2701 = (uintptr_t)((x2700)<(x2562)); + x2702 = (x2700)+(x2645); + x2703 = (uintptr_t)((x2702)<(x2645)); + x2704 = (x2701)+(x2703); + x2705 = (x2704)+(x2567); + x2706 = (uintptr_t)((x2705)<(x2567)); + x2707 = (x2705)+(x2649); + x2708 = (uintptr_t)((x2707)<(x2649)); + x2709 = (x2706)+(x2708); + x2710 = (x2709)+(x2572); + x2711 = (uintptr_t)((x2710)<(x2572)); + x2712 = (x2710)+(x2654); + x2713 = (uintptr_t)((x2712)<(x2654)); + x2714 = (x2711)+(x2713); + x2715 = (x2714)+(x2577); + x2716 = (uintptr_t)((x2715)<(x2577)); + x2717 = (x2715)+(x2659); + x2718 = (uintptr_t)((x2717)<(x2659)); + x2719 = (x2716)+(x2718); + x2720 = (x2719)+(x2582); + x2721 = (uintptr_t)((x2720)<(x2582)); + x2722 = (x2720)+(x2664); + x2723 = (uintptr_t)((x2722)<(x2664)); + x2724 = (x2721)+(x2723); + x2725 = (x2724)+(x2587); + x2726 = (uintptr_t)((x2725)<(x2587)); + x2727 = (x2725)+(x2669); + x2728 = (uintptr_t)((x2727)<(x2669)); + x2729 = (x2726)+(x2728); + x2730 = (x2729)+(x2592); + x2731 = (uintptr_t)((x2730)<(x2592)); + x2732 = (x2730)+(x2674); + x2733 = (uintptr_t)((x2732)<(x2674)); + x2734 = (x2731)+(x2733); + x2735 = (x2734)+(x2597); + x2736 = (uintptr_t)((x2735)<(x2597)); + x2737 = (x2735)+(x2679); + x2738 = (uintptr_t)((x2737)<(x2679)); + x2739 = (x2736)+(x2738); + x2740 = (x2739)+(x2602); + x2741 = (uintptr_t)((x2740)<(x2602)); + x2742 = (x2740)+(x2684); + x2743 = (uintptr_t)((x2742)<(x2684)); + x2744 = (x2741)+(x2743); + x2745 = (x2744)+(x2607); + x2746 = (uintptr_t)((x2745)<(x2607)); + x2747 = (x2745)+(x2689); + x2748 = (uintptr_t)((x2747)<(x2689)); + x2749 = (x2746)+(x2748); + x2750 = (x2749)+(x2612); + x2751 = (uintptr_t)((x2750)<(x2612)); + x2752 = (x2750)+(x2694); + x2753 = (uintptr_t)((x2752)<(x2694)); + x2754 = (x2751)+(x2753); + x2755 = (x2754)+(x2617); + x2756 = (uintptr_t)((x2755)<(x2617)); + x2757 = (x2755)+(x2697); + x2758 = (uintptr_t)((x2757)<(x2697)); + x2759 = (x2756)+(x2758); + x2760 = (x2759)+(x2619); + x2761 = (x21)*(x11); + x2762 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x11))>>32 : ((__uint128_t)(x21)*(x11))>>64); + x2763 = (x21)*(x10); + x2764 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x10))>>32 : ((__uint128_t)(x21)*(x10))>>64); + x2765 = (x21)*(x9); + x2766 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x9))>>32 : ((__uint128_t)(x21)*(x9))>>64); + x2767 = (x21)*(x8); + x2768 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x8))>>32 : ((__uint128_t)(x21)*(x8))>>64); + x2769 = (x21)*(x7); + x2770 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x7))>>32 : ((__uint128_t)(x21)*(x7))>>64); + x2771 = (x21)*(x6); + x2772 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x6))>>32 : ((__uint128_t)(x21)*(x6))>>64); + x2773 = (x21)*(x5); + x2774 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x5))>>32 : ((__uint128_t)(x21)*(x5))>>64); + x2775 = (x21)*(x4); + x2776 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x4))>>32 : ((__uint128_t)(x21)*(x4))>>64); + x2777 = (x21)*(x3); + x2778 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x3))>>32 : ((__uint128_t)(x21)*(x3))>>64); + x2779 = (x21)*(x2); + x2780 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x2))>>32 : ((__uint128_t)(x21)*(x2))>>64); + x2781 = (x21)*(x1); + x2782 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x1))>>32 : ((__uint128_t)(x21)*(x1))>>64); + x2783 = (x21)*(x0); + x2784 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x0))>>32 : ((__uint128_t)(x21)*(x0))>>64); + x2785 = (x2784)+(x2781); + x2786 = (uintptr_t)((x2785)<(x2784)); + x2787 = (x2786)+(x2782); + x2788 = (uintptr_t)((x2787)<(x2782)); + x2789 = (x2787)+(x2779); + x2790 = (uintptr_t)((x2789)<(x2779)); + x2791 = (x2788)+(x2790); + x2792 = (x2791)+(x2780); + x2793 = (uintptr_t)((x2792)<(x2780)); + x2794 = (x2792)+(x2777); + x2795 = (uintptr_t)((x2794)<(x2777)); + x2796 = (x2793)+(x2795); + x2797 = (x2796)+(x2778); + x2798 = (uintptr_t)((x2797)<(x2778)); + x2799 = (x2797)+(x2775); + x2800 = (uintptr_t)((x2799)<(x2775)); + x2801 = (x2798)+(x2800); + x2802 = (x2801)+(x2776); + x2803 = (uintptr_t)((x2802)<(x2776)); + x2804 = (x2802)+(x2773); + x2805 = (uintptr_t)((x2804)<(x2773)); + x2806 = (x2803)+(x2805); + x2807 = (x2806)+(x2774); + x2808 = (uintptr_t)((x2807)<(x2774)); + x2809 = (x2807)+(x2771); + x2810 = (uintptr_t)((x2809)<(x2771)); + x2811 = (x2808)+(x2810); + x2812 = (x2811)+(x2772); + x2813 = (uintptr_t)((x2812)<(x2772)); + x2814 = (x2812)+(x2769); + x2815 = (uintptr_t)((x2814)<(x2769)); + x2816 = (x2813)+(x2815); + x2817 = (x2816)+(x2770); + x2818 = (uintptr_t)((x2817)<(x2770)); + x2819 = (x2817)+(x2767); + x2820 = (uintptr_t)((x2819)<(x2767)); + x2821 = (x2818)+(x2820); + x2822 = (x2821)+(x2768); + x2823 = (uintptr_t)((x2822)<(x2768)); + x2824 = (x2822)+(x2765); + x2825 = (uintptr_t)((x2824)<(x2765)); + x2826 = (x2823)+(x2825); + x2827 = (x2826)+(x2766); + x2828 = (uintptr_t)((x2827)<(x2766)); + x2829 = (x2827)+(x2763); + x2830 = (uintptr_t)((x2829)<(x2763)); + x2831 = (x2828)+(x2830); + x2832 = (x2831)+(x2764); + x2833 = (uintptr_t)((x2832)<(x2764)); + x2834 = (x2832)+(x2761); + x2835 = (uintptr_t)((x2834)<(x2761)); + x2836 = (x2833)+(x2835); + x2837 = (x2836)+(x2762); + x2838 = (x2702)+(x2783); + x2839 = (uintptr_t)((x2838)<(x2702)); + x2840 = (x2839)+(x2707); + x2841 = (uintptr_t)((x2840)<(x2707)); + x2842 = (x2840)+(x2785); + x2843 = (uintptr_t)((x2842)<(x2785)); + x2844 = (x2841)+(x2843); + x2845 = (x2844)+(x2712); + x2846 = (uintptr_t)((x2845)<(x2712)); + x2847 = (x2845)+(x2789); + x2848 = (uintptr_t)((x2847)<(x2789)); + x2849 = (x2846)+(x2848); + x2850 = (x2849)+(x2717); + x2851 = (uintptr_t)((x2850)<(x2717)); + x2852 = (x2850)+(x2794); + x2853 = (uintptr_t)((x2852)<(x2794)); + x2854 = (x2851)+(x2853); + x2855 = (x2854)+(x2722); + x2856 = (uintptr_t)((x2855)<(x2722)); + x2857 = (x2855)+(x2799); + x2858 = (uintptr_t)((x2857)<(x2799)); + x2859 = (x2856)+(x2858); + x2860 = (x2859)+(x2727); + x2861 = (uintptr_t)((x2860)<(x2727)); + x2862 = (x2860)+(x2804); + x2863 = (uintptr_t)((x2862)<(x2804)); + x2864 = (x2861)+(x2863); + x2865 = (x2864)+(x2732); + x2866 = (uintptr_t)((x2865)<(x2732)); + x2867 = (x2865)+(x2809); + x2868 = (uintptr_t)((x2867)<(x2809)); + x2869 = (x2866)+(x2868); + x2870 = (x2869)+(x2737); + x2871 = (uintptr_t)((x2870)<(x2737)); + x2872 = (x2870)+(x2814); + x2873 = (uintptr_t)((x2872)<(x2814)); + x2874 = (x2871)+(x2873); + x2875 = (x2874)+(x2742); + x2876 = (uintptr_t)((x2875)<(x2742)); + x2877 = (x2875)+(x2819); + x2878 = (uintptr_t)((x2877)<(x2819)); + x2879 = (x2876)+(x2878); + x2880 = (x2879)+(x2747); + x2881 = (uintptr_t)((x2880)<(x2747)); + x2882 = (x2880)+(x2824); + x2883 = (uintptr_t)((x2882)<(x2824)); + x2884 = (x2881)+(x2883); + x2885 = (x2884)+(x2752); + x2886 = (uintptr_t)((x2885)<(x2752)); + x2887 = (x2885)+(x2829); + x2888 = (uintptr_t)((x2887)<(x2829)); + x2889 = (x2886)+(x2888); + x2890 = (x2889)+(x2757); + x2891 = (uintptr_t)((x2890)<(x2757)); + x2892 = (x2890)+(x2834); + x2893 = (uintptr_t)((x2892)<(x2834)); + x2894 = (x2891)+(x2893); + x2895 = (x2894)+(x2760); + x2896 = (uintptr_t)((x2895)<(x2760)); + x2897 = (x2895)+(x2837); + x2898 = (uintptr_t)((x2897)<(x2837)); + x2899 = (x2896)+(x2898); + x2900 = (x2838)*((uintptr_t)3901742149ULL); + x2901 = (x2900)*((uintptr_t)4294967295ULL); + x2902 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2900)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2900)*((uintptr_t)4294967295ULL))>>64); + x2903 = (x2900)*((uintptr_t)4294967295ULL); + x2904 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2900)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2900)*((uintptr_t)4294967295ULL))>>64); + x2905 = (x2900)*((uintptr_t)4294967295ULL); + x2906 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2900)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2900)*((uintptr_t)4294967295ULL))>>64); + x2907 = (x2900)*((uintptr_t)4294967295ULL); + x2908 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2900)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2900)*((uintptr_t)4294967295ULL))>>64); + x2909 = (x2900)*((uintptr_t)4294967295ULL); + x2910 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2900)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2900)*((uintptr_t)4294967295ULL))>>64); + x2911 = (x2900)*((uintptr_t)4294967295ULL); + x2912 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2900)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2900)*((uintptr_t)4294967295ULL))>>64); + x2913 = (x2900)*((uintptr_t)3345173889ULL); + x2914 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2900)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x2900)*((uintptr_t)3345173889ULL))>>64); + x2915 = (x2900)*((uintptr_t)4097256927ULL); + x2916 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2900)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x2900)*((uintptr_t)4097256927ULL))>>64); + x2917 = (x2900)*((uintptr_t)1478102450ULL); + x2918 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2900)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x2900)*((uintptr_t)1478102450ULL))>>64); + x2919 = (x2900)*((uintptr_t)1219536762ULL); + x2920 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2900)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x2900)*((uintptr_t)1219536762ULL))>>64); + x2921 = (x2900)*((uintptr_t)3974895978ULL); + x2922 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2900)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x2900)*((uintptr_t)3974895978ULL))>>64); + x2923 = (x2900)*((uintptr_t)3435473267ULL); + x2924 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x2900)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x2900)*((uintptr_t)3435473267ULL))>>64); + x2925 = (x2924)+(x2921); + x2926 = (uintptr_t)((x2925)<(x2924)); + x2927 = (x2926)+(x2922); + x2928 = (uintptr_t)((x2927)<(x2922)); + x2929 = (x2927)+(x2919); + x2930 = (uintptr_t)((x2929)<(x2919)); + x2931 = (x2928)+(x2930); + x2932 = (x2931)+(x2920); + x2933 = (uintptr_t)((x2932)<(x2920)); + x2934 = (x2932)+(x2917); + x2935 = (uintptr_t)((x2934)<(x2917)); + x2936 = (x2933)+(x2935); + x2937 = (x2936)+(x2918); + x2938 = (uintptr_t)((x2937)<(x2918)); + x2939 = (x2937)+(x2915); + x2940 = (uintptr_t)((x2939)<(x2915)); + x2941 = (x2938)+(x2940); + x2942 = (x2941)+(x2916); + x2943 = (uintptr_t)((x2942)<(x2916)); + x2944 = (x2942)+(x2913); + x2945 = (uintptr_t)((x2944)<(x2913)); + x2946 = (x2943)+(x2945); + x2947 = (x2946)+(x2914); + x2948 = (uintptr_t)((x2947)<(x2914)); + x2949 = (x2947)+(x2911); + x2950 = (uintptr_t)((x2949)<(x2911)); + x2951 = (x2948)+(x2950); + x2952 = (x2951)+(x2912); + x2953 = (uintptr_t)((x2952)<(x2912)); + x2954 = (x2952)+(x2909); + x2955 = (uintptr_t)((x2954)<(x2909)); + x2956 = (x2953)+(x2955); + x2957 = (x2956)+(x2910); + x2958 = (uintptr_t)((x2957)<(x2910)); + x2959 = (x2957)+(x2907); + x2960 = (uintptr_t)((x2959)<(x2907)); + x2961 = (x2958)+(x2960); + x2962 = (x2961)+(x2908); + x2963 = (uintptr_t)((x2962)<(x2908)); + x2964 = (x2962)+(x2905); + x2965 = (uintptr_t)((x2964)<(x2905)); + x2966 = (x2963)+(x2965); + x2967 = (x2966)+(x2906); + x2968 = (uintptr_t)((x2967)<(x2906)); + x2969 = (x2967)+(x2903); + x2970 = (uintptr_t)((x2969)<(x2903)); + x2971 = (x2968)+(x2970); + x2972 = (x2971)+(x2904); + x2973 = (uintptr_t)((x2972)<(x2904)); + x2974 = (x2972)+(x2901); + x2975 = (uintptr_t)((x2974)<(x2901)); + x2976 = (x2973)+(x2975); + x2977 = (x2976)+(x2902); + x2978 = (x2838)+(x2923); + x2979 = (uintptr_t)((x2978)<(x2838)); + x2980 = (x2979)+(x2842); + x2981 = (uintptr_t)((x2980)<(x2842)); + x2982 = (x2980)+(x2925); + x2983 = (uintptr_t)((x2982)<(x2925)); + x2984 = (x2981)+(x2983); + x2985 = (x2984)+(x2847); + x2986 = (uintptr_t)((x2985)<(x2847)); + x2987 = (x2985)+(x2929); + x2988 = (uintptr_t)((x2987)<(x2929)); + x2989 = (x2986)+(x2988); + x2990 = (x2989)+(x2852); + x2991 = (uintptr_t)((x2990)<(x2852)); + x2992 = (x2990)+(x2934); + x2993 = (uintptr_t)((x2992)<(x2934)); + x2994 = (x2991)+(x2993); + x2995 = (x2994)+(x2857); + x2996 = (uintptr_t)((x2995)<(x2857)); + x2997 = (x2995)+(x2939); + x2998 = (uintptr_t)((x2997)<(x2939)); + x2999 = (x2996)+(x2998); + x3000 = (x2999)+(x2862); + x3001 = (uintptr_t)((x3000)<(x2862)); + x3002 = (x3000)+(x2944); + x3003 = (uintptr_t)((x3002)<(x2944)); + x3004 = (x3001)+(x3003); + x3005 = (x3004)+(x2867); + x3006 = (uintptr_t)((x3005)<(x2867)); + x3007 = (x3005)+(x2949); + x3008 = (uintptr_t)((x3007)<(x2949)); + x3009 = (x3006)+(x3008); + x3010 = (x3009)+(x2872); + x3011 = (uintptr_t)((x3010)<(x2872)); + x3012 = (x3010)+(x2954); + x3013 = (uintptr_t)((x3012)<(x2954)); + x3014 = (x3011)+(x3013); + x3015 = (x3014)+(x2877); + x3016 = (uintptr_t)((x3015)<(x2877)); + x3017 = (x3015)+(x2959); + x3018 = (uintptr_t)((x3017)<(x2959)); + x3019 = (x3016)+(x3018); + x3020 = (x3019)+(x2882); + x3021 = (uintptr_t)((x3020)<(x2882)); + x3022 = (x3020)+(x2964); + x3023 = (uintptr_t)((x3022)<(x2964)); + x3024 = (x3021)+(x3023); + x3025 = (x3024)+(x2887); + x3026 = (uintptr_t)((x3025)<(x2887)); + x3027 = (x3025)+(x2969); + x3028 = (uintptr_t)((x3027)<(x2969)); + x3029 = (x3026)+(x3028); + x3030 = (x3029)+(x2892); + x3031 = (uintptr_t)((x3030)<(x2892)); + x3032 = (x3030)+(x2974); + x3033 = (uintptr_t)((x3032)<(x2974)); + x3034 = (x3031)+(x3033); + x3035 = (x3034)+(x2897); + x3036 = (uintptr_t)((x3035)<(x2897)); + x3037 = (x3035)+(x2977); + x3038 = (uintptr_t)((x3037)<(x2977)); + x3039 = (x3036)+(x3038); + x3040 = (x3039)+(x2899); + x3041 = (x22)*(x11); + x3042 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x11))>>32 : ((__uint128_t)(x22)*(x11))>>64); + x3043 = (x22)*(x10); + x3044 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x10))>>32 : ((__uint128_t)(x22)*(x10))>>64); + x3045 = (x22)*(x9); + x3046 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x9))>>32 : ((__uint128_t)(x22)*(x9))>>64); + x3047 = (x22)*(x8); + x3048 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x8))>>32 : ((__uint128_t)(x22)*(x8))>>64); + x3049 = (x22)*(x7); + x3050 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x7))>>32 : ((__uint128_t)(x22)*(x7))>>64); + x3051 = (x22)*(x6); + x3052 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x6))>>32 : ((__uint128_t)(x22)*(x6))>>64); + x3053 = (x22)*(x5); + x3054 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x5))>>32 : ((__uint128_t)(x22)*(x5))>>64); + x3055 = (x22)*(x4); + x3056 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x4))>>32 : ((__uint128_t)(x22)*(x4))>>64); + x3057 = (x22)*(x3); + x3058 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x3))>>32 : ((__uint128_t)(x22)*(x3))>>64); + x3059 = (x22)*(x2); + x3060 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x2))>>32 : ((__uint128_t)(x22)*(x2))>>64); + x3061 = (x22)*(x1); + x3062 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x1))>>32 : ((__uint128_t)(x22)*(x1))>>64); + x3063 = (x22)*(x0); + x3064 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x0))>>32 : ((__uint128_t)(x22)*(x0))>>64); + x3065 = (x3064)+(x3061); + x3066 = (uintptr_t)((x3065)<(x3064)); + x3067 = (x3066)+(x3062); + x3068 = (uintptr_t)((x3067)<(x3062)); + x3069 = (x3067)+(x3059); + x3070 = (uintptr_t)((x3069)<(x3059)); + x3071 = (x3068)+(x3070); + x3072 = (x3071)+(x3060); + x3073 = (uintptr_t)((x3072)<(x3060)); + x3074 = (x3072)+(x3057); + x3075 = (uintptr_t)((x3074)<(x3057)); + x3076 = (x3073)+(x3075); + x3077 = (x3076)+(x3058); + x3078 = (uintptr_t)((x3077)<(x3058)); + x3079 = (x3077)+(x3055); + x3080 = (uintptr_t)((x3079)<(x3055)); + x3081 = (x3078)+(x3080); + x3082 = (x3081)+(x3056); + x3083 = (uintptr_t)((x3082)<(x3056)); + x3084 = (x3082)+(x3053); + x3085 = (uintptr_t)((x3084)<(x3053)); + x3086 = (x3083)+(x3085); + x3087 = (x3086)+(x3054); + x3088 = (uintptr_t)((x3087)<(x3054)); + x3089 = (x3087)+(x3051); + x3090 = (uintptr_t)((x3089)<(x3051)); + x3091 = (x3088)+(x3090); + x3092 = (x3091)+(x3052); + x3093 = (uintptr_t)((x3092)<(x3052)); + x3094 = (x3092)+(x3049); + x3095 = (uintptr_t)((x3094)<(x3049)); + x3096 = (x3093)+(x3095); + x3097 = (x3096)+(x3050); + x3098 = (uintptr_t)((x3097)<(x3050)); + x3099 = (x3097)+(x3047); + x3100 = (uintptr_t)((x3099)<(x3047)); + x3101 = (x3098)+(x3100); + x3102 = (x3101)+(x3048); + x3103 = (uintptr_t)((x3102)<(x3048)); + x3104 = (x3102)+(x3045); + x3105 = (uintptr_t)((x3104)<(x3045)); + x3106 = (x3103)+(x3105); + x3107 = (x3106)+(x3046); + x3108 = (uintptr_t)((x3107)<(x3046)); + x3109 = (x3107)+(x3043); + x3110 = (uintptr_t)((x3109)<(x3043)); + x3111 = (x3108)+(x3110); + x3112 = (x3111)+(x3044); + x3113 = (uintptr_t)((x3112)<(x3044)); + x3114 = (x3112)+(x3041); + x3115 = (uintptr_t)((x3114)<(x3041)); + x3116 = (x3113)+(x3115); + x3117 = (x3116)+(x3042); + x3118 = (x2982)+(x3063); + x3119 = (uintptr_t)((x3118)<(x2982)); + x3120 = (x3119)+(x2987); + x3121 = (uintptr_t)((x3120)<(x2987)); + x3122 = (x3120)+(x3065); + x3123 = (uintptr_t)((x3122)<(x3065)); + x3124 = (x3121)+(x3123); + x3125 = (x3124)+(x2992); + x3126 = (uintptr_t)((x3125)<(x2992)); + x3127 = (x3125)+(x3069); + x3128 = (uintptr_t)((x3127)<(x3069)); + x3129 = (x3126)+(x3128); + x3130 = (x3129)+(x2997); + x3131 = (uintptr_t)((x3130)<(x2997)); + x3132 = (x3130)+(x3074); + x3133 = (uintptr_t)((x3132)<(x3074)); + x3134 = (x3131)+(x3133); + x3135 = (x3134)+(x3002); + x3136 = (uintptr_t)((x3135)<(x3002)); + x3137 = (x3135)+(x3079); + x3138 = (uintptr_t)((x3137)<(x3079)); + x3139 = (x3136)+(x3138); + x3140 = (x3139)+(x3007); + x3141 = (uintptr_t)((x3140)<(x3007)); + x3142 = (x3140)+(x3084); + x3143 = (uintptr_t)((x3142)<(x3084)); + x3144 = (x3141)+(x3143); + x3145 = (x3144)+(x3012); + x3146 = (uintptr_t)((x3145)<(x3012)); + x3147 = (x3145)+(x3089); + x3148 = (uintptr_t)((x3147)<(x3089)); + x3149 = (x3146)+(x3148); + x3150 = (x3149)+(x3017); + x3151 = (uintptr_t)((x3150)<(x3017)); + x3152 = (x3150)+(x3094); + x3153 = (uintptr_t)((x3152)<(x3094)); + x3154 = (x3151)+(x3153); + x3155 = (x3154)+(x3022); + x3156 = (uintptr_t)((x3155)<(x3022)); + x3157 = (x3155)+(x3099); + x3158 = (uintptr_t)((x3157)<(x3099)); + x3159 = (x3156)+(x3158); + x3160 = (x3159)+(x3027); + x3161 = (uintptr_t)((x3160)<(x3027)); + x3162 = (x3160)+(x3104); + x3163 = (uintptr_t)((x3162)<(x3104)); + x3164 = (x3161)+(x3163); + x3165 = (x3164)+(x3032); + x3166 = (uintptr_t)((x3165)<(x3032)); + x3167 = (x3165)+(x3109); + x3168 = (uintptr_t)((x3167)<(x3109)); + x3169 = (x3166)+(x3168); + x3170 = (x3169)+(x3037); + x3171 = (uintptr_t)((x3170)<(x3037)); + x3172 = (x3170)+(x3114); + x3173 = (uintptr_t)((x3172)<(x3114)); + x3174 = (x3171)+(x3173); + x3175 = (x3174)+(x3040); + x3176 = (uintptr_t)((x3175)<(x3040)); + x3177 = (x3175)+(x3117); + x3178 = (uintptr_t)((x3177)<(x3117)); + x3179 = (x3176)+(x3178); + x3180 = (x3118)*((uintptr_t)3901742149ULL); + x3181 = (x3180)*((uintptr_t)4294967295ULL); + x3182 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3180)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x3180)*((uintptr_t)4294967295ULL))>>64); + x3183 = (x3180)*((uintptr_t)4294967295ULL); + x3184 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3180)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x3180)*((uintptr_t)4294967295ULL))>>64); + x3185 = (x3180)*((uintptr_t)4294967295ULL); + x3186 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3180)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x3180)*((uintptr_t)4294967295ULL))>>64); + x3187 = (x3180)*((uintptr_t)4294967295ULL); + x3188 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3180)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x3180)*((uintptr_t)4294967295ULL))>>64); + x3189 = (x3180)*((uintptr_t)4294967295ULL); + x3190 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3180)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x3180)*((uintptr_t)4294967295ULL))>>64); + x3191 = (x3180)*((uintptr_t)4294967295ULL); + x3192 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3180)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x3180)*((uintptr_t)4294967295ULL))>>64); + x3193 = (x3180)*((uintptr_t)3345173889ULL); + x3194 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3180)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x3180)*((uintptr_t)3345173889ULL))>>64); + x3195 = (x3180)*((uintptr_t)4097256927ULL); + x3196 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3180)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x3180)*((uintptr_t)4097256927ULL))>>64); + x3197 = (x3180)*((uintptr_t)1478102450ULL); + x3198 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3180)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x3180)*((uintptr_t)1478102450ULL))>>64); + x3199 = (x3180)*((uintptr_t)1219536762ULL); + x3200 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3180)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x3180)*((uintptr_t)1219536762ULL))>>64); + x3201 = (x3180)*((uintptr_t)3974895978ULL); + x3202 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3180)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x3180)*((uintptr_t)3974895978ULL))>>64); + x3203 = (x3180)*((uintptr_t)3435473267ULL); + x3204 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x3180)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x3180)*((uintptr_t)3435473267ULL))>>64); + x3205 = (x3204)+(x3201); + x3206 = (uintptr_t)((x3205)<(x3204)); + x3207 = (x3206)+(x3202); + x3208 = (uintptr_t)((x3207)<(x3202)); + x3209 = (x3207)+(x3199); + x3210 = (uintptr_t)((x3209)<(x3199)); + x3211 = (x3208)+(x3210); + x3212 = (x3211)+(x3200); + x3213 = (uintptr_t)((x3212)<(x3200)); + x3214 = (x3212)+(x3197); + x3215 = (uintptr_t)((x3214)<(x3197)); + x3216 = (x3213)+(x3215); + x3217 = (x3216)+(x3198); + x3218 = (uintptr_t)((x3217)<(x3198)); + x3219 = (x3217)+(x3195); + x3220 = (uintptr_t)((x3219)<(x3195)); + x3221 = (x3218)+(x3220); + x3222 = (x3221)+(x3196); + x3223 = (uintptr_t)((x3222)<(x3196)); + x3224 = (x3222)+(x3193); + x3225 = (uintptr_t)((x3224)<(x3193)); + x3226 = (x3223)+(x3225); + x3227 = (x3226)+(x3194); + x3228 = (uintptr_t)((x3227)<(x3194)); + x3229 = (x3227)+(x3191); + x3230 = (uintptr_t)((x3229)<(x3191)); + x3231 = (x3228)+(x3230); + x3232 = (x3231)+(x3192); + x3233 = (uintptr_t)((x3232)<(x3192)); + x3234 = (x3232)+(x3189); + x3235 = (uintptr_t)((x3234)<(x3189)); + x3236 = (x3233)+(x3235); + x3237 = (x3236)+(x3190); + x3238 = (uintptr_t)((x3237)<(x3190)); + x3239 = (x3237)+(x3187); + x3240 = (uintptr_t)((x3239)<(x3187)); + x3241 = (x3238)+(x3240); + x3242 = (x3241)+(x3188); + x3243 = (uintptr_t)((x3242)<(x3188)); + x3244 = (x3242)+(x3185); + x3245 = (uintptr_t)((x3244)<(x3185)); + x3246 = (x3243)+(x3245); + x3247 = (x3246)+(x3186); + x3248 = (uintptr_t)((x3247)<(x3186)); + x3249 = (x3247)+(x3183); + x3250 = (uintptr_t)((x3249)<(x3183)); + x3251 = (x3248)+(x3250); + x3252 = (x3251)+(x3184); + x3253 = (uintptr_t)((x3252)<(x3184)); + x3254 = (x3252)+(x3181); + x3255 = (uintptr_t)((x3254)<(x3181)); + x3256 = (x3253)+(x3255); + x3257 = (x3256)+(x3182); + x3258 = (x3118)+(x3203); + x3259 = (uintptr_t)((x3258)<(x3118)); + x3260 = (x3259)+(x3122); + x3261 = (uintptr_t)((x3260)<(x3122)); + x3262 = (x3260)+(x3205); + x3263 = (uintptr_t)((x3262)<(x3205)); + x3264 = (x3261)+(x3263); + x3265 = (x3264)+(x3127); + x3266 = (uintptr_t)((x3265)<(x3127)); + x3267 = (x3265)+(x3209); + x3268 = (uintptr_t)((x3267)<(x3209)); + x3269 = (x3266)+(x3268); + x3270 = (x3269)+(x3132); + x3271 = (uintptr_t)((x3270)<(x3132)); + x3272 = (x3270)+(x3214); + x3273 = (uintptr_t)((x3272)<(x3214)); + x3274 = (x3271)+(x3273); + x3275 = (x3274)+(x3137); + x3276 = (uintptr_t)((x3275)<(x3137)); + x3277 = (x3275)+(x3219); + x3278 = (uintptr_t)((x3277)<(x3219)); + x3279 = (x3276)+(x3278); + x3280 = (x3279)+(x3142); + x3281 = (uintptr_t)((x3280)<(x3142)); + x3282 = (x3280)+(x3224); + x3283 = (uintptr_t)((x3282)<(x3224)); + x3284 = (x3281)+(x3283); + x3285 = (x3284)+(x3147); + x3286 = (uintptr_t)((x3285)<(x3147)); + x3287 = (x3285)+(x3229); + x3288 = (uintptr_t)((x3287)<(x3229)); + x3289 = (x3286)+(x3288); + x3290 = (x3289)+(x3152); + x3291 = (uintptr_t)((x3290)<(x3152)); + x3292 = (x3290)+(x3234); + x3293 = (uintptr_t)((x3292)<(x3234)); + x3294 = (x3291)+(x3293); + x3295 = (x3294)+(x3157); + x3296 = (uintptr_t)((x3295)<(x3157)); + x3297 = (x3295)+(x3239); + x3298 = (uintptr_t)((x3297)<(x3239)); + x3299 = (x3296)+(x3298); + x3300 = (x3299)+(x3162); + x3301 = (uintptr_t)((x3300)<(x3162)); + x3302 = (x3300)+(x3244); + x3303 = (uintptr_t)((x3302)<(x3244)); + x3304 = (x3301)+(x3303); + x3305 = (x3304)+(x3167); + x3306 = (uintptr_t)((x3305)<(x3167)); + x3307 = (x3305)+(x3249); + x3308 = (uintptr_t)((x3307)<(x3249)); + x3309 = (x3306)+(x3308); + x3310 = (x3309)+(x3172); + x3311 = (uintptr_t)((x3310)<(x3172)); + x3312 = (x3310)+(x3254); + x3313 = (uintptr_t)((x3312)<(x3254)); + x3314 = (x3311)+(x3313); + x3315 = (x3314)+(x3177); + x3316 = (uintptr_t)((x3315)<(x3177)); + x3317 = (x3315)+(x3257); + x3318 = (uintptr_t)((x3317)<(x3257)); + x3319 = (x3316)+(x3318); + x3320 = (x3319)+(x3179); + x3321 = (x3262)-((uintptr_t)3435473267ULL); + x3322 = (uintptr_t)((x3262)<(x3321)); + x3323 = (x3267)-((uintptr_t)3974895978ULL); + x3324 = (uintptr_t)((x3267)<(x3323)); + x3325 = (x3323)-(x3322); + x3326 = (uintptr_t)((x3323)<(x3325)); + x3327 = (x3324)+(x3326); + x3328 = (x3272)-((uintptr_t)1219536762ULL); + x3329 = (uintptr_t)((x3272)<(x3328)); + x3330 = (x3328)-(x3327); + x3331 = (uintptr_t)((x3328)<(x3330)); + x3332 = (x3329)+(x3331); + x3333 = (x3277)-((uintptr_t)1478102450ULL); + x3334 = (uintptr_t)((x3277)<(x3333)); + x3335 = (x3333)-(x3332); + x3336 = (uintptr_t)((x3333)<(x3335)); + x3337 = (x3334)+(x3336); + x3338 = (x3282)-((uintptr_t)4097256927ULL); + x3339 = (uintptr_t)((x3282)<(x3338)); + x3340 = (x3338)-(x3337); + x3341 = (uintptr_t)((x3338)<(x3340)); + x3342 = (x3339)+(x3341); + x3343 = (x3287)-((uintptr_t)3345173889ULL); + x3344 = (uintptr_t)((x3287)<(x3343)); + x3345 = (x3343)-(x3342); + x3346 = (uintptr_t)((x3343)<(x3345)); + x3347 = (x3344)+(x3346); + x3348 = (x3292)-((uintptr_t)4294967295ULL); + x3349 = (uintptr_t)((x3292)<(x3348)); + x3350 = (x3348)-(x3347); + x3351 = (uintptr_t)((x3348)<(x3350)); + x3352 = (x3349)+(x3351); + x3353 = (x3297)-((uintptr_t)4294967295ULL); + x3354 = (uintptr_t)((x3297)<(x3353)); + x3355 = (x3353)-(x3352); + x3356 = (uintptr_t)((x3353)<(x3355)); + x3357 = (x3354)+(x3356); + x3358 = (x3302)-((uintptr_t)4294967295ULL); + x3359 = (uintptr_t)((x3302)<(x3358)); + x3360 = (x3358)-(x3357); + x3361 = (uintptr_t)((x3358)<(x3360)); + x3362 = (x3359)+(x3361); + x3363 = (x3307)-((uintptr_t)4294967295ULL); + x3364 = (uintptr_t)((x3307)<(x3363)); + x3365 = (x3363)-(x3362); + x3366 = (uintptr_t)((x3363)<(x3365)); + x3367 = (x3364)+(x3366); + x3368 = (x3312)-((uintptr_t)4294967295ULL); + x3369 = (uintptr_t)((x3312)<(x3368)); + x3370 = (x3368)-(x3367); + x3371 = (uintptr_t)((x3368)<(x3370)); + x3372 = (x3369)+(x3371); + x3373 = (x3317)-((uintptr_t)4294967295ULL); + x3374 = (uintptr_t)((x3317)<(x3373)); + x3375 = (x3373)-(x3372); + x3376 = (uintptr_t)((x3373)<(x3375)); + x3377 = (x3374)+(x3376); + x3378 = (x3320)-(x3377); + x3379 = (uintptr_t)((x3320)<(x3378)); + x3380 = ((uintptr_t)-1ULL)+((uintptr_t)((x3379)==((uintptr_t)0ULL))); + x3381 = (x3380)^((uintptr_t)4294967295ULL); + x3382 = ((x3262)&(x3380))|((x3321)&(x3381)); + x3383 = ((uintptr_t)-1ULL)+((uintptr_t)((x3379)==((uintptr_t)0ULL))); + x3384 = (x3383)^((uintptr_t)4294967295ULL); + x3385 = ((x3267)&(x3383))|((x3325)&(x3384)); + x3386 = ((uintptr_t)-1ULL)+((uintptr_t)((x3379)==((uintptr_t)0ULL))); + x3387 = (x3386)^((uintptr_t)4294967295ULL); + x3388 = ((x3272)&(x3386))|((x3330)&(x3387)); + x3389 = ((uintptr_t)-1ULL)+((uintptr_t)((x3379)==((uintptr_t)0ULL))); + x3390 = (x3389)^((uintptr_t)4294967295ULL); + x3391 = ((x3277)&(x3389))|((x3335)&(x3390)); + x3392 = ((uintptr_t)-1ULL)+((uintptr_t)((x3379)==((uintptr_t)0ULL))); + x3393 = (x3392)^((uintptr_t)4294967295ULL); + x3394 = ((x3282)&(x3392))|((x3340)&(x3393)); + x3395 = ((uintptr_t)-1ULL)+((uintptr_t)((x3379)==((uintptr_t)0ULL))); + x3396 = (x3395)^((uintptr_t)4294967295ULL); + x3397 = ((x3287)&(x3395))|((x3345)&(x3396)); + x3398 = ((uintptr_t)-1ULL)+((uintptr_t)((x3379)==((uintptr_t)0ULL))); + x3399 = (x3398)^((uintptr_t)4294967295ULL); + x3400 = ((x3292)&(x3398))|((x3350)&(x3399)); + x3401 = ((uintptr_t)-1ULL)+((uintptr_t)((x3379)==((uintptr_t)0ULL))); + x3402 = (x3401)^((uintptr_t)4294967295ULL); + x3403 = ((x3297)&(x3401))|((x3355)&(x3402)); + x3404 = ((uintptr_t)-1ULL)+((uintptr_t)((x3379)==((uintptr_t)0ULL))); + x3405 = (x3404)^((uintptr_t)4294967295ULL); + x3406 = ((x3302)&(x3404))|((x3360)&(x3405)); + x3407 = ((uintptr_t)-1ULL)+((uintptr_t)((x3379)==((uintptr_t)0ULL))); + x3408 = (x3407)^((uintptr_t)4294967295ULL); + x3409 = ((x3307)&(x3407))|((x3365)&(x3408)); + x3410 = ((uintptr_t)-1ULL)+((uintptr_t)((x3379)==((uintptr_t)0ULL))); + x3411 = (x3410)^((uintptr_t)4294967295ULL); + x3412 = ((x3312)&(x3410))|((x3370)&(x3411)); + x3413 = ((uintptr_t)-1ULL)+((uintptr_t)((x3379)==((uintptr_t)0ULL))); + x3414 = (x3413)^((uintptr_t)4294967295ULL); + x3415 = ((x3317)&(x3413))|((x3375)&(x3414)); + x3416 = x3382; + x3417 = x3385; + x3418 = x3388; + x3419 = x3391; + x3420 = x3394; + x3421 = x3397; + x3422 = x3400; + x3423 = x3403; + x3424 = x3406; + x3425 = x3409; + x3426 = x3412; + x3427 = x3415; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x3416, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x3417, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x3418, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3419, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x3420, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x3421, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3422, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x3423, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x3424, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)36ULL), x3425, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x3426, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)44ULL), x3427, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_square(uint32_t out1[12], const uint32_t arg1[12]) { + internal_fiat_p384_scalar_square((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p384_scalar_add(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x12, x0, x25, x1, x13, x27, x2, x14, x29, x3, x15, x31, x4, x16, x33, x5, x17, x35, x6, x18, x37, x7, x19, x39, x8, x20, x41, x9, x21, x43, x10, x22, x45, x11, x23, x49, x51, x53, x55, x57, x59, x61, x63, x65, x67, x47, x69, x24, x72, x48, x73, x26, x75, x50, x76, x28, x78, x52, x79, x30, x81, x54, x82, x32, x84, x56, x85, x34, x87, x58, x88, x36, x90, x60, x91, x38, x93, x62, x94, x40, x96, x64, x97, x42, x99, x66, x100, x44, x102, x68, x103, x71, x46, x105, x70, x106, x74, x77, x80, x83, x86, x89, x92, x95, x98, x101, x104, x107, x108, x109, x110, x111, x112, x113, x114, x115, x116, x117, x118, x119; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x9 = _br2_load((in0)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x10 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x11 = _br2_load((in0)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + x12 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x16 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x17 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x18 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x19 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x20 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x21 = _br2_load((in1)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x22 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x23 = _br2_load((in1)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x24 = (x0)+(x12); + x25 = ((uintptr_t)((x24)<(x0)))+(x1); + x26 = (x25)+(x13); + x27 = (((uintptr_t)((x25)<(x1)))+((uintptr_t)((x26)<(x13))))+(x2); + x28 = (x27)+(x14); + x29 = (((uintptr_t)((x27)<(x2)))+((uintptr_t)((x28)<(x14))))+(x3); + x30 = (x29)+(x15); + x31 = (((uintptr_t)((x29)<(x3)))+((uintptr_t)((x30)<(x15))))+(x4); + x32 = (x31)+(x16); + x33 = (((uintptr_t)((x31)<(x4)))+((uintptr_t)((x32)<(x16))))+(x5); + x34 = (x33)+(x17); + x35 = (((uintptr_t)((x33)<(x5)))+((uintptr_t)((x34)<(x17))))+(x6); + x36 = (x35)+(x18); + x37 = (((uintptr_t)((x35)<(x6)))+((uintptr_t)((x36)<(x18))))+(x7); + x38 = (x37)+(x19); + x39 = (((uintptr_t)((x37)<(x7)))+((uintptr_t)((x38)<(x19))))+(x8); + x40 = (x39)+(x20); + x41 = (((uintptr_t)((x39)<(x8)))+((uintptr_t)((x40)<(x20))))+(x9); + x42 = (x41)+(x21); + x43 = (((uintptr_t)((x41)<(x9)))+((uintptr_t)((x42)<(x21))))+(x10); + x44 = (x43)+(x22); + x45 = (((uintptr_t)((x43)<(x10)))+((uintptr_t)((x44)<(x22))))+(x11); + x46 = (x45)+(x23); + x47 = ((uintptr_t)((x45)<(x11)))+((uintptr_t)((x46)<(x23))); + x48 = (x24)-((uintptr_t)3435473267ULL); + x49 = (x26)-((uintptr_t)3974895978ULL); + x50 = (x49)-((uintptr_t)((x24)<(x48))); + x51 = (x28)-((uintptr_t)1219536762ULL); + x52 = (x51)-(((uintptr_t)((x26)<(x49)))+((uintptr_t)((x49)<(x50)))); + x53 = (x30)-((uintptr_t)1478102450ULL); + x54 = (x53)-(((uintptr_t)((x28)<(x51)))+((uintptr_t)((x51)<(x52)))); + x55 = (x32)-((uintptr_t)4097256927ULL); + x56 = (x55)-(((uintptr_t)((x30)<(x53)))+((uintptr_t)((x53)<(x54)))); + x57 = (x34)-((uintptr_t)3345173889ULL); + x58 = (x57)-(((uintptr_t)((x32)<(x55)))+((uintptr_t)((x55)<(x56)))); + x59 = (x36)-((uintptr_t)4294967295ULL); + x60 = (x59)-(((uintptr_t)((x34)<(x57)))+((uintptr_t)((x57)<(x58)))); + x61 = (x38)-((uintptr_t)4294967295ULL); + x62 = (x61)-(((uintptr_t)((x36)<(x59)))+((uintptr_t)((x59)<(x60)))); + x63 = (x40)-((uintptr_t)4294967295ULL); + x64 = (x63)-(((uintptr_t)((x38)<(x61)))+((uintptr_t)((x61)<(x62)))); + x65 = (x42)-((uintptr_t)4294967295ULL); + x66 = (x65)-(((uintptr_t)((x40)<(x63)))+((uintptr_t)((x63)<(x64)))); + x67 = (x44)-((uintptr_t)4294967295ULL); + x68 = (x67)-(((uintptr_t)((x42)<(x65)))+((uintptr_t)((x65)<(x66)))); + x69 = (x46)-((uintptr_t)4294967295ULL); + x70 = (x69)-(((uintptr_t)((x44)<(x67)))+((uintptr_t)((x67)<(x68)))); + x71 = (uintptr_t)((x47)<((x47)-(((uintptr_t)((x46)<(x69)))+((uintptr_t)((x69)<(x70)))))); + x72 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x73 = (x72)^((uintptr_t)4294967295ULL); + x74 = ((x24)&(x72))|((x48)&(x73)); + x75 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x76 = (x75)^((uintptr_t)4294967295ULL); + x77 = ((x26)&(x75))|((x50)&(x76)); + x78 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x79 = (x78)^((uintptr_t)4294967295ULL); + x80 = ((x28)&(x78))|((x52)&(x79)); + x81 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x82 = (x81)^((uintptr_t)4294967295ULL); + x83 = ((x30)&(x81))|((x54)&(x82)); + x84 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x85 = (x84)^((uintptr_t)4294967295ULL); + x86 = ((x32)&(x84))|((x56)&(x85)); + x87 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x88 = (x87)^((uintptr_t)4294967295ULL); + x89 = ((x34)&(x87))|((x58)&(x88)); + x90 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x91 = (x90)^((uintptr_t)4294967295ULL); + x92 = ((x36)&(x90))|((x60)&(x91)); + x93 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x94 = (x93)^((uintptr_t)4294967295ULL); + x95 = ((x38)&(x93))|((x62)&(x94)); + x96 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x97 = (x96)^((uintptr_t)4294967295ULL); + x98 = ((x40)&(x96))|((x64)&(x97)); + x99 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x100 = (x99)^((uintptr_t)4294967295ULL); + x101 = ((x42)&(x99))|((x66)&(x100)); + x102 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x103 = (x102)^((uintptr_t)4294967295ULL); + x104 = ((x44)&(x102))|((x68)&(x103)); + x105 = ((uintptr_t)-1ULL)+((uintptr_t)((x71)==((uintptr_t)0ULL))); + x106 = (x105)^((uintptr_t)4294967295ULL); + x107 = ((x46)&(x105))|((x70)&(x106)); + x108 = x74; + x109 = x77; + x110 = x80; + x111 = x83; + x112 = x86; + x113 = x89; + x114 = x92; + x115 = x95; + x116 = x98; + x117 = x101; + x118 = x104; + x119 = x107; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x108, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x109, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x110, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x111, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x112, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x113, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x114, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x115, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x116, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)36ULL), x117, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x118, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)44ULL), x119, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_add(uint32_t out1[12], const uint32_t arg1[12], const uint32_t arg2[12]) { + internal_fiat_p384_scalar_add((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p384_scalar_sub(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x12, x13, x0, x14, x1, x25, x15, x2, x27, x16, x3, x29, x17, x4, x31, x18, x5, x33, x19, x6, x35, x20, x7, x37, x21, x8, x39, x22, x9, x41, x23, x10, x43, x11, x45, x24, x49, x26, x51, x28, x53, x30, x55, x32, x57, x34, x59, x36, x61, x38, x63, x40, x65, x42, x67, x44, x46, x47, x48, x50, x52, x54, x56, x58, x60, x62, x64, x66, x68, x69, x70, x71, x72, x73, x74, x75, x76, x77, x78, x79, x80, x81; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x9 = _br2_load((in0)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x10 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x11 = _br2_load((in0)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + x12 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x16 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x17 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x18 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x19 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x20 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x21 = _br2_load((in1)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x22 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x23 = _br2_load((in1)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x24 = (x0)-(x12); + x25 = (x1)-(x13); + x26 = (x25)-((uintptr_t)((x0)<(x24))); + x27 = (x2)-(x14); + x28 = (x27)-(((uintptr_t)((x1)<(x25)))+((uintptr_t)((x25)<(x26)))); + x29 = (x3)-(x15); + x30 = (x29)-(((uintptr_t)((x2)<(x27)))+((uintptr_t)((x27)<(x28)))); + x31 = (x4)-(x16); + x32 = (x31)-(((uintptr_t)((x3)<(x29)))+((uintptr_t)((x29)<(x30)))); + x33 = (x5)-(x17); + x34 = (x33)-(((uintptr_t)((x4)<(x31)))+((uintptr_t)((x31)<(x32)))); + x35 = (x6)-(x18); + x36 = (x35)-(((uintptr_t)((x5)<(x33)))+((uintptr_t)((x33)<(x34)))); + x37 = (x7)-(x19); + x38 = (x37)-(((uintptr_t)((x6)<(x35)))+((uintptr_t)((x35)<(x36)))); + x39 = (x8)-(x20); + x40 = (x39)-(((uintptr_t)((x7)<(x37)))+((uintptr_t)((x37)<(x38)))); + x41 = (x9)-(x21); + x42 = (x41)-(((uintptr_t)((x8)<(x39)))+((uintptr_t)((x39)<(x40)))); + x43 = (x10)-(x22); + x44 = (x43)-(((uintptr_t)((x9)<(x41)))+((uintptr_t)((x41)<(x42)))); + x45 = (x11)-(x23); + x46 = (x45)-(((uintptr_t)((x10)<(x43)))+((uintptr_t)((x43)<(x44)))); + x47 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)((x11)<(x45)))+((uintptr_t)((x45)<(x46))))==((uintptr_t)0ULL))); + x48 = (x24)+((x47)&((uintptr_t)3435473267ULL)); + x49 = ((uintptr_t)((x48)<(x24)))+(x26); + x50 = (x49)+((x47)&((uintptr_t)3974895978ULL)); + x51 = (((uintptr_t)((x49)<(x26)))+((uintptr_t)((x50)<((x47)&((uintptr_t)3974895978ULL)))))+(x28); + x52 = (x51)+((x47)&((uintptr_t)1219536762ULL)); + x53 = (((uintptr_t)((x51)<(x28)))+((uintptr_t)((x52)<((x47)&((uintptr_t)1219536762ULL)))))+(x30); + x54 = (x53)+((x47)&((uintptr_t)1478102450ULL)); + x55 = (((uintptr_t)((x53)<(x30)))+((uintptr_t)((x54)<((x47)&((uintptr_t)1478102450ULL)))))+(x32); + x56 = (x55)+((x47)&((uintptr_t)4097256927ULL)); + x57 = (((uintptr_t)((x55)<(x32)))+((uintptr_t)((x56)<((x47)&((uintptr_t)4097256927ULL)))))+(x34); + x58 = (x57)+((x47)&((uintptr_t)3345173889ULL)); + x59 = (((uintptr_t)((x57)<(x34)))+((uintptr_t)((x58)<((x47)&((uintptr_t)3345173889ULL)))))+(x36); + x60 = (x59)+(x47); + x61 = (((uintptr_t)((x59)<(x36)))+((uintptr_t)((x60)<(x47))))+(x38); + x62 = (x61)+(x47); + x63 = (((uintptr_t)((x61)<(x38)))+((uintptr_t)((x62)<(x47))))+(x40); + x64 = (x63)+(x47); + x65 = (((uintptr_t)((x63)<(x40)))+((uintptr_t)((x64)<(x47))))+(x42); + x66 = (x65)+(x47); + x67 = (((uintptr_t)((x65)<(x42)))+((uintptr_t)((x66)<(x47))))+(x44); + x68 = (x67)+(x47); + x69 = ((((uintptr_t)((x67)<(x44)))+((uintptr_t)((x68)<(x47))))+(x46))+(x47); + x70 = x48; + x71 = x50; + x72 = x52; + x73 = x54; + x74 = x56; + x75 = x58; + x76 = x60; + x77 = x62; + x78 = x64; + x79 = x66; + x80 = x68; + x81 = x69; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x70, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x71, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x72, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x73, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x74, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x75, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x76, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x77, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x78, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)36ULL), x79, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x80, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)44ULL), x81, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_sub(uint32_t out1[12], const uint32_t arg1[12], const uint32_t arg2[12]) { + internal_fiat_p384_scalar_sub((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p384_scalar_opp(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x1, x2, x13, x3, x15, x4, x17, x5, x19, x6, x21, x7, x23, x8, x25, x9, x27, x10, x29, x11, x31, x33, x12, x37, x14, x39, x16, x41, x18, x43, x20, x45, x22, x47, x24, x49, x26, x51, x28, x53, x30, x55, x32, x34, x35, x36, x38, x40, x42, x44, x46, x48, x50, x52, x54, x56, x57, x58, x59, x60, x61, x62, x63, x64, x65, x66, x67, x68, x69; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x9 = _br2_load((in0)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x10 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x11 = _br2_load((in0)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x12 = ((uintptr_t)0ULL)-(x0); + x13 = ((uintptr_t)0ULL)-(x1); + x14 = (x13)-((uintptr_t)(((uintptr_t)0ULL)<(x12))); + x15 = ((uintptr_t)0ULL)-(x2); + x16 = (x15)-(((uintptr_t)(((uintptr_t)0ULL)<(x13)))+((uintptr_t)((x13)<(x14)))); + x17 = ((uintptr_t)0ULL)-(x3); + x18 = (x17)-(((uintptr_t)(((uintptr_t)0ULL)<(x15)))+((uintptr_t)((x15)<(x16)))); + x19 = ((uintptr_t)0ULL)-(x4); + x20 = (x19)-(((uintptr_t)(((uintptr_t)0ULL)<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = ((uintptr_t)0ULL)-(x5); + x22 = (x21)-(((uintptr_t)(((uintptr_t)0ULL)<(x19)))+((uintptr_t)((x19)<(x20)))); + x23 = ((uintptr_t)0ULL)-(x6); + x24 = (x23)-(((uintptr_t)(((uintptr_t)0ULL)<(x21)))+((uintptr_t)((x21)<(x22)))); + x25 = ((uintptr_t)0ULL)-(x7); + x26 = (x25)-(((uintptr_t)(((uintptr_t)0ULL)<(x23)))+((uintptr_t)((x23)<(x24)))); + x27 = ((uintptr_t)0ULL)-(x8); + x28 = (x27)-(((uintptr_t)(((uintptr_t)0ULL)<(x25)))+((uintptr_t)((x25)<(x26)))); + x29 = ((uintptr_t)0ULL)-(x9); + x30 = (x29)-(((uintptr_t)(((uintptr_t)0ULL)<(x27)))+((uintptr_t)((x27)<(x28)))); + x31 = ((uintptr_t)0ULL)-(x10); + x32 = (x31)-(((uintptr_t)(((uintptr_t)0ULL)<(x29)))+((uintptr_t)((x29)<(x30)))); + x33 = ((uintptr_t)0ULL)-(x11); + x34 = (x33)-(((uintptr_t)(((uintptr_t)0ULL)<(x31)))+((uintptr_t)((x31)<(x32)))); + x35 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)(((uintptr_t)0ULL)<(x33)))+((uintptr_t)((x33)<(x34))))==((uintptr_t)0ULL))); + x36 = (x12)+((x35)&((uintptr_t)3435473267ULL)); + x37 = ((uintptr_t)((x36)<(x12)))+(x14); + x38 = (x37)+((x35)&((uintptr_t)3974895978ULL)); + x39 = (((uintptr_t)((x37)<(x14)))+((uintptr_t)((x38)<((x35)&((uintptr_t)3974895978ULL)))))+(x16); + x40 = (x39)+((x35)&((uintptr_t)1219536762ULL)); + x41 = (((uintptr_t)((x39)<(x16)))+((uintptr_t)((x40)<((x35)&((uintptr_t)1219536762ULL)))))+(x18); + x42 = (x41)+((x35)&((uintptr_t)1478102450ULL)); + x43 = (((uintptr_t)((x41)<(x18)))+((uintptr_t)((x42)<((x35)&((uintptr_t)1478102450ULL)))))+(x20); + x44 = (x43)+((x35)&((uintptr_t)4097256927ULL)); + x45 = (((uintptr_t)((x43)<(x20)))+((uintptr_t)((x44)<((x35)&((uintptr_t)4097256927ULL)))))+(x22); + x46 = (x45)+((x35)&((uintptr_t)3345173889ULL)); + x47 = (((uintptr_t)((x45)<(x22)))+((uintptr_t)((x46)<((x35)&((uintptr_t)3345173889ULL)))))+(x24); + x48 = (x47)+(x35); + x49 = (((uintptr_t)((x47)<(x24)))+((uintptr_t)((x48)<(x35))))+(x26); + x50 = (x49)+(x35); + x51 = (((uintptr_t)((x49)<(x26)))+((uintptr_t)((x50)<(x35))))+(x28); + x52 = (x51)+(x35); + x53 = (((uintptr_t)((x51)<(x28)))+((uintptr_t)((x52)<(x35))))+(x30); + x54 = (x53)+(x35); + x55 = (((uintptr_t)((x53)<(x30)))+((uintptr_t)((x54)<(x35))))+(x32); + x56 = (x55)+(x35); + x57 = ((((uintptr_t)((x55)<(x32)))+((uintptr_t)((x56)<(x35))))+(x34))+(x35); + x58 = x36; + x59 = x38; + x60 = x40; + x61 = x42; + x62 = x44; + x63 = x46; + x64 = x48; + x65 = x50; + x66 = x52; + x67 = x54; + x68 = x56; + x69 = x57; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x58, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x59, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x60, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x61, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x62, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x63, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x64, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x65, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x66, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)36ULL), x67, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x68, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)44ULL), x69, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_opp(uint32_t out1[12], const uint32_t arg1[12]) { + internal_fiat_p384_scalar_opp((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p384_scalar_from_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x35, x37, x34, x32, x39, x33, x30, x41, x31, x28, x43, x29, x26, x45, x27, x24, x47, x25, x22, x49, x23, x20, x51, x21, x18, x53, x19, x16, x55, x17, x14, x13, x12, x36, x38, x40, x42, x44, x46, x48, x50, x52, x54, x56, x57, x15, x1, x58, x59, x60, x61, x62, x63, x64, x65, x66, x67, x68, x69, x106, x108, x105, x103, x110, x104, x101, x112, x102, x99, x114, x100, x97, x116, x98, x95, x118, x96, x93, x120, x94, x91, x122, x92, x89, x124, x90, x87, x126, x88, x85, x84, x71, x129, x72, x107, x131, x73, x109, x133, x74, x111, x135, x75, x113, x137, x76, x115, x139, x77, x117, x141, x78, x119, x143, x79, x121, x145, x80, x123, x147, x81, x125, x149, x82, x127, x151, x83, x70, x128, x86, x2, x130, x132, x134, x136, x138, x140, x142, x144, x146, x148, x150, x152, x189, x191, x188, x186, x193, x187, x184, x195, x185, x182, x197, x183, x180, x199, x181, x178, x201, x179, x176, x203, x177, x174, x205, x175, x172, x207, x173, x170, x209, x171, x168, x167, x154, x212, x155, x190, x214, x156, x192, x216, x157, x194, x218, x158, x196, x220, x159, x198, x222, x160, x200, x224, x161, x202, x226, x162, x204, x228, x163, x206, x230, x164, x208, x232, x165, x210, x234, x166, x153, x211, x169, x3, x213, x215, x217, x219, x221, x223, x225, x227, x229, x231, x233, x235, x272, x274, x271, x269, x276, x270, x267, x278, x268, x265, x280, x266, x263, x282, x264, x261, x284, x262, x259, x286, x260, x257, x288, x258, x255, x290, x256, x253, x292, x254, x251, x250, x237, x295, x238, x273, x297, x239, x275, x299, x240, x277, x301, x241, x279, x303, x242, x281, x305, x243, x283, x307, x244, x285, x309, x245, x287, x311, x246, x289, x313, x247, x291, x315, x248, x293, x317, x249, x236, x294, x252, x4, x296, x298, x300, x302, x304, x306, x308, x310, x312, x314, x316, x318, x355, x357, x354, x352, x359, x353, x350, x361, x351, x348, x363, x349, x346, x365, x347, x344, x367, x345, x342, x369, x343, x340, x371, x341, x338, x373, x339, x336, x375, x337, x334, x333, x320, x378, x321, x356, x380, x322, x358, x382, x323, x360, x384, x324, x362, x386, x325, x364, x388, x326, x366, x390, x327, x368, x392, x328, x370, x394, x329, x372, x396, x330, x374, x398, x331, x376, x400, x332, x319, x377, x335, x5, x379, x381, x383, x385, x387, x389, x391, x393, x395, x397, x399, x401, x438, x440, x437, x435, x442, x436, x433, x444, x434, x431, x446, x432, x429, x448, x430, x427, x450, x428, x425, x452, x426, x423, x454, x424, x421, x456, x422, x419, x458, x420, x417, x416, x403, x461, x404, x439, x463, x405, x441, x465, x406, x443, x467, x407, x445, x469, x408, x447, x471, x409, x449, x473, x410, x451, x475, x411, x453, x477, x412, x455, x479, x413, x457, x481, x414, x459, x483, x415, x402, x460, x418, x6, x462, x464, x466, x468, x470, x472, x474, x476, x478, x480, x482, x484, x521, x523, x520, x518, x525, x519, x516, x527, x517, x514, x529, x515, x512, x531, x513, x510, x533, x511, x508, x535, x509, x506, x537, x507, x504, x539, x505, x502, x541, x503, x500, x499, x486, x544, x487, x522, x546, x488, x524, x548, x489, x526, x550, x490, x528, x552, x491, x530, x554, x492, x532, x556, x493, x534, x558, x494, x536, x560, x495, x538, x562, x496, x540, x564, x497, x542, x566, x498, x485, x543, x501, x7, x545, x547, x549, x551, x553, x555, x557, x559, x561, x563, x565, x567, x604, x606, x603, x601, x608, x602, x599, x610, x600, x597, x612, x598, x595, x614, x596, x593, x616, x594, x591, x618, x592, x589, x620, x590, x587, x622, x588, x585, x624, x586, x583, x582, x569, x627, x570, x605, x629, x571, x607, x631, x572, x609, x633, x573, x611, x635, x574, x613, x637, x575, x615, x639, x576, x617, x641, x577, x619, x643, x578, x621, x645, x579, x623, x647, x580, x625, x649, x581, x568, x626, x584, x8, x628, x630, x632, x634, x636, x638, x640, x642, x644, x646, x648, x650, x687, x689, x686, x684, x691, x685, x682, x693, x683, x680, x695, x681, x678, x697, x679, x676, x699, x677, x674, x701, x675, x672, x703, x673, x670, x705, x671, x668, x707, x669, x666, x665, x652, x710, x653, x688, x712, x654, x690, x714, x655, x692, x716, x656, x694, x718, x657, x696, x720, x658, x698, x722, x659, x700, x724, x660, x702, x726, x661, x704, x728, x662, x706, x730, x663, x708, x732, x664, x651, x709, x667, x9, x711, x713, x715, x717, x719, x721, x723, x725, x727, x729, x731, x733, x770, x772, x769, x767, x774, x768, x765, x776, x766, x763, x778, x764, x761, x780, x762, x759, x782, x760, x757, x784, x758, x755, x786, x756, x753, x788, x754, x751, x790, x752, x749, x748, x735, x793, x736, x771, x795, x737, x773, x797, x738, x775, x799, x739, x777, x801, x740, x779, x803, x741, x781, x805, x742, x783, x807, x743, x785, x809, x744, x787, x811, x745, x789, x813, x746, x791, x815, x747, x734, x792, x750, x10, x794, x796, x798, x800, x802, x804, x806, x808, x810, x812, x814, x816, x853, x855, x852, x850, x857, x851, x848, x859, x849, x846, x861, x847, x844, x863, x845, x842, x865, x843, x840, x867, x841, x838, x869, x839, x836, x871, x837, x834, x873, x835, x832, x831, x818, x876, x819, x854, x878, x820, x856, x880, x821, x858, x882, x822, x860, x884, x823, x862, x886, x824, x864, x888, x825, x866, x890, x826, x868, x892, x827, x870, x894, x828, x872, x896, x829, x874, x898, x830, x817, x875, x833, x11, x877, x879, x881, x883, x885, x887, x889, x891, x893, x895, x897, x899, x936, x938, x935, x933, x940, x934, x931, x942, x932, x929, x944, x930, x927, x946, x928, x925, x948, x926, x923, x950, x924, x921, x952, x922, x919, x954, x920, x917, x956, x918, x915, x914, x901, x959, x902, x937, x961, x903, x939, x963, x904, x941, x965, x905, x943, x967, x906, x945, x969, x907, x947, x971, x908, x949, x973, x909, x951, x975, x910, x953, x977, x911, x955, x979, x912, x957, x981, x913, x900, x958, x916, x985, x987, x989, x991, x993, x995, x997, x999, x1001, x1003, x983, x1005, x960, x1008, x984, x1009, x962, x1011, x986, x1012, x964, x1014, x988, x1015, x966, x1017, x990, x1018, x968, x1020, x992, x1021, x970, x1023, x994, x1024, x972, x1026, x996, x1027, x974, x1029, x998, x1030, x976, x1032, x1000, x1033, x978, x1035, x1002, x1036, x980, x1038, x1004, x1039, x1007, x982, x1041, x1006, x1042, x1010, x1013, x1016, x1019, x1022, x1025, x1028, x1031, x1034, x1037, x1040, x1043, x1044, x1045, x1046, x1047, x1048, x1049, x1050, x1051, x1052, x1053, x1054, x1055; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x9 = _br2_load((in0)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x10 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x11 = _br2_load((in0)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x12 = x0; + x13 = (x12)*((uintptr_t)3901742149ULL); + x14 = (x13)*((uintptr_t)4294967295ULL); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)4294967295ULL))>>64); + x16 = (x13)*((uintptr_t)4294967295ULL); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)4294967295ULL))>>64); + x18 = (x13)*((uintptr_t)4294967295ULL); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)4294967295ULL))>>64); + x20 = (x13)*((uintptr_t)4294967295ULL); + x21 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)4294967295ULL))>>64); + x22 = (x13)*((uintptr_t)4294967295ULL); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)4294967295ULL))>>64); + x24 = (x13)*((uintptr_t)4294967295ULL); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)4294967295ULL))>>64); + x26 = (x13)*((uintptr_t)3345173889ULL); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)3345173889ULL))>>64); + x28 = (x13)*((uintptr_t)4097256927ULL); + x29 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)4097256927ULL))>>64); + x30 = (x13)*((uintptr_t)1478102450ULL); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)1478102450ULL))>>64); + x32 = (x13)*((uintptr_t)1219536762ULL); + x33 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)1219536762ULL))>>64); + x34 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)3974895978ULL))>>64); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)3435473267ULL))>>64); + x36 = (x35)+((x13)*((uintptr_t)3974895978ULL)); + x37 = ((uintptr_t)((x36)<(x35)))+(x34); + x38 = (x37)+(x32); + x39 = (((uintptr_t)((x37)<(x34)))+((uintptr_t)((x38)<(x32))))+(x33); + x40 = (x39)+(x30); + x41 = (((uintptr_t)((x39)<(x33)))+((uintptr_t)((x40)<(x30))))+(x31); + x42 = (x41)+(x28); + x43 = (((uintptr_t)((x41)<(x31)))+((uintptr_t)((x42)<(x28))))+(x29); + x44 = (x43)+(x26); + x45 = (((uintptr_t)((x43)<(x29)))+((uintptr_t)((x44)<(x26))))+(x27); + x46 = (x45)+(x24); + x47 = (((uintptr_t)((x45)<(x27)))+((uintptr_t)((x46)<(x24))))+(x25); + x48 = (x47)+(x22); + x49 = (((uintptr_t)((x47)<(x25)))+((uintptr_t)((x48)<(x22))))+(x23); + x50 = (x49)+(x20); + x51 = (((uintptr_t)((x49)<(x23)))+((uintptr_t)((x50)<(x20))))+(x21); + x52 = (x51)+(x18); + x53 = (((uintptr_t)((x51)<(x21)))+((uintptr_t)((x52)<(x18))))+(x19); + x54 = (x53)+(x16); + x55 = (((uintptr_t)((x53)<(x19)))+((uintptr_t)((x54)<(x16))))+(x17); + x56 = (x55)+(x14); + x57 = ((uintptr_t)((x55)<(x17)))+((uintptr_t)((x56)<(x14))); + x58 = ((uintptr_t)(((x12)+((x13)*((uintptr_t)3435473267ULL)))<(x12)))+(x36); + x59 = ((uintptr_t)((x58)<(x36)))+(x38); + x60 = ((uintptr_t)((x59)<(x38)))+(x40); + x61 = ((uintptr_t)((x60)<(x40)))+(x42); + x62 = ((uintptr_t)((x61)<(x42)))+(x44); + x63 = ((uintptr_t)((x62)<(x44)))+(x46); + x64 = ((uintptr_t)((x63)<(x46)))+(x48); + x65 = ((uintptr_t)((x64)<(x48)))+(x50); + x66 = ((uintptr_t)((x65)<(x50)))+(x52); + x67 = ((uintptr_t)((x66)<(x52)))+(x54); + x68 = ((uintptr_t)((x67)<(x54)))+(x56); + x69 = ((uintptr_t)((x68)<(x56)))+((x57)+(x15)); + x70 = (uintptr_t)((x69)<((x57)+(x15))); + x71 = (x58)+(x1); + x72 = ((uintptr_t)((x71)<(x58)))+(x59); + x73 = ((uintptr_t)((x72)<(x59)))+(x60); + x74 = ((uintptr_t)((x73)<(x60)))+(x61); + x75 = ((uintptr_t)((x74)<(x61)))+(x62); + x76 = ((uintptr_t)((x75)<(x62)))+(x63); + x77 = ((uintptr_t)((x76)<(x63)))+(x64); + x78 = ((uintptr_t)((x77)<(x64)))+(x65); + x79 = ((uintptr_t)((x78)<(x65)))+(x66); + x80 = ((uintptr_t)((x79)<(x66)))+(x67); + x81 = ((uintptr_t)((x80)<(x67)))+(x68); + x82 = ((uintptr_t)((x81)<(x68)))+(x69); + x83 = (uintptr_t)((x82)<(x69)); + x84 = (x71)*((uintptr_t)3901742149ULL); + x85 = (x84)*((uintptr_t)4294967295ULL); + x86 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x84)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x84)*((uintptr_t)4294967295ULL))>>64); + x87 = (x84)*((uintptr_t)4294967295ULL); + x88 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x84)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x84)*((uintptr_t)4294967295ULL))>>64); + x89 = (x84)*((uintptr_t)4294967295ULL); + x90 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x84)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x84)*((uintptr_t)4294967295ULL))>>64); + x91 = (x84)*((uintptr_t)4294967295ULL); + x92 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x84)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x84)*((uintptr_t)4294967295ULL))>>64); + x93 = (x84)*((uintptr_t)4294967295ULL); + x94 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x84)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x84)*((uintptr_t)4294967295ULL))>>64); + x95 = (x84)*((uintptr_t)4294967295ULL); + x96 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x84)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x84)*((uintptr_t)4294967295ULL))>>64); + x97 = (x84)*((uintptr_t)3345173889ULL); + x98 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x84)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x84)*((uintptr_t)3345173889ULL))>>64); + x99 = (x84)*((uintptr_t)4097256927ULL); + x100 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x84)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x84)*((uintptr_t)4097256927ULL))>>64); + x101 = (x84)*((uintptr_t)1478102450ULL); + x102 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x84)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x84)*((uintptr_t)1478102450ULL))>>64); + x103 = (x84)*((uintptr_t)1219536762ULL); + x104 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x84)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x84)*((uintptr_t)1219536762ULL))>>64); + x105 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x84)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x84)*((uintptr_t)3974895978ULL))>>64); + x106 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x84)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x84)*((uintptr_t)3435473267ULL))>>64); + x107 = (x106)+((x84)*((uintptr_t)3974895978ULL)); + x108 = ((uintptr_t)((x107)<(x106)))+(x105); + x109 = (x108)+(x103); + x110 = (((uintptr_t)((x108)<(x105)))+((uintptr_t)((x109)<(x103))))+(x104); + x111 = (x110)+(x101); + x112 = (((uintptr_t)((x110)<(x104)))+((uintptr_t)((x111)<(x101))))+(x102); + x113 = (x112)+(x99); + x114 = (((uintptr_t)((x112)<(x102)))+((uintptr_t)((x113)<(x99))))+(x100); + x115 = (x114)+(x97); + x116 = (((uintptr_t)((x114)<(x100)))+((uintptr_t)((x115)<(x97))))+(x98); + x117 = (x116)+(x95); + x118 = (((uintptr_t)((x116)<(x98)))+((uintptr_t)((x117)<(x95))))+(x96); + x119 = (x118)+(x93); + x120 = (((uintptr_t)((x118)<(x96)))+((uintptr_t)((x119)<(x93))))+(x94); + x121 = (x120)+(x91); + x122 = (((uintptr_t)((x120)<(x94)))+((uintptr_t)((x121)<(x91))))+(x92); + x123 = (x122)+(x89); + x124 = (((uintptr_t)((x122)<(x92)))+((uintptr_t)((x123)<(x89))))+(x90); + x125 = (x124)+(x87); + x126 = (((uintptr_t)((x124)<(x90)))+((uintptr_t)((x125)<(x87))))+(x88); + x127 = (x126)+(x85); + x128 = ((uintptr_t)((x126)<(x88)))+((uintptr_t)((x127)<(x85))); + x129 = ((uintptr_t)(((x71)+((x84)*((uintptr_t)3435473267ULL)))<(x71)))+(x72); + x130 = (x129)+(x107); + x131 = (((uintptr_t)((x129)<(x72)))+((uintptr_t)((x130)<(x107))))+(x73); + x132 = (x131)+(x109); + x133 = (((uintptr_t)((x131)<(x73)))+((uintptr_t)((x132)<(x109))))+(x74); + x134 = (x133)+(x111); + x135 = (((uintptr_t)((x133)<(x74)))+((uintptr_t)((x134)<(x111))))+(x75); + x136 = (x135)+(x113); + x137 = (((uintptr_t)((x135)<(x75)))+((uintptr_t)((x136)<(x113))))+(x76); + x138 = (x137)+(x115); + x139 = (((uintptr_t)((x137)<(x76)))+((uintptr_t)((x138)<(x115))))+(x77); + x140 = (x139)+(x117); + x141 = (((uintptr_t)((x139)<(x77)))+((uintptr_t)((x140)<(x117))))+(x78); + x142 = (x141)+(x119); + x143 = (((uintptr_t)((x141)<(x78)))+((uintptr_t)((x142)<(x119))))+(x79); + x144 = (x143)+(x121); + x145 = (((uintptr_t)((x143)<(x79)))+((uintptr_t)((x144)<(x121))))+(x80); + x146 = (x145)+(x123); + x147 = (((uintptr_t)((x145)<(x80)))+((uintptr_t)((x146)<(x123))))+(x81); + x148 = (x147)+(x125); + x149 = (((uintptr_t)((x147)<(x81)))+((uintptr_t)((x148)<(x125))))+(x82); + x150 = (x149)+(x127); + x151 = (((uintptr_t)((x149)<(x82)))+((uintptr_t)((x150)<(x127))))+((x83)+(x70)); + x152 = (x151)+((x128)+(x86)); + x153 = ((uintptr_t)((x151)<((x83)+(x70))))+((uintptr_t)((x152)<((x128)+(x86)))); + x154 = (x130)+(x2); + x155 = ((uintptr_t)((x154)<(x130)))+(x132); + x156 = ((uintptr_t)((x155)<(x132)))+(x134); + x157 = ((uintptr_t)((x156)<(x134)))+(x136); + x158 = ((uintptr_t)((x157)<(x136)))+(x138); + x159 = ((uintptr_t)((x158)<(x138)))+(x140); + x160 = ((uintptr_t)((x159)<(x140)))+(x142); + x161 = ((uintptr_t)((x160)<(x142)))+(x144); + x162 = ((uintptr_t)((x161)<(x144)))+(x146); + x163 = ((uintptr_t)((x162)<(x146)))+(x148); + x164 = ((uintptr_t)((x163)<(x148)))+(x150); + x165 = ((uintptr_t)((x164)<(x150)))+(x152); + x166 = (uintptr_t)((x165)<(x152)); + x167 = (x154)*((uintptr_t)3901742149ULL); + x168 = (x167)*((uintptr_t)4294967295ULL); + x169 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x167)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x167)*((uintptr_t)4294967295ULL))>>64); + x170 = (x167)*((uintptr_t)4294967295ULL); + x171 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x167)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x167)*((uintptr_t)4294967295ULL))>>64); + x172 = (x167)*((uintptr_t)4294967295ULL); + x173 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x167)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x167)*((uintptr_t)4294967295ULL))>>64); + x174 = (x167)*((uintptr_t)4294967295ULL); + x175 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x167)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x167)*((uintptr_t)4294967295ULL))>>64); + x176 = (x167)*((uintptr_t)4294967295ULL); + x177 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x167)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x167)*((uintptr_t)4294967295ULL))>>64); + x178 = (x167)*((uintptr_t)4294967295ULL); + x179 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x167)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x167)*((uintptr_t)4294967295ULL))>>64); + x180 = (x167)*((uintptr_t)3345173889ULL); + x181 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x167)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x167)*((uintptr_t)3345173889ULL))>>64); + x182 = (x167)*((uintptr_t)4097256927ULL); + x183 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x167)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x167)*((uintptr_t)4097256927ULL))>>64); + x184 = (x167)*((uintptr_t)1478102450ULL); + x185 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x167)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x167)*((uintptr_t)1478102450ULL))>>64); + x186 = (x167)*((uintptr_t)1219536762ULL); + x187 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x167)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x167)*((uintptr_t)1219536762ULL))>>64); + x188 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x167)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x167)*((uintptr_t)3974895978ULL))>>64); + x189 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x167)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x167)*((uintptr_t)3435473267ULL))>>64); + x190 = (x189)+((x167)*((uintptr_t)3974895978ULL)); + x191 = ((uintptr_t)((x190)<(x189)))+(x188); + x192 = (x191)+(x186); + x193 = (((uintptr_t)((x191)<(x188)))+((uintptr_t)((x192)<(x186))))+(x187); + x194 = (x193)+(x184); + x195 = (((uintptr_t)((x193)<(x187)))+((uintptr_t)((x194)<(x184))))+(x185); + x196 = (x195)+(x182); + x197 = (((uintptr_t)((x195)<(x185)))+((uintptr_t)((x196)<(x182))))+(x183); + x198 = (x197)+(x180); + x199 = (((uintptr_t)((x197)<(x183)))+((uintptr_t)((x198)<(x180))))+(x181); + x200 = (x199)+(x178); + x201 = (((uintptr_t)((x199)<(x181)))+((uintptr_t)((x200)<(x178))))+(x179); + x202 = (x201)+(x176); + x203 = (((uintptr_t)((x201)<(x179)))+((uintptr_t)((x202)<(x176))))+(x177); + x204 = (x203)+(x174); + x205 = (((uintptr_t)((x203)<(x177)))+((uintptr_t)((x204)<(x174))))+(x175); + x206 = (x205)+(x172); + x207 = (((uintptr_t)((x205)<(x175)))+((uintptr_t)((x206)<(x172))))+(x173); + x208 = (x207)+(x170); + x209 = (((uintptr_t)((x207)<(x173)))+((uintptr_t)((x208)<(x170))))+(x171); + x210 = (x209)+(x168); + x211 = ((uintptr_t)((x209)<(x171)))+((uintptr_t)((x210)<(x168))); + x212 = ((uintptr_t)(((x154)+((x167)*((uintptr_t)3435473267ULL)))<(x154)))+(x155); + x213 = (x212)+(x190); + x214 = (((uintptr_t)((x212)<(x155)))+((uintptr_t)((x213)<(x190))))+(x156); + x215 = (x214)+(x192); + x216 = (((uintptr_t)((x214)<(x156)))+((uintptr_t)((x215)<(x192))))+(x157); + x217 = (x216)+(x194); + x218 = (((uintptr_t)((x216)<(x157)))+((uintptr_t)((x217)<(x194))))+(x158); + x219 = (x218)+(x196); + x220 = (((uintptr_t)((x218)<(x158)))+((uintptr_t)((x219)<(x196))))+(x159); + x221 = (x220)+(x198); + x222 = (((uintptr_t)((x220)<(x159)))+((uintptr_t)((x221)<(x198))))+(x160); + x223 = (x222)+(x200); + x224 = (((uintptr_t)((x222)<(x160)))+((uintptr_t)((x223)<(x200))))+(x161); + x225 = (x224)+(x202); + x226 = (((uintptr_t)((x224)<(x161)))+((uintptr_t)((x225)<(x202))))+(x162); + x227 = (x226)+(x204); + x228 = (((uintptr_t)((x226)<(x162)))+((uintptr_t)((x227)<(x204))))+(x163); + x229 = (x228)+(x206); + x230 = (((uintptr_t)((x228)<(x163)))+((uintptr_t)((x229)<(x206))))+(x164); + x231 = (x230)+(x208); + x232 = (((uintptr_t)((x230)<(x164)))+((uintptr_t)((x231)<(x208))))+(x165); + x233 = (x232)+(x210); + x234 = (((uintptr_t)((x232)<(x165)))+((uintptr_t)((x233)<(x210))))+((x166)+(x153)); + x235 = (x234)+((x211)+(x169)); + x236 = ((uintptr_t)((x234)<((x166)+(x153))))+((uintptr_t)((x235)<((x211)+(x169)))); + x237 = (x213)+(x3); + x238 = ((uintptr_t)((x237)<(x213)))+(x215); + x239 = ((uintptr_t)((x238)<(x215)))+(x217); + x240 = ((uintptr_t)((x239)<(x217)))+(x219); + x241 = ((uintptr_t)((x240)<(x219)))+(x221); + x242 = ((uintptr_t)((x241)<(x221)))+(x223); + x243 = ((uintptr_t)((x242)<(x223)))+(x225); + x244 = ((uintptr_t)((x243)<(x225)))+(x227); + x245 = ((uintptr_t)((x244)<(x227)))+(x229); + x246 = ((uintptr_t)((x245)<(x229)))+(x231); + x247 = ((uintptr_t)((x246)<(x231)))+(x233); + x248 = ((uintptr_t)((x247)<(x233)))+(x235); + x249 = (uintptr_t)((x248)<(x235)); + x250 = (x237)*((uintptr_t)3901742149ULL); + x251 = (x250)*((uintptr_t)4294967295ULL); + x252 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x250)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x250)*((uintptr_t)4294967295ULL))>>64); + x253 = (x250)*((uintptr_t)4294967295ULL); + x254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x250)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x250)*((uintptr_t)4294967295ULL))>>64); + x255 = (x250)*((uintptr_t)4294967295ULL); + x256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x250)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x250)*((uintptr_t)4294967295ULL))>>64); + x257 = (x250)*((uintptr_t)4294967295ULL); + x258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x250)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x250)*((uintptr_t)4294967295ULL))>>64); + x259 = (x250)*((uintptr_t)4294967295ULL); + x260 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x250)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x250)*((uintptr_t)4294967295ULL))>>64); + x261 = (x250)*((uintptr_t)4294967295ULL); + x262 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x250)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x250)*((uintptr_t)4294967295ULL))>>64); + x263 = (x250)*((uintptr_t)3345173889ULL); + x264 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x250)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x250)*((uintptr_t)3345173889ULL))>>64); + x265 = (x250)*((uintptr_t)4097256927ULL); + x266 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x250)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x250)*((uintptr_t)4097256927ULL))>>64); + x267 = (x250)*((uintptr_t)1478102450ULL); + x268 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x250)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x250)*((uintptr_t)1478102450ULL))>>64); + x269 = (x250)*((uintptr_t)1219536762ULL); + x270 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x250)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x250)*((uintptr_t)1219536762ULL))>>64); + x271 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x250)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x250)*((uintptr_t)3974895978ULL))>>64); + x272 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x250)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x250)*((uintptr_t)3435473267ULL))>>64); + x273 = (x272)+((x250)*((uintptr_t)3974895978ULL)); + x274 = ((uintptr_t)((x273)<(x272)))+(x271); + x275 = (x274)+(x269); + x276 = (((uintptr_t)((x274)<(x271)))+((uintptr_t)((x275)<(x269))))+(x270); + x277 = (x276)+(x267); + x278 = (((uintptr_t)((x276)<(x270)))+((uintptr_t)((x277)<(x267))))+(x268); + x279 = (x278)+(x265); + x280 = (((uintptr_t)((x278)<(x268)))+((uintptr_t)((x279)<(x265))))+(x266); + x281 = (x280)+(x263); + x282 = (((uintptr_t)((x280)<(x266)))+((uintptr_t)((x281)<(x263))))+(x264); + x283 = (x282)+(x261); + x284 = (((uintptr_t)((x282)<(x264)))+((uintptr_t)((x283)<(x261))))+(x262); + x285 = (x284)+(x259); + x286 = (((uintptr_t)((x284)<(x262)))+((uintptr_t)((x285)<(x259))))+(x260); + x287 = (x286)+(x257); + x288 = (((uintptr_t)((x286)<(x260)))+((uintptr_t)((x287)<(x257))))+(x258); + x289 = (x288)+(x255); + x290 = (((uintptr_t)((x288)<(x258)))+((uintptr_t)((x289)<(x255))))+(x256); + x291 = (x290)+(x253); + x292 = (((uintptr_t)((x290)<(x256)))+((uintptr_t)((x291)<(x253))))+(x254); + x293 = (x292)+(x251); + x294 = ((uintptr_t)((x292)<(x254)))+((uintptr_t)((x293)<(x251))); + x295 = ((uintptr_t)(((x237)+((x250)*((uintptr_t)3435473267ULL)))<(x237)))+(x238); + x296 = (x295)+(x273); + x297 = (((uintptr_t)((x295)<(x238)))+((uintptr_t)((x296)<(x273))))+(x239); + x298 = (x297)+(x275); + x299 = (((uintptr_t)((x297)<(x239)))+((uintptr_t)((x298)<(x275))))+(x240); + x300 = (x299)+(x277); + x301 = (((uintptr_t)((x299)<(x240)))+((uintptr_t)((x300)<(x277))))+(x241); + x302 = (x301)+(x279); + x303 = (((uintptr_t)((x301)<(x241)))+((uintptr_t)((x302)<(x279))))+(x242); + x304 = (x303)+(x281); + x305 = (((uintptr_t)((x303)<(x242)))+((uintptr_t)((x304)<(x281))))+(x243); + x306 = (x305)+(x283); + x307 = (((uintptr_t)((x305)<(x243)))+((uintptr_t)((x306)<(x283))))+(x244); + x308 = (x307)+(x285); + x309 = (((uintptr_t)((x307)<(x244)))+((uintptr_t)((x308)<(x285))))+(x245); + x310 = (x309)+(x287); + x311 = (((uintptr_t)((x309)<(x245)))+((uintptr_t)((x310)<(x287))))+(x246); + x312 = (x311)+(x289); + x313 = (((uintptr_t)((x311)<(x246)))+((uintptr_t)((x312)<(x289))))+(x247); + x314 = (x313)+(x291); + x315 = (((uintptr_t)((x313)<(x247)))+((uintptr_t)((x314)<(x291))))+(x248); + x316 = (x315)+(x293); + x317 = (((uintptr_t)((x315)<(x248)))+((uintptr_t)((x316)<(x293))))+((x249)+(x236)); + x318 = (x317)+((x294)+(x252)); + x319 = ((uintptr_t)((x317)<((x249)+(x236))))+((uintptr_t)((x318)<((x294)+(x252)))); + x320 = (x296)+(x4); + x321 = ((uintptr_t)((x320)<(x296)))+(x298); + x322 = ((uintptr_t)((x321)<(x298)))+(x300); + x323 = ((uintptr_t)((x322)<(x300)))+(x302); + x324 = ((uintptr_t)((x323)<(x302)))+(x304); + x325 = ((uintptr_t)((x324)<(x304)))+(x306); + x326 = ((uintptr_t)((x325)<(x306)))+(x308); + x327 = ((uintptr_t)((x326)<(x308)))+(x310); + x328 = ((uintptr_t)((x327)<(x310)))+(x312); + x329 = ((uintptr_t)((x328)<(x312)))+(x314); + x330 = ((uintptr_t)((x329)<(x314)))+(x316); + x331 = ((uintptr_t)((x330)<(x316)))+(x318); + x332 = (uintptr_t)((x331)<(x318)); + x333 = (x320)*((uintptr_t)3901742149ULL); + x334 = (x333)*((uintptr_t)4294967295ULL); + x335 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)4294967295ULL))>>64); + x336 = (x333)*((uintptr_t)4294967295ULL); + x337 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)4294967295ULL))>>64); + x338 = (x333)*((uintptr_t)4294967295ULL); + x339 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)4294967295ULL))>>64); + x340 = (x333)*((uintptr_t)4294967295ULL); + x341 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)4294967295ULL))>>64); + x342 = (x333)*((uintptr_t)4294967295ULL); + x343 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)4294967295ULL))>>64); + x344 = (x333)*((uintptr_t)4294967295ULL); + x345 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)4294967295ULL))>>64); + x346 = (x333)*((uintptr_t)3345173889ULL); + x347 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)3345173889ULL))>>64); + x348 = (x333)*((uintptr_t)4097256927ULL); + x349 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)4097256927ULL))>>64); + x350 = (x333)*((uintptr_t)1478102450ULL); + x351 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)1478102450ULL))>>64); + x352 = (x333)*((uintptr_t)1219536762ULL); + x353 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)1219536762ULL))>>64); + x354 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)3974895978ULL))>>64); + x355 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x333)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x333)*((uintptr_t)3435473267ULL))>>64); + x356 = (x355)+((x333)*((uintptr_t)3974895978ULL)); + x357 = ((uintptr_t)((x356)<(x355)))+(x354); + x358 = (x357)+(x352); + x359 = (((uintptr_t)((x357)<(x354)))+((uintptr_t)((x358)<(x352))))+(x353); + x360 = (x359)+(x350); + x361 = (((uintptr_t)((x359)<(x353)))+((uintptr_t)((x360)<(x350))))+(x351); + x362 = (x361)+(x348); + x363 = (((uintptr_t)((x361)<(x351)))+((uintptr_t)((x362)<(x348))))+(x349); + x364 = (x363)+(x346); + x365 = (((uintptr_t)((x363)<(x349)))+((uintptr_t)((x364)<(x346))))+(x347); + x366 = (x365)+(x344); + x367 = (((uintptr_t)((x365)<(x347)))+((uintptr_t)((x366)<(x344))))+(x345); + x368 = (x367)+(x342); + x369 = (((uintptr_t)((x367)<(x345)))+((uintptr_t)((x368)<(x342))))+(x343); + x370 = (x369)+(x340); + x371 = (((uintptr_t)((x369)<(x343)))+((uintptr_t)((x370)<(x340))))+(x341); + x372 = (x371)+(x338); + x373 = (((uintptr_t)((x371)<(x341)))+((uintptr_t)((x372)<(x338))))+(x339); + x374 = (x373)+(x336); + x375 = (((uintptr_t)((x373)<(x339)))+((uintptr_t)((x374)<(x336))))+(x337); + x376 = (x375)+(x334); + x377 = ((uintptr_t)((x375)<(x337)))+((uintptr_t)((x376)<(x334))); + x378 = ((uintptr_t)(((x320)+((x333)*((uintptr_t)3435473267ULL)))<(x320)))+(x321); + x379 = (x378)+(x356); + x380 = (((uintptr_t)((x378)<(x321)))+((uintptr_t)((x379)<(x356))))+(x322); + x381 = (x380)+(x358); + x382 = (((uintptr_t)((x380)<(x322)))+((uintptr_t)((x381)<(x358))))+(x323); + x383 = (x382)+(x360); + x384 = (((uintptr_t)((x382)<(x323)))+((uintptr_t)((x383)<(x360))))+(x324); + x385 = (x384)+(x362); + x386 = (((uintptr_t)((x384)<(x324)))+((uintptr_t)((x385)<(x362))))+(x325); + x387 = (x386)+(x364); + x388 = (((uintptr_t)((x386)<(x325)))+((uintptr_t)((x387)<(x364))))+(x326); + x389 = (x388)+(x366); + x390 = (((uintptr_t)((x388)<(x326)))+((uintptr_t)((x389)<(x366))))+(x327); + x391 = (x390)+(x368); + x392 = (((uintptr_t)((x390)<(x327)))+((uintptr_t)((x391)<(x368))))+(x328); + x393 = (x392)+(x370); + x394 = (((uintptr_t)((x392)<(x328)))+((uintptr_t)((x393)<(x370))))+(x329); + x395 = (x394)+(x372); + x396 = (((uintptr_t)((x394)<(x329)))+((uintptr_t)((x395)<(x372))))+(x330); + x397 = (x396)+(x374); + x398 = (((uintptr_t)((x396)<(x330)))+((uintptr_t)((x397)<(x374))))+(x331); + x399 = (x398)+(x376); + x400 = (((uintptr_t)((x398)<(x331)))+((uintptr_t)((x399)<(x376))))+((x332)+(x319)); + x401 = (x400)+((x377)+(x335)); + x402 = ((uintptr_t)((x400)<((x332)+(x319))))+((uintptr_t)((x401)<((x377)+(x335)))); + x403 = (x379)+(x5); + x404 = ((uintptr_t)((x403)<(x379)))+(x381); + x405 = ((uintptr_t)((x404)<(x381)))+(x383); + x406 = ((uintptr_t)((x405)<(x383)))+(x385); + x407 = ((uintptr_t)((x406)<(x385)))+(x387); + x408 = ((uintptr_t)((x407)<(x387)))+(x389); + x409 = ((uintptr_t)((x408)<(x389)))+(x391); + x410 = ((uintptr_t)((x409)<(x391)))+(x393); + x411 = ((uintptr_t)((x410)<(x393)))+(x395); + x412 = ((uintptr_t)((x411)<(x395)))+(x397); + x413 = ((uintptr_t)((x412)<(x397)))+(x399); + x414 = ((uintptr_t)((x413)<(x399)))+(x401); + x415 = (uintptr_t)((x414)<(x401)); + x416 = (x403)*((uintptr_t)3901742149ULL); + x417 = (x416)*((uintptr_t)4294967295ULL); + x418 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)4294967295ULL))>>64); + x419 = (x416)*((uintptr_t)4294967295ULL); + x420 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)4294967295ULL))>>64); + x421 = (x416)*((uintptr_t)4294967295ULL); + x422 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)4294967295ULL))>>64); + x423 = (x416)*((uintptr_t)4294967295ULL); + x424 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)4294967295ULL))>>64); + x425 = (x416)*((uintptr_t)4294967295ULL); + x426 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)4294967295ULL))>>64); + x427 = (x416)*((uintptr_t)4294967295ULL); + x428 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)4294967295ULL))>>64); + x429 = (x416)*((uintptr_t)3345173889ULL); + x430 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)3345173889ULL))>>64); + x431 = (x416)*((uintptr_t)4097256927ULL); + x432 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)4097256927ULL))>>64); + x433 = (x416)*((uintptr_t)1478102450ULL); + x434 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)1478102450ULL))>>64); + x435 = (x416)*((uintptr_t)1219536762ULL); + x436 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)1219536762ULL))>>64); + x437 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)3974895978ULL))>>64); + x438 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x416)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x416)*((uintptr_t)3435473267ULL))>>64); + x439 = (x438)+((x416)*((uintptr_t)3974895978ULL)); + x440 = ((uintptr_t)((x439)<(x438)))+(x437); + x441 = (x440)+(x435); + x442 = (((uintptr_t)((x440)<(x437)))+((uintptr_t)((x441)<(x435))))+(x436); + x443 = (x442)+(x433); + x444 = (((uintptr_t)((x442)<(x436)))+((uintptr_t)((x443)<(x433))))+(x434); + x445 = (x444)+(x431); + x446 = (((uintptr_t)((x444)<(x434)))+((uintptr_t)((x445)<(x431))))+(x432); + x447 = (x446)+(x429); + x448 = (((uintptr_t)((x446)<(x432)))+((uintptr_t)((x447)<(x429))))+(x430); + x449 = (x448)+(x427); + x450 = (((uintptr_t)((x448)<(x430)))+((uintptr_t)((x449)<(x427))))+(x428); + x451 = (x450)+(x425); + x452 = (((uintptr_t)((x450)<(x428)))+((uintptr_t)((x451)<(x425))))+(x426); + x453 = (x452)+(x423); + x454 = (((uintptr_t)((x452)<(x426)))+((uintptr_t)((x453)<(x423))))+(x424); + x455 = (x454)+(x421); + x456 = (((uintptr_t)((x454)<(x424)))+((uintptr_t)((x455)<(x421))))+(x422); + x457 = (x456)+(x419); + x458 = (((uintptr_t)((x456)<(x422)))+((uintptr_t)((x457)<(x419))))+(x420); + x459 = (x458)+(x417); + x460 = ((uintptr_t)((x458)<(x420)))+((uintptr_t)((x459)<(x417))); + x461 = ((uintptr_t)(((x403)+((x416)*((uintptr_t)3435473267ULL)))<(x403)))+(x404); + x462 = (x461)+(x439); + x463 = (((uintptr_t)((x461)<(x404)))+((uintptr_t)((x462)<(x439))))+(x405); + x464 = (x463)+(x441); + x465 = (((uintptr_t)((x463)<(x405)))+((uintptr_t)((x464)<(x441))))+(x406); + x466 = (x465)+(x443); + x467 = (((uintptr_t)((x465)<(x406)))+((uintptr_t)((x466)<(x443))))+(x407); + x468 = (x467)+(x445); + x469 = (((uintptr_t)((x467)<(x407)))+((uintptr_t)((x468)<(x445))))+(x408); + x470 = (x469)+(x447); + x471 = (((uintptr_t)((x469)<(x408)))+((uintptr_t)((x470)<(x447))))+(x409); + x472 = (x471)+(x449); + x473 = (((uintptr_t)((x471)<(x409)))+((uintptr_t)((x472)<(x449))))+(x410); + x474 = (x473)+(x451); + x475 = (((uintptr_t)((x473)<(x410)))+((uintptr_t)((x474)<(x451))))+(x411); + x476 = (x475)+(x453); + x477 = (((uintptr_t)((x475)<(x411)))+((uintptr_t)((x476)<(x453))))+(x412); + x478 = (x477)+(x455); + x479 = (((uintptr_t)((x477)<(x412)))+((uintptr_t)((x478)<(x455))))+(x413); + x480 = (x479)+(x457); + x481 = (((uintptr_t)((x479)<(x413)))+((uintptr_t)((x480)<(x457))))+(x414); + x482 = (x481)+(x459); + x483 = (((uintptr_t)((x481)<(x414)))+((uintptr_t)((x482)<(x459))))+((x415)+(x402)); + x484 = (x483)+((x460)+(x418)); + x485 = ((uintptr_t)((x483)<((x415)+(x402))))+((uintptr_t)((x484)<((x460)+(x418)))); + x486 = (x462)+(x6); + x487 = ((uintptr_t)((x486)<(x462)))+(x464); + x488 = ((uintptr_t)((x487)<(x464)))+(x466); + x489 = ((uintptr_t)((x488)<(x466)))+(x468); + x490 = ((uintptr_t)((x489)<(x468)))+(x470); + x491 = ((uintptr_t)((x490)<(x470)))+(x472); + x492 = ((uintptr_t)((x491)<(x472)))+(x474); + x493 = ((uintptr_t)((x492)<(x474)))+(x476); + x494 = ((uintptr_t)((x493)<(x476)))+(x478); + x495 = ((uintptr_t)((x494)<(x478)))+(x480); + x496 = ((uintptr_t)((x495)<(x480)))+(x482); + x497 = ((uintptr_t)((x496)<(x482)))+(x484); + x498 = (uintptr_t)((x497)<(x484)); + x499 = (x486)*((uintptr_t)3901742149ULL); + x500 = (x499)*((uintptr_t)4294967295ULL); + x501 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x499)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x499)*((uintptr_t)4294967295ULL))>>64); + x502 = (x499)*((uintptr_t)4294967295ULL); + x503 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x499)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x499)*((uintptr_t)4294967295ULL))>>64); + x504 = (x499)*((uintptr_t)4294967295ULL); + x505 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x499)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x499)*((uintptr_t)4294967295ULL))>>64); + x506 = (x499)*((uintptr_t)4294967295ULL); + x507 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x499)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x499)*((uintptr_t)4294967295ULL))>>64); + x508 = (x499)*((uintptr_t)4294967295ULL); + x509 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x499)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x499)*((uintptr_t)4294967295ULL))>>64); + x510 = (x499)*((uintptr_t)4294967295ULL); + x511 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x499)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x499)*((uintptr_t)4294967295ULL))>>64); + x512 = (x499)*((uintptr_t)3345173889ULL); + x513 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x499)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x499)*((uintptr_t)3345173889ULL))>>64); + x514 = (x499)*((uintptr_t)4097256927ULL); + x515 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x499)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x499)*((uintptr_t)4097256927ULL))>>64); + x516 = (x499)*((uintptr_t)1478102450ULL); + x517 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x499)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x499)*((uintptr_t)1478102450ULL))>>64); + x518 = (x499)*((uintptr_t)1219536762ULL); + x519 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x499)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x499)*((uintptr_t)1219536762ULL))>>64); + x520 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x499)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x499)*((uintptr_t)3974895978ULL))>>64); + x521 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x499)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x499)*((uintptr_t)3435473267ULL))>>64); + x522 = (x521)+((x499)*((uintptr_t)3974895978ULL)); + x523 = ((uintptr_t)((x522)<(x521)))+(x520); + x524 = (x523)+(x518); + x525 = (((uintptr_t)((x523)<(x520)))+((uintptr_t)((x524)<(x518))))+(x519); + x526 = (x525)+(x516); + x527 = (((uintptr_t)((x525)<(x519)))+((uintptr_t)((x526)<(x516))))+(x517); + x528 = (x527)+(x514); + x529 = (((uintptr_t)((x527)<(x517)))+((uintptr_t)((x528)<(x514))))+(x515); + x530 = (x529)+(x512); + x531 = (((uintptr_t)((x529)<(x515)))+((uintptr_t)((x530)<(x512))))+(x513); + x532 = (x531)+(x510); + x533 = (((uintptr_t)((x531)<(x513)))+((uintptr_t)((x532)<(x510))))+(x511); + x534 = (x533)+(x508); + x535 = (((uintptr_t)((x533)<(x511)))+((uintptr_t)((x534)<(x508))))+(x509); + x536 = (x535)+(x506); + x537 = (((uintptr_t)((x535)<(x509)))+((uintptr_t)((x536)<(x506))))+(x507); + x538 = (x537)+(x504); + x539 = (((uintptr_t)((x537)<(x507)))+((uintptr_t)((x538)<(x504))))+(x505); + x540 = (x539)+(x502); + x541 = (((uintptr_t)((x539)<(x505)))+((uintptr_t)((x540)<(x502))))+(x503); + x542 = (x541)+(x500); + x543 = ((uintptr_t)((x541)<(x503)))+((uintptr_t)((x542)<(x500))); + x544 = ((uintptr_t)(((x486)+((x499)*((uintptr_t)3435473267ULL)))<(x486)))+(x487); + x545 = (x544)+(x522); + x546 = (((uintptr_t)((x544)<(x487)))+((uintptr_t)((x545)<(x522))))+(x488); + x547 = (x546)+(x524); + x548 = (((uintptr_t)((x546)<(x488)))+((uintptr_t)((x547)<(x524))))+(x489); + x549 = (x548)+(x526); + x550 = (((uintptr_t)((x548)<(x489)))+((uintptr_t)((x549)<(x526))))+(x490); + x551 = (x550)+(x528); + x552 = (((uintptr_t)((x550)<(x490)))+((uintptr_t)((x551)<(x528))))+(x491); + x553 = (x552)+(x530); + x554 = (((uintptr_t)((x552)<(x491)))+((uintptr_t)((x553)<(x530))))+(x492); + x555 = (x554)+(x532); + x556 = (((uintptr_t)((x554)<(x492)))+((uintptr_t)((x555)<(x532))))+(x493); + x557 = (x556)+(x534); + x558 = (((uintptr_t)((x556)<(x493)))+((uintptr_t)((x557)<(x534))))+(x494); + x559 = (x558)+(x536); + x560 = (((uintptr_t)((x558)<(x494)))+((uintptr_t)((x559)<(x536))))+(x495); + x561 = (x560)+(x538); + x562 = (((uintptr_t)((x560)<(x495)))+((uintptr_t)((x561)<(x538))))+(x496); + x563 = (x562)+(x540); + x564 = (((uintptr_t)((x562)<(x496)))+((uintptr_t)((x563)<(x540))))+(x497); + x565 = (x564)+(x542); + x566 = (((uintptr_t)((x564)<(x497)))+((uintptr_t)((x565)<(x542))))+((x498)+(x485)); + x567 = (x566)+((x543)+(x501)); + x568 = ((uintptr_t)((x566)<((x498)+(x485))))+((uintptr_t)((x567)<((x543)+(x501)))); + x569 = (x545)+(x7); + x570 = ((uintptr_t)((x569)<(x545)))+(x547); + x571 = ((uintptr_t)((x570)<(x547)))+(x549); + x572 = ((uintptr_t)((x571)<(x549)))+(x551); + x573 = ((uintptr_t)((x572)<(x551)))+(x553); + x574 = ((uintptr_t)((x573)<(x553)))+(x555); + x575 = ((uintptr_t)((x574)<(x555)))+(x557); + x576 = ((uintptr_t)((x575)<(x557)))+(x559); + x577 = ((uintptr_t)((x576)<(x559)))+(x561); + x578 = ((uintptr_t)((x577)<(x561)))+(x563); + x579 = ((uintptr_t)((x578)<(x563)))+(x565); + x580 = ((uintptr_t)((x579)<(x565)))+(x567); + x581 = (uintptr_t)((x580)<(x567)); + x582 = (x569)*((uintptr_t)3901742149ULL); + x583 = (x582)*((uintptr_t)4294967295ULL); + x584 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x582)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x582)*((uintptr_t)4294967295ULL))>>64); + x585 = (x582)*((uintptr_t)4294967295ULL); + x586 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x582)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x582)*((uintptr_t)4294967295ULL))>>64); + x587 = (x582)*((uintptr_t)4294967295ULL); + x588 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x582)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x582)*((uintptr_t)4294967295ULL))>>64); + x589 = (x582)*((uintptr_t)4294967295ULL); + x590 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x582)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x582)*((uintptr_t)4294967295ULL))>>64); + x591 = (x582)*((uintptr_t)4294967295ULL); + x592 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x582)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x582)*((uintptr_t)4294967295ULL))>>64); + x593 = (x582)*((uintptr_t)4294967295ULL); + x594 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x582)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x582)*((uintptr_t)4294967295ULL))>>64); + x595 = (x582)*((uintptr_t)3345173889ULL); + x596 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x582)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x582)*((uintptr_t)3345173889ULL))>>64); + x597 = (x582)*((uintptr_t)4097256927ULL); + x598 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x582)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x582)*((uintptr_t)4097256927ULL))>>64); + x599 = (x582)*((uintptr_t)1478102450ULL); + x600 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x582)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x582)*((uintptr_t)1478102450ULL))>>64); + x601 = (x582)*((uintptr_t)1219536762ULL); + x602 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x582)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x582)*((uintptr_t)1219536762ULL))>>64); + x603 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x582)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x582)*((uintptr_t)3974895978ULL))>>64); + x604 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x582)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x582)*((uintptr_t)3435473267ULL))>>64); + x605 = (x604)+((x582)*((uintptr_t)3974895978ULL)); + x606 = ((uintptr_t)((x605)<(x604)))+(x603); + x607 = (x606)+(x601); + x608 = (((uintptr_t)((x606)<(x603)))+((uintptr_t)((x607)<(x601))))+(x602); + x609 = (x608)+(x599); + x610 = (((uintptr_t)((x608)<(x602)))+((uintptr_t)((x609)<(x599))))+(x600); + x611 = (x610)+(x597); + x612 = (((uintptr_t)((x610)<(x600)))+((uintptr_t)((x611)<(x597))))+(x598); + x613 = (x612)+(x595); + x614 = (((uintptr_t)((x612)<(x598)))+((uintptr_t)((x613)<(x595))))+(x596); + x615 = (x614)+(x593); + x616 = (((uintptr_t)((x614)<(x596)))+((uintptr_t)((x615)<(x593))))+(x594); + x617 = (x616)+(x591); + x618 = (((uintptr_t)((x616)<(x594)))+((uintptr_t)((x617)<(x591))))+(x592); + x619 = (x618)+(x589); + x620 = (((uintptr_t)((x618)<(x592)))+((uintptr_t)((x619)<(x589))))+(x590); + x621 = (x620)+(x587); + x622 = (((uintptr_t)((x620)<(x590)))+((uintptr_t)((x621)<(x587))))+(x588); + x623 = (x622)+(x585); + x624 = (((uintptr_t)((x622)<(x588)))+((uintptr_t)((x623)<(x585))))+(x586); + x625 = (x624)+(x583); + x626 = ((uintptr_t)((x624)<(x586)))+((uintptr_t)((x625)<(x583))); + x627 = ((uintptr_t)(((x569)+((x582)*((uintptr_t)3435473267ULL)))<(x569)))+(x570); + x628 = (x627)+(x605); + x629 = (((uintptr_t)((x627)<(x570)))+((uintptr_t)((x628)<(x605))))+(x571); + x630 = (x629)+(x607); + x631 = (((uintptr_t)((x629)<(x571)))+((uintptr_t)((x630)<(x607))))+(x572); + x632 = (x631)+(x609); + x633 = (((uintptr_t)((x631)<(x572)))+((uintptr_t)((x632)<(x609))))+(x573); + x634 = (x633)+(x611); + x635 = (((uintptr_t)((x633)<(x573)))+((uintptr_t)((x634)<(x611))))+(x574); + x636 = (x635)+(x613); + x637 = (((uintptr_t)((x635)<(x574)))+((uintptr_t)((x636)<(x613))))+(x575); + x638 = (x637)+(x615); + x639 = (((uintptr_t)((x637)<(x575)))+((uintptr_t)((x638)<(x615))))+(x576); + x640 = (x639)+(x617); + x641 = (((uintptr_t)((x639)<(x576)))+((uintptr_t)((x640)<(x617))))+(x577); + x642 = (x641)+(x619); + x643 = (((uintptr_t)((x641)<(x577)))+((uintptr_t)((x642)<(x619))))+(x578); + x644 = (x643)+(x621); + x645 = (((uintptr_t)((x643)<(x578)))+((uintptr_t)((x644)<(x621))))+(x579); + x646 = (x645)+(x623); + x647 = (((uintptr_t)((x645)<(x579)))+((uintptr_t)((x646)<(x623))))+(x580); + x648 = (x647)+(x625); + x649 = (((uintptr_t)((x647)<(x580)))+((uintptr_t)((x648)<(x625))))+((x581)+(x568)); + x650 = (x649)+((x626)+(x584)); + x651 = ((uintptr_t)((x649)<((x581)+(x568))))+((uintptr_t)((x650)<((x626)+(x584)))); + x652 = (x628)+(x8); + x653 = ((uintptr_t)((x652)<(x628)))+(x630); + x654 = ((uintptr_t)((x653)<(x630)))+(x632); + x655 = ((uintptr_t)((x654)<(x632)))+(x634); + x656 = ((uintptr_t)((x655)<(x634)))+(x636); + x657 = ((uintptr_t)((x656)<(x636)))+(x638); + x658 = ((uintptr_t)((x657)<(x638)))+(x640); + x659 = ((uintptr_t)((x658)<(x640)))+(x642); + x660 = ((uintptr_t)((x659)<(x642)))+(x644); + x661 = ((uintptr_t)((x660)<(x644)))+(x646); + x662 = ((uintptr_t)((x661)<(x646)))+(x648); + x663 = ((uintptr_t)((x662)<(x648)))+(x650); + x664 = (uintptr_t)((x663)<(x650)); + x665 = (x652)*((uintptr_t)3901742149ULL); + x666 = (x665)*((uintptr_t)4294967295ULL); + x667 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x665)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x665)*((uintptr_t)4294967295ULL))>>64); + x668 = (x665)*((uintptr_t)4294967295ULL); + x669 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x665)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x665)*((uintptr_t)4294967295ULL))>>64); + x670 = (x665)*((uintptr_t)4294967295ULL); + x671 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x665)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x665)*((uintptr_t)4294967295ULL))>>64); + x672 = (x665)*((uintptr_t)4294967295ULL); + x673 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x665)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x665)*((uintptr_t)4294967295ULL))>>64); + x674 = (x665)*((uintptr_t)4294967295ULL); + x675 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x665)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x665)*((uintptr_t)4294967295ULL))>>64); + x676 = (x665)*((uintptr_t)4294967295ULL); + x677 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x665)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x665)*((uintptr_t)4294967295ULL))>>64); + x678 = (x665)*((uintptr_t)3345173889ULL); + x679 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x665)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x665)*((uintptr_t)3345173889ULL))>>64); + x680 = (x665)*((uintptr_t)4097256927ULL); + x681 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x665)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x665)*((uintptr_t)4097256927ULL))>>64); + x682 = (x665)*((uintptr_t)1478102450ULL); + x683 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x665)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x665)*((uintptr_t)1478102450ULL))>>64); + x684 = (x665)*((uintptr_t)1219536762ULL); + x685 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x665)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x665)*((uintptr_t)1219536762ULL))>>64); + x686 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x665)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x665)*((uintptr_t)3974895978ULL))>>64); + x687 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x665)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x665)*((uintptr_t)3435473267ULL))>>64); + x688 = (x687)+((x665)*((uintptr_t)3974895978ULL)); + x689 = ((uintptr_t)((x688)<(x687)))+(x686); + x690 = (x689)+(x684); + x691 = (((uintptr_t)((x689)<(x686)))+((uintptr_t)((x690)<(x684))))+(x685); + x692 = (x691)+(x682); + x693 = (((uintptr_t)((x691)<(x685)))+((uintptr_t)((x692)<(x682))))+(x683); + x694 = (x693)+(x680); + x695 = (((uintptr_t)((x693)<(x683)))+((uintptr_t)((x694)<(x680))))+(x681); + x696 = (x695)+(x678); + x697 = (((uintptr_t)((x695)<(x681)))+((uintptr_t)((x696)<(x678))))+(x679); + x698 = (x697)+(x676); + x699 = (((uintptr_t)((x697)<(x679)))+((uintptr_t)((x698)<(x676))))+(x677); + x700 = (x699)+(x674); + x701 = (((uintptr_t)((x699)<(x677)))+((uintptr_t)((x700)<(x674))))+(x675); + x702 = (x701)+(x672); + x703 = (((uintptr_t)((x701)<(x675)))+((uintptr_t)((x702)<(x672))))+(x673); + x704 = (x703)+(x670); + x705 = (((uintptr_t)((x703)<(x673)))+((uintptr_t)((x704)<(x670))))+(x671); + x706 = (x705)+(x668); + x707 = (((uintptr_t)((x705)<(x671)))+((uintptr_t)((x706)<(x668))))+(x669); + x708 = (x707)+(x666); + x709 = ((uintptr_t)((x707)<(x669)))+((uintptr_t)((x708)<(x666))); + x710 = ((uintptr_t)(((x652)+((x665)*((uintptr_t)3435473267ULL)))<(x652)))+(x653); + x711 = (x710)+(x688); + x712 = (((uintptr_t)((x710)<(x653)))+((uintptr_t)((x711)<(x688))))+(x654); + x713 = (x712)+(x690); + x714 = (((uintptr_t)((x712)<(x654)))+((uintptr_t)((x713)<(x690))))+(x655); + x715 = (x714)+(x692); + x716 = (((uintptr_t)((x714)<(x655)))+((uintptr_t)((x715)<(x692))))+(x656); + x717 = (x716)+(x694); + x718 = (((uintptr_t)((x716)<(x656)))+((uintptr_t)((x717)<(x694))))+(x657); + x719 = (x718)+(x696); + x720 = (((uintptr_t)((x718)<(x657)))+((uintptr_t)((x719)<(x696))))+(x658); + x721 = (x720)+(x698); + x722 = (((uintptr_t)((x720)<(x658)))+((uintptr_t)((x721)<(x698))))+(x659); + x723 = (x722)+(x700); + x724 = (((uintptr_t)((x722)<(x659)))+((uintptr_t)((x723)<(x700))))+(x660); + x725 = (x724)+(x702); + x726 = (((uintptr_t)((x724)<(x660)))+((uintptr_t)((x725)<(x702))))+(x661); + x727 = (x726)+(x704); + x728 = (((uintptr_t)((x726)<(x661)))+((uintptr_t)((x727)<(x704))))+(x662); + x729 = (x728)+(x706); + x730 = (((uintptr_t)((x728)<(x662)))+((uintptr_t)((x729)<(x706))))+(x663); + x731 = (x730)+(x708); + x732 = (((uintptr_t)((x730)<(x663)))+((uintptr_t)((x731)<(x708))))+((x664)+(x651)); + x733 = (x732)+((x709)+(x667)); + x734 = ((uintptr_t)((x732)<((x664)+(x651))))+((uintptr_t)((x733)<((x709)+(x667)))); + x735 = (x711)+(x9); + x736 = ((uintptr_t)((x735)<(x711)))+(x713); + x737 = ((uintptr_t)((x736)<(x713)))+(x715); + x738 = ((uintptr_t)((x737)<(x715)))+(x717); + x739 = ((uintptr_t)((x738)<(x717)))+(x719); + x740 = ((uintptr_t)((x739)<(x719)))+(x721); + x741 = ((uintptr_t)((x740)<(x721)))+(x723); + x742 = ((uintptr_t)((x741)<(x723)))+(x725); + x743 = ((uintptr_t)((x742)<(x725)))+(x727); + x744 = ((uintptr_t)((x743)<(x727)))+(x729); + x745 = ((uintptr_t)((x744)<(x729)))+(x731); + x746 = ((uintptr_t)((x745)<(x731)))+(x733); + x747 = (uintptr_t)((x746)<(x733)); + x748 = (x735)*((uintptr_t)3901742149ULL); + x749 = (x748)*((uintptr_t)4294967295ULL); + x750 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x748)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x748)*((uintptr_t)4294967295ULL))>>64); + x751 = (x748)*((uintptr_t)4294967295ULL); + x752 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x748)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x748)*((uintptr_t)4294967295ULL))>>64); + x753 = (x748)*((uintptr_t)4294967295ULL); + x754 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x748)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x748)*((uintptr_t)4294967295ULL))>>64); + x755 = (x748)*((uintptr_t)4294967295ULL); + x756 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x748)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x748)*((uintptr_t)4294967295ULL))>>64); + x757 = (x748)*((uintptr_t)4294967295ULL); + x758 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x748)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x748)*((uintptr_t)4294967295ULL))>>64); + x759 = (x748)*((uintptr_t)4294967295ULL); + x760 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x748)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x748)*((uintptr_t)4294967295ULL))>>64); + x761 = (x748)*((uintptr_t)3345173889ULL); + x762 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x748)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x748)*((uintptr_t)3345173889ULL))>>64); + x763 = (x748)*((uintptr_t)4097256927ULL); + x764 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x748)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x748)*((uintptr_t)4097256927ULL))>>64); + x765 = (x748)*((uintptr_t)1478102450ULL); + x766 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x748)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x748)*((uintptr_t)1478102450ULL))>>64); + x767 = (x748)*((uintptr_t)1219536762ULL); + x768 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x748)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x748)*((uintptr_t)1219536762ULL))>>64); + x769 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x748)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x748)*((uintptr_t)3974895978ULL))>>64); + x770 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x748)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x748)*((uintptr_t)3435473267ULL))>>64); + x771 = (x770)+((x748)*((uintptr_t)3974895978ULL)); + x772 = ((uintptr_t)((x771)<(x770)))+(x769); + x773 = (x772)+(x767); + x774 = (((uintptr_t)((x772)<(x769)))+((uintptr_t)((x773)<(x767))))+(x768); + x775 = (x774)+(x765); + x776 = (((uintptr_t)((x774)<(x768)))+((uintptr_t)((x775)<(x765))))+(x766); + x777 = (x776)+(x763); + x778 = (((uintptr_t)((x776)<(x766)))+((uintptr_t)((x777)<(x763))))+(x764); + x779 = (x778)+(x761); + x780 = (((uintptr_t)((x778)<(x764)))+((uintptr_t)((x779)<(x761))))+(x762); + x781 = (x780)+(x759); + x782 = (((uintptr_t)((x780)<(x762)))+((uintptr_t)((x781)<(x759))))+(x760); + x783 = (x782)+(x757); + x784 = (((uintptr_t)((x782)<(x760)))+((uintptr_t)((x783)<(x757))))+(x758); + x785 = (x784)+(x755); + x786 = (((uintptr_t)((x784)<(x758)))+((uintptr_t)((x785)<(x755))))+(x756); + x787 = (x786)+(x753); + x788 = (((uintptr_t)((x786)<(x756)))+((uintptr_t)((x787)<(x753))))+(x754); + x789 = (x788)+(x751); + x790 = (((uintptr_t)((x788)<(x754)))+((uintptr_t)((x789)<(x751))))+(x752); + x791 = (x790)+(x749); + x792 = ((uintptr_t)((x790)<(x752)))+((uintptr_t)((x791)<(x749))); + x793 = ((uintptr_t)(((x735)+((x748)*((uintptr_t)3435473267ULL)))<(x735)))+(x736); + x794 = (x793)+(x771); + x795 = (((uintptr_t)((x793)<(x736)))+((uintptr_t)((x794)<(x771))))+(x737); + x796 = (x795)+(x773); + x797 = (((uintptr_t)((x795)<(x737)))+((uintptr_t)((x796)<(x773))))+(x738); + x798 = (x797)+(x775); + x799 = (((uintptr_t)((x797)<(x738)))+((uintptr_t)((x798)<(x775))))+(x739); + x800 = (x799)+(x777); + x801 = (((uintptr_t)((x799)<(x739)))+((uintptr_t)((x800)<(x777))))+(x740); + x802 = (x801)+(x779); + x803 = (((uintptr_t)((x801)<(x740)))+((uintptr_t)((x802)<(x779))))+(x741); + x804 = (x803)+(x781); + x805 = (((uintptr_t)((x803)<(x741)))+((uintptr_t)((x804)<(x781))))+(x742); + x806 = (x805)+(x783); + x807 = (((uintptr_t)((x805)<(x742)))+((uintptr_t)((x806)<(x783))))+(x743); + x808 = (x807)+(x785); + x809 = (((uintptr_t)((x807)<(x743)))+((uintptr_t)((x808)<(x785))))+(x744); + x810 = (x809)+(x787); + x811 = (((uintptr_t)((x809)<(x744)))+((uintptr_t)((x810)<(x787))))+(x745); + x812 = (x811)+(x789); + x813 = (((uintptr_t)((x811)<(x745)))+((uintptr_t)((x812)<(x789))))+(x746); + x814 = (x813)+(x791); + x815 = (((uintptr_t)((x813)<(x746)))+((uintptr_t)((x814)<(x791))))+((x747)+(x734)); + x816 = (x815)+((x792)+(x750)); + x817 = ((uintptr_t)((x815)<((x747)+(x734))))+((uintptr_t)((x816)<((x792)+(x750)))); + x818 = (x794)+(x10); + x819 = ((uintptr_t)((x818)<(x794)))+(x796); + x820 = ((uintptr_t)((x819)<(x796)))+(x798); + x821 = ((uintptr_t)((x820)<(x798)))+(x800); + x822 = ((uintptr_t)((x821)<(x800)))+(x802); + x823 = ((uintptr_t)((x822)<(x802)))+(x804); + x824 = ((uintptr_t)((x823)<(x804)))+(x806); + x825 = ((uintptr_t)((x824)<(x806)))+(x808); + x826 = ((uintptr_t)((x825)<(x808)))+(x810); + x827 = ((uintptr_t)((x826)<(x810)))+(x812); + x828 = ((uintptr_t)((x827)<(x812)))+(x814); + x829 = ((uintptr_t)((x828)<(x814)))+(x816); + x830 = (uintptr_t)((x829)<(x816)); + x831 = (x818)*((uintptr_t)3901742149ULL); + x832 = (x831)*((uintptr_t)4294967295ULL); + x833 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x831)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x831)*((uintptr_t)4294967295ULL))>>64); + x834 = (x831)*((uintptr_t)4294967295ULL); + x835 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x831)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x831)*((uintptr_t)4294967295ULL))>>64); + x836 = (x831)*((uintptr_t)4294967295ULL); + x837 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x831)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x831)*((uintptr_t)4294967295ULL))>>64); + x838 = (x831)*((uintptr_t)4294967295ULL); + x839 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x831)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x831)*((uintptr_t)4294967295ULL))>>64); + x840 = (x831)*((uintptr_t)4294967295ULL); + x841 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x831)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x831)*((uintptr_t)4294967295ULL))>>64); + x842 = (x831)*((uintptr_t)4294967295ULL); + x843 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x831)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x831)*((uintptr_t)4294967295ULL))>>64); + x844 = (x831)*((uintptr_t)3345173889ULL); + x845 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x831)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x831)*((uintptr_t)3345173889ULL))>>64); + x846 = (x831)*((uintptr_t)4097256927ULL); + x847 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x831)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x831)*((uintptr_t)4097256927ULL))>>64); + x848 = (x831)*((uintptr_t)1478102450ULL); + x849 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x831)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x831)*((uintptr_t)1478102450ULL))>>64); + x850 = (x831)*((uintptr_t)1219536762ULL); + x851 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x831)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x831)*((uintptr_t)1219536762ULL))>>64); + x852 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x831)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x831)*((uintptr_t)3974895978ULL))>>64); + x853 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x831)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x831)*((uintptr_t)3435473267ULL))>>64); + x854 = (x853)+((x831)*((uintptr_t)3974895978ULL)); + x855 = ((uintptr_t)((x854)<(x853)))+(x852); + x856 = (x855)+(x850); + x857 = (((uintptr_t)((x855)<(x852)))+((uintptr_t)((x856)<(x850))))+(x851); + x858 = (x857)+(x848); + x859 = (((uintptr_t)((x857)<(x851)))+((uintptr_t)((x858)<(x848))))+(x849); + x860 = (x859)+(x846); + x861 = (((uintptr_t)((x859)<(x849)))+((uintptr_t)((x860)<(x846))))+(x847); + x862 = (x861)+(x844); + x863 = (((uintptr_t)((x861)<(x847)))+((uintptr_t)((x862)<(x844))))+(x845); + x864 = (x863)+(x842); + x865 = (((uintptr_t)((x863)<(x845)))+((uintptr_t)((x864)<(x842))))+(x843); + x866 = (x865)+(x840); + x867 = (((uintptr_t)((x865)<(x843)))+((uintptr_t)((x866)<(x840))))+(x841); + x868 = (x867)+(x838); + x869 = (((uintptr_t)((x867)<(x841)))+((uintptr_t)((x868)<(x838))))+(x839); + x870 = (x869)+(x836); + x871 = (((uintptr_t)((x869)<(x839)))+((uintptr_t)((x870)<(x836))))+(x837); + x872 = (x871)+(x834); + x873 = (((uintptr_t)((x871)<(x837)))+((uintptr_t)((x872)<(x834))))+(x835); + x874 = (x873)+(x832); + x875 = ((uintptr_t)((x873)<(x835)))+((uintptr_t)((x874)<(x832))); + x876 = ((uintptr_t)(((x818)+((x831)*((uintptr_t)3435473267ULL)))<(x818)))+(x819); + x877 = (x876)+(x854); + x878 = (((uintptr_t)((x876)<(x819)))+((uintptr_t)((x877)<(x854))))+(x820); + x879 = (x878)+(x856); + x880 = (((uintptr_t)((x878)<(x820)))+((uintptr_t)((x879)<(x856))))+(x821); + x881 = (x880)+(x858); + x882 = (((uintptr_t)((x880)<(x821)))+((uintptr_t)((x881)<(x858))))+(x822); + x883 = (x882)+(x860); + x884 = (((uintptr_t)((x882)<(x822)))+((uintptr_t)((x883)<(x860))))+(x823); + x885 = (x884)+(x862); + x886 = (((uintptr_t)((x884)<(x823)))+((uintptr_t)((x885)<(x862))))+(x824); + x887 = (x886)+(x864); + x888 = (((uintptr_t)((x886)<(x824)))+((uintptr_t)((x887)<(x864))))+(x825); + x889 = (x888)+(x866); + x890 = (((uintptr_t)((x888)<(x825)))+((uintptr_t)((x889)<(x866))))+(x826); + x891 = (x890)+(x868); + x892 = (((uintptr_t)((x890)<(x826)))+((uintptr_t)((x891)<(x868))))+(x827); + x893 = (x892)+(x870); + x894 = (((uintptr_t)((x892)<(x827)))+((uintptr_t)((x893)<(x870))))+(x828); + x895 = (x894)+(x872); + x896 = (((uintptr_t)((x894)<(x828)))+((uintptr_t)((x895)<(x872))))+(x829); + x897 = (x896)+(x874); + x898 = (((uintptr_t)((x896)<(x829)))+((uintptr_t)((x897)<(x874))))+((x830)+(x817)); + x899 = (x898)+((x875)+(x833)); + x900 = ((uintptr_t)((x898)<((x830)+(x817))))+((uintptr_t)((x899)<((x875)+(x833)))); + x901 = (x877)+(x11); + x902 = ((uintptr_t)((x901)<(x877)))+(x879); + x903 = ((uintptr_t)((x902)<(x879)))+(x881); + x904 = ((uintptr_t)((x903)<(x881)))+(x883); + x905 = ((uintptr_t)((x904)<(x883)))+(x885); + x906 = ((uintptr_t)((x905)<(x885)))+(x887); + x907 = ((uintptr_t)((x906)<(x887)))+(x889); + x908 = ((uintptr_t)((x907)<(x889)))+(x891); + x909 = ((uintptr_t)((x908)<(x891)))+(x893); + x910 = ((uintptr_t)((x909)<(x893)))+(x895); + x911 = ((uintptr_t)((x910)<(x895)))+(x897); + x912 = ((uintptr_t)((x911)<(x897)))+(x899); + x913 = (uintptr_t)((x912)<(x899)); + x914 = (x901)*((uintptr_t)3901742149ULL); + x915 = (x914)*((uintptr_t)4294967295ULL); + x916 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x914)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x914)*((uintptr_t)4294967295ULL))>>64); + x917 = (x914)*((uintptr_t)4294967295ULL); + x918 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x914)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x914)*((uintptr_t)4294967295ULL))>>64); + x919 = (x914)*((uintptr_t)4294967295ULL); + x920 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x914)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x914)*((uintptr_t)4294967295ULL))>>64); + x921 = (x914)*((uintptr_t)4294967295ULL); + x922 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x914)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x914)*((uintptr_t)4294967295ULL))>>64); + x923 = (x914)*((uintptr_t)4294967295ULL); + x924 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x914)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x914)*((uintptr_t)4294967295ULL))>>64); + x925 = (x914)*((uintptr_t)4294967295ULL); + x926 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x914)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x914)*((uintptr_t)4294967295ULL))>>64); + x927 = (x914)*((uintptr_t)3345173889ULL); + x928 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x914)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x914)*((uintptr_t)3345173889ULL))>>64); + x929 = (x914)*((uintptr_t)4097256927ULL); + x930 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x914)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x914)*((uintptr_t)4097256927ULL))>>64); + x931 = (x914)*((uintptr_t)1478102450ULL); + x932 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x914)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x914)*((uintptr_t)1478102450ULL))>>64); + x933 = (x914)*((uintptr_t)1219536762ULL); + x934 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x914)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x914)*((uintptr_t)1219536762ULL))>>64); + x935 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x914)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x914)*((uintptr_t)3974895978ULL))>>64); + x936 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x914)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x914)*((uintptr_t)3435473267ULL))>>64); + x937 = (x936)+((x914)*((uintptr_t)3974895978ULL)); + x938 = ((uintptr_t)((x937)<(x936)))+(x935); + x939 = (x938)+(x933); + x940 = (((uintptr_t)((x938)<(x935)))+((uintptr_t)((x939)<(x933))))+(x934); + x941 = (x940)+(x931); + x942 = (((uintptr_t)((x940)<(x934)))+((uintptr_t)((x941)<(x931))))+(x932); + x943 = (x942)+(x929); + x944 = (((uintptr_t)((x942)<(x932)))+((uintptr_t)((x943)<(x929))))+(x930); + x945 = (x944)+(x927); + x946 = (((uintptr_t)((x944)<(x930)))+((uintptr_t)((x945)<(x927))))+(x928); + x947 = (x946)+(x925); + x948 = (((uintptr_t)((x946)<(x928)))+((uintptr_t)((x947)<(x925))))+(x926); + x949 = (x948)+(x923); + x950 = (((uintptr_t)((x948)<(x926)))+((uintptr_t)((x949)<(x923))))+(x924); + x951 = (x950)+(x921); + x952 = (((uintptr_t)((x950)<(x924)))+((uintptr_t)((x951)<(x921))))+(x922); + x953 = (x952)+(x919); + x954 = (((uintptr_t)((x952)<(x922)))+((uintptr_t)((x953)<(x919))))+(x920); + x955 = (x954)+(x917); + x956 = (((uintptr_t)((x954)<(x920)))+((uintptr_t)((x955)<(x917))))+(x918); + x957 = (x956)+(x915); + x958 = ((uintptr_t)((x956)<(x918)))+((uintptr_t)((x957)<(x915))); + x959 = ((uintptr_t)(((x901)+((x914)*((uintptr_t)3435473267ULL)))<(x901)))+(x902); + x960 = (x959)+(x937); + x961 = (((uintptr_t)((x959)<(x902)))+((uintptr_t)((x960)<(x937))))+(x903); + x962 = (x961)+(x939); + x963 = (((uintptr_t)((x961)<(x903)))+((uintptr_t)((x962)<(x939))))+(x904); + x964 = (x963)+(x941); + x965 = (((uintptr_t)((x963)<(x904)))+((uintptr_t)((x964)<(x941))))+(x905); + x966 = (x965)+(x943); + x967 = (((uintptr_t)((x965)<(x905)))+((uintptr_t)((x966)<(x943))))+(x906); + x968 = (x967)+(x945); + x969 = (((uintptr_t)((x967)<(x906)))+((uintptr_t)((x968)<(x945))))+(x907); + x970 = (x969)+(x947); + x971 = (((uintptr_t)((x969)<(x907)))+((uintptr_t)((x970)<(x947))))+(x908); + x972 = (x971)+(x949); + x973 = (((uintptr_t)((x971)<(x908)))+((uintptr_t)((x972)<(x949))))+(x909); + x974 = (x973)+(x951); + x975 = (((uintptr_t)((x973)<(x909)))+((uintptr_t)((x974)<(x951))))+(x910); + x976 = (x975)+(x953); + x977 = (((uintptr_t)((x975)<(x910)))+((uintptr_t)((x976)<(x953))))+(x911); + x978 = (x977)+(x955); + x979 = (((uintptr_t)((x977)<(x911)))+((uintptr_t)((x978)<(x955))))+(x912); + x980 = (x979)+(x957); + x981 = (((uintptr_t)((x979)<(x912)))+((uintptr_t)((x980)<(x957))))+((x913)+(x900)); + x982 = (x981)+((x958)+(x916)); + x983 = ((uintptr_t)((x981)<((x913)+(x900))))+((uintptr_t)((x982)<((x958)+(x916)))); + x984 = (x960)-((uintptr_t)3435473267ULL); + x985 = (x962)-((uintptr_t)3974895978ULL); + x986 = (x985)-((uintptr_t)((x960)<(x984))); + x987 = (x964)-((uintptr_t)1219536762ULL); + x988 = (x987)-(((uintptr_t)((x962)<(x985)))+((uintptr_t)((x985)<(x986)))); + x989 = (x966)-((uintptr_t)1478102450ULL); + x990 = (x989)-(((uintptr_t)((x964)<(x987)))+((uintptr_t)((x987)<(x988)))); + x991 = (x968)-((uintptr_t)4097256927ULL); + x992 = (x991)-(((uintptr_t)((x966)<(x989)))+((uintptr_t)((x989)<(x990)))); + x993 = (x970)-((uintptr_t)3345173889ULL); + x994 = (x993)-(((uintptr_t)((x968)<(x991)))+((uintptr_t)((x991)<(x992)))); + x995 = (x972)-((uintptr_t)4294967295ULL); + x996 = (x995)-(((uintptr_t)((x970)<(x993)))+((uintptr_t)((x993)<(x994)))); + x997 = (x974)-((uintptr_t)4294967295ULL); + x998 = (x997)-(((uintptr_t)((x972)<(x995)))+((uintptr_t)((x995)<(x996)))); + x999 = (x976)-((uintptr_t)4294967295ULL); + x1000 = (x999)-(((uintptr_t)((x974)<(x997)))+((uintptr_t)((x997)<(x998)))); + x1001 = (x978)-((uintptr_t)4294967295ULL); + x1002 = (x1001)-(((uintptr_t)((x976)<(x999)))+((uintptr_t)((x999)<(x1000)))); + x1003 = (x980)-((uintptr_t)4294967295ULL); + x1004 = (x1003)-(((uintptr_t)((x978)<(x1001)))+((uintptr_t)((x1001)<(x1002)))); + x1005 = (x982)-((uintptr_t)4294967295ULL); + x1006 = (x1005)-(((uintptr_t)((x980)<(x1003)))+((uintptr_t)((x1003)<(x1004)))); + x1007 = (uintptr_t)((x983)<((x983)-(((uintptr_t)((x982)<(x1005)))+((uintptr_t)((x1005)<(x1006)))))); + x1008 = ((uintptr_t)-1ULL)+((uintptr_t)((x1007)==((uintptr_t)0ULL))); + x1009 = (x1008)^((uintptr_t)4294967295ULL); + x1010 = ((x960)&(x1008))|((x984)&(x1009)); + x1011 = ((uintptr_t)-1ULL)+((uintptr_t)((x1007)==((uintptr_t)0ULL))); + x1012 = (x1011)^((uintptr_t)4294967295ULL); + x1013 = ((x962)&(x1011))|((x986)&(x1012)); + x1014 = ((uintptr_t)-1ULL)+((uintptr_t)((x1007)==((uintptr_t)0ULL))); + x1015 = (x1014)^((uintptr_t)4294967295ULL); + x1016 = ((x964)&(x1014))|((x988)&(x1015)); + x1017 = ((uintptr_t)-1ULL)+((uintptr_t)((x1007)==((uintptr_t)0ULL))); + x1018 = (x1017)^((uintptr_t)4294967295ULL); + x1019 = ((x966)&(x1017))|((x990)&(x1018)); + x1020 = ((uintptr_t)-1ULL)+((uintptr_t)((x1007)==((uintptr_t)0ULL))); + x1021 = (x1020)^((uintptr_t)4294967295ULL); + x1022 = ((x968)&(x1020))|((x992)&(x1021)); + x1023 = ((uintptr_t)-1ULL)+((uintptr_t)((x1007)==((uintptr_t)0ULL))); + x1024 = (x1023)^((uintptr_t)4294967295ULL); + x1025 = ((x970)&(x1023))|((x994)&(x1024)); + x1026 = ((uintptr_t)-1ULL)+((uintptr_t)((x1007)==((uintptr_t)0ULL))); + x1027 = (x1026)^((uintptr_t)4294967295ULL); + x1028 = ((x972)&(x1026))|((x996)&(x1027)); + x1029 = ((uintptr_t)-1ULL)+((uintptr_t)((x1007)==((uintptr_t)0ULL))); + x1030 = (x1029)^((uintptr_t)4294967295ULL); + x1031 = ((x974)&(x1029))|((x998)&(x1030)); + x1032 = ((uintptr_t)-1ULL)+((uintptr_t)((x1007)==((uintptr_t)0ULL))); + x1033 = (x1032)^((uintptr_t)4294967295ULL); + x1034 = ((x976)&(x1032))|((x1000)&(x1033)); + x1035 = ((uintptr_t)-1ULL)+((uintptr_t)((x1007)==((uintptr_t)0ULL))); + x1036 = (x1035)^((uintptr_t)4294967295ULL); + x1037 = ((x978)&(x1035))|((x1002)&(x1036)); + x1038 = ((uintptr_t)-1ULL)+((uintptr_t)((x1007)==((uintptr_t)0ULL))); + x1039 = (x1038)^((uintptr_t)4294967295ULL); + x1040 = ((x980)&(x1038))|((x1004)&(x1039)); + x1041 = ((uintptr_t)-1ULL)+((uintptr_t)((x1007)==((uintptr_t)0ULL))); + x1042 = (x1041)^((uintptr_t)4294967295ULL); + x1043 = ((x982)&(x1041))|((x1006)&(x1042)); + x1044 = x1010; + x1045 = x1013; + x1046 = x1016; + x1047 = x1019; + x1048 = x1022; + x1049 = x1025; + x1050 = x1028; + x1051 = x1031; + x1052 = x1034; + x1053 = x1037; + x1054 = x1040; + x1055 = x1043; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x1044, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1045, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1046, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x1047, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x1048, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x1049, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x1050, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x1051, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x1052, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)36ULL), x1053, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x1054, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)44ULL), x1055, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_from_montgomery(uint32_t out1[12], const uint32_t arg1[12]) { + internal_fiat_p384_scalar_from_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p384_scalar_to_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x0, x23, x46, x48, x44, x42, x50, x43, x40, x52, x41, x38, x54, x39, x36, x56, x37, x34, x58, x35, x32, x60, x33, x30, x62, x31, x28, x64, x29, x26, x66, x27, x24, x91, x93, x90, x88, x95, x89, x86, x97, x87, x84, x99, x85, x82, x101, x83, x80, x103, x81, x78, x105, x79, x76, x107, x77, x74, x109, x75, x72, x111, x73, x70, x69, x45, x114, x47, x92, x116, x49, x94, x118, x51, x96, x120, x53, x98, x122, x55, x100, x124, x57, x102, x126, x59, x104, x128, x61, x106, x130, x63, x108, x132, x65, x110, x134, x67, x112, x136, x68, x25, x113, x71, x160, x162, x159, x157, x164, x158, x155, x166, x156, x153, x168, x154, x151, x170, x152, x149, x172, x150, x147, x174, x148, x145, x176, x146, x143, x178, x144, x141, x180, x142, x139, x12, x115, x184, x117, x161, x186, x119, x163, x188, x121, x165, x190, x123, x167, x192, x125, x169, x194, x127, x171, x196, x129, x173, x198, x131, x175, x200, x133, x177, x202, x135, x179, x204, x137, x181, x229, x231, x228, x226, x233, x227, x224, x235, x225, x222, x237, x223, x220, x239, x221, x218, x241, x219, x216, x243, x217, x214, x245, x215, x212, x247, x213, x210, x249, x211, x208, x207, x183, x252, x185, x230, x254, x187, x232, x256, x189, x234, x258, x191, x236, x260, x193, x238, x262, x195, x240, x264, x197, x242, x266, x199, x244, x268, x201, x246, x270, x203, x248, x272, x205, x250, x274, x206, x138, x182, x140, x251, x209, x298, x300, x297, x295, x302, x296, x293, x304, x294, x291, x306, x292, x289, x308, x290, x287, x310, x288, x285, x312, x286, x283, x314, x284, x281, x316, x282, x279, x318, x280, x277, x13, x253, x322, x255, x299, x324, x257, x301, x326, x259, x303, x328, x261, x305, x330, x263, x307, x332, x265, x309, x334, x267, x311, x336, x269, x313, x338, x271, x315, x340, x273, x317, x342, x275, x319, x367, x369, x366, x364, x371, x365, x362, x373, x363, x360, x375, x361, x358, x377, x359, x356, x379, x357, x354, x381, x355, x352, x383, x353, x350, x385, x351, x348, x387, x349, x346, x345, x321, x390, x323, x368, x392, x325, x370, x394, x327, x372, x396, x329, x374, x398, x331, x376, x400, x333, x378, x402, x335, x380, x404, x337, x382, x406, x339, x384, x408, x341, x386, x410, x343, x388, x412, x344, x276, x320, x278, x389, x347, x436, x438, x435, x433, x440, x434, x431, x442, x432, x429, x444, x430, x427, x446, x428, x425, x448, x426, x423, x450, x424, x421, x452, x422, x419, x454, x420, x417, x456, x418, x415, x14, x391, x460, x393, x437, x462, x395, x439, x464, x397, x441, x466, x399, x443, x468, x401, x445, x470, x403, x447, x472, x405, x449, x474, x407, x451, x476, x409, x453, x478, x411, x455, x480, x413, x457, x505, x507, x504, x502, x509, x503, x500, x511, x501, x498, x513, x499, x496, x515, x497, x494, x517, x495, x492, x519, x493, x490, x521, x491, x488, x523, x489, x486, x525, x487, x484, x483, x459, x528, x461, x506, x530, x463, x508, x532, x465, x510, x534, x467, x512, x536, x469, x514, x538, x471, x516, x540, x473, x518, x542, x475, x520, x544, x477, x522, x546, x479, x524, x548, x481, x526, x550, x482, x414, x458, x416, x527, x485, x574, x576, x573, x571, x578, x572, x569, x580, x570, x567, x582, x568, x565, x584, x566, x563, x586, x564, x561, x588, x562, x559, x590, x560, x557, x592, x558, x555, x594, x556, x553, x15, x529, x598, x531, x575, x600, x533, x577, x602, x535, x579, x604, x537, x581, x606, x539, x583, x608, x541, x585, x610, x543, x587, x612, x545, x589, x614, x547, x591, x616, x549, x593, x618, x551, x595, x643, x645, x642, x640, x647, x641, x638, x649, x639, x636, x651, x637, x634, x653, x635, x632, x655, x633, x630, x657, x631, x628, x659, x629, x626, x661, x627, x624, x663, x625, x622, x621, x597, x666, x599, x644, x668, x601, x646, x670, x603, x648, x672, x605, x650, x674, x607, x652, x676, x609, x654, x678, x611, x656, x680, x613, x658, x682, x615, x660, x684, x617, x662, x686, x619, x664, x688, x620, x552, x596, x554, x665, x623, x712, x714, x711, x709, x716, x710, x707, x718, x708, x705, x720, x706, x703, x722, x704, x701, x724, x702, x699, x726, x700, x697, x728, x698, x695, x730, x696, x693, x732, x694, x691, x16, x667, x736, x669, x713, x738, x671, x715, x740, x673, x717, x742, x675, x719, x744, x677, x721, x746, x679, x723, x748, x681, x725, x750, x683, x727, x752, x685, x729, x754, x687, x731, x756, x689, x733, x781, x783, x780, x778, x785, x779, x776, x787, x777, x774, x789, x775, x772, x791, x773, x770, x793, x771, x768, x795, x769, x766, x797, x767, x764, x799, x765, x762, x801, x763, x760, x759, x735, x804, x737, x782, x806, x739, x784, x808, x741, x786, x810, x743, x788, x812, x745, x790, x814, x747, x792, x816, x749, x794, x818, x751, x796, x820, x753, x798, x822, x755, x800, x824, x757, x802, x826, x758, x690, x734, x692, x803, x761, x850, x852, x849, x847, x854, x848, x845, x856, x846, x843, x858, x844, x841, x860, x842, x839, x862, x840, x837, x864, x838, x835, x866, x836, x833, x868, x834, x831, x870, x832, x829, x17, x805, x874, x807, x851, x876, x809, x853, x878, x811, x855, x880, x813, x857, x882, x815, x859, x884, x817, x861, x886, x819, x863, x888, x821, x865, x890, x823, x867, x892, x825, x869, x894, x827, x871, x919, x921, x918, x916, x923, x917, x914, x925, x915, x912, x927, x913, x910, x929, x911, x908, x931, x909, x906, x933, x907, x904, x935, x905, x902, x937, x903, x900, x939, x901, x898, x897, x873, x942, x875, x920, x944, x877, x922, x946, x879, x924, x948, x881, x926, x950, x883, x928, x952, x885, x930, x954, x887, x932, x956, x889, x934, x958, x891, x936, x960, x893, x938, x962, x895, x940, x964, x896, x828, x872, x830, x941, x899, x988, x990, x987, x985, x992, x986, x983, x994, x984, x981, x996, x982, x979, x998, x980, x977, x1000, x978, x975, x1002, x976, x973, x1004, x974, x971, x1006, x972, x969, x1008, x970, x967, x18, x943, x1012, x945, x989, x1014, x947, x991, x1016, x949, x993, x1018, x951, x995, x1020, x953, x997, x1022, x955, x999, x1024, x957, x1001, x1026, x959, x1003, x1028, x961, x1005, x1030, x963, x1007, x1032, x965, x1009, x1057, x1059, x1056, x1054, x1061, x1055, x1052, x1063, x1053, x1050, x1065, x1051, x1048, x1067, x1049, x1046, x1069, x1047, x1044, x1071, x1045, x1042, x1073, x1043, x1040, x1075, x1041, x1038, x1077, x1039, x1036, x1035, x1011, x1080, x1013, x1058, x1082, x1015, x1060, x1084, x1017, x1062, x1086, x1019, x1064, x1088, x1021, x1066, x1090, x1023, x1068, x1092, x1025, x1070, x1094, x1027, x1072, x1096, x1029, x1074, x1098, x1031, x1076, x1100, x1033, x1078, x1102, x1034, x966, x1010, x968, x1079, x1037, x1126, x1128, x1125, x1123, x1130, x1124, x1121, x1132, x1122, x1119, x1134, x1120, x1117, x1136, x1118, x1115, x1138, x1116, x1113, x1140, x1114, x1111, x1142, x1112, x1109, x1144, x1110, x1107, x1146, x1108, x1105, x19, x1081, x1150, x1083, x1127, x1152, x1085, x1129, x1154, x1087, x1131, x1156, x1089, x1133, x1158, x1091, x1135, x1160, x1093, x1137, x1162, x1095, x1139, x1164, x1097, x1141, x1166, x1099, x1143, x1168, x1101, x1145, x1170, x1103, x1147, x1195, x1197, x1194, x1192, x1199, x1193, x1190, x1201, x1191, x1188, x1203, x1189, x1186, x1205, x1187, x1184, x1207, x1185, x1182, x1209, x1183, x1180, x1211, x1181, x1178, x1213, x1179, x1176, x1215, x1177, x1174, x1173, x1149, x1218, x1151, x1196, x1220, x1153, x1198, x1222, x1155, x1200, x1224, x1157, x1202, x1226, x1159, x1204, x1228, x1161, x1206, x1230, x1163, x1208, x1232, x1165, x1210, x1234, x1167, x1212, x1236, x1169, x1214, x1238, x1171, x1216, x1240, x1172, x1104, x1148, x1106, x1217, x1175, x1264, x1266, x1263, x1261, x1268, x1262, x1259, x1270, x1260, x1257, x1272, x1258, x1255, x1274, x1256, x1253, x1276, x1254, x1251, x1278, x1252, x1249, x1280, x1250, x1247, x1282, x1248, x1245, x1284, x1246, x1243, x20, x1219, x1288, x1221, x1265, x1290, x1223, x1267, x1292, x1225, x1269, x1294, x1227, x1271, x1296, x1229, x1273, x1298, x1231, x1275, x1300, x1233, x1277, x1302, x1235, x1279, x1304, x1237, x1281, x1306, x1239, x1283, x1308, x1241, x1285, x1333, x1335, x1332, x1330, x1337, x1331, x1328, x1339, x1329, x1326, x1341, x1327, x1324, x1343, x1325, x1322, x1345, x1323, x1320, x1347, x1321, x1318, x1349, x1319, x1316, x1351, x1317, x1314, x1353, x1315, x1312, x1311, x1287, x1356, x1289, x1334, x1358, x1291, x1336, x1360, x1293, x1338, x1362, x1295, x1340, x1364, x1297, x1342, x1366, x1299, x1344, x1368, x1301, x1346, x1370, x1303, x1348, x1372, x1305, x1350, x1374, x1307, x1352, x1376, x1309, x1354, x1378, x1310, x1242, x1286, x1244, x1355, x1313, x1402, x1404, x1401, x1399, x1406, x1400, x1397, x1408, x1398, x1395, x1410, x1396, x1393, x1412, x1394, x1391, x1414, x1392, x1389, x1416, x1390, x1387, x1418, x1388, x1385, x1420, x1386, x1383, x1422, x1384, x1381, x21, x1357, x1426, x1359, x1403, x1428, x1361, x1405, x1430, x1363, x1407, x1432, x1365, x1409, x1434, x1367, x1411, x1436, x1369, x1413, x1438, x1371, x1415, x1440, x1373, x1417, x1442, x1375, x1419, x1444, x1377, x1421, x1446, x1379, x1423, x1471, x1473, x1470, x1468, x1475, x1469, x1466, x1477, x1467, x1464, x1479, x1465, x1462, x1481, x1463, x1460, x1483, x1461, x1458, x1485, x1459, x1456, x1487, x1457, x1454, x1489, x1455, x1452, x1491, x1453, x1450, x1449, x1425, x1494, x1427, x1472, x1496, x1429, x1474, x1498, x1431, x1476, x1500, x1433, x1478, x1502, x1435, x1480, x1504, x1437, x1482, x1506, x1439, x1484, x1508, x1441, x1486, x1510, x1443, x1488, x1512, x1445, x1490, x1514, x1447, x1492, x1516, x1448, x1380, x1424, x1382, x1493, x1451, x1540, x1542, x1539, x1537, x1544, x1538, x1535, x1546, x1536, x1533, x1548, x1534, x1531, x1550, x1532, x1529, x1552, x1530, x1527, x1554, x1528, x1525, x1556, x1526, x1523, x1558, x1524, x1521, x1560, x1522, x1519, x22, x1495, x1564, x1497, x1541, x1566, x1499, x1543, x1568, x1501, x1545, x1570, x1503, x1547, x1572, x1505, x1549, x1574, x1507, x1551, x1576, x1509, x1553, x1578, x1511, x1555, x1580, x1513, x1557, x1582, x1515, x1559, x1584, x1517, x1561, x1609, x1611, x1608, x1606, x1613, x1607, x1604, x1615, x1605, x1602, x1617, x1603, x1600, x1619, x1601, x1598, x1621, x1599, x1596, x1623, x1597, x1594, x1625, x1595, x1592, x1627, x1593, x1590, x1629, x1591, x1588, x1587, x1563, x1632, x1565, x1610, x1634, x1567, x1612, x1636, x1569, x1614, x1638, x1571, x1616, x1640, x1573, x1618, x1642, x1575, x1620, x1644, x1577, x1622, x1646, x1579, x1624, x1648, x1581, x1626, x1650, x1583, x1628, x1652, x1585, x1630, x1654, x1586, x1518, x1562, x1520, x1631, x1589, x1658, x1660, x1662, x1664, x1666, x1668, x1670, x1672, x1674, x1676, x1656, x1678, x1633, x1681, x1657, x1682, x1635, x1684, x1659, x1685, x1637, x1687, x1661, x1688, x1639, x1690, x1663, x1691, x1641, x1693, x1665, x1694, x1643, x1696, x1667, x1697, x1645, x1699, x1669, x1700, x1647, x1702, x1671, x1703, x1649, x1705, x1673, x1706, x1651, x1708, x1675, x1709, x1653, x1711, x1677, x1712, x1680, x1655, x1714, x1679, x1715, x1683, x1686, x1689, x1692, x1695, x1698, x1701, x1704, x1707, x1710, x1713, x1716, x1717, x1718, x1719, x1720, x1721, x1722, x1723, x1724, x1725, x1726, x1727, x1728; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x9 = _br2_load((in0)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x10 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x11 = _br2_load((in0)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x12 = x1; + x13 = x2; + x14 = x3; + x15 = x4; + x16 = x5; + x17 = x6; + x18 = x7; + x19 = x8; + x20 = x9; + x21 = x10; + x22 = x11; + x23 = x0; + x24 = (x23)*((uintptr_t)210038273ULL); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)210038273ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)210038273ULL))>>64); + x26 = (x23)*((uintptr_t)725204769ULL); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)725204769ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)725204769ULL))>>64); + x28 = (x23)*((uintptr_t)1068522362ULL); + x29 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)1068522362ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)1068522362ULL))>>64); + x30 = (x23)*((uintptr_t)673605781ULL); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)673605781ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)673605781ULL))>>64); + x32 = (x23)*((uintptr_t)3557640471ULL); + x33 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)3557640471ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)3557640471ULL))>>64); + x34 = (x23)*((uintptr_t)1252728005ULL); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)1252728005ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)1252728005ULL))>>64); + x36 = (x23)*((uintptr_t)3158198330ULL); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)3158198330ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)3158198330ULL))>>64); + x38 = (x23)*((uintptr_t)4239927623ULL); + x39 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4239927623ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4239927623ULL))>>64); + x40 = (x23)*((uintptr_t)4282221029ULL); + x41 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4282221029ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4282221029ULL))>>64); + x42 = (x23)*((uintptr_t)3743065113ULL); + x43 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)3743065113ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)3743065113ULL))>>64); + x44 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)758225700ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)758225700ULL))>>64); + x45 = (x23)*((uintptr_t)431229353ULL); + x46 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)431229353ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)431229353ULL))>>64); + x47 = (x46)+((x23)*((uintptr_t)758225700ULL)); + x48 = ((uintptr_t)((x47)<(x46)))+(x44); + x49 = (x48)+(x42); + x50 = (((uintptr_t)((x48)<(x44)))+((uintptr_t)((x49)<(x42))))+(x43); + x51 = (x50)+(x40); + x52 = (((uintptr_t)((x50)<(x43)))+((uintptr_t)((x51)<(x40))))+(x41); + x53 = (x52)+(x38); + x54 = (((uintptr_t)((x52)<(x41)))+((uintptr_t)((x53)<(x38))))+(x39); + x55 = (x54)+(x36); + x56 = (((uintptr_t)((x54)<(x39)))+((uintptr_t)((x55)<(x36))))+(x37); + x57 = (x56)+(x34); + x58 = (((uintptr_t)((x56)<(x37)))+((uintptr_t)((x57)<(x34))))+(x35); + x59 = (x58)+(x32); + x60 = (((uintptr_t)((x58)<(x35)))+((uintptr_t)((x59)<(x32))))+(x33); + x61 = (x60)+(x30); + x62 = (((uintptr_t)((x60)<(x33)))+((uintptr_t)((x61)<(x30))))+(x31); + x63 = (x62)+(x28); + x64 = (((uintptr_t)((x62)<(x31)))+((uintptr_t)((x63)<(x28))))+(x29); + x65 = (x64)+(x26); + x66 = (((uintptr_t)((x64)<(x29)))+((uintptr_t)((x65)<(x26))))+(x27); + x67 = (x66)+(x24); + x68 = ((uintptr_t)((x66)<(x27)))+((uintptr_t)((x67)<(x24))); + x69 = (x45)*((uintptr_t)3901742149ULL); + x70 = (x69)*((uintptr_t)4294967295ULL); + x71 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x69)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x69)*((uintptr_t)4294967295ULL))>>64); + x72 = (x69)*((uintptr_t)4294967295ULL); + x73 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x69)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x69)*((uintptr_t)4294967295ULL))>>64); + x74 = (x69)*((uintptr_t)4294967295ULL); + x75 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x69)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x69)*((uintptr_t)4294967295ULL))>>64); + x76 = (x69)*((uintptr_t)4294967295ULL); + x77 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x69)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x69)*((uintptr_t)4294967295ULL))>>64); + x78 = (x69)*((uintptr_t)4294967295ULL); + x79 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x69)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x69)*((uintptr_t)4294967295ULL))>>64); + x80 = (x69)*((uintptr_t)4294967295ULL); + x81 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x69)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x69)*((uintptr_t)4294967295ULL))>>64); + x82 = (x69)*((uintptr_t)3345173889ULL); + x83 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x69)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x69)*((uintptr_t)3345173889ULL))>>64); + x84 = (x69)*((uintptr_t)4097256927ULL); + x85 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x69)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x69)*((uintptr_t)4097256927ULL))>>64); + x86 = (x69)*((uintptr_t)1478102450ULL); + x87 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x69)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x69)*((uintptr_t)1478102450ULL))>>64); + x88 = (x69)*((uintptr_t)1219536762ULL); + x89 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x69)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x69)*((uintptr_t)1219536762ULL))>>64); + x90 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x69)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x69)*((uintptr_t)3974895978ULL))>>64); + x91 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x69)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x69)*((uintptr_t)3435473267ULL))>>64); + x92 = (x91)+((x69)*((uintptr_t)3974895978ULL)); + x93 = ((uintptr_t)((x92)<(x91)))+(x90); + x94 = (x93)+(x88); + x95 = (((uintptr_t)((x93)<(x90)))+((uintptr_t)((x94)<(x88))))+(x89); + x96 = (x95)+(x86); + x97 = (((uintptr_t)((x95)<(x89)))+((uintptr_t)((x96)<(x86))))+(x87); + x98 = (x97)+(x84); + x99 = (((uintptr_t)((x97)<(x87)))+((uintptr_t)((x98)<(x84))))+(x85); + x100 = (x99)+(x82); + x101 = (((uintptr_t)((x99)<(x85)))+((uintptr_t)((x100)<(x82))))+(x83); + x102 = (x101)+(x80); + x103 = (((uintptr_t)((x101)<(x83)))+((uintptr_t)((x102)<(x80))))+(x81); + x104 = (x103)+(x78); + x105 = (((uintptr_t)((x103)<(x81)))+((uintptr_t)((x104)<(x78))))+(x79); + x106 = (x105)+(x76); + x107 = (((uintptr_t)((x105)<(x79)))+((uintptr_t)((x106)<(x76))))+(x77); + x108 = (x107)+(x74); + x109 = (((uintptr_t)((x107)<(x77)))+((uintptr_t)((x108)<(x74))))+(x75); + x110 = (x109)+(x72); + x111 = (((uintptr_t)((x109)<(x75)))+((uintptr_t)((x110)<(x72))))+(x73); + x112 = (x111)+(x70); + x113 = ((uintptr_t)((x111)<(x73)))+((uintptr_t)((x112)<(x70))); + x114 = ((uintptr_t)(((x45)+((x69)*((uintptr_t)3435473267ULL)))<(x45)))+(x47); + x115 = (x114)+(x92); + x116 = (((uintptr_t)((x114)<(x47)))+((uintptr_t)((x115)<(x92))))+(x49); + x117 = (x116)+(x94); + x118 = (((uintptr_t)((x116)<(x49)))+((uintptr_t)((x117)<(x94))))+(x51); + x119 = (x118)+(x96); + x120 = (((uintptr_t)((x118)<(x51)))+((uintptr_t)((x119)<(x96))))+(x53); + x121 = (x120)+(x98); + x122 = (((uintptr_t)((x120)<(x53)))+((uintptr_t)((x121)<(x98))))+(x55); + x123 = (x122)+(x100); + x124 = (((uintptr_t)((x122)<(x55)))+((uintptr_t)((x123)<(x100))))+(x57); + x125 = (x124)+(x102); + x126 = (((uintptr_t)((x124)<(x57)))+((uintptr_t)((x125)<(x102))))+(x59); + x127 = (x126)+(x104); + x128 = (((uintptr_t)((x126)<(x59)))+((uintptr_t)((x127)<(x104))))+(x61); + x129 = (x128)+(x106); + x130 = (((uintptr_t)((x128)<(x61)))+((uintptr_t)((x129)<(x106))))+(x63); + x131 = (x130)+(x108); + x132 = (((uintptr_t)((x130)<(x63)))+((uintptr_t)((x131)<(x108))))+(x65); + x133 = (x132)+(x110); + x134 = (((uintptr_t)((x132)<(x65)))+((uintptr_t)((x133)<(x110))))+(x67); + x135 = (x134)+(x112); + x136 = (((uintptr_t)((x134)<(x67)))+((uintptr_t)((x135)<(x112))))+((x68)+(x25)); + x137 = (x136)+((x113)+(x71)); + x138 = ((uintptr_t)((x136)<((x68)+(x25))))+((uintptr_t)((x137)<((x113)+(x71)))); + x139 = (x12)*((uintptr_t)210038273ULL); + x140 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)210038273ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)210038273ULL))>>64); + x141 = (x12)*((uintptr_t)725204769ULL); + x142 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)725204769ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)725204769ULL))>>64); + x143 = (x12)*((uintptr_t)1068522362ULL); + x144 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)1068522362ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)1068522362ULL))>>64); + x145 = (x12)*((uintptr_t)673605781ULL); + x146 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)673605781ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)673605781ULL))>>64); + x147 = (x12)*((uintptr_t)3557640471ULL); + x148 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)3557640471ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)3557640471ULL))>>64); + x149 = (x12)*((uintptr_t)1252728005ULL); + x150 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)1252728005ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)1252728005ULL))>>64); + x151 = (x12)*((uintptr_t)3158198330ULL); + x152 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)3158198330ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)3158198330ULL))>>64); + x153 = (x12)*((uintptr_t)4239927623ULL); + x154 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4239927623ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4239927623ULL))>>64); + x155 = (x12)*((uintptr_t)4282221029ULL); + x156 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4282221029ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4282221029ULL))>>64); + x157 = (x12)*((uintptr_t)3743065113ULL); + x158 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)3743065113ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)3743065113ULL))>>64); + x159 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)758225700ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)758225700ULL))>>64); + x160 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)431229353ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)431229353ULL))>>64); + x161 = (x160)+((x12)*((uintptr_t)758225700ULL)); + x162 = ((uintptr_t)((x161)<(x160)))+(x159); + x163 = (x162)+(x157); + x164 = (((uintptr_t)((x162)<(x159)))+((uintptr_t)((x163)<(x157))))+(x158); + x165 = (x164)+(x155); + x166 = (((uintptr_t)((x164)<(x158)))+((uintptr_t)((x165)<(x155))))+(x156); + x167 = (x166)+(x153); + x168 = (((uintptr_t)((x166)<(x156)))+((uintptr_t)((x167)<(x153))))+(x154); + x169 = (x168)+(x151); + x170 = (((uintptr_t)((x168)<(x154)))+((uintptr_t)((x169)<(x151))))+(x152); + x171 = (x170)+(x149); + x172 = (((uintptr_t)((x170)<(x152)))+((uintptr_t)((x171)<(x149))))+(x150); + x173 = (x172)+(x147); + x174 = (((uintptr_t)((x172)<(x150)))+((uintptr_t)((x173)<(x147))))+(x148); + x175 = (x174)+(x145); + x176 = (((uintptr_t)((x174)<(x148)))+((uintptr_t)((x175)<(x145))))+(x146); + x177 = (x176)+(x143); + x178 = (((uintptr_t)((x176)<(x146)))+((uintptr_t)((x177)<(x143))))+(x144); + x179 = (x178)+(x141); + x180 = (((uintptr_t)((x178)<(x144)))+((uintptr_t)((x179)<(x141))))+(x142); + x181 = (x180)+(x139); + x182 = ((uintptr_t)((x180)<(x142)))+((uintptr_t)((x181)<(x139))); + x183 = (x115)+((x12)*((uintptr_t)431229353ULL)); + x184 = ((uintptr_t)((x183)<(x115)))+(x117); + x185 = (x184)+(x161); + x186 = (((uintptr_t)((x184)<(x117)))+((uintptr_t)((x185)<(x161))))+(x119); + x187 = (x186)+(x163); + x188 = (((uintptr_t)((x186)<(x119)))+((uintptr_t)((x187)<(x163))))+(x121); + x189 = (x188)+(x165); + x190 = (((uintptr_t)((x188)<(x121)))+((uintptr_t)((x189)<(x165))))+(x123); + x191 = (x190)+(x167); + x192 = (((uintptr_t)((x190)<(x123)))+((uintptr_t)((x191)<(x167))))+(x125); + x193 = (x192)+(x169); + x194 = (((uintptr_t)((x192)<(x125)))+((uintptr_t)((x193)<(x169))))+(x127); + x195 = (x194)+(x171); + x196 = (((uintptr_t)((x194)<(x127)))+((uintptr_t)((x195)<(x171))))+(x129); + x197 = (x196)+(x173); + x198 = (((uintptr_t)((x196)<(x129)))+((uintptr_t)((x197)<(x173))))+(x131); + x199 = (x198)+(x175); + x200 = (((uintptr_t)((x198)<(x131)))+((uintptr_t)((x199)<(x175))))+(x133); + x201 = (x200)+(x177); + x202 = (((uintptr_t)((x200)<(x133)))+((uintptr_t)((x201)<(x177))))+(x135); + x203 = (x202)+(x179); + x204 = (((uintptr_t)((x202)<(x135)))+((uintptr_t)((x203)<(x179))))+(x137); + x205 = (x204)+(x181); + x206 = ((uintptr_t)((x204)<(x137)))+((uintptr_t)((x205)<(x181))); + x207 = (x183)*((uintptr_t)3901742149ULL); + x208 = (x207)*((uintptr_t)4294967295ULL); + x209 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x207)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x207)*((uintptr_t)4294967295ULL))>>64); + x210 = (x207)*((uintptr_t)4294967295ULL); + x211 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x207)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x207)*((uintptr_t)4294967295ULL))>>64); + x212 = (x207)*((uintptr_t)4294967295ULL); + x213 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x207)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x207)*((uintptr_t)4294967295ULL))>>64); + x214 = (x207)*((uintptr_t)4294967295ULL); + x215 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x207)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x207)*((uintptr_t)4294967295ULL))>>64); + x216 = (x207)*((uintptr_t)4294967295ULL); + x217 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x207)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x207)*((uintptr_t)4294967295ULL))>>64); + x218 = (x207)*((uintptr_t)4294967295ULL); + x219 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x207)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x207)*((uintptr_t)4294967295ULL))>>64); + x220 = (x207)*((uintptr_t)3345173889ULL); + x221 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x207)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x207)*((uintptr_t)3345173889ULL))>>64); + x222 = (x207)*((uintptr_t)4097256927ULL); + x223 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x207)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x207)*((uintptr_t)4097256927ULL))>>64); + x224 = (x207)*((uintptr_t)1478102450ULL); + x225 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x207)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x207)*((uintptr_t)1478102450ULL))>>64); + x226 = (x207)*((uintptr_t)1219536762ULL); + x227 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x207)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x207)*((uintptr_t)1219536762ULL))>>64); + x228 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x207)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x207)*((uintptr_t)3974895978ULL))>>64); + x229 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x207)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x207)*((uintptr_t)3435473267ULL))>>64); + x230 = (x229)+((x207)*((uintptr_t)3974895978ULL)); + x231 = ((uintptr_t)((x230)<(x229)))+(x228); + x232 = (x231)+(x226); + x233 = (((uintptr_t)((x231)<(x228)))+((uintptr_t)((x232)<(x226))))+(x227); + x234 = (x233)+(x224); + x235 = (((uintptr_t)((x233)<(x227)))+((uintptr_t)((x234)<(x224))))+(x225); + x236 = (x235)+(x222); + x237 = (((uintptr_t)((x235)<(x225)))+((uintptr_t)((x236)<(x222))))+(x223); + x238 = (x237)+(x220); + x239 = (((uintptr_t)((x237)<(x223)))+((uintptr_t)((x238)<(x220))))+(x221); + x240 = (x239)+(x218); + x241 = (((uintptr_t)((x239)<(x221)))+((uintptr_t)((x240)<(x218))))+(x219); + x242 = (x241)+(x216); + x243 = (((uintptr_t)((x241)<(x219)))+((uintptr_t)((x242)<(x216))))+(x217); + x244 = (x243)+(x214); + x245 = (((uintptr_t)((x243)<(x217)))+((uintptr_t)((x244)<(x214))))+(x215); + x246 = (x245)+(x212); + x247 = (((uintptr_t)((x245)<(x215)))+((uintptr_t)((x246)<(x212))))+(x213); + x248 = (x247)+(x210); + x249 = (((uintptr_t)((x247)<(x213)))+((uintptr_t)((x248)<(x210))))+(x211); + x250 = (x249)+(x208); + x251 = ((uintptr_t)((x249)<(x211)))+((uintptr_t)((x250)<(x208))); + x252 = ((uintptr_t)(((x183)+((x207)*((uintptr_t)3435473267ULL)))<(x183)))+(x185); + x253 = (x252)+(x230); + x254 = (((uintptr_t)((x252)<(x185)))+((uintptr_t)((x253)<(x230))))+(x187); + x255 = (x254)+(x232); + x256 = (((uintptr_t)((x254)<(x187)))+((uintptr_t)((x255)<(x232))))+(x189); + x257 = (x256)+(x234); + x258 = (((uintptr_t)((x256)<(x189)))+((uintptr_t)((x257)<(x234))))+(x191); + x259 = (x258)+(x236); + x260 = (((uintptr_t)((x258)<(x191)))+((uintptr_t)((x259)<(x236))))+(x193); + x261 = (x260)+(x238); + x262 = (((uintptr_t)((x260)<(x193)))+((uintptr_t)((x261)<(x238))))+(x195); + x263 = (x262)+(x240); + x264 = (((uintptr_t)((x262)<(x195)))+((uintptr_t)((x263)<(x240))))+(x197); + x265 = (x264)+(x242); + x266 = (((uintptr_t)((x264)<(x197)))+((uintptr_t)((x265)<(x242))))+(x199); + x267 = (x266)+(x244); + x268 = (((uintptr_t)((x266)<(x199)))+((uintptr_t)((x267)<(x244))))+(x201); + x269 = (x268)+(x246); + x270 = (((uintptr_t)((x268)<(x201)))+((uintptr_t)((x269)<(x246))))+(x203); + x271 = (x270)+(x248); + x272 = (((uintptr_t)((x270)<(x203)))+((uintptr_t)((x271)<(x248))))+(x205); + x273 = (x272)+(x250); + x274 = (((uintptr_t)((x272)<(x205)))+((uintptr_t)((x273)<(x250))))+(((x206)+(x138))+((x182)+(x140))); + x275 = (x274)+((x251)+(x209)); + x276 = ((uintptr_t)((x274)<(((x206)+(x138))+((x182)+(x140)))))+((uintptr_t)((x275)<((x251)+(x209)))); + x277 = (x13)*((uintptr_t)210038273ULL); + x278 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)210038273ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)210038273ULL))>>64); + x279 = (x13)*((uintptr_t)725204769ULL); + x280 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)725204769ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)725204769ULL))>>64); + x281 = (x13)*((uintptr_t)1068522362ULL); + x282 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)1068522362ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)1068522362ULL))>>64); + x283 = (x13)*((uintptr_t)673605781ULL); + x284 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)673605781ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)673605781ULL))>>64); + x285 = (x13)*((uintptr_t)3557640471ULL); + x286 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)3557640471ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)3557640471ULL))>>64); + x287 = (x13)*((uintptr_t)1252728005ULL); + x288 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)1252728005ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)1252728005ULL))>>64); + x289 = (x13)*((uintptr_t)3158198330ULL); + x290 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)3158198330ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)3158198330ULL))>>64); + x291 = (x13)*((uintptr_t)4239927623ULL); + x292 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)4239927623ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)4239927623ULL))>>64); + x293 = (x13)*((uintptr_t)4282221029ULL); + x294 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)4282221029ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)4282221029ULL))>>64); + x295 = (x13)*((uintptr_t)3743065113ULL); + x296 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)3743065113ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)3743065113ULL))>>64); + x297 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)758225700ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)758225700ULL))>>64); + x298 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)431229353ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)431229353ULL))>>64); + x299 = (x298)+((x13)*((uintptr_t)758225700ULL)); + x300 = ((uintptr_t)((x299)<(x298)))+(x297); + x301 = (x300)+(x295); + x302 = (((uintptr_t)((x300)<(x297)))+((uintptr_t)((x301)<(x295))))+(x296); + x303 = (x302)+(x293); + x304 = (((uintptr_t)((x302)<(x296)))+((uintptr_t)((x303)<(x293))))+(x294); + x305 = (x304)+(x291); + x306 = (((uintptr_t)((x304)<(x294)))+((uintptr_t)((x305)<(x291))))+(x292); + x307 = (x306)+(x289); + x308 = (((uintptr_t)((x306)<(x292)))+((uintptr_t)((x307)<(x289))))+(x290); + x309 = (x308)+(x287); + x310 = (((uintptr_t)((x308)<(x290)))+((uintptr_t)((x309)<(x287))))+(x288); + x311 = (x310)+(x285); + x312 = (((uintptr_t)((x310)<(x288)))+((uintptr_t)((x311)<(x285))))+(x286); + x313 = (x312)+(x283); + x314 = (((uintptr_t)((x312)<(x286)))+((uintptr_t)((x313)<(x283))))+(x284); + x315 = (x314)+(x281); + x316 = (((uintptr_t)((x314)<(x284)))+((uintptr_t)((x315)<(x281))))+(x282); + x317 = (x316)+(x279); + x318 = (((uintptr_t)((x316)<(x282)))+((uintptr_t)((x317)<(x279))))+(x280); + x319 = (x318)+(x277); + x320 = ((uintptr_t)((x318)<(x280)))+((uintptr_t)((x319)<(x277))); + x321 = (x253)+((x13)*((uintptr_t)431229353ULL)); + x322 = ((uintptr_t)((x321)<(x253)))+(x255); + x323 = (x322)+(x299); + x324 = (((uintptr_t)((x322)<(x255)))+((uintptr_t)((x323)<(x299))))+(x257); + x325 = (x324)+(x301); + x326 = (((uintptr_t)((x324)<(x257)))+((uintptr_t)((x325)<(x301))))+(x259); + x327 = (x326)+(x303); + x328 = (((uintptr_t)((x326)<(x259)))+((uintptr_t)((x327)<(x303))))+(x261); + x329 = (x328)+(x305); + x330 = (((uintptr_t)((x328)<(x261)))+((uintptr_t)((x329)<(x305))))+(x263); + x331 = (x330)+(x307); + x332 = (((uintptr_t)((x330)<(x263)))+((uintptr_t)((x331)<(x307))))+(x265); + x333 = (x332)+(x309); + x334 = (((uintptr_t)((x332)<(x265)))+((uintptr_t)((x333)<(x309))))+(x267); + x335 = (x334)+(x311); + x336 = (((uintptr_t)((x334)<(x267)))+((uintptr_t)((x335)<(x311))))+(x269); + x337 = (x336)+(x313); + x338 = (((uintptr_t)((x336)<(x269)))+((uintptr_t)((x337)<(x313))))+(x271); + x339 = (x338)+(x315); + x340 = (((uintptr_t)((x338)<(x271)))+((uintptr_t)((x339)<(x315))))+(x273); + x341 = (x340)+(x317); + x342 = (((uintptr_t)((x340)<(x273)))+((uintptr_t)((x341)<(x317))))+(x275); + x343 = (x342)+(x319); + x344 = ((uintptr_t)((x342)<(x275)))+((uintptr_t)((x343)<(x319))); + x345 = (x321)*((uintptr_t)3901742149ULL); + x346 = (x345)*((uintptr_t)4294967295ULL); + x347 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x345)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x345)*((uintptr_t)4294967295ULL))>>64); + x348 = (x345)*((uintptr_t)4294967295ULL); + x349 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x345)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x345)*((uintptr_t)4294967295ULL))>>64); + x350 = (x345)*((uintptr_t)4294967295ULL); + x351 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x345)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x345)*((uintptr_t)4294967295ULL))>>64); + x352 = (x345)*((uintptr_t)4294967295ULL); + x353 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x345)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x345)*((uintptr_t)4294967295ULL))>>64); + x354 = (x345)*((uintptr_t)4294967295ULL); + x355 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x345)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x345)*((uintptr_t)4294967295ULL))>>64); + x356 = (x345)*((uintptr_t)4294967295ULL); + x357 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x345)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x345)*((uintptr_t)4294967295ULL))>>64); + x358 = (x345)*((uintptr_t)3345173889ULL); + x359 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x345)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x345)*((uintptr_t)3345173889ULL))>>64); + x360 = (x345)*((uintptr_t)4097256927ULL); + x361 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x345)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x345)*((uintptr_t)4097256927ULL))>>64); + x362 = (x345)*((uintptr_t)1478102450ULL); + x363 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x345)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x345)*((uintptr_t)1478102450ULL))>>64); + x364 = (x345)*((uintptr_t)1219536762ULL); + x365 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x345)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x345)*((uintptr_t)1219536762ULL))>>64); + x366 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x345)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x345)*((uintptr_t)3974895978ULL))>>64); + x367 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x345)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x345)*((uintptr_t)3435473267ULL))>>64); + x368 = (x367)+((x345)*((uintptr_t)3974895978ULL)); + x369 = ((uintptr_t)((x368)<(x367)))+(x366); + x370 = (x369)+(x364); + x371 = (((uintptr_t)((x369)<(x366)))+((uintptr_t)((x370)<(x364))))+(x365); + x372 = (x371)+(x362); + x373 = (((uintptr_t)((x371)<(x365)))+((uintptr_t)((x372)<(x362))))+(x363); + x374 = (x373)+(x360); + x375 = (((uintptr_t)((x373)<(x363)))+((uintptr_t)((x374)<(x360))))+(x361); + x376 = (x375)+(x358); + x377 = (((uintptr_t)((x375)<(x361)))+((uintptr_t)((x376)<(x358))))+(x359); + x378 = (x377)+(x356); + x379 = (((uintptr_t)((x377)<(x359)))+((uintptr_t)((x378)<(x356))))+(x357); + x380 = (x379)+(x354); + x381 = (((uintptr_t)((x379)<(x357)))+((uintptr_t)((x380)<(x354))))+(x355); + x382 = (x381)+(x352); + x383 = (((uintptr_t)((x381)<(x355)))+((uintptr_t)((x382)<(x352))))+(x353); + x384 = (x383)+(x350); + x385 = (((uintptr_t)((x383)<(x353)))+((uintptr_t)((x384)<(x350))))+(x351); + x386 = (x385)+(x348); + x387 = (((uintptr_t)((x385)<(x351)))+((uintptr_t)((x386)<(x348))))+(x349); + x388 = (x387)+(x346); + x389 = ((uintptr_t)((x387)<(x349)))+((uintptr_t)((x388)<(x346))); + x390 = ((uintptr_t)(((x321)+((x345)*((uintptr_t)3435473267ULL)))<(x321)))+(x323); + x391 = (x390)+(x368); + x392 = (((uintptr_t)((x390)<(x323)))+((uintptr_t)((x391)<(x368))))+(x325); + x393 = (x392)+(x370); + x394 = (((uintptr_t)((x392)<(x325)))+((uintptr_t)((x393)<(x370))))+(x327); + x395 = (x394)+(x372); + x396 = (((uintptr_t)((x394)<(x327)))+((uintptr_t)((x395)<(x372))))+(x329); + x397 = (x396)+(x374); + x398 = (((uintptr_t)((x396)<(x329)))+((uintptr_t)((x397)<(x374))))+(x331); + x399 = (x398)+(x376); + x400 = (((uintptr_t)((x398)<(x331)))+((uintptr_t)((x399)<(x376))))+(x333); + x401 = (x400)+(x378); + x402 = (((uintptr_t)((x400)<(x333)))+((uintptr_t)((x401)<(x378))))+(x335); + x403 = (x402)+(x380); + x404 = (((uintptr_t)((x402)<(x335)))+((uintptr_t)((x403)<(x380))))+(x337); + x405 = (x404)+(x382); + x406 = (((uintptr_t)((x404)<(x337)))+((uintptr_t)((x405)<(x382))))+(x339); + x407 = (x406)+(x384); + x408 = (((uintptr_t)((x406)<(x339)))+((uintptr_t)((x407)<(x384))))+(x341); + x409 = (x408)+(x386); + x410 = (((uintptr_t)((x408)<(x341)))+((uintptr_t)((x409)<(x386))))+(x343); + x411 = (x410)+(x388); + x412 = (((uintptr_t)((x410)<(x343)))+((uintptr_t)((x411)<(x388))))+(((x344)+(x276))+((x320)+(x278))); + x413 = (x412)+((x389)+(x347)); + x414 = ((uintptr_t)((x412)<(((x344)+(x276))+((x320)+(x278)))))+((uintptr_t)((x413)<((x389)+(x347)))); + x415 = (x14)*((uintptr_t)210038273ULL); + x416 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)210038273ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)210038273ULL))>>64); + x417 = (x14)*((uintptr_t)725204769ULL); + x418 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)725204769ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)725204769ULL))>>64); + x419 = (x14)*((uintptr_t)1068522362ULL); + x420 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)1068522362ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)1068522362ULL))>>64); + x421 = (x14)*((uintptr_t)673605781ULL); + x422 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)673605781ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)673605781ULL))>>64); + x423 = (x14)*((uintptr_t)3557640471ULL); + x424 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)3557640471ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)3557640471ULL))>>64); + x425 = (x14)*((uintptr_t)1252728005ULL); + x426 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)1252728005ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)1252728005ULL))>>64); + x427 = (x14)*((uintptr_t)3158198330ULL); + x428 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)3158198330ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)3158198330ULL))>>64); + x429 = (x14)*((uintptr_t)4239927623ULL); + x430 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)4239927623ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)4239927623ULL))>>64); + x431 = (x14)*((uintptr_t)4282221029ULL); + x432 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)4282221029ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)4282221029ULL))>>64); + x433 = (x14)*((uintptr_t)3743065113ULL); + x434 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)3743065113ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)3743065113ULL))>>64); + x435 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)758225700ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)758225700ULL))>>64); + x436 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)431229353ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)431229353ULL))>>64); + x437 = (x436)+((x14)*((uintptr_t)758225700ULL)); + x438 = ((uintptr_t)((x437)<(x436)))+(x435); + x439 = (x438)+(x433); + x440 = (((uintptr_t)((x438)<(x435)))+((uintptr_t)((x439)<(x433))))+(x434); + x441 = (x440)+(x431); + x442 = (((uintptr_t)((x440)<(x434)))+((uintptr_t)((x441)<(x431))))+(x432); + x443 = (x442)+(x429); + x444 = (((uintptr_t)((x442)<(x432)))+((uintptr_t)((x443)<(x429))))+(x430); + x445 = (x444)+(x427); + x446 = (((uintptr_t)((x444)<(x430)))+((uintptr_t)((x445)<(x427))))+(x428); + x447 = (x446)+(x425); + x448 = (((uintptr_t)((x446)<(x428)))+((uintptr_t)((x447)<(x425))))+(x426); + x449 = (x448)+(x423); + x450 = (((uintptr_t)((x448)<(x426)))+((uintptr_t)((x449)<(x423))))+(x424); + x451 = (x450)+(x421); + x452 = (((uintptr_t)((x450)<(x424)))+((uintptr_t)((x451)<(x421))))+(x422); + x453 = (x452)+(x419); + x454 = (((uintptr_t)((x452)<(x422)))+((uintptr_t)((x453)<(x419))))+(x420); + x455 = (x454)+(x417); + x456 = (((uintptr_t)((x454)<(x420)))+((uintptr_t)((x455)<(x417))))+(x418); + x457 = (x456)+(x415); + x458 = ((uintptr_t)((x456)<(x418)))+((uintptr_t)((x457)<(x415))); + x459 = (x391)+((x14)*((uintptr_t)431229353ULL)); + x460 = ((uintptr_t)((x459)<(x391)))+(x393); + x461 = (x460)+(x437); + x462 = (((uintptr_t)((x460)<(x393)))+((uintptr_t)((x461)<(x437))))+(x395); + x463 = (x462)+(x439); + x464 = (((uintptr_t)((x462)<(x395)))+((uintptr_t)((x463)<(x439))))+(x397); + x465 = (x464)+(x441); + x466 = (((uintptr_t)((x464)<(x397)))+((uintptr_t)((x465)<(x441))))+(x399); + x467 = (x466)+(x443); + x468 = (((uintptr_t)((x466)<(x399)))+((uintptr_t)((x467)<(x443))))+(x401); + x469 = (x468)+(x445); + x470 = (((uintptr_t)((x468)<(x401)))+((uintptr_t)((x469)<(x445))))+(x403); + x471 = (x470)+(x447); + x472 = (((uintptr_t)((x470)<(x403)))+((uintptr_t)((x471)<(x447))))+(x405); + x473 = (x472)+(x449); + x474 = (((uintptr_t)((x472)<(x405)))+((uintptr_t)((x473)<(x449))))+(x407); + x475 = (x474)+(x451); + x476 = (((uintptr_t)((x474)<(x407)))+((uintptr_t)((x475)<(x451))))+(x409); + x477 = (x476)+(x453); + x478 = (((uintptr_t)((x476)<(x409)))+((uintptr_t)((x477)<(x453))))+(x411); + x479 = (x478)+(x455); + x480 = (((uintptr_t)((x478)<(x411)))+((uintptr_t)((x479)<(x455))))+(x413); + x481 = (x480)+(x457); + x482 = ((uintptr_t)((x480)<(x413)))+((uintptr_t)((x481)<(x457))); + x483 = (x459)*((uintptr_t)3901742149ULL); + x484 = (x483)*((uintptr_t)4294967295ULL); + x485 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x483)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x483)*((uintptr_t)4294967295ULL))>>64); + x486 = (x483)*((uintptr_t)4294967295ULL); + x487 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x483)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x483)*((uintptr_t)4294967295ULL))>>64); + x488 = (x483)*((uintptr_t)4294967295ULL); + x489 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x483)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x483)*((uintptr_t)4294967295ULL))>>64); + x490 = (x483)*((uintptr_t)4294967295ULL); + x491 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x483)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x483)*((uintptr_t)4294967295ULL))>>64); + x492 = (x483)*((uintptr_t)4294967295ULL); + x493 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x483)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x483)*((uintptr_t)4294967295ULL))>>64); + x494 = (x483)*((uintptr_t)4294967295ULL); + x495 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x483)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x483)*((uintptr_t)4294967295ULL))>>64); + x496 = (x483)*((uintptr_t)3345173889ULL); + x497 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x483)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x483)*((uintptr_t)3345173889ULL))>>64); + x498 = (x483)*((uintptr_t)4097256927ULL); + x499 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x483)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x483)*((uintptr_t)4097256927ULL))>>64); + x500 = (x483)*((uintptr_t)1478102450ULL); + x501 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x483)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x483)*((uintptr_t)1478102450ULL))>>64); + x502 = (x483)*((uintptr_t)1219536762ULL); + x503 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x483)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x483)*((uintptr_t)1219536762ULL))>>64); + x504 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x483)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x483)*((uintptr_t)3974895978ULL))>>64); + x505 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x483)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x483)*((uintptr_t)3435473267ULL))>>64); + x506 = (x505)+((x483)*((uintptr_t)3974895978ULL)); + x507 = ((uintptr_t)((x506)<(x505)))+(x504); + x508 = (x507)+(x502); + x509 = (((uintptr_t)((x507)<(x504)))+((uintptr_t)((x508)<(x502))))+(x503); + x510 = (x509)+(x500); + x511 = (((uintptr_t)((x509)<(x503)))+((uintptr_t)((x510)<(x500))))+(x501); + x512 = (x511)+(x498); + x513 = (((uintptr_t)((x511)<(x501)))+((uintptr_t)((x512)<(x498))))+(x499); + x514 = (x513)+(x496); + x515 = (((uintptr_t)((x513)<(x499)))+((uintptr_t)((x514)<(x496))))+(x497); + x516 = (x515)+(x494); + x517 = (((uintptr_t)((x515)<(x497)))+((uintptr_t)((x516)<(x494))))+(x495); + x518 = (x517)+(x492); + x519 = (((uintptr_t)((x517)<(x495)))+((uintptr_t)((x518)<(x492))))+(x493); + x520 = (x519)+(x490); + x521 = (((uintptr_t)((x519)<(x493)))+((uintptr_t)((x520)<(x490))))+(x491); + x522 = (x521)+(x488); + x523 = (((uintptr_t)((x521)<(x491)))+((uintptr_t)((x522)<(x488))))+(x489); + x524 = (x523)+(x486); + x525 = (((uintptr_t)((x523)<(x489)))+((uintptr_t)((x524)<(x486))))+(x487); + x526 = (x525)+(x484); + x527 = ((uintptr_t)((x525)<(x487)))+((uintptr_t)((x526)<(x484))); + x528 = ((uintptr_t)(((x459)+((x483)*((uintptr_t)3435473267ULL)))<(x459)))+(x461); + x529 = (x528)+(x506); + x530 = (((uintptr_t)((x528)<(x461)))+((uintptr_t)((x529)<(x506))))+(x463); + x531 = (x530)+(x508); + x532 = (((uintptr_t)((x530)<(x463)))+((uintptr_t)((x531)<(x508))))+(x465); + x533 = (x532)+(x510); + x534 = (((uintptr_t)((x532)<(x465)))+((uintptr_t)((x533)<(x510))))+(x467); + x535 = (x534)+(x512); + x536 = (((uintptr_t)((x534)<(x467)))+((uintptr_t)((x535)<(x512))))+(x469); + x537 = (x536)+(x514); + x538 = (((uintptr_t)((x536)<(x469)))+((uintptr_t)((x537)<(x514))))+(x471); + x539 = (x538)+(x516); + x540 = (((uintptr_t)((x538)<(x471)))+((uintptr_t)((x539)<(x516))))+(x473); + x541 = (x540)+(x518); + x542 = (((uintptr_t)((x540)<(x473)))+((uintptr_t)((x541)<(x518))))+(x475); + x543 = (x542)+(x520); + x544 = (((uintptr_t)((x542)<(x475)))+((uintptr_t)((x543)<(x520))))+(x477); + x545 = (x544)+(x522); + x546 = (((uintptr_t)((x544)<(x477)))+((uintptr_t)((x545)<(x522))))+(x479); + x547 = (x546)+(x524); + x548 = (((uintptr_t)((x546)<(x479)))+((uintptr_t)((x547)<(x524))))+(x481); + x549 = (x548)+(x526); + x550 = (((uintptr_t)((x548)<(x481)))+((uintptr_t)((x549)<(x526))))+(((x482)+(x414))+((x458)+(x416))); + x551 = (x550)+((x527)+(x485)); + x552 = ((uintptr_t)((x550)<(((x482)+(x414))+((x458)+(x416)))))+((uintptr_t)((x551)<((x527)+(x485)))); + x553 = (x15)*((uintptr_t)210038273ULL); + x554 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)210038273ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)210038273ULL))>>64); + x555 = (x15)*((uintptr_t)725204769ULL); + x556 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)725204769ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)725204769ULL))>>64); + x557 = (x15)*((uintptr_t)1068522362ULL); + x558 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)1068522362ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)1068522362ULL))>>64); + x559 = (x15)*((uintptr_t)673605781ULL); + x560 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)673605781ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)673605781ULL))>>64); + x561 = (x15)*((uintptr_t)3557640471ULL); + x562 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)3557640471ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)3557640471ULL))>>64); + x563 = (x15)*((uintptr_t)1252728005ULL); + x564 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)1252728005ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)1252728005ULL))>>64); + x565 = (x15)*((uintptr_t)3158198330ULL); + x566 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)3158198330ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)3158198330ULL))>>64); + x567 = (x15)*((uintptr_t)4239927623ULL); + x568 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)4239927623ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)4239927623ULL))>>64); + x569 = (x15)*((uintptr_t)4282221029ULL); + x570 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)4282221029ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)4282221029ULL))>>64); + x571 = (x15)*((uintptr_t)3743065113ULL); + x572 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)3743065113ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)3743065113ULL))>>64); + x573 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)758225700ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)758225700ULL))>>64); + x574 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)431229353ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)431229353ULL))>>64); + x575 = (x574)+((x15)*((uintptr_t)758225700ULL)); + x576 = ((uintptr_t)((x575)<(x574)))+(x573); + x577 = (x576)+(x571); + x578 = (((uintptr_t)((x576)<(x573)))+((uintptr_t)((x577)<(x571))))+(x572); + x579 = (x578)+(x569); + x580 = (((uintptr_t)((x578)<(x572)))+((uintptr_t)((x579)<(x569))))+(x570); + x581 = (x580)+(x567); + x582 = (((uintptr_t)((x580)<(x570)))+((uintptr_t)((x581)<(x567))))+(x568); + x583 = (x582)+(x565); + x584 = (((uintptr_t)((x582)<(x568)))+((uintptr_t)((x583)<(x565))))+(x566); + x585 = (x584)+(x563); + x586 = (((uintptr_t)((x584)<(x566)))+((uintptr_t)((x585)<(x563))))+(x564); + x587 = (x586)+(x561); + x588 = (((uintptr_t)((x586)<(x564)))+((uintptr_t)((x587)<(x561))))+(x562); + x589 = (x588)+(x559); + x590 = (((uintptr_t)((x588)<(x562)))+((uintptr_t)((x589)<(x559))))+(x560); + x591 = (x590)+(x557); + x592 = (((uintptr_t)((x590)<(x560)))+((uintptr_t)((x591)<(x557))))+(x558); + x593 = (x592)+(x555); + x594 = (((uintptr_t)((x592)<(x558)))+((uintptr_t)((x593)<(x555))))+(x556); + x595 = (x594)+(x553); + x596 = ((uintptr_t)((x594)<(x556)))+((uintptr_t)((x595)<(x553))); + x597 = (x529)+((x15)*((uintptr_t)431229353ULL)); + x598 = ((uintptr_t)((x597)<(x529)))+(x531); + x599 = (x598)+(x575); + x600 = (((uintptr_t)((x598)<(x531)))+((uintptr_t)((x599)<(x575))))+(x533); + x601 = (x600)+(x577); + x602 = (((uintptr_t)((x600)<(x533)))+((uintptr_t)((x601)<(x577))))+(x535); + x603 = (x602)+(x579); + x604 = (((uintptr_t)((x602)<(x535)))+((uintptr_t)((x603)<(x579))))+(x537); + x605 = (x604)+(x581); + x606 = (((uintptr_t)((x604)<(x537)))+((uintptr_t)((x605)<(x581))))+(x539); + x607 = (x606)+(x583); + x608 = (((uintptr_t)((x606)<(x539)))+((uintptr_t)((x607)<(x583))))+(x541); + x609 = (x608)+(x585); + x610 = (((uintptr_t)((x608)<(x541)))+((uintptr_t)((x609)<(x585))))+(x543); + x611 = (x610)+(x587); + x612 = (((uintptr_t)((x610)<(x543)))+((uintptr_t)((x611)<(x587))))+(x545); + x613 = (x612)+(x589); + x614 = (((uintptr_t)((x612)<(x545)))+((uintptr_t)((x613)<(x589))))+(x547); + x615 = (x614)+(x591); + x616 = (((uintptr_t)((x614)<(x547)))+((uintptr_t)((x615)<(x591))))+(x549); + x617 = (x616)+(x593); + x618 = (((uintptr_t)((x616)<(x549)))+((uintptr_t)((x617)<(x593))))+(x551); + x619 = (x618)+(x595); + x620 = ((uintptr_t)((x618)<(x551)))+((uintptr_t)((x619)<(x595))); + x621 = (x597)*((uintptr_t)3901742149ULL); + x622 = (x621)*((uintptr_t)4294967295ULL); + x623 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x621)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x621)*((uintptr_t)4294967295ULL))>>64); + x624 = (x621)*((uintptr_t)4294967295ULL); + x625 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x621)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x621)*((uintptr_t)4294967295ULL))>>64); + x626 = (x621)*((uintptr_t)4294967295ULL); + x627 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x621)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x621)*((uintptr_t)4294967295ULL))>>64); + x628 = (x621)*((uintptr_t)4294967295ULL); + x629 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x621)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x621)*((uintptr_t)4294967295ULL))>>64); + x630 = (x621)*((uintptr_t)4294967295ULL); + x631 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x621)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x621)*((uintptr_t)4294967295ULL))>>64); + x632 = (x621)*((uintptr_t)4294967295ULL); + x633 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x621)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x621)*((uintptr_t)4294967295ULL))>>64); + x634 = (x621)*((uintptr_t)3345173889ULL); + x635 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x621)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x621)*((uintptr_t)3345173889ULL))>>64); + x636 = (x621)*((uintptr_t)4097256927ULL); + x637 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x621)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x621)*((uintptr_t)4097256927ULL))>>64); + x638 = (x621)*((uintptr_t)1478102450ULL); + x639 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x621)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x621)*((uintptr_t)1478102450ULL))>>64); + x640 = (x621)*((uintptr_t)1219536762ULL); + x641 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x621)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x621)*((uintptr_t)1219536762ULL))>>64); + x642 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x621)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x621)*((uintptr_t)3974895978ULL))>>64); + x643 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x621)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x621)*((uintptr_t)3435473267ULL))>>64); + x644 = (x643)+((x621)*((uintptr_t)3974895978ULL)); + x645 = ((uintptr_t)((x644)<(x643)))+(x642); + x646 = (x645)+(x640); + x647 = (((uintptr_t)((x645)<(x642)))+((uintptr_t)((x646)<(x640))))+(x641); + x648 = (x647)+(x638); + x649 = (((uintptr_t)((x647)<(x641)))+((uintptr_t)((x648)<(x638))))+(x639); + x650 = (x649)+(x636); + x651 = (((uintptr_t)((x649)<(x639)))+((uintptr_t)((x650)<(x636))))+(x637); + x652 = (x651)+(x634); + x653 = (((uintptr_t)((x651)<(x637)))+((uintptr_t)((x652)<(x634))))+(x635); + x654 = (x653)+(x632); + x655 = (((uintptr_t)((x653)<(x635)))+((uintptr_t)((x654)<(x632))))+(x633); + x656 = (x655)+(x630); + x657 = (((uintptr_t)((x655)<(x633)))+((uintptr_t)((x656)<(x630))))+(x631); + x658 = (x657)+(x628); + x659 = (((uintptr_t)((x657)<(x631)))+((uintptr_t)((x658)<(x628))))+(x629); + x660 = (x659)+(x626); + x661 = (((uintptr_t)((x659)<(x629)))+((uintptr_t)((x660)<(x626))))+(x627); + x662 = (x661)+(x624); + x663 = (((uintptr_t)((x661)<(x627)))+((uintptr_t)((x662)<(x624))))+(x625); + x664 = (x663)+(x622); + x665 = ((uintptr_t)((x663)<(x625)))+((uintptr_t)((x664)<(x622))); + x666 = ((uintptr_t)(((x597)+((x621)*((uintptr_t)3435473267ULL)))<(x597)))+(x599); + x667 = (x666)+(x644); + x668 = (((uintptr_t)((x666)<(x599)))+((uintptr_t)((x667)<(x644))))+(x601); + x669 = (x668)+(x646); + x670 = (((uintptr_t)((x668)<(x601)))+((uintptr_t)((x669)<(x646))))+(x603); + x671 = (x670)+(x648); + x672 = (((uintptr_t)((x670)<(x603)))+((uintptr_t)((x671)<(x648))))+(x605); + x673 = (x672)+(x650); + x674 = (((uintptr_t)((x672)<(x605)))+((uintptr_t)((x673)<(x650))))+(x607); + x675 = (x674)+(x652); + x676 = (((uintptr_t)((x674)<(x607)))+((uintptr_t)((x675)<(x652))))+(x609); + x677 = (x676)+(x654); + x678 = (((uintptr_t)((x676)<(x609)))+((uintptr_t)((x677)<(x654))))+(x611); + x679 = (x678)+(x656); + x680 = (((uintptr_t)((x678)<(x611)))+((uintptr_t)((x679)<(x656))))+(x613); + x681 = (x680)+(x658); + x682 = (((uintptr_t)((x680)<(x613)))+((uintptr_t)((x681)<(x658))))+(x615); + x683 = (x682)+(x660); + x684 = (((uintptr_t)((x682)<(x615)))+((uintptr_t)((x683)<(x660))))+(x617); + x685 = (x684)+(x662); + x686 = (((uintptr_t)((x684)<(x617)))+((uintptr_t)((x685)<(x662))))+(x619); + x687 = (x686)+(x664); + x688 = (((uintptr_t)((x686)<(x619)))+((uintptr_t)((x687)<(x664))))+(((x620)+(x552))+((x596)+(x554))); + x689 = (x688)+((x665)+(x623)); + x690 = ((uintptr_t)((x688)<(((x620)+(x552))+((x596)+(x554)))))+((uintptr_t)((x689)<((x665)+(x623)))); + x691 = (x16)*((uintptr_t)210038273ULL); + x692 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)210038273ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)210038273ULL))>>64); + x693 = (x16)*((uintptr_t)725204769ULL); + x694 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)725204769ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)725204769ULL))>>64); + x695 = (x16)*((uintptr_t)1068522362ULL); + x696 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)1068522362ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)1068522362ULL))>>64); + x697 = (x16)*((uintptr_t)673605781ULL); + x698 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)673605781ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)673605781ULL))>>64); + x699 = (x16)*((uintptr_t)3557640471ULL); + x700 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)3557640471ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)3557640471ULL))>>64); + x701 = (x16)*((uintptr_t)1252728005ULL); + x702 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)1252728005ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)1252728005ULL))>>64); + x703 = (x16)*((uintptr_t)3158198330ULL); + x704 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)3158198330ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)3158198330ULL))>>64); + x705 = (x16)*((uintptr_t)4239927623ULL); + x706 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)4239927623ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)4239927623ULL))>>64); + x707 = (x16)*((uintptr_t)4282221029ULL); + x708 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)4282221029ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)4282221029ULL))>>64); + x709 = (x16)*((uintptr_t)3743065113ULL); + x710 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)3743065113ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)3743065113ULL))>>64); + x711 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)758225700ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)758225700ULL))>>64); + x712 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)431229353ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)431229353ULL))>>64); + x713 = (x712)+((x16)*((uintptr_t)758225700ULL)); + x714 = ((uintptr_t)((x713)<(x712)))+(x711); + x715 = (x714)+(x709); + x716 = (((uintptr_t)((x714)<(x711)))+((uintptr_t)((x715)<(x709))))+(x710); + x717 = (x716)+(x707); + x718 = (((uintptr_t)((x716)<(x710)))+((uintptr_t)((x717)<(x707))))+(x708); + x719 = (x718)+(x705); + x720 = (((uintptr_t)((x718)<(x708)))+((uintptr_t)((x719)<(x705))))+(x706); + x721 = (x720)+(x703); + x722 = (((uintptr_t)((x720)<(x706)))+((uintptr_t)((x721)<(x703))))+(x704); + x723 = (x722)+(x701); + x724 = (((uintptr_t)((x722)<(x704)))+((uintptr_t)((x723)<(x701))))+(x702); + x725 = (x724)+(x699); + x726 = (((uintptr_t)((x724)<(x702)))+((uintptr_t)((x725)<(x699))))+(x700); + x727 = (x726)+(x697); + x728 = (((uintptr_t)((x726)<(x700)))+((uintptr_t)((x727)<(x697))))+(x698); + x729 = (x728)+(x695); + x730 = (((uintptr_t)((x728)<(x698)))+((uintptr_t)((x729)<(x695))))+(x696); + x731 = (x730)+(x693); + x732 = (((uintptr_t)((x730)<(x696)))+((uintptr_t)((x731)<(x693))))+(x694); + x733 = (x732)+(x691); + x734 = ((uintptr_t)((x732)<(x694)))+((uintptr_t)((x733)<(x691))); + x735 = (x667)+((x16)*((uintptr_t)431229353ULL)); + x736 = ((uintptr_t)((x735)<(x667)))+(x669); + x737 = (x736)+(x713); + x738 = (((uintptr_t)((x736)<(x669)))+((uintptr_t)((x737)<(x713))))+(x671); + x739 = (x738)+(x715); + x740 = (((uintptr_t)((x738)<(x671)))+((uintptr_t)((x739)<(x715))))+(x673); + x741 = (x740)+(x717); + x742 = (((uintptr_t)((x740)<(x673)))+((uintptr_t)((x741)<(x717))))+(x675); + x743 = (x742)+(x719); + x744 = (((uintptr_t)((x742)<(x675)))+((uintptr_t)((x743)<(x719))))+(x677); + x745 = (x744)+(x721); + x746 = (((uintptr_t)((x744)<(x677)))+((uintptr_t)((x745)<(x721))))+(x679); + x747 = (x746)+(x723); + x748 = (((uintptr_t)((x746)<(x679)))+((uintptr_t)((x747)<(x723))))+(x681); + x749 = (x748)+(x725); + x750 = (((uintptr_t)((x748)<(x681)))+((uintptr_t)((x749)<(x725))))+(x683); + x751 = (x750)+(x727); + x752 = (((uintptr_t)((x750)<(x683)))+((uintptr_t)((x751)<(x727))))+(x685); + x753 = (x752)+(x729); + x754 = (((uintptr_t)((x752)<(x685)))+((uintptr_t)((x753)<(x729))))+(x687); + x755 = (x754)+(x731); + x756 = (((uintptr_t)((x754)<(x687)))+((uintptr_t)((x755)<(x731))))+(x689); + x757 = (x756)+(x733); + x758 = ((uintptr_t)((x756)<(x689)))+((uintptr_t)((x757)<(x733))); + x759 = (x735)*((uintptr_t)3901742149ULL); + x760 = (x759)*((uintptr_t)4294967295ULL); + x761 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x759)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x759)*((uintptr_t)4294967295ULL))>>64); + x762 = (x759)*((uintptr_t)4294967295ULL); + x763 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x759)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x759)*((uintptr_t)4294967295ULL))>>64); + x764 = (x759)*((uintptr_t)4294967295ULL); + x765 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x759)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x759)*((uintptr_t)4294967295ULL))>>64); + x766 = (x759)*((uintptr_t)4294967295ULL); + x767 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x759)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x759)*((uintptr_t)4294967295ULL))>>64); + x768 = (x759)*((uintptr_t)4294967295ULL); + x769 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x759)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x759)*((uintptr_t)4294967295ULL))>>64); + x770 = (x759)*((uintptr_t)4294967295ULL); + x771 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x759)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x759)*((uintptr_t)4294967295ULL))>>64); + x772 = (x759)*((uintptr_t)3345173889ULL); + x773 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x759)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x759)*((uintptr_t)3345173889ULL))>>64); + x774 = (x759)*((uintptr_t)4097256927ULL); + x775 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x759)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x759)*((uintptr_t)4097256927ULL))>>64); + x776 = (x759)*((uintptr_t)1478102450ULL); + x777 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x759)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x759)*((uintptr_t)1478102450ULL))>>64); + x778 = (x759)*((uintptr_t)1219536762ULL); + x779 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x759)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x759)*((uintptr_t)1219536762ULL))>>64); + x780 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x759)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x759)*((uintptr_t)3974895978ULL))>>64); + x781 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x759)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x759)*((uintptr_t)3435473267ULL))>>64); + x782 = (x781)+((x759)*((uintptr_t)3974895978ULL)); + x783 = ((uintptr_t)((x782)<(x781)))+(x780); + x784 = (x783)+(x778); + x785 = (((uintptr_t)((x783)<(x780)))+((uintptr_t)((x784)<(x778))))+(x779); + x786 = (x785)+(x776); + x787 = (((uintptr_t)((x785)<(x779)))+((uintptr_t)((x786)<(x776))))+(x777); + x788 = (x787)+(x774); + x789 = (((uintptr_t)((x787)<(x777)))+((uintptr_t)((x788)<(x774))))+(x775); + x790 = (x789)+(x772); + x791 = (((uintptr_t)((x789)<(x775)))+((uintptr_t)((x790)<(x772))))+(x773); + x792 = (x791)+(x770); + x793 = (((uintptr_t)((x791)<(x773)))+((uintptr_t)((x792)<(x770))))+(x771); + x794 = (x793)+(x768); + x795 = (((uintptr_t)((x793)<(x771)))+((uintptr_t)((x794)<(x768))))+(x769); + x796 = (x795)+(x766); + x797 = (((uintptr_t)((x795)<(x769)))+((uintptr_t)((x796)<(x766))))+(x767); + x798 = (x797)+(x764); + x799 = (((uintptr_t)((x797)<(x767)))+((uintptr_t)((x798)<(x764))))+(x765); + x800 = (x799)+(x762); + x801 = (((uintptr_t)((x799)<(x765)))+((uintptr_t)((x800)<(x762))))+(x763); + x802 = (x801)+(x760); + x803 = ((uintptr_t)((x801)<(x763)))+((uintptr_t)((x802)<(x760))); + x804 = ((uintptr_t)(((x735)+((x759)*((uintptr_t)3435473267ULL)))<(x735)))+(x737); + x805 = (x804)+(x782); + x806 = (((uintptr_t)((x804)<(x737)))+((uintptr_t)((x805)<(x782))))+(x739); + x807 = (x806)+(x784); + x808 = (((uintptr_t)((x806)<(x739)))+((uintptr_t)((x807)<(x784))))+(x741); + x809 = (x808)+(x786); + x810 = (((uintptr_t)((x808)<(x741)))+((uintptr_t)((x809)<(x786))))+(x743); + x811 = (x810)+(x788); + x812 = (((uintptr_t)((x810)<(x743)))+((uintptr_t)((x811)<(x788))))+(x745); + x813 = (x812)+(x790); + x814 = (((uintptr_t)((x812)<(x745)))+((uintptr_t)((x813)<(x790))))+(x747); + x815 = (x814)+(x792); + x816 = (((uintptr_t)((x814)<(x747)))+((uintptr_t)((x815)<(x792))))+(x749); + x817 = (x816)+(x794); + x818 = (((uintptr_t)((x816)<(x749)))+((uintptr_t)((x817)<(x794))))+(x751); + x819 = (x818)+(x796); + x820 = (((uintptr_t)((x818)<(x751)))+((uintptr_t)((x819)<(x796))))+(x753); + x821 = (x820)+(x798); + x822 = (((uintptr_t)((x820)<(x753)))+((uintptr_t)((x821)<(x798))))+(x755); + x823 = (x822)+(x800); + x824 = (((uintptr_t)((x822)<(x755)))+((uintptr_t)((x823)<(x800))))+(x757); + x825 = (x824)+(x802); + x826 = (((uintptr_t)((x824)<(x757)))+((uintptr_t)((x825)<(x802))))+(((x758)+(x690))+((x734)+(x692))); + x827 = (x826)+((x803)+(x761)); + x828 = ((uintptr_t)((x826)<(((x758)+(x690))+((x734)+(x692)))))+((uintptr_t)((x827)<((x803)+(x761)))); + x829 = (x17)*((uintptr_t)210038273ULL); + x830 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)210038273ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)210038273ULL))>>64); + x831 = (x17)*((uintptr_t)725204769ULL); + x832 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)725204769ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)725204769ULL))>>64); + x833 = (x17)*((uintptr_t)1068522362ULL); + x834 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)1068522362ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)1068522362ULL))>>64); + x835 = (x17)*((uintptr_t)673605781ULL); + x836 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)673605781ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)673605781ULL))>>64); + x837 = (x17)*((uintptr_t)3557640471ULL); + x838 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)3557640471ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)3557640471ULL))>>64); + x839 = (x17)*((uintptr_t)1252728005ULL); + x840 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)1252728005ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)1252728005ULL))>>64); + x841 = (x17)*((uintptr_t)3158198330ULL); + x842 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)3158198330ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)3158198330ULL))>>64); + x843 = (x17)*((uintptr_t)4239927623ULL); + x844 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)4239927623ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)4239927623ULL))>>64); + x845 = (x17)*((uintptr_t)4282221029ULL); + x846 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)4282221029ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)4282221029ULL))>>64); + x847 = (x17)*((uintptr_t)3743065113ULL); + x848 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)3743065113ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)3743065113ULL))>>64); + x849 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)758225700ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)758225700ULL))>>64); + x850 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)431229353ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)431229353ULL))>>64); + x851 = (x850)+((x17)*((uintptr_t)758225700ULL)); + x852 = ((uintptr_t)((x851)<(x850)))+(x849); + x853 = (x852)+(x847); + x854 = (((uintptr_t)((x852)<(x849)))+((uintptr_t)((x853)<(x847))))+(x848); + x855 = (x854)+(x845); + x856 = (((uintptr_t)((x854)<(x848)))+((uintptr_t)((x855)<(x845))))+(x846); + x857 = (x856)+(x843); + x858 = (((uintptr_t)((x856)<(x846)))+((uintptr_t)((x857)<(x843))))+(x844); + x859 = (x858)+(x841); + x860 = (((uintptr_t)((x858)<(x844)))+((uintptr_t)((x859)<(x841))))+(x842); + x861 = (x860)+(x839); + x862 = (((uintptr_t)((x860)<(x842)))+((uintptr_t)((x861)<(x839))))+(x840); + x863 = (x862)+(x837); + x864 = (((uintptr_t)((x862)<(x840)))+((uintptr_t)((x863)<(x837))))+(x838); + x865 = (x864)+(x835); + x866 = (((uintptr_t)((x864)<(x838)))+((uintptr_t)((x865)<(x835))))+(x836); + x867 = (x866)+(x833); + x868 = (((uintptr_t)((x866)<(x836)))+((uintptr_t)((x867)<(x833))))+(x834); + x869 = (x868)+(x831); + x870 = (((uintptr_t)((x868)<(x834)))+((uintptr_t)((x869)<(x831))))+(x832); + x871 = (x870)+(x829); + x872 = ((uintptr_t)((x870)<(x832)))+((uintptr_t)((x871)<(x829))); + x873 = (x805)+((x17)*((uintptr_t)431229353ULL)); + x874 = ((uintptr_t)((x873)<(x805)))+(x807); + x875 = (x874)+(x851); + x876 = (((uintptr_t)((x874)<(x807)))+((uintptr_t)((x875)<(x851))))+(x809); + x877 = (x876)+(x853); + x878 = (((uintptr_t)((x876)<(x809)))+((uintptr_t)((x877)<(x853))))+(x811); + x879 = (x878)+(x855); + x880 = (((uintptr_t)((x878)<(x811)))+((uintptr_t)((x879)<(x855))))+(x813); + x881 = (x880)+(x857); + x882 = (((uintptr_t)((x880)<(x813)))+((uintptr_t)((x881)<(x857))))+(x815); + x883 = (x882)+(x859); + x884 = (((uintptr_t)((x882)<(x815)))+((uintptr_t)((x883)<(x859))))+(x817); + x885 = (x884)+(x861); + x886 = (((uintptr_t)((x884)<(x817)))+((uintptr_t)((x885)<(x861))))+(x819); + x887 = (x886)+(x863); + x888 = (((uintptr_t)((x886)<(x819)))+((uintptr_t)((x887)<(x863))))+(x821); + x889 = (x888)+(x865); + x890 = (((uintptr_t)((x888)<(x821)))+((uintptr_t)((x889)<(x865))))+(x823); + x891 = (x890)+(x867); + x892 = (((uintptr_t)((x890)<(x823)))+((uintptr_t)((x891)<(x867))))+(x825); + x893 = (x892)+(x869); + x894 = (((uintptr_t)((x892)<(x825)))+((uintptr_t)((x893)<(x869))))+(x827); + x895 = (x894)+(x871); + x896 = ((uintptr_t)((x894)<(x827)))+((uintptr_t)((x895)<(x871))); + x897 = (x873)*((uintptr_t)3901742149ULL); + x898 = (x897)*((uintptr_t)4294967295ULL); + x899 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x897)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x897)*((uintptr_t)4294967295ULL))>>64); + x900 = (x897)*((uintptr_t)4294967295ULL); + x901 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x897)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x897)*((uintptr_t)4294967295ULL))>>64); + x902 = (x897)*((uintptr_t)4294967295ULL); + x903 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x897)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x897)*((uintptr_t)4294967295ULL))>>64); + x904 = (x897)*((uintptr_t)4294967295ULL); + x905 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x897)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x897)*((uintptr_t)4294967295ULL))>>64); + x906 = (x897)*((uintptr_t)4294967295ULL); + x907 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x897)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x897)*((uintptr_t)4294967295ULL))>>64); + x908 = (x897)*((uintptr_t)4294967295ULL); + x909 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x897)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x897)*((uintptr_t)4294967295ULL))>>64); + x910 = (x897)*((uintptr_t)3345173889ULL); + x911 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x897)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x897)*((uintptr_t)3345173889ULL))>>64); + x912 = (x897)*((uintptr_t)4097256927ULL); + x913 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x897)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x897)*((uintptr_t)4097256927ULL))>>64); + x914 = (x897)*((uintptr_t)1478102450ULL); + x915 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x897)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x897)*((uintptr_t)1478102450ULL))>>64); + x916 = (x897)*((uintptr_t)1219536762ULL); + x917 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x897)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x897)*((uintptr_t)1219536762ULL))>>64); + x918 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x897)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x897)*((uintptr_t)3974895978ULL))>>64); + x919 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x897)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x897)*((uintptr_t)3435473267ULL))>>64); + x920 = (x919)+((x897)*((uintptr_t)3974895978ULL)); + x921 = ((uintptr_t)((x920)<(x919)))+(x918); + x922 = (x921)+(x916); + x923 = (((uintptr_t)((x921)<(x918)))+((uintptr_t)((x922)<(x916))))+(x917); + x924 = (x923)+(x914); + x925 = (((uintptr_t)((x923)<(x917)))+((uintptr_t)((x924)<(x914))))+(x915); + x926 = (x925)+(x912); + x927 = (((uintptr_t)((x925)<(x915)))+((uintptr_t)((x926)<(x912))))+(x913); + x928 = (x927)+(x910); + x929 = (((uintptr_t)((x927)<(x913)))+((uintptr_t)((x928)<(x910))))+(x911); + x930 = (x929)+(x908); + x931 = (((uintptr_t)((x929)<(x911)))+((uintptr_t)((x930)<(x908))))+(x909); + x932 = (x931)+(x906); + x933 = (((uintptr_t)((x931)<(x909)))+((uintptr_t)((x932)<(x906))))+(x907); + x934 = (x933)+(x904); + x935 = (((uintptr_t)((x933)<(x907)))+((uintptr_t)((x934)<(x904))))+(x905); + x936 = (x935)+(x902); + x937 = (((uintptr_t)((x935)<(x905)))+((uintptr_t)((x936)<(x902))))+(x903); + x938 = (x937)+(x900); + x939 = (((uintptr_t)((x937)<(x903)))+((uintptr_t)((x938)<(x900))))+(x901); + x940 = (x939)+(x898); + x941 = ((uintptr_t)((x939)<(x901)))+((uintptr_t)((x940)<(x898))); + x942 = ((uintptr_t)(((x873)+((x897)*((uintptr_t)3435473267ULL)))<(x873)))+(x875); + x943 = (x942)+(x920); + x944 = (((uintptr_t)((x942)<(x875)))+((uintptr_t)((x943)<(x920))))+(x877); + x945 = (x944)+(x922); + x946 = (((uintptr_t)((x944)<(x877)))+((uintptr_t)((x945)<(x922))))+(x879); + x947 = (x946)+(x924); + x948 = (((uintptr_t)((x946)<(x879)))+((uintptr_t)((x947)<(x924))))+(x881); + x949 = (x948)+(x926); + x950 = (((uintptr_t)((x948)<(x881)))+((uintptr_t)((x949)<(x926))))+(x883); + x951 = (x950)+(x928); + x952 = (((uintptr_t)((x950)<(x883)))+((uintptr_t)((x951)<(x928))))+(x885); + x953 = (x952)+(x930); + x954 = (((uintptr_t)((x952)<(x885)))+((uintptr_t)((x953)<(x930))))+(x887); + x955 = (x954)+(x932); + x956 = (((uintptr_t)((x954)<(x887)))+((uintptr_t)((x955)<(x932))))+(x889); + x957 = (x956)+(x934); + x958 = (((uintptr_t)((x956)<(x889)))+((uintptr_t)((x957)<(x934))))+(x891); + x959 = (x958)+(x936); + x960 = (((uintptr_t)((x958)<(x891)))+((uintptr_t)((x959)<(x936))))+(x893); + x961 = (x960)+(x938); + x962 = (((uintptr_t)((x960)<(x893)))+((uintptr_t)((x961)<(x938))))+(x895); + x963 = (x962)+(x940); + x964 = (((uintptr_t)((x962)<(x895)))+((uintptr_t)((x963)<(x940))))+(((x896)+(x828))+((x872)+(x830))); + x965 = (x964)+((x941)+(x899)); + x966 = ((uintptr_t)((x964)<(((x896)+(x828))+((x872)+(x830)))))+((uintptr_t)((x965)<((x941)+(x899)))); + x967 = (x18)*((uintptr_t)210038273ULL); + x968 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)210038273ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)210038273ULL))>>64); + x969 = (x18)*((uintptr_t)725204769ULL); + x970 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)725204769ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)725204769ULL))>>64); + x971 = (x18)*((uintptr_t)1068522362ULL); + x972 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)1068522362ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)1068522362ULL))>>64); + x973 = (x18)*((uintptr_t)673605781ULL); + x974 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)673605781ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)673605781ULL))>>64); + x975 = (x18)*((uintptr_t)3557640471ULL); + x976 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)3557640471ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)3557640471ULL))>>64); + x977 = (x18)*((uintptr_t)1252728005ULL); + x978 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)1252728005ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)1252728005ULL))>>64); + x979 = (x18)*((uintptr_t)3158198330ULL); + x980 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)3158198330ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)3158198330ULL))>>64); + x981 = (x18)*((uintptr_t)4239927623ULL); + x982 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)4239927623ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)4239927623ULL))>>64); + x983 = (x18)*((uintptr_t)4282221029ULL); + x984 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)4282221029ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)4282221029ULL))>>64); + x985 = (x18)*((uintptr_t)3743065113ULL); + x986 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)3743065113ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)3743065113ULL))>>64); + x987 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)758225700ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)758225700ULL))>>64); + x988 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)431229353ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)431229353ULL))>>64); + x989 = (x988)+((x18)*((uintptr_t)758225700ULL)); + x990 = ((uintptr_t)((x989)<(x988)))+(x987); + x991 = (x990)+(x985); + x992 = (((uintptr_t)((x990)<(x987)))+((uintptr_t)((x991)<(x985))))+(x986); + x993 = (x992)+(x983); + x994 = (((uintptr_t)((x992)<(x986)))+((uintptr_t)((x993)<(x983))))+(x984); + x995 = (x994)+(x981); + x996 = (((uintptr_t)((x994)<(x984)))+((uintptr_t)((x995)<(x981))))+(x982); + x997 = (x996)+(x979); + x998 = (((uintptr_t)((x996)<(x982)))+((uintptr_t)((x997)<(x979))))+(x980); + x999 = (x998)+(x977); + x1000 = (((uintptr_t)((x998)<(x980)))+((uintptr_t)((x999)<(x977))))+(x978); + x1001 = (x1000)+(x975); + x1002 = (((uintptr_t)((x1000)<(x978)))+((uintptr_t)((x1001)<(x975))))+(x976); + x1003 = (x1002)+(x973); + x1004 = (((uintptr_t)((x1002)<(x976)))+((uintptr_t)((x1003)<(x973))))+(x974); + x1005 = (x1004)+(x971); + x1006 = (((uintptr_t)((x1004)<(x974)))+((uintptr_t)((x1005)<(x971))))+(x972); + x1007 = (x1006)+(x969); + x1008 = (((uintptr_t)((x1006)<(x972)))+((uintptr_t)((x1007)<(x969))))+(x970); + x1009 = (x1008)+(x967); + x1010 = ((uintptr_t)((x1008)<(x970)))+((uintptr_t)((x1009)<(x967))); + x1011 = (x943)+((x18)*((uintptr_t)431229353ULL)); + x1012 = ((uintptr_t)((x1011)<(x943)))+(x945); + x1013 = (x1012)+(x989); + x1014 = (((uintptr_t)((x1012)<(x945)))+((uintptr_t)((x1013)<(x989))))+(x947); + x1015 = (x1014)+(x991); + x1016 = (((uintptr_t)((x1014)<(x947)))+((uintptr_t)((x1015)<(x991))))+(x949); + x1017 = (x1016)+(x993); + x1018 = (((uintptr_t)((x1016)<(x949)))+((uintptr_t)((x1017)<(x993))))+(x951); + x1019 = (x1018)+(x995); + x1020 = (((uintptr_t)((x1018)<(x951)))+((uintptr_t)((x1019)<(x995))))+(x953); + x1021 = (x1020)+(x997); + x1022 = (((uintptr_t)((x1020)<(x953)))+((uintptr_t)((x1021)<(x997))))+(x955); + x1023 = (x1022)+(x999); + x1024 = (((uintptr_t)((x1022)<(x955)))+((uintptr_t)((x1023)<(x999))))+(x957); + x1025 = (x1024)+(x1001); + x1026 = (((uintptr_t)((x1024)<(x957)))+((uintptr_t)((x1025)<(x1001))))+(x959); + x1027 = (x1026)+(x1003); + x1028 = (((uintptr_t)((x1026)<(x959)))+((uintptr_t)((x1027)<(x1003))))+(x961); + x1029 = (x1028)+(x1005); + x1030 = (((uintptr_t)((x1028)<(x961)))+((uintptr_t)((x1029)<(x1005))))+(x963); + x1031 = (x1030)+(x1007); + x1032 = (((uintptr_t)((x1030)<(x963)))+((uintptr_t)((x1031)<(x1007))))+(x965); + x1033 = (x1032)+(x1009); + x1034 = ((uintptr_t)((x1032)<(x965)))+((uintptr_t)((x1033)<(x1009))); + x1035 = (x1011)*((uintptr_t)3901742149ULL); + x1036 = (x1035)*((uintptr_t)4294967295ULL); + x1037 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1035)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1035)*((uintptr_t)4294967295ULL))>>64); + x1038 = (x1035)*((uintptr_t)4294967295ULL); + x1039 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1035)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1035)*((uintptr_t)4294967295ULL))>>64); + x1040 = (x1035)*((uintptr_t)4294967295ULL); + x1041 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1035)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1035)*((uintptr_t)4294967295ULL))>>64); + x1042 = (x1035)*((uintptr_t)4294967295ULL); + x1043 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1035)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1035)*((uintptr_t)4294967295ULL))>>64); + x1044 = (x1035)*((uintptr_t)4294967295ULL); + x1045 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1035)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1035)*((uintptr_t)4294967295ULL))>>64); + x1046 = (x1035)*((uintptr_t)4294967295ULL); + x1047 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1035)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1035)*((uintptr_t)4294967295ULL))>>64); + x1048 = (x1035)*((uintptr_t)3345173889ULL); + x1049 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1035)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x1035)*((uintptr_t)3345173889ULL))>>64); + x1050 = (x1035)*((uintptr_t)4097256927ULL); + x1051 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1035)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x1035)*((uintptr_t)4097256927ULL))>>64); + x1052 = (x1035)*((uintptr_t)1478102450ULL); + x1053 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1035)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x1035)*((uintptr_t)1478102450ULL))>>64); + x1054 = (x1035)*((uintptr_t)1219536762ULL); + x1055 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1035)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x1035)*((uintptr_t)1219536762ULL))>>64); + x1056 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1035)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x1035)*((uintptr_t)3974895978ULL))>>64); + x1057 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1035)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x1035)*((uintptr_t)3435473267ULL))>>64); + x1058 = (x1057)+((x1035)*((uintptr_t)3974895978ULL)); + x1059 = ((uintptr_t)((x1058)<(x1057)))+(x1056); + x1060 = (x1059)+(x1054); + x1061 = (((uintptr_t)((x1059)<(x1056)))+((uintptr_t)((x1060)<(x1054))))+(x1055); + x1062 = (x1061)+(x1052); + x1063 = (((uintptr_t)((x1061)<(x1055)))+((uintptr_t)((x1062)<(x1052))))+(x1053); + x1064 = (x1063)+(x1050); + x1065 = (((uintptr_t)((x1063)<(x1053)))+((uintptr_t)((x1064)<(x1050))))+(x1051); + x1066 = (x1065)+(x1048); + x1067 = (((uintptr_t)((x1065)<(x1051)))+((uintptr_t)((x1066)<(x1048))))+(x1049); + x1068 = (x1067)+(x1046); + x1069 = (((uintptr_t)((x1067)<(x1049)))+((uintptr_t)((x1068)<(x1046))))+(x1047); + x1070 = (x1069)+(x1044); + x1071 = (((uintptr_t)((x1069)<(x1047)))+((uintptr_t)((x1070)<(x1044))))+(x1045); + x1072 = (x1071)+(x1042); + x1073 = (((uintptr_t)((x1071)<(x1045)))+((uintptr_t)((x1072)<(x1042))))+(x1043); + x1074 = (x1073)+(x1040); + x1075 = (((uintptr_t)((x1073)<(x1043)))+((uintptr_t)((x1074)<(x1040))))+(x1041); + x1076 = (x1075)+(x1038); + x1077 = (((uintptr_t)((x1075)<(x1041)))+((uintptr_t)((x1076)<(x1038))))+(x1039); + x1078 = (x1077)+(x1036); + x1079 = ((uintptr_t)((x1077)<(x1039)))+((uintptr_t)((x1078)<(x1036))); + x1080 = ((uintptr_t)(((x1011)+((x1035)*((uintptr_t)3435473267ULL)))<(x1011)))+(x1013); + x1081 = (x1080)+(x1058); + x1082 = (((uintptr_t)((x1080)<(x1013)))+((uintptr_t)((x1081)<(x1058))))+(x1015); + x1083 = (x1082)+(x1060); + x1084 = (((uintptr_t)((x1082)<(x1015)))+((uintptr_t)((x1083)<(x1060))))+(x1017); + x1085 = (x1084)+(x1062); + x1086 = (((uintptr_t)((x1084)<(x1017)))+((uintptr_t)((x1085)<(x1062))))+(x1019); + x1087 = (x1086)+(x1064); + x1088 = (((uintptr_t)((x1086)<(x1019)))+((uintptr_t)((x1087)<(x1064))))+(x1021); + x1089 = (x1088)+(x1066); + x1090 = (((uintptr_t)((x1088)<(x1021)))+((uintptr_t)((x1089)<(x1066))))+(x1023); + x1091 = (x1090)+(x1068); + x1092 = (((uintptr_t)((x1090)<(x1023)))+((uintptr_t)((x1091)<(x1068))))+(x1025); + x1093 = (x1092)+(x1070); + x1094 = (((uintptr_t)((x1092)<(x1025)))+((uintptr_t)((x1093)<(x1070))))+(x1027); + x1095 = (x1094)+(x1072); + x1096 = (((uintptr_t)((x1094)<(x1027)))+((uintptr_t)((x1095)<(x1072))))+(x1029); + x1097 = (x1096)+(x1074); + x1098 = (((uintptr_t)((x1096)<(x1029)))+((uintptr_t)((x1097)<(x1074))))+(x1031); + x1099 = (x1098)+(x1076); + x1100 = (((uintptr_t)((x1098)<(x1031)))+((uintptr_t)((x1099)<(x1076))))+(x1033); + x1101 = (x1100)+(x1078); + x1102 = (((uintptr_t)((x1100)<(x1033)))+((uintptr_t)((x1101)<(x1078))))+(((x1034)+(x966))+((x1010)+(x968))); + x1103 = (x1102)+((x1079)+(x1037)); + x1104 = ((uintptr_t)((x1102)<(((x1034)+(x966))+((x1010)+(x968)))))+((uintptr_t)((x1103)<((x1079)+(x1037)))); + x1105 = (x19)*((uintptr_t)210038273ULL); + x1106 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)210038273ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)210038273ULL))>>64); + x1107 = (x19)*((uintptr_t)725204769ULL); + x1108 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)725204769ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)725204769ULL))>>64); + x1109 = (x19)*((uintptr_t)1068522362ULL); + x1110 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)1068522362ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)1068522362ULL))>>64); + x1111 = (x19)*((uintptr_t)673605781ULL); + x1112 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)673605781ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)673605781ULL))>>64); + x1113 = (x19)*((uintptr_t)3557640471ULL); + x1114 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)3557640471ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)3557640471ULL))>>64); + x1115 = (x19)*((uintptr_t)1252728005ULL); + x1116 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)1252728005ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)1252728005ULL))>>64); + x1117 = (x19)*((uintptr_t)3158198330ULL); + x1118 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)3158198330ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)3158198330ULL))>>64); + x1119 = (x19)*((uintptr_t)4239927623ULL); + x1120 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)4239927623ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)4239927623ULL))>>64); + x1121 = (x19)*((uintptr_t)4282221029ULL); + x1122 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)4282221029ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)4282221029ULL))>>64); + x1123 = (x19)*((uintptr_t)3743065113ULL); + x1124 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)3743065113ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)3743065113ULL))>>64); + x1125 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)758225700ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)758225700ULL))>>64); + x1126 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)431229353ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)431229353ULL))>>64); + x1127 = (x1126)+((x19)*((uintptr_t)758225700ULL)); + x1128 = ((uintptr_t)((x1127)<(x1126)))+(x1125); + x1129 = (x1128)+(x1123); + x1130 = (((uintptr_t)((x1128)<(x1125)))+((uintptr_t)((x1129)<(x1123))))+(x1124); + x1131 = (x1130)+(x1121); + x1132 = (((uintptr_t)((x1130)<(x1124)))+((uintptr_t)((x1131)<(x1121))))+(x1122); + x1133 = (x1132)+(x1119); + x1134 = (((uintptr_t)((x1132)<(x1122)))+((uintptr_t)((x1133)<(x1119))))+(x1120); + x1135 = (x1134)+(x1117); + x1136 = (((uintptr_t)((x1134)<(x1120)))+((uintptr_t)((x1135)<(x1117))))+(x1118); + x1137 = (x1136)+(x1115); + x1138 = (((uintptr_t)((x1136)<(x1118)))+((uintptr_t)((x1137)<(x1115))))+(x1116); + x1139 = (x1138)+(x1113); + x1140 = (((uintptr_t)((x1138)<(x1116)))+((uintptr_t)((x1139)<(x1113))))+(x1114); + x1141 = (x1140)+(x1111); + x1142 = (((uintptr_t)((x1140)<(x1114)))+((uintptr_t)((x1141)<(x1111))))+(x1112); + x1143 = (x1142)+(x1109); + x1144 = (((uintptr_t)((x1142)<(x1112)))+((uintptr_t)((x1143)<(x1109))))+(x1110); + x1145 = (x1144)+(x1107); + x1146 = (((uintptr_t)((x1144)<(x1110)))+((uintptr_t)((x1145)<(x1107))))+(x1108); + x1147 = (x1146)+(x1105); + x1148 = ((uintptr_t)((x1146)<(x1108)))+((uintptr_t)((x1147)<(x1105))); + x1149 = (x1081)+((x19)*((uintptr_t)431229353ULL)); + x1150 = ((uintptr_t)((x1149)<(x1081)))+(x1083); + x1151 = (x1150)+(x1127); + x1152 = (((uintptr_t)((x1150)<(x1083)))+((uintptr_t)((x1151)<(x1127))))+(x1085); + x1153 = (x1152)+(x1129); + x1154 = (((uintptr_t)((x1152)<(x1085)))+((uintptr_t)((x1153)<(x1129))))+(x1087); + x1155 = (x1154)+(x1131); + x1156 = (((uintptr_t)((x1154)<(x1087)))+((uintptr_t)((x1155)<(x1131))))+(x1089); + x1157 = (x1156)+(x1133); + x1158 = (((uintptr_t)((x1156)<(x1089)))+((uintptr_t)((x1157)<(x1133))))+(x1091); + x1159 = (x1158)+(x1135); + x1160 = (((uintptr_t)((x1158)<(x1091)))+((uintptr_t)((x1159)<(x1135))))+(x1093); + x1161 = (x1160)+(x1137); + x1162 = (((uintptr_t)((x1160)<(x1093)))+((uintptr_t)((x1161)<(x1137))))+(x1095); + x1163 = (x1162)+(x1139); + x1164 = (((uintptr_t)((x1162)<(x1095)))+((uintptr_t)((x1163)<(x1139))))+(x1097); + x1165 = (x1164)+(x1141); + x1166 = (((uintptr_t)((x1164)<(x1097)))+((uintptr_t)((x1165)<(x1141))))+(x1099); + x1167 = (x1166)+(x1143); + x1168 = (((uintptr_t)((x1166)<(x1099)))+((uintptr_t)((x1167)<(x1143))))+(x1101); + x1169 = (x1168)+(x1145); + x1170 = (((uintptr_t)((x1168)<(x1101)))+((uintptr_t)((x1169)<(x1145))))+(x1103); + x1171 = (x1170)+(x1147); + x1172 = ((uintptr_t)((x1170)<(x1103)))+((uintptr_t)((x1171)<(x1147))); + x1173 = (x1149)*((uintptr_t)3901742149ULL); + x1174 = (x1173)*((uintptr_t)4294967295ULL); + x1175 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1173)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1173)*((uintptr_t)4294967295ULL))>>64); + x1176 = (x1173)*((uintptr_t)4294967295ULL); + x1177 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1173)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1173)*((uintptr_t)4294967295ULL))>>64); + x1178 = (x1173)*((uintptr_t)4294967295ULL); + x1179 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1173)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1173)*((uintptr_t)4294967295ULL))>>64); + x1180 = (x1173)*((uintptr_t)4294967295ULL); + x1181 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1173)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1173)*((uintptr_t)4294967295ULL))>>64); + x1182 = (x1173)*((uintptr_t)4294967295ULL); + x1183 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1173)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1173)*((uintptr_t)4294967295ULL))>>64); + x1184 = (x1173)*((uintptr_t)4294967295ULL); + x1185 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1173)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1173)*((uintptr_t)4294967295ULL))>>64); + x1186 = (x1173)*((uintptr_t)3345173889ULL); + x1187 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1173)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x1173)*((uintptr_t)3345173889ULL))>>64); + x1188 = (x1173)*((uintptr_t)4097256927ULL); + x1189 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1173)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x1173)*((uintptr_t)4097256927ULL))>>64); + x1190 = (x1173)*((uintptr_t)1478102450ULL); + x1191 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1173)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x1173)*((uintptr_t)1478102450ULL))>>64); + x1192 = (x1173)*((uintptr_t)1219536762ULL); + x1193 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1173)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x1173)*((uintptr_t)1219536762ULL))>>64); + x1194 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1173)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x1173)*((uintptr_t)3974895978ULL))>>64); + x1195 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1173)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x1173)*((uintptr_t)3435473267ULL))>>64); + x1196 = (x1195)+((x1173)*((uintptr_t)3974895978ULL)); + x1197 = ((uintptr_t)((x1196)<(x1195)))+(x1194); + x1198 = (x1197)+(x1192); + x1199 = (((uintptr_t)((x1197)<(x1194)))+((uintptr_t)((x1198)<(x1192))))+(x1193); + x1200 = (x1199)+(x1190); + x1201 = (((uintptr_t)((x1199)<(x1193)))+((uintptr_t)((x1200)<(x1190))))+(x1191); + x1202 = (x1201)+(x1188); + x1203 = (((uintptr_t)((x1201)<(x1191)))+((uintptr_t)((x1202)<(x1188))))+(x1189); + x1204 = (x1203)+(x1186); + x1205 = (((uintptr_t)((x1203)<(x1189)))+((uintptr_t)((x1204)<(x1186))))+(x1187); + x1206 = (x1205)+(x1184); + x1207 = (((uintptr_t)((x1205)<(x1187)))+((uintptr_t)((x1206)<(x1184))))+(x1185); + x1208 = (x1207)+(x1182); + x1209 = (((uintptr_t)((x1207)<(x1185)))+((uintptr_t)((x1208)<(x1182))))+(x1183); + x1210 = (x1209)+(x1180); + x1211 = (((uintptr_t)((x1209)<(x1183)))+((uintptr_t)((x1210)<(x1180))))+(x1181); + x1212 = (x1211)+(x1178); + x1213 = (((uintptr_t)((x1211)<(x1181)))+((uintptr_t)((x1212)<(x1178))))+(x1179); + x1214 = (x1213)+(x1176); + x1215 = (((uintptr_t)((x1213)<(x1179)))+((uintptr_t)((x1214)<(x1176))))+(x1177); + x1216 = (x1215)+(x1174); + x1217 = ((uintptr_t)((x1215)<(x1177)))+((uintptr_t)((x1216)<(x1174))); + x1218 = ((uintptr_t)(((x1149)+((x1173)*((uintptr_t)3435473267ULL)))<(x1149)))+(x1151); + x1219 = (x1218)+(x1196); + x1220 = (((uintptr_t)((x1218)<(x1151)))+((uintptr_t)((x1219)<(x1196))))+(x1153); + x1221 = (x1220)+(x1198); + x1222 = (((uintptr_t)((x1220)<(x1153)))+((uintptr_t)((x1221)<(x1198))))+(x1155); + x1223 = (x1222)+(x1200); + x1224 = (((uintptr_t)((x1222)<(x1155)))+((uintptr_t)((x1223)<(x1200))))+(x1157); + x1225 = (x1224)+(x1202); + x1226 = (((uintptr_t)((x1224)<(x1157)))+((uintptr_t)((x1225)<(x1202))))+(x1159); + x1227 = (x1226)+(x1204); + x1228 = (((uintptr_t)((x1226)<(x1159)))+((uintptr_t)((x1227)<(x1204))))+(x1161); + x1229 = (x1228)+(x1206); + x1230 = (((uintptr_t)((x1228)<(x1161)))+((uintptr_t)((x1229)<(x1206))))+(x1163); + x1231 = (x1230)+(x1208); + x1232 = (((uintptr_t)((x1230)<(x1163)))+((uintptr_t)((x1231)<(x1208))))+(x1165); + x1233 = (x1232)+(x1210); + x1234 = (((uintptr_t)((x1232)<(x1165)))+((uintptr_t)((x1233)<(x1210))))+(x1167); + x1235 = (x1234)+(x1212); + x1236 = (((uintptr_t)((x1234)<(x1167)))+((uintptr_t)((x1235)<(x1212))))+(x1169); + x1237 = (x1236)+(x1214); + x1238 = (((uintptr_t)((x1236)<(x1169)))+((uintptr_t)((x1237)<(x1214))))+(x1171); + x1239 = (x1238)+(x1216); + x1240 = (((uintptr_t)((x1238)<(x1171)))+((uintptr_t)((x1239)<(x1216))))+(((x1172)+(x1104))+((x1148)+(x1106))); + x1241 = (x1240)+((x1217)+(x1175)); + x1242 = ((uintptr_t)((x1240)<(((x1172)+(x1104))+((x1148)+(x1106)))))+((uintptr_t)((x1241)<((x1217)+(x1175)))); + x1243 = (x20)*((uintptr_t)210038273ULL); + x1244 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)210038273ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)210038273ULL))>>64); + x1245 = (x20)*((uintptr_t)725204769ULL); + x1246 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)725204769ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)725204769ULL))>>64); + x1247 = (x20)*((uintptr_t)1068522362ULL); + x1248 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)1068522362ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)1068522362ULL))>>64); + x1249 = (x20)*((uintptr_t)673605781ULL); + x1250 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)673605781ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)673605781ULL))>>64); + x1251 = (x20)*((uintptr_t)3557640471ULL); + x1252 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)3557640471ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)3557640471ULL))>>64); + x1253 = (x20)*((uintptr_t)1252728005ULL); + x1254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)1252728005ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)1252728005ULL))>>64); + x1255 = (x20)*((uintptr_t)3158198330ULL); + x1256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)3158198330ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)3158198330ULL))>>64); + x1257 = (x20)*((uintptr_t)4239927623ULL); + x1258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)4239927623ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)4239927623ULL))>>64); + x1259 = (x20)*((uintptr_t)4282221029ULL); + x1260 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)4282221029ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)4282221029ULL))>>64); + x1261 = (x20)*((uintptr_t)3743065113ULL); + x1262 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)3743065113ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)3743065113ULL))>>64); + x1263 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)758225700ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)758225700ULL))>>64); + x1264 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)431229353ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)431229353ULL))>>64); + x1265 = (x1264)+((x20)*((uintptr_t)758225700ULL)); + x1266 = ((uintptr_t)((x1265)<(x1264)))+(x1263); + x1267 = (x1266)+(x1261); + x1268 = (((uintptr_t)((x1266)<(x1263)))+((uintptr_t)((x1267)<(x1261))))+(x1262); + x1269 = (x1268)+(x1259); + x1270 = (((uintptr_t)((x1268)<(x1262)))+((uintptr_t)((x1269)<(x1259))))+(x1260); + x1271 = (x1270)+(x1257); + x1272 = (((uintptr_t)((x1270)<(x1260)))+((uintptr_t)((x1271)<(x1257))))+(x1258); + x1273 = (x1272)+(x1255); + x1274 = (((uintptr_t)((x1272)<(x1258)))+((uintptr_t)((x1273)<(x1255))))+(x1256); + x1275 = (x1274)+(x1253); + x1276 = (((uintptr_t)((x1274)<(x1256)))+((uintptr_t)((x1275)<(x1253))))+(x1254); + x1277 = (x1276)+(x1251); + x1278 = (((uintptr_t)((x1276)<(x1254)))+((uintptr_t)((x1277)<(x1251))))+(x1252); + x1279 = (x1278)+(x1249); + x1280 = (((uintptr_t)((x1278)<(x1252)))+((uintptr_t)((x1279)<(x1249))))+(x1250); + x1281 = (x1280)+(x1247); + x1282 = (((uintptr_t)((x1280)<(x1250)))+((uintptr_t)((x1281)<(x1247))))+(x1248); + x1283 = (x1282)+(x1245); + x1284 = (((uintptr_t)((x1282)<(x1248)))+((uintptr_t)((x1283)<(x1245))))+(x1246); + x1285 = (x1284)+(x1243); + x1286 = ((uintptr_t)((x1284)<(x1246)))+((uintptr_t)((x1285)<(x1243))); + x1287 = (x1219)+((x20)*((uintptr_t)431229353ULL)); + x1288 = ((uintptr_t)((x1287)<(x1219)))+(x1221); + x1289 = (x1288)+(x1265); + x1290 = (((uintptr_t)((x1288)<(x1221)))+((uintptr_t)((x1289)<(x1265))))+(x1223); + x1291 = (x1290)+(x1267); + x1292 = (((uintptr_t)((x1290)<(x1223)))+((uintptr_t)((x1291)<(x1267))))+(x1225); + x1293 = (x1292)+(x1269); + x1294 = (((uintptr_t)((x1292)<(x1225)))+((uintptr_t)((x1293)<(x1269))))+(x1227); + x1295 = (x1294)+(x1271); + x1296 = (((uintptr_t)((x1294)<(x1227)))+((uintptr_t)((x1295)<(x1271))))+(x1229); + x1297 = (x1296)+(x1273); + x1298 = (((uintptr_t)((x1296)<(x1229)))+((uintptr_t)((x1297)<(x1273))))+(x1231); + x1299 = (x1298)+(x1275); + x1300 = (((uintptr_t)((x1298)<(x1231)))+((uintptr_t)((x1299)<(x1275))))+(x1233); + x1301 = (x1300)+(x1277); + x1302 = (((uintptr_t)((x1300)<(x1233)))+((uintptr_t)((x1301)<(x1277))))+(x1235); + x1303 = (x1302)+(x1279); + x1304 = (((uintptr_t)((x1302)<(x1235)))+((uintptr_t)((x1303)<(x1279))))+(x1237); + x1305 = (x1304)+(x1281); + x1306 = (((uintptr_t)((x1304)<(x1237)))+((uintptr_t)((x1305)<(x1281))))+(x1239); + x1307 = (x1306)+(x1283); + x1308 = (((uintptr_t)((x1306)<(x1239)))+((uintptr_t)((x1307)<(x1283))))+(x1241); + x1309 = (x1308)+(x1285); + x1310 = ((uintptr_t)((x1308)<(x1241)))+((uintptr_t)((x1309)<(x1285))); + x1311 = (x1287)*((uintptr_t)3901742149ULL); + x1312 = (x1311)*((uintptr_t)4294967295ULL); + x1313 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1311)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1311)*((uintptr_t)4294967295ULL))>>64); + x1314 = (x1311)*((uintptr_t)4294967295ULL); + x1315 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1311)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1311)*((uintptr_t)4294967295ULL))>>64); + x1316 = (x1311)*((uintptr_t)4294967295ULL); + x1317 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1311)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1311)*((uintptr_t)4294967295ULL))>>64); + x1318 = (x1311)*((uintptr_t)4294967295ULL); + x1319 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1311)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1311)*((uintptr_t)4294967295ULL))>>64); + x1320 = (x1311)*((uintptr_t)4294967295ULL); + x1321 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1311)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1311)*((uintptr_t)4294967295ULL))>>64); + x1322 = (x1311)*((uintptr_t)4294967295ULL); + x1323 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1311)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1311)*((uintptr_t)4294967295ULL))>>64); + x1324 = (x1311)*((uintptr_t)3345173889ULL); + x1325 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1311)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x1311)*((uintptr_t)3345173889ULL))>>64); + x1326 = (x1311)*((uintptr_t)4097256927ULL); + x1327 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1311)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x1311)*((uintptr_t)4097256927ULL))>>64); + x1328 = (x1311)*((uintptr_t)1478102450ULL); + x1329 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1311)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x1311)*((uintptr_t)1478102450ULL))>>64); + x1330 = (x1311)*((uintptr_t)1219536762ULL); + x1331 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1311)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x1311)*((uintptr_t)1219536762ULL))>>64); + x1332 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1311)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x1311)*((uintptr_t)3974895978ULL))>>64); + x1333 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1311)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x1311)*((uintptr_t)3435473267ULL))>>64); + x1334 = (x1333)+((x1311)*((uintptr_t)3974895978ULL)); + x1335 = ((uintptr_t)((x1334)<(x1333)))+(x1332); + x1336 = (x1335)+(x1330); + x1337 = (((uintptr_t)((x1335)<(x1332)))+((uintptr_t)((x1336)<(x1330))))+(x1331); + x1338 = (x1337)+(x1328); + x1339 = (((uintptr_t)((x1337)<(x1331)))+((uintptr_t)((x1338)<(x1328))))+(x1329); + x1340 = (x1339)+(x1326); + x1341 = (((uintptr_t)((x1339)<(x1329)))+((uintptr_t)((x1340)<(x1326))))+(x1327); + x1342 = (x1341)+(x1324); + x1343 = (((uintptr_t)((x1341)<(x1327)))+((uintptr_t)((x1342)<(x1324))))+(x1325); + x1344 = (x1343)+(x1322); + x1345 = (((uintptr_t)((x1343)<(x1325)))+((uintptr_t)((x1344)<(x1322))))+(x1323); + x1346 = (x1345)+(x1320); + x1347 = (((uintptr_t)((x1345)<(x1323)))+((uintptr_t)((x1346)<(x1320))))+(x1321); + x1348 = (x1347)+(x1318); + x1349 = (((uintptr_t)((x1347)<(x1321)))+((uintptr_t)((x1348)<(x1318))))+(x1319); + x1350 = (x1349)+(x1316); + x1351 = (((uintptr_t)((x1349)<(x1319)))+((uintptr_t)((x1350)<(x1316))))+(x1317); + x1352 = (x1351)+(x1314); + x1353 = (((uintptr_t)((x1351)<(x1317)))+((uintptr_t)((x1352)<(x1314))))+(x1315); + x1354 = (x1353)+(x1312); + x1355 = ((uintptr_t)((x1353)<(x1315)))+((uintptr_t)((x1354)<(x1312))); + x1356 = ((uintptr_t)(((x1287)+((x1311)*((uintptr_t)3435473267ULL)))<(x1287)))+(x1289); + x1357 = (x1356)+(x1334); + x1358 = (((uintptr_t)((x1356)<(x1289)))+((uintptr_t)((x1357)<(x1334))))+(x1291); + x1359 = (x1358)+(x1336); + x1360 = (((uintptr_t)((x1358)<(x1291)))+((uintptr_t)((x1359)<(x1336))))+(x1293); + x1361 = (x1360)+(x1338); + x1362 = (((uintptr_t)((x1360)<(x1293)))+((uintptr_t)((x1361)<(x1338))))+(x1295); + x1363 = (x1362)+(x1340); + x1364 = (((uintptr_t)((x1362)<(x1295)))+((uintptr_t)((x1363)<(x1340))))+(x1297); + x1365 = (x1364)+(x1342); + x1366 = (((uintptr_t)((x1364)<(x1297)))+((uintptr_t)((x1365)<(x1342))))+(x1299); + x1367 = (x1366)+(x1344); + x1368 = (((uintptr_t)((x1366)<(x1299)))+((uintptr_t)((x1367)<(x1344))))+(x1301); + x1369 = (x1368)+(x1346); + x1370 = (((uintptr_t)((x1368)<(x1301)))+((uintptr_t)((x1369)<(x1346))))+(x1303); + x1371 = (x1370)+(x1348); + x1372 = (((uintptr_t)((x1370)<(x1303)))+((uintptr_t)((x1371)<(x1348))))+(x1305); + x1373 = (x1372)+(x1350); + x1374 = (((uintptr_t)((x1372)<(x1305)))+((uintptr_t)((x1373)<(x1350))))+(x1307); + x1375 = (x1374)+(x1352); + x1376 = (((uintptr_t)((x1374)<(x1307)))+((uintptr_t)((x1375)<(x1352))))+(x1309); + x1377 = (x1376)+(x1354); + x1378 = (((uintptr_t)((x1376)<(x1309)))+((uintptr_t)((x1377)<(x1354))))+(((x1310)+(x1242))+((x1286)+(x1244))); + x1379 = (x1378)+((x1355)+(x1313)); + x1380 = ((uintptr_t)((x1378)<(((x1310)+(x1242))+((x1286)+(x1244)))))+((uintptr_t)((x1379)<((x1355)+(x1313)))); + x1381 = (x21)*((uintptr_t)210038273ULL); + x1382 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)210038273ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)210038273ULL))>>64); + x1383 = (x21)*((uintptr_t)725204769ULL); + x1384 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)725204769ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)725204769ULL))>>64); + x1385 = (x21)*((uintptr_t)1068522362ULL); + x1386 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)1068522362ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)1068522362ULL))>>64); + x1387 = (x21)*((uintptr_t)673605781ULL); + x1388 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)673605781ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)673605781ULL))>>64); + x1389 = (x21)*((uintptr_t)3557640471ULL); + x1390 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)3557640471ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)3557640471ULL))>>64); + x1391 = (x21)*((uintptr_t)1252728005ULL); + x1392 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)1252728005ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)1252728005ULL))>>64); + x1393 = (x21)*((uintptr_t)3158198330ULL); + x1394 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)3158198330ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)3158198330ULL))>>64); + x1395 = (x21)*((uintptr_t)4239927623ULL); + x1396 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)4239927623ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)4239927623ULL))>>64); + x1397 = (x21)*((uintptr_t)4282221029ULL); + x1398 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)4282221029ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)4282221029ULL))>>64); + x1399 = (x21)*((uintptr_t)3743065113ULL); + x1400 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)3743065113ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)3743065113ULL))>>64); + x1401 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)758225700ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)758225700ULL))>>64); + x1402 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)431229353ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)431229353ULL))>>64); + x1403 = (x1402)+((x21)*((uintptr_t)758225700ULL)); + x1404 = ((uintptr_t)((x1403)<(x1402)))+(x1401); + x1405 = (x1404)+(x1399); + x1406 = (((uintptr_t)((x1404)<(x1401)))+((uintptr_t)((x1405)<(x1399))))+(x1400); + x1407 = (x1406)+(x1397); + x1408 = (((uintptr_t)((x1406)<(x1400)))+((uintptr_t)((x1407)<(x1397))))+(x1398); + x1409 = (x1408)+(x1395); + x1410 = (((uintptr_t)((x1408)<(x1398)))+((uintptr_t)((x1409)<(x1395))))+(x1396); + x1411 = (x1410)+(x1393); + x1412 = (((uintptr_t)((x1410)<(x1396)))+((uintptr_t)((x1411)<(x1393))))+(x1394); + x1413 = (x1412)+(x1391); + x1414 = (((uintptr_t)((x1412)<(x1394)))+((uintptr_t)((x1413)<(x1391))))+(x1392); + x1415 = (x1414)+(x1389); + x1416 = (((uintptr_t)((x1414)<(x1392)))+((uintptr_t)((x1415)<(x1389))))+(x1390); + x1417 = (x1416)+(x1387); + x1418 = (((uintptr_t)((x1416)<(x1390)))+((uintptr_t)((x1417)<(x1387))))+(x1388); + x1419 = (x1418)+(x1385); + x1420 = (((uintptr_t)((x1418)<(x1388)))+((uintptr_t)((x1419)<(x1385))))+(x1386); + x1421 = (x1420)+(x1383); + x1422 = (((uintptr_t)((x1420)<(x1386)))+((uintptr_t)((x1421)<(x1383))))+(x1384); + x1423 = (x1422)+(x1381); + x1424 = ((uintptr_t)((x1422)<(x1384)))+((uintptr_t)((x1423)<(x1381))); + x1425 = (x1357)+((x21)*((uintptr_t)431229353ULL)); + x1426 = ((uintptr_t)((x1425)<(x1357)))+(x1359); + x1427 = (x1426)+(x1403); + x1428 = (((uintptr_t)((x1426)<(x1359)))+((uintptr_t)((x1427)<(x1403))))+(x1361); + x1429 = (x1428)+(x1405); + x1430 = (((uintptr_t)((x1428)<(x1361)))+((uintptr_t)((x1429)<(x1405))))+(x1363); + x1431 = (x1430)+(x1407); + x1432 = (((uintptr_t)((x1430)<(x1363)))+((uintptr_t)((x1431)<(x1407))))+(x1365); + x1433 = (x1432)+(x1409); + x1434 = (((uintptr_t)((x1432)<(x1365)))+((uintptr_t)((x1433)<(x1409))))+(x1367); + x1435 = (x1434)+(x1411); + x1436 = (((uintptr_t)((x1434)<(x1367)))+((uintptr_t)((x1435)<(x1411))))+(x1369); + x1437 = (x1436)+(x1413); + x1438 = (((uintptr_t)((x1436)<(x1369)))+((uintptr_t)((x1437)<(x1413))))+(x1371); + x1439 = (x1438)+(x1415); + x1440 = (((uintptr_t)((x1438)<(x1371)))+((uintptr_t)((x1439)<(x1415))))+(x1373); + x1441 = (x1440)+(x1417); + x1442 = (((uintptr_t)((x1440)<(x1373)))+((uintptr_t)((x1441)<(x1417))))+(x1375); + x1443 = (x1442)+(x1419); + x1444 = (((uintptr_t)((x1442)<(x1375)))+((uintptr_t)((x1443)<(x1419))))+(x1377); + x1445 = (x1444)+(x1421); + x1446 = (((uintptr_t)((x1444)<(x1377)))+((uintptr_t)((x1445)<(x1421))))+(x1379); + x1447 = (x1446)+(x1423); + x1448 = ((uintptr_t)((x1446)<(x1379)))+((uintptr_t)((x1447)<(x1423))); + x1449 = (x1425)*((uintptr_t)3901742149ULL); + x1450 = (x1449)*((uintptr_t)4294967295ULL); + x1451 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1449)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1449)*((uintptr_t)4294967295ULL))>>64); + x1452 = (x1449)*((uintptr_t)4294967295ULL); + x1453 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1449)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1449)*((uintptr_t)4294967295ULL))>>64); + x1454 = (x1449)*((uintptr_t)4294967295ULL); + x1455 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1449)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1449)*((uintptr_t)4294967295ULL))>>64); + x1456 = (x1449)*((uintptr_t)4294967295ULL); + x1457 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1449)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1449)*((uintptr_t)4294967295ULL))>>64); + x1458 = (x1449)*((uintptr_t)4294967295ULL); + x1459 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1449)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1449)*((uintptr_t)4294967295ULL))>>64); + x1460 = (x1449)*((uintptr_t)4294967295ULL); + x1461 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1449)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1449)*((uintptr_t)4294967295ULL))>>64); + x1462 = (x1449)*((uintptr_t)3345173889ULL); + x1463 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1449)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x1449)*((uintptr_t)3345173889ULL))>>64); + x1464 = (x1449)*((uintptr_t)4097256927ULL); + x1465 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1449)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x1449)*((uintptr_t)4097256927ULL))>>64); + x1466 = (x1449)*((uintptr_t)1478102450ULL); + x1467 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1449)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x1449)*((uintptr_t)1478102450ULL))>>64); + x1468 = (x1449)*((uintptr_t)1219536762ULL); + x1469 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1449)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x1449)*((uintptr_t)1219536762ULL))>>64); + x1470 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1449)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x1449)*((uintptr_t)3974895978ULL))>>64); + x1471 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1449)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x1449)*((uintptr_t)3435473267ULL))>>64); + x1472 = (x1471)+((x1449)*((uintptr_t)3974895978ULL)); + x1473 = ((uintptr_t)((x1472)<(x1471)))+(x1470); + x1474 = (x1473)+(x1468); + x1475 = (((uintptr_t)((x1473)<(x1470)))+((uintptr_t)((x1474)<(x1468))))+(x1469); + x1476 = (x1475)+(x1466); + x1477 = (((uintptr_t)((x1475)<(x1469)))+((uintptr_t)((x1476)<(x1466))))+(x1467); + x1478 = (x1477)+(x1464); + x1479 = (((uintptr_t)((x1477)<(x1467)))+((uintptr_t)((x1478)<(x1464))))+(x1465); + x1480 = (x1479)+(x1462); + x1481 = (((uintptr_t)((x1479)<(x1465)))+((uintptr_t)((x1480)<(x1462))))+(x1463); + x1482 = (x1481)+(x1460); + x1483 = (((uintptr_t)((x1481)<(x1463)))+((uintptr_t)((x1482)<(x1460))))+(x1461); + x1484 = (x1483)+(x1458); + x1485 = (((uintptr_t)((x1483)<(x1461)))+((uintptr_t)((x1484)<(x1458))))+(x1459); + x1486 = (x1485)+(x1456); + x1487 = (((uintptr_t)((x1485)<(x1459)))+((uintptr_t)((x1486)<(x1456))))+(x1457); + x1488 = (x1487)+(x1454); + x1489 = (((uintptr_t)((x1487)<(x1457)))+((uintptr_t)((x1488)<(x1454))))+(x1455); + x1490 = (x1489)+(x1452); + x1491 = (((uintptr_t)((x1489)<(x1455)))+((uintptr_t)((x1490)<(x1452))))+(x1453); + x1492 = (x1491)+(x1450); + x1493 = ((uintptr_t)((x1491)<(x1453)))+((uintptr_t)((x1492)<(x1450))); + x1494 = ((uintptr_t)(((x1425)+((x1449)*((uintptr_t)3435473267ULL)))<(x1425)))+(x1427); + x1495 = (x1494)+(x1472); + x1496 = (((uintptr_t)((x1494)<(x1427)))+((uintptr_t)((x1495)<(x1472))))+(x1429); + x1497 = (x1496)+(x1474); + x1498 = (((uintptr_t)((x1496)<(x1429)))+((uintptr_t)((x1497)<(x1474))))+(x1431); + x1499 = (x1498)+(x1476); + x1500 = (((uintptr_t)((x1498)<(x1431)))+((uintptr_t)((x1499)<(x1476))))+(x1433); + x1501 = (x1500)+(x1478); + x1502 = (((uintptr_t)((x1500)<(x1433)))+((uintptr_t)((x1501)<(x1478))))+(x1435); + x1503 = (x1502)+(x1480); + x1504 = (((uintptr_t)((x1502)<(x1435)))+((uintptr_t)((x1503)<(x1480))))+(x1437); + x1505 = (x1504)+(x1482); + x1506 = (((uintptr_t)((x1504)<(x1437)))+((uintptr_t)((x1505)<(x1482))))+(x1439); + x1507 = (x1506)+(x1484); + x1508 = (((uintptr_t)((x1506)<(x1439)))+((uintptr_t)((x1507)<(x1484))))+(x1441); + x1509 = (x1508)+(x1486); + x1510 = (((uintptr_t)((x1508)<(x1441)))+((uintptr_t)((x1509)<(x1486))))+(x1443); + x1511 = (x1510)+(x1488); + x1512 = (((uintptr_t)((x1510)<(x1443)))+((uintptr_t)((x1511)<(x1488))))+(x1445); + x1513 = (x1512)+(x1490); + x1514 = (((uintptr_t)((x1512)<(x1445)))+((uintptr_t)((x1513)<(x1490))))+(x1447); + x1515 = (x1514)+(x1492); + x1516 = (((uintptr_t)((x1514)<(x1447)))+((uintptr_t)((x1515)<(x1492))))+(((x1448)+(x1380))+((x1424)+(x1382))); + x1517 = (x1516)+((x1493)+(x1451)); + x1518 = ((uintptr_t)((x1516)<(((x1448)+(x1380))+((x1424)+(x1382)))))+((uintptr_t)((x1517)<((x1493)+(x1451)))); + x1519 = (x22)*((uintptr_t)210038273ULL); + x1520 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)210038273ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)210038273ULL))>>64); + x1521 = (x22)*((uintptr_t)725204769ULL); + x1522 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)725204769ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)725204769ULL))>>64); + x1523 = (x22)*((uintptr_t)1068522362ULL); + x1524 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)1068522362ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)1068522362ULL))>>64); + x1525 = (x22)*((uintptr_t)673605781ULL); + x1526 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)673605781ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)673605781ULL))>>64); + x1527 = (x22)*((uintptr_t)3557640471ULL); + x1528 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)3557640471ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)3557640471ULL))>>64); + x1529 = (x22)*((uintptr_t)1252728005ULL); + x1530 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)1252728005ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)1252728005ULL))>>64); + x1531 = (x22)*((uintptr_t)3158198330ULL); + x1532 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)3158198330ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)3158198330ULL))>>64); + x1533 = (x22)*((uintptr_t)4239927623ULL); + x1534 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)4239927623ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)4239927623ULL))>>64); + x1535 = (x22)*((uintptr_t)4282221029ULL); + x1536 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)4282221029ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)4282221029ULL))>>64); + x1537 = (x22)*((uintptr_t)3743065113ULL); + x1538 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)3743065113ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)3743065113ULL))>>64); + x1539 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)758225700ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)758225700ULL))>>64); + x1540 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)431229353ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)431229353ULL))>>64); + x1541 = (x1540)+((x22)*((uintptr_t)758225700ULL)); + x1542 = ((uintptr_t)((x1541)<(x1540)))+(x1539); + x1543 = (x1542)+(x1537); + x1544 = (((uintptr_t)((x1542)<(x1539)))+((uintptr_t)((x1543)<(x1537))))+(x1538); + x1545 = (x1544)+(x1535); + x1546 = (((uintptr_t)((x1544)<(x1538)))+((uintptr_t)((x1545)<(x1535))))+(x1536); + x1547 = (x1546)+(x1533); + x1548 = (((uintptr_t)((x1546)<(x1536)))+((uintptr_t)((x1547)<(x1533))))+(x1534); + x1549 = (x1548)+(x1531); + x1550 = (((uintptr_t)((x1548)<(x1534)))+((uintptr_t)((x1549)<(x1531))))+(x1532); + x1551 = (x1550)+(x1529); + x1552 = (((uintptr_t)((x1550)<(x1532)))+((uintptr_t)((x1551)<(x1529))))+(x1530); + x1553 = (x1552)+(x1527); + x1554 = (((uintptr_t)((x1552)<(x1530)))+((uintptr_t)((x1553)<(x1527))))+(x1528); + x1555 = (x1554)+(x1525); + x1556 = (((uintptr_t)((x1554)<(x1528)))+((uintptr_t)((x1555)<(x1525))))+(x1526); + x1557 = (x1556)+(x1523); + x1558 = (((uintptr_t)((x1556)<(x1526)))+((uintptr_t)((x1557)<(x1523))))+(x1524); + x1559 = (x1558)+(x1521); + x1560 = (((uintptr_t)((x1558)<(x1524)))+((uintptr_t)((x1559)<(x1521))))+(x1522); + x1561 = (x1560)+(x1519); + x1562 = ((uintptr_t)((x1560)<(x1522)))+((uintptr_t)((x1561)<(x1519))); + x1563 = (x1495)+((x22)*((uintptr_t)431229353ULL)); + x1564 = ((uintptr_t)((x1563)<(x1495)))+(x1497); + x1565 = (x1564)+(x1541); + x1566 = (((uintptr_t)((x1564)<(x1497)))+((uintptr_t)((x1565)<(x1541))))+(x1499); + x1567 = (x1566)+(x1543); + x1568 = (((uintptr_t)((x1566)<(x1499)))+((uintptr_t)((x1567)<(x1543))))+(x1501); + x1569 = (x1568)+(x1545); + x1570 = (((uintptr_t)((x1568)<(x1501)))+((uintptr_t)((x1569)<(x1545))))+(x1503); + x1571 = (x1570)+(x1547); + x1572 = (((uintptr_t)((x1570)<(x1503)))+((uintptr_t)((x1571)<(x1547))))+(x1505); + x1573 = (x1572)+(x1549); + x1574 = (((uintptr_t)((x1572)<(x1505)))+((uintptr_t)((x1573)<(x1549))))+(x1507); + x1575 = (x1574)+(x1551); + x1576 = (((uintptr_t)((x1574)<(x1507)))+((uintptr_t)((x1575)<(x1551))))+(x1509); + x1577 = (x1576)+(x1553); + x1578 = (((uintptr_t)((x1576)<(x1509)))+((uintptr_t)((x1577)<(x1553))))+(x1511); + x1579 = (x1578)+(x1555); + x1580 = (((uintptr_t)((x1578)<(x1511)))+((uintptr_t)((x1579)<(x1555))))+(x1513); + x1581 = (x1580)+(x1557); + x1582 = (((uintptr_t)((x1580)<(x1513)))+((uintptr_t)((x1581)<(x1557))))+(x1515); + x1583 = (x1582)+(x1559); + x1584 = (((uintptr_t)((x1582)<(x1515)))+((uintptr_t)((x1583)<(x1559))))+(x1517); + x1585 = (x1584)+(x1561); + x1586 = ((uintptr_t)((x1584)<(x1517)))+((uintptr_t)((x1585)<(x1561))); + x1587 = (x1563)*((uintptr_t)3901742149ULL); + x1588 = (x1587)*((uintptr_t)4294967295ULL); + x1589 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1587)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1587)*((uintptr_t)4294967295ULL))>>64); + x1590 = (x1587)*((uintptr_t)4294967295ULL); + x1591 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1587)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1587)*((uintptr_t)4294967295ULL))>>64); + x1592 = (x1587)*((uintptr_t)4294967295ULL); + x1593 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1587)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1587)*((uintptr_t)4294967295ULL))>>64); + x1594 = (x1587)*((uintptr_t)4294967295ULL); + x1595 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1587)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1587)*((uintptr_t)4294967295ULL))>>64); + x1596 = (x1587)*((uintptr_t)4294967295ULL); + x1597 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1587)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1587)*((uintptr_t)4294967295ULL))>>64); + x1598 = (x1587)*((uintptr_t)4294967295ULL); + x1599 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1587)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1587)*((uintptr_t)4294967295ULL))>>64); + x1600 = (x1587)*((uintptr_t)3345173889ULL); + x1601 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1587)*((uintptr_t)3345173889ULL))>>32 : ((__uint128_t)(x1587)*((uintptr_t)3345173889ULL))>>64); + x1602 = (x1587)*((uintptr_t)4097256927ULL); + x1603 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1587)*((uintptr_t)4097256927ULL))>>32 : ((__uint128_t)(x1587)*((uintptr_t)4097256927ULL))>>64); + x1604 = (x1587)*((uintptr_t)1478102450ULL); + x1605 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1587)*((uintptr_t)1478102450ULL))>>32 : ((__uint128_t)(x1587)*((uintptr_t)1478102450ULL))>>64); + x1606 = (x1587)*((uintptr_t)1219536762ULL); + x1607 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1587)*((uintptr_t)1219536762ULL))>>32 : ((__uint128_t)(x1587)*((uintptr_t)1219536762ULL))>>64); + x1608 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1587)*((uintptr_t)3974895978ULL))>>32 : ((__uint128_t)(x1587)*((uintptr_t)3974895978ULL))>>64); + x1609 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1587)*((uintptr_t)3435473267ULL))>>32 : ((__uint128_t)(x1587)*((uintptr_t)3435473267ULL))>>64); + x1610 = (x1609)+((x1587)*((uintptr_t)3974895978ULL)); + x1611 = ((uintptr_t)((x1610)<(x1609)))+(x1608); + x1612 = (x1611)+(x1606); + x1613 = (((uintptr_t)((x1611)<(x1608)))+((uintptr_t)((x1612)<(x1606))))+(x1607); + x1614 = (x1613)+(x1604); + x1615 = (((uintptr_t)((x1613)<(x1607)))+((uintptr_t)((x1614)<(x1604))))+(x1605); + x1616 = (x1615)+(x1602); + x1617 = (((uintptr_t)((x1615)<(x1605)))+((uintptr_t)((x1616)<(x1602))))+(x1603); + x1618 = (x1617)+(x1600); + x1619 = (((uintptr_t)((x1617)<(x1603)))+((uintptr_t)((x1618)<(x1600))))+(x1601); + x1620 = (x1619)+(x1598); + x1621 = (((uintptr_t)((x1619)<(x1601)))+((uintptr_t)((x1620)<(x1598))))+(x1599); + x1622 = (x1621)+(x1596); + x1623 = (((uintptr_t)((x1621)<(x1599)))+((uintptr_t)((x1622)<(x1596))))+(x1597); + x1624 = (x1623)+(x1594); + x1625 = (((uintptr_t)((x1623)<(x1597)))+((uintptr_t)((x1624)<(x1594))))+(x1595); + x1626 = (x1625)+(x1592); + x1627 = (((uintptr_t)((x1625)<(x1595)))+((uintptr_t)((x1626)<(x1592))))+(x1593); + x1628 = (x1627)+(x1590); + x1629 = (((uintptr_t)((x1627)<(x1593)))+((uintptr_t)((x1628)<(x1590))))+(x1591); + x1630 = (x1629)+(x1588); + x1631 = ((uintptr_t)((x1629)<(x1591)))+((uintptr_t)((x1630)<(x1588))); + x1632 = ((uintptr_t)(((x1563)+((x1587)*((uintptr_t)3435473267ULL)))<(x1563)))+(x1565); + x1633 = (x1632)+(x1610); + x1634 = (((uintptr_t)((x1632)<(x1565)))+((uintptr_t)((x1633)<(x1610))))+(x1567); + x1635 = (x1634)+(x1612); + x1636 = (((uintptr_t)((x1634)<(x1567)))+((uintptr_t)((x1635)<(x1612))))+(x1569); + x1637 = (x1636)+(x1614); + x1638 = (((uintptr_t)((x1636)<(x1569)))+((uintptr_t)((x1637)<(x1614))))+(x1571); + x1639 = (x1638)+(x1616); + x1640 = (((uintptr_t)((x1638)<(x1571)))+((uintptr_t)((x1639)<(x1616))))+(x1573); + x1641 = (x1640)+(x1618); + x1642 = (((uintptr_t)((x1640)<(x1573)))+((uintptr_t)((x1641)<(x1618))))+(x1575); + x1643 = (x1642)+(x1620); + x1644 = (((uintptr_t)((x1642)<(x1575)))+((uintptr_t)((x1643)<(x1620))))+(x1577); + x1645 = (x1644)+(x1622); + x1646 = (((uintptr_t)((x1644)<(x1577)))+((uintptr_t)((x1645)<(x1622))))+(x1579); + x1647 = (x1646)+(x1624); + x1648 = (((uintptr_t)((x1646)<(x1579)))+((uintptr_t)((x1647)<(x1624))))+(x1581); + x1649 = (x1648)+(x1626); + x1650 = (((uintptr_t)((x1648)<(x1581)))+((uintptr_t)((x1649)<(x1626))))+(x1583); + x1651 = (x1650)+(x1628); + x1652 = (((uintptr_t)((x1650)<(x1583)))+((uintptr_t)((x1651)<(x1628))))+(x1585); + x1653 = (x1652)+(x1630); + x1654 = (((uintptr_t)((x1652)<(x1585)))+((uintptr_t)((x1653)<(x1630))))+(((x1586)+(x1518))+((x1562)+(x1520))); + x1655 = (x1654)+((x1631)+(x1589)); + x1656 = ((uintptr_t)((x1654)<(((x1586)+(x1518))+((x1562)+(x1520)))))+((uintptr_t)((x1655)<((x1631)+(x1589)))); + x1657 = (x1633)-((uintptr_t)3435473267ULL); + x1658 = (x1635)-((uintptr_t)3974895978ULL); + x1659 = (x1658)-((uintptr_t)((x1633)<(x1657))); + x1660 = (x1637)-((uintptr_t)1219536762ULL); + x1661 = (x1660)-(((uintptr_t)((x1635)<(x1658)))+((uintptr_t)((x1658)<(x1659)))); + x1662 = (x1639)-((uintptr_t)1478102450ULL); + x1663 = (x1662)-(((uintptr_t)((x1637)<(x1660)))+((uintptr_t)((x1660)<(x1661)))); + x1664 = (x1641)-((uintptr_t)4097256927ULL); + x1665 = (x1664)-(((uintptr_t)((x1639)<(x1662)))+((uintptr_t)((x1662)<(x1663)))); + x1666 = (x1643)-((uintptr_t)3345173889ULL); + x1667 = (x1666)-(((uintptr_t)((x1641)<(x1664)))+((uintptr_t)((x1664)<(x1665)))); + x1668 = (x1645)-((uintptr_t)4294967295ULL); + x1669 = (x1668)-(((uintptr_t)((x1643)<(x1666)))+((uintptr_t)((x1666)<(x1667)))); + x1670 = (x1647)-((uintptr_t)4294967295ULL); + x1671 = (x1670)-(((uintptr_t)((x1645)<(x1668)))+((uintptr_t)((x1668)<(x1669)))); + x1672 = (x1649)-((uintptr_t)4294967295ULL); + x1673 = (x1672)-(((uintptr_t)((x1647)<(x1670)))+((uintptr_t)((x1670)<(x1671)))); + x1674 = (x1651)-((uintptr_t)4294967295ULL); + x1675 = (x1674)-(((uintptr_t)((x1649)<(x1672)))+((uintptr_t)((x1672)<(x1673)))); + x1676 = (x1653)-((uintptr_t)4294967295ULL); + x1677 = (x1676)-(((uintptr_t)((x1651)<(x1674)))+((uintptr_t)((x1674)<(x1675)))); + x1678 = (x1655)-((uintptr_t)4294967295ULL); + x1679 = (x1678)-(((uintptr_t)((x1653)<(x1676)))+((uintptr_t)((x1676)<(x1677)))); + x1680 = (uintptr_t)((x1656)<((x1656)-(((uintptr_t)((x1655)<(x1678)))+((uintptr_t)((x1678)<(x1679)))))); + x1681 = ((uintptr_t)-1ULL)+((uintptr_t)((x1680)==((uintptr_t)0ULL))); + x1682 = (x1681)^((uintptr_t)4294967295ULL); + x1683 = ((x1633)&(x1681))|((x1657)&(x1682)); + x1684 = ((uintptr_t)-1ULL)+((uintptr_t)((x1680)==((uintptr_t)0ULL))); + x1685 = (x1684)^((uintptr_t)4294967295ULL); + x1686 = ((x1635)&(x1684))|((x1659)&(x1685)); + x1687 = ((uintptr_t)-1ULL)+((uintptr_t)((x1680)==((uintptr_t)0ULL))); + x1688 = (x1687)^((uintptr_t)4294967295ULL); + x1689 = ((x1637)&(x1687))|((x1661)&(x1688)); + x1690 = ((uintptr_t)-1ULL)+((uintptr_t)((x1680)==((uintptr_t)0ULL))); + x1691 = (x1690)^((uintptr_t)4294967295ULL); + x1692 = ((x1639)&(x1690))|((x1663)&(x1691)); + x1693 = ((uintptr_t)-1ULL)+((uintptr_t)((x1680)==((uintptr_t)0ULL))); + x1694 = (x1693)^((uintptr_t)4294967295ULL); + x1695 = ((x1641)&(x1693))|((x1665)&(x1694)); + x1696 = ((uintptr_t)-1ULL)+((uintptr_t)((x1680)==((uintptr_t)0ULL))); + x1697 = (x1696)^((uintptr_t)4294967295ULL); + x1698 = ((x1643)&(x1696))|((x1667)&(x1697)); + x1699 = ((uintptr_t)-1ULL)+((uintptr_t)((x1680)==((uintptr_t)0ULL))); + x1700 = (x1699)^((uintptr_t)4294967295ULL); + x1701 = ((x1645)&(x1699))|((x1669)&(x1700)); + x1702 = ((uintptr_t)-1ULL)+((uintptr_t)((x1680)==((uintptr_t)0ULL))); + x1703 = (x1702)^((uintptr_t)4294967295ULL); + x1704 = ((x1647)&(x1702))|((x1671)&(x1703)); + x1705 = ((uintptr_t)-1ULL)+((uintptr_t)((x1680)==((uintptr_t)0ULL))); + x1706 = (x1705)^((uintptr_t)4294967295ULL); + x1707 = ((x1649)&(x1705))|((x1673)&(x1706)); + x1708 = ((uintptr_t)-1ULL)+((uintptr_t)((x1680)==((uintptr_t)0ULL))); + x1709 = (x1708)^((uintptr_t)4294967295ULL); + x1710 = ((x1651)&(x1708))|((x1675)&(x1709)); + x1711 = ((uintptr_t)-1ULL)+((uintptr_t)((x1680)==((uintptr_t)0ULL))); + x1712 = (x1711)^((uintptr_t)4294967295ULL); + x1713 = ((x1653)&(x1711))|((x1677)&(x1712)); + x1714 = ((uintptr_t)-1ULL)+((uintptr_t)((x1680)==((uintptr_t)0ULL))); + x1715 = (x1714)^((uintptr_t)4294967295ULL); + x1716 = ((x1655)&(x1714))|((x1679)&(x1715)); + x1717 = x1683; + x1718 = x1686; + x1719 = x1689; + x1720 = x1692; + x1721 = x1695; + x1722 = x1698; + x1723 = x1701; + x1724 = x1704; + x1725 = x1707; + x1726 = x1710; + x1727 = x1713; + x1728 = x1716; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x1717, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1718, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1719, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x1720, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x1721, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x1722, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x1723, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x1724, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x1725, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)36ULL), x1726, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x1727, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)44ULL), x1728, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_to_montgomery(uint32_t out1[12], const uint32_t arg1[12]) { + internal_fiat_p384_scalar_to_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffff] + */ +static +uintptr_t internal_fiat_p384_scalar_nonzero(uintptr_t in0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, out0, x13; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x9 = _br2_load((in0)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x10 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x11 = _br2_load((in0)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x12 = (x0)|((x1)|((x2)|((x3)|((x4)|((x5)|((x6)|((x7)|((x8)|((x9)|((x10)|(x11))))))))))); + x13 = x12; + out0 = x13; + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_nonzero(uint32_t* out1, const uint32_t arg1[12]) { + *out1 = (uint32_t)internal_fiat_p384_scalar_nonzero((uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0x1] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p384_scalar_selectznz(uintptr_t out0, uintptr_t in0, uintptr_t in1, uintptr_t in2) { + uintptr_t x12, x24, x0, x25, x13, x27, x1, x28, x14, x30, x2, x31, x15, x33, x3, x34, x16, x36, x4, x37, x17, x39, x5, x40, x18, x42, x6, x43, x19, x45, x7, x46, x20, x48, x8, x49, x21, x51, x9, x52, x22, x54, x10, x55, x23, x57, x11, x58, x26, x29, x32, x35, x38, x41, x44, x47, x50, x53, x56, x59, x60, x61, x62, x63, x64, x65, x66, x67, x68, x69, x70, x71; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + x12 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x13 = _br2_load((in2)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x14 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x15 = _br2_load((in2)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x16 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x17 = _br2_load((in2)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x18 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x19 = _br2_load((in2)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x20 = _br2_load((in2)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x21 = _br2_load((in2)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x22 = _br2_load((in2)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x23 = _br2_load((in2)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x24 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x25 = (x24)^((uintptr_t)4294967295ULL); + x26 = ((x12)&(x24))|((x0)&(x25)); + x27 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x28 = (x27)^((uintptr_t)4294967295ULL); + x29 = ((x13)&(x27))|((x1)&(x28)); + x30 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x31 = (x30)^((uintptr_t)4294967295ULL); + x32 = ((x14)&(x30))|((x2)&(x31)); + x33 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x34 = (x33)^((uintptr_t)4294967295ULL); + x35 = ((x15)&(x33))|((x3)&(x34)); + x36 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x37 = (x36)^((uintptr_t)4294967295ULL); + x38 = ((x16)&(x36))|((x4)&(x37)); + x39 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x40 = (x39)^((uintptr_t)4294967295ULL); + x41 = ((x17)&(x39))|((x5)&(x40)); + x42 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x43 = (x42)^((uintptr_t)4294967295ULL); + x44 = ((x18)&(x42))|((x6)&(x43)); + x45 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x46 = (x45)^((uintptr_t)4294967295ULL); + x47 = ((x19)&(x45))|((x7)&(x46)); + x48 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x49 = (x48)^((uintptr_t)4294967295ULL); + x50 = ((x20)&(x48))|((x8)&(x49)); + x51 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x52 = (x51)^((uintptr_t)4294967295ULL); + x53 = ((x21)&(x51))|((x9)&(x52)); + x54 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x55 = (x54)^((uintptr_t)4294967295ULL); + x56 = ((x22)&(x54))|((x10)&(x55)); + x57 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x58 = (x57)^((uintptr_t)4294967295ULL); + x59 = ((x23)&(x57))|((x11)&(x58)); + x60 = x26; + x61 = x29; + x62 = x32; + x63 = x35; + x64 = x38; + x65 = x41; + x66 = x44; + x67 = x47; + x68 = x50; + x69 = x53; + x70 = x56; + x71 = x59; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x60, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x61, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x62, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x63, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x64, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x65, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x66, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x67, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x68, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)36ULL), x69, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x70, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)44ULL), x71, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_selectznz(uint32_t out1[12], uint8_t arg1, const uint32_t arg2[12], const uint32_t arg3[12]) { + internal_fiat_p384_scalar_selectznz((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static +void internal_fiat_p384_scalar_to_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0, x23, x25, x27, x22, x31, x33, x21, x37, x39, x20, x43, x45, x19, x49, x51, x18, x55, x57, x17, x61, x63, x16, x67, x69, x15, x73, x75, x14, x79, x81, x13, x85, x87, x12, x91, x93, x24, x26, x28, x29, x30, x32, x34, x35, x36, x38, x40, x41, x42, x44, x46, x47, x48, x50, x52, x53, x54, x56, x58, x59, x60, x62, x64, x65, x66, x68, x70, x71, x72, x74, x76, x77, x78, x80, x82, x83, x84, x86, x88, x89, x90, x92, x94, x95, x96, x97, x98, x99, x100, x101, x102, x103, x104, x105, x106, x107, x108, x109, x110, x111, x112, x113, x114, x115, x116, x117, x118, x119, x120, x121, x122, x123, x124, x125, x126, x127, x128, x129, x130, x131, x132, x133, x134, x135, x136, x137, x138, x139, x140, x141, x142, x143; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x9 = _br2_load((in0)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x10 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x11 = _br2_load((in0)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x12 = x11; + x13 = x10; + x14 = x9; + x15 = x8; + x16 = x7; + x17 = x6; + x18 = x5; + x19 = x4; + x20 = x3; + x21 = x2; + x22 = x1; + x23 = x0; + x24 = (x23)&((uintptr_t)255ULL); + x25 = (x23)>>((uintptr_t)8ULL); + x26 = (x25)&((uintptr_t)255ULL); + x27 = (x25)>>((uintptr_t)8ULL); + x28 = (x27)&((uintptr_t)255ULL); + x29 = (x27)>>((uintptr_t)8ULL); + x30 = (x22)&((uintptr_t)255ULL); + x31 = (x22)>>((uintptr_t)8ULL); + x32 = (x31)&((uintptr_t)255ULL); + x33 = (x31)>>((uintptr_t)8ULL); + x34 = (x33)&((uintptr_t)255ULL); + x35 = (x33)>>((uintptr_t)8ULL); + x36 = (x21)&((uintptr_t)255ULL); + x37 = (x21)>>((uintptr_t)8ULL); + x38 = (x37)&((uintptr_t)255ULL); + x39 = (x37)>>((uintptr_t)8ULL); + x40 = (x39)&((uintptr_t)255ULL); + x41 = (x39)>>((uintptr_t)8ULL); + x42 = (x20)&((uintptr_t)255ULL); + x43 = (x20)>>((uintptr_t)8ULL); + x44 = (x43)&((uintptr_t)255ULL); + x45 = (x43)>>((uintptr_t)8ULL); + x46 = (x45)&((uintptr_t)255ULL); + x47 = (x45)>>((uintptr_t)8ULL); + x48 = (x19)&((uintptr_t)255ULL); + x49 = (x19)>>((uintptr_t)8ULL); + x50 = (x49)&((uintptr_t)255ULL); + x51 = (x49)>>((uintptr_t)8ULL); + x52 = (x51)&((uintptr_t)255ULL); + x53 = (x51)>>((uintptr_t)8ULL); + x54 = (x18)&((uintptr_t)255ULL); + x55 = (x18)>>((uintptr_t)8ULL); + x56 = (x55)&((uintptr_t)255ULL); + x57 = (x55)>>((uintptr_t)8ULL); + x58 = (x57)&((uintptr_t)255ULL); + x59 = (x57)>>((uintptr_t)8ULL); + x60 = (x17)&((uintptr_t)255ULL); + x61 = (x17)>>((uintptr_t)8ULL); + x62 = (x61)&((uintptr_t)255ULL); + x63 = (x61)>>((uintptr_t)8ULL); + x64 = (x63)&((uintptr_t)255ULL); + x65 = (x63)>>((uintptr_t)8ULL); + x66 = (x16)&((uintptr_t)255ULL); + x67 = (x16)>>((uintptr_t)8ULL); + x68 = (x67)&((uintptr_t)255ULL); + x69 = (x67)>>((uintptr_t)8ULL); + x70 = (x69)&((uintptr_t)255ULL); + x71 = (x69)>>((uintptr_t)8ULL); + x72 = (x15)&((uintptr_t)255ULL); + x73 = (x15)>>((uintptr_t)8ULL); + x74 = (x73)&((uintptr_t)255ULL); + x75 = (x73)>>((uintptr_t)8ULL); + x76 = (x75)&((uintptr_t)255ULL); + x77 = (x75)>>((uintptr_t)8ULL); + x78 = (x14)&((uintptr_t)255ULL); + x79 = (x14)>>((uintptr_t)8ULL); + x80 = (x79)&((uintptr_t)255ULL); + x81 = (x79)>>((uintptr_t)8ULL); + x82 = (x81)&((uintptr_t)255ULL); + x83 = (x81)>>((uintptr_t)8ULL); + x84 = (x13)&((uintptr_t)255ULL); + x85 = (x13)>>((uintptr_t)8ULL); + x86 = (x85)&((uintptr_t)255ULL); + x87 = (x85)>>((uintptr_t)8ULL); + x88 = (x87)&((uintptr_t)255ULL); + x89 = (x87)>>((uintptr_t)8ULL); + x90 = (x12)&((uintptr_t)255ULL); + x91 = (x12)>>((uintptr_t)8ULL); + x92 = (x91)&((uintptr_t)255ULL); + x93 = (x91)>>((uintptr_t)8ULL); + x94 = (x93)&((uintptr_t)255ULL); + x95 = (x93)>>((uintptr_t)8ULL); + x96 = x24; + x97 = x26; + x98 = x28; + x99 = x29; + x100 = x30; + x101 = x32; + x102 = x34; + x103 = x35; + x104 = x36; + x105 = x38; + x106 = x40; + x107 = x41; + x108 = x42; + x109 = x44; + x110 = x46; + x111 = x47; + x112 = x48; + x113 = x50; + x114 = x52; + x115 = x53; + x116 = x54; + x117 = x56; + x118 = x58; + x119 = x59; + x120 = x60; + x121 = x62; + x122 = x64; + x123 = x65; + x124 = x66; + x125 = x68; + x126 = x70; + x127 = x71; + x128 = x72; + x129 = x74; + x130 = x76; + x131 = x77; + x132 = x78; + x133 = x80; + x134 = x82; + x135 = x83; + x136 = x84; + x137 = x86; + x138 = x88; + x139 = x89; + x140 = x90; + x141 = x92; + x142 = x94; + x143 = x95; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x96, 1); + _br2_store((out0)+((uintptr_t)1ULL), x97, 1); + _br2_store((out0)+((uintptr_t)2ULL), x98, 1); + _br2_store((out0)+((uintptr_t)3ULL), x99, 1); + _br2_store((out0)+((uintptr_t)4ULL), x100, 1); + _br2_store((out0)+((uintptr_t)5ULL), x101, 1); + _br2_store((out0)+((uintptr_t)6ULL), x102, 1); + _br2_store((out0)+((uintptr_t)7ULL), x103, 1); + _br2_store((out0)+((uintptr_t)8ULL), x104, 1); + _br2_store((out0)+((uintptr_t)9ULL), x105, 1); + _br2_store((out0)+((uintptr_t)10ULL), x106, 1); + _br2_store((out0)+((uintptr_t)11ULL), x107, 1); + _br2_store((out0)+((uintptr_t)12ULL), x108, 1); + _br2_store((out0)+((uintptr_t)13ULL), x109, 1); + _br2_store((out0)+((uintptr_t)14ULL), x110, 1); + _br2_store((out0)+((uintptr_t)15ULL), x111, 1); + _br2_store((out0)+((uintptr_t)16ULL), x112, 1); + _br2_store((out0)+((uintptr_t)17ULL), x113, 1); + _br2_store((out0)+((uintptr_t)18ULL), x114, 1); + _br2_store((out0)+((uintptr_t)19ULL), x115, 1); + _br2_store((out0)+((uintptr_t)20ULL), x116, 1); + _br2_store((out0)+((uintptr_t)21ULL), x117, 1); + _br2_store((out0)+((uintptr_t)22ULL), x118, 1); + _br2_store((out0)+((uintptr_t)23ULL), x119, 1); + _br2_store((out0)+((uintptr_t)24ULL), x120, 1); + _br2_store((out0)+((uintptr_t)25ULL), x121, 1); + _br2_store((out0)+((uintptr_t)26ULL), x122, 1); + _br2_store((out0)+((uintptr_t)27ULL), x123, 1); + _br2_store((out0)+((uintptr_t)28ULL), x124, 1); + _br2_store((out0)+((uintptr_t)29ULL), x125, 1); + _br2_store((out0)+((uintptr_t)30ULL), x126, 1); + _br2_store((out0)+((uintptr_t)31ULL), x127, 1); + _br2_store((out0)+((uintptr_t)32ULL), x128, 1); + _br2_store((out0)+((uintptr_t)33ULL), x129, 1); + _br2_store((out0)+((uintptr_t)34ULL), x130, 1); + _br2_store((out0)+((uintptr_t)35ULL), x131, 1); + _br2_store((out0)+((uintptr_t)36ULL), x132, 1); + _br2_store((out0)+((uintptr_t)37ULL), x133, 1); + _br2_store((out0)+((uintptr_t)38ULL), x134, 1); + _br2_store((out0)+((uintptr_t)39ULL), x135, 1); + _br2_store((out0)+((uintptr_t)40ULL), x136, 1); + _br2_store((out0)+((uintptr_t)41ULL), x137, 1); + _br2_store((out0)+((uintptr_t)42ULL), x138, 1); + _br2_store((out0)+((uintptr_t)43ULL), x139, 1); + _br2_store((out0)+((uintptr_t)44ULL), x140, 1); + _br2_store((out0)+((uintptr_t)45ULL), x141, 1); + _br2_store((out0)+((uintptr_t)46ULL), x142, 1); + _br2_store((out0)+((uintptr_t)47ULL), x143, 1); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_to_bytes(uint8_t out1[48], const uint32_t arg1[12]) { + internal_fiat_p384_scalar_to_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p384_scalar_from_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x47, x46, x45, x44, x43, x42, x41, x40, x39, x38, x37, x36, x35, x34, x33, x32, x31, x30, x29, x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x12, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0, x94, x95, x93, x96, x92, x97, x90, x91, x89, x99, x88, x100, x86, x87, x85, x102, x84, x103, x82, x83, x81, x105, x80, x106, x78, x79, x77, x108, x76, x109, x74, x75, x73, x111, x72, x112, x70, x71, x69, x114, x68, x115, x66, x67, x65, x117, x64, x118, x62, x63, x61, x120, x60, x121, x58, x59, x57, x123, x56, x124, x54, x55, x53, x126, x52, x127, x50, x51, x49, x129, x48, x130, x98, x101, x104, x107, x110, x113, x116, x119, x122, x125, x128, x131, x132, x133, x134, x135, x136, x137, x138, x139, x140, x141, x142, x143; + x0 = _br2_load((in0)+((uintptr_t)0ULL), 1); + x1 = _br2_load((in0)+((uintptr_t)1ULL), 1); + x2 = _br2_load((in0)+((uintptr_t)2ULL), 1); + x3 = _br2_load((in0)+((uintptr_t)3ULL), 1); + x4 = _br2_load((in0)+((uintptr_t)4ULL), 1); + x5 = _br2_load((in0)+((uintptr_t)5ULL), 1); + x6 = _br2_load((in0)+((uintptr_t)6ULL), 1); + x7 = _br2_load((in0)+((uintptr_t)7ULL), 1); + x8 = _br2_load((in0)+((uintptr_t)8ULL), 1); + x9 = _br2_load((in0)+((uintptr_t)9ULL), 1); + x10 = _br2_load((in0)+((uintptr_t)10ULL), 1); + x11 = _br2_load((in0)+((uintptr_t)11ULL), 1); + x12 = _br2_load((in0)+((uintptr_t)12ULL), 1); + x13 = _br2_load((in0)+((uintptr_t)13ULL), 1); + x14 = _br2_load((in0)+((uintptr_t)14ULL), 1); + x15 = _br2_load((in0)+((uintptr_t)15ULL), 1); + x16 = _br2_load((in0)+((uintptr_t)16ULL), 1); + x17 = _br2_load((in0)+((uintptr_t)17ULL), 1); + x18 = _br2_load((in0)+((uintptr_t)18ULL), 1); + x19 = _br2_load((in0)+((uintptr_t)19ULL), 1); + x20 = _br2_load((in0)+((uintptr_t)20ULL), 1); + x21 = _br2_load((in0)+((uintptr_t)21ULL), 1); + x22 = _br2_load((in0)+((uintptr_t)22ULL), 1); + x23 = _br2_load((in0)+((uintptr_t)23ULL), 1); + x24 = _br2_load((in0)+((uintptr_t)24ULL), 1); + x25 = _br2_load((in0)+((uintptr_t)25ULL), 1); + x26 = _br2_load((in0)+((uintptr_t)26ULL), 1); + x27 = _br2_load((in0)+((uintptr_t)27ULL), 1); + x28 = _br2_load((in0)+((uintptr_t)28ULL), 1); + x29 = _br2_load((in0)+((uintptr_t)29ULL), 1); + x30 = _br2_load((in0)+((uintptr_t)30ULL), 1); + x31 = _br2_load((in0)+((uintptr_t)31ULL), 1); + x32 = _br2_load((in0)+((uintptr_t)32ULL), 1); + x33 = _br2_load((in0)+((uintptr_t)33ULL), 1); + x34 = _br2_load((in0)+((uintptr_t)34ULL), 1); + x35 = _br2_load((in0)+((uintptr_t)35ULL), 1); + x36 = _br2_load((in0)+((uintptr_t)36ULL), 1); + x37 = _br2_load((in0)+((uintptr_t)37ULL), 1); + x38 = _br2_load((in0)+((uintptr_t)38ULL), 1); + x39 = _br2_load((in0)+((uintptr_t)39ULL), 1); + x40 = _br2_load((in0)+((uintptr_t)40ULL), 1); + x41 = _br2_load((in0)+((uintptr_t)41ULL), 1); + x42 = _br2_load((in0)+((uintptr_t)42ULL), 1); + x43 = _br2_load((in0)+((uintptr_t)43ULL), 1); + x44 = _br2_load((in0)+((uintptr_t)44ULL), 1); + x45 = _br2_load((in0)+((uintptr_t)45ULL), 1); + x46 = _br2_load((in0)+((uintptr_t)46ULL), 1); + x47 = _br2_load((in0)+((uintptr_t)47ULL), 1); + /*skip*/ + /*skip*/ + x48 = (x47)<<((uintptr_t)24ULL); + x49 = (x46)<<((uintptr_t)16ULL); + x50 = (x45)<<((uintptr_t)8ULL); + x51 = x44; + x52 = (x43)<<((uintptr_t)24ULL); + x53 = (x42)<<((uintptr_t)16ULL); + x54 = (x41)<<((uintptr_t)8ULL); + x55 = x40; + x56 = (x39)<<((uintptr_t)24ULL); + x57 = (x38)<<((uintptr_t)16ULL); + x58 = (x37)<<((uintptr_t)8ULL); + x59 = x36; + x60 = (x35)<<((uintptr_t)24ULL); + x61 = (x34)<<((uintptr_t)16ULL); + x62 = (x33)<<((uintptr_t)8ULL); + x63 = x32; + x64 = (x31)<<((uintptr_t)24ULL); + x65 = (x30)<<((uintptr_t)16ULL); + x66 = (x29)<<((uintptr_t)8ULL); + x67 = x28; + x68 = (x27)<<((uintptr_t)24ULL); + x69 = (x26)<<((uintptr_t)16ULL); + x70 = (x25)<<((uintptr_t)8ULL); + x71 = x24; + x72 = (x23)<<((uintptr_t)24ULL); + x73 = (x22)<<((uintptr_t)16ULL); + x74 = (x21)<<((uintptr_t)8ULL); + x75 = x20; + x76 = (x19)<<((uintptr_t)24ULL); + x77 = (x18)<<((uintptr_t)16ULL); + x78 = (x17)<<((uintptr_t)8ULL); + x79 = x16; + x80 = (x15)<<((uintptr_t)24ULL); + x81 = (x14)<<((uintptr_t)16ULL); + x82 = (x13)<<((uintptr_t)8ULL); + x83 = x12; + x84 = (x11)<<((uintptr_t)24ULL); + x85 = (x10)<<((uintptr_t)16ULL); + x86 = (x9)<<((uintptr_t)8ULL); + x87 = x8; + x88 = (x7)<<((uintptr_t)24ULL); + x89 = (x6)<<((uintptr_t)16ULL); + x90 = (x5)<<((uintptr_t)8ULL); + x91 = x4; + x92 = (x3)<<((uintptr_t)24ULL); + x93 = (x2)<<((uintptr_t)16ULL); + x94 = (x1)<<((uintptr_t)8ULL); + x95 = x0; + x96 = (x94)+(x95); + x97 = (x93)+(x96); + x98 = (x92)+(x97); + x99 = (x90)+(x91); + x100 = (x89)+(x99); + x101 = (x88)+(x100); + x102 = (x86)+(x87); + x103 = (x85)+(x102); + x104 = (x84)+(x103); + x105 = (x82)+(x83); + x106 = (x81)+(x105); + x107 = (x80)+(x106); + x108 = (x78)+(x79); + x109 = (x77)+(x108); + x110 = (x76)+(x109); + x111 = (x74)+(x75); + x112 = (x73)+(x111); + x113 = (x72)+(x112); + x114 = (x70)+(x71); + x115 = (x69)+(x114); + x116 = (x68)+(x115); + x117 = (x66)+(x67); + x118 = (x65)+(x117); + x119 = (x64)+(x118); + x120 = (x62)+(x63); + x121 = (x61)+(x120); + x122 = (x60)+(x121); + x123 = (x58)+(x59); + x124 = (x57)+(x123); + x125 = (x56)+(x124); + x126 = (x54)+(x55); + x127 = (x53)+(x126); + x128 = (x52)+(x127); + x129 = (x50)+(x51); + x130 = (x49)+(x129); + x131 = (x48)+(x130); + x132 = x98; + x133 = x101; + x134 = x104; + x135 = x107; + x136 = x110; + x137 = x113; + x138 = x116; + x139 = x119; + x140 = x122; + x141 = x125; + x142 = x128; + x143 = x131; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x132, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x133, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x134, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x135, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x136, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x137, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x138, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x139, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x140, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)36ULL), x141, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x142, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)44ULL), x143, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_from_bytes(uint32_t out1[12], const uint8_t arg1[48]) { + internal_fiat_p384_scalar_from_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p384_scalar_set_one(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11; + /*skip*/ + x0 = (uintptr_t)859494029ULL; + x1 = (uintptr_t)320071317ULL; + x2 = (uintptr_t)3075430533ULL; + x3 = (uintptr_t)2816864845ULL; + x4 = (uintptr_t)197710368ULL; + x5 = (uintptr_t)949793406ULL; + x6 = (uintptr_t)0ULL; + x7 = (uintptr_t)0ULL; + x8 = (uintptr_t)0ULL; + x9 = (uintptr_t)0ULL; + x10 = (uintptr_t)0ULL; + x11 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x7, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x8, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)36ULL), x9, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x10, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)44ULL), x11, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_set_one(uint32_t out1[12]) { + internal_fiat_p384_scalar_set_one((uintptr_t)out1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p384_scalar_msat(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12; + /*skip*/ + x0 = (uintptr_t)3435473267ULL; + x1 = (uintptr_t)3974895978ULL; + x2 = (uintptr_t)1219536762ULL; + x3 = (uintptr_t)1478102450ULL; + x4 = (uintptr_t)4097256927ULL; + x5 = (uintptr_t)3345173889ULL; + x6 = (uintptr_t)4294967295ULL; + x7 = (uintptr_t)4294967295ULL; + x8 = (uintptr_t)4294967295ULL; + x9 = (uintptr_t)4294967295ULL; + x10 = (uintptr_t)4294967295ULL; + x11 = (uintptr_t)4294967295ULL; + x12 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x7, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x8, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)36ULL), x9, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x10, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)44ULL), x11, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)48ULL), x12, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_msat(uint32_t out1[13]) { + internal_fiat_p384_scalar_msat((uintptr_t)out1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0xffffffff] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffff] + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +uintptr_t internal_fiat_p384_scalar_divstep(uintptr_t out1, uintptr_t out2, uintptr_t out3, uintptr_t out4, uintptr_t in0, uintptr_t in1, uintptr_t in2, uintptr_t in3, uintptr_t in4) { + uintptr_t x50, x52, x53, x54, x56, x57, x59, x60, x62, x63, x65, x66, x68, x69, x71, x72, x74, x75, x77, x78, x80, x81, x83, x84, x86, x87, x89, x90, x92, x93, x0, x96, x1, x98, x2, x100, x3, x102, x4, x104, x5, x106, x6, x108, x7, x110, x8, x112, x9, x114, x10, x116, x11, x118, x12, x95, x120, x13, x121, x97, x123, x14, x124, x99, x126, x15, x127, x101, x129, x16, x130, x103, x132, x17, x133, x105, x135, x18, x136, x107, x138, x19, x139, x109, x141, x20, x142, x111, x144, x21, x145, x113, x147, x22, x148, x115, x150, x23, x151, x117, x153, x24, x154, x119, x156, x25, x157, x159, x160, x162, x163, x165, x166, x168, x169, x171, x172, x174, x175, x177, x178, x180, x181, x183, x184, x186, x187, x189, x190, x192, x193, x196, x197, x198, x200, x201, x202, x203, x205, x206, x207, x208, x210, x211, x212, x213, x215, x216, x217, x218, x220, x221, x222, x223, x225, x226, x227, x228, x230, x231, x232, x233, x235, x236, x237, x238, x240, x241, x242, x243, x245, x246, x247, x248, x250, x253, x254, x255, x257, x258, x259, x260, x262, x263, x264, x265, x267, x268, x269, x270, x272, x273, x274, x275, x277, x278, x279, x280, x282, x283, x284, x285, x287, x288, x289, x290, x292, x293, x294, x295, x297, x298, x299, x300, x302, x303, x304, x305, x307, x308, x251, x309, x37, x36, x35, x34, x33, x32, x31, x30, x29, x28, x27, x26, x323, x321, x324, x326, x327, x320, x328, x330, x331, x319, x332, x334, x335, x318, x336, x338, x339, x317, x340, x342, x343, x316, x344, x346, x347, x315, x348, x350, x351, x314, x352, x354, x355, x313, x356, x358, x359, x312, x360, x362, x363, x311, x364, x366, x367, x322, x370, x325, x371, x372, x374, x375, x329, x376, x377, x379, x380, x333, x381, x382, x384, x385, x337, x386, x387, x389, x390, x341, x391, x392, x394, x395, x345, x396, x397, x399, x400, x349, x401, x402, x404, x405, x353, x406, x407, x409, x410, x357, x411, x412, x414, x415, x361, x416, x417, x419, x420, x365, x421, x368, x369, x423, x38, x424, x373, x426, x39, x427, x378, x429, x40, x430, x383, x432, x41, x433, x388, x435, x42, x436, x393, x438, x43, x439, x398, x441, x44, x442, x403, x444, x45, x445, x408, x447, x46, x448, x413, x450, x47, x451, x418, x453, x48, x454, x51, x422, x456, x49, x457, x460, x461, x463, x464, x466, x467, x469, x470, x472, x473, x475, x476, x478, x479, x481, x482, x484, x485, x487, x488, x490, x491, x493, x494, x496, x497, x462, x122, x500, x125, x501, x465, x502, x504, x505, x128, x506, x468, x507, x509, x510, x131, x511, x471, x512, x514, x515, x134, x516, x474, x517, x519, x520, x137, x521, x477, x522, x524, x525, x140, x526, x480, x527, x529, x530, x143, x531, x483, x532, x534, x535, x146, x536, x486, x537, x539, x540, x149, x541, x489, x542, x544, x545, x152, x546, x492, x547, x549, x550, x155, x551, x495, x552, x554, x555, x158, x556, x498, x161, x558, x559, x164, x561, x562, x167, x564, x565, x170, x567, x568, x173, x570, x571, x176, x573, x574, x179, x576, x577, x182, x579, x580, x185, x582, x583, x188, x585, x586, x191, x588, x589, x459, x194, x591, x592, x560, x425, x595, x428, x596, x563, x597, x599, x600, x431, x601, x566, x602, x604, x605, x434, x606, x569, x607, x609, x610, x437, x611, x572, x612, x614, x615, x440, x616, x575, x617, x619, x620, x443, x621, x578, x622, x624, x625, x446, x626, x581, x627, x629, x630, x449, x631, x584, x632, x634, x635, x452, x636, x587, x637, x639, x640, x455, x641, x590, x642, x644, x645, x458, x646, x593, x647, x649, x652, x653, x654, x656, x657, x658, x659, x661, x662, x663, x664, x666, x667, x668, x669, x671, x672, x673, x674, x676, x677, x678, x679, x681, x682, x683, x684, x686, x687, x688, x689, x691, x692, x693, x694, x696, x697, x698, x699, x701, x702, x703, x704, x706, x707, x650, x708, x55, x499, x503, x508, x513, x518, x523, x528, x533, x538, x543, x548, x553, x557, x195, x724, x252, x725, x199, x727, x256, x728, x204, x730, x261, x731, x209, x733, x266, x734, x214, x736, x271, x737, x219, x739, x276, x740, x224, x742, x281, x743, x229, x745, x286, x746, x234, x748, x291, x749, x239, x751, x296, x752, x244, x754, x301, x755, x310, x249, x757, x306, x758, x594, x760, x651, x761, x598, x763, x655, x764, x603, x766, x660, x767, x608, x769, x665, x770, x613, x772, x670, x773, x618, x775, x675, x776, x623, x778, x680, x779, x628, x781, x685, x782, x633, x784, x690, x785, x638, x787, x695, x788, x643, x790, x700, x791, x709, x648, x793, x705, x794, x710, x58, x61, x64, x67, x70, x73, x76, x79, x82, x85, x88, x91, x94, x711, x712, x713, x714, x715, x716, x717, x718, x719, x720, x721, x722, x723, x726, x729, x732, x735, x738, x741, x744, x747, x750, x753, x756, x759, x762, x765, x768, x771, x774, x777, x780, x783, x786, x789, x792, x795, out0, x796, x797, x798, x799, x800, x801, x802, x803, x804, x805, x806, x807, x808, x809, x810, x811, x812, x813, x814, x815, x816, x817, x818, x819, x820, x821, x822, x823, x824, x825, x826, x827, x828, x829, x830, x831, x832, x833, x834, x835, x836, x837, x838, x839, x840, x841, x842, x843, x844, x845, x846; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)44ULL), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)48ULL), sizeof(uintptr_t)); + /*skip*/ + x13 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x14 = _br2_load((in2)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x15 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x16 = _br2_load((in2)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x17 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x18 = _br2_load((in2)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x19 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x20 = _br2_load((in2)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x21 = _br2_load((in2)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x22 = _br2_load((in2)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x23 = _br2_load((in2)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x24 = _br2_load((in2)+((uintptr_t)44ULL), sizeof(uintptr_t)); + x25 = _br2_load((in2)+((uintptr_t)48ULL), sizeof(uintptr_t)); + /*skip*/ + x26 = _br2_load((in3)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x27 = _br2_load((in3)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x28 = _br2_load((in3)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x29 = _br2_load((in3)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x30 = _br2_load((in3)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x31 = _br2_load((in3)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x32 = _br2_load((in3)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x33 = _br2_load((in3)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x34 = _br2_load((in3)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x35 = _br2_load((in3)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x36 = _br2_load((in3)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x37 = _br2_load((in3)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + x38 = _br2_load((in4)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x39 = _br2_load((in4)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x40 = _br2_load((in4)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x41 = _br2_load((in4)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x42 = _br2_load((in4)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x43 = _br2_load((in4)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x44 = _br2_load((in4)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x45 = _br2_load((in4)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x46 = _br2_load((in4)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x47 = _br2_load((in4)+((uintptr_t)36ULL), sizeof(uintptr_t)); + x48 = _br2_load((in4)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x49 = _br2_load((in4)+((uintptr_t)44ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x50 = ((in0)^((uintptr_t)4294967295ULL))+((uintptr_t)1ULL); + x51 = ((x50)>>((uintptr_t)31ULL))&((x13)&((uintptr_t)1ULL)); + x52 = ((in0)^((uintptr_t)4294967295ULL))+((uintptr_t)1ULL); + x53 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x54 = (x53)^((uintptr_t)4294967295ULL); + x55 = ((x52)&(x53))|((in0)&(x54)); + x56 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x57 = (x56)^((uintptr_t)4294967295ULL); + x58 = ((x13)&(x56))|((x0)&(x57)); + x59 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x60 = (x59)^((uintptr_t)4294967295ULL); + x61 = ((x14)&(x59))|((x1)&(x60)); + x62 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x63 = (x62)^((uintptr_t)4294967295ULL); + x64 = ((x15)&(x62))|((x2)&(x63)); + x65 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x66 = (x65)^((uintptr_t)4294967295ULL); + x67 = ((x16)&(x65))|((x3)&(x66)); + x68 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x69 = (x68)^((uintptr_t)4294967295ULL); + x70 = ((x17)&(x68))|((x4)&(x69)); + x71 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x72 = (x71)^((uintptr_t)4294967295ULL); + x73 = ((x18)&(x71))|((x5)&(x72)); + x74 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x75 = (x74)^((uintptr_t)4294967295ULL); + x76 = ((x19)&(x74))|((x6)&(x75)); + x77 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x78 = (x77)^((uintptr_t)4294967295ULL); + x79 = ((x20)&(x77))|((x7)&(x78)); + x80 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x81 = (x80)^((uintptr_t)4294967295ULL); + x82 = ((x21)&(x80))|((x8)&(x81)); + x83 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x84 = (x83)^((uintptr_t)4294967295ULL); + x85 = ((x22)&(x83))|((x9)&(x84)); + x86 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x87 = (x86)^((uintptr_t)4294967295ULL); + x88 = ((x23)&(x86))|((x10)&(x87)); + x89 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x90 = (x89)^((uintptr_t)4294967295ULL); + x91 = ((x24)&(x89))|((x11)&(x90)); + x92 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x93 = (x92)^((uintptr_t)4294967295ULL); + x94 = ((x25)&(x92))|((x12)&(x93)); + x95 = ((uintptr_t)1ULL)+((x0)^((uintptr_t)4294967295ULL)); + x96 = (uintptr_t)((x95)<((uintptr_t)1ULL)); + x97 = (x96)+((x1)^((uintptr_t)4294967295ULL)); + x98 = (uintptr_t)((x97)<((x1)^((uintptr_t)4294967295ULL))); + x99 = (x98)+((x2)^((uintptr_t)4294967295ULL)); + x100 = (uintptr_t)((x99)<((x2)^((uintptr_t)4294967295ULL))); + x101 = (x100)+((x3)^((uintptr_t)4294967295ULL)); + x102 = (uintptr_t)((x101)<((x3)^((uintptr_t)4294967295ULL))); + x103 = (x102)+((x4)^((uintptr_t)4294967295ULL)); + x104 = (uintptr_t)((x103)<((x4)^((uintptr_t)4294967295ULL))); + x105 = (x104)+((x5)^((uintptr_t)4294967295ULL)); + x106 = (uintptr_t)((x105)<((x5)^((uintptr_t)4294967295ULL))); + x107 = (x106)+((x6)^((uintptr_t)4294967295ULL)); + x108 = (uintptr_t)((x107)<((x6)^((uintptr_t)4294967295ULL))); + x109 = (x108)+((x7)^((uintptr_t)4294967295ULL)); + x110 = (uintptr_t)((x109)<((x7)^((uintptr_t)4294967295ULL))); + x111 = (x110)+((x8)^((uintptr_t)4294967295ULL)); + x112 = (uintptr_t)((x111)<((x8)^((uintptr_t)4294967295ULL))); + x113 = (x112)+((x9)^((uintptr_t)4294967295ULL)); + x114 = (uintptr_t)((x113)<((x9)^((uintptr_t)4294967295ULL))); + x115 = (x114)+((x10)^((uintptr_t)4294967295ULL)); + x116 = (uintptr_t)((x115)<((x10)^((uintptr_t)4294967295ULL))); + x117 = (x116)+((x11)^((uintptr_t)4294967295ULL)); + x118 = (uintptr_t)((x117)<((x11)^((uintptr_t)4294967295ULL))); + x119 = (x118)+((x12)^((uintptr_t)4294967295ULL)); + x120 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x121 = (x120)^((uintptr_t)4294967295ULL); + x122 = ((x95)&(x120))|((x13)&(x121)); + x123 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x124 = (x123)^((uintptr_t)4294967295ULL); + x125 = ((x97)&(x123))|((x14)&(x124)); + x126 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x127 = (x126)^((uintptr_t)4294967295ULL); + x128 = ((x99)&(x126))|((x15)&(x127)); + x129 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x130 = (x129)^((uintptr_t)4294967295ULL); + x131 = ((x101)&(x129))|((x16)&(x130)); + x132 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x133 = (x132)^((uintptr_t)4294967295ULL); + x134 = ((x103)&(x132))|((x17)&(x133)); + x135 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x136 = (x135)^((uintptr_t)4294967295ULL); + x137 = ((x105)&(x135))|((x18)&(x136)); + x138 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x139 = (x138)^((uintptr_t)4294967295ULL); + x140 = ((x107)&(x138))|((x19)&(x139)); + x141 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x142 = (x141)^((uintptr_t)4294967295ULL); + x143 = ((x109)&(x141))|((x20)&(x142)); + x144 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x145 = (x144)^((uintptr_t)4294967295ULL); + x146 = ((x111)&(x144))|((x21)&(x145)); + x147 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x148 = (x147)^((uintptr_t)4294967295ULL); + x149 = ((x113)&(x147))|((x22)&(x148)); + x150 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x151 = (x150)^((uintptr_t)4294967295ULL); + x152 = ((x115)&(x150))|((x23)&(x151)); + x153 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x154 = (x153)^((uintptr_t)4294967295ULL); + x155 = ((x117)&(x153))|((x24)&(x154)); + x156 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x157 = (x156)^((uintptr_t)4294967295ULL); + x158 = ((x119)&(x156))|((x25)&(x157)); + x159 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x160 = (x159)^((uintptr_t)4294967295ULL); + x161 = ((x38)&(x159))|((x26)&(x160)); + x162 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x163 = (x162)^((uintptr_t)4294967295ULL); + x164 = ((x39)&(x162))|((x27)&(x163)); + x165 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x166 = (x165)^((uintptr_t)4294967295ULL); + x167 = ((x40)&(x165))|((x28)&(x166)); + x168 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x169 = (x168)^((uintptr_t)4294967295ULL); + x170 = ((x41)&(x168))|((x29)&(x169)); + x171 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x172 = (x171)^((uintptr_t)4294967295ULL); + x173 = ((x42)&(x171))|((x30)&(x172)); + x174 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x175 = (x174)^((uintptr_t)4294967295ULL); + x176 = ((x43)&(x174))|((x31)&(x175)); + x177 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x178 = (x177)^((uintptr_t)4294967295ULL); + x179 = ((x44)&(x177))|((x32)&(x178)); + x180 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x181 = (x180)^((uintptr_t)4294967295ULL); + x182 = ((x45)&(x180))|((x33)&(x181)); + x183 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x184 = (x183)^((uintptr_t)4294967295ULL); + x185 = ((x46)&(x183))|((x34)&(x184)); + x186 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x187 = (x186)^((uintptr_t)4294967295ULL); + x188 = ((x47)&(x186))|((x35)&(x187)); + x189 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x190 = (x189)^((uintptr_t)4294967295ULL); + x191 = ((x48)&(x189))|((x36)&(x190)); + x192 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x193 = (x192)^((uintptr_t)4294967295ULL); + x194 = ((x49)&(x192))|((x37)&(x193)); + x195 = (x161)+(x161); + x196 = (uintptr_t)((x195)<(x161)); + x197 = (x196)+(x164); + x198 = (uintptr_t)((x197)<(x164)); + x199 = (x197)+(x164); + x200 = (uintptr_t)((x199)<(x164)); + x201 = (x198)+(x200); + x202 = (x201)+(x167); + x203 = (uintptr_t)((x202)<(x167)); + x204 = (x202)+(x167); + x205 = (uintptr_t)((x204)<(x167)); + x206 = (x203)+(x205); + x207 = (x206)+(x170); + x208 = (uintptr_t)((x207)<(x170)); + x209 = (x207)+(x170); + x210 = (uintptr_t)((x209)<(x170)); + x211 = (x208)+(x210); + x212 = (x211)+(x173); + x213 = (uintptr_t)((x212)<(x173)); + x214 = (x212)+(x173); + x215 = (uintptr_t)((x214)<(x173)); + x216 = (x213)+(x215); + x217 = (x216)+(x176); + x218 = (uintptr_t)((x217)<(x176)); + x219 = (x217)+(x176); + x220 = (uintptr_t)((x219)<(x176)); + x221 = (x218)+(x220); + x222 = (x221)+(x179); + x223 = (uintptr_t)((x222)<(x179)); + x224 = (x222)+(x179); + x225 = (uintptr_t)((x224)<(x179)); + x226 = (x223)+(x225); + x227 = (x226)+(x182); + x228 = (uintptr_t)((x227)<(x182)); + x229 = (x227)+(x182); + x230 = (uintptr_t)((x229)<(x182)); + x231 = (x228)+(x230); + x232 = (x231)+(x185); + x233 = (uintptr_t)((x232)<(x185)); + x234 = (x232)+(x185); + x235 = (uintptr_t)((x234)<(x185)); + x236 = (x233)+(x235); + x237 = (x236)+(x188); + x238 = (uintptr_t)((x237)<(x188)); + x239 = (x237)+(x188); + x240 = (uintptr_t)((x239)<(x188)); + x241 = (x238)+(x240); + x242 = (x241)+(x191); + x243 = (uintptr_t)((x242)<(x191)); + x244 = (x242)+(x191); + x245 = (uintptr_t)((x244)<(x191)); + x246 = (x243)+(x245); + x247 = (x246)+(x194); + x248 = (uintptr_t)((x247)<(x194)); + x249 = (x247)+(x194); + x250 = (uintptr_t)((x249)<(x194)); + x251 = (x248)+(x250); + x252 = (x195)-((uintptr_t)3435473267ULL); + x253 = (uintptr_t)((x195)<(x252)); + x254 = (x199)-((uintptr_t)3974895978ULL); + x255 = (uintptr_t)((x199)<(x254)); + x256 = (x254)-(x253); + x257 = (uintptr_t)((x254)<(x256)); + x258 = (x255)+(x257); + x259 = (x204)-((uintptr_t)1219536762ULL); + x260 = (uintptr_t)((x204)<(x259)); + x261 = (x259)-(x258); + x262 = (uintptr_t)((x259)<(x261)); + x263 = (x260)+(x262); + x264 = (x209)-((uintptr_t)1478102450ULL); + x265 = (uintptr_t)((x209)<(x264)); + x266 = (x264)-(x263); + x267 = (uintptr_t)((x264)<(x266)); + x268 = (x265)+(x267); + x269 = (x214)-((uintptr_t)4097256927ULL); + x270 = (uintptr_t)((x214)<(x269)); + x271 = (x269)-(x268); + x272 = (uintptr_t)((x269)<(x271)); + x273 = (x270)+(x272); + x274 = (x219)-((uintptr_t)3345173889ULL); + x275 = (uintptr_t)((x219)<(x274)); + x276 = (x274)-(x273); + x277 = (uintptr_t)((x274)<(x276)); + x278 = (x275)+(x277); + x279 = (x224)-((uintptr_t)4294967295ULL); + x280 = (uintptr_t)((x224)<(x279)); + x281 = (x279)-(x278); + x282 = (uintptr_t)((x279)<(x281)); + x283 = (x280)+(x282); + x284 = (x229)-((uintptr_t)4294967295ULL); + x285 = (uintptr_t)((x229)<(x284)); + x286 = (x284)-(x283); + x287 = (uintptr_t)((x284)<(x286)); + x288 = (x285)+(x287); + x289 = (x234)-((uintptr_t)4294967295ULL); + x290 = (uintptr_t)((x234)<(x289)); + x291 = (x289)-(x288); + x292 = (uintptr_t)((x289)<(x291)); + x293 = (x290)+(x292); + x294 = (x239)-((uintptr_t)4294967295ULL); + x295 = (uintptr_t)((x239)<(x294)); + x296 = (x294)-(x293); + x297 = (uintptr_t)((x294)<(x296)); + x298 = (x295)+(x297); + x299 = (x244)-((uintptr_t)4294967295ULL); + x300 = (uintptr_t)((x244)<(x299)); + x301 = (x299)-(x298); + x302 = (uintptr_t)((x299)<(x301)); + x303 = (x300)+(x302); + x304 = (x249)-((uintptr_t)4294967295ULL); + x305 = (uintptr_t)((x249)<(x304)); + x306 = (x304)-(x303); + x307 = (uintptr_t)((x304)<(x306)); + x308 = (x305)+(x307); + x309 = (x251)-(x308); + x310 = (uintptr_t)((x251)<(x309)); + x311 = x37; + x312 = x36; + x313 = x35; + x314 = x34; + x315 = x33; + x316 = x32; + x317 = x31; + x318 = x30; + x319 = x29; + x320 = x28; + x321 = x27; + x322 = x26; + x323 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x322))); + x324 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x321))); + x325 = (((uintptr_t)0ULL)-(x321))-(x323); + x326 = (uintptr_t)((((uintptr_t)0ULL)-(x321))<(x325)); + x327 = (x324)+(x326); + x328 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x320))); + x329 = (((uintptr_t)0ULL)-(x320))-(x327); + x330 = (uintptr_t)((((uintptr_t)0ULL)-(x320))<(x329)); + x331 = (x328)+(x330); + x332 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x319))); + x333 = (((uintptr_t)0ULL)-(x319))-(x331); + x334 = (uintptr_t)((((uintptr_t)0ULL)-(x319))<(x333)); + x335 = (x332)+(x334); + x336 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x318))); + x337 = (((uintptr_t)0ULL)-(x318))-(x335); + x338 = (uintptr_t)((((uintptr_t)0ULL)-(x318))<(x337)); + x339 = (x336)+(x338); + x340 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x317))); + x341 = (((uintptr_t)0ULL)-(x317))-(x339); + x342 = (uintptr_t)((((uintptr_t)0ULL)-(x317))<(x341)); + x343 = (x340)+(x342); + x344 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x316))); + x345 = (((uintptr_t)0ULL)-(x316))-(x343); + x346 = (uintptr_t)((((uintptr_t)0ULL)-(x316))<(x345)); + x347 = (x344)+(x346); + x348 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x315))); + x349 = (((uintptr_t)0ULL)-(x315))-(x347); + x350 = (uintptr_t)((((uintptr_t)0ULL)-(x315))<(x349)); + x351 = (x348)+(x350); + x352 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x314))); + x353 = (((uintptr_t)0ULL)-(x314))-(x351); + x354 = (uintptr_t)((((uintptr_t)0ULL)-(x314))<(x353)); + x355 = (x352)+(x354); + x356 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x313))); + x357 = (((uintptr_t)0ULL)-(x313))-(x355); + x358 = (uintptr_t)((((uintptr_t)0ULL)-(x313))<(x357)); + x359 = (x356)+(x358); + x360 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x312))); + x361 = (((uintptr_t)0ULL)-(x312))-(x359); + x362 = (uintptr_t)((((uintptr_t)0ULL)-(x312))<(x361)); + x363 = (x360)+(x362); + x364 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x311))); + x365 = (((uintptr_t)0ULL)-(x311))-(x363); + x366 = (uintptr_t)((((uintptr_t)0ULL)-(x311))<(x365)); + x367 = (x364)+(x366); + x368 = ((uintptr_t)-1ULL)+((uintptr_t)((x367)==((uintptr_t)0ULL))); + x369 = (((uintptr_t)0ULL)-(x322))+((x368)&((uintptr_t)3435473267ULL)); + x370 = (uintptr_t)((x369)<(((uintptr_t)0ULL)-(x322))); + x371 = (x370)+(x325); + x372 = (uintptr_t)((x371)<(x325)); + x373 = (x371)+((x368)&((uintptr_t)3974895978ULL)); + x374 = (uintptr_t)((x373)<((x368)&((uintptr_t)3974895978ULL))); + x375 = (x372)+(x374); + x376 = (x375)+(x329); + x377 = (uintptr_t)((x376)<(x329)); + x378 = (x376)+((x368)&((uintptr_t)1219536762ULL)); + x379 = (uintptr_t)((x378)<((x368)&((uintptr_t)1219536762ULL))); + x380 = (x377)+(x379); + x381 = (x380)+(x333); + x382 = (uintptr_t)((x381)<(x333)); + x383 = (x381)+((x368)&((uintptr_t)1478102450ULL)); + x384 = (uintptr_t)((x383)<((x368)&((uintptr_t)1478102450ULL))); + x385 = (x382)+(x384); + x386 = (x385)+(x337); + x387 = (uintptr_t)((x386)<(x337)); + x388 = (x386)+((x368)&((uintptr_t)4097256927ULL)); + x389 = (uintptr_t)((x388)<((x368)&((uintptr_t)4097256927ULL))); + x390 = (x387)+(x389); + x391 = (x390)+(x341); + x392 = (uintptr_t)((x391)<(x341)); + x393 = (x391)+((x368)&((uintptr_t)3345173889ULL)); + x394 = (uintptr_t)((x393)<((x368)&((uintptr_t)3345173889ULL))); + x395 = (x392)+(x394); + x396 = (x395)+(x345); + x397 = (uintptr_t)((x396)<(x345)); + x398 = (x396)+(x368); + x399 = (uintptr_t)((x398)<(x368)); + x400 = (x397)+(x399); + x401 = (x400)+(x349); + x402 = (uintptr_t)((x401)<(x349)); + x403 = (x401)+(x368); + x404 = (uintptr_t)((x403)<(x368)); + x405 = (x402)+(x404); + x406 = (x405)+(x353); + x407 = (uintptr_t)((x406)<(x353)); + x408 = (x406)+(x368); + x409 = (uintptr_t)((x408)<(x368)); + x410 = (x407)+(x409); + x411 = (x410)+(x357); + x412 = (uintptr_t)((x411)<(x357)); + x413 = (x411)+(x368); + x414 = (uintptr_t)((x413)<(x368)); + x415 = (x412)+(x414); + x416 = (x415)+(x361); + x417 = (uintptr_t)((x416)<(x361)); + x418 = (x416)+(x368); + x419 = (uintptr_t)((x418)<(x368)); + x420 = (x417)+(x419); + x421 = (x420)+(x365); + x422 = (x421)+(x368); + x423 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x424 = (x423)^((uintptr_t)4294967295ULL); + x425 = ((x369)&(x423))|((x38)&(x424)); + x426 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x427 = (x426)^((uintptr_t)4294967295ULL); + x428 = ((x373)&(x426))|((x39)&(x427)); + x429 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x430 = (x429)^((uintptr_t)4294967295ULL); + x431 = ((x378)&(x429))|((x40)&(x430)); + x432 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x433 = (x432)^((uintptr_t)4294967295ULL); + x434 = ((x383)&(x432))|((x41)&(x433)); + x435 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x436 = (x435)^((uintptr_t)4294967295ULL); + x437 = ((x388)&(x435))|((x42)&(x436)); + x438 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x439 = (x438)^((uintptr_t)4294967295ULL); + x440 = ((x393)&(x438))|((x43)&(x439)); + x441 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x442 = (x441)^((uintptr_t)4294967295ULL); + x443 = ((x398)&(x441))|((x44)&(x442)); + x444 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x445 = (x444)^((uintptr_t)4294967295ULL); + x446 = ((x403)&(x444))|((x45)&(x445)); + x447 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x448 = (x447)^((uintptr_t)4294967295ULL); + x449 = ((x408)&(x447))|((x46)&(x448)); + x450 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x451 = (x450)^((uintptr_t)4294967295ULL); + x452 = ((x413)&(x450))|((x47)&(x451)); + x453 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x454 = (x453)^((uintptr_t)4294967295ULL); + x455 = ((x418)&(x453))|((x48)&(x454)); + x456 = ((uintptr_t)-1ULL)+((uintptr_t)((x51)==((uintptr_t)0ULL))); + x457 = (x456)^((uintptr_t)4294967295ULL); + x458 = ((x422)&(x456))|((x49)&(x457)); + x459 = (x122)&((uintptr_t)1ULL); + x460 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x461 = (x460)^((uintptr_t)4294967295ULL); + x462 = ((x58)&(x460))|(((uintptr_t)0ULL)&(x461)); + x463 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x464 = (x463)^((uintptr_t)4294967295ULL); + x465 = ((x61)&(x463))|(((uintptr_t)0ULL)&(x464)); + x466 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x467 = (x466)^((uintptr_t)4294967295ULL); + x468 = ((x64)&(x466))|(((uintptr_t)0ULL)&(x467)); + x469 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x470 = (x469)^((uintptr_t)4294967295ULL); + x471 = ((x67)&(x469))|(((uintptr_t)0ULL)&(x470)); + x472 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x473 = (x472)^((uintptr_t)4294967295ULL); + x474 = ((x70)&(x472))|(((uintptr_t)0ULL)&(x473)); + x475 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x476 = (x475)^((uintptr_t)4294967295ULL); + x477 = ((x73)&(x475))|(((uintptr_t)0ULL)&(x476)); + x478 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x479 = (x478)^((uintptr_t)4294967295ULL); + x480 = ((x76)&(x478))|(((uintptr_t)0ULL)&(x479)); + x481 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x482 = (x481)^((uintptr_t)4294967295ULL); + x483 = ((x79)&(x481))|(((uintptr_t)0ULL)&(x482)); + x484 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x485 = (x484)^((uintptr_t)4294967295ULL); + x486 = ((x82)&(x484))|(((uintptr_t)0ULL)&(x485)); + x487 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x488 = (x487)^((uintptr_t)4294967295ULL); + x489 = ((x85)&(x487))|(((uintptr_t)0ULL)&(x488)); + x490 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x491 = (x490)^((uintptr_t)4294967295ULL); + x492 = ((x88)&(x490))|(((uintptr_t)0ULL)&(x491)); + x493 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x494 = (x493)^((uintptr_t)4294967295ULL); + x495 = ((x91)&(x493))|(((uintptr_t)0ULL)&(x494)); + x496 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x497 = (x496)^((uintptr_t)4294967295ULL); + x498 = ((x94)&(x496))|(((uintptr_t)0ULL)&(x497)); + x499 = (x122)+(x462); + x500 = (uintptr_t)((x499)<(x122)); + x501 = (x500)+(x125); + x502 = (uintptr_t)((x501)<(x125)); + x503 = (x501)+(x465); + x504 = (uintptr_t)((x503)<(x465)); + x505 = (x502)+(x504); + x506 = (x505)+(x128); + x507 = (uintptr_t)((x506)<(x128)); + x508 = (x506)+(x468); + x509 = (uintptr_t)((x508)<(x468)); + x510 = (x507)+(x509); + x511 = (x510)+(x131); + x512 = (uintptr_t)((x511)<(x131)); + x513 = (x511)+(x471); + x514 = (uintptr_t)((x513)<(x471)); + x515 = (x512)+(x514); + x516 = (x515)+(x134); + x517 = (uintptr_t)((x516)<(x134)); + x518 = (x516)+(x474); + x519 = (uintptr_t)((x518)<(x474)); + x520 = (x517)+(x519); + x521 = (x520)+(x137); + x522 = (uintptr_t)((x521)<(x137)); + x523 = (x521)+(x477); + x524 = (uintptr_t)((x523)<(x477)); + x525 = (x522)+(x524); + x526 = (x525)+(x140); + x527 = (uintptr_t)((x526)<(x140)); + x528 = (x526)+(x480); + x529 = (uintptr_t)((x528)<(x480)); + x530 = (x527)+(x529); + x531 = (x530)+(x143); + x532 = (uintptr_t)((x531)<(x143)); + x533 = (x531)+(x483); + x534 = (uintptr_t)((x533)<(x483)); + x535 = (x532)+(x534); + x536 = (x535)+(x146); + x537 = (uintptr_t)((x536)<(x146)); + x538 = (x536)+(x486); + x539 = (uintptr_t)((x538)<(x486)); + x540 = (x537)+(x539); + x541 = (x540)+(x149); + x542 = (uintptr_t)((x541)<(x149)); + x543 = (x541)+(x489); + x544 = (uintptr_t)((x543)<(x489)); + x545 = (x542)+(x544); + x546 = (x545)+(x152); + x547 = (uintptr_t)((x546)<(x152)); + x548 = (x546)+(x492); + x549 = (uintptr_t)((x548)<(x492)); + x550 = (x547)+(x549); + x551 = (x550)+(x155); + x552 = (uintptr_t)((x551)<(x155)); + x553 = (x551)+(x495); + x554 = (uintptr_t)((x553)<(x495)); + x555 = (x552)+(x554); + x556 = (x555)+(x158); + x557 = (x556)+(x498); + x558 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x559 = (x558)^((uintptr_t)4294967295ULL); + x560 = ((x161)&(x558))|(((uintptr_t)0ULL)&(x559)); + x561 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x562 = (x561)^((uintptr_t)4294967295ULL); + x563 = ((x164)&(x561))|(((uintptr_t)0ULL)&(x562)); + x564 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x565 = (x564)^((uintptr_t)4294967295ULL); + x566 = ((x167)&(x564))|(((uintptr_t)0ULL)&(x565)); + x567 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x568 = (x567)^((uintptr_t)4294967295ULL); + x569 = ((x170)&(x567))|(((uintptr_t)0ULL)&(x568)); + x570 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x571 = (x570)^((uintptr_t)4294967295ULL); + x572 = ((x173)&(x570))|(((uintptr_t)0ULL)&(x571)); + x573 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x574 = (x573)^((uintptr_t)4294967295ULL); + x575 = ((x176)&(x573))|(((uintptr_t)0ULL)&(x574)); + x576 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x577 = (x576)^((uintptr_t)4294967295ULL); + x578 = ((x179)&(x576))|(((uintptr_t)0ULL)&(x577)); + x579 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x580 = (x579)^((uintptr_t)4294967295ULL); + x581 = ((x182)&(x579))|(((uintptr_t)0ULL)&(x580)); + x582 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x583 = (x582)^((uintptr_t)4294967295ULL); + x584 = ((x185)&(x582))|(((uintptr_t)0ULL)&(x583)); + x585 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x586 = (x585)^((uintptr_t)4294967295ULL); + x587 = ((x188)&(x585))|(((uintptr_t)0ULL)&(x586)); + x588 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x589 = (x588)^((uintptr_t)4294967295ULL); + x590 = ((x191)&(x588))|(((uintptr_t)0ULL)&(x589)); + x591 = ((uintptr_t)-1ULL)+((uintptr_t)((x459)==((uintptr_t)0ULL))); + x592 = (x591)^((uintptr_t)4294967295ULL); + x593 = ((x194)&(x591))|(((uintptr_t)0ULL)&(x592)); + x594 = (x425)+(x560); + x595 = (uintptr_t)((x594)<(x425)); + x596 = (x595)+(x428); + x597 = (uintptr_t)((x596)<(x428)); + x598 = (x596)+(x563); + x599 = (uintptr_t)((x598)<(x563)); + x600 = (x597)+(x599); + x601 = (x600)+(x431); + x602 = (uintptr_t)((x601)<(x431)); + x603 = (x601)+(x566); + x604 = (uintptr_t)((x603)<(x566)); + x605 = (x602)+(x604); + x606 = (x605)+(x434); + x607 = (uintptr_t)((x606)<(x434)); + x608 = (x606)+(x569); + x609 = (uintptr_t)((x608)<(x569)); + x610 = (x607)+(x609); + x611 = (x610)+(x437); + x612 = (uintptr_t)((x611)<(x437)); + x613 = (x611)+(x572); + x614 = (uintptr_t)((x613)<(x572)); + x615 = (x612)+(x614); + x616 = (x615)+(x440); + x617 = (uintptr_t)((x616)<(x440)); + x618 = (x616)+(x575); + x619 = (uintptr_t)((x618)<(x575)); + x620 = (x617)+(x619); + x621 = (x620)+(x443); + x622 = (uintptr_t)((x621)<(x443)); + x623 = (x621)+(x578); + x624 = (uintptr_t)((x623)<(x578)); + x625 = (x622)+(x624); + x626 = (x625)+(x446); + x627 = (uintptr_t)((x626)<(x446)); + x628 = (x626)+(x581); + x629 = (uintptr_t)((x628)<(x581)); + x630 = (x627)+(x629); + x631 = (x630)+(x449); + x632 = (uintptr_t)((x631)<(x449)); + x633 = (x631)+(x584); + x634 = (uintptr_t)((x633)<(x584)); + x635 = (x632)+(x634); + x636 = (x635)+(x452); + x637 = (uintptr_t)((x636)<(x452)); + x638 = (x636)+(x587); + x639 = (uintptr_t)((x638)<(x587)); + x640 = (x637)+(x639); + x641 = (x640)+(x455); + x642 = (uintptr_t)((x641)<(x455)); + x643 = (x641)+(x590); + x644 = (uintptr_t)((x643)<(x590)); + x645 = (x642)+(x644); + x646 = (x645)+(x458); + x647 = (uintptr_t)((x646)<(x458)); + x648 = (x646)+(x593); + x649 = (uintptr_t)((x648)<(x593)); + x650 = (x647)+(x649); + x651 = (x594)-((uintptr_t)3435473267ULL); + x652 = (uintptr_t)((x594)<(x651)); + x653 = (x598)-((uintptr_t)3974895978ULL); + x654 = (uintptr_t)((x598)<(x653)); + x655 = (x653)-(x652); + x656 = (uintptr_t)((x653)<(x655)); + x657 = (x654)+(x656); + x658 = (x603)-((uintptr_t)1219536762ULL); + x659 = (uintptr_t)((x603)<(x658)); + x660 = (x658)-(x657); + x661 = (uintptr_t)((x658)<(x660)); + x662 = (x659)+(x661); + x663 = (x608)-((uintptr_t)1478102450ULL); + x664 = (uintptr_t)((x608)<(x663)); + x665 = (x663)-(x662); + x666 = (uintptr_t)((x663)<(x665)); + x667 = (x664)+(x666); + x668 = (x613)-((uintptr_t)4097256927ULL); + x669 = (uintptr_t)((x613)<(x668)); + x670 = (x668)-(x667); + x671 = (uintptr_t)((x668)<(x670)); + x672 = (x669)+(x671); + x673 = (x618)-((uintptr_t)3345173889ULL); + x674 = (uintptr_t)((x618)<(x673)); + x675 = (x673)-(x672); + x676 = (uintptr_t)((x673)<(x675)); + x677 = (x674)+(x676); + x678 = (x623)-((uintptr_t)4294967295ULL); + x679 = (uintptr_t)((x623)<(x678)); + x680 = (x678)-(x677); + x681 = (uintptr_t)((x678)<(x680)); + x682 = (x679)+(x681); + x683 = (x628)-((uintptr_t)4294967295ULL); + x684 = (uintptr_t)((x628)<(x683)); + x685 = (x683)-(x682); + x686 = (uintptr_t)((x683)<(x685)); + x687 = (x684)+(x686); + x688 = (x633)-((uintptr_t)4294967295ULL); + x689 = (uintptr_t)((x633)<(x688)); + x690 = (x688)-(x687); + x691 = (uintptr_t)((x688)<(x690)); + x692 = (x689)+(x691); + x693 = (x638)-((uintptr_t)4294967295ULL); + x694 = (uintptr_t)((x638)<(x693)); + x695 = (x693)-(x692); + x696 = (uintptr_t)((x693)<(x695)); + x697 = (x694)+(x696); + x698 = (x643)-((uintptr_t)4294967295ULL); + x699 = (uintptr_t)((x643)<(x698)); + x700 = (x698)-(x697); + x701 = (uintptr_t)((x698)<(x700)); + x702 = (x699)+(x701); + x703 = (x648)-((uintptr_t)4294967295ULL); + x704 = (uintptr_t)((x648)<(x703)); + x705 = (x703)-(x702); + x706 = (uintptr_t)((x703)<(x705)); + x707 = (x704)+(x706); + x708 = (x650)-(x707); + x709 = (uintptr_t)((x650)<(x708)); + x710 = (x55)+((uintptr_t)1ULL); + x711 = ((x499)>>((uintptr_t)1ULL))|((x503)<<((uintptr_t)31ULL)); + x712 = ((x503)>>((uintptr_t)1ULL))|((x508)<<((uintptr_t)31ULL)); + x713 = ((x508)>>((uintptr_t)1ULL))|((x513)<<((uintptr_t)31ULL)); + x714 = ((x513)>>((uintptr_t)1ULL))|((x518)<<((uintptr_t)31ULL)); + x715 = ((x518)>>((uintptr_t)1ULL))|((x523)<<((uintptr_t)31ULL)); + x716 = ((x523)>>((uintptr_t)1ULL))|((x528)<<((uintptr_t)31ULL)); + x717 = ((x528)>>((uintptr_t)1ULL))|((x533)<<((uintptr_t)31ULL)); + x718 = ((x533)>>((uintptr_t)1ULL))|((x538)<<((uintptr_t)31ULL)); + x719 = ((x538)>>((uintptr_t)1ULL))|((x543)<<((uintptr_t)31ULL)); + x720 = ((x543)>>((uintptr_t)1ULL))|((x548)<<((uintptr_t)31ULL)); + x721 = ((x548)>>((uintptr_t)1ULL))|((x553)<<((uintptr_t)31ULL)); + x722 = ((x553)>>((uintptr_t)1ULL))|((x557)<<((uintptr_t)31ULL)); + x723 = ((x557)&((uintptr_t)2147483648ULL))|((x557)>>((uintptr_t)1ULL)); + x724 = ((uintptr_t)-1ULL)+((uintptr_t)((x310)==((uintptr_t)0ULL))); + x725 = (x724)^((uintptr_t)4294967295ULL); + x726 = ((x195)&(x724))|((x252)&(x725)); + x727 = ((uintptr_t)-1ULL)+((uintptr_t)((x310)==((uintptr_t)0ULL))); + x728 = (x727)^((uintptr_t)4294967295ULL); + x729 = ((x199)&(x727))|((x256)&(x728)); + x730 = ((uintptr_t)-1ULL)+((uintptr_t)((x310)==((uintptr_t)0ULL))); + x731 = (x730)^((uintptr_t)4294967295ULL); + x732 = ((x204)&(x730))|((x261)&(x731)); + x733 = ((uintptr_t)-1ULL)+((uintptr_t)((x310)==((uintptr_t)0ULL))); + x734 = (x733)^((uintptr_t)4294967295ULL); + x735 = ((x209)&(x733))|((x266)&(x734)); + x736 = ((uintptr_t)-1ULL)+((uintptr_t)((x310)==((uintptr_t)0ULL))); + x737 = (x736)^((uintptr_t)4294967295ULL); + x738 = ((x214)&(x736))|((x271)&(x737)); + x739 = ((uintptr_t)-1ULL)+((uintptr_t)((x310)==((uintptr_t)0ULL))); + x740 = (x739)^((uintptr_t)4294967295ULL); + x741 = ((x219)&(x739))|((x276)&(x740)); + x742 = ((uintptr_t)-1ULL)+((uintptr_t)((x310)==((uintptr_t)0ULL))); + x743 = (x742)^((uintptr_t)4294967295ULL); + x744 = ((x224)&(x742))|((x281)&(x743)); + x745 = ((uintptr_t)-1ULL)+((uintptr_t)((x310)==((uintptr_t)0ULL))); + x746 = (x745)^((uintptr_t)4294967295ULL); + x747 = ((x229)&(x745))|((x286)&(x746)); + x748 = ((uintptr_t)-1ULL)+((uintptr_t)((x310)==((uintptr_t)0ULL))); + x749 = (x748)^((uintptr_t)4294967295ULL); + x750 = ((x234)&(x748))|((x291)&(x749)); + x751 = ((uintptr_t)-1ULL)+((uintptr_t)((x310)==((uintptr_t)0ULL))); + x752 = (x751)^((uintptr_t)4294967295ULL); + x753 = ((x239)&(x751))|((x296)&(x752)); + x754 = ((uintptr_t)-1ULL)+((uintptr_t)((x310)==((uintptr_t)0ULL))); + x755 = (x754)^((uintptr_t)4294967295ULL); + x756 = ((x244)&(x754))|((x301)&(x755)); + x757 = ((uintptr_t)-1ULL)+((uintptr_t)((x310)==((uintptr_t)0ULL))); + x758 = (x757)^((uintptr_t)4294967295ULL); + x759 = ((x249)&(x757))|((x306)&(x758)); + x760 = ((uintptr_t)-1ULL)+((uintptr_t)((x709)==((uintptr_t)0ULL))); + x761 = (x760)^((uintptr_t)4294967295ULL); + x762 = ((x594)&(x760))|((x651)&(x761)); + x763 = ((uintptr_t)-1ULL)+((uintptr_t)((x709)==((uintptr_t)0ULL))); + x764 = (x763)^((uintptr_t)4294967295ULL); + x765 = ((x598)&(x763))|((x655)&(x764)); + x766 = ((uintptr_t)-1ULL)+((uintptr_t)((x709)==((uintptr_t)0ULL))); + x767 = (x766)^((uintptr_t)4294967295ULL); + x768 = ((x603)&(x766))|((x660)&(x767)); + x769 = ((uintptr_t)-1ULL)+((uintptr_t)((x709)==((uintptr_t)0ULL))); + x770 = (x769)^((uintptr_t)4294967295ULL); + x771 = ((x608)&(x769))|((x665)&(x770)); + x772 = ((uintptr_t)-1ULL)+((uintptr_t)((x709)==((uintptr_t)0ULL))); + x773 = (x772)^((uintptr_t)4294967295ULL); + x774 = ((x613)&(x772))|((x670)&(x773)); + x775 = ((uintptr_t)-1ULL)+((uintptr_t)((x709)==((uintptr_t)0ULL))); + x776 = (x775)^((uintptr_t)4294967295ULL); + x777 = ((x618)&(x775))|((x675)&(x776)); + x778 = ((uintptr_t)-1ULL)+((uintptr_t)((x709)==((uintptr_t)0ULL))); + x779 = (x778)^((uintptr_t)4294967295ULL); + x780 = ((x623)&(x778))|((x680)&(x779)); + x781 = ((uintptr_t)-1ULL)+((uintptr_t)((x709)==((uintptr_t)0ULL))); + x782 = (x781)^((uintptr_t)4294967295ULL); + x783 = ((x628)&(x781))|((x685)&(x782)); + x784 = ((uintptr_t)-1ULL)+((uintptr_t)((x709)==((uintptr_t)0ULL))); + x785 = (x784)^((uintptr_t)4294967295ULL); + x786 = ((x633)&(x784))|((x690)&(x785)); + x787 = ((uintptr_t)-1ULL)+((uintptr_t)((x709)==((uintptr_t)0ULL))); + x788 = (x787)^((uintptr_t)4294967295ULL); + x789 = ((x638)&(x787))|((x695)&(x788)); + x790 = ((uintptr_t)-1ULL)+((uintptr_t)((x709)==((uintptr_t)0ULL))); + x791 = (x790)^((uintptr_t)4294967295ULL); + x792 = ((x643)&(x790))|((x700)&(x791)); + x793 = ((uintptr_t)-1ULL)+((uintptr_t)((x709)==((uintptr_t)0ULL))); + x794 = (x793)^((uintptr_t)4294967295ULL); + x795 = ((x648)&(x793))|((x705)&(x794)); + x796 = x710; + x797 = x58; + x798 = x61; + x799 = x64; + x800 = x67; + x801 = x70; + x802 = x73; + x803 = x76; + x804 = x79; + x805 = x82; + x806 = x85; + x807 = x88; + x808 = x91; + x809 = x94; + /*skip*/ + x810 = x711; + x811 = x712; + x812 = x713; + x813 = x714; + x814 = x715; + x815 = x716; + x816 = x717; + x817 = x718; + x818 = x719; + x819 = x720; + x820 = x721; + x821 = x722; + x822 = x723; + /*skip*/ + x823 = x726; + x824 = x729; + x825 = x732; + x826 = x735; + x827 = x738; + x828 = x741; + x829 = x744; + x830 = x747; + x831 = x750; + x832 = x753; + x833 = x756; + x834 = x759; + /*skip*/ + x835 = x762; + x836 = x765; + x837 = x768; + x838 = x771; + x839 = x774; + x840 = x777; + x841 = x780; + x842 = x783; + x843 = x786; + x844 = x789; + x845 = x792; + x846 = x795; + /*skip*/ + out0 = x796; + _br2_store((out1)+((uintptr_t)0ULL), x797, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)4ULL), x798, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)8ULL), x799, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)12ULL), x800, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)16ULL), x801, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)20ULL), x802, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)24ULL), x803, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)28ULL), x804, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)32ULL), x805, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)36ULL), x806, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)40ULL), x807, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)44ULL), x808, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)48ULL), x809, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out2)+((uintptr_t)0ULL), x810, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)4ULL), x811, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)8ULL), x812, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)12ULL), x813, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)16ULL), x814, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)20ULL), x815, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)24ULL), x816, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)28ULL), x817, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)32ULL), x818, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)36ULL), x819, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)40ULL), x820, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)44ULL), x821, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)48ULL), x822, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out3)+((uintptr_t)0ULL), x823, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)4ULL), x824, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)8ULL), x825, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)12ULL), x826, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)16ULL), x827, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)20ULL), x828, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)24ULL), x829, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)28ULL), x830, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)32ULL), x831, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)36ULL), x832, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)40ULL), x833, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)44ULL), x834, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out4)+((uintptr_t)0ULL), x835, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)4ULL), x836, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)8ULL), x837, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)12ULL), x838, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)16ULL), x839, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)20ULL), x840, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)24ULL), x841, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)28ULL), x842, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)32ULL), x843, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)36ULL), x844, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)40ULL), x845, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)44ULL), x846, sizeof(uintptr_t)); + /*skip*/ + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_divstep(uint32_t* out1, uint32_t out2[13], uint32_t out3[13], uint32_t out4[12], uint32_t out5[12], uint32_t arg1, const uint32_t arg2[13], const uint32_t arg3[13], const uint32_t arg4[12], const uint32_t arg5[12]) { + *out1 = (uint32_t)internal_fiat_p384_scalar_divstep((uintptr_t)out2, (uintptr_t)out3, (uintptr_t)out4, (uintptr_t)out5, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3, (uintptr_t)arg4, (uintptr_t)arg5); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_p384_scalar_divstep_precomp(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11; + /*skip*/ + x0 = (uintptr_t)3859045226ULL; + x1 = (uintptr_t)1230543584ULL; + x2 = (uintptr_t)2264940781ULL; + x3 = (uintptr_t)1016746834ULL; + x4 = (uintptr_t)2541601346ULL; + x5 = (uintptr_t)3670739326ULL; + x6 = (uintptr_t)3521953334ULL; + x7 = (uintptr_t)3047895206ULL; + x8 = (uintptr_t)529897843ULL; + x9 = (uintptr_t)2547491080ULL; + x10 = (uintptr_t)3530658492ULL; + x11 = (uintptr_t)731910904ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x7, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x8, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)36ULL), x9, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x10, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)44ULL), x11, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_divstep_precomp(uint32_t out1[12]) { + internal_fiat_p384_scalar_divstep_precomp((uintptr_t)out1); +} diff --git a/fiat-bedrock2/src/p384_scalar_64.c b/fiat-bedrock2/src/p384_scalar_64.c new file mode 100644 index 0000000000..f3258b4f0e --- /dev/null +++ b/fiat-bedrock2/src/p384_scalar_64.c @@ -0,0 +1,3867 @@ +/* Autogenerated: 'src/ExtractionOCaml/bedrock2_word_by_word_montgomery' --lang bedrock2 --static --no-wide-int --widen-carry --widen-bytes --split-multiret --no-select --no-field-element-typedefs p384_scalar 64 '2^384 - 1388124618062372383947042015309946732620727252194336364173' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: p384_scalar */ +/* machine_wordsize = 64 (from "64") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from "2^384 - 1388124618062372383947042015309946732620727252194336364173") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) in */ +/* if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384 */ + +#include +#include + +// We use memcpy to work around -fstrict-aliasing. +// A plain memcpy is enough on clang 10, but not on gcc 10, which fails +// to infer the bounds on an integer loaded by memcpy. +// Adding a range mask after memcpy in turn makes slower code in clang. +// Loading individual bytes, shifting them together, and or-ing is fast +// on clang and sometimes on GCC, but other times GCC inlines individual +// byte operations without reconstructing wider accesses. +// The little-endian idiom below seems fast in gcc 9+ and clang 10. +static __attribute__((always_inline)) inline uintptr_t +_br2_load(uintptr_t a, uintptr_t sz) { + switch (sz) { + case 1: { uint8_t r = 0; memcpy(&r, (void*)a, 1); return r; } + case 2: { uint16_t r = 0; memcpy(&r, (void*)a, 2); return r; } + case 4: { uint32_t r = 0; memcpy(&r, (void*)a, 4); return r; } + case 8: { uint64_t r = 0; memcpy(&r, (void*)a, 8); return r; } + default: __builtin_unreachable(); + } +} + +static __attribute__((always_inline)) inline void +_br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) { + memcpy((void*)a, &v, sz); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p384_scalar_mul(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x1, x2, x3, x4, x5, x0, x17, x26, x29, x31, x27, x32, x24, x33, x35, x36, x25, x37, x22, x38, x40, x41, x23, x42, x20, x43, x45, x46, x21, x47, x18, x48, x50, x51, x19, x53, x62, x65, x67, x63, x68, x60, x69, x71, x72, x61, x73, x58, x74, x76, x77, x59, x78, x56, x79, x81, x82, x57, x83, x54, x84, x86, x87, x55, x64, x89, x28, x90, x30, x91, x66, x92, x94, x95, x34, x96, x70, x97, x99, x100, x39, x101, x75, x102, x104, x105, x44, x106, x80, x107, x109, x110, x49, x111, x85, x112, x114, x115, x52, x116, x88, x117, x119, x12, x129, x132, x134, x130, x135, x127, x136, x138, x139, x128, x140, x125, x141, x143, x144, x126, x145, x123, x146, x148, x149, x124, x150, x121, x151, x153, x154, x122, x131, x93, x157, x98, x158, x133, x159, x161, x162, x103, x163, x137, x164, x166, x167, x108, x168, x142, x169, x171, x172, x113, x173, x147, x174, x176, x177, x118, x178, x152, x179, x181, x182, x120, x183, x155, x184, x186, x188, x197, x200, x202, x198, x203, x195, x204, x206, x207, x196, x208, x193, x209, x211, x212, x194, x213, x191, x214, x216, x217, x192, x218, x189, x219, x221, x222, x190, x199, x224, x156, x225, x160, x226, x201, x227, x229, x230, x165, x231, x205, x232, x234, x235, x170, x236, x210, x237, x239, x240, x175, x241, x215, x242, x244, x245, x180, x246, x220, x247, x249, x250, x185, x251, x223, x252, x254, x255, x187, x13, x265, x268, x270, x266, x271, x263, x272, x274, x275, x264, x276, x261, x277, x279, x280, x262, x281, x259, x282, x284, x285, x260, x286, x257, x287, x289, x290, x258, x267, x228, x293, x233, x294, x269, x295, x297, x298, x238, x299, x273, x300, x302, x303, x243, x304, x278, x305, x307, x308, x248, x309, x283, x310, x312, x313, x253, x314, x288, x315, x317, x318, x256, x319, x291, x320, x322, x324, x333, x336, x338, x334, x339, x331, x340, x342, x343, x332, x344, x329, x345, x347, x348, x330, x349, x327, x350, x352, x353, x328, x354, x325, x355, x357, x358, x326, x335, x360, x292, x361, x296, x362, x337, x363, x365, x366, x301, x367, x341, x368, x370, x371, x306, x372, x346, x373, x375, x376, x311, x377, x351, x378, x380, x381, x316, x382, x356, x383, x385, x386, x321, x387, x359, x388, x390, x391, x323, x14, x401, x404, x406, x402, x407, x399, x408, x410, x411, x400, x412, x397, x413, x415, x416, x398, x417, x395, x418, x420, x421, x396, x422, x393, x423, x425, x426, x394, x403, x364, x429, x369, x430, x405, x431, x433, x434, x374, x435, x409, x436, x438, x439, x379, x440, x414, x441, x443, x444, x384, x445, x419, x446, x448, x449, x389, x450, x424, x451, x453, x454, x392, x455, x427, x456, x458, x460, x469, x472, x474, x470, x475, x467, x476, x478, x479, x468, x480, x465, x481, x483, x484, x466, x485, x463, x486, x488, x489, x464, x490, x461, x491, x493, x494, x462, x471, x496, x428, x497, x432, x498, x473, x499, x501, x502, x437, x503, x477, x504, x506, x507, x442, x508, x482, x509, x511, x512, x447, x513, x487, x514, x516, x517, x452, x518, x492, x519, x521, x522, x457, x523, x495, x524, x526, x527, x459, x15, x537, x540, x542, x538, x543, x535, x544, x546, x547, x536, x548, x533, x549, x551, x552, x534, x553, x531, x554, x556, x557, x532, x558, x529, x559, x561, x562, x530, x539, x500, x565, x505, x566, x541, x567, x569, x570, x510, x571, x545, x572, x574, x575, x515, x576, x550, x577, x579, x580, x520, x581, x555, x582, x584, x585, x525, x586, x560, x587, x589, x590, x528, x591, x563, x592, x594, x596, x605, x608, x610, x606, x611, x603, x612, x614, x615, x604, x616, x601, x617, x619, x620, x602, x621, x599, x622, x624, x625, x600, x626, x597, x627, x629, x630, x598, x607, x632, x564, x633, x568, x634, x609, x635, x637, x638, x573, x639, x613, x640, x642, x643, x578, x644, x618, x645, x647, x648, x583, x649, x623, x650, x652, x653, x588, x654, x628, x655, x657, x658, x593, x659, x631, x660, x662, x663, x595, x11, x10, x9, x8, x7, x16, x6, x673, x676, x678, x674, x679, x671, x680, x682, x683, x672, x684, x669, x685, x687, x688, x670, x689, x667, x690, x692, x693, x668, x694, x665, x695, x697, x698, x666, x675, x636, x701, x641, x702, x677, x703, x705, x706, x646, x707, x681, x708, x710, x711, x651, x712, x686, x713, x715, x716, x656, x717, x691, x718, x720, x721, x661, x722, x696, x723, x725, x726, x664, x727, x699, x728, x730, x732, x741, x744, x746, x742, x747, x739, x748, x750, x751, x740, x752, x737, x753, x755, x756, x738, x757, x735, x758, x760, x761, x736, x762, x733, x763, x765, x766, x734, x743, x768, x700, x769, x704, x770, x745, x771, x773, x774, x709, x775, x749, x776, x778, x779, x714, x780, x754, x781, x783, x784, x719, x785, x759, x786, x788, x789, x724, x790, x764, x791, x793, x794, x729, x795, x767, x796, x798, x799, x731, x802, x803, x804, x806, x807, x808, x809, x811, x812, x813, x814, x816, x817, x818, x819, x821, x822, x823, x824, x826, x827, x800, x828, x772, x830, x801, x831, x777, x833, x805, x834, x782, x836, x810, x837, x787, x839, x815, x840, x792, x842, x820, x843, x829, x797, x845, x825, x846, x832, x835, x838, x841, x844, x847, x848, x849, x850, x851, x852, x853; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + x6 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x8 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x12 = x1; + x13 = x2; + x14 = x3; + x15 = x4; + x16 = x5; + x17 = x0; + x18 = (x17)*(x11); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x11))>>32 : ((__uint128_t)(x17)*(x11))>>64); + x20 = (x17)*(x10); + x21 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x10))>>32 : ((__uint128_t)(x17)*(x10))>>64); + x22 = (x17)*(x9); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x9))>>32 : ((__uint128_t)(x17)*(x9))>>64); + x24 = (x17)*(x8); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x8))>>32 : ((__uint128_t)(x17)*(x8))>>64); + x26 = (x17)*(x7); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x7))>>32 : ((__uint128_t)(x17)*(x7))>>64); + x28 = (x17)*(x6); + x29 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x6))>>32 : ((__uint128_t)(x17)*(x6))>>64); + x30 = (x29)+(x26); + x31 = (uintptr_t)((x30)<(x29)); + x32 = (x31)+(x27); + x33 = (uintptr_t)((x32)<(x27)); + x34 = (x32)+(x24); + x35 = (uintptr_t)((x34)<(x24)); + x36 = (x33)+(x35); + x37 = (x36)+(x25); + x38 = (uintptr_t)((x37)<(x25)); + x39 = (x37)+(x22); + x40 = (uintptr_t)((x39)<(x22)); + x41 = (x38)+(x40); + x42 = (x41)+(x23); + x43 = (uintptr_t)((x42)<(x23)); + x44 = (x42)+(x20); + x45 = (uintptr_t)((x44)<(x20)); + x46 = (x43)+(x45); + x47 = (x46)+(x21); + x48 = (uintptr_t)((x47)<(x21)); + x49 = (x47)+(x18); + x50 = (uintptr_t)((x49)<(x18)); + x51 = (x48)+(x50); + x52 = (x51)+(x19); + x53 = (x28)*((uintptr_t)7986114184663260229ULL); + x54 = (x53)*((uintptr_t)18446744073709551615ULL); + x55 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x53)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x53)*((uintptr_t)18446744073709551615ULL))>>64); + x56 = (x53)*((uintptr_t)18446744073709551615ULL); + x57 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x53)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x53)*((uintptr_t)18446744073709551615ULL))>>64); + x58 = (x53)*((uintptr_t)18446744073709551615ULL); + x59 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x53)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x53)*((uintptr_t)18446744073709551615ULL))>>64); + x60 = (x53)*((uintptr_t)14367412456785391071ULL); + x61 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x53)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x53)*((uintptr_t)14367412456785391071ULL))>>64); + x62 = (x53)*((uintptr_t)6348401684107011962ULL); + x63 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x53)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x53)*((uintptr_t)6348401684107011962ULL))>>64); + x64 = (x53)*((uintptr_t)17072048233947408755ULL); + x65 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x53)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x53)*((uintptr_t)17072048233947408755ULL))>>64); + x66 = (x65)+(x62); + x67 = (uintptr_t)((x66)<(x65)); + x68 = (x67)+(x63); + x69 = (uintptr_t)((x68)<(x63)); + x70 = (x68)+(x60); + x71 = (uintptr_t)((x70)<(x60)); + x72 = (x69)+(x71); + x73 = (x72)+(x61); + x74 = (uintptr_t)((x73)<(x61)); + x75 = (x73)+(x58); + x76 = (uintptr_t)((x75)<(x58)); + x77 = (x74)+(x76); + x78 = (x77)+(x59); + x79 = (uintptr_t)((x78)<(x59)); + x80 = (x78)+(x56); + x81 = (uintptr_t)((x80)<(x56)); + x82 = (x79)+(x81); + x83 = (x82)+(x57); + x84 = (uintptr_t)((x83)<(x57)); + x85 = (x83)+(x54); + x86 = (uintptr_t)((x85)<(x54)); + x87 = (x84)+(x86); + x88 = (x87)+(x55); + x89 = (x28)+(x64); + x90 = (uintptr_t)((x89)<(x28)); + x91 = (x90)+(x30); + x92 = (uintptr_t)((x91)<(x30)); + x93 = (x91)+(x66); + x94 = (uintptr_t)((x93)<(x66)); + x95 = (x92)+(x94); + x96 = (x95)+(x34); + x97 = (uintptr_t)((x96)<(x34)); + x98 = (x96)+(x70); + x99 = (uintptr_t)((x98)<(x70)); + x100 = (x97)+(x99); + x101 = (x100)+(x39); + x102 = (uintptr_t)((x101)<(x39)); + x103 = (x101)+(x75); + x104 = (uintptr_t)((x103)<(x75)); + x105 = (x102)+(x104); + x106 = (x105)+(x44); + x107 = (uintptr_t)((x106)<(x44)); + x108 = (x106)+(x80); + x109 = (uintptr_t)((x108)<(x80)); + x110 = (x107)+(x109); + x111 = (x110)+(x49); + x112 = (uintptr_t)((x111)<(x49)); + x113 = (x111)+(x85); + x114 = (uintptr_t)((x113)<(x85)); + x115 = (x112)+(x114); + x116 = (x115)+(x52); + x117 = (uintptr_t)((x116)<(x52)); + x118 = (x116)+(x88); + x119 = (uintptr_t)((x118)<(x88)); + x120 = (x117)+(x119); + x121 = (x12)*(x11); + x122 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x11))>>32 : ((__uint128_t)(x12)*(x11))>>64); + x123 = (x12)*(x10); + x124 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x10))>>32 : ((__uint128_t)(x12)*(x10))>>64); + x125 = (x12)*(x9); + x126 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x9))>>32 : ((__uint128_t)(x12)*(x9))>>64); + x127 = (x12)*(x8); + x128 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x8))>>32 : ((__uint128_t)(x12)*(x8))>>64); + x129 = (x12)*(x7); + x130 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x7))>>32 : ((__uint128_t)(x12)*(x7))>>64); + x131 = (x12)*(x6); + x132 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x6))>>32 : ((__uint128_t)(x12)*(x6))>>64); + x133 = (x132)+(x129); + x134 = (uintptr_t)((x133)<(x132)); + x135 = (x134)+(x130); + x136 = (uintptr_t)((x135)<(x130)); + x137 = (x135)+(x127); + x138 = (uintptr_t)((x137)<(x127)); + x139 = (x136)+(x138); + x140 = (x139)+(x128); + x141 = (uintptr_t)((x140)<(x128)); + x142 = (x140)+(x125); + x143 = (uintptr_t)((x142)<(x125)); + x144 = (x141)+(x143); + x145 = (x144)+(x126); + x146 = (uintptr_t)((x145)<(x126)); + x147 = (x145)+(x123); + x148 = (uintptr_t)((x147)<(x123)); + x149 = (x146)+(x148); + x150 = (x149)+(x124); + x151 = (uintptr_t)((x150)<(x124)); + x152 = (x150)+(x121); + x153 = (uintptr_t)((x152)<(x121)); + x154 = (x151)+(x153); + x155 = (x154)+(x122); + x156 = (x93)+(x131); + x157 = (uintptr_t)((x156)<(x93)); + x158 = (x157)+(x98); + x159 = (uintptr_t)((x158)<(x98)); + x160 = (x158)+(x133); + x161 = (uintptr_t)((x160)<(x133)); + x162 = (x159)+(x161); + x163 = (x162)+(x103); + x164 = (uintptr_t)((x163)<(x103)); + x165 = (x163)+(x137); + x166 = (uintptr_t)((x165)<(x137)); + x167 = (x164)+(x166); + x168 = (x167)+(x108); + x169 = (uintptr_t)((x168)<(x108)); + x170 = (x168)+(x142); + x171 = (uintptr_t)((x170)<(x142)); + x172 = (x169)+(x171); + x173 = (x172)+(x113); + x174 = (uintptr_t)((x173)<(x113)); + x175 = (x173)+(x147); + x176 = (uintptr_t)((x175)<(x147)); + x177 = (x174)+(x176); + x178 = (x177)+(x118); + x179 = (uintptr_t)((x178)<(x118)); + x180 = (x178)+(x152); + x181 = (uintptr_t)((x180)<(x152)); + x182 = (x179)+(x181); + x183 = (x182)+(x120); + x184 = (uintptr_t)((x183)<(x120)); + x185 = (x183)+(x155); + x186 = (uintptr_t)((x185)<(x155)); + x187 = (x184)+(x186); + x188 = (x156)*((uintptr_t)7986114184663260229ULL); + x189 = (x188)*((uintptr_t)18446744073709551615ULL); + x190 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x188)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x188)*((uintptr_t)18446744073709551615ULL))>>64); + x191 = (x188)*((uintptr_t)18446744073709551615ULL); + x192 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x188)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x188)*((uintptr_t)18446744073709551615ULL))>>64); + x193 = (x188)*((uintptr_t)18446744073709551615ULL); + x194 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x188)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x188)*((uintptr_t)18446744073709551615ULL))>>64); + x195 = (x188)*((uintptr_t)14367412456785391071ULL); + x196 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x188)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x188)*((uintptr_t)14367412456785391071ULL))>>64); + x197 = (x188)*((uintptr_t)6348401684107011962ULL); + x198 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x188)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x188)*((uintptr_t)6348401684107011962ULL))>>64); + x199 = (x188)*((uintptr_t)17072048233947408755ULL); + x200 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x188)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x188)*((uintptr_t)17072048233947408755ULL))>>64); + x201 = (x200)+(x197); + x202 = (uintptr_t)((x201)<(x200)); + x203 = (x202)+(x198); + x204 = (uintptr_t)((x203)<(x198)); + x205 = (x203)+(x195); + x206 = (uintptr_t)((x205)<(x195)); + x207 = (x204)+(x206); + x208 = (x207)+(x196); + x209 = (uintptr_t)((x208)<(x196)); + x210 = (x208)+(x193); + x211 = (uintptr_t)((x210)<(x193)); + x212 = (x209)+(x211); + x213 = (x212)+(x194); + x214 = (uintptr_t)((x213)<(x194)); + x215 = (x213)+(x191); + x216 = (uintptr_t)((x215)<(x191)); + x217 = (x214)+(x216); + x218 = (x217)+(x192); + x219 = (uintptr_t)((x218)<(x192)); + x220 = (x218)+(x189); + x221 = (uintptr_t)((x220)<(x189)); + x222 = (x219)+(x221); + x223 = (x222)+(x190); + x224 = (x156)+(x199); + x225 = (uintptr_t)((x224)<(x156)); + x226 = (x225)+(x160); + x227 = (uintptr_t)((x226)<(x160)); + x228 = (x226)+(x201); + x229 = (uintptr_t)((x228)<(x201)); + x230 = (x227)+(x229); + x231 = (x230)+(x165); + x232 = (uintptr_t)((x231)<(x165)); + x233 = (x231)+(x205); + x234 = (uintptr_t)((x233)<(x205)); + x235 = (x232)+(x234); + x236 = (x235)+(x170); + x237 = (uintptr_t)((x236)<(x170)); + x238 = (x236)+(x210); + x239 = (uintptr_t)((x238)<(x210)); + x240 = (x237)+(x239); + x241 = (x240)+(x175); + x242 = (uintptr_t)((x241)<(x175)); + x243 = (x241)+(x215); + x244 = (uintptr_t)((x243)<(x215)); + x245 = (x242)+(x244); + x246 = (x245)+(x180); + x247 = (uintptr_t)((x246)<(x180)); + x248 = (x246)+(x220); + x249 = (uintptr_t)((x248)<(x220)); + x250 = (x247)+(x249); + x251 = (x250)+(x185); + x252 = (uintptr_t)((x251)<(x185)); + x253 = (x251)+(x223); + x254 = (uintptr_t)((x253)<(x223)); + x255 = (x252)+(x254); + x256 = (x255)+(x187); + x257 = (x13)*(x11); + x258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x11))>>32 : ((__uint128_t)(x13)*(x11))>>64); + x259 = (x13)*(x10); + x260 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x10))>>32 : ((__uint128_t)(x13)*(x10))>>64); + x261 = (x13)*(x9); + x262 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x9))>>32 : ((__uint128_t)(x13)*(x9))>>64); + x263 = (x13)*(x8); + x264 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x8))>>32 : ((__uint128_t)(x13)*(x8))>>64); + x265 = (x13)*(x7); + x266 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x7))>>32 : ((__uint128_t)(x13)*(x7))>>64); + x267 = (x13)*(x6); + x268 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x6))>>32 : ((__uint128_t)(x13)*(x6))>>64); + x269 = (x268)+(x265); + x270 = (uintptr_t)((x269)<(x268)); + x271 = (x270)+(x266); + x272 = (uintptr_t)((x271)<(x266)); + x273 = (x271)+(x263); + x274 = (uintptr_t)((x273)<(x263)); + x275 = (x272)+(x274); + x276 = (x275)+(x264); + x277 = (uintptr_t)((x276)<(x264)); + x278 = (x276)+(x261); + x279 = (uintptr_t)((x278)<(x261)); + x280 = (x277)+(x279); + x281 = (x280)+(x262); + x282 = (uintptr_t)((x281)<(x262)); + x283 = (x281)+(x259); + x284 = (uintptr_t)((x283)<(x259)); + x285 = (x282)+(x284); + x286 = (x285)+(x260); + x287 = (uintptr_t)((x286)<(x260)); + x288 = (x286)+(x257); + x289 = (uintptr_t)((x288)<(x257)); + x290 = (x287)+(x289); + x291 = (x290)+(x258); + x292 = (x228)+(x267); + x293 = (uintptr_t)((x292)<(x228)); + x294 = (x293)+(x233); + x295 = (uintptr_t)((x294)<(x233)); + x296 = (x294)+(x269); + x297 = (uintptr_t)((x296)<(x269)); + x298 = (x295)+(x297); + x299 = (x298)+(x238); + x300 = (uintptr_t)((x299)<(x238)); + x301 = (x299)+(x273); + x302 = (uintptr_t)((x301)<(x273)); + x303 = (x300)+(x302); + x304 = (x303)+(x243); + x305 = (uintptr_t)((x304)<(x243)); + x306 = (x304)+(x278); + x307 = (uintptr_t)((x306)<(x278)); + x308 = (x305)+(x307); + x309 = (x308)+(x248); + x310 = (uintptr_t)((x309)<(x248)); + x311 = (x309)+(x283); + x312 = (uintptr_t)((x311)<(x283)); + x313 = (x310)+(x312); + x314 = (x313)+(x253); + x315 = (uintptr_t)((x314)<(x253)); + x316 = (x314)+(x288); + x317 = (uintptr_t)((x316)<(x288)); + x318 = (x315)+(x317); + x319 = (x318)+(x256); + x320 = (uintptr_t)((x319)<(x256)); + x321 = (x319)+(x291); + x322 = (uintptr_t)((x321)<(x291)); + x323 = (x320)+(x322); + x324 = (x292)*((uintptr_t)7986114184663260229ULL); + x325 = (x324)*((uintptr_t)18446744073709551615ULL); + x326 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x324)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x324)*((uintptr_t)18446744073709551615ULL))>>64); + x327 = (x324)*((uintptr_t)18446744073709551615ULL); + x328 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x324)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x324)*((uintptr_t)18446744073709551615ULL))>>64); + x329 = (x324)*((uintptr_t)18446744073709551615ULL); + x330 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x324)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x324)*((uintptr_t)18446744073709551615ULL))>>64); + x331 = (x324)*((uintptr_t)14367412456785391071ULL); + x332 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x324)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x324)*((uintptr_t)14367412456785391071ULL))>>64); + x333 = (x324)*((uintptr_t)6348401684107011962ULL); + x334 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x324)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x324)*((uintptr_t)6348401684107011962ULL))>>64); + x335 = (x324)*((uintptr_t)17072048233947408755ULL); + x336 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x324)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x324)*((uintptr_t)17072048233947408755ULL))>>64); + x337 = (x336)+(x333); + x338 = (uintptr_t)((x337)<(x336)); + x339 = (x338)+(x334); + x340 = (uintptr_t)((x339)<(x334)); + x341 = (x339)+(x331); + x342 = (uintptr_t)((x341)<(x331)); + x343 = (x340)+(x342); + x344 = (x343)+(x332); + x345 = (uintptr_t)((x344)<(x332)); + x346 = (x344)+(x329); + x347 = (uintptr_t)((x346)<(x329)); + x348 = (x345)+(x347); + x349 = (x348)+(x330); + x350 = (uintptr_t)((x349)<(x330)); + x351 = (x349)+(x327); + x352 = (uintptr_t)((x351)<(x327)); + x353 = (x350)+(x352); + x354 = (x353)+(x328); + x355 = (uintptr_t)((x354)<(x328)); + x356 = (x354)+(x325); + x357 = (uintptr_t)((x356)<(x325)); + x358 = (x355)+(x357); + x359 = (x358)+(x326); + x360 = (x292)+(x335); + x361 = (uintptr_t)((x360)<(x292)); + x362 = (x361)+(x296); + x363 = (uintptr_t)((x362)<(x296)); + x364 = (x362)+(x337); + x365 = (uintptr_t)((x364)<(x337)); + x366 = (x363)+(x365); + x367 = (x366)+(x301); + x368 = (uintptr_t)((x367)<(x301)); + x369 = (x367)+(x341); + x370 = (uintptr_t)((x369)<(x341)); + x371 = (x368)+(x370); + x372 = (x371)+(x306); + x373 = (uintptr_t)((x372)<(x306)); + x374 = (x372)+(x346); + x375 = (uintptr_t)((x374)<(x346)); + x376 = (x373)+(x375); + x377 = (x376)+(x311); + x378 = (uintptr_t)((x377)<(x311)); + x379 = (x377)+(x351); + x380 = (uintptr_t)((x379)<(x351)); + x381 = (x378)+(x380); + x382 = (x381)+(x316); + x383 = (uintptr_t)((x382)<(x316)); + x384 = (x382)+(x356); + x385 = (uintptr_t)((x384)<(x356)); + x386 = (x383)+(x385); + x387 = (x386)+(x321); + x388 = (uintptr_t)((x387)<(x321)); + x389 = (x387)+(x359); + x390 = (uintptr_t)((x389)<(x359)); + x391 = (x388)+(x390); + x392 = (x391)+(x323); + x393 = (x14)*(x11); + x394 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x11))>>32 : ((__uint128_t)(x14)*(x11))>>64); + x395 = (x14)*(x10); + x396 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x10))>>32 : ((__uint128_t)(x14)*(x10))>>64); + x397 = (x14)*(x9); + x398 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x9))>>32 : ((__uint128_t)(x14)*(x9))>>64); + x399 = (x14)*(x8); + x400 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x8))>>32 : ((__uint128_t)(x14)*(x8))>>64); + x401 = (x14)*(x7); + x402 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x7))>>32 : ((__uint128_t)(x14)*(x7))>>64); + x403 = (x14)*(x6); + x404 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x6))>>32 : ((__uint128_t)(x14)*(x6))>>64); + x405 = (x404)+(x401); + x406 = (uintptr_t)((x405)<(x404)); + x407 = (x406)+(x402); + x408 = (uintptr_t)((x407)<(x402)); + x409 = (x407)+(x399); + x410 = (uintptr_t)((x409)<(x399)); + x411 = (x408)+(x410); + x412 = (x411)+(x400); + x413 = (uintptr_t)((x412)<(x400)); + x414 = (x412)+(x397); + x415 = (uintptr_t)((x414)<(x397)); + x416 = (x413)+(x415); + x417 = (x416)+(x398); + x418 = (uintptr_t)((x417)<(x398)); + x419 = (x417)+(x395); + x420 = (uintptr_t)((x419)<(x395)); + x421 = (x418)+(x420); + x422 = (x421)+(x396); + x423 = (uintptr_t)((x422)<(x396)); + x424 = (x422)+(x393); + x425 = (uintptr_t)((x424)<(x393)); + x426 = (x423)+(x425); + x427 = (x426)+(x394); + x428 = (x364)+(x403); + x429 = (uintptr_t)((x428)<(x364)); + x430 = (x429)+(x369); + x431 = (uintptr_t)((x430)<(x369)); + x432 = (x430)+(x405); + x433 = (uintptr_t)((x432)<(x405)); + x434 = (x431)+(x433); + x435 = (x434)+(x374); + x436 = (uintptr_t)((x435)<(x374)); + x437 = (x435)+(x409); + x438 = (uintptr_t)((x437)<(x409)); + x439 = (x436)+(x438); + x440 = (x439)+(x379); + x441 = (uintptr_t)((x440)<(x379)); + x442 = (x440)+(x414); + x443 = (uintptr_t)((x442)<(x414)); + x444 = (x441)+(x443); + x445 = (x444)+(x384); + x446 = (uintptr_t)((x445)<(x384)); + x447 = (x445)+(x419); + x448 = (uintptr_t)((x447)<(x419)); + x449 = (x446)+(x448); + x450 = (x449)+(x389); + x451 = (uintptr_t)((x450)<(x389)); + x452 = (x450)+(x424); + x453 = (uintptr_t)((x452)<(x424)); + x454 = (x451)+(x453); + x455 = (x454)+(x392); + x456 = (uintptr_t)((x455)<(x392)); + x457 = (x455)+(x427); + x458 = (uintptr_t)((x457)<(x427)); + x459 = (x456)+(x458); + x460 = (x428)*((uintptr_t)7986114184663260229ULL); + x461 = (x460)*((uintptr_t)18446744073709551615ULL); + x462 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x460)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x460)*((uintptr_t)18446744073709551615ULL))>>64); + x463 = (x460)*((uintptr_t)18446744073709551615ULL); + x464 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x460)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x460)*((uintptr_t)18446744073709551615ULL))>>64); + x465 = (x460)*((uintptr_t)18446744073709551615ULL); + x466 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x460)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x460)*((uintptr_t)18446744073709551615ULL))>>64); + x467 = (x460)*((uintptr_t)14367412456785391071ULL); + x468 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x460)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x460)*((uintptr_t)14367412456785391071ULL))>>64); + x469 = (x460)*((uintptr_t)6348401684107011962ULL); + x470 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x460)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x460)*((uintptr_t)6348401684107011962ULL))>>64); + x471 = (x460)*((uintptr_t)17072048233947408755ULL); + x472 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x460)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x460)*((uintptr_t)17072048233947408755ULL))>>64); + x473 = (x472)+(x469); + x474 = (uintptr_t)((x473)<(x472)); + x475 = (x474)+(x470); + x476 = (uintptr_t)((x475)<(x470)); + x477 = (x475)+(x467); + x478 = (uintptr_t)((x477)<(x467)); + x479 = (x476)+(x478); + x480 = (x479)+(x468); + x481 = (uintptr_t)((x480)<(x468)); + x482 = (x480)+(x465); + x483 = (uintptr_t)((x482)<(x465)); + x484 = (x481)+(x483); + x485 = (x484)+(x466); + x486 = (uintptr_t)((x485)<(x466)); + x487 = (x485)+(x463); + x488 = (uintptr_t)((x487)<(x463)); + x489 = (x486)+(x488); + x490 = (x489)+(x464); + x491 = (uintptr_t)((x490)<(x464)); + x492 = (x490)+(x461); + x493 = (uintptr_t)((x492)<(x461)); + x494 = (x491)+(x493); + x495 = (x494)+(x462); + x496 = (x428)+(x471); + x497 = (uintptr_t)((x496)<(x428)); + x498 = (x497)+(x432); + x499 = (uintptr_t)((x498)<(x432)); + x500 = (x498)+(x473); + x501 = (uintptr_t)((x500)<(x473)); + x502 = (x499)+(x501); + x503 = (x502)+(x437); + x504 = (uintptr_t)((x503)<(x437)); + x505 = (x503)+(x477); + x506 = (uintptr_t)((x505)<(x477)); + x507 = (x504)+(x506); + x508 = (x507)+(x442); + x509 = (uintptr_t)((x508)<(x442)); + x510 = (x508)+(x482); + x511 = (uintptr_t)((x510)<(x482)); + x512 = (x509)+(x511); + x513 = (x512)+(x447); + x514 = (uintptr_t)((x513)<(x447)); + x515 = (x513)+(x487); + x516 = (uintptr_t)((x515)<(x487)); + x517 = (x514)+(x516); + x518 = (x517)+(x452); + x519 = (uintptr_t)((x518)<(x452)); + x520 = (x518)+(x492); + x521 = (uintptr_t)((x520)<(x492)); + x522 = (x519)+(x521); + x523 = (x522)+(x457); + x524 = (uintptr_t)((x523)<(x457)); + x525 = (x523)+(x495); + x526 = (uintptr_t)((x525)<(x495)); + x527 = (x524)+(x526); + x528 = (x527)+(x459); + x529 = (x15)*(x11); + x530 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x11))>>32 : ((__uint128_t)(x15)*(x11))>>64); + x531 = (x15)*(x10); + x532 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x10))>>32 : ((__uint128_t)(x15)*(x10))>>64); + x533 = (x15)*(x9); + x534 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x9))>>32 : ((__uint128_t)(x15)*(x9))>>64); + x535 = (x15)*(x8); + x536 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x8))>>32 : ((__uint128_t)(x15)*(x8))>>64); + x537 = (x15)*(x7); + x538 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x7))>>32 : ((__uint128_t)(x15)*(x7))>>64); + x539 = (x15)*(x6); + x540 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x6))>>32 : ((__uint128_t)(x15)*(x6))>>64); + x541 = (x540)+(x537); + x542 = (uintptr_t)((x541)<(x540)); + x543 = (x542)+(x538); + x544 = (uintptr_t)((x543)<(x538)); + x545 = (x543)+(x535); + x546 = (uintptr_t)((x545)<(x535)); + x547 = (x544)+(x546); + x548 = (x547)+(x536); + x549 = (uintptr_t)((x548)<(x536)); + x550 = (x548)+(x533); + x551 = (uintptr_t)((x550)<(x533)); + x552 = (x549)+(x551); + x553 = (x552)+(x534); + x554 = (uintptr_t)((x553)<(x534)); + x555 = (x553)+(x531); + x556 = (uintptr_t)((x555)<(x531)); + x557 = (x554)+(x556); + x558 = (x557)+(x532); + x559 = (uintptr_t)((x558)<(x532)); + x560 = (x558)+(x529); + x561 = (uintptr_t)((x560)<(x529)); + x562 = (x559)+(x561); + x563 = (x562)+(x530); + x564 = (x500)+(x539); + x565 = (uintptr_t)((x564)<(x500)); + x566 = (x565)+(x505); + x567 = (uintptr_t)((x566)<(x505)); + x568 = (x566)+(x541); + x569 = (uintptr_t)((x568)<(x541)); + x570 = (x567)+(x569); + x571 = (x570)+(x510); + x572 = (uintptr_t)((x571)<(x510)); + x573 = (x571)+(x545); + x574 = (uintptr_t)((x573)<(x545)); + x575 = (x572)+(x574); + x576 = (x575)+(x515); + x577 = (uintptr_t)((x576)<(x515)); + x578 = (x576)+(x550); + x579 = (uintptr_t)((x578)<(x550)); + x580 = (x577)+(x579); + x581 = (x580)+(x520); + x582 = (uintptr_t)((x581)<(x520)); + x583 = (x581)+(x555); + x584 = (uintptr_t)((x583)<(x555)); + x585 = (x582)+(x584); + x586 = (x585)+(x525); + x587 = (uintptr_t)((x586)<(x525)); + x588 = (x586)+(x560); + x589 = (uintptr_t)((x588)<(x560)); + x590 = (x587)+(x589); + x591 = (x590)+(x528); + x592 = (uintptr_t)((x591)<(x528)); + x593 = (x591)+(x563); + x594 = (uintptr_t)((x593)<(x563)); + x595 = (x592)+(x594); + x596 = (x564)*((uintptr_t)7986114184663260229ULL); + x597 = (x596)*((uintptr_t)18446744073709551615ULL); + x598 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x596)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x596)*((uintptr_t)18446744073709551615ULL))>>64); + x599 = (x596)*((uintptr_t)18446744073709551615ULL); + x600 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x596)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x596)*((uintptr_t)18446744073709551615ULL))>>64); + x601 = (x596)*((uintptr_t)18446744073709551615ULL); + x602 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x596)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x596)*((uintptr_t)18446744073709551615ULL))>>64); + x603 = (x596)*((uintptr_t)14367412456785391071ULL); + x604 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x596)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x596)*((uintptr_t)14367412456785391071ULL))>>64); + x605 = (x596)*((uintptr_t)6348401684107011962ULL); + x606 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x596)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x596)*((uintptr_t)6348401684107011962ULL))>>64); + x607 = (x596)*((uintptr_t)17072048233947408755ULL); + x608 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x596)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x596)*((uintptr_t)17072048233947408755ULL))>>64); + x609 = (x608)+(x605); + x610 = (uintptr_t)((x609)<(x608)); + x611 = (x610)+(x606); + x612 = (uintptr_t)((x611)<(x606)); + x613 = (x611)+(x603); + x614 = (uintptr_t)((x613)<(x603)); + x615 = (x612)+(x614); + x616 = (x615)+(x604); + x617 = (uintptr_t)((x616)<(x604)); + x618 = (x616)+(x601); + x619 = (uintptr_t)((x618)<(x601)); + x620 = (x617)+(x619); + x621 = (x620)+(x602); + x622 = (uintptr_t)((x621)<(x602)); + x623 = (x621)+(x599); + x624 = (uintptr_t)((x623)<(x599)); + x625 = (x622)+(x624); + x626 = (x625)+(x600); + x627 = (uintptr_t)((x626)<(x600)); + x628 = (x626)+(x597); + x629 = (uintptr_t)((x628)<(x597)); + x630 = (x627)+(x629); + x631 = (x630)+(x598); + x632 = (x564)+(x607); + x633 = (uintptr_t)((x632)<(x564)); + x634 = (x633)+(x568); + x635 = (uintptr_t)((x634)<(x568)); + x636 = (x634)+(x609); + x637 = (uintptr_t)((x636)<(x609)); + x638 = (x635)+(x637); + x639 = (x638)+(x573); + x640 = (uintptr_t)((x639)<(x573)); + x641 = (x639)+(x613); + x642 = (uintptr_t)((x641)<(x613)); + x643 = (x640)+(x642); + x644 = (x643)+(x578); + x645 = (uintptr_t)((x644)<(x578)); + x646 = (x644)+(x618); + x647 = (uintptr_t)((x646)<(x618)); + x648 = (x645)+(x647); + x649 = (x648)+(x583); + x650 = (uintptr_t)((x649)<(x583)); + x651 = (x649)+(x623); + x652 = (uintptr_t)((x651)<(x623)); + x653 = (x650)+(x652); + x654 = (x653)+(x588); + x655 = (uintptr_t)((x654)<(x588)); + x656 = (x654)+(x628); + x657 = (uintptr_t)((x656)<(x628)); + x658 = (x655)+(x657); + x659 = (x658)+(x593); + x660 = (uintptr_t)((x659)<(x593)); + x661 = (x659)+(x631); + x662 = (uintptr_t)((x661)<(x631)); + x663 = (x660)+(x662); + x664 = (x663)+(x595); + x665 = (x16)*(x11); + x666 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x11))>>32 : ((__uint128_t)(x16)*(x11))>>64); + x667 = (x16)*(x10); + x668 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x10))>>32 : ((__uint128_t)(x16)*(x10))>>64); + x669 = (x16)*(x9); + x670 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x9))>>32 : ((__uint128_t)(x16)*(x9))>>64); + x671 = (x16)*(x8); + x672 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x8))>>32 : ((__uint128_t)(x16)*(x8))>>64); + x673 = (x16)*(x7); + x674 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x7))>>32 : ((__uint128_t)(x16)*(x7))>>64); + x675 = (x16)*(x6); + x676 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x6))>>32 : ((__uint128_t)(x16)*(x6))>>64); + x677 = (x676)+(x673); + x678 = (uintptr_t)((x677)<(x676)); + x679 = (x678)+(x674); + x680 = (uintptr_t)((x679)<(x674)); + x681 = (x679)+(x671); + x682 = (uintptr_t)((x681)<(x671)); + x683 = (x680)+(x682); + x684 = (x683)+(x672); + x685 = (uintptr_t)((x684)<(x672)); + x686 = (x684)+(x669); + x687 = (uintptr_t)((x686)<(x669)); + x688 = (x685)+(x687); + x689 = (x688)+(x670); + x690 = (uintptr_t)((x689)<(x670)); + x691 = (x689)+(x667); + x692 = (uintptr_t)((x691)<(x667)); + x693 = (x690)+(x692); + x694 = (x693)+(x668); + x695 = (uintptr_t)((x694)<(x668)); + x696 = (x694)+(x665); + x697 = (uintptr_t)((x696)<(x665)); + x698 = (x695)+(x697); + x699 = (x698)+(x666); + x700 = (x636)+(x675); + x701 = (uintptr_t)((x700)<(x636)); + x702 = (x701)+(x641); + x703 = (uintptr_t)((x702)<(x641)); + x704 = (x702)+(x677); + x705 = (uintptr_t)((x704)<(x677)); + x706 = (x703)+(x705); + x707 = (x706)+(x646); + x708 = (uintptr_t)((x707)<(x646)); + x709 = (x707)+(x681); + x710 = (uintptr_t)((x709)<(x681)); + x711 = (x708)+(x710); + x712 = (x711)+(x651); + x713 = (uintptr_t)((x712)<(x651)); + x714 = (x712)+(x686); + x715 = (uintptr_t)((x714)<(x686)); + x716 = (x713)+(x715); + x717 = (x716)+(x656); + x718 = (uintptr_t)((x717)<(x656)); + x719 = (x717)+(x691); + x720 = (uintptr_t)((x719)<(x691)); + x721 = (x718)+(x720); + x722 = (x721)+(x661); + x723 = (uintptr_t)((x722)<(x661)); + x724 = (x722)+(x696); + x725 = (uintptr_t)((x724)<(x696)); + x726 = (x723)+(x725); + x727 = (x726)+(x664); + x728 = (uintptr_t)((x727)<(x664)); + x729 = (x727)+(x699); + x730 = (uintptr_t)((x729)<(x699)); + x731 = (x728)+(x730); + x732 = (x700)*((uintptr_t)7986114184663260229ULL); + x733 = (x732)*((uintptr_t)18446744073709551615ULL); + x734 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x732)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x732)*((uintptr_t)18446744073709551615ULL))>>64); + x735 = (x732)*((uintptr_t)18446744073709551615ULL); + x736 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x732)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x732)*((uintptr_t)18446744073709551615ULL))>>64); + x737 = (x732)*((uintptr_t)18446744073709551615ULL); + x738 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x732)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x732)*((uintptr_t)18446744073709551615ULL))>>64); + x739 = (x732)*((uintptr_t)14367412456785391071ULL); + x740 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x732)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x732)*((uintptr_t)14367412456785391071ULL))>>64); + x741 = (x732)*((uintptr_t)6348401684107011962ULL); + x742 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x732)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x732)*((uintptr_t)6348401684107011962ULL))>>64); + x743 = (x732)*((uintptr_t)17072048233947408755ULL); + x744 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x732)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x732)*((uintptr_t)17072048233947408755ULL))>>64); + x745 = (x744)+(x741); + x746 = (uintptr_t)((x745)<(x744)); + x747 = (x746)+(x742); + x748 = (uintptr_t)((x747)<(x742)); + x749 = (x747)+(x739); + x750 = (uintptr_t)((x749)<(x739)); + x751 = (x748)+(x750); + x752 = (x751)+(x740); + x753 = (uintptr_t)((x752)<(x740)); + x754 = (x752)+(x737); + x755 = (uintptr_t)((x754)<(x737)); + x756 = (x753)+(x755); + x757 = (x756)+(x738); + x758 = (uintptr_t)((x757)<(x738)); + x759 = (x757)+(x735); + x760 = (uintptr_t)((x759)<(x735)); + x761 = (x758)+(x760); + x762 = (x761)+(x736); + x763 = (uintptr_t)((x762)<(x736)); + x764 = (x762)+(x733); + x765 = (uintptr_t)((x764)<(x733)); + x766 = (x763)+(x765); + x767 = (x766)+(x734); + x768 = (x700)+(x743); + x769 = (uintptr_t)((x768)<(x700)); + x770 = (x769)+(x704); + x771 = (uintptr_t)((x770)<(x704)); + x772 = (x770)+(x745); + x773 = (uintptr_t)((x772)<(x745)); + x774 = (x771)+(x773); + x775 = (x774)+(x709); + x776 = (uintptr_t)((x775)<(x709)); + x777 = (x775)+(x749); + x778 = (uintptr_t)((x777)<(x749)); + x779 = (x776)+(x778); + x780 = (x779)+(x714); + x781 = (uintptr_t)((x780)<(x714)); + x782 = (x780)+(x754); + x783 = (uintptr_t)((x782)<(x754)); + x784 = (x781)+(x783); + x785 = (x784)+(x719); + x786 = (uintptr_t)((x785)<(x719)); + x787 = (x785)+(x759); + x788 = (uintptr_t)((x787)<(x759)); + x789 = (x786)+(x788); + x790 = (x789)+(x724); + x791 = (uintptr_t)((x790)<(x724)); + x792 = (x790)+(x764); + x793 = (uintptr_t)((x792)<(x764)); + x794 = (x791)+(x793); + x795 = (x794)+(x729); + x796 = (uintptr_t)((x795)<(x729)); + x797 = (x795)+(x767); + x798 = (uintptr_t)((x797)<(x767)); + x799 = (x796)+(x798); + x800 = (x799)+(x731); + x801 = (x772)-((uintptr_t)17072048233947408755ULL); + x802 = (uintptr_t)((x772)<(x801)); + x803 = (x777)-((uintptr_t)6348401684107011962ULL); + x804 = (uintptr_t)((x777)<(x803)); + x805 = (x803)-(x802); + x806 = (uintptr_t)((x803)<(x805)); + x807 = (x804)+(x806); + x808 = (x782)-((uintptr_t)14367412456785391071ULL); + x809 = (uintptr_t)((x782)<(x808)); + x810 = (x808)-(x807); + x811 = (uintptr_t)((x808)<(x810)); + x812 = (x809)+(x811); + x813 = (x787)-((uintptr_t)18446744073709551615ULL); + x814 = (uintptr_t)((x787)<(x813)); + x815 = (x813)-(x812); + x816 = (uintptr_t)((x813)<(x815)); + x817 = (x814)+(x816); + x818 = (x792)-((uintptr_t)18446744073709551615ULL); + x819 = (uintptr_t)((x792)<(x818)); + x820 = (x818)-(x817); + x821 = (uintptr_t)((x818)<(x820)); + x822 = (x819)+(x821); + x823 = (x797)-((uintptr_t)18446744073709551615ULL); + x824 = (uintptr_t)((x797)<(x823)); + x825 = (x823)-(x822); + x826 = (uintptr_t)((x823)<(x825)); + x827 = (x824)+(x826); + x828 = (x800)-(x827); + x829 = (uintptr_t)((x800)<(x828)); + x830 = ((uintptr_t)-1ULL)+((uintptr_t)((x829)==((uintptr_t)0ULL))); + x831 = (x830)^((uintptr_t)18446744073709551615ULL); + x832 = ((x772)&(x830))|((x801)&(x831)); + x833 = ((uintptr_t)-1ULL)+((uintptr_t)((x829)==((uintptr_t)0ULL))); + x834 = (x833)^((uintptr_t)18446744073709551615ULL); + x835 = ((x777)&(x833))|((x805)&(x834)); + x836 = ((uintptr_t)-1ULL)+((uintptr_t)((x829)==((uintptr_t)0ULL))); + x837 = (x836)^((uintptr_t)18446744073709551615ULL); + x838 = ((x782)&(x836))|((x810)&(x837)); + x839 = ((uintptr_t)-1ULL)+((uintptr_t)((x829)==((uintptr_t)0ULL))); + x840 = (x839)^((uintptr_t)18446744073709551615ULL); + x841 = ((x787)&(x839))|((x815)&(x840)); + x842 = ((uintptr_t)-1ULL)+((uintptr_t)((x829)==((uintptr_t)0ULL))); + x843 = (x842)^((uintptr_t)18446744073709551615ULL); + x844 = ((x792)&(x842))|((x820)&(x843)); + x845 = ((uintptr_t)-1ULL)+((uintptr_t)((x829)==((uintptr_t)0ULL))); + x846 = (x845)^((uintptr_t)18446744073709551615ULL); + x847 = ((x797)&(x845))|((x825)&(x846)); + x848 = x832; + x849 = x835; + x850 = x838; + x851 = x841; + x852 = x844; + x853 = x847; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x848, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x849, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x850, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x851, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x852, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x853, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_mul(uint64_t out1[6], const uint64_t arg1[6], const uint64_t arg2[6]) { + internal_fiat_p384_scalar_mul((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p384_scalar_square(uintptr_t out0, uintptr_t in0) { + uintptr_t x11, x20, x23, x25, x21, x26, x18, x27, x29, x30, x19, x31, x16, x32, x34, x35, x17, x36, x14, x37, x39, x40, x15, x41, x12, x42, x44, x45, x13, x47, x56, x59, x61, x57, x62, x54, x63, x65, x66, x55, x67, x52, x68, x70, x71, x53, x72, x50, x73, x75, x76, x51, x77, x48, x78, x80, x81, x49, x58, x83, x22, x84, x24, x85, x60, x86, x88, x89, x28, x90, x64, x91, x93, x94, x33, x95, x69, x96, x98, x99, x38, x100, x74, x101, x103, x104, x43, x105, x79, x106, x108, x109, x46, x110, x82, x111, x113, x6, x123, x126, x128, x124, x129, x121, x130, x132, x133, x122, x134, x119, x135, x137, x138, x120, x139, x117, x140, x142, x143, x118, x144, x115, x145, x147, x148, x116, x125, x87, x151, x92, x152, x127, x153, x155, x156, x97, x157, x131, x158, x160, x161, x102, x162, x136, x163, x165, x166, x107, x167, x141, x168, x170, x171, x112, x172, x146, x173, x175, x176, x114, x177, x149, x178, x180, x182, x191, x194, x196, x192, x197, x189, x198, x200, x201, x190, x202, x187, x203, x205, x206, x188, x207, x185, x208, x210, x211, x186, x212, x183, x213, x215, x216, x184, x193, x218, x150, x219, x154, x220, x195, x221, x223, x224, x159, x225, x199, x226, x228, x229, x164, x230, x204, x231, x233, x234, x169, x235, x209, x236, x238, x239, x174, x240, x214, x241, x243, x244, x179, x245, x217, x246, x248, x249, x181, x7, x259, x262, x264, x260, x265, x257, x266, x268, x269, x258, x270, x255, x271, x273, x274, x256, x275, x253, x276, x278, x279, x254, x280, x251, x281, x283, x284, x252, x261, x222, x287, x227, x288, x263, x289, x291, x292, x232, x293, x267, x294, x296, x297, x237, x298, x272, x299, x301, x302, x242, x303, x277, x304, x306, x307, x247, x308, x282, x309, x311, x312, x250, x313, x285, x314, x316, x318, x327, x330, x332, x328, x333, x325, x334, x336, x337, x326, x338, x323, x339, x341, x342, x324, x343, x321, x344, x346, x347, x322, x348, x319, x349, x351, x352, x320, x329, x354, x286, x355, x290, x356, x331, x357, x359, x360, x295, x361, x335, x362, x364, x365, x300, x366, x340, x367, x369, x370, x305, x371, x345, x372, x374, x375, x310, x376, x350, x377, x379, x380, x315, x381, x353, x382, x384, x385, x317, x8, x395, x398, x400, x396, x401, x393, x402, x404, x405, x394, x406, x391, x407, x409, x410, x392, x411, x389, x412, x414, x415, x390, x416, x387, x417, x419, x420, x388, x397, x358, x423, x363, x424, x399, x425, x427, x428, x368, x429, x403, x430, x432, x433, x373, x434, x408, x435, x437, x438, x378, x439, x413, x440, x442, x443, x383, x444, x418, x445, x447, x448, x386, x449, x421, x450, x452, x454, x463, x466, x468, x464, x469, x461, x470, x472, x473, x462, x474, x459, x475, x477, x478, x460, x479, x457, x480, x482, x483, x458, x484, x455, x485, x487, x488, x456, x465, x490, x422, x491, x426, x492, x467, x493, x495, x496, x431, x497, x471, x498, x500, x501, x436, x502, x476, x503, x505, x506, x441, x507, x481, x508, x510, x511, x446, x512, x486, x513, x515, x516, x451, x517, x489, x518, x520, x521, x453, x9, x531, x534, x536, x532, x537, x529, x538, x540, x541, x530, x542, x527, x543, x545, x546, x528, x547, x525, x548, x550, x551, x526, x552, x523, x553, x555, x556, x524, x533, x494, x559, x499, x560, x535, x561, x563, x564, x504, x565, x539, x566, x568, x569, x509, x570, x544, x571, x573, x574, x514, x575, x549, x576, x578, x579, x519, x580, x554, x581, x583, x584, x522, x585, x557, x586, x588, x590, x599, x602, x604, x600, x605, x597, x606, x608, x609, x598, x610, x595, x611, x613, x614, x596, x615, x593, x616, x618, x619, x594, x620, x591, x621, x623, x624, x592, x601, x626, x558, x627, x562, x628, x603, x629, x631, x632, x567, x633, x607, x634, x636, x637, x572, x638, x612, x639, x641, x642, x577, x643, x617, x644, x646, x647, x582, x648, x622, x649, x651, x652, x587, x653, x625, x654, x656, x657, x589, x5, x4, x3, x2, x1, x10, x0, x667, x670, x672, x668, x673, x665, x674, x676, x677, x666, x678, x663, x679, x681, x682, x664, x683, x661, x684, x686, x687, x662, x688, x659, x689, x691, x692, x660, x669, x630, x695, x635, x696, x671, x697, x699, x700, x640, x701, x675, x702, x704, x705, x645, x706, x680, x707, x709, x710, x650, x711, x685, x712, x714, x715, x655, x716, x690, x717, x719, x720, x658, x721, x693, x722, x724, x726, x735, x738, x740, x736, x741, x733, x742, x744, x745, x734, x746, x731, x747, x749, x750, x732, x751, x729, x752, x754, x755, x730, x756, x727, x757, x759, x760, x728, x737, x762, x694, x763, x698, x764, x739, x765, x767, x768, x703, x769, x743, x770, x772, x773, x708, x774, x748, x775, x777, x778, x713, x779, x753, x780, x782, x783, x718, x784, x758, x785, x787, x788, x723, x789, x761, x790, x792, x793, x725, x796, x797, x798, x800, x801, x802, x803, x805, x806, x807, x808, x810, x811, x812, x813, x815, x816, x817, x818, x820, x821, x794, x822, x766, x824, x795, x825, x771, x827, x799, x828, x776, x830, x804, x831, x781, x833, x809, x834, x786, x836, x814, x837, x823, x791, x839, x819, x840, x826, x829, x832, x835, x838, x841, x842, x843, x844, x845, x846, x847; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x6 = x1; + x7 = x2; + x8 = x3; + x9 = x4; + x10 = x5; + x11 = x0; + x12 = (x11)*(x5); + x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x5))>>32 : ((__uint128_t)(x11)*(x5))>>64); + x14 = (x11)*(x4); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x4))>>32 : ((__uint128_t)(x11)*(x4))>>64); + x16 = (x11)*(x3); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x3))>>32 : ((__uint128_t)(x11)*(x3))>>64); + x18 = (x11)*(x2); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x2))>>32 : ((__uint128_t)(x11)*(x2))>>64); + x20 = (x11)*(x1); + x21 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x1))>>32 : ((__uint128_t)(x11)*(x1))>>64); + x22 = (x11)*(x0); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x0))>>32 : ((__uint128_t)(x11)*(x0))>>64); + x24 = (x23)+(x20); + x25 = (uintptr_t)((x24)<(x23)); + x26 = (x25)+(x21); + x27 = (uintptr_t)((x26)<(x21)); + x28 = (x26)+(x18); + x29 = (uintptr_t)((x28)<(x18)); + x30 = (x27)+(x29); + x31 = (x30)+(x19); + x32 = (uintptr_t)((x31)<(x19)); + x33 = (x31)+(x16); + x34 = (uintptr_t)((x33)<(x16)); + x35 = (x32)+(x34); + x36 = (x35)+(x17); + x37 = (uintptr_t)((x36)<(x17)); + x38 = (x36)+(x14); + x39 = (uintptr_t)((x38)<(x14)); + x40 = (x37)+(x39); + x41 = (x40)+(x15); + x42 = (uintptr_t)((x41)<(x15)); + x43 = (x41)+(x12); + x44 = (uintptr_t)((x43)<(x12)); + x45 = (x42)+(x44); + x46 = (x45)+(x13); + x47 = (x22)*((uintptr_t)7986114184663260229ULL); + x48 = (x47)*((uintptr_t)18446744073709551615ULL); + x49 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x47)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x47)*((uintptr_t)18446744073709551615ULL))>>64); + x50 = (x47)*((uintptr_t)18446744073709551615ULL); + x51 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x47)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x47)*((uintptr_t)18446744073709551615ULL))>>64); + x52 = (x47)*((uintptr_t)18446744073709551615ULL); + x53 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x47)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x47)*((uintptr_t)18446744073709551615ULL))>>64); + x54 = (x47)*((uintptr_t)14367412456785391071ULL); + x55 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x47)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x47)*((uintptr_t)14367412456785391071ULL))>>64); + x56 = (x47)*((uintptr_t)6348401684107011962ULL); + x57 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x47)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x47)*((uintptr_t)6348401684107011962ULL))>>64); + x58 = (x47)*((uintptr_t)17072048233947408755ULL); + x59 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x47)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x47)*((uintptr_t)17072048233947408755ULL))>>64); + x60 = (x59)+(x56); + x61 = (uintptr_t)((x60)<(x59)); + x62 = (x61)+(x57); + x63 = (uintptr_t)((x62)<(x57)); + x64 = (x62)+(x54); + x65 = (uintptr_t)((x64)<(x54)); + x66 = (x63)+(x65); + x67 = (x66)+(x55); + x68 = (uintptr_t)((x67)<(x55)); + x69 = (x67)+(x52); + x70 = (uintptr_t)((x69)<(x52)); + x71 = (x68)+(x70); + x72 = (x71)+(x53); + x73 = (uintptr_t)((x72)<(x53)); + x74 = (x72)+(x50); + x75 = (uintptr_t)((x74)<(x50)); + x76 = (x73)+(x75); + x77 = (x76)+(x51); + x78 = (uintptr_t)((x77)<(x51)); + x79 = (x77)+(x48); + x80 = (uintptr_t)((x79)<(x48)); + x81 = (x78)+(x80); + x82 = (x81)+(x49); + x83 = (x22)+(x58); + x84 = (uintptr_t)((x83)<(x22)); + x85 = (x84)+(x24); + x86 = (uintptr_t)((x85)<(x24)); + x87 = (x85)+(x60); + x88 = (uintptr_t)((x87)<(x60)); + x89 = (x86)+(x88); + x90 = (x89)+(x28); + x91 = (uintptr_t)((x90)<(x28)); + x92 = (x90)+(x64); + x93 = (uintptr_t)((x92)<(x64)); + x94 = (x91)+(x93); + x95 = (x94)+(x33); + x96 = (uintptr_t)((x95)<(x33)); + x97 = (x95)+(x69); + x98 = (uintptr_t)((x97)<(x69)); + x99 = (x96)+(x98); + x100 = (x99)+(x38); + x101 = (uintptr_t)((x100)<(x38)); + x102 = (x100)+(x74); + x103 = (uintptr_t)((x102)<(x74)); + x104 = (x101)+(x103); + x105 = (x104)+(x43); + x106 = (uintptr_t)((x105)<(x43)); + x107 = (x105)+(x79); + x108 = (uintptr_t)((x107)<(x79)); + x109 = (x106)+(x108); + x110 = (x109)+(x46); + x111 = (uintptr_t)((x110)<(x46)); + x112 = (x110)+(x82); + x113 = (uintptr_t)((x112)<(x82)); + x114 = (x111)+(x113); + x115 = (x6)*(x5); + x116 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x5))>>32 : ((__uint128_t)(x6)*(x5))>>64); + x117 = (x6)*(x4); + x118 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x4))>>32 : ((__uint128_t)(x6)*(x4))>>64); + x119 = (x6)*(x3); + x120 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x3))>>32 : ((__uint128_t)(x6)*(x3))>>64); + x121 = (x6)*(x2); + x122 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x2))>>32 : ((__uint128_t)(x6)*(x2))>>64); + x123 = (x6)*(x1); + x124 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x1))>>32 : ((__uint128_t)(x6)*(x1))>>64); + x125 = (x6)*(x0); + x126 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x0))>>32 : ((__uint128_t)(x6)*(x0))>>64); + x127 = (x126)+(x123); + x128 = (uintptr_t)((x127)<(x126)); + x129 = (x128)+(x124); + x130 = (uintptr_t)((x129)<(x124)); + x131 = (x129)+(x121); + x132 = (uintptr_t)((x131)<(x121)); + x133 = (x130)+(x132); + x134 = (x133)+(x122); + x135 = (uintptr_t)((x134)<(x122)); + x136 = (x134)+(x119); + x137 = (uintptr_t)((x136)<(x119)); + x138 = (x135)+(x137); + x139 = (x138)+(x120); + x140 = (uintptr_t)((x139)<(x120)); + x141 = (x139)+(x117); + x142 = (uintptr_t)((x141)<(x117)); + x143 = (x140)+(x142); + x144 = (x143)+(x118); + x145 = (uintptr_t)((x144)<(x118)); + x146 = (x144)+(x115); + x147 = (uintptr_t)((x146)<(x115)); + x148 = (x145)+(x147); + x149 = (x148)+(x116); + x150 = (x87)+(x125); + x151 = (uintptr_t)((x150)<(x87)); + x152 = (x151)+(x92); + x153 = (uintptr_t)((x152)<(x92)); + x154 = (x152)+(x127); + x155 = (uintptr_t)((x154)<(x127)); + x156 = (x153)+(x155); + x157 = (x156)+(x97); + x158 = (uintptr_t)((x157)<(x97)); + x159 = (x157)+(x131); + x160 = (uintptr_t)((x159)<(x131)); + x161 = (x158)+(x160); + x162 = (x161)+(x102); + x163 = (uintptr_t)((x162)<(x102)); + x164 = (x162)+(x136); + x165 = (uintptr_t)((x164)<(x136)); + x166 = (x163)+(x165); + x167 = (x166)+(x107); + x168 = (uintptr_t)((x167)<(x107)); + x169 = (x167)+(x141); + x170 = (uintptr_t)((x169)<(x141)); + x171 = (x168)+(x170); + x172 = (x171)+(x112); + x173 = (uintptr_t)((x172)<(x112)); + x174 = (x172)+(x146); + x175 = (uintptr_t)((x174)<(x146)); + x176 = (x173)+(x175); + x177 = (x176)+(x114); + x178 = (uintptr_t)((x177)<(x114)); + x179 = (x177)+(x149); + x180 = (uintptr_t)((x179)<(x149)); + x181 = (x178)+(x180); + x182 = (x150)*((uintptr_t)7986114184663260229ULL); + x183 = (x182)*((uintptr_t)18446744073709551615ULL); + x184 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x182)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x182)*((uintptr_t)18446744073709551615ULL))>>64); + x185 = (x182)*((uintptr_t)18446744073709551615ULL); + x186 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x182)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x182)*((uintptr_t)18446744073709551615ULL))>>64); + x187 = (x182)*((uintptr_t)18446744073709551615ULL); + x188 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x182)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x182)*((uintptr_t)18446744073709551615ULL))>>64); + x189 = (x182)*((uintptr_t)14367412456785391071ULL); + x190 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x182)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x182)*((uintptr_t)14367412456785391071ULL))>>64); + x191 = (x182)*((uintptr_t)6348401684107011962ULL); + x192 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x182)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x182)*((uintptr_t)6348401684107011962ULL))>>64); + x193 = (x182)*((uintptr_t)17072048233947408755ULL); + x194 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x182)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x182)*((uintptr_t)17072048233947408755ULL))>>64); + x195 = (x194)+(x191); + x196 = (uintptr_t)((x195)<(x194)); + x197 = (x196)+(x192); + x198 = (uintptr_t)((x197)<(x192)); + x199 = (x197)+(x189); + x200 = (uintptr_t)((x199)<(x189)); + x201 = (x198)+(x200); + x202 = (x201)+(x190); + x203 = (uintptr_t)((x202)<(x190)); + x204 = (x202)+(x187); + x205 = (uintptr_t)((x204)<(x187)); + x206 = (x203)+(x205); + x207 = (x206)+(x188); + x208 = (uintptr_t)((x207)<(x188)); + x209 = (x207)+(x185); + x210 = (uintptr_t)((x209)<(x185)); + x211 = (x208)+(x210); + x212 = (x211)+(x186); + x213 = (uintptr_t)((x212)<(x186)); + x214 = (x212)+(x183); + x215 = (uintptr_t)((x214)<(x183)); + x216 = (x213)+(x215); + x217 = (x216)+(x184); + x218 = (x150)+(x193); + x219 = (uintptr_t)((x218)<(x150)); + x220 = (x219)+(x154); + x221 = (uintptr_t)((x220)<(x154)); + x222 = (x220)+(x195); + x223 = (uintptr_t)((x222)<(x195)); + x224 = (x221)+(x223); + x225 = (x224)+(x159); + x226 = (uintptr_t)((x225)<(x159)); + x227 = (x225)+(x199); + x228 = (uintptr_t)((x227)<(x199)); + x229 = (x226)+(x228); + x230 = (x229)+(x164); + x231 = (uintptr_t)((x230)<(x164)); + x232 = (x230)+(x204); + x233 = (uintptr_t)((x232)<(x204)); + x234 = (x231)+(x233); + x235 = (x234)+(x169); + x236 = (uintptr_t)((x235)<(x169)); + x237 = (x235)+(x209); + x238 = (uintptr_t)((x237)<(x209)); + x239 = (x236)+(x238); + x240 = (x239)+(x174); + x241 = (uintptr_t)((x240)<(x174)); + x242 = (x240)+(x214); + x243 = (uintptr_t)((x242)<(x214)); + x244 = (x241)+(x243); + x245 = (x244)+(x179); + x246 = (uintptr_t)((x245)<(x179)); + x247 = (x245)+(x217); + x248 = (uintptr_t)((x247)<(x217)); + x249 = (x246)+(x248); + x250 = (x249)+(x181); + x251 = (x7)*(x5); + x252 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x5))>>32 : ((__uint128_t)(x7)*(x5))>>64); + x253 = (x7)*(x4); + x254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x4))>>32 : ((__uint128_t)(x7)*(x4))>>64); + x255 = (x7)*(x3); + x256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x3))>>32 : ((__uint128_t)(x7)*(x3))>>64); + x257 = (x7)*(x2); + x258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x2))>>32 : ((__uint128_t)(x7)*(x2))>>64); + x259 = (x7)*(x1); + x260 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x1))>>32 : ((__uint128_t)(x7)*(x1))>>64); + x261 = (x7)*(x0); + x262 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x0))>>32 : ((__uint128_t)(x7)*(x0))>>64); + x263 = (x262)+(x259); + x264 = (uintptr_t)((x263)<(x262)); + x265 = (x264)+(x260); + x266 = (uintptr_t)((x265)<(x260)); + x267 = (x265)+(x257); + x268 = (uintptr_t)((x267)<(x257)); + x269 = (x266)+(x268); + x270 = (x269)+(x258); + x271 = (uintptr_t)((x270)<(x258)); + x272 = (x270)+(x255); + x273 = (uintptr_t)((x272)<(x255)); + x274 = (x271)+(x273); + x275 = (x274)+(x256); + x276 = (uintptr_t)((x275)<(x256)); + x277 = (x275)+(x253); + x278 = (uintptr_t)((x277)<(x253)); + x279 = (x276)+(x278); + x280 = (x279)+(x254); + x281 = (uintptr_t)((x280)<(x254)); + x282 = (x280)+(x251); + x283 = (uintptr_t)((x282)<(x251)); + x284 = (x281)+(x283); + x285 = (x284)+(x252); + x286 = (x222)+(x261); + x287 = (uintptr_t)((x286)<(x222)); + x288 = (x287)+(x227); + x289 = (uintptr_t)((x288)<(x227)); + x290 = (x288)+(x263); + x291 = (uintptr_t)((x290)<(x263)); + x292 = (x289)+(x291); + x293 = (x292)+(x232); + x294 = (uintptr_t)((x293)<(x232)); + x295 = (x293)+(x267); + x296 = (uintptr_t)((x295)<(x267)); + x297 = (x294)+(x296); + x298 = (x297)+(x237); + x299 = (uintptr_t)((x298)<(x237)); + x300 = (x298)+(x272); + x301 = (uintptr_t)((x300)<(x272)); + x302 = (x299)+(x301); + x303 = (x302)+(x242); + x304 = (uintptr_t)((x303)<(x242)); + x305 = (x303)+(x277); + x306 = (uintptr_t)((x305)<(x277)); + x307 = (x304)+(x306); + x308 = (x307)+(x247); + x309 = (uintptr_t)((x308)<(x247)); + x310 = (x308)+(x282); + x311 = (uintptr_t)((x310)<(x282)); + x312 = (x309)+(x311); + x313 = (x312)+(x250); + x314 = (uintptr_t)((x313)<(x250)); + x315 = (x313)+(x285); + x316 = (uintptr_t)((x315)<(x285)); + x317 = (x314)+(x316); + x318 = (x286)*((uintptr_t)7986114184663260229ULL); + x319 = (x318)*((uintptr_t)18446744073709551615ULL); + x320 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x318)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x318)*((uintptr_t)18446744073709551615ULL))>>64); + x321 = (x318)*((uintptr_t)18446744073709551615ULL); + x322 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x318)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x318)*((uintptr_t)18446744073709551615ULL))>>64); + x323 = (x318)*((uintptr_t)18446744073709551615ULL); + x324 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x318)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x318)*((uintptr_t)18446744073709551615ULL))>>64); + x325 = (x318)*((uintptr_t)14367412456785391071ULL); + x326 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x318)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x318)*((uintptr_t)14367412456785391071ULL))>>64); + x327 = (x318)*((uintptr_t)6348401684107011962ULL); + x328 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x318)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x318)*((uintptr_t)6348401684107011962ULL))>>64); + x329 = (x318)*((uintptr_t)17072048233947408755ULL); + x330 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x318)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x318)*((uintptr_t)17072048233947408755ULL))>>64); + x331 = (x330)+(x327); + x332 = (uintptr_t)((x331)<(x330)); + x333 = (x332)+(x328); + x334 = (uintptr_t)((x333)<(x328)); + x335 = (x333)+(x325); + x336 = (uintptr_t)((x335)<(x325)); + x337 = (x334)+(x336); + x338 = (x337)+(x326); + x339 = (uintptr_t)((x338)<(x326)); + x340 = (x338)+(x323); + x341 = (uintptr_t)((x340)<(x323)); + x342 = (x339)+(x341); + x343 = (x342)+(x324); + x344 = (uintptr_t)((x343)<(x324)); + x345 = (x343)+(x321); + x346 = (uintptr_t)((x345)<(x321)); + x347 = (x344)+(x346); + x348 = (x347)+(x322); + x349 = (uintptr_t)((x348)<(x322)); + x350 = (x348)+(x319); + x351 = (uintptr_t)((x350)<(x319)); + x352 = (x349)+(x351); + x353 = (x352)+(x320); + x354 = (x286)+(x329); + x355 = (uintptr_t)((x354)<(x286)); + x356 = (x355)+(x290); + x357 = (uintptr_t)((x356)<(x290)); + x358 = (x356)+(x331); + x359 = (uintptr_t)((x358)<(x331)); + x360 = (x357)+(x359); + x361 = (x360)+(x295); + x362 = (uintptr_t)((x361)<(x295)); + x363 = (x361)+(x335); + x364 = (uintptr_t)((x363)<(x335)); + x365 = (x362)+(x364); + x366 = (x365)+(x300); + x367 = (uintptr_t)((x366)<(x300)); + x368 = (x366)+(x340); + x369 = (uintptr_t)((x368)<(x340)); + x370 = (x367)+(x369); + x371 = (x370)+(x305); + x372 = (uintptr_t)((x371)<(x305)); + x373 = (x371)+(x345); + x374 = (uintptr_t)((x373)<(x345)); + x375 = (x372)+(x374); + x376 = (x375)+(x310); + x377 = (uintptr_t)((x376)<(x310)); + x378 = (x376)+(x350); + x379 = (uintptr_t)((x378)<(x350)); + x380 = (x377)+(x379); + x381 = (x380)+(x315); + x382 = (uintptr_t)((x381)<(x315)); + x383 = (x381)+(x353); + x384 = (uintptr_t)((x383)<(x353)); + x385 = (x382)+(x384); + x386 = (x385)+(x317); + x387 = (x8)*(x5); + x388 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x5))>>32 : ((__uint128_t)(x8)*(x5))>>64); + x389 = (x8)*(x4); + x390 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x4))>>32 : ((__uint128_t)(x8)*(x4))>>64); + x391 = (x8)*(x3); + x392 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x3))>>32 : ((__uint128_t)(x8)*(x3))>>64); + x393 = (x8)*(x2); + x394 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x2))>>32 : ((__uint128_t)(x8)*(x2))>>64); + x395 = (x8)*(x1); + x396 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x1))>>32 : ((__uint128_t)(x8)*(x1))>>64); + x397 = (x8)*(x0); + x398 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x0))>>32 : ((__uint128_t)(x8)*(x0))>>64); + x399 = (x398)+(x395); + x400 = (uintptr_t)((x399)<(x398)); + x401 = (x400)+(x396); + x402 = (uintptr_t)((x401)<(x396)); + x403 = (x401)+(x393); + x404 = (uintptr_t)((x403)<(x393)); + x405 = (x402)+(x404); + x406 = (x405)+(x394); + x407 = (uintptr_t)((x406)<(x394)); + x408 = (x406)+(x391); + x409 = (uintptr_t)((x408)<(x391)); + x410 = (x407)+(x409); + x411 = (x410)+(x392); + x412 = (uintptr_t)((x411)<(x392)); + x413 = (x411)+(x389); + x414 = (uintptr_t)((x413)<(x389)); + x415 = (x412)+(x414); + x416 = (x415)+(x390); + x417 = (uintptr_t)((x416)<(x390)); + x418 = (x416)+(x387); + x419 = (uintptr_t)((x418)<(x387)); + x420 = (x417)+(x419); + x421 = (x420)+(x388); + x422 = (x358)+(x397); + x423 = (uintptr_t)((x422)<(x358)); + x424 = (x423)+(x363); + x425 = (uintptr_t)((x424)<(x363)); + x426 = (x424)+(x399); + x427 = (uintptr_t)((x426)<(x399)); + x428 = (x425)+(x427); + x429 = (x428)+(x368); + x430 = (uintptr_t)((x429)<(x368)); + x431 = (x429)+(x403); + x432 = (uintptr_t)((x431)<(x403)); + x433 = (x430)+(x432); + x434 = (x433)+(x373); + x435 = (uintptr_t)((x434)<(x373)); + x436 = (x434)+(x408); + x437 = (uintptr_t)((x436)<(x408)); + x438 = (x435)+(x437); + x439 = (x438)+(x378); + x440 = (uintptr_t)((x439)<(x378)); + x441 = (x439)+(x413); + x442 = (uintptr_t)((x441)<(x413)); + x443 = (x440)+(x442); + x444 = (x443)+(x383); + x445 = (uintptr_t)((x444)<(x383)); + x446 = (x444)+(x418); + x447 = (uintptr_t)((x446)<(x418)); + x448 = (x445)+(x447); + x449 = (x448)+(x386); + x450 = (uintptr_t)((x449)<(x386)); + x451 = (x449)+(x421); + x452 = (uintptr_t)((x451)<(x421)); + x453 = (x450)+(x452); + x454 = (x422)*((uintptr_t)7986114184663260229ULL); + x455 = (x454)*((uintptr_t)18446744073709551615ULL); + x456 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x454)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x454)*((uintptr_t)18446744073709551615ULL))>>64); + x457 = (x454)*((uintptr_t)18446744073709551615ULL); + x458 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x454)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x454)*((uintptr_t)18446744073709551615ULL))>>64); + x459 = (x454)*((uintptr_t)18446744073709551615ULL); + x460 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x454)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x454)*((uintptr_t)18446744073709551615ULL))>>64); + x461 = (x454)*((uintptr_t)14367412456785391071ULL); + x462 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x454)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x454)*((uintptr_t)14367412456785391071ULL))>>64); + x463 = (x454)*((uintptr_t)6348401684107011962ULL); + x464 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x454)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x454)*((uintptr_t)6348401684107011962ULL))>>64); + x465 = (x454)*((uintptr_t)17072048233947408755ULL); + x466 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x454)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x454)*((uintptr_t)17072048233947408755ULL))>>64); + x467 = (x466)+(x463); + x468 = (uintptr_t)((x467)<(x466)); + x469 = (x468)+(x464); + x470 = (uintptr_t)((x469)<(x464)); + x471 = (x469)+(x461); + x472 = (uintptr_t)((x471)<(x461)); + x473 = (x470)+(x472); + x474 = (x473)+(x462); + x475 = (uintptr_t)((x474)<(x462)); + x476 = (x474)+(x459); + x477 = (uintptr_t)((x476)<(x459)); + x478 = (x475)+(x477); + x479 = (x478)+(x460); + x480 = (uintptr_t)((x479)<(x460)); + x481 = (x479)+(x457); + x482 = (uintptr_t)((x481)<(x457)); + x483 = (x480)+(x482); + x484 = (x483)+(x458); + x485 = (uintptr_t)((x484)<(x458)); + x486 = (x484)+(x455); + x487 = (uintptr_t)((x486)<(x455)); + x488 = (x485)+(x487); + x489 = (x488)+(x456); + x490 = (x422)+(x465); + x491 = (uintptr_t)((x490)<(x422)); + x492 = (x491)+(x426); + x493 = (uintptr_t)((x492)<(x426)); + x494 = (x492)+(x467); + x495 = (uintptr_t)((x494)<(x467)); + x496 = (x493)+(x495); + x497 = (x496)+(x431); + x498 = (uintptr_t)((x497)<(x431)); + x499 = (x497)+(x471); + x500 = (uintptr_t)((x499)<(x471)); + x501 = (x498)+(x500); + x502 = (x501)+(x436); + x503 = (uintptr_t)((x502)<(x436)); + x504 = (x502)+(x476); + x505 = (uintptr_t)((x504)<(x476)); + x506 = (x503)+(x505); + x507 = (x506)+(x441); + x508 = (uintptr_t)((x507)<(x441)); + x509 = (x507)+(x481); + x510 = (uintptr_t)((x509)<(x481)); + x511 = (x508)+(x510); + x512 = (x511)+(x446); + x513 = (uintptr_t)((x512)<(x446)); + x514 = (x512)+(x486); + x515 = (uintptr_t)((x514)<(x486)); + x516 = (x513)+(x515); + x517 = (x516)+(x451); + x518 = (uintptr_t)((x517)<(x451)); + x519 = (x517)+(x489); + x520 = (uintptr_t)((x519)<(x489)); + x521 = (x518)+(x520); + x522 = (x521)+(x453); + x523 = (x9)*(x5); + x524 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x5))>>32 : ((__uint128_t)(x9)*(x5))>>64); + x525 = (x9)*(x4); + x526 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x4))>>32 : ((__uint128_t)(x9)*(x4))>>64); + x527 = (x9)*(x3); + x528 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x3))>>32 : ((__uint128_t)(x9)*(x3))>>64); + x529 = (x9)*(x2); + x530 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x2))>>32 : ((__uint128_t)(x9)*(x2))>>64); + x531 = (x9)*(x1); + x532 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x1))>>32 : ((__uint128_t)(x9)*(x1))>>64); + x533 = (x9)*(x0); + x534 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x0))>>32 : ((__uint128_t)(x9)*(x0))>>64); + x535 = (x534)+(x531); + x536 = (uintptr_t)((x535)<(x534)); + x537 = (x536)+(x532); + x538 = (uintptr_t)((x537)<(x532)); + x539 = (x537)+(x529); + x540 = (uintptr_t)((x539)<(x529)); + x541 = (x538)+(x540); + x542 = (x541)+(x530); + x543 = (uintptr_t)((x542)<(x530)); + x544 = (x542)+(x527); + x545 = (uintptr_t)((x544)<(x527)); + x546 = (x543)+(x545); + x547 = (x546)+(x528); + x548 = (uintptr_t)((x547)<(x528)); + x549 = (x547)+(x525); + x550 = (uintptr_t)((x549)<(x525)); + x551 = (x548)+(x550); + x552 = (x551)+(x526); + x553 = (uintptr_t)((x552)<(x526)); + x554 = (x552)+(x523); + x555 = (uintptr_t)((x554)<(x523)); + x556 = (x553)+(x555); + x557 = (x556)+(x524); + x558 = (x494)+(x533); + x559 = (uintptr_t)((x558)<(x494)); + x560 = (x559)+(x499); + x561 = (uintptr_t)((x560)<(x499)); + x562 = (x560)+(x535); + x563 = (uintptr_t)((x562)<(x535)); + x564 = (x561)+(x563); + x565 = (x564)+(x504); + x566 = (uintptr_t)((x565)<(x504)); + x567 = (x565)+(x539); + x568 = (uintptr_t)((x567)<(x539)); + x569 = (x566)+(x568); + x570 = (x569)+(x509); + x571 = (uintptr_t)((x570)<(x509)); + x572 = (x570)+(x544); + x573 = (uintptr_t)((x572)<(x544)); + x574 = (x571)+(x573); + x575 = (x574)+(x514); + x576 = (uintptr_t)((x575)<(x514)); + x577 = (x575)+(x549); + x578 = (uintptr_t)((x577)<(x549)); + x579 = (x576)+(x578); + x580 = (x579)+(x519); + x581 = (uintptr_t)((x580)<(x519)); + x582 = (x580)+(x554); + x583 = (uintptr_t)((x582)<(x554)); + x584 = (x581)+(x583); + x585 = (x584)+(x522); + x586 = (uintptr_t)((x585)<(x522)); + x587 = (x585)+(x557); + x588 = (uintptr_t)((x587)<(x557)); + x589 = (x586)+(x588); + x590 = (x558)*((uintptr_t)7986114184663260229ULL); + x591 = (x590)*((uintptr_t)18446744073709551615ULL); + x592 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x590)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x590)*((uintptr_t)18446744073709551615ULL))>>64); + x593 = (x590)*((uintptr_t)18446744073709551615ULL); + x594 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x590)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x590)*((uintptr_t)18446744073709551615ULL))>>64); + x595 = (x590)*((uintptr_t)18446744073709551615ULL); + x596 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x590)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x590)*((uintptr_t)18446744073709551615ULL))>>64); + x597 = (x590)*((uintptr_t)14367412456785391071ULL); + x598 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x590)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x590)*((uintptr_t)14367412456785391071ULL))>>64); + x599 = (x590)*((uintptr_t)6348401684107011962ULL); + x600 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x590)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x590)*((uintptr_t)6348401684107011962ULL))>>64); + x601 = (x590)*((uintptr_t)17072048233947408755ULL); + x602 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x590)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x590)*((uintptr_t)17072048233947408755ULL))>>64); + x603 = (x602)+(x599); + x604 = (uintptr_t)((x603)<(x602)); + x605 = (x604)+(x600); + x606 = (uintptr_t)((x605)<(x600)); + x607 = (x605)+(x597); + x608 = (uintptr_t)((x607)<(x597)); + x609 = (x606)+(x608); + x610 = (x609)+(x598); + x611 = (uintptr_t)((x610)<(x598)); + x612 = (x610)+(x595); + x613 = (uintptr_t)((x612)<(x595)); + x614 = (x611)+(x613); + x615 = (x614)+(x596); + x616 = (uintptr_t)((x615)<(x596)); + x617 = (x615)+(x593); + x618 = (uintptr_t)((x617)<(x593)); + x619 = (x616)+(x618); + x620 = (x619)+(x594); + x621 = (uintptr_t)((x620)<(x594)); + x622 = (x620)+(x591); + x623 = (uintptr_t)((x622)<(x591)); + x624 = (x621)+(x623); + x625 = (x624)+(x592); + x626 = (x558)+(x601); + x627 = (uintptr_t)((x626)<(x558)); + x628 = (x627)+(x562); + x629 = (uintptr_t)((x628)<(x562)); + x630 = (x628)+(x603); + x631 = (uintptr_t)((x630)<(x603)); + x632 = (x629)+(x631); + x633 = (x632)+(x567); + x634 = (uintptr_t)((x633)<(x567)); + x635 = (x633)+(x607); + x636 = (uintptr_t)((x635)<(x607)); + x637 = (x634)+(x636); + x638 = (x637)+(x572); + x639 = (uintptr_t)((x638)<(x572)); + x640 = (x638)+(x612); + x641 = (uintptr_t)((x640)<(x612)); + x642 = (x639)+(x641); + x643 = (x642)+(x577); + x644 = (uintptr_t)((x643)<(x577)); + x645 = (x643)+(x617); + x646 = (uintptr_t)((x645)<(x617)); + x647 = (x644)+(x646); + x648 = (x647)+(x582); + x649 = (uintptr_t)((x648)<(x582)); + x650 = (x648)+(x622); + x651 = (uintptr_t)((x650)<(x622)); + x652 = (x649)+(x651); + x653 = (x652)+(x587); + x654 = (uintptr_t)((x653)<(x587)); + x655 = (x653)+(x625); + x656 = (uintptr_t)((x655)<(x625)); + x657 = (x654)+(x656); + x658 = (x657)+(x589); + x659 = (x10)*(x5); + x660 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x5))>>32 : ((__uint128_t)(x10)*(x5))>>64); + x661 = (x10)*(x4); + x662 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x4))>>32 : ((__uint128_t)(x10)*(x4))>>64); + x663 = (x10)*(x3); + x664 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x3))>>32 : ((__uint128_t)(x10)*(x3))>>64); + x665 = (x10)*(x2); + x666 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x2))>>32 : ((__uint128_t)(x10)*(x2))>>64); + x667 = (x10)*(x1); + x668 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x1))>>32 : ((__uint128_t)(x10)*(x1))>>64); + x669 = (x10)*(x0); + x670 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x0))>>32 : ((__uint128_t)(x10)*(x0))>>64); + x671 = (x670)+(x667); + x672 = (uintptr_t)((x671)<(x670)); + x673 = (x672)+(x668); + x674 = (uintptr_t)((x673)<(x668)); + x675 = (x673)+(x665); + x676 = (uintptr_t)((x675)<(x665)); + x677 = (x674)+(x676); + x678 = (x677)+(x666); + x679 = (uintptr_t)((x678)<(x666)); + x680 = (x678)+(x663); + x681 = (uintptr_t)((x680)<(x663)); + x682 = (x679)+(x681); + x683 = (x682)+(x664); + x684 = (uintptr_t)((x683)<(x664)); + x685 = (x683)+(x661); + x686 = (uintptr_t)((x685)<(x661)); + x687 = (x684)+(x686); + x688 = (x687)+(x662); + x689 = (uintptr_t)((x688)<(x662)); + x690 = (x688)+(x659); + x691 = (uintptr_t)((x690)<(x659)); + x692 = (x689)+(x691); + x693 = (x692)+(x660); + x694 = (x630)+(x669); + x695 = (uintptr_t)((x694)<(x630)); + x696 = (x695)+(x635); + x697 = (uintptr_t)((x696)<(x635)); + x698 = (x696)+(x671); + x699 = (uintptr_t)((x698)<(x671)); + x700 = (x697)+(x699); + x701 = (x700)+(x640); + x702 = (uintptr_t)((x701)<(x640)); + x703 = (x701)+(x675); + x704 = (uintptr_t)((x703)<(x675)); + x705 = (x702)+(x704); + x706 = (x705)+(x645); + x707 = (uintptr_t)((x706)<(x645)); + x708 = (x706)+(x680); + x709 = (uintptr_t)((x708)<(x680)); + x710 = (x707)+(x709); + x711 = (x710)+(x650); + x712 = (uintptr_t)((x711)<(x650)); + x713 = (x711)+(x685); + x714 = (uintptr_t)((x713)<(x685)); + x715 = (x712)+(x714); + x716 = (x715)+(x655); + x717 = (uintptr_t)((x716)<(x655)); + x718 = (x716)+(x690); + x719 = (uintptr_t)((x718)<(x690)); + x720 = (x717)+(x719); + x721 = (x720)+(x658); + x722 = (uintptr_t)((x721)<(x658)); + x723 = (x721)+(x693); + x724 = (uintptr_t)((x723)<(x693)); + x725 = (x722)+(x724); + x726 = (x694)*((uintptr_t)7986114184663260229ULL); + x727 = (x726)*((uintptr_t)18446744073709551615ULL); + x728 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x726)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x726)*((uintptr_t)18446744073709551615ULL))>>64); + x729 = (x726)*((uintptr_t)18446744073709551615ULL); + x730 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x726)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x726)*((uintptr_t)18446744073709551615ULL))>>64); + x731 = (x726)*((uintptr_t)18446744073709551615ULL); + x732 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x726)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x726)*((uintptr_t)18446744073709551615ULL))>>64); + x733 = (x726)*((uintptr_t)14367412456785391071ULL); + x734 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x726)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x726)*((uintptr_t)14367412456785391071ULL))>>64); + x735 = (x726)*((uintptr_t)6348401684107011962ULL); + x736 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x726)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x726)*((uintptr_t)6348401684107011962ULL))>>64); + x737 = (x726)*((uintptr_t)17072048233947408755ULL); + x738 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x726)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x726)*((uintptr_t)17072048233947408755ULL))>>64); + x739 = (x738)+(x735); + x740 = (uintptr_t)((x739)<(x738)); + x741 = (x740)+(x736); + x742 = (uintptr_t)((x741)<(x736)); + x743 = (x741)+(x733); + x744 = (uintptr_t)((x743)<(x733)); + x745 = (x742)+(x744); + x746 = (x745)+(x734); + x747 = (uintptr_t)((x746)<(x734)); + x748 = (x746)+(x731); + x749 = (uintptr_t)((x748)<(x731)); + x750 = (x747)+(x749); + x751 = (x750)+(x732); + x752 = (uintptr_t)((x751)<(x732)); + x753 = (x751)+(x729); + x754 = (uintptr_t)((x753)<(x729)); + x755 = (x752)+(x754); + x756 = (x755)+(x730); + x757 = (uintptr_t)((x756)<(x730)); + x758 = (x756)+(x727); + x759 = (uintptr_t)((x758)<(x727)); + x760 = (x757)+(x759); + x761 = (x760)+(x728); + x762 = (x694)+(x737); + x763 = (uintptr_t)((x762)<(x694)); + x764 = (x763)+(x698); + x765 = (uintptr_t)((x764)<(x698)); + x766 = (x764)+(x739); + x767 = (uintptr_t)((x766)<(x739)); + x768 = (x765)+(x767); + x769 = (x768)+(x703); + x770 = (uintptr_t)((x769)<(x703)); + x771 = (x769)+(x743); + x772 = (uintptr_t)((x771)<(x743)); + x773 = (x770)+(x772); + x774 = (x773)+(x708); + x775 = (uintptr_t)((x774)<(x708)); + x776 = (x774)+(x748); + x777 = (uintptr_t)((x776)<(x748)); + x778 = (x775)+(x777); + x779 = (x778)+(x713); + x780 = (uintptr_t)((x779)<(x713)); + x781 = (x779)+(x753); + x782 = (uintptr_t)((x781)<(x753)); + x783 = (x780)+(x782); + x784 = (x783)+(x718); + x785 = (uintptr_t)((x784)<(x718)); + x786 = (x784)+(x758); + x787 = (uintptr_t)((x786)<(x758)); + x788 = (x785)+(x787); + x789 = (x788)+(x723); + x790 = (uintptr_t)((x789)<(x723)); + x791 = (x789)+(x761); + x792 = (uintptr_t)((x791)<(x761)); + x793 = (x790)+(x792); + x794 = (x793)+(x725); + x795 = (x766)-((uintptr_t)17072048233947408755ULL); + x796 = (uintptr_t)((x766)<(x795)); + x797 = (x771)-((uintptr_t)6348401684107011962ULL); + x798 = (uintptr_t)((x771)<(x797)); + x799 = (x797)-(x796); + x800 = (uintptr_t)((x797)<(x799)); + x801 = (x798)+(x800); + x802 = (x776)-((uintptr_t)14367412456785391071ULL); + x803 = (uintptr_t)((x776)<(x802)); + x804 = (x802)-(x801); + x805 = (uintptr_t)((x802)<(x804)); + x806 = (x803)+(x805); + x807 = (x781)-((uintptr_t)18446744073709551615ULL); + x808 = (uintptr_t)((x781)<(x807)); + x809 = (x807)-(x806); + x810 = (uintptr_t)((x807)<(x809)); + x811 = (x808)+(x810); + x812 = (x786)-((uintptr_t)18446744073709551615ULL); + x813 = (uintptr_t)((x786)<(x812)); + x814 = (x812)-(x811); + x815 = (uintptr_t)((x812)<(x814)); + x816 = (x813)+(x815); + x817 = (x791)-((uintptr_t)18446744073709551615ULL); + x818 = (uintptr_t)((x791)<(x817)); + x819 = (x817)-(x816); + x820 = (uintptr_t)((x817)<(x819)); + x821 = (x818)+(x820); + x822 = (x794)-(x821); + x823 = (uintptr_t)((x794)<(x822)); + x824 = ((uintptr_t)-1ULL)+((uintptr_t)((x823)==((uintptr_t)0ULL))); + x825 = (x824)^((uintptr_t)18446744073709551615ULL); + x826 = ((x766)&(x824))|((x795)&(x825)); + x827 = ((uintptr_t)-1ULL)+((uintptr_t)((x823)==((uintptr_t)0ULL))); + x828 = (x827)^((uintptr_t)18446744073709551615ULL); + x829 = ((x771)&(x827))|((x799)&(x828)); + x830 = ((uintptr_t)-1ULL)+((uintptr_t)((x823)==((uintptr_t)0ULL))); + x831 = (x830)^((uintptr_t)18446744073709551615ULL); + x832 = ((x776)&(x830))|((x804)&(x831)); + x833 = ((uintptr_t)-1ULL)+((uintptr_t)((x823)==((uintptr_t)0ULL))); + x834 = (x833)^((uintptr_t)18446744073709551615ULL); + x835 = ((x781)&(x833))|((x809)&(x834)); + x836 = ((uintptr_t)-1ULL)+((uintptr_t)((x823)==((uintptr_t)0ULL))); + x837 = (x836)^((uintptr_t)18446744073709551615ULL); + x838 = ((x786)&(x836))|((x814)&(x837)); + x839 = ((uintptr_t)-1ULL)+((uintptr_t)((x823)==((uintptr_t)0ULL))); + x840 = (x839)^((uintptr_t)18446744073709551615ULL); + x841 = ((x791)&(x839))|((x819)&(x840)); + x842 = x826; + x843 = x829; + x844 = x832; + x845 = x835; + x846 = x838; + x847 = x841; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x842, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x843, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x844, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x845, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x846, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x847, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_square(uint64_t out1[6], const uint64_t arg1[6]) { + internal_fiat_p384_scalar_square((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p384_scalar_add(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x6, x0, x13, x1, x7, x15, x2, x8, x17, x3, x9, x19, x4, x10, x21, x5, x11, x25, x27, x29, x31, x23, x33, x12, x36, x24, x37, x14, x39, x26, x40, x16, x42, x28, x43, x18, x45, x30, x46, x20, x48, x32, x49, x35, x22, x51, x34, x52, x38, x41, x44, x47, x50, x53, x54, x55, x56, x57, x58, x59; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + x6 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x8 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x12 = (x0)+(x6); + x13 = ((uintptr_t)((x12)<(x0)))+(x1); + x14 = (x13)+(x7); + x15 = (((uintptr_t)((x13)<(x1)))+((uintptr_t)((x14)<(x7))))+(x2); + x16 = (x15)+(x8); + x17 = (((uintptr_t)((x15)<(x2)))+((uintptr_t)((x16)<(x8))))+(x3); + x18 = (x17)+(x9); + x19 = (((uintptr_t)((x17)<(x3)))+((uintptr_t)((x18)<(x9))))+(x4); + x20 = (x19)+(x10); + x21 = (((uintptr_t)((x19)<(x4)))+((uintptr_t)((x20)<(x10))))+(x5); + x22 = (x21)+(x11); + x23 = ((uintptr_t)((x21)<(x5)))+((uintptr_t)((x22)<(x11))); + x24 = (x12)-((uintptr_t)17072048233947408755ULL); + x25 = (x14)-((uintptr_t)6348401684107011962ULL); + x26 = (x25)-((uintptr_t)((x12)<(x24))); + x27 = (x16)-((uintptr_t)14367412456785391071ULL); + x28 = (x27)-(((uintptr_t)((x14)<(x25)))+((uintptr_t)((x25)<(x26)))); + x29 = (x18)-((uintptr_t)18446744073709551615ULL); + x30 = (x29)-(((uintptr_t)((x16)<(x27)))+((uintptr_t)((x27)<(x28)))); + x31 = (x20)-((uintptr_t)18446744073709551615ULL); + x32 = (x31)-(((uintptr_t)((x18)<(x29)))+((uintptr_t)((x29)<(x30)))); + x33 = (x22)-((uintptr_t)18446744073709551615ULL); + x34 = (x33)-(((uintptr_t)((x20)<(x31)))+((uintptr_t)((x31)<(x32)))); + x35 = (uintptr_t)((x23)<((x23)-(((uintptr_t)((x22)<(x33)))+((uintptr_t)((x33)<(x34)))))); + x36 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x37 = (x36)^((uintptr_t)18446744073709551615ULL); + x38 = ((x12)&(x36))|((x24)&(x37)); + x39 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x40 = (x39)^((uintptr_t)18446744073709551615ULL); + x41 = ((x14)&(x39))|((x26)&(x40)); + x42 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x43 = (x42)^((uintptr_t)18446744073709551615ULL); + x44 = ((x16)&(x42))|((x28)&(x43)); + x45 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x46 = (x45)^((uintptr_t)18446744073709551615ULL); + x47 = ((x18)&(x45))|((x30)&(x46)); + x48 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x49 = (x48)^((uintptr_t)18446744073709551615ULL); + x50 = ((x20)&(x48))|((x32)&(x49)); + x51 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x52 = (x51)^((uintptr_t)18446744073709551615ULL); + x53 = ((x22)&(x51))|((x34)&(x52)); + x54 = x38; + x55 = x41; + x56 = x44; + x57 = x47; + x58 = x50; + x59 = x53; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x54, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x55, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x56, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x57, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x58, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x59, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_add(uint64_t out1[6], const uint64_t arg1[6], const uint64_t arg2[6]) { + internal_fiat_p384_scalar_add((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p384_scalar_sub(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x6, x7, x0, x8, x1, x13, x9, x2, x15, x10, x3, x17, x11, x4, x19, x5, x21, x12, x25, x14, x27, x16, x29, x18, x31, x20, x22, x23, x24, x26, x28, x30, x32, x33, x34, x35, x36, x37, x38, x39; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + x6 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x8 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x12 = (x0)-(x6); + x13 = (x1)-(x7); + x14 = (x13)-((uintptr_t)((x0)<(x12))); + x15 = (x2)-(x8); + x16 = (x15)-(((uintptr_t)((x1)<(x13)))+((uintptr_t)((x13)<(x14)))); + x17 = (x3)-(x9); + x18 = (x17)-(((uintptr_t)((x2)<(x15)))+((uintptr_t)((x15)<(x16)))); + x19 = (x4)-(x10); + x20 = (x19)-(((uintptr_t)((x3)<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = (x5)-(x11); + x22 = (x21)-(((uintptr_t)((x4)<(x19)))+((uintptr_t)((x19)<(x20)))); + x23 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)((x5)<(x21)))+((uintptr_t)((x21)<(x22))))==((uintptr_t)0ULL))); + x24 = (x12)+((x23)&((uintptr_t)17072048233947408755ULL)); + x25 = ((uintptr_t)((x24)<(x12)))+(x14); + x26 = (x25)+((x23)&((uintptr_t)6348401684107011962ULL)); + x27 = (((uintptr_t)((x25)<(x14)))+((uintptr_t)((x26)<((x23)&((uintptr_t)6348401684107011962ULL)))))+(x16); + x28 = (x27)+((x23)&((uintptr_t)14367412456785391071ULL)); + x29 = (((uintptr_t)((x27)<(x16)))+((uintptr_t)((x28)<((x23)&((uintptr_t)14367412456785391071ULL)))))+(x18); + x30 = (x29)+(x23); + x31 = (((uintptr_t)((x29)<(x18)))+((uintptr_t)((x30)<(x23))))+(x20); + x32 = (x31)+(x23); + x33 = ((((uintptr_t)((x31)<(x20)))+((uintptr_t)((x32)<(x23))))+(x22))+(x23); + x34 = x24; + x35 = x26; + x36 = x28; + x37 = x30; + x38 = x32; + x39 = x33; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x34, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x35, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x36, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x37, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x38, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x39, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_sub(uint64_t out1[6], const uint64_t arg1[6], const uint64_t arg2[6]) { + internal_fiat_p384_scalar_sub((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p384_scalar_opp(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x1, x2, x7, x3, x9, x4, x11, x5, x13, x15, x6, x19, x8, x21, x10, x23, x12, x25, x14, x16, x17, x18, x20, x22, x24, x26, x27, x28, x29, x30, x31, x32, x33; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x6 = ((uintptr_t)0ULL)-(x0); + x7 = ((uintptr_t)0ULL)-(x1); + x8 = (x7)-((uintptr_t)(((uintptr_t)0ULL)<(x6))); + x9 = ((uintptr_t)0ULL)-(x2); + x10 = (x9)-(((uintptr_t)(((uintptr_t)0ULL)<(x7)))+((uintptr_t)((x7)<(x8)))); + x11 = ((uintptr_t)0ULL)-(x3); + x12 = (x11)-(((uintptr_t)(((uintptr_t)0ULL)<(x9)))+((uintptr_t)((x9)<(x10)))); + x13 = ((uintptr_t)0ULL)-(x4); + x14 = (x13)-(((uintptr_t)(((uintptr_t)0ULL)<(x11)))+((uintptr_t)((x11)<(x12)))); + x15 = ((uintptr_t)0ULL)-(x5); + x16 = (x15)-(((uintptr_t)(((uintptr_t)0ULL)<(x13)))+((uintptr_t)((x13)<(x14)))); + x17 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)(((uintptr_t)0ULL)<(x15)))+((uintptr_t)((x15)<(x16))))==((uintptr_t)0ULL))); + x18 = (x6)+((x17)&((uintptr_t)17072048233947408755ULL)); + x19 = ((uintptr_t)((x18)<(x6)))+(x8); + x20 = (x19)+((x17)&((uintptr_t)6348401684107011962ULL)); + x21 = (((uintptr_t)((x19)<(x8)))+((uintptr_t)((x20)<((x17)&((uintptr_t)6348401684107011962ULL)))))+(x10); + x22 = (x21)+((x17)&((uintptr_t)14367412456785391071ULL)); + x23 = (((uintptr_t)((x21)<(x10)))+((uintptr_t)((x22)<((x17)&((uintptr_t)14367412456785391071ULL)))))+(x12); + x24 = (x23)+(x17); + x25 = (((uintptr_t)((x23)<(x12)))+((uintptr_t)((x24)<(x17))))+(x14); + x26 = (x25)+(x17); + x27 = ((((uintptr_t)((x25)<(x14)))+((uintptr_t)((x26)<(x17))))+(x16))+(x17); + x28 = x18; + x29 = x20; + x30 = x22; + x31 = x24; + x32 = x26; + x33 = x27; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x28, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x29, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x30, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x31, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x32, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x33, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_opp(uint64_t out1[6], const uint64_t arg1[6]) { + internal_fiat_p384_scalar_opp((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p384_scalar_from_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x17, x19, x16, x14, x21, x15, x12, x23, x13, x10, x25, x11, x8, x7, x6, x18, x20, x22, x24, x26, x27, x9, x1, x28, x29, x30, x31, x32, x33, x52, x54, x51, x49, x56, x50, x47, x58, x48, x45, x60, x46, x43, x42, x35, x63, x36, x53, x65, x37, x55, x67, x38, x57, x69, x39, x59, x71, x40, x61, x73, x41, x34, x62, x44, x2, x64, x66, x68, x70, x72, x74, x93, x95, x92, x90, x97, x91, x88, x99, x89, x86, x101, x87, x84, x83, x76, x104, x77, x94, x106, x78, x96, x108, x79, x98, x110, x80, x100, x112, x81, x102, x114, x82, x75, x103, x85, x3, x105, x107, x109, x111, x113, x115, x134, x136, x133, x131, x138, x132, x129, x140, x130, x127, x142, x128, x125, x124, x117, x145, x118, x135, x147, x119, x137, x149, x120, x139, x151, x121, x141, x153, x122, x143, x155, x123, x116, x144, x126, x4, x146, x148, x150, x152, x154, x156, x175, x177, x174, x172, x179, x173, x170, x181, x171, x168, x183, x169, x166, x165, x158, x186, x159, x176, x188, x160, x178, x190, x161, x180, x192, x162, x182, x194, x163, x184, x196, x164, x157, x185, x167, x5, x187, x189, x191, x193, x195, x197, x216, x218, x215, x213, x220, x214, x211, x222, x212, x209, x224, x210, x207, x206, x199, x227, x200, x217, x229, x201, x219, x231, x202, x221, x233, x203, x223, x235, x204, x225, x237, x205, x198, x226, x208, x241, x243, x245, x247, x239, x249, x228, x252, x240, x253, x230, x255, x242, x256, x232, x258, x244, x259, x234, x261, x246, x262, x236, x264, x248, x265, x251, x238, x267, x250, x268, x254, x257, x260, x263, x266, x269, x270, x271, x272, x273, x274, x275; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x6 = x0; + x7 = (x6)*((uintptr_t)7986114184663260229ULL); + x8 = (x7)*((uintptr_t)18446744073709551615ULL); + x9 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)18446744073709551615ULL))>>64); + x10 = (x7)*((uintptr_t)18446744073709551615ULL); + x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)18446744073709551615ULL))>>64); + x12 = (x7)*((uintptr_t)18446744073709551615ULL); + x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)18446744073709551615ULL))>>64); + x14 = (x7)*((uintptr_t)14367412456785391071ULL); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)14367412456785391071ULL))>>64); + x16 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)6348401684107011962ULL))>>64); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)17072048233947408755ULL))>>64); + x18 = (x17)+((x7)*((uintptr_t)6348401684107011962ULL)); + x19 = ((uintptr_t)((x18)<(x17)))+(x16); + x20 = (x19)+(x14); + x21 = (((uintptr_t)((x19)<(x16)))+((uintptr_t)((x20)<(x14))))+(x15); + x22 = (x21)+(x12); + x23 = (((uintptr_t)((x21)<(x15)))+((uintptr_t)((x22)<(x12))))+(x13); + x24 = (x23)+(x10); + x25 = (((uintptr_t)((x23)<(x13)))+((uintptr_t)((x24)<(x10))))+(x11); + x26 = (x25)+(x8); + x27 = ((uintptr_t)((x25)<(x11)))+((uintptr_t)((x26)<(x8))); + x28 = ((uintptr_t)(((x6)+((x7)*((uintptr_t)17072048233947408755ULL)))<(x6)))+(x18); + x29 = ((uintptr_t)((x28)<(x18)))+(x20); + x30 = ((uintptr_t)((x29)<(x20)))+(x22); + x31 = ((uintptr_t)((x30)<(x22)))+(x24); + x32 = ((uintptr_t)((x31)<(x24)))+(x26); + x33 = ((uintptr_t)((x32)<(x26)))+((x27)+(x9)); + x34 = (uintptr_t)((x33)<((x27)+(x9))); + x35 = (x28)+(x1); + x36 = ((uintptr_t)((x35)<(x28)))+(x29); + x37 = ((uintptr_t)((x36)<(x29)))+(x30); + x38 = ((uintptr_t)((x37)<(x30)))+(x31); + x39 = ((uintptr_t)((x38)<(x31)))+(x32); + x40 = ((uintptr_t)((x39)<(x32)))+(x33); + x41 = (uintptr_t)((x40)<(x33)); + x42 = (x35)*((uintptr_t)7986114184663260229ULL); + x43 = (x42)*((uintptr_t)18446744073709551615ULL); + x44 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x42)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x42)*((uintptr_t)18446744073709551615ULL))>>64); + x45 = (x42)*((uintptr_t)18446744073709551615ULL); + x46 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x42)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x42)*((uintptr_t)18446744073709551615ULL))>>64); + x47 = (x42)*((uintptr_t)18446744073709551615ULL); + x48 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x42)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x42)*((uintptr_t)18446744073709551615ULL))>>64); + x49 = (x42)*((uintptr_t)14367412456785391071ULL); + x50 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x42)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x42)*((uintptr_t)14367412456785391071ULL))>>64); + x51 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x42)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x42)*((uintptr_t)6348401684107011962ULL))>>64); + x52 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x42)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x42)*((uintptr_t)17072048233947408755ULL))>>64); + x53 = (x52)+((x42)*((uintptr_t)6348401684107011962ULL)); + x54 = ((uintptr_t)((x53)<(x52)))+(x51); + x55 = (x54)+(x49); + x56 = (((uintptr_t)((x54)<(x51)))+((uintptr_t)((x55)<(x49))))+(x50); + x57 = (x56)+(x47); + x58 = (((uintptr_t)((x56)<(x50)))+((uintptr_t)((x57)<(x47))))+(x48); + x59 = (x58)+(x45); + x60 = (((uintptr_t)((x58)<(x48)))+((uintptr_t)((x59)<(x45))))+(x46); + x61 = (x60)+(x43); + x62 = ((uintptr_t)((x60)<(x46)))+((uintptr_t)((x61)<(x43))); + x63 = ((uintptr_t)(((x35)+((x42)*((uintptr_t)17072048233947408755ULL)))<(x35)))+(x36); + x64 = (x63)+(x53); + x65 = (((uintptr_t)((x63)<(x36)))+((uintptr_t)((x64)<(x53))))+(x37); + x66 = (x65)+(x55); + x67 = (((uintptr_t)((x65)<(x37)))+((uintptr_t)((x66)<(x55))))+(x38); + x68 = (x67)+(x57); + x69 = (((uintptr_t)((x67)<(x38)))+((uintptr_t)((x68)<(x57))))+(x39); + x70 = (x69)+(x59); + x71 = (((uintptr_t)((x69)<(x39)))+((uintptr_t)((x70)<(x59))))+(x40); + x72 = (x71)+(x61); + x73 = (((uintptr_t)((x71)<(x40)))+((uintptr_t)((x72)<(x61))))+((x41)+(x34)); + x74 = (x73)+((x62)+(x44)); + x75 = ((uintptr_t)((x73)<((x41)+(x34))))+((uintptr_t)((x74)<((x62)+(x44)))); + x76 = (x64)+(x2); + x77 = ((uintptr_t)((x76)<(x64)))+(x66); + x78 = ((uintptr_t)((x77)<(x66)))+(x68); + x79 = ((uintptr_t)((x78)<(x68)))+(x70); + x80 = ((uintptr_t)((x79)<(x70)))+(x72); + x81 = ((uintptr_t)((x80)<(x72)))+(x74); + x82 = (uintptr_t)((x81)<(x74)); + x83 = (x76)*((uintptr_t)7986114184663260229ULL); + x84 = (x83)*((uintptr_t)18446744073709551615ULL); + x85 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x83)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x83)*((uintptr_t)18446744073709551615ULL))>>64); + x86 = (x83)*((uintptr_t)18446744073709551615ULL); + x87 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x83)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x83)*((uintptr_t)18446744073709551615ULL))>>64); + x88 = (x83)*((uintptr_t)18446744073709551615ULL); + x89 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x83)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x83)*((uintptr_t)18446744073709551615ULL))>>64); + x90 = (x83)*((uintptr_t)14367412456785391071ULL); + x91 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x83)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x83)*((uintptr_t)14367412456785391071ULL))>>64); + x92 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x83)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x83)*((uintptr_t)6348401684107011962ULL))>>64); + x93 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x83)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x83)*((uintptr_t)17072048233947408755ULL))>>64); + x94 = (x93)+((x83)*((uintptr_t)6348401684107011962ULL)); + x95 = ((uintptr_t)((x94)<(x93)))+(x92); + x96 = (x95)+(x90); + x97 = (((uintptr_t)((x95)<(x92)))+((uintptr_t)((x96)<(x90))))+(x91); + x98 = (x97)+(x88); + x99 = (((uintptr_t)((x97)<(x91)))+((uintptr_t)((x98)<(x88))))+(x89); + x100 = (x99)+(x86); + x101 = (((uintptr_t)((x99)<(x89)))+((uintptr_t)((x100)<(x86))))+(x87); + x102 = (x101)+(x84); + x103 = ((uintptr_t)((x101)<(x87)))+((uintptr_t)((x102)<(x84))); + x104 = ((uintptr_t)(((x76)+((x83)*((uintptr_t)17072048233947408755ULL)))<(x76)))+(x77); + x105 = (x104)+(x94); + x106 = (((uintptr_t)((x104)<(x77)))+((uintptr_t)((x105)<(x94))))+(x78); + x107 = (x106)+(x96); + x108 = (((uintptr_t)((x106)<(x78)))+((uintptr_t)((x107)<(x96))))+(x79); + x109 = (x108)+(x98); + x110 = (((uintptr_t)((x108)<(x79)))+((uintptr_t)((x109)<(x98))))+(x80); + x111 = (x110)+(x100); + x112 = (((uintptr_t)((x110)<(x80)))+((uintptr_t)((x111)<(x100))))+(x81); + x113 = (x112)+(x102); + x114 = (((uintptr_t)((x112)<(x81)))+((uintptr_t)((x113)<(x102))))+((x82)+(x75)); + x115 = (x114)+((x103)+(x85)); + x116 = ((uintptr_t)((x114)<((x82)+(x75))))+((uintptr_t)((x115)<((x103)+(x85)))); + x117 = (x105)+(x3); + x118 = ((uintptr_t)((x117)<(x105)))+(x107); + x119 = ((uintptr_t)((x118)<(x107)))+(x109); + x120 = ((uintptr_t)((x119)<(x109)))+(x111); + x121 = ((uintptr_t)((x120)<(x111)))+(x113); + x122 = ((uintptr_t)((x121)<(x113)))+(x115); + x123 = (uintptr_t)((x122)<(x115)); + x124 = (x117)*((uintptr_t)7986114184663260229ULL); + x125 = (x124)*((uintptr_t)18446744073709551615ULL); + x126 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x124)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x124)*((uintptr_t)18446744073709551615ULL))>>64); + x127 = (x124)*((uintptr_t)18446744073709551615ULL); + x128 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x124)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x124)*((uintptr_t)18446744073709551615ULL))>>64); + x129 = (x124)*((uintptr_t)18446744073709551615ULL); + x130 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x124)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x124)*((uintptr_t)18446744073709551615ULL))>>64); + x131 = (x124)*((uintptr_t)14367412456785391071ULL); + x132 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x124)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x124)*((uintptr_t)14367412456785391071ULL))>>64); + x133 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x124)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x124)*((uintptr_t)6348401684107011962ULL))>>64); + x134 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x124)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x124)*((uintptr_t)17072048233947408755ULL))>>64); + x135 = (x134)+((x124)*((uintptr_t)6348401684107011962ULL)); + x136 = ((uintptr_t)((x135)<(x134)))+(x133); + x137 = (x136)+(x131); + x138 = (((uintptr_t)((x136)<(x133)))+((uintptr_t)((x137)<(x131))))+(x132); + x139 = (x138)+(x129); + x140 = (((uintptr_t)((x138)<(x132)))+((uintptr_t)((x139)<(x129))))+(x130); + x141 = (x140)+(x127); + x142 = (((uintptr_t)((x140)<(x130)))+((uintptr_t)((x141)<(x127))))+(x128); + x143 = (x142)+(x125); + x144 = ((uintptr_t)((x142)<(x128)))+((uintptr_t)((x143)<(x125))); + x145 = ((uintptr_t)(((x117)+((x124)*((uintptr_t)17072048233947408755ULL)))<(x117)))+(x118); + x146 = (x145)+(x135); + x147 = (((uintptr_t)((x145)<(x118)))+((uintptr_t)((x146)<(x135))))+(x119); + x148 = (x147)+(x137); + x149 = (((uintptr_t)((x147)<(x119)))+((uintptr_t)((x148)<(x137))))+(x120); + x150 = (x149)+(x139); + x151 = (((uintptr_t)((x149)<(x120)))+((uintptr_t)((x150)<(x139))))+(x121); + x152 = (x151)+(x141); + x153 = (((uintptr_t)((x151)<(x121)))+((uintptr_t)((x152)<(x141))))+(x122); + x154 = (x153)+(x143); + x155 = (((uintptr_t)((x153)<(x122)))+((uintptr_t)((x154)<(x143))))+((x123)+(x116)); + x156 = (x155)+((x144)+(x126)); + x157 = ((uintptr_t)((x155)<((x123)+(x116))))+((uintptr_t)((x156)<((x144)+(x126)))); + x158 = (x146)+(x4); + x159 = ((uintptr_t)((x158)<(x146)))+(x148); + x160 = ((uintptr_t)((x159)<(x148)))+(x150); + x161 = ((uintptr_t)((x160)<(x150)))+(x152); + x162 = ((uintptr_t)((x161)<(x152)))+(x154); + x163 = ((uintptr_t)((x162)<(x154)))+(x156); + x164 = (uintptr_t)((x163)<(x156)); + x165 = (x158)*((uintptr_t)7986114184663260229ULL); + x166 = (x165)*((uintptr_t)18446744073709551615ULL); + x167 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)18446744073709551615ULL))>>64); + x168 = (x165)*((uintptr_t)18446744073709551615ULL); + x169 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)18446744073709551615ULL))>>64); + x170 = (x165)*((uintptr_t)18446744073709551615ULL); + x171 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)18446744073709551615ULL))>>64); + x172 = (x165)*((uintptr_t)14367412456785391071ULL); + x173 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)14367412456785391071ULL))>>64); + x174 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)6348401684107011962ULL))>>64); + x175 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)17072048233947408755ULL))>>64); + x176 = (x175)+((x165)*((uintptr_t)6348401684107011962ULL)); + x177 = ((uintptr_t)((x176)<(x175)))+(x174); + x178 = (x177)+(x172); + x179 = (((uintptr_t)((x177)<(x174)))+((uintptr_t)((x178)<(x172))))+(x173); + x180 = (x179)+(x170); + x181 = (((uintptr_t)((x179)<(x173)))+((uintptr_t)((x180)<(x170))))+(x171); + x182 = (x181)+(x168); + x183 = (((uintptr_t)((x181)<(x171)))+((uintptr_t)((x182)<(x168))))+(x169); + x184 = (x183)+(x166); + x185 = ((uintptr_t)((x183)<(x169)))+((uintptr_t)((x184)<(x166))); + x186 = ((uintptr_t)(((x158)+((x165)*((uintptr_t)17072048233947408755ULL)))<(x158)))+(x159); + x187 = (x186)+(x176); + x188 = (((uintptr_t)((x186)<(x159)))+((uintptr_t)((x187)<(x176))))+(x160); + x189 = (x188)+(x178); + x190 = (((uintptr_t)((x188)<(x160)))+((uintptr_t)((x189)<(x178))))+(x161); + x191 = (x190)+(x180); + x192 = (((uintptr_t)((x190)<(x161)))+((uintptr_t)((x191)<(x180))))+(x162); + x193 = (x192)+(x182); + x194 = (((uintptr_t)((x192)<(x162)))+((uintptr_t)((x193)<(x182))))+(x163); + x195 = (x194)+(x184); + x196 = (((uintptr_t)((x194)<(x163)))+((uintptr_t)((x195)<(x184))))+((x164)+(x157)); + x197 = (x196)+((x185)+(x167)); + x198 = ((uintptr_t)((x196)<((x164)+(x157))))+((uintptr_t)((x197)<((x185)+(x167)))); + x199 = (x187)+(x5); + x200 = ((uintptr_t)((x199)<(x187)))+(x189); + x201 = ((uintptr_t)((x200)<(x189)))+(x191); + x202 = ((uintptr_t)((x201)<(x191)))+(x193); + x203 = ((uintptr_t)((x202)<(x193)))+(x195); + x204 = ((uintptr_t)((x203)<(x195)))+(x197); + x205 = (uintptr_t)((x204)<(x197)); + x206 = (x199)*((uintptr_t)7986114184663260229ULL); + x207 = (x206)*((uintptr_t)18446744073709551615ULL); + x208 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744073709551615ULL))>>64); + x209 = (x206)*((uintptr_t)18446744073709551615ULL); + x210 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744073709551615ULL))>>64); + x211 = (x206)*((uintptr_t)18446744073709551615ULL); + x212 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744073709551615ULL))>>64); + x213 = (x206)*((uintptr_t)14367412456785391071ULL); + x214 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)14367412456785391071ULL))>>64); + x215 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)6348401684107011962ULL))>>64); + x216 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)17072048233947408755ULL))>>64); + x217 = (x216)+((x206)*((uintptr_t)6348401684107011962ULL)); + x218 = ((uintptr_t)((x217)<(x216)))+(x215); + x219 = (x218)+(x213); + x220 = (((uintptr_t)((x218)<(x215)))+((uintptr_t)((x219)<(x213))))+(x214); + x221 = (x220)+(x211); + x222 = (((uintptr_t)((x220)<(x214)))+((uintptr_t)((x221)<(x211))))+(x212); + x223 = (x222)+(x209); + x224 = (((uintptr_t)((x222)<(x212)))+((uintptr_t)((x223)<(x209))))+(x210); + x225 = (x224)+(x207); + x226 = ((uintptr_t)((x224)<(x210)))+((uintptr_t)((x225)<(x207))); + x227 = ((uintptr_t)(((x199)+((x206)*((uintptr_t)17072048233947408755ULL)))<(x199)))+(x200); + x228 = (x227)+(x217); + x229 = (((uintptr_t)((x227)<(x200)))+((uintptr_t)((x228)<(x217))))+(x201); + x230 = (x229)+(x219); + x231 = (((uintptr_t)((x229)<(x201)))+((uintptr_t)((x230)<(x219))))+(x202); + x232 = (x231)+(x221); + x233 = (((uintptr_t)((x231)<(x202)))+((uintptr_t)((x232)<(x221))))+(x203); + x234 = (x233)+(x223); + x235 = (((uintptr_t)((x233)<(x203)))+((uintptr_t)((x234)<(x223))))+(x204); + x236 = (x235)+(x225); + x237 = (((uintptr_t)((x235)<(x204)))+((uintptr_t)((x236)<(x225))))+((x205)+(x198)); + x238 = (x237)+((x226)+(x208)); + x239 = ((uintptr_t)((x237)<((x205)+(x198))))+((uintptr_t)((x238)<((x226)+(x208)))); + x240 = (x228)-((uintptr_t)17072048233947408755ULL); + x241 = (x230)-((uintptr_t)6348401684107011962ULL); + x242 = (x241)-((uintptr_t)((x228)<(x240))); + x243 = (x232)-((uintptr_t)14367412456785391071ULL); + x244 = (x243)-(((uintptr_t)((x230)<(x241)))+((uintptr_t)((x241)<(x242)))); + x245 = (x234)-((uintptr_t)18446744073709551615ULL); + x246 = (x245)-(((uintptr_t)((x232)<(x243)))+((uintptr_t)((x243)<(x244)))); + x247 = (x236)-((uintptr_t)18446744073709551615ULL); + x248 = (x247)-(((uintptr_t)((x234)<(x245)))+((uintptr_t)((x245)<(x246)))); + x249 = (x238)-((uintptr_t)18446744073709551615ULL); + x250 = (x249)-(((uintptr_t)((x236)<(x247)))+((uintptr_t)((x247)<(x248)))); + x251 = (uintptr_t)((x239)<((x239)-(((uintptr_t)((x238)<(x249)))+((uintptr_t)((x249)<(x250)))))); + x252 = ((uintptr_t)-1ULL)+((uintptr_t)((x251)==((uintptr_t)0ULL))); + x253 = (x252)^((uintptr_t)18446744073709551615ULL); + x254 = ((x228)&(x252))|((x240)&(x253)); + x255 = ((uintptr_t)-1ULL)+((uintptr_t)((x251)==((uintptr_t)0ULL))); + x256 = (x255)^((uintptr_t)18446744073709551615ULL); + x257 = ((x230)&(x255))|((x242)&(x256)); + x258 = ((uintptr_t)-1ULL)+((uintptr_t)((x251)==((uintptr_t)0ULL))); + x259 = (x258)^((uintptr_t)18446744073709551615ULL); + x260 = ((x232)&(x258))|((x244)&(x259)); + x261 = ((uintptr_t)-1ULL)+((uintptr_t)((x251)==((uintptr_t)0ULL))); + x262 = (x261)^((uintptr_t)18446744073709551615ULL); + x263 = ((x234)&(x261))|((x246)&(x262)); + x264 = ((uintptr_t)-1ULL)+((uintptr_t)((x251)==((uintptr_t)0ULL))); + x265 = (x264)^((uintptr_t)18446744073709551615ULL); + x266 = ((x236)&(x264))|((x248)&(x265)); + x267 = ((uintptr_t)-1ULL)+((uintptr_t)((x251)==((uintptr_t)0ULL))); + x268 = (x267)^((uintptr_t)18446744073709551615ULL); + x269 = ((x238)&(x267))|((x250)&(x268)); + x270 = x254; + x271 = x257; + x272 = x260; + x273 = x263; + x274 = x266; + x275 = x269; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x270, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x271, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x272, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x273, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x274, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x275, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_from_montgomery(uint64_t out1[6], const uint64_t arg1[6]) { + internal_fiat_p384_scalar_from_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p384_scalar_to_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x1, x2, x3, x4, x5, x0, x11, x22, x24, x20, x18, x26, x19, x16, x28, x17, x14, x30, x15, x12, x43, x45, x42, x40, x47, x41, x38, x49, x39, x36, x51, x37, x34, x33, x21, x54, x23, x44, x56, x25, x46, x58, x27, x48, x60, x29, x50, x62, x31, x52, x64, x32, x13, x53, x35, x76, x78, x75, x73, x80, x74, x71, x82, x72, x69, x84, x70, x67, x6, x55, x88, x57, x77, x90, x59, x79, x92, x61, x81, x94, x63, x83, x96, x65, x85, x109, x111, x108, x106, x113, x107, x104, x115, x105, x102, x117, x103, x100, x99, x87, x120, x89, x110, x122, x91, x112, x124, x93, x114, x126, x95, x116, x128, x97, x118, x130, x98, x66, x86, x68, x119, x101, x142, x144, x141, x139, x146, x140, x137, x148, x138, x135, x150, x136, x133, x7, x121, x154, x123, x143, x156, x125, x145, x158, x127, x147, x160, x129, x149, x162, x131, x151, x175, x177, x174, x172, x179, x173, x170, x181, x171, x168, x183, x169, x166, x165, x153, x186, x155, x176, x188, x157, x178, x190, x159, x180, x192, x161, x182, x194, x163, x184, x196, x164, x132, x152, x134, x185, x167, x208, x210, x207, x205, x212, x206, x203, x214, x204, x201, x216, x202, x199, x8, x187, x220, x189, x209, x222, x191, x211, x224, x193, x213, x226, x195, x215, x228, x197, x217, x241, x243, x240, x238, x245, x239, x236, x247, x237, x234, x249, x235, x232, x231, x219, x252, x221, x242, x254, x223, x244, x256, x225, x246, x258, x227, x248, x260, x229, x250, x262, x230, x198, x218, x200, x251, x233, x274, x276, x273, x271, x278, x272, x269, x280, x270, x267, x282, x268, x265, x9, x253, x286, x255, x275, x288, x257, x277, x290, x259, x279, x292, x261, x281, x294, x263, x283, x307, x309, x306, x304, x311, x305, x302, x313, x303, x300, x315, x301, x298, x297, x285, x318, x287, x308, x320, x289, x310, x322, x291, x312, x324, x293, x314, x326, x295, x316, x328, x296, x264, x284, x266, x317, x299, x340, x342, x339, x337, x344, x338, x335, x346, x336, x333, x348, x334, x331, x10, x319, x352, x321, x341, x354, x323, x343, x356, x325, x345, x358, x327, x347, x360, x329, x349, x373, x375, x372, x370, x377, x371, x368, x379, x369, x366, x381, x367, x364, x363, x351, x384, x353, x374, x386, x355, x376, x388, x357, x378, x390, x359, x380, x392, x361, x382, x394, x362, x330, x350, x332, x383, x365, x398, x400, x402, x404, x396, x406, x385, x409, x397, x410, x387, x412, x399, x413, x389, x415, x401, x416, x391, x418, x403, x419, x393, x421, x405, x422, x408, x395, x424, x407, x425, x411, x414, x417, x420, x423, x426, x427, x428, x429, x430, x431, x432; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x6 = x1; + x7 = x2; + x8 = x3; + x9 = x4; + x10 = x5; + x11 = x0; + x12 = (x11)*((uintptr_t)902107514168524577ULL); + x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)902107514168524577ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)902107514168524577ULL))>>64); + x14 = (x11)*((uintptr_t)4589268600508278933ULL); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)4589268600508278933ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)4589268600508278933ULL))>>64); + x16 = (x11)*((uintptr_t)15279949475123764421ULL); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)15279949475123764421ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)15279949475123764421ULL))>>64); + x18 = (x11)*((uintptr_t)13564358545871743303ULL); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)13564358545871743303ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)13564358545871743303ULL))>>64); + x20 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)18391999277541532697ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)18391999277541532697ULL))>>64); + x21 = (x11)*((uintptr_t)3256554584917936553ULL); + x22 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)3256554584917936553ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)3256554584917936553ULL))>>64); + x23 = (x22)+((x11)*((uintptr_t)18391999277541532697ULL)); + x24 = ((uintptr_t)((x23)<(x22)))+(x20); + x25 = (x24)+(x18); + x26 = (((uintptr_t)((x24)<(x20)))+((uintptr_t)((x25)<(x18))))+(x19); + x27 = (x26)+(x16); + x28 = (((uintptr_t)((x26)<(x19)))+((uintptr_t)((x27)<(x16))))+(x17); + x29 = (x28)+(x14); + x30 = (((uintptr_t)((x28)<(x17)))+((uintptr_t)((x29)<(x14))))+(x15); + x31 = (x30)+(x12); + x32 = ((uintptr_t)((x30)<(x15)))+((uintptr_t)((x31)<(x12))); + x33 = (x21)*((uintptr_t)7986114184663260229ULL); + x34 = (x33)*((uintptr_t)18446744073709551615ULL); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)18446744073709551615ULL))>>64); + x36 = (x33)*((uintptr_t)18446744073709551615ULL); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)18446744073709551615ULL))>>64); + x38 = (x33)*((uintptr_t)18446744073709551615ULL); + x39 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)18446744073709551615ULL))>>64); + x40 = (x33)*((uintptr_t)14367412456785391071ULL); + x41 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)14367412456785391071ULL))>>64); + x42 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)6348401684107011962ULL))>>64); + x43 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)17072048233947408755ULL))>>64); + x44 = (x43)+((x33)*((uintptr_t)6348401684107011962ULL)); + x45 = ((uintptr_t)((x44)<(x43)))+(x42); + x46 = (x45)+(x40); + x47 = (((uintptr_t)((x45)<(x42)))+((uintptr_t)((x46)<(x40))))+(x41); + x48 = (x47)+(x38); + x49 = (((uintptr_t)((x47)<(x41)))+((uintptr_t)((x48)<(x38))))+(x39); + x50 = (x49)+(x36); + x51 = (((uintptr_t)((x49)<(x39)))+((uintptr_t)((x50)<(x36))))+(x37); + x52 = (x51)+(x34); + x53 = ((uintptr_t)((x51)<(x37)))+((uintptr_t)((x52)<(x34))); + x54 = ((uintptr_t)(((x21)+((x33)*((uintptr_t)17072048233947408755ULL)))<(x21)))+(x23); + x55 = (x54)+(x44); + x56 = (((uintptr_t)((x54)<(x23)))+((uintptr_t)((x55)<(x44))))+(x25); + x57 = (x56)+(x46); + x58 = (((uintptr_t)((x56)<(x25)))+((uintptr_t)((x57)<(x46))))+(x27); + x59 = (x58)+(x48); + x60 = (((uintptr_t)((x58)<(x27)))+((uintptr_t)((x59)<(x48))))+(x29); + x61 = (x60)+(x50); + x62 = (((uintptr_t)((x60)<(x29)))+((uintptr_t)((x61)<(x50))))+(x31); + x63 = (x62)+(x52); + x64 = (((uintptr_t)((x62)<(x31)))+((uintptr_t)((x63)<(x52))))+((x32)+(x13)); + x65 = (x64)+((x53)+(x35)); + x66 = ((uintptr_t)((x64)<((x32)+(x13))))+((uintptr_t)((x65)<((x53)+(x35)))); + x67 = (x6)*((uintptr_t)902107514168524577ULL); + x68 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)902107514168524577ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)902107514168524577ULL))>>64); + x69 = (x6)*((uintptr_t)4589268600508278933ULL); + x70 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)4589268600508278933ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)4589268600508278933ULL))>>64); + x71 = (x6)*((uintptr_t)15279949475123764421ULL); + x72 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)15279949475123764421ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)15279949475123764421ULL))>>64); + x73 = (x6)*((uintptr_t)13564358545871743303ULL); + x74 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)13564358545871743303ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)13564358545871743303ULL))>>64); + x75 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)18391999277541532697ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)18391999277541532697ULL))>>64); + x76 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)3256554584917936553ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)3256554584917936553ULL))>>64); + x77 = (x76)+((x6)*((uintptr_t)18391999277541532697ULL)); + x78 = ((uintptr_t)((x77)<(x76)))+(x75); + x79 = (x78)+(x73); + x80 = (((uintptr_t)((x78)<(x75)))+((uintptr_t)((x79)<(x73))))+(x74); + x81 = (x80)+(x71); + x82 = (((uintptr_t)((x80)<(x74)))+((uintptr_t)((x81)<(x71))))+(x72); + x83 = (x82)+(x69); + x84 = (((uintptr_t)((x82)<(x72)))+((uintptr_t)((x83)<(x69))))+(x70); + x85 = (x84)+(x67); + x86 = ((uintptr_t)((x84)<(x70)))+((uintptr_t)((x85)<(x67))); + x87 = (x55)+((x6)*((uintptr_t)3256554584917936553ULL)); + x88 = ((uintptr_t)((x87)<(x55)))+(x57); + x89 = (x88)+(x77); + x90 = (((uintptr_t)((x88)<(x57)))+((uintptr_t)((x89)<(x77))))+(x59); + x91 = (x90)+(x79); + x92 = (((uintptr_t)((x90)<(x59)))+((uintptr_t)((x91)<(x79))))+(x61); + x93 = (x92)+(x81); + x94 = (((uintptr_t)((x92)<(x61)))+((uintptr_t)((x93)<(x81))))+(x63); + x95 = (x94)+(x83); + x96 = (((uintptr_t)((x94)<(x63)))+((uintptr_t)((x95)<(x83))))+(x65); + x97 = (x96)+(x85); + x98 = ((uintptr_t)((x96)<(x65)))+((uintptr_t)((x97)<(x85))); + x99 = (x87)*((uintptr_t)7986114184663260229ULL); + x100 = (x99)*((uintptr_t)18446744073709551615ULL); + x101 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x99)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x99)*((uintptr_t)18446744073709551615ULL))>>64); + x102 = (x99)*((uintptr_t)18446744073709551615ULL); + x103 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x99)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x99)*((uintptr_t)18446744073709551615ULL))>>64); + x104 = (x99)*((uintptr_t)18446744073709551615ULL); + x105 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x99)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x99)*((uintptr_t)18446744073709551615ULL))>>64); + x106 = (x99)*((uintptr_t)14367412456785391071ULL); + x107 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x99)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x99)*((uintptr_t)14367412456785391071ULL))>>64); + x108 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x99)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x99)*((uintptr_t)6348401684107011962ULL))>>64); + x109 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x99)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x99)*((uintptr_t)17072048233947408755ULL))>>64); + x110 = (x109)+((x99)*((uintptr_t)6348401684107011962ULL)); + x111 = ((uintptr_t)((x110)<(x109)))+(x108); + x112 = (x111)+(x106); + x113 = (((uintptr_t)((x111)<(x108)))+((uintptr_t)((x112)<(x106))))+(x107); + x114 = (x113)+(x104); + x115 = (((uintptr_t)((x113)<(x107)))+((uintptr_t)((x114)<(x104))))+(x105); + x116 = (x115)+(x102); + x117 = (((uintptr_t)((x115)<(x105)))+((uintptr_t)((x116)<(x102))))+(x103); + x118 = (x117)+(x100); + x119 = ((uintptr_t)((x117)<(x103)))+((uintptr_t)((x118)<(x100))); + x120 = ((uintptr_t)(((x87)+((x99)*((uintptr_t)17072048233947408755ULL)))<(x87)))+(x89); + x121 = (x120)+(x110); + x122 = (((uintptr_t)((x120)<(x89)))+((uintptr_t)((x121)<(x110))))+(x91); + x123 = (x122)+(x112); + x124 = (((uintptr_t)((x122)<(x91)))+((uintptr_t)((x123)<(x112))))+(x93); + x125 = (x124)+(x114); + x126 = (((uintptr_t)((x124)<(x93)))+((uintptr_t)((x125)<(x114))))+(x95); + x127 = (x126)+(x116); + x128 = (((uintptr_t)((x126)<(x95)))+((uintptr_t)((x127)<(x116))))+(x97); + x129 = (x128)+(x118); + x130 = (((uintptr_t)((x128)<(x97)))+((uintptr_t)((x129)<(x118))))+(((x98)+(x66))+((x86)+(x68))); + x131 = (x130)+((x119)+(x101)); + x132 = ((uintptr_t)((x130)<(((x98)+(x66))+((x86)+(x68)))))+((uintptr_t)((x131)<((x119)+(x101)))); + x133 = (x7)*((uintptr_t)902107514168524577ULL); + x134 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)902107514168524577ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)902107514168524577ULL))>>64); + x135 = (x7)*((uintptr_t)4589268600508278933ULL); + x136 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)4589268600508278933ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)4589268600508278933ULL))>>64); + x137 = (x7)*((uintptr_t)15279949475123764421ULL); + x138 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)15279949475123764421ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)15279949475123764421ULL))>>64); + x139 = (x7)*((uintptr_t)13564358545871743303ULL); + x140 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)13564358545871743303ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)13564358545871743303ULL))>>64); + x141 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)18391999277541532697ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)18391999277541532697ULL))>>64); + x142 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)3256554584917936553ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)3256554584917936553ULL))>>64); + x143 = (x142)+((x7)*((uintptr_t)18391999277541532697ULL)); + x144 = ((uintptr_t)((x143)<(x142)))+(x141); + x145 = (x144)+(x139); + x146 = (((uintptr_t)((x144)<(x141)))+((uintptr_t)((x145)<(x139))))+(x140); + x147 = (x146)+(x137); + x148 = (((uintptr_t)((x146)<(x140)))+((uintptr_t)((x147)<(x137))))+(x138); + x149 = (x148)+(x135); + x150 = (((uintptr_t)((x148)<(x138)))+((uintptr_t)((x149)<(x135))))+(x136); + x151 = (x150)+(x133); + x152 = ((uintptr_t)((x150)<(x136)))+((uintptr_t)((x151)<(x133))); + x153 = (x121)+((x7)*((uintptr_t)3256554584917936553ULL)); + x154 = ((uintptr_t)((x153)<(x121)))+(x123); + x155 = (x154)+(x143); + x156 = (((uintptr_t)((x154)<(x123)))+((uintptr_t)((x155)<(x143))))+(x125); + x157 = (x156)+(x145); + x158 = (((uintptr_t)((x156)<(x125)))+((uintptr_t)((x157)<(x145))))+(x127); + x159 = (x158)+(x147); + x160 = (((uintptr_t)((x158)<(x127)))+((uintptr_t)((x159)<(x147))))+(x129); + x161 = (x160)+(x149); + x162 = (((uintptr_t)((x160)<(x129)))+((uintptr_t)((x161)<(x149))))+(x131); + x163 = (x162)+(x151); + x164 = ((uintptr_t)((x162)<(x131)))+((uintptr_t)((x163)<(x151))); + x165 = (x153)*((uintptr_t)7986114184663260229ULL); + x166 = (x165)*((uintptr_t)18446744073709551615ULL); + x167 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)18446744073709551615ULL))>>64); + x168 = (x165)*((uintptr_t)18446744073709551615ULL); + x169 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)18446744073709551615ULL))>>64); + x170 = (x165)*((uintptr_t)18446744073709551615ULL); + x171 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)18446744073709551615ULL))>>64); + x172 = (x165)*((uintptr_t)14367412456785391071ULL); + x173 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)14367412456785391071ULL))>>64); + x174 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)6348401684107011962ULL))>>64); + x175 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)17072048233947408755ULL))>>64); + x176 = (x175)+((x165)*((uintptr_t)6348401684107011962ULL)); + x177 = ((uintptr_t)((x176)<(x175)))+(x174); + x178 = (x177)+(x172); + x179 = (((uintptr_t)((x177)<(x174)))+((uintptr_t)((x178)<(x172))))+(x173); + x180 = (x179)+(x170); + x181 = (((uintptr_t)((x179)<(x173)))+((uintptr_t)((x180)<(x170))))+(x171); + x182 = (x181)+(x168); + x183 = (((uintptr_t)((x181)<(x171)))+((uintptr_t)((x182)<(x168))))+(x169); + x184 = (x183)+(x166); + x185 = ((uintptr_t)((x183)<(x169)))+((uintptr_t)((x184)<(x166))); + x186 = ((uintptr_t)(((x153)+((x165)*((uintptr_t)17072048233947408755ULL)))<(x153)))+(x155); + x187 = (x186)+(x176); + x188 = (((uintptr_t)((x186)<(x155)))+((uintptr_t)((x187)<(x176))))+(x157); + x189 = (x188)+(x178); + x190 = (((uintptr_t)((x188)<(x157)))+((uintptr_t)((x189)<(x178))))+(x159); + x191 = (x190)+(x180); + x192 = (((uintptr_t)((x190)<(x159)))+((uintptr_t)((x191)<(x180))))+(x161); + x193 = (x192)+(x182); + x194 = (((uintptr_t)((x192)<(x161)))+((uintptr_t)((x193)<(x182))))+(x163); + x195 = (x194)+(x184); + x196 = (((uintptr_t)((x194)<(x163)))+((uintptr_t)((x195)<(x184))))+(((x164)+(x132))+((x152)+(x134))); + x197 = (x196)+((x185)+(x167)); + x198 = ((uintptr_t)((x196)<(((x164)+(x132))+((x152)+(x134)))))+((uintptr_t)((x197)<((x185)+(x167)))); + x199 = (x8)*((uintptr_t)902107514168524577ULL); + x200 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)902107514168524577ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)902107514168524577ULL))>>64); + x201 = (x8)*((uintptr_t)4589268600508278933ULL); + x202 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)4589268600508278933ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)4589268600508278933ULL))>>64); + x203 = (x8)*((uintptr_t)15279949475123764421ULL); + x204 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)15279949475123764421ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)15279949475123764421ULL))>>64); + x205 = (x8)*((uintptr_t)13564358545871743303ULL); + x206 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)13564358545871743303ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)13564358545871743303ULL))>>64); + x207 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)18391999277541532697ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)18391999277541532697ULL))>>64); + x208 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)3256554584917936553ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)3256554584917936553ULL))>>64); + x209 = (x208)+((x8)*((uintptr_t)18391999277541532697ULL)); + x210 = ((uintptr_t)((x209)<(x208)))+(x207); + x211 = (x210)+(x205); + x212 = (((uintptr_t)((x210)<(x207)))+((uintptr_t)((x211)<(x205))))+(x206); + x213 = (x212)+(x203); + x214 = (((uintptr_t)((x212)<(x206)))+((uintptr_t)((x213)<(x203))))+(x204); + x215 = (x214)+(x201); + x216 = (((uintptr_t)((x214)<(x204)))+((uintptr_t)((x215)<(x201))))+(x202); + x217 = (x216)+(x199); + x218 = ((uintptr_t)((x216)<(x202)))+((uintptr_t)((x217)<(x199))); + x219 = (x187)+((x8)*((uintptr_t)3256554584917936553ULL)); + x220 = ((uintptr_t)((x219)<(x187)))+(x189); + x221 = (x220)+(x209); + x222 = (((uintptr_t)((x220)<(x189)))+((uintptr_t)((x221)<(x209))))+(x191); + x223 = (x222)+(x211); + x224 = (((uintptr_t)((x222)<(x191)))+((uintptr_t)((x223)<(x211))))+(x193); + x225 = (x224)+(x213); + x226 = (((uintptr_t)((x224)<(x193)))+((uintptr_t)((x225)<(x213))))+(x195); + x227 = (x226)+(x215); + x228 = (((uintptr_t)((x226)<(x195)))+((uintptr_t)((x227)<(x215))))+(x197); + x229 = (x228)+(x217); + x230 = ((uintptr_t)((x228)<(x197)))+((uintptr_t)((x229)<(x217))); + x231 = (x219)*((uintptr_t)7986114184663260229ULL); + x232 = (x231)*((uintptr_t)18446744073709551615ULL); + x233 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x231)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x231)*((uintptr_t)18446744073709551615ULL))>>64); + x234 = (x231)*((uintptr_t)18446744073709551615ULL); + x235 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x231)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x231)*((uintptr_t)18446744073709551615ULL))>>64); + x236 = (x231)*((uintptr_t)18446744073709551615ULL); + x237 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x231)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x231)*((uintptr_t)18446744073709551615ULL))>>64); + x238 = (x231)*((uintptr_t)14367412456785391071ULL); + x239 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x231)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x231)*((uintptr_t)14367412456785391071ULL))>>64); + x240 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x231)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x231)*((uintptr_t)6348401684107011962ULL))>>64); + x241 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x231)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x231)*((uintptr_t)17072048233947408755ULL))>>64); + x242 = (x241)+((x231)*((uintptr_t)6348401684107011962ULL)); + x243 = ((uintptr_t)((x242)<(x241)))+(x240); + x244 = (x243)+(x238); + x245 = (((uintptr_t)((x243)<(x240)))+((uintptr_t)((x244)<(x238))))+(x239); + x246 = (x245)+(x236); + x247 = (((uintptr_t)((x245)<(x239)))+((uintptr_t)((x246)<(x236))))+(x237); + x248 = (x247)+(x234); + x249 = (((uintptr_t)((x247)<(x237)))+((uintptr_t)((x248)<(x234))))+(x235); + x250 = (x249)+(x232); + x251 = ((uintptr_t)((x249)<(x235)))+((uintptr_t)((x250)<(x232))); + x252 = ((uintptr_t)(((x219)+((x231)*((uintptr_t)17072048233947408755ULL)))<(x219)))+(x221); + x253 = (x252)+(x242); + x254 = (((uintptr_t)((x252)<(x221)))+((uintptr_t)((x253)<(x242))))+(x223); + x255 = (x254)+(x244); + x256 = (((uintptr_t)((x254)<(x223)))+((uintptr_t)((x255)<(x244))))+(x225); + x257 = (x256)+(x246); + x258 = (((uintptr_t)((x256)<(x225)))+((uintptr_t)((x257)<(x246))))+(x227); + x259 = (x258)+(x248); + x260 = (((uintptr_t)((x258)<(x227)))+((uintptr_t)((x259)<(x248))))+(x229); + x261 = (x260)+(x250); + x262 = (((uintptr_t)((x260)<(x229)))+((uintptr_t)((x261)<(x250))))+(((x230)+(x198))+((x218)+(x200))); + x263 = (x262)+((x251)+(x233)); + x264 = ((uintptr_t)((x262)<(((x230)+(x198))+((x218)+(x200)))))+((uintptr_t)((x263)<((x251)+(x233)))); + x265 = (x9)*((uintptr_t)902107514168524577ULL); + x266 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)902107514168524577ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)902107514168524577ULL))>>64); + x267 = (x9)*((uintptr_t)4589268600508278933ULL); + x268 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)4589268600508278933ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)4589268600508278933ULL))>>64); + x269 = (x9)*((uintptr_t)15279949475123764421ULL); + x270 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)15279949475123764421ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)15279949475123764421ULL))>>64); + x271 = (x9)*((uintptr_t)13564358545871743303ULL); + x272 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)13564358545871743303ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)13564358545871743303ULL))>>64); + x273 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)18391999277541532697ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)18391999277541532697ULL))>>64); + x274 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)3256554584917936553ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)3256554584917936553ULL))>>64); + x275 = (x274)+((x9)*((uintptr_t)18391999277541532697ULL)); + x276 = ((uintptr_t)((x275)<(x274)))+(x273); + x277 = (x276)+(x271); + x278 = (((uintptr_t)((x276)<(x273)))+((uintptr_t)((x277)<(x271))))+(x272); + x279 = (x278)+(x269); + x280 = (((uintptr_t)((x278)<(x272)))+((uintptr_t)((x279)<(x269))))+(x270); + x281 = (x280)+(x267); + x282 = (((uintptr_t)((x280)<(x270)))+((uintptr_t)((x281)<(x267))))+(x268); + x283 = (x282)+(x265); + x284 = ((uintptr_t)((x282)<(x268)))+((uintptr_t)((x283)<(x265))); + x285 = (x253)+((x9)*((uintptr_t)3256554584917936553ULL)); + x286 = ((uintptr_t)((x285)<(x253)))+(x255); + x287 = (x286)+(x275); + x288 = (((uintptr_t)((x286)<(x255)))+((uintptr_t)((x287)<(x275))))+(x257); + x289 = (x288)+(x277); + x290 = (((uintptr_t)((x288)<(x257)))+((uintptr_t)((x289)<(x277))))+(x259); + x291 = (x290)+(x279); + x292 = (((uintptr_t)((x290)<(x259)))+((uintptr_t)((x291)<(x279))))+(x261); + x293 = (x292)+(x281); + x294 = (((uintptr_t)((x292)<(x261)))+((uintptr_t)((x293)<(x281))))+(x263); + x295 = (x294)+(x283); + x296 = ((uintptr_t)((x294)<(x263)))+((uintptr_t)((x295)<(x283))); + x297 = (x285)*((uintptr_t)7986114184663260229ULL); + x298 = (x297)*((uintptr_t)18446744073709551615ULL); + x299 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)18446744073709551615ULL))>>64); + x300 = (x297)*((uintptr_t)18446744073709551615ULL); + x301 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)18446744073709551615ULL))>>64); + x302 = (x297)*((uintptr_t)18446744073709551615ULL); + x303 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)18446744073709551615ULL))>>64); + x304 = (x297)*((uintptr_t)14367412456785391071ULL); + x305 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)14367412456785391071ULL))>>64); + x306 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)6348401684107011962ULL))>>64); + x307 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x297)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x297)*((uintptr_t)17072048233947408755ULL))>>64); + x308 = (x307)+((x297)*((uintptr_t)6348401684107011962ULL)); + x309 = ((uintptr_t)((x308)<(x307)))+(x306); + x310 = (x309)+(x304); + x311 = (((uintptr_t)((x309)<(x306)))+((uintptr_t)((x310)<(x304))))+(x305); + x312 = (x311)+(x302); + x313 = (((uintptr_t)((x311)<(x305)))+((uintptr_t)((x312)<(x302))))+(x303); + x314 = (x313)+(x300); + x315 = (((uintptr_t)((x313)<(x303)))+((uintptr_t)((x314)<(x300))))+(x301); + x316 = (x315)+(x298); + x317 = ((uintptr_t)((x315)<(x301)))+((uintptr_t)((x316)<(x298))); + x318 = ((uintptr_t)(((x285)+((x297)*((uintptr_t)17072048233947408755ULL)))<(x285)))+(x287); + x319 = (x318)+(x308); + x320 = (((uintptr_t)((x318)<(x287)))+((uintptr_t)((x319)<(x308))))+(x289); + x321 = (x320)+(x310); + x322 = (((uintptr_t)((x320)<(x289)))+((uintptr_t)((x321)<(x310))))+(x291); + x323 = (x322)+(x312); + x324 = (((uintptr_t)((x322)<(x291)))+((uintptr_t)((x323)<(x312))))+(x293); + x325 = (x324)+(x314); + x326 = (((uintptr_t)((x324)<(x293)))+((uintptr_t)((x325)<(x314))))+(x295); + x327 = (x326)+(x316); + x328 = (((uintptr_t)((x326)<(x295)))+((uintptr_t)((x327)<(x316))))+(((x296)+(x264))+((x284)+(x266))); + x329 = (x328)+((x317)+(x299)); + x330 = ((uintptr_t)((x328)<(((x296)+(x264))+((x284)+(x266)))))+((uintptr_t)((x329)<((x317)+(x299)))); + x331 = (x10)*((uintptr_t)902107514168524577ULL); + x332 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)902107514168524577ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)902107514168524577ULL))>>64); + x333 = (x10)*((uintptr_t)4589268600508278933ULL); + x334 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)4589268600508278933ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)4589268600508278933ULL))>>64); + x335 = (x10)*((uintptr_t)15279949475123764421ULL); + x336 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)15279949475123764421ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)15279949475123764421ULL))>>64); + x337 = (x10)*((uintptr_t)13564358545871743303ULL); + x338 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)13564358545871743303ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)13564358545871743303ULL))>>64); + x339 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)18391999277541532697ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)18391999277541532697ULL))>>64); + x340 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)3256554584917936553ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)3256554584917936553ULL))>>64); + x341 = (x340)+((x10)*((uintptr_t)18391999277541532697ULL)); + x342 = ((uintptr_t)((x341)<(x340)))+(x339); + x343 = (x342)+(x337); + x344 = (((uintptr_t)((x342)<(x339)))+((uintptr_t)((x343)<(x337))))+(x338); + x345 = (x344)+(x335); + x346 = (((uintptr_t)((x344)<(x338)))+((uintptr_t)((x345)<(x335))))+(x336); + x347 = (x346)+(x333); + x348 = (((uintptr_t)((x346)<(x336)))+((uintptr_t)((x347)<(x333))))+(x334); + x349 = (x348)+(x331); + x350 = ((uintptr_t)((x348)<(x334)))+((uintptr_t)((x349)<(x331))); + x351 = (x319)+((x10)*((uintptr_t)3256554584917936553ULL)); + x352 = ((uintptr_t)((x351)<(x319)))+(x321); + x353 = (x352)+(x341); + x354 = (((uintptr_t)((x352)<(x321)))+((uintptr_t)((x353)<(x341))))+(x323); + x355 = (x354)+(x343); + x356 = (((uintptr_t)((x354)<(x323)))+((uintptr_t)((x355)<(x343))))+(x325); + x357 = (x356)+(x345); + x358 = (((uintptr_t)((x356)<(x325)))+((uintptr_t)((x357)<(x345))))+(x327); + x359 = (x358)+(x347); + x360 = (((uintptr_t)((x358)<(x327)))+((uintptr_t)((x359)<(x347))))+(x329); + x361 = (x360)+(x349); + x362 = ((uintptr_t)((x360)<(x329)))+((uintptr_t)((x361)<(x349))); + x363 = (x351)*((uintptr_t)7986114184663260229ULL); + x364 = (x363)*((uintptr_t)18446744073709551615ULL); + x365 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x363)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x363)*((uintptr_t)18446744073709551615ULL))>>64); + x366 = (x363)*((uintptr_t)18446744073709551615ULL); + x367 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x363)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x363)*((uintptr_t)18446744073709551615ULL))>>64); + x368 = (x363)*((uintptr_t)18446744073709551615ULL); + x369 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x363)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x363)*((uintptr_t)18446744073709551615ULL))>>64); + x370 = (x363)*((uintptr_t)14367412456785391071ULL); + x371 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x363)*((uintptr_t)14367412456785391071ULL))>>32 : ((__uint128_t)(x363)*((uintptr_t)14367412456785391071ULL))>>64); + x372 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x363)*((uintptr_t)6348401684107011962ULL))>>32 : ((__uint128_t)(x363)*((uintptr_t)6348401684107011962ULL))>>64); + x373 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x363)*((uintptr_t)17072048233947408755ULL))>>32 : ((__uint128_t)(x363)*((uintptr_t)17072048233947408755ULL))>>64); + x374 = (x373)+((x363)*((uintptr_t)6348401684107011962ULL)); + x375 = ((uintptr_t)((x374)<(x373)))+(x372); + x376 = (x375)+(x370); + x377 = (((uintptr_t)((x375)<(x372)))+((uintptr_t)((x376)<(x370))))+(x371); + x378 = (x377)+(x368); + x379 = (((uintptr_t)((x377)<(x371)))+((uintptr_t)((x378)<(x368))))+(x369); + x380 = (x379)+(x366); + x381 = (((uintptr_t)((x379)<(x369)))+((uintptr_t)((x380)<(x366))))+(x367); + x382 = (x381)+(x364); + x383 = ((uintptr_t)((x381)<(x367)))+((uintptr_t)((x382)<(x364))); + x384 = ((uintptr_t)(((x351)+((x363)*((uintptr_t)17072048233947408755ULL)))<(x351)))+(x353); + x385 = (x384)+(x374); + x386 = (((uintptr_t)((x384)<(x353)))+((uintptr_t)((x385)<(x374))))+(x355); + x387 = (x386)+(x376); + x388 = (((uintptr_t)((x386)<(x355)))+((uintptr_t)((x387)<(x376))))+(x357); + x389 = (x388)+(x378); + x390 = (((uintptr_t)((x388)<(x357)))+((uintptr_t)((x389)<(x378))))+(x359); + x391 = (x390)+(x380); + x392 = (((uintptr_t)((x390)<(x359)))+((uintptr_t)((x391)<(x380))))+(x361); + x393 = (x392)+(x382); + x394 = (((uintptr_t)((x392)<(x361)))+((uintptr_t)((x393)<(x382))))+(((x362)+(x330))+((x350)+(x332))); + x395 = (x394)+((x383)+(x365)); + x396 = ((uintptr_t)((x394)<(((x362)+(x330))+((x350)+(x332)))))+((uintptr_t)((x395)<((x383)+(x365)))); + x397 = (x385)-((uintptr_t)17072048233947408755ULL); + x398 = (x387)-((uintptr_t)6348401684107011962ULL); + x399 = (x398)-((uintptr_t)((x385)<(x397))); + x400 = (x389)-((uintptr_t)14367412456785391071ULL); + x401 = (x400)-(((uintptr_t)((x387)<(x398)))+((uintptr_t)((x398)<(x399)))); + x402 = (x391)-((uintptr_t)18446744073709551615ULL); + x403 = (x402)-(((uintptr_t)((x389)<(x400)))+((uintptr_t)((x400)<(x401)))); + x404 = (x393)-((uintptr_t)18446744073709551615ULL); + x405 = (x404)-(((uintptr_t)((x391)<(x402)))+((uintptr_t)((x402)<(x403)))); + x406 = (x395)-((uintptr_t)18446744073709551615ULL); + x407 = (x406)-(((uintptr_t)((x393)<(x404)))+((uintptr_t)((x404)<(x405)))); + x408 = (uintptr_t)((x396)<((x396)-(((uintptr_t)((x395)<(x406)))+((uintptr_t)((x406)<(x407)))))); + x409 = ((uintptr_t)-1ULL)+((uintptr_t)((x408)==((uintptr_t)0ULL))); + x410 = (x409)^((uintptr_t)18446744073709551615ULL); + x411 = ((x385)&(x409))|((x397)&(x410)); + x412 = ((uintptr_t)-1ULL)+((uintptr_t)((x408)==((uintptr_t)0ULL))); + x413 = (x412)^((uintptr_t)18446744073709551615ULL); + x414 = ((x387)&(x412))|((x399)&(x413)); + x415 = ((uintptr_t)-1ULL)+((uintptr_t)((x408)==((uintptr_t)0ULL))); + x416 = (x415)^((uintptr_t)18446744073709551615ULL); + x417 = ((x389)&(x415))|((x401)&(x416)); + x418 = ((uintptr_t)-1ULL)+((uintptr_t)((x408)==((uintptr_t)0ULL))); + x419 = (x418)^((uintptr_t)18446744073709551615ULL); + x420 = ((x391)&(x418))|((x403)&(x419)); + x421 = ((uintptr_t)-1ULL)+((uintptr_t)((x408)==((uintptr_t)0ULL))); + x422 = (x421)^((uintptr_t)18446744073709551615ULL); + x423 = ((x393)&(x421))|((x405)&(x422)); + x424 = ((uintptr_t)-1ULL)+((uintptr_t)((x408)==((uintptr_t)0ULL))); + x425 = (x424)^((uintptr_t)18446744073709551615ULL); + x426 = ((x395)&(x424))|((x407)&(x425)); + x427 = x411; + x428 = x414; + x429 = x417; + x430 = x420; + x431 = x423; + x432 = x426; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x427, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x428, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x429, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x430, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x431, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x432, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_to_montgomery(uint64_t out1[6], const uint64_t arg1[6]) { + internal_fiat_p384_scalar_to_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffffffffffff] + */ +static +uintptr_t internal_fiat_p384_scalar_nonzero(uintptr_t in0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, out0, x7; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x6 = (x0)|((x1)|((x2)|((x3)|((x4)|(x5))))); + x7 = x6; + out0 = x7; + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_nonzero(uint64_t* out1, const uint64_t arg1[6]) { + *out1 = (uint64_t)internal_fiat_p384_scalar_nonzero((uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0x1] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p384_scalar_selectznz(uintptr_t out0, uintptr_t in0, uintptr_t in1, uintptr_t in2) { + uintptr_t x6, x12, x0, x13, x7, x15, x1, x16, x8, x18, x2, x19, x9, x21, x3, x22, x10, x24, x4, x25, x11, x27, x5, x28, x14, x17, x20, x23, x26, x29, x30, x31, x32, x33, x34, x35; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + x6 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x7 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x8 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x9 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x10 = _br2_load((in2)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x11 = _br2_load((in2)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x12 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x13 = (x12)^((uintptr_t)18446744073709551615ULL); + x14 = ((x6)&(x12))|((x0)&(x13)); + x15 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x16 = (x15)^((uintptr_t)18446744073709551615ULL); + x17 = ((x7)&(x15))|((x1)&(x16)); + x18 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x19 = (x18)^((uintptr_t)18446744073709551615ULL); + x20 = ((x8)&(x18))|((x2)&(x19)); + x21 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x22 = (x21)^((uintptr_t)18446744073709551615ULL); + x23 = ((x9)&(x21))|((x3)&(x22)); + x24 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x25 = (x24)^((uintptr_t)18446744073709551615ULL); + x26 = ((x10)&(x24))|((x4)&(x25)); + x27 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x28 = (x27)^((uintptr_t)18446744073709551615ULL); + x29 = ((x11)&(x27))|((x5)&(x28)); + x30 = x14; + x31 = x17; + x32 = x20; + x33 = x23; + x34 = x26; + x35 = x29; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x30, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x31, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x32, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x33, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x34, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x35, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_selectznz(uint64_t out1[6], uint8_t arg1, const uint64_t arg2[6], const uint64_t arg3[6]) { + internal_fiat_p384_scalar_selectznz((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static +void internal_fiat_p384_scalar_to_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x5, x4, x3, x2, x1, x0, x11, x13, x15, x17, x19, x21, x23, x10, x27, x29, x31, x33, x35, x37, x9, x41, x43, x45, x47, x49, x51, x8, x55, x57, x59, x61, x63, x65, x7, x69, x71, x73, x75, x77, x79, x6, x83, x85, x87, x89, x91, x93, x12, x14, x16, x18, x20, x22, x24, x25, x26, x28, x30, x32, x34, x36, x38, x39, x40, x42, x44, x46, x48, x50, x52, x53, x54, x56, x58, x60, x62, x64, x66, x67, x68, x70, x72, x74, x76, x78, x80, x81, x82, x84, x86, x88, x90, x92, x94, x95, x96, x97, x98, x99, x100, x101, x102, x103, x104, x105, x106, x107, x108, x109, x110, x111, x112, x113, x114, x115, x116, x117, x118, x119, x120, x121, x122, x123, x124, x125, x126, x127, x128, x129, x130, x131, x132, x133, x134, x135, x136, x137, x138, x139, x140, x141, x142, x143; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x6 = x5; + x7 = x4; + x8 = x3; + x9 = x2; + x10 = x1; + x11 = x0; + x12 = (x11)&((uintptr_t)255ULL); + x13 = (x11)>>((uintptr_t)8ULL); + x14 = (x13)&((uintptr_t)255ULL); + x15 = (x13)>>((uintptr_t)8ULL); + x16 = (x15)&((uintptr_t)255ULL); + x17 = (x15)>>((uintptr_t)8ULL); + x18 = (x17)&((uintptr_t)255ULL); + x19 = (x17)>>((uintptr_t)8ULL); + x20 = (x19)&((uintptr_t)255ULL); + x21 = (x19)>>((uintptr_t)8ULL); + x22 = (x21)&((uintptr_t)255ULL); + x23 = (x21)>>((uintptr_t)8ULL); + x24 = (x23)&((uintptr_t)255ULL); + x25 = (x23)>>((uintptr_t)8ULL); + x26 = (x10)&((uintptr_t)255ULL); + x27 = (x10)>>((uintptr_t)8ULL); + x28 = (x27)&((uintptr_t)255ULL); + x29 = (x27)>>((uintptr_t)8ULL); + x30 = (x29)&((uintptr_t)255ULL); + x31 = (x29)>>((uintptr_t)8ULL); + x32 = (x31)&((uintptr_t)255ULL); + x33 = (x31)>>((uintptr_t)8ULL); + x34 = (x33)&((uintptr_t)255ULL); + x35 = (x33)>>((uintptr_t)8ULL); + x36 = (x35)&((uintptr_t)255ULL); + x37 = (x35)>>((uintptr_t)8ULL); + x38 = (x37)&((uintptr_t)255ULL); + x39 = (x37)>>((uintptr_t)8ULL); + x40 = (x9)&((uintptr_t)255ULL); + x41 = (x9)>>((uintptr_t)8ULL); + x42 = (x41)&((uintptr_t)255ULL); + x43 = (x41)>>((uintptr_t)8ULL); + x44 = (x43)&((uintptr_t)255ULL); + x45 = (x43)>>((uintptr_t)8ULL); + x46 = (x45)&((uintptr_t)255ULL); + x47 = (x45)>>((uintptr_t)8ULL); + x48 = (x47)&((uintptr_t)255ULL); + x49 = (x47)>>((uintptr_t)8ULL); + x50 = (x49)&((uintptr_t)255ULL); + x51 = (x49)>>((uintptr_t)8ULL); + x52 = (x51)&((uintptr_t)255ULL); + x53 = (x51)>>((uintptr_t)8ULL); + x54 = (x8)&((uintptr_t)255ULL); + x55 = (x8)>>((uintptr_t)8ULL); + x56 = (x55)&((uintptr_t)255ULL); + x57 = (x55)>>((uintptr_t)8ULL); + x58 = (x57)&((uintptr_t)255ULL); + x59 = (x57)>>((uintptr_t)8ULL); + x60 = (x59)&((uintptr_t)255ULL); + x61 = (x59)>>((uintptr_t)8ULL); + x62 = (x61)&((uintptr_t)255ULL); + x63 = (x61)>>((uintptr_t)8ULL); + x64 = (x63)&((uintptr_t)255ULL); + x65 = (x63)>>((uintptr_t)8ULL); + x66 = (x65)&((uintptr_t)255ULL); + x67 = (x65)>>((uintptr_t)8ULL); + x68 = (x7)&((uintptr_t)255ULL); + x69 = (x7)>>((uintptr_t)8ULL); + x70 = (x69)&((uintptr_t)255ULL); + x71 = (x69)>>((uintptr_t)8ULL); + x72 = (x71)&((uintptr_t)255ULL); + x73 = (x71)>>((uintptr_t)8ULL); + x74 = (x73)&((uintptr_t)255ULL); + x75 = (x73)>>((uintptr_t)8ULL); + x76 = (x75)&((uintptr_t)255ULL); + x77 = (x75)>>((uintptr_t)8ULL); + x78 = (x77)&((uintptr_t)255ULL); + x79 = (x77)>>((uintptr_t)8ULL); + x80 = (x79)&((uintptr_t)255ULL); + x81 = (x79)>>((uintptr_t)8ULL); + x82 = (x6)&((uintptr_t)255ULL); + x83 = (x6)>>((uintptr_t)8ULL); + x84 = (x83)&((uintptr_t)255ULL); + x85 = (x83)>>((uintptr_t)8ULL); + x86 = (x85)&((uintptr_t)255ULL); + x87 = (x85)>>((uintptr_t)8ULL); + x88 = (x87)&((uintptr_t)255ULL); + x89 = (x87)>>((uintptr_t)8ULL); + x90 = (x89)&((uintptr_t)255ULL); + x91 = (x89)>>((uintptr_t)8ULL); + x92 = (x91)&((uintptr_t)255ULL); + x93 = (x91)>>((uintptr_t)8ULL); + x94 = (x93)&((uintptr_t)255ULL); + x95 = (x93)>>((uintptr_t)8ULL); + x96 = x12; + x97 = x14; + x98 = x16; + x99 = x18; + x100 = x20; + x101 = x22; + x102 = x24; + x103 = x25; + x104 = x26; + x105 = x28; + x106 = x30; + x107 = x32; + x108 = x34; + x109 = x36; + x110 = x38; + x111 = x39; + x112 = x40; + x113 = x42; + x114 = x44; + x115 = x46; + x116 = x48; + x117 = x50; + x118 = x52; + x119 = x53; + x120 = x54; + x121 = x56; + x122 = x58; + x123 = x60; + x124 = x62; + x125 = x64; + x126 = x66; + x127 = x67; + x128 = x68; + x129 = x70; + x130 = x72; + x131 = x74; + x132 = x76; + x133 = x78; + x134 = x80; + x135 = x81; + x136 = x82; + x137 = x84; + x138 = x86; + x139 = x88; + x140 = x90; + x141 = x92; + x142 = x94; + x143 = x95; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x96, 1); + _br2_store((out0)+((uintptr_t)1ULL), x97, 1); + _br2_store((out0)+((uintptr_t)2ULL), x98, 1); + _br2_store((out0)+((uintptr_t)3ULL), x99, 1); + _br2_store((out0)+((uintptr_t)4ULL), x100, 1); + _br2_store((out0)+((uintptr_t)5ULL), x101, 1); + _br2_store((out0)+((uintptr_t)6ULL), x102, 1); + _br2_store((out0)+((uintptr_t)7ULL), x103, 1); + _br2_store((out0)+((uintptr_t)8ULL), x104, 1); + _br2_store((out0)+((uintptr_t)9ULL), x105, 1); + _br2_store((out0)+((uintptr_t)10ULL), x106, 1); + _br2_store((out0)+((uintptr_t)11ULL), x107, 1); + _br2_store((out0)+((uintptr_t)12ULL), x108, 1); + _br2_store((out0)+((uintptr_t)13ULL), x109, 1); + _br2_store((out0)+((uintptr_t)14ULL), x110, 1); + _br2_store((out0)+((uintptr_t)15ULL), x111, 1); + _br2_store((out0)+((uintptr_t)16ULL), x112, 1); + _br2_store((out0)+((uintptr_t)17ULL), x113, 1); + _br2_store((out0)+((uintptr_t)18ULL), x114, 1); + _br2_store((out0)+((uintptr_t)19ULL), x115, 1); + _br2_store((out0)+((uintptr_t)20ULL), x116, 1); + _br2_store((out0)+((uintptr_t)21ULL), x117, 1); + _br2_store((out0)+((uintptr_t)22ULL), x118, 1); + _br2_store((out0)+((uintptr_t)23ULL), x119, 1); + _br2_store((out0)+((uintptr_t)24ULL), x120, 1); + _br2_store((out0)+((uintptr_t)25ULL), x121, 1); + _br2_store((out0)+((uintptr_t)26ULL), x122, 1); + _br2_store((out0)+((uintptr_t)27ULL), x123, 1); + _br2_store((out0)+((uintptr_t)28ULL), x124, 1); + _br2_store((out0)+((uintptr_t)29ULL), x125, 1); + _br2_store((out0)+((uintptr_t)30ULL), x126, 1); + _br2_store((out0)+((uintptr_t)31ULL), x127, 1); + _br2_store((out0)+((uintptr_t)32ULL), x128, 1); + _br2_store((out0)+((uintptr_t)33ULL), x129, 1); + _br2_store((out0)+((uintptr_t)34ULL), x130, 1); + _br2_store((out0)+((uintptr_t)35ULL), x131, 1); + _br2_store((out0)+((uintptr_t)36ULL), x132, 1); + _br2_store((out0)+((uintptr_t)37ULL), x133, 1); + _br2_store((out0)+((uintptr_t)38ULL), x134, 1); + _br2_store((out0)+((uintptr_t)39ULL), x135, 1); + _br2_store((out0)+((uintptr_t)40ULL), x136, 1); + _br2_store((out0)+((uintptr_t)41ULL), x137, 1); + _br2_store((out0)+((uintptr_t)42ULL), x138, 1); + _br2_store((out0)+((uintptr_t)43ULL), x139, 1); + _br2_store((out0)+((uintptr_t)44ULL), x140, 1); + _br2_store((out0)+((uintptr_t)45ULL), x141, 1); + _br2_store((out0)+((uintptr_t)46ULL), x142, 1); + _br2_store((out0)+((uintptr_t)47ULL), x143, 1); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_to_bytes(uint8_t out1[48], const uint64_t arg1[6]) { + internal_fiat_p384_scalar_to_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p384_scalar_from_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x47, x46, x45, x44, x43, x42, x41, x40, x39, x38, x37, x36, x35, x34, x33, x32, x31, x30, x29, x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x12, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0, x94, x95, x93, x96, x92, x97, x91, x98, x90, x99, x89, x100, x88, x101, x86, x87, x85, x103, x84, x104, x83, x105, x82, x106, x81, x107, x80, x108, x78, x79, x77, x110, x76, x111, x75, x112, x74, x113, x73, x114, x72, x115, x70, x71, x69, x117, x68, x118, x67, x119, x66, x120, x65, x121, x64, x122, x62, x63, x61, x124, x60, x125, x59, x126, x58, x127, x57, x128, x56, x129, x54, x55, x53, x131, x52, x132, x51, x133, x50, x134, x49, x135, x48, x136, x102, x109, x116, x123, x130, x137, x138, x139, x140, x141, x142, x143; + x0 = _br2_load((in0)+((uintptr_t)0ULL), 1); + x1 = _br2_load((in0)+((uintptr_t)1ULL), 1); + x2 = _br2_load((in0)+((uintptr_t)2ULL), 1); + x3 = _br2_load((in0)+((uintptr_t)3ULL), 1); + x4 = _br2_load((in0)+((uintptr_t)4ULL), 1); + x5 = _br2_load((in0)+((uintptr_t)5ULL), 1); + x6 = _br2_load((in0)+((uintptr_t)6ULL), 1); + x7 = _br2_load((in0)+((uintptr_t)7ULL), 1); + x8 = _br2_load((in0)+((uintptr_t)8ULL), 1); + x9 = _br2_load((in0)+((uintptr_t)9ULL), 1); + x10 = _br2_load((in0)+((uintptr_t)10ULL), 1); + x11 = _br2_load((in0)+((uintptr_t)11ULL), 1); + x12 = _br2_load((in0)+((uintptr_t)12ULL), 1); + x13 = _br2_load((in0)+((uintptr_t)13ULL), 1); + x14 = _br2_load((in0)+((uintptr_t)14ULL), 1); + x15 = _br2_load((in0)+((uintptr_t)15ULL), 1); + x16 = _br2_load((in0)+((uintptr_t)16ULL), 1); + x17 = _br2_load((in0)+((uintptr_t)17ULL), 1); + x18 = _br2_load((in0)+((uintptr_t)18ULL), 1); + x19 = _br2_load((in0)+((uintptr_t)19ULL), 1); + x20 = _br2_load((in0)+((uintptr_t)20ULL), 1); + x21 = _br2_load((in0)+((uintptr_t)21ULL), 1); + x22 = _br2_load((in0)+((uintptr_t)22ULL), 1); + x23 = _br2_load((in0)+((uintptr_t)23ULL), 1); + x24 = _br2_load((in0)+((uintptr_t)24ULL), 1); + x25 = _br2_load((in0)+((uintptr_t)25ULL), 1); + x26 = _br2_load((in0)+((uintptr_t)26ULL), 1); + x27 = _br2_load((in0)+((uintptr_t)27ULL), 1); + x28 = _br2_load((in0)+((uintptr_t)28ULL), 1); + x29 = _br2_load((in0)+((uintptr_t)29ULL), 1); + x30 = _br2_load((in0)+((uintptr_t)30ULL), 1); + x31 = _br2_load((in0)+((uintptr_t)31ULL), 1); + x32 = _br2_load((in0)+((uintptr_t)32ULL), 1); + x33 = _br2_load((in0)+((uintptr_t)33ULL), 1); + x34 = _br2_load((in0)+((uintptr_t)34ULL), 1); + x35 = _br2_load((in0)+((uintptr_t)35ULL), 1); + x36 = _br2_load((in0)+((uintptr_t)36ULL), 1); + x37 = _br2_load((in0)+((uintptr_t)37ULL), 1); + x38 = _br2_load((in0)+((uintptr_t)38ULL), 1); + x39 = _br2_load((in0)+((uintptr_t)39ULL), 1); + x40 = _br2_load((in0)+((uintptr_t)40ULL), 1); + x41 = _br2_load((in0)+((uintptr_t)41ULL), 1); + x42 = _br2_load((in0)+((uintptr_t)42ULL), 1); + x43 = _br2_load((in0)+((uintptr_t)43ULL), 1); + x44 = _br2_load((in0)+((uintptr_t)44ULL), 1); + x45 = _br2_load((in0)+((uintptr_t)45ULL), 1); + x46 = _br2_load((in0)+((uintptr_t)46ULL), 1); + x47 = _br2_load((in0)+((uintptr_t)47ULL), 1); + /*skip*/ + /*skip*/ + x48 = (x47)<<((uintptr_t)56ULL); + x49 = (x46)<<((uintptr_t)48ULL); + x50 = (x45)<<((uintptr_t)40ULL); + x51 = (x44)<<((uintptr_t)32ULL); + x52 = (x43)<<((uintptr_t)24ULL); + x53 = (x42)<<((uintptr_t)16ULL); + x54 = (x41)<<((uintptr_t)8ULL); + x55 = x40; + x56 = (x39)<<((uintptr_t)56ULL); + x57 = (x38)<<((uintptr_t)48ULL); + x58 = (x37)<<((uintptr_t)40ULL); + x59 = (x36)<<((uintptr_t)32ULL); + x60 = (x35)<<((uintptr_t)24ULL); + x61 = (x34)<<((uintptr_t)16ULL); + x62 = (x33)<<((uintptr_t)8ULL); + x63 = x32; + x64 = (x31)<<((uintptr_t)56ULL); + x65 = (x30)<<((uintptr_t)48ULL); + x66 = (x29)<<((uintptr_t)40ULL); + x67 = (x28)<<((uintptr_t)32ULL); + x68 = (x27)<<((uintptr_t)24ULL); + x69 = (x26)<<((uintptr_t)16ULL); + x70 = (x25)<<((uintptr_t)8ULL); + x71 = x24; + x72 = (x23)<<((uintptr_t)56ULL); + x73 = (x22)<<((uintptr_t)48ULL); + x74 = (x21)<<((uintptr_t)40ULL); + x75 = (x20)<<((uintptr_t)32ULL); + x76 = (x19)<<((uintptr_t)24ULL); + x77 = (x18)<<((uintptr_t)16ULL); + x78 = (x17)<<((uintptr_t)8ULL); + x79 = x16; + x80 = (x15)<<((uintptr_t)56ULL); + x81 = (x14)<<((uintptr_t)48ULL); + x82 = (x13)<<((uintptr_t)40ULL); + x83 = (x12)<<((uintptr_t)32ULL); + x84 = (x11)<<((uintptr_t)24ULL); + x85 = (x10)<<((uintptr_t)16ULL); + x86 = (x9)<<((uintptr_t)8ULL); + x87 = x8; + x88 = (x7)<<((uintptr_t)56ULL); + x89 = (x6)<<((uintptr_t)48ULL); + x90 = (x5)<<((uintptr_t)40ULL); + x91 = (x4)<<((uintptr_t)32ULL); + x92 = (x3)<<((uintptr_t)24ULL); + x93 = (x2)<<((uintptr_t)16ULL); + x94 = (x1)<<((uintptr_t)8ULL); + x95 = x0; + x96 = (x94)+(x95); + x97 = (x93)+(x96); + x98 = (x92)+(x97); + x99 = (x91)+(x98); + x100 = (x90)+(x99); + x101 = (x89)+(x100); + x102 = (x88)+(x101); + x103 = (x86)+(x87); + x104 = (x85)+(x103); + x105 = (x84)+(x104); + x106 = (x83)+(x105); + x107 = (x82)+(x106); + x108 = (x81)+(x107); + x109 = (x80)+(x108); + x110 = (x78)+(x79); + x111 = (x77)+(x110); + x112 = (x76)+(x111); + x113 = (x75)+(x112); + x114 = (x74)+(x113); + x115 = (x73)+(x114); + x116 = (x72)+(x115); + x117 = (x70)+(x71); + x118 = (x69)+(x117); + x119 = (x68)+(x118); + x120 = (x67)+(x119); + x121 = (x66)+(x120); + x122 = (x65)+(x121); + x123 = (x64)+(x122); + x124 = (x62)+(x63); + x125 = (x61)+(x124); + x126 = (x60)+(x125); + x127 = (x59)+(x126); + x128 = (x58)+(x127); + x129 = (x57)+(x128); + x130 = (x56)+(x129); + x131 = (x54)+(x55); + x132 = (x53)+(x131); + x133 = (x52)+(x132); + x134 = (x51)+(x133); + x135 = (x50)+(x134); + x136 = (x49)+(x135); + x137 = (x48)+(x136); + x138 = x102; + x139 = x109; + x140 = x116; + x141 = x123; + x142 = x130; + x143 = x137; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x138, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x139, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x140, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x141, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x142, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x143, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_from_bytes(uint64_t out1[6], const uint8_t arg1[48]) { + internal_fiat_p384_scalar_from_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p384_scalar_set_one(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5; + /*skip*/ + x0 = (uintptr_t)1374695839762142861ULL; + x1 = (uintptr_t)12098342389602539653ULL; + x2 = (uintptr_t)4079331616924160544ULL; + x3 = (uintptr_t)0ULL; + x4 = (uintptr_t)0ULL; + x5 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x5, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_set_one(uint64_t out1[6]) { + internal_fiat_p384_scalar_set_one((uintptr_t)out1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p384_scalar_msat(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6; + /*skip*/ + x0 = (uintptr_t)17072048233947408755ULL; + x1 = (uintptr_t)6348401684107011962ULL; + x2 = (uintptr_t)14367412456785391071ULL; + x3 = (uintptr_t)18446744073709551615ULL; + x4 = (uintptr_t)18446744073709551615ULL; + x5 = (uintptr_t)18446744073709551615ULL; + x6 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)48ULL), x6, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_msat(uint64_t out1[7]) { + internal_fiat_p384_scalar_msat((uintptr_t)out1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0xffffffffffffffff] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffffffffffff] + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +uintptr_t internal_fiat_p384_scalar_divstep(uintptr_t out1, uintptr_t out2, uintptr_t out3, uintptr_t out4, uintptr_t in0, uintptr_t in1, uintptr_t in2, uintptr_t in3, uintptr_t in4) { + uintptr_t x26, x28, x29, x30, x32, x33, x35, x36, x38, x39, x41, x42, x44, x45, x47, x48, x50, x51, x0, x54, x1, x56, x2, x58, x3, x60, x4, x62, x5, x64, x6, x53, x66, x7, x67, x55, x69, x8, x70, x57, x72, x9, x73, x59, x75, x10, x76, x61, x78, x11, x79, x63, x81, x12, x82, x65, x84, x13, x85, x87, x88, x90, x91, x93, x94, x96, x97, x99, x100, x102, x103, x106, x107, x108, x110, x111, x112, x113, x115, x116, x117, x118, x120, x121, x122, x123, x125, x126, x127, x128, x130, x133, x134, x135, x137, x138, x139, x140, x142, x143, x144, x145, x147, x148, x149, x150, x152, x153, x154, x155, x157, x158, x131, x159, x19, x18, x17, x16, x15, x14, x167, x165, x168, x170, x171, x164, x172, x174, x175, x163, x176, x178, x179, x162, x180, x182, x183, x161, x184, x186, x187, x166, x190, x169, x191, x192, x194, x195, x173, x196, x197, x199, x200, x177, x201, x202, x204, x205, x181, x206, x207, x209, x210, x185, x211, x188, x189, x213, x20, x214, x193, x216, x21, x217, x198, x219, x22, x220, x203, x222, x23, x223, x208, x225, x24, x226, x27, x212, x228, x25, x229, x232, x233, x235, x236, x238, x239, x241, x242, x244, x245, x247, x248, x250, x251, x234, x68, x254, x71, x255, x237, x256, x258, x259, x74, x260, x240, x261, x263, x264, x77, x265, x243, x266, x268, x269, x80, x270, x246, x271, x273, x274, x83, x275, x249, x276, x278, x279, x86, x280, x252, x89, x282, x283, x92, x285, x286, x95, x288, x289, x98, x291, x292, x101, x294, x295, x231, x104, x297, x298, x284, x215, x301, x218, x302, x287, x303, x305, x306, x221, x307, x290, x308, x310, x311, x224, x312, x293, x313, x315, x316, x227, x317, x296, x318, x320, x321, x230, x322, x299, x323, x325, x328, x329, x330, x332, x333, x334, x335, x337, x338, x339, x340, x342, x343, x344, x345, x347, x348, x349, x350, x352, x353, x326, x354, x31, x253, x257, x262, x267, x272, x277, x281, x105, x364, x132, x365, x109, x367, x136, x368, x114, x370, x141, x371, x119, x373, x146, x374, x124, x376, x151, x377, x160, x129, x379, x156, x380, x300, x382, x327, x383, x304, x385, x331, x386, x309, x388, x336, x389, x314, x391, x341, x392, x319, x394, x346, x395, x355, x324, x397, x351, x398, x356, x34, x37, x40, x43, x46, x49, x52, x357, x358, x359, x360, x361, x362, x363, x366, x369, x372, x375, x378, x381, x384, x387, x390, x393, x396, x399, out0, x400, x401, x402, x403, x404, x405, x406, x407, x408, x409, x410, x411, x412, x413, x414, x415, x416, x417, x418, x419, x420, x421, x422, x423, x424, x425, x426; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)48ULL), sizeof(uintptr_t)); + /*skip*/ + x7 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x8 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x9 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x10 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x11 = _br2_load((in2)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x12 = _br2_load((in2)+((uintptr_t)40ULL), sizeof(uintptr_t)); + x13 = _br2_load((in2)+((uintptr_t)48ULL), sizeof(uintptr_t)); + /*skip*/ + x14 = _br2_load((in3)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x15 = _br2_load((in3)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x16 = _br2_load((in3)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x17 = _br2_load((in3)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x18 = _br2_load((in3)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x19 = _br2_load((in3)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + x20 = _br2_load((in4)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x21 = _br2_load((in4)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x22 = _br2_load((in4)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x23 = _br2_load((in4)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x24 = _br2_load((in4)+((uintptr_t)32ULL), sizeof(uintptr_t)); + x25 = _br2_load((in4)+((uintptr_t)40ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x26 = ((in0)^((uintptr_t)18446744073709551615ULL))+((uintptr_t)1ULL); + x27 = ((x26)>>((uintptr_t)63ULL))&((x7)&((uintptr_t)1ULL)); + x28 = ((in0)^((uintptr_t)18446744073709551615ULL))+((uintptr_t)1ULL); + x29 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x30 = (x29)^((uintptr_t)18446744073709551615ULL); + x31 = ((x28)&(x29))|((in0)&(x30)); + x32 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x33 = (x32)^((uintptr_t)18446744073709551615ULL); + x34 = ((x7)&(x32))|((x0)&(x33)); + x35 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x36 = (x35)^((uintptr_t)18446744073709551615ULL); + x37 = ((x8)&(x35))|((x1)&(x36)); + x38 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x39 = (x38)^((uintptr_t)18446744073709551615ULL); + x40 = ((x9)&(x38))|((x2)&(x39)); + x41 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x42 = (x41)^((uintptr_t)18446744073709551615ULL); + x43 = ((x10)&(x41))|((x3)&(x42)); + x44 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x45 = (x44)^((uintptr_t)18446744073709551615ULL); + x46 = ((x11)&(x44))|((x4)&(x45)); + x47 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x48 = (x47)^((uintptr_t)18446744073709551615ULL); + x49 = ((x12)&(x47))|((x5)&(x48)); + x50 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x51 = (x50)^((uintptr_t)18446744073709551615ULL); + x52 = ((x13)&(x50))|((x6)&(x51)); + x53 = ((uintptr_t)1ULL)+((x0)^((uintptr_t)18446744073709551615ULL)); + x54 = (uintptr_t)((x53)<((uintptr_t)1ULL)); + x55 = (x54)+((x1)^((uintptr_t)18446744073709551615ULL)); + x56 = (uintptr_t)((x55)<((x1)^((uintptr_t)18446744073709551615ULL))); + x57 = (x56)+((x2)^((uintptr_t)18446744073709551615ULL)); + x58 = (uintptr_t)((x57)<((x2)^((uintptr_t)18446744073709551615ULL))); + x59 = (x58)+((x3)^((uintptr_t)18446744073709551615ULL)); + x60 = (uintptr_t)((x59)<((x3)^((uintptr_t)18446744073709551615ULL))); + x61 = (x60)+((x4)^((uintptr_t)18446744073709551615ULL)); + x62 = (uintptr_t)((x61)<((x4)^((uintptr_t)18446744073709551615ULL))); + x63 = (x62)+((x5)^((uintptr_t)18446744073709551615ULL)); + x64 = (uintptr_t)((x63)<((x5)^((uintptr_t)18446744073709551615ULL))); + x65 = (x64)+((x6)^((uintptr_t)18446744073709551615ULL)); + x66 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x67 = (x66)^((uintptr_t)18446744073709551615ULL); + x68 = ((x53)&(x66))|((x7)&(x67)); + x69 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x70 = (x69)^((uintptr_t)18446744073709551615ULL); + x71 = ((x55)&(x69))|((x8)&(x70)); + x72 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x73 = (x72)^((uintptr_t)18446744073709551615ULL); + x74 = ((x57)&(x72))|((x9)&(x73)); + x75 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x76 = (x75)^((uintptr_t)18446744073709551615ULL); + x77 = ((x59)&(x75))|((x10)&(x76)); + x78 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x79 = (x78)^((uintptr_t)18446744073709551615ULL); + x80 = ((x61)&(x78))|((x11)&(x79)); + x81 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x82 = (x81)^((uintptr_t)18446744073709551615ULL); + x83 = ((x63)&(x81))|((x12)&(x82)); + x84 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x85 = (x84)^((uintptr_t)18446744073709551615ULL); + x86 = ((x65)&(x84))|((x13)&(x85)); + x87 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x88 = (x87)^((uintptr_t)18446744073709551615ULL); + x89 = ((x20)&(x87))|((x14)&(x88)); + x90 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x91 = (x90)^((uintptr_t)18446744073709551615ULL); + x92 = ((x21)&(x90))|((x15)&(x91)); + x93 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x94 = (x93)^((uintptr_t)18446744073709551615ULL); + x95 = ((x22)&(x93))|((x16)&(x94)); + x96 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x97 = (x96)^((uintptr_t)18446744073709551615ULL); + x98 = ((x23)&(x96))|((x17)&(x97)); + x99 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x100 = (x99)^((uintptr_t)18446744073709551615ULL); + x101 = ((x24)&(x99))|((x18)&(x100)); + x102 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x103 = (x102)^((uintptr_t)18446744073709551615ULL); + x104 = ((x25)&(x102))|((x19)&(x103)); + x105 = (x89)+(x89); + x106 = (uintptr_t)((x105)<(x89)); + x107 = (x106)+(x92); + x108 = (uintptr_t)((x107)<(x92)); + x109 = (x107)+(x92); + x110 = (uintptr_t)((x109)<(x92)); + x111 = (x108)+(x110); + x112 = (x111)+(x95); + x113 = (uintptr_t)((x112)<(x95)); + x114 = (x112)+(x95); + x115 = (uintptr_t)((x114)<(x95)); + x116 = (x113)+(x115); + x117 = (x116)+(x98); + x118 = (uintptr_t)((x117)<(x98)); + x119 = (x117)+(x98); + x120 = (uintptr_t)((x119)<(x98)); + x121 = (x118)+(x120); + x122 = (x121)+(x101); + x123 = (uintptr_t)((x122)<(x101)); + x124 = (x122)+(x101); + x125 = (uintptr_t)((x124)<(x101)); + x126 = (x123)+(x125); + x127 = (x126)+(x104); + x128 = (uintptr_t)((x127)<(x104)); + x129 = (x127)+(x104); + x130 = (uintptr_t)((x129)<(x104)); + x131 = (x128)+(x130); + x132 = (x105)-((uintptr_t)17072048233947408755ULL); + x133 = (uintptr_t)((x105)<(x132)); + x134 = (x109)-((uintptr_t)6348401684107011962ULL); + x135 = (uintptr_t)((x109)<(x134)); + x136 = (x134)-(x133); + x137 = (uintptr_t)((x134)<(x136)); + x138 = (x135)+(x137); + x139 = (x114)-((uintptr_t)14367412456785391071ULL); + x140 = (uintptr_t)((x114)<(x139)); + x141 = (x139)-(x138); + x142 = (uintptr_t)((x139)<(x141)); + x143 = (x140)+(x142); + x144 = (x119)-((uintptr_t)18446744073709551615ULL); + x145 = (uintptr_t)((x119)<(x144)); + x146 = (x144)-(x143); + x147 = (uintptr_t)((x144)<(x146)); + x148 = (x145)+(x147); + x149 = (x124)-((uintptr_t)18446744073709551615ULL); + x150 = (uintptr_t)((x124)<(x149)); + x151 = (x149)-(x148); + x152 = (uintptr_t)((x149)<(x151)); + x153 = (x150)+(x152); + x154 = (x129)-((uintptr_t)18446744073709551615ULL); + x155 = (uintptr_t)((x129)<(x154)); + x156 = (x154)-(x153); + x157 = (uintptr_t)((x154)<(x156)); + x158 = (x155)+(x157); + x159 = (x131)-(x158); + x160 = (uintptr_t)((x131)<(x159)); + x161 = x19; + x162 = x18; + x163 = x17; + x164 = x16; + x165 = x15; + x166 = x14; + x167 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x166))); + x168 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x165))); + x169 = (((uintptr_t)0ULL)-(x165))-(x167); + x170 = (uintptr_t)((((uintptr_t)0ULL)-(x165))<(x169)); + x171 = (x168)+(x170); + x172 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x164))); + x173 = (((uintptr_t)0ULL)-(x164))-(x171); + x174 = (uintptr_t)((((uintptr_t)0ULL)-(x164))<(x173)); + x175 = (x172)+(x174); + x176 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x163))); + x177 = (((uintptr_t)0ULL)-(x163))-(x175); + x178 = (uintptr_t)((((uintptr_t)0ULL)-(x163))<(x177)); + x179 = (x176)+(x178); + x180 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x162))); + x181 = (((uintptr_t)0ULL)-(x162))-(x179); + x182 = (uintptr_t)((((uintptr_t)0ULL)-(x162))<(x181)); + x183 = (x180)+(x182); + x184 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x161))); + x185 = (((uintptr_t)0ULL)-(x161))-(x183); + x186 = (uintptr_t)((((uintptr_t)0ULL)-(x161))<(x185)); + x187 = (x184)+(x186); + x188 = ((uintptr_t)-1ULL)+((uintptr_t)((x187)==((uintptr_t)0ULL))); + x189 = (((uintptr_t)0ULL)-(x166))+((x188)&((uintptr_t)17072048233947408755ULL)); + x190 = (uintptr_t)((x189)<(((uintptr_t)0ULL)-(x166))); + x191 = (x190)+(x169); + x192 = (uintptr_t)((x191)<(x169)); + x193 = (x191)+((x188)&((uintptr_t)6348401684107011962ULL)); + x194 = (uintptr_t)((x193)<((x188)&((uintptr_t)6348401684107011962ULL))); + x195 = (x192)+(x194); + x196 = (x195)+(x173); + x197 = (uintptr_t)((x196)<(x173)); + x198 = (x196)+((x188)&((uintptr_t)14367412456785391071ULL)); + x199 = (uintptr_t)((x198)<((x188)&((uintptr_t)14367412456785391071ULL))); + x200 = (x197)+(x199); + x201 = (x200)+(x177); + x202 = (uintptr_t)((x201)<(x177)); + x203 = (x201)+(x188); + x204 = (uintptr_t)((x203)<(x188)); + x205 = (x202)+(x204); + x206 = (x205)+(x181); + x207 = (uintptr_t)((x206)<(x181)); + x208 = (x206)+(x188); + x209 = (uintptr_t)((x208)<(x188)); + x210 = (x207)+(x209); + x211 = (x210)+(x185); + x212 = (x211)+(x188); + x213 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x214 = (x213)^((uintptr_t)18446744073709551615ULL); + x215 = ((x189)&(x213))|((x20)&(x214)); + x216 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x217 = (x216)^((uintptr_t)18446744073709551615ULL); + x218 = ((x193)&(x216))|((x21)&(x217)); + x219 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x220 = (x219)^((uintptr_t)18446744073709551615ULL); + x221 = ((x198)&(x219))|((x22)&(x220)); + x222 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x223 = (x222)^((uintptr_t)18446744073709551615ULL); + x224 = ((x203)&(x222))|((x23)&(x223)); + x225 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x226 = (x225)^((uintptr_t)18446744073709551615ULL); + x227 = ((x208)&(x225))|((x24)&(x226)); + x228 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL))); + x229 = (x228)^((uintptr_t)18446744073709551615ULL); + x230 = ((x212)&(x228))|((x25)&(x229)); + x231 = (x68)&((uintptr_t)1ULL); + x232 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x233 = (x232)^((uintptr_t)18446744073709551615ULL); + x234 = ((x34)&(x232))|(((uintptr_t)0ULL)&(x233)); + x235 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x236 = (x235)^((uintptr_t)18446744073709551615ULL); + x237 = ((x37)&(x235))|(((uintptr_t)0ULL)&(x236)); + x238 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x239 = (x238)^((uintptr_t)18446744073709551615ULL); + x240 = ((x40)&(x238))|(((uintptr_t)0ULL)&(x239)); + x241 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x242 = (x241)^((uintptr_t)18446744073709551615ULL); + x243 = ((x43)&(x241))|(((uintptr_t)0ULL)&(x242)); + x244 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x245 = (x244)^((uintptr_t)18446744073709551615ULL); + x246 = ((x46)&(x244))|(((uintptr_t)0ULL)&(x245)); + x247 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x248 = (x247)^((uintptr_t)18446744073709551615ULL); + x249 = ((x49)&(x247))|(((uintptr_t)0ULL)&(x248)); + x250 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x251 = (x250)^((uintptr_t)18446744073709551615ULL); + x252 = ((x52)&(x250))|(((uintptr_t)0ULL)&(x251)); + x253 = (x68)+(x234); + x254 = (uintptr_t)((x253)<(x68)); + x255 = (x254)+(x71); + x256 = (uintptr_t)((x255)<(x71)); + x257 = (x255)+(x237); + x258 = (uintptr_t)((x257)<(x237)); + x259 = (x256)+(x258); + x260 = (x259)+(x74); + x261 = (uintptr_t)((x260)<(x74)); + x262 = (x260)+(x240); + x263 = (uintptr_t)((x262)<(x240)); + x264 = (x261)+(x263); + x265 = (x264)+(x77); + x266 = (uintptr_t)((x265)<(x77)); + x267 = (x265)+(x243); + x268 = (uintptr_t)((x267)<(x243)); + x269 = (x266)+(x268); + x270 = (x269)+(x80); + x271 = (uintptr_t)((x270)<(x80)); + x272 = (x270)+(x246); + x273 = (uintptr_t)((x272)<(x246)); + x274 = (x271)+(x273); + x275 = (x274)+(x83); + x276 = (uintptr_t)((x275)<(x83)); + x277 = (x275)+(x249); + x278 = (uintptr_t)((x277)<(x249)); + x279 = (x276)+(x278); + x280 = (x279)+(x86); + x281 = (x280)+(x252); + x282 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x283 = (x282)^((uintptr_t)18446744073709551615ULL); + x284 = ((x89)&(x282))|(((uintptr_t)0ULL)&(x283)); + x285 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x286 = (x285)^((uintptr_t)18446744073709551615ULL); + x287 = ((x92)&(x285))|(((uintptr_t)0ULL)&(x286)); + x288 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x289 = (x288)^((uintptr_t)18446744073709551615ULL); + x290 = ((x95)&(x288))|(((uintptr_t)0ULL)&(x289)); + x291 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x292 = (x291)^((uintptr_t)18446744073709551615ULL); + x293 = ((x98)&(x291))|(((uintptr_t)0ULL)&(x292)); + x294 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x295 = (x294)^((uintptr_t)18446744073709551615ULL); + x296 = ((x101)&(x294))|(((uintptr_t)0ULL)&(x295)); + x297 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL))); + x298 = (x297)^((uintptr_t)18446744073709551615ULL); + x299 = ((x104)&(x297))|(((uintptr_t)0ULL)&(x298)); + x300 = (x215)+(x284); + x301 = (uintptr_t)((x300)<(x215)); + x302 = (x301)+(x218); + x303 = (uintptr_t)((x302)<(x218)); + x304 = (x302)+(x287); + x305 = (uintptr_t)((x304)<(x287)); + x306 = (x303)+(x305); + x307 = (x306)+(x221); + x308 = (uintptr_t)((x307)<(x221)); + x309 = (x307)+(x290); + x310 = (uintptr_t)((x309)<(x290)); + x311 = (x308)+(x310); + x312 = (x311)+(x224); + x313 = (uintptr_t)((x312)<(x224)); + x314 = (x312)+(x293); + x315 = (uintptr_t)((x314)<(x293)); + x316 = (x313)+(x315); + x317 = (x316)+(x227); + x318 = (uintptr_t)((x317)<(x227)); + x319 = (x317)+(x296); + x320 = (uintptr_t)((x319)<(x296)); + x321 = (x318)+(x320); + x322 = (x321)+(x230); + x323 = (uintptr_t)((x322)<(x230)); + x324 = (x322)+(x299); + x325 = (uintptr_t)((x324)<(x299)); + x326 = (x323)+(x325); + x327 = (x300)-((uintptr_t)17072048233947408755ULL); + x328 = (uintptr_t)((x300)<(x327)); + x329 = (x304)-((uintptr_t)6348401684107011962ULL); + x330 = (uintptr_t)((x304)<(x329)); + x331 = (x329)-(x328); + x332 = (uintptr_t)((x329)<(x331)); + x333 = (x330)+(x332); + x334 = (x309)-((uintptr_t)14367412456785391071ULL); + x335 = (uintptr_t)((x309)<(x334)); + x336 = (x334)-(x333); + x337 = (uintptr_t)((x334)<(x336)); + x338 = (x335)+(x337); + x339 = (x314)-((uintptr_t)18446744073709551615ULL); + x340 = (uintptr_t)((x314)<(x339)); + x341 = (x339)-(x338); + x342 = (uintptr_t)((x339)<(x341)); + x343 = (x340)+(x342); + x344 = (x319)-((uintptr_t)18446744073709551615ULL); + x345 = (uintptr_t)((x319)<(x344)); + x346 = (x344)-(x343); + x347 = (uintptr_t)((x344)<(x346)); + x348 = (x345)+(x347); + x349 = (x324)-((uintptr_t)18446744073709551615ULL); + x350 = (uintptr_t)((x324)<(x349)); + x351 = (x349)-(x348); + x352 = (uintptr_t)((x349)<(x351)); + x353 = (x350)+(x352); + x354 = (x326)-(x353); + x355 = (uintptr_t)((x326)<(x354)); + x356 = (x31)+((uintptr_t)1ULL); + x357 = ((x253)>>((uintptr_t)1ULL))|((x257)<<((uintptr_t)63ULL)); + x358 = ((x257)>>((uintptr_t)1ULL))|((x262)<<((uintptr_t)63ULL)); + x359 = ((x262)>>((uintptr_t)1ULL))|((x267)<<((uintptr_t)63ULL)); + x360 = ((x267)>>((uintptr_t)1ULL))|((x272)<<((uintptr_t)63ULL)); + x361 = ((x272)>>((uintptr_t)1ULL))|((x277)<<((uintptr_t)63ULL)); + x362 = ((x277)>>((uintptr_t)1ULL))|((x281)<<((uintptr_t)63ULL)); + x363 = ((x281)&((uintptr_t)9223372036854775808ULL))|((x281)>>((uintptr_t)1ULL)); + x364 = ((uintptr_t)-1ULL)+((uintptr_t)((x160)==((uintptr_t)0ULL))); + x365 = (x364)^((uintptr_t)18446744073709551615ULL); + x366 = ((x105)&(x364))|((x132)&(x365)); + x367 = ((uintptr_t)-1ULL)+((uintptr_t)((x160)==((uintptr_t)0ULL))); + x368 = (x367)^((uintptr_t)18446744073709551615ULL); + x369 = ((x109)&(x367))|((x136)&(x368)); + x370 = ((uintptr_t)-1ULL)+((uintptr_t)((x160)==((uintptr_t)0ULL))); + x371 = (x370)^((uintptr_t)18446744073709551615ULL); + x372 = ((x114)&(x370))|((x141)&(x371)); + x373 = ((uintptr_t)-1ULL)+((uintptr_t)((x160)==((uintptr_t)0ULL))); + x374 = (x373)^((uintptr_t)18446744073709551615ULL); + x375 = ((x119)&(x373))|((x146)&(x374)); + x376 = ((uintptr_t)-1ULL)+((uintptr_t)((x160)==((uintptr_t)0ULL))); + x377 = (x376)^((uintptr_t)18446744073709551615ULL); + x378 = ((x124)&(x376))|((x151)&(x377)); + x379 = ((uintptr_t)-1ULL)+((uintptr_t)((x160)==((uintptr_t)0ULL))); + x380 = (x379)^((uintptr_t)18446744073709551615ULL); + x381 = ((x129)&(x379))|((x156)&(x380)); + x382 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x383 = (x382)^((uintptr_t)18446744073709551615ULL); + x384 = ((x300)&(x382))|((x327)&(x383)); + x385 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x386 = (x385)^((uintptr_t)18446744073709551615ULL); + x387 = ((x304)&(x385))|((x331)&(x386)); + x388 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x389 = (x388)^((uintptr_t)18446744073709551615ULL); + x390 = ((x309)&(x388))|((x336)&(x389)); + x391 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x392 = (x391)^((uintptr_t)18446744073709551615ULL); + x393 = ((x314)&(x391))|((x341)&(x392)); + x394 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x395 = (x394)^((uintptr_t)18446744073709551615ULL); + x396 = ((x319)&(x394))|((x346)&(x395)); + x397 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x398 = (x397)^((uintptr_t)18446744073709551615ULL); + x399 = ((x324)&(x397))|((x351)&(x398)); + x400 = x356; + x401 = x34; + x402 = x37; + x403 = x40; + x404 = x43; + x405 = x46; + x406 = x49; + x407 = x52; + /*skip*/ + x408 = x357; + x409 = x358; + x410 = x359; + x411 = x360; + x412 = x361; + x413 = x362; + x414 = x363; + /*skip*/ + x415 = x366; + x416 = x369; + x417 = x372; + x418 = x375; + x419 = x378; + x420 = x381; + /*skip*/ + x421 = x384; + x422 = x387; + x423 = x390; + x424 = x393; + x425 = x396; + x426 = x399; + /*skip*/ + out0 = x400; + _br2_store((out1)+((uintptr_t)0ULL), x401, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)8ULL), x402, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)16ULL), x403, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)24ULL), x404, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)32ULL), x405, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)40ULL), x406, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)48ULL), x407, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out2)+((uintptr_t)0ULL), x408, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)8ULL), x409, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)16ULL), x410, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)24ULL), x411, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)32ULL), x412, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)40ULL), x413, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)48ULL), x414, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out3)+((uintptr_t)0ULL), x415, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)8ULL), x416, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)16ULL), x417, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)24ULL), x418, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)32ULL), x419, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)40ULL), x420, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out4)+((uintptr_t)0ULL), x421, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)8ULL), x422, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)16ULL), x423, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)24ULL), x424, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)32ULL), x425, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)40ULL), x426, sizeof(uintptr_t)); + /*skip*/ + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_divstep(uint64_t* out1, uint64_t out2[7], uint64_t out3[7], uint64_t out4[6], uint64_t out5[6], uint64_t arg1, const uint64_t arg2[7], const uint64_t arg3[7], const uint64_t arg4[6], const uint64_t arg5[6]) { + *out1 = (uint64_t)internal_fiat_p384_scalar_divstep((uintptr_t)out2, (uintptr_t)out3, (uintptr_t)out4, (uintptr_t)out5, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3, (uintptr_t)arg4, (uintptr_t)arg5); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_p384_scalar_divstep_precomp(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5; + /*skip*/ + x0 = (uintptr_t)5285144453441674090ULL; + x1 = (uintptr_t)4366894402606481645ULL; + x2 = (uintptr_t)15765705359852683842ULL; + x3 = (uintptr_t)13090610234927136310ULL; + x4 = (uintptr_t)10941390875981617523ULL; + x5 = (uintptr_t)3143533399796454076ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)40ULL), x5, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_p384_scalar_divstep_precomp(uint64_t out1[6]) { + internal_fiat_p384_scalar_divstep_precomp((uintptr_t)out1); +} diff --git a/fiat-bedrock2/src/secp256k1_scalar_32.c b/fiat-bedrock2/src/secp256k1_scalar_32.c new file mode 100644 index 0000000000..4026e8d2b0 --- /dev/null +++ b/fiat-bedrock2/src/secp256k1_scalar_32.c @@ -0,0 +1,5871 @@ +/* Autogenerated: 'src/ExtractionOCaml/bedrock2_word_by_word_montgomery' --lang bedrock2 --static --no-wide-int --widen-carry --widen-bytes --split-multiret --no-select --no-field-element-typedefs secp256k1_scalar 32 '2^256 - 432420386565659656852420866394968145599' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: secp256k1_scalar */ +/* machine_wordsize = 32 (from "32") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141 (from "2^256 - 432420386565659656852420866394968145599") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +#include + +// We use memcpy to work around -fstrict-aliasing. +// A plain memcpy is enough on clang 10, but not on gcc 10, which fails +// to infer the bounds on an integer loaded by memcpy. +// Adding a range mask after memcpy in turn makes slower code in clang. +// Loading individual bytes, shifting them together, and or-ing is fast +// on clang and sometimes on GCC, but other times GCC inlines individual +// byte operations without reconstructing wider accesses. +// The little-endian idiom below seems fast in gcc 9+ and clang 10. +static __attribute__((always_inline)) inline uintptr_t +_br2_load(uintptr_t a, uintptr_t sz) { + switch (sz) { + case 1: { uint8_t r = 0; memcpy(&r, (void*)a, 1); return r; } + case 2: { uint16_t r = 0; memcpy(&r, (void*)a, 2); return r; } + case 4: { uint32_t r = 0; memcpy(&r, (void*)a, 4); return r; } + case 8: { uint64_t r = 0; memcpy(&r, (void*)a, 8); return r; } + default: __builtin_unreachable(); + } +} + +static __attribute__((always_inline)) inline void +_br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) { + memcpy((void*)a, &v, sz); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_mul(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x1, x2, x3, x4, x5, x6, x7, x0, x23, x36, x39, x41, x37, x42, x34, x43, x45, x46, x35, x47, x32, x48, x50, x51, x33, x52, x30, x53, x55, x56, x31, x57, x28, x58, x60, x61, x29, x62, x26, x63, x65, x66, x27, x67, x24, x68, x70, x71, x25, x73, x86, x89, x91, x87, x92, x84, x93, x95, x96, x85, x97, x82, x98, x100, x101, x83, x102, x80, x103, x105, x106, x81, x107, x78, x108, x110, x111, x79, x112, x76, x113, x115, x116, x77, x117, x74, x118, x120, x121, x75, x88, x123, x38, x124, x40, x125, x90, x126, x128, x129, x44, x130, x94, x131, x133, x134, x49, x135, x99, x136, x138, x139, x54, x140, x104, x141, x143, x144, x59, x145, x109, x146, x148, x149, x64, x150, x114, x151, x153, x154, x69, x155, x119, x156, x158, x159, x72, x160, x122, x161, x163, x16, x177, x180, x182, x178, x183, x175, x184, x186, x187, x176, x188, x173, x189, x191, x192, x174, x193, x171, x194, x196, x197, x172, x198, x169, x199, x201, x202, x170, x203, x167, x204, x206, x207, x168, x208, x165, x209, x211, x212, x166, x179, x127, x215, x132, x216, x181, x217, x219, x220, x137, x221, x185, x222, x224, x225, x142, x226, x190, x227, x229, x230, x147, x231, x195, x232, x234, x235, x152, x236, x200, x237, x239, x240, x157, x241, x205, x242, x244, x245, x162, x246, x210, x247, x249, x250, x164, x251, x213, x252, x254, x256, x269, x272, x274, x270, x275, x267, x276, x278, x279, x268, x280, x265, x281, x283, x284, x266, x285, x263, x286, x288, x289, x264, x290, x261, x291, x293, x294, x262, x295, x259, x296, x298, x299, x260, x300, x257, x301, x303, x304, x258, x271, x306, x214, x307, x218, x308, x273, x309, x311, x312, x223, x313, x277, x314, x316, x317, x228, x318, x282, x319, x321, x322, x233, x323, x287, x324, x326, x327, x238, x328, x292, x329, x331, x332, x243, x333, x297, x334, x336, x337, x248, x338, x302, x339, x341, x342, x253, x343, x305, x344, x346, x347, x255, x17, x361, x364, x366, x362, x367, x359, x368, x370, x371, x360, x372, x357, x373, x375, x376, x358, x377, x355, x378, x380, x381, x356, x382, x353, x383, x385, x386, x354, x387, x351, x388, x390, x391, x352, x392, x349, x393, x395, x396, x350, x363, x310, x399, x315, x400, x365, x401, x403, x404, x320, x405, x369, x406, x408, x409, x325, x410, x374, x411, x413, x414, x330, x415, x379, x416, x418, x419, x335, x420, x384, x421, x423, x424, x340, x425, x389, x426, x428, x429, x345, x430, x394, x431, x433, x434, x348, x435, x397, x436, x438, x440, x453, x456, x458, x454, x459, x451, x460, x462, x463, x452, x464, x449, x465, x467, x468, x450, x469, x447, x470, x472, x473, x448, x474, x445, x475, x477, x478, x446, x479, x443, x480, x482, x483, x444, x484, x441, x485, x487, x488, x442, x455, x490, x398, x491, x402, x492, x457, x493, x495, x496, x407, x497, x461, x498, x500, x501, x412, x502, x466, x503, x505, x506, x417, x507, x471, x508, x510, x511, x422, x512, x476, x513, x515, x516, x427, x517, x481, x518, x520, x521, x432, x522, x486, x523, x525, x526, x437, x527, x489, x528, x530, x531, x439, x18, x545, x548, x550, x546, x551, x543, x552, x554, x555, x544, x556, x541, x557, x559, x560, x542, x561, x539, x562, x564, x565, x540, x566, x537, x567, x569, x570, x538, x571, x535, x572, x574, x575, x536, x576, x533, x577, x579, x580, x534, x547, x494, x583, x499, x584, x549, x585, x587, x588, x504, x589, x553, x590, x592, x593, x509, x594, x558, x595, x597, x598, x514, x599, x563, x600, x602, x603, x519, x604, x568, x605, x607, x608, x524, x609, x573, x610, x612, x613, x529, x614, x578, x615, x617, x618, x532, x619, x581, x620, x622, x624, x637, x640, x642, x638, x643, x635, x644, x646, x647, x636, x648, x633, x649, x651, x652, x634, x653, x631, x654, x656, x657, x632, x658, x629, x659, x661, x662, x630, x663, x627, x664, x666, x667, x628, x668, x625, x669, x671, x672, x626, x639, x674, x582, x675, x586, x676, x641, x677, x679, x680, x591, x681, x645, x682, x684, x685, x596, x686, x650, x687, x689, x690, x601, x691, x655, x692, x694, x695, x606, x696, x660, x697, x699, x700, x611, x701, x665, x702, x704, x705, x616, x706, x670, x707, x709, x710, x621, x711, x673, x712, x714, x715, x623, x19, x729, x732, x734, x730, x735, x727, x736, x738, x739, x728, x740, x725, x741, x743, x744, x726, x745, x723, x746, x748, x749, x724, x750, x721, x751, x753, x754, x722, x755, x719, x756, x758, x759, x720, x760, x717, x761, x763, x764, x718, x731, x678, x767, x683, x768, x733, x769, x771, x772, x688, x773, x737, x774, x776, x777, x693, x778, x742, x779, x781, x782, x698, x783, x747, x784, x786, x787, x703, x788, x752, x789, x791, x792, x708, x793, x757, x794, x796, x797, x713, x798, x762, x799, x801, x802, x716, x803, x765, x804, x806, x808, x821, x824, x826, x822, x827, x819, x828, x830, x831, x820, x832, x817, x833, x835, x836, x818, x837, x815, x838, x840, x841, x816, x842, x813, x843, x845, x846, x814, x847, x811, x848, x850, x851, x812, x852, x809, x853, x855, x856, x810, x823, x858, x766, x859, x770, x860, x825, x861, x863, x864, x775, x865, x829, x866, x868, x869, x780, x870, x834, x871, x873, x874, x785, x875, x839, x876, x878, x879, x790, x880, x844, x881, x883, x884, x795, x885, x849, x886, x888, x889, x800, x890, x854, x891, x893, x894, x805, x895, x857, x896, x898, x899, x807, x20, x913, x916, x918, x914, x919, x911, x920, x922, x923, x912, x924, x909, x925, x927, x928, x910, x929, x907, x930, x932, x933, x908, x934, x905, x935, x937, x938, x906, x939, x903, x940, x942, x943, x904, x944, x901, x945, x947, x948, x902, x915, x862, x951, x867, x952, x917, x953, x955, x956, x872, x957, x921, x958, x960, x961, x877, x962, x926, x963, x965, x966, x882, x967, x931, x968, x970, x971, x887, x972, x936, x973, x975, x976, x892, x977, x941, x978, x980, x981, x897, x982, x946, x983, x985, x986, x900, x987, x949, x988, x990, x992, x1005, x1008, x1010, x1006, x1011, x1003, x1012, x1014, x1015, x1004, x1016, x1001, x1017, x1019, x1020, x1002, x1021, x999, x1022, x1024, x1025, x1000, x1026, x997, x1027, x1029, x1030, x998, x1031, x995, x1032, x1034, x1035, x996, x1036, x993, x1037, x1039, x1040, x994, x1007, x1042, x950, x1043, x954, x1044, x1009, x1045, x1047, x1048, x959, x1049, x1013, x1050, x1052, x1053, x964, x1054, x1018, x1055, x1057, x1058, x969, x1059, x1023, x1060, x1062, x1063, x974, x1064, x1028, x1065, x1067, x1068, x979, x1069, x1033, x1070, x1072, x1073, x984, x1074, x1038, x1075, x1077, x1078, x989, x1079, x1041, x1080, x1082, x1083, x991, x21, x1097, x1100, x1102, x1098, x1103, x1095, x1104, x1106, x1107, x1096, x1108, x1093, x1109, x1111, x1112, x1094, x1113, x1091, x1114, x1116, x1117, x1092, x1118, x1089, x1119, x1121, x1122, x1090, x1123, x1087, x1124, x1126, x1127, x1088, x1128, x1085, x1129, x1131, x1132, x1086, x1099, x1046, x1135, x1051, x1136, x1101, x1137, x1139, x1140, x1056, x1141, x1105, x1142, x1144, x1145, x1061, x1146, x1110, x1147, x1149, x1150, x1066, x1151, x1115, x1152, x1154, x1155, x1071, x1156, x1120, x1157, x1159, x1160, x1076, x1161, x1125, x1162, x1164, x1165, x1081, x1166, x1130, x1167, x1169, x1170, x1084, x1171, x1133, x1172, x1174, x1176, x1189, x1192, x1194, x1190, x1195, x1187, x1196, x1198, x1199, x1188, x1200, x1185, x1201, x1203, x1204, x1186, x1205, x1183, x1206, x1208, x1209, x1184, x1210, x1181, x1211, x1213, x1214, x1182, x1215, x1179, x1216, x1218, x1219, x1180, x1220, x1177, x1221, x1223, x1224, x1178, x1191, x1226, x1134, x1227, x1138, x1228, x1193, x1229, x1231, x1232, x1143, x1233, x1197, x1234, x1236, x1237, x1148, x1238, x1202, x1239, x1241, x1242, x1153, x1243, x1207, x1244, x1246, x1247, x1158, x1248, x1212, x1249, x1251, x1252, x1163, x1253, x1217, x1254, x1256, x1257, x1168, x1258, x1222, x1259, x1261, x1262, x1173, x1263, x1225, x1264, x1266, x1267, x1175, x15, x14, x13, x12, x11, x10, x9, x22, x8, x1281, x1284, x1286, x1282, x1287, x1279, x1288, x1290, x1291, x1280, x1292, x1277, x1293, x1295, x1296, x1278, x1297, x1275, x1298, x1300, x1301, x1276, x1302, x1273, x1303, x1305, x1306, x1274, x1307, x1271, x1308, x1310, x1311, x1272, x1312, x1269, x1313, x1315, x1316, x1270, x1283, x1230, x1319, x1235, x1320, x1285, x1321, x1323, x1324, x1240, x1325, x1289, x1326, x1328, x1329, x1245, x1330, x1294, x1331, x1333, x1334, x1250, x1335, x1299, x1336, x1338, x1339, x1255, x1340, x1304, x1341, x1343, x1344, x1260, x1345, x1309, x1346, x1348, x1349, x1265, x1350, x1314, x1351, x1353, x1354, x1268, x1355, x1317, x1356, x1358, x1360, x1373, x1376, x1378, x1374, x1379, x1371, x1380, x1382, x1383, x1372, x1384, x1369, x1385, x1387, x1388, x1370, x1389, x1367, x1390, x1392, x1393, x1368, x1394, x1365, x1395, x1397, x1398, x1366, x1399, x1363, x1400, x1402, x1403, x1364, x1404, x1361, x1405, x1407, x1408, x1362, x1375, x1410, x1318, x1411, x1322, x1412, x1377, x1413, x1415, x1416, x1327, x1417, x1381, x1418, x1420, x1421, x1332, x1422, x1386, x1423, x1425, x1426, x1337, x1427, x1391, x1428, x1430, x1431, x1342, x1432, x1396, x1433, x1435, x1436, x1347, x1437, x1401, x1438, x1440, x1441, x1352, x1442, x1406, x1443, x1445, x1446, x1357, x1447, x1409, x1448, x1450, x1451, x1359, x1454, x1455, x1456, x1458, x1459, x1460, x1461, x1463, x1464, x1465, x1466, x1468, x1469, x1470, x1471, x1473, x1474, x1475, x1476, x1478, x1479, x1480, x1481, x1483, x1484, x1485, x1486, x1488, x1489, x1452, x1490, x1414, x1492, x1453, x1493, x1419, x1495, x1457, x1496, x1424, x1498, x1462, x1499, x1429, x1501, x1467, x1502, x1434, x1504, x1472, x1505, x1439, x1507, x1477, x1508, x1444, x1510, x1482, x1511, x1491, x1449, x1513, x1487, x1514, x1494, x1497, x1500, x1503, x1506, x1509, x1512, x1515, x1516, x1517, x1518, x1519, x1520, x1521, x1522, x1523; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = x1; + x17 = x2; + x18 = x3; + x19 = x4; + x20 = x5; + x21 = x6; + x22 = x7; + x23 = x0; + x24 = (x23)*(x15); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x15))>>32 : ((__uint128_t)(x23)*(x15))>>64); + x26 = (x23)*(x14); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x14))>>32 : ((__uint128_t)(x23)*(x14))>>64); + x28 = (x23)*(x13); + x29 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x13))>>32 : ((__uint128_t)(x23)*(x13))>>64); + x30 = (x23)*(x12); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x12))>>32 : ((__uint128_t)(x23)*(x12))>>64); + x32 = (x23)*(x11); + x33 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x11))>>32 : ((__uint128_t)(x23)*(x11))>>64); + x34 = (x23)*(x10); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x10))>>32 : ((__uint128_t)(x23)*(x10))>>64); + x36 = (x23)*(x9); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x9))>>32 : ((__uint128_t)(x23)*(x9))>>64); + x38 = (x23)*(x8); + x39 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x8))>>32 : ((__uint128_t)(x23)*(x8))>>64); + x40 = (x39)+(x36); + x41 = (uintptr_t)((x40)<(x39)); + x42 = (x41)+(x37); + x43 = (uintptr_t)((x42)<(x37)); + x44 = (x42)+(x34); + x45 = (uintptr_t)((x44)<(x34)); + x46 = (x43)+(x45); + x47 = (x46)+(x35); + x48 = (uintptr_t)((x47)<(x35)); + x49 = (x47)+(x32); + x50 = (uintptr_t)((x49)<(x32)); + x51 = (x48)+(x50); + x52 = (x51)+(x33); + x53 = (uintptr_t)((x52)<(x33)); + x54 = (x52)+(x30); + x55 = (uintptr_t)((x54)<(x30)); + x56 = (x53)+(x55); + x57 = (x56)+(x31); + x58 = (uintptr_t)((x57)<(x31)); + x59 = (x57)+(x28); + x60 = (uintptr_t)((x59)<(x28)); + x61 = (x58)+(x60); + x62 = (x61)+(x29); + x63 = (uintptr_t)((x62)<(x29)); + x64 = (x62)+(x26); + x65 = (uintptr_t)((x64)<(x26)); + x66 = (x63)+(x65); + x67 = (x66)+(x27); + x68 = (uintptr_t)((x67)<(x27)); + x69 = (x67)+(x24); + x70 = (uintptr_t)((x69)<(x24)); + x71 = (x68)+(x70); + x72 = (x71)+(x25); + x73 = (x38)*((uintptr_t)1435021631ULL); + x74 = (x73)*((uintptr_t)4294967295ULL); + x75 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)4294967295ULL))>>64); + x76 = (x73)*((uintptr_t)4294967295ULL); + x77 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)4294967295ULL))>>64); + x78 = (x73)*((uintptr_t)4294967295ULL); + x79 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)4294967295ULL))>>64); + x80 = (x73)*((uintptr_t)4294967294ULL); + x81 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)4294967294ULL))>>64); + x82 = (x73)*((uintptr_t)3132021990ULL); + x83 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)3132021990ULL))>>64); + x84 = (x73)*((uintptr_t)2940772411ULL); + x85 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)2940772411ULL))>>64); + x86 = (x73)*((uintptr_t)3218235020ULL); + x87 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)3218235020ULL))>>64); + x88 = (x73)*((uintptr_t)3493216577ULL); + x89 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x73)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x73)*((uintptr_t)3493216577ULL))>>64); + x90 = (x89)+(x86); + x91 = (uintptr_t)((x90)<(x89)); + x92 = (x91)+(x87); + x93 = (uintptr_t)((x92)<(x87)); + x94 = (x92)+(x84); + x95 = (uintptr_t)((x94)<(x84)); + x96 = (x93)+(x95); + x97 = (x96)+(x85); + x98 = (uintptr_t)((x97)<(x85)); + x99 = (x97)+(x82); + x100 = (uintptr_t)((x99)<(x82)); + x101 = (x98)+(x100); + x102 = (x101)+(x83); + x103 = (uintptr_t)((x102)<(x83)); + x104 = (x102)+(x80); + x105 = (uintptr_t)((x104)<(x80)); + x106 = (x103)+(x105); + x107 = (x106)+(x81); + x108 = (uintptr_t)((x107)<(x81)); + x109 = (x107)+(x78); + x110 = (uintptr_t)((x109)<(x78)); + x111 = (x108)+(x110); + x112 = (x111)+(x79); + x113 = (uintptr_t)((x112)<(x79)); + x114 = (x112)+(x76); + x115 = (uintptr_t)((x114)<(x76)); + x116 = (x113)+(x115); + x117 = (x116)+(x77); + x118 = (uintptr_t)((x117)<(x77)); + x119 = (x117)+(x74); + x120 = (uintptr_t)((x119)<(x74)); + x121 = (x118)+(x120); + x122 = (x121)+(x75); + x123 = (x38)+(x88); + x124 = (uintptr_t)((x123)<(x38)); + x125 = (x124)+(x40); + x126 = (uintptr_t)((x125)<(x40)); + x127 = (x125)+(x90); + x128 = (uintptr_t)((x127)<(x90)); + x129 = (x126)+(x128); + x130 = (x129)+(x44); + x131 = (uintptr_t)((x130)<(x44)); + x132 = (x130)+(x94); + x133 = (uintptr_t)((x132)<(x94)); + x134 = (x131)+(x133); + x135 = (x134)+(x49); + x136 = (uintptr_t)((x135)<(x49)); + x137 = (x135)+(x99); + x138 = (uintptr_t)((x137)<(x99)); + x139 = (x136)+(x138); + x140 = (x139)+(x54); + x141 = (uintptr_t)((x140)<(x54)); + x142 = (x140)+(x104); + x143 = (uintptr_t)((x142)<(x104)); + x144 = (x141)+(x143); + x145 = (x144)+(x59); + x146 = (uintptr_t)((x145)<(x59)); + x147 = (x145)+(x109); + x148 = (uintptr_t)((x147)<(x109)); + x149 = (x146)+(x148); + x150 = (x149)+(x64); + x151 = (uintptr_t)((x150)<(x64)); + x152 = (x150)+(x114); + x153 = (uintptr_t)((x152)<(x114)); + x154 = (x151)+(x153); + x155 = (x154)+(x69); + x156 = (uintptr_t)((x155)<(x69)); + x157 = (x155)+(x119); + x158 = (uintptr_t)((x157)<(x119)); + x159 = (x156)+(x158); + x160 = (x159)+(x72); + x161 = (uintptr_t)((x160)<(x72)); + x162 = (x160)+(x122); + x163 = (uintptr_t)((x162)<(x122)); + x164 = (x161)+(x163); + x165 = (x16)*(x15); + x166 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x15))>>32 : ((__uint128_t)(x16)*(x15))>>64); + x167 = (x16)*(x14); + x168 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x14))>>32 : ((__uint128_t)(x16)*(x14))>>64); + x169 = (x16)*(x13); + x170 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x13))>>32 : ((__uint128_t)(x16)*(x13))>>64); + x171 = (x16)*(x12); + x172 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x12))>>32 : ((__uint128_t)(x16)*(x12))>>64); + x173 = (x16)*(x11); + x174 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x11))>>32 : ((__uint128_t)(x16)*(x11))>>64); + x175 = (x16)*(x10); + x176 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x10))>>32 : ((__uint128_t)(x16)*(x10))>>64); + x177 = (x16)*(x9); + x178 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x9))>>32 : ((__uint128_t)(x16)*(x9))>>64); + x179 = (x16)*(x8); + x180 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x8))>>32 : ((__uint128_t)(x16)*(x8))>>64); + x181 = (x180)+(x177); + x182 = (uintptr_t)((x181)<(x180)); + x183 = (x182)+(x178); + x184 = (uintptr_t)((x183)<(x178)); + x185 = (x183)+(x175); + x186 = (uintptr_t)((x185)<(x175)); + x187 = (x184)+(x186); + x188 = (x187)+(x176); + x189 = (uintptr_t)((x188)<(x176)); + x190 = (x188)+(x173); + x191 = (uintptr_t)((x190)<(x173)); + x192 = (x189)+(x191); + x193 = (x192)+(x174); + x194 = (uintptr_t)((x193)<(x174)); + x195 = (x193)+(x171); + x196 = (uintptr_t)((x195)<(x171)); + x197 = (x194)+(x196); + x198 = (x197)+(x172); + x199 = (uintptr_t)((x198)<(x172)); + x200 = (x198)+(x169); + x201 = (uintptr_t)((x200)<(x169)); + x202 = (x199)+(x201); + x203 = (x202)+(x170); + x204 = (uintptr_t)((x203)<(x170)); + x205 = (x203)+(x167); + x206 = (uintptr_t)((x205)<(x167)); + x207 = (x204)+(x206); + x208 = (x207)+(x168); + x209 = (uintptr_t)((x208)<(x168)); + x210 = (x208)+(x165); + x211 = (uintptr_t)((x210)<(x165)); + x212 = (x209)+(x211); + x213 = (x212)+(x166); + x214 = (x127)+(x179); + x215 = (uintptr_t)((x214)<(x127)); + x216 = (x215)+(x132); + x217 = (uintptr_t)((x216)<(x132)); + x218 = (x216)+(x181); + x219 = (uintptr_t)((x218)<(x181)); + x220 = (x217)+(x219); + x221 = (x220)+(x137); + x222 = (uintptr_t)((x221)<(x137)); + x223 = (x221)+(x185); + x224 = (uintptr_t)((x223)<(x185)); + x225 = (x222)+(x224); + x226 = (x225)+(x142); + x227 = (uintptr_t)((x226)<(x142)); + x228 = (x226)+(x190); + x229 = (uintptr_t)((x228)<(x190)); + x230 = (x227)+(x229); + x231 = (x230)+(x147); + x232 = (uintptr_t)((x231)<(x147)); + x233 = (x231)+(x195); + x234 = (uintptr_t)((x233)<(x195)); + x235 = (x232)+(x234); + x236 = (x235)+(x152); + x237 = (uintptr_t)((x236)<(x152)); + x238 = (x236)+(x200); + x239 = (uintptr_t)((x238)<(x200)); + x240 = (x237)+(x239); + x241 = (x240)+(x157); + x242 = (uintptr_t)((x241)<(x157)); + x243 = (x241)+(x205); + x244 = (uintptr_t)((x243)<(x205)); + x245 = (x242)+(x244); + x246 = (x245)+(x162); + x247 = (uintptr_t)((x246)<(x162)); + x248 = (x246)+(x210); + x249 = (uintptr_t)((x248)<(x210)); + x250 = (x247)+(x249); + x251 = (x250)+(x164); + x252 = (uintptr_t)((x251)<(x164)); + x253 = (x251)+(x213); + x254 = (uintptr_t)((x253)<(x213)); + x255 = (x252)+(x254); + x256 = (x214)*((uintptr_t)1435021631ULL); + x257 = (x256)*((uintptr_t)4294967295ULL); + x258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x256)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x256)*((uintptr_t)4294967295ULL))>>64); + x259 = (x256)*((uintptr_t)4294967295ULL); + x260 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x256)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x256)*((uintptr_t)4294967295ULL))>>64); + x261 = (x256)*((uintptr_t)4294967295ULL); + x262 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x256)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x256)*((uintptr_t)4294967295ULL))>>64); + x263 = (x256)*((uintptr_t)4294967294ULL); + x264 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x256)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x256)*((uintptr_t)4294967294ULL))>>64); + x265 = (x256)*((uintptr_t)3132021990ULL); + x266 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x256)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x256)*((uintptr_t)3132021990ULL))>>64); + x267 = (x256)*((uintptr_t)2940772411ULL); + x268 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x256)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x256)*((uintptr_t)2940772411ULL))>>64); + x269 = (x256)*((uintptr_t)3218235020ULL); + x270 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x256)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x256)*((uintptr_t)3218235020ULL))>>64); + x271 = (x256)*((uintptr_t)3493216577ULL); + x272 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x256)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x256)*((uintptr_t)3493216577ULL))>>64); + x273 = (x272)+(x269); + x274 = (uintptr_t)((x273)<(x272)); + x275 = (x274)+(x270); + x276 = (uintptr_t)((x275)<(x270)); + x277 = (x275)+(x267); + x278 = (uintptr_t)((x277)<(x267)); + x279 = (x276)+(x278); + x280 = (x279)+(x268); + x281 = (uintptr_t)((x280)<(x268)); + x282 = (x280)+(x265); + x283 = (uintptr_t)((x282)<(x265)); + x284 = (x281)+(x283); + x285 = (x284)+(x266); + x286 = (uintptr_t)((x285)<(x266)); + x287 = (x285)+(x263); + x288 = (uintptr_t)((x287)<(x263)); + x289 = (x286)+(x288); + x290 = (x289)+(x264); + x291 = (uintptr_t)((x290)<(x264)); + x292 = (x290)+(x261); + x293 = (uintptr_t)((x292)<(x261)); + x294 = (x291)+(x293); + x295 = (x294)+(x262); + x296 = (uintptr_t)((x295)<(x262)); + x297 = (x295)+(x259); + x298 = (uintptr_t)((x297)<(x259)); + x299 = (x296)+(x298); + x300 = (x299)+(x260); + x301 = (uintptr_t)((x300)<(x260)); + x302 = (x300)+(x257); + x303 = (uintptr_t)((x302)<(x257)); + x304 = (x301)+(x303); + x305 = (x304)+(x258); + x306 = (x214)+(x271); + x307 = (uintptr_t)((x306)<(x214)); + x308 = (x307)+(x218); + x309 = (uintptr_t)((x308)<(x218)); + x310 = (x308)+(x273); + x311 = (uintptr_t)((x310)<(x273)); + x312 = (x309)+(x311); + x313 = (x312)+(x223); + x314 = (uintptr_t)((x313)<(x223)); + x315 = (x313)+(x277); + x316 = (uintptr_t)((x315)<(x277)); + x317 = (x314)+(x316); + x318 = (x317)+(x228); + x319 = (uintptr_t)((x318)<(x228)); + x320 = (x318)+(x282); + x321 = (uintptr_t)((x320)<(x282)); + x322 = (x319)+(x321); + x323 = (x322)+(x233); + x324 = (uintptr_t)((x323)<(x233)); + x325 = (x323)+(x287); + x326 = (uintptr_t)((x325)<(x287)); + x327 = (x324)+(x326); + x328 = (x327)+(x238); + x329 = (uintptr_t)((x328)<(x238)); + x330 = (x328)+(x292); + x331 = (uintptr_t)((x330)<(x292)); + x332 = (x329)+(x331); + x333 = (x332)+(x243); + x334 = (uintptr_t)((x333)<(x243)); + x335 = (x333)+(x297); + x336 = (uintptr_t)((x335)<(x297)); + x337 = (x334)+(x336); + x338 = (x337)+(x248); + x339 = (uintptr_t)((x338)<(x248)); + x340 = (x338)+(x302); + x341 = (uintptr_t)((x340)<(x302)); + x342 = (x339)+(x341); + x343 = (x342)+(x253); + x344 = (uintptr_t)((x343)<(x253)); + x345 = (x343)+(x305); + x346 = (uintptr_t)((x345)<(x305)); + x347 = (x344)+(x346); + x348 = (x347)+(x255); + x349 = (x17)*(x15); + x350 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x15))>>32 : ((__uint128_t)(x17)*(x15))>>64); + x351 = (x17)*(x14); + x352 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x14))>>32 : ((__uint128_t)(x17)*(x14))>>64); + x353 = (x17)*(x13); + x354 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x13))>>32 : ((__uint128_t)(x17)*(x13))>>64); + x355 = (x17)*(x12); + x356 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x12))>>32 : ((__uint128_t)(x17)*(x12))>>64); + x357 = (x17)*(x11); + x358 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x11))>>32 : ((__uint128_t)(x17)*(x11))>>64); + x359 = (x17)*(x10); + x360 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x10))>>32 : ((__uint128_t)(x17)*(x10))>>64); + x361 = (x17)*(x9); + x362 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x9))>>32 : ((__uint128_t)(x17)*(x9))>>64); + x363 = (x17)*(x8); + x364 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x8))>>32 : ((__uint128_t)(x17)*(x8))>>64); + x365 = (x364)+(x361); + x366 = (uintptr_t)((x365)<(x364)); + x367 = (x366)+(x362); + x368 = (uintptr_t)((x367)<(x362)); + x369 = (x367)+(x359); + x370 = (uintptr_t)((x369)<(x359)); + x371 = (x368)+(x370); + x372 = (x371)+(x360); + x373 = (uintptr_t)((x372)<(x360)); + x374 = (x372)+(x357); + x375 = (uintptr_t)((x374)<(x357)); + x376 = (x373)+(x375); + x377 = (x376)+(x358); + x378 = (uintptr_t)((x377)<(x358)); + x379 = (x377)+(x355); + x380 = (uintptr_t)((x379)<(x355)); + x381 = (x378)+(x380); + x382 = (x381)+(x356); + x383 = (uintptr_t)((x382)<(x356)); + x384 = (x382)+(x353); + x385 = (uintptr_t)((x384)<(x353)); + x386 = (x383)+(x385); + x387 = (x386)+(x354); + x388 = (uintptr_t)((x387)<(x354)); + x389 = (x387)+(x351); + x390 = (uintptr_t)((x389)<(x351)); + x391 = (x388)+(x390); + x392 = (x391)+(x352); + x393 = (uintptr_t)((x392)<(x352)); + x394 = (x392)+(x349); + x395 = (uintptr_t)((x394)<(x349)); + x396 = (x393)+(x395); + x397 = (x396)+(x350); + x398 = (x310)+(x363); + x399 = (uintptr_t)((x398)<(x310)); + x400 = (x399)+(x315); + x401 = (uintptr_t)((x400)<(x315)); + x402 = (x400)+(x365); + x403 = (uintptr_t)((x402)<(x365)); + x404 = (x401)+(x403); + x405 = (x404)+(x320); + x406 = (uintptr_t)((x405)<(x320)); + x407 = (x405)+(x369); + x408 = (uintptr_t)((x407)<(x369)); + x409 = (x406)+(x408); + x410 = (x409)+(x325); + x411 = (uintptr_t)((x410)<(x325)); + x412 = (x410)+(x374); + x413 = (uintptr_t)((x412)<(x374)); + x414 = (x411)+(x413); + x415 = (x414)+(x330); + x416 = (uintptr_t)((x415)<(x330)); + x417 = (x415)+(x379); + x418 = (uintptr_t)((x417)<(x379)); + x419 = (x416)+(x418); + x420 = (x419)+(x335); + x421 = (uintptr_t)((x420)<(x335)); + x422 = (x420)+(x384); + x423 = (uintptr_t)((x422)<(x384)); + x424 = (x421)+(x423); + x425 = (x424)+(x340); + x426 = (uintptr_t)((x425)<(x340)); + x427 = (x425)+(x389); + x428 = (uintptr_t)((x427)<(x389)); + x429 = (x426)+(x428); + x430 = (x429)+(x345); + x431 = (uintptr_t)((x430)<(x345)); + x432 = (x430)+(x394); + x433 = (uintptr_t)((x432)<(x394)); + x434 = (x431)+(x433); + x435 = (x434)+(x348); + x436 = (uintptr_t)((x435)<(x348)); + x437 = (x435)+(x397); + x438 = (uintptr_t)((x437)<(x397)); + x439 = (x436)+(x438); + x440 = (x398)*((uintptr_t)1435021631ULL); + x441 = (x440)*((uintptr_t)4294967295ULL); + x442 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x440)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x440)*((uintptr_t)4294967295ULL))>>64); + x443 = (x440)*((uintptr_t)4294967295ULL); + x444 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x440)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x440)*((uintptr_t)4294967295ULL))>>64); + x445 = (x440)*((uintptr_t)4294967295ULL); + x446 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x440)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x440)*((uintptr_t)4294967295ULL))>>64); + x447 = (x440)*((uintptr_t)4294967294ULL); + x448 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x440)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x440)*((uintptr_t)4294967294ULL))>>64); + x449 = (x440)*((uintptr_t)3132021990ULL); + x450 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x440)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x440)*((uintptr_t)3132021990ULL))>>64); + x451 = (x440)*((uintptr_t)2940772411ULL); + x452 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x440)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x440)*((uintptr_t)2940772411ULL))>>64); + x453 = (x440)*((uintptr_t)3218235020ULL); + x454 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x440)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x440)*((uintptr_t)3218235020ULL))>>64); + x455 = (x440)*((uintptr_t)3493216577ULL); + x456 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x440)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x440)*((uintptr_t)3493216577ULL))>>64); + x457 = (x456)+(x453); + x458 = (uintptr_t)((x457)<(x456)); + x459 = (x458)+(x454); + x460 = (uintptr_t)((x459)<(x454)); + x461 = (x459)+(x451); + x462 = (uintptr_t)((x461)<(x451)); + x463 = (x460)+(x462); + x464 = (x463)+(x452); + x465 = (uintptr_t)((x464)<(x452)); + x466 = (x464)+(x449); + x467 = (uintptr_t)((x466)<(x449)); + x468 = (x465)+(x467); + x469 = (x468)+(x450); + x470 = (uintptr_t)((x469)<(x450)); + x471 = (x469)+(x447); + x472 = (uintptr_t)((x471)<(x447)); + x473 = (x470)+(x472); + x474 = (x473)+(x448); + x475 = (uintptr_t)((x474)<(x448)); + x476 = (x474)+(x445); + x477 = (uintptr_t)((x476)<(x445)); + x478 = (x475)+(x477); + x479 = (x478)+(x446); + x480 = (uintptr_t)((x479)<(x446)); + x481 = (x479)+(x443); + x482 = (uintptr_t)((x481)<(x443)); + x483 = (x480)+(x482); + x484 = (x483)+(x444); + x485 = (uintptr_t)((x484)<(x444)); + x486 = (x484)+(x441); + x487 = (uintptr_t)((x486)<(x441)); + x488 = (x485)+(x487); + x489 = (x488)+(x442); + x490 = (x398)+(x455); + x491 = (uintptr_t)((x490)<(x398)); + x492 = (x491)+(x402); + x493 = (uintptr_t)((x492)<(x402)); + x494 = (x492)+(x457); + x495 = (uintptr_t)((x494)<(x457)); + x496 = (x493)+(x495); + x497 = (x496)+(x407); + x498 = (uintptr_t)((x497)<(x407)); + x499 = (x497)+(x461); + x500 = (uintptr_t)((x499)<(x461)); + x501 = (x498)+(x500); + x502 = (x501)+(x412); + x503 = (uintptr_t)((x502)<(x412)); + x504 = (x502)+(x466); + x505 = (uintptr_t)((x504)<(x466)); + x506 = (x503)+(x505); + x507 = (x506)+(x417); + x508 = (uintptr_t)((x507)<(x417)); + x509 = (x507)+(x471); + x510 = (uintptr_t)((x509)<(x471)); + x511 = (x508)+(x510); + x512 = (x511)+(x422); + x513 = (uintptr_t)((x512)<(x422)); + x514 = (x512)+(x476); + x515 = (uintptr_t)((x514)<(x476)); + x516 = (x513)+(x515); + x517 = (x516)+(x427); + x518 = (uintptr_t)((x517)<(x427)); + x519 = (x517)+(x481); + x520 = (uintptr_t)((x519)<(x481)); + x521 = (x518)+(x520); + x522 = (x521)+(x432); + x523 = (uintptr_t)((x522)<(x432)); + x524 = (x522)+(x486); + x525 = (uintptr_t)((x524)<(x486)); + x526 = (x523)+(x525); + x527 = (x526)+(x437); + x528 = (uintptr_t)((x527)<(x437)); + x529 = (x527)+(x489); + x530 = (uintptr_t)((x529)<(x489)); + x531 = (x528)+(x530); + x532 = (x531)+(x439); + x533 = (x18)*(x15); + x534 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x15))>>32 : ((__uint128_t)(x18)*(x15))>>64); + x535 = (x18)*(x14); + x536 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x14))>>32 : ((__uint128_t)(x18)*(x14))>>64); + x537 = (x18)*(x13); + x538 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x13))>>32 : ((__uint128_t)(x18)*(x13))>>64); + x539 = (x18)*(x12); + x540 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x12))>>32 : ((__uint128_t)(x18)*(x12))>>64); + x541 = (x18)*(x11); + x542 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x11))>>32 : ((__uint128_t)(x18)*(x11))>>64); + x543 = (x18)*(x10); + x544 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x10))>>32 : ((__uint128_t)(x18)*(x10))>>64); + x545 = (x18)*(x9); + x546 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x9))>>32 : ((__uint128_t)(x18)*(x9))>>64); + x547 = (x18)*(x8); + x548 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x8))>>32 : ((__uint128_t)(x18)*(x8))>>64); + x549 = (x548)+(x545); + x550 = (uintptr_t)((x549)<(x548)); + x551 = (x550)+(x546); + x552 = (uintptr_t)((x551)<(x546)); + x553 = (x551)+(x543); + x554 = (uintptr_t)((x553)<(x543)); + x555 = (x552)+(x554); + x556 = (x555)+(x544); + x557 = (uintptr_t)((x556)<(x544)); + x558 = (x556)+(x541); + x559 = (uintptr_t)((x558)<(x541)); + x560 = (x557)+(x559); + x561 = (x560)+(x542); + x562 = (uintptr_t)((x561)<(x542)); + x563 = (x561)+(x539); + x564 = (uintptr_t)((x563)<(x539)); + x565 = (x562)+(x564); + x566 = (x565)+(x540); + x567 = (uintptr_t)((x566)<(x540)); + x568 = (x566)+(x537); + x569 = (uintptr_t)((x568)<(x537)); + x570 = (x567)+(x569); + x571 = (x570)+(x538); + x572 = (uintptr_t)((x571)<(x538)); + x573 = (x571)+(x535); + x574 = (uintptr_t)((x573)<(x535)); + x575 = (x572)+(x574); + x576 = (x575)+(x536); + x577 = (uintptr_t)((x576)<(x536)); + x578 = (x576)+(x533); + x579 = (uintptr_t)((x578)<(x533)); + x580 = (x577)+(x579); + x581 = (x580)+(x534); + x582 = (x494)+(x547); + x583 = (uintptr_t)((x582)<(x494)); + x584 = (x583)+(x499); + x585 = (uintptr_t)((x584)<(x499)); + x586 = (x584)+(x549); + x587 = (uintptr_t)((x586)<(x549)); + x588 = (x585)+(x587); + x589 = (x588)+(x504); + x590 = (uintptr_t)((x589)<(x504)); + x591 = (x589)+(x553); + x592 = (uintptr_t)((x591)<(x553)); + x593 = (x590)+(x592); + x594 = (x593)+(x509); + x595 = (uintptr_t)((x594)<(x509)); + x596 = (x594)+(x558); + x597 = (uintptr_t)((x596)<(x558)); + x598 = (x595)+(x597); + x599 = (x598)+(x514); + x600 = (uintptr_t)((x599)<(x514)); + x601 = (x599)+(x563); + x602 = (uintptr_t)((x601)<(x563)); + x603 = (x600)+(x602); + x604 = (x603)+(x519); + x605 = (uintptr_t)((x604)<(x519)); + x606 = (x604)+(x568); + x607 = (uintptr_t)((x606)<(x568)); + x608 = (x605)+(x607); + x609 = (x608)+(x524); + x610 = (uintptr_t)((x609)<(x524)); + x611 = (x609)+(x573); + x612 = (uintptr_t)((x611)<(x573)); + x613 = (x610)+(x612); + x614 = (x613)+(x529); + x615 = (uintptr_t)((x614)<(x529)); + x616 = (x614)+(x578); + x617 = (uintptr_t)((x616)<(x578)); + x618 = (x615)+(x617); + x619 = (x618)+(x532); + x620 = (uintptr_t)((x619)<(x532)); + x621 = (x619)+(x581); + x622 = (uintptr_t)((x621)<(x581)); + x623 = (x620)+(x622); + x624 = (x582)*((uintptr_t)1435021631ULL); + x625 = (x624)*((uintptr_t)4294967295ULL); + x626 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x624)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x624)*((uintptr_t)4294967295ULL))>>64); + x627 = (x624)*((uintptr_t)4294967295ULL); + x628 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x624)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x624)*((uintptr_t)4294967295ULL))>>64); + x629 = (x624)*((uintptr_t)4294967295ULL); + x630 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x624)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x624)*((uintptr_t)4294967295ULL))>>64); + x631 = (x624)*((uintptr_t)4294967294ULL); + x632 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x624)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x624)*((uintptr_t)4294967294ULL))>>64); + x633 = (x624)*((uintptr_t)3132021990ULL); + x634 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x624)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x624)*((uintptr_t)3132021990ULL))>>64); + x635 = (x624)*((uintptr_t)2940772411ULL); + x636 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x624)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x624)*((uintptr_t)2940772411ULL))>>64); + x637 = (x624)*((uintptr_t)3218235020ULL); + x638 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x624)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x624)*((uintptr_t)3218235020ULL))>>64); + x639 = (x624)*((uintptr_t)3493216577ULL); + x640 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x624)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x624)*((uintptr_t)3493216577ULL))>>64); + x641 = (x640)+(x637); + x642 = (uintptr_t)((x641)<(x640)); + x643 = (x642)+(x638); + x644 = (uintptr_t)((x643)<(x638)); + x645 = (x643)+(x635); + x646 = (uintptr_t)((x645)<(x635)); + x647 = (x644)+(x646); + x648 = (x647)+(x636); + x649 = (uintptr_t)((x648)<(x636)); + x650 = (x648)+(x633); + x651 = (uintptr_t)((x650)<(x633)); + x652 = (x649)+(x651); + x653 = (x652)+(x634); + x654 = (uintptr_t)((x653)<(x634)); + x655 = (x653)+(x631); + x656 = (uintptr_t)((x655)<(x631)); + x657 = (x654)+(x656); + x658 = (x657)+(x632); + x659 = (uintptr_t)((x658)<(x632)); + x660 = (x658)+(x629); + x661 = (uintptr_t)((x660)<(x629)); + x662 = (x659)+(x661); + x663 = (x662)+(x630); + x664 = (uintptr_t)((x663)<(x630)); + x665 = (x663)+(x627); + x666 = (uintptr_t)((x665)<(x627)); + x667 = (x664)+(x666); + x668 = (x667)+(x628); + x669 = (uintptr_t)((x668)<(x628)); + x670 = (x668)+(x625); + x671 = (uintptr_t)((x670)<(x625)); + x672 = (x669)+(x671); + x673 = (x672)+(x626); + x674 = (x582)+(x639); + x675 = (uintptr_t)((x674)<(x582)); + x676 = (x675)+(x586); + x677 = (uintptr_t)((x676)<(x586)); + x678 = (x676)+(x641); + x679 = (uintptr_t)((x678)<(x641)); + x680 = (x677)+(x679); + x681 = (x680)+(x591); + x682 = (uintptr_t)((x681)<(x591)); + x683 = (x681)+(x645); + x684 = (uintptr_t)((x683)<(x645)); + x685 = (x682)+(x684); + x686 = (x685)+(x596); + x687 = (uintptr_t)((x686)<(x596)); + x688 = (x686)+(x650); + x689 = (uintptr_t)((x688)<(x650)); + x690 = (x687)+(x689); + x691 = (x690)+(x601); + x692 = (uintptr_t)((x691)<(x601)); + x693 = (x691)+(x655); + x694 = (uintptr_t)((x693)<(x655)); + x695 = (x692)+(x694); + x696 = (x695)+(x606); + x697 = (uintptr_t)((x696)<(x606)); + x698 = (x696)+(x660); + x699 = (uintptr_t)((x698)<(x660)); + x700 = (x697)+(x699); + x701 = (x700)+(x611); + x702 = (uintptr_t)((x701)<(x611)); + x703 = (x701)+(x665); + x704 = (uintptr_t)((x703)<(x665)); + x705 = (x702)+(x704); + x706 = (x705)+(x616); + x707 = (uintptr_t)((x706)<(x616)); + x708 = (x706)+(x670); + x709 = (uintptr_t)((x708)<(x670)); + x710 = (x707)+(x709); + x711 = (x710)+(x621); + x712 = (uintptr_t)((x711)<(x621)); + x713 = (x711)+(x673); + x714 = (uintptr_t)((x713)<(x673)); + x715 = (x712)+(x714); + x716 = (x715)+(x623); + x717 = (x19)*(x15); + x718 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x15))>>32 : ((__uint128_t)(x19)*(x15))>>64); + x719 = (x19)*(x14); + x720 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x14))>>32 : ((__uint128_t)(x19)*(x14))>>64); + x721 = (x19)*(x13); + x722 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x13))>>32 : ((__uint128_t)(x19)*(x13))>>64); + x723 = (x19)*(x12); + x724 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x12))>>32 : ((__uint128_t)(x19)*(x12))>>64); + x725 = (x19)*(x11); + x726 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x11))>>32 : ((__uint128_t)(x19)*(x11))>>64); + x727 = (x19)*(x10); + x728 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x10))>>32 : ((__uint128_t)(x19)*(x10))>>64); + x729 = (x19)*(x9); + x730 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x9))>>32 : ((__uint128_t)(x19)*(x9))>>64); + x731 = (x19)*(x8); + x732 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x8))>>32 : ((__uint128_t)(x19)*(x8))>>64); + x733 = (x732)+(x729); + x734 = (uintptr_t)((x733)<(x732)); + x735 = (x734)+(x730); + x736 = (uintptr_t)((x735)<(x730)); + x737 = (x735)+(x727); + x738 = (uintptr_t)((x737)<(x727)); + x739 = (x736)+(x738); + x740 = (x739)+(x728); + x741 = (uintptr_t)((x740)<(x728)); + x742 = (x740)+(x725); + x743 = (uintptr_t)((x742)<(x725)); + x744 = (x741)+(x743); + x745 = (x744)+(x726); + x746 = (uintptr_t)((x745)<(x726)); + x747 = (x745)+(x723); + x748 = (uintptr_t)((x747)<(x723)); + x749 = (x746)+(x748); + x750 = (x749)+(x724); + x751 = (uintptr_t)((x750)<(x724)); + x752 = (x750)+(x721); + x753 = (uintptr_t)((x752)<(x721)); + x754 = (x751)+(x753); + x755 = (x754)+(x722); + x756 = (uintptr_t)((x755)<(x722)); + x757 = (x755)+(x719); + x758 = (uintptr_t)((x757)<(x719)); + x759 = (x756)+(x758); + x760 = (x759)+(x720); + x761 = (uintptr_t)((x760)<(x720)); + x762 = (x760)+(x717); + x763 = (uintptr_t)((x762)<(x717)); + x764 = (x761)+(x763); + x765 = (x764)+(x718); + x766 = (x678)+(x731); + x767 = (uintptr_t)((x766)<(x678)); + x768 = (x767)+(x683); + x769 = (uintptr_t)((x768)<(x683)); + x770 = (x768)+(x733); + x771 = (uintptr_t)((x770)<(x733)); + x772 = (x769)+(x771); + x773 = (x772)+(x688); + x774 = (uintptr_t)((x773)<(x688)); + x775 = (x773)+(x737); + x776 = (uintptr_t)((x775)<(x737)); + x777 = (x774)+(x776); + x778 = (x777)+(x693); + x779 = (uintptr_t)((x778)<(x693)); + x780 = (x778)+(x742); + x781 = (uintptr_t)((x780)<(x742)); + x782 = (x779)+(x781); + x783 = (x782)+(x698); + x784 = (uintptr_t)((x783)<(x698)); + x785 = (x783)+(x747); + x786 = (uintptr_t)((x785)<(x747)); + x787 = (x784)+(x786); + x788 = (x787)+(x703); + x789 = (uintptr_t)((x788)<(x703)); + x790 = (x788)+(x752); + x791 = (uintptr_t)((x790)<(x752)); + x792 = (x789)+(x791); + x793 = (x792)+(x708); + x794 = (uintptr_t)((x793)<(x708)); + x795 = (x793)+(x757); + x796 = (uintptr_t)((x795)<(x757)); + x797 = (x794)+(x796); + x798 = (x797)+(x713); + x799 = (uintptr_t)((x798)<(x713)); + x800 = (x798)+(x762); + x801 = (uintptr_t)((x800)<(x762)); + x802 = (x799)+(x801); + x803 = (x802)+(x716); + x804 = (uintptr_t)((x803)<(x716)); + x805 = (x803)+(x765); + x806 = (uintptr_t)((x805)<(x765)); + x807 = (x804)+(x806); + x808 = (x766)*((uintptr_t)1435021631ULL); + x809 = (x808)*((uintptr_t)4294967295ULL); + x810 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x808)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x808)*((uintptr_t)4294967295ULL))>>64); + x811 = (x808)*((uintptr_t)4294967295ULL); + x812 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x808)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x808)*((uintptr_t)4294967295ULL))>>64); + x813 = (x808)*((uintptr_t)4294967295ULL); + x814 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x808)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x808)*((uintptr_t)4294967295ULL))>>64); + x815 = (x808)*((uintptr_t)4294967294ULL); + x816 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x808)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x808)*((uintptr_t)4294967294ULL))>>64); + x817 = (x808)*((uintptr_t)3132021990ULL); + x818 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x808)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x808)*((uintptr_t)3132021990ULL))>>64); + x819 = (x808)*((uintptr_t)2940772411ULL); + x820 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x808)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x808)*((uintptr_t)2940772411ULL))>>64); + x821 = (x808)*((uintptr_t)3218235020ULL); + x822 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x808)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x808)*((uintptr_t)3218235020ULL))>>64); + x823 = (x808)*((uintptr_t)3493216577ULL); + x824 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x808)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x808)*((uintptr_t)3493216577ULL))>>64); + x825 = (x824)+(x821); + x826 = (uintptr_t)((x825)<(x824)); + x827 = (x826)+(x822); + x828 = (uintptr_t)((x827)<(x822)); + x829 = (x827)+(x819); + x830 = (uintptr_t)((x829)<(x819)); + x831 = (x828)+(x830); + x832 = (x831)+(x820); + x833 = (uintptr_t)((x832)<(x820)); + x834 = (x832)+(x817); + x835 = (uintptr_t)((x834)<(x817)); + x836 = (x833)+(x835); + x837 = (x836)+(x818); + x838 = (uintptr_t)((x837)<(x818)); + x839 = (x837)+(x815); + x840 = (uintptr_t)((x839)<(x815)); + x841 = (x838)+(x840); + x842 = (x841)+(x816); + x843 = (uintptr_t)((x842)<(x816)); + x844 = (x842)+(x813); + x845 = (uintptr_t)((x844)<(x813)); + x846 = (x843)+(x845); + x847 = (x846)+(x814); + x848 = (uintptr_t)((x847)<(x814)); + x849 = (x847)+(x811); + x850 = (uintptr_t)((x849)<(x811)); + x851 = (x848)+(x850); + x852 = (x851)+(x812); + x853 = (uintptr_t)((x852)<(x812)); + x854 = (x852)+(x809); + x855 = (uintptr_t)((x854)<(x809)); + x856 = (x853)+(x855); + x857 = (x856)+(x810); + x858 = (x766)+(x823); + x859 = (uintptr_t)((x858)<(x766)); + x860 = (x859)+(x770); + x861 = (uintptr_t)((x860)<(x770)); + x862 = (x860)+(x825); + x863 = (uintptr_t)((x862)<(x825)); + x864 = (x861)+(x863); + x865 = (x864)+(x775); + x866 = (uintptr_t)((x865)<(x775)); + x867 = (x865)+(x829); + x868 = (uintptr_t)((x867)<(x829)); + x869 = (x866)+(x868); + x870 = (x869)+(x780); + x871 = (uintptr_t)((x870)<(x780)); + x872 = (x870)+(x834); + x873 = (uintptr_t)((x872)<(x834)); + x874 = (x871)+(x873); + x875 = (x874)+(x785); + x876 = (uintptr_t)((x875)<(x785)); + x877 = (x875)+(x839); + x878 = (uintptr_t)((x877)<(x839)); + x879 = (x876)+(x878); + x880 = (x879)+(x790); + x881 = (uintptr_t)((x880)<(x790)); + x882 = (x880)+(x844); + x883 = (uintptr_t)((x882)<(x844)); + x884 = (x881)+(x883); + x885 = (x884)+(x795); + x886 = (uintptr_t)((x885)<(x795)); + x887 = (x885)+(x849); + x888 = (uintptr_t)((x887)<(x849)); + x889 = (x886)+(x888); + x890 = (x889)+(x800); + x891 = (uintptr_t)((x890)<(x800)); + x892 = (x890)+(x854); + x893 = (uintptr_t)((x892)<(x854)); + x894 = (x891)+(x893); + x895 = (x894)+(x805); + x896 = (uintptr_t)((x895)<(x805)); + x897 = (x895)+(x857); + x898 = (uintptr_t)((x897)<(x857)); + x899 = (x896)+(x898); + x900 = (x899)+(x807); + x901 = (x20)*(x15); + x902 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x15))>>32 : ((__uint128_t)(x20)*(x15))>>64); + x903 = (x20)*(x14); + x904 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x14))>>32 : ((__uint128_t)(x20)*(x14))>>64); + x905 = (x20)*(x13); + x906 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x13))>>32 : ((__uint128_t)(x20)*(x13))>>64); + x907 = (x20)*(x12); + x908 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x12))>>32 : ((__uint128_t)(x20)*(x12))>>64); + x909 = (x20)*(x11); + x910 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x11))>>32 : ((__uint128_t)(x20)*(x11))>>64); + x911 = (x20)*(x10); + x912 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x10))>>32 : ((__uint128_t)(x20)*(x10))>>64); + x913 = (x20)*(x9); + x914 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x9))>>32 : ((__uint128_t)(x20)*(x9))>>64); + x915 = (x20)*(x8); + x916 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x8))>>32 : ((__uint128_t)(x20)*(x8))>>64); + x917 = (x916)+(x913); + x918 = (uintptr_t)((x917)<(x916)); + x919 = (x918)+(x914); + x920 = (uintptr_t)((x919)<(x914)); + x921 = (x919)+(x911); + x922 = (uintptr_t)((x921)<(x911)); + x923 = (x920)+(x922); + x924 = (x923)+(x912); + x925 = (uintptr_t)((x924)<(x912)); + x926 = (x924)+(x909); + x927 = (uintptr_t)((x926)<(x909)); + x928 = (x925)+(x927); + x929 = (x928)+(x910); + x930 = (uintptr_t)((x929)<(x910)); + x931 = (x929)+(x907); + x932 = (uintptr_t)((x931)<(x907)); + x933 = (x930)+(x932); + x934 = (x933)+(x908); + x935 = (uintptr_t)((x934)<(x908)); + x936 = (x934)+(x905); + x937 = (uintptr_t)((x936)<(x905)); + x938 = (x935)+(x937); + x939 = (x938)+(x906); + x940 = (uintptr_t)((x939)<(x906)); + x941 = (x939)+(x903); + x942 = (uintptr_t)((x941)<(x903)); + x943 = (x940)+(x942); + x944 = (x943)+(x904); + x945 = (uintptr_t)((x944)<(x904)); + x946 = (x944)+(x901); + x947 = (uintptr_t)((x946)<(x901)); + x948 = (x945)+(x947); + x949 = (x948)+(x902); + x950 = (x862)+(x915); + x951 = (uintptr_t)((x950)<(x862)); + x952 = (x951)+(x867); + x953 = (uintptr_t)((x952)<(x867)); + x954 = (x952)+(x917); + x955 = (uintptr_t)((x954)<(x917)); + x956 = (x953)+(x955); + x957 = (x956)+(x872); + x958 = (uintptr_t)((x957)<(x872)); + x959 = (x957)+(x921); + x960 = (uintptr_t)((x959)<(x921)); + x961 = (x958)+(x960); + x962 = (x961)+(x877); + x963 = (uintptr_t)((x962)<(x877)); + x964 = (x962)+(x926); + x965 = (uintptr_t)((x964)<(x926)); + x966 = (x963)+(x965); + x967 = (x966)+(x882); + x968 = (uintptr_t)((x967)<(x882)); + x969 = (x967)+(x931); + x970 = (uintptr_t)((x969)<(x931)); + x971 = (x968)+(x970); + x972 = (x971)+(x887); + x973 = (uintptr_t)((x972)<(x887)); + x974 = (x972)+(x936); + x975 = (uintptr_t)((x974)<(x936)); + x976 = (x973)+(x975); + x977 = (x976)+(x892); + x978 = (uintptr_t)((x977)<(x892)); + x979 = (x977)+(x941); + x980 = (uintptr_t)((x979)<(x941)); + x981 = (x978)+(x980); + x982 = (x981)+(x897); + x983 = (uintptr_t)((x982)<(x897)); + x984 = (x982)+(x946); + x985 = (uintptr_t)((x984)<(x946)); + x986 = (x983)+(x985); + x987 = (x986)+(x900); + x988 = (uintptr_t)((x987)<(x900)); + x989 = (x987)+(x949); + x990 = (uintptr_t)((x989)<(x949)); + x991 = (x988)+(x990); + x992 = (x950)*((uintptr_t)1435021631ULL); + x993 = (x992)*((uintptr_t)4294967295ULL); + x994 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x992)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x992)*((uintptr_t)4294967295ULL))>>64); + x995 = (x992)*((uintptr_t)4294967295ULL); + x996 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x992)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x992)*((uintptr_t)4294967295ULL))>>64); + x997 = (x992)*((uintptr_t)4294967295ULL); + x998 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x992)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x992)*((uintptr_t)4294967295ULL))>>64); + x999 = (x992)*((uintptr_t)4294967294ULL); + x1000 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x992)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x992)*((uintptr_t)4294967294ULL))>>64); + x1001 = (x992)*((uintptr_t)3132021990ULL); + x1002 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x992)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x992)*((uintptr_t)3132021990ULL))>>64); + x1003 = (x992)*((uintptr_t)2940772411ULL); + x1004 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x992)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x992)*((uintptr_t)2940772411ULL))>>64); + x1005 = (x992)*((uintptr_t)3218235020ULL); + x1006 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x992)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x992)*((uintptr_t)3218235020ULL))>>64); + x1007 = (x992)*((uintptr_t)3493216577ULL); + x1008 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x992)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x992)*((uintptr_t)3493216577ULL))>>64); + x1009 = (x1008)+(x1005); + x1010 = (uintptr_t)((x1009)<(x1008)); + x1011 = (x1010)+(x1006); + x1012 = (uintptr_t)((x1011)<(x1006)); + x1013 = (x1011)+(x1003); + x1014 = (uintptr_t)((x1013)<(x1003)); + x1015 = (x1012)+(x1014); + x1016 = (x1015)+(x1004); + x1017 = (uintptr_t)((x1016)<(x1004)); + x1018 = (x1016)+(x1001); + x1019 = (uintptr_t)((x1018)<(x1001)); + x1020 = (x1017)+(x1019); + x1021 = (x1020)+(x1002); + x1022 = (uintptr_t)((x1021)<(x1002)); + x1023 = (x1021)+(x999); + x1024 = (uintptr_t)((x1023)<(x999)); + x1025 = (x1022)+(x1024); + x1026 = (x1025)+(x1000); + x1027 = (uintptr_t)((x1026)<(x1000)); + x1028 = (x1026)+(x997); + x1029 = (uintptr_t)((x1028)<(x997)); + x1030 = (x1027)+(x1029); + x1031 = (x1030)+(x998); + x1032 = (uintptr_t)((x1031)<(x998)); + x1033 = (x1031)+(x995); + x1034 = (uintptr_t)((x1033)<(x995)); + x1035 = (x1032)+(x1034); + x1036 = (x1035)+(x996); + x1037 = (uintptr_t)((x1036)<(x996)); + x1038 = (x1036)+(x993); + x1039 = (uintptr_t)((x1038)<(x993)); + x1040 = (x1037)+(x1039); + x1041 = (x1040)+(x994); + x1042 = (x950)+(x1007); + x1043 = (uintptr_t)((x1042)<(x950)); + x1044 = (x1043)+(x954); + x1045 = (uintptr_t)((x1044)<(x954)); + x1046 = (x1044)+(x1009); + x1047 = (uintptr_t)((x1046)<(x1009)); + x1048 = (x1045)+(x1047); + x1049 = (x1048)+(x959); + x1050 = (uintptr_t)((x1049)<(x959)); + x1051 = (x1049)+(x1013); + x1052 = (uintptr_t)((x1051)<(x1013)); + x1053 = (x1050)+(x1052); + x1054 = (x1053)+(x964); + x1055 = (uintptr_t)((x1054)<(x964)); + x1056 = (x1054)+(x1018); + x1057 = (uintptr_t)((x1056)<(x1018)); + x1058 = (x1055)+(x1057); + x1059 = (x1058)+(x969); + x1060 = (uintptr_t)((x1059)<(x969)); + x1061 = (x1059)+(x1023); + x1062 = (uintptr_t)((x1061)<(x1023)); + x1063 = (x1060)+(x1062); + x1064 = (x1063)+(x974); + x1065 = (uintptr_t)((x1064)<(x974)); + x1066 = (x1064)+(x1028); + x1067 = (uintptr_t)((x1066)<(x1028)); + x1068 = (x1065)+(x1067); + x1069 = (x1068)+(x979); + x1070 = (uintptr_t)((x1069)<(x979)); + x1071 = (x1069)+(x1033); + x1072 = (uintptr_t)((x1071)<(x1033)); + x1073 = (x1070)+(x1072); + x1074 = (x1073)+(x984); + x1075 = (uintptr_t)((x1074)<(x984)); + x1076 = (x1074)+(x1038); + x1077 = (uintptr_t)((x1076)<(x1038)); + x1078 = (x1075)+(x1077); + x1079 = (x1078)+(x989); + x1080 = (uintptr_t)((x1079)<(x989)); + x1081 = (x1079)+(x1041); + x1082 = (uintptr_t)((x1081)<(x1041)); + x1083 = (x1080)+(x1082); + x1084 = (x1083)+(x991); + x1085 = (x21)*(x15); + x1086 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x15))>>32 : ((__uint128_t)(x21)*(x15))>>64); + x1087 = (x21)*(x14); + x1088 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x14))>>32 : ((__uint128_t)(x21)*(x14))>>64); + x1089 = (x21)*(x13); + x1090 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x13))>>32 : ((__uint128_t)(x21)*(x13))>>64); + x1091 = (x21)*(x12); + x1092 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x12))>>32 : ((__uint128_t)(x21)*(x12))>>64); + x1093 = (x21)*(x11); + x1094 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x11))>>32 : ((__uint128_t)(x21)*(x11))>>64); + x1095 = (x21)*(x10); + x1096 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x10))>>32 : ((__uint128_t)(x21)*(x10))>>64); + x1097 = (x21)*(x9); + x1098 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x9))>>32 : ((__uint128_t)(x21)*(x9))>>64); + x1099 = (x21)*(x8); + x1100 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x8))>>32 : ((__uint128_t)(x21)*(x8))>>64); + x1101 = (x1100)+(x1097); + x1102 = (uintptr_t)((x1101)<(x1100)); + x1103 = (x1102)+(x1098); + x1104 = (uintptr_t)((x1103)<(x1098)); + x1105 = (x1103)+(x1095); + x1106 = (uintptr_t)((x1105)<(x1095)); + x1107 = (x1104)+(x1106); + x1108 = (x1107)+(x1096); + x1109 = (uintptr_t)((x1108)<(x1096)); + x1110 = (x1108)+(x1093); + x1111 = (uintptr_t)((x1110)<(x1093)); + x1112 = (x1109)+(x1111); + x1113 = (x1112)+(x1094); + x1114 = (uintptr_t)((x1113)<(x1094)); + x1115 = (x1113)+(x1091); + x1116 = (uintptr_t)((x1115)<(x1091)); + x1117 = (x1114)+(x1116); + x1118 = (x1117)+(x1092); + x1119 = (uintptr_t)((x1118)<(x1092)); + x1120 = (x1118)+(x1089); + x1121 = (uintptr_t)((x1120)<(x1089)); + x1122 = (x1119)+(x1121); + x1123 = (x1122)+(x1090); + x1124 = (uintptr_t)((x1123)<(x1090)); + x1125 = (x1123)+(x1087); + x1126 = (uintptr_t)((x1125)<(x1087)); + x1127 = (x1124)+(x1126); + x1128 = (x1127)+(x1088); + x1129 = (uintptr_t)((x1128)<(x1088)); + x1130 = (x1128)+(x1085); + x1131 = (uintptr_t)((x1130)<(x1085)); + x1132 = (x1129)+(x1131); + x1133 = (x1132)+(x1086); + x1134 = (x1046)+(x1099); + x1135 = (uintptr_t)((x1134)<(x1046)); + x1136 = (x1135)+(x1051); + x1137 = (uintptr_t)((x1136)<(x1051)); + x1138 = (x1136)+(x1101); + x1139 = (uintptr_t)((x1138)<(x1101)); + x1140 = (x1137)+(x1139); + x1141 = (x1140)+(x1056); + x1142 = (uintptr_t)((x1141)<(x1056)); + x1143 = (x1141)+(x1105); + x1144 = (uintptr_t)((x1143)<(x1105)); + x1145 = (x1142)+(x1144); + x1146 = (x1145)+(x1061); + x1147 = (uintptr_t)((x1146)<(x1061)); + x1148 = (x1146)+(x1110); + x1149 = (uintptr_t)((x1148)<(x1110)); + x1150 = (x1147)+(x1149); + x1151 = (x1150)+(x1066); + x1152 = (uintptr_t)((x1151)<(x1066)); + x1153 = (x1151)+(x1115); + x1154 = (uintptr_t)((x1153)<(x1115)); + x1155 = (x1152)+(x1154); + x1156 = (x1155)+(x1071); + x1157 = (uintptr_t)((x1156)<(x1071)); + x1158 = (x1156)+(x1120); + x1159 = (uintptr_t)((x1158)<(x1120)); + x1160 = (x1157)+(x1159); + x1161 = (x1160)+(x1076); + x1162 = (uintptr_t)((x1161)<(x1076)); + x1163 = (x1161)+(x1125); + x1164 = (uintptr_t)((x1163)<(x1125)); + x1165 = (x1162)+(x1164); + x1166 = (x1165)+(x1081); + x1167 = (uintptr_t)((x1166)<(x1081)); + x1168 = (x1166)+(x1130); + x1169 = (uintptr_t)((x1168)<(x1130)); + x1170 = (x1167)+(x1169); + x1171 = (x1170)+(x1084); + x1172 = (uintptr_t)((x1171)<(x1084)); + x1173 = (x1171)+(x1133); + x1174 = (uintptr_t)((x1173)<(x1133)); + x1175 = (x1172)+(x1174); + x1176 = (x1134)*((uintptr_t)1435021631ULL); + x1177 = (x1176)*((uintptr_t)4294967295ULL); + x1178 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1176)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1176)*((uintptr_t)4294967295ULL))>>64); + x1179 = (x1176)*((uintptr_t)4294967295ULL); + x1180 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1176)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1176)*((uintptr_t)4294967295ULL))>>64); + x1181 = (x1176)*((uintptr_t)4294967295ULL); + x1182 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1176)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1176)*((uintptr_t)4294967295ULL))>>64); + x1183 = (x1176)*((uintptr_t)4294967294ULL); + x1184 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1176)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x1176)*((uintptr_t)4294967294ULL))>>64); + x1185 = (x1176)*((uintptr_t)3132021990ULL); + x1186 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1176)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x1176)*((uintptr_t)3132021990ULL))>>64); + x1187 = (x1176)*((uintptr_t)2940772411ULL); + x1188 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1176)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x1176)*((uintptr_t)2940772411ULL))>>64); + x1189 = (x1176)*((uintptr_t)3218235020ULL); + x1190 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1176)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x1176)*((uintptr_t)3218235020ULL))>>64); + x1191 = (x1176)*((uintptr_t)3493216577ULL); + x1192 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1176)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x1176)*((uintptr_t)3493216577ULL))>>64); + x1193 = (x1192)+(x1189); + x1194 = (uintptr_t)((x1193)<(x1192)); + x1195 = (x1194)+(x1190); + x1196 = (uintptr_t)((x1195)<(x1190)); + x1197 = (x1195)+(x1187); + x1198 = (uintptr_t)((x1197)<(x1187)); + x1199 = (x1196)+(x1198); + x1200 = (x1199)+(x1188); + x1201 = (uintptr_t)((x1200)<(x1188)); + x1202 = (x1200)+(x1185); + x1203 = (uintptr_t)((x1202)<(x1185)); + x1204 = (x1201)+(x1203); + x1205 = (x1204)+(x1186); + x1206 = (uintptr_t)((x1205)<(x1186)); + x1207 = (x1205)+(x1183); + x1208 = (uintptr_t)((x1207)<(x1183)); + x1209 = (x1206)+(x1208); + x1210 = (x1209)+(x1184); + x1211 = (uintptr_t)((x1210)<(x1184)); + x1212 = (x1210)+(x1181); + x1213 = (uintptr_t)((x1212)<(x1181)); + x1214 = (x1211)+(x1213); + x1215 = (x1214)+(x1182); + x1216 = (uintptr_t)((x1215)<(x1182)); + x1217 = (x1215)+(x1179); + x1218 = (uintptr_t)((x1217)<(x1179)); + x1219 = (x1216)+(x1218); + x1220 = (x1219)+(x1180); + x1221 = (uintptr_t)((x1220)<(x1180)); + x1222 = (x1220)+(x1177); + x1223 = (uintptr_t)((x1222)<(x1177)); + x1224 = (x1221)+(x1223); + x1225 = (x1224)+(x1178); + x1226 = (x1134)+(x1191); + x1227 = (uintptr_t)((x1226)<(x1134)); + x1228 = (x1227)+(x1138); + x1229 = (uintptr_t)((x1228)<(x1138)); + x1230 = (x1228)+(x1193); + x1231 = (uintptr_t)((x1230)<(x1193)); + x1232 = (x1229)+(x1231); + x1233 = (x1232)+(x1143); + x1234 = (uintptr_t)((x1233)<(x1143)); + x1235 = (x1233)+(x1197); + x1236 = (uintptr_t)((x1235)<(x1197)); + x1237 = (x1234)+(x1236); + x1238 = (x1237)+(x1148); + x1239 = (uintptr_t)((x1238)<(x1148)); + x1240 = (x1238)+(x1202); + x1241 = (uintptr_t)((x1240)<(x1202)); + x1242 = (x1239)+(x1241); + x1243 = (x1242)+(x1153); + x1244 = (uintptr_t)((x1243)<(x1153)); + x1245 = (x1243)+(x1207); + x1246 = (uintptr_t)((x1245)<(x1207)); + x1247 = (x1244)+(x1246); + x1248 = (x1247)+(x1158); + x1249 = (uintptr_t)((x1248)<(x1158)); + x1250 = (x1248)+(x1212); + x1251 = (uintptr_t)((x1250)<(x1212)); + x1252 = (x1249)+(x1251); + x1253 = (x1252)+(x1163); + x1254 = (uintptr_t)((x1253)<(x1163)); + x1255 = (x1253)+(x1217); + x1256 = (uintptr_t)((x1255)<(x1217)); + x1257 = (x1254)+(x1256); + x1258 = (x1257)+(x1168); + x1259 = (uintptr_t)((x1258)<(x1168)); + x1260 = (x1258)+(x1222); + x1261 = (uintptr_t)((x1260)<(x1222)); + x1262 = (x1259)+(x1261); + x1263 = (x1262)+(x1173); + x1264 = (uintptr_t)((x1263)<(x1173)); + x1265 = (x1263)+(x1225); + x1266 = (uintptr_t)((x1265)<(x1225)); + x1267 = (x1264)+(x1266); + x1268 = (x1267)+(x1175); + x1269 = (x22)*(x15); + x1270 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x15))>>32 : ((__uint128_t)(x22)*(x15))>>64); + x1271 = (x22)*(x14); + x1272 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x14))>>32 : ((__uint128_t)(x22)*(x14))>>64); + x1273 = (x22)*(x13); + x1274 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x13))>>32 : ((__uint128_t)(x22)*(x13))>>64); + x1275 = (x22)*(x12); + x1276 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x12))>>32 : ((__uint128_t)(x22)*(x12))>>64); + x1277 = (x22)*(x11); + x1278 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x11))>>32 : ((__uint128_t)(x22)*(x11))>>64); + x1279 = (x22)*(x10); + x1280 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x10))>>32 : ((__uint128_t)(x22)*(x10))>>64); + x1281 = (x22)*(x9); + x1282 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x9))>>32 : ((__uint128_t)(x22)*(x9))>>64); + x1283 = (x22)*(x8); + x1284 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x8))>>32 : ((__uint128_t)(x22)*(x8))>>64); + x1285 = (x1284)+(x1281); + x1286 = (uintptr_t)((x1285)<(x1284)); + x1287 = (x1286)+(x1282); + x1288 = (uintptr_t)((x1287)<(x1282)); + x1289 = (x1287)+(x1279); + x1290 = (uintptr_t)((x1289)<(x1279)); + x1291 = (x1288)+(x1290); + x1292 = (x1291)+(x1280); + x1293 = (uintptr_t)((x1292)<(x1280)); + x1294 = (x1292)+(x1277); + x1295 = (uintptr_t)((x1294)<(x1277)); + x1296 = (x1293)+(x1295); + x1297 = (x1296)+(x1278); + x1298 = (uintptr_t)((x1297)<(x1278)); + x1299 = (x1297)+(x1275); + x1300 = (uintptr_t)((x1299)<(x1275)); + x1301 = (x1298)+(x1300); + x1302 = (x1301)+(x1276); + x1303 = (uintptr_t)((x1302)<(x1276)); + x1304 = (x1302)+(x1273); + x1305 = (uintptr_t)((x1304)<(x1273)); + x1306 = (x1303)+(x1305); + x1307 = (x1306)+(x1274); + x1308 = (uintptr_t)((x1307)<(x1274)); + x1309 = (x1307)+(x1271); + x1310 = (uintptr_t)((x1309)<(x1271)); + x1311 = (x1308)+(x1310); + x1312 = (x1311)+(x1272); + x1313 = (uintptr_t)((x1312)<(x1272)); + x1314 = (x1312)+(x1269); + x1315 = (uintptr_t)((x1314)<(x1269)); + x1316 = (x1313)+(x1315); + x1317 = (x1316)+(x1270); + x1318 = (x1230)+(x1283); + x1319 = (uintptr_t)((x1318)<(x1230)); + x1320 = (x1319)+(x1235); + x1321 = (uintptr_t)((x1320)<(x1235)); + x1322 = (x1320)+(x1285); + x1323 = (uintptr_t)((x1322)<(x1285)); + x1324 = (x1321)+(x1323); + x1325 = (x1324)+(x1240); + x1326 = (uintptr_t)((x1325)<(x1240)); + x1327 = (x1325)+(x1289); + x1328 = (uintptr_t)((x1327)<(x1289)); + x1329 = (x1326)+(x1328); + x1330 = (x1329)+(x1245); + x1331 = (uintptr_t)((x1330)<(x1245)); + x1332 = (x1330)+(x1294); + x1333 = (uintptr_t)((x1332)<(x1294)); + x1334 = (x1331)+(x1333); + x1335 = (x1334)+(x1250); + x1336 = (uintptr_t)((x1335)<(x1250)); + x1337 = (x1335)+(x1299); + x1338 = (uintptr_t)((x1337)<(x1299)); + x1339 = (x1336)+(x1338); + x1340 = (x1339)+(x1255); + x1341 = (uintptr_t)((x1340)<(x1255)); + x1342 = (x1340)+(x1304); + x1343 = (uintptr_t)((x1342)<(x1304)); + x1344 = (x1341)+(x1343); + x1345 = (x1344)+(x1260); + x1346 = (uintptr_t)((x1345)<(x1260)); + x1347 = (x1345)+(x1309); + x1348 = (uintptr_t)((x1347)<(x1309)); + x1349 = (x1346)+(x1348); + x1350 = (x1349)+(x1265); + x1351 = (uintptr_t)((x1350)<(x1265)); + x1352 = (x1350)+(x1314); + x1353 = (uintptr_t)((x1352)<(x1314)); + x1354 = (x1351)+(x1353); + x1355 = (x1354)+(x1268); + x1356 = (uintptr_t)((x1355)<(x1268)); + x1357 = (x1355)+(x1317); + x1358 = (uintptr_t)((x1357)<(x1317)); + x1359 = (x1356)+(x1358); + x1360 = (x1318)*((uintptr_t)1435021631ULL); + x1361 = (x1360)*((uintptr_t)4294967295ULL); + x1362 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1360)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1360)*((uintptr_t)4294967295ULL))>>64); + x1363 = (x1360)*((uintptr_t)4294967295ULL); + x1364 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1360)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1360)*((uintptr_t)4294967295ULL))>>64); + x1365 = (x1360)*((uintptr_t)4294967295ULL); + x1366 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1360)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1360)*((uintptr_t)4294967295ULL))>>64); + x1367 = (x1360)*((uintptr_t)4294967294ULL); + x1368 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1360)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x1360)*((uintptr_t)4294967294ULL))>>64); + x1369 = (x1360)*((uintptr_t)3132021990ULL); + x1370 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1360)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x1360)*((uintptr_t)3132021990ULL))>>64); + x1371 = (x1360)*((uintptr_t)2940772411ULL); + x1372 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1360)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x1360)*((uintptr_t)2940772411ULL))>>64); + x1373 = (x1360)*((uintptr_t)3218235020ULL); + x1374 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1360)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x1360)*((uintptr_t)3218235020ULL))>>64); + x1375 = (x1360)*((uintptr_t)3493216577ULL); + x1376 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1360)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x1360)*((uintptr_t)3493216577ULL))>>64); + x1377 = (x1376)+(x1373); + x1378 = (uintptr_t)((x1377)<(x1376)); + x1379 = (x1378)+(x1374); + x1380 = (uintptr_t)((x1379)<(x1374)); + x1381 = (x1379)+(x1371); + x1382 = (uintptr_t)((x1381)<(x1371)); + x1383 = (x1380)+(x1382); + x1384 = (x1383)+(x1372); + x1385 = (uintptr_t)((x1384)<(x1372)); + x1386 = (x1384)+(x1369); + x1387 = (uintptr_t)((x1386)<(x1369)); + x1388 = (x1385)+(x1387); + x1389 = (x1388)+(x1370); + x1390 = (uintptr_t)((x1389)<(x1370)); + x1391 = (x1389)+(x1367); + x1392 = (uintptr_t)((x1391)<(x1367)); + x1393 = (x1390)+(x1392); + x1394 = (x1393)+(x1368); + x1395 = (uintptr_t)((x1394)<(x1368)); + x1396 = (x1394)+(x1365); + x1397 = (uintptr_t)((x1396)<(x1365)); + x1398 = (x1395)+(x1397); + x1399 = (x1398)+(x1366); + x1400 = (uintptr_t)((x1399)<(x1366)); + x1401 = (x1399)+(x1363); + x1402 = (uintptr_t)((x1401)<(x1363)); + x1403 = (x1400)+(x1402); + x1404 = (x1403)+(x1364); + x1405 = (uintptr_t)((x1404)<(x1364)); + x1406 = (x1404)+(x1361); + x1407 = (uintptr_t)((x1406)<(x1361)); + x1408 = (x1405)+(x1407); + x1409 = (x1408)+(x1362); + x1410 = (x1318)+(x1375); + x1411 = (uintptr_t)((x1410)<(x1318)); + x1412 = (x1411)+(x1322); + x1413 = (uintptr_t)((x1412)<(x1322)); + x1414 = (x1412)+(x1377); + x1415 = (uintptr_t)((x1414)<(x1377)); + x1416 = (x1413)+(x1415); + x1417 = (x1416)+(x1327); + x1418 = (uintptr_t)((x1417)<(x1327)); + x1419 = (x1417)+(x1381); + x1420 = (uintptr_t)((x1419)<(x1381)); + x1421 = (x1418)+(x1420); + x1422 = (x1421)+(x1332); + x1423 = (uintptr_t)((x1422)<(x1332)); + x1424 = (x1422)+(x1386); + x1425 = (uintptr_t)((x1424)<(x1386)); + x1426 = (x1423)+(x1425); + x1427 = (x1426)+(x1337); + x1428 = (uintptr_t)((x1427)<(x1337)); + x1429 = (x1427)+(x1391); + x1430 = (uintptr_t)((x1429)<(x1391)); + x1431 = (x1428)+(x1430); + x1432 = (x1431)+(x1342); + x1433 = (uintptr_t)((x1432)<(x1342)); + x1434 = (x1432)+(x1396); + x1435 = (uintptr_t)((x1434)<(x1396)); + x1436 = (x1433)+(x1435); + x1437 = (x1436)+(x1347); + x1438 = (uintptr_t)((x1437)<(x1347)); + x1439 = (x1437)+(x1401); + x1440 = (uintptr_t)((x1439)<(x1401)); + x1441 = (x1438)+(x1440); + x1442 = (x1441)+(x1352); + x1443 = (uintptr_t)((x1442)<(x1352)); + x1444 = (x1442)+(x1406); + x1445 = (uintptr_t)((x1444)<(x1406)); + x1446 = (x1443)+(x1445); + x1447 = (x1446)+(x1357); + x1448 = (uintptr_t)((x1447)<(x1357)); + x1449 = (x1447)+(x1409); + x1450 = (uintptr_t)((x1449)<(x1409)); + x1451 = (x1448)+(x1450); + x1452 = (x1451)+(x1359); + x1453 = (x1414)-((uintptr_t)3493216577ULL); + x1454 = (uintptr_t)((x1414)<(x1453)); + x1455 = (x1419)-((uintptr_t)3218235020ULL); + x1456 = (uintptr_t)((x1419)<(x1455)); + x1457 = (x1455)-(x1454); + x1458 = (uintptr_t)((x1455)<(x1457)); + x1459 = (x1456)+(x1458); + x1460 = (x1424)-((uintptr_t)2940772411ULL); + x1461 = (uintptr_t)((x1424)<(x1460)); + x1462 = (x1460)-(x1459); + x1463 = (uintptr_t)((x1460)<(x1462)); + x1464 = (x1461)+(x1463); + x1465 = (x1429)-((uintptr_t)3132021990ULL); + x1466 = (uintptr_t)((x1429)<(x1465)); + x1467 = (x1465)-(x1464); + x1468 = (uintptr_t)((x1465)<(x1467)); + x1469 = (x1466)+(x1468); + x1470 = (x1434)-((uintptr_t)4294967294ULL); + x1471 = (uintptr_t)((x1434)<(x1470)); + x1472 = (x1470)-(x1469); + x1473 = (uintptr_t)((x1470)<(x1472)); + x1474 = (x1471)+(x1473); + x1475 = (x1439)-((uintptr_t)4294967295ULL); + x1476 = (uintptr_t)((x1439)<(x1475)); + x1477 = (x1475)-(x1474); + x1478 = (uintptr_t)((x1475)<(x1477)); + x1479 = (x1476)+(x1478); + x1480 = (x1444)-((uintptr_t)4294967295ULL); + x1481 = (uintptr_t)((x1444)<(x1480)); + x1482 = (x1480)-(x1479); + x1483 = (uintptr_t)((x1480)<(x1482)); + x1484 = (x1481)+(x1483); + x1485 = (x1449)-((uintptr_t)4294967295ULL); + x1486 = (uintptr_t)((x1449)<(x1485)); + x1487 = (x1485)-(x1484); + x1488 = (uintptr_t)((x1485)<(x1487)); + x1489 = (x1486)+(x1488); + x1490 = (x1452)-(x1489); + x1491 = (uintptr_t)((x1452)<(x1490)); + x1492 = ((uintptr_t)-1ULL)+((uintptr_t)((x1491)==((uintptr_t)0ULL))); + x1493 = (x1492)^((uintptr_t)4294967295ULL); + x1494 = ((x1414)&(x1492))|((x1453)&(x1493)); + x1495 = ((uintptr_t)-1ULL)+((uintptr_t)((x1491)==((uintptr_t)0ULL))); + x1496 = (x1495)^((uintptr_t)4294967295ULL); + x1497 = ((x1419)&(x1495))|((x1457)&(x1496)); + x1498 = ((uintptr_t)-1ULL)+((uintptr_t)((x1491)==((uintptr_t)0ULL))); + x1499 = (x1498)^((uintptr_t)4294967295ULL); + x1500 = ((x1424)&(x1498))|((x1462)&(x1499)); + x1501 = ((uintptr_t)-1ULL)+((uintptr_t)((x1491)==((uintptr_t)0ULL))); + x1502 = (x1501)^((uintptr_t)4294967295ULL); + x1503 = ((x1429)&(x1501))|((x1467)&(x1502)); + x1504 = ((uintptr_t)-1ULL)+((uintptr_t)((x1491)==((uintptr_t)0ULL))); + x1505 = (x1504)^((uintptr_t)4294967295ULL); + x1506 = ((x1434)&(x1504))|((x1472)&(x1505)); + x1507 = ((uintptr_t)-1ULL)+((uintptr_t)((x1491)==((uintptr_t)0ULL))); + x1508 = (x1507)^((uintptr_t)4294967295ULL); + x1509 = ((x1439)&(x1507))|((x1477)&(x1508)); + x1510 = ((uintptr_t)-1ULL)+((uintptr_t)((x1491)==((uintptr_t)0ULL))); + x1511 = (x1510)^((uintptr_t)4294967295ULL); + x1512 = ((x1444)&(x1510))|((x1482)&(x1511)); + x1513 = ((uintptr_t)-1ULL)+((uintptr_t)((x1491)==((uintptr_t)0ULL))); + x1514 = (x1513)^((uintptr_t)4294967295ULL); + x1515 = ((x1449)&(x1513))|((x1487)&(x1514)); + x1516 = x1494; + x1517 = x1497; + x1518 = x1500; + x1519 = x1503; + x1520 = x1506; + x1521 = x1509; + x1522 = x1512; + x1523 = x1515; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x1516, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1517, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1518, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x1519, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x1520, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x1521, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x1522, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x1523, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_mul(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_secp256k1_scalar_mul((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_square(uintptr_t out0, uintptr_t in0) { + uintptr_t x15, x28, x31, x33, x29, x34, x26, x35, x37, x38, x27, x39, x24, x40, x42, x43, x25, x44, x22, x45, x47, x48, x23, x49, x20, x50, x52, x53, x21, x54, x18, x55, x57, x58, x19, x59, x16, x60, x62, x63, x17, x65, x78, x81, x83, x79, x84, x76, x85, x87, x88, x77, x89, x74, x90, x92, x93, x75, x94, x72, x95, x97, x98, x73, x99, x70, x100, x102, x103, x71, x104, x68, x105, x107, x108, x69, x109, x66, x110, x112, x113, x67, x80, x115, x30, x116, x32, x117, x82, x118, x120, x121, x36, x122, x86, x123, x125, x126, x41, x127, x91, x128, x130, x131, x46, x132, x96, x133, x135, x136, x51, x137, x101, x138, x140, x141, x56, x142, x106, x143, x145, x146, x61, x147, x111, x148, x150, x151, x64, x152, x114, x153, x155, x8, x169, x172, x174, x170, x175, x167, x176, x178, x179, x168, x180, x165, x181, x183, x184, x166, x185, x163, x186, x188, x189, x164, x190, x161, x191, x193, x194, x162, x195, x159, x196, x198, x199, x160, x200, x157, x201, x203, x204, x158, x171, x119, x207, x124, x208, x173, x209, x211, x212, x129, x213, x177, x214, x216, x217, x134, x218, x182, x219, x221, x222, x139, x223, x187, x224, x226, x227, x144, x228, x192, x229, x231, x232, x149, x233, x197, x234, x236, x237, x154, x238, x202, x239, x241, x242, x156, x243, x205, x244, x246, x248, x261, x264, x266, x262, x267, x259, x268, x270, x271, x260, x272, x257, x273, x275, x276, x258, x277, x255, x278, x280, x281, x256, x282, x253, x283, x285, x286, x254, x287, x251, x288, x290, x291, x252, x292, x249, x293, x295, x296, x250, x263, x298, x206, x299, x210, x300, x265, x301, x303, x304, x215, x305, x269, x306, x308, x309, x220, x310, x274, x311, x313, x314, x225, x315, x279, x316, x318, x319, x230, x320, x284, x321, x323, x324, x235, x325, x289, x326, x328, x329, x240, x330, x294, x331, x333, x334, x245, x335, x297, x336, x338, x339, x247, x9, x353, x356, x358, x354, x359, x351, x360, x362, x363, x352, x364, x349, x365, x367, x368, x350, x369, x347, x370, x372, x373, x348, x374, x345, x375, x377, x378, x346, x379, x343, x380, x382, x383, x344, x384, x341, x385, x387, x388, x342, x355, x302, x391, x307, x392, x357, x393, x395, x396, x312, x397, x361, x398, x400, x401, x317, x402, x366, x403, x405, x406, x322, x407, x371, x408, x410, x411, x327, x412, x376, x413, x415, x416, x332, x417, x381, x418, x420, x421, x337, x422, x386, x423, x425, x426, x340, x427, x389, x428, x430, x432, x445, x448, x450, x446, x451, x443, x452, x454, x455, x444, x456, x441, x457, x459, x460, x442, x461, x439, x462, x464, x465, x440, x466, x437, x467, x469, x470, x438, x471, x435, x472, x474, x475, x436, x476, x433, x477, x479, x480, x434, x447, x482, x390, x483, x394, x484, x449, x485, x487, x488, x399, x489, x453, x490, x492, x493, x404, x494, x458, x495, x497, x498, x409, x499, x463, x500, x502, x503, x414, x504, x468, x505, x507, x508, x419, x509, x473, x510, x512, x513, x424, x514, x478, x515, x517, x518, x429, x519, x481, x520, x522, x523, x431, x10, x537, x540, x542, x538, x543, x535, x544, x546, x547, x536, x548, x533, x549, x551, x552, x534, x553, x531, x554, x556, x557, x532, x558, x529, x559, x561, x562, x530, x563, x527, x564, x566, x567, x528, x568, x525, x569, x571, x572, x526, x539, x486, x575, x491, x576, x541, x577, x579, x580, x496, x581, x545, x582, x584, x585, x501, x586, x550, x587, x589, x590, x506, x591, x555, x592, x594, x595, x511, x596, x560, x597, x599, x600, x516, x601, x565, x602, x604, x605, x521, x606, x570, x607, x609, x610, x524, x611, x573, x612, x614, x616, x629, x632, x634, x630, x635, x627, x636, x638, x639, x628, x640, x625, x641, x643, x644, x626, x645, x623, x646, x648, x649, x624, x650, x621, x651, x653, x654, x622, x655, x619, x656, x658, x659, x620, x660, x617, x661, x663, x664, x618, x631, x666, x574, x667, x578, x668, x633, x669, x671, x672, x583, x673, x637, x674, x676, x677, x588, x678, x642, x679, x681, x682, x593, x683, x647, x684, x686, x687, x598, x688, x652, x689, x691, x692, x603, x693, x657, x694, x696, x697, x608, x698, x662, x699, x701, x702, x613, x703, x665, x704, x706, x707, x615, x11, x721, x724, x726, x722, x727, x719, x728, x730, x731, x720, x732, x717, x733, x735, x736, x718, x737, x715, x738, x740, x741, x716, x742, x713, x743, x745, x746, x714, x747, x711, x748, x750, x751, x712, x752, x709, x753, x755, x756, x710, x723, x670, x759, x675, x760, x725, x761, x763, x764, x680, x765, x729, x766, x768, x769, x685, x770, x734, x771, x773, x774, x690, x775, x739, x776, x778, x779, x695, x780, x744, x781, x783, x784, x700, x785, x749, x786, x788, x789, x705, x790, x754, x791, x793, x794, x708, x795, x757, x796, x798, x800, x813, x816, x818, x814, x819, x811, x820, x822, x823, x812, x824, x809, x825, x827, x828, x810, x829, x807, x830, x832, x833, x808, x834, x805, x835, x837, x838, x806, x839, x803, x840, x842, x843, x804, x844, x801, x845, x847, x848, x802, x815, x850, x758, x851, x762, x852, x817, x853, x855, x856, x767, x857, x821, x858, x860, x861, x772, x862, x826, x863, x865, x866, x777, x867, x831, x868, x870, x871, x782, x872, x836, x873, x875, x876, x787, x877, x841, x878, x880, x881, x792, x882, x846, x883, x885, x886, x797, x887, x849, x888, x890, x891, x799, x12, x905, x908, x910, x906, x911, x903, x912, x914, x915, x904, x916, x901, x917, x919, x920, x902, x921, x899, x922, x924, x925, x900, x926, x897, x927, x929, x930, x898, x931, x895, x932, x934, x935, x896, x936, x893, x937, x939, x940, x894, x907, x854, x943, x859, x944, x909, x945, x947, x948, x864, x949, x913, x950, x952, x953, x869, x954, x918, x955, x957, x958, x874, x959, x923, x960, x962, x963, x879, x964, x928, x965, x967, x968, x884, x969, x933, x970, x972, x973, x889, x974, x938, x975, x977, x978, x892, x979, x941, x980, x982, x984, x997, x1000, x1002, x998, x1003, x995, x1004, x1006, x1007, x996, x1008, x993, x1009, x1011, x1012, x994, x1013, x991, x1014, x1016, x1017, x992, x1018, x989, x1019, x1021, x1022, x990, x1023, x987, x1024, x1026, x1027, x988, x1028, x985, x1029, x1031, x1032, x986, x999, x1034, x942, x1035, x946, x1036, x1001, x1037, x1039, x1040, x951, x1041, x1005, x1042, x1044, x1045, x956, x1046, x1010, x1047, x1049, x1050, x961, x1051, x1015, x1052, x1054, x1055, x966, x1056, x1020, x1057, x1059, x1060, x971, x1061, x1025, x1062, x1064, x1065, x976, x1066, x1030, x1067, x1069, x1070, x981, x1071, x1033, x1072, x1074, x1075, x983, x13, x1089, x1092, x1094, x1090, x1095, x1087, x1096, x1098, x1099, x1088, x1100, x1085, x1101, x1103, x1104, x1086, x1105, x1083, x1106, x1108, x1109, x1084, x1110, x1081, x1111, x1113, x1114, x1082, x1115, x1079, x1116, x1118, x1119, x1080, x1120, x1077, x1121, x1123, x1124, x1078, x1091, x1038, x1127, x1043, x1128, x1093, x1129, x1131, x1132, x1048, x1133, x1097, x1134, x1136, x1137, x1053, x1138, x1102, x1139, x1141, x1142, x1058, x1143, x1107, x1144, x1146, x1147, x1063, x1148, x1112, x1149, x1151, x1152, x1068, x1153, x1117, x1154, x1156, x1157, x1073, x1158, x1122, x1159, x1161, x1162, x1076, x1163, x1125, x1164, x1166, x1168, x1181, x1184, x1186, x1182, x1187, x1179, x1188, x1190, x1191, x1180, x1192, x1177, x1193, x1195, x1196, x1178, x1197, x1175, x1198, x1200, x1201, x1176, x1202, x1173, x1203, x1205, x1206, x1174, x1207, x1171, x1208, x1210, x1211, x1172, x1212, x1169, x1213, x1215, x1216, x1170, x1183, x1218, x1126, x1219, x1130, x1220, x1185, x1221, x1223, x1224, x1135, x1225, x1189, x1226, x1228, x1229, x1140, x1230, x1194, x1231, x1233, x1234, x1145, x1235, x1199, x1236, x1238, x1239, x1150, x1240, x1204, x1241, x1243, x1244, x1155, x1245, x1209, x1246, x1248, x1249, x1160, x1250, x1214, x1251, x1253, x1254, x1165, x1255, x1217, x1256, x1258, x1259, x1167, x7, x6, x5, x4, x3, x2, x1, x14, x0, x1273, x1276, x1278, x1274, x1279, x1271, x1280, x1282, x1283, x1272, x1284, x1269, x1285, x1287, x1288, x1270, x1289, x1267, x1290, x1292, x1293, x1268, x1294, x1265, x1295, x1297, x1298, x1266, x1299, x1263, x1300, x1302, x1303, x1264, x1304, x1261, x1305, x1307, x1308, x1262, x1275, x1222, x1311, x1227, x1312, x1277, x1313, x1315, x1316, x1232, x1317, x1281, x1318, x1320, x1321, x1237, x1322, x1286, x1323, x1325, x1326, x1242, x1327, x1291, x1328, x1330, x1331, x1247, x1332, x1296, x1333, x1335, x1336, x1252, x1337, x1301, x1338, x1340, x1341, x1257, x1342, x1306, x1343, x1345, x1346, x1260, x1347, x1309, x1348, x1350, x1352, x1365, x1368, x1370, x1366, x1371, x1363, x1372, x1374, x1375, x1364, x1376, x1361, x1377, x1379, x1380, x1362, x1381, x1359, x1382, x1384, x1385, x1360, x1386, x1357, x1387, x1389, x1390, x1358, x1391, x1355, x1392, x1394, x1395, x1356, x1396, x1353, x1397, x1399, x1400, x1354, x1367, x1402, x1310, x1403, x1314, x1404, x1369, x1405, x1407, x1408, x1319, x1409, x1373, x1410, x1412, x1413, x1324, x1414, x1378, x1415, x1417, x1418, x1329, x1419, x1383, x1420, x1422, x1423, x1334, x1424, x1388, x1425, x1427, x1428, x1339, x1429, x1393, x1430, x1432, x1433, x1344, x1434, x1398, x1435, x1437, x1438, x1349, x1439, x1401, x1440, x1442, x1443, x1351, x1446, x1447, x1448, x1450, x1451, x1452, x1453, x1455, x1456, x1457, x1458, x1460, x1461, x1462, x1463, x1465, x1466, x1467, x1468, x1470, x1471, x1472, x1473, x1475, x1476, x1477, x1478, x1480, x1481, x1444, x1482, x1406, x1484, x1445, x1485, x1411, x1487, x1449, x1488, x1416, x1490, x1454, x1491, x1421, x1493, x1459, x1494, x1426, x1496, x1464, x1497, x1431, x1499, x1469, x1500, x1436, x1502, x1474, x1503, x1483, x1441, x1505, x1479, x1506, x1486, x1489, x1492, x1495, x1498, x1501, x1504, x1507, x1508, x1509, x1510, x1511, x1512, x1513, x1514, x1515; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x1; + x9 = x2; + x10 = x3; + x11 = x4; + x12 = x5; + x13 = x6; + x14 = x7; + x15 = x0; + x16 = (x15)*(x7); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x7))>>32 : ((__uint128_t)(x15)*(x7))>>64); + x18 = (x15)*(x6); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x6))>>32 : ((__uint128_t)(x15)*(x6))>>64); + x20 = (x15)*(x5); + x21 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x5))>>32 : ((__uint128_t)(x15)*(x5))>>64); + x22 = (x15)*(x4); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x4))>>32 : ((__uint128_t)(x15)*(x4))>>64); + x24 = (x15)*(x3); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x3))>>32 : ((__uint128_t)(x15)*(x3))>>64); + x26 = (x15)*(x2); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x2))>>32 : ((__uint128_t)(x15)*(x2))>>64); + x28 = (x15)*(x1); + x29 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x1))>>32 : ((__uint128_t)(x15)*(x1))>>64); + x30 = (x15)*(x0); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x0))>>32 : ((__uint128_t)(x15)*(x0))>>64); + x32 = (x31)+(x28); + x33 = (uintptr_t)((x32)<(x31)); + x34 = (x33)+(x29); + x35 = (uintptr_t)((x34)<(x29)); + x36 = (x34)+(x26); + x37 = (uintptr_t)((x36)<(x26)); + x38 = (x35)+(x37); + x39 = (x38)+(x27); + x40 = (uintptr_t)((x39)<(x27)); + x41 = (x39)+(x24); + x42 = (uintptr_t)((x41)<(x24)); + x43 = (x40)+(x42); + x44 = (x43)+(x25); + x45 = (uintptr_t)((x44)<(x25)); + x46 = (x44)+(x22); + x47 = (uintptr_t)((x46)<(x22)); + x48 = (x45)+(x47); + x49 = (x48)+(x23); + x50 = (uintptr_t)((x49)<(x23)); + x51 = (x49)+(x20); + x52 = (uintptr_t)((x51)<(x20)); + x53 = (x50)+(x52); + x54 = (x53)+(x21); + x55 = (uintptr_t)((x54)<(x21)); + x56 = (x54)+(x18); + x57 = (uintptr_t)((x56)<(x18)); + x58 = (x55)+(x57); + x59 = (x58)+(x19); + x60 = (uintptr_t)((x59)<(x19)); + x61 = (x59)+(x16); + x62 = (uintptr_t)((x61)<(x16)); + x63 = (x60)+(x62); + x64 = (x63)+(x17); + x65 = (x30)*((uintptr_t)1435021631ULL); + x66 = (x65)*((uintptr_t)4294967295ULL); + x67 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)4294967295ULL))>>64); + x68 = (x65)*((uintptr_t)4294967295ULL); + x69 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)4294967295ULL))>>64); + x70 = (x65)*((uintptr_t)4294967295ULL); + x71 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)4294967295ULL))>>64); + x72 = (x65)*((uintptr_t)4294967294ULL); + x73 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)4294967294ULL))>>64); + x74 = (x65)*((uintptr_t)3132021990ULL); + x75 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)3132021990ULL))>>64); + x76 = (x65)*((uintptr_t)2940772411ULL); + x77 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)2940772411ULL))>>64); + x78 = (x65)*((uintptr_t)3218235020ULL); + x79 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)3218235020ULL))>>64); + x80 = (x65)*((uintptr_t)3493216577ULL); + x81 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x65)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x65)*((uintptr_t)3493216577ULL))>>64); + x82 = (x81)+(x78); + x83 = (uintptr_t)((x82)<(x81)); + x84 = (x83)+(x79); + x85 = (uintptr_t)((x84)<(x79)); + x86 = (x84)+(x76); + x87 = (uintptr_t)((x86)<(x76)); + x88 = (x85)+(x87); + x89 = (x88)+(x77); + x90 = (uintptr_t)((x89)<(x77)); + x91 = (x89)+(x74); + x92 = (uintptr_t)((x91)<(x74)); + x93 = (x90)+(x92); + x94 = (x93)+(x75); + x95 = (uintptr_t)((x94)<(x75)); + x96 = (x94)+(x72); + x97 = (uintptr_t)((x96)<(x72)); + x98 = (x95)+(x97); + x99 = (x98)+(x73); + x100 = (uintptr_t)((x99)<(x73)); + x101 = (x99)+(x70); + x102 = (uintptr_t)((x101)<(x70)); + x103 = (x100)+(x102); + x104 = (x103)+(x71); + x105 = (uintptr_t)((x104)<(x71)); + x106 = (x104)+(x68); + x107 = (uintptr_t)((x106)<(x68)); + x108 = (x105)+(x107); + x109 = (x108)+(x69); + x110 = (uintptr_t)((x109)<(x69)); + x111 = (x109)+(x66); + x112 = (uintptr_t)((x111)<(x66)); + x113 = (x110)+(x112); + x114 = (x113)+(x67); + x115 = (x30)+(x80); + x116 = (uintptr_t)((x115)<(x30)); + x117 = (x116)+(x32); + x118 = (uintptr_t)((x117)<(x32)); + x119 = (x117)+(x82); + x120 = (uintptr_t)((x119)<(x82)); + x121 = (x118)+(x120); + x122 = (x121)+(x36); + x123 = (uintptr_t)((x122)<(x36)); + x124 = (x122)+(x86); + x125 = (uintptr_t)((x124)<(x86)); + x126 = (x123)+(x125); + x127 = (x126)+(x41); + x128 = (uintptr_t)((x127)<(x41)); + x129 = (x127)+(x91); + x130 = (uintptr_t)((x129)<(x91)); + x131 = (x128)+(x130); + x132 = (x131)+(x46); + x133 = (uintptr_t)((x132)<(x46)); + x134 = (x132)+(x96); + x135 = (uintptr_t)((x134)<(x96)); + x136 = (x133)+(x135); + x137 = (x136)+(x51); + x138 = (uintptr_t)((x137)<(x51)); + x139 = (x137)+(x101); + x140 = (uintptr_t)((x139)<(x101)); + x141 = (x138)+(x140); + x142 = (x141)+(x56); + x143 = (uintptr_t)((x142)<(x56)); + x144 = (x142)+(x106); + x145 = (uintptr_t)((x144)<(x106)); + x146 = (x143)+(x145); + x147 = (x146)+(x61); + x148 = (uintptr_t)((x147)<(x61)); + x149 = (x147)+(x111); + x150 = (uintptr_t)((x149)<(x111)); + x151 = (x148)+(x150); + x152 = (x151)+(x64); + x153 = (uintptr_t)((x152)<(x64)); + x154 = (x152)+(x114); + x155 = (uintptr_t)((x154)<(x114)); + x156 = (x153)+(x155); + x157 = (x8)*(x7); + x158 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x7))>>32 : ((__uint128_t)(x8)*(x7))>>64); + x159 = (x8)*(x6); + x160 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x6))>>32 : ((__uint128_t)(x8)*(x6))>>64); + x161 = (x8)*(x5); + x162 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x5))>>32 : ((__uint128_t)(x8)*(x5))>>64); + x163 = (x8)*(x4); + x164 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x4))>>32 : ((__uint128_t)(x8)*(x4))>>64); + x165 = (x8)*(x3); + x166 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x3))>>32 : ((__uint128_t)(x8)*(x3))>>64); + x167 = (x8)*(x2); + x168 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x2))>>32 : ((__uint128_t)(x8)*(x2))>>64); + x169 = (x8)*(x1); + x170 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x1))>>32 : ((__uint128_t)(x8)*(x1))>>64); + x171 = (x8)*(x0); + x172 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x0))>>32 : ((__uint128_t)(x8)*(x0))>>64); + x173 = (x172)+(x169); + x174 = (uintptr_t)((x173)<(x172)); + x175 = (x174)+(x170); + x176 = (uintptr_t)((x175)<(x170)); + x177 = (x175)+(x167); + x178 = (uintptr_t)((x177)<(x167)); + x179 = (x176)+(x178); + x180 = (x179)+(x168); + x181 = (uintptr_t)((x180)<(x168)); + x182 = (x180)+(x165); + x183 = (uintptr_t)((x182)<(x165)); + x184 = (x181)+(x183); + x185 = (x184)+(x166); + x186 = (uintptr_t)((x185)<(x166)); + x187 = (x185)+(x163); + x188 = (uintptr_t)((x187)<(x163)); + x189 = (x186)+(x188); + x190 = (x189)+(x164); + x191 = (uintptr_t)((x190)<(x164)); + x192 = (x190)+(x161); + x193 = (uintptr_t)((x192)<(x161)); + x194 = (x191)+(x193); + x195 = (x194)+(x162); + x196 = (uintptr_t)((x195)<(x162)); + x197 = (x195)+(x159); + x198 = (uintptr_t)((x197)<(x159)); + x199 = (x196)+(x198); + x200 = (x199)+(x160); + x201 = (uintptr_t)((x200)<(x160)); + x202 = (x200)+(x157); + x203 = (uintptr_t)((x202)<(x157)); + x204 = (x201)+(x203); + x205 = (x204)+(x158); + x206 = (x119)+(x171); + x207 = (uintptr_t)((x206)<(x119)); + x208 = (x207)+(x124); + x209 = (uintptr_t)((x208)<(x124)); + x210 = (x208)+(x173); + x211 = (uintptr_t)((x210)<(x173)); + x212 = (x209)+(x211); + x213 = (x212)+(x129); + x214 = (uintptr_t)((x213)<(x129)); + x215 = (x213)+(x177); + x216 = (uintptr_t)((x215)<(x177)); + x217 = (x214)+(x216); + x218 = (x217)+(x134); + x219 = (uintptr_t)((x218)<(x134)); + x220 = (x218)+(x182); + x221 = (uintptr_t)((x220)<(x182)); + x222 = (x219)+(x221); + x223 = (x222)+(x139); + x224 = (uintptr_t)((x223)<(x139)); + x225 = (x223)+(x187); + x226 = (uintptr_t)((x225)<(x187)); + x227 = (x224)+(x226); + x228 = (x227)+(x144); + x229 = (uintptr_t)((x228)<(x144)); + x230 = (x228)+(x192); + x231 = (uintptr_t)((x230)<(x192)); + x232 = (x229)+(x231); + x233 = (x232)+(x149); + x234 = (uintptr_t)((x233)<(x149)); + x235 = (x233)+(x197); + x236 = (uintptr_t)((x235)<(x197)); + x237 = (x234)+(x236); + x238 = (x237)+(x154); + x239 = (uintptr_t)((x238)<(x154)); + x240 = (x238)+(x202); + x241 = (uintptr_t)((x240)<(x202)); + x242 = (x239)+(x241); + x243 = (x242)+(x156); + x244 = (uintptr_t)((x243)<(x156)); + x245 = (x243)+(x205); + x246 = (uintptr_t)((x245)<(x205)); + x247 = (x244)+(x246); + x248 = (x206)*((uintptr_t)1435021631ULL); + x249 = (x248)*((uintptr_t)4294967295ULL); + x250 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x248)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x248)*((uintptr_t)4294967295ULL))>>64); + x251 = (x248)*((uintptr_t)4294967295ULL); + x252 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x248)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x248)*((uintptr_t)4294967295ULL))>>64); + x253 = (x248)*((uintptr_t)4294967295ULL); + x254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x248)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x248)*((uintptr_t)4294967295ULL))>>64); + x255 = (x248)*((uintptr_t)4294967294ULL); + x256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x248)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x248)*((uintptr_t)4294967294ULL))>>64); + x257 = (x248)*((uintptr_t)3132021990ULL); + x258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x248)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x248)*((uintptr_t)3132021990ULL))>>64); + x259 = (x248)*((uintptr_t)2940772411ULL); + x260 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x248)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x248)*((uintptr_t)2940772411ULL))>>64); + x261 = (x248)*((uintptr_t)3218235020ULL); + x262 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x248)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x248)*((uintptr_t)3218235020ULL))>>64); + x263 = (x248)*((uintptr_t)3493216577ULL); + x264 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x248)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x248)*((uintptr_t)3493216577ULL))>>64); + x265 = (x264)+(x261); + x266 = (uintptr_t)((x265)<(x264)); + x267 = (x266)+(x262); + x268 = (uintptr_t)((x267)<(x262)); + x269 = (x267)+(x259); + x270 = (uintptr_t)((x269)<(x259)); + x271 = (x268)+(x270); + x272 = (x271)+(x260); + x273 = (uintptr_t)((x272)<(x260)); + x274 = (x272)+(x257); + x275 = (uintptr_t)((x274)<(x257)); + x276 = (x273)+(x275); + x277 = (x276)+(x258); + x278 = (uintptr_t)((x277)<(x258)); + x279 = (x277)+(x255); + x280 = (uintptr_t)((x279)<(x255)); + x281 = (x278)+(x280); + x282 = (x281)+(x256); + x283 = (uintptr_t)((x282)<(x256)); + x284 = (x282)+(x253); + x285 = (uintptr_t)((x284)<(x253)); + x286 = (x283)+(x285); + x287 = (x286)+(x254); + x288 = (uintptr_t)((x287)<(x254)); + x289 = (x287)+(x251); + x290 = (uintptr_t)((x289)<(x251)); + x291 = (x288)+(x290); + x292 = (x291)+(x252); + x293 = (uintptr_t)((x292)<(x252)); + x294 = (x292)+(x249); + x295 = (uintptr_t)((x294)<(x249)); + x296 = (x293)+(x295); + x297 = (x296)+(x250); + x298 = (x206)+(x263); + x299 = (uintptr_t)((x298)<(x206)); + x300 = (x299)+(x210); + x301 = (uintptr_t)((x300)<(x210)); + x302 = (x300)+(x265); + x303 = (uintptr_t)((x302)<(x265)); + x304 = (x301)+(x303); + x305 = (x304)+(x215); + x306 = (uintptr_t)((x305)<(x215)); + x307 = (x305)+(x269); + x308 = (uintptr_t)((x307)<(x269)); + x309 = (x306)+(x308); + x310 = (x309)+(x220); + x311 = (uintptr_t)((x310)<(x220)); + x312 = (x310)+(x274); + x313 = (uintptr_t)((x312)<(x274)); + x314 = (x311)+(x313); + x315 = (x314)+(x225); + x316 = (uintptr_t)((x315)<(x225)); + x317 = (x315)+(x279); + x318 = (uintptr_t)((x317)<(x279)); + x319 = (x316)+(x318); + x320 = (x319)+(x230); + x321 = (uintptr_t)((x320)<(x230)); + x322 = (x320)+(x284); + x323 = (uintptr_t)((x322)<(x284)); + x324 = (x321)+(x323); + x325 = (x324)+(x235); + x326 = (uintptr_t)((x325)<(x235)); + x327 = (x325)+(x289); + x328 = (uintptr_t)((x327)<(x289)); + x329 = (x326)+(x328); + x330 = (x329)+(x240); + x331 = (uintptr_t)((x330)<(x240)); + x332 = (x330)+(x294); + x333 = (uintptr_t)((x332)<(x294)); + x334 = (x331)+(x333); + x335 = (x334)+(x245); + x336 = (uintptr_t)((x335)<(x245)); + x337 = (x335)+(x297); + x338 = (uintptr_t)((x337)<(x297)); + x339 = (x336)+(x338); + x340 = (x339)+(x247); + x341 = (x9)*(x7); + x342 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x7))>>32 : ((__uint128_t)(x9)*(x7))>>64); + x343 = (x9)*(x6); + x344 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x6))>>32 : ((__uint128_t)(x9)*(x6))>>64); + x345 = (x9)*(x5); + x346 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x5))>>32 : ((__uint128_t)(x9)*(x5))>>64); + x347 = (x9)*(x4); + x348 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x4))>>32 : ((__uint128_t)(x9)*(x4))>>64); + x349 = (x9)*(x3); + x350 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x3))>>32 : ((__uint128_t)(x9)*(x3))>>64); + x351 = (x9)*(x2); + x352 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x2))>>32 : ((__uint128_t)(x9)*(x2))>>64); + x353 = (x9)*(x1); + x354 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x1))>>32 : ((__uint128_t)(x9)*(x1))>>64); + x355 = (x9)*(x0); + x356 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x0))>>32 : ((__uint128_t)(x9)*(x0))>>64); + x357 = (x356)+(x353); + x358 = (uintptr_t)((x357)<(x356)); + x359 = (x358)+(x354); + x360 = (uintptr_t)((x359)<(x354)); + x361 = (x359)+(x351); + x362 = (uintptr_t)((x361)<(x351)); + x363 = (x360)+(x362); + x364 = (x363)+(x352); + x365 = (uintptr_t)((x364)<(x352)); + x366 = (x364)+(x349); + x367 = (uintptr_t)((x366)<(x349)); + x368 = (x365)+(x367); + x369 = (x368)+(x350); + x370 = (uintptr_t)((x369)<(x350)); + x371 = (x369)+(x347); + x372 = (uintptr_t)((x371)<(x347)); + x373 = (x370)+(x372); + x374 = (x373)+(x348); + x375 = (uintptr_t)((x374)<(x348)); + x376 = (x374)+(x345); + x377 = (uintptr_t)((x376)<(x345)); + x378 = (x375)+(x377); + x379 = (x378)+(x346); + x380 = (uintptr_t)((x379)<(x346)); + x381 = (x379)+(x343); + x382 = (uintptr_t)((x381)<(x343)); + x383 = (x380)+(x382); + x384 = (x383)+(x344); + x385 = (uintptr_t)((x384)<(x344)); + x386 = (x384)+(x341); + x387 = (uintptr_t)((x386)<(x341)); + x388 = (x385)+(x387); + x389 = (x388)+(x342); + x390 = (x302)+(x355); + x391 = (uintptr_t)((x390)<(x302)); + x392 = (x391)+(x307); + x393 = (uintptr_t)((x392)<(x307)); + x394 = (x392)+(x357); + x395 = (uintptr_t)((x394)<(x357)); + x396 = (x393)+(x395); + x397 = (x396)+(x312); + x398 = (uintptr_t)((x397)<(x312)); + x399 = (x397)+(x361); + x400 = (uintptr_t)((x399)<(x361)); + x401 = (x398)+(x400); + x402 = (x401)+(x317); + x403 = (uintptr_t)((x402)<(x317)); + x404 = (x402)+(x366); + x405 = (uintptr_t)((x404)<(x366)); + x406 = (x403)+(x405); + x407 = (x406)+(x322); + x408 = (uintptr_t)((x407)<(x322)); + x409 = (x407)+(x371); + x410 = (uintptr_t)((x409)<(x371)); + x411 = (x408)+(x410); + x412 = (x411)+(x327); + x413 = (uintptr_t)((x412)<(x327)); + x414 = (x412)+(x376); + x415 = (uintptr_t)((x414)<(x376)); + x416 = (x413)+(x415); + x417 = (x416)+(x332); + x418 = (uintptr_t)((x417)<(x332)); + x419 = (x417)+(x381); + x420 = (uintptr_t)((x419)<(x381)); + x421 = (x418)+(x420); + x422 = (x421)+(x337); + x423 = (uintptr_t)((x422)<(x337)); + x424 = (x422)+(x386); + x425 = (uintptr_t)((x424)<(x386)); + x426 = (x423)+(x425); + x427 = (x426)+(x340); + x428 = (uintptr_t)((x427)<(x340)); + x429 = (x427)+(x389); + x430 = (uintptr_t)((x429)<(x389)); + x431 = (x428)+(x430); + x432 = (x390)*((uintptr_t)1435021631ULL); + x433 = (x432)*((uintptr_t)4294967295ULL); + x434 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x432)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x432)*((uintptr_t)4294967295ULL))>>64); + x435 = (x432)*((uintptr_t)4294967295ULL); + x436 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x432)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x432)*((uintptr_t)4294967295ULL))>>64); + x437 = (x432)*((uintptr_t)4294967295ULL); + x438 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x432)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x432)*((uintptr_t)4294967295ULL))>>64); + x439 = (x432)*((uintptr_t)4294967294ULL); + x440 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x432)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x432)*((uintptr_t)4294967294ULL))>>64); + x441 = (x432)*((uintptr_t)3132021990ULL); + x442 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x432)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x432)*((uintptr_t)3132021990ULL))>>64); + x443 = (x432)*((uintptr_t)2940772411ULL); + x444 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x432)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x432)*((uintptr_t)2940772411ULL))>>64); + x445 = (x432)*((uintptr_t)3218235020ULL); + x446 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x432)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x432)*((uintptr_t)3218235020ULL))>>64); + x447 = (x432)*((uintptr_t)3493216577ULL); + x448 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x432)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x432)*((uintptr_t)3493216577ULL))>>64); + x449 = (x448)+(x445); + x450 = (uintptr_t)((x449)<(x448)); + x451 = (x450)+(x446); + x452 = (uintptr_t)((x451)<(x446)); + x453 = (x451)+(x443); + x454 = (uintptr_t)((x453)<(x443)); + x455 = (x452)+(x454); + x456 = (x455)+(x444); + x457 = (uintptr_t)((x456)<(x444)); + x458 = (x456)+(x441); + x459 = (uintptr_t)((x458)<(x441)); + x460 = (x457)+(x459); + x461 = (x460)+(x442); + x462 = (uintptr_t)((x461)<(x442)); + x463 = (x461)+(x439); + x464 = (uintptr_t)((x463)<(x439)); + x465 = (x462)+(x464); + x466 = (x465)+(x440); + x467 = (uintptr_t)((x466)<(x440)); + x468 = (x466)+(x437); + x469 = (uintptr_t)((x468)<(x437)); + x470 = (x467)+(x469); + x471 = (x470)+(x438); + x472 = (uintptr_t)((x471)<(x438)); + x473 = (x471)+(x435); + x474 = (uintptr_t)((x473)<(x435)); + x475 = (x472)+(x474); + x476 = (x475)+(x436); + x477 = (uintptr_t)((x476)<(x436)); + x478 = (x476)+(x433); + x479 = (uintptr_t)((x478)<(x433)); + x480 = (x477)+(x479); + x481 = (x480)+(x434); + x482 = (x390)+(x447); + x483 = (uintptr_t)((x482)<(x390)); + x484 = (x483)+(x394); + x485 = (uintptr_t)((x484)<(x394)); + x486 = (x484)+(x449); + x487 = (uintptr_t)((x486)<(x449)); + x488 = (x485)+(x487); + x489 = (x488)+(x399); + x490 = (uintptr_t)((x489)<(x399)); + x491 = (x489)+(x453); + x492 = (uintptr_t)((x491)<(x453)); + x493 = (x490)+(x492); + x494 = (x493)+(x404); + x495 = (uintptr_t)((x494)<(x404)); + x496 = (x494)+(x458); + x497 = (uintptr_t)((x496)<(x458)); + x498 = (x495)+(x497); + x499 = (x498)+(x409); + x500 = (uintptr_t)((x499)<(x409)); + x501 = (x499)+(x463); + x502 = (uintptr_t)((x501)<(x463)); + x503 = (x500)+(x502); + x504 = (x503)+(x414); + x505 = (uintptr_t)((x504)<(x414)); + x506 = (x504)+(x468); + x507 = (uintptr_t)((x506)<(x468)); + x508 = (x505)+(x507); + x509 = (x508)+(x419); + x510 = (uintptr_t)((x509)<(x419)); + x511 = (x509)+(x473); + x512 = (uintptr_t)((x511)<(x473)); + x513 = (x510)+(x512); + x514 = (x513)+(x424); + x515 = (uintptr_t)((x514)<(x424)); + x516 = (x514)+(x478); + x517 = (uintptr_t)((x516)<(x478)); + x518 = (x515)+(x517); + x519 = (x518)+(x429); + x520 = (uintptr_t)((x519)<(x429)); + x521 = (x519)+(x481); + x522 = (uintptr_t)((x521)<(x481)); + x523 = (x520)+(x522); + x524 = (x523)+(x431); + x525 = (x10)*(x7); + x526 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x7))>>32 : ((__uint128_t)(x10)*(x7))>>64); + x527 = (x10)*(x6); + x528 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x6))>>32 : ((__uint128_t)(x10)*(x6))>>64); + x529 = (x10)*(x5); + x530 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x5))>>32 : ((__uint128_t)(x10)*(x5))>>64); + x531 = (x10)*(x4); + x532 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x4))>>32 : ((__uint128_t)(x10)*(x4))>>64); + x533 = (x10)*(x3); + x534 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x3))>>32 : ((__uint128_t)(x10)*(x3))>>64); + x535 = (x10)*(x2); + x536 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x2))>>32 : ((__uint128_t)(x10)*(x2))>>64); + x537 = (x10)*(x1); + x538 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x1))>>32 : ((__uint128_t)(x10)*(x1))>>64); + x539 = (x10)*(x0); + x540 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x0))>>32 : ((__uint128_t)(x10)*(x0))>>64); + x541 = (x540)+(x537); + x542 = (uintptr_t)((x541)<(x540)); + x543 = (x542)+(x538); + x544 = (uintptr_t)((x543)<(x538)); + x545 = (x543)+(x535); + x546 = (uintptr_t)((x545)<(x535)); + x547 = (x544)+(x546); + x548 = (x547)+(x536); + x549 = (uintptr_t)((x548)<(x536)); + x550 = (x548)+(x533); + x551 = (uintptr_t)((x550)<(x533)); + x552 = (x549)+(x551); + x553 = (x552)+(x534); + x554 = (uintptr_t)((x553)<(x534)); + x555 = (x553)+(x531); + x556 = (uintptr_t)((x555)<(x531)); + x557 = (x554)+(x556); + x558 = (x557)+(x532); + x559 = (uintptr_t)((x558)<(x532)); + x560 = (x558)+(x529); + x561 = (uintptr_t)((x560)<(x529)); + x562 = (x559)+(x561); + x563 = (x562)+(x530); + x564 = (uintptr_t)((x563)<(x530)); + x565 = (x563)+(x527); + x566 = (uintptr_t)((x565)<(x527)); + x567 = (x564)+(x566); + x568 = (x567)+(x528); + x569 = (uintptr_t)((x568)<(x528)); + x570 = (x568)+(x525); + x571 = (uintptr_t)((x570)<(x525)); + x572 = (x569)+(x571); + x573 = (x572)+(x526); + x574 = (x486)+(x539); + x575 = (uintptr_t)((x574)<(x486)); + x576 = (x575)+(x491); + x577 = (uintptr_t)((x576)<(x491)); + x578 = (x576)+(x541); + x579 = (uintptr_t)((x578)<(x541)); + x580 = (x577)+(x579); + x581 = (x580)+(x496); + x582 = (uintptr_t)((x581)<(x496)); + x583 = (x581)+(x545); + x584 = (uintptr_t)((x583)<(x545)); + x585 = (x582)+(x584); + x586 = (x585)+(x501); + x587 = (uintptr_t)((x586)<(x501)); + x588 = (x586)+(x550); + x589 = (uintptr_t)((x588)<(x550)); + x590 = (x587)+(x589); + x591 = (x590)+(x506); + x592 = (uintptr_t)((x591)<(x506)); + x593 = (x591)+(x555); + x594 = (uintptr_t)((x593)<(x555)); + x595 = (x592)+(x594); + x596 = (x595)+(x511); + x597 = (uintptr_t)((x596)<(x511)); + x598 = (x596)+(x560); + x599 = (uintptr_t)((x598)<(x560)); + x600 = (x597)+(x599); + x601 = (x600)+(x516); + x602 = (uintptr_t)((x601)<(x516)); + x603 = (x601)+(x565); + x604 = (uintptr_t)((x603)<(x565)); + x605 = (x602)+(x604); + x606 = (x605)+(x521); + x607 = (uintptr_t)((x606)<(x521)); + x608 = (x606)+(x570); + x609 = (uintptr_t)((x608)<(x570)); + x610 = (x607)+(x609); + x611 = (x610)+(x524); + x612 = (uintptr_t)((x611)<(x524)); + x613 = (x611)+(x573); + x614 = (uintptr_t)((x613)<(x573)); + x615 = (x612)+(x614); + x616 = (x574)*((uintptr_t)1435021631ULL); + x617 = (x616)*((uintptr_t)4294967295ULL); + x618 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x616)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x616)*((uintptr_t)4294967295ULL))>>64); + x619 = (x616)*((uintptr_t)4294967295ULL); + x620 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x616)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x616)*((uintptr_t)4294967295ULL))>>64); + x621 = (x616)*((uintptr_t)4294967295ULL); + x622 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x616)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x616)*((uintptr_t)4294967295ULL))>>64); + x623 = (x616)*((uintptr_t)4294967294ULL); + x624 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x616)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x616)*((uintptr_t)4294967294ULL))>>64); + x625 = (x616)*((uintptr_t)3132021990ULL); + x626 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x616)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x616)*((uintptr_t)3132021990ULL))>>64); + x627 = (x616)*((uintptr_t)2940772411ULL); + x628 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x616)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x616)*((uintptr_t)2940772411ULL))>>64); + x629 = (x616)*((uintptr_t)3218235020ULL); + x630 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x616)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x616)*((uintptr_t)3218235020ULL))>>64); + x631 = (x616)*((uintptr_t)3493216577ULL); + x632 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x616)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x616)*((uintptr_t)3493216577ULL))>>64); + x633 = (x632)+(x629); + x634 = (uintptr_t)((x633)<(x632)); + x635 = (x634)+(x630); + x636 = (uintptr_t)((x635)<(x630)); + x637 = (x635)+(x627); + x638 = (uintptr_t)((x637)<(x627)); + x639 = (x636)+(x638); + x640 = (x639)+(x628); + x641 = (uintptr_t)((x640)<(x628)); + x642 = (x640)+(x625); + x643 = (uintptr_t)((x642)<(x625)); + x644 = (x641)+(x643); + x645 = (x644)+(x626); + x646 = (uintptr_t)((x645)<(x626)); + x647 = (x645)+(x623); + x648 = (uintptr_t)((x647)<(x623)); + x649 = (x646)+(x648); + x650 = (x649)+(x624); + x651 = (uintptr_t)((x650)<(x624)); + x652 = (x650)+(x621); + x653 = (uintptr_t)((x652)<(x621)); + x654 = (x651)+(x653); + x655 = (x654)+(x622); + x656 = (uintptr_t)((x655)<(x622)); + x657 = (x655)+(x619); + x658 = (uintptr_t)((x657)<(x619)); + x659 = (x656)+(x658); + x660 = (x659)+(x620); + x661 = (uintptr_t)((x660)<(x620)); + x662 = (x660)+(x617); + x663 = (uintptr_t)((x662)<(x617)); + x664 = (x661)+(x663); + x665 = (x664)+(x618); + x666 = (x574)+(x631); + x667 = (uintptr_t)((x666)<(x574)); + x668 = (x667)+(x578); + x669 = (uintptr_t)((x668)<(x578)); + x670 = (x668)+(x633); + x671 = (uintptr_t)((x670)<(x633)); + x672 = (x669)+(x671); + x673 = (x672)+(x583); + x674 = (uintptr_t)((x673)<(x583)); + x675 = (x673)+(x637); + x676 = (uintptr_t)((x675)<(x637)); + x677 = (x674)+(x676); + x678 = (x677)+(x588); + x679 = (uintptr_t)((x678)<(x588)); + x680 = (x678)+(x642); + x681 = (uintptr_t)((x680)<(x642)); + x682 = (x679)+(x681); + x683 = (x682)+(x593); + x684 = (uintptr_t)((x683)<(x593)); + x685 = (x683)+(x647); + x686 = (uintptr_t)((x685)<(x647)); + x687 = (x684)+(x686); + x688 = (x687)+(x598); + x689 = (uintptr_t)((x688)<(x598)); + x690 = (x688)+(x652); + x691 = (uintptr_t)((x690)<(x652)); + x692 = (x689)+(x691); + x693 = (x692)+(x603); + x694 = (uintptr_t)((x693)<(x603)); + x695 = (x693)+(x657); + x696 = (uintptr_t)((x695)<(x657)); + x697 = (x694)+(x696); + x698 = (x697)+(x608); + x699 = (uintptr_t)((x698)<(x608)); + x700 = (x698)+(x662); + x701 = (uintptr_t)((x700)<(x662)); + x702 = (x699)+(x701); + x703 = (x702)+(x613); + x704 = (uintptr_t)((x703)<(x613)); + x705 = (x703)+(x665); + x706 = (uintptr_t)((x705)<(x665)); + x707 = (x704)+(x706); + x708 = (x707)+(x615); + x709 = (x11)*(x7); + x710 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x7))>>32 : ((__uint128_t)(x11)*(x7))>>64); + x711 = (x11)*(x6); + x712 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x6))>>32 : ((__uint128_t)(x11)*(x6))>>64); + x713 = (x11)*(x5); + x714 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x5))>>32 : ((__uint128_t)(x11)*(x5))>>64); + x715 = (x11)*(x4); + x716 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x4))>>32 : ((__uint128_t)(x11)*(x4))>>64); + x717 = (x11)*(x3); + x718 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x3))>>32 : ((__uint128_t)(x11)*(x3))>>64); + x719 = (x11)*(x2); + x720 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x2))>>32 : ((__uint128_t)(x11)*(x2))>>64); + x721 = (x11)*(x1); + x722 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x1))>>32 : ((__uint128_t)(x11)*(x1))>>64); + x723 = (x11)*(x0); + x724 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x0))>>32 : ((__uint128_t)(x11)*(x0))>>64); + x725 = (x724)+(x721); + x726 = (uintptr_t)((x725)<(x724)); + x727 = (x726)+(x722); + x728 = (uintptr_t)((x727)<(x722)); + x729 = (x727)+(x719); + x730 = (uintptr_t)((x729)<(x719)); + x731 = (x728)+(x730); + x732 = (x731)+(x720); + x733 = (uintptr_t)((x732)<(x720)); + x734 = (x732)+(x717); + x735 = (uintptr_t)((x734)<(x717)); + x736 = (x733)+(x735); + x737 = (x736)+(x718); + x738 = (uintptr_t)((x737)<(x718)); + x739 = (x737)+(x715); + x740 = (uintptr_t)((x739)<(x715)); + x741 = (x738)+(x740); + x742 = (x741)+(x716); + x743 = (uintptr_t)((x742)<(x716)); + x744 = (x742)+(x713); + x745 = (uintptr_t)((x744)<(x713)); + x746 = (x743)+(x745); + x747 = (x746)+(x714); + x748 = (uintptr_t)((x747)<(x714)); + x749 = (x747)+(x711); + x750 = (uintptr_t)((x749)<(x711)); + x751 = (x748)+(x750); + x752 = (x751)+(x712); + x753 = (uintptr_t)((x752)<(x712)); + x754 = (x752)+(x709); + x755 = (uintptr_t)((x754)<(x709)); + x756 = (x753)+(x755); + x757 = (x756)+(x710); + x758 = (x670)+(x723); + x759 = (uintptr_t)((x758)<(x670)); + x760 = (x759)+(x675); + x761 = (uintptr_t)((x760)<(x675)); + x762 = (x760)+(x725); + x763 = (uintptr_t)((x762)<(x725)); + x764 = (x761)+(x763); + x765 = (x764)+(x680); + x766 = (uintptr_t)((x765)<(x680)); + x767 = (x765)+(x729); + x768 = (uintptr_t)((x767)<(x729)); + x769 = (x766)+(x768); + x770 = (x769)+(x685); + x771 = (uintptr_t)((x770)<(x685)); + x772 = (x770)+(x734); + x773 = (uintptr_t)((x772)<(x734)); + x774 = (x771)+(x773); + x775 = (x774)+(x690); + x776 = (uintptr_t)((x775)<(x690)); + x777 = (x775)+(x739); + x778 = (uintptr_t)((x777)<(x739)); + x779 = (x776)+(x778); + x780 = (x779)+(x695); + x781 = (uintptr_t)((x780)<(x695)); + x782 = (x780)+(x744); + x783 = (uintptr_t)((x782)<(x744)); + x784 = (x781)+(x783); + x785 = (x784)+(x700); + x786 = (uintptr_t)((x785)<(x700)); + x787 = (x785)+(x749); + x788 = (uintptr_t)((x787)<(x749)); + x789 = (x786)+(x788); + x790 = (x789)+(x705); + x791 = (uintptr_t)((x790)<(x705)); + x792 = (x790)+(x754); + x793 = (uintptr_t)((x792)<(x754)); + x794 = (x791)+(x793); + x795 = (x794)+(x708); + x796 = (uintptr_t)((x795)<(x708)); + x797 = (x795)+(x757); + x798 = (uintptr_t)((x797)<(x757)); + x799 = (x796)+(x798); + x800 = (x758)*((uintptr_t)1435021631ULL); + x801 = (x800)*((uintptr_t)4294967295ULL); + x802 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x800)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x800)*((uintptr_t)4294967295ULL))>>64); + x803 = (x800)*((uintptr_t)4294967295ULL); + x804 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x800)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x800)*((uintptr_t)4294967295ULL))>>64); + x805 = (x800)*((uintptr_t)4294967295ULL); + x806 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x800)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x800)*((uintptr_t)4294967295ULL))>>64); + x807 = (x800)*((uintptr_t)4294967294ULL); + x808 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x800)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x800)*((uintptr_t)4294967294ULL))>>64); + x809 = (x800)*((uintptr_t)3132021990ULL); + x810 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x800)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x800)*((uintptr_t)3132021990ULL))>>64); + x811 = (x800)*((uintptr_t)2940772411ULL); + x812 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x800)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x800)*((uintptr_t)2940772411ULL))>>64); + x813 = (x800)*((uintptr_t)3218235020ULL); + x814 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x800)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x800)*((uintptr_t)3218235020ULL))>>64); + x815 = (x800)*((uintptr_t)3493216577ULL); + x816 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x800)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x800)*((uintptr_t)3493216577ULL))>>64); + x817 = (x816)+(x813); + x818 = (uintptr_t)((x817)<(x816)); + x819 = (x818)+(x814); + x820 = (uintptr_t)((x819)<(x814)); + x821 = (x819)+(x811); + x822 = (uintptr_t)((x821)<(x811)); + x823 = (x820)+(x822); + x824 = (x823)+(x812); + x825 = (uintptr_t)((x824)<(x812)); + x826 = (x824)+(x809); + x827 = (uintptr_t)((x826)<(x809)); + x828 = (x825)+(x827); + x829 = (x828)+(x810); + x830 = (uintptr_t)((x829)<(x810)); + x831 = (x829)+(x807); + x832 = (uintptr_t)((x831)<(x807)); + x833 = (x830)+(x832); + x834 = (x833)+(x808); + x835 = (uintptr_t)((x834)<(x808)); + x836 = (x834)+(x805); + x837 = (uintptr_t)((x836)<(x805)); + x838 = (x835)+(x837); + x839 = (x838)+(x806); + x840 = (uintptr_t)((x839)<(x806)); + x841 = (x839)+(x803); + x842 = (uintptr_t)((x841)<(x803)); + x843 = (x840)+(x842); + x844 = (x843)+(x804); + x845 = (uintptr_t)((x844)<(x804)); + x846 = (x844)+(x801); + x847 = (uintptr_t)((x846)<(x801)); + x848 = (x845)+(x847); + x849 = (x848)+(x802); + x850 = (x758)+(x815); + x851 = (uintptr_t)((x850)<(x758)); + x852 = (x851)+(x762); + x853 = (uintptr_t)((x852)<(x762)); + x854 = (x852)+(x817); + x855 = (uintptr_t)((x854)<(x817)); + x856 = (x853)+(x855); + x857 = (x856)+(x767); + x858 = (uintptr_t)((x857)<(x767)); + x859 = (x857)+(x821); + x860 = (uintptr_t)((x859)<(x821)); + x861 = (x858)+(x860); + x862 = (x861)+(x772); + x863 = (uintptr_t)((x862)<(x772)); + x864 = (x862)+(x826); + x865 = (uintptr_t)((x864)<(x826)); + x866 = (x863)+(x865); + x867 = (x866)+(x777); + x868 = (uintptr_t)((x867)<(x777)); + x869 = (x867)+(x831); + x870 = (uintptr_t)((x869)<(x831)); + x871 = (x868)+(x870); + x872 = (x871)+(x782); + x873 = (uintptr_t)((x872)<(x782)); + x874 = (x872)+(x836); + x875 = (uintptr_t)((x874)<(x836)); + x876 = (x873)+(x875); + x877 = (x876)+(x787); + x878 = (uintptr_t)((x877)<(x787)); + x879 = (x877)+(x841); + x880 = (uintptr_t)((x879)<(x841)); + x881 = (x878)+(x880); + x882 = (x881)+(x792); + x883 = (uintptr_t)((x882)<(x792)); + x884 = (x882)+(x846); + x885 = (uintptr_t)((x884)<(x846)); + x886 = (x883)+(x885); + x887 = (x886)+(x797); + x888 = (uintptr_t)((x887)<(x797)); + x889 = (x887)+(x849); + x890 = (uintptr_t)((x889)<(x849)); + x891 = (x888)+(x890); + x892 = (x891)+(x799); + x893 = (x12)*(x7); + x894 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x7))>>32 : ((__uint128_t)(x12)*(x7))>>64); + x895 = (x12)*(x6); + x896 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x6))>>32 : ((__uint128_t)(x12)*(x6))>>64); + x897 = (x12)*(x5); + x898 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x5))>>32 : ((__uint128_t)(x12)*(x5))>>64); + x899 = (x12)*(x4); + x900 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x4))>>32 : ((__uint128_t)(x12)*(x4))>>64); + x901 = (x12)*(x3); + x902 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x3))>>32 : ((__uint128_t)(x12)*(x3))>>64); + x903 = (x12)*(x2); + x904 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x2))>>32 : ((__uint128_t)(x12)*(x2))>>64); + x905 = (x12)*(x1); + x906 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x1))>>32 : ((__uint128_t)(x12)*(x1))>>64); + x907 = (x12)*(x0); + x908 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x0))>>32 : ((__uint128_t)(x12)*(x0))>>64); + x909 = (x908)+(x905); + x910 = (uintptr_t)((x909)<(x908)); + x911 = (x910)+(x906); + x912 = (uintptr_t)((x911)<(x906)); + x913 = (x911)+(x903); + x914 = (uintptr_t)((x913)<(x903)); + x915 = (x912)+(x914); + x916 = (x915)+(x904); + x917 = (uintptr_t)((x916)<(x904)); + x918 = (x916)+(x901); + x919 = (uintptr_t)((x918)<(x901)); + x920 = (x917)+(x919); + x921 = (x920)+(x902); + x922 = (uintptr_t)((x921)<(x902)); + x923 = (x921)+(x899); + x924 = (uintptr_t)((x923)<(x899)); + x925 = (x922)+(x924); + x926 = (x925)+(x900); + x927 = (uintptr_t)((x926)<(x900)); + x928 = (x926)+(x897); + x929 = (uintptr_t)((x928)<(x897)); + x930 = (x927)+(x929); + x931 = (x930)+(x898); + x932 = (uintptr_t)((x931)<(x898)); + x933 = (x931)+(x895); + x934 = (uintptr_t)((x933)<(x895)); + x935 = (x932)+(x934); + x936 = (x935)+(x896); + x937 = (uintptr_t)((x936)<(x896)); + x938 = (x936)+(x893); + x939 = (uintptr_t)((x938)<(x893)); + x940 = (x937)+(x939); + x941 = (x940)+(x894); + x942 = (x854)+(x907); + x943 = (uintptr_t)((x942)<(x854)); + x944 = (x943)+(x859); + x945 = (uintptr_t)((x944)<(x859)); + x946 = (x944)+(x909); + x947 = (uintptr_t)((x946)<(x909)); + x948 = (x945)+(x947); + x949 = (x948)+(x864); + x950 = (uintptr_t)((x949)<(x864)); + x951 = (x949)+(x913); + x952 = (uintptr_t)((x951)<(x913)); + x953 = (x950)+(x952); + x954 = (x953)+(x869); + x955 = (uintptr_t)((x954)<(x869)); + x956 = (x954)+(x918); + x957 = (uintptr_t)((x956)<(x918)); + x958 = (x955)+(x957); + x959 = (x958)+(x874); + x960 = (uintptr_t)((x959)<(x874)); + x961 = (x959)+(x923); + x962 = (uintptr_t)((x961)<(x923)); + x963 = (x960)+(x962); + x964 = (x963)+(x879); + x965 = (uintptr_t)((x964)<(x879)); + x966 = (x964)+(x928); + x967 = (uintptr_t)((x966)<(x928)); + x968 = (x965)+(x967); + x969 = (x968)+(x884); + x970 = (uintptr_t)((x969)<(x884)); + x971 = (x969)+(x933); + x972 = (uintptr_t)((x971)<(x933)); + x973 = (x970)+(x972); + x974 = (x973)+(x889); + x975 = (uintptr_t)((x974)<(x889)); + x976 = (x974)+(x938); + x977 = (uintptr_t)((x976)<(x938)); + x978 = (x975)+(x977); + x979 = (x978)+(x892); + x980 = (uintptr_t)((x979)<(x892)); + x981 = (x979)+(x941); + x982 = (uintptr_t)((x981)<(x941)); + x983 = (x980)+(x982); + x984 = (x942)*((uintptr_t)1435021631ULL); + x985 = (x984)*((uintptr_t)4294967295ULL); + x986 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)4294967295ULL))>>64); + x987 = (x984)*((uintptr_t)4294967295ULL); + x988 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)4294967295ULL))>>64); + x989 = (x984)*((uintptr_t)4294967295ULL); + x990 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)4294967295ULL))>>64); + x991 = (x984)*((uintptr_t)4294967294ULL); + x992 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)4294967294ULL))>>64); + x993 = (x984)*((uintptr_t)3132021990ULL); + x994 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)3132021990ULL))>>64); + x995 = (x984)*((uintptr_t)2940772411ULL); + x996 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)2940772411ULL))>>64); + x997 = (x984)*((uintptr_t)3218235020ULL); + x998 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)3218235020ULL))>>64); + x999 = (x984)*((uintptr_t)3493216577ULL); + x1000 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x984)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x984)*((uintptr_t)3493216577ULL))>>64); + x1001 = (x1000)+(x997); + x1002 = (uintptr_t)((x1001)<(x1000)); + x1003 = (x1002)+(x998); + x1004 = (uintptr_t)((x1003)<(x998)); + x1005 = (x1003)+(x995); + x1006 = (uintptr_t)((x1005)<(x995)); + x1007 = (x1004)+(x1006); + x1008 = (x1007)+(x996); + x1009 = (uintptr_t)((x1008)<(x996)); + x1010 = (x1008)+(x993); + x1011 = (uintptr_t)((x1010)<(x993)); + x1012 = (x1009)+(x1011); + x1013 = (x1012)+(x994); + x1014 = (uintptr_t)((x1013)<(x994)); + x1015 = (x1013)+(x991); + x1016 = (uintptr_t)((x1015)<(x991)); + x1017 = (x1014)+(x1016); + x1018 = (x1017)+(x992); + x1019 = (uintptr_t)((x1018)<(x992)); + x1020 = (x1018)+(x989); + x1021 = (uintptr_t)((x1020)<(x989)); + x1022 = (x1019)+(x1021); + x1023 = (x1022)+(x990); + x1024 = (uintptr_t)((x1023)<(x990)); + x1025 = (x1023)+(x987); + x1026 = (uintptr_t)((x1025)<(x987)); + x1027 = (x1024)+(x1026); + x1028 = (x1027)+(x988); + x1029 = (uintptr_t)((x1028)<(x988)); + x1030 = (x1028)+(x985); + x1031 = (uintptr_t)((x1030)<(x985)); + x1032 = (x1029)+(x1031); + x1033 = (x1032)+(x986); + x1034 = (x942)+(x999); + x1035 = (uintptr_t)((x1034)<(x942)); + x1036 = (x1035)+(x946); + x1037 = (uintptr_t)((x1036)<(x946)); + x1038 = (x1036)+(x1001); + x1039 = (uintptr_t)((x1038)<(x1001)); + x1040 = (x1037)+(x1039); + x1041 = (x1040)+(x951); + x1042 = (uintptr_t)((x1041)<(x951)); + x1043 = (x1041)+(x1005); + x1044 = (uintptr_t)((x1043)<(x1005)); + x1045 = (x1042)+(x1044); + x1046 = (x1045)+(x956); + x1047 = (uintptr_t)((x1046)<(x956)); + x1048 = (x1046)+(x1010); + x1049 = (uintptr_t)((x1048)<(x1010)); + x1050 = (x1047)+(x1049); + x1051 = (x1050)+(x961); + x1052 = (uintptr_t)((x1051)<(x961)); + x1053 = (x1051)+(x1015); + x1054 = (uintptr_t)((x1053)<(x1015)); + x1055 = (x1052)+(x1054); + x1056 = (x1055)+(x966); + x1057 = (uintptr_t)((x1056)<(x966)); + x1058 = (x1056)+(x1020); + x1059 = (uintptr_t)((x1058)<(x1020)); + x1060 = (x1057)+(x1059); + x1061 = (x1060)+(x971); + x1062 = (uintptr_t)((x1061)<(x971)); + x1063 = (x1061)+(x1025); + x1064 = (uintptr_t)((x1063)<(x1025)); + x1065 = (x1062)+(x1064); + x1066 = (x1065)+(x976); + x1067 = (uintptr_t)((x1066)<(x976)); + x1068 = (x1066)+(x1030); + x1069 = (uintptr_t)((x1068)<(x1030)); + x1070 = (x1067)+(x1069); + x1071 = (x1070)+(x981); + x1072 = (uintptr_t)((x1071)<(x981)); + x1073 = (x1071)+(x1033); + x1074 = (uintptr_t)((x1073)<(x1033)); + x1075 = (x1072)+(x1074); + x1076 = (x1075)+(x983); + x1077 = (x13)*(x7); + x1078 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x7))>>32 : ((__uint128_t)(x13)*(x7))>>64); + x1079 = (x13)*(x6); + x1080 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x6))>>32 : ((__uint128_t)(x13)*(x6))>>64); + x1081 = (x13)*(x5); + x1082 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x5))>>32 : ((__uint128_t)(x13)*(x5))>>64); + x1083 = (x13)*(x4); + x1084 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x4))>>32 : ((__uint128_t)(x13)*(x4))>>64); + x1085 = (x13)*(x3); + x1086 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x3))>>32 : ((__uint128_t)(x13)*(x3))>>64); + x1087 = (x13)*(x2); + x1088 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x2))>>32 : ((__uint128_t)(x13)*(x2))>>64); + x1089 = (x13)*(x1); + x1090 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x1))>>32 : ((__uint128_t)(x13)*(x1))>>64); + x1091 = (x13)*(x0); + x1092 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x0))>>32 : ((__uint128_t)(x13)*(x0))>>64); + x1093 = (x1092)+(x1089); + x1094 = (uintptr_t)((x1093)<(x1092)); + x1095 = (x1094)+(x1090); + x1096 = (uintptr_t)((x1095)<(x1090)); + x1097 = (x1095)+(x1087); + x1098 = (uintptr_t)((x1097)<(x1087)); + x1099 = (x1096)+(x1098); + x1100 = (x1099)+(x1088); + x1101 = (uintptr_t)((x1100)<(x1088)); + x1102 = (x1100)+(x1085); + x1103 = (uintptr_t)((x1102)<(x1085)); + x1104 = (x1101)+(x1103); + x1105 = (x1104)+(x1086); + x1106 = (uintptr_t)((x1105)<(x1086)); + x1107 = (x1105)+(x1083); + x1108 = (uintptr_t)((x1107)<(x1083)); + x1109 = (x1106)+(x1108); + x1110 = (x1109)+(x1084); + x1111 = (uintptr_t)((x1110)<(x1084)); + x1112 = (x1110)+(x1081); + x1113 = (uintptr_t)((x1112)<(x1081)); + x1114 = (x1111)+(x1113); + x1115 = (x1114)+(x1082); + x1116 = (uintptr_t)((x1115)<(x1082)); + x1117 = (x1115)+(x1079); + x1118 = (uintptr_t)((x1117)<(x1079)); + x1119 = (x1116)+(x1118); + x1120 = (x1119)+(x1080); + x1121 = (uintptr_t)((x1120)<(x1080)); + x1122 = (x1120)+(x1077); + x1123 = (uintptr_t)((x1122)<(x1077)); + x1124 = (x1121)+(x1123); + x1125 = (x1124)+(x1078); + x1126 = (x1038)+(x1091); + x1127 = (uintptr_t)((x1126)<(x1038)); + x1128 = (x1127)+(x1043); + x1129 = (uintptr_t)((x1128)<(x1043)); + x1130 = (x1128)+(x1093); + x1131 = (uintptr_t)((x1130)<(x1093)); + x1132 = (x1129)+(x1131); + x1133 = (x1132)+(x1048); + x1134 = (uintptr_t)((x1133)<(x1048)); + x1135 = (x1133)+(x1097); + x1136 = (uintptr_t)((x1135)<(x1097)); + x1137 = (x1134)+(x1136); + x1138 = (x1137)+(x1053); + x1139 = (uintptr_t)((x1138)<(x1053)); + x1140 = (x1138)+(x1102); + x1141 = (uintptr_t)((x1140)<(x1102)); + x1142 = (x1139)+(x1141); + x1143 = (x1142)+(x1058); + x1144 = (uintptr_t)((x1143)<(x1058)); + x1145 = (x1143)+(x1107); + x1146 = (uintptr_t)((x1145)<(x1107)); + x1147 = (x1144)+(x1146); + x1148 = (x1147)+(x1063); + x1149 = (uintptr_t)((x1148)<(x1063)); + x1150 = (x1148)+(x1112); + x1151 = (uintptr_t)((x1150)<(x1112)); + x1152 = (x1149)+(x1151); + x1153 = (x1152)+(x1068); + x1154 = (uintptr_t)((x1153)<(x1068)); + x1155 = (x1153)+(x1117); + x1156 = (uintptr_t)((x1155)<(x1117)); + x1157 = (x1154)+(x1156); + x1158 = (x1157)+(x1073); + x1159 = (uintptr_t)((x1158)<(x1073)); + x1160 = (x1158)+(x1122); + x1161 = (uintptr_t)((x1160)<(x1122)); + x1162 = (x1159)+(x1161); + x1163 = (x1162)+(x1076); + x1164 = (uintptr_t)((x1163)<(x1076)); + x1165 = (x1163)+(x1125); + x1166 = (uintptr_t)((x1165)<(x1125)); + x1167 = (x1164)+(x1166); + x1168 = (x1126)*((uintptr_t)1435021631ULL); + x1169 = (x1168)*((uintptr_t)4294967295ULL); + x1170 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1168)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1168)*((uintptr_t)4294967295ULL))>>64); + x1171 = (x1168)*((uintptr_t)4294967295ULL); + x1172 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1168)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1168)*((uintptr_t)4294967295ULL))>>64); + x1173 = (x1168)*((uintptr_t)4294967295ULL); + x1174 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1168)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1168)*((uintptr_t)4294967295ULL))>>64); + x1175 = (x1168)*((uintptr_t)4294967294ULL); + x1176 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1168)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x1168)*((uintptr_t)4294967294ULL))>>64); + x1177 = (x1168)*((uintptr_t)3132021990ULL); + x1178 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1168)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x1168)*((uintptr_t)3132021990ULL))>>64); + x1179 = (x1168)*((uintptr_t)2940772411ULL); + x1180 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1168)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x1168)*((uintptr_t)2940772411ULL))>>64); + x1181 = (x1168)*((uintptr_t)3218235020ULL); + x1182 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1168)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x1168)*((uintptr_t)3218235020ULL))>>64); + x1183 = (x1168)*((uintptr_t)3493216577ULL); + x1184 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1168)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x1168)*((uintptr_t)3493216577ULL))>>64); + x1185 = (x1184)+(x1181); + x1186 = (uintptr_t)((x1185)<(x1184)); + x1187 = (x1186)+(x1182); + x1188 = (uintptr_t)((x1187)<(x1182)); + x1189 = (x1187)+(x1179); + x1190 = (uintptr_t)((x1189)<(x1179)); + x1191 = (x1188)+(x1190); + x1192 = (x1191)+(x1180); + x1193 = (uintptr_t)((x1192)<(x1180)); + x1194 = (x1192)+(x1177); + x1195 = (uintptr_t)((x1194)<(x1177)); + x1196 = (x1193)+(x1195); + x1197 = (x1196)+(x1178); + x1198 = (uintptr_t)((x1197)<(x1178)); + x1199 = (x1197)+(x1175); + x1200 = (uintptr_t)((x1199)<(x1175)); + x1201 = (x1198)+(x1200); + x1202 = (x1201)+(x1176); + x1203 = (uintptr_t)((x1202)<(x1176)); + x1204 = (x1202)+(x1173); + x1205 = (uintptr_t)((x1204)<(x1173)); + x1206 = (x1203)+(x1205); + x1207 = (x1206)+(x1174); + x1208 = (uintptr_t)((x1207)<(x1174)); + x1209 = (x1207)+(x1171); + x1210 = (uintptr_t)((x1209)<(x1171)); + x1211 = (x1208)+(x1210); + x1212 = (x1211)+(x1172); + x1213 = (uintptr_t)((x1212)<(x1172)); + x1214 = (x1212)+(x1169); + x1215 = (uintptr_t)((x1214)<(x1169)); + x1216 = (x1213)+(x1215); + x1217 = (x1216)+(x1170); + x1218 = (x1126)+(x1183); + x1219 = (uintptr_t)((x1218)<(x1126)); + x1220 = (x1219)+(x1130); + x1221 = (uintptr_t)((x1220)<(x1130)); + x1222 = (x1220)+(x1185); + x1223 = (uintptr_t)((x1222)<(x1185)); + x1224 = (x1221)+(x1223); + x1225 = (x1224)+(x1135); + x1226 = (uintptr_t)((x1225)<(x1135)); + x1227 = (x1225)+(x1189); + x1228 = (uintptr_t)((x1227)<(x1189)); + x1229 = (x1226)+(x1228); + x1230 = (x1229)+(x1140); + x1231 = (uintptr_t)((x1230)<(x1140)); + x1232 = (x1230)+(x1194); + x1233 = (uintptr_t)((x1232)<(x1194)); + x1234 = (x1231)+(x1233); + x1235 = (x1234)+(x1145); + x1236 = (uintptr_t)((x1235)<(x1145)); + x1237 = (x1235)+(x1199); + x1238 = (uintptr_t)((x1237)<(x1199)); + x1239 = (x1236)+(x1238); + x1240 = (x1239)+(x1150); + x1241 = (uintptr_t)((x1240)<(x1150)); + x1242 = (x1240)+(x1204); + x1243 = (uintptr_t)((x1242)<(x1204)); + x1244 = (x1241)+(x1243); + x1245 = (x1244)+(x1155); + x1246 = (uintptr_t)((x1245)<(x1155)); + x1247 = (x1245)+(x1209); + x1248 = (uintptr_t)((x1247)<(x1209)); + x1249 = (x1246)+(x1248); + x1250 = (x1249)+(x1160); + x1251 = (uintptr_t)((x1250)<(x1160)); + x1252 = (x1250)+(x1214); + x1253 = (uintptr_t)((x1252)<(x1214)); + x1254 = (x1251)+(x1253); + x1255 = (x1254)+(x1165); + x1256 = (uintptr_t)((x1255)<(x1165)); + x1257 = (x1255)+(x1217); + x1258 = (uintptr_t)((x1257)<(x1217)); + x1259 = (x1256)+(x1258); + x1260 = (x1259)+(x1167); + x1261 = (x14)*(x7); + x1262 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x7))>>32 : ((__uint128_t)(x14)*(x7))>>64); + x1263 = (x14)*(x6); + x1264 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x6))>>32 : ((__uint128_t)(x14)*(x6))>>64); + x1265 = (x14)*(x5); + x1266 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x5))>>32 : ((__uint128_t)(x14)*(x5))>>64); + x1267 = (x14)*(x4); + x1268 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x4))>>32 : ((__uint128_t)(x14)*(x4))>>64); + x1269 = (x14)*(x3); + x1270 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x3))>>32 : ((__uint128_t)(x14)*(x3))>>64); + x1271 = (x14)*(x2); + x1272 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x2))>>32 : ((__uint128_t)(x14)*(x2))>>64); + x1273 = (x14)*(x1); + x1274 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x1))>>32 : ((__uint128_t)(x14)*(x1))>>64); + x1275 = (x14)*(x0); + x1276 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x0))>>32 : ((__uint128_t)(x14)*(x0))>>64); + x1277 = (x1276)+(x1273); + x1278 = (uintptr_t)((x1277)<(x1276)); + x1279 = (x1278)+(x1274); + x1280 = (uintptr_t)((x1279)<(x1274)); + x1281 = (x1279)+(x1271); + x1282 = (uintptr_t)((x1281)<(x1271)); + x1283 = (x1280)+(x1282); + x1284 = (x1283)+(x1272); + x1285 = (uintptr_t)((x1284)<(x1272)); + x1286 = (x1284)+(x1269); + x1287 = (uintptr_t)((x1286)<(x1269)); + x1288 = (x1285)+(x1287); + x1289 = (x1288)+(x1270); + x1290 = (uintptr_t)((x1289)<(x1270)); + x1291 = (x1289)+(x1267); + x1292 = (uintptr_t)((x1291)<(x1267)); + x1293 = (x1290)+(x1292); + x1294 = (x1293)+(x1268); + x1295 = (uintptr_t)((x1294)<(x1268)); + x1296 = (x1294)+(x1265); + x1297 = (uintptr_t)((x1296)<(x1265)); + x1298 = (x1295)+(x1297); + x1299 = (x1298)+(x1266); + x1300 = (uintptr_t)((x1299)<(x1266)); + x1301 = (x1299)+(x1263); + x1302 = (uintptr_t)((x1301)<(x1263)); + x1303 = (x1300)+(x1302); + x1304 = (x1303)+(x1264); + x1305 = (uintptr_t)((x1304)<(x1264)); + x1306 = (x1304)+(x1261); + x1307 = (uintptr_t)((x1306)<(x1261)); + x1308 = (x1305)+(x1307); + x1309 = (x1308)+(x1262); + x1310 = (x1222)+(x1275); + x1311 = (uintptr_t)((x1310)<(x1222)); + x1312 = (x1311)+(x1227); + x1313 = (uintptr_t)((x1312)<(x1227)); + x1314 = (x1312)+(x1277); + x1315 = (uintptr_t)((x1314)<(x1277)); + x1316 = (x1313)+(x1315); + x1317 = (x1316)+(x1232); + x1318 = (uintptr_t)((x1317)<(x1232)); + x1319 = (x1317)+(x1281); + x1320 = (uintptr_t)((x1319)<(x1281)); + x1321 = (x1318)+(x1320); + x1322 = (x1321)+(x1237); + x1323 = (uintptr_t)((x1322)<(x1237)); + x1324 = (x1322)+(x1286); + x1325 = (uintptr_t)((x1324)<(x1286)); + x1326 = (x1323)+(x1325); + x1327 = (x1326)+(x1242); + x1328 = (uintptr_t)((x1327)<(x1242)); + x1329 = (x1327)+(x1291); + x1330 = (uintptr_t)((x1329)<(x1291)); + x1331 = (x1328)+(x1330); + x1332 = (x1331)+(x1247); + x1333 = (uintptr_t)((x1332)<(x1247)); + x1334 = (x1332)+(x1296); + x1335 = (uintptr_t)((x1334)<(x1296)); + x1336 = (x1333)+(x1335); + x1337 = (x1336)+(x1252); + x1338 = (uintptr_t)((x1337)<(x1252)); + x1339 = (x1337)+(x1301); + x1340 = (uintptr_t)((x1339)<(x1301)); + x1341 = (x1338)+(x1340); + x1342 = (x1341)+(x1257); + x1343 = (uintptr_t)((x1342)<(x1257)); + x1344 = (x1342)+(x1306); + x1345 = (uintptr_t)((x1344)<(x1306)); + x1346 = (x1343)+(x1345); + x1347 = (x1346)+(x1260); + x1348 = (uintptr_t)((x1347)<(x1260)); + x1349 = (x1347)+(x1309); + x1350 = (uintptr_t)((x1349)<(x1309)); + x1351 = (x1348)+(x1350); + x1352 = (x1310)*((uintptr_t)1435021631ULL); + x1353 = (x1352)*((uintptr_t)4294967295ULL); + x1354 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1352)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1352)*((uintptr_t)4294967295ULL))>>64); + x1355 = (x1352)*((uintptr_t)4294967295ULL); + x1356 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1352)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1352)*((uintptr_t)4294967295ULL))>>64); + x1357 = (x1352)*((uintptr_t)4294967295ULL); + x1358 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1352)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1352)*((uintptr_t)4294967295ULL))>>64); + x1359 = (x1352)*((uintptr_t)4294967294ULL); + x1360 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1352)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x1352)*((uintptr_t)4294967294ULL))>>64); + x1361 = (x1352)*((uintptr_t)3132021990ULL); + x1362 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1352)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x1352)*((uintptr_t)3132021990ULL))>>64); + x1363 = (x1352)*((uintptr_t)2940772411ULL); + x1364 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1352)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x1352)*((uintptr_t)2940772411ULL))>>64); + x1365 = (x1352)*((uintptr_t)3218235020ULL); + x1366 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1352)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x1352)*((uintptr_t)3218235020ULL))>>64); + x1367 = (x1352)*((uintptr_t)3493216577ULL); + x1368 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x1352)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x1352)*((uintptr_t)3493216577ULL))>>64); + x1369 = (x1368)+(x1365); + x1370 = (uintptr_t)((x1369)<(x1368)); + x1371 = (x1370)+(x1366); + x1372 = (uintptr_t)((x1371)<(x1366)); + x1373 = (x1371)+(x1363); + x1374 = (uintptr_t)((x1373)<(x1363)); + x1375 = (x1372)+(x1374); + x1376 = (x1375)+(x1364); + x1377 = (uintptr_t)((x1376)<(x1364)); + x1378 = (x1376)+(x1361); + x1379 = (uintptr_t)((x1378)<(x1361)); + x1380 = (x1377)+(x1379); + x1381 = (x1380)+(x1362); + x1382 = (uintptr_t)((x1381)<(x1362)); + x1383 = (x1381)+(x1359); + x1384 = (uintptr_t)((x1383)<(x1359)); + x1385 = (x1382)+(x1384); + x1386 = (x1385)+(x1360); + x1387 = (uintptr_t)((x1386)<(x1360)); + x1388 = (x1386)+(x1357); + x1389 = (uintptr_t)((x1388)<(x1357)); + x1390 = (x1387)+(x1389); + x1391 = (x1390)+(x1358); + x1392 = (uintptr_t)((x1391)<(x1358)); + x1393 = (x1391)+(x1355); + x1394 = (uintptr_t)((x1393)<(x1355)); + x1395 = (x1392)+(x1394); + x1396 = (x1395)+(x1356); + x1397 = (uintptr_t)((x1396)<(x1356)); + x1398 = (x1396)+(x1353); + x1399 = (uintptr_t)((x1398)<(x1353)); + x1400 = (x1397)+(x1399); + x1401 = (x1400)+(x1354); + x1402 = (x1310)+(x1367); + x1403 = (uintptr_t)((x1402)<(x1310)); + x1404 = (x1403)+(x1314); + x1405 = (uintptr_t)((x1404)<(x1314)); + x1406 = (x1404)+(x1369); + x1407 = (uintptr_t)((x1406)<(x1369)); + x1408 = (x1405)+(x1407); + x1409 = (x1408)+(x1319); + x1410 = (uintptr_t)((x1409)<(x1319)); + x1411 = (x1409)+(x1373); + x1412 = (uintptr_t)((x1411)<(x1373)); + x1413 = (x1410)+(x1412); + x1414 = (x1413)+(x1324); + x1415 = (uintptr_t)((x1414)<(x1324)); + x1416 = (x1414)+(x1378); + x1417 = (uintptr_t)((x1416)<(x1378)); + x1418 = (x1415)+(x1417); + x1419 = (x1418)+(x1329); + x1420 = (uintptr_t)((x1419)<(x1329)); + x1421 = (x1419)+(x1383); + x1422 = (uintptr_t)((x1421)<(x1383)); + x1423 = (x1420)+(x1422); + x1424 = (x1423)+(x1334); + x1425 = (uintptr_t)((x1424)<(x1334)); + x1426 = (x1424)+(x1388); + x1427 = (uintptr_t)((x1426)<(x1388)); + x1428 = (x1425)+(x1427); + x1429 = (x1428)+(x1339); + x1430 = (uintptr_t)((x1429)<(x1339)); + x1431 = (x1429)+(x1393); + x1432 = (uintptr_t)((x1431)<(x1393)); + x1433 = (x1430)+(x1432); + x1434 = (x1433)+(x1344); + x1435 = (uintptr_t)((x1434)<(x1344)); + x1436 = (x1434)+(x1398); + x1437 = (uintptr_t)((x1436)<(x1398)); + x1438 = (x1435)+(x1437); + x1439 = (x1438)+(x1349); + x1440 = (uintptr_t)((x1439)<(x1349)); + x1441 = (x1439)+(x1401); + x1442 = (uintptr_t)((x1441)<(x1401)); + x1443 = (x1440)+(x1442); + x1444 = (x1443)+(x1351); + x1445 = (x1406)-((uintptr_t)3493216577ULL); + x1446 = (uintptr_t)((x1406)<(x1445)); + x1447 = (x1411)-((uintptr_t)3218235020ULL); + x1448 = (uintptr_t)((x1411)<(x1447)); + x1449 = (x1447)-(x1446); + x1450 = (uintptr_t)((x1447)<(x1449)); + x1451 = (x1448)+(x1450); + x1452 = (x1416)-((uintptr_t)2940772411ULL); + x1453 = (uintptr_t)((x1416)<(x1452)); + x1454 = (x1452)-(x1451); + x1455 = (uintptr_t)((x1452)<(x1454)); + x1456 = (x1453)+(x1455); + x1457 = (x1421)-((uintptr_t)3132021990ULL); + x1458 = (uintptr_t)((x1421)<(x1457)); + x1459 = (x1457)-(x1456); + x1460 = (uintptr_t)((x1457)<(x1459)); + x1461 = (x1458)+(x1460); + x1462 = (x1426)-((uintptr_t)4294967294ULL); + x1463 = (uintptr_t)((x1426)<(x1462)); + x1464 = (x1462)-(x1461); + x1465 = (uintptr_t)((x1462)<(x1464)); + x1466 = (x1463)+(x1465); + x1467 = (x1431)-((uintptr_t)4294967295ULL); + x1468 = (uintptr_t)((x1431)<(x1467)); + x1469 = (x1467)-(x1466); + x1470 = (uintptr_t)((x1467)<(x1469)); + x1471 = (x1468)+(x1470); + x1472 = (x1436)-((uintptr_t)4294967295ULL); + x1473 = (uintptr_t)((x1436)<(x1472)); + x1474 = (x1472)-(x1471); + x1475 = (uintptr_t)((x1472)<(x1474)); + x1476 = (x1473)+(x1475); + x1477 = (x1441)-((uintptr_t)4294967295ULL); + x1478 = (uintptr_t)((x1441)<(x1477)); + x1479 = (x1477)-(x1476); + x1480 = (uintptr_t)((x1477)<(x1479)); + x1481 = (x1478)+(x1480); + x1482 = (x1444)-(x1481); + x1483 = (uintptr_t)((x1444)<(x1482)); + x1484 = ((uintptr_t)-1ULL)+((uintptr_t)((x1483)==((uintptr_t)0ULL))); + x1485 = (x1484)^((uintptr_t)4294967295ULL); + x1486 = ((x1406)&(x1484))|((x1445)&(x1485)); + x1487 = ((uintptr_t)-1ULL)+((uintptr_t)((x1483)==((uintptr_t)0ULL))); + x1488 = (x1487)^((uintptr_t)4294967295ULL); + x1489 = ((x1411)&(x1487))|((x1449)&(x1488)); + x1490 = ((uintptr_t)-1ULL)+((uintptr_t)((x1483)==((uintptr_t)0ULL))); + x1491 = (x1490)^((uintptr_t)4294967295ULL); + x1492 = ((x1416)&(x1490))|((x1454)&(x1491)); + x1493 = ((uintptr_t)-1ULL)+((uintptr_t)((x1483)==((uintptr_t)0ULL))); + x1494 = (x1493)^((uintptr_t)4294967295ULL); + x1495 = ((x1421)&(x1493))|((x1459)&(x1494)); + x1496 = ((uintptr_t)-1ULL)+((uintptr_t)((x1483)==((uintptr_t)0ULL))); + x1497 = (x1496)^((uintptr_t)4294967295ULL); + x1498 = ((x1426)&(x1496))|((x1464)&(x1497)); + x1499 = ((uintptr_t)-1ULL)+((uintptr_t)((x1483)==((uintptr_t)0ULL))); + x1500 = (x1499)^((uintptr_t)4294967295ULL); + x1501 = ((x1431)&(x1499))|((x1469)&(x1500)); + x1502 = ((uintptr_t)-1ULL)+((uintptr_t)((x1483)==((uintptr_t)0ULL))); + x1503 = (x1502)^((uintptr_t)4294967295ULL); + x1504 = ((x1436)&(x1502))|((x1474)&(x1503)); + x1505 = ((uintptr_t)-1ULL)+((uintptr_t)((x1483)==((uintptr_t)0ULL))); + x1506 = (x1505)^((uintptr_t)4294967295ULL); + x1507 = ((x1441)&(x1505))|((x1479)&(x1506)); + x1508 = x1486; + x1509 = x1489; + x1510 = x1492; + x1511 = x1495; + x1512 = x1498; + x1513 = x1501; + x1514 = x1504; + x1515 = x1507; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x1508, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1509, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1510, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x1511, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x1512, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x1513, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x1514, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x1515, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_square(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_secp256k1_scalar_square((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_add(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x8, x0, x17, x1, x9, x19, x2, x10, x21, x3, x11, x23, x4, x12, x25, x5, x13, x27, x6, x14, x29, x7, x15, x33, x35, x37, x39, x41, x43, x31, x45, x16, x48, x32, x49, x18, x51, x34, x52, x20, x54, x36, x55, x22, x57, x38, x58, x24, x60, x40, x61, x26, x63, x42, x64, x28, x66, x44, x67, x47, x30, x69, x46, x70, x50, x53, x56, x59, x62, x65, x68, x71, x72, x73, x74, x75, x76, x77, x78, x79; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = (x0)+(x8); + x17 = ((uintptr_t)((x16)<(x0)))+(x1); + x18 = (x17)+(x9); + x19 = (((uintptr_t)((x17)<(x1)))+((uintptr_t)((x18)<(x9))))+(x2); + x20 = (x19)+(x10); + x21 = (((uintptr_t)((x19)<(x2)))+((uintptr_t)((x20)<(x10))))+(x3); + x22 = (x21)+(x11); + x23 = (((uintptr_t)((x21)<(x3)))+((uintptr_t)((x22)<(x11))))+(x4); + x24 = (x23)+(x12); + x25 = (((uintptr_t)((x23)<(x4)))+((uintptr_t)((x24)<(x12))))+(x5); + x26 = (x25)+(x13); + x27 = (((uintptr_t)((x25)<(x5)))+((uintptr_t)((x26)<(x13))))+(x6); + x28 = (x27)+(x14); + x29 = (((uintptr_t)((x27)<(x6)))+((uintptr_t)((x28)<(x14))))+(x7); + x30 = (x29)+(x15); + x31 = ((uintptr_t)((x29)<(x7)))+((uintptr_t)((x30)<(x15))); + x32 = (x16)-((uintptr_t)3493216577ULL); + x33 = (x18)-((uintptr_t)3218235020ULL); + x34 = (x33)-((uintptr_t)((x16)<(x32))); + x35 = (x20)-((uintptr_t)2940772411ULL); + x36 = (x35)-(((uintptr_t)((x18)<(x33)))+((uintptr_t)((x33)<(x34)))); + x37 = (x22)-((uintptr_t)3132021990ULL); + x38 = (x37)-(((uintptr_t)((x20)<(x35)))+((uintptr_t)((x35)<(x36)))); + x39 = (x24)-((uintptr_t)4294967294ULL); + x40 = (x39)-(((uintptr_t)((x22)<(x37)))+((uintptr_t)((x37)<(x38)))); + x41 = (x26)-((uintptr_t)4294967295ULL); + x42 = (x41)-(((uintptr_t)((x24)<(x39)))+((uintptr_t)((x39)<(x40)))); + x43 = (x28)-((uintptr_t)4294967295ULL); + x44 = (x43)-(((uintptr_t)((x26)<(x41)))+((uintptr_t)((x41)<(x42)))); + x45 = (x30)-((uintptr_t)4294967295ULL); + x46 = (x45)-(((uintptr_t)((x28)<(x43)))+((uintptr_t)((x43)<(x44)))); + x47 = (uintptr_t)((x31)<((x31)-(((uintptr_t)((x30)<(x45)))+((uintptr_t)((x45)<(x46)))))); + x48 = ((uintptr_t)-1ULL)+((uintptr_t)((x47)==((uintptr_t)0ULL))); + x49 = (x48)^((uintptr_t)4294967295ULL); + x50 = ((x16)&(x48))|((x32)&(x49)); + x51 = ((uintptr_t)-1ULL)+((uintptr_t)((x47)==((uintptr_t)0ULL))); + x52 = (x51)^((uintptr_t)4294967295ULL); + x53 = ((x18)&(x51))|((x34)&(x52)); + x54 = ((uintptr_t)-1ULL)+((uintptr_t)((x47)==((uintptr_t)0ULL))); + x55 = (x54)^((uintptr_t)4294967295ULL); + x56 = ((x20)&(x54))|((x36)&(x55)); + x57 = ((uintptr_t)-1ULL)+((uintptr_t)((x47)==((uintptr_t)0ULL))); + x58 = (x57)^((uintptr_t)4294967295ULL); + x59 = ((x22)&(x57))|((x38)&(x58)); + x60 = ((uintptr_t)-1ULL)+((uintptr_t)((x47)==((uintptr_t)0ULL))); + x61 = (x60)^((uintptr_t)4294967295ULL); + x62 = ((x24)&(x60))|((x40)&(x61)); + x63 = ((uintptr_t)-1ULL)+((uintptr_t)((x47)==((uintptr_t)0ULL))); + x64 = (x63)^((uintptr_t)4294967295ULL); + x65 = ((x26)&(x63))|((x42)&(x64)); + x66 = ((uintptr_t)-1ULL)+((uintptr_t)((x47)==((uintptr_t)0ULL))); + x67 = (x66)^((uintptr_t)4294967295ULL); + x68 = ((x28)&(x66))|((x44)&(x67)); + x69 = ((uintptr_t)-1ULL)+((uintptr_t)((x47)==((uintptr_t)0ULL))); + x70 = (x69)^((uintptr_t)4294967295ULL); + x71 = ((x30)&(x69))|((x46)&(x70)); + x72 = x50; + x73 = x53; + x74 = x56; + x75 = x59; + x76 = x62; + x77 = x65; + x78 = x68; + x79 = x71; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x72, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x73, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x74, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x75, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x76, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x77, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x78, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x79, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_add(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_secp256k1_scalar_add((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_sub(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x8, x9, x0, x10, x1, x17, x11, x2, x19, x12, x3, x21, x13, x4, x23, x14, x5, x25, x15, x6, x27, x7, x29, x16, x33, x18, x35, x20, x37, x22, x39, x24, x41, x26, x43, x28, x30, x31, x32, x34, x36, x38, x40, x42, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = (x0)-(x8); + x17 = (x1)-(x9); + x18 = (x17)-((uintptr_t)((x0)<(x16))); + x19 = (x2)-(x10); + x20 = (x19)-(((uintptr_t)((x1)<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = (x3)-(x11); + x22 = (x21)-(((uintptr_t)((x2)<(x19)))+((uintptr_t)((x19)<(x20)))); + x23 = (x4)-(x12); + x24 = (x23)-(((uintptr_t)((x3)<(x21)))+((uintptr_t)((x21)<(x22)))); + x25 = (x5)-(x13); + x26 = (x25)-(((uintptr_t)((x4)<(x23)))+((uintptr_t)((x23)<(x24)))); + x27 = (x6)-(x14); + x28 = (x27)-(((uintptr_t)((x5)<(x25)))+((uintptr_t)((x25)<(x26)))); + x29 = (x7)-(x15); + x30 = (x29)-(((uintptr_t)((x6)<(x27)))+((uintptr_t)((x27)<(x28)))); + x31 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)((x7)<(x29)))+((uintptr_t)((x29)<(x30))))==((uintptr_t)0ULL))); + x32 = (x16)+((x31)&((uintptr_t)3493216577ULL)); + x33 = ((uintptr_t)((x32)<(x16)))+(x18); + x34 = (x33)+((x31)&((uintptr_t)3218235020ULL)); + x35 = (((uintptr_t)((x33)<(x18)))+((uintptr_t)((x34)<((x31)&((uintptr_t)3218235020ULL)))))+(x20); + x36 = (x35)+((x31)&((uintptr_t)2940772411ULL)); + x37 = (((uintptr_t)((x35)<(x20)))+((uintptr_t)((x36)<((x31)&((uintptr_t)2940772411ULL)))))+(x22); + x38 = (x37)+((x31)&((uintptr_t)3132021990ULL)); + x39 = (((uintptr_t)((x37)<(x22)))+((uintptr_t)((x38)<((x31)&((uintptr_t)3132021990ULL)))))+(x24); + x40 = (x39)+((x31)&((uintptr_t)4294967294ULL)); + x41 = (((uintptr_t)((x39)<(x24)))+((uintptr_t)((x40)<((x31)&((uintptr_t)4294967294ULL)))))+(x26); + x42 = (x41)+(x31); + x43 = (((uintptr_t)((x41)<(x26)))+((uintptr_t)((x42)<(x31))))+(x28); + x44 = (x43)+(x31); + x45 = ((((uintptr_t)((x43)<(x28)))+((uintptr_t)((x44)<(x31))))+(x30))+(x31); + x46 = x32; + x47 = x34; + x48 = x36; + x49 = x38; + x50 = x40; + x51 = x42; + x52 = x44; + x53 = x45; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x46, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x47, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x48, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x49, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x50, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x51, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x52, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x53, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_sub(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_secp256k1_scalar_sub((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_opp(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x1, x2, x9, x3, x11, x4, x13, x5, x15, x6, x17, x7, x19, x21, x8, x25, x10, x27, x12, x29, x14, x31, x16, x33, x18, x35, x20, x22, x23, x24, x26, x28, x30, x32, x34, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = ((uintptr_t)0ULL)-(x0); + x9 = ((uintptr_t)0ULL)-(x1); + x10 = (x9)-((uintptr_t)(((uintptr_t)0ULL)<(x8))); + x11 = ((uintptr_t)0ULL)-(x2); + x12 = (x11)-(((uintptr_t)(((uintptr_t)0ULL)<(x9)))+((uintptr_t)((x9)<(x10)))); + x13 = ((uintptr_t)0ULL)-(x3); + x14 = (x13)-(((uintptr_t)(((uintptr_t)0ULL)<(x11)))+((uintptr_t)((x11)<(x12)))); + x15 = ((uintptr_t)0ULL)-(x4); + x16 = (x15)-(((uintptr_t)(((uintptr_t)0ULL)<(x13)))+((uintptr_t)((x13)<(x14)))); + x17 = ((uintptr_t)0ULL)-(x5); + x18 = (x17)-(((uintptr_t)(((uintptr_t)0ULL)<(x15)))+((uintptr_t)((x15)<(x16)))); + x19 = ((uintptr_t)0ULL)-(x6); + x20 = (x19)-(((uintptr_t)(((uintptr_t)0ULL)<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = ((uintptr_t)0ULL)-(x7); + x22 = (x21)-(((uintptr_t)(((uintptr_t)0ULL)<(x19)))+((uintptr_t)((x19)<(x20)))); + x23 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)(((uintptr_t)0ULL)<(x21)))+((uintptr_t)((x21)<(x22))))==((uintptr_t)0ULL))); + x24 = (x8)+((x23)&((uintptr_t)3493216577ULL)); + x25 = ((uintptr_t)((x24)<(x8)))+(x10); + x26 = (x25)+((x23)&((uintptr_t)3218235020ULL)); + x27 = (((uintptr_t)((x25)<(x10)))+((uintptr_t)((x26)<((x23)&((uintptr_t)3218235020ULL)))))+(x12); + x28 = (x27)+((x23)&((uintptr_t)2940772411ULL)); + x29 = (((uintptr_t)((x27)<(x12)))+((uintptr_t)((x28)<((x23)&((uintptr_t)2940772411ULL)))))+(x14); + x30 = (x29)+((x23)&((uintptr_t)3132021990ULL)); + x31 = (((uintptr_t)((x29)<(x14)))+((uintptr_t)((x30)<((x23)&((uintptr_t)3132021990ULL)))))+(x16); + x32 = (x31)+((x23)&((uintptr_t)4294967294ULL)); + x33 = (((uintptr_t)((x31)<(x16)))+((uintptr_t)((x32)<((x23)&((uintptr_t)4294967294ULL)))))+(x18); + x34 = (x33)+(x23); + x35 = (((uintptr_t)((x33)<(x18)))+((uintptr_t)((x34)<(x23))))+(x20); + x36 = (x35)+(x23); + x37 = ((((uintptr_t)((x35)<(x20)))+((uintptr_t)((x36)<(x23))))+(x22))+(x23); + x38 = x24; + x39 = x26; + x40 = x28; + x41 = x30; + x42 = x32; + x43 = x34; + x44 = x36; + x45 = x37; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x38, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x39, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x40, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x41, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x42, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x43, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x44, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x45, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_opp(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_secp256k1_scalar_opp((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_from_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x23, x25, x22, x20, x27, x21, x18, x29, x19, x16, x31, x17, x14, x33, x15, x12, x35, x13, x10, x9, x8, x24, x26, x28, x30, x32, x34, x36, x37, x11, x1, x38, x39, x40, x41, x42, x43, x44, x45, x70, x72, x69, x67, x74, x68, x65, x76, x66, x63, x78, x64, x61, x80, x62, x59, x82, x60, x57, x56, x47, x85, x48, x71, x87, x49, x73, x89, x50, x75, x91, x51, x77, x93, x52, x79, x95, x53, x81, x97, x54, x83, x99, x55, x46, x84, x58, x2, x86, x88, x90, x92, x94, x96, x98, x100, x125, x127, x124, x122, x129, x123, x120, x131, x121, x118, x133, x119, x116, x135, x117, x114, x137, x115, x112, x111, x102, x140, x103, x126, x142, x104, x128, x144, x105, x130, x146, x106, x132, x148, x107, x134, x150, x108, x136, x152, x109, x138, x154, x110, x101, x139, x113, x3, x141, x143, x145, x147, x149, x151, x153, x155, x180, x182, x179, x177, x184, x178, x175, x186, x176, x173, x188, x174, x171, x190, x172, x169, x192, x170, x167, x166, x157, x195, x158, x181, x197, x159, x183, x199, x160, x185, x201, x161, x187, x203, x162, x189, x205, x163, x191, x207, x164, x193, x209, x165, x156, x194, x168, x4, x196, x198, x200, x202, x204, x206, x208, x210, x235, x237, x234, x232, x239, x233, x230, x241, x231, x228, x243, x229, x226, x245, x227, x224, x247, x225, x222, x221, x212, x250, x213, x236, x252, x214, x238, x254, x215, x240, x256, x216, x242, x258, x217, x244, x260, x218, x246, x262, x219, x248, x264, x220, x211, x249, x223, x5, x251, x253, x255, x257, x259, x261, x263, x265, x290, x292, x289, x287, x294, x288, x285, x296, x286, x283, x298, x284, x281, x300, x282, x279, x302, x280, x277, x276, x267, x305, x268, x291, x307, x269, x293, x309, x270, x295, x311, x271, x297, x313, x272, x299, x315, x273, x301, x317, x274, x303, x319, x275, x266, x304, x278, x6, x306, x308, x310, x312, x314, x316, x318, x320, x345, x347, x344, x342, x349, x343, x340, x351, x341, x338, x353, x339, x336, x355, x337, x334, x357, x335, x332, x331, x322, x360, x323, x346, x362, x324, x348, x364, x325, x350, x366, x326, x352, x368, x327, x354, x370, x328, x356, x372, x329, x358, x374, x330, x321, x359, x333, x7, x361, x363, x365, x367, x369, x371, x373, x375, x400, x402, x399, x397, x404, x398, x395, x406, x396, x393, x408, x394, x391, x410, x392, x389, x412, x390, x387, x386, x377, x415, x378, x401, x417, x379, x403, x419, x380, x405, x421, x381, x407, x423, x382, x409, x425, x383, x411, x427, x384, x413, x429, x385, x376, x414, x388, x433, x435, x437, x439, x441, x443, x431, x445, x416, x448, x432, x449, x418, x451, x434, x452, x420, x454, x436, x455, x422, x457, x438, x458, x424, x460, x440, x461, x426, x463, x442, x464, x428, x466, x444, x467, x447, x430, x469, x446, x470, x450, x453, x456, x459, x462, x465, x468, x471, x472, x473, x474, x475, x476, x477, x478, x479; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x0; + x9 = (x8)*((uintptr_t)1435021631ULL); + x10 = (x9)*((uintptr_t)4294967295ULL); + x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)4294967295ULL))>>64); + x12 = (x9)*((uintptr_t)4294967295ULL); + x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)4294967295ULL))>>64); + x14 = (x9)*((uintptr_t)4294967295ULL); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)4294967295ULL))>>64); + x16 = (x9)*((uintptr_t)4294967294ULL); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)4294967294ULL))>>64); + x18 = (x9)*((uintptr_t)3132021990ULL); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)3132021990ULL))>>64); + x20 = (x9)*((uintptr_t)2940772411ULL); + x21 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)2940772411ULL))>>64); + x22 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)3218235020ULL))>>64); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)3493216577ULL))>>64); + x24 = (x23)+((x9)*((uintptr_t)3218235020ULL)); + x25 = ((uintptr_t)((x24)<(x23)))+(x22); + x26 = (x25)+(x20); + x27 = (((uintptr_t)((x25)<(x22)))+((uintptr_t)((x26)<(x20))))+(x21); + x28 = (x27)+(x18); + x29 = (((uintptr_t)((x27)<(x21)))+((uintptr_t)((x28)<(x18))))+(x19); + x30 = (x29)+(x16); + x31 = (((uintptr_t)((x29)<(x19)))+((uintptr_t)((x30)<(x16))))+(x17); + x32 = (x31)+(x14); + x33 = (((uintptr_t)((x31)<(x17)))+((uintptr_t)((x32)<(x14))))+(x15); + x34 = (x33)+(x12); + x35 = (((uintptr_t)((x33)<(x15)))+((uintptr_t)((x34)<(x12))))+(x13); + x36 = (x35)+(x10); + x37 = ((uintptr_t)((x35)<(x13)))+((uintptr_t)((x36)<(x10))); + x38 = ((uintptr_t)(((x8)+((x9)*((uintptr_t)3493216577ULL)))<(x8)))+(x24); + x39 = ((uintptr_t)((x38)<(x24)))+(x26); + x40 = ((uintptr_t)((x39)<(x26)))+(x28); + x41 = ((uintptr_t)((x40)<(x28)))+(x30); + x42 = ((uintptr_t)((x41)<(x30)))+(x32); + x43 = ((uintptr_t)((x42)<(x32)))+(x34); + x44 = ((uintptr_t)((x43)<(x34)))+(x36); + x45 = ((uintptr_t)((x44)<(x36)))+((x37)+(x11)); + x46 = (uintptr_t)((x45)<((x37)+(x11))); + x47 = (x38)+(x1); + x48 = ((uintptr_t)((x47)<(x38)))+(x39); + x49 = ((uintptr_t)((x48)<(x39)))+(x40); + x50 = ((uintptr_t)((x49)<(x40)))+(x41); + x51 = ((uintptr_t)((x50)<(x41)))+(x42); + x52 = ((uintptr_t)((x51)<(x42)))+(x43); + x53 = ((uintptr_t)((x52)<(x43)))+(x44); + x54 = ((uintptr_t)((x53)<(x44)))+(x45); + x55 = (uintptr_t)((x54)<(x45)); + x56 = (x47)*((uintptr_t)1435021631ULL); + x57 = (x56)*((uintptr_t)4294967295ULL); + x58 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x56)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x56)*((uintptr_t)4294967295ULL))>>64); + x59 = (x56)*((uintptr_t)4294967295ULL); + x60 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x56)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x56)*((uintptr_t)4294967295ULL))>>64); + x61 = (x56)*((uintptr_t)4294967295ULL); + x62 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x56)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x56)*((uintptr_t)4294967295ULL))>>64); + x63 = (x56)*((uintptr_t)4294967294ULL); + x64 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x56)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x56)*((uintptr_t)4294967294ULL))>>64); + x65 = (x56)*((uintptr_t)3132021990ULL); + x66 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x56)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x56)*((uintptr_t)3132021990ULL))>>64); + x67 = (x56)*((uintptr_t)2940772411ULL); + x68 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x56)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x56)*((uintptr_t)2940772411ULL))>>64); + x69 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x56)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x56)*((uintptr_t)3218235020ULL))>>64); + x70 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x56)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x56)*((uintptr_t)3493216577ULL))>>64); + x71 = (x70)+((x56)*((uintptr_t)3218235020ULL)); + x72 = ((uintptr_t)((x71)<(x70)))+(x69); + x73 = (x72)+(x67); + x74 = (((uintptr_t)((x72)<(x69)))+((uintptr_t)((x73)<(x67))))+(x68); + x75 = (x74)+(x65); + x76 = (((uintptr_t)((x74)<(x68)))+((uintptr_t)((x75)<(x65))))+(x66); + x77 = (x76)+(x63); + x78 = (((uintptr_t)((x76)<(x66)))+((uintptr_t)((x77)<(x63))))+(x64); + x79 = (x78)+(x61); + x80 = (((uintptr_t)((x78)<(x64)))+((uintptr_t)((x79)<(x61))))+(x62); + x81 = (x80)+(x59); + x82 = (((uintptr_t)((x80)<(x62)))+((uintptr_t)((x81)<(x59))))+(x60); + x83 = (x82)+(x57); + x84 = ((uintptr_t)((x82)<(x60)))+((uintptr_t)((x83)<(x57))); + x85 = ((uintptr_t)(((x47)+((x56)*((uintptr_t)3493216577ULL)))<(x47)))+(x48); + x86 = (x85)+(x71); + x87 = (((uintptr_t)((x85)<(x48)))+((uintptr_t)((x86)<(x71))))+(x49); + x88 = (x87)+(x73); + x89 = (((uintptr_t)((x87)<(x49)))+((uintptr_t)((x88)<(x73))))+(x50); + x90 = (x89)+(x75); + x91 = (((uintptr_t)((x89)<(x50)))+((uintptr_t)((x90)<(x75))))+(x51); + x92 = (x91)+(x77); + x93 = (((uintptr_t)((x91)<(x51)))+((uintptr_t)((x92)<(x77))))+(x52); + x94 = (x93)+(x79); + x95 = (((uintptr_t)((x93)<(x52)))+((uintptr_t)((x94)<(x79))))+(x53); + x96 = (x95)+(x81); + x97 = (((uintptr_t)((x95)<(x53)))+((uintptr_t)((x96)<(x81))))+(x54); + x98 = (x97)+(x83); + x99 = (((uintptr_t)((x97)<(x54)))+((uintptr_t)((x98)<(x83))))+((x55)+(x46)); + x100 = (x99)+((x84)+(x58)); + x101 = ((uintptr_t)((x99)<((x55)+(x46))))+((uintptr_t)((x100)<((x84)+(x58)))); + x102 = (x86)+(x2); + x103 = ((uintptr_t)((x102)<(x86)))+(x88); + x104 = ((uintptr_t)((x103)<(x88)))+(x90); + x105 = ((uintptr_t)((x104)<(x90)))+(x92); + x106 = ((uintptr_t)((x105)<(x92)))+(x94); + x107 = ((uintptr_t)((x106)<(x94)))+(x96); + x108 = ((uintptr_t)((x107)<(x96)))+(x98); + x109 = ((uintptr_t)((x108)<(x98)))+(x100); + x110 = (uintptr_t)((x109)<(x100)); + x111 = (x102)*((uintptr_t)1435021631ULL); + x112 = (x111)*((uintptr_t)4294967295ULL); + x113 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x111)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x111)*((uintptr_t)4294967295ULL))>>64); + x114 = (x111)*((uintptr_t)4294967295ULL); + x115 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x111)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x111)*((uintptr_t)4294967295ULL))>>64); + x116 = (x111)*((uintptr_t)4294967295ULL); + x117 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x111)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x111)*((uintptr_t)4294967295ULL))>>64); + x118 = (x111)*((uintptr_t)4294967294ULL); + x119 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x111)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x111)*((uintptr_t)4294967294ULL))>>64); + x120 = (x111)*((uintptr_t)3132021990ULL); + x121 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x111)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x111)*((uintptr_t)3132021990ULL))>>64); + x122 = (x111)*((uintptr_t)2940772411ULL); + x123 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x111)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x111)*((uintptr_t)2940772411ULL))>>64); + x124 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x111)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x111)*((uintptr_t)3218235020ULL))>>64); + x125 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x111)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x111)*((uintptr_t)3493216577ULL))>>64); + x126 = (x125)+((x111)*((uintptr_t)3218235020ULL)); + x127 = ((uintptr_t)((x126)<(x125)))+(x124); + x128 = (x127)+(x122); + x129 = (((uintptr_t)((x127)<(x124)))+((uintptr_t)((x128)<(x122))))+(x123); + x130 = (x129)+(x120); + x131 = (((uintptr_t)((x129)<(x123)))+((uintptr_t)((x130)<(x120))))+(x121); + x132 = (x131)+(x118); + x133 = (((uintptr_t)((x131)<(x121)))+((uintptr_t)((x132)<(x118))))+(x119); + x134 = (x133)+(x116); + x135 = (((uintptr_t)((x133)<(x119)))+((uintptr_t)((x134)<(x116))))+(x117); + x136 = (x135)+(x114); + x137 = (((uintptr_t)((x135)<(x117)))+((uintptr_t)((x136)<(x114))))+(x115); + x138 = (x137)+(x112); + x139 = ((uintptr_t)((x137)<(x115)))+((uintptr_t)((x138)<(x112))); + x140 = ((uintptr_t)(((x102)+((x111)*((uintptr_t)3493216577ULL)))<(x102)))+(x103); + x141 = (x140)+(x126); + x142 = (((uintptr_t)((x140)<(x103)))+((uintptr_t)((x141)<(x126))))+(x104); + x143 = (x142)+(x128); + x144 = (((uintptr_t)((x142)<(x104)))+((uintptr_t)((x143)<(x128))))+(x105); + x145 = (x144)+(x130); + x146 = (((uintptr_t)((x144)<(x105)))+((uintptr_t)((x145)<(x130))))+(x106); + x147 = (x146)+(x132); + x148 = (((uintptr_t)((x146)<(x106)))+((uintptr_t)((x147)<(x132))))+(x107); + x149 = (x148)+(x134); + x150 = (((uintptr_t)((x148)<(x107)))+((uintptr_t)((x149)<(x134))))+(x108); + x151 = (x150)+(x136); + x152 = (((uintptr_t)((x150)<(x108)))+((uintptr_t)((x151)<(x136))))+(x109); + x153 = (x152)+(x138); + x154 = (((uintptr_t)((x152)<(x109)))+((uintptr_t)((x153)<(x138))))+((x110)+(x101)); + x155 = (x154)+((x139)+(x113)); + x156 = ((uintptr_t)((x154)<((x110)+(x101))))+((uintptr_t)((x155)<((x139)+(x113)))); + x157 = (x141)+(x3); + x158 = ((uintptr_t)((x157)<(x141)))+(x143); + x159 = ((uintptr_t)((x158)<(x143)))+(x145); + x160 = ((uintptr_t)((x159)<(x145)))+(x147); + x161 = ((uintptr_t)((x160)<(x147)))+(x149); + x162 = ((uintptr_t)((x161)<(x149)))+(x151); + x163 = ((uintptr_t)((x162)<(x151)))+(x153); + x164 = ((uintptr_t)((x163)<(x153)))+(x155); + x165 = (uintptr_t)((x164)<(x155)); + x166 = (x157)*((uintptr_t)1435021631ULL); + x167 = (x166)*((uintptr_t)4294967295ULL); + x168 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x166)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x166)*((uintptr_t)4294967295ULL))>>64); + x169 = (x166)*((uintptr_t)4294967295ULL); + x170 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x166)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x166)*((uintptr_t)4294967295ULL))>>64); + x171 = (x166)*((uintptr_t)4294967295ULL); + x172 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x166)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x166)*((uintptr_t)4294967295ULL))>>64); + x173 = (x166)*((uintptr_t)4294967294ULL); + x174 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x166)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x166)*((uintptr_t)4294967294ULL))>>64); + x175 = (x166)*((uintptr_t)3132021990ULL); + x176 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x166)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x166)*((uintptr_t)3132021990ULL))>>64); + x177 = (x166)*((uintptr_t)2940772411ULL); + x178 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x166)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x166)*((uintptr_t)2940772411ULL))>>64); + x179 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x166)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x166)*((uintptr_t)3218235020ULL))>>64); + x180 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x166)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x166)*((uintptr_t)3493216577ULL))>>64); + x181 = (x180)+((x166)*((uintptr_t)3218235020ULL)); + x182 = ((uintptr_t)((x181)<(x180)))+(x179); + x183 = (x182)+(x177); + x184 = (((uintptr_t)((x182)<(x179)))+((uintptr_t)((x183)<(x177))))+(x178); + x185 = (x184)+(x175); + x186 = (((uintptr_t)((x184)<(x178)))+((uintptr_t)((x185)<(x175))))+(x176); + x187 = (x186)+(x173); + x188 = (((uintptr_t)((x186)<(x176)))+((uintptr_t)((x187)<(x173))))+(x174); + x189 = (x188)+(x171); + x190 = (((uintptr_t)((x188)<(x174)))+((uintptr_t)((x189)<(x171))))+(x172); + x191 = (x190)+(x169); + x192 = (((uintptr_t)((x190)<(x172)))+((uintptr_t)((x191)<(x169))))+(x170); + x193 = (x192)+(x167); + x194 = ((uintptr_t)((x192)<(x170)))+((uintptr_t)((x193)<(x167))); + x195 = ((uintptr_t)(((x157)+((x166)*((uintptr_t)3493216577ULL)))<(x157)))+(x158); + x196 = (x195)+(x181); + x197 = (((uintptr_t)((x195)<(x158)))+((uintptr_t)((x196)<(x181))))+(x159); + x198 = (x197)+(x183); + x199 = (((uintptr_t)((x197)<(x159)))+((uintptr_t)((x198)<(x183))))+(x160); + x200 = (x199)+(x185); + x201 = (((uintptr_t)((x199)<(x160)))+((uintptr_t)((x200)<(x185))))+(x161); + x202 = (x201)+(x187); + x203 = (((uintptr_t)((x201)<(x161)))+((uintptr_t)((x202)<(x187))))+(x162); + x204 = (x203)+(x189); + x205 = (((uintptr_t)((x203)<(x162)))+((uintptr_t)((x204)<(x189))))+(x163); + x206 = (x205)+(x191); + x207 = (((uintptr_t)((x205)<(x163)))+((uintptr_t)((x206)<(x191))))+(x164); + x208 = (x207)+(x193); + x209 = (((uintptr_t)((x207)<(x164)))+((uintptr_t)((x208)<(x193))))+((x165)+(x156)); + x210 = (x209)+((x194)+(x168)); + x211 = ((uintptr_t)((x209)<((x165)+(x156))))+((uintptr_t)((x210)<((x194)+(x168)))); + x212 = (x196)+(x4); + x213 = ((uintptr_t)((x212)<(x196)))+(x198); + x214 = ((uintptr_t)((x213)<(x198)))+(x200); + x215 = ((uintptr_t)((x214)<(x200)))+(x202); + x216 = ((uintptr_t)((x215)<(x202)))+(x204); + x217 = ((uintptr_t)((x216)<(x204)))+(x206); + x218 = ((uintptr_t)((x217)<(x206)))+(x208); + x219 = ((uintptr_t)((x218)<(x208)))+(x210); + x220 = (uintptr_t)((x219)<(x210)); + x221 = (x212)*((uintptr_t)1435021631ULL); + x222 = (x221)*((uintptr_t)4294967295ULL); + x223 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x221)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x221)*((uintptr_t)4294967295ULL))>>64); + x224 = (x221)*((uintptr_t)4294967295ULL); + x225 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x221)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x221)*((uintptr_t)4294967295ULL))>>64); + x226 = (x221)*((uintptr_t)4294967295ULL); + x227 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x221)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x221)*((uintptr_t)4294967295ULL))>>64); + x228 = (x221)*((uintptr_t)4294967294ULL); + x229 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x221)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x221)*((uintptr_t)4294967294ULL))>>64); + x230 = (x221)*((uintptr_t)3132021990ULL); + x231 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x221)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x221)*((uintptr_t)3132021990ULL))>>64); + x232 = (x221)*((uintptr_t)2940772411ULL); + x233 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x221)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x221)*((uintptr_t)2940772411ULL))>>64); + x234 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x221)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x221)*((uintptr_t)3218235020ULL))>>64); + x235 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x221)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x221)*((uintptr_t)3493216577ULL))>>64); + x236 = (x235)+((x221)*((uintptr_t)3218235020ULL)); + x237 = ((uintptr_t)((x236)<(x235)))+(x234); + x238 = (x237)+(x232); + x239 = (((uintptr_t)((x237)<(x234)))+((uintptr_t)((x238)<(x232))))+(x233); + x240 = (x239)+(x230); + x241 = (((uintptr_t)((x239)<(x233)))+((uintptr_t)((x240)<(x230))))+(x231); + x242 = (x241)+(x228); + x243 = (((uintptr_t)((x241)<(x231)))+((uintptr_t)((x242)<(x228))))+(x229); + x244 = (x243)+(x226); + x245 = (((uintptr_t)((x243)<(x229)))+((uintptr_t)((x244)<(x226))))+(x227); + x246 = (x245)+(x224); + x247 = (((uintptr_t)((x245)<(x227)))+((uintptr_t)((x246)<(x224))))+(x225); + x248 = (x247)+(x222); + x249 = ((uintptr_t)((x247)<(x225)))+((uintptr_t)((x248)<(x222))); + x250 = ((uintptr_t)(((x212)+((x221)*((uintptr_t)3493216577ULL)))<(x212)))+(x213); + x251 = (x250)+(x236); + x252 = (((uintptr_t)((x250)<(x213)))+((uintptr_t)((x251)<(x236))))+(x214); + x253 = (x252)+(x238); + x254 = (((uintptr_t)((x252)<(x214)))+((uintptr_t)((x253)<(x238))))+(x215); + x255 = (x254)+(x240); + x256 = (((uintptr_t)((x254)<(x215)))+((uintptr_t)((x255)<(x240))))+(x216); + x257 = (x256)+(x242); + x258 = (((uintptr_t)((x256)<(x216)))+((uintptr_t)((x257)<(x242))))+(x217); + x259 = (x258)+(x244); + x260 = (((uintptr_t)((x258)<(x217)))+((uintptr_t)((x259)<(x244))))+(x218); + x261 = (x260)+(x246); + x262 = (((uintptr_t)((x260)<(x218)))+((uintptr_t)((x261)<(x246))))+(x219); + x263 = (x262)+(x248); + x264 = (((uintptr_t)((x262)<(x219)))+((uintptr_t)((x263)<(x248))))+((x220)+(x211)); + x265 = (x264)+((x249)+(x223)); + x266 = ((uintptr_t)((x264)<((x220)+(x211))))+((uintptr_t)((x265)<((x249)+(x223)))); + x267 = (x251)+(x5); + x268 = ((uintptr_t)((x267)<(x251)))+(x253); + x269 = ((uintptr_t)((x268)<(x253)))+(x255); + x270 = ((uintptr_t)((x269)<(x255)))+(x257); + x271 = ((uintptr_t)((x270)<(x257)))+(x259); + x272 = ((uintptr_t)((x271)<(x259)))+(x261); + x273 = ((uintptr_t)((x272)<(x261)))+(x263); + x274 = ((uintptr_t)((x273)<(x263)))+(x265); + x275 = (uintptr_t)((x274)<(x265)); + x276 = (x267)*((uintptr_t)1435021631ULL); + x277 = (x276)*((uintptr_t)4294967295ULL); + x278 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x276)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x276)*((uintptr_t)4294967295ULL))>>64); + x279 = (x276)*((uintptr_t)4294967295ULL); + x280 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x276)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x276)*((uintptr_t)4294967295ULL))>>64); + x281 = (x276)*((uintptr_t)4294967295ULL); + x282 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x276)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x276)*((uintptr_t)4294967295ULL))>>64); + x283 = (x276)*((uintptr_t)4294967294ULL); + x284 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x276)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x276)*((uintptr_t)4294967294ULL))>>64); + x285 = (x276)*((uintptr_t)3132021990ULL); + x286 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x276)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x276)*((uintptr_t)3132021990ULL))>>64); + x287 = (x276)*((uintptr_t)2940772411ULL); + x288 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x276)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x276)*((uintptr_t)2940772411ULL))>>64); + x289 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x276)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x276)*((uintptr_t)3218235020ULL))>>64); + x290 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x276)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x276)*((uintptr_t)3493216577ULL))>>64); + x291 = (x290)+((x276)*((uintptr_t)3218235020ULL)); + x292 = ((uintptr_t)((x291)<(x290)))+(x289); + x293 = (x292)+(x287); + x294 = (((uintptr_t)((x292)<(x289)))+((uintptr_t)((x293)<(x287))))+(x288); + x295 = (x294)+(x285); + x296 = (((uintptr_t)((x294)<(x288)))+((uintptr_t)((x295)<(x285))))+(x286); + x297 = (x296)+(x283); + x298 = (((uintptr_t)((x296)<(x286)))+((uintptr_t)((x297)<(x283))))+(x284); + x299 = (x298)+(x281); + x300 = (((uintptr_t)((x298)<(x284)))+((uintptr_t)((x299)<(x281))))+(x282); + x301 = (x300)+(x279); + x302 = (((uintptr_t)((x300)<(x282)))+((uintptr_t)((x301)<(x279))))+(x280); + x303 = (x302)+(x277); + x304 = ((uintptr_t)((x302)<(x280)))+((uintptr_t)((x303)<(x277))); + x305 = ((uintptr_t)(((x267)+((x276)*((uintptr_t)3493216577ULL)))<(x267)))+(x268); + x306 = (x305)+(x291); + x307 = (((uintptr_t)((x305)<(x268)))+((uintptr_t)((x306)<(x291))))+(x269); + x308 = (x307)+(x293); + x309 = (((uintptr_t)((x307)<(x269)))+((uintptr_t)((x308)<(x293))))+(x270); + x310 = (x309)+(x295); + x311 = (((uintptr_t)((x309)<(x270)))+((uintptr_t)((x310)<(x295))))+(x271); + x312 = (x311)+(x297); + x313 = (((uintptr_t)((x311)<(x271)))+((uintptr_t)((x312)<(x297))))+(x272); + x314 = (x313)+(x299); + x315 = (((uintptr_t)((x313)<(x272)))+((uintptr_t)((x314)<(x299))))+(x273); + x316 = (x315)+(x301); + x317 = (((uintptr_t)((x315)<(x273)))+((uintptr_t)((x316)<(x301))))+(x274); + x318 = (x317)+(x303); + x319 = (((uintptr_t)((x317)<(x274)))+((uintptr_t)((x318)<(x303))))+((x275)+(x266)); + x320 = (x319)+((x304)+(x278)); + x321 = ((uintptr_t)((x319)<((x275)+(x266))))+((uintptr_t)((x320)<((x304)+(x278)))); + x322 = (x306)+(x6); + x323 = ((uintptr_t)((x322)<(x306)))+(x308); + x324 = ((uintptr_t)((x323)<(x308)))+(x310); + x325 = ((uintptr_t)((x324)<(x310)))+(x312); + x326 = ((uintptr_t)((x325)<(x312)))+(x314); + x327 = ((uintptr_t)((x326)<(x314)))+(x316); + x328 = ((uintptr_t)((x327)<(x316)))+(x318); + x329 = ((uintptr_t)((x328)<(x318)))+(x320); + x330 = (uintptr_t)((x329)<(x320)); + x331 = (x322)*((uintptr_t)1435021631ULL); + x332 = (x331)*((uintptr_t)4294967295ULL); + x333 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x331)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x331)*((uintptr_t)4294967295ULL))>>64); + x334 = (x331)*((uintptr_t)4294967295ULL); + x335 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x331)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x331)*((uintptr_t)4294967295ULL))>>64); + x336 = (x331)*((uintptr_t)4294967295ULL); + x337 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x331)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x331)*((uintptr_t)4294967295ULL))>>64); + x338 = (x331)*((uintptr_t)4294967294ULL); + x339 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x331)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x331)*((uintptr_t)4294967294ULL))>>64); + x340 = (x331)*((uintptr_t)3132021990ULL); + x341 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x331)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x331)*((uintptr_t)3132021990ULL))>>64); + x342 = (x331)*((uintptr_t)2940772411ULL); + x343 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x331)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x331)*((uintptr_t)2940772411ULL))>>64); + x344 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x331)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x331)*((uintptr_t)3218235020ULL))>>64); + x345 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x331)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x331)*((uintptr_t)3493216577ULL))>>64); + x346 = (x345)+((x331)*((uintptr_t)3218235020ULL)); + x347 = ((uintptr_t)((x346)<(x345)))+(x344); + x348 = (x347)+(x342); + x349 = (((uintptr_t)((x347)<(x344)))+((uintptr_t)((x348)<(x342))))+(x343); + x350 = (x349)+(x340); + x351 = (((uintptr_t)((x349)<(x343)))+((uintptr_t)((x350)<(x340))))+(x341); + x352 = (x351)+(x338); + x353 = (((uintptr_t)((x351)<(x341)))+((uintptr_t)((x352)<(x338))))+(x339); + x354 = (x353)+(x336); + x355 = (((uintptr_t)((x353)<(x339)))+((uintptr_t)((x354)<(x336))))+(x337); + x356 = (x355)+(x334); + x357 = (((uintptr_t)((x355)<(x337)))+((uintptr_t)((x356)<(x334))))+(x335); + x358 = (x357)+(x332); + x359 = ((uintptr_t)((x357)<(x335)))+((uintptr_t)((x358)<(x332))); + x360 = ((uintptr_t)(((x322)+((x331)*((uintptr_t)3493216577ULL)))<(x322)))+(x323); + x361 = (x360)+(x346); + x362 = (((uintptr_t)((x360)<(x323)))+((uintptr_t)((x361)<(x346))))+(x324); + x363 = (x362)+(x348); + x364 = (((uintptr_t)((x362)<(x324)))+((uintptr_t)((x363)<(x348))))+(x325); + x365 = (x364)+(x350); + x366 = (((uintptr_t)((x364)<(x325)))+((uintptr_t)((x365)<(x350))))+(x326); + x367 = (x366)+(x352); + x368 = (((uintptr_t)((x366)<(x326)))+((uintptr_t)((x367)<(x352))))+(x327); + x369 = (x368)+(x354); + x370 = (((uintptr_t)((x368)<(x327)))+((uintptr_t)((x369)<(x354))))+(x328); + x371 = (x370)+(x356); + x372 = (((uintptr_t)((x370)<(x328)))+((uintptr_t)((x371)<(x356))))+(x329); + x373 = (x372)+(x358); + x374 = (((uintptr_t)((x372)<(x329)))+((uintptr_t)((x373)<(x358))))+((x330)+(x321)); + x375 = (x374)+((x359)+(x333)); + x376 = ((uintptr_t)((x374)<((x330)+(x321))))+((uintptr_t)((x375)<((x359)+(x333)))); + x377 = (x361)+(x7); + x378 = ((uintptr_t)((x377)<(x361)))+(x363); + x379 = ((uintptr_t)((x378)<(x363)))+(x365); + x380 = ((uintptr_t)((x379)<(x365)))+(x367); + x381 = ((uintptr_t)((x380)<(x367)))+(x369); + x382 = ((uintptr_t)((x381)<(x369)))+(x371); + x383 = ((uintptr_t)((x382)<(x371)))+(x373); + x384 = ((uintptr_t)((x383)<(x373)))+(x375); + x385 = (uintptr_t)((x384)<(x375)); + x386 = (x377)*((uintptr_t)1435021631ULL); + x387 = (x386)*((uintptr_t)4294967295ULL); + x388 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x386)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x386)*((uintptr_t)4294967295ULL))>>64); + x389 = (x386)*((uintptr_t)4294967295ULL); + x390 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x386)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x386)*((uintptr_t)4294967295ULL))>>64); + x391 = (x386)*((uintptr_t)4294967295ULL); + x392 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x386)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x386)*((uintptr_t)4294967295ULL))>>64); + x393 = (x386)*((uintptr_t)4294967294ULL); + x394 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x386)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x386)*((uintptr_t)4294967294ULL))>>64); + x395 = (x386)*((uintptr_t)3132021990ULL); + x396 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x386)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x386)*((uintptr_t)3132021990ULL))>>64); + x397 = (x386)*((uintptr_t)2940772411ULL); + x398 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x386)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x386)*((uintptr_t)2940772411ULL))>>64); + x399 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x386)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x386)*((uintptr_t)3218235020ULL))>>64); + x400 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x386)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x386)*((uintptr_t)3493216577ULL))>>64); + x401 = (x400)+((x386)*((uintptr_t)3218235020ULL)); + x402 = ((uintptr_t)((x401)<(x400)))+(x399); + x403 = (x402)+(x397); + x404 = (((uintptr_t)((x402)<(x399)))+((uintptr_t)((x403)<(x397))))+(x398); + x405 = (x404)+(x395); + x406 = (((uintptr_t)((x404)<(x398)))+((uintptr_t)((x405)<(x395))))+(x396); + x407 = (x406)+(x393); + x408 = (((uintptr_t)((x406)<(x396)))+((uintptr_t)((x407)<(x393))))+(x394); + x409 = (x408)+(x391); + x410 = (((uintptr_t)((x408)<(x394)))+((uintptr_t)((x409)<(x391))))+(x392); + x411 = (x410)+(x389); + x412 = (((uintptr_t)((x410)<(x392)))+((uintptr_t)((x411)<(x389))))+(x390); + x413 = (x412)+(x387); + x414 = ((uintptr_t)((x412)<(x390)))+((uintptr_t)((x413)<(x387))); + x415 = ((uintptr_t)(((x377)+((x386)*((uintptr_t)3493216577ULL)))<(x377)))+(x378); + x416 = (x415)+(x401); + x417 = (((uintptr_t)((x415)<(x378)))+((uintptr_t)((x416)<(x401))))+(x379); + x418 = (x417)+(x403); + x419 = (((uintptr_t)((x417)<(x379)))+((uintptr_t)((x418)<(x403))))+(x380); + x420 = (x419)+(x405); + x421 = (((uintptr_t)((x419)<(x380)))+((uintptr_t)((x420)<(x405))))+(x381); + x422 = (x421)+(x407); + x423 = (((uintptr_t)((x421)<(x381)))+((uintptr_t)((x422)<(x407))))+(x382); + x424 = (x423)+(x409); + x425 = (((uintptr_t)((x423)<(x382)))+((uintptr_t)((x424)<(x409))))+(x383); + x426 = (x425)+(x411); + x427 = (((uintptr_t)((x425)<(x383)))+((uintptr_t)((x426)<(x411))))+(x384); + x428 = (x427)+(x413); + x429 = (((uintptr_t)((x427)<(x384)))+((uintptr_t)((x428)<(x413))))+((x385)+(x376)); + x430 = (x429)+((x414)+(x388)); + x431 = ((uintptr_t)((x429)<((x385)+(x376))))+((uintptr_t)((x430)<((x414)+(x388)))); + x432 = (x416)-((uintptr_t)3493216577ULL); + x433 = (x418)-((uintptr_t)3218235020ULL); + x434 = (x433)-((uintptr_t)((x416)<(x432))); + x435 = (x420)-((uintptr_t)2940772411ULL); + x436 = (x435)-(((uintptr_t)((x418)<(x433)))+((uintptr_t)((x433)<(x434)))); + x437 = (x422)-((uintptr_t)3132021990ULL); + x438 = (x437)-(((uintptr_t)((x420)<(x435)))+((uintptr_t)((x435)<(x436)))); + x439 = (x424)-((uintptr_t)4294967294ULL); + x440 = (x439)-(((uintptr_t)((x422)<(x437)))+((uintptr_t)((x437)<(x438)))); + x441 = (x426)-((uintptr_t)4294967295ULL); + x442 = (x441)-(((uintptr_t)((x424)<(x439)))+((uintptr_t)((x439)<(x440)))); + x443 = (x428)-((uintptr_t)4294967295ULL); + x444 = (x443)-(((uintptr_t)((x426)<(x441)))+((uintptr_t)((x441)<(x442)))); + x445 = (x430)-((uintptr_t)4294967295ULL); + x446 = (x445)-(((uintptr_t)((x428)<(x443)))+((uintptr_t)((x443)<(x444)))); + x447 = (uintptr_t)((x431)<((x431)-(((uintptr_t)((x430)<(x445)))+((uintptr_t)((x445)<(x446)))))); + x448 = ((uintptr_t)-1ULL)+((uintptr_t)((x447)==((uintptr_t)0ULL))); + x449 = (x448)^((uintptr_t)4294967295ULL); + x450 = ((x416)&(x448))|((x432)&(x449)); + x451 = ((uintptr_t)-1ULL)+((uintptr_t)((x447)==((uintptr_t)0ULL))); + x452 = (x451)^((uintptr_t)4294967295ULL); + x453 = ((x418)&(x451))|((x434)&(x452)); + x454 = ((uintptr_t)-1ULL)+((uintptr_t)((x447)==((uintptr_t)0ULL))); + x455 = (x454)^((uintptr_t)4294967295ULL); + x456 = ((x420)&(x454))|((x436)&(x455)); + x457 = ((uintptr_t)-1ULL)+((uintptr_t)((x447)==((uintptr_t)0ULL))); + x458 = (x457)^((uintptr_t)4294967295ULL); + x459 = ((x422)&(x457))|((x438)&(x458)); + x460 = ((uintptr_t)-1ULL)+((uintptr_t)((x447)==((uintptr_t)0ULL))); + x461 = (x460)^((uintptr_t)4294967295ULL); + x462 = ((x424)&(x460))|((x440)&(x461)); + x463 = ((uintptr_t)-1ULL)+((uintptr_t)((x447)==((uintptr_t)0ULL))); + x464 = (x463)^((uintptr_t)4294967295ULL); + x465 = ((x426)&(x463))|((x442)&(x464)); + x466 = ((uintptr_t)-1ULL)+((uintptr_t)((x447)==((uintptr_t)0ULL))); + x467 = (x466)^((uintptr_t)4294967295ULL); + x468 = ((x428)&(x466))|((x444)&(x467)); + x469 = ((uintptr_t)-1ULL)+((uintptr_t)((x447)==((uintptr_t)0ULL))); + x470 = (x469)^((uintptr_t)4294967295ULL); + x471 = ((x430)&(x469))|((x446)&(x470)); + x472 = x450; + x473 = x453; + x474 = x456; + x475 = x459; + x476 = x462; + x477 = x465; + x478 = x468; + x479 = x471; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x472, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x473, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x474, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x475, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x476, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x477, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x478, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x479, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_from_montgomery(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_secp256k1_scalar_from_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_to_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x1, x2, x3, x4, x5, x6, x7, x0, x15, x30, x32, x28, x26, x34, x27, x24, x36, x25, x22, x38, x23, x20, x40, x21, x18, x42, x19, x16, x59, x61, x58, x56, x63, x57, x54, x65, x55, x52, x67, x53, x50, x69, x51, x48, x71, x49, x46, x45, x29, x74, x31, x60, x76, x33, x62, x78, x35, x64, x80, x37, x66, x82, x39, x68, x84, x41, x70, x86, x43, x72, x88, x44, x17, x73, x47, x104, x106, x103, x101, x108, x102, x99, x110, x100, x97, x112, x98, x95, x114, x96, x93, x116, x94, x91, x8, x75, x120, x77, x105, x122, x79, x107, x124, x81, x109, x126, x83, x111, x128, x85, x113, x130, x87, x115, x132, x89, x117, x149, x151, x148, x146, x153, x147, x144, x155, x145, x142, x157, x143, x140, x159, x141, x138, x161, x139, x136, x135, x119, x164, x121, x150, x166, x123, x152, x168, x125, x154, x170, x127, x156, x172, x129, x158, x174, x131, x160, x176, x133, x162, x178, x134, x90, x118, x92, x163, x137, x194, x196, x193, x191, x198, x192, x189, x200, x190, x187, x202, x188, x185, x204, x186, x183, x206, x184, x181, x9, x165, x210, x167, x195, x212, x169, x197, x214, x171, x199, x216, x173, x201, x218, x175, x203, x220, x177, x205, x222, x179, x207, x239, x241, x238, x236, x243, x237, x234, x245, x235, x232, x247, x233, x230, x249, x231, x228, x251, x229, x226, x225, x209, x254, x211, x240, x256, x213, x242, x258, x215, x244, x260, x217, x246, x262, x219, x248, x264, x221, x250, x266, x223, x252, x268, x224, x180, x208, x182, x253, x227, x284, x286, x283, x281, x288, x282, x279, x290, x280, x277, x292, x278, x275, x294, x276, x273, x296, x274, x271, x10, x255, x300, x257, x285, x302, x259, x287, x304, x261, x289, x306, x263, x291, x308, x265, x293, x310, x267, x295, x312, x269, x297, x329, x331, x328, x326, x333, x327, x324, x335, x325, x322, x337, x323, x320, x339, x321, x318, x341, x319, x316, x315, x299, x344, x301, x330, x346, x303, x332, x348, x305, x334, x350, x307, x336, x352, x309, x338, x354, x311, x340, x356, x313, x342, x358, x314, x270, x298, x272, x343, x317, x374, x376, x373, x371, x378, x372, x369, x380, x370, x367, x382, x368, x365, x384, x366, x363, x386, x364, x361, x11, x345, x390, x347, x375, x392, x349, x377, x394, x351, x379, x396, x353, x381, x398, x355, x383, x400, x357, x385, x402, x359, x387, x419, x421, x418, x416, x423, x417, x414, x425, x415, x412, x427, x413, x410, x429, x411, x408, x431, x409, x406, x405, x389, x434, x391, x420, x436, x393, x422, x438, x395, x424, x440, x397, x426, x442, x399, x428, x444, x401, x430, x446, x403, x432, x448, x404, x360, x388, x362, x433, x407, x464, x466, x463, x461, x468, x462, x459, x470, x460, x457, x472, x458, x455, x474, x456, x453, x476, x454, x451, x12, x435, x480, x437, x465, x482, x439, x467, x484, x441, x469, x486, x443, x471, x488, x445, x473, x490, x447, x475, x492, x449, x477, x509, x511, x508, x506, x513, x507, x504, x515, x505, x502, x517, x503, x500, x519, x501, x498, x521, x499, x496, x495, x479, x524, x481, x510, x526, x483, x512, x528, x485, x514, x530, x487, x516, x532, x489, x518, x534, x491, x520, x536, x493, x522, x538, x494, x450, x478, x452, x523, x497, x554, x556, x553, x551, x558, x552, x549, x560, x550, x547, x562, x548, x545, x564, x546, x543, x566, x544, x541, x13, x525, x570, x527, x555, x572, x529, x557, x574, x531, x559, x576, x533, x561, x578, x535, x563, x580, x537, x565, x582, x539, x567, x599, x601, x598, x596, x603, x597, x594, x605, x595, x592, x607, x593, x590, x609, x591, x588, x611, x589, x586, x585, x569, x614, x571, x600, x616, x573, x602, x618, x575, x604, x620, x577, x606, x622, x579, x608, x624, x581, x610, x626, x583, x612, x628, x584, x540, x568, x542, x613, x587, x644, x646, x643, x641, x648, x642, x639, x650, x640, x637, x652, x638, x635, x654, x636, x633, x656, x634, x631, x14, x615, x660, x617, x645, x662, x619, x647, x664, x621, x649, x666, x623, x651, x668, x625, x653, x670, x627, x655, x672, x629, x657, x689, x691, x688, x686, x693, x687, x684, x695, x685, x682, x697, x683, x680, x699, x681, x678, x701, x679, x676, x675, x659, x704, x661, x690, x706, x663, x692, x708, x665, x694, x710, x667, x696, x712, x669, x698, x714, x671, x700, x716, x673, x702, x718, x674, x630, x658, x632, x703, x677, x722, x724, x726, x728, x730, x732, x720, x734, x705, x737, x721, x738, x707, x740, x723, x741, x709, x743, x725, x744, x711, x746, x727, x747, x713, x749, x729, x750, x715, x752, x731, x753, x717, x755, x733, x756, x736, x719, x758, x735, x759, x739, x742, x745, x748, x751, x754, x757, x760, x761, x762, x763, x764, x765, x766, x767, x768; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x1; + x9 = x2; + x10 = x3; + x11 = x4; + x12 = x5; + x13 = x6; + x14 = x7; + x15 = x0; + x16 = (x15)*((uintptr_t)2640780501ULL); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)2640780501ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)2640780501ULL))>>64); + x18 = (x15)*((uintptr_t)2177276869ULL); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)2177276869ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)2177276869ULL))>>64); + x20 = (x15)*((uintptr_t)3868718564ULL); + x21 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)3868718564ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)3868718564ULL))>>64); + x22 = (x15)*((uintptr_t)1540163526ULL); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)1540163526ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)1540163526ULL))>>64); + x24 = (x15)*((uintptr_t)1947506370ULL); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)1947506370ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)1947506370ULL))>>64); + x26 = (x15)*((uintptr_t)243071096ULL); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)243071096ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)243071096ULL))>>64); + x28 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)2305618452ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)2305618452ULL))>>64); + x29 = (x15)*((uintptr_t)1742197056ULL); + x30 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)1742197056ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)1742197056ULL))>>64); + x31 = (x30)+((x15)*((uintptr_t)2305618452ULL)); + x32 = ((uintptr_t)((x31)<(x30)))+(x28); + x33 = (x32)+(x26); + x34 = (((uintptr_t)((x32)<(x28)))+((uintptr_t)((x33)<(x26))))+(x27); + x35 = (x34)+(x24); + x36 = (((uintptr_t)((x34)<(x27)))+((uintptr_t)((x35)<(x24))))+(x25); + x37 = (x36)+(x22); + x38 = (((uintptr_t)((x36)<(x25)))+((uintptr_t)((x37)<(x22))))+(x23); + x39 = (x38)+(x20); + x40 = (((uintptr_t)((x38)<(x23)))+((uintptr_t)((x39)<(x20))))+(x21); + x41 = (x40)+(x18); + x42 = (((uintptr_t)((x40)<(x21)))+((uintptr_t)((x41)<(x18))))+(x19); + x43 = (x42)+(x16); + x44 = ((uintptr_t)((x42)<(x19)))+((uintptr_t)((x43)<(x16))); + x45 = (x29)*((uintptr_t)1435021631ULL); + x46 = (x45)*((uintptr_t)4294967295ULL); + x47 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)4294967295ULL))>>64); + x48 = (x45)*((uintptr_t)4294967295ULL); + x49 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)4294967295ULL))>>64); + x50 = (x45)*((uintptr_t)4294967295ULL); + x51 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)4294967295ULL))>>64); + x52 = (x45)*((uintptr_t)4294967294ULL); + x53 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)4294967294ULL))>>64); + x54 = (x45)*((uintptr_t)3132021990ULL); + x55 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)3132021990ULL))>>64); + x56 = (x45)*((uintptr_t)2940772411ULL); + x57 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)2940772411ULL))>>64); + x58 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)3218235020ULL))>>64); + x59 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x45)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x45)*((uintptr_t)3493216577ULL))>>64); + x60 = (x59)+((x45)*((uintptr_t)3218235020ULL)); + x61 = ((uintptr_t)((x60)<(x59)))+(x58); + x62 = (x61)+(x56); + x63 = (((uintptr_t)((x61)<(x58)))+((uintptr_t)((x62)<(x56))))+(x57); + x64 = (x63)+(x54); + x65 = (((uintptr_t)((x63)<(x57)))+((uintptr_t)((x64)<(x54))))+(x55); + x66 = (x65)+(x52); + x67 = (((uintptr_t)((x65)<(x55)))+((uintptr_t)((x66)<(x52))))+(x53); + x68 = (x67)+(x50); + x69 = (((uintptr_t)((x67)<(x53)))+((uintptr_t)((x68)<(x50))))+(x51); + x70 = (x69)+(x48); + x71 = (((uintptr_t)((x69)<(x51)))+((uintptr_t)((x70)<(x48))))+(x49); + x72 = (x71)+(x46); + x73 = ((uintptr_t)((x71)<(x49)))+((uintptr_t)((x72)<(x46))); + x74 = ((uintptr_t)(((x29)+((x45)*((uintptr_t)3493216577ULL)))<(x29)))+(x31); + x75 = (x74)+(x60); + x76 = (((uintptr_t)((x74)<(x31)))+((uintptr_t)((x75)<(x60))))+(x33); + x77 = (x76)+(x62); + x78 = (((uintptr_t)((x76)<(x33)))+((uintptr_t)((x77)<(x62))))+(x35); + x79 = (x78)+(x64); + x80 = (((uintptr_t)((x78)<(x35)))+((uintptr_t)((x79)<(x64))))+(x37); + x81 = (x80)+(x66); + x82 = (((uintptr_t)((x80)<(x37)))+((uintptr_t)((x81)<(x66))))+(x39); + x83 = (x82)+(x68); + x84 = (((uintptr_t)((x82)<(x39)))+((uintptr_t)((x83)<(x68))))+(x41); + x85 = (x84)+(x70); + x86 = (((uintptr_t)((x84)<(x41)))+((uintptr_t)((x85)<(x70))))+(x43); + x87 = (x86)+(x72); + x88 = (((uintptr_t)((x86)<(x43)))+((uintptr_t)((x87)<(x72))))+((x44)+(x17)); + x89 = (x88)+((x73)+(x47)); + x90 = ((uintptr_t)((x88)<((x44)+(x17))))+((uintptr_t)((x89)<((x73)+(x47)))); + x91 = (x8)*((uintptr_t)2640780501ULL); + x92 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)2640780501ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)2640780501ULL))>>64); + x93 = (x8)*((uintptr_t)2177276869ULL); + x94 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)2177276869ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)2177276869ULL))>>64); + x95 = (x8)*((uintptr_t)3868718564ULL); + x96 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)3868718564ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)3868718564ULL))>>64); + x97 = (x8)*((uintptr_t)1540163526ULL); + x98 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)1540163526ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)1540163526ULL))>>64); + x99 = (x8)*((uintptr_t)1947506370ULL); + x100 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)1947506370ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)1947506370ULL))>>64); + x101 = (x8)*((uintptr_t)243071096ULL); + x102 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)243071096ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)243071096ULL))>>64); + x103 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)2305618452ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)2305618452ULL))>>64); + x104 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)1742197056ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)1742197056ULL))>>64); + x105 = (x104)+((x8)*((uintptr_t)2305618452ULL)); + x106 = ((uintptr_t)((x105)<(x104)))+(x103); + x107 = (x106)+(x101); + x108 = (((uintptr_t)((x106)<(x103)))+((uintptr_t)((x107)<(x101))))+(x102); + x109 = (x108)+(x99); + x110 = (((uintptr_t)((x108)<(x102)))+((uintptr_t)((x109)<(x99))))+(x100); + x111 = (x110)+(x97); + x112 = (((uintptr_t)((x110)<(x100)))+((uintptr_t)((x111)<(x97))))+(x98); + x113 = (x112)+(x95); + x114 = (((uintptr_t)((x112)<(x98)))+((uintptr_t)((x113)<(x95))))+(x96); + x115 = (x114)+(x93); + x116 = (((uintptr_t)((x114)<(x96)))+((uintptr_t)((x115)<(x93))))+(x94); + x117 = (x116)+(x91); + x118 = ((uintptr_t)((x116)<(x94)))+((uintptr_t)((x117)<(x91))); + x119 = (x75)+((x8)*((uintptr_t)1742197056ULL)); + x120 = ((uintptr_t)((x119)<(x75)))+(x77); + x121 = (x120)+(x105); + x122 = (((uintptr_t)((x120)<(x77)))+((uintptr_t)((x121)<(x105))))+(x79); + x123 = (x122)+(x107); + x124 = (((uintptr_t)((x122)<(x79)))+((uintptr_t)((x123)<(x107))))+(x81); + x125 = (x124)+(x109); + x126 = (((uintptr_t)((x124)<(x81)))+((uintptr_t)((x125)<(x109))))+(x83); + x127 = (x126)+(x111); + x128 = (((uintptr_t)((x126)<(x83)))+((uintptr_t)((x127)<(x111))))+(x85); + x129 = (x128)+(x113); + x130 = (((uintptr_t)((x128)<(x85)))+((uintptr_t)((x129)<(x113))))+(x87); + x131 = (x130)+(x115); + x132 = (((uintptr_t)((x130)<(x87)))+((uintptr_t)((x131)<(x115))))+(x89); + x133 = (x132)+(x117); + x134 = ((uintptr_t)((x132)<(x89)))+((uintptr_t)((x133)<(x117))); + x135 = (x119)*((uintptr_t)1435021631ULL); + x136 = (x135)*((uintptr_t)4294967295ULL); + x137 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x135)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x135)*((uintptr_t)4294967295ULL))>>64); + x138 = (x135)*((uintptr_t)4294967295ULL); + x139 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x135)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x135)*((uintptr_t)4294967295ULL))>>64); + x140 = (x135)*((uintptr_t)4294967295ULL); + x141 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x135)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x135)*((uintptr_t)4294967295ULL))>>64); + x142 = (x135)*((uintptr_t)4294967294ULL); + x143 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x135)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x135)*((uintptr_t)4294967294ULL))>>64); + x144 = (x135)*((uintptr_t)3132021990ULL); + x145 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x135)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x135)*((uintptr_t)3132021990ULL))>>64); + x146 = (x135)*((uintptr_t)2940772411ULL); + x147 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x135)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x135)*((uintptr_t)2940772411ULL))>>64); + x148 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x135)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x135)*((uintptr_t)3218235020ULL))>>64); + x149 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x135)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x135)*((uintptr_t)3493216577ULL))>>64); + x150 = (x149)+((x135)*((uintptr_t)3218235020ULL)); + x151 = ((uintptr_t)((x150)<(x149)))+(x148); + x152 = (x151)+(x146); + x153 = (((uintptr_t)((x151)<(x148)))+((uintptr_t)((x152)<(x146))))+(x147); + x154 = (x153)+(x144); + x155 = (((uintptr_t)((x153)<(x147)))+((uintptr_t)((x154)<(x144))))+(x145); + x156 = (x155)+(x142); + x157 = (((uintptr_t)((x155)<(x145)))+((uintptr_t)((x156)<(x142))))+(x143); + x158 = (x157)+(x140); + x159 = (((uintptr_t)((x157)<(x143)))+((uintptr_t)((x158)<(x140))))+(x141); + x160 = (x159)+(x138); + x161 = (((uintptr_t)((x159)<(x141)))+((uintptr_t)((x160)<(x138))))+(x139); + x162 = (x161)+(x136); + x163 = ((uintptr_t)((x161)<(x139)))+((uintptr_t)((x162)<(x136))); + x164 = ((uintptr_t)(((x119)+((x135)*((uintptr_t)3493216577ULL)))<(x119)))+(x121); + x165 = (x164)+(x150); + x166 = (((uintptr_t)((x164)<(x121)))+((uintptr_t)((x165)<(x150))))+(x123); + x167 = (x166)+(x152); + x168 = (((uintptr_t)((x166)<(x123)))+((uintptr_t)((x167)<(x152))))+(x125); + x169 = (x168)+(x154); + x170 = (((uintptr_t)((x168)<(x125)))+((uintptr_t)((x169)<(x154))))+(x127); + x171 = (x170)+(x156); + x172 = (((uintptr_t)((x170)<(x127)))+((uintptr_t)((x171)<(x156))))+(x129); + x173 = (x172)+(x158); + x174 = (((uintptr_t)((x172)<(x129)))+((uintptr_t)((x173)<(x158))))+(x131); + x175 = (x174)+(x160); + x176 = (((uintptr_t)((x174)<(x131)))+((uintptr_t)((x175)<(x160))))+(x133); + x177 = (x176)+(x162); + x178 = (((uintptr_t)((x176)<(x133)))+((uintptr_t)((x177)<(x162))))+(((x134)+(x90))+((x118)+(x92))); + x179 = (x178)+((x163)+(x137)); + x180 = ((uintptr_t)((x178)<(((x134)+(x90))+((x118)+(x92)))))+((uintptr_t)((x179)<((x163)+(x137)))); + x181 = (x9)*((uintptr_t)2640780501ULL); + x182 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)2640780501ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)2640780501ULL))>>64); + x183 = (x9)*((uintptr_t)2177276869ULL); + x184 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)2177276869ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)2177276869ULL))>>64); + x185 = (x9)*((uintptr_t)3868718564ULL); + x186 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)3868718564ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)3868718564ULL))>>64); + x187 = (x9)*((uintptr_t)1540163526ULL); + x188 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)1540163526ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)1540163526ULL))>>64); + x189 = (x9)*((uintptr_t)1947506370ULL); + x190 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)1947506370ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)1947506370ULL))>>64); + x191 = (x9)*((uintptr_t)243071096ULL); + x192 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)243071096ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)243071096ULL))>>64); + x193 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)2305618452ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)2305618452ULL))>>64); + x194 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)1742197056ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)1742197056ULL))>>64); + x195 = (x194)+((x9)*((uintptr_t)2305618452ULL)); + x196 = ((uintptr_t)((x195)<(x194)))+(x193); + x197 = (x196)+(x191); + x198 = (((uintptr_t)((x196)<(x193)))+((uintptr_t)((x197)<(x191))))+(x192); + x199 = (x198)+(x189); + x200 = (((uintptr_t)((x198)<(x192)))+((uintptr_t)((x199)<(x189))))+(x190); + x201 = (x200)+(x187); + x202 = (((uintptr_t)((x200)<(x190)))+((uintptr_t)((x201)<(x187))))+(x188); + x203 = (x202)+(x185); + x204 = (((uintptr_t)((x202)<(x188)))+((uintptr_t)((x203)<(x185))))+(x186); + x205 = (x204)+(x183); + x206 = (((uintptr_t)((x204)<(x186)))+((uintptr_t)((x205)<(x183))))+(x184); + x207 = (x206)+(x181); + x208 = ((uintptr_t)((x206)<(x184)))+((uintptr_t)((x207)<(x181))); + x209 = (x165)+((x9)*((uintptr_t)1742197056ULL)); + x210 = ((uintptr_t)((x209)<(x165)))+(x167); + x211 = (x210)+(x195); + x212 = (((uintptr_t)((x210)<(x167)))+((uintptr_t)((x211)<(x195))))+(x169); + x213 = (x212)+(x197); + x214 = (((uintptr_t)((x212)<(x169)))+((uintptr_t)((x213)<(x197))))+(x171); + x215 = (x214)+(x199); + x216 = (((uintptr_t)((x214)<(x171)))+((uintptr_t)((x215)<(x199))))+(x173); + x217 = (x216)+(x201); + x218 = (((uintptr_t)((x216)<(x173)))+((uintptr_t)((x217)<(x201))))+(x175); + x219 = (x218)+(x203); + x220 = (((uintptr_t)((x218)<(x175)))+((uintptr_t)((x219)<(x203))))+(x177); + x221 = (x220)+(x205); + x222 = (((uintptr_t)((x220)<(x177)))+((uintptr_t)((x221)<(x205))))+(x179); + x223 = (x222)+(x207); + x224 = ((uintptr_t)((x222)<(x179)))+((uintptr_t)((x223)<(x207))); + x225 = (x209)*((uintptr_t)1435021631ULL); + x226 = (x225)*((uintptr_t)4294967295ULL); + x227 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x225)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x225)*((uintptr_t)4294967295ULL))>>64); + x228 = (x225)*((uintptr_t)4294967295ULL); + x229 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x225)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x225)*((uintptr_t)4294967295ULL))>>64); + x230 = (x225)*((uintptr_t)4294967295ULL); + x231 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x225)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x225)*((uintptr_t)4294967295ULL))>>64); + x232 = (x225)*((uintptr_t)4294967294ULL); + x233 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x225)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x225)*((uintptr_t)4294967294ULL))>>64); + x234 = (x225)*((uintptr_t)3132021990ULL); + x235 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x225)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x225)*((uintptr_t)3132021990ULL))>>64); + x236 = (x225)*((uintptr_t)2940772411ULL); + x237 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x225)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x225)*((uintptr_t)2940772411ULL))>>64); + x238 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x225)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x225)*((uintptr_t)3218235020ULL))>>64); + x239 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x225)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x225)*((uintptr_t)3493216577ULL))>>64); + x240 = (x239)+((x225)*((uintptr_t)3218235020ULL)); + x241 = ((uintptr_t)((x240)<(x239)))+(x238); + x242 = (x241)+(x236); + x243 = (((uintptr_t)((x241)<(x238)))+((uintptr_t)((x242)<(x236))))+(x237); + x244 = (x243)+(x234); + x245 = (((uintptr_t)((x243)<(x237)))+((uintptr_t)((x244)<(x234))))+(x235); + x246 = (x245)+(x232); + x247 = (((uintptr_t)((x245)<(x235)))+((uintptr_t)((x246)<(x232))))+(x233); + x248 = (x247)+(x230); + x249 = (((uintptr_t)((x247)<(x233)))+((uintptr_t)((x248)<(x230))))+(x231); + x250 = (x249)+(x228); + x251 = (((uintptr_t)((x249)<(x231)))+((uintptr_t)((x250)<(x228))))+(x229); + x252 = (x251)+(x226); + x253 = ((uintptr_t)((x251)<(x229)))+((uintptr_t)((x252)<(x226))); + x254 = ((uintptr_t)(((x209)+((x225)*((uintptr_t)3493216577ULL)))<(x209)))+(x211); + x255 = (x254)+(x240); + x256 = (((uintptr_t)((x254)<(x211)))+((uintptr_t)((x255)<(x240))))+(x213); + x257 = (x256)+(x242); + x258 = (((uintptr_t)((x256)<(x213)))+((uintptr_t)((x257)<(x242))))+(x215); + x259 = (x258)+(x244); + x260 = (((uintptr_t)((x258)<(x215)))+((uintptr_t)((x259)<(x244))))+(x217); + x261 = (x260)+(x246); + x262 = (((uintptr_t)((x260)<(x217)))+((uintptr_t)((x261)<(x246))))+(x219); + x263 = (x262)+(x248); + x264 = (((uintptr_t)((x262)<(x219)))+((uintptr_t)((x263)<(x248))))+(x221); + x265 = (x264)+(x250); + x266 = (((uintptr_t)((x264)<(x221)))+((uintptr_t)((x265)<(x250))))+(x223); + x267 = (x266)+(x252); + x268 = (((uintptr_t)((x266)<(x223)))+((uintptr_t)((x267)<(x252))))+(((x224)+(x180))+((x208)+(x182))); + x269 = (x268)+((x253)+(x227)); + x270 = ((uintptr_t)((x268)<(((x224)+(x180))+((x208)+(x182)))))+((uintptr_t)((x269)<((x253)+(x227)))); + x271 = (x10)*((uintptr_t)2640780501ULL); + x272 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)2640780501ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)2640780501ULL))>>64); + x273 = (x10)*((uintptr_t)2177276869ULL); + x274 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)2177276869ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)2177276869ULL))>>64); + x275 = (x10)*((uintptr_t)3868718564ULL); + x276 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)3868718564ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)3868718564ULL))>>64); + x277 = (x10)*((uintptr_t)1540163526ULL); + x278 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)1540163526ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)1540163526ULL))>>64); + x279 = (x10)*((uintptr_t)1947506370ULL); + x280 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)1947506370ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)1947506370ULL))>>64); + x281 = (x10)*((uintptr_t)243071096ULL); + x282 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)243071096ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)243071096ULL))>>64); + x283 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)2305618452ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)2305618452ULL))>>64); + x284 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)1742197056ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)1742197056ULL))>>64); + x285 = (x284)+((x10)*((uintptr_t)2305618452ULL)); + x286 = ((uintptr_t)((x285)<(x284)))+(x283); + x287 = (x286)+(x281); + x288 = (((uintptr_t)((x286)<(x283)))+((uintptr_t)((x287)<(x281))))+(x282); + x289 = (x288)+(x279); + x290 = (((uintptr_t)((x288)<(x282)))+((uintptr_t)((x289)<(x279))))+(x280); + x291 = (x290)+(x277); + x292 = (((uintptr_t)((x290)<(x280)))+((uintptr_t)((x291)<(x277))))+(x278); + x293 = (x292)+(x275); + x294 = (((uintptr_t)((x292)<(x278)))+((uintptr_t)((x293)<(x275))))+(x276); + x295 = (x294)+(x273); + x296 = (((uintptr_t)((x294)<(x276)))+((uintptr_t)((x295)<(x273))))+(x274); + x297 = (x296)+(x271); + x298 = ((uintptr_t)((x296)<(x274)))+((uintptr_t)((x297)<(x271))); + x299 = (x255)+((x10)*((uintptr_t)1742197056ULL)); + x300 = ((uintptr_t)((x299)<(x255)))+(x257); + x301 = (x300)+(x285); + x302 = (((uintptr_t)((x300)<(x257)))+((uintptr_t)((x301)<(x285))))+(x259); + x303 = (x302)+(x287); + x304 = (((uintptr_t)((x302)<(x259)))+((uintptr_t)((x303)<(x287))))+(x261); + x305 = (x304)+(x289); + x306 = (((uintptr_t)((x304)<(x261)))+((uintptr_t)((x305)<(x289))))+(x263); + x307 = (x306)+(x291); + x308 = (((uintptr_t)((x306)<(x263)))+((uintptr_t)((x307)<(x291))))+(x265); + x309 = (x308)+(x293); + x310 = (((uintptr_t)((x308)<(x265)))+((uintptr_t)((x309)<(x293))))+(x267); + x311 = (x310)+(x295); + x312 = (((uintptr_t)((x310)<(x267)))+((uintptr_t)((x311)<(x295))))+(x269); + x313 = (x312)+(x297); + x314 = ((uintptr_t)((x312)<(x269)))+((uintptr_t)((x313)<(x297))); + x315 = (x299)*((uintptr_t)1435021631ULL); + x316 = (x315)*((uintptr_t)4294967295ULL); + x317 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x315)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x315)*((uintptr_t)4294967295ULL))>>64); + x318 = (x315)*((uintptr_t)4294967295ULL); + x319 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x315)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x315)*((uintptr_t)4294967295ULL))>>64); + x320 = (x315)*((uintptr_t)4294967295ULL); + x321 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x315)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x315)*((uintptr_t)4294967295ULL))>>64); + x322 = (x315)*((uintptr_t)4294967294ULL); + x323 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x315)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x315)*((uintptr_t)4294967294ULL))>>64); + x324 = (x315)*((uintptr_t)3132021990ULL); + x325 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x315)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x315)*((uintptr_t)3132021990ULL))>>64); + x326 = (x315)*((uintptr_t)2940772411ULL); + x327 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x315)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x315)*((uintptr_t)2940772411ULL))>>64); + x328 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x315)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x315)*((uintptr_t)3218235020ULL))>>64); + x329 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x315)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x315)*((uintptr_t)3493216577ULL))>>64); + x330 = (x329)+((x315)*((uintptr_t)3218235020ULL)); + x331 = ((uintptr_t)((x330)<(x329)))+(x328); + x332 = (x331)+(x326); + x333 = (((uintptr_t)((x331)<(x328)))+((uintptr_t)((x332)<(x326))))+(x327); + x334 = (x333)+(x324); + x335 = (((uintptr_t)((x333)<(x327)))+((uintptr_t)((x334)<(x324))))+(x325); + x336 = (x335)+(x322); + x337 = (((uintptr_t)((x335)<(x325)))+((uintptr_t)((x336)<(x322))))+(x323); + x338 = (x337)+(x320); + x339 = (((uintptr_t)((x337)<(x323)))+((uintptr_t)((x338)<(x320))))+(x321); + x340 = (x339)+(x318); + x341 = (((uintptr_t)((x339)<(x321)))+((uintptr_t)((x340)<(x318))))+(x319); + x342 = (x341)+(x316); + x343 = ((uintptr_t)((x341)<(x319)))+((uintptr_t)((x342)<(x316))); + x344 = ((uintptr_t)(((x299)+((x315)*((uintptr_t)3493216577ULL)))<(x299)))+(x301); + x345 = (x344)+(x330); + x346 = (((uintptr_t)((x344)<(x301)))+((uintptr_t)((x345)<(x330))))+(x303); + x347 = (x346)+(x332); + x348 = (((uintptr_t)((x346)<(x303)))+((uintptr_t)((x347)<(x332))))+(x305); + x349 = (x348)+(x334); + x350 = (((uintptr_t)((x348)<(x305)))+((uintptr_t)((x349)<(x334))))+(x307); + x351 = (x350)+(x336); + x352 = (((uintptr_t)((x350)<(x307)))+((uintptr_t)((x351)<(x336))))+(x309); + x353 = (x352)+(x338); + x354 = (((uintptr_t)((x352)<(x309)))+((uintptr_t)((x353)<(x338))))+(x311); + x355 = (x354)+(x340); + x356 = (((uintptr_t)((x354)<(x311)))+((uintptr_t)((x355)<(x340))))+(x313); + x357 = (x356)+(x342); + x358 = (((uintptr_t)((x356)<(x313)))+((uintptr_t)((x357)<(x342))))+(((x314)+(x270))+((x298)+(x272))); + x359 = (x358)+((x343)+(x317)); + x360 = ((uintptr_t)((x358)<(((x314)+(x270))+((x298)+(x272)))))+((uintptr_t)((x359)<((x343)+(x317)))); + x361 = (x11)*((uintptr_t)2640780501ULL); + x362 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)2640780501ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)2640780501ULL))>>64); + x363 = (x11)*((uintptr_t)2177276869ULL); + x364 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)2177276869ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)2177276869ULL))>>64); + x365 = (x11)*((uintptr_t)3868718564ULL); + x366 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)3868718564ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)3868718564ULL))>>64); + x367 = (x11)*((uintptr_t)1540163526ULL); + x368 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)1540163526ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)1540163526ULL))>>64); + x369 = (x11)*((uintptr_t)1947506370ULL); + x370 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)1947506370ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)1947506370ULL))>>64); + x371 = (x11)*((uintptr_t)243071096ULL); + x372 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)243071096ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)243071096ULL))>>64); + x373 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)2305618452ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)2305618452ULL))>>64); + x374 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)1742197056ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)1742197056ULL))>>64); + x375 = (x374)+((x11)*((uintptr_t)2305618452ULL)); + x376 = ((uintptr_t)((x375)<(x374)))+(x373); + x377 = (x376)+(x371); + x378 = (((uintptr_t)((x376)<(x373)))+((uintptr_t)((x377)<(x371))))+(x372); + x379 = (x378)+(x369); + x380 = (((uintptr_t)((x378)<(x372)))+((uintptr_t)((x379)<(x369))))+(x370); + x381 = (x380)+(x367); + x382 = (((uintptr_t)((x380)<(x370)))+((uintptr_t)((x381)<(x367))))+(x368); + x383 = (x382)+(x365); + x384 = (((uintptr_t)((x382)<(x368)))+((uintptr_t)((x383)<(x365))))+(x366); + x385 = (x384)+(x363); + x386 = (((uintptr_t)((x384)<(x366)))+((uintptr_t)((x385)<(x363))))+(x364); + x387 = (x386)+(x361); + x388 = ((uintptr_t)((x386)<(x364)))+((uintptr_t)((x387)<(x361))); + x389 = (x345)+((x11)*((uintptr_t)1742197056ULL)); + x390 = ((uintptr_t)((x389)<(x345)))+(x347); + x391 = (x390)+(x375); + x392 = (((uintptr_t)((x390)<(x347)))+((uintptr_t)((x391)<(x375))))+(x349); + x393 = (x392)+(x377); + x394 = (((uintptr_t)((x392)<(x349)))+((uintptr_t)((x393)<(x377))))+(x351); + x395 = (x394)+(x379); + x396 = (((uintptr_t)((x394)<(x351)))+((uintptr_t)((x395)<(x379))))+(x353); + x397 = (x396)+(x381); + x398 = (((uintptr_t)((x396)<(x353)))+((uintptr_t)((x397)<(x381))))+(x355); + x399 = (x398)+(x383); + x400 = (((uintptr_t)((x398)<(x355)))+((uintptr_t)((x399)<(x383))))+(x357); + x401 = (x400)+(x385); + x402 = (((uintptr_t)((x400)<(x357)))+((uintptr_t)((x401)<(x385))))+(x359); + x403 = (x402)+(x387); + x404 = ((uintptr_t)((x402)<(x359)))+((uintptr_t)((x403)<(x387))); + x405 = (x389)*((uintptr_t)1435021631ULL); + x406 = (x405)*((uintptr_t)4294967295ULL); + x407 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)4294967295ULL))>>64); + x408 = (x405)*((uintptr_t)4294967295ULL); + x409 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)4294967295ULL))>>64); + x410 = (x405)*((uintptr_t)4294967295ULL); + x411 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)4294967295ULL))>>64); + x412 = (x405)*((uintptr_t)4294967294ULL); + x413 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)4294967294ULL))>>64); + x414 = (x405)*((uintptr_t)3132021990ULL); + x415 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)3132021990ULL))>>64); + x416 = (x405)*((uintptr_t)2940772411ULL); + x417 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)2940772411ULL))>>64); + x418 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)3218235020ULL))>>64); + x419 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x405)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x405)*((uintptr_t)3493216577ULL))>>64); + x420 = (x419)+((x405)*((uintptr_t)3218235020ULL)); + x421 = ((uintptr_t)((x420)<(x419)))+(x418); + x422 = (x421)+(x416); + x423 = (((uintptr_t)((x421)<(x418)))+((uintptr_t)((x422)<(x416))))+(x417); + x424 = (x423)+(x414); + x425 = (((uintptr_t)((x423)<(x417)))+((uintptr_t)((x424)<(x414))))+(x415); + x426 = (x425)+(x412); + x427 = (((uintptr_t)((x425)<(x415)))+((uintptr_t)((x426)<(x412))))+(x413); + x428 = (x427)+(x410); + x429 = (((uintptr_t)((x427)<(x413)))+((uintptr_t)((x428)<(x410))))+(x411); + x430 = (x429)+(x408); + x431 = (((uintptr_t)((x429)<(x411)))+((uintptr_t)((x430)<(x408))))+(x409); + x432 = (x431)+(x406); + x433 = ((uintptr_t)((x431)<(x409)))+((uintptr_t)((x432)<(x406))); + x434 = ((uintptr_t)(((x389)+((x405)*((uintptr_t)3493216577ULL)))<(x389)))+(x391); + x435 = (x434)+(x420); + x436 = (((uintptr_t)((x434)<(x391)))+((uintptr_t)((x435)<(x420))))+(x393); + x437 = (x436)+(x422); + x438 = (((uintptr_t)((x436)<(x393)))+((uintptr_t)((x437)<(x422))))+(x395); + x439 = (x438)+(x424); + x440 = (((uintptr_t)((x438)<(x395)))+((uintptr_t)((x439)<(x424))))+(x397); + x441 = (x440)+(x426); + x442 = (((uintptr_t)((x440)<(x397)))+((uintptr_t)((x441)<(x426))))+(x399); + x443 = (x442)+(x428); + x444 = (((uintptr_t)((x442)<(x399)))+((uintptr_t)((x443)<(x428))))+(x401); + x445 = (x444)+(x430); + x446 = (((uintptr_t)((x444)<(x401)))+((uintptr_t)((x445)<(x430))))+(x403); + x447 = (x446)+(x432); + x448 = (((uintptr_t)((x446)<(x403)))+((uintptr_t)((x447)<(x432))))+(((x404)+(x360))+((x388)+(x362))); + x449 = (x448)+((x433)+(x407)); + x450 = ((uintptr_t)((x448)<(((x404)+(x360))+((x388)+(x362)))))+((uintptr_t)((x449)<((x433)+(x407)))); + x451 = (x12)*((uintptr_t)2640780501ULL); + x452 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)2640780501ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)2640780501ULL))>>64); + x453 = (x12)*((uintptr_t)2177276869ULL); + x454 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)2177276869ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)2177276869ULL))>>64); + x455 = (x12)*((uintptr_t)3868718564ULL); + x456 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)3868718564ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)3868718564ULL))>>64); + x457 = (x12)*((uintptr_t)1540163526ULL); + x458 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)1540163526ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)1540163526ULL))>>64); + x459 = (x12)*((uintptr_t)1947506370ULL); + x460 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)1947506370ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)1947506370ULL))>>64); + x461 = (x12)*((uintptr_t)243071096ULL); + x462 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)243071096ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)243071096ULL))>>64); + x463 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)2305618452ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)2305618452ULL))>>64); + x464 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)1742197056ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)1742197056ULL))>>64); + x465 = (x464)+((x12)*((uintptr_t)2305618452ULL)); + x466 = ((uintptr_t)((x465)<(x464)))+(x463); + x467 = (x466)+(x461); + x468 = (((uintptr_t)((x466)<(x463)))+((uintptr_t)((x467)<(x461))))+(x462); + x469 = (x468)+(x459); + x470 = (((uintptr_t)((x468)<(x462)))+((uintptr_t)((x469)<(x459))))+(x460); + x471 = (x470)+(x457); + x472 = (((uintptr_t)((x470)<(x460)))+((uintptr_t)((x471)<(x457))))+(x458); + x473 = (x472)+(x455); + x474 = (((uintptr_t)((x472)<(x458)))+((uintptr_t)((x473)<(x455))))+(x456); + x475 = (x474)+(x453); + x476 = (((uintptr_t)((x474)<(x456)))+((uintptr_t)((x475)<(x453))))+(x454); + x477 = (x476)+(x451); + x478 = ((uintptr_t)((x476)<(x454)))+((uintptr_t)((x477)<(x451))); + x479 = (x435)+((x12)*((uintptr_t)1742197056ULL)); + x480 = ((uintptr_t)((x479)<(x435)))+(x437); + x481 = (x480)+(x465); + x482 = (((uintptr_t)((x480)<(x437)))+((uintptr_t)((x481)<(x465))))+(x439); + x483 = (x482)+(x467); + x484 = (((uintptr_t)((x482)<(x439)))+((uintptr_t)((x483)<(x467))))+(x441); + x485 = (x484)+(x469); + x486 = (((uintptr_t)((x484)<(x441)))+((uintptr_t)((x485)<(x469))))+(x443); + x487 = (x486)+(x471); + x488 = (((uintptr_t)((x486)<(x443)))+((uintptr_t)((x487)<(x471))))+(x445); + x489 = (x488)+(x473); + x490 = (((uintptr_t)((x488)<(x445)))+((uintptr_t)((x489)<(x473))))+(x447); + x491 = (x490)+(x475); + x492 = (((uintptr_t)((x490)<(x447)))+((uintptr_t)((x491)<(x475))))+(x449); + x493 = (x492)+(x477); + x494 = ((uintptr_t)((x492)<(x449)))+((uintptr_t)((x493)<(x477))); + x495 = (x479)*((uintptr_t)1435021631ULL); + x496 = (x495)*((uintptr_t)4294967295ULL); + x497 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x495)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x495)*((uintptr_t)4294967295ULL))>>64); + x498 = (x495)*((uintptr_t)4294967295ULL); + x499 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x495)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x495)*((uintptr_t)4294967295ULL))>>64); + x500 = (x495)*((uintptr_t)4294967295ULL); + x501 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x495)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x495)*((uintptr_t)4294967295ULL))>>64); + x502 = (x495)*((uintptr_t)4294967294ULL); + x503 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x495)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x495)*((uintptr_t)4294967294ULL))>>64); + x504 = (x495)*((uintptr_t)3132021990ULL); + x505 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x495)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x495)*((uintptr_t)3132021990ULL))>>64); + x506 = (x495)*((uintptr_t)2940772411ULL); + x507 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x495)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x495)*((uintptr_t)2940772411ULL))>>64); + x508 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x495)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x495)*((uintptr_t)3218235020ULL))>>64); + x509 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x495)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x495)*((uintptr_t)3493216577ULL))>>64); + x510 = (x509)+((x495)*((uintptr_t)3218235020ULL)); + x511 = ((uintptr_t)((x510)<(x509)))+(x508); + x512 = (x511)+(x506); + x513 = (((uintptr_t)((x511)<(x508)))+((uintptr_t)((x512)<(x506))))+(x507); + x514 = (x513)+(x504); + x515 = (((uintptr_t)((x513)<(x507)))+((uintptr_t)((x514)<(x504))))+(x505); + x516 = (x515)+(x502); + x517 = (((uintptr_t)((x515)<(x505)))+((uintptr_t)((x516)<(x502))))+(x503); + x518 = (x517)+(x500); + x519 = (((uintptr_t)((x517)<(x503)))+((uintptr_t)((x518)<(x500))))+(x501); + x520 = (x519)+(x498); + x521 = (((uintptr_t)((x519)<(x501)))+((uintptr_t)((x520)<(x498))))+(x499); + x522 = (x521)+(x496); + x523 = ((uintptr_t)((x521)<(x499)))+((uintptr_t)((x522)<(x496))); + x524 = ((uintptr_t)(((x479)+((x495)*((uintptr_t)3493216577ULL)))<(x479)))+(x481); + x525 = (x524)+(x510); + x526 = (((uintptr_t)((x524)<(x481)))+((uintptr_t)((x525)<(x510))))+(x483); + x527 = (x526)+(x512); + x528 = (((uintptr_t)((x526)<(x483)))+((uintptr_t)((x527)<(x512))))+(x485); + x529 = (x528)+(x514); + x530 = (((uintptr_t)((x528)<(x485)))+((uintptr_t)((x529)<(x514))))+(x487); + x531 = (x530)+(x516); + x532 = (((uintptr_t)((x530)<(x487)))+((uintptr_t)((x531)<(x516))))+(x489); + x533 = (x532)+(x518); + x534 = (((uintptr_t)((x532)<(x489)))+((uintptr_t)((x533)<(x518))))+(x491); + x535 = (x534)+(x520); + x536 = (((uintptr_t)((x534)<(x491)))+((uintptr_t)((x535)<(x520))))+(x493); + x537 = (x536)+(x522); + x538 = (((uintptr_t)((x536)<(x493)))+((uintptr_t)((x537)<(x522))))+(((x494)+(x450))+((x478)+(x452))); + x539 = (x538)+((x523)+(x497)); + x540 = ((uintptr_t)((x538)<(((x494)+(x450))+((x478)+(x452)))))+((uintptr_t)((x539)<((x523)+(x497)))); + x541 = (x13)*((uintptr_t)2640780501ULL); + x542 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)2640780501ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)2640780501ULL))>>64); + x543 = (x13)*((uintptr_t)2177276869ULL); + x544 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)2177276869ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)2177276869ULL))>>64); + x545 = (x13)*((uintptr_t)3868718564ULL); + x546 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)3868718564ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)3868718564ULL))>>64); + x547 = (x13)*((uintptr_t)1540163526ULL); + x548 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)1540163526ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)1540163526ULL))>>64); + x549 = (x13)*((uintptr_t)1947506370ULL); + x550 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)1947506370ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)1947506370ULL))>>64); + x551 = (x13)*((uintptr_t)243071096ULL); + x552 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)243071096ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)243071096ULL))>>64); + x553 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)2305618452ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)2305618452ULL))>>64); + x554 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)1742197056ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)1742197056ULL))>>64); + x555 = (x554)+((x13)*((uintptr_t)2305618452ULL)); + x556 = ((uintptr_t)((x555)<(x554)))+(x553); + x557 = (x556)+(x551); + x558 = (((uintptr_t)((x556)<(x553)))+((uintptr_t)((x557)<(x551))))+(x552); + x559 = (x558)+(x549); + x560 = (((uintptr_t)((x558)<(x552)))+((uintptr_t)((x559)<(x549))))+(x550); + x561 = (x560)+(x547); + x562 = (((uintptr_t)((x560)<(x550)))+((uintptr_t)((x561)<(x547))))+(x548); + x563 = (x562)+(x545); + x564 = (((uintptr_t)((x562)<(x548)))+((uintptr_t)((x563)<(x545))))+(x546); + x565 = (x564)+(x543); + x566 = (((uintptr_t)((x564)<(x546)))+((uintptr_t)((x565)<(x543))))+(x544); + x567 = (x566)+(x541); + x568 = ((uintptr_t)((x566)<(x544)))+((uintptr_t)((x567)<(x541))); + x569 = (x525)+((x13)*((uintptr_t)1742197056ULL)); + x570 = ((uintptr_t)((x569)<(x525)))+(x527); + x571 = (x570)+(x555); + x572 = (((uintptr_t)((x570)<(x527)))+((uintptr_t)((x571)<(x555))))+(x529); + x573 = (x572)+(x557); + x574 = (((uintptr_t)((x572)<(x529)))+((uintptr_t)((x573)<(x557))))+(x531); + x575 = (x574)+(x559); + x576 = (((uintptr_t)((x574)<(x531)))+((uintptr_t)((x575)<(x559))))+(x533); + x577 = (x576)+(x561); + x578 = (((uintptr_t)((x576)<(x533)))+((uintptr_t)((x577)<(x561))))+(x535); + x579 = (x578)+(x563); + x580 = (((uintptr_t)((x578)<(x535)))+((uintptr_t)((x579)<(x563))))+(x537); + x581 = (x580)+(x565); + x582 = (((uintptr_t)((x580)<(x537)))+((uintptr_t)((x581)<(x565))))+(x539); + x583 = (x582)+(x567); + x584 = ((uintptr_t)((x582)<(x539)))+((uintptr_t)((x583)<(x567))); + x585 = (x569)*((uintptr_t)1435021631ULL); + x586 = (x585)*((uintptr_t)4294967295ULL); + x587 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x585)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x585)*((uintptr_t)4294967295ULL))>>64); + x588 = (x585)*((uintptr_t)4294967295ULL); + x589 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x585)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x585)*((uintptr_t)4294967295ULL))>>64); + x590 = (x585)*((uintptr_t)4294967295ULL); + x591 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x585)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x585)*((uintptr_t)4294967295ULL))>>64); + x592 = (x585)*((uintptr_t)4294967294ULL); + x593 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x585)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x585)*((uintptr_t)4294967294ULL))>>64); + x594 = (x585)*((uintptr_t)3132021990ULL); + x595 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x585)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x585)*((uintptr_t)3132021990ULL))>>64); + x596 = (x585)*((uintptr_t)2940772411ULL); + x597 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x585)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x585)*((uintptr_t)2940772411ULL))>>64); + x598 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x585)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x585)*((uintptr_t)3218235020ULL))>>64); + x599 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x585)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x585)*((uintptr_t)3493216577ULL))>>64); + x600 = (x599)+((x585)*((uintptr_t)3218235020ULL)); + x601 = ((uintptr_t)((x600)<(x599)))+(x598); + x602 = (x601)+(x596); + x603 = (((uintptr_t)((x601)<(x598)))+((uintptr_t)((x602)<(x596))))+(x597); + x604 = (x603)+(x594); + x605 = (((uintptr_t)((x603)<(x597)))+((uintptr_t)((x604)<(x594))))+(x595); + x606 = (x605)+(x592); + x607 = (((uintptr_t)((x605)<(x595)))+((uintptr_t)((x606)<(x592))))+(x593); + x608 = (x607)+(x590); + x609 = (((uintptr_t)((x607)<(x593)))+((uintptr_t)((x608)<(x590))))+(x591); + x610 = (x609)+(x588); + x611 = (((uintptr_t)((x609)<(x591)))+((uintptr_t)((x610)<(x588))))+(x589); + x612 = (x611)+(x586); + x613 = ((uintptr_t)((x611)<(x589)))+((uintptr_t)((x612)<(x586))); + x614 = ((uintptr_t)(((x569)+((x585)*((uintptr_t)3493216577ULL)))<(x569)))+(x571); + x615 = (x614)+(x600); + x616 = (((uintptr_t)((x614)<(x571)))+((uintptr_t)((x615)<(x600))))+(x573); + x617 = (x616)+(x602); + x618 = (((uintptr_t)((x616)<(x573)))+((uintptr_t)((x617)<(x602))))+(x575); + x619 = (x618)+(x604); + x620 = (((uintptr_t)((x618)<(x575)))+((uintptr_t)((x619)<(x604))))+(x577); + x621 = (x620)+(x606); + x622 = (((uintptr_t)((x620)<(x577)))+((uintptr_t)((x621)<(x606))))+(x579); + x623 = (x622)+(x608); + x624 = (((uintptr_t)((x622)<(x579)))+((uintptr_t)((x623)<(x608))))+(x581); + x625 = (x624)+(x610); + x626 = (((uintptr_t)((x624)<(x581)))+((uintptr_t)((x625)<(x610))))+(x583); + x627 = (x626)+(x612); + x628 = (((uintptr_t)((x626)<(x583)))+((uintptr_t)((x627)<(x612))))+(((x584)+(x540))+((x568)+(x542))); + x629 = (x628)+((x613)+(x587)); + x630 = ((uintptr_t)((x628)<(((x584)+(x540))+((x568)+(x542)))))+((uintptr_t)((x629)<((x613)+(x587)))); + x631 = (x14)*((uintptr_t)2640780501ULL); + x632 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)2640780501ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)2640780501ULL))>>64); + x633 = (x14)*((uintptr_t)2177276869ULL); + x634 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)2177276869ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)2177276869ULL))>>64); + x635 = (x14)*((uintptr_t)3868718564ULL); + x636 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)3868718564ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)3868718564ULL))>>64); + x637 = (x14)*((uintptr_t)1540163526ULL); + x638 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)1540163526ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)1540163526ULL))>>64); + x639 = (x14)*((uintptr_t)1947506370ULL); + x640 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)1947506370ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)1947506370ULL))>>64); + x641 = (x14)*((uintptr_t)243071096ULL); + x642 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)243071096ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)243071096ULL))>>64); + x643 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)2305618452ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)2305618452ULL))>>64); + x644 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)1742197056ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)1742197056ULL))>>64); + x645 = (x644)+((x14)*((uintptr_t)2305618452ULL)); + x646 = ((uintptr_t)((x645)<(x644)))+(x643); + x647 = (x646)+(x641); + x648 = (((uintptr_t)((x646)<(x643)))+((uintptr_t)((x647)<(x641))))+(x642); + x649 = (x648)+(x639); + x650 = (((uintptr_t)((x648)<(x642)))+((uintptr_t)((x649)<(x639))))+(x640); + x651 = (x650)+(x637); + x652 = (((uintptr_t)((x650)<(x640)))+((uintptr_t)((x651)<(x637))))+(x638); + x653 = (x652)+(x635); + x654 = (((uintptr_t)((x652)<(x638)))+((uintptr_t)((x653)<(x635))))+(x636); + x655 = (x654)+(x633); + x656 = (((uintptr_t)((x654)<(x636)))+((uintptr_t)((x655)<(x633))))+(x634); + x657 = (x656)+(x631); + x658 = ((uintptr_t)((x656)<(x634)))+((uintptr_t)((x657)<(x631))); + x659 = (x615)+((x14)*((uintptr_t)1742197056ULL)); + x660 = ((uintptr_t)((x659)<(x615)))+(x617); + x661 = (x660)+(x645); + x662 = (((uintptr_t)((x660)<(x617)))+((uintptr_t)((x661)<(x645))))+(x619); + x663 = (x662)+(x647); + x664 = (((uintptr_t)((x662)<(x619)))+((uintptr_t)((x663)<(x647))))+(x621); + x665 = (x664)+(x649); + x666 = (((uintptr_t)((x664)<(x621)))+((uintptr_t)((x665)<(x649))))+(x623); + x667 = (x666)+(x651); + x668 = (((uintptr_t)((x666)<(x623)))+((uintptr_t)((x667)<(x651))))+(x625); + x669 = (x668)+(x653); + x670 = (((uintptr_t)((x668)<(x625)))+((uintptr_t)((x669)<(x653))))+(x627); + x671 = (x670)+(x655); + x672 = (((uintptr_t)((x670)<(x627)))+((uintptr_t)((x671)<(x655))))+(x629); + x673 = (x672)+(x657); + x674 = ((uintptr_t)((x672)<(x629)))+((uintptr_t)((x673)<(x657))); + x675 = (x659)*((uintptr_t)1435021631ULL); + x676 = (x675)*((uintptr_t)4294967295ULL); + x677 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967295ULL))>>64); + x678 = (x675)*((uintptr_t)4294967295ULL); + x679 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967295ULL))>>64); + x680 = (x675)*((uintptr_t)4294967295ULL); + x681 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967295ULL))>>64); + x682 = (x675)*((uintptr_t)4294967294ULL); + x683 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967294ULL))>>64); + x684 = (x675)*((uintptr_t)3132021990ULL); + x685 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)3132021990ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)3132021990ULL))>>64); + x686 = (x675)*((uintptr_t)2940772411ULL); + x687 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)2940772411ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)2940772411ULL))>>64); + x688 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)3218235020ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)3218235020ULL))>>64); + x689 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)3493216577ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)3493216577ULL))>>64); + x690 = (x689)+((x675)*((uintptr_t)3218235020ULL)); + x691 = ((uintptr_t)((x690)<(x689)))+(x688); + x692 = (x691)+(x686); + x693 = (((uintptr_t)((x691)<(x688)))+((uintptr_t)((x692)<(x686))))+(x687); + x694 = (x693)+(x684); + x695 = (((uintptr_t)((x693)<(x687)))+((uintptr_t)((x694)<(x684))))+(x685); + x696 = (x695)+(x682); + x697 = (((uintptr_t)((x695)<(x685)))+((uintptr_t)((x696)<(x682))))+(x683); + x698 = (x697)+(x680); + x699 = (((uintptr_t)((x697)<(x683)))+((uintptr_t)((x698)<(x680))))+(x681); + x700 = (x699)+(x678); + x701 = (((uintptr_t)((x699)<(x681)))+((uintptr_t)((x700)<(x678))))+(x679); + x702 = (x701)+(x676); + x703 = ((uintptr_t)((x701)<(x679)))+((uintptr_t)((x702)<(x676))); + x704 = ((uintptr_t)(((x659)+((x675)*((uintptr_t)3493216577ULL)))<(x659)))+(x661); + x705 = (x704)+(x690); + x706 = (((uintptr_t)((x704)<(x661)))+((uintptr_t)((x705)<(x690))))+(x663); + x707 = (x706)+(x692); + x708 = (((uintptr_t)((x706)<(x663)))+((uintptr_t)((x707)<(x692))))+(x665); + x709 = (x708)+(x694); + x710 = (((uintptr_t)((x708)<(x665)))+((uintptr_t)((x709)<(x694))))+(x667); + x711 = (x710)+(x696); + x712 = (((uintptr_t)((x710)<(x667)))+((uintptr_t)((x711)<(x696))))+(x669); + x713 = (x712)+(x698); + x714 = (((uintptr_t)((x712)<(x669)))+((uintptr_t)((x713)<(x698))))+(x671); + x715 = (x714)+(x700); + x716 = (((uintptr_t)((x714)<(x671)))+((uintptr_t)((x715)<(x700))))+(x673); + x717 = (x716)+(x702); + x718 = (((uintptr_t)((x716)<(x673)))+((uintptr_t)((x717)<(x702))))+(((x674)+(x630))+((x658)+(x632))); + x719 = (x718)+((x703)+(x677)); + x720 = ((uintptr_t)((x718)<(((x674)+(x630))+((x658)+(x632)))))+((uintptr_t)((x719)<((x703)+(x677)))); + x721 = (x705)-((uintptr_t)3493216577ULL); + x722 = (x707)-((uintptr_t)3218235020ULL); + x723 = (x722)-((uintptr_t)((x705)<(x721))); + x724 = (x709)-((uintptr_t)2940772411ULL); + x725 = (x724)-(((uintptr_t)((x707)<(x722)))+((uintptr_t)((x722)<(x723)))); + x726 = (x711)-((uintptr_t)3132021990ULL); + x727 = (x726)-(((uintptr_t)((x709)<(x724)))+((uintptr_t)((x724)<(x725)))); + x728 = (x713)-((uintptr_t)4294967294ULL); + x729 = (x728)-(((uintptr_t)((x711)<(x726)))+((uintptr_t)((x726)<(x727)))); + x730 = (x715)-((uintptr_t)4294967295ULL); + x731 = (x730)-(((uintptr_t)((x713)<(x728)))+((uintptr_t)((x728)<(x729)))); + x732 = (x717)-((uintptr_t)4294967295ULL); + x733 = (x732)-(((uintptr_t)((x715)<(x730)))+((uintptr_t)((x730)<(x731)))); + x734 = (x719)-((uintptr_t)4294967295ULL); + x735 = (x734)-(((uintptr_t)((x717)<(x732)))+((uintptr_t)((x732)<(x733)))); + x736 = (uintptr_t)((x720)<((x720)-(((uintptr_t)((x719)<(x734)))+((uintptr_t)((x734)<(x735)))))); + x737 = ((uintptr_t)-1ULL)+((uintptr_t)((x736)==((uintptr_t)0ULL))); + x738 = (x737)^((uintptr_t)4294967295ULL); + x739 = ((x705)&(x737))|((x721)&(x738)); + x740 = ((uintptr_t)-1ULL)+((uintptr_t)((x736)==((uintptr_t)0ULL))); + x741 = (x740)^((uintptr_t)4294967295ULL); + x742 = ((x707)&(x740))|((x723)&(x741)); + x743 = ((uintptr_t)-1ULL)+((uintptr_t)((x736)==((uintptr_t)0ULL))); + x744 = (x743)^((uintptr_t)4294967295ULL); + x745 = ((x709)&(x743))|((x725)&(x744)); + x746 = ((uintptr_t)-1ULL)+((uintptr_t)((x736)==((uintptr_t)0ULL))); + x747 = (x746)^((uintptr_t)4294967295ULL); + x748 = ((x711)&(x746))|((x727)&(x747)); + x749 = ((uintptr_t)-1ULL)+((uintptr_t)((x736)==((uintptr_t)0ULL))); + x750 = (x749)^((uintptr_t)4294967295ULL); + x751 = ((x713)&(x749))|((x729)&(x750)); + x752 = ((uintptr_t)-1ULL)+((uintptr_t)((x736)==((uintptr_t)0ULL))); + x753 = (x752)^((uintptr_t)4294967295ULL); + x754 = ((x715)&(x752))|((x731)&(x753)); + x755 = ((uintptr_t)-1ULL)+((uintptr_t)((x736)==((uintptr_t)0ULL))); + x756 = (x755)^((uintptr_t)4294967295ULL); + x757 = ((x717)&(x755))|((x733)&(x756)); + x758 = ((uintptr_t)-1ULL)+((uintptr_t)((x736)==((uintptr_t)0ULL))); + x759 = (x758)^((uintptr_t)4294967295ULL); + x760 = ((x719)&(x758))|((x735)&(x759)); + x761 = x739; + x762 = x742; + x763 = x745; + x764 = x748; + x765 = x751; + x766 = x754; + x767 = x757; + x768 = x760; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x761, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x762, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x763, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x764, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x765, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x766, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x767, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x768, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_to_montgomery(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_secp256k1_scalar_to_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffff] + */ +static +uintptr_t internal_fiat_secp256k1_scalar_nonzero(uintptr_t in0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8, out0, x9; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = (x0)|((x1)|((x2)|((x3)|((x4)|((x5)|((x6)|(x7))))))); + x9 = x8; + out0 = x9; + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_nonzero(uint32_t* out1, const uint32_t arg1[8]) { + *out1 = (uint32_t)internal_fiat_secp256k1_scalar_nonzero((uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0x1] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_selectznz(uintptr_t out0, uintptr_t in0, uintptr_t in1, uintptr_t in2) { + uintptr_t x8, x16, x0, x17, x9, x19, x1, x20, x10, x22, x2, x23, x11, x25, x3, x26, x12, x28, x4, x29, x13, x31, x5, x32, x14, x34, x6, x35, x15, x37, x7, x38, x18, x21, x24, x27, x30, x33, x36, x39, x40, x41, x42, x43, x44, x45, x46, x47; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x9 = _br2_load((in2)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x10 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x11 = _br2_load((in2)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x12 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in2)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x14 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x15 = _br2_load((in2)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x17 = (x16)^((uintptr_t)4294967295ULL); + x18 = ((x8)&(x16))|((x0)&(x17)); + x19 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x20 = (x19)^((uintptr_t)4294967295ULL); + x21 = ((x9)&(x19))|((x1)&(x20)); + x22 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x23 = (x22)^((uintptr_t)4294967295ULL); + x24 = ((x10)&(x22))|((x2)&(x23)); + x25 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x26 = (x25)^((uintptr_t)4294967295ULL); + x27 = ((x11)&(x25))|((x3)&(x26)); + x28 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x29 = (x28)^((uintptr_t)4294967295ULL); + x30 = ((x12)&(x28))|((x4)&(x29)); + x31 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x32 = (x31)^((uintptr_t)4294967295ULL); + x33 = ((x13)&(x31))|((x5)&(x32)); + x34 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x35 = (x34)^((uintptr_t)4294967295ULL); + x36 = ((x14)&(x34))|((x6)&(x35)); + x37 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x38 = (x37)^((uintptr_t)4294967295ULL); + x39 = ((x15)&(x37))|((x7)&(x38)); + x40 = x18; + x41 = x21; + x42 = x24; + x43 = x27; + x44 = x30; + x45 = x33; + x46 = x36; + x47 = x39; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x40, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x41, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x42, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x43, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x44, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x45, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x46, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x47, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_selectznz(uint32_t out1[8], uint8_t arg1, const uint32_t arg2[8], const uint32_t arg3[8]) { + internal_fiat_secp256k1_scalar_selectznz((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static +void internal_fiat_secp256k1_scalar_to_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x7, x6, x5, x4, x3, x2, x1, x0, x15, x17, x19, x14, x23, x25, x13, x29, x31, x12, x35, x37, x11, x41, x43, x10, x47, x49, x9, x53, x55, x8, x59, x61, x16, x18, x20, x21, x22, x24, x26, x27, x28, x30, x32, x33, x34, x36, x38, x39, x40, x42, x44, x45, x46, x48, x50, x51, x52, x54, x56, x57, x58, x60, x62, x63, x64, x65, x66, x67, x68, x69, x70, x71, x72, x73, x74, x75, x76, x77, x78, x79, x80, x81, x82, x83, x84, x85, x86, x87, x88, x89, x90, x91, x92, x93, x94, x95; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x7; + x9 = x6; + x10 = x5; + x11 = x4; + x12 = x3; + x13 = x2; + x14 = x1; + x15 = x0; + x16 = (x15)&((uintptr_t)255ULL); + x17 = (x15)>>((uintptr_t)8ULL); + x18 = (x17)&((uintptr_t)255ULL); + x19 = (x17)>>((uintptr_t)8ULL); + x20 = (x19)&((uintptr_t)255ULL); + x21 = (x19)>>((uintptr_t)8ULL); + x22 = (x14)&((uintptr_t)255ULL); + x23 = (x14)>>((uintptr_t)8ULL); + x24 = (x23)&((uintptr_t)255ULL); + x25 = (x23)>>((uintptr_t)8ULL); + x26 = (x25)&((uintptr_t)255ULL); + x27 = (x25)>>((uintptr_t)8ULL); + x28 = (x13)&((uintptr_t)255ULL); + x29 = (x13)>>((uintptr_t)8ULL); + x30 = (x29)&((uintptr_t)255ULL); + x31 = (x29)>>((uintptr_t)8ULL); + x32 = (x31)&((uintptr_t)255ULL); + x33 = (x31)>>((uintptr_t)8ULL); + x34 = (x12)&((uintptr_t)255ULL); + x35 = (x12)>>((uintptr_t)8ULL); + x36 = (x35)&((uintptr_t)255ULL); + x37 = (x35)>>((uintptr_t)8ULL); + x38 = (x37)&((uintptr_t)255ULL); + x39 = (x37)>>((uintptr_t)8ULL); + x40 = (x11)&((uintptr_t)255ULL); + x41 = (x11)>>((uintptr_t)8ULL); + x42 = (x41)&((uintptr_t)255ULL); + x43 = (x41)>>((uintptr_t)8ULL); + x44 = (x43)&((uintptr_t)255ULL); + x45 = (x43)>>((uintptr_t)8ULL); + x46 = (x10)&((uintptr_t)255ULL); + x47 = (x10)>>((uintptr_t)8ULL); + x48 = (x47)&((uintptr_t)255ULL); + x49 = (x47)>>((uintptr_t)8ULL); + x50 = (x49)&((uintptr_t)255ULL); + x51 = (x49)>>((uintptr_t)8ULL); + x52 = (x9)&((uintptr_t)255ULL); + x53 = (x9)>>((uintptr_t)8ULL); + x54 = (x53)&((uintptr_t)255ULL); + x55 = (x53)>>((uintptr_t)8ULL); + x56 = (x55)&((uintptr_t)255ULL); + x57 = (x55)>>((uintptr_t)8ULL); + x58 = (x8)&((uintptr_t)255ULL); + x59 = (x8)>>((uintptr_t)8ULL); + x60 = (x59)&((uintptr_t)255ULL); + x61 = (x59)>>((uintptr_t)8ULL); + x62 = (x61)&((uintptr_t)255ULL); + x63 = (x61)>>((uintptr_t)8ULL); + x64 = x16; + x65 = x18; + x66 = x20; + x67 = x21; + x68 = x22; + x69 = x24; + x70 = x26; + x71 = x27; + x72 = x28; + x73 = x30; + x74 = x32; + x75 = x33; + x76 = x34; + x77 = x36; + x78 = x38; + x79 = x39; + x80 = x40; + x81 = x42; + x82 = x44; + x83 = x45; + x84 = x46; + x85 = x48; + x86 = x50; + x87 = x51; + x88 = x52; + x89 = x54; + x90 = x56; + x91 = x57; + x92 = x58; + x93 = x60; + x94 = x62; + x95 = x63; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x64, 1); + _br2_store((out0)+((uintptr_t)1ULL), x65, 1); + _br2_store((out0)+((uintptr_t)2ULL), x66, 1); + _br2_store((out0)+((uintptr_t)3ULL), x67, 1); + _br2_store((out0)+((uintptr_t)4ULL), x68, 1); + _br2_store((out0)+((uintptr_t)5ULL), x69, 1); + _br2_store((out0)+((uintptr_t)6ULL), x70, 1); + _br2_store((out0)+((uintptr_t)7ULL), x71, 1); + _br2_store((out0)+((uintptr_t)8ULL), x72, 1); + _br2_store((out0)+((uintptr_t)9ULL), x73, 1); + _br2_store((out0)+((uintptr_t)10ULL), x74, 1); + _br2_store((out0)+((uintptr_t)11ULL), x75, 1); + _br2_store((out0)+((uintptr_t)12ULL), x76, 1); + _br2_store((out0)+((uintptr_t)13ULL), x77, 1); + _br2_store((out0)+((uintptr_t)14ULL), x78, 1); + _br2_store((out0)+((uintptr_t)15ULL), x79, 1); + _br2_store((out0)+((uintptr_t)16ULL), x80, 1); + _br2_store((out0)+((uintptr_t)17ULL), x81, 1); + _br2_store((out0)+((uintptr_t)18ULL), x82, 1); + _br2_store((out0)+((uintptr_t)19ULL), x83, 1); + _br2_store((out0)+((uintptr_t)20ULL), x84, 1); + _br2_store((out0)+((uintptr_t)21ULL), x85, 1); + _br2_store((out0)+((uintptr_t)22ULL), x86, 1); + _br2_store((out0)+((uintptr_t)23ULL), x87, 1); + _br2_store((out0)+((uintptr_t)24ULL), x88, 1); + _br2_store((out0)+((uintptr_t)25ULL), x89, 1); + _br2_store((out0)+((uintptr_t)26ULL), x90, 1); + _br2_store((out0)+((uintptr_t)27ULL), x91, 1); + _br2_store((out0)+((uintptr_t)28ULL), x92, 1); + _br2_store((out0)+((uintptr_t)29ULL), x93, 1); + _br2_store((out0)+((uintptr_t)30ULL), x94, 1); + _br2_store((out0)+((uintptr_t)31ULL), x95, 1); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_to_bytes(uint8_t out1[32], const uint32_t arg1[8]) { + internal_fiat_secp256k1_scalar_to_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_from_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x31, x30, x29, x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x12, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0, x62, x63, x61, x64, x60, x65, x58, x59, x57, x67, x56, x68, x54, x55, x53, x70, x52, x71, x50, x51, x49, x73, x48, x74, x46, x47, x45, x76, x44, x77, x42, x43, x41, x79, x40, x80, x38, x39, x37, x82, x36, x83, x34, x35, x33, x85, x32, x86, x66, x69, x72, x75, x78, x81, x84, x87, x88, x89, x90, x91, x92, x93, x94, x95; + x0 = _br2_load((in0)+((uintptr_t)0ULL), 1); + x1 = _br2_load((in0)+((uintptr_t)1ULL), 1); + x2 = _br2_load((in0)+((uintptr_t)2ULL), 1); + x3 = _br2_load((in0)+((uintptr_t)3ULL), 1); + x4 = _br2_load((in0)+((uintptr_t)4ULL), 1); + x5 = _br2_load((in0)+((uintptr_t)5ULL), 1); + x6 = _br2_load((in0)+((uintptr_t)6ULL), 1); + x7 = _br2_load((in0)+((uintptr_t)7ULL), 1); + x8 = _br2_load((in0)+((uintptr_t)8ULL), 1); + x9 = _br2_load((in0)+((uintptr_t)9ULL), 1); + x10 = _br2_load((in0)+((uintptr_t)10ULL), 1); + x11 = _br2_load((in0)+((uintptr_t)11ULL), 1); + x12 = _br2_load((in0)+((uintptr_t)12ULL), 1); + x13 = _br2_load((in0)+((uintptr_t)13ULL), 1); + x14 = _br2_load((in0)+((uintptr_t)14ULL), 1); + x15 = _br2_load((in0)+((uintptr_t)15ULL), 1); + x16 = _br2_load((in0)+((uintptr_t)16ULL), 1); + x17 = _br2_load((in0)+((uintptr_t)17ULL), 1); + x18 = _br2_load((in0)+((uintptr_t)18ULL), 1); + x19 = _br2_load((in0)+((uintptr_t)19ULL), 1); + x20 = _br2_load((in0)+((uintptr_t)20ULL), 1); + x21 = _br2_load((in0)+((uintptr_t)21ULL), 1); + x22 = _br2_load((in0)+((uintptr_t)22ULL), 1); + x23 = _br2_load((in0)+((uintptr_t)23ULL), 1); + x24 = _br2_load((in0)+((uintptr_t)24ULL), 1); + x25 = _br2_load((in0)+((uintptr_t)25ULL), 1); + x26 = _br2_load((in0)+((uintptr_t)26ULL), 1); + x27 = _br2_load((in0)+((uintptr_t)27ULL), 1); + x28 = _br2_load((in0)+((uintptr_t)28ULL), 1); + x29 = _br2_load((in0)+((uintptr_t)29ULL), 1); + x30 = _br2_load((in0)+((uintptr_t)30ULL), 1); + x31 = _br2_load((in0)+((uintptr_t)31ULL), 1); + /*skip*/ + /*skip*/ + x32 = (x31)<<((uintptr_t)24ULL); + x33 = (x30)<<((uintptr_t)16ULL); + x34 = (x29)<<((uintptr_t)8ULL); + x35 = x28; + x36 = (x27)<<((uintptr_t)24ULL); + x37 = (x26)<<((uintptr_t)16ULL); + x38 = (x25)<<((uintptr_t)8ULL); + x39 = x24; + x40 = (x23)<<((uintptr_t)24ULL); + x41 = (x22)<<((uintptr_t)16ULL); + x42 = (x21)<<((uintptr_t)8ULL); + x43 = x20; + x44 = (x19)<<((uintptr_t)24ULL); + x45 = (x18)<<((uintptr_t)16ULL); + x46 = (x17)<<((uintptr_t)8ULL); + x47 = x16; + x48 = (x15)<<((uintptr_t)24ULL); + x49 = (x14)<<((uintptr_t)16ULL); + x50 = (x13)<<((uintptr_t)8ULL); + x51 = x12; + x52 = (x11)<<((uintptr_t)24ULL); + x53 = (x10)<<((uintptr_t)16ULL); + x54 = (x9)<<((uintptr_t)8ULL); + x55 = x8; + x56 = (x7)<<((uintptr_t)24ULL); + x57 = (x6)<<((uintptr_t)16ULL); + x58 = (x5)<<((uintptr_t)8ULL); + x59 = x4; + x60 = (x3)<<((uintptr_t)24ULL); + x61 = (x2)<<((uintptr_t)16ULL); + x62 = (x1)<<((uintptr_t)8ULL); + x63 = x0; + x64 = (x62)+(x63); + x65 = (x61)+(x64); + x66 = (x60)+(x65); + x67 = (x58)+(x59); + x68 = (x57)+(x67); + x69 = (x56)+(x68); + x70 = (x54)+(x55); + x71 = (x53)+(x70); + x72 = (x52)+(x71); + x73 = (x50)+(x51); + x74 = (x49)+(x73); + x75 = (x48)+(x74); + x76 = (x46)+(x47); + x77 = (x45)+(x76); + x78 = (x44)+(x77); + x79 = (x42)+(x43); + x80 = (x41)+(x79); + x81 = (x40)+(x80); + x82 = (x38)+(x39); + x83 = (x37)+(x82); + x84 = (x36)+(x83); + x85 = (x34)+(x35); + x86 = (x33)+(x85); + x87 = (x32)+(x86); + x88 = x66; + x89 = x69; + x90 = x72; + x91 = x75; + x92 = x78; + x93 = x81; + x94 = x84; + x95 = x87; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x88, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x89, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x90, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x91, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x92, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x93, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x94, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x95, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_from_bytes(uint32_t out1[8], const uint8_t arg1[32]) { + internal_fiat_secp256k1_scalar_from_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_set_one(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7; + /*skip*/ + x0 = (uintptr_t)801750719ULL; + x1 = (uintptr_t)1076732275ULL; + x2 = (uintptr_t)1354194884ULL; + x3 = (uintptr_t)1162945305ULL; + x4 = (uintptr_t)1ULL; + x5 = (uintptr_t)0ULL; + x6 = (uintptr_t)0ULL; + x7 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x7, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_set_one(uint32_t out1[8]) { + internal_fiat_secp256k1_scalar_set_one((uintptr_t)out1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_msat(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8; + /*skip*/ + x0 = (uintptr_t)3493216577ULL; + x1 = (uintptr_t)3218235020ULL; + x2 = (uintptr_t)2940772411ULL; + x3 = (uintptr_t)3132021990ULL; + x4 = (uintptr_t)4294967294ULL; + x5 = (uintptr_t)4294967295ULL; + x6 = (uintptr_t)4294967295ULL; + x7 = (uintptr_t)4294967295ULL; + x8 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x7, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x8, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_msat(uint32_t out1[9]) { + internal_fiat_secp256k1_scalar_msat((uintptr_t)out1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0xffffffff] + * in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * in4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffff] + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +uintptr_t internal_fiat_secp256k1_scalar_divstep(uintptr_t out1, uintptr_t out2, uintptr_t out3, uintptr_t out4, uintptr_t in0, uintptr_t in1, uintptr_t in2, uintptr_t in3, uintptr_t in4) { + uintptr_t x34, x36, x37, x38, x40, x41, x43, x44, x46, x47, x49, x50, x52, x53, x55, x56, x58, x59, x61, x62, x64, x65, x0, x68, x1, x70, x2, x72, x3, x74, x4, x76, x5, x78, x6, x80, x7, x82, x8, x67, x84, x9, x85, x69, x87, x10, x88, x71, x90, x11, x91, x73, x93, x12, x94, x75, x96, x13, x97, x77, x99, x14, x100, x79, x102, x15, x103, x81, x105, x16, x106, x83, x108, x17, x109, x111, x112, x114, x115, x117, x118, x120, x121, x123, x124, x126, x127, x129, x130, x132, x133, x136, x137, x138, x140, x141, x142, x143, x145, x146, x147, x148, x150, x151, x152, x153, x155, x156, x157, x158, x160, x161, x162, x163, x165, x166, x167, x168, x170, x173, x174, x175, x177, x178, x179, x180, x182, x183, x184, x185, x187, x188, x189, x190, x192, x193, x194, x195, x197, x198, x199, x200, x202, x203, x204, x205, x207, x208, x171, x209, x25, x24, x23, x22, x21, x20, x19, x18, x219, x217, x220, x222, x223, x216, x224, x226, x227, x215, x228, x230, x231, x214, x232, x234, x235, x213, x236, x238, x239, x212, x240, x242, x243, x211, x244, x246, x247, x218, x250, x221, x251, x252, x254, x255, x225, x256, x257, x259, x260, x229, x261, x262, x264, x265, x233, x266, x267, x269, x270, x237, x271, x272, x274, x275, x241, x276, x277, x279, x280, x245, x281, x248, x249, x283, x26, x284, x253, x286, x27, x287, x258, x289, x28, x290, x263, x292, x29, x293, x268, x295, x30, x296, x273, x298, x31, x299, x278, x301, x32, x302, x35, x282, x304, x33, x305, x308, x309, x311, x312, x314, x315, x317, x318, x320, x321, x323, x324, x326, x327, x329, x330, x332, x333, x310, x86, x336, x89, x337, x313, x338, x340, x341, x92, x342, x316, x343, x345, x346, x95, x347, x319, x348, x350, x351, x98, x352, x322, x353, x355, x356, x101, x357, x325, x358, x360, x361, x104, x362, x328, x363, x365, x366, x107, x367, x331, x368, x370, x371, x110, x372, x334, x113, x374, x375, x116, x377, x378, x119, x380, x381, x122, x383, x384, x125, x386, x387, x128, x389, x390, x131, x392, x393, x307, x134, x395, x396, x376, x285, x399, x288, x400, x379, x401, x403, x404, x291, x405, x382, x406, x408, x409, x294, x410, x385, x411, x413, x414, x297, x415, x388, x416, x418, x419, x300, x420, x391, x421, x423, x424, x303, x425, x394, x426, x428, x429, x306, x430, x397, x431, x433, x436, x437, x438, x440, x441, x442, x443, x445, x446, x447, x448, x450, x451, x452, x453, x455, x456, x457, x458, x460, x461, x462, x463, x465, x466, x467, x468, x470, x471, x434, x472, x39, x335, x339, x344, x349, x354, x359, x364, x369, x373, x135, x484, x172, x485, x139, x487, x176, x488, x144, x490, x181, x491, x149, x493, x186, x494, x154, x496, x191, x497, x159, x499, x196, x500, x164, x502, x201, x503, x210, x169, x505, x206, x506, x398, x508, x435, x509, x402, x511, x439, x512, x407, x514, x444, x515, x412, x517, x449, x518, x417, x520, x454, x521, x422, x523, x459, x524, x427, x526, x464, x527, x473, x432, x529, x469, x530, x474, x42, x45, x48, x51, x54, x57, x60, x63, x66, x475, x476, x477, x478, x479, x480, x481, x482, x483, x486, x489, x492, x495, x498, x501, x504, x507, x510, x513, x516, x519, x522, x525, x528, x531, out0, x532, x533, x534, x535, x536, x537, x538, x539, x540, x541, x542, x543, x544, x545, x546, x547, x548, x549, x550, x551, x552, x553, x554, x555, x556, x557, x558, x559, x560, x561, x562, x563, x564, x565, x566; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x8 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + /*skip*/ + x9 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x10 = _br2_load((in2)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x11 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x12 = _br2_load((in2)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x13 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x14 = _br2_load((in2)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x15 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x16 = _br2_load((in2)+((uintptr_t)28ULL), sizeof(uintptr_t)); + x17 = _br2_load((in2)+((uintptr_t)32ULL), sizeof(uintptr_t)); + /*skip*/ + x18 = _br2_load((in3)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x19 = _br2_load((in3)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x20 = _br2_load((in3)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x21 = _br2_load((in3)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x22 = _br2_load((in3)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x23 = _br2_load((in3)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x24 = _br2_load((in3)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x25 = _br2_load((in3)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + x26 = _br2_load((in4)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x27 = _br2_load((in4)+((uintptr_t)4ULL), sizeof(uintptr_t)); + x28 = _br2_load((in4)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x29 = _br2_load((in4)+((uintptr_t)12ULL), sizeof(uintptr_t)); + x30 = _br2_load((in4)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x31 = _br2_load((in4)+((uintptr_t)20ULL), sizeof(uintptr_t)); + x32 = _br2_load((in4)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x33 = _br2_load((in4)+((uintptr_t)28ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x34 = ((in0)^((uintptr_t)4294967295ULL))+((uintptr_t)1ULL); + x35 = ((x34)>>((uintptr_t)31ULL))&((x9)&((uintptr_t)1ULL)); + x36 = ((in0)^((uintptr_t)4294967295ULL))+((uintptr_t)1ULL); + x37 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x38 = (x37)^((uintptr_t)4294967295ULL); + x39 = ((x36)&(x37))|((in0)&(x38)); + x40 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x41 = (x40)^((uintptr_t)4294967295ULL); + x42 = ((x9)&(x40))|((x0)&(x41)); + x43 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x44 = (x43)^((uintptr_t)4294967295ULL); + x45 = ((x10)&(x43))|((x1)&(x44)); + x46 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x47 = (x46)^((uintptr_t)4294967295ULL); + x48 = ((x11)&(x46))|((x2)&(x47)); + x49 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x50 = (x49)^((uintptr_t)4294967295ULL); + x51 = ((x12)&(x49))|((x3)&(x50)); + x52 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x53 = (x52)^((uintptr_t)4294967295ULL); + x54 = ((x13)&(x52))|((x4)&(x53)); + x55 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x56 = (x55)^((uintptr_t)4294967295ULL); + x57 = ((x14)&(x55))|((x5)&(x56)); + x58 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x59 = (x58)^((uintptr_t)4294967295ULL); + x60 = ((x15)&(x58))|((x6)&(x59)); + x61 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x62 = (x61)^((uintptr_t)4294967295ULL); + x63 = ((x16)&(x61))|((x7)&(x62)); + x64 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x65 = (x64)^((uintptr_t)4294967295ULL); + x66 = ((x17)&(x64))|((x8)&(x65)); + x67 = ((uintptr_t)1ULL)+((x0)^((uintptr_t)4294967295ULL)); + x68 = (uintptr_t)((x67)<((uintptr_t)1ULL)); + x69 = (x68)+((x1)^((uintptr_t)4294967295ULL)); + x70 = (uintptr_t)((x69)<((x1)^((uintptr_t)4294967295ULL))); + x71 = (x70)+((x2)^((uintptr_t)4294967295ULL)); + x72 = (uintptr_t)((x71)<((x2)^((uintptr_t)4294967295ULL))); + x73 = (x72)+((x3)^((uintptr_t)4294967295ULL)); + x74 = (uintptr_t)((x73)<((x3)^((uintptr_t)4294967295ULL))); + x75 = (x74)+((x4)^((uintptr_t)4294967295ULL)); + x76 = (uintptr_t)((x75)<((x4)^((uintptr_t)4294967295ULL))); + x77 = (x76)+((x5)^((uintptr_t)4294967295ULL)); + x78 = (uintptr_t)((x77)<((x5)^((uintptr_t)4294967295ULL))); + x79 = (x78)+((x6)^((uintptr_t)4294967295ULL)); + x80 = (uintptr_t)((x79)<((x6)^((uintptr_t)4294967295ULL))); + x81 = (x80)+((x7)^((uintptr_t)4294967295ULL)); + x82 = (uintptr_t)((x81)<((x7)^((uintptr_t)4294967295ULL))); + x83 = (x82)+((x8)^((uintptr_t)4294967295ULL)); + x84 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x85 = (x84)^((uintptr_t)4294967295ULL); + x86 = ((x67)&(x84))|((x9)&(x85)); + x87 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x88 = (x87)^((uintptr_t)4294967295ULL); + x89 = ((x69)&(x87))|((x10)&(x88)); + x90 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x91 = (x90)^((uintptr_t)4294967295ULL); + x92 = ((x71)&(x90))|((x11)&(x91)); + x93 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x94 = (x93)^((uintptr_t)4294967295ULL); + x95 = ((x73)&(x93))|((x12)&(x94)); + x96 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x97 = (x96)^((uintptr_t)4294967295ULL); + x98 = ((x75)&(x96))|((x13)&(x97)); + x99 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x100 = (x99)^((uintptr_t)4294967295ULL); + x101 = ((x77)&(x99))|((x14)&(x100)); + x102 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x103 = (x102)^((uintptr_t)4294967295ULL); + x104 = ((x79)&(x102))|((x15)&(x103)); + x105 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x106 = (x105)^((uintptr_t)4294967295ULL); + x107 = ((x81)&(x105))|((x16)&(x106)); + x108 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x109 = (x108)^((uintptr_t)4294967295ULL); + x110 = ((x83)&(x108))|((x17)&(x109)); + x111 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x112 = (x111)^((uintptr_t)4294967295ULL); + x113 = ((x26)&(x111))|((x18)&(x112)); + x114 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x115 = (x114)^((uintptr_t)4294967295ULL); + x116 = ((x27)&(x114))|((x19)&(x115)); + x117 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x118 = (x117)^((uintptr_t)4294967295ULL); + x119 = ((x28)&(x117))|((x20)&(x118)); + x120 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x121 = (x120)^((uintptr_t)4294967295ULL); + x122 = ((x29)&(x120))|((x21)&(x121)); + x123 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x124 = (x123)^((uintptr_t)4294967295ULL); + x125 = ((x30)&(x123))|((x22)&(x124)); + x126 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x127 = (x126)^((uintptr_t)4294967295ULL); + x128 = ((x31)&(x126))|((x23)&(x127)); + x129 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x130 = (x129)^((uintptr_t)4294967295ULL); + x131 = ((x32)&(x129))|((x24)&(x130)); + x132 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x133 = (x132)^((uintptr_t)4294967295ULL); + x134 = ((x33)&(x132))|((x25)&(x133)); + x135 = (x113)+(x113); + x136 = (uintptr_t)((x135)<(x113)); + x137 = (x136)+(x116); + x138 = (uintptr_t)((x137)<(x116)); + x139 = (x137)+(x116); + x140 = (uintptr_t)((x139)<(x116)); + x141 = (x138)+(x140); + x142 = (x141)+(x119); + x143 = (uintptr_t)((x142)<(x119)); + x144 = (x142)+(x119); + x145 = (uintptr_t)((x144)<(x119)); + x146 = (x143)+(x145); + x147 = (x146)+(x122); + x148 = (uintptr_t)((x147)<(x122)); + x149 = (x147)+(x122); + x150 = (uintptr_t)((x149)<(x122)); + x151 = (x148)+(x150); + x152 = (x151)+(x125); + x153 = (uintptr_t)((x152)<(x125)); + x154 = (x152)+(x125); + x155 = (uintptr_t)((x154)<(x125)); + x156 = (x153)+(x155); + x157 = (x156)+(x128); + x158 = (uintptr_t)((x157)<(x128)); + x159 = (x157)+(x128); + x160 = (uintptr_t)((x159)<(x128)); + x161 = (x158)+(x160); + x162 = (x161)+(x131); + x163 = (uintptr_t)((x162)<(x131)); + x164 = (x162)+(x131); + x165 = (uintptr_t)((x164)<(x131)); + x166 = (x163)+(x165); + x167 = (x166)+(x134); + x168 = (uintptr_t)((x167)<(x134)); + x169 = (x167)+(x134); + x170 = (uintptr_t)((x169)<(x134)); + x171 = (x168)+(x170); + x172 = (x135)-((uintptr_t)3493216577ULL); + x173 = (uintptr_t)((x135)<(x172)); + x174 = (x139)-((uintptr_t)3218235020ULL); + x175 = (uintptr_t)((x139)<(x174)); + x176 = (x174)-(x173); + x177 = (uintptr_t)((x174)<(x176)); + x178 = (x175)+(x177); + x179 = (x144)-((uintptr_t)2940772411ULL); + x180 = (uintptr_t)((x144)<(x179)); + x181 = (x179)-(x178); + x182 = (uintptr_t)((x179)<(x181)); + x183 = (x180)+(x182); + x184 = (x149)-((uintptr_t)3132021990ULL); + x185 = (uintptr_t)((x149)<(x184)); + x186 = (x184)-(x183); + x187 = (uintptr_t)((x184)<(x186)); + x188 = (x185)+(x187); + x189 = (x154)-((uintptr_t)4294967294ULL); + x190 = (uintptr_t)((x154)<(x189)); + x191 = (x189)-(x188); + x192 = (uintptr_t)((x189)<(x191)); + x193 = (x190)+(x192); + x194 = (x159)-((uintptr_t)4294967295ULL); + x195 = (uintptr_t)((x159)<(x194)); + x196 = (x194)-(x193); + x197 = (uintptr_t)((x194)<(x196)); + x198 = (x195)+(x197); + x199 = (x164)-((uintptr_t)4294967295ULL); + x200 = (uintptr_t)((x164)<(x199)); + x201 = (x199)-(x198); + x202 = (uintptr_t)((x199)<(x201)); + x203 = (x200)+(x202); + x204 = (x169)-((uintptr_t)4294967295ULL); + x205 = (uintptr_t)((x169)<(x204)); + x206 = (x204)-(x203); + x207 = (uintptr_t)((x204)<(x206)); + x208 = (x205)+(x207); + x209 = (x171)-(x208); + x210 = (uintptr_t)((x171)<(x209)); + x211 = x25; + x212 = x24; + x213 = x23; + x214 = x22; + x215 = x21; + x216 = x20; + x217 = x19; + x218 = x18; + x219 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x218))); + x220 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x217))); + x221 = (((uintptr_t)0ULL)-(x217))-(x219); + x222 = (uintptr_t)((((uintptr_t)0ULL)-(x217))<(x221)); + x223 = (x220)+(x222); + x224 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x216))); + x225 = (((uintptr_t)0ULL)-(x216))-(x223); + x226 = (uintptr_t)((((uintptr_t)0ULL)-(x216))<(x225)); + x227 = (x224)+(x226); + x228 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x215))); + x229 = (((uintptr_t)0ULL)-(x215))-(x227); + x230 = (uintptr_t)((((uintptr_t)0ULL)-(x215))<(x229)); + x231 = (x228)+(x230); + x232 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x214))); + x233 = (((uintptr_t)0ULL)-(x214))-(x231); + x234 = (uintptr_t)((((uintptr_t)0ULL)-(x214))<(x233)); + x235 = (x232)+(x234); + x236 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x213))); + x237 = (((uintptr_t)0ULL)-(x213))-(x235); + x238 = (uintptr_t)((((uintptr_t)0ULL)-(x213))<(x237)); + x239 = (x236)+(x238); + x240 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x212))); + x241 = (((uintptr_t)0ULL)-(x212))-(x239); + x242 = (uintptr_t)((((uintptr_t)0ULL)-(x212))<(x241)); + x243 = (x240)+(x242); + x244 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x211))); + x245 = (((uintptr_t)0ULL)-(x211))-(x243); + x246 = (uintptr_t)((((uintptr_t)0ULL)-(x211))<(x245)); + x247 = (x244)+(x246); + x248 = ((uintptr_t)-1ULL)+((uintptr_t)((x247)==((uintptr_t)0ULL))); + x249 = (((uintptr_t)0ULL)-(x218))+((x248)&((uintptr_t)3493216577ULL)); + x250 = (uintptr_t)((x249)<(((uintptr_t)0ULL)-(x218))); + x251 = (x250)+(x221); + x252 = (uintptr_t)((x251)<(x221)); + x253 = (x251)+((x248)&((uintptr_t)3218235020ULL)); + x254 = (uintptr_t)((x253)<((x248)&((uintptr_t)3218235020ULL))); + x255 = (x252)+(x254); + x256 = (x255)+(x225); + x257 = (uintptr_t)((x256)<(x225)); + x258 = (x256)+((x248)&((uintptr_t)2940772411ULL)); + x259 = (uintptr_t)((x258)<((x248)&((uintptr_t)2940772411ULL))); + x260 = (x257)+(x259); + x261 = (x260)+(x229); + x262 = (uintptr_t)((x261)<(x229)); + x263 = (x261)+((x248)&((uintptr_t)3132021990ULL)); + x264 = (uintptr_t)((x263)<((x248)&((uintptr_t)3132021990ULL))); + x265 = (x262)+(x264); + x266 = (x265)+(x233); + x267 = (uintptr_t)((x266)<(x233)); + x268 = (x266)+((x248)&((uintptr_t)4294967294ULL)); + x269 = (uintptr_t)((x268)<((x248)&((uintptr_t)4294967294ULL))); + x270 = (x267)+(x269); + x271 = (x270)+(x237); + x272 = (uintptr_t)((x271)<(x237)); + x273 = (x271)+(x248); + x274 = (uintptr_t)((x273)<(x248)); + x275 = (x272)+(x274); + x276 = (x275)+(x241); + x277 = (uintptr_t)((x276)<(x241)); + x278 = (x276)+(x248); + x279 = (uintptr_t)((x278)<(x248)); + x280 = (x277)+(x279); + x281 = (x280)+(x245); + x282 = (x281)+(x248); + x283 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x284 = (x283)^((uintptr_t)4294967295ULL); + x285 = ((x249)&(x283))|((x26)&(x284)); + x286 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x287 = (x286)^((uintptr_t)4294967295ULL); + x288 = ((x253)&(x286))|((x27)&(x287)); + x289 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x290 = (x289)^((uintptr_t)4294967295ULL); + x291 = ((x258)&(x289))|((x28)&(x290)); + x292 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x293 = (x292)^((uintptr_t)4294967295ULL); + x294 = ((x263)&(x292))|((x29)&(x293)); + x295 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x296 = (x295)^((uintptr_t)4294967295ULL); + x297 = ((x268)&(x295))|((x30)&(x296)); + x298 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x299 = (x298)^((uintptr_t)4294967295ULL); + x300 = ((x273)&(x298))|((x31)&(x299)); + x301 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x302 = (x301)^((uintptr_t)4294967295ULL); + x303 = ((x278)&(x301))|((x32)&(x302)); + x304 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL))); + x305 = (x304)^((uintptr_t)4294967295ULL); + x306 = ((x282)&(x304))|((x33)&(x305)); + x307 = (x86)&((uintptr_t)1ULL); + x308 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x309 = (x308)^((uintptr_t)4294967295ULL); + x310 = ((x42)&(x308))|(((uintptr_t)0ULL)&(x309)); + x311 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x312 = (x311)^((uintptr_t)4294967295ULL); + x313 = ((x45)&(x311))|(((uintptr_t)0ULL)&(x312)); + x314 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x315 = (x314)^((uintptr_t)4294967295ULL); + x316 = ((x48)&(x314))|(((uintptr_t)0ULL)&(x315)); + x317 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x318 = (x317)^((uintptr_t)4294967295ULL); + x319 = ((x51)&(x317))|(((uintptr_t)0ULL)&(x318)); + x320 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x321 = (x320)^((uintptr_t)4294967295ULL); + x322 = ((x54)&(x320))|(((uintptr_t)0ULL)&(x321)); + x323 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x324 = (x323)^((uintptr_t)4294967295ULL); + x325 = ((x57)&(x323))|(((uintptr_t)0ULL)&(x324)); + x326 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x327 = (x326)^((uintptr_t)4294967295ULL); + x328 = ((x60)&(x326))|(((uintptr_t)0ULL)&(x327)); + x329 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x330 = (x329)^((uintptr_t)4294967295ULL); + x331 = ((x63)&(x329))|(((uintptr_t)0ULL)&(x330)); + x332 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x333 = (x332)^((uintptr_t)4294967295ULL); + x334 = ((x66)&(x332))|(((uintptr_t)0ULL)&(x333)); + x335 = (x86)+(x310); + x336 = (uintptr_t)((x335)<(x86)); + x337 = (x336)+(x89); + x338 = (uintptr_t)((x337)<(x89)); + x339 = (x337)+(x313); + x340 = (uintptr_t)((x339)<(x313)); + x341 = (x338)+(x340); + x342 = (x341)+(x92); + x343 = (uintptr_t)((x342)<(x92)); + x344 = (x342)+(x316); + x345 = (uintptr_t)((x344)<(x316)); + x346 = (x343)+(x345); + x347 = (x346)+(x95); + x348 = (uintptr_t)((x347)<(x95)); + x349 = (x347)+(x319); + x350 = (uintptr_t)((x349)<(x319)); + x351 = (x348)+(x350); + x352 = (x351)+(x98); + x353 = (uintptr_t)((x352)<(x98)); + x354 = (x352)+(x322); + x355 = (uintptr_t)((x354)<(x322)); + x356 = (x353)+(x355); + x357 = (x356)+(x101); + x358 = (uintptr_t)((x357)<(x101)); + x359 = (x357)+(x325); + x360 = (uintptr_t)((x359)<(x325)); + x361 = (x358)+(x360); + x362 = (x361)+(x104); + x363 = (uintptr_t)((x362)<(x104)); + x364 = (x362)+(x328); + x365 = (uintptr_t)((x364)<(x328)); + x366 = (x363)+(x365); + x367 = (x366)+(x107); + x368 = (uintptr_t)((x367)<(x107)); + x369 = (x367)+(x331); + x370 = (uintptr_t)((x369)<(x331)); + x371 = (x368)+(x370); + x372 = (x371)+(x110); + x373 = (x372)+(x334); + x374 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x375 = (x374)^((uintptr_t)4294967295ULL); + x376 = ((x113)&(x374))|(((uintptr_t)0ULL)&(x375)); + x377 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x378 = (x377)^((uintptr_t)4294967295ULL); + x379 = ((x116)&(x377))|(((uintptr_t)0ULL)&(x378)); + x380 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x381 = (x380)^((uintptr_t)4294967295ULL); + x382 = ((x119)&(x380))|(((uintptr_t)0ULL)&(x381)); + x383 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x384 = (x383)^((uintptr_t)4294967295ULL); + x385 = ((x122)&(x383))|(((uintptr_t)0ULL)&(x384)); + x386 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x387 = (x386)^((uintptr_t)4294967295ULL); + x388 = ((x125)&(x386))|(((uintptr_t)0ULL)&(x387)); + x389 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x390 = (x389)^((uintptr_t)4294967295ULL); + x391 = ((x128)&(x389))|(((uintptr_t)0ULL)&(x390)); + x392 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x393 = (x392)^((uintptr_t)4294967295ULL); + x394 = ((x131)&(x392))|(((uintptr_t)0ULL)&(x393)); + x395 = ((uintptr_t)-1ULL)+((uintptr_t)((x307)==((uintptr_t)0ULL))); + x396 = (x395)^((uintptr_t)4294967295ULL); + x397 = ((x134)&(x395))|(((uintptr_t)0ULL)&(x396)); + x398 = (x285)+(x376); + x399 = (uintptr_t)((x398)<(x285)); + x400 = (x399)+(x288); + x401 = (uintptr_t)((x400)<(x288)); + x402 = (x400)+(x379); + x403 = (uintptr_t)((x402)<(x379)); + x404 = (x401)+(x403); + x405 = (x404)+(x291); + x406 = (uintptr_t)((x405)<(x291)); + x407 = (x405)+(x382); + x408 = (uintptr_t)((x407)<(x382)); + x409 = (x406)+(x408); + x410 = (x409)+(x294); + x411 = (uintptr_t)((x410)<(x294)); + x412 = (x410)+(x385); + x413 = (uintptr_t)((x412)<(x385)); + x414 = (x411)+(x413); + x415 = (x414)+(x297); + x416 = (uintptr_t)((x415)<(x297)); + x417 = (x415)+(x388); + x418 = (uintptr_t)((x417)<(x388)); + x419 = (x416)+(x418); + x420 = (x419)+(x300); + x421 = (uintptr_t)((x420)<(x300)); + x422 = (x420)+(x391); + x423 = (uintptr_t)((x422)<(x391)); + x424 = (x421)+(x423); + x425 = (x424)+(x303); + x426 = (uintptr_t)((x425)<(x303)); + x427 = (x425)+(x394); + x428 = (uintptr_t)((x427)<(x394)); + x429 = (x426)+(x428); + x430 = (x429)+(x306); + x431 = (uintptr_t)((x430)<(x306)); + x432 = (x430)+(x397); + x433 = (uintptr_t)((x432)<(x397)); + x434 = (x431)+(x433); + x435 = (x398)-((uintptr_t)3493216577ULL); + x436 = (uintptr_t)((x398)<(x435)); + x437 = (x402)-((uintptr_t)3218235020ULL); + x438 = (uintptr_t)((x402)<(x437)); + x439 = (x437)-(x436); + x440 = (uintptr_t)((x437)<(x439)); + x441 = (x438)+(x440); + x442 = (x407)-((uintptr_t)2940772411ULL); + x443 = (uintptr_t)((x407)<(x442)); + x444 = (x442)-(x441); + x445 = (uintptr_t)((x442)<(x444)); + x446 = (x443)+(x445); + x447 = (x412)-((uintptr_t)3132021990ULL); + x448 = (uintptr_t)((x412)<(x447)); + x449 = (x447)-(x446); + x450 = (uintptr_t)((x447)<(x449)); + x451 = (x448)+(x450); + x452 = (x417)-((uintptr_t)4294967294ULL); + x453 = (uintptr_t)((x417)<(x452)); + x454 = (x452)-(x451); + x455 = (uintptr_t)((x452)<(x454)); + x456 = (x453)+(x455); + x457 = (x422)-((uintptr_t)4294967295ULL); + x458 = (uintptr_t)((x422)<(x457)); + x459 = (x457)-(x456); + x460 = (uintptr_t)((x457)<(x459)); + x461 = (x458)+(x460); + x462 = (x427)-((uintptr_t)4294967295ULL); + x463 = (uintptr_t)((x427)<(x462)); + x464 = (x462)-(x461); + x465 = (uintptr_t)((x462)<(x464)); + x466 = (x463)+(x465); + x467 = (x432)-((uintptr_t)4294967295ULL); + x468 = (uintptr_t)((x432)<(x467)); + x469 = (x467)-(x466); + x470 = (uintptr_t)((x467)<(x469)); + x471 = (x468)+(x470); + x472 = (x434)-(x471); + x473 = (uintptr_t)((x434)<(x472)); + x474 = (x39)+((uintptr_t)1ULL); + x475 = ((x335)>>((uintptr_t)1ULL))|((x339)<<((uintptr_t)31ULL)); + x476 = ((x339)>>((uintptr_t)1ULL))|((x344)<<((uintptr_t)31ULL)); + x477 = ((x344)>>((uintptr_t)1ULL))|((x349)<<((uintptr_t)31ULL)); + x478 = ((x349)>>((uintptr_t)1ULL))|((x354)<<((uintptr_t)31ULL)); + x479 = ((x354)>>((uintptr_t)1ULL))|((x359)<<((uintptr_t)31ULL)); + x480 = ((x359)>>((uintptr_t)1ULL))|((x364)<<((uintptr_t)31ULL)); + x481 = ((x364)>>((uintptr_t)1ULL))|((x369)<<((uintptr_t)31ULL)); + x482 = ((x369)>>((uintptr_t)1ULL))|((x373)<<((uintptr_t)31ULL)); + x483 = ((x373)&((uintptr_t)2147483648ULL))|((x373)>>((uintptr_t)1ULL)); + x484 = ((uintptr_t)-1ULL)+((uintptr_t)((x210)==((uintptr_t)0ULL))); + x485 = (x484)^((uintptr_t)4294967295ULL); + x486 = ((x135)&(x484))|((x172)&(x485)); + x487 = ((uintptr_t)-1ULL)+((uintptr_t)((x210)==((uintptr_t)0ULL))); + x488 = (x487)^((uintptr_t)4294967295ULL); + x489 = ((x139)&(x487))|((x176)&(x488)); + x490 = ((uintptr_t)-1ULL)+((uintptr_t)((x210)==((uintptr_t)0ULL))); + x491 = (x490)^((uintptr_t)4294967295ULL); + x492 = ((x144)&(x490))|((x181)&(x491)); + x493 = ((uintptr_t)-1ULL)+((uintptr_t)((x210)==((uintptr_t)0ULL))); + x494 = (x493)^((uintptr_t)4294967295ULL); + x495 = ((x149)&(x493))|((x186)&(x494)); + x496 = ((uintptr_t)-1ULL)+((uintptr_t)((x210)==((uintptr_t)0ULL))); + x497 = (x496)^((uintptr_t)4294967295ULL); + x498 = ((x154)&(x496))|((x191)&(x497)); + x499 = ((uintptr_t)-1ULL)+((uintptr_t)((x210)==((uintptr_t)0ULL))); + x500 = (x499)^((uintptr_t)4294967295ULL); + x501 = ((x159)&(x499))|((x196)&(x500)); + x502 = ((uintptr_t)-1ULL)+((uintptr_t)((x210)==((uintptr_t)0ULL))); + x503 = (x502)^((uintptr_t)4294967295ULL); + x504 = ((x164)&(x502))|((x201)&(x503)); + x505 = ((uintptr_t)-1ULL)+((uintptr_t)((x210)==((uintptr_t)0ULL))); + x506 = (x505)^((uintptr_t)4294967295ULL); + x507 = ((x169)&(x505))|((x206)&(x506)); + x508 = ((uintptr_t)-1ULL)+((uintptr_t)((x473)==((uintptr_t)0ULL))); + x509 = (x508)^((uintptr_t)4294967295ULL); + x510 = ((x398)&(x508))|((x435)&(x509)); + x511 = ((uintptr_t)-1ULL)+((uintptr_t)((x473)==((uintptr_t)0ULL))); + x512 = (x511)^((uintptr_t)4294967295ULL); + x513 = ((x402)&(x511))|((x439)&(x512)); + x514 = ((uintptr_t)-1ULL)+((uintptr_t)((x473)==((uintptr_t)0ULL))); + x515 = (x514)^((uintptr_t)4294967295ULL); + x516 = ((x407)&(x514))|((x444)&(x515)); + x517 = ((uintptr_t)-1ULL)+((uintptr_t)((x473)==((uintptr_t)0ULL))); + x518 = (x517)^((uintptr_t)4294967295ULL); + x519 = ((x412)&(x517))|((x449)&(x518)); + x520 = ((uintptr_t)-1ULL)+((uintptr_t)((x473)==((uintptr_t)0ULL))); + x521 = (x520)^((uintptr_t)4294967295ULL); + x522 = ((x417)&(x520))|((x454)&(x521)); + x523 = ((uintptr_t)-1ULL)+((uintptr_t)((x473)==((uintptr_t)0ULL))); + x524 = (x523)^((uintptr_t)4294967295ULL); + x525 = ((x422)&(x523))|((x459)&(x524)); + x526 = ((uintptr_t)-1ULL)+((uintptr_t)((x473)==((uintptr_t)0ULL))); + x527 = (x526)^((uintptr_t)4294967295ULL); + x528 = ((x427)&(x526))|((x464)&(x527)); + x529 = ((uintptr_t)-1ULL)+((uintptr_t)((x473)==((uintptr_t)0ULL))); + x530 = (x529)^((uintptr_t)4294967295ULL); + x531 = ((x432)&(x529))|((x469)&(x530)); + x532 = x474; + x533 = x42; + x534 = x45; + x535 = x48; + x536 = x51; + x537 = x54; + x538 = x57; + x539 = x60; + x540 = x63; + x541 = x66; + /*skip*/ + x542 = x475; + x543 = x476; + x544 = x477; + x545 = x478; + x546 = x479; + x547 = x480; + x548 = x481; + x549 = x482; + x550 = x483; + /*skip*/ + x551 = x486; + x552 = x489; + x553 = x492; + x554 = x495; + x555 = x498; + x556 = x501; + x557 = x504; + x558 = x507; + /*skip*/ + x559 = x510; + x560 = x513; + x561 = x516; + x562 = x519; + x563 = x522; + x564 = x525; + x565 = x528; + x566 = x531; + /*skip*/ + out0 = x532; + _br2_store((out1)+((uintptr_t)0ULL), x533, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)4ULL), x534, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)8ULL), x535, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)12ULL), x536, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)16ULL), x537, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)20ULL), x538, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)24ULL), x539, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)28ULL), x540, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)32ULL), x541, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out2)+((uintptr_t)0ULL), x542, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)4ULL), x543, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)8ULL), x544, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)12ULL), x545, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)16ULL), x546, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)20ULL), x547, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)24ULL), x548, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)28ULL), x549, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)32ULL), x550, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out3)+((uintptr_t)0ULL), x551, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)4ULL), x552, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)8ULL), x553, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)12ULL), x554, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)16ULL), x555, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)20ULL), x556, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)24ULL), x557, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)28ULL), x558, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out4)+((uintptr_t)0ULL), x559, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)4ULL), x560, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)8ULL), x561, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)12ULL), x562, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)16ULL), x563, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)20ULL), x564, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)24ULL), x565, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)28ULL), x566, sizeof(uintptr_t)); + /*skip*/ + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_divstep(uint32_t* out1, uint32_t out2[9], uint32_t out3[9], uint32_t out4[8], uint32_t out5[8], uint32_t arg1, const uint32_t arg2[9], const uint32_t arg3[9], const uint32_t arg4[8], const uint32_t arg5[8]) { + *out1 = (uint32_t)internal_fiat_secp256k1_scalar_divstep((uintptr_t)out2, (uintptr_t)out3, (uintptr_t)out4, (uintptr_t)out5, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3, (uintptr_t)arg4, (uintptr_t)arg5); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_divstep_precomp(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7; + /*skip*/ + x0 = (uintptr_t)731690217ULL; + x1 = (uintptr_t)3611499085ULL; + x2 = (uintptr_t)853132547ULL; + x3 = (uintptr_t)2875708250ULL; + x4 = (uintptr_t)2241651551ULL; + x5 = (uintptr_t)2918631397ULL; + x6 = (uintptr_t)502711161ULL; + x7 = (uintptr_t)1632911685ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)4ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)12ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)20ULL), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)28ULL), x7, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_divstep_precomp(uint32_t out1[8]) { + internal_fiat_secp256k1_scalar_divstep_precomp((uintptr_t)out1); +} diff --git a/fiat-bedrock2/src/secp256k1_scalar_64.c b/fiat-bedrock2/src/secp256k1_scalar_64.c new file mode 100644 index 0000000000..f4d2f3b3ca --- /dev/null +++ b/fiat-bedrock2/src/secp256k1_scalar_64.c @@ -0,0 +1,2175 @@ +/* Autogenerated: 'src/ExtractionOCaml/bedrock2_word_by_word_montgomery' --lang bedrock2 --static --no-wide-int --widen-carry --widen-bytes --split-multiret --no-select --no-field-element-typedefs secp256k1_scalar 64 '2^256 - 432420386565659656852420866394968145599' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: secp256k1_scalar */ +/* machine_wordsize = 64 (from "64") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141 (from "2^256 - 432420386565659656852420866394968145599") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +#include + +// We use memcpy to work around -fstrict-aliasing. +// A plain memcpy is enough on clang 10, but not on gcc 10, which fails +// to infer the bounds on an integer loaded by memcpy. +// Adding a range mask after memcpy in turn makes slower code in clang. +// Loading individual bytes, shifting them together, and or-ing is fast +// on clang and sometimes on GCC, but other times GCC inlines individual +// byte operations without reconstructing wider accesses. +// The little-endian idiom below seems fast in gcc 9+ and clang 10. +static __attribute__((always_inline)) inline uintptr_t +_br2_load(uintptr_t a, uintptr_t sz) { + switch (sz) { + case 1: { uint8_t r = 0; memcpy(&r, (void*)a, 1); return r; } + case 2: { uint16_t r = 0; memcpy(&r, (void*)a, 2); return r; } + case 4: { uint32_t r = 0; memcpy(&r, (void*)a, 4); return r; } + case 8: { uint64_t r = 0; memcpy(&r, (void*)a, 8); return r; } + default: __builtin_unreachable(); + } +} + +static __attribute__((always_inline)) inline void +_br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) { + memcpy((void*)a, &v, sz); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_mul(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x1, x2, x3, x0, x11, x16, x19, x21, x17, x22, x14, x23, x25, x26, x15, x27, x12, x28, x30, x31, x13, x33, x38, x41, x43, x39, x44, x36, x45, x47, x48, x37, x49, x34, x50, x52, x53, x35, x40, x55, x18, x56, x20, x57, x42, x58, x60, x61, x24, x62, x46, x63, x65, x66, x29, x67, x51, x68, x70, x71, x32, x72, x54, x73, x75, x8, x81, x84, x86, x82, x87, x79, x88, x90, x91, x80, x92, x77, x93, x95, x96, x78, x83, x59, x99, x64, x100, x85, x101, x103, x104, x69, x105, x89, x106, x108, x109, x74, x110, x94, x111, x113, x114, x76, x115, x97, x116, x118, x120, x125, x128, x130, x126, x131, x123, x132, x134, x135, x124, x136, x121, x137, x139, x140, x122, x127, x142, x98, x143, x102, x144, x129, x145, x147, x148, x107, x149, x133, x150, x152, x153, x112, x154, x138, x155, x157, x158, x117, x159, x141, x160, x162, x163, x119, x9, x169, x172, x174, x170, x175, x167, x176, x178, x179, x168, x180, x165, x181, x183, x184, x166, x171, x146, x187, x151, x188, x173, x189, x191, x192, x156, x193, x177, x194, x196, x197, x161, x198, x182, x199, x201, x202, x164, x203, x185, x204, x206, x208, x213, x216, x218, x214, x219, x211, x220, x222, x223, x212, x224, x209, x225, x227, x228, x210, x215, x230, x186, x231, x190, x232, x217, x233, x235, x236, x195, x237, x221, x238, x240, x241, x200, x242, x226, x243, x245, x246, x205, x247, x229, x248, x250, x251, x207, x7, x6, x5, x10, x4, x257, x260, x262, x258, x263, x255, x264, x266, x267, x256, x268, x253, x269, x271, x272, x254, x259, x234, x275, x239, x276, x261, x277, x279, x280, x244, x281, x265, x282, x284, x285, x249, x286, x270, x287, x289, x290, x252, x291, x273, x292, x294, x296, x301, x304, x306, x302, x307, x299, x308, x310, x311, x300, x312, x297, x313, x315, x316, x298, x303, x318, x274, x319, x278, x320, x305, x321, x323, x324, x283, x325, x309, x326, x328, x329, x288, x330, x314, x331, x333, x334, x293, x335, x317, x336, x338, x339, x295, x342, x343, x344, x346, x347, x348, x349, x351, x352, x353, x354, x356, x357, x340, x358, x322, x360, x341, x361, x327, x363, x345, x364, x332, x366, x350, x367, x359, x337, x369, x355, x370, x362, x365, x368, x371, x372, x373, x374, x375; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x1; + x9 = x2; + x10 = x3; + x11 = x0; + x12 = (x11)*(x7); + x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x7))>>32 : ((__uint128_t)(x11)*(x7))>>64); + x14 = (x11)*(x6); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x6))>>32 : ((__uint128_t)(x11)*(x6))>>64); + x16 = (x11)*(x5); + x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x5))>>32 : ((__uint128_t)(x11)*(x5))>>64); + x18 = (x11)*(x4); + x19 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*(x4))>>32 : ((__uint128_t)(x11)*(x4))>>64); + x20 = (x19)+(x16); + x21 = (uintptr_t)((x20)<(x19)); + x22 = (x21)+(x17); + x23 = (uintptr_t)((x22)<(x17)); + x24 = (x22)+(x14); + x25 = (uintptr_t)((x24)<(x14)); + x26 = (x23)+(x25); + x27 = (x26)+(x15); + x28 = (uintptr_t)((x27)<(x15)); + x29 = (x27)+(x12); + x30 = (uintptr_t)((x29)<(x12)); + x31 = (x28)+(x30); + x32 = (x31)+(x13); + x33 = (x18)*((uintptr_t)5408259542528602431ULL); + x34 = (x33)*((uintptr_t)18446744073709551615ULL); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)18446744073709551615ULL))>>64); + x36 = (x33)*((uintptr_t)18446744073709551614ULL); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)18446744073709551614ULL))>>64); + x38 = (x33)*((uintptr_t)13451932020343611451ULL); + x39 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)13451932020343611451ULL))>>64); + x40 = (x33)*((uintptr_t)13822214165235122497ULL); + x41 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x33)*((uintptr_t)13822214165235122497ULL))>>64); + x42 = (x41)+(x38); + x43 = (uintptr_t)((x42)<(x41)); + x44 = (x43)+(x39); + x45 = (uintptr_t)((x44)<(x39)); + x46 = (x44)+(x36); + x47 = (uintptr_t)((x46)<(x36)); + x48 = (x45)+(x47); + x49 = (x48)+(x37); + x50 = (uintptr_t)((x49)<(x37)); + x51 = (x49)+(x34); + x52 = (uintptr_t)((x51)<(x34)); + x53 = (x50)+(x52); + x54 = (x53)+(x35); + x55 = (x18)+(x40); + x56 = (uintptr_t)((x55)<(x18)); + x57 = (x56)+(x20); + x58 = (uintptr_t)((x57)<(x20)); + x59 = (x57)+(x42); + x60 = (uintptr_t)((x59)<(x42)); + x61 = (x58)+(x60); + x62 = (x61)+(x24); + x63 = (uintptr_t)((x62)<(x24)); + x64 = (x62)+(x46); + x65 = (uintptr_t)((x64)<(x46)); + x66 = (x63)+(x65); + x67 = (x66)+(x29); + x68 = (uintptr_t)((x67)<(x29)); + x69 = (x67)+(x51); + x70 = (uintptr_t)((x69)<(x51)); + x71 = (x68)+(x70); + x72 = (x71)+(x32); + x73 = (uintptr_t)((x72)<(x32)); + x74 = (x72)+(x54); + x75 = (uintptr_t)((x74)<(x54)); + x76 = (x73)+(x75); + x77 = (x8)*(x7); + x78 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x7))>>32 : ((__uint128_t)(x8)*(x7))>>64); + x79 = (x8)*(x6); + x80 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x6))>>32 : ((__uint128_t)(x8)*(x6))>>64); + x81 = (x8)*(x5); + x82 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x5))>>32 : ((__uint128_t)(x8)*(x5))>>64); + x83 = (x8)*(x4); + x84 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*(x4))>>32 : ((__uint128_t)(x8)*(x4))>>64); + x85 = (x84)+(x81); + x86 = (uintptr_t)((x85)<(x84)); + x87 = (x86)+(x82); + x88 = (uintptr_t)((x87)<(x82)); + x89 = (x87)+(x79); + x90 = (uintptr_t)((x89)<(x79)); + x91 = (x88)+(x90); + x92 = (x91)+(x80); + x93 = (uintptr_t)((x92)<(x80)); + x94 = (x92)+(x77); + x95 = (uintptr_t)((x94)<(x77)); + x96 = (x93)+(x95); + x97 = (x96)+(x78); + x98 = (x59)+(x83); + x99 = (uintptr_t)((x98)<(x59)); + x100 = (x99)+(x64); + x101 = (uintptr_t)((x100)<(x64)); + x102 = (x100)+(x85); + x103 = (uintptr_t)((x102)<(x85)); + x104 = (x101)+(x103); + x105 = (x104)+(x69); + x106 = (uintptr_t)((x105)<(x69)); + x107 = (x105)+(x89); + x108 = (uintptr_t)((x107)<(x89)); + x109 = (x106)+(x108); + x110 = (x109)+(x74); + x111 = (uintptr_t)((x110)<(x74)); + x112 = (x110)+(x94); + x113 = (uintptr_t)((x112)<(x94)); + x114 = (x111)+(x113); + x115 = (x114)+(x76); + x116 = (uintptr_t)((x115)<(x76)); + x117 = (x115)+(x97); + x118 = (uintptr_t)((x117)<(x97)); + x119 = (x116)+(x118); + x120 = (x98)*((uintptr_t)5408259542528602431ULL); + x121 = (x120)*((uintptr_t)18446744073709551615ULL); + x122 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x120)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x120)*((uintptr_t)18446744073709551615ULL))>>64); + x123 = (x120)*((uintptr_t)18446744073709551614ULL); + x124 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x120)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x120)*((uintptr_t)18446744073709551614ULL))>>64); + x125 = (x120)*((uintptr_t)13451932020343611451ULL); + x126 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x120)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x120)*((uintptr_t)13451932020343611451ULL))>>64); + x127 = (x120)*((uintptr_t)13822214165235122497ULL); + x128 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x120)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x120)*((uintptr_t)13822214165235122497ULL))>>64); + x129 = (x128)+(x125); + x130 = (uintptr_t)((x129)<(x128)); + x131 = (x130)+(x126); + x132 = (uintptr_t)((x131)<(x126)); + x133 = (x131)+(x123); + x134 = (uintptr_t)((x133)<(x123)); + x135 = (x132)+(x134); + x136 = (x135)+(x124); + x137 = (uintptr_t)((x136)<(x124)); + x138 = (x136)+(x121); + x139 = (uintptr_t)((x138)<(x121)); + x140 = (x137)+(x139); + x141 = (x140)+(x122); + x142 = (x98)+(x127); + x143 = (uintptr_t)((x142)<(x98)); + x144 = (x143)+(x102); + x145 = (uintptr_t)((x144)<(x102)); + x146 = (x144)+(x129); + x147 = (uintptr_t)((x146)<(x129)); + x148 = (x145)+(x147); + x149 = (x148)+(x107); + x150 = (uintptr_t)((x149)<(x107)); + x151 = (x149)+(x133); + x152 = (uintptr_t)((x151)<(x133)); + x153 = (x150)+(x152); + x154 = (x153)+(x112); + x155 = (uintptr_t)((x154)<(x112)); + x156 = (x154)+(x138); + x157 = (uintptr_t)((x156)<(x138)); + x158 = (x155)+(x157); + x159 = (x158)+(x117); + x160 = (uintptr_t)((x159)<(x117)); + x161 = (x159)+(x141); + x162 = (uintptr_t)((x161)<(x141)); + x163 = (x160)+(x162); + x164 = (x163)+(x119); + x165 = (x9)*(x7); + x166 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x7))>>32 : ((__uint128_t)(x9)*(x7))>>64); + x167 = (x9)*(x6); + x168 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x6))>>32 : ((__uint128_t)(x9)*(x6))>>64); + x169 = (x9)*(x5); + x170 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x5))>>32 : ((__uint128_t)(x9)*(x5))>>64); + x171 = (x9)*(x4); + x172 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*(x4))>>32 : ((__uint128_t)(x9)*(x4))>>64); + x173 = (x172)+(x169); + x174 = (uintptr_t)((x173)<(x172)); + x175 = (x174)+(x170); + x176 = (uintptr_t)((x175)<(x170)); + x177 = (x175)+(x167); + x178 = (uintptr_t)((x177)<(x167)); + x179 = (x176)+(x178); + x180 = (x179)+(x168); + x181 = (uintptr_t)((x180)<(x168)); + x182 = (x180)+(x165); + x183 = (uintptr_t)((x182)<(x165)); + x184 = (x181)+(x183); + x185 = (x184)+(x166); + x186 = (x146)+(x171); + x187 = (uintptr_t)((x186)<(x146)); + x188 = (x187)+(x151); + x189 = (uintptr_t)((x188)<(x151)); + x190 = (x188)+(x173); + x191 = (uintptr_t)((x190)<(x173)); + x192 = (x189)+(x191); + x193 = (x192)+(x156); + x194 = (uintptr_t)((x193)<(x156)); + x195 = (x193)+(x177); + x196 = (uintptr_t)((x195)<(x177)); + x197 = (x194)+(x196); + x198 = (x197)+(x161); + x199 = (uintptr_t)((x198)<(x161)); + x200 = (x198)+(x182); + x201 = (uintptr_t)((x200)<(x182)); + x202 = (x199)+(x201); + x203 = (x202)+(x164); + x204 = (uintptr_t)((x203)<(x164)); + x205 = (x203)+(x185); + x206 = (uintptr_t)((x205)<(x185)); + x207 = (x204)+(x206); + x208 = (x186)*((uintptr_t)5408259542528602431ULL); + x209 = (x208)*((uintptr_t)18446744073709551615ULL); + x210 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x208)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x208)*((uintptr_t)18446744073709551615ULL))>>64); + x211 = (x208)*((uintptr_t)18446744073709551614ULL); + x212 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x208)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x208)*((uintptr_t)18446744073709551614ULL))>>64); + x213 = (x208)*((uintptr_t)13451932020343611451ULL); + x214 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x208)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x208)*((uintptr_t)13451932020343611451ULL))>>64); + x215 = (x208)*((uintptr_t)13822214165235122497ULL); + x216 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x208)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x208)*((uintptr_t)13822214165235122497ULL))>>64); + x217 = (x216)+(x213); + x218 = (uintptr_t)((x217)<(x216)); + x219 = (x218)+(x214); + x220 = (uintptr_t)((x219)<(x214)); + x221 = (x219)+(x211); + x222 = (uintptr_t)((x221)<(x211)); + x223 = (x220)+(x222); + x224 = (x223)+(x212); + x225 = (uintptr_t)((x224)<(x212)); + x226 = (x224)+(x209); + x227 = (uintptr_t)((x226)<(x209)); + x228 = (x225)+(x227); + x229 = (x228)+(x210); + x230 = (x186)+(x215); + x231 = (uintptr_t)((x230)<(x186)); + x232 = (x231)+(x190); + x233 = (uintptr_t)((x232)<(x190)); + x234 = (x232)+(x217); + x235 = (uintptr_t)((x234)<(x217)); + x236 = (x233)+(x235); + x237 = (x236)+(x195); + x238 = (uintptr_t)((x237)<(x195)); + x239 = (x237)+(x221); + x240 = (uintptr_t)((x239)<(x221)); + x241 = (x238)+(x240); + x242 = (x241)+(x200); + x243 = (uintptr_t)((x242)<(x200)); + x244 = (x242)+(x226); + x245 = (uintptr_t)((x244)<(x226)); + x246 = (x243)+(x245); + x247 = (x246)+(x205); + x248 = (uintptr_t)((x247)<(x205)); + x249 = (x247)+(x229); + x250 = (uintptr_t)((x249)<(x229)); + x251 = (x248)+(x250); + x252 = (x251)+(x207); + x253 = (x10)*(x7); + x254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x7))>>32 : ((__uint128_t)(x10)*(x7))>>64); + x255 = (x10)*(x6); + x256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x6))>>32 : ((__uint128_t)(x10)*(x6))>>64); + x257 = (x10)*(x5); + x258 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x5))>>32 : ((__uint128_t)(x10)*(x5))>>64); + x259 = (x10)*(x4); + x260 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*(x4))>>32 : ((__uint128_t)(x10)*(x4))>>64); + x261 = (x260)+(x257); + x262 = (uintptr_t)((x261)<(x260)); + x263 = (x262)+(x258); + x264 = (uintptr_t)((x263)<(x258)); + x265 = (x263)+(x255); + x266 = (uintptr_t)((x265)<(x255)); + x267 = (x264)+(x266); + x268 = (x267)+(x256); + x269 = (uintptr_t)((x268)<(x256)); + x270 = (x268)+(x253); + x271 = (uintptr_t)((x270)<(x253)); + x272 = (x269)+(x271); + x273 = (x272)+(x254); + x274 = (x234)+(x259); + x275 = (uintptr_t)((x274)<(x234)); + x276 = (x275)+(x239); + x277 = (uintptr_t)((x276)<(x239)); + x278 = (x276)+(x261); + x279 = (uintptr_t)((x278)<(x261)); + x280 = (x277)+(x279); + x281 = (x280)+(x244); + x282 = (uintptr_t)((x281)<(x244)); + x283 = (x281)+(x265); + x284 = (uintptr_t)((x283)<(x265)); + x285 = (x282)+(x284); + x286 = (x285)+(x249); + x287 = (uintptr_t)((x286)<(x249)); + x288 = (x286)+(x270); + x289 = (uintptr_t)((x288)<(x270)); + x290 = (x287)+(x289); + x291 = (x290)+(x252); + x292 = (uintptr_t)((x291)<(x252)); + x293 = (x291)+(x273); + x294 = (uintptr_t)((x293)<(x273)); + x295 = (x292)+(x294); + x296 = (x274)*((uintptr_t)5408259542528602431ULL); + x297 = (x296)*((uintptr_t)18446744073709551615ULL); + x298 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x296)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x296)*((uintptr_t)18446744073709551615ULL))>>64); + x299 = (x296)*((uintptr_t)18446744073709551614ULL); + x300 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x296)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x296)*((uintptr_t)18446744073709551614ULL))>>64); + x301 = (x296)*((uintptr_t)13451932020343611451ULL); + x302 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x296)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x296)*((uintptr_t)13451932020343611451ULL))>>64); + x303 = (x296)*((uintptr_t)13822214165235122497ULL); + x304 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x296)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x296)*((uintptr_t)13822214165235122497ULL))>>64); + x305 = (x304)+(x301); + x306 = (uintptr_t)((x305)<(x304)); + x307 = (x306)+(x302); + x308 = (uintptr_t)((x307)<(x302)); + x309 = (x307)+(x299); + x310 = (uintptr_t)((x309)<(x299)); + x311 = (x308)+(x310); + x312 = (x311)+(x300); + x313 = (uintptr_t)((x312)<(x300)); + x314 = (x312)+(x297); + x315 = (uintptr_t)((x314)<(x297)); + x316 = (x313)+(x315); + x317 = (x316)+(x298); + x318 = (x274)+(x303); + x319 = (uintptr_t)((x318)<(x274)); + x320 = (x319)+(x278); + x321 = (uintptr_t)((x320)<(x278)); + x322 = (x320)+(x305); + x323 = (uintptr_t)((x322)<(x305)); + x324 = (x321)+(x323); + x325 = (x324)+(x283); + x326 = (uintptr_t)((x325)<(x283)); + x327 = (x325)+(x309); + x328 = (uintptr_t)((x327)<(x309)); + x329 = (x326)+(x328); + x330 = (x329)+(x288); + x331 = (uintptr_t)((x330)<(x288)); + x332 = (x330)+(x314); + x333 = (uintptr_t)((x332)<(x314)); + x334 = (x331)+(x333); + x335 = (x334)+(x293); + x336 = (uintptr_t)((x335)<(x293)); + x337 = (x335)+(x317); + x338 = (uintptr_t)((x337)<(x317)); + x339 = (x336)+(x338); + x340 = (x339)+(x295); + x341 = (x322)-((uintptr_t)13822214165235122497ULL); + x342 = (uintptr_t)((x322)<(x341)); + x343 = (x327)-((uintptr_t)13451932020343611451ULL); + x344 = (uintptr_t)((x327)<(x343)); + x345 = (x343)-(x342); + x346 = (uintptr_t)((x343)<(x345)); + x347 = (x344)+(x346); + x348 = (x332)-((uintptr_t)18446744073709551614ULL); + x349 = (uintptr_t)((x332)<(x348)); + x350 = (x348)-(x347); + x351 = (uintptr_t)((x348)<(x350)); + x352 = (x349)+(x351); + x353 = (x337)-((uintptr_t)18446744073709551615ULL); + x354 = (uintptr_t)((x337)<(x353)); + x355 = (x353)-(x352); + x356 = (uintptr_t)((x353)<(x355)); + x357 = (x354)+(x356); + x358 = (x340)-(x357); + x359 = (uintptr_t)((x340)<(x358)); + x360 = ((uintptr_t)-1ULL)+((uintptr_t)((x359)==((uintptr_t)0ULL))); + x361 = (x360)^((uintptr_t)18446744073709551615ULL); + x362 = ((x322)&(x360))|((x341)&(x361)); + x363 = ((uintptr_t)-1ULL)+((uintptr_t)((x359)==((uintptr_t)0ULL))); + x364 = (x363)^((uintptr_t)18446744073709551615ULL); + x365 = ((x327)&(x363))|((x345)&(x364)); + x366 = ((uintptr_t)-1ULL)+((uintptr_t)((x359)==((uintptr_t)0ULL))); + x367 = (x366)^((uintptr_t)18446744073709551615ULL); + x368 = ((x332)&(x366))|((x350)&(x367)); + x369 = ((uintptr_t)-1ULL)+((uintptr_t)((x359)==((uintptr_t)0ULL))); + x370 = (x369)^((uintptr_t)18446744073709551615ULL); + x371 = ((x337)&(x369))|((x355)&(x370)); + x372 = x362; + x373 = x365; + x374 = x368; + x375 = x371; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x372, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x373, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x374, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x375, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_mul(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_secp256k1_scalar_mul((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_square(uintptr_t out0, uintptr_t in0) { + uintptr_t x7, x12, x15, x17, x13, x18, x10, x19, x21, x22, x11, x23, x8, x24, x26, x27, x9, x29, x34, x37, x39, x35, x40, x32, x41, x43, x44, x33, x45, x30, x46, x48, x49, x31, x36, x51, x14, x52, x16, x53, x38, x54, x56, x57, x20, x58, x42, x59, x61, x62, x25, x63, x47, x64, x66, x67, x28, x68, x50, x69, x71, x4, x77, x80, x82, x78, x83, x75, x84, x86, x87, x76, x88, x73, x89, x91, x92, x74, x79, x55, x95, x60, x96, x81, x97, x99, x100, x65, x101, x85, x102, x104, x105, x70, x106, x90, x107, x109, x110, x72, x111, x93, x112, x114, x116, x121, x124, x126, x122, x127, x119, x128, x130, x131, x120, x132, x117, x133, x135, x136, x118, x123, x138, x94, x139, x98, x140, x125, x141, x143, x144, x103, x145, x129, x146, x148, x149, x108, x150, x134, x151, x153, x154, x113, x155, x137, x156, x158, x159, x115, x5, x165, x168, x170, x166, x171, x163, x172, x174, x175, x164, x176, x161, x177, x179, x180, x162, x167, x142, x183, x147, x184, x169, x185, x187, x188, x152, x189, x173, x190, x192, x193, x157, x194, x178, x195, x197, x198, x160, x199, x181, x200, x202, x204, x209, x212, x214, x210, x215, x207, x216, x218, x219, x208, x220, x205, x221, x223, x224, x206, x211, x226, x182, x227, x186, x228, x213, x229, x231, x232, x191, x233, x217, x234, x236, x237, x196, x238, x222, x239, x241, x242, x201, x243, x225, x244, x246, x247, x203, x3, x2, x1, x6, x0, x253, x256, x258, x254, x259, x251, x260, x262, x263, x252, x264, x249, x265, x267, x268, x250, x255, x230, x271, x235, x272, x257, x273, x275, x276, x240, x277, x261, x278, x280, x281, x245, x282, x266, x283, x285, x286, x248, x287, x269, x288, x290, x292, x297, x300, x302, x298, x303, x295, x304, x306, x307, x296, x308, x293, x309, x311, x312, x294, x299, x314, x270, x315, x274, x316, x301, x317, x319, x320, x279, x321, x305, x322, x324, x325, x284, x326, x310, x327, x329, x330, x289, x331, x313, x332, x334, x335, x291, x338, x339, x340, x342, x343, x344, x345, x347, x348, x349, x350, x352, x353, x336, x354, x318, x356, x337, x357, x323, x359, x341, x360, x328, x362, x346, x363, x355, x333, x365, x351, x366, x358, x361, x364, x367, x368, x369, x370, x371; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x1; + x5 = x2; + x6 = x3; + x7 = x0; + x8 = (x7)*(x3); + x9 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x3))>>32 : ((__uint128_t)(x7)*(x3))>>64); + x10 = (x7)*(x2); + x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x2))>>32 : ((__uint128_t)(x7)*(x2))>>64); + x12 = (x7)*(x1); + x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x1))>>32 : ((__uint128_t)(x7)*(x1))>>64); + x14 = (x7)*(x0); + x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*(x0))>>32 : ((__uint128_t)(x7)*(x0))>>64); + x16 = (x15)+(x12); + x17 = (uintptr_t)((x16)<(x15)); + x18 = (x17)+(x13); + x19 = (uintptr_t)((x18)<(x13)); + x20 = (x18)+(x10); + x21 = (uintptr_t)((x20)<(x10)); + x22 = (x19)+(x21); + x23 = (x22)+(x11); + x24 = (uintptr_t)((x23)<(x11)); + x25 = (x23)+(x8); + x26 = (uintptr_t)((x25)<(x8)); + x27 = (x24)+(x26); + x28 = (x27)+(x9); + x29 = (x14)*((uintptr_t)5408259542528602431ULL); + x30 = (x29)*((uintptr_t)18446744073709551615ULL); + x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x29)*((uintptr_t)18446744073709551615ULL))>>64); + x32 = (x29)*((uintptr_t)18446744073709551614ULL); + x33 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x29)*((uintptr_t)18446744073709551614ULL))>>64); + x34 = (x29)*((uintptr_t)13451932020343611451ULL); + x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x29)*((uintptr_t)13451932020343611451ULL))>>64); + x36 = (x29)*((uintptr_t)13822214165235122497ULL); + x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x29)*((uintptr_t)13822214165235122497ULL))>>64); + x38 = (x37)+(x34); + x39 = (uintptr_t)((x38)<(x37)); + x40 = (x39)+(x35); + x41 = (uintptr_t)((x40)<(x35)); + x42 = (x40)+(x32); + x43 = (uintptr_t)((x42)<(x32)); + x44 = (x41)+(x43); + x45 = (x44)+(x33); + x46 = (uintptr_t)((x45)<(x33)); + x47 = (x45)+(x30); + x48 = (uintptr_t)((x47)<(x30)); + x49 = (x46)+(x48); + x50 = (x49)+(x31); + x51 = (x14)+(x36); + x52 = (uintptr_t)((x51)<(x14)); + x53 = (x52)+(x16); + x54 = (uintptr_t)((x53)<(x16)); + x55 = (x53)+(x38); + x56 = (uintptr_t)((x55)<(x38)); + x57 = (x54)+(x56); + x58 = (x57)+(x20); + x59 = (uintptr_t)((x58)<(x20)); + x60 = (x58)+(x42); + x61 = (uintptr_t)((x60)<(x42)); + x62 = (x59)+(x61); + x63 = (x62)+(x25); + x64 = (uintptr_t)((x63)<(x25)); + x65 = (x63)+(x47); + x66 = (uintptr_t)((x65)<(x47)); + x67 = (x64)+(x66); + x68 = (x67)+(x28); + x69 = (uintptr_t)((x68)<(x28)); + x70 = (x68)+(x50); + x71 = (uintptr_t)((x70)<(x50)); + x72 = (x69)+(x71); + x73 = (x4)*(x3); + x74 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*(x3))>>32 : ((__uint128_t)(x4)*(x3))>>64); + x75 = (x4)*(x2); + x76 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*(x2))>>32 : ((__uint128_t)(x4)*(x2))>>64); + x77 = (x4)*(x1); + x78 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*(x1))>>32 : ((__uint128_t)(x4)*(x1))>>64); + x79 = (x4)*(x0); + x80 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*(x0))>>32 : ((__uint128_t)(x4)*(x0))>>64); + x81 = (x80)+(x77); + x82 = (uintptr_t)((x81)<(x80)); + x83 = (x82)+(x78); + x84 = (uintptr_t)((x83)<(x78)); + x85 = (x83)+(x75); + x86 = (uintptr_t)((x85)<(x75)); + x87 = (x84)+(x86); + x88 = (x87)+(x76); + x89 = (uintptr_t)((x88)<(x76)); + x90 = (x88)+(x73); + x91 = (uintptr_t)((x90)<(x73)); + x92 = (x89)+(x91); + x93 = (x92)+(x74); + x94 = (x55)+(x79); + x95 = (uintptr_t)((x94)<(x55)); + x96 = (x95)+(x60); + x97 = (uintptr_t)((x96)<(x60)); + x98 = (x96)+(x81); + x99 = (uintptr_t)((x98)<(x81)); + x100 = (x97)+(x99); + x101 = (x100)+(x65); + x102 = (uintptr_t)((x101)<(x65)); + x103 = (x101)+(x85); + x104 = (uintptr_t)((x103)<(x85)); + x105 = (x102)+(x104); + x106 = (x105)+(x70); + x107 = (uintptr_t)((x106)<(x70)); + x108 = (x106)+(x90); + x109 = (uintptr_t)((x108)<(x90)); + x110 = (x107)+(x109); + x111 = (x110)+(x72); + x112 = (uintptr_t)((x111)<(x72)); + x113 = (x111)+(x93); + x114 = (uintptr_t)((x113)<(x93)); + x115 = (x112)+(x114); + x116 = (x94)*((uintptr_t)5408259542528602431ULL); + x117 = (x116)*((uintptr_t)18446744073709551615ULL); + x118 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x116)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x116)*((uintptr_t)18446744073709551615ULL))>>64); + x119 = (x116)*((uintptr_t)18446744073709551614ULL); + x120 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x116)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x116)*((uintptr_t)18446744073709551614ULL))>>64); + x121 = (x116)*((uintptr_t)13451932020343611451ULL); + x122 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x116)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x116)*((uintptr_t)13451932020343611451ULL))>>64); + x123 = (x116)*((uintptr_t)13822214165235122497ULL); + x124 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x116)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x116)*((uintptr_t)13822214165235122497ULL))>>64); + x125 = (x124)+(x121); + x126 = (uintptr_t)((x125)<(x124)); + x127 = (x126)+(x122); + x128 = (uintptr_t)((x127)<(x122)); + x129 = (x127)+(x119); + x130 = (uintptr_t)((x129)<(x119)); + x131 = (x128)+(x130); + x132 = (x131)+(x120); + x133 = (uintptr_t)((x132)<(x120)); + x134 = (x132)+(x117); + x135 = (uintptr_t)((x134)<(x117)); + x136 = (x133)+(x135); + x137 = (x136)+(x118); + x138 = (x94)+(x123); + x139 = (uintptr_t)((x138)<(x94)); + x140 = (x139)+(x98); + x141 = (uintptr_t)((x140)<(x98)); + x142 = (x140)+(x125); + x143 = (uintptr_t)((x142)<(x125)); + x144 = (x141)+(x143); + x145 = (x144)+(x103); + x146 = (uintptr_t)((x145)<(x103)); + x147 = (x145)+(x129); + x148 = (uintptr_t)((x147)<(x129)); + x149 = (x146)+(x148); + x150 = (x149)+(x108); + x151 = (uintptr_t)((x150)<(x108)); + x152 = (x150)+(x134); + x153 = (uintptr_t)((x152)<(x134)); + x154 = (x151)+(x153); + x155 = (x154)+(x113); + x156 = (uintptr_t)((x155)<(x113)); + x157 = (x155)+(x137); + x158 = (uintptr_t)((x157)<(x137)); + x159 = (x156)+(x158); + x160 = (x159)+(x115); + x161 = (x5)*(x3); + x162 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*(x3))>>32 : ((__uint128_t)(x5)*(x3))>>64); + x163 = (x5)*(x2); + x164 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*(x2))>>32 : ((__uint128_t)(x5)*(x2))>>64); + x165 = (x5)*(x1); + x166 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*(x1))>>32 : ((__uint128_t)(x5)*(x1))>>64); + x167 = (x5)*(x0); + x168 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*(x0))>>32 : ((__uint128_t)(x5)*(x0))>>64); + x169 = (x168)+(x165); + x170 = (uintptr_t)((x169)<(x168)); + x171 = (x170)+(x166); + x172 = (uintptr_t)((x171)<(x166)); + x173 = (x171)+(x163); + x174 = (uintptr_t)((x173)<(x163)); + x175 = (x172)+(x174); + x176 = (x175)+(x164); + x177 = (uintptr_t)((x176)<(x164)); + x178 = (x176)+(x161); + x179 = (uintptr_t)((x178)<(x161)); + x180 = (x177)+(x179); + x181 = (x180)+(x162); + x182 = (x142)+(x167); + x183 = (uintptr_t)((x182)<(x142)); + x184 = (x183)+(x147); + x185 = (uintptr_t)((x184)<(x147)); + x186 = (x184)+(x169); + x187 = (uintptr_t)((x186)<(x169)); + x188 = (x185)+(x187); + x189 = (x188)+(x152); + x190 = (uintptr_t)((x189)<(x152)); + x191 = (x189)+(x173); + x192 = (uintptr_t)((x191)<(x173)); + x193 = (x190)+(x192); + x194 = (x193)+(x157); + x195 = (uintptr_t)((x194)<(x157)); + x196 = (x194)+(x178); + x197 = (uintptr_t)((x196)<(x178)); + x198 = (x195)+(x197); + x199 = (x198)+(x160); + x200 = (uintptr_t)((x199)<(x160)); + x201 = (x199)+(x181); + x202 = (uintptr_t)((x201)<(x181)); + x203 = (x200)+(x202); + x204 = (x182)*((uintptr_t)5408259542528602431ULL); + x205 = (x204)*((uintptr_t)18446744073709551615ULL); + x206 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x204)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x204)*((uintptr_t)18446744073709551615ULL))>>64); + x207 = (x204)*((uintptr_t)18446744073709551614ULL); + x208 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x204)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x204)*((uintptr_t)18446744073709551614ULL))>>64); + x209 = (x204)*((uintptr_t)13451932020343611451ULL); + x210 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x204)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x204)*((uintptr_t)13451932020343611451ULL))>>64); + x211 = (x204)*((uintptr_t)13822214165235122497ULL); + x212 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x204)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x204)*((uintptr_t)13822214165235122497ULL))>>64); + x213 = (x212)+(x209); + x214 = (uintptr_t)((x213)<(x212)); + x215 = (x214)+(x210); + x216 = (uintptr_t)((x215)<(x210)); + x217 = (x215)+(x207); + x218 = (uintptr_t)((x217)<(x207)); + x219 = (x216)+(x218); + x220 = (x219)+(x208); + x221 = (uintptr_t)((x220)<(x208)); + x222 = (x220)+(x205); + x223 = (uintptr_t)((x222)<(x205)); + x224 = (x221)+(x223); + x225 = (x224)+(x206); + x226 = (x182)+(x211); + x227 = (uintptr_t)((x226)<(x182)); + x228 = (x227)+(x186); + x229 = (uintptr_t)((x228)<(x186)); + x230 = (x228)+(x213); + x231 = (uintptr_t)((x230)<(x213)); + x232 = (x229)+(x231); + x233 = (x232)+(x191); + x234 = (uintptr_t)((x233)<(x191)); + x235 = (x233)+(x217); + x236 = (uintptr_t)((x235)<(x217)); + x237 = (x234)+(x236); + x238 = (x237)+(x196); + x239 = (uintptr_t)((x238)<(x196)); + x240 = (x238)+(x222); + x241 = (uintptr_t)((x240)<(x222)); + x242 = (x239)+(x241); + x243 = (x242)+(x201); + x244 = (uintptr_t)((x243)<(x201)); + x245 = (x243)+(x225); + x246 = (uintptr_t)((x245)<(x225)); + x247 = (x244)+(x246); + x248 = (x247)+(x203); + x249 = (x6)*(x3); + x250 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x3))>>32 : ((__uint128_t)(x6)*(x3))>>64); + x251 = (x6)*(x2); + x252 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x2))>>32 : ((__uint128_t)(x6)*(x2))>>64); + x253 = (x6)*(x1); + x254 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x1))>>32 : ((__uint128_t)(x6)*(x1))>>64); + x255 = (x6)*(x0); + x256 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*(x0))>>32 : ((__uint128_t)(x6)*(x0))>>64); + x257 = (x256)+(x253); + x258 = (uintptr_t)((x257)<(x256)); + x259 = (x258)+(x254); + x260 = (uintptr_t)((x259)<(x254)); + x261 = (x259)+(x251); + x262 = (uintptr_t)((x261)<(x251)); + x263 = (x260)+(x262); + x264 = (x263)+(x252); + x265 = (uintptr_t)((x264)<(x252)); + x266 = (x264)+(x249); + x267 = (uintptr_t)((x266)<(x249)); + x268 = (x265)+(x267); + x269 = (x268)+(x250); + x270 = (x230)+(x255); + x271 = (uintptr_t)((x270)<(x230)); + x272 = (x271)+(x235); + x273 = (uintptr_t)((x272)<(x235)); + x274 = (x272)+(x257); + x275 = (uintptr_t)((x274)<(x257)); + x276 = (x273)+(x275); + x277 = (x276)+(x240); + x278 = (uintptr_t)((x277)<(x240)); + x279 = (x277)+(x261); + x280 = (uintptr_t)((x279)<(x261)); + x281 = (x278)+(x280); + x282 = (x281)+(x245); + x283 = (uintptr_t)((x282)<(x245)); + x284 = (x282)+(x266); + x285 = (uintptr_t)((x284)<(x266)); + x286 = (x283)+(x285); + x287 = (x286)+(x248); + x288 = (uintptr_t)((x287)<(x248)); + x289 = (x287)+(x269); + x290 = (uintptr_t)((x289)<(x269)); + x291 = (x288)+(x290); + x292 = (x270)*((uintptr_t)5408259542528602431ULL); + x293 = (x292)*((uintptr_t)18446744073709551615ULL); + x294 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x292)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x292)*((uintptr_t)18446744073709551615ULL))>>64); + x295 = (x292)*((uintptr_t)18446744073709551614ULL); + x296 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x292)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x292)*((uintptr_t)18446744073709551614ULL))>>64); + x297 = (x292)*((uintptr_t)13451932020343611451ULL); + x298 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x292)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x292)*((uintptr_t)13451932020343611451ULL))>>64); + x299 = (x292)*((uintptr_t)13822214165235122497ULL); + x300 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x292)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x292)*((uintptr_t)13822214165235122497ULL))>>64); + x301 = (x300)+(x297); + x302 = (uintptr_t)((x301)<(x300)); + x303 = (x302)+(x298); + x304 = (uintptr_t)((x303)<(x298)); + x305 = (x303)+(x295); + x306 = (uintptr_t)((x305)<(x295)); + x307 = (x304)+(x306); + x308 = (x307)+(x296); + x309 = (uintptr_t)((x308)<(x296)); + x310 = (x308)+(x293); + x311 = (uintptr_t)((x310)<(x293)); + x312 = (x309)+(x311); + x313 = (x312)+(x294); + x314 = (x270)+(x299); + x315 = (uintptr_t)((x314)<(x270)); + x316 = (x315)+(x274); + x317 = (uintptr_t)((x316)<(x274)); + x318 = (x316)+(x301); + x319 = (uintptr_t)((x318)<(x301)); + x320 = (x317)+(x319); + x321 = (x320)+(x279); + x322 = (uintptr_t)((x321)<(x279)); + x323 = (x321)+(x305); + x324 = (uintptr_t)((x323)<(x305)); + x325 = (x322)+(x324); + x326 = (x325)+(x284); + x327 = (uintptr_t)((x326)<(x284)); + x328 = (x326)+(x310); + x329 = (uintptr_t)((x328)<(x310)); + x330 = (x327)+(x329); + x331 = (x330)+(x289); + x332 = (uintptr_t)((x331)<(x289)); + x333 = (x331)+(x313); + x334 = (uintptr_t)((x333)<(x313)); + x335 = (x332)+(x334); + x336 = (x335)+(x291); + x337 = (x318)-((uintptr_t)13822214165235122497ULL); + x338 = (uintptr_t)((x318)<(x337)); + x339 = (x323)-((uintptr_t)13451932020343611451ULL); + x340 = (uintptr_t)((x323)<(x339)); + x341 = (x339)-(x338); + x342 = (uintptr_t)((x339)<(x341)); + x343 = (x340)+(x342); + x344 = (x328)-((uintptr_t)18446744073709551614ULL); + x345 = (uintptr_t)((x328)<(x344)); + x346 = (x344)-(x343); + x347 = (uintptr_t)((x344)<(x346)); + x348 = (x345)+(x347); + x349 = (x333)-((uintptr_t)18446744073709551615ULL); + x350 = (uintptr_t)((x333)<(x349)); + x351 = (x349)-(x348); + x352 = (uintptr_t)((x349)<(x351)); + x353 = (x350)+(x352); + x354 = (x336)-(x353); + x355 = (uintptr_t)((x336)<(x354)); + x356 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x357 = (x356)^((uintptr_t)18446744073709551615ULL); + x358 = ((x318)&(x356))|((x337)&(x357)); + x359 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x360 = (x359)^((uintptr_t)18446744073709551615ULL); + x361 = ((x323)&(x359))|((x341)&(x360)); + x362 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x363 = (x362)^((uintptr_t)18446744073709551615ULL); + x364 = ((x328)&(x362))|((x346)&(x363)); + x365 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL))); + x366 = (x365)^((uintptr_t)18446744073709551615ULL); + x367 = ((x333)&(x365))|((x351)&(x366)); + x368 = x358; + x369 = x361; + x370 = x364; + x371 = x367; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x368, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x369, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x370, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x371, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_square(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_secp256k1_scalar_square((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_add(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x4, x0, x9, x1, x5, x11, x2, x6, x13, x3, x7, x17, x19, x15, x21, x8, x24, x16, x25, x10, x27, x18, x28, x12, x30, x20, x31, x23, x14, x33, x22, x34, x26, x29, x32, x35, x36, x37, x38, x39; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = (x0)+(x4); + x9 = ((uintptr_t)((x8)<(x0)))+(x1); + x10 = (x9)+(x5); + x11 = (((uintptr_t)((x9)<(x1)))+((uintptr_t)((x10)<(x5))))+(x2); + x12 = (x11)+(x6); + x13 = (((uintptr_t)((x11)<(x2)))+((uintptr_t)((x12)<(x6))))+(x3); + x14 = (x13)+(x7); + x15 = ((uintptr_t)((x13)<(x3)))+((uintptr_t)((x14)<(x7))); + x16 = (x8)-((uintptr_t)13822214165235122497ULL); + x17 = (x10)-((uintptr_t)13451932020343611451ULL); + x18 = (x17)-((uintptr_t)((x8)<(x16))); + x19 = (x12)-((uintptr_t)18446744073709551614ULL); + x20 = (x19)-(((uintptr_t)((x10)<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = (x14)-((uintptr_t)18446744073709551615ULL); + x22 = (x21)-(((uintptr_t)((x12)<(x19)))+((uintptr_t)((x19)<(x20)))); + x23 = (uintptr_t)((x15)<((x15)-(((uintptr_t)((x14)<(x21)))+((uintptr_t)((x21)<(x22)))))); + x24 = ((uintptr_t)-1ULL)+((uintptr_t)((x23)==((uintptr_t)0ULL))); + x25 = (x24)^((uintptr_t)18446744073709551615ULL); + x26 = ((x8)&(x24))|((x16)&(x25)); + x27 = ((uintptr_t)-1ULL)+((uintptr_t)((x23)==((uintptr_t)0ULL))); + x28 = (x27)^((uintptr_t)18446744073709551615ULL); + x29 = ((x10)&(x27))|((x18)&(x28)); + x30 = ((uintptr_t)-1ULL)+((uintptr_t)((x23)==((uintptr_t)0ULL))); + x31 = (x30)^((uintptr_t)18446744073709551615ULL); + x32 = ((x12)&(x30))|((x20)&(x31)); + x33 = ((uintptr_t)-1ULL)+((uintptr_t)((x23)==((uintptr_t)0ULL))); + x34 = (x33)^((uintptr_t)18446744073709551615ULL); + x35 = ((x14)&(x33))|((x22)&(x34)); + x36 = x26; + x37 = x29; + x38 = x32; + x39 = x35; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x36, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x37, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x38, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x39, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_add(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_secp256k1_scalar_add((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_sub(uintptr_t out0, uintptr_t in0, uintptr_t in1) { + uintptr_t x4, x5, x0, x6, x1, x9, x7, x2, x11, x3, x13, x8, x17, x10, x19, x12, x14, x15, x16, x18, x20, x21, x22, x23, x24, x25; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = (x0)-(x4); + x9 = (x1)-(x5); + x10 = (x9)-((uintptr_t)((x0)<(x8))); + x11 = (x2)-(x6); + x12 = (x11)-(((uintptr_t)((x1)<(x9)))+((uintptr_t)((x9)<(x10)))); + x13 = (x3)-(x7); + x14 = (x13)-(((uintptr_t)((x2)<(x11)))+((uintptr_t)((x11)<(x12)))); + x15 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)((x3)<(x13)))+((uintptr_t)((x13)<(x14))))==((uintptr_t)0ULL))); + x16 = (x8)+((x15)&((uintptr_t)13822214165235122497ULL)); + x17 = ((uintptr_t)((x16)<(x8)))+(x10); + x18 = (x17)+((x15)&((uintptr_t)13451932020343611451ULL)); + x19 = (((uintptr_t)((x17)<(x10)))+((uintptr_t)((x18)<((x15)&((uintptr_t)13451932020343611451ULL)))))+(x12); + x20 = (x19)+((x15)&((uintptr_t)18446744073709551614ULL)); + x21 = ((((uintptr_t)((x19)<(x12)))+((uintptr_t)((x20)<((x15)&((uintptr_t)18446744073709551614ULL)))))+(x14))+(x15); + x22 = x16; + x23 = x18; + x24 = x20; + x25 = x21; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x22, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x23, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x24, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x25, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_sub(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_secp256k1_scalar_sub((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_opp(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x1, x2, x5, x3, x7, x9, x4, x13, x6, x15, x8, x10, x11, x12, x14, x16, x17, x18, x19, x20, x21; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = ((uintptr_t)0ULL)-(x0); + x5 = ((uintptr_t)0ULL)-(x1); + x6 = (x5)-((uintptr_t)(((uintptr_t)0ULL)<(x4))); + x7 = ((uintptr_t)0ULL)-(x2); + x8 = (x7)-(((uintptr_t)(((uintptr_t)0ULL)<(x5)))+((uintptr_t)((x5)<(x6)))); + x9 = ((uintptr_t)0ULL)-(x3); + x10 = (x9)-(((uintptr_t)(((uintptr_t)0ULL)<(x7)))+((uintptr_t)((x7)<(x8)))); + x11 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)(((uintptr_t)0ULL)<(x9)))+((uintptr_t)((x9)<(x10))))==((uintptr_t)0ULL))); + x12 = (x4)+((x11)&((uintptr_t)13822214165235122497ULL)); + x13 = ((uintptr_t)((x12)<(x4)))+(x6); + x14 = (x13)+((x11)&((uintptr_t)13451932020343611451ULL)); + x15 = (((uintptr_t)((x13)<(x6)))+((uintptr_t)((x14)<((x11)&((uintptr_t)13451932020343611451ULL)))))+(x8); + x16 = (x15)+((x11)&((uintptr_t)18446744073709551614ULL)); + x17 = ((((uintptr_t)((x15)<(x8)))+((uintptr_t)((x16)<((x11)&((uintptr_t)18446744073709551614ULL)))))+(x10))+(x11); + x18 = x12; + x19 = x14; + x20 = x16; + x21 = x17; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x18, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x19, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x20, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x21, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_opp(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_secp256k1_scalar_opp((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_from_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x11, x13, x10, x8, x15, x9, x6, x5, x4, x12, x14, x16, x17, x7, x1, x18, x19, x20, x21, x34, x36, x33, x31, x38, x32, x29, x28, x23, x41, x24, x35, x43, x25, x37, x45, x26, x39, x47, x27, x22, x40, x30, x2, x42, x44, x46, x48, x61, x63, x60, x58, x65, x59, x56, x55, x50, x68, x51, x62, x70, x52, x64, x72, x53, x66, x74, x54, x49, x67, x57, x3, x69, x71, x73, x75, x88, x90, x87, x85, x92, x86, x83, x82, x77, x95, x78, x89, x97, x79, x91, x99, x80, x93, x101, x81, x76, x94, x84, x105, x107, x103, x109, x96, x112, x104, x113, x98, x115, x106, x116, x100, x118, x108, x119, x111, x102, x121, x110, x122, x114, x117, x120, x123, x124, x125, x126, x127; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x0; + x5 = (x4)*((uintptr_t)5408259542528602431ULL); + x6 = (x5)*((uintptr_t)18446744073709551615ULL); + x7 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)18446744073709551615ULL))>>64); + x8 = (x5)*((uintptr_t)18446744073709551614ULL); + x9 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)18446744073709551614ULL))>>64); + x10 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)13451932020343611451ULL))>>64); + x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)13822214165235122497ULL))>>64); + x12 = (x11)+((x5)*((uintptr_t)13451932020343611451ULL)); + x13 = ((uintptr_t)((x12)<(x11)))+(x10); + x14 = (x13)+(x8); + x15 = (((uintptr_t)((x13)<(x10)))+((uintptr_t)((x14)<(x8))))+(x9); + x16 = (x15)+(x6); + x17 = ((uintptr_t)((x15)<(x9)))+((uintptr_t)((x16)<(x6))); + x18 = ((uintptr_t)(((x4)+((x5)*((uintptr_t)13822214165235122497ULL)))<(x4)))+(x12); + x19 = ((uintptr_t)((x18)<(x12)))+(x14); + x20 = ((uintptr_t)((x19)<(x14)))+(x16); + x21 = ((uintptr_t)((x20)<(x16)))+((x17)+(x7)); + x22 = (uintptr_t)((x21)<((x17)+(x7))); + x23 = (x18)+(x1); + x24 = ((uintptr_t)((x23)<(x18)))+(x19); + x25 = ((uintptr_t)((x24)<(x19)))+(x20); + x26 = ((uintptr_t)((x25)<(x20)))+(x21); + x27 = (uintptr_t)((x26)<(x21)); + x28 = (x23)*((uintptr_t)5408259542528602431ULL); + x29 = (x28)*((uintptr_t)18446744073709551615ULL); + x30 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x28)*((uintptr_t)18446744073709551615ULL))>>64); + x31 = (x28)*((uintptr_t)18446744073709551614ULL); + x32 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x28)*((uintptr_t)18446744073709551614ULL))>>64); + x33 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x28)*((uintptr_t)13451932020343611451ULL))>>64); + x34 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x28)*((uintptr_t)13822214165235122497ULL))>>64); + x35 = (x34)+((x28)*((uintptr_t)13451932020343611451ULL)); + x36 = ((uintptr_t)((x35)<(x34)))+(x33); + x37 = (x36)+(x31); + x38 = (((uintptr_t)((x36)<(x33)))+((uintptr_t)((x37)<(x31))))+(x32); + x39 = (x38)+(x29); + x40 = ((uintptr_t)((x38)<(x32)))+((uintptr_t)((x39)<(x29))); + x41 = ((uintptr_t)(((x23)+((x28)*((uintptr_t)13822214165235122497ULL)))<(x23)))+(x24); + x42 = (x41)+(x35); + x43 = (((uintptr_t)((x41)<(x24)))+((uintptr_t)((x42)<(x35))))+(x25); + x44 = (x43)+(x37); + x45 = (((uintptr_t)((x43)<(x25)))+((uintptr_t)((x44)<(x37))))+(x26); + x46 = (x45)+(x39); + x47 = (((uintptr_t)((x45)<(x26)))+((uintptr_t)((x46)<(x39))))+((x27)+(x22)); + x48 = (x47)+((x40)+(x30)); + x49 = ((uintptr_t)((x47)<((x27)+(x22))))+((uintptr_t)((x48)<((x40)+(x30)))); + x50 = (x42)+(x2); + x51 = ((uintptr_t)((x50)<(x42)))+(x44); + x52 = ((uintptr_t)((x51)<(x44)))+(x46); + x53 = ((uintptr_t)((x52)<(x46)))+(x48); + x54 = (uintptr_t)((x53)<(x48)); + x55 = (x50)*((uintptr_t)5408259542528602431ULL); + x56 = (x55)*((uintptr_t)18446744073709551615ULL); + x57 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x55)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x55)*((uintptr_t)18446744073709551615ULL))>>64); + x58 = (x55)*((uintptr_t)18446744073709551614ULL); + x59 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x55)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x55)*((uintptr_t)18446744073709551614ULL))>>64); + x60 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x55)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x55)*((uintptr_t)13451932020343611451ULL))>>64); + x61 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x55)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x55)*((uintptr_t)13822214165235122497ULL))>>64); + x62 = (x61)+((x55)*((uintptr_t)13451932020343611451ULL)); + x63 = ((uintptr_t)((x62)<(x61)))+(x60); + x64 = (x63)+(x58); + x65 = (((uintptr_t)((x63)<(x60)))+((uintptr_t)((x64)<(x58))))+(x59); + x66 = (x65)+(x56); + x67 = ((uintptr_t)((x65)<(x59)))+((uintptr_t)((x66)<(x56))); + x68 = ((uintptr_t)(((x50)+((x55)*((uintptr_t)13822214165235122497ULL)))<(x50)))+(x51); + x69 = (x68)+(x62); + x70 = (((uintptr_t)((x68)<(x51)))+((uintptr_t)((x69)<(x62))))+(x52); + x71 = (x70)+(x64); + x72 = (((uintptr_t)((x70)<(x52)))+((uintptr_t)((x71)<(x64))))+(x53); + x73 = (x72)+(x66); + x74 = (((uintptr_t)((x72)<(x53)))+((uintptr_t)((x73)<(x66))))+((x54)+(x49)); + x75 = (x74)+((x67)+(x57)); + x76 = ((uintptr_t)((x74)<((x54)+(x49))))+((uintptr_t)((x75)<((x67)+(x57)))); + x77 = (x69)+(x3); + x78 = ((uintptr_t)((x77)<(x69)))+(x71); + x79 = ((uintptr_t)((x78)<(x71)))+(x73); + x80 = ((uintptr_t)((x79)<(x73)))+(x75); + x81 = (uintptr_t)((x80)<(x75)); + x82 = (x77)*((uintptr_t)5408259542528602431ULL); + x83 = (x82)*((uintptr_t)18446744073709551615ULL); + x84 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x82)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x82)*((uintptr_t)18446744073709551615ULL))>>64); + x85 = (x82)*((uintptr_t)18446744073709551614ULL); + x86 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x82)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x82)*((uintptr_t)18446744073709551614ULL))>>64); + x87 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x82)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x82)*((uintptr_t)13451932020343611451ULL))>>64); + x88 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x82)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x82)*((uintptr_t)13822214165235122497ULL))>>64); + x89 = (x88)+((x82)*((uintptr_t)13451932020343611451ULL)); + x90 = ((uintptr_t)((x89)<(x88)))+(x87); + x91 = (x90)+(x85); + x92 = (((uintptr_t)((x90)<(x87)))+((uintptr_t)((x91)<(x85))))+(x86); + x93 = (x92)+(x83); + x94 = ((uintptr_t)((x92)<(x86)))+((uintptr_t)((x93)<(x83))); + x95 = ((uintptr_t)(((x77)+((x82)*((uintptr_t)13822214165235122497ULL)))<(x77)))+(x78); + x96 = (x95)+(x89); + x97 = (((uintptr_t)((x95)<(x78)))+((uintptr_t)((x96)<(x89))))+(x79); + x98 = (x97)+(x91); + x99 = (((uintptr_t)((x97)<(x79)))+((uintptr_t)((x98)<(x91))))+(x80); + x100 = (x99)+(x93); + x101 = (((uintptr_t)((x99)<(x80)))+((uintptr_t)((x100)<(x93))))+((x81)+(x76)); + x102 = (x101)+((x94)+(x84)); + x103 = ((uintptr_t)((x101)<((x81)+(x76))))+((uintptr_t)((x102)<((x94)+(x84)))); + x104 = (x96)-((uintptr_t)13822214165235122497ULL); + x105 = (x98)-((uintptr_t)13451932020343611451ULL); + x106 = (x105)-((uintptr_t)((x96)<(x104))); + x107 = (x100)-((uintptr_t)18446744073709551614ULL); + x108 = (x107)-(((uintptr_t)((x98)<(x105)))+((uintptr_t)((x105)<(x106)))); + x109 = (x102)-((uintptr_t)18446744073709551615ULL); + x110 = (x109)-(((uintptr_t)((x100)<(x107)))+((uintptr_t)((x107)<(x108)))); + x111 = (uintptr_t)((x103)<((x103)-(((uintptr_t)((x102)<(x109)))+((uintptr_t)((x109)<(x110)))))); + x112 = ((uintptr_t)-1ULL)+((uintptr_t)((x111)==((uintptr_t)0ULL))); + x113 = (x112)^((uintptr_t)18446744073709551615ULL); + x114 = ((x96)&(x112))|((x104)&(x113)); + x115 = ((uintptr_t)-1ULL)+((uintptr_t)((x111)==((uintptr_t)0ULL))); + x116 = (x115)^((uintptr_t)18446744073709551615ULL); + x117 = ((x98)&(x115))|((x106)&(x116)); + x118 = ((uintptr_t)-1ULL)+((uintptr_t)((x111)==((uintptr_t)0ULL))); + x119 = (x118)^((uintptr_t)18446744073709551615ULL); + x120 = ((x100)&(x118))|((x108)&(x119)); + x121 = ((uintptr_t)-1ULL)+((uintptr_t)((x111)==((uintptr_t)0ULL))); + x122 = (x121)^((uintptr_t)18446744073709551615ULL); + x123 = ((x102)&(x121))|((x110)&(x122)); + x124 = x114; + x125 = x117; + x126 = x120; + x127 = x123; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x124, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x125, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x126, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x127, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_from_montgomery(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_secp256k1_scalar_from_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_to_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x1, x2, x3, x0, x7, x14, x16, x12, x10, x18, x11, x8, x27, x29, x26, x24, x31, x25, x22, x21, x13, x34, x15, x28, x36, x17, x30, x38, x19, x32, x40, x20, x9, x33, x23, x48, x50, x47, x45, x52, x46, x43, x4, x35, x56, x37, x49, x58, x39, x51, x60, x41, x53, x69, x71, x68, x66, x73, x67, x64, x63, x55, x76, x57, x70, x78, x59, x72, x80, x61, x74, x82, x62, x42, x54, x44, x75, x65, x90, x92, x89, x87, x94, x88, x85, x5, x77, x98, x79, x91, x100, x81, x93, x102, x83, x95, x111, x113, x110, x108, x115, x109, x106, x105, x97, x118, x99, x112, x120, x101, x114, x122, x103, x116, x124, x104, x84, x96, x86, x117, x107, x132, x134, x131, x129, x136, x130, x127, x6, x119, x140, x121, x133, x142, x123, x135, x144, x125, x137, x153, x155, x152, x150, x157, x151, x148, x147, x139, x160, x141, x154, x162, x143, x156, x164, x145, x158, x166, x146, x126, x138, x128, x159, x149, x170, x172, x168, x174, x161, x177, x169, x178, x163, x180, x171, x181, x165, x183, x173, x184, x176, x167, x186, x175, x187, x179, x182, x185, x188, x189, x190, x191, x192; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x1; + x5 = x2; + x6 = x3; + x7 = x0; + x8 = (x7)*((uintptr_t)11342065889886772165ULL); + x9 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)11342065889886772165ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)11342065889886772165ULL))>>64); + x10 = (x7)*((uintptr_t)16616019711348246470ULL); + x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)16616019711348246470ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)16616019711348246470ULL))>>64); + x12 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)8364476168144746616ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)8364476168144746616ULL))>>64); + x13 = (x7)*((uintptr_t)9902555850136342848ULL); + x14 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)9902555850136342848ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)9902555850136342848ULL))>>64); + x15 = (x14)+((x7)*((uintptr_t)8364476168144746616ULL)); + x16 = ((uintptr_t)((x15)<(x14)))+(x12); + x17 = (x16)+(x10); + x18 = (((uintptr_t)((x16)<(x12)))+((uintptr_t)((x17)<(x10))))+(x11); + x19 = (x18)+(x8); + x20 = ((uintptr_t)((x18)<(x11)))+((uintptr_t)((x19)<(x8))); + x21 = (x13)*((uintptr_t)5408259542528602431ULL); + x22 = (x21)*((uintptr_t)18446744073709551615ULL); + x23 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)18446744073709551615ULL))>>64); + x24 = (x21)*((uintptr_t)18446744073709551614ULL); + x25 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)18446744073709551614ULL))>>64); + x26 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)13451932020343611451ULL))>>64); + x27 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)13822214165235122497ULL))>>64); + x28 = (x27)+((x21)*((uintptr_t)13451932020343611451ULL)); + x29 = ((uintptr_t)((x28)<(x27)))+(x26); + x30 = (x29)+(x24); + x31 = (((uintptr_t)((x29)<(x26)))+((uintptr_t)((x30)<(x24))))+(x25); + x32 = (x31)+(x22); + x33 = ((uintptr_t)((x31)<(x25)))+((uintptr_t)((x32)<(x22))); + x34 = ((uintptr_t)(((x13)+((x21)*((uintptr_t)13822214165235122497ULL)))<(x13)))+(x15); + x35 = (x34)+(x28); + x36 = (((uintptr_t)((x34)<(x15)))+((uintptr_t)((x35)<(x28))))+(x17); + x37 = (x36)+(x30); + x38 = (((uintptr_t)((x36)<(x17)))+((uintptr_t)((x37)<(x30))))+(x19); + x39 = (x38)+(x32); + x40 = (((uintptr_t)((x38)<(x19)))+((uintptr_t)((x39)<(x32))))+((x20)+(x9)); + x41 = (x40)+((x33)+(x23)); + x42 = ((uintptr_t)((x40)<((x20)+(x9))))+((uintptr_t)((x41)<((x33)+(x23)))); + x43 = (x4)*((uintptr_t)11342065889886772165ULL); + x44 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*((uintptr_t)11342065889886772165ULL))>>32 : ((__uint128_t)(x4)*((uintptr_t)11342065889886772165ULL))>>64); + x45 = (x4)*((uintptr_t)16616019711348246470ULL); + x46 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*((uintptr_t)16616019711348246470ULL))>>32 : ((__uint128_t)(x4)*((uintptr_t)16616019711348246470ULL))>>64); + x47 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*((uintptr_t)8364476168144746616ULL))>>32 : ((__uint128_t)(x4)*((uintptr_t)8364476168144746616ULL))>>64); + x48 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x4)*((uintptr_t)9902555850136342848ULL))>>32 : ((__uint128_t)(x4)*((uintptr_t)9902555850136342848ULL))>>64); + x49 = (x48)+((x4)*((uintptr_t)8364476168144746616ULL)); + x50 = ((uintptr_t)((x49)<(x48)))+(x47); + x51 = (x50)+(x45); + x52 = (((uintptr_t)((x50)<(x47)))+((uintptr_t)((x51)<(x45))))+(x46); + x53 = (x52)+(x43); + x54 = ((uintptr_t)((x52)<(x46)))+((uintptr_t)((x53)<(x43))); + x55 = (x35)+((x4)*((uintptr_t)9902555850136342848ULL)); + x56 = ((uintptr_t)((x55)<(x35)))+(x37); + x57 = (x56)+(x49); + x58 = (((uintptr_t)((x56)<(x37)))+((uintptr_t)((x57)<(x49))))+(x39); + x59 = (x58)+(x51); + x60 = (((uintptr_t)((x58)<(x39)))+((uintptr_t)((x59)<(x51))))+(x41); + x61 = (x60)+(x53); + x62 = ((uintptr_t)((x60)<(x41)))+((uintptr_t)((x61)<(x53))); + x63 = (x55)*((uintptr_t)5408259542528602431ULL); + x64 = (x63)*((uintptr_t)18446744073709551615ULL); + x65 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x63)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x63)*((uintptr_t)18446744073709551615ULL))>>64); + x66 = (x63)*((uintptr_t)18446744073709551614ULL); + x67 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x63)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x63)*((uintptr_t)18446744073709551614ULL))>>64); + x68 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x63)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x63)*((uintptr_t)13451932020343611451ULL))>>64); + x69 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x63)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x63)*((uintptr_t)13822214165235122497ULL))>>64); + x70 = (x69)+((x63)*((uintptr_t)13451932020343611451ULL)); + x71 = ((uintptr_t)((x70)<(x69)))+(x68); + x72 = (x71)+(x66); + x73 = (((uintptr_t)((x71)<(x68)))+((uintptr_t)((x72)<(x66))))+(x67); + x74 = (x73)+(x64); + x75 = ((uintptr_t)((x73)<(x67)))+((uintptr_t)((x74)<(x64))); + x76 = ((uintptr_t)(((x55)+((x63)*((uintptr_t)13822214165235122497ULL)))<(x55)))+(x57); + x77 = (x76)+(x70); + x78 = (((uintptr_t)((x76)<(x57)))+((uintptr_t)((x77)<(x70))))+(x59); + x79 = (x78)+(x72); + x80 = (((uintptr_t)((x78)<(x59)))+((uintptr_t)((x79)<(x72))))+(x61); + x81 = (x80)+(x74); + x82 = (((uintptr_t)((x80)<(x61)))+((uintptr_t)((x81)<(x74))))+(((x62)+(x42))+((x54)+(x44))); + x83 = (x82)+((x75)+(x65)); + x84 = ((uintptr_t)((x82)<(((x62)+(x42))+((x54)+(x44)))))+((uintptr_t)((x83)<((x75)+(x65)))); + x85 = (x5)*((uintptr_t)11342065889886772165ULL); + x86 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)11342065889886772165ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)11342065889886772165ULL))>>64); + x87 = (x5)*((uintptr_t)16616019711348246470ULL); + x88 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)16616019711348246470ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)16616019711348246470ULL))>>64); + x89 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)8364476168144746616ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)8364476168144746616ULL))>>64); + x90 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x5)*((uintptr_t)9902555850136342848ULL))>>32 : ((__uint128_t)(x5)*((uintptr_t)9902555850136342848ULL))>>64); + x91 = (x90)+((x5)*((uintptr_t)8364476168144746616ULL)); + x92 = ((uintptr_t)((x91)<(x90)))+(x89); + x93 = (x92)+(x87); + x94 = (((uintptr_t)((x92)<(x89)))+((uintptr_t)((x93)<(x87))))+(x88); + x95 = (x94)+(x85); + x96 = ((uintptr_t)((x94)<(x88)))+((uintptr_t)((x95)<(x85))); + x97 = (x77)+((x5)*((uintptr_t)9902555850136342848ULL)); + x98 = ((uintptr_t)((x97)<(x77)))+(x79); + x99 = (x98)+(x91); + x100 = (((uintptr_t)((x98)<(x79)))+((uintptr_t)((x99)<(x91))))+(x81); + x101 = (x100)+(x93); + x102 = (((uintptr_t)((x100)<(x81)))+((uintptr_t)((x101)<(x93))))+(x83); + x103 = (x102)+(x95); + x104 = ((uintptr_t)((x102)<(x83)))+((uintptr_t)((x103)<(x95))); + x105 = (x97)*((uintptr_t)5408259542528602431ULL); + x106 = (x105)*((uintptr_t)18446744073709551615ULL); + x107 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x105)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x105)*((uintptr_t)18446744073709551615ULL))>>64); + x108 = (x105)*((uintptr_t)18446744073709551614ULL); + x109 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x105)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x105)*((uintptr_t)18446744073709551614ULL))>>64); + x110 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x105)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x105)*((uintptr_t)13451932020343611451ULL))>>64); + x111 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x105)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x105)*((uintptr_t)13822214165235122497ULL))>>64); + x112 = (x111)+((x105)*((uintptr_t)13451932020343611451ULL)); + x113 = ((uintptr_t)((x112)<(x111)))+(x110); + x114 = (x113)+(x108); + x115 = (((uintptr_t)((x113)<(x110)))+((uintptr_t)((x114)<(x108))))+(x109); + x116 = (x115)+(x106); + x117 = ((uintptr_t)((x115)<(x109)))+((uintptr_t)((x116)<(x106))); + x118 = ((uintptr_t)(((x97)+((x105)*((uintptr_t)13822214165235122497ULL)))<(x97)))+(x99); + x119 = (x118)+(x112); + x120 = (((uintptr_t)((x118)<(x99)))+((uintptr_t)((x119)<(x112))))+(x101); + x121 = (x120)+(x114); + x122 = (((uintptr_t)((x120)<(x101)))+((uintptr_t)((x121)<(x114))))+(x103); + x123 = (x122)+(x116); + x124 = (((uintptr_t)((x122)<(x103)))+((uintptr_t)((x123)<(x116))))+(((x104)+(x84))+((x96)+(x86))); + x125 = (x124)+((x117)+(x107)); + x126 = ((uintptr_t)((x124)<(((x104)+(x84))+((x96)+(x86)))))+((uintptr_t)((x125)<((x117)+(x107)))); + x127 = (x6)*((uintptr_t)11342065889886772165ULL); + x128 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)11342065889886772165ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)11342065889886772165ULL))>>64); + x129 = (x6)*((uintptr_t)16616019711348246470ULL); + x130 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)16616019711348246470ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)16616019711348246470ULL))>>64); + x131 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)8364476168144746616ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)8364476168144746616ULL))>>64); + x132 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)9902555850136342848ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)9902555850136342848ULL))>>64); + x133 = (x132)+((x6)*((uintptr_t)8364476168144746616ULL)); + x134 = ((uintptr_t)((x133)<(x132)))+(x131); + x135 = (x134)+(x129); + x136 = (((uintptr_t)((x134)<(x131)))+((uintptr_t)((x135)<(x129))))+(x130); + x137 = (x136)+(x127); + x138 = ((uintptr_t)((x136)<(x130)))+((uintptr_t)((x137)<(x127))); + x139 = (x119)+((x6)*((uintptr_t)9902555850136342848ULL)); + x140 = ((uintptr_t)((x139)<(x119)))+(x121); + x141 = (x140)+(x133); + x142 = (((uintptr_t)((x140)<(x121)))+((uintptr_t)((x141)<(x133))))+(x123); + x143 = (x142)+(x135); + x144 = (((uintptr_t)((x142)<(x123)))+((uintptr_t)((x143)<(x135))))+(x125); + x145 = (x144)+(x137); + x146 = ((uintptr_t)((x144)<(x125)))+((uintptr_t)((x145)<(x137))); + x147 = (x139)*((uintptr_t)5408259542528602431ULL); + x148 = (x147)*((uintptr_t)18446744073709551615ULL); + x149 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)18446744073709551615ULL))>>64); + x150 = (x147)*((uintptr_t)18446744073709551614ULL); + x151 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)18446744073709551614ULL))>>64); + x152 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)13451932020343611451ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)13451932020343611451ULL))>>64); + x153 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x147)*((uintptr_t)13822214165235122497ULL))>>32 : ((__uint128_t)(x147)*((uintptr_t)13822214165235122497ULL))>>64); + x154 = (x153)+((x147)*((uintptr_t)13451932020343611451ULL)); + x155 = ((uintptr_t)((x154)<(x153)))+(x152); + x156 = (x155)+(x150); + x157 = (((uintptr_t)((x155)<(x152)))+((uintptr_t)((x156)<(x150))))+(x151); + x158 = (x157)+(x148); + x159 = ((uintptr_t)((x157)<(x151)))+((uintptr_t)((x158)<(x148))); + x160 = ((uintptr_t)(((x139)+((x147)*((uintptr_t)13822214165235122497ULL)))<(x139)))+(x141); + x161 = (x160)+(x154); + x162 = (((uintptr_t)((x160)<(x141)))+((uintptr_t)((x161)<(x154))))+(x143); + x163 = (x162)+(x156); + x164 = (((uintptr_t)((x162)<(x143)))+((uintptr_t)((x163)<(x156))))+(x145); + x165 = (x164)+(x158); + x166 = (((uintptr_t)((x164)<(x145)))+((uintptr_t)((x165)<(x158))))+(((x146)+(x126))+((x138)+(x128))); + x167 = (x166)+((x159)+(x149)); + x168 = ((uintptr_t)((x166)<(((x146)+(x126))+((x138)+(x128)))))+((uintptr_t)((x167)<((x159)+(x149)))); + x169 = (x161)-((uintptr_t)13822214165235122497ULL); + x170 = (x163)-((uintptr_t)13451932020343611451ULL); + x171 = (x170)-((uintptr_t)((x161)<(x169))); + x172 = (x165)-((uintptr_t)18446744073709551614ULL); + x173 = (x172)-(((uintptr_t)((x163)<(x170)))+((uintptr_t)((x170)<(x171)))); + x174 = (x167)-((uintptr_t)18446744073709551615ULL); + x175 = (x174)-(((uintptr_t)((x165)<(x172)))+((uintptr_t)((x172)<(x173)))); + x176 = (uintptr_t)((x168)<((x168)-(((uintptr_t)((x167)<(x174)))+((uintptr_t)((x174)<(x175)))))); + x177 = ((uintptr_t)-1ULL)+((uintptr_t)((x176)==((uintptr_t)0ULL))); + x178 = (x177)^((uintptr_t)18446744073709551615ULL); + x179 = ((x161)&(x177))|((x169)&(x178)); + x180 = ((uintptr_t)-1ULL)+((uintptr_t)((x176)==((uintptr_t)0ULL))); + x181 = (x180)^((uintptr_t)18446744073709551615ULL); + x182 = ((x163)&(x180))|((x171)&(x181)); + x183 = ((uintptr_t)-1ULL)+((uintptr_t)((x176)==((uintptr_t)0ULL))); + x184 = (x183)^((uintptr_t)18446744073709551615ULL); + x185 = ((x165)&(x183))|((x173)&(x184)); + x186 = ((uintptr_t)-1ULL)+((uintptr_t)((x176)==((uintptr_t)0ULL))); + x187 = (x186)^((uintptr_t)18446744073709551615ULL); + x188 = ((x167)&(x186))|((x175)&(x187)); + x189 = x179; + x190 = x182; + x191 = x185; + x192 = x188; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x189, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x190, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x191, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x192, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_to_montgomery(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_secp256k1_scalar_to_montgomery((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffffffffffff] + */ +static +uintptr_t internal_fiat_secp256k1_scalar_nonzero(uintptr_t in0) { + uintptr_t x0, x1, x2, x3, x4, out0, x5; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = (x0)|((x1)|((x2)|(x3))); + x5 = x4; + out0 = x5; + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_nonzero(uint64_t* out1, const uint64_t arg1[4]) { + *out1 = (uint64_t)internal_fiat_secp256k1_scalar_nonzero((uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0x1] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_selectznz(uintptr_t out0, uintptr_t in0, uintptr_t in1, uintptr_t in2) { + uintptr_t x4, x8, x0, x9, x5, x11, x1, x12, x6, x14, x2, x15, x7, x17, x3, x18, x10, x13, x16, x19, x20, x21, x22, x23; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x5 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x6 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x7 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x9 = (x8)^((uintptr_t)18446744073709551615ULL); + x10 = ((x4)&(x8))|((x0)&(x9)); + x11 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x12 = (x11)^((uintptr_t)18446744073709551615ULL); + x13 = ((x5)&(x11))|((x1)&(x12)); + x14 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x15 = (x14)^((uintptr_t)18446744073709551615ULL); + x16 = ((x6)&(x14))|((x2)&(x15)); + x17 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL))); + x18 = (x17)^((uintptr_t)18446744073709551615ULL); + x19 = ((x7)&(x17))|((x3)&(x18)); + x20 = x10; + x21 = x13; + x22 = x16; + x23 = x19; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x20, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x21, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x22, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x23, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_selectznz(uint64_t out1[4], uint8_t arg1, const uint64_t arg2[4], const uint64_t arg3[4]) { + internal_fiat_secp256k1_scalar_selectznz((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static +void internal_fiat_secp256k1_scalar_to_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x3, x2, x1, x0, x7, x9, x11, x13, x15, x17, x19, x6, x23, x25, x27, x29, x31, x33, x5, x37, x39, x41, x43, x45, x47, x4, x51, x53, x55, x57, x59, x61, x8, x10, x12, x14, x16, x18, x20, x21, x22, x24, x26, x28, x30, x32, x34, x35, x36, x38, x40, x42, x44, x46, x48, x49, x50, x52, x54, x56, x58, x60, x62, x63, x64, x65, x66, x67, x68, x69, x70, x71, x72, x73, x74, x75, x76, x77, x78, x79, x80, x81, x82, x83, x84, x85, x86, x87, x88, x89, x90, x91, x92, x93, x94, x95; + x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x3; + x5 = x2; + x6 = x1; + x7 = x0; + x8 = (x7)&((uintptr_t)255ULL); + x9 = (x7)>>((uintptr_t)8ULL); + x10 = (x9)&((uintptr_t)255ULL); + x11 = (x9)>>((uintptr_t)8ULL); + x12 = (x11)&((uintptr_t)255ULL); + x13 = (x11)>>((uintptr_t)8ULL); + x14 = (x13)&((uintptr_t)255ULL); + x15 = (x13)>>((uintptr_t)8ULL); + x16 = (x15)&((uintptr_t)255ULL); + x17 = (x15)>>((uintptr_t)8ULL); + x18 = (x17)&((uintptr_t)255ULL); + x19 = (x17)>>((uintptr_t)8ULL); + x20 = (x19)&((uintptr_t)255ULL); + x21 = (x19)>>((uintptr_t)8ULL); + x22 = (x6)&((uintptr_t)255ULL); + x23 = (x6)>>((uintptr_t)8ULL); + x24 = (x23)&((uintptr_t)255ULL); + x25 = (x23)>>((uintptr_t)8ULL); + x26 = (x25)&((uintptr_t)255ULL); + x27 = (x25)>>((uintptr_t)8ULL); + x28 = (x27)&((uintptr_t)255ULL); + x29 = (x27)>>((uintptr_t)8ULL); + x30 = (x29)&((uintptr_t)255ULL); + x31 = (x29)>>((uintptr_t)8ULL); + x32 = (x31)&((uintptr_t)255ULL); + x33 = (x31)>>((uintptr_t)8ULL); + x34 = (x33)&((uintptr_t)255ULL); + x35 = (x33)>>((uintptr_t)8ULL); + x36 = (x5)&((uintptr_t)255ULL); + x37 = (x5)>>((uintptr_t)8ULL); + x38 = (x37)&((uintptr_t)255ULL); + x39 = (x37)>>((uintptr_t)8ULL); + x40 = (x39)&((uintptr_t)255ULL); + x41 = (x39)>>((uintptr_t)8ULL); + x42 = (x41)&((uintptr_t)255ULL); + x43 = (x41)>>((uintptr_t)8ULL); + x44 = (x43)&((uintptr_t)255ULL); + x45 = (x43)>>((uintptr_t)8ULL); + x46 = (x45)&((uintptr_t)255ULL); + x47 = (x45)>>((uintptr_t)8ULL); + x48 = (x47)&((uintptr_t)255ULL); + x49 = (x47)>>((uintptr_t)8ULL); + x50 = (x4)&((uintptr_t)255ULL); + x51 = (x4)>>((uintptr_t)8ULL); + x52 = (x51)&((uintptr_t)255ULL); + x53 = (x51)>>((uintptr_t)8ULL); + x54 = (x53)&((uintptr_t)255ULL); + x55 = (x53)>>((uintptr_t)8ULL); + x56 = (x55)&((uintptr_t)255ULL); + x57 = (x55)>>((uintptr_t)8ULL); + x58 = (x57)&((uintptr_t)255ULL); + x59 = (x57)>>((uintptr_t)8ULL); + x60 = (x59)&((uintptr_t)255ULL); + x61 = (x59)>>((uintptr_t)8ULL); + x62 = (x61)&((uintptr_t)255ULL); + x63 = (x61)>>((uintptr_t)8ULL); + x64 = x8; + x65 = x10; + x66 = x12; + x67 = x14; + x68 = x16; + x69 = x18; + x70 = x20; + x71 = x21; + x72 = x22; + x73 = x24; + x74 = x26; + x75 = x28; + x76 = x30; + x77 = x32; + x78 = x34; + x79 = x35; + x80 = x36; + x81 = x38; + x82 = x40; + x83 = x42; + x84 = x44; + x85 = x46; + x86 = x48; + x87 = x49; + x88 = x50; + x89 = x52; + x90 = x54; + x91 = x56; + x92 = x58; + x93 = x60; + x94 = x62; + x95 = x63; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x64, 1); + _br2_store((out0)+((uintptr_t)1ULL), x65, 1); + _br2_store((out0)+((uintptr_t)2ULL), x66, 1); + _br2_store((out0)+((uintptr_t)3ULL), x67, 1); + _br2_store((out0)+((uintptr_t)4ULL), x68, 1); + _br2_store((out0)+((uintptr_t)5ULL), x69, 1); + _br2_store((out0)+((uintptr_t)6ULL), x70, 1); + _br2_store((out0)+((uintptr_t)7ULL), x71, 1); + _br2_store((out0)+((uintptr_t)8ULL), x72, 1); + _br2_store((out0)+((uintptr_t)9ULL), x73, 1); + _br2_store((out0)+((uintptr_t)10ULL), x74, 1); + _br2_store((out0)+((uintptr_t)11ULL), x75, 1); + _br2_store((out0)+((uintptr_t)12ULL), x76, 1); + _br2_store((out0)+((uintptr_t)13ULL), x77, 1); + _br2_store((out0)+((uintptr_t)14ULL), x78, 1); + _br2_store((out0)+((uintptr_t)15ULL), x79, 1); + _br2_store((out0)+((uintptr_t)16ULL), x80, 1); + _br2_store((out0)+((uintptr_t)17ULL), x81, 1); + _br2_store((out0)+((uintptr_t)18ULL), x82, 1); + _br2_store((out0)+((uintptr_t)19ULL), x83, 1); + _br2_store((out0)+((uintptr_t)20ULL), x84, 1); + _br2_store((out0)+((uintptr_t)21ULL), x85, 1); + _br2_store((out0)+((uintptr_t)22ULL), x86, 1); + _br2_store((out0)+((uintptr_t)23ULL), x87, 1); + _br2_store((out0)+((uintptr_t)24ULL), x88, 1); + _br2_store((out0)+((uintptr_t)25ULL), x89, 1); + _br2_store((out0)+((uintptr_t)26ULL), x90, 1); + _br2_store((out0)+((uintptr_t)27ULL), x91, 1); + _br2_store((out0)+((uintptr_t)28ULL), x92, 1); + _br2_store((out0)+((uintptr_t)29ULL), x93, 1); + _br2_store((out0)+((uintptr_t)30ULL), x94, 1); + _br2_store((out0)+((uintptr_t)31ULL), x95, 1); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_to_bytes(uint8_t out1[32], const uint64_t arg1[4]) { + internal_fiat_secp256k1_scalar_to_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * in0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_from_bytes(uintptr_t out0, uintptr_t in0) { + uintptr_t x31, x30, x29, x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x12, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0, x62, x63, x61, x64, x60, x65, x59, x66, x58, x67, x57, x68, x56, x69, x54, x55, x53, x71, x52, x72, x51, x73, x50, x74, x49, x75, x48, x76, x46, x47, x45, x78, x44, x79, x43, x80, x42, x81, x41, x82, x40, x83, x38, x39, x37, x85, x36, x86, x35, x87, x34, x88, x33, x89, x32, x90, x70, x77, x84, x91, x92, x93, x94, x95; + x0 = _br2_load((in0)+((uintptr_t)0ULL), 1); + x1 = _br2_load((in0)+((uintptr_t)1ULL), 1); + x2 = _br2_load((in0)+((uintptr_t)2ULL), 1); + x3 = _br2_load((in0)+((uintptr_t)3ULL), 1); + x4 = _br2_load((in0)+((uintptr_t)4ULL), 1); + x5 = _br2_load((in0)+((uintptr_t)5ULL), 1); + x6 = _br2_load((in0)+((uintptr_t)6ULL), 1); + x7 = _br2_load((in0)+((uintptr_t)7ULL), 1); + x8 = _br2_load((in0)+((uintptr_t)8ULL), 1); + x9 = _br2_load((in0)+((uintptr_t)9ULL), 1); + x10 = _br2_load((in0)+((uintptr_t)10ULL), 1); + x11 = _br2_load((in0)+((uintptr_t)11ULL), 1); + x12 = _br2_load((in0)+((uintptr_t)12ULL), 1); + x13 = _br2_load((in0)+((uintptr_t)13ULL), 1); + x14 = _br2_load((in0)+((uintptr_t)14ULL), 1); + x15 = _br2_load((in0)+((uintptr_t)15ULL), 1); + x16 = _br2_load((in0)+((uintptr_t)16ULL), 1); + x17 = _br2_load((in0)+((uintptr_t)17ULL), 1); + x18 = _br2_load((in0)+((uintptr_t)18ULL), 1); + x19 = _br2_load((in0)+((uintptr_t)19ULL), 1); + x20 = _br2_load((in0)+((uintptr_t)20ULL), 1); + x21 = _br2_load((in0)+((uintptr_t)21ULL), 1); + x22 = _br2_load((in0)+((uintptr_t)22ULL), 1); + x23 = _br2_load((in0)+((uintptr_t)23ULL), 1); + x24 = _br2_load((in0)+((uintptr_t)24ULL), 1); + x25 = _br2_load((in0)+((uintptr_t)25ULL), 1); + x26 = _br2_load((in0)+((uintptr_t)26ULL), 1); + x27 = _br2_load((in0)+((uintptr_t)27ULL), 1); + x28 = _br2_load((in0)+((uintptr_t)28ULL), 1); + x29 = _br2_load((in0)+((uintptr_t)29ULL), 1); + x30 = _br2_load((in0)+((uintptr_t)30ULL), 1); + x31 = _br2_load((in0)+((uintptr_t)31ULL), 1); + /*skip*/ + /*skip*/ + x32 = (x31)<<((uintptr_t)56ULL); + x33 = (x30)<<((uintptr_t)48ULL); + x34 = (x29)<<((uintptr_t)40ULL); + x35 = (x28)<<((uintptr_t)32ULL); + x36 = (x27)<<((uintptr_t)24ULL); + x37 = (x26)<<((uintptr_t)16ULL); + x38 = (x25)<<((uintptr_t)8ULL); + x39 = x24; + x40 = (x23)<<((uintptr_t)56ULL); + x41 = (x22)<<((uintptr_t)48ULL); + x42 = (x21)<<((uintptr_t)40ULL); + x43 = (x20)<<((uintptr_t)32ULL); + x44 = (x19)<<((uintptr_t)24ULL); + x45 = (x18)<<((uintptr_t)16ULL); + x46 = (x17)<<((uintptr_t)8ULL); + x47 = x16; + x48 = (x15)<<((uintptr_t)56ULL); + x49 = (x14)<<((uintptr_t)48ULL); + x50 = (x13)<<((uintptr_t)40ULL); + x51 = (x12)<<((uintptr_t)32ULL); + x52 = (x11)<<((uintptr_t)24ULL); + x53 = (x10)<<((uintptr_t)16ULL); + x54 = (x9)<<((uintptr_t)8ULL); + x55 = x8; + x56 = (x7)<<((uintptr_t)56ULL); + x57 = (x6)<<((uintptr_t)48ULL); + x58 = (x5)<<((uintptr_t)40ULL); + x59 = (x4)<<((uintptr_t)32ULL); + x60 = (x3)<<((uintptr_t)24ULL); + x61 = (x2)<<((uintptr_t)16ULL); + x62 = (x1)<<((uintptr_t)8ULL); + x63 = x0; + x64 = (x62)+(x63); + x65 = (x61)+(x64); + x66 = (x60)+(x65); + x67 = (x59)+(x66); + x68 = (x58)+(x67); + x69 = (x57)+(x68); + x70 = (x56)+(x69); + x71 = (x54)+(x55); + x72 = (x53)+(x71); + x73 = (x52)+(x72); + x74 = (x51)+(x73); + x75 = (x50)+(x74); + x76 = (x49)+(x75); + x77 = (x48)+(x76); + x78 = (x46)+(x47); + x79 = (x45)+(x78); + x80 = (x44)+(x79); + x81 = (x43)+(x80); + x82 = (x42)+(x81); + x83 = (x41)+(x82); + x84 = (x40)+(x83); + x85 = (x38)+(x39); + x86 = (x37)+(x85); + x87 = (x36)+(x86); + x88 = (x35)+(x87); + x89 = (x34)+(x88); + x90 = (x33)+(x89); + x91 = (x32)+(x90); + x92 = x70; + x93 = x77; + x94 = x84; + x95 = x91; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x92, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x93, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x94, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x95, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_from_bytes(uint64_t out1[4], const uint8_t arg1[32]) { + internal_fiat_secp256k1_scalar_from_bytes((uintptr_t)out1, (uintptr_t)arg1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_set_one(uintptr_t out0) { + uintptr_t x0, x1, x2, x3; + /*skip*/ + x0 = (uintptr_t)4624529908474429119ULL; + x1 = (uintptr_t)4994812053365940164ULL; + x2 = (uintptr_t)1ULL; + x3 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_set_one(uint64_t out1[4]) { + internal_fiat_secp256k1_scalar_set_one((uintptr_t)out1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_msat(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4; + /*skip*/ + x0 = (uintptr_t)13822214165235122497ULL; + x1 = (uintptr_t)13451932020343611451ULL; + x2 = (uintptr_t)18446744073709551614ULL; + x3 = (uintptr_t)18446744073709551615ULL; + x4 = (uintptr_t)0ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)32ULL), x4, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_msat(uint64_t out1[5]) { + internal_fiat_secp256k1_scalar_msat((uintptr_t)out1); +} + + +/* + * Input Bounds: + * in0: [0x0 ~> 0xffffffffffffffff] + * in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * in4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out0: [0x0 ~> 0xffffffffffffffff] + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +uintptr_t internal_fiat_secp256k1_scalar_divstep(uintptr_t out1, uintptr_t out2, uintptr_t out3, uintptr_t out4, uintptr_t in0, uintptr_t in1, uintptr_t in2, uintptr_t in3, uintptr_t in4) { + uintptr_t x18, x20, x21, x22, x24, x25, x27, x28, x30, x31, x33, x34, x36, x37, x0, x40, x1, x42, x2, x44, x3, x46, x4, x39, x48, x5, x49, x41, x51, x6, x52, x43, x54, x7, x55, x45, x57, x8, x58, x47, x60, x9, x61, x63, x64, x66, x67, x69, x70, x72, x73, x76, x77, x78, x80, x81, x82, x83, x85, x86, x87, x88, x90, x93, x94, x95, x97, x98, x99, x100, x102, x103, x104, x105, x107, x108, x91, x109, x13, x12, x11, x10, x115, x113, x116, x118, x119, x112, x120, x122, x123, x111, x124, x126, x127, x114, x130, x117, x131, x132, x134, x135, x121, x136, x137, x139, x140, x125, x141, x128, x129, x143, x14, x144, x133, x146, x15, x147, x138, x149, x16, x150, x19, x142, x152, x17, x153, x156, x157, x159, x160, x162, x163, x165, x166, x168, x169, x158, x50, x172, x53, x173, x161, x174, x176, x177, x56, x178, x164, x179, x181, x182, x59, x183, x167, x184, x186, x187, x62, x188, x170, x65, x190, x191, x68, x193, x194, x71, x196, x197, x155, x74, x199, x200, x192, x145, x203, x148, x204, x195, x205, x207, x208, x151, x209, x198, x210, x212, x213, x154, x214, x201, x215, x217, x220, x221, x222, x224, x225, x226, x227, x229, x230, x231, x232, x234, x235, x218, x236, x23, x171, x175, x180, x185, x189, x75, x244, x92, x245, x79, x247, x96, x248, x84, x250, x101, x251, x110, x89, x253, x106, x254, x202, x256, x219, x257, x206, x259, x223, x260, x211, x262, x228, x263, x237, x216, x265, x233, x266, x238, x26, x29, x32, x35, x38, x239, x240, x241, x242, x243, x246, x249, x252, x255, x258, x261, x264, x267, out0, x268, x269, x270, x271, x272, x273, x274, x275, x276, x277, x278, x279, x280, x281, x282, x283, x284, x285, x286; + /*skip*/ + x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t)); + /*skip*/ + x5 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x6 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x7 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x8 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t)); + x9 = _br2_load((in2)+((uintptr_t)32ULL), sizeof(uintptr_t)); + /*skip*/ + x10 = _br2_load((in3)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x11 = _br2_load((in3)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x12 = _br2_load((in3)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x13 = _br2_load((in3)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + x14 = _br2_load((in4)+((uintptr_t)0ULL), sizeof(uintptr_t)); + x15 = _br2_load((in4)+((uintptr_t)8ULL), sizeof(uintptr_t)); + x16 = _br2_load((in4)+((uintptr_t)16ULL), sizeof(uintptr_t)); + x17 = _br2_load((in4)+((uintptr_t)24ULL), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x18 = ((in0)^((uintptr_t)18446744073709551615ULL))+((uintptr_t)1ULL); + x19 = ((x18)>>((uintptr_t)63ULL))&((x5)&((uintptr_t)1ULL)); + x20 = ((in0)^((uintptr_t)18446744073709551615ULL))+((uintptr_t)1ULL); + x21 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x22 = (x21)^((uintptr_t)18446744073709551615ULL); + x23 = ((x20)&(x21))|((in0)&(x22)); + x24 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x25 = (x24)^((uintptr_t)18446744073709551615ULL); + x26 = ((x5)&(x24))|((x0)&(x25)); + x27 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x28 = (x27)^((uintptr_t)18446744073709551615ULL); + x29 = ((x6)&(x27))|((x1)&(x28)); + x30 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x31 = (x30)^((uintptr_t)18446744073709551615ULL); + x32 = ((x7)&(x30))|((x2)&(x31)); + x33 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x34 = (x33)^((uintptr_t)18446744073709551615ULL); + x35 = ((x8)&(x33))|((x3)&(x34)); + x36 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x37 = (x36)^((uintptr_t)18446744073709551615ULL); + x38 = ((x9)&(x36))|((x4)&(x37)); + x39 = ((uintptr_t)1ULL)+((x0)^((uintptr_t)18446744073709551615ULL)); + x40 = (uintptr_t)((x39)<((uintptr_t)1ULL)); + x41 = (x40)+((x1)^((uintptr_t)18446744073709551615ULL)); + x42 = (uintptr_t)((x41)<((x1)^((uintptr_t)18446744073709551615ULL))); + x43 = (x42)+((x2)^((uintptr_t)18446744073709551615ULL)); + x44 = (uintptr_t)((x43)<((x2)^((uintptr_t)18446744073709551615ULL))); + x45 = (x44)+((x3)^((uintptr_t)18446744073709551615ULL)); + x46 = (uintptr_t)((x45)<((x3)^((uintptr_t)18446744073709551615ULL))); + x47 = (x46)+((x4)^((uintptr_t)18446744073709551615ULL)); + x48 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x49 = (x48)^((uintptr_t)18446744073709551615ULL); + x50 = ((x39)&(x48))|((x5)&(x49)); + x51 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x52 = (x51)^((uintptr_t)18446744073709551615ULL); + x53 = ((x41)&(x51))|((x6)&(x52)); + x54 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x55 = (x54)^((uintptr_t)18446744073709551615ULL); + x56 = ((x43)&(x54))|((x7)&(x55)); + x57 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x58 = (x57)^((uintptr_t)18446744073709551615ULL); + x59 = ((x45)&(x57))|((x8)&(x58)); + x60 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x61 = (x60)^((uintptr_t)18446744073709551615ULL); + x62 = ((x47)&(x60))|((x9)&(x61)); + x63 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x64 = (x63)^((uintptr_t)18446744073709551615ULL); + x65 = ((x14)&(x63))|((x10)&(x64)); + x66 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x67 = (x66)^((uintptr_t)18446744073709551615ULL); + x68 = ((x15)&(x66))|((x11)&(x67)); + x69 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x70 = (x69)^((uintptr_t)18446744073709551615ULL); + x71 = ((x16)&(x69))|((x12)&(x70)); + x72 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x73 = (x72)^((uintptr_t)18446744073709551615ULL); + x74 = ((x17)&(x72))|((x13)&(x73)); + x75 = (x65)+(x65); + x76 = (uintptr_t)((x75)<(x65)); + x77 = (x76)+(x68); + x78 = (uintptr_t)((x77)<(x68)); + x79 = (x77)+(x68); + x80 = (uintptr_t)((x79)<(x68)); + x81 = (x78)+(x80); + x82 = (x81)+(x71); + x83 = (uintptr_t)((x82)<(x71)); + x84 = (x82)+(x71); + x85 = (uintptr_t)((x84)<(x71)); + x86 = (x83)+(x85); + x87 = (x86)+(x74); + x88 = (uintptr_t)((x87)<(x74)); + x89 = (x87)+(x74); + x90 = (uintptr_t)((x89)<(x74)); + x91 = (x88)+(x90); + x92 = (x75)-((uintptr_t)13822214165235122497ULL); + x93 = (uintptr_t)((x75)<(x92)); + x94 = (x79)-((uintptr_t)13451932020343611451ULL); + x95 = (uintptr_t)((x79)<(x94)); + x96 = (x94)-(x93); + x97 = (uintptr_t)((x94)<(x96)); + x98 = (x95)+(x97); + x99 = (x84)-((uintptr_t)18446744073709551614ULL); + x100 = (uintptr_t)((x84)<(x99)); + x101 = (x99)-(x98); + x102 = (uintptr_t)((x99)<(x101)); + x103 = (x100)+(x102); + x104 = (x89)-((uintptr_t)18446744073709551615ULL); + x105 = (uintptr_t)((x89)<(x104)); + x106 = (x104)-(x103); + x107 = (uintptr_t)((x104)<(x106)); + x108 = (x105)+(x107); + x109 = (x91)-(x108); + x110 = (uintptr_t)((x91)<(x109)); + x111 = x13; + x112 = x12; + x113 = x11; + x114 = x10; + x115 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x114))); + x116 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x113))); + x117 = (((uintptr_t)0ULL)-(x113))-(x115); + x118 = (uintptr_t)((((uintptr_t)0ULL)-(x113))<(x117)); + x119 = (x116)+(x118); + x120 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x112))); + x121 = (((uintptr_t)0ULL)-(x112))-(x119); + x122 = (uintptr_t)((((uintptr_t)0ULL)-(x112))<(x121)); + x123 = (x120)+(x122); + x124 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x111))); + x125 = (((uintptr_t)0ULL)-(x111))-(x123); + x126 = (uintptr_t)((((uintptr_t)0ULL)-(x111))<(x125)); + x127 = (x124)+(x126); + x128 = ((uintptr_t)-1ULL)+((uintptr_t)((x127)==((uintptr_t)0ULL))); + x129 = (((uintptr_t)0ULL)-(x114))+((x128)&((uintptr_t)13822214165235122497ULL)); + x130 = (uintptr_t)((x129)<(((uintptr_t)0ULL)-(x114))); + x131 = (x130)+(x117); + x132 = (uintptr_t)((x131)<(x117)); + x133 = (x131)+((x128)&((uintptr_t)13451932020343611451ULL)); + x134 = (uintptr_t)((x133)<((x128)&((uintptr_t)13451932020343611451ULL))); + x135 = (x132)+(x134); + x136 = (x135)+(x121); + x137 = (uintptr_t)((x136)<(x121)); + x138 = (x136)+((x128)&((uintptr_t)18446744073709551614ULL)); + x139 = (uintptr_t)((x138)<((x128)&((uintptr_t)18446744073709551614ULL))); + x140 = (x137)+(x139); + x141 = (x140)+(x125); + x142 = (x141)+(x128); + x143 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x144 = (x143)^((uintptr_t)18446744073709551615ULL); + x145 = ((x129)&(x143))|((x14)&(x144)); + x146 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x147 = (x146)^((uintptr_t)18446744073709551615ULL); + x148 = ((x133)&(x146))|((x15)&(x147)); + x149 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x150 = (x149)^((uintptr_t)18446744073709551615ULL); + x151 = ((x138)&(x149))|((x16)&(x150)); + x152 = ((uintptr_t)-1ULL)+((uintptr_t)((x19)==((uintptr_t)0ULL))); + x153 = (x152)^((uintptr_t)18446744073709551615ULL); + x154 = ((x142)&(x152))|((x17)&(x153)); + x155 = (x50)&((uintptr_t)1ULL); + x156 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x157 = (x156)^((uintptr_t)18446744073709551615ULL); + x158 = ((x26)&(x156))|(((uintptr_t)0ULL)&(x157)); + x159 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x160 = (x159)^((uintptr_t)18446744073709551615ULL); + x161 = ((x29)&(x159))|(((uintptr_t)0ULL)&(x160)); + x162 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x163 = (x162)^((uintptr_t)18446744073709551615ULL); + x164 = ((x32)&(x162))|(((uintptr_t)0ULL)&(x163)); + x165 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x166 = (x165)^((uintptr_t)18446744073709551615ULL); + x167 = ((x35)&(x165))|(((uintptr_t)0ULL)&(x166)); + x168 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x169 = (x168)^((uintptr_t)18446744073709551615ULL); + x170 = ((x38)&(x168))|(((uintptr_t)0ULL)&(x169)); + x171 = (x50)+(x158); + x172 = (uintptr_t)((x171)<(x50)); + x173 = (x172)+(x53); + x174 = (uintptr_t)((x173)<(x53)); + x175 = (x173)+(x161); + x176 = (uintptr_t)((x175)<(x161)); + x177 = (x174)+(x176); + x178 = (x177)+(x56); + x179 = (uintptr_t)((x178)<(x56)); + x180 = (x178)+(x164); + x181 = (uintptr_t)((x180)<(x164)); + x182 = (x179)+(x181); + x183 = (x182)+(x59); + x184 = (uintptr_t)((x183)<(x59)); + x185 = (x183)+(x167); + x186 = (uintptr_t)((x185)<(x167)); + x187 = (x184)+(x186); + x188 = (x187)+(x62); + x189 = (x188)+(x170); + x190 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x191 = (x190)^((uintptr_t)18446744073709551615ULL); + x192 = ((x65)&(x190))|(((uintptr_t)0ULL)&(x191)); + x193 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x194 = (x193)^((uintptr_t)18446744073709551615ULL); + x195 = ((x68)&(x193))|(((uintptr_t)0ULL)&(x194)); + x196 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x197 = (x196)^((uintptr_t)18446744073709551615ULL); + x198 = ((x71)&(x196))|(((uintptr_t)0ULL)&(x197)); + x199 = ((uintptr_t)-1ULL)+((uintptr_t)((x155)==((uintptr_t)0ULL))); + x200 = (x199)^((uintptr_t)18446744073709551615ULL); + x201 = ((x74)&(x199))|(((uintptr_t)0ULL)&(x200)); + x202 = (x145)+(x192); + x203 = (uintptr_t)((x202)<(x145)); + x204 = (x203)+(x148); + x205 = (uintptr_t)((x204)<(x148)); + x206 = (x204)+(x195); + x207 = (uintptr_t)((x206)<(x195)); + x208 = (x205)+(x207); + x209 = (x208)+(x151); + x210 = (uintptr_t)((x209)<(x151)); + x211 = (x209)+(x198); + x212 = (uintptr_t)((x211)<(x198)); + x213 = (x210)+(x212); + x214 = (x213)+(x154); + x215 = (uintptr_t)((x214)<(x154)); + x216 = (x214)+(x201); + x217 = (uintptr_t)((x216)<(x201)); + x218 = (x215)+(x217); + x219 = (x202)-((uintptr_t)13822214165235122497ULL); + x220 = (uintptr_t)((x202)<(x219)); + x221 = (x206)-((uintptr_t)13451932020343611451ULL); + x222 = (uintptr_t)((x206)<(x221)); + x223 = (x221)-(x220); + x224 = (uintptr_t)((x221)<(x223)); + x225 = (x222)+(x224); + x226 = (x211)-((uintptr_t)18446744073709551614ULL); + x227 = (uintptr_t)((x211)<(x226)); + x228 = (x226)-(x225); + x229 = (uintptr_t)((x226)<(x228)); + x230 = (x227)+(x229); + x231 = (x216)-((uintptr_t)18446744073709551615ULL); + x232 = (uintptr_t)((x216)<(x231)); + x233 = (x231)-(x230); + x234 = (uintptr_t)((x231)<(x233)); + x235 = (x232)+(x234); + x236 = (x218)-(x235); + x237 = (uintptr_t)((x218)<(x236)); + x238 = (x23)+((uintptr_t)1ULL); + x239 = ((x171)>>((uintptr_t)1ULL))|((x175)<<((uintptr_t)63ULL)); + x240 = ((x175)>>((uintptr_t)1ULL))|((x180)<<((uintptr_t)63ULL)); + x241 = ((x180)>>((uintptr_t)1ULL))|((x185)<<((uintptr_t)63ULL)); + x242 = ((x185)>>((uintptr_t)1ULL))|((x189)<<((uintptr_t)63ULL)); + x243 = ((x189)&((uintptr_t)9223372036854775808ULL))|((x189)>>((uintptr_t)1ULL)); + x244 = ((uintptr_t)-1ULL)+((uintptr_t)((x110)==((uintptr_t)0ULL))); + x245 = (x244)^((uintptr_t)18446744073709551615ULL); + x246 = ((x75)&(x244))|((x92)&(x245)); + x247 = ((uintptr_t)-1ULL)+((uintptr_t)((x110)==((uintptr_t)0ULL))); + x248 = (x247)^((uintptr_t)18446744073709551615ULL); + x249 = ((x79)&(x247))|((x96)&(x248)); + x250 = ((uintptr_t)-1ULL)+((uintptr_t)((x110)==((uintptr_t)0ULL))); + x251 = (x250)^((uintptr_t)18446744073709551615ULL); + x252 = ((x84)&(x250))|((x101)&(x251)); + x253 = ((uintptr_t)-1ULL)+((uintptr_t)((x110)==((uintptr_t)0ULL))); + x254 = (x253)^((uintptr_t)18446744073709551615ULL); + x255 = ((x89)&(x253))|((x106)&(x254)); + x256 = ((uintptr_t)-1ULL)+((uintptr_t)((x237)==((uintptr_t)0ULL))); + x257 = (x256)^((uintptr_t)18446744073709551615ULL); + x258 = ((x202)&(x256))|((x219)&(x257)); + x259 = ((uintptr_t)-1ULL)+((uintptr_t)((x237)==((uintptr_t)0ULL))); + x260 = (x259)^((uintptr_t)18446744073709551615ULL); + x261 = ((x206)&(x259))|((x223)&(x260)); + x262 = ((uintptr_t)-1ULL)+((uintptr_t)((x237)==((uintptr_t)0ULL))); + x263 = (x262)^((uintptr_t)18446744073709551615ULL); + x264 = ((x211)&(x262))|((x228)&(x263)); + x265 = ((uintptr_t)-1ULL)+((uintptr_t)((x237)==((uintptr_t)0ULL))); + x266 = (x265)^((uintptr_t)18446744073709551615ULL); + x267 = ((x216)&(x265))|((x233)&(x266)); + x268 = x238; + x269 = x26; + x270 = x29; + x271 = x32; + x272 = x35; + x273 = x38; + /*skip*/ + x274 = x239; + x275 = x240; + x276 = x241; + x277 = x242; + x278 = x243; + /*skip*/ + x279 = x246; + x280 = x249; + x281 = x252; + x282 = x255; + /*skip*/ + x283 = x258; + x284 = x261; + x285 = x264; + x286 = x267; + /*skip*/ + out0 = x268; + _br2_store((out1)+((uintptr_t)0ULL), x269, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)8ULL), x270, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)16ULL), x271, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)24ULL), x272, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)32ULL), x273, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out2)+((uintptr_t)0ULL), x274, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)8ULL), x275, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)16ULL), x276, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)24ULL), x277, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)32ULL), x278, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out3)+((uintptr_t)0ULL), x279, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)8ULL), x280, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)16ULL), x281, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)24ULL), x282, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out4)+((uintptr_t)0ULL), x283, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)8ULL), x284, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)16ULL), x285, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)24ULL), x286, sizeof(uintptr_t)); + /*skip*/ + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_divstep(uint64_t* out1, uint64_t out2[5], uint64_t out3[5], uint64_t out4[4], uint64_t out5[4], uint64_t arg1, const uint64_t arg2[5], const uint64_t arg3[5], const uint64_t arg4[4], const uint64_t arg5[4]) { + *out1 = (uint64_t)internal_fiat_secp256k1_scalar_divstep((uintptr_t)out2, (uintptr_t)out3, (uintptr_t)out4, (uintptr_t)out5, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3, (uintptr_t)arg4, (uintptr_t)arg5); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_secp256k1_scalar_divstep_precomp(uintptr_t out0) { + uintptr_t x0, x1, x2, x3; + /*skip*/ + x0 = (uintptr_t)15511270460340614377ULL; + x1 = (uintptr_t)12351072887440524547ULL; + x2 = (uintptr_t)12535426401435444063ULL; + x3 = (uintptr_t)7013302284833964921ULL; + /*skip*/ + _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_secp256k1_scalar_divstep_precomp(uint64_t out1[4]) { + internal_fiat_secp256k1_scalar_divstep_precomp((uintptr_t)out1); +} diff --git a/fiat-c/src/curve25519_scalar_32.c b/fiat-c/src/curve25519_scalar_32.c new file mode 100644 index 0000000000..867cb7cea0 --- /dev/null +++ b/fiat-c/src/curve25519_scalar_32.c @@ -0,0 +1,5046 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier 25519_scalar 32 '2^252 + 27742317777372353535851937790883648493' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: 25519_scalar */ +/* machine_wordsize = 32 (from "32") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed (from "2^252 + 27742317777372353535851937790883648493") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +typedef unsigned char fiat_25519_scalar_uint1; +typedef signed char fiat_25519_scalar_int1; +#if defined(__GNUC__) || defined(__clang__) +# define FIAT_25519_SCALAR_FIAT_INLINE __inline__ +#else +# define FIAT_25519_SCALAR_FIAT_INLINE +#endif + +/* The type fiat_25519_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +typedef uint32_t fiat_25519_scalar_montgomery_domain_field_element[8]; + +/* The type fiat_25519_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +typedef uint32_t fiat_25519_scalar_non_montgomery_domain_field_element[8]; + +#if (-1 & 3) != 3 +#error "This code only works on a two's complement system" +#endif + +#if !defined(FIAT_25519_SCALAR_NO_ASM) && (defined(__GNUC__) || defined(__clang__)) +static __inline__ uint32_t fiat_25519_scalar_value_barrier_u32(uint32_t a) { + __asm__("" : "+r"(a) : /* no inputs */); + return a; +} +#else +# define fiat_25519_scalar_value_barrier_u32(x) (x) +#endif + + +/* + * The function fiat_25519_scalar_addcarryx_u32 is an addition with carry. + * + * Postconditions: + * out1 = (arg1 + arg2 + arg3) mod 2^32 + * out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffff] + * arg3: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_addcarryx_u32(uint32_t* out1, fiat_25519_scalar_uint1* out2, fiat_25519_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + uint64_t x1; + uint32_t x2; + fiat_25519_scalar_uint1 x3; + x1 = ((arg1 + (uint64_t)arg2) + arg3); + x2 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + x3 = (fiat_25519_scalar_uint1)(x1 >> 32); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_25519_scalar_subborrowx_u32 is a subtraction with borrow. + * + * Postconditions: + * out1 = (-arg1 + arg2 + -arg3) mod 2^32 + * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffff] + * arg3: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_subborrowx_u32(uint32_t* out1, fiat_25519_scalar_uint1* out2, fiat_25519_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + int64_t x1; + fiat_25519_scalar_int1 x2; + uint32_t x3; + x1 = ((arg2 - (int64_t)arg1) - arg3); + x2 = (fiat_25519_scalar_int1)(x1 >> 32); + x3 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + *out1 = x3; + *out2 = (fiat_25519_scalar_uint1)(0x0 - x2); +} + +/* + * The function fiat_25519_scalar_mulx_u32 is a multiplication, returning the full double-width result. + * + * Postconditions: + * out1 = (arg1 * arg2) mod 2^32 + * out2 = ⌊arg1 * arg2 / 2^32⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffff] + * arg2: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [0x0 ~> 0xffffffff] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_mulx_u32(uint32_t* out1, uint32_t* out2, uint32_t arg1, uint32_t arg2) { + uint64_t x1; + uint32_t x2; + uint32_t x3; + x1 = ((uint64_t)arg1 * arg2); + x2 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + x3 = (uint32_t)(x1 >> 32); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_25519_scalar_cmovznz_u32 is a single-word conditional move. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffff] + * arg3: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_cmovznz_u32(uint32_t* out1, fiat_25519_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + fiat_25519_scalar_uint1 x1; + uint32_t x2; + uint32_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_25519_scalar_int1)(0x0 - x1) & UINT32_C(0xffffffff)); + x3 = ((fiat_25519_scalar_value_barrier_u32(x2) & arg3) | (fiat_25519_scalar_value_barrier_u32((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_25519_scalar_mul multiplies two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_mul(fiat_25519_scalar_montgomery_domain_field_element out1, const fiat_25519_scalar_montgomery_domain_field_element arg1, const fiat_25519_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + fiat_25519_scalar_uint1 x26; + uint32_t x27; + fiat_25519_scalar_uint1 x28; + uint32_t x29; + fiat_25519_scalar_uint1 x30; + uint32_t x31; + fiat_25519_scalar_uint1 x32; + uint32_t x33; + fiat_25519_scalar_uint1 x34; + uint32_t x35; + fiat_25519_scalar_uint1 x36; + uint32_t x37; + fiat_25519_scalar_uint1 x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + fiat_25519_scalar_uint1 x53; + uint32_t x54; + fiat_25519_scalar_uint1 x55; + uint32_t x56; + fiat_25519_scalar_uint1 x57; + uint32_t x58; + uint32_t x59; + fiat_25519_scalar_uint1 x60; + uint32_t x61; + fiat_25519_scalar_uint1 x62; + uint32_t x63; + fiat_25519_scalar_uint1 x64; + uint32_t x65; + fiat_25519_scalar_uint1 x66; + uint32_t x67; + fiat_25519_scalar_uint1 x68; + uint32_t x69; + fiat_25519_scalar_uint1 x70; + uint32_t x71; + fiat_25519_scalar_uint1 x72; + uint32_t x73; + fiat_25519_scalar_uint1 x74; + uint32_t x75; + fiat_25519_scalar_uint1 x76; + uint32_t x77; + uint32_t x78; + uint32_t x79; + uint32_t x80; + uint32_t x81; + uint32_t x82; + uint32_t x83; + uint32_t x84; + uint32_t x85; + uint32_t x86; + uint32_t x87; + uint32_t x88; + uint32_t x89; + uint32_t x90; + uint32_t x91; + uint32_t x92; + uint32_t x93; + fiat_25519_scalar_uint1 x94; + uint32_t x95; + fiat_25519_scalar_uint1 x96; + uint32_t x97; + fiat_25519_scalar_uint1 x98; + uint32_t x99; + fiat_25519_scalar_uint1 x100; + uint32_t x101; + fiat_25519_scalar_uint1 x102; + uint32_t x103; + fiat_25519_scalar_uint1 x104; + uint32_t x105; + fiat_25519_scalar_uint1 x106; + uint32_t x107; + uint32_t x108; + fiat_25519_scalar_uint1 x109; + uint32_t x110; + fiat_25519_scalar_uint1 x111; + uint32_t x112; + fiat_25519_scalar_uint1 x113; + uint32_t x114; + fiat_25519_scalar_uint1 x115; + uint32_t x116; + fiat_25519_scalar_uint1 x117; + uint32_t x118; + fiat_25519_scalar_uint1 x119; + uint32_t x120; + fiat_25519_scalar_uint1 x121; + uint32_t x122; + fiat_25519_scalar_uint1 x123; + uint32_t x124; + fiat_25519_scalar_uint1 x125; + uint32_t x126; + uint32_t x127; + uint32_t x128; + uint32_t x129; + uint32_t x130; + uint32_t x131; + uint32_t x132; + uint32_t x133; + uint32_t x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + fiat_25519_scalar_uint1 x139; + uint32_t x140; + fiat_25519_scalar_uint1 x141; + uint32_t x142; + fiat_25519_scalar_uint1 x143; + uint32_t x144; + uint32_t x145; + fiat_25519_scalar_uint1 x146; + uint32_t x147; + fiat_25519_scalar_uint1 x148; + uint32_t x149; + fiat_25519_scalar_uint1 x150; + uint32_t x151; + fiat_25519_scalar_uint1 x152; + uint32_t x153; + fiat_25519_scalar_uint1 x154; + uint32_t x155; + fiat_25519_scalar_uint1 x156; + uint32_t x157; + fiat_25519_scalar_uint1 x158; + uint32_t x159; + fiat_25519_scalar_uint1 x160; + uint32_t x161; + fiat_25519_scalar_uint1 x162; + uint32_t x163; + uint32_t x164; + uint32_t x165; + uint32_t x166; + uint32_t x167; + uint32_t x168; + uint32_t x169; + uint32_t x170; + uint32_t x171; + uint32_t x172; + uint32_t x173; + uint32_t x174; + uint32_t x175; + uint32_t x176; + uint32_t x177; + uint32_t x178; + uint32_t x179; + uint32_t x180; + fiat_25519_scalar_uint1 x181; + uint32_t x182; + fiat_25519_scalar_uint1 x183; + uint32_t x184; + fiat_25519_scalar_uint1 x185; + uint32_t x186; + fiat_25519_scalar_uint1 x187; + uint32_t x188; + fiat_25519_scalar_uint1 x189; + uint32_t x190; + fiat_25519_scalar_uint1 x191; + uint32_t x192; + fiat_25519_scalar_uint1 x193; + uint32_t x194; + uint32_t x195; + fiat_25519_scalar_uint1 x196; + uint32_t x197; + fiat_25519_scalar_uint1 x198; + uint32_t x199; + fiat_25519_scalar_uint1 x200; + uint32_t x201; + fiat_25519_scalar_uint1 x202; + uint32_t x203; + fiat_25519_scalar_uint1 x204; + uint32_t x205; + fiat_25519_scalar_uint1 x206; + uint32_t x207; + fiat_25519_scalar_uint1 x208; + uint32_t x209; + fiat_25519_scalar_uint1 x210; + uint32_t x211; + fiat_25519_scalar_uint1 x212; + uint32_t x213; + uint32_t x214; + uint32_t x215; + uint32_t x216; + uint32_t x217; + uint32_t x218; + uint32_t x219; + uint32_t x220; + uint32_t x221; + uint32_t x222; + uint32_t x223; + uint32_t x224; + uint32_t x225; + fiat_25519_scalar_uint1 x226; + uint32_t x227; + fiat_25519_scalar_uint1 x228; + uint32_t x229; + fiat_25519_scalar_uint1 x230; + uint32_t x231; + uint32_t x232; + fiat_25519_scalar_uint1 x233; + uint32_t x234; + fiat_25519_scalar_uint1 x235; + uint32_t x236; + fiat_25519_scalar_uint1 x237; + uint32_t x238; + fiat_25519_scalar_uint1 x239; + uint32_t x240; + fiat_25519_scalar_uint1 x241; + uint32_t x242; + fiat_25519_scalar_uint1 x243; + uint32_t x244; + fiat_25519_scalar_uint1 x245; + uint32_t x246; + fiat_25519_scalar_uint1 x247; + uint32_t x248; + fiat_25519_scalar_uint1 x249; + uint32_t x250; + uint32_t x251; + uint32_t x252; + uint32_t x253; + uint32_t x254; + uint32_t x255; + uint32_t x256; + uint32_t x257; + uint32_t x258; + uint32_t x259; + uint32_t x260; + uint32_t x261; + uint32_t x262; + uint32_t x263; + uint32_t x264; + uint32_t x265; + uint32_t x266; + uint32_t x267; + fiat_25519_scalar_uint1 x268; + uint32_t x269; + fiat_25519_scalar_uint1 x270; + uint32_t x271; + fiat_25519_scalar_uint1 x272; + uint32_t x273; + fiat_25519_scalar_uint1 x274; + uint32_t x275; + fiat_25519_scalar_uint1 x276; + uint32_t x277; + fiat_25519_scalar_uint1 x278; + uint32_t x279; + fiat_25519_scalar_uint1 x280; + uint32_t x281; + uint32_t x282; + fiat_25519_scalar_uint1 x283; + uint32_t x284; + fiat_25519_scalar_uint1 x285; + uint32_t x286; + fiat_25519_scalar_uint1 x287; + uint32_t x288; + fiat_25519_scalar_uint1 x289; + uint32_t x290; + fiat_25519_scalar_uint1 x291; + uint32_t x292; + fiat_25519_scalar_uint1 x293; + uint32_t x294; + fiat_25519_scalar_uint1 x295; + uint32_t x296; + fiat_25519_scalar_uint1 x297; + uint32_t x298; + fiat_25519_scalar_uint1 x299; + uint32_t x300; + uint32_t x301; + uint32_t x302; + uint32_t x303; + uint32_t x304; + uint32_t x305; + uint32_t x306; + uint32_t x307; + uint32_t x308; + uint32_t x309; + uint32_t x310; + uint32_t x311; + uint32_t x312; + fiat_25519_scalar_uint1 x313; + uint32_t x314; + fiat_25519_scalar_uint1 x315; + uint32_t x316; + fiat_25519_scalar_uint1 x317; + uint32_t x318; + uint32_t x319; + fiat_25519_scalar_uint1 x320; + uint32_t x321; + fiat_25519_scalar_uint1 x322; + uint32_t x323; + fiat_25519_scalar_uint1 x324; + uint32_t x325; + fiat_25519_scalar_uint1 x326; + uint32_t x327; + fiat_25519_scalar_uint1 x328; + uint32_t x329; + fiat_25519_scalar_uint1 x330; + uint32_t x331; + fiat_25519_scalar_uint1 x332; + uint32_t x333; + fiat_25519_scalar_uint1 x334; + uint32_t x335; + fiat_25519_scalar_uint1 x336; + uint32_t x337; + uint32_t x338; + uint32_t x339; + uint32_t x340; + uint32_t x341; + uint32_t x342; + uint32_t x343; + uint32_t x344; + uint32_t x345; + uint32_t x346; + uint32_t x347; + uint32_t x348; + uint32_t x349; + uint32_t x350; + uint32_t x351; + uint32_t x352; + uint32_t x353; + uint32_t x354; + fiat_25519_scalar_uint1 x355; + uint32_t x356; + fiat_25519_scalar_uint1 x357; + uint32_t x358; + fiat_25519_scalar_uint1 x359; + uint32_t x360; + fiat_25519_scalar_uint1 x361; + uint32_t x362; + fiat_25519_scalar_uint1 x363; + uint32_t x364; + fiat_25519_scalar_uint1 x365; + uint32_t x366; + fiat_25519_scalar_uint1 x367; + uint32_t x368; + uint32_t x369; + fiat_25519_scalar_uint1 x370; + uint32_t x371; + fiat_25519_scalar_uint1 x372; + uint32_t x373; + fiat_25519_scalar_uint1 x374; + uint32_t x375; + fiat_25519_scalar_uint1 x376; + uint32_t x377; + fiat_25519_scalar_uint1 x378; + uint32_t x379; + fiat_25519_scalar_uint1 x380; + uint32_t x381; + fiat_25519_scalar_uint1 x382; + uint32_t x383; + fiat_25519_scalar_uint1 x384; + uint32_t x385; + fiat_25519_scalar_uint1 x386; + uint32_t x387; + uint32_t x388; + uint32_t x389; + uint32_t x390; + uint32_t x391; + uint32_t x392; + uint32_t x393; + uint32_t x394; + uint32_t x395; + uint32_t x396; + uint32_t x397; + uint32_t x398; + uint32_t x399; + fiat_25519_scalar_uint1 x400; + uint32_t x401; + fiat_25519_scalar_uint1 x402; + uint32_t x403; + fiat_25519_scalar_uint1 x404; + uint32_t x405; + uint32_t x406; + fiat_25519_scalar_uint1 x407; + uint32_t x408; + fiat_25519_scalar_uint1 x409; + uint32_t x410; + fiat_25519_scalar_uint1 x411; + uint32_t x412; + fiat_25519_scalar_uint1 x413; + uint32_t x414; + fiat_25519_scalar_uint1 x415; + uint32_t x416; + fiat_25519_scalar_uint1 x417; + uint32_t x418; + fiat_25519_scalar_uint1 x419; + uint32_t x420; + fiat_25519_scalar_uint1 x421; + uint32_t x422; + fiat_25519_scalar_uint1 x423; + uint32_t x424; + uint32_t x425; + uint32_t x426; + uint32_t x427; + uint32_t x428; + uint32_t x429; + uint32_t x430; + uint32_t x431; + uint32_t x432; + uint32_t x433; + uint32_t x434; + uint32_t x435; + uint32_t x436; + uint32_t x437; + uint32_t x438; + uint32_t x439; + uint32_t x440; + uint32_t x441; + fiat_25519_scalar_uint1 x442; + uint32_t x443; + fiat_25519_scalar_uint1 x444; + uint32_t x445; + fiat_25519_scalar_uint1 x446; + uint32_t x447; + fiat_25519_scalar_uint1 x448; + uint32_t x449; + fiat_25519_scalar_uint1 x450; + uint32_t x451; + fiat_25519_scalar_uint1 x452; + uint32_t x453; + fiat_25519_scalar_uint1 x454; + uint32_t x455; + uint32_t x456; + fiat_25519_scalar_uint1 x457; + uint32_t x458; + fiat_25519_scalar_uint1 x459; + uint32_t x460; + fiat_25519_scalar_uint1 x461; + uint32_t x462; + fiat_25519_scalar_uint1 x463; + uint32_t x464; + fiat_25519_scalar_uint1 x465; + uint32_t x466; + fiat_25519_scalar_uint1 x467; + uint32_t x468; + fiat_25519_scalar_uint1 x469; + uint32_t x470; + fiat_25519_scalar_uint1 x471; + uint32_t x472; + fiat_25519_scalar_uint1 x473; + uint32_t x474; + uint32_t x475; + uint32_t x476; + uint32_t x477; + uint32_t x478; + uint32_t x479; + uint32_t x480; + uint32_t x481; + uint32_t x482; + uint32_t x483; + uint32_t x484; + uint32_t x485; + uint32_t x486; + fiat_25519_scalar_uint1 x487; + uint32_t x488; + fiat_25519_scalar_uint1 x489; + uint32_t x490; + fiat_25519_scalar_uint1 x491; + uint32_t x492; + uint32_t x493; + fiat_25519_scalar_uint1 x494; + uint32_t x495; + fiat_25519_scalar_uint1 x496; + uint32_t x497; + fiat_25519_scalar_uint1 x498; + uint32_t x499; + fiat_25519_scalar_uint1 x500; + uint32_t x501; + fiat_25519_scalar_uint1 x502; + uint32_t x503; + fiat_25519_scalar_uint1 x504; + uint32_t x505; + fiat_25519_scalar_uint1 x506; + uint32_t x507; + fiat_25519_scalar_uint1 x508; + uint32_t x509; + fiat_25519_scalar_uint1 x510; + uint32_t x511; + uint32_t x512; + uint32_t x513; + uint32_t x514; + uint32_t x515; + uint32_t x516; + uint32_t x517; + uint32_t x518; + uint32_t x519; + uint32_t x520; + uint32_t x521; + uint32_t x522; + uint32_t x523; + uint32_t x524; + uint32_t x525; + uint32_t x526; + uint32_t x527; + uint32_t x528; + fiat_25519_scalar_uint1 x529; + uint32_t x530; + fiat_25519_scalar_uint1 x531; + uint32_t x532; + fiat_25519_scalar_uint1 x533; + uint32_t x534; + fiat_25519_scalar_uint1 x535; + uint32_t x536; + fiat_25519_scalar_uint1 x537; + uint32_t x538; + fiat_25519_scalar_uint1 x539; + uint32_t x540; + fiat_25519_scalar_uint1 x541; + uint32_t x542; + uint32_t x543; + fiat_25519_scalar_uint1 x544; + uint32_t x545; + fiat_25519_scalar_uint1 x546; + uint32_t x547; + fiat_25519_scalar_uint1 x548; + uint32_t x549; + fiat_25519_scalar_uint1 x550; + uint32_t x551; + fiat_25519_scalar_uint1 x552; + uint32_t x553; + fiat_25519_scalar_uint1 x554; + uint32_t x555; + fiat_25519_scalar_uint1 x556; + uint32_t x557; + fiat_25519_scalar_uint1 x558; + uint32_t x559; + fiat_25519_scalar_uint1 x560; + uint32_t x561; + uint32_t x562; + uint32_t x563; + uint32_t x564; + uint32_t x565; + uint32_t x566; + uint32_t x567; + uint32_t x568; + uint32_t x569; + uint32_t x570; + uint32_t x571; + uint32_t x572; + uint32_t x573; + fiat_25519_scalar_uint1 x574; + uint32_t x575; + fiat_25519_scalar_uint1 x576; + uint32_t x577; + fiat_25519_scalar_uint1 x578; + uint32_t x579; + uint32_t x580; + fiat_25519_scalar_uint1 x581; + uint32_t x582; + fiat_25519_scalar_uint1 x583; + uint32_t x584; + fiat_25519_scalar_uint1 x585; + uint32_t x586; + fiat_25519_scalar_uint1 x587; + uint32_t x588; + fiat_25519_scalar_uint1 x589; + uint32_t x590; + fiat_25519_scalar_uint1 x591; + uint32_t x592; + fiat_25519_scalar_uint1 x593; + uint32_t x594; + fiat_25519_scalar_uint1 x595; + uint32_t x596; + fiat_25519_scalar_uint1 x597; + uint32_t x598; + uint32_t x599; + uint32_t x600; + uint32_t x601; + uint32_t x602; + uint32_t x603; + uint32_t x604; + uint32_t x605; + uint32_t x606; + uint32_t x607; + uint32_t x608; + uint32_t x609; + uint32_t x610; + uint32_t x611; + uint32_t x612; + uint32_t x613; + uint32_t x614; + uint32_t x615; + fiat_25519_scalar_uint1 x616; + uint32_t x617; + fiat_25519_scalar_uint1 x618; + uint32_t x619; + fiat_25519_scalar_uint1 x620; + uint32_t x621; + fiat_25519_scalar_uint1 x622; + uint32_t x623; + fiat_25519_scalar_uint1 x624; + uint32_t x625; + fiat_25519_scalar_uint1 x626; + uint32_t x627; + fiat_25519_scalar_uint1 x628; + uint32_t x629; + uint32_t x630; + fiat_25519_scalar_uint1 x631; + uint32_t x632; + fiat_25519_scalar_uint1 x633; + uint32_t x634; + fiat_25519_scalar_uint1 x635; + uint32_t x636; + fiat_25519_scalar_uint1 x637; + uint32_t x638; + fiat_25519_scalar_uint1 x639; + uint32_t x640; + fiat_25519_scalar_uint1 x641; + uint32_t x642; + fiat_25519_scalar_uint1 x643; + uint32_t x644; + fiat_25519_scalar_uint1 x645; + uint32_t x646; + fiat_25519_scalar_uint1 x647; + uint32_t x648; + uint32_t x649; + uint32_t x650; + uint32_t x651; + uint32_t x652; + uint32_t x653; + uint32_t x654; + uint32_t x655; + uint32_t x656; + uint32_t x657; + uint32_t x658; + uint32_t x659; + uint32_t x660; + fiat_25519_scalar_uint1 x661; + uint32_t x662; + fiat_25519_scalar_uint1 x663; + uint32_t x664; + fiat_25519_scalar_uint1 x665; + uint32_t x666; + uint32_t x667; + fiat_25519_scalar_uint1 x668; + uint32_t x669; + fiat_25519_scalar_uint1 x670; + uint32_t x671; + fiat_25519_scalar_uint1 x672; + uint32_t x673; + fiat_25519_scalar_uint1 x674; + uint32_t x675; + fiat_25519_scalar_uint1 x676; + uint32_t x677; + fiat_25519_scalar_uint1 x678; + uint32_t x679; + fiat_25519_scalar_uint1 x680; + uint32_t x681; + fiat_25519_scalar_uint1 x682; + uint32_t x683; + fiat_25519_scalar_uint1 x684; + uint32_t x685; + uint32_t x686; + fiat_25519_scalar_uint1 x687; + uint32_t x688; + fiat_25519_scalar_uint1 x689; + uint32_t x690; + fiat_25519_scalar_uint1 x691; + uint32_t x692; + fiat_25519_scalar_uint1 x693; + uint32_t x694; + fiat_25519_scalar_uint1 x695; + uint32_t x696; + fiat_25519_scalar_uint1 x697; + uint32_t x698; + fiat_25519_scalar_uint1 x699; + uint32_t x700; + fiat_25519_scalar_uint1 x701; + uint32_t x702; + fiat_25519_scalar_uint1 x703; + uint32_t x704; + uint32_t x705; + uint32_t x706; + uint32_t x707; + uint32_t x708; + uint32_t x709; + uint32_t x710; + uint32_t x711; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[6]); + x7 = (arg1[7]); + x8 = (arg1[0]); + fiat_25519_scalar_mulx_u32(&x9, &x10, x8, (arg2[7])); + fiat_25519_scalar_mulx_u32(&x11, &x12, x8, (arg2[6])); + fiat_25519_scalar_mulx_u32(&x13, &x14, x8, (arg2[5])); + fiat_25519_scalar_mulx_u32(&x15, &x16, x8, (arg2[4])); + fiat_25519_scalar_mulx_u32(&x17, &x18, x8, (arg2[3])); + fiat_25519_scalar_mulx_u32(&x19, &x20, x8, (arg2[2])); + fiat_25519_scalar_mulx_u32(&x21, &x22, x8, (arg2[1])); + fiat_25519_scalar_mulx_u32(&x23, &x24, x8, (arg2[0])); + fiat_25519_scalar_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_25519_scalar_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_25519_scalar_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_25519_scalar_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_25519_scalar_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_25519_scalar_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_25519_scalar_addcarryx_u32(&x37, &x38, x36, x12, x9); + x39 = (x38 + x10); + fiat_25519_scalar_mulx_u32(&x40, &x41, x23, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x42, &x43, x40, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x44, &x45, x40, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x46, &x47, x40, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x48, &x49, x40, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x50, &x51, x40, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x52, &x53, 0x0, x51, x48); + fiat_25519_scalar_addcarryx_u32(&x54, &x55, x53, x49, x46); + fiat_25519_scalar_addcarryx_u32(&x56, &x57, x55, x47, x44); + x58 = (x57 + x45); + fiat_25519_scalar_addcarryx_u32(&x59, &x60, 0x0, x23, x50); + fiat_25519_scalar_addcarryx_u32(&x61, &x62, x60, x25, x52); + fiat_25519_scalar_addcarryx_u32(&x63, &x64, x62, x27, x54); + fiat_25519_scalar_addcarryx_u32(&x65, &x66, x64, x29, x56); + fiat_25519_scalar_addcarryx_u32(&x67, &x68, x66, x31, x58); + fiat_25519_scalar_addcarryx_u32(&x69, &x70, x68, x33, 0x0); + fiat_25519_scalar_addcarryx_u32(&x71, &x72, x70, x35, 0x0); + fiat_25519_scalar_addcarryx_u32(&x73, &x74, x72, x37, x42); + fiat_25519_scalar_addcarryx_u32(&x75, &x76, x74, x39, x43); + fiat_25519_scalar_mulx_u32(&x77, &x78, x1, (arg2[7])); + fiat_25519_scalar_mulx_u32(&x79, &x80, x1, (arg2[6])); + fiat_25519_scalar_mulx_u32(&x81, &x82, x1, (arg2[5])); + fiat_25519_scalar_mulx_u32(&x83, &x84, x1, (arg2[4])); + fiat_25519_scalar_mulx_u32(&x85, &x86, x1, (arg2[3])); + fiat_25519_scalar_mulx_u32(&x87, &x88, x1, (arg2[2])); + fiat_25519_scalar_mulx_u32(&x89, &x90, x1, (arg2[1])); + fiat_25519_scalar_mulx_u32(&x91, &x92, x1, (arg2[0])); + fiat_25519_scalar_addcarryx_u32(&x93, &x94, 0x0, x92, x89); + fiat_25519_scalar_addcarryx_u32(&x95, &x96, x94, x90, x87); + fiat_25519_scalar_addcarryx_u32(&x97, &x98, x96, x88, x85); + fiat_25519_scalar_addcarryx_u32(&x99, &x100, x98, x86, x83); + fiat_25519_scalar_addcarryx_u32(&x101, &x102, x100, x84, x81); + fiat_25519_scalar_addcarryx_u32(&x103, &x104, x102, x82, x79); + fiat_25519_scalar_addcarryx_u32(&x105, &x106, x104, x80, x77); + x107 = (x106 + x78); + fiat_25519_scalar_addcarryx_u32(&x108, &x109, 0x0, x61, x91); + fiat_25519_scalar_addcarryx_u32(&x110, &x111, x109, x63, x93); + fiat_25519_scalar_addcarryx_u32(&x112, &x113, x111, x65, x95); + fiat_25519_scalar_addcarryx_u32(&x114, &x115, x113, x67, x97); + fiat_25519_scalar_addcarryx_u32(&x116, &x117, x115, x69, x99); + fiat_25519_scalar_addcarryx_u32(&x118, &x119, x117, x71, x101); + fiat_25519_scalar_addcarryx_u32(&x120, &x121, x119, x73, x103); + fiat_25519_scalar_addcarryx_u32(&x122, &x123, x121, x75, x105); + fiat_25519_scalar_addcarryx_u32(&x124, &x125, x123, x76, x107); + fiat_25519_scalar_mulx_u32(&x126, &x127, x108, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x128, &x129, x126, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x130, &x131, x126, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x132, &x133, x126, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x134, &x135, x126, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x136, &x137, x126, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x138, &x139, 0x0, x137, x134); + fiat_25519_scalar_addcarryx_u32(&x140, &x141, x139, x135, x132); + fiat_25519_scalar_addcarryx_u32(&x142, &x143, x141, x133, x130); + x144 = (x143 + x131); + fiat_25519_scalar_addcarryx_u32(&x145, &x146, 0x0, x108, x136); + fiat_25519_scalar_addcarryx_u32(&x147, &x148, x146, x110, x138); + fiat_25519_scalar_addcarryx_u32(&x149, &x150, x148, x112, x140); + fiat_25519_scalar_addcarryx_u32(&x151, &x152, x150, x114, x142); + fiat_25519_scalar_addcarryx_u32(&x153, &x154, x152, x116, x144); + fiat_25519_scalar_addcarryx_u32(&x155, &x156, x154, x118, 0x0); + fiat_25519_scalar_addcarryx_u32(&x157, &x158, x156, x120, 0x0); + fiat_25519_scalar_addcarryx_u32(&x159, &x160, x158, x122, x128); + fiat_25519_scalar_addcarryx_u32(&x161, &x162, x160, x124, x129); + x163 = ((uint32_t)x162 + x125); + fiat_25519_scalar_mulx_u32(&x164, &x165, x2, (arg2[7])); + fiat_25519_scalar_mulx_u32(&x166, &x167, x2, (arg2[6])); + fiat_25519_scalar_mulx_u32(&x168, &x169, x2, (arg2[5])); + fiat_25519_scalar_mulx_u32(&x170, &x171, x2, (arg2[4])); + fiat_25519_scalar_mulx_u32(&x172, &x173, x2, (arg2[3])); + fiat_25519_scalar_mulx_u32(&x174, &x175, x2, (arg2[2])); + fiat_25519_scalar_mulx_u32(&x176, &x177, x2, (arg2[1])); + fiat_25519_scalar_mulx_u32(&x178, &x179, x2, (arg2[0])); + fiat_25519_scalar_addcarryx_u32(&x180, &x181, 0x0, x179, x176); + fiat_25519_scalar_addcarryx_u32(&x182, &x183, x181, x177, x174); + fiat_25519_scalar_addcarryx_u32(&x184, &x185, x183, x175, x172); + fiat_25519_scalar_addcarryx_u32(&x186, &x187, x185, x173, x170); + fiat_25519_scalar_addcarryx_u32(&x188, &x189, x187, x171, x168); + fiat_25519_scalar_addcarryx_u32(&x190, &x191, x189, x169, x166); + fiat_25519_scalar_addcarryx_u32(&x192, &x193, x191, x167, x164); + x194 = (x193 + x165); + fiat_25519_scalar_addcarryx_u32(&x195, &x196, 0x0, x147, x178); + fiat_25519_scalar_addcarryx_u32(&x197, &x198, x196, x149, x180); + fiat_25519_scalar_addcarryx_u32(&x199, &x200, x198, x151, x182); + fiat_25519_scalar_addcarryx_u32(&x201, &x202, x200, x153, x184); + fiat_25519_scalar_addcarryx_u32(&x203, &x204, x202, x155, x186); + fiat_25519_scalar_addcarryx_u32(&x205, &x206, x204, x157, x188); + fiat_25519_scalar_addcarryx_u32(&x207, &x208, x206, x159, x190); + fiat_25519_scalar_addcarryx_u32(&x209, &x210, x208, x161, x192); + fiat_25519_scalar_addcarryx_u32(&x211, &x212, x210, x163, x194); + fiat_25519_scalar_mulx_u32(&x213, &x214, x195, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x215, &x216, x213, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x217, &x218, x213, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x219, &x220, x213, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x221, &x222, x213, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x223, &x224, x213, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x225, &x226, 0x0, x224, x221); + fiat_25519_scalar_addcarryx_u32(&x227, &x228, x226, x222, x219); + fiat_25519_scalar_addcarryx_u32(&x229, &x230, x228, x220, x217); + x231 = (x230 + x218); + fiat_25519_scalar_addcarryx_u32(&x232, &x233, 0x0, x195, x223); + fiat_25519_scalar_addcarryx_u32(&x234, &x235, x233, x197, x225); + fiat_25519_scalar_addcarryx_u32(&x236, &x237, x235, x199, x227); + fiat_25519_scalar_addcarryx_u32(&x238, &x239, x237, x201, x229); + fiat_25519_scalar_addcarryx_u32(&x240, &x241, x239, x203, x231); + fiat_25519_scalar_addcarryx_u32(&x242, &x243, x241, x205, 0x0); + fiat_25519_scalar_addcarryx_u32(&x244, &x245, x243, x207, 0x0); + fiat_25519_scalar_addcarryx_u32(&x246, &x247, x245, x209, x215); + fiat_25519_scalar_addcarryx_u32(&x248, &x249, x247, x211, x216); + x250 = ((uint32_t)x249 + x212); + fiat_25519_scalar_mulx_u32(&x251, &x252, x3, (arg2[7])); + fiat_25519_scalar_mulx_u32(&x253, &x254, x3, (arg2[6])); + fiat_25519_scalar_mulx_u32(&x255, &x256, x3, (arg2[5])); + fiat_25519_scalar_mulx_u32(&x257, &x258, x3, (arg2[4])); + fiat_25519_scalar_mulx_u32(&x259, &x260, x3, (arg2[3])); + fiat_25519_scalar_mulx_u32(&x261, &x262, x3, (arg2[2])); + fiat_25519_scalar_mulx_u32(&x263, &x264, x3, (arg2[1])); + fiat_25519_scalar_mulx_u32(&x265, &x266, x3, (arg2[0])); + fiat_25519_scalar_addcarryx_u32(&x267, &x268, 0x0, x266, x263); + fiat_25519_scalar_addcarryx_u32(&x269, &x270, x268, x264, x261); + fiat_25519_scalar_addcarryx_u32(&x271, &x272, x270, x262, x259); + fiat_25519_scalar_addcarryx_u32(&x273, &x274, x272, x260, x257); + fiat_25519_scalar_addcarryx_u32(&x275, &x276, x274, x258, x255); + fiat_25519_scalar_addcarryx_u32(&x277, &x278, x276, x256, x253); + fiat_25519_scalar_addcarryx_u32(&x279, &x280, x278, x254, x251); + x281 = (x280 + x252); + fiat_25519_scalar_addcarryx_u32(&x282, &x283, 0x0, x234, x265); + fiat_25519_scalar_addcarryx_u32(&x284, &x285, x283, x236, x267); + fiat_25519_scalar_addcarryx_u32(&x286, &x287, x285, x238, x269); + fiat_25519_scalar_addcarryx_u32(&x288, &x289, x287, x240, x271); + fiat_25519_scalar_addcarryx_u32(&x290, &x291, x289, x242, x273); + fiat_25519_scalar_addcarryx_u32(&x292, &x293, x291, x244, x275); + fiat_25519_scalar_addcarryx_u32(&x294, &x295, x293, x246, x277); + fiat_25519_scalar_addcarryx_u32(&x296, &x297, x295, x248, x279); + fiat_25519_scalar_addcarryx_u32(&x298, &x299, x297, x250, x281); + fiat_25519_scalar_mulx_u32(&x300, &x301, x282, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x302, &x303, x300, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x304, &x305, x300, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x306, &x307, x300, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x308, &x309, x300, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x310, &x311, x300, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x312, &x313, 0x0, x311, x308); + fiat_25519_scalar_addcarryx_u32(&x314, &x315, x313, x309, x306); + fiat_25519_scalar_addcarryx_u32(&x316, &x317, x315, x307, x304); + x318 = (x317 + x305); + fiat_25519_scalar_addcarryx_u32(&x319, &x320, 0x0, x282, x310); + fiat_25519_scalar_addcarryx_u32(&x321, &x322, x320, x284, x312); + fiat_25519_scalar_addcarryx_u32(&x323, &x324, x322, x286, x314); + fiat_25519_scalar_addcarryx_u32(&x325, &x326, x324, x288, x316); + fiat_25519_scalar_addcarryx_u32(&x327, &x328, x326, x290, x318); + fiat_25519_scalar_addcarryx_u32(&x329, &x330, x328, x292, 0x0); + fiat_25519_scalar_addcarryx_u32(&x331, &x332, x330, x294, 0x0); + fiat_25519_scalar_addcarryx_u32(&x333, &x334, x332, x296, x302); + fiat_25519_scalar_addcarryx_u32(&x335, &x336, x334, x298, x303); + x337 = ((uint32_t)x336 + x299); + fiat_25519_scalar_mulx_u32(&x338, &x339, x4, (arg2[7])); + fiat_25519_scalar_mulx_u32(&x340, &x341, x4, (arg2[6])); + fiat_25519_scalar_mulx_u32(&x342, &x343, x4, (arg2[5])); + fiat_25519_scalar_mulx_u32(&x344, &x345, x4, (arg2[4])); + fiat_25519_scalar_mulx_u32(&x346, &x347, x4, (arg2[3])); + fiat_25519_scalar_mulx_u32(&x348, &x349, x4, (arg2[2])); + fiat_25519_scalar_mulx_u32(&x350, &x351, x4, (arg2[1])); + fiat_25519_scalar_mulx_u32(&x352, &x353, x4, (arg2[0])); + fiat_25519_scalar_addcarryx_u32(&x354, &x355, 0x0, x353, x350); + fiat_25519_scalar_addcarryx_u32(&x356, &x357, x355, x351, x348); + fiat_25519_scalar_addcarryx_u32(&x358, &x359, x357, x349, x346); + fiat_25519_scalar_addcarryx_u32(&x360, &x361, x359, x347, x344); + fiat_25519_scalar_addcarryx_u32(&x362, &x363, x361, x345, x342); + fiat_25519_scalar_addcarryx_u32(&x364, &x365, x363, x343, x340); + fiat_25519_scalar_addcarryx_u32(&x366, &x367, x365, x341, x338); + x368 = (x367 + x339); + fiat_25519_scalar_addcarryx_u32(&x369, &x370, 0x0, x321, x352); + fiat_25519_scalar_addcarryx_u32(&x371, &x372, x370, x323, x354); + fiat_25519_scalar_addcarryx_u32(&x373, &x374, x372, x325, x356); + fiat_25519_scalar_addcarryx_u32(&x375, &x376, x374, x327, x358); + fiat_25519_scalar_addcarryx_u32(&x377, &x378, x376, x329, x360); + fiat_25519_scalar_addcarryx_u32(&x379, &x380, x378, x331, x362); + fiat_25519_scalar_addcarryx_u32(&x381, &x382, x380, x333, x364); + fiat_25519_scalar_addcarryx_u32(&x383, &x384, x382, x335, x366); + fiat_25519_scalar_addcarryx_u32(&x385, &x386, x384, x337, x368); + fiat_25519_scalar_mulx_u32(&x387, &x388, x369, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x389, &x390, x387, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x391, &x392, x387, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x393, &x394, x387, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x395, &x396, x387, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x397, &x398, x387, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x399, &x400, 0x0, x398, x395); + fiat_25519_scalar_addcarryx_u32(&x401, &x402, x400, x396, x393); + fiat_25519_scalar_addcarryx_u32(&x403, &x404, x402, x394, x391); + x405 = (x404 + x392); + fiat_25519_scalar_addcarryx_u32(&x406, &x407, 0x0, x369, x397); + fiat_25519_scalar_addcarryx_u32(&x408, &x409, x407, x371, x399); + fiat_25519_scalar_addcarryx_u32(&x410, &x411, x409, x373, x401); + fiat_25519_scalar_addcarryx_u32(&x412, &x413, x411, x375, x403); + fiat_25519_scalar_addcarryx_u32(&x414, &x415, x413, x377, x405); + fiat_25519_scalar_addcarryx_u32(&x416, &x417, x415, x379, 0x0); + fiat_25519_scalar_addcarryx_u32(&x418, &x419, x417, x381, 0x0); + fiat_25519_scalar_addcarryx_u32(&x420, &x421, x419, x383, x389); + fiat_25519_scalar_addcarryx_u32(&x422, &x423, x421, x385, x390); + x424 = ((uint32_t)x423 + x386); + fiat_25519_scalar_mulx_u32(&x425, &x426, x5, (arg2[7])); + fiat_25519_scalar_mulx_u32(&x427, &x428, x5, (arg2[6])); + fiat_25519_scalar_mulx_u32(&x429, &x430, x5, (arg2[5])); + fiat_25519_scalar_mulx_u32(&x431, &x432, x5, (arg2[4])); + fiat_25519_scalar_mulx_u32(&x433, &x434, x5, (arg2[3])); + fiat_25519_scalar_mulx_u32(&x435, &x436, x5, (arg2[2])); + fiat_25519_scalar_mulx_u32(&x437, &x438, x5, (arg2[1])); + fiat_25519_scalar_mulx_u32(&x439, &x440, x5, (arg2[0])); + fiat_25519_scalar_addcarryx_u32(&x441, &x442, 0x0, x440, x437); + fiat_25519_scalar_addcarryx_u32(&x443, &x444, x442, x438, x435); + fiat_25519_scalar_addcarryx_u32(&x445, &x446, x444, x436, x433); + fiat_25519_scalar_addcarryx_u32(&x447, &x448, x446, x434, x431); + fiat_25519_scalar_addcarryx_u32(&x449, &x450, x448, x432, x429); + fiat_25519_scalar_addcarryx_u32(&x451, &x452, x450, x430, x427); + fiat_25519_scalar_addcarryx_u32(&x453, &x454, x452, x428, x425); + x455 = (x454 + x426); + fiat_25519_scalar_addcarryx_u32(&x456, &x457, 0x0, x408, x439); + fiat_25519_scalar_addcarryx_u32(&x458, &x459, x457, x410, x441); + fiat_25519_scalar_addcarryx_u32(&x460, &x461, x459, x412, x443); + fiat_25519_scalar_addcarryx_u32(&x462, &x463, x461, x414, x445); + fiat_25519_scalar_addcarryx_u32(&x464, &x465, x463, x416, x447); + fiat_25519_scalar_addcarryx_u32(&x466, &x467, x465, x418, x449); + fiat_25519_scalar_addcarryx_u32(&x468, &x469, x467, x420, x451); + fiat_25519_scalar_addcarryx_u32(&x470, &x471, x469, x422, x453); + fiat_25519_scalar_addcarryx_u32(&x472, &x473, x471, x424, x455); + fiat_25519_scalar_mulx_u32(&x474, &x475, x456, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x476, &x477, x474, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x478, &x479, x474, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x480, &x481, x474, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x482, &x483, x474, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x484, &x485, x474, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x486, &x487, 0x0, x485, x482); + fiat_25519_scalar_addcarryx_u32(&x488, &x489, x487, x483, x480); + fiat_25519_scalar_addcarryx_u32(&x490, &x491, x489, x481, x478); + x492 = (x491 + x479); + fiat_25519_scalar_addcarryx_u32(&x493, &x494, 0x0, x456, x484); + fiat_25519_scalar_addcarryx_u32(&x495, &x496, x494, x458, x486); + fiat_25519_scalar_addcarryx_u32(&x497, &x498, x496, x460, x488); + fiat_25519_scalar_addcarryx_u32(&x499, &x500, x498, x462, x490); + fiat_25519_scalar_addcarryx_u32(&x501, &x502, x500, x464, x492); + fiat_25519_scalar_addcarryx_u32(&x503, &x504, x502, x466, 0x0); + fiat_25519_scalar_addcarryx_u32(&x505, &x506, x504, x468, 0x0); + fiat_25519_scalar_addcarryx_u32(&x507, &x508, x506, x470, x476); + fiat_25519_scalar_addcarryx_u32(&x509, &x510, x508, x472, x477); + x511 = ((uint32_t)x510 + x473); + fiat_25519_scalar_mulx_u32(&x512, &x513, x6, (arg2[7])); + fiat_25519_scalar_mulx_u32(&x514, &x515, x6, (arg2[6])); + fiat_25519_scalar_mulx_u32(&x516, &x517, x6, (arg2[5])); + fiat_25519_scalar_mulx_u32(&x518, &x519, x6, (arg2[4])); + fiat_25519_scalar_mulx_u32(&x520, &x521, x6, (arg2[3])); + fiat_25519_scalar_mulx_u32(&x522, &x523, x6, (arg2[2])); + fiat_25519_scalar_mulx_u32(&x524, &x525, x6, (arg2[1])); + fiat_25519_scalar_mulx_u32(&x526, &x527, x6, (arg2[0])); + fiat_25519_scalar_addcarryx_u32(&x528, &x529, 0x0, x527, x524); + fiat_25519_scalar_addcarryx_u32(&x530, &x531, x529, x525, x522); + fiat_25519_scalar_addcarryx_u32(&x532, &x533, x531, x523, x520); + fiat_25519_scalar_addcarryx_u32(&x534, &x535, x533, x521, x518); + fiat_25519_scalar_addcarryx_u32(&x536, &x537, x535, x519, x516); + fiat_25519_scalar_addcarryx_u32(&x538, &x539, x537, x517, x514); + fiat_25519_scalar_addcarryx_u32(&x540, &x541, x539, x515, x512); + x542 = (x541 + x513); + fiat_25519_scalar_addcarryx_u32(&x543, &x544, 0x0, x495, x526); + fiat_25519_scalar_addcarryx_u32(&x545, &x546, x544, x497, x528); + fiat_25519_scalar_addcarryx_u32(&x547, &x548, x546, x499, x530); + fiat_25519_scalar_addcarryx_u32(&x549, &x550, x548, x501, x532); + fiat_25519_scalar_addcarryx_u32(&x551, &x552, x550, x503, x534); + fiat_25519_scalar_addcarryx_u32(&x553, &x554, x552, x505, x536); + fiat_25519_scalar_addcarryx_u32(&x555, &x556, x554, x507, x538); + fiat_25519_scalar_addcarryx_u32(&x557, &x558, x556, x509, x540); + fiat_25519_scalar_addcarryx_u32(&x559, &x560, x558, x511, x542); + fiat_25519_scalar_mulx_u32(&x561, &x562, x543, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x563, &x564, x561, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x565, &x566, x561, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x567, &x568, x561, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x569, &x570, x561, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x571, &x572, x561, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x573, &x574, 0x0, x572, x569); + fiat_25519_scalar_addcarryx_u32(&x575, &x576, x574, x570, x567); + fiat_25519_scalar_addcarryx_u32(&x577, &x578, x576, x568, x565); + x579 = (x578 + x566); + fiat_25519_scalar_addcarryx_u32(&x580, &x581, 0x0, x543, x571); + fiat_25519_scalar_addcarryx_u32(&x582, &x583, x581, x545, x573); + fiat_25519_scalar_addcarryx_u32(&x584, &x585, x583, x547, x575); + fiat_25519_scalar_addcarryx_u32(&x586, &x587, x585, x549, x577); + fiat_25519_scalar_addcarryx_u32(&x588, &x589, x587, x551, x579); + fiat_25519_scalar_addcarryx_u32(&x590, &x591, x589, x553, 0x0); + fiat_25519_scalar_addcarryx_u32(&x592, &x593, x591, x555, 0x0); + fiat_25519_scalar_addcarryx_u32(&x594, &x595, x593, x557, x563); + fiat_25519_scalar_addcarryx_u32(&x596, &x597, x595, x559, x564); + x598 = ((uint32_t)x597 + x560); + fiat_25519_scalar_mulx_u32(&x599, &x600, x7, (arg2[7])); + fiat_25519_scalar_mulx_u32(&x601, &x602, x7, (arg2[6])); + fiat_25519_scalar_mulx_u32(&x603, &x604, x7, (arg2[5])); + fiat_25519_scalar_mulx_u32(&x605, &x606, x7, (arg2[4])); + fiat_25519_scalar_mulx_u32(&x607, &x608, x7, (arg2[3])); + fiat_25519_scalar_mulx_u32(&x609, &x610, x7, (arg2[2])); + fiat_25519_scalar_mulx_u32(&x611, &x612, x7, (arg2[1])); + fiat_25519_scalar_mulx_u32(&x613, &x614, x7, (arg2[0])); + fiat_25519_scalar_addcarryx_u32(&x615, &x616, 0x0, x614, x611); + fiat_25519_scalar_addcarryx_u32(&x617, &x618, x616, x612, x609); + fiat_25519_scalar_addcarryx_u32(&x619, &x620, x618, x610, x607); + fiat_25519_scalar_addcarryx_u32(&x621, &x622, x620, x608, x605); + fiat_25519_scalar_addcarryx_u32(&x623, &x624, x622, x606, x603); + fiat_25519_scalar_addcarryx_u32(&x625, &x626, x624, x604, x601); + fiat_25519_scalar_addcarryx_u32(&x627, &x628, x626, x602, x599); + x629 = (x628 + x600); + fiat_25519_scalar_addcarryx_u32(&x630, &x631, 0x0, x582, x613); + fiat_25519_scalar_addcarryx_u32(&x632, &x633, x631, x584, x615); + fiat_25519_scalar_addcarryx_u32(&x634, &x635, x633, x586, x617); + fiat_25519_scalar_addcarryx_u32(&x636, &x637, x635, x588, x619); + fiat_25519_scalar_addcarryx_u32(&x638, &x639, x637, x590, x621); + fiat_25519_scalar_addcarryx_u32(&x640, &x641, x639, x592, x623); + fiat_25519_scalar_addcarryx_u32(&x642, &x643, x641, x594, x625); + fiat_25519_scalar_addcarryx_u32(&x644, &x645, x643, x596, x627); + fiat_25519_scalar_addcarryx_u32(&x646, &x647, x645, x598, x629); + fiat_25519_scalar_mulx_u32(&x648, &x649, x630, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x650, &x651, x648, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x652, &x653, x648, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x654, &x655, x648, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x656, &x657, x648, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x658, &x659, x648, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x660, &x661, 0x0, x659, x656); + fiat_25519_scalar_addcarryx_u32(&x662, &x663, x661, x657, x654); + fiat_25519_scalar_addcarryx_u32(&x664, &x665, x663, x655, x652); + x666 = (x665 + x653); + fiat_25519_scalar_addcarryx_u32(&x667, &x668, 0x0, x630, x658); + fiat_25519_scalar_addcarryx_u32(&x669, &x670, x668, x632, x660); + fiat_25519_scalar_addcarryx_u32(&x671, &x672, x670, x634, x662); + fiat_25519_scalar_addcarryx_u32(&x673, &x674, x672, x636, x664); + fiat_25519_scalar_addcarryx_u32(&x675, &x676, x674, x638, x666); + fiat_25519_scalar_addcarryx_u32(&x677, &x678, x676, x640, 0x0); + fiat_25519_scalar_addcarryx_u32(&x679, &x680, x678, x642, 0x0); + fiat_25519_scalar_addcarryx_u32(&x681, &x682, x680, x644, x650); + fiat_25519_scalar_addcarryx_u32(&x683, &x684, x682, x646, x651); + x685 = ((uint32_t)x684 + x647); + fiat_25519_scalar_subborrowx_u32(&x686, &x687, 0x0, x669, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_subborrowx_u32(&x688, &x689, x687, x671, UINT32_C(0x5812631a)); + fiat_25519_scalar_subborrowx_u32(&x690, &x691, x689, x673, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_subborrowx_u32(&x692, &x693, x691, x675, UINT32_C(0x14def9de)); + fiat_25519_scalar_subborrowx_u32(&x694, &x695, x693, x677, 0x0); + fiat_25519_scalar_subborrowx_u32(&x696, &x697, x695, x679, 0x0); + fiat_25519_scalar_subborrowx_u32(&x698, &x699, x697, x681, 0x0); + fiat_25519_scalar_subborrowx_u32(&x700, &x701, x699, x683, UINT32_C(0x10000000)); + fiat_25519_scalar_subborrowx_u32(&x702, &x703, x701, x685, 0x0); + fiat_25519_scalar_cmovznz_u32(&x704, x703, x686, x669); + fiat_25519_scalar_cmovznz_u32(&x705, x703, x688, x671); + fiat_25519_scalar_cmovznz_u32(&x706, x703, x690, x673); + fiat_25519_scalar_cmovznz_u32(&x707, x703, x692, x675); + fiat_25519_scalar_cmovznz_u32(&x708, x703, x694, x677); + fiat_25519_scalar_cmovznz_u32(&x709, x703, x696, x679); + fiat_25519_scalar_cmovznz_u32(&x710, x703, x698, x681); + fiat_25519_scalar_cmovznz_u32(&x711, x703, x700, x683); + out1[0] = x704; + out1[1] = x705; + out1[2] = x706; + out1[3] = x707; + out1[4] = x708; + out1[5] = x709; + out1[6] = x710; + out1[7] = x711; +} + +/* + * The function fiat_25519_scalar_square squares a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_square(fiat_25519_scalar_montgomery_domain_field_element out1, const fiat_25519_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + fiat_25519_scalar_uint1 x26; + uint32_t x27; + fiat_25519_scalar_uint1 x28; + uint32_t x29; + fiat_25519_scalar_uint1 x30; + uint32_t x31; + fiat_25519_scalar_uint1 x32; + uint32_t x33; + fiat_25519_scalar_uint1 x34; + uint32_t x35; + fiat_25519_scalar_uint1 x36; + uint32_t x37; + fiat_25519_scalar_uint1 x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + fiat_25519_scalar_uint1 x53; + uint32_t x54; + fiat_25519_scalar_uint1 x55; + uint32_t x56; + fiat_25519_scalar_uint1 x57; + uint32_t x58; + uint32_t x59; + fiat_25519_scalar_uint1 x60; + uint32_t x61; + fiat_25519_scalar_uint1 x62; + uint32_t x63; + fiat_25519_scalar_uint1 x64; + uint32_t x65; + fiat_25519_scalar_uint1 x66; + uint32_t x67; + fiat_25519_scalar_uint1 x68; + uint32_t x69; + fiat_25519_scalar_uint1 x70; + uint32_t x71; + fiat_25519_scalar_uint1 x72; + uint32_t x73; + fiat_25519_scalar_uint1 x74; + uint32_t x75; + fiat_25519_scalar_uint1 x76; + uint32_t x77; + uint32_t x78; + uint32_t x79; + uint32_t x80; + uint32_t x81; + uint32_t x82; + uint32_t x83; + uint32_t x84; + uint32_t x85; + uint32_t x86; + uint32_t x87; + uint32_t x88; + uint32_t x89; + uint32_t x90; + uint32_t x91; + uint32_t x92; + uint32_t x93; + fiat_25519_scalar_uint1 x94; + uint32_t x95; + fiat_25519_scalar_uint1 x96; + uint32_t x97; + fiat_25519_scalar_uint1 x98; + uint32_t x99; + fiat_25519_scalar_uint1 x100; + uint32_t x101; + fiat_25519_scalar_uint1 x102; + uint32_t x103; + fiat_25519_scalar_uint1 x104; + uint32_t x105; + fiat_25519_scalar_uint1 x106; + uint32_t x107; + uint32_t x108; + fiat_25519_scalar_uint1 x109; + uint32_t x110; + fiat_25519_scalar_uint1 x111; + uint32_t x112; + fiat_25519_scalar_uint1 x113; + uint32_t x114; + fiat_25519_scalar_uint1 x115; + uint32_t x116; + fiat_25519_scalar_uint1 x117; + uint32_t x118; + fiat_25519_scalar_uint1 x119; + uint32_t x120; + fiat_25519_scalar_uint1 x121; + uint32_t x122; + fiat_25519_scalar_uint1 x123; + uint32_t x124; + fiat_25519_scalar_uint1 x125; + uint32_t x126; + uint32_t x127; + uint32_t x128; + uint32_t x129; + uint32_t x130; + uint32_t x131; + uint32_t x132; + uint32_t x133; + uint32_t x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + fiat_25519_scalar_uint1 x139; + uint32_t x140; + fiat_25519_scalar_uint1 x141; + uint32_t x142; + fiat_25519_scalar_uint1 x143; + uint32_t x144; + uint32_t x145; + fiat_25519_scalar_uint1 x146; + uint32_t x147; + fiat_25519_scalar_uint1 x148; + uint32_t x149; + fiat_25519_scalar_uint1 x150; + uint32_t x151; + fiat_25519_scalar_uint1 x152; + uint32_t x153; + fiat_25519_scalar_uint1 x154; + uint32_t x155; + fiat_25519_scalar_uint1 x156; + uint32_t x157; + fiat_25519_scalar_uint1 x158; + uint32_t x159; + fiat_25519_scalar_uint1 x160; + uint32_t x161; + fiat_25519_scalar_uint1 x162; + uint32_t x163; + uint32_t x164; + uint32_t x165; + uint32_t x166; + uint32_t x167; + uint32_t x168; + uint32_t x169; + uint32_t x170; + uint32_t x171; + uint32_t x172; + uint32_t x173; + uint32_t x174; + uint32_t x175; + uint32_t x176; + uint32_t x177; + uint32_t x178; + uint32_t x179; + uint32_t x180; + fiat_25519_scalar_uint1 x181; + uint32_t x182; + fiat_25519_scalar_uint1 x183; + uint32_t x184; + fiat_25519_scalar_uint1 x185; + uint32_t x186; + fiat_25519_scalar_uint1 x187; + uint32_t x188; + fiat_25519_scalar_uint1 x189; + uint32_t x190; + fiat_25519_scalar_uint1 x191; + uint32_t x192; + fiat_25519_scalar_uint1 x193; + uint32_t x194; + uint32_t x195; + fiat_25519_scalar_uint1 x196; + uint32_t x197; + fiat_25519_scalar_uint1 x198; + uint32_t x199; + fiat_25519_scalar_uint1 x200; + uint32_t x201; + fiat_25519_scalar_uint1 x202; + uint32_t x203; + fiat_25519_scalar_uint1 x204; + uint32_t x205; + fiat_25519_scalar_uint1 x206; + uint32_t x207; + fiat_25519_scalar_uint1 x208; + uint32_t x209; + fiat_25519_scalar_uint1 x210; + uint32_t x211; + fiat_25519_scalar_uint1 x212; + uint32_t x213; + uint32_t x214; + uint32_t x215; + uint32_t x216; + uint32_t x217; + uint32_t x218; + uint32_t x219; + uint32_t x220; + uint32_t x221; + uint32_t x222; + uint32_t x223; + uint32_t x224; + uint32_t x225; + fiat_25519_scalar_uint1 x226; + uint32_t x227; + fiat_25519_scalar_uint1 x228; + uint32_t x229; + fiat_25519_scalar_uint1 x230; + uint32_t x231; + uint32_t x232; + fiat_25519_scalar_uint1 x233; + uint32_t x234; + fiat_25519_scalar_uint1 x235; + uint32_t x236; + fiat_25519_scalar_uint1 x237; + uint32_t x238; + fiat_25519_scalar_uint1 x239; + uint32_t x240; + fiat_25519_scalar_uint1 x241; + uint32_t x242; + fiat_25519_scalar_uint1 x243; + uint32_t x244; + fiat_25519_scalar_uint1 x245; + uint32_t x246; + fiat_25519_scalar_uint1 x247; + uint32_t x248; + fiat_25519_scalar_uint1 x249; + uint32_t x250; + uint32_t x251; + uint32_t x252; + uint32_t x253; + uint32_t x254; + uint32_t x255; + uint32_t x256; + uint32_t x257; + uint32_t x258; + uint32_t x259; + uint32_t x260; + uint32_t x261; + uint32_t x262; + uint32_t x263; + uint32_t x264; + uint32_t x265; + uint32_t x266; + uint32_t x267; + fiat_25519_scalar_uint1 x268; + uint32_t x269; + fiat_25519_scalar_uint1 x270; + uint32_t x271; + fiat_25519_scalar_uint1 x272; + uint32_t x273; + fiat_25519_scalar_uint1 x274; + uint32_t x275; + fiat_25519_scalar_uint1 x276; + uint32_t x277; + fiat_25519_scalar_uint1 x278; + uint32_t x279; + fiat_25519_scalar_uint1 x280; + uint32_t x281; + uint32_t x282; + fiat_25519_scalar_uint1 x283; + uint32_t x284; + fiat_25519_scalar_uint1 x285; + uint32_t x286; + fiat_25519_scalar_uint1 x287; + uint32_t x288; + fiat_25519_scalar_uint1 x289; + uint32_t x290; + fiat_25519_scalar_uint1 x291; + uint32_t x292; + fiat_25519_scalar_uint1 x293; + uint32_t x294; + fiat_25519_scalar_uint1 x295; + uint32_t x296; + fiat_25519_scalar_uint1 x297; + uint32_t x298; + fiat_25519_scalar_uint1 x299; + uint32_t x300; + uint32_t x301; + uint32_t x302; + uint32_t x303; + uint32_t x304; + uint32_t x305; + uint32_t x306; + uint32_t x307; + uint32_t x308; + uint32_t x309; + uint32_t x310; + uint32_t x311; + uint32_t x312; + fiat_25519_scalar_uint1 x313; + uint32_t x314; + fiat_25519_scalar_uint1 x315; + uint32_t x316; + fiat_25519_scalar_uint1 x317; + uint32_t x318; + uint32_t x319; + fiat_25519_scalar_uint1 x320; + uint32_t x321; + fiat_25519_scalar_uint1 x322; + uint32_t x323; + fiat_25519_scalar_uint1 x324; + uint32_t x325; + fiat_25519_scalar_uint1 x326; + uint32_t x327; + fiat_25519_scalar_uint1 x328; + uint32_t x329; + fiat_25519_scalar_uint1 x330; + uint32_t x331; + fiat_25519_scalar_uint1 x332; + uint32_t x333; + fiat_25519_scalar_uint1 x334; + uint32_t x335; + fiat_25519_scalar_uint1 x336; + uint32_t x337; + uint32_t x338; + uint32_t x339; + uint32_t x340; + uint32_t x341; + uint32_t x342; + uint32_t x343; + uint32_t x344; + uint32_t x345; + uint32_t x346; + uint32_t x347; + uint32_t x348; + uint32_t x349; + uint32_t x350; + uint32_t x351; + uint32_t x352; + uint32_t x353; + uint32_t x354; + fiat_25519_scalar_uint1 x355; + uint32_t x356; + fiat_25519_scalar_uint1 x357; + uint32_t x358; + fiat_25519_scalar_uint1 x359; + uint32_t x360; + fiat_25519_scalar_uint1 x361; + uint32_t x362; + fiat_25519_scalar_uint1 x363; + uint32_t x364; + fiat_25519_scalar_uint1 x365; + uint32_t x366; + fiat_25519_scalar_uint1 x367; + uint32_t x368; + uint32_t x369; + fiat_25519_scalar_uint1 x370; + uint32_t x371; + fiat_25519_scalar_uint1 x372; + uint32_t x373; + fiat_25519_scalar_uint1 x374; + uint32_t x375; + fiat_25519_scalar_uint1 x376; + uint32_t x377; + fiat_25519_scalar_uint1 x378; + uint32_t x379; + fiat_25519_scalar_uint1 x380; + uint32_t x381; + fiat_25519_scalar_uint1 x382; + uint32_t x383; + fiat_25519_scalar_uint1 x384; + uint32_t x385; + fiat_25519_scalar_uint1 x386; + uint32_t x387; + uint32_t x388; + uint32_t x389; + uint32_t x390; + uint32_t x391; + uint32_t x392; + uint32_t x393; + uint32_t x394; + uint32_t x395; + uint32_t x396; + uint32_t x397; + uint32_t x398; + uint32_t x399; + fiat_25519_scalar_uint1 x400; + uint32_t x401; + fiat_25519_scalar_uint1 x402; + uint32_t x403; + fiat_25519_scalar_uint1 x404; + uint32_t x405; + uint32_t x406; + fiat_25519_scalar_uint1 x407; + uint32_t x408; + fiat_25519_scalar_uint1 x409; + uint32_t x410; + fiat_25519_scalar_uint1 x411; + uint32_t x412; + fiat_25519_scalar_uint1 x413; + uint32_t x414; + fiat_25519_scalar_uint1 x415; + uint32_t x416; + fiat_25519_scalar_uint1 x417; + uint32_t x418; + fiat_25519_scalar_uint1 x419; + uint32_t x420; + fiat_25519_scalar_uint1 x421; + uint32_t x422; + fiat_25519_scalar_uint1 x423; + uint32_t x424; + uint32_t x425; + uint32_t x426; + uint32_t x427; + uint32_t x428; + uint32_t x429; + uint32_t x430; + uint32_t x431; + uint32_t x432; + uint32_t x433; + uint32_t x434; + uint32_t x435; + uint32_t x436; + uint32_t x437; + uint32_t x438; + uint32_t x439; + uint32_t x440; + uint32_t x441; + fiat_25519_scalar_uint1 x442; + uint32_t x443; + fiat_25519_scalar_uint1 x444; + uint32_t x445; + fiat_25519_scalar_uint1 x446; + uint32_t x447; + fiat_25519_scalar_uint1 x448; + uint32_t x449; + fiat_25519_scalar_uint1 x450; + uint32_t x451; + fiat_25519_scalar_uint1 x452; + uint32_t x453; + fiat_25519_scalar_uint1 x454; + uint32_t x455; + uint32_t x456; + fiat_25519_scalar_uint1 x457; + uint32_t x458; + fiat_25519_scalar_uint1 x459; + uint32_t x460; + fiat_25519_scalar_uint1 x461; + uint32_t x462; + fiat_25519_scalar_uint1 x463; + uint32_t x464; + fiat_25519_scalar_uint1 x465; + uint32_t x466; + fiat_25519_scalar_uint1 x467; + uint32_t x468; + fiat_25519_scalar_uint1 x469; + uint32_t x470; + fiat_25519_scalar_uint1 x471; + uint32_t x472; + fiat_25519_scalar_uint1 x473; + uint32_t x474; + uint32_t x475; + uint32_t x476; + uint32_t x477; + uint32_t x478; + uint32_t x479; + uint32_t x480; + uint32_t x481; + uint32_t x482; + uint32_t x483; + uint32_t x484; + uint32_t x485; + uint32_t x486; + fiat_25519_scalar_uint1 x487; + uint32_t x488; + fiat_25519_scalar_uint1 x489; + uint32_t x490; + fiat_25519_scalar_uint1 x491; + uint32_t x492; + uint32_t x493; + fiat_25519_scalar_uint1 x494; + uint32_t x495; + fiat_25519_scalar_uint1 x496; + uint32_t x497; + fiat_25519_scalar_uint1 x498; + uint32_t x499; + fiat_25519_scalar_uint1 x500; + uint32_t x501; + fiat_25519_scalar_uint1 x502; + uint32_t x503; + fiat_25519_scalar_uint1 x504; + uint32_t x505; + fiat_25519_scalar_uint1 x506; + uint32_t x507; + fiat_25519_scalar_uint1 x508; + uint32_t x509; + fiat_25519_scalar_uint1 x510; + uint32_t x511; + uint32_t x512; + uint32_t x513; + uint32_t x514; + uint32_t x515; + uint32_t x516; + uint32_t x517; + uint32_t x518; + uint32_t x519; + uint32_t x520; + uint32_t x521; + uint32_t x522; + uint32_t x523; + uint32_t x524; + uint32_t x525; + uint32_t x526; + uint32_t x527; + uint32_t x528; + fiat_25519_scalar_uint1 x529; + uint32_t x530; + fiat_25519_scalar_uint1 x531; + uint32_t x532; + fiat_25519_scalar_uint1 x533; + uint32_t x534; + fiat_25519_scalar_uint1 x535; + uint32_t x536; + fiat_25519_scalar_uint1 x537; + uint32_t x538; + fiat_25519_scalar_uint1 x539; + uint32_t x540; + fiat_25519_scalar_uint1 x541; + uint32_t x542; + uint32_t x543; + fiat_25519_scalar_uint1 x544; + uint32_t x545; + fiat_25519_scalar_uint1 x546; + uint32_t x547; + fiat_25519_scalar_uint1 x548; + uint32_t x549; + fiat_25519_scalar_uint1 x550; + uint32_t x551; + fiat_25519_scalar_uint1 x552; + uint32_t x553; + fiat_25519_scalar_uint1 x554; + uint32_t x555; + fiat_25519_scalar_uint1 x556; + uint32_t x557; + fiat_25519_scalar_uint1 x558; + uint32_t x559; + fiat_25519_scalar_uint1 x560; + uint32_t x561; + uint32_t x562; + uint32_t x563; + uint32_t x564; + uint32_t x565; + uint32_t x566; + uint32_t x567; + uint32_t x568; + uint32_t x569; + uint32_t x570; + uint32_t x571; + uint32_t x572; + uint32_t x573; + fiat_25519_scalar_uint1 x574; + uint32_t x575; + fiat_25519_scalar_uint1 x576; + uint32_t x577; + fiat_25519_scalar_uint1 x578; + uint32_t x579; + uint32_t x580; + fiat_25519_scalar_uint1 x581; + uint32_t x582; + fiat_25519_scalar_uint1 x583; + uint32_t x584; + fiat_25519_scalar_uint1 x585; + uint32_t x586; + fiat_25519_scalar_uint1 x587; + uint32_t x588; + fiat_25519_scalar_uint1 x589; + uint32_t x590; + fiat_25519_scalar_uint1 x591; + uint32_t x592; + fiat_25519_scalar_uint1 x593; + uint32_t x594; + fiat_25519_scalar_uint1 x595; + uint32_t x596; + fiat_25519_scalar_uint1 x597; + uint32_t x598; + uint32_t x599; + uint32_t x600; + uint32_t x601; + uint32_t x602; + uint32_t x603; + uint32_t x604; + uint32_t x605; + uint32_t x606; + uint32_t x607; + uint32_t x608; + uint32_t x609; + uint32_t x610; + uint32_t x611; + uint32_t x612; + uint32_t x613; + uint32_t x614; + uint32_t x615; + fiat_25519_scalar_uint1 x616; + uint32_t x617; + fiat_25519_scalar_uint1 x618; + uint32_t x619; + fiat_25519_scalar_uint1 x620; + uint32_t x621; + fiat_25519_scalar_uint1 x622; + uint32_t x623; + fiat_25519_scalar_uint1 x624; + uint32_t x625; + fiat_25519_scalar_uint1 x626; + uint32_t x627; + fiat_25519_scalar_uint1 x628; + uint32_t x629; + uint32_t x630; + fiat_25519_scalar_uint1 x631; + uint32_t x632; + fiat_25519_scalar_uint1 x633; + uint32_t x634; + fiat_25519_scalar_uint1 x635; + uint32_t x636; + fiat_25519_scalar_uint1 x637; + uint32_t x638; + fiat_25519_scalar_uint1 x639; + uint32_t x640; + fiat_25519_scalar_uint1 x641; + uint32_t x642; + fiat_25519_scalar_uint1 x643; + uint32_t x644; + fiat_25519_scalar_uint1 x645; + uint32_t x646; + fiat_25519_scalar_uint1 x647; + uint32_t x648; + uint32_t x649; + uint32_t x650; + uint32_t x651; + uint32_t x652; + uint32_t x653; + uint32_t x654; + uint32_t x655; + uint32_t x656; + uint32_t x657; + uint32_t x658; + uint32_t x659; + uint32_t x660; + fiat_25519_scalar_uint1 x661; + uint32_t x662; + fiat_25519_scalar_uint1 x663; + uint32_t x664; + fiat_25519_scalar_uint1 x665; + uint32_t x666; + uint32_t x667; + fiat_25519_scalar_uint1 x668; + uint32_t x669; + fiat_25519_scalar_uint1 x670; + uint32_t x671; + fiat_25519_scalar_uint1 x672; + uint32_t x673; + fiat_25519_scalar_uint1 x674; + uint32_t x675; + fiat_25519_scalar_uint1 x676; + uint32_t x677; + fiat_25519_scalar_uint1 x678; + uint32_t x679; + fiat_25519_scalar_uint1 x680; + uint32_t x681; + fiat_25519_scalar_uint1 x682; + uint32_t x683; + fiat_25519_scalar_uint1 x684; + uint32_t x685; + uint32_t x686; + fiat_25519_scalar_uint1 x687; + uint32_t x688; + fiat_25519_scalar_uint1 x689; + uint32_t x690; + fiat_25519_scalar_uint1 x691; + uint32_t x692; + fiat_25519_scalar_uint1 x693; + uint32_t x694; + fiat_25519_scalar_uint1 x695; + uint32_t x696; + fiat_25519_scalar_uint1 x697; + uint32_t x698; + fiat_25519_scalar_uint1 x699; + uint32_t x700; + fiat_25519_scalar_uint1 x701; + uint32_t x702; + fiat_25519_scalar_uint1 x703; + uint32_t x704; + uint32_t x705; + uint32_t x706; + uint32_t x707; + uint32_t x708; + uint32_t x709; + uint32_t x710; + uint32_t x711; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[6]); + x7 = (arg1[7]); + x8 = (arg1[0]); + fiat_25519_scalar_mulx_u32(&x9, &x10, x8, (arg1[7])); + fiat_25519_scalar_mulx_u32(&x11, &x12, x8, (arg1[6])); + fiat_25519_scalar_mulx_u32(&x13, &x14, x8, (arg1[5])); + fiat_25519_scalar_mulx_u32(&x15, &x16, x8, (arg1[4])); + fiat_25519_scalar_mulx_u32(&x17, &x18, x8, (arg1[3])); + fiat_25519_scalar_mulx_u32(&x19, &x20, x8, (arg1[2])); + fiat_25519_scalar_mulx_u32(&x21, &x22, x8, (arg1[1])); + fiat_25519_scalar_mulx_u32(&x23, &x24, x8, (arg1[0])); + fiat_25519_scalar_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_25519_scalar_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_25519_scalar_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_25519_scalar_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_25519_scalar_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_25519_scalar_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_25519_scalar_addcarryx_u32(&x37, &x38, x36, x12, x9); + x39 = (x38 + x10); + fiat_25519_scalar_mulx_u32(&x40, &x41, x23, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x42, &x43, x40, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x44, &x45, x40, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x46, &x47, x40, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x48, &x49, x40, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x50, &x51, x40, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x52, &x53, 0x0, x51, x48); + fiat_25519_scalar_addcarryx_u32(&x54, &x55, x53, x49, x46); + fiat_25519_scalar_addcarryx_u32(&x56, &x57, x55, x47, x44); + x58 = (x57 + x45); + fiat_25519_scalar_addcarryx_u32(&x59, &x60, 0x0, x23, x50); + fiat_25519_scalar_addcarryx_u32(&x61, &x62, x60, x25, x52); + fiat_25519_scalar_addcarryx_u32(&x63, &x64, x62, x27, x54); + fiat_25519_scalar_addcarryx_u32(&x65, &x66, x64, x29, x56); + fiat_25519_scalar_addcarryx_u32(&x67, &x68, x66, x31, x58); + fiat_25519_scalar_addcarryx_u32(&x69, &x70, x68, x33, 0x0); + fiat_25519_scalar_addcarryx_u32(&x71, &x72, x70, x35, 0x0); + fiat_25519_scalar_addcarryx_u32(&x73, &x74, x72, x37, x42); + fiat_25519_scalar_addcarryx_u32(&x75, &x76, x74, x39, x43); + fiat_25519_scalar_mulx_u32(&x77, &x78, x1, (arg1[7])); + fiat_25519_scalar_mulx_u32(&x79, &x80, x1, (arg1[6])); + fiat_25519_scalar_mulx_u32(&x81, &x82, x1, (arg1[5])); + fiat_25519_scalar_mulx_u32(&x83, &x84, x1, (arg1[4])); + fiat_25519_scalar_mulx_u32(&x85, &x86, x1, (arg1[3])); + fiat_25519_scalar_mulx_u32(&x87, &x88, x1, (arg1[2])); + fiat_25519_scalar_mulx_u32(&x89, &x90, x1, (arg1[1])); + fiat_25519_scalar_mulx_u32(&x91, &x92, x1, (arg1[0])); + fiat_25519_scalar_addcarryx_u32(&x93, &x94, 0x0, x92, x89); + fiat_25519_scalar_addcarryx_u32(&x95, &x96, x94, x90, x87); + fiat_25519_scalar_addcarryx_u32(&x97, &x98, x96, x88, x85); + fiat_25519_scalar_addcarryx_u32(&x99, &x100, x98, x86, x83); + fiat_25519_scalar_addcarryx_u32(&x101, &x102, x100, x84, x81); + fiat_25519_scalar_addcarryx_u32(&x103, &x104, x102, x82, x79); + fiat_25519_scalar_addcarryx_u32(&x105, &x106, x104, x80, x77); + x107 = (x106 + x78); + fiat_25519_scalar_addcarryx_u32(&x108, &x109, 0x0, x61, x91); + fiat_25519_scalar_addcarryx_u32(&x110, &x111, x109, x63, x93); + fiat_25519_scalar_addcarryx_u32(&x112, &x113, x111, x65, x95); + fiat_25519_scalar_addcarryx_u32(&x114, &x115, x113, x67, x97); + fiat_25519_scalar_addcarryx_u32(&x116, &x117, x115, x69, x99); + fiat_25519_scalar_addcarryx_u32(&x118, &x119, x117, x71, x101); + fiat_25519_scalar_addcarryx_u32(&x120, &x121, x119, x73, x103); + fiat_25519_scalar_addcarryx_u32(&x122, &x123, x121, x75, x105); + fiat_25519_scalar_addcarryx_u32(&x124, &x125, x123, x76, x107); + fiat_25519_scalar_mulx_u32(&x126, &x127, x108, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x128, &x129, x126, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x130, &x131, x126, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x132, &x133, x126, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x134, &x135, x126, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x136, &x137, x126, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x138, &x139, 0x0, x137, x134); + fiat_25519_scalar_addcarryx_u32(&x140, &x141, x139, x135, x132); + fiat_25519_scalar_addcarryx_u32(&x142, &x143, x141, x133, x130); + x144 = (x143 + x131); + fiat_25519_scalar_addcarryx_u32(&x145, &x146, 0x0, x108, x136); + fiat_25519_scalar_addcarryx_u32(&x147, &x148, x146, x110, x138); + fiat_25519_scalar_addcarryx_u32(&x149, &x150, x148, x112, x140); + fiat_25519_scalar_addcarryx_u32(&x151, &x152, x150, x114, x142); + fiat_25519_scalar_addcarryx_u32(&x153, &x154, x152, x116, x144); + fiat_25519_scalar_addcarryx_u32(&x155, &x156, x154, x118, 0x0); + fiat_25519_scalar_addcarryx_u32(&x157, &x158, x156, x120, 0x0); + fiat_25519_scalar_addcarryx_u32(&x159, &x160, x158, x122, x128); + fiat_25519_scalar_addcarryx_u32(&x161, &x162, x160, x124, x129); + x163 = ((uint32_t)x162 + x125); + fiat_25519_scalar_mulx_u32(&x164, &x165, x2, (arg1[7])); + fiat_25519_scalar_mulx_u32(&x166, &x167, x2, (arg1[6])); + fiat_25519_scalar_mulx_u32(&x168, &x169, x2, (arg1[5])); + fiat_25519_scalar_mulx_u32(&x170, &x171, x2, (arg1[4])); + fiat_25519_scalar_mulx_u32(&x172, &x173, x2, (arg1[3])); + fiat_25519_scalar_mulx_u32(&x174, &x175, x2, (arg1[2])); + fiat_25519_scalar_mulx_u32(&x176, &x177, x2, (arg1[1])); + fiat_25519_scalar_mulx_u32(&x178, &x179, x2, (arg1[0])); + fiat_25519_scalar_addcarryx_u32(&x180, &x181, 0x0, x179, x176); + fiat_25519_scalar_addcarryx_u32(&x182, &x183, x181, x177, x174); + fiat_25519_scalar_addcarryx_u32(&x184, &x185, x183, x175, x172); + fiat_25519_scalar_addcarryx_u32(&x186, &x187, x185, x173, x170); + fiat_25519_scalar_addcarryx_u32(&x188, &x189, x187, x171, x168); + fiat_25519_scalar_addcarryx_u32(&x190, &x191, x189, x169, x166); + fiat_25519_scalar_addcarryx_u32(&x192, &x193, x191, x167, x164); + x194 = (x193 + x165); + fiat_25519_scalar_addcarryx_u32(&x195, &x196, 0x0, x147, x178); + fiat_25519_scalar_addcarryx_u32(&x197, &x198, x196, x149, x180); + fiat_25519_scalar_addcarryx_u32(&x199, &x200, x198, x151, x182); + fiat_25519_scalar_addcarryx_u32(&x201, &x202, x200, x153, x184); + fiat_25519_scalar_addcarryx_u32(&x203, &x204, x202, x155, x186); + fiat_25519_scalar_addcarryx_u32(&x205, &x206, x204, x157, x188); + fiat_25519_scalar_addcarryx_u32(&x207, &x208, x206, x159, x190); + fiat_25519_scalar_addcarryx_u32(&x209, &x210, x208, x161, x192); + fiat_25519_scalar_addcarryx_u32(&x211, &x212, x210, x163, x194); + fiat_25519_scalar_mulx_u32(&x213, &x214, x195, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x215, &x216, x213, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x217, &x218, x213, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x219, &x220, x213, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x221, &x222, x213, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x223, &x224, x213, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x225, &x226, 0x0, x224, x221); + fiat_25519_scalar_addcarryx_u32(&x227, &x228, x226, x222, x219); + fiat_25519_scalar_addcarryx_u32(&x229, &x230, x228, x220, x217); + x231 = (x230 + x218); + fiat_25519_scalar_addcarryx_u32(&x232, &x233, 0x0, x195, x223); + fiat_25519_scalar_addcarryx_u32(&x234, &x235, x233, x197, x225); + fiat_25519_scalar_addcarryx_u32(&x236, &x237, x235, x199, x227); + fiat_25519_scalar_addcarryx_u32(&x238, &x239, x237, x201, x229); + fiat_25519_scalar_addcarryx_u32(&x240, &x241, x239, x203, x231); + fiat_25519_scalar_addcarryx_u32(&x242, &x243, x241, x205, 0x0); + fiat_25519_scalar_addcarryx_u32(&x244, &x245, x243, x207, 0x0); + fiat_25519_scalar_addcarryx_u32(&x246, &x247, x245, x209, x215); + fiat_25519_scalar_addcarryx_u32(&x248, &x249, x247, x211, x216); + x250 = ((uint32_t)x249 + x212); + fiat_25519_scalar_mulx_u32(&x251, &x252, x3, (arg1[7])); + fiat_25519_scalar_mulx_u32(&x253, &x254, x3, (arg1[6])); + fiat_25519_scalar_mulx_u32(&x255, &x256, x3, (arg1[5])); + fiat_25519_scalar_mulx_u32(&x257, &x258, x3, (arg1[4])); + fiat_25519_scalar_mulx_u32(&x259, &x260, x3, (arg1[3])); + fiat_25519_scalar_mulx_u32(&x261, &x262, x3, (arg1[2])); + fiat_25519_scalar_mulx_u32(&x263, &x264, x3, (arg1[1])); + fiat_25519_scalar_mulx_u32(&x265, &x266, x3, (arg1[0])); + fiat_25519_scalar_addcarryx_u32(&x267, &x268, 0x0, x266, x263); + fiat_25519_scalar_addcarryx_u32(&x269, &x270, x268, x264, x261); + fiat_25519_scalar_addcarryx_u32(&x271, &x272, x270, x262, x259); + fiat_25519_scalar_addcarryx_u32(&x273, &x274, x272, x260, x257); + fiat_25519_scalar_addcarryx_u32(&x275, &x276, x274, x258, x255); + fiat_25519_scalar_addcarryx_u32(&x277, &x278, x276, x256, x253); + fiat_25519_scalar_addcarryx_u32(&x279, &x280, x278, x254, x251); + x281 = (x280 + x252); + fiat_25519_scalar_addcarryx_u32(&x282, &x283, 0x0, x234, x265); + fiat_25519_scalar_addcarryx_u32(&x284, &x285, x283, x236, x267); + fiat_25519_scalar_addcarryx_u32(&x286, &x287, x285, x238, x269); + fiat_25519_scalar_addcarryx_u32(&x288, &x289, x287, x240, x271); + fiat_25519_scalar_addcarryx_u32(&x290, &x291, x289, x242, x273); + fiat_25519_scalar_addcarryx_u32(&x292, &x293, x291, x244, x275); + fiat_25519_scalar_addcarryx_u32(&x294, &x295, x293, x246, x277); + fiat_25519_scalar_addcarryx_u32(&x296, &x297, x295, x248, x279); + fiat_25519_scalar_addcarryx_u32(&x298, &x299, x297, x250, x281); + fiat_25519_scalar_mulx_u32(&x300, &x301, x282, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x302, &x303, x300, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x304, &x305, x300, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x306, &x307, x300, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x308, &x309, x300, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x310, &x311, x300, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x312, &x313, 0x0, x311, x308); + fiat_25519_scalar_addcarryx_u32(&x314, &x315, x313, x309, x306); + fiat_25519_scalar_addcarryx_u32(&x316, &x317, x315, x307, x304); + x318 = (x317 + x305); + fiat_25519_scalar_addcarryx_u32(&x319, &x320, 0x0, x282, x310); + fiat_25519_scalar_addcarryx_u32(&x321, &x322, x320, x284, x312); + fiat_25519_scalar_addcarryx_u32(&x323, &x324, x322, x286, x314); + fiat_25519_scalar_addcarryx_u32(&x325, &x326, x324, x288, x316); + fiat_25519_scalar_addcarryx_u32(&x327, &x328, x326, x290, x318); + fiat_25519_scalar_addcarryx_u32(&x329, &x330, x328, x292, 0x0); + fiat_25519_scalar_addcarryx_u32(&x331, &x332, x330, x294, 0x0); + fiat_25519_scalar_addcarryx_u32(&x333, &x334, x332, x296, x302); + fiat_25519_scalar_addcarryx_u32(&x335, &x336, x334, x298, x303); + x337 = ((uint32_t)x336 + x299); + fiat_25519_scalar_mulx_u32(&x338, &x339, x4, (arg1[7])); + fiat_25519_scalar_mulx_u32(&x340, &x341, x4, (arg1[6])); + fiat_25519_scalar_mulx_u32(&x342, &x343, x4, (arg1[5])); + fiat_25519_scalar_mulx_u32(&x344, &x345, x4, (arg1[4])); + fiat_25519_scalar_mulx_u32(&x346, &x347, x4, (arg1[3])); + fiat_25519_scalar_mulx_u32(&x348, &x349, x4, (arg1[2])); + fiat_25519_scalar_mulx_u32(&x350, &x351, x4, (arg1[1])); + fiat_25519_scalar_mulx_u32(&x352, &x353, x4, (arg1[0])); + fiat_25519_scalar_addcarryx_u32(&x354, &x355, 0x0, x353, x350); + fiat_25519_scalar_addcarryx_u32(&x356, &x357, x355, x351, x348); + fiat_25519_scalar_addcarryx_u32(&x358, &x359, x357, x349, x346); + fiat_25519_scalar_addcarryx_u32(&x360, &x361, x359, x347, x344); + fiat_25519_scalar_addcarryx_u32(&x362, &x363, x361, x345, x342); + fiat_25519_scalar_addcarryx_u32(&x364, &x365, x363, x343, x340); + fiat_25519_scalar_addcarryx_u32(&x366, &x367, x365, x341, x338); + x368 = (x367 + x339); + fiat_25519_scalar_addcarryx_u32(&x369, &x370, 0x0, x321, x352); + fiat_25519_scalar_addcarryx_u32(&x371, &x372, x370, x323, x354); + fiat_25519_scalar_addcarryx_u32(&x373, &x374, x372, x325, x356); + fiat_25519_scalar_addcarryx_u32(&x375, &x376, x374, x327, x358); + fiat_25519_scalar_addcarryx_u32(&x377, &x378, x376, x329, x360); + fiat_25519_scalar_addcarryx_u32(&x379, &x380, x378, x331, x362); + fiat_25519_scalar_addcarryx_u32(&x381, &x382, x380, x333, x364); + fiat_25519_scalar_addcarryx_u32(&x383, &x384, x382, x335, x366); + fiat_25519_scalar_addcarryx_u32(&x385, &x386, x384, x337, x368); + fiat_25519_scalar_mulx_u32(&x387, &x388, x369, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x389, &x390, x387, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x391, &x392, x387, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x393, &x394, x387, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x395, &x396, x387, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x397, &x398, x387, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x399, &x400, 0x0, x398, x395); + fiat_25519_scalar_addcarryx_u32(&x401, &x402, x400, x396, x393); + fiat_25519_scalar_addcarryx_u32(&x403, &x404, x402, x394, x391); + x405 = (x404 + x392); + fiat_25519_scalar_addcarryx_u32(&x406, &x407, 0x0, x369, x397); + fiat_25519_scalar_addcarryx_u32(&x408, &x409, x407, x371, x399); + fiat_25519_scalar_addcarryx_u32(&x410, &x411, x409, x373, x401); + fiat_25519_scalar_addcarryx_u32(&x412, &x413, x411, x375, x403); + fiat_25519_scalar_addcarryx_u32(&x414, &x415, x413, x377, x405); + fiat_25519_scalar_addcarryx_u32(&x416, &x417, x415, x379, 0x0); + fiat_25519_scalar_addcarryx_u32(&x418, &x419, x417, x381, 0x0); + fiat_25519_scalar_addcarryx_u32(&x420, &x421, x419, x383, x389); + fiat_25519_scalar_addcarryx_u32(&x422, &x423, x421, x385, x390); + x424 = ((uint32_t)x423 + x386); + fiat_25519_scalar_mulx_u32(&x425, &x426, x5, (arg1[7])); + fiat_25519_scalar_mulx_u32(&x427, &x428, x5, (arg1[6])); + fiat_25519_scalar_mulx_u32(&x429, &x430, x5, (arg1[5])); + fiat_25519_scalar_mulx_u32(&x431, &x432, x5, (arg1[4])); + fiat_25519_scalar_mulx_u32(&x433, &x434, x5, (arg1[3])); + fiat_25519_scalar_mulx_u32(&x435, &x436, x5, (arg1[2])); + fiat_25519_scalar_mulx_u32(&x437, &x438, x5, (arg1[1])); + fiat_25519_scalar_mulx_u32(&x439, &x440, x5, (arg1[0])); + fiat_25519_scalar_addcarryx_u32(&x441, &x442, 0x0, x440, x437); + fiat_25519_scalar_addcarryx_u32(&x443, &x444, x442, x438, x435); + fiat_25519_scalar_addcarryx_u32(&x445, &x446, x444, x436, x433); + fiat_25519_scalar_addcarryx_u32(&x447, &x448, x446, x434, x431); + fiat_25519_scalar_addcarryx_u32(&x449, &x450, x448, x432, x429); + fiat_25519_scalar_addcarryx_u32(&x451, &x452, x450, x430, x427); + fiat_25519_scalar_addcarryx_u32(&x453, &x454, x452, x428, x425); + x455 = (x454 + x426); + fiat_25519_scalar_addcarryx_u32(&x456, &x457, 0x0, x408, x439); + fiat_25519_scalar_addcarryx_u32(&x458, &x459, x457, x410, x441); + fiat_25519_scalar_addcarryx_u32(&x460, &x461, x459, x412, x443); + fiat_25519_scalar_addcarryx_u32(&x462, &x463, x461, x414, x445); + fiat_25519_scalar_addcarryx_u32(&x464, &x465, x463, x416, x447); + fiat_25519_scalar_addcarryx_u32(&x466, &x467, x465, x418, x449); + fiat_25519_scalar_addcarryx_u32(&x468, &x469, x467, x420, x451); + fiat_25519_scalar_addcarryx_u32(&x470, &x471, x469, x422, x453); + fiat_25519_scalar_addcarryx_u32(&x472, &x473, x471, x424, x455); + fiat_25519_scalar_mulx_u32(&x474, &x475, x456, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x476, &x477, x474, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x478, &x479, x474, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x480, &x481, x474, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x482, &x483, x474, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x484, &x485, x474, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x486, &x487, 0x0, x485, x482); + fiat_25519_scalar_addcarryx_u32(&x488, &x489, x487, x483, x480); + fiat_25519_scalar_addcarryx_u32(&x490, &x491, x489, x481, x478); + x492 = (x491 + x479); + fiat_25519_scalar_addcarryx_u32(&x493, &x494, 0x0, x456, x484); + fiat_25519_scalar_addcarryx_u32(&x495, &x496, x494, x458, x486); + fiat_25519_scalar_addcarryx_u32(&x497, &x498, x496, x460, x488); + fiat_25519_scalar_addcarryx_u32(&x499, &x500, x498, x462, x490); + fiat_25519_scalar_addcarryx_u32(&x501, &x502, x500, x464, x492); + fiat_25519_scalar_addcarryx_u32(&x503, &x504, x502, x466, 0x0); + fiat_25519_scalar_addcarryx_u32(&x505, &x506, x504, x468, 0x0); + fiat_25519_scalar_addcarryx_u32(&x507, &x508, x506, x470, x476); + fiat_25519_scalar_addcarryx_u32(&x509, &x510, x508, x472, x477); + x511 = ((uint32_t)x510 + x473); + fiat_25519_scalar_mulx_u32(&x512, &x513, x6, (arg1[7])); + fiat_25519_scalar_mulx_u32(&x514, &x515, x6, (arg1[6])); + fiat_25519_scalar_mulx_u32(&x516, &x517, x6, (arg1[5])); + fiat_25519_scalar_mulx_u32(&x518, &x519, x6, (arg1[4])); + fiat_25519_scalar_mulx_u32(&x520, &x521, x6, (arg1[3])); + fiat_25519_scalar_mulx_u32(&x522, &x523, x6, (arg1[2])); + fiat_25519_scalar_mulx_u32(&x524, &x525, x6, (arg1[1])); + fiat_25519_scalar_mulx_u32(&x526, &x527, x6, (arg1[0])); + fiat_25519_scalar_addcarryx_u32(&x528, &x529, 0x0, x527, x524); + fiat_25519_scalar_addcarryx_u32(&x530, &x531, x529, x525, x522); + fiat_25519_scalar_addcarryx_u32(&x532, &x533, x531, x523, x520); + fiat_25519_scalar_addcarryx_u32(&x534, &x535, x533, x521, x518); + fiat_25519_scalar_addcarryx_u32(&x536, &x537, x535, x519, x516); + fiat_25519_scalar_addcarryx_u32(&x538, &x539, x537, x517, x514); + fiat_25519_scalar_addcarryx_u32(&x540, &x541, x539, x515, x512); + x542 = (x541 + x513); + fiat_25519_scalar_addcarryx_u32(&x543, &x544, 0x0, x495, x526); + fiat_25519_scalar_addcarryx_u32(&x545, &x546, x544, x497, x528); + fiat_25519_scalar_addcarryx_u32(&x547, &x548, x546, x499, x530); + fiat_25519_scalar_addcarryx_u32(&x549, &x550, x548, x501, x532); + fiat_25519_scalar_addcarryx_u32(&x551, &x552, x550, x503, x534); + fiat_25519_scalar_addcarryx_u32(&x553, &x554, x552, x505, x536); + fiat_25519_scalar_addcarryx_u32(&x555, &x556, x554, x507, x538); + fiat_25519_scalar_addcarryx_u32(&x557, &x558, x556, x509, x540); + fiat_25519_scalar_addcarryx_u32(&x559, &x560, x558, x511, x542); + fiat_25519_scalar_mulx_u32(&x561, &x562, x543, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x563, &x564, x561, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x565, &x566, x561, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x567, &x568, x561, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x569, &x570, x561, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x571, &x572, x561, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x573, &x574, 0x0, x572, x569); + fiat_25519_scalar_addcarryx_u32(&x575, &x576, x574, x570, x567); + fiat_25519_scalar_addcarryx_u32(&x577, &x578, x576, x568, x565); + x579 = (x578 + x566); + fiat_25519_scalar_addcarryx_u32(&x580, &x581, 0x0, x543, x571); + fiat_25519_scalar_addcarryx_u32(&x582, &x583, x581, x545, x573); + fiat_25519_scalar_addcarryx_u32(&x584, &x585, x583, x547, x575); + fiat_25519_scalar_addcarryx_u32(&x586, &x587, x585, x549, x577); + fiat_25519_scalar_addcarryx_u32(&x588, &x589, x587, x551, x579); + fiat_25519_scalar_addcarryx_u32(&x590, &x591, x589, x553, 0x0); + fiat_25519_scalar_addcarryx_u32(&x592, &x593, x591, x555, 0x0); + fiat_25519_scalar_addcarryx_u32(&x594, &x595, x593, x557, x563); + fiat_25519_scalar_addcarryx_u32(&x596, &x597, x595, x559, x564); + x598 = ((uint32_t)x597 + x560); + fiat_25519_scalar_mulx_u32(&x599, &x600, x7, (arg1[7])); + fiat_25519_scalar_mulx_u32(&x601, &x602, x7, (arg1[6])); + fiat_25519_scalar_mulx_u32(&x603, &x604, x7, (arg1[5])); + fiat_25519_scalar_mulx_u32(&x605, &x606, x7, (arg1[4])); + fiat_25519_scalar_mulx_u32(&x607, &x608, x7, (arg1[3])); + fiat_25519_scalar_mulx_u32(&x609, &x610, x7, (arg1[2])); + fiat_25519_scalar_mulx_u32(&x611, &x612, x7, (arg1[1])); + fiat_25519_scalar_mulx_u32(&x613, &x614, x7, (arg1[0])); + fiat_25519_scalar_addcarryx_u32(&x615, &x616, 0x0, x614, x611); + fiat_25519_scalar_addcarryx_u32(&x617, &x618, x616, x612, x609); + fiat_25519_scalar_addcarryx_u32(&x619, &x620, x618, x610, x607); + fiat_25519_scalar_addcarryx_u32(&x621, &x622, x620, x608, x605); + fiat_25519_scalar_addcarryx_u32(&x623, &x624, x622, x606, x603); + fiat_25519_scalar_addcarryx_u32(&x625, &x626, x624, x604, x601); + fiat_25519_scalar_addcarryx_u32(&x627, &x628, x626, x602, x599); + x629 = (x628 + x600); + fiat_25519_scalar_addcarryx_u32(&x630, &x631, 0x0, x582, x613); + fiat_25519_scalar_addcarryx_u32(&x632, &x633, x631, x584, x615); + fiat_25519_scalar_addcarryx_u32(&x634, &x635, x633, x586, x617); + fiat_25519_scalar_addcarryx_u32(&x636, &x637, x635, x588, x619); + fiat_25519_scalar_addcarryx_u32(&x638, &x639, x637, x590, x621); + fiat_25519_scalar_addcarryx_u32(&x640, &x641, x639, x592, x623); + fiat_25519_scalar_addcarryx_u32(&x642, &x643, x641, x594, x625); + fiat_25519_scalar_addcarryx_u32(&x644, &x645, x643, x596, x627); + fiat_25519_scalar_addcarryx_u32(&x646, &x647, x645, x598, x629); + fiat_25519_scalar_mulx_u32(&x648, &x649, x630, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x650, &x651, x648, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x652, &x653, x648, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x654, &x655, x648, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x656, &x657, x648, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x658, &x659, x648, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x660, &x661, 0x0, x659, x656); + fiat_25519_scalar_addcarryx_u32(&x662, &x663, x661, x657, x654); + fiat_25519_scalar_addcarryx_u32(&x664, &x665, x663, x655, x652); + x666 = (x665 + x653); + fiat_25519_scalar_addcarryx_u32(&x667, &x668, 0x0, x630, x658); + fiat_25519_scalar_addcarryx_u32(&x669, &x670, x668, x632, x660); + fiat_25519_scalar_addcarryx_u32(&x671, &x672, x670, x634, x662); + fiat_25519_scalar_addcarryx_u32(&x673, &x674, x672, x636, x664); + fiat_25519_scalar_addcarryx_u32(&x675, &x676, x674, x638, x666); + fiat_25519_scalar_addcarryx_u32(&x677, &x678, x676, x640, 0x0); + fiat_25519_scalar_addcarryx_u32(&x679, &x680, x678, x642, 0x0); + fiat_25519_scalar_addcarryx_u32(&x681, &x682, x680, x644, x650); + fiat_25519_scalar_addcarryx_u32(&x683, &x684, x682, x646, x651); + x685 = ((uint32_t)x684 + x647); + fiat_25519_scalar_subborrowx_u32(&x686, &x687, 0x0, x669, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_subborrowx_u32(&x688, &x689, x687, x671, UINT32_C(0x5812631a)); + fiat_25519_scalar_subborrowx_u32(&x690, &x691, x689, x673, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_subborrowx_u32(&x692, &x693, x691, x675, UINT32_C(0x14def9de)); + fiat_25519_scalar_subborrowx_u32(&x694, &x695, x693, x677, 0x0); + fiat_25519_scalar_subborrowx_u32(&x696, &x697, x695, x679, 0x0); + fiat_25519_scalar_subborrowx_u32(&x698, &x699, x697, x681, 0x0); + fiat_25519_scalar_subborrowx_u32(&x700, &x701, x699, x683, UINT32_C(0x10000000)); + fiat_25519_scalar_subborrowx_u32(&x702, &x703, x701, x685, 0x0); + fiat_25519_scalar_cmovznz_u32(&x704, x703, x686, x669); + fiat_25519_scalar_cmovznz_u32(&x705, x703, x688, x671); + fiat_25519_scalar_cmovznz_u32(&x706, x703, x690, x673); + fiat_25519_scalar_cmovznz_u32(&x707, x703, x692, x675); + fiat_25519_scalar_cmovznz_u32(&x708, x703, x694, x677); + fiat_25519_scalar_cmovznz_u32(&x709, x703, x696, x679); + fiat_25519_scalar_cmovznz_u32(&x710, x703, x698, x681); + fiat_25519_scalar_cmovznz_u32(&x711, x703, x700, x683); + out1[0] = x704; + out1[1] = x705; + out1[2] = x706; + out1[3] = x707; + out1[4] = x708; + out1[5] = x709; + out1[6] = x710; + out1[7] = x711; +} + +/* + * The function fiat_25519_scalar_add adds two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_add(fiat_25519_scalar_montgomery_domain_field_element out1, const fiat_25519_scalar_montgomery_domain_field_element arg1, const fiat_25519_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + fiat_25519_scalar_uint1 x2; + uint32_t x3; + fiat_25519_scalar_uint1 x4; + uint32_t x5; + fiat_25519_scalar_uint1 x6; + uint32_t x7; + fiat_25519_scalar_uint1 x8; + uint32_t x9; + fiat_25519_scalar_uint1 x10; + uint32_t x11; + fiat_25519_scalar_uint1 x12; + uint32_t x13; + fiat_25519_scalar_uint1 x14; + uint32_t x15; + fiat_25519_scalar_uint1 x16; + uint32_t x17; + fiat_25519_scalar_uint1 x18; + uint32_t x19; + fiat_25519_scalar_uint1 x20; + uint32_t x21; + fiat_25519_scalar_uint1 x22; + uint32_t x23; + fiat_25519_scalar_uint1 x24; + uint32_t x25; + fiat_25519_scalar_uint1 x26; + uint32_t x27; + fiat_25519_scalar_uint1 x28; + uint32_t x29; + fiat_25519_scalar_uint1 x30; + uint32_t x31; + fiat_25519_scalar_uint1 x32; + uint32_t x33; + fiat_25519_scalar_uint1 x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + uint32_t x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + fiat_25519_scalar_addcarryx_u32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_25519_scalar_addcarryx_u32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_25519_scalar_addcarryx_u32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_25519_scalar_addcarryx_u32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_25519_scalar_addcarryx_u32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_25519_scalar_addcarryx_u32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_25519_scalar_addcarryx_u32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + fiat_25519_scalar_addcarryx_u32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + fiat_25519_scalar_subborrowx_u32(&x17, &x18, 0x0, x1, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_subborrowx_u32(&x19, &x20, x18, x3, UINT32_C(0x5812631a)); + fiat_25519_scalar_subborrowx_u32(&x21, &x22, x20, x5, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_subborrowx_u32(&x23, &x24, x22, x7, UINT32_C(0x14def9de)); + fiat_25519_scalar_subborrowx_u32(&x25, &x26, x24, x9, 0x0); + fiat_25519_scalar_subborrowx_u32(&x27, &x28, x26, x11, 0x0); + fiat_25519_scalar_subborrowx_u32(&x29, &x30, x28, x13, 0x0); + fiat_25519_scalar_subborrowx_u32(&x31, &x32, x30, x15, UINT32_C(0x10000000)); + fiat_25519_scalar_subborrowx_u32(&x33, &x34, x32, x16, 0x0); + fiat_25519_scalar_cmovznz_u32(&x35, x34, x17, x1); + fiat_25519_scalar_cmovznz_u32(&x36, x34, x19, x3); + fiat_25519_scalar_cmovznz_u32(&x37, x34, x21, x5); + fiat_25519_scalar_cmovznz_u32(&x38, x34, x23, x7); + fiat_25519_scalar_cmovznz_u32(&x39, x34, x25, x9); + fiat_25519_scalar_cmovznz_u32(&x40, x34, x27, x11); + fiat_25519_scalar_cmovznz_u32(&x41, x34, x29, x13); + fiat_25519_scalar_cmovznz_u32(&x42, x34, x31, x15); + out1[0] = x35; + out1[1] = x36; + out1[2] = x37; + out1[3] = x38; + out1[4] = x39; + out1[5] = x40; + out1[6] = x41; + out1[7] = x42; +} + +/* + * The function fiat_25519_scalar_sub subtracts two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_sub(fiat_25519_scalar_montgomery_domain_field_element out1, const fiat_25519_scalar_montgomery_domain_field_element arg1, const fiat_25519_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + fiat_25519_scalar_uint1 x2; + uint32_t x3; + fiat_25519_scalar_uint1 x4; + uint32_t x5; + fiat_25519_scalar_uint1 x6; + uint32_t x7; + fiat_25519_scalar_uint1 x8; + uint32_t x9; + fiat_25519_scalar_uint1 x10; + uint32_t x11; + fiat_25519_scalar_uint1 x12; + uint32_t x13; + fiat_25519_scalar_uint1 x14; + uint32_t x15; + fiat_25519_scalar_uint1 x16; + uint32_t x17; + uint32_t x18; + fiat_25519_scalar_uint1 x19; + uint32_t x20; + fiat_25519_scalar_uint1 x21; + uint32_t x22; + fiat_25519_scalar_uint1 x23; + uint32_t x24; + fiat_25519_scalar_uint1 x25; + uint32_t x26; + fiat_25519_scalar_uint1 x27; + uint32_t x28; + fiat_25519_scalar_uint1 x29; + uint32_t x30; + fiat_25519_scalar_uint1 x31; + uint32_t x32; + fiat_25519_scalar_uint1 x33; + fiat_25519_scalar_subborrowx_u32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_25519_scalar_subborrowx_u32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_25519_scalar_subborrowx_u32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_25519_scalar_subborrowx_u32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_25519_scalar_subborrowx_u32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_25519_scalar_subborrowx_u32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_25519_scalar_subborrowx_u32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + fiat_25519_scalar_subborrowx_u32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + fiat_25519_scalar_cmovznz_u32(&x17, x16, 0x0, UINT32_C(0xffffffff)); + fiat_25519_scalar_addcarryx_u32(&x18, &x19, 0x0, x1, (x17 & UINT32_C(0x5cf5d3ed))); + fiat_25519_scalar_addcarryx_u32(&x20, &x21, x19, x3, (x17 & UINT32_C(0x5812631a))); + fiat_25519_scalar_addcarryx_u32(&x22, &x23, x21, x5, (x17 & UINT32_C(0xa2f79cd6))); + fiat_25519_scalar_addcarryx_u32(&x24, &x25, x23, x7, (x17 & UINT32_C(0x14def9de))); + fiat_25519_scalar_addcarryx_u32(&x26, &x27, x25, x9, 0x0); + fiat_25519_scalar_addcarryx_u32(&x28, &x29, x27, x11, 0x0); + fiat_25519_scalar_addcarryx_u32(&x30, &x31, x29, x13, 0x0); + fiat_25519_scalar_addcarryx_u32(&x32, &x33, x31, x15, (x17 & UINT32_C(0x10000000))); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/* + * The function fiat_25519_scalar_opp negates a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_opp(fiat_25519_scalar_montgomery_domain_field_element out1, const fiat_25519_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + fiat_25519_scalar_uint1 x2; + uint32_t x3; + fiat_25519_scalar_uint1 x4; + uint32_t x5; + fiat_25519_scalar_uint1 x6; + uint32_t x7; + fiat_25519_scalar_uint1 x8; + uint32_t x9; + fiat_25519_scalar_uint1 x10; + uint32_t x11; + fiat_25519_scalar_uint1 x12; + uint32_t x13; + fiat_25519_scalar_uint1 x14; + uint32_t x15; + fiat_25519_scalar_uint1 x16; + uint32_t x17; + uint32_t x18; + fiat_25519_scalar_uint1 x19; + uint32_t x20; + fiat_25519_scalar_uint1 x21; + uint32_t x22; + fiat_25519_scalar_uint1 x23; + uint32_t x24; + fiat_25519_scalar_uint1 x25; + uint32_t x26; + fiat_25519_scalar_uint1 x27; + uint32_t x28; + fiat_25519_scalar_uint1 x29; + uint32_t x30; + fiat_25519_scalar_uint1 x31; + uint32_t x32; + fiat_25519_scalar_uint1 x33; + fiat_25519_scalar_subborrowx_u32(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_25519_scalar_subborrowx_u32(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_25519_scalar_subborrowx_u32(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_25519_scalar_subborrowx_u32(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_25519_scalar_subborrowx_u32(&x9, &x10, x8, 0x0, (arg1[4])); + fiat_25519_scalar_subborrowx_u32(&x11, &x12, x10, 0x0, (arg1[5])); + fiat_25519_scalar_subborrowx_u32(&x13, &x14, x12, 0x0, (arg1[6])); + fiat_25519_scalar_subborrowx_u32(&x15, &x16, x14, 0x0, (arg1[7])); + fiat_25519_scalar_cmovznz_u32(&x17, x16, 0x0, UINT32_C(0xffffffff)); + fiat_25519_scalar_addcarryx_u32(&x18, &x19, 0x0, x1, (x17 & UINT32_C(0x5cf5d3ed))); + fiat_25519_scalar_addcarryx_u32(&x20, &x21, x19, x3, (x17 & UINT32_C(0x5812631a))); + fiat_25519_scalar_addcarryx_u32(&x22, &x23, x21, x5, (x17 & UINT32_C(0xa2f79cd6))); + fiat_25519_scalar_addcarryx_u32(&x24, &x25, x23, x7, (x17 & UINT32_C(0x14def9de))); + fiat_25519_scalar_addcarryx_u32(&x26, &x27, x25, x9, 0x0); + fiat_25519_scalar_addcarryx_u32(&x28, &x29, x27, x11, 0x0); + fiat_25519_scalar_addcarryx_u32(&x30, &x31, x29, x13, 0x0); + fiat_25519_scalar_addcarryx_u32(&x32, &x33, x31, x15, (x17 & UINT32_C(0x10000000))); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/* + * The function fiat_25519_scalar_from_montgomery translates a field element out of the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_from_montgomery(fiat_25519_scalar_non_montgomery_domain_field_element out1, const fiat_25519_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + fiat_25519_scalar_uint1 x15; + uint32_t x16; + fiat_25519_scalar_uint1 x17; + uint32_t x18; + fiat_25519_scalar_uint1 x19; + uint32_t x20; + fiat_25519_scalar_uint1 x21; + uint32_t x22; + fiat_25519_scalar_uint1 x23; + uint32_t x24; + fiat_25519_scalar_uint1 x25; + uint32_t x26; + fiat_25519_scalar_uint1 x27; + uint32_t x28; + fiat_25519_scalar_uint1 x29; + uint32_t x30; + fiat_25519_scalar_uint1 x31; + uint32_t x32; + fiat_25519_scalar_uint1 x33; + uint32_t x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + uint32_t x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + fiat_25519_scalar_uint1 x47; + uint32_t x48; + fiat_25519_scalar_uint1 x49; + uint32_t x50; + fiat_25519_scalar_uint1 x51; + uint32_t x52; + fiat_25519_scalar_uint1 x53; + uint32_t x54; + fiat_25519_scalar_uint1 x55; + uint32_t x56; + fiat_25519_scalar_uint1 x57; + uint32_t x58; + fiat_25519_scalar_uint1 x59; + uint32_t x60; + fiat_25519_scalar_uint1 x61; + uint32_t x62; + fiat_25519_scalar_uint1 x63; + uint32_t x64; + fiat_25519_scalar_uint1 x65; + uint32_t x66; + fiat_25519_scalar_uint1 x67; + uint32_t x68; + uint32_t x69; + uint32_t x70; + uint32_t x71; + uint32_t x72; + uint32_t x73; + uint32_t x74; + uint32_t x75; + uint32_t x76; + uint32_t x77; + uint32_t x78; + uint32_t x79; + uint32_t x80; + fiat_25519_scalar_uint1 x81; + uint32_t x82; + fiat_25519_scalar_uint1 x83; + uint32_t x84; + fiat_25519_scalar_uint1 x85; + uint32_t x86; + fiat_25519_scalar_uint1 x87; + uint32_t x88; + fiat_25519_scalar_uint1 x89; + uint32_t x90; + fiat_25519_scalar_uint1 x91; + uint32_t x92; + fiat_25519_scalar_uint1 x93; + uint32_t x94; + fiat_25519_scalar_uint1 x95; + uint32_t x96; + fiat_25519_scalar_uint1 x97; + uint32_t x98; + fiat_25519_scalar_uint1 x99; + uint32_t x100; + fiat_25519_scalar_uint1 x101; + uint32_t x102; + uint32_t x103; + uint32_t x104; + uint32_t x105; + uint32_t x106; + uint32_t x107; + uint32_t x108; + uint32_t x109; + uint32_t x110; + uint32_t x111; + uint32_t x112; + uint32_t x113; + uint32_t x114; + fiat_25519_scalar_uint1 x115; + uint32_t x116; + fiat_25519_scalar_uint1 x117; + uint32_t x118; + fiat_25519_scalar_uint1 x119; + uint32_t x120; + fiat_25519_scalar_uint1 x121; + uint32_t x122; + fiat_25519_scalar_uint1 x123; + uint32_t x124; + fiat_25519_scalar_uint1 x125; + uint32_t x126; + fiat_25519_scalar_uint1 x127; + uint32_t x128; + fiat_25519_scalar_uint1 x129; + uint32_t x130; + fiat_25519_scalar_uint1 x131; + uint32_t x132; + fiat_25519_scalar_uint1 x133; + uint32_t x134; + fiat_25519_scalar_uint1 x135; + uint32_t x136; + fiat_25519_scalar_uint1 x137; + uint32_t x138; + fiat_25519_scalar_uint1 x139; + uint32_t x140; + fiat_25519_scalar_uint1 x141; + uint32_t x142; + fiat_25519_scalar_uint1 x143; + uint32_t x144; + fiat_25519_scalar_uint1 x145; + uint32_t x146; + fiat_25519_scalar_uint1 x147; + uint32_t x148; + fiat_25519_scalar_uint1 x149; + uint32_t x150; + uint32_t x151; + uint32_t x152; + uint32_t x153; + uint32_t x154; + uint32_t x155; + uint32_t x156; + uint32_t x157; + uint32_t x158; + uint32_t x159; + uint32_t x160; + uint32_t x161; + uint32_t x162; + fiat_25519_scalar_uint1 x163; + uint32_t x164; + fiat_25519_scalar_uint1 x165; + uint32_t x166; + fiat_25519_scalar_uint1 x167; + uint32_t x168; + fiat_25519_scalar_uint1 x169; + uint32_t x170; + fiat_25519_scalar_uint1 x171; + uint32_t x172; + fiat_25519_scalar_uint1 x173; + uint32_t x174; + fiat_25519_scalar_uint1 x175; + uint32_t x176; + fiat_25519_scalar_uint1 x177; + uint32_t x178; + fiat_25519_scalar_uint1 x179; + uint32_t x180; + fiat_25519_scalar_uint1 x181; + uint32_t x182; + fiat_25519_scalar_uint1 x183; + uint32_t x184; + fiat_25519_scalar_uint1 x185; + uint32_t x186; + fiat_25519_scalar_uint1 x187; + uint32_t x188; + fiat_25519_scalar_uint1 x189; + uint32_t x190; + fiat_25519_scalar_uint1 x191; + uint32_t x192; + fiat_25519_scalar_uint1 x193; + uint32_t x194; + fiat_25519_scalar_uint1 x195; + uint32_t x196; + fiat_25519_scalar_uint1 x197; + uint32_t x198; + uint32_t x199; + uint32_t x200; + uint32_t x201; + uint32_t x202; + uint32_t x203; + uint32_t x204; + uint32_t x205; + uint32_t x206; + uint32_t x207; + uint32_t x208; + uint32_t x209; + uint32_t x210; + fiat_25519_scalar_uint1 x211; + uint32_t x212; + fiat_25519_scalar_uint1 x213; + uint32_t x214; + fiat_25519_scalar_uint1 x215; + uint32_t x216; + fiat_25519_scalar_uint1 x217; + uint32_t x218; + fiat_25519_scalar_uint1 x219; + uint32_t x220; + fiat_25519_scalar_uint1 x221; + uint32_t x222; + fiat_25519_scalar_uint1 x223; + uint32_t x224; + fiat_25519_scalar_uint1 x225; + uint32_t x226; + fiat_25519_scalar_uint1 x227; + uint32_t x228; + fiat_25519_scalar_uint1 x229; + uint32_t x230; + fiat_25519_scalar_uint1 x231; + uint32_t x232; + fiat_25519_scalar_uint1 x233; + uint32_t x234; + fiat_25519_scalar_uint1 x235; + uint32_t x236; + fiat_25519_scalar_uint1 x237; + uint32_t x238; + fiat_25519_scalar_uint1 x239; + uint32_t x240; + fiat_25519_scalar_uint1 x241; + uint32_t x242; + fiat_25519_scalar_uint1 x243; + uint32_t x244; + fiat_25519_scalar_uint1 x245; + uint32_t x246; + uint32_t x247; + uint32_t x248; + uint32_t x249; + uint32_t x250; + uint32_t x251; + uint32_t x252; + uint32_t x253; + uint32_t x254; + uint32_t x255; + uint32_t x256; + uint32_t x257; + uint32_t x258; + fiat_25519_scalar_uint1 x259; + uint32_t x260; + fiat_25519_scalar_uint1 x261; + uint32_t x262; + fiat_25519_scalar_uint1 x263; + uint32_t x264; + fiat_25519_scalar_uint1 x265; + uint32_t x266; + fiat_25519_scalar_uint1 x267; + uint32_t x268; + fiat_25519_scalar_uint1 x269; + uint32_t x270; + fiat_25519_scalar_uint1 x271; + uint32_t x272; + fiat_25519_scalar_uint1 x273; + uint32_t x274; + fiat_25519_scalar_uint1 x275; + uint32_t x276; + fiat_25519_scalar_uint1 x277; + uint32_t x278; + fiat_25519_scalar_uint1 x279; + uint32_t x280; + fiat_25519_scalar_uint1 x281; + uint32_t x282; + fiat_25519_scalar_uint1 x283; + uint32_t x284; + fiat_25519_scalar_uint1 x285; + uint32_t x286; + fiat_25519_scalar_uint1 x287; + uint32_t x288; + fiat_25519_scalar_uint1 x289; + uint32_t x290; + fiat_25519_scalar_uint1 x291; + uint32_t x292; + fiat_25519_scalar_uint1 x293; + uint32_t x294; + uint32_t x295; + uint32_t x296; + uint32_t x297; + uint32_t x298; + uint32_t x299; + uint32_t x300; + uint32_t x301; + uint32_t x302; + uint32_t x303; + uint32_t x304; + uint32_t x305; + uint32_t x306; + fiat_25519_scalar_uint1 x307; + uint32_t x308; + fiat_25519_scalar_uint1 x309; + uint32_t x310; + fiat_25519_scalar_uint1 x311; + uint32_t x312; + fiat_25519_scalar_uint1 x313; + uint32_t x314; + fiat_25519_scalar_uint1 x315; + uint32_t x316; + fiat_25519_scalar_uint1 x317; + uint32_t x318; + fiat_25519_scalar_uint1 x319; + uint32_t x320; + fiat_25519_scalar_uint1 x321; + uint32_t x322; + fiat_25519_scalar_uint1 x323; + uint32_t x324; + fiat_25519_scalar_uint1 x325; + uint32_t x326; + fiat_25519_scalar_uint1 x327; + uint32_t x328; + uint32_t x329; + fiat_25519_scalar_uint1 x330; + uint32_t x331; + fiat_25519_scalar_uint1 x332; + uint32_t x333; + fiat_25519_scalar_uint1 x334; + uint32_t x335; + fiat_25519_scalar_uint1 x336; + uint32_t x337; + fiat_25519_scalar_uint1 x338; + uint32_t x339; + fiat_25519_scalar_uint1 x340; + uint32_t x341; + fiat_25519_scalar_uint1 x342; + uint32_t x343; + fiat_25519_scalar_uint1 x344; + uint32_t x345; + fiat_25519_scalar_uint1 x346; + uint32_t x347; + uint32_t x348; + uint32_t x349; + uint32_t x350; + uint32_t x351; + uint32_t x352; + uint32_t x353; + uint32_t x354; + x1 = (arg1[0]); + fiat_25519_scalar_mulx_u32(&x2, &x3, x1, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x4, &x5, x2, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x6, &x7, x2, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x8, &x9, x2, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x10, &x11, x2, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x12, &x13, x2, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x14, &x15, 0x0, x13, x10); + fiat_25519_scalar_addcarryx_u32(&x16, &x17, x15, x11, x8); + fiat_25519_scalar_addcarryx_u32(&x18, &x19, x17, x9, x6); + fiat_25519_scalar_addcarryx_u32(&x20, &x21, 0x0, x1, x12); + fiat_25519_scalar_addcarryx_u32(&x22, &x23, x21, 0x0, x14); + fiat_25519_scalar_addcarryx_u32(&x24, &x25, x23, 0x0, x16); + fiat_25519_scalar_addcarryx_u32(&x26, &x27, x25, 0x0, x18); + fiat_25519_scalar_addcarryx_u32(&x28, &x29, 0x0, x22, (arg1[1])); + fiat_25519_scalar_addcarryx_u32(&x30, &x31, x29, x24, 0x0); + fiat_25519_scalar_addcarryx_u32(&x32, &x33, x31, x26, 0x0); + fiat_25519_scalar_mulx_u32(&x34, &x35, x28, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x36, &x37, x34, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x38, &x39, x34, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x40, &x41, x34, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x42, &x43, x34, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x44, &x45, x34, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x46, &x47, 0x0, x45, x42); + fiat_25519_scalar_addcarryx_u32(&x48, &x49, x47, x43, x40); + fiat_25519_scalar_addcarryx_u32(&x50, &x51, x49, x41, x38); + fiat_25519_scalar_addcarryx_u32(&x52, &x53, 0x0, x28, x44); + fiat_25519_scalar_addcarryx_u32(&x54, &x55, x53, x30, x46); + fiat_25519_scalar_addcarryx_u32(&x56, &x57, x55, x32, x48); + fiat_25519_scalar_addcarryx_u32(&x58, &x59, x57, (x33 + (x27 + (x19 + x7))), x50); + fiat_25519_scalar_addcarryx_u32(&x60, &x61, 0x0, x5, x36); + fiat_25519_scalar_addcarryx_u32(&x62, &x63, 0x0, x54, (arg1[2])); + fiat_25519_scalar_addcarryx_u32(&x64, &x65, x63, x56, 0x0); + fiat_25519_scalar_addcarryx_u32(&x66, &x67, x65, x58, 0x0); + fiat_25519_scalar_mulx_u32(&x68, &x69, x62, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x70, &x71, x68, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x72, &x73, x68, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x74, &x75, x68, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x76, &x77, x68, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x78, &x79, x68, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x80, &x81, 0x0, x79, x76); + fiat_25519_scalar_addcarryx_u32(&x82, &x83, x81, x77, x74); + fiat_25519_scalar_addcarryx_u32(&x84, &x85, x83, x75, x72); + fiat_25519_scalar_addcarryx_u32(&x86, &x87, 0x0, x62, x78); + fiat_25519_scalar_addcarryx_u32(&x88, &x89, x87, x64, x80); + fiat_25519_scalar_addcarryx_u32(&x90, &x91, x89, x66, x82); + fiat_25519_scalar_addcarryx_u32(&x92, &x93, x91, (x67 + (x59 + (x51 + x39))), x84); + fiat_25519_scalar_addcarryx_u32(&x94, &x95, 0x0, (x61 + x37), x70); + fiat_25519_scalar_addcarryx_u32(&x96, &x97, 0x0, x88, (arg1[3])); + fiat_25519_scalar_addcarryx_u32(&x98, &x99, x97, x90, 0x0); + fiat_25519_scalar_addcarryx_u32(&x100, &x101, x99, x92, 0x0); + fiat_25519_scalar_mulx_u32(&x102, &x103, x96, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x104, &x105, x102, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x106, &x107, x102, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x108, &x109, x102, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x110, &x111, x102, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x112, &x113, x102, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x114, &x115, 0x0, x113, x110); + fiat_25519_scalar_addcarryx_u32(&x116, &x117, x115, x111, x108); + fiat_25519_scalar_addcarryx_u32(&x118, &x119, x117, x109, x106); + fiat_25519_scalar_addcarryx_u32(&x120, &x121, 0x0, x96, x112); + fiat_25519_scalar_addcarryx_u32(&x122, &x123, x121, x98, x114); + fiat_25519_scalar_addcarryx_u32(&x124, &x125, x123, x100, x116); + fiat_25519_scalar_addcarryx_u32(&x126, &x127, x125, (x101 + (x93 + (x85 + x73))), x118); + fiat_25519_scalar_addcarryx_u32(&x128, &x129, x127, x4, (x119 + x107)); + fiat_25519_scalar_addcarryx_u32(&x130, &x131, x129, x60, 0x0); + fiat_25519_scalar_addcarryx_u32(&x132, &x133, x131, x94, 0x0); + fiat_25519_scalar_addcarryx_u32(&x134, &x135, x133, (x95 + x71), x104); + fiat_25519_scalar_addcarryx_u32(&x136, &x137, 0x0, x122, (arg1[4])); + fiat_25519_scalar_addcarryx_u32(&x138, &x139, x137, x124, 0x0); + fiat_25519_scalar_addcarryx_u32(&x140, &x141, x139, x126, 0x0); + fiat_25519_scalar_addcarryx_u32(&x142, &x143, x141, x128, 0x0); + fiat_25519_scalar_addcarryx_u32(&x144, &x145, x143, x130, 0x0); + fiat_25519_scalar_addcarryx_u32(&x146, &x147, x145, x132, 0x0); + fiat_25519_scalar_addcarryx_u32(&x148, &x149, x147, x134, 0x0); + fiat_25519_scalar_mulx_u32(&x150, &x151, x136, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x152, &x153, x150, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x154, &x155, x150, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x156, &x157, x150, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x158, &x159, x150, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x160, &x161, x150, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x162, &x163, 0x0, x161, x158); + fiat_25519_scalar_addcarryx_u32(&x164, &x165, x163, x159, x156); + fiat_25519_scalar_addcarryx_u32(&x166, &x167, x165, x157, x154); + fiat_25519_scalar_addcarryx_u32(&x168, &x169, 0x0, x136, x160); + fiat_25519_scalar_addcarryx_u32(&x170, &x171, x169, x138, x162); + fiat_25519_scalar_addcarryx_u32(&x172, &x173, x171, x140, x164); + fiat_25519_scalar_addcarryx_u32(&x174, &x175, x173, x142, x166); + fiat_25519_scalar_addcarryx_u32(&x176, &x177, x175, x144, (x167 + x155)); + fiat_25519_scalar_addcarryx_u32(&x178, &x179, x177, x146, 0x0); + fiat_25519_scalar_addcarryx_u32(&x180, &x181, x179, x148, 0x0); + fiat_25519_scalar_addcarryx_u32(&x182, &x183, x181, (x149 + (x135 + x105)), x152); + fiat_25519_scalar_addcarryx_u32(&x184, &x185, 0x0, x170, (arg1[5])); + fiat_25519_scalar_addcarryx_u32(&x186, &x187, x185, x172, 0x0); + fiat_25519_scalar_addcarryx_u32(&x188, &x189, x187, x174, 0x0); + fiat_25519_scalar_addcarryx_u32(&x190, &x191, x189, x176, 0x0); + fiat_25519_scalar_addcarryx_u32(&x192, &x193, x191, x178, 0x0); + fiat_25519_scalar_addcarryx_u32(&x194, &x195, x193, x180, 0x0); + fiat_25519_scalar_addcarryx_u32(&x196, &x197, x195, x182, 0x0); + fiat_25519_scalar_mulx_u32(&x198, &x199, x184, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x200, &x201, x198, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x202, &x203, x198, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x204, &x205, x198, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x206, &x207, x198, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x208, &x209, x198, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x210, &x211, 0x0, x209, x206); + fiat_25519_scalar_addcarryx_u32(&x212, &x213, x211, x207, x204); + fiat_25519_scalar_addcarryx_u32(&x214, &x215, x213, x205, x202); + fiat_25519_scalar_addcarryx_u32(&x216, &x217, 0x0, x184, x208); + fiat_25519_scalar_addcarryx_u32(&x218, &x219, x217, x186, x210); + fiat_25519_scalar_addcarryx_u32(&x220, &x221, x219, x188, x212); + fiat_25519_scalar_addcarryx_u32(&x222, &x223, x221, x190, x214); + fiat_25519_scalar_addcarryx_u32(&x224, &x225, x223, x192, (x215 + x203)); + fiat_25519_scalar_addcarryx_u32(&x226, &x227, x225, x194, 0x0); + fiat_25519_scalar_addcarryx_u32(&x228, &x229, x227, x196, 0x0); + fiat_25519_scalar_addcarryx_u32(&x230, &x231, x229, (x197 + (x183 + x153)), x200); + fiat_25519_scalar_addcarryx_u32(&x232, &x233, 0x0, x218, (arg1[6])); + fiat_25519_scalar_addcarryx_u32(&x234, &x235, x233, x220, 0x0); + fiat_25519_scalar_addcarryx_u32(&x236, &x237, x235, x222, 0x0); + fiat_25519_scalar_addcarryx_u32(&x238, &x239, x237, x224, 0x0); + fiat_25519_scalar_addcarryx_u32(&x240, &x241, x239, x226, 0x0); + fiat_25519_scalar_addcarryx_u32(&x242, &x243, x241, x228, 0x0); + fiat_25519_scalar_addcarryx_u32(&x244, &x245, x243, x230, 0x0); + fiat_25519_scalar_mulx_u32(&x246, &x247, x232, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x248, &x249, x246, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x250, &x251, x246, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x252, &x253, x246, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x254, &x255, x246, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x256, &x257, x246, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x258, &x259, 0x0, x257, x254); + fiat_25519_scalar_addcarryx_u32(&x260, &x261, x259, x255, x252); + fiat_25519_scalar_addcarryx_u32(&x262, &x263, x261, x253, x250); + fiat_25519_scalar_addcarryx_u32(&x264, &x265, 0x0, x232, x256); + fiat_25519_scalar_addcarryx_u32(&x266, &x267, x265, x234, x258); + fiat_25519_scalar_addcarryx_u32(&x268, &x269, x267, x236, x260); + fiat_25519_scalar_addcarryx_u32(&x270, &x271, x269, x238, x262); + fiat_25519_scalar_addcarryx_u32(&x272, &x273, x271, x240, (x263 + x251)); + fiat_25519_scalar_addcarryx_u32(&x274, &x275, x273, x242, 0x0); + fiat_25519_scalar_addcarryx_u32(&x276, &x277, x275, x244, 0x0); + fiat_25519_scalar_addcarryx_u32(&x278, &x279, x277, (x245 + (x231 + x201)), x248); + fiat_25519_scalar_addcarryx_u32(&x280, &x281, 0x0, x266, (arg1[7])); + fiat_25519_scalar_addcarryx_u32(&x282, &x283, x281, x268, 0x0); + fiat_25519_scalar_addcarryx_u32(&x284, &x285, x283, x270, 0x0); + fiat_25519_scalar_addcarryx_u32(&x286, &x287, x285, x272, 0x0); + fiat_25519_scalar_addcarryx_u32(&x288, &x289, x287, x274, 0x0); + fiat_25519_scalar_addcarryx_u32(&x290, &x291, x289, x276, 0x0); + fiat_25519_scalar_addcarryx_u32(&x292, &x293, x291, x278, 0x0); + fiat_25519_scalar_mulx_u32(&x294, &x295, x280, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x296, &x297, x294, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x298, &x299, x294, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x300, &x301, x294, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x302, &x303, x294, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x304, &x305, x294, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x306, &x307, 0x0, x305, x302); + fiat_25519_scalar_addcarryx_u32(&x308, &x309, x307, x303, x300); + fiat_25519_scalar_addcarryx_u32(&x310, &x311, x309, x301, x298); + fiat_25519_scalar_addcarryx_u32(&x312, &x313, 0x0, x280, x304); + fiat_25519_scalar_addcarryx_u32(&x314, &x315, x313, x282, x306); + fiat_25519_scalar_addcarryx_u32(&x316, &x317, x315, x284, x308); + fiat_25519_scalar_addcarryx_u32(&x318, &x319, x317, x286, x310); + fiat_25519_scalar_addcarryx_u32(&x320, &x321, x319, x288, (x311 + x299)); + fiat_25519_scalar_addcarryx_u32(&x322, &x323, x321, x290, 0x0); + fiat_25519_scalar_addcarryx_u32(&x324, &x325, x323, x292, 0x0); + fiat_25519_scalar_addcarryx_u32(&x326, &x327, x325, (x293 + (x279 + x249)), x296); + x328 = (x327 + x297); + fiat_25519_scalar_subborrowx_u32(&x329, &x330, 0x0, x314, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_subborrowx_u32(&x331, &x332, x330, x316, UINT32_C(0x5812631a)); + fiat_25519_scalar_subborrowx_u32(&x333, &x334, x332, x318, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_subborrowx_u32(&x335, &x336, x334, x320, UINT32_C(0x14def9de)); + fiat_25519_scalar_subborrowx_u32(&x337, &x338, x336, x322, 0x0); + fiat_25519_scalar_subborrowx_u32(&x339, &x340, x338, x324, 0x0); + fiat_25519_scalar_subborrowx_u32(&x341, &x342, x340, x326, 0x0); + fiat_25519_scalar_subborrowx_u32(&x343, &x344, x342, x328, UINT32_C(0x10000000)); + fiat_25519_scalar_subborrowx_u32(&x345, &x346, x344, 0x0, 0x0); + fiat_25519_scalar_cmovznz_u32(&x347, x346, x329, x314); + fiat_25519_scalar_cmovznz_u32(&x348, x346, x331, x316); + fiat_25519_scalar_cmovznz_u32(&x349, x346, x333, x318); + fiat_25519_scalar_cmovznz_u32(&x350, x346, x335, x320); + fiat_25519_scalar_cmovznz_u32(&x351, x346, x337, x322); + fiat_25519_scalar_cmovznz_u32(&x352, x346, x339, x324); + fiat_25519_scalar_cmovznz_u32(&x353, x346, x341, x326); + fiat_25519_scalar_cmovznz_u32(&x354, x346, x343, x328); + out1[0] = x347; + out1[1] = x348; + out1[2] = x349; + out1[3] = x350; + out1[4] = x351; + out1[5] = x352; + out1[6] = x353; + out1[7] = x354; +} + +/* + * The function fiat_25519_scalar_to_montgomery translates a field element into the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = eval arg1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_to_montgomery(fiat_25519_scalar_montgomery_domain_field_element out1, const fiat_25519_scalar_non_montgomery_domain_field_element arg1) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + fiat_25519_scalar_uint1 x26; + uint32_t x27; + fiat_25519_scalar_uint1 x28; + uint32_t x29; + fiat_25519_scalar_uint1 x30; + uint32_t x31; + fiat_25519_scalar_uint1 x32; + uint32_t x33; + fiat_25519_scalar_uint1 x34; + uint32_t x35; + fiat_25519_scalar_uint1 x36; + uint32_t x37; + fiat_25519_scalar_uint1 x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + fiat_25519_scalar_uint1 x52; + uint32_t x53; + fiat_25519_scalar_uint1 x54; + uint32_t x55; + fiat_25519_scalar_uint1 x56; + uint32_t x57; + fiat_25519_scalar_uint1 x58; + uint32_t x59; + fiat_25519_scalar_uint1 x60; + uint32_t x61; + fiat_25519_scalar_uint1 x62; + uint32_t x63; + fiat_25519_scalar_uint1 x64; + uint32_t x65; + fiat_25519_scalar_uint1 x66; + uint32_t x67; + fiat_25519_scalar_uint1 x68; + uint32_t x69; + fiat_25519_scalar_uint1 x70; + uint32_t x71; + fiat_25519_scalar_uint1 x72; + uint32_t x73; + uint32_t x74; + uint32_t x75; + uint32_t x76; + uint32_t x77; + uint32_t x78; + uint32_t x79; + uint32_t x80; + uint32_t x81; + uint32_t x82; + uint32_t x83; + uint32_t x84; + uint32_t x85; + uint32_t x86; + uint32_t x87; + uint32_t x88; + uint32_t x89; + fiat_25519_scalar_uint1 x90; + uint32_t x91; + fiat_25519_scalar_uint1 x92; + uint32_t x93; + fiat_25519_scalar_uint1 x94; + uint32_t x95; + fiat_25519_scalar_uint1 x96; + uint32_t x97; + fiat_25519_scalar_uint1 x98; + uint32_t x99; + fiat_25519_scalar_uint1 x100; + uint32_t x101; + fiat_25519_scalar_uint1 x102; + uint32_t x103; + fiat_25519_scalar_uint1 x104; + uint32_t x105; + fiat_25519_scalar_uint1 x106; + uint32_t x107; + fiat_25519_scalar_uint1 x108; + uint32_t x109; + fiat_25519_scalar_uint1 x110; + uint32_t x111; + fiat_25519_scalar_uint1 x112; + uint32_t x113; + fiat_25519_scalar_uint1 x114; + uint32_t x115; + fiat_25519_scalar_uint1 x116; + uint32_t x117; + fiat_25519_scalar_uint1 x118; + uint32_t x119; + uint32_t x120; + uint32_t x121; + uint32_t x122; + uint32_t x123; + uint32_t x124; + uint32_t x125; + uint32_t x126; + uint32_t x127; + uint32_t x128; + uint32_t x129; + uint32_t x130; + uint32_t x131; + fiat_25519_scalar_uint1 x132; + uint32_t x133; + fiat_25519_scalar_uint1 x134; + uint32_t x135; + fiat_25519_scalar_uint1 x136; + uint32_t x137; + fiat_25519_scalar_uint1 x138; + uint32_t x139; + fiat_25519_scalar_uint1 x140; + uint32_t x141; + fiat_25519_scalar_uint1 x142; + uint32_t x143; + fiat_25519_scalar_uint1 x144; + uint32_t x145; + fiat_25519_scalar_uint1 x146; + uint32_t x147; + fiat_25519_scalar_uint1 x148; + uint32_t x149; + fiat_25519_scalar_uint1 x150; + uint32_t x151; + fiat_25519_scalar_uint1 x152; + uint32_t x153; + uint32_t x154; + uint32_t x155; + uint32_t x156; + uint32_t x157; + uint32_t x158; + uint32_t x159; + uint32_t x160; + uint32_t x161; + uint32_t x162; + uint32_t x163; + uint32_t x164; + uint32_t x165; + uint32_t x166; + uint32_t x167; + uint32_t x168; + uint32_t x169; + fiat_25519_scalar_uint1 x170; + uint32_t x171; + fiat_25519_scalar_uint1 x172; + uint32_t x173; + fiat_25519_scalar_uint1 x174; + uint32_t x175; + fiat_25519_scalar_uint1 x176; + uint32_t x177; + fiat_25519_scalar_uint1 x178; + uint32_t x179; + fiat_25519_scalar_uint1 x180; + uint32_t x181; + fiat_25519_scalar_uint1 x182; + uint32_t x183; + fiat_25519_scalar_uint1 x184; + uint32_t x185; + fiat_25519_scalar_uint1 x186; + uint32_t x187; + fiat_25519_scalar_uint1 x188; + uint32_t x189; + fiat_25519_scalar_uint1 x190; + uint32_t x191; + fiat_25519_scalar_uint1 x192; + uint32_t x193; + fiat_25519_scalar_uint1 x194; + uint32_t x195; + fiat_25519_scalar_uint1 x196; + uint32_t x197; + fiat_25519_scalar_uint1 x198; + uint32_t x199; + uint32_t x200; + uint32_t x201; + uint32_t x202; + uint32_t x203; + uint32_t x204; + uint32_t x205; + uint32_t x206; + uint32_t x207; + uint32_t x208; + uint32_t x209; + uint32_t x210; + uint32_t x211; + fiat_25519_scalar_uint1 x212; + uint32_t x213; + fiat_25519_scalar_uint1 x214; + uint32_t x215; + fiat_25519_scalar_uint1 x216; + uint32_t x217; + fiat_25519_scalar_uint1 x218; + uint32_t x219; + fiat_25519_scalar_uint1 x220; + uint32_t x221; + fiat_25519_scalar_uint1 x222; + uint32_t x223; + fiat_25519_scalar_uint1 x224; + uint32_t x225; + fiat_25519_scalar_uint1 x226; + uint32_t x227; + fiat_25519_scalar_uint1 x228; + uint32_t x229; + fiat_25519_scalar_uint1 x230; + uint32_t x231; + fiat_25519_scalar_uint1 x232; + uint32_t x233; + uint32_t x234; + uint32_t x235; + uint32_t x236; + uint32_t x237; + uint32_t x238; + uint32_t x239; + uint32_t x240; + uint32_t x241; + uint32_t x242; + uint32_t x243; + uint32_t x244; + uint32_t x245; + uint32_t x246; + uint32_t x247; + uint32_t x248; + uint32_t x249; + fiat_25519_scalar_uint1 x250; + uint32_t x251; + fiat_25519_scalar_uint1 x252; + uint32_t x253; + fiat_25519_scalar_uint1 x254; + uint32_t x255; + fiat_25519_scalar_uint1 x256; + uint32_t x257; + fiat_25519_scalar_uint1 x258; + uint32_t x259; + fiat_25519_scalar_uint1 x260; + uint32_t x261; + fiat_25519_scalar_uint1 x262; + uint32_t x263; + fiat_25519_scalar_uint1 x264; + uint32_t x265; + fiat_25519_scalar_uint1 x266; + uint32_t x267; + fiat_25519_scalar_uint1 x268; + uint32_t x269; + fiat_25519_scalar_uint1 x270; + uint32_t x271; + fiat_25519_scalar_uint1 x272; + uint32_t x273; + fiat_25519_scalar_uint1 x274; + uint32_t x275; + fiat_25519_scalar_uint1 x276; + uint32_t x277; + fiat_25519_scalar_uint1 x278; + uint32_t x279; + uint32_t x280; + uint32_t x281; + uint32_t x282; + uint32_t x283; + uint32_t x284; + uint32_t x285; + uint32_t x286; + uint32_t x287; + uint32_t x288; + uint32_t x289; + uint32_t x290; + uint32_t x291; + fiat_25519_scalar_uint1 x292; + uint32_t x293; + fiat_25519_scalar_uint1 x294; + uint32_t x295; + fiat_25519_scalar_uint1 x296; + uint32_t x297; + fiat_25519_scalar_uint1 x298; + uint32_t x299; + fiat_25519_scalar_uint1 x300; + uint32_t x301; + fiat_25519_scalar_uint1 x302; + uint32_t x303; + fiat_25519_scalar_uint1 x304; + uint32_t x305; + fiat_25519_scalar_uint1 x306; + uint32_t x307; + fiat_25519_scalar_uint1 x308; + uint32_t x309; + fiat_25519_scalar_uint1 x310; + uint32_t x311; + fiat_25519_scalar_uint1 x312; + uint32_t x313; + uint32_t x314; + uint32_t x315; + uint32_t x316; + uint32_t x317; + uint32_t x318; + uint32_t x319; + uint32_t x320; + uint32_t x321; + uint32_t x322; + uint32_t x323; + uint32_t x324; + uint32_t x325; + uint32_t x326; + uint32_t x327; + uint32_t x328; + uint32_t x329; + fiat_25519_scalar_uint1 x330; + uint32_t x331; + fiat_25519_scalar_uint1 x332; + uint32_t x333; + fiat_25519_scalar_uint1 x334; + uint32_t x335; + fiat_25519_scalar_uint1 x336; + uint32_t x337; + fiat_25519_scalar_uint1 x338; + uint32_t x339; + fiat_25519_scalar_uint1 x340; + uint32_t x341; + fiat_25519_scalar_uint1 x342; + uint32_t x343; + fiat_25519_scalar_uint1 x344; + uint32_t x345; + fiat_25519_scalar_uint1 x346; + uint32_t x347; + fiat_25519_scalar_uint1 x348; + uint32_t x349; + fiat_25519_scalar_uint1 x350; + uint32_t x351; + fiat_25519_scalar_uint1 x352; + uint32_t x353; + fiat_25519_scalar_uint1 x354; + uint32_t x355; + fiat_25519_scalar_uint1 x356; + uint32_t x357; + fiat_25519_scalar_uint1 x358; + uint32_t x359; + uint32_t x360; + uint32_t x361; + uint32_t x362; + uint32_t x363; + uint32_t x364; + uint32_t x365; + uint32_t x366; + uint32_t x367; + uint32_t x368; + uint32_t x369; + uint32_t x370; + uint32_t x371; + fiat_25519_scalar_uint1 x372; + uint32_t x373; + fiat_25519_scalar_uint1 x374; + uint32_t x375; + fiat_25519_scalar_uint1 x376; + uint32_t x377; + fiat_25519_scalar_uint1 x378; + uint32_t x379; + fiat_25519_scalar_uint1 x380; + uint32_t x381; + fiat_25519_scalar_uint1 x382; + uint32_t x383; + fiat_25519_scalar_uint1 x384; + uint32_t x385; + fiat_25519_scalar_uint1 x386; + uint32_t x387; + fiat_25519_scalar_uint1 x388; + uint32_t x389; + fiat_25519_scalar_uint1 x390; + uint32_t x391; + fiat_25519_scalar_uint1 x392; + uint32_t x393; + uint32_t x394; + uint32_t x395; + uint32_t x396; + uint32_t x397; + uint32_t x398; + uint32_t x399; + uint32_t x400; + uint32_t x401; + uint32_t x402; + uint32_t x403; + uint32_t x404; + uint32_t x405; + uint32_t x406; + uint32_t x407; + uint32_t x408; + uint32_t x409; + fiat_25519_scalar_uint1 x410; + uint32_t x411; + fiat_25519_scalar_uint1 x412; + uint32_t x413; + fiat_25519_scalar_uint1 x414; + uint32_t x415; + fiat_25519_scalar_uint1 x416; + uint32_t x417; + fiat_25519_scalar_uint1 x418; + uint32_t x419; + fiat_25519_scalar_uint1 x420; + uint32_t x421; + fiat_25519_scalar_uint1 x422; + uint32_t x423; + fiat_25519_scalar_uint1 x424; + uint32_t x425; + fiat_25519_scalar_uint1 x426; + uint32_t x427; + fiat_25519_scalar_uint1 x428; + uint32_t x429; + fiat_25519_scalar_uint1 x430; + uint32_t x431; + fiat_25519_scalar_uint1 x432; + uint32_t x433; + fiat_25519_scalar_uint1 x434; + uint32_t x435; + fiat_25519_scalar_uint1 x436; + uint32_t x437; + fiat_25519_scalar_uint1 x438; + uint32_t x439; + uint32_t x440; + uint32_t x441; + uint32_t x442; + uint32_t x443; + uint32_t x444; + uint32_t x445; + uint32_t x446; + uint32_t x447; + uint32_t x448; + uint32_t x449; + uint32_t x450; + uint32_t x451; + fiat_25519_scalar_uint1 x452; + uint32_t x453; + fiat_25519_scalar_uint1 x454; + uint32_t x455; + fiat_25519_scalar_uint1 x456; + uint32_t x457; + fiat_25519_scalar_uint1 x458; + uint32_t x459; + fiat_25519_scalar_uint1 x460; + uint32_t x461; + fiat_25519_scalar_uint1 x462; + uint32_t x463; + fiat_25519_scalar_uint1 x464; + uint32_t x465; + fiat_25519_scalar_uint1 x466; + uint32_t x467; + fiat_25519_scalar_uint1 x468; + uint32_t x469; + fiat_25519_scalar_uint1 x470; + uint32_t x471; + fiat_25519_scalar_uint1 x472; + uint32_t x473; + uint32_t x474; + uint32_t x475; + uint32_t x476; + uint32_t x477; + uint32_t x478; + uint32_t x479; + uint32_t x480; + uint32_t x481; + uint32_t x482; + uint32_t x483; + uint32_t x484; + uint32_t x485; + uint32_t x486; + uint32_t x487; + uint32_t x488; + uint32_t x489; + fiat_25519_scalar_uint1 x490; + uint32_t x491; + fiat_25519_scalar_uint1 x492; + uint32_t x493; + fiat_25519_scalar_uint1 x494; + uint32_t x495; + fiat_25519_scalar_uint1 x496; + uint32_t x497; + fiat_25519_scalar_uint1 x498; + uint32_t x499; + fiat_25519_scalar_uint1 x500; + uint32_t x501; + fiat_25519_scalar_uint1 x502; + uint32_t x503; + fiat_25519_scalar_uint1 x504; + uint32_t x505; + fiat_25519_scalar_uint1 x506; + uint32_t x507; + fiat_25519_scalar_uint1 x508; + uint32_t x509; + fiat_25519_scalar_uint1 x510; + uint32_t x511; + fiat_25519_scalar_uint1 x512; + uint32_t x513; + fiat_25519_scalar_uint1 x514; + uint32_t x515; + fiat_25519_scalar_uint1 x516; + uint32_t x517; + fiat_25519_scalar_uint1 x518; + uint32_t x519; + uint32_t x520; + uint32_t x521; + uint32_t x522; + uint32_t x523; + uint32_t x524; + uint32_t x525; + uint32_t x526; + uint32_t x527; + uint32_t x528; + uint32_t x529; + uint32_t x530; + uint32_t x531; + fiat_25519_scalar_uint1 x532; + uint32_t x533; + fiat_25519_scalar_uint1 x534; + uint32_t x535; + fiat_25519_scalar_uint1 x536; + uint32_t x537; + fiat_25519_scalar_uint1 x538; + uint32_t x539; + fiat_25519_scalar_uint1 x540; + uint32_t x541; + fiat_25519_scalar_uint1 x542; + uint32_t x543; + fiat_25519_scalar_uint1 x544; + uint32_t x545; + fiat_25519_scalar_uint1 x546; + uint32_t x547; + fiat_25519_scalar_uint1 x548; + uint32_t x549; + fiat_25519_scalar_uint1 x550; + uint32_t x551; + fiat_25519_scalar_uint1 x552; + uint32_t x553; + uint32_t x554; + uint32_t x555; + uint32_t x556; + uint32_t x557; + uint32_t x558; + uint32_t x559; + uint32_t x560; + uint32_t x561; + uint32_t x562; + uint32_t x563; + uint32_t x564; + uint32_t x565; + uint32_t x566; + uint32_t x567; + uint32_t x568; + uint32_t x569; + fiat_25519_scalar_uint1 x570; + uint32_t x571; + fiat_25519_scalar_uint1 x572; + uint32_t x573; + fiat_25519_scalar_uint1 x574; + uint32_t x575; + fiat_25519_scalar_uint1 x576; + uint32_t x577; + fiat_25519_scalar_uint1 x578; + uint32_t x579; + fiat_25519_scalar_uint1 x580; + uint32_t x581; + fiat_25519_scalar_uint1 x582; + uint32_t x583; + fiat_25519_scalar_uint1 x584; + uint32_t x585; + fiat_25519_scalar_uint1 x586; + uint32_t x587; + fiat_25519_scalar_uint1 x588; + uint32_t x589; + fiat_25519_scalar_uint1 x590; + uint32_t x591; + fiat_25519_scalar_uint1 x592; + uint32_t x593; + fiat_25519_scalar_uint1 x594; + uint32_t x595; + fiat_25519_scalar_uint1 x596; + uint32_t x597; + fiat_25519_scalar_uint1 x598; + uint32_t x599; + uint32_t x600; + uint32_t x601; + uint32_t x602; + uint32_t x603; + uint32_t x604; + uint32_t x605; + uint32_t x606; + uint32_t x607; + uint32_t x608; + uint32_t x609; + uint32_t x610; + uint32_t x611; + fiat_25519_scalar_uint1 x612; + uint32_t x613; + fiat_25519_scalar_uint1 x614; + uint32_t x615; + fiat_25519_scalar_uint1 x616; + uint32_t x617; + fiat_25519_scalar_uint1 x618; + uint32_t x619; + fiat_25519_scalar_uint1 x620; + uint32_t x621; + fiat_25519_scalar_uint1 x622; + uint32_t x623; + fiat_25519_scalar_uint1 x624; + uint32_t x625; + fiat_25519_scalar_uint1 x626; + uint32_t x627; + fiat_25519_scalar_uint1 x628; + uint32_t x629; + fiat_25519_scalar_uint1 x630; + uint32_t x631; + fiat_25519_scalar_uint1 x632; + uint32_t x633; + uint32_t x634; + fiat_25519_scalar_uint1 x635; + uint32_t x636; + fiat_25519_scalar_uint1 x637; + uint32_t x638; + fiat_25519_scalar_uint1 x639; + uint32_t x640; + fiat_25519_scalar_uint1 x641; + uint32_t x642; + fiat_25519_scalar_uint1 x643; + uint32_t x644; + fiat_25519_scalar_uint1 x645; + uint32_t x646; + fiat_25519_scalar_uint1 x647; + uint32_t x648; + fiat_25519_scalar_uint1 x649; + uint32_t x650; + fiat_25519_scalar_uint1 x651; + uint32_t x652; + uint32_t x653; + uint32_t x654; + uint32_t x655; + uint32_t x656; + uint32_t x657; + uint32_t x658; + uint32_t x659; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[6]); + x7 = (arg1[7]); + x8 = (arg1[0]); + fiat_25519_scalar_mulx_u32(&x9, &x10, x8, UINT32_C(0x399411b)); + fiat_25519_scalar_mulx_u32(&x11, &x12, x8, UINT32_C(0x7c309a3d)); + fiat_25519_scalar_mulx_u32(&x13, &x14, x8, UINT32_C(0xceec73d2)); + fiat_25519_scalar_mulx_u32(&x15, &x16, x8, UINT32_C(0x17f5be65)); + fiat_25519_scalar_mulx_u32(&x17, &x18, x8, UINT32_C(0xd00e1ba7)); + fiat_25519_scalar_mulx_u32(&x19, &x20, x8, UINT32_C(0x68859347)); + fiat_25519_scalar_mulx_u32(&x21, &x22, x8, UINT32_C(0xa40611e3)); + fiat_25519_scalar_mulx_u32(&x23, &x24, x8, UINT32_C(0x449c0f01)); + fiat_25519_scalar_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_25519_scalar_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_25519_scalar_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_25519_scalar_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_25519_scalar_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_25519_scalar_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_25519_scalar_addcarryx_u32(&x37, &x38, x36, x12, x9); + fiat_25519_scalar_mulx_u32(&x39, &x40, x23, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x41, &x42, x39, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x43, &x44, x39, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x45, &x46, x39, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x47, &x48, x39, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x49, &x50, x39, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x51, &x52, 0x0, x50, x47); + fiat_25519_scalar_addcarryx_u32(&x53, &x54, x52, x48, x45); + fiat_25519_scalar_addcarryx_u32(&x55, &x56, x54, x46, x43); + fiat_25519_scalar_addcarryx_u32(&x57, &x58, 0x0, x23, x49); + fiat_25519_scalar_addcarryx_u32(&x59, &x60, x58, x25, x51); + fiat_25519_scalar_addcarryx_u32(&x61, &x62, x60, x27, x53); + fiat_25519_scalar_addcarryx_u32(&x63, &x64, x62, x29, x55); + fiat_25519_scalar_addcarryx_u32(&x65, &x66, x64, x31, (x56 + x44)); + fiat_25519_scalar_addcarryx_u32(&x67, &x68, x66, x33, 0x0); + fiat_25519_scalar_addcarryx_u32(&x69, &x70, x68, x35, 0x0); + fiat_25519_scalar_addcarryx_u32(&x71, &x72, x70, x37, x41); + fiat_25519_scalar_mulx_u32(&x73, &x74, x1, UINT32_C(0x399411b)); + fiat_25519_scalar_mulx_u32(&x75, &x76, x1, UINT32_C(0x7c309a3d)); + fiat_25519_scalar_mulx_u32(&x77, &x78, x1, UINT32_C(0xceec73d2)); + fiat_25519_scalar_mulx_u32(&x79, &x80, x1, UINT32_C(0x17f5be65)); + fiat_25519_scalar_mulx_u32(&x81, &x82, x1, UINT32_C(0xd00e1ba7)); + fiat_25519_scalar_mulx_u32(&x83, &x84, x1, UINT32_C(0x68859347)); + fiat_25519_scalar_mulx_u32(&x85, &x86, x1, UINT32_C(0xa40611e3)); + fiat_25519_scalar_mulx_u32(&x87, &x88, x1, UINT32_C(0x449c0f01)); + fiat_25519_scalar_addcarryx_u32(&x89, &x90, 0x0, x88, x85); + fiat_25519_scalar_addcarryx_u32(&x91, &x92, x90, x86, x83); + fiat_25519_scalar_addcarryx_u32(&x93, &x94, x92, x84, x81); + fiat_25519_scalar_addcarryx_u32(&x95, &x96, x94, x82, x79); + fiat_25519_scalar_addcarryx_u32(&x97, &x98, x96, x80, x77); + fiat_25519_scalar_addcarryx_u32(&x99, &x100, x98, x78, x75); + fiat_25519_scalar_addcarryx_u32(&x101, &x102, x100, x76, x73); + fiat_25519_scalar_addcarryx_u32(&x103, &x104, 0x0, x59, x87); + fiat_25519_scalar_addcarryx_u32(&x105, &x106, x104, x61, x89); + fiat_25519_scalar_addcarryx_u32(&x107, &x108, x106, x63, x91); + fiat_25519_scalar_addcarryx_u32(&x109, &x110, x108, x65, x93); + fiat_25519_scalar_addcarryx_u32(&x111, &x112, x110, x67, x95); + fiat_25519_scalar_addcarryx_u32(&x113, &x114, x112, x69, x97); + fiat_25519_scalar_addcarryx_u32(&x115, &x116, x114, x71, x99); + fiat_25519_scalar_addcarryx_u32(&x117, &x118, x116, ((x72 + (x38 + x10)) + x42), x101); + fiat_25519_scalar_mulx_u32(&x119, &x120, x103, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x121, &x122, x119, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x123, &x124, x119, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x125, &x126, x119, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x127, &x128, x119, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x129, &x130, x119, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x131, &x132, 0x0, x130, x127); + fiat_25519_scalar_addcarryx_u32(&x133, &x134, x132, x128, x125); + fiat_25519_scalar_addcarryx_u32(&x135, &x136, x134, x126, x123); + fiat_25519_scalar_addcarryx_u32(&x137, &x138, 0x0, x103, x129); + fiat_25519_scalar_addcarryx_u32(&x139, &x140, x138, x105, x131); + fiat_25519_scalar_addcarryx_u32(&x141, &x142, x140, x107, x133); + fiat_25519_scalar_addcarryx_u32(&x143, &x144, x142, x109, x135); + fiat_25519_scalar_addcarryx_u32(&x145, &x146, x144, x111, (x136 + x124)); + fiat_25519_scalar_addcarryx_u32(&x147, &x148, x146, x113, 0x0); + fiat_25519_scalar_addcarryx_u32(&x149, &x150, x148, x115, 0x0); + fiat_25519_scalar_addcarryx_u32(&x151, &x152, x150, x117, x121); + fiat_25519_scalar_mulx_u32(&x153, &x154, x2, UINT32_C(0x399411b)); + fiat_25519_scalar_mulx_u32(&x155, &x156, x2, UINT32_C(0x7c309a3d)); + fiat_25519_scalar_mulx_u32(&x157, &x158, x2, UINT32_C(0xceec73d2)); + fiat_25519_scalar_mulx_u32(&x159, &x160, x2, UINT32_C(0x17f5be65)); + fiat_25519_scalar_mulx_u32(&x161, &x162, x2, UINT32_C(0xd00e1ba7)); + fiat_25519_scalar_mulx_u32(&x163, &x164, x2, UINT32_C(0x68859347)); + fiat_25519_scalar_mulx_u32(&x165, &x166, x2, UINT32_C(0xa40611e3)); + fiat_25519_scalar_mulx_u32(&x167, &x168, x2, UINT32_C(0x449c0f01)); + fiat_25519_scalar_addcarryx_u32(&x169, &x170, 0x0, x168, x165); + fiat_25519_scalar_addcarryx_u32(&x171, &x172, x170, x166, x163); + fiat_25519_scalar_addcarryx_u32(&x173, &x174, x172, x164, x161); + fiat_25519_scalar_addcarryx_u32(&x175, &x176, x174, x162, x159); + fiat_25519_scalar_addcarryx_u32(&x177, &x178, x176, x160, x157); + fiat_25519_scalar_addcarryx_u32(&x179, &x180, x178, x158, x155); + fiat_25519_scalar_addcarryx_u32(&x181, &x182, x180, x156, x153); + fiat_25519_scalar_addcarryx_u32(&x183, &x184, 0x0, x139, x167); + fiat_25519_scalar_addcarryx_u32(&x185, &x186, x184, x141, x169); + fiat_25519_scalar_addcarryx_u32(&x187, &x188, x186, x143, x171); + fiat_25519_scalar_addcarryx_u32(&x189, &x190, x188, x145, x173); + fiat_25519_scalar_addcarryx_u32(&x191, &x192, x190, x147, x175); + fiat_25519_scalar_addcarryx_u32(&x193, &x194, x192, x149, x177); + fiat_25519_scalar_addcarryx_u32(&x195, &x196, x194, x151, x179); + fiat_25519_scalar_addcarryx_u32(&x197, &x198, x196, ((x152 + (x118 + (x102 + x74))) + x122), x181); + fiat_25519_scalar_mulx_u32(&x199, &x200, x183, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x201, &x202, x199, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x203, &x204, x199, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x205, &x206, x199, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x207, &x208, x199, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x209, &x210, x199, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x211, &x212, 0x0, x210, x207); + fiat_25519_scalar_addcarryx_u32(&x213, &x214, x212, x208, x205); + fiat_25519_scalar_addcarryx_u32(&x215, &x216, x214, x206, x203); + fiat_25519_scalar_addcarryx_u32(&x217, &x218, 0x0, x183, x209); + fiat_25519_scalar_addcarryx_u32(&x219, &x220, x218, x185, x211); + fiat_25519_scalar_addcarryx_u32(&x221, &x222, x220, x187, x213); + fiat_25519_scalar_addcarryx_u32(&x223, &x224, x222, x189, x215); + fiat_25519_scalar_addcarryx_u32(&x225, &x226, x224, x191, (x216 + x204)); + fiat_25519_scalar_addcarryx_u32(&x227, &x228, x226, x193, 0x0); + fiat_25519_scalar_addcarryx_u32(&x229, &x230, x228, x195, 0x0); + fiat_25519_scalar_addcarryx_u32(&x231, &x232, x230, x197, x201); + fiat_25519_scalar_mulx_u32(&x233, &x234, x3, UINT32_C(0x399411b)); + fiat_25519_scalar_mulx_u32(&x235, &x236, x3, UINT32_C(0x7c309a3d)); + fiat_25519_scalar_mulx_u32(&x237, &x238, x3, UINT32_C(0xceec73d2)); + fiat_25519_scalar_mulx_u32(&x239, &x240, x3, UINT32_C(0x17f5be65)); + fiat_25519_scalar_mulx_u32(&x241, &x242, x3, UINT32_C(0xd00e1ba7)); + fiat_25519_scalar_mulx_u32(&x243, &x244, x3, UINT32_C(0x68859347)); + fiat_25519_scalar_mulx_u32(&x245, &x246, x3, UINT32_C(0xa40611e3)); + fiat_25519_scalar_mulx_u32(&x247, &x248, x3, UINT32_C(0x449c0f01)); + fiat_25519_scalar_addcarryx_u32(&x249, &x250, 0x0, x248, x245); + fiat_25519_scalar_addcarryx_u32(&x251, &x252, x250, x246, x243); + fiat_25519_scalar_addcarryx_u32(&x253, &x254, x252, x244, x241); + fiat_25519_scalar_addcarryx_u32(&x255, &x256, x254, x242, x239); + fiat_25519_scalar_addcarryx_u32(&x257, &x258, x256, x240, x237); + fiat_25519_scalar_addcarryx_u32(&x259, &x260, x258, x238, x235); + fiat_25519_scalar_addcarryx_u32(&x261, &x262, x260, x236, x233); + fiat_25519_scalar_addcarryx_u32(&x263, &x264, 0x0, x219, x247); + fiat_25519_scalar_addcarryx_u32(&x265, &x266, x264, x221, x249); + fiat_25519_scalar_addcarryx_u32(&x267, &x268, x266, x223, x251); + fiat_25519_scalar_addcarryx_u32(&x269, &x270, x268, x225, x253); + fiat_25519_scalar_addcarryx_u32(&x271, &x272, x270, x227, x255); + fiat_25519_scalar_addcarryx_u32(&x273, &x274, x272, x229, x257); + fiat_25519_scalar_addcarryx_u32(&x275, &x276, x274, x231, x259); + fiat_25519_scalar_addcarryx_u32(&x277, &x278, x276, ((x232 + (x198 + (x182 + x154))) + x202), x261); + fiat_25519_scalar_mulx_u32(&x279, &x280, x263, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x281, &x282, x279, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x283, &x284, x279, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x285, &x286, x279, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x287, &x288, x279, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x289, &x290, x279, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x291, &x292, 0x0, x290, x287); + fiat_25519_scalar_addcarryx_u32(&x293, &x294, x292, x288, x285); + fiat_25519_scalar_addcarryx_u32(&x295, &x296, x294, x286, x283); + fiat_25519_scalar_addcarryx_u32(&x297, &x298, 0x0, x263, x289); + fiat_25519_scalar_addcarryx_u32(&x299, &x300, x298, x265, x291); + fiat_25519_scalar_addcarryx_u32(&x301, &x302, x300, x267, x293); + fiat_25519_scalar_addcarryx_u32(&x303, &x304, x302, x269, x295); + fiat_25519_scalar_addcarryx_u32(&x305, &x306, x304, x271, (x296 + x284)); + fiat_25519_scalar_addcarryx_u32(&x307, &x308, x306, x273, 0x0); + fiat_25519_scalar_addcarryx_u32(&x309, &x310, x308, x275, 0x0); + fiat_25519_scalar_addcarryx_u32(&x311, &x312, x310, x277, x281); + fiat_25519_scalar_mulx_u32(&x313, &x314, x4, UINT32_C(0x399411b)); + fiat_25519_scalar_mulx_u32(&x315, &x316, x4, UINT32_C(0x7c309a3d)); + fiat_25519_scalar_mulx_u32(&x317, &x318, x4, UINT32_C(0xceec73d2)); + fiat_25519_scalar_mulx_u32(&x319, &x320, x4, UINT32_C(0x17f5be65)); + fiat_25519_scalar_mulx_u32(&x321, &x322, x4, UINT32_C(0xd00e1ba7)); + fiat_25519_scalar_mulx_u32(&x323, &x324, x4, UINT32_C(0x68859347)); + fiat_25519_scalar_mulx_u32(&x325, &x326, x4, UINT32_C(0xa40611e3)); + fiat_25519_scalar_mulx_u32(&x327, &x328, x4, UINT32_C(0x449c0f01)); + fiat_25519_scalar_addcarryx_u32(&x329, &x330, 0x0, x328, x325); + fiat_25519_scalar_addcarryx_u32(&x331, &x332, x330, x326, x323); + fiat_25519_scalar_addcarryx_u32(&x333, &x334, x332, x324, x321); + fiat_25519_scalar_addcarryx_u32(&x335, &x336, x334, x322, x319); + fiat_25519_scalar_addcarryx_u32(&x337, &x338, x336, x320, x317); + fiat_25519_scalar_addcarryx_u32(&x339, &x340, x338, x318, x315); + fiat_25519_scalar_addcarryx_u32(&x341, &x342, x340, x316, x313); + fiat_25519_scalar_addcarryx_u32(&x343, &x344, 0x0, x299, x327); + fiat_25519_scalar_addcarryx_u32(&x345, &x346, x344, x301, x329); + fiat_25519_scalar_addcarryx_u32(&x347, &x348, x346, x303, x331); + fiat_25519_scalar_addcarryx_u32(&x349, &x350, x348, x305, x333); + fiat_25519_scalar_addcarryx_u32(&x351, &x352, x350, x307, x335); + fiat_25519_scalar_addcarryx_u32(&x353, &x354, x352, x309, x337); + fiat_25519_scalar_addcarryx_u32(&x355, &x356, x354, x311, x339); + fiat_25519_scalar_addcarryx_u32(&x357, &x358, x356, ((x312 + (x278 + (x262 + x234))) + x282), x341); + fiat_25519_scalar_mulx_u32(&x359, &x360, x343, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x361, &x362, x359, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x363, &x364, x359, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x365, &x366, x359, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x367, &x368, x359, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x369, &x370, x359, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x371, &x372, 0x0, x370, x367); + fiat_25519_scalar_addcarryx_u32(&x373, &x374, x372, x368, x365); + fiat_25519_scalar_addcarryx_u32(&x375, &x376, x374, x366, x363); + fiat_25519_scalar_addcarryx_u32(&x377, &x378, 0x0, x343, x369); + fiat_25519_scalar_addcarryx_u32(&x379, &x380, x378, x345, x371); + fiat_25519_scalar_addcarryx_u32(&x381, &x382, x380, x347, x373); + fiat_25519_scalar_addcarryx_u32(&x383, &x384, x382, x349, x375); + fiat_25519_scalar_addcarryx_u32(&x385, &x386, x384, x351, (x376 + x364)); + fiat_25519_scalar_addcarryx_u32(&x387, &x388, x386, x353, 0x0); + fiat_25519_scalar_addcarryx_u32(&x389, &x390, x388, x355, 0x0); + fiat_25519_scalar_addcarryx_u32(&x391, &x392, x390, x357, x361); + fiat_25519_scalar_mulx_u32(&x393, &x394, x5, UINT32_C(0x399411b)); + fiat_25519_scalar_mulx_u32(&x395, &x396, x5, UINT32_C(0x7c309a3d)); + fiat_25519_scalar_mulx_u32(&x397, &x398, x5, UINT32_C(0xceec73d2)); + fiat_25519_scalar_mulx_u32(&x399, &x400, x5, UINT32_C(0x17f5be65)); + fiat_25519_scalar_mulx_u32(&x401, &x402, x5, UINT32_C(0xd00e1ba7)); + fiat_25519_scalar_mulx_u32(&x403, &x404, x5, UINT32_C(0x68859347)); + fiat_25519_scalar_mulx_u32(&x405, &x406, x5, UINT32_C(0xa40611e3)); + fiat_25519_scalar_mulx_u32(&x407, &x408, x5, UINT32_C(0x449c0f01)); + fiat_25519_scalar_addcarryx_u32(&x409, &x410, 0x0, x408, x405); + fiat_25519_scalar_addcarryx_u32(&x411, &x412, x410, x406, x403); + fiat_25519_scalar_addcarryx_u32(&x413, &x414, x412, x404, x401); + fiat_25519_scalar_addcarryx_u32(&x415, &x416, x414, x402, x399); + fiat_25519_scalar_addcarryx_u32(&x417, &x418, x416, x400, x397); + fiat_25519_scalar_addcarryx_u32(&x419, &x420, x418, x398, x395); + fiat_25519_scalar_addcarryx_u32(&x421, &x422, x420, x396, x393); + fiat_25519_scalar_addcarryx_u32(&x423, &x424, 0x0, x379, x407); + fiat_25519_scalar_addcarryx_u32(&x425, &x426, x424, x381, x409); + fiat_25519_scalar_addcarryx_u32(&x427, &x428, x426, x383, x411); + fiat_25519_scalar_addcarryx_u32(&x429, &x430, x428, x385, x413); + fiat_25519_scalar_addcarryx_u32(&x431, &x432, x430, x387, x415); + fiat_25519_scalar_addcarryx_u32(&x433, &x434, x432, x389, x417); + fiat_25519_scalar_addcarryx_u32(&x435, &x436, x434, x391, x419); + fiat_25519_scalar_addcarryx_u32(&x437, &x438, x436, ((x392 + (x358 + (x342 + x314))) + x362), x421); + fiat_25519_scalar_mulx_u32(&x439, &x440, x423, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x441, &x442, x439, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x443, &x444, x439, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x445, &x446, x439, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x447, &x448, x439, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x449, &x450, x439, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x451, &x452, 0x0, x450, x447); + fiat_25519_scalar_addcarryx_u32(&x453, &x454, x452, x448, x445); + fiat_25519_scalar_addcarryx_u32(&x455, &x456, x454, x446, x443); + fiat_25519_scalar_addcarryx_u32(&x457, &x458, 0x0, x423, x449); + fiat_25519_scalar_addcarryx_u32(&x459, &x460, x458, x425, x451); + fiat_25519_scalar_addcarryx_u32(&x461, &x462, x460, x427, x453); + fiat_25519_scalar_addcarryx_u32(&x463, &x464, x462, x429, x455); + fiat_25519_scalar_addcarryx_u32(&x465, &x466, x464, x431, (x456 + x444)); + fiat_25519_scalar_addcarryx_u32(&x467, &x468, x466, x433, 0x0); + fiat_25519_scalar_addcarryx_u32(&x469, &x470, x468, x435, 0x0); + fiat_25519_scalar_addcarryx_u32(&x471, &x472, x470, x437, x441); + fiat_25519_scalar_mulx_u32(&x473, &x474, x6, UINT32_C(0x399411b)); + fiat_25519_scalar_mulx_u32(&x475, &x476, x6, UINT32_C(0x7c309a3d)); + fiat_25519_scalar_mulx_u32(&x477, &x478, x6, UINT32_C(0xceec73d2)); + fiat_25519_scalar_mulx_u32(&x479, &x480, x6, UINT32_C(0x17f5be65)); + fiat_25519_scalar_mulx_u32(&x481, &x482, x6, UINT32_C(0xd00e1ba7)); + fiat_25519_scalar_mulx_u32(&x483, &x484, x6, UINT32_C(0x68859347)); + fiat_25519_scalar_mulx_u32(&x485, &x486, x6, UINT32_C(0xa40611e3)); + fiat_25519_scalar_mulx_u32(&x487, &x488, x6, UINT32_C(0x449c0f01)); + fiat_25519_scalar_addcarryx_u32(&x489, &x490, 0x0, x488, x485); + fiat_25519_scalar_addcarryx_u32(&x491, &x492, x490, x486, x483); + fiat_25519_scalar_addcarryx_u32(&x493, &x494, x492, x484, x481); + fiat_25519_scalar_addcarryx_u32(&x495, &x496, x494, x482, x479); + fiat_25519_scalar_addcarryx_u32(&x497, &x498, x496, x480, x477); + fiat_25519_scalar_addcarryx_u32(&x499, &x500, x498, x478, x475); + fiat_25519_scalar_addcarryx_u32(&x501, &x502, x500, x476, x473); + fiat_25519_scalar_addcarryx_u32(&x503, &x504, 0x0, x459, x487); + fiat_25519_scalar_addcarryx_u32(&x505, &x506, x504, x461, x489); + fiat_25519_scalar_addcarryx_u32(&x507, &x508, x506, x463, x491); + fiat_25519_scalar_addcarryx_u32(&x509, &x510, x508, x465, x493); + fiat_25519_scalar_addcarryx_u32(&x511, &x512, x510, x467, x495); + fiat_25519_scalar_addcarryx_u32(&x513, &x514, x512, x469, x497); + fiat_25519_scalar_addcarryx_u32(&x515, &x516, x514, x471, x499); + fiat_25519_scalar_addcarryx_u32(&x517, &x518, x516, ((x472 + (x438 + (x422 + x394))) + x442), x501); + fiat_25519_scalar_mulx_u32(&x519, &x520, x503, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x521, &x522, x519, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x523, &x524, x519, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x525, &x526, x519, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x527, &x528, x519, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x529, &x530, x519, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x531, &x532, 0x0, x530, x527); + fiat_25519_scalar_addcarryx_u32(&x533, &x534, x532, x528, x525); + fiat_25519_scalar_addcarryx_u32(&x535, &x536, x534, x526, x523); + fiat_25519_scalar_addcarryx_u32(&x537, &x538, 0x0, x503, x529); + fiat_25519_scalar_addcarryx_u32(&x539, &x540, x538, x505, x531); + fiat_25519_scalar_addcarryx_u32(&x541, &x542, x540, x507, x533); + fiat_25519_scalar_addcarryx_u32(&x543, &x544, x542, x509, x535); + fiat_25519_scalar_addcarryx_u32(&x545, &x546, x544, x511, (x536 + x524)); + fiat_25519_scalar_addcarryx_u32(&x547, &x548, x546, x513, 0x0); + fiat_25519_scalar_addcarryx_u32(&x549, &x550, x548, x515, 0x0); + fiat_25519_scalar_addcarryx_u32(&x551, &x552, x550, x517, x521); + fiat_25519_scalar_mulx_u32(&x553, &x554, x7, UINT32_C(0x399411b)); + fiat_25519_scalar_mulx_u32(&x555, &x556, x7, UINT32_C(0x7c309a3d)); + fiat_25519_scalar_mulx_u32(&x557, &x558, x7, UINT32_C(0xceec73d2)); + fiat_25519_scalar_mulx_u32(&x559, &x560, x7, UINT32_C(0x17f5be65)); + fiat_25519_scalar_mulx_u32(&x561, &x562, x7, UINT32_C(0xd00e1ba7)); + fiat_25519_scalar_mulx_u32(&x563, &x564, x7, UINT32_C(0x68859347)); + fiat_25519_scalar_mulx_u32(&x565, &x566, x7, UINT32_C(0xa40611e3)); + fiat_25519_scalar_mulx_u32(&x567, &x568, x7, UINT32_C(0x449c0f01)); + fiat_25519_scalar_addcarryx_u32(&x569, &x570, 0x0, x568, x565); + fiat_25519_scalar_addcarryx_u32(&x571, &x572, x570, x566, x563); + fiat_25519_scalar_addcarryx_u32(&x573, &x574, x572, x564, x561); + fiat_25519_scalar_addcarryx_u32(&x575, &x576, x574, x562, x559); + fiat_25519_scalar_addcarryx_u32(&x577, &x578, x576, x560, x557); + fiat_25519_scalar_addcarryx_u32(&x579, &x580, x578, x558, x555); + fiat_25519_scalar_addcarryx_u32(&x581, &x582, x580, x556, x553); + fiat_25519_scalar_addcarryx_u32(&x583, &x584, 0x0, x539, x567); + fiat_25519_scalar_addcarryx_u32(&x585, &x586, x584, x541, x569); + fiat_25519_scalar_addcarryx_u32(&x587, &x588, x586, x543, x571); + fiat_25519_scalar_addcarryx_u32(&x589, &x590, x588, x545, x573); + fiat_25519_scalar_addcarryx_u32(&x591, &x592, x590, x547, x575); + fiat_25519_scalar_addcarryx_u32(&x593, &x594, x592, x549, x577); + fiat_25519_scalar_addcarryx_u32(&x595, &x596, x594, x551, x579); + fiat_25519_scalar_addcarryx_u32(&x597, &x598, x596, ((x552 + (x518 + (x502 + x474))) + x522), x581); + fiat_25519_scalar_mulx_u32(&x599, &x600, x583, UINT32_C(0x12547e1b)); + fiat_25519_scalar_mulx_u32(&x601, &x602, x599, UINT32_C(0x10000000)); + fiat_25519_scalar_mulx_u32(&x603, &x604, x599, UINT32_C(0x14def9de)); + fiat_25519_scalar_mulx_u32(&x605, &x606, x599, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_mulx_u32(&x607, &x608, x599, UINT32_C(0x5812631a)); + fiat_25519_scalar_mulx_u32(&x609, &x610, x599, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_addcarryx_u32(&x611, &x612, 0x0, x610, x607); + fiat_25519_scalar_addcarryx_u32(&x613, &x614, x612, x608, x605); + fiat_25519_scalar_addcarryx_u32(&x615, &x616, x614, x606, x603); + fiat_25519_scalar_addcarryx_u32(&x617, &x618, 0x0, x583, x609); + fiat_25519_scalar_addcarryx_u32(&x619, &x620, x618, x585, x611); + fiat_25519_scalar_addcarryx_u32(&x621, &x622, x620, x587, x613); + fiat_25519_scalar_addcarryx_u32(&x623, &x624, x622, x589, x615); + fiat_25519_scalar_addcarryx_u32(&x625, &x626, x624, x591, (x616 + x604)); + fiat_25519_scalar_addcarryx_u32(&x627, &x628, x626, x593, 0x0); + fiat_25519_scalar_addcarryx_u32(&x629, &x630, x628, x595, 0x0); + fiat_25519_scalar_addcarryx_u32(&x631, &x632, x630, x597, x601); + x633 = ((x632 + (x598 + (x582 + x554))) + x602); + fiat_25519_scalar_subborrowx_u32(&x634, &x635, 0x0, x619, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_subborrowx_u32(&x636, &x637, x635, x621, UINT32_C(0x5812631a)); + fiat_25519_scalar_subborrowx_u32(&x638, &x639, x637, x623, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_subborrowx_u32(&x640, &x641, x639, x625, UINT32_C(0x14def9de)); + fiat_25519_scalar_subborrowx_u32(&x642, &x643, x641, x627, 0x0); + fiat_25519_scalar_subborrowx_u32(&x644, &x645, x643, x629, 0x0); + fiat_25519_scalar_subborrowx_u32(&x646, &x647, x645, x631, 0x0); + fiat_25519_scalar_subborrowx_u32(&x648, &x649, x647, x633, UINT32_C(0x10000000)); + fiat_25519_scalar_subborrowx_u32(&x650, &x651, x649, 0x0, 0x0); + fiat_25519_scalar_cmovznz_u32(&x652, x651, x634, x619); + fiat_25519_scalar_cmovznz_u32(&x653, x651, x636, x621); + fiat_25519_scalar_cmovznz_u32(&x654, x651, x638, x623); + fiat_25519_scalar_cmovznz_u32(&x655, x651, x640, x625); + fiat_25519_scalar_cmovznz_u32(&x656, x651, x642, x627); + fiat_25519_scalar_cmovznz_u32(&x657, x651, x644, x629); + fiat_25519_scalar_cmovznz_u32(&x658, x651, x646, x631); + fiat_25519_scalar_cmovznz_u32(&x659, x651, x648, x633); + out1[0] = x652; + out1[1] = x653; + out1[2] = x654; + out1[3] = x655; + out1[4] = x656; + out1[5] = x657; + out1[6] = x658; + out1[7] = x659; +} + +/* + * The function fiat_25519_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_nonzero(uint32_t* out1, const uint32_t arg1[8]) { + uint32_t x1; + x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | (arg1[7])))))))); + *out1 = x1; +} + +/* + * The function fiat_25519_scalar_selectznz is a multi-limb conditional select. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_selectznz(uint32_t out1[8], fiat_25519_scalar_uint1 arg1, const uint32_t arg2[8], const uint32_t arg3[8]) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + fiat_25519_scalar_cmovznz_u32(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_25519_scalar_cmovznz_u32(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_25519_scalar_cmovznz_u32(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_25519_scalar_cmovznz_u32(&x4, arg1, (arg2[3]), (arg3[3])); + fiat_25519_scalar_cmovznz_u32(&x5, arg1, (arg2[4]), (arg3[4])); + fiat_25519_scalar_cmovznz_u32(&x6, arg1, (arg2[5]), (arg3[5])); + fiat_25519_scalar_cmovznz_u32(&x7, arg1, (arg2[6]), (arg3[6])); + fiat_25519_scalar_cmovznz_u32(&x8, arg1, (arg2[7]), (arg3[7])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; + out1[6] = x7; + out1[7] = x8; +} + +/* + * The function fiat_25519_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0x1fffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_to_bytes(uint8_t out1[32], const uint32_t arg1[8]) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint8_t x9; + uint32_t x10; + uint8_t x11; + uint32_t x12; + uint8_t x13; + uint8_t x14; + uint8_t x15; + uint32_t x16; + uint8_t x17; + uint32_t x18; + uint8_t x19; + uint8_t x20; + uint8_t x21; + uint32_t x22; + uint8_t x23; + uint32_t x24; + uint8_t x25; + uint8_t x26; + uint8_t x27; + uint32_t x28; + uint8_t x29; + uint32_t x30; + uint8_t x31; + uint8_t x32; + uint8_t x33; + uint32_t x34; + uint8_t x35; + uint32_t x36; + uint8_t x37; + uint8_t x38; + uint8_t x39; + uint32_t x40; + uint8_t x41; + uint32_t x42; + uint8_t x43; + uint8_t x44; + uint8_t x45; + uint32_t x46; + uint8_t x47; + uint32_t x48; + uint8_t x49; + uint8_t x50; + uint8_t x51; + uint32_t x52; + uint8_t x53; + uint32_t x54; + uint8_t x55; + uint8_t x56; + x1 = (arg1[7]); + x2 = (arg1[6]); + x3 = (arg1[5]); + x4 = (arg1[4]); + x5 = (arg1[3]); + x6 = (arg1[2]); + x7 = (arg1[1]); + x8 = (arg1[0]); + x9 = (uint8_t)(x8 & UINT8_C(0xff)); + x10 = (x8 >> 8); + x11 = (uint8_t)(x10 & UINT8_C(0xff)); + x12 = (x10 >> 8); + x13 = (uint8_t)(x12 & UINT8_C(0xff)); + x14 = (uint8_t)(x12 >> 8); + x15 = (uint8_t)(x7 & UINT8_C(0xff)); + x16 = (x7 >> 8); + x17 = (uint8_t)(x16 & UINT8_C(0xff)); + x18 = (x16 >> 8); + x19 = (uint8_t)(x18 & UINT8_C(0xff)); + x20 = (uint8_t)(x18 >> 8); + x21 = (uint8_t)(x6 & UINT8_C(0xff)); + x22 = (x6 >> 8); + x23 = (uint8_t)(x22 & UINT8_C(0xff)); + x24 = (x22 >> 8); + x25 = (uint8_t)(x24 & UINT8_C(0xff)); + x26 = (uint8_t)(x24 >> 8); + x27 = (uint8_t)(x5 & UINT8_C(0xff)); + x28 = (x5 >> 8); + x29 = (uint8_t)(x28 & UINT8_C(0xff)); + x30 = (x28 >> 8); + x31 = (uint8_t)(x30 & UINT8_C(0xff)); + x32 = (uint8_t)(x30 >> 8); + x33 = (uint8_t)(x4 & UINT8_C(0xff)); + x34 = (x4 >> 8); + x35 = (uint8_t)(x34 & UINT8_C(0xff)); + x36 = (x34 >> 8); + x37 = (uint8_t)(x36 & UINT8_C(0xff)); + x38 = (uint8_t)(x36 >> 8); + x39 = (uint8_t)(x3 & UINT8_C(0xff)); + x40 = (x3 >> 8); + x41 = (uint8_t)(x40 & UINT8_C(0xff)); + x42 = (x40 >> 8); + x43 = (uint8_t)(x42 & UINT8_C(0xff)); + x44 = (uint8_t)(x42 >> 8); + x45 = (uint8_t)(x2 & UINT8_C(0xff)); + x46 = (x2 >> 8); + x47 = (uint8_t)(x46 & UINT8_C(0xff)); + x48 = (x46 >> 8); + x49 = (uint8_t)(x48 & UINT8_C(0xff)); + x50 = (uint8_t)(x48 >> 8); + x51 = (uint8_t)(x1 & UINT8_C(0xff)); + x52 = (x1 >> 8); + x53 = (uint8_t)(x52 & UINT8_C(0xff)); + x54 = (x52 >> 8); + x55 = (uint8_t)(x54 & UINT8_C(0xff)); + x56 = (uint8_t)(x54 >> 8); + out1[0] = x9; + out1[1] = x11; + out1[2] = x13; + out1[3] = x14; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x26; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x38; + out1[20] = x39; + out1[21] = x41; + out1[22] = x43; + out1[23] = x44; + out1[24] = x45; + out1[25] = x47; + out1[26] = x49; + out1[27] = x50; + out1[28] = x51; + out1[29] = x53; + out1[30] = x55; + out1[31] = x56; +} + +/* + * The function fiat_25519_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. + * + * Preconditions: + * 0 ≤ bytes_eval arg1 < m + * Postconditions: + * eval out1 mod m = bytes_eval arg1 mod m + * 0 ≤ eval out1 < m + * + * Input Bounds: + * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0x1fffffff]] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_from_bytes(uint32_t out1[8], const uint8_t arg1[32]) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint8_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint8_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint8_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint8_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint8_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint8_t x24; + uint32_t x25; + uint32_t x26; + uint32_t x27; + uint8_t x28; + uint32_t x29; + uint32_t x30; + uint32_t x31; + uint8_t x32; + uint32_t x33; + uint32_t x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + uint32_t x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + uint32_t x53; + uint32_t x54; + uint32_t x55; + uint32_t x56; + x1 = ((uint32_t)(arg1[31]) << 24); + x2 = ((uint32_t)(arg1[30]) << 16); + x3 = ((uint32_t)(arg1[29]) << 8); + x4 = (arg1[28]); + x5 = ((uint32_t)(arg1[27]) << 24); + x6 = ((uint32_t)(arg1[26]) << 16); + x7 = ((uint32_t)(arg1[25]) << 8); + x8 = (arg1[24]); + x9 = ((uint32_t)(arg1[23]) << 24); + x10 = ((uint32_t)(arg1[22]) << 16); + x11 = ((uint32_t)(arg1[21]) << 8); + x12 = (arg1[20]); + x13 = ((uint32_t)(arg1[19]) << 24); + x14 = ((uint32_t)(arg1[18]) << 16); + x15 = ((uint32_t)(arg1[17]) << 8); + x16 = (arg1[16]); + x17 = ((uint32_t)(arg1[15]) << 24); + x18 = ((uint32_t)(arg1[14]) << 16); + x19 = ((uint32_t)(arg1[13]) << 8); + x20 = (arg1[12]); + x21 = ((uint32_t)(arg1[11]) << 24); + x22 = ((uint32_t)(arg1[10]) << 16); + x23 = ((uint32_t)(arg1[9]) << 8); + x24 = (arg1[8]); + x25 = ((uint32_t)(arg1[7]) << 24); + x26 = ((uint32_t)(arg1[6]) << 16); + x27 = ((uint32_t)(arg1[5]) << 8); + x28 = (arg1[4]); + x29 = ((uint32_t)(arg1[3]) << 24); + x30 = ((uint32_t)(arg1[2]) << 16); + x31 = ((uint32_t)(arg1[1]) << 8); + x32 = (arg1[0]); + x33 = (x31 + (uint32_t)x32); + x34 = (x30 + x33); + x35 = (x29 + x34); + x36 = (x27 + (uint32_t)x28); + x37 = (x26 + x36); + x38 = (x25 + x37); + x39 = (x23 + (uint32_t)x24); + x40 = (x22 + x39); + x41 = (x21 + x40); + x42 = (x19 + (uint32_t)x20); + x43 = (x18 + x42); + x44 = (x17 + x43); + x45 = (x15 + (uint32_t)x16); + x46 = (x14 + x45); + x47 = (x13 + x46); + x48 = (x11 + (uint32_t)x12); + x49 = (x10 + x48); + x50 = (x9 + x49); + x51 = (x7 + (uint32_t)x8); + x52 = (x6 + x51); + x53 = (x5 + x52); + x54 = (x3 + (uint32_t)x4); + x55 = (x2 + x54); + x56 = (x1 + x55); + out1[0] = x35; + out1[1] = x38; + out1[2] = x41; + out1[3] = x44; + out1[4] = x47; + out1[5] = x50; + out1[6] = x53; + out1[7] = x56; +} + +/* + * The function fiat_25519_scalar_set_one returns the field element one in the Montgomery domain. + * + * Postconditions: + * eval (from_montgomery out1) mod m = 1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_set_one(fiat_25519_scalar_montgomery_domain_field_element out1) { + out1[0] = UINT32_C(0x8d98951d); + out1[1] = UINT32_C(0xd6ec3174); + out1[2] = UINT32_C(0x737dcf70); + out1[3] = UINT32_C(0xc6ef5bf4); + out1[4] = UINT32_C(0xfffffffe); + out1[5] = UINT32_C(0xffffffff); + out1[6] = UINT32_C(0xffffffff); + out1[7] = UINT32_C(0xfffffff); +} + +/* + * The function fiat_25519_scalar_msat returns the saturated representation of the prime modulus. + * + * Postconditions: + * twos_complement_eval out1 = m + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_msat(uint32_t out1[9]) { + out1[0] = UINT32_C(0x5cf5d3ed); + out1[1] = UINT32_C(0x5812631a); + out1[2] = UINT32_C(0xa2f79cd6); + out1[3] = UINT32_C(0x14def9de); + out1[4] = 0x0; + out1[5] = 0x0; + out1[6] = 0x0; + out1[7] = UINT32_C(0x10000000); + out1[8] = 0x0; +} + +/* + * The function fiat_25519_scalar_divstep computes a divstep. + * + * Preconditions: + * 0 ≤ eval arg4 < m + * 0 ≤ eval arg5 < m + * Postconditions: + * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) + * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) + * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) + * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) + * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) + * 0 ≤ eval out5 < m + * 0 ≤ eval out5 < m + * 0 ≤ eval out2 < m + * 0 ≤ eval out3 < m + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffff] + * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_divstep(uint32_t* out1, uint32_t out2[9], uint32_t out3[9], uint32_t out4[8], uint32_t out5[8], uint32_t arg1, const uint32_t arg2[9], const uint32_t arg3[9], const uint32_t arg4[8], const uint32_t arg5[8]) { + uint32_t x1; + fiat_25519_scalar_uint1 x2; + fiat_25519_scalar_uint1 x3; + uint32_t x4; + fiat_25519_scalar_uint1 x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + fiat_25519_scalar_uint1 x17; + uint32_t x18; + fiat_25519_scalar_uint1 x19; + uint32_t x20; + fiat_25519_scalar_uint1 x21; + uint32_t x22; + fiat_25519_scalar_uint1 x23; + uint32_t x24; + fiat_25519_scalar_uint1 x25; + uint32_t x26; + fiat_25519_scalar_uint1 x27; + uint32_t x28; + fiat_25519_scalar_uint1 x29; + uint32_t x30; + fiat_25519_scalar_uint1 x31; + uint32_t x32; + fiat_25519_scalar_uint1 x33; + uint32_t x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + uint32_t x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + fiat_25519_scalar_uint1 x52; + uint32_t x53; + fiat_25519_scalar_uint1 x54; + uint32_t x55; + fiat_25519_scalar_uint1 x56; + uint32_t x57; + fiat_25519_scalar_uint1 x58; + uint32_t x59; + fiat_25519_scalar_uint1 x60; + uint32_t x61; + fiat_25519_scalar_uint1 x62; + uint32_t x63; + fiat_25519_scalar_uint1 x64; + uint32_t x65; + fiat_25519_scalar_uint1 x66; + uint32_t x67; + fiat_25519_scalar_uint1 x68; + uint32_t x69; + fiat_25519_scalar_uint1 x70; + uint32_t x71; + fiat_25519_scalar_uint1 x72; + uint32_t x73; + fiat_25519_scalar_uint1 x74; + uint32_t x75; + fiat_25519_scalar_uint1 x76; + uint32_t x77; + fiat_25519_scalar_uint1 x78; + uint32_t x79; + fiat_25519_scalar_uint1 x80; + uint32_t x81; + fiat_25519_scalar_uint1 x82; + uint32_t x83; + fiat_25519_scalar_uint1 x84; + uint32_t x85; + uint32_t x86; + uint32_t x87; + uint32_t x88; + uint32_t x89; + uint32_t x90; + uint32_t x91; + uint32_t x92; + uint32_t x93; + fiat_25519_scalar_uint1 x94; + uint32_t x95; + fiat_25519_scalar_uint1 x96; + uint32_t x97; + fiat_25519_scalar_uint1 x98; + uint32_t x99; + fiat_25519_scalar_uint1 x100; + uint32_t x101; + fiat_25519_scalar_uint1 x102; + uint32_t x103; + fiat_25519_scalar_uint1 x104; + uint32_t x105; + fiat_25519_scalar_uint1 x106; + uint32_t x107; + fiat_25519_scalar_uint1 x108; + uint32_t x109; + uint32_t x110; + fiat_25519_scalar_uint1 x111; + uint32_t x112; + fiat_25519_scalar_uint1 x113; + uint32_t x114; + fiat_25519_scalar_uint1 x115; + uint32_t x116; + fiat_25519_scalar_uint1 x117; + uint32_t x118; + fiat_25519_scalar_uint1 x119; + uint32_t x120; + fiat_25519_scalar_uint1 x121; + uint32_t x122; + fiat_25519_scalar_uint1 x123; + uint32_t x124; + fiat_25519_scalar_uint1 x125; + uint32_t x126; + uint32_t x127; + uint32_t x128; + uint32_t x129; + uint32_t x130; + uint32_t x131; + uint32_t x132; + uint32_t x133; + fiat_25519_scalar_uint1 x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + uint32_t x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + fiat_25519_scalar_uint1 x145; + uint32_t x146; + fiat_25519_scalar_uint1 x147; + uint32_t x148; + fiat_25519_scalar_uint1 x149; + uint32_t x150; + fiat_25519_scalar_uint1 x151; + uint32_t x152; + fiat_25519_scalar_uint1 x153; + uint32_t x154; + fiat_25519_scalar_uint1 x155; + uint32_t x156; + fiat_25519_scalar_uint1 x157; + uint32_t x158; + fiat_25519_scalar_uint1 x159; + uint32_t x160; + fiat_25519_scalar_uint1 x161; + uint32_t x162; + uint32_t x163; + uint32_t x164; + uint32_t x165; + uint32_t x166; + uint32_t x167; + uint32_t x168; + uint32_t x169; + uint32_t x170; + fiat_25519_scalar_uint1 x171; + uint32_t x172; + fiat_25519_scalar_uint1 x173; + uint32_t x174; + fiat_25519_scalar_uint1 x175; + uint32_t x176; + fiat_25519_scalar_uint1 x177; + uint32_t x178; + fiat_25519_scalar_uint1 x179; + uint32_t x180; + fiat_25519_scalar_uint1 x181; + uint32_t x182; + fiat_25519_scalar_uint1 x183; + uint32_t x184; + fiat_25519_scalar_uint1 x185; + uint32_t x186; + fiat_25519_scalar_uint1 x187; + uint32_t x188; + fiat_25519_scalar_uint1 x189; + uint32_t x190; + fiat_25519_scalar_uint1 x191; + uint32_t x192; + fiat_25519_scalar_uint1 x193; + uint32_t x194; + fiat_25519_scalar_uint1 x195; + uint32_t x196; + fiat_25519_scalar_uint1 x197; + uint32_t x198; + fiat_25519_scalar_uint1 x199; + uint32_t x200; + fiat_25519_scalar_uint1 x201; + uint32_t x202; + fiat_25519_scalar_uint1 x203; + uint32_t x204; + fiat_25519_scalar_uint1 x205; + uint32_t x206; + uint32_t x207; + uint32_t x208; + uint32_t x209; + uint32_t x210; + uint32_t x211; + uint32_t x212; + uint32_t x213; + uint32_t x214; + uint32_t x215; + uint32_t x216; + uint32_t x217; + uint32_t x218; + uint32_t x219; + uint32_t x220; + uint32_t x221; + uint32_t x222; + uint32_t x223; + uint32_t x224; + uint32_t x225; + uint32_t x226; + uint32_t x227; + uint32_t x228; + uint32_t x229; + uint32_t x230; + fiat_25519_scalar_addcarryx_u32(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_25519_scalar_uint1)((fiat_25519_scalar_uint1)(x1 >> 31) & (fiat_25519_scalar_uint1)((arg3[0]) & 0x1)); + fiat_25519_scalar_addcarryx_u32(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_25519_scalar_cmovznz_u32(&x6, x3, arg1, x4); + fiat_25519_scalar_cmovznz_u32(&x7, x3, (arg2[0]), (arg3[0])); + fiat_25519_scalar_cmovznz_u32(&x8, x3, (arg2[1]), (arg3[1])); + fiat_25519_scalar_cmovznz_u32(&x9, x3, (arg2[2]), (arg3[2])); + fiat_25519_scalar_cmovznz_u32(&x10, x3, (arg2[3]), (arg3[3])); + fiat_25519_scalar_cmovznz_u32(&x11, x3, (arg2[4]), (arg3[4])); + fiat_25519_scalar_cmovznz_u32(&x12, x3, (arg2[5]), (arg3[5])); + fiat_25519_scalar_cmovznz_u32(&x13, x3, (arg2[6]), (arg3[6])); + fiat_25519_scalar_cmovznz_u32(&x14, x3, (arg2[7]), (arg3[7])); + fiat_25519_scalar_cmovznz_u32(&x15, x3, (arg2[8]), (arg3[8])); + fiat_25519_scalar_addcarryx_u32(&x16, &x17, 0x0, 0x1, (~(arg2[0]))); + fiat_25519_scalar_addcarryx_u32(&x18, &x19, x17, 0x0, (~(arg2[1]))); + fiat_25519_scalar_addcarryx_u32(&x20, &x21, x19, 0x0, (~(arg2[2]))); + fiat_25519_scalar_addcarryx_u32(&x22, &x23, x21, 0x0, (~(arg2[3]))); + fiat_25519_scalar_addcarryx_u32(&x24, &x25, x23, 0x0, (~(arg2[4]))); + fiat_25519_scalar_addcarryx_u32(&x26, &x27, x25, 0x0, (~(arg2[5]))); + fiat_25519_scalar_addcarryx_u32(&x28, &x29, x27, 0x0, (~(arg2[6]))); + fiat_25519_scalar_addcarryx_u32(&x30, &x31, x29, 0x0, (~(arg2[7]))); + fiat_25519_scalar_addcarryx_u32(&x32, &x33, x31, 0x0, (~(arg2[8]))); + fiat_25519_scalar_cmovznz_u32(&x34, x3, (arg3[0]), x16); + fiat_25519_scalar_cmovznz_u32(&x35, x3, (arg3[1]), x18); + fiat_25519_scalar_cmovznz_u32(&x36, x3, (arg3[2]), x20); + fiat_25519_scalar_cmovznz_u32(&x37, x3, (arg3[3]), x22); + fiat_25519_scalar_cmovznz_u32(&x38, x3, (arg3[4]), x24); + fiat_25519_scalar_cmovznz_u32(&x39, x3, (arg3[5]), x26); + fiat_25519_scalar_cmovznz_u32(&x40, x3, (arg3[6]), x28); + fiat_25519_scalar_cmovznz_u32(&x41, x3, (arg3[7]), x30); + fiat_25519_scalar_cmovznz_u32(&x42, x3, (arg3[8]), x32); + fiat_25519_scalar_cmovznz_u32(&x43, x3, (arg4[0]), (arg5[0])); + fiat_25519_scalar_cmovznz_u32(&x44, x3, (arg4[1]), (arg5[1])); + fiat_25519_scalar_cmovznz_u32(&x45, x3, (arg4[2]), (arg5[2])); + fiat_25519_scalar_cmovznz_u32(&x46, x3, (arg4[3]), (arg5[3])); + fiat_25519_scalar_cmovznz_u32(&x47, x3, (arg4[4]), (arg5[4])); + fiat_25519_scalar_cmovznz_u32(&x48, x3, (arg4[5]), (arg5[5])); + fiat_25519_scalar_cmovznz_u32(&x49, x3, (arg4[6]), (arg5[6])); + fiat_25519_scalar_cmovznz_u32(&x50, x3, (arg4[7]), (arg5[7])); + fiat_25519_scalar_addcarryx_u32(&x51, &x52, 0x0, x43, x43); + fiat_25519_scalar_addcarryx_u32(&x53, &x54, x52, x44, x44); + fiat_25519_scalar_addcarryx_u32(&x55, &x56, x54, x45, x45); + fiat_25519_scalar_addcarryx_u32(&x57, &x58, x56, x46, x46); + fiat_25519_scalar_addcarryx_u32(&x59, &x60, x58, x47, x47); + fiat_25519_scalar_addcarryx_u32(&x61, &x62, x60, x48, x48); + fiat_25519_scalar_addcarryx_u32(&x63, &x64, x62, x49, x49); + fiat_25519_scalar_addcarryx_u32(&x65, &x66, x64, x50, x50); + fiat_25519_scalar_subborrowx_u32(&x67, &x68, 0x0, x51, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_subborrowx_u32(&x69, &x70, x68, x53, UINT32_C(0x5812631a)); + fiat_25519_scalar_subborrowx_u32(&x71, &x72, x70, x55, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_subborrowx_u32(&x73, &x74, x72, x57, UINT32_C(0x14def9de)); + fiat_25519_scalar_subborrowx_u32(&x75, &x76, x74, x59, 0x0); + fiat_25519_scalar_subborrowx_u32(&x77, &x78, x76, x61, 0x0); + fiat_25519_scalar_subborrowx_u32(&x79, &x80, x78, x63, 0x0); + fiat_25519_scalar_subborrowx_u32(&x81, &x82, x80, x65, UINT32_C(0x10000000)); + fiat_25519_scalar_subborrowx_u32(&x83, &x84, x82, x66, 0x0); + x85 = (arg4[7]); + x86 = (arg4[6]); + x87 = (arg4[5]); + x88 = (arg4[4]); + x89 = (arg4[3]); + x90 = (arg4[2]); + x91 = (arg4[1]); + x92 = (arg4[0]); + fiat_25519_scalar_subborrowx_u32(&x93, &x94, 0x0, 0x0, x92); + fiat_25519_scalar_subborrowx_u32(&x95, &x96, x94, 0x0, x91); + fiat_25519_scalar_subborrowx_u32(&x97, &x98, x96, 0x0, x90); + fiat_25519_scalar_subborrowx_u32(&x99, &x100, x98, 0x0, x89); + fiat_25519_scalar_subborrowx_u32(&x101, &x102, x100, 0x0, x88); + fiat_25519_scalar_subborrowx_u32(&x103, &x104, x102, 0x0, x87); + fiat_25519_scalar_subborrowx_u32(&x105, &x106, x104, 0x0, x86); + fiat_25519_scalar_subborrowx_u32(&x107, &x108, x106, 0x0, x85); + fiat_25519_scalar_cmovznz_u32(&x109, x108, 0x0, UINT32_C(0xffffffff)); + fiat_25519_scalar_addcarryx_u32(&x110, &x111, 0x0, x93, (x109 & UINT32_C(0x5cf5d3ed))); + fiat_25519_scalar_addcarryx_u32(&x112, &x113, x111, x95, (x109 & UINT32_C(0x5812631a))); + fiat_25519_scalar_addcarryx_u32(&x114, &x115, x113, x97, (x109 & UINT32_C(0xa2f79cd6))); + fiat_25519_scalar_addcarryx_u32(&x116, &x117, x115, x99, (x109 & UINT32_C(0x14def9de))); + fiat_25519_scalar_addcarryx_u32(&x118, &x119, x117, x101, 0x0); + fiat_25519_scalar_addcarryx_u32(&x120, &x121, x119, x103, 0x0); + fiat_25519_scalar_addcarryx_u32(&x122, &x123, x121, x105, 0x0); + fiat_25519_scalar_addcarryx_u32(&x124, &x125, x123, x107, (x109 & UINT32_C(0x10000000))); + fiat_25519_scalar_cmovznz_u32(&x126, x3, (arg5[0]), x110); + fiat_25519_scalar_cmovznz_u32(&x127, x3, (arg5[1]), x112); + fiat_25519_scalar_cmovznz_u32(&x128, x3, (arg5[2]), x114); + fiat_25519_scalar_cmovznz_u32(&x129, x3, (arg5[3]), x116); + fiat_25519_scalar_cmovznz_u32(&x130, x3, (arg5[4]), x118); + fiat_25519_scalar_cmovznz_u32(&x131, x3, (arg5[5]), x120); + fiat_25519_scalar_cmovznz_u32(&x132, x3, (arg5[6]), x122); + fiat_25519_scalar_cmovznz_u32(&x133, x3, (arg5[7]), x124); + x134 = (fiat_25519_scalar_uint1)(x34 & 0x1); + fiat_25519_scalar_cmovznz_u32(&x135, x134, 0x0, x7); + fiat_25519_scalar_cmovznz_u32(&x136, x134, 0x0, x8); + fiat_25519_scalar_cmovznz_u32(&x137, x134, 0x0, x9); + fiat_25519_scalar_cmovznz_u32(&x138, x134, 0x0, x10); + fiat_25519_scalar_cmovznz_u32(&x139, x134, 0x0, x11); + fiat_25519_scalar_cmovznz_u32(&x140, x134, 0x0, x12); + fiat_25519_scalar_cmovznz_u32(&x141, x134, 0x0, x13); + fiat_25519_scalar_cmovznz_u32(&x142, x134, 0x0, x14); + fiat_25519_scalar_cmovznz_u32(&x143, x134, 0x0, x15); + fiat_25519_scalar_addcarryx_u32(&x144, &x145, 0x0, x34, x135); + fiat_25519_scalar_addcarryx_u32(&x146, &x147, x145, x35, x136); + fiat_25519_scalar_addcarryx_u32(&x148, &x149, x147, x36, x137); + fiat_25519_scalar_addcarryx_u32(&x150, &x151, x149, x37, x138); + fiat_25519_scalar_addcarryx_u32(&x152, &x153, x151, x38, x139); + fiat_25519_scalar_addcarryx_u32(&x154, &x155, x153, x39, x140); + fiat_25519_scalar_addcarryx_u32(&x156, &x157, x155, x40, x141); + fiat_25519_scalar_addcarryx_u32(&x158, &x159, x157, x41, x142); + fiat_25519_scalar_addcarryx_u32(&x160, &x161, x159, x42, x143); + fiat_25519_scalar_cmovznz_u32(&x162, x134, 0x0, x43); + fiat_25519_scalar_cmovznz_u32(&x163, x134, 0x0, x44); + fiat_25519_scalar_cmovznz_u32(&x164, x134, 0x0, x45); + fiat_25519_scalar_cmovznz_u32(&x165, x134, 0x0, x46); + fiat_25519_scalar_cmovznz_u32(&x166, x134, 0x0, x47); + fiat_25519_scalar_cmovznz_u32(&x167, x134, 0x0, x48); + fiat_25519_scalar_cmovznz_u32(&x168, x134, 0x0, x49); + fiat_25519_scalar_cmovznz_u32(&x169, x134, 0x0, x50); + fiat_25519_scalar_addcarryx_u32(&x170, &x171, 0x0, x126, x162); + fiat_25519_scalar_addcarryx_u32(&x172, &x173, x171, x127, x163); + fiat_25519_scalar_addcarryx_u32(&x174, &x175, x173, x128, x164); + fiat_25519_scalar_addcarryx_u32(&x176, &x177, x175, x129, x165); + fiat_25519_scalar_addcarryx_u32(&x178, &x179, x177, x130, x166); + fiat_25519_scalar_addcarryx_u32(&x180, &x181, x179, x131, x167); + fiat_25519_scalar_addcarryx_u32(&x182, &x183, x181, x132, x168); + fiat_25519_scalar_addcarryx_u32(&x184, &x185, x183, x133, x169); + fiat_25519_scalar_subborrowx_u32(&x186, &x187, 0x0, x170, UINT32_C(0x5cf5d3ed)); + fiat_25519_scalar_subborrowx_u32(&x188, &x189, x187, x172, UINT32_C(0x5812631a)); + fiat_25519_scalar_subborrowx_u32(&x190, &x191, x189, x174, UINT32_C(0xa2f79cd6)); + fiat_25519_scalar_subborrowx_u32(&x192, &x193, x191, x176, UINT32_C(0x14def9de)); + fiat_25519_scalar_subborrowx_u32(&x194, &x195, x193, x178, 0x0); + fiat_25519_scalar_subborrowx_u32(&x196, &x197, x195, x180, 0x0); + fiat_25519_scalar_subborrowx_u32(&x198, &x199, x197, x182, 0x0); + fiat_25519_scalar_subborrowx_u32(&x200, &x201, x199, x184, UINT32_C(0x10000000)); + fiat_25519_scalar_subborrowx_u32(&x202, &x203, x201, x185, 0x0); + fiat_25519_scalar_addcarryx_u32(&x204, &x205, 0x0, x6, 0x1); + x206 = ((x144 >> 1) | ((x146 << 31) & UINT32_C(0xffffffff))); + x207 = ((x146 >> 1) | ((x148 << 31) & UINT32_C(0xffffffff))); + x208 = ((x148 >> 1) | ((x150 << 31) & UINT32_C(0xffffffff))); + x209 = ((x150 >> 1) | ((x152 << 31) & UINT32_C(0xffffffff))); + x210 = ((x152 >> 1) | ((x154 << 31) & UINT32_C(0xffffffff))); + x211 = ((x154 >> 1) | ((x156 << 31) & UINT32_C(0xffffffff))); + x212 = ((x156 >> 1) | ((x158 << 31) & UINT32_C(0xffffffff))); + x213 = ((x158 >> 1) | ((x160 << 31) & UINT32_C(0xffffffff))); + x214 = ((x160 & UINT32_C(0x80000000)) | (x160 >> 1)); + fiat_25519_scalar_cmovznz_u32(&x215, x84, x67, x51); + fiat_25519_scalar_cmovznz_u32(&x216, x84, x69, x53); + fiat_25519_scalar_cmovznz_u32(&x217, x84, x71, x55); + fiat_25519_scalar_cmovznz_u32(&x218, x84, x73, x57); + fiat_25519_scalar_cmovznz_u32(&x219, x84, x75, x59); + fiat_25519_scalar_cmovznz_u32(&x220, x84, x77, x61); + fiat_25519_scalar_cmovznz_u32(&x221, x84, x79, x63); + fiat_25519_scalar_cmovznz_u32(&x222, x84, x81, x65); + fiat_25519_scalar_cmovznz_u32(&x223, x203, x186, x170); + fiat_25519_scalar_cmovznz_u32(&x224, x203, x188, x172); + fiat_25519_scalar_cmovznz_u32(&x225, x203, x190, x174); + fiat_25519_scalar_cmovznz_u32(&x226, x203, x192, x176); + fiat_25519_scalar_cmovznz_u32(&x227, x203, x194, x178); + fiat_25519_scalar_cmovznz_u32(&x228, x203, x196, x180); + fiat_25519_scalar_cmovznz_u32(&x229, x203, x198, x182); + fiat_25519_scalar_cmovznz_u32(&x230, x203, x200, x184); + *out1 = x204; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out2[7] = x14; + out2[8] = x15; + out3[0] = x206; + out3[1] = x207; + out3[2] = x208; + out3[3] = x209; + out3[4] = x210; + out3[5] = x211; + out3[6] = x212; + out3[7] = x213; + out3[8] = x214; + out4[0] = x215; + out4[1] = x216; + out4[2] = x217; + out4[3] = x218; + out4[4] = x219; + out4[5] = x220; + out4[6] = x221; + out4[7] = x222; + out5[0] = x223; + out5[1] = x224; + out5[2] = x225; + out5[3] = x226; + out5[4] = x227; + out5[5] = x228; + out5[6] = x229; + out5[7] = x230; +} + +/* + * The function fiat_25519_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). + * + * Postconditions: + * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_divstep_precomp(uint32_t out1[8]) { + out1[0] = UINT32_C(0x36a7cb92); + out1[1] = UINT32_C(0xd70af844); + out1[2] = UINT32_C(0xb0b8b159); + out1[3] = UINT32_C(0x5f71c978); + out1[4] = UINT32_C(0x74947f1a); + out1[5] = UINT32_C(0xe76d8169); + out1[6] = UINT32_C(0xf193e4ff); + out1[7] = UINT32_C(0x19a2d36); +} diff --git a/fiat-c/src/curve25519_scalar_64.c b/fiat-c/src/curve25519_scalar_64.c new file mode 100644 index 0000000000..c710b84621 --- /dev/null +++ b/fiat-c/src/curve25519_scalar_64.c @@ -0,0 +1,2049 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier 25519_scalar 64 '2^252 + 27742317777372353535851937790883648493' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: 25519_scalar */ +/* machine_wordsize = 64 (from "64") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed (from "2^252 + 27742317777372353535851937790883648493") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +typedef unsigned char fiat_25519_scalar_uint1; +typedef signed char fiat_25519_scalar_int1; +#if defined(__GNUC__) || defined(__clang__) +# define FIAT_25519_SCALAR_FIAT_EXTENSION __extension__ +# define FIAT_25519_SCALAR_FIAT_INLINE __inline__ +#else +# define FIAT_25519_SCALAR_FIAT_EXTENSION +# define FIAT_25519_SCALAR_FIAT_INLINE +#endif + +FIAT_25519_SCALAR_FIAT_EXTENSION typedef signed __int128 fiat_25519_scalar_int128; +FIAT_25519_SCALAR_FIAT_EXTENSION typedef unsigned __int128 fiat_25519_scalar_uint128; + +/* The type fiat_25519_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +typedef uint64_t fiat_25519_scalar_montgomery_domain_field_element[4]; + +/* The type fiat_25519_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +typedef uint64_t fiat_25519_scalar_non_montgomery_domain_field_element[4]; + +#if (-1 & 3) != 3 +#error "This code only works on a two's complement system" +#endif + +#if !defined(FIAT_25519_SCALAR_NO_ASM) && (defined(__GNUC__) || defined(__clang__)) +static __inline__ uint64_t fiat_25519_scalar_value_barrier_u64(uint64_t a) { + __asm__("" : "+r"(a) : /* no inputs */); + return a; +} +#else +# define fiat_25519_scalar_value_barrier_u64(x) (x) +#endif + + +/* + * The function fiat_25519_scalar_addcarryx_u64 is an addition with carry. + * + * Postconditions: + * out1 = (arg1 + arg2 + arg3) mod 2^64 + * out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_addcarryx_u64(uint64_t* out1, fiat_25519_scalar_uint1* out2, fiat_25519_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_25519_scalar_uint128 x1; + uint64_t x2; + fiat_25519_scalar_uint1 x3; + x1 = ((arg1 + (fiat_25519_scalar_uint128)arg2) + arg3); + x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + x3 = (fiat_25519_scalar_uint1)(x1 >> 64); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_25519_scalar_subborrowx_u64 is a subtraction with borrow. + * + * Postconditions: + * out1 = (-arg1 + arg2 + -arg3) mod 2^64 + * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_subborrowx_u64(uint64_t* out1, fiat_25519_scalar_uint1* out2, fiat_25519_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_25519_scalar_int128 x1; + fiat_25519_scalar_int1 x2; + uint64_t x3; + x1 = ((arg2 - (fiat_25519_scalar_int128)arg1) - arg3); + x2 = (fiat_25519_scalar_int1)(x1 >> 64); + x3 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + *out1 = x3; + *out2 = (fiat_25519_scalar_uint1)(0x0 - x2); +} + +/* + * The function fiat_25519_scalar_mulx_u64 is a multiplication, returning the full double-width result. + * + * Postconditions: + * out1 = (arg1 * arg2) mod 2^64 + * out2 = ⌊arg1 * arg2 / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffffffffffff] + * arg2: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_mulx_u64(uint64_t* out1, uint64_t* out2, uint64_t arg1, uint64_t arg2) { + fiat_25519_scalar_uint128 x1; + uint64_t x2; + uint64_t x3; + x1 = ((fiat_25519_scalar_uint128)arg1 * arg2); + x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + x3 = (uint64_t)(x1 >> 64); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_25519_scalar_cmovznz_u64 is a single-word conditional move. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_cmovznz_u64(uint64_t* out1, fiat_25519_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_25519_scalar_uint1 x1; + uint64_t x2; + uint64_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_25519_scalar_int1)(0x0 - x1) & UINT64_C(0xffffffffffffffff)); + x3 = ((fiat_25519_scalar_value_barrier_u64(x2) & arg3) | (fiat_25519_scalar_value_barrier_u64((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_25519_scalar_mul multiplies two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_mul(fiat_25519_scalar_montgomery_domain_field_element out1, const fiat_25519_scalar_montgomery_domain_field_element arg1, const fiat_25519_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_25519_scalar_uint1 x14; + uint64_t x15; + fiat_25519_scalar_uint1 x16; + uint64_t x17; + fiat_25519_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + fiat_25519_scalar_uint1 x29; + uint64_t x30; + uint64_t x31; + fiat_25519_scalar_uint1 x32; + uint64_t x33; + fiat_25519_scalar_uint1 x34; + uint64_t x35; + fiat_25519_scalar_uint1 x36; + uint64_t x37; + fiat_25519_scalar_uint1 x38; + uint64_t x39; + fiat_25519_scalar_uint1 x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + fiat_25519_scalar_uint1 x50; + uint64_t x51; + fiat_25519_scalar_uint1 x52; + uint64_t x53; + fiat_25519_scalar_uint1 x54; + uint64_t x55; + uint64_t x56; + fiat_25519_scalar_uint1 x57; + uint64_t x58; + fiat_25519_scalar_uint1 x59; + uint64_t x60; + fiat_25519_scalar_uint1 x61; + uint64_t x62; + fiat_25519_scalar_uint1 x63; + uint64_t x64; + fiat_25519_scalar_uint1 x65; + uint64_t x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + fiat_25519_scalar_uint1 x75; + uint64_t x76; + uint64_t x77; + fiat_25519_scalar_uint1 x78; + uint64_t x79; + fiat_25519_scalar_uint1 x80; + uint64_t x81; + fiat_25519_scalar_uint1 x82; + uint64_t x83; + fiat_25519_scalar_uint1 x84; + uint64_t x85; + fiat_25519_scalar_uint1 x86; + uint64_t x87; + uint64_t x88; + uint64_t x89; + uint64_t x90; + uint64_t x91; + uint64_t x92; + uint64_t x93; + uint64_t x94; + uint64_t x95; + uint64_t x96; + fiat_25519_scalar_uint1 x97; + uint64_t x98; + fiat_25519_scalar_uint1 x99; + uint64_t x100; + fiat_25519_scalar_uint1 x101; + uint64_t x102; + uint64_t x103; + fiat_25519_scalar_uint1 x104; + uint64_t x105; + fiat_25519_scalar_uint1 x106; + uint64_t x107; + fiat_25519_scalar_uint1 x108; + uint64_t x109; + fiat_25519_scalar_uint1 x110; + uint64_t x111; + fiat_25519_scalar_uint1 x112; + uint64_t x113; + uint64_t x114; + uint64_t x115; + uint64_t x116; + uint64_t x117; + uint64_t x118; + uint64_t x119; + uint64_t x120; + uint64_t x121; + fiat_25519_scalar_uint1 x122; + uint64_t x123; + uint64_t x124; + fiat_25519_scalar_uint1 x125; + uint64_t x126; + fiat_25519_scalar_uint1 x127; + uint64_t x128; + fiat_25519_scalar_uint1 x129; + uint64_t x130; + fiat_25519_scalar_uint1 x131; + uint64_t x132; + fiat_25519_scalar_uint1 x133; + uint64_t x134; + uint64_t x135; + uint64_t x136; + uint64_t x137; + uint64_t x138; + uint64_t x139; + uint64_t x140; + uint64_t x141; + uint64_t x142; + uint64_t x143; + fiat_25519_scalar_uint1 x144; + uint64_t x145; + fiat_25519_scalar_uint1 x146; + uint64_t x147; + fiat_25519_scalar_uint1 x148; + uint64_t x149; + uint64_t x150; + fiat_25519_scalar_uint1 x151; + uint64_t x152; + fiat_25519_scalar_uint1 x153; + uint64_t x154; + fiat_25519_scalar_uint1 x155; + uint64_t x156; + fiat_25519_scalar_uint1 x157; + uint64_t x158; + fiat_25519_scalar_uint1 x159; + uint64_t x160; + uint64_t x161; + uint64_t x162; + uint64_t x163; + uint64_t x164; + uint64_t x165; + uint64_t x166; + uint64_t x167; + uint64_t x168; + fiat_25519_scalar_uint1 x169; + uint64_t x170; + uint64_t x171; + fiat_25519_scalar_uint1 x172; + uint64_t x173; + fiat_25519_scalar_uint1 x174; + uint64_t x175; + fiat_25519_scalar_uint1 x176; + uint64_t x177; + fiat_25519_scalar_uint1 x178; + uint64_t x179; + fiat_25519_scalar_uint1 x180; + uint64_t x181; + uint64_t x182; + fiat_25519_scalar_uint1 x183; + uint64_t x184; + fiat_25519_scalar_uint1 x185; + uint64_t x186; + fiat_25519_scalar_uint1 x187; + uint64_t x188; + fiat_25519_scalar_uint1 x189; + uint64_t x190; + fiat_25519_scalar_uint1 x191; + uint64_t x192; + uint64_t x193; + uint64_t x194; + uint64_t x195; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_25519_scalar_mulx_u64(&x5, &x6, x4, (arg2[3])); + fiat_25519_scalar_mulx_u64(&x7, &x8, x4, (arg2[2])); + fiat_25519_scalar_mulx_u64(&x9, &x10, x4, (arg2[1])); + fiat_25519_scalar_mulx_u64(&x11, &x12, x4, (arg2[0])); + fiat_25519_scalar_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_25519_scalar_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_25519_scalar_addcarryx_u64(&x17, &x18, x16, x8, x5); + x19 = (x18 + x6); + fiat_25519_scalar_mulx_u64(&x20, &x21, x11, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x22, &x23, x20, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x24, &x25, x20, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x26, &x27, x20, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x28, &x29, 0x0, x27, x24); + x30 = (x29 + x25); + fiat_25519_scalar_addcarryx_u64(&x31, &x32, 0x0, x11, x26); + fiat_25519_scalar_addcarryx_u64(&x33, &x34, x32, x13, x28); + fiat_25519_scalar_addcarryx_u64(&x35, &x36, x34, x15, x30); + fiat_25519_scalar_addcarryx_u64(&x37, &x38, x36, x17, x22); + fiat_25519_scalar_addcarryx_u64(&x39, &x40, x38, x19, x23); + fiat_25519_scalar_mulx_u64(&x41, &x42, x1, (arg2[3])); + fiat_25519_scalar_mulx_u64(&x43, &x44, x1, (arg2[2])); + fiat_25519_scalar_mulx_u64(&x45, &x46, x1, (arg2[1])); + fiat_25519_scalar_mulx_u64(&x47, &x48, x1, (arg2[0])); + fiat_25519_scalar_addcarryx_u64(&x49, &x50, 0x0, x48, x45); + fiat_25519_scalar_addcarryx_u64(&x51, &x52, x50, x46, x43); + fiat_25519_scalar_addcarryx_u64(&x53, &x54, x52, x44, x41); + x55 = (x54 + x42); + fiat_25519_scalar_addcarryx_u64(&x56, &x57, 0x0, x33, x47); + fiat_25519_scalar_addcarryx_u64(&x58, &x59, x57, x35, x49); + fiat_25519_scalar_addcarryx_u64(&x60, &x61, x59, x37, x51); + fiat_25519_scalar_addcarryx_u64(&x62, &x63, x61, x39, x53); + fiat_25519_scalar_addcarryx_u64(&x64, &x65, x63, x40, x55); + fiat_25519_scalar_mulx_u64(&x66, &x67, x56, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x68, &x69, x66, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x70, &x71, x66, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x72, &x73, x66, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x74, &x75, 0x0, x73, x70); + x76 = (x75 + x71); + fiat_25519_scalar_addcarryx_u64(&x77, &x78, 0x0, x56, x72); + fiat_25519_scalar_addcarryx_u64(&x79, &x80, x78, x58, x74); + fiat_25519_scalar_addcarryx_u64(&x81, &x82, x80, x60, x76); + fiat_25519_scalar_addcarryx_u64(&x83, &x84, x82, x62, x68); + fiat_25519_scalar_addcarryx_u64(&x85, &x86, x84, x64, x69); + x87 = ((uint64_t)x86 + x65); + fiat_25519_scalar_mulx_u64(&x88, &x89, x2, (arg2[3])); + fiat_25519_scalar_mulx_u64(&x90, &x91, x2, (arg2[2])); + fiat_25519_scalar_mulx_u64(&x92, &x93, x2, (arg2[1])); + fiat_25519_scalar_mulx_u64(&x94, &x95, x2, (arg2[0])); + fiat_25519_scalar_addcarryx_u64(&x96, &x97, 0x0, x95, x92); + fiat_25519_scalar_addcarryx_u64(&x98, &x99, x97, x93, x90); + fiat_25519_scalar_addcarryx_u64(&x100, &x101, x99, x91, x88); + x102 = (x101 + x89); + fiat_25519_scalar_addcarryx_u64(&x103, &x104, 0x0, x79, x94); + fiat_25519_scalar_addcarryx_u64(&x105, &x106, x104, x81, x96); + fiat_25519_scalar_addcarryx_u64(&x107, &x108, x106, x83, x98); + fiat_25519_scalar_addcarryx_u64(&x109, &x110, x108, x85, x100); + fiat_25519_scalar_addcarryx_u64(&x111, &x112, x110, x87, x102); + fiat_25519_scalar_mulx_u64(&x113, &x114, x103, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x115, &x116, x113, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x117, &x118, x113, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x119, &x120, x113, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x121, &x122, 0x0, x120, x117); + x123 = (x122 + x118); + fiat_25519_scalar_addcarryx_u64(&x124, &x125, 0x0, x103, x119); + fiat_25519_scalar_addcarryx_u64(&x126, &x127, x125, x105, x121); + fiat_25519_scalar_addcarryx_u64(&x128, &x129, x127, x107, x123); + fiat_25519_scalar_addcarryx_u64(&x130, &x131, x129, x109, x115); + fiat_25519_scalar_addcarryx_u64(&x132, &x133, x131, x111, x116); + x134 = ((uint64_t)x133 + x112); + fiat_25519_scalar_mulx_u64(&x135, &x136, x3, (arg2[3])); + fiat_25519_scalar_mulx_u64(&x137, &x138, x3, (arg2[2])); + fiat_25519_scalar_mulx_u64(&x139, &x140, x3, (arg2[1])); + fiat_25519_scalar_mulx_u64(&x141, &x142, x3, (arg2[0])); + fiat_25519_scalar_addcarryx_u64(&x143, &x144, 0x0, x142, x139); + fiat_25519_scalar_addcarryx_u64(&x145, &x146, x144, x140, x137); + fiat_25519_scalar_addcarryx_u64(&x147, &x148, x146, x138, x135); + x149 = (x148 + x136); + fiat_25519_scalar_addcarryx_u64(&x150, &x151, 0x0, x126, x141); + fiat_25519_scalar_addcarryx_u64(&x152, &x153, x151, x128, x143); + fiat_25519_scalar_addcarryx_u64(&x154, &x155, x153, x130, x145); + fiat_25519_scalar_addcarryx_u64(&x156, &x157, x155, x132, x147); + fiat_25519_scalar_addcarryx_u64(&x158, &x159, x157, x134, x149); + fiat_25519_scalar_mulx_u64(&x160, &x161, x150, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x162, &x163, x160, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x164, &x165, x160, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x166, &x167, x160, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x168, &x169, 0x0, x167, x164); + x170 = (x169 + x165); + fiat_25519_scalar_addcarryx_u64(&x171, &x172, 0x0, x150, x166); + fiat_25519_scalar_addcarryx_u64(&x173, &x174, x172, x152, x168); + fiat_25519_scalar_addcarryx_u64(&x175, &x176, x174, x154, x170); + fiat_25519_scalar_addcarryx_u64(&x177, &x178, x176, x156, x162); + fiat_25519_scalar_addcarryx_u64(&x179, &x180, x178, x158, x163); + x181 = ((uint64_t)x180 + x159); + fiat_25519_scalar_subborrowx_u64(&x182, &x183, 0x0, x173, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_subborrowx_u64(&x184, &x185, x183, x175, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_subborrowx_u64(&x186, &x187, x185, x177, 0x0); + fiat_25519_scalar_subborrowx_u64(&x188, &x189, x187, x179, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_subborrowx_u64(&x190, &x191, x189, x181, 0x0); + fiat_25519_scalar_cmovznz_u64(&x192, x191, x182, x173); + fiat_25519_scalar_cmovznz_u64(&x193, x191, x184, x175); + fiat_25519_scalar_cmovznz_u64(&x194, x191, x186, x177); + fiat_25519_scalar_cmovznz_u64(&x195, x191, x188, x179); + out1[0] = x192; + out1[1] = x193; + out1[2] = x194; + out1[3] = x195; +} + +/* + * The function fiat_25519_scalar_square squares a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_square(fiat_25519_scalar_montgomery_domain_field_element out1, const fiat_25519_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_25519_scalar_uint1 x14; + uint64_t x15; + fiat_25519_scalar_uint1 x16; + uint64_t x17; + fiat_25519_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + fiat_25519_scalar_uint1 x29; + uint64_t x30; + uint64_t x31; + fiat_25519_scalar_uint1 x32; + uint64_t x33; + fiat_25519_scalar_uint1 x34; + uint64_t x35; + fiat_25519_scalar_uint1 x36; + uint64_t x37; + fiat_25519_scalar_uint1 x38; + uint64_t x39; + fiat_25519_scalar_uint1 x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + fiat_25519_scalar_uint1 x50; + uint64_t x51; + fiat_25519_scalar_uint1 x52; + uint64_t x53; + fiat_25519_scalar_uint1 x54; + uint64_t x55; + uint64_t x56; + fiat_25519_scalar_uint1 x57; + uint64_t x58; + fiat_25519_scalar_uint1 x59; + uint64_t x60; + fiat_25519_scalar_uint1 x61; + uint64_t x62; + fiat_25519_scalar_uint1 x63; + uint64_t x64; + fiat_25519_scalar_uint1 x65; + uint64_t x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + fiat_25519_scalar_uint1 x75; + uint64_t x76; + uint64_t x77; + fiat_25519_scalar_uint1 x78; + uint64_t x79; + fiat_25519_scalar_uint1 x80; + uint64_t x81; + fiat_25519_scalar_uint1 x82; + uint64_t x83; + fiat_25519_scalar_uint1 x84; + uint64_t x85; + fiat_25519_scalar_uint1 x86; + uint64_t x87; + uint64_t x88; + uint64_t x89; + uint64_t x90; + uint64_t x91; + uint64_t x92; + uint64_t x93; + uint64_t x94; + uint64_t x95; + uint64_t x96; + fiat_25519_scalar_uint1 x97; + uint64_t x98; + fiat_25519_scalar_uint1 x99; + uint64_t x100; + fiat_25519_scalar_uint1 x101; + uint64_t x102; + uint64_t x103; + fiat_25519_scalar_uint1 x104; + uint64_t x105; + fiat_25519_scalar_uint1 x106; + uint64_t x107; + fiat_25519_scalar_uint1 x108; + uint64_t x109; + fiat_25519_scalar_uint1 x110; + uint64_t x111; + fiat_25519_scalar_uint1 x112; + uint64_t x113; + uint64_t x114; + uint64_t x115; + uint64_t x116; + uint64_t x117; + uint64_t x118; + uint64_t x119; + uint64_t x120; + uint64_t x121; + fiat_25519_scalar_uint1 x122; + uint64_t x123; + uint64_t x124; + fiat_25519_scalar_uint1 x125; + uint64_t x126; + fiat_25519_scalar_uint1 x127; + uint64_t x128; + fiat_25519_scalar_uint1 x129; + uint64_t x130; + fiat_25519_scalar_uint1 x131; + uint64_t x132; + fiat_25519_scalar_uint1 x133; + uint64_t x134; + uint64_t x135; + uint64_t x136; + uint64_t x137; + uint64_t x138; + uint64_t x139; + uint64_t x140; + uint64_t x141; + uint64_t x142; + uint64_t x143; + fiat_25519_scalar_uint1 x144; + uint64_t x145; + fiat_25519_scalar_uint1 x146; + uint64_t x147; + fiat_25519_scalar_uint1 x148; + uint64_t x149; + uint64_t x150; + fiat_25519_scalar_uint1 x151; + uint64_t x152; + fiat_25519_scalar_uint1 x153; + uint64_t x154; + fiat_25519_scalar_uint1 x155; + uint64_t x156; + fiat_25519_scalar_uint1 x157; + uint64_t x158; + fiat_25519_scalar_uint1 x159; + uint64_t x160; + uint64_t x161; + uint64_t x162; + uint64_t x163; + uint64_t x164; + uint64_t x165; + uint64_t x166; + uint64_t x167; + uint64_t x168; + fiat_25519_scalar_uint1 x169; + uint64_t x170; + uint64_t x171; + fiat_25519_scalar_uint1 x172; + uint64_t x173; + fiat_25519_scalar_uint1 x174; + uint64_t x175; + fiat_25519_scalar_uint1 x176; + uint64_t x177; + fiat_25519_scalar_uint1 x178; + uint64_t x179; + fiat_25519_scalar_uint1 x180; + uint64_t x181; + uint64_t x182; + fiat_25519_scalar_uint1 x183; + uint64_t x184; + fiat_25519_scalar_uint1 x185; + uint64_t x186; + fiat_25519_scalar_uint1 x187; + uint64_t x188; + fiat_25519_scalar_uint1 x189; + uint64_t x190; + fiat_25519_scalar_uint1 x191; + uint64_t x192; + uint64_t x193; + uint64_t x194; + uint64_t x195; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_25519_scalar_mulx_u64(&x5, &x6, x4, (arg1[3])); + fiat_25519_scalar_mulx_u64(&x7, &x8, x4, (arg1[2])); + fiat_25519_scalar_mulx_u64(&x9, &x10, x4, (arg1[1])); + fiat_25519_scalar_mulx_u64(&x11, &x12, x4, (arg1[0])); + fiat_25519_scalar_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_25519_scalar_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_25519_scalar_addcarryx_u64(&x17, &x18, x16, x8, x5); + x19 = (x18 + x6); + fiat_25519_scalar_mulx_u64(&x20, &x21, x11, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x22, &x23, x20, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x24, &x25, x20, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x26, &x27, x20, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x28, &x29, 0x0, x27, x24); + x30 = (x29 + x25); + fiat_25519_scalar_addcarryx_u64(&x31, &x32, 0x0, x11, x26); + fiat_25519_scalar_addcarryx_u64(&x33, &x34, x32, x13, x28); + fiat_25519_scalar_addcarryx_u64(&x35, &x36, x34, x15, x30); + fiat_25519_scalar_addcarryx_u64(&x37, &x38, x36, x17, x22); + fiat_25519_scalar_addcarryx_u64(&x39, &x40, x38, x19, x23); + fiat_25519_scalar_mulx_u64(&x41, &x42, x1, (arg1[3])); + fiat_25519_scalar_mulx_u64(&x43, &x44, x1, (arg1[2])); + fiat_25519_scalar_mulx_u64(&x45, &x46, x1, (arg1[1])); + fiat_25519_scalar_mulx_u64(&x47, &x48, x1, (arg1[0])); + fiat_25519_scalar_addcarryx_u64(&x49, &x50, 0x0, x48, x45); + fiat_25519_scalar_addcarryx_u64(&x51, &x52, x50, x46, x43); + fiat_25519_scalar_addcarryx_u64(&x53, &x54, x52, x44, x41); + x55 = (x54 + x42); + fiat_25519_scalar_addcarryx_u64(&x56, &x57, 0x0, x33, x47); + fiat_25519_scalar_addcarryx_u64(&x58, &x59, x57, x35, x49); + fiat_25519_scalar_addcarryx_u64(&x60, &x61, x59, x37, x51); + fiat_25519_scalar_addcarryx_u64(&x62, &x63, x61, x39, x53); + fiat_25519_scalar_addcarryx_u64(&x64, &x65, x63, x40, x55); + fiat_25519_scalar_mulx_u64(&x66, &x67, x56, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x68, &x69, x66, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x70, &x71, x66, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x72, &x73, x66, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x74, &x75, 0x0, x73, x70); + x76 = (x75 + x71); + fiat_25519_scalar_addcarryx_u64(&x77, &x78, 0x0, x56, x72); + fiat_25519_scalar_addcarryx_u64(&x79, &x80, x78, x58, x74); + fiat_25519_scalar_addcarryx_u64(&x81, &x82, x80, x60, x76); + fiat_25519_scalar_addcarryx_u64(&x83, &x84, x82, x62, x68); + fiat_25519_scalar_addcarryx_u64(&x85, &x86, x84, x64, x69); + x87 = ((uint64_t)x86 + x65); + fiat_25519_scalar_mulx_u64(&x88, &x89, x2, (arg1[3])); + fiat_25519_scalar_mulx_u64(&x90, &x91, x2, (arg1[2])); + fiat_25519_scalar_mulx_u64(&x92, &x93, x2, (arg1[1])); + fiat_25519_scalar_mulx_u64(&x94, &x95, x2, (arg1[0])); + fiat_25519_scalar_addcarryx_u64(&x96, &x97, 0x0, x95, x92); + fiat_25519_scalar_addcarryx_u64(&x98, &x99, x97, x93, x90); + fiat_25519_scalar_addcarryx_u64(&x100, &x101, x99, x91, x88); + x102 = (x101 + x89); + fiat_25519_scalar_addcarryx_u64(&x103, &x104, 0x0, x79, x94); + fiat_25519_scalar_addcarryx_u64(&x105, &x106, x104, x81, x96); + fiat_25519_scalar_addcarryx_u64(&x107, &x108, x106, x83, x98); + fiat_25519_scalar_addcarryx_u64(&x109, &x110, x108, x85, x100); + fiat_25519_scalar_addcarryx_u64(&x111, &x112, x110, x87, x102); + fiat_25519_scalar_mulx_u64(&x113, &x114, x103, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x115, &x116, x113, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x117, &x118, x113, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x119, &x120, x113, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x121, &x122, 0x0, x120, x117); + x123 = (x122 + x118); + fiat_25519_scalar_addcarryx_u64(&x124, &x125, 0x0, x103, x119); + fiat_25519_scalar_addcarryx_u64(&x126, &x127, x125, x105, x121); + fiat_25519_scalar_addcarryx_u64(&x128, &x129, x127, x107, x123); + fiat_25519_scalar_addcarryx_u64(&x130, &x131, x129, x109, x115); + fiat_25519_scalar_addcarryx_u64(&x132, &x133, x131, x111, x116); + x134 = ((uint64_t)x133 + x112); + fiat_25519_scalar_mulx_u64(&x135, &x136, x3, (arg1[3])); + fiat_25519_scalar_mulx_u64(&x137, &x138, x3, (arg1[2])); + fiat_25519_scalar_mulx_u64(&x139, &x140, x3, (arg1[1])); + fiat_25519_scalar_mulx_u64(&x141, &x142, x3, (arg1[0])); + fiat_25519_scalar_addcarryx_u64(&x143, &x144, 0x0, x142, x139); + fiat_25519_scalar_addcarryx_u64(&x145, &x146, x144, x140, x137); + fiat_25519_scalar_addcarryx_u64(&x147, &x148, x146, x138, x135); + x149 = (x148 + x136); + fiat_25519_scalar_addcarryx_u64(&x150, &x151, 0x0, x126, x141); + fiat_25519_scalar_addcarryx_u64(&x152, &x153, x151, x128, x143); + fiat_25519_scalar_addcarryx_u64(&x154, &x155, x153, x130, x145); + fiat_25519_scalar_addcarryx_u64(&x156, &x157, x155, x132, x147); + fiat_25519_scalar_addcarryx_u64(&x158, &x159, x157, x134, x149); + fiat_25519_scalar_mulx_u64(&x160, &x161, x150, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x162, &x163, x160, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x164, &x165, x160, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x166, &x167, x160, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x168, &x169, 0x0, x167, x164); + x170 = (x169 + x165); + fiat_25519_scalar_addcarryx_u64(&x171, &x172, 0x0, x150, x166); + fiat_25519_scalar_addcarryx_u64(&x173, &x174, x172, x152, x168); + fiat_25519_scalar_addcarryx_u64(&x175, &x176, x174, x154, x170); + fiat_25519_scalar_addcarryx_u64(&x177, &x178, x176, x156, x162); + fiat_25519_scalar_addcarryx_u64(&x179, &x180, x178, x158, x163); + x181 = ((uint64_t)x180 + x159); + fiat_25519_scalar_subborrowx_u64(&x182, &x183, 0x0, x173, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_subborrowx_u64(&x184, &x185, x183, x175, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_subborrowx_u64(&x186, &x187, x185, x177, 0x0); + fiat_25519_scalar_subborrowx_u64(&x188, &x189, x187, x179, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_subborrowx_u64(&x190, &x191, x189, x181, 0x0); + fiat_25519_scalar_cmovznz_u64(&x192, x191, x182, x173); + fiat_25519_scalar_cmovznz_u64(&x193, x191, x184, x175); + fiat_25519_scalar_cmovznz_u64(&x194, x191, x186, x177); + fiat_25519_scalar_cmovznz_u64(&x195, x191, x188, x179); + out1[0] = x192; + out1[1] = x193; + out1[2] = x194; + out1[3] = x195; +} + +/* + * The function fiat_25519_scalar_add adds two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_add(fiat_25519_scalar_montgomery_domain_field_element out1, const fiat_25519_scalar_montgomery_domain_field_element arg1, const fiat_25519_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_25519_scalar_uint1 x2; + uint64_t x3; + fiat_25519_scalar_uint1 x4; + uint64_t x5; + fiat_25519_scalar_uint1 x6; + uint64_t x7; + fiat_25519_scalar_uint1 x8; + uint64_t x9; + fiat_25519_scalar_uint1 x10; + uint64_t x11; + fiat_25519_scalar_uint1 x12; + uint64_t x13; + fiat_25519_scalar_uint1 x14; + uint64_t x15; + fiat_25519_scalar_uint1 x16; + uint64_t x17; + fiat_25519_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + fiat_25519_scalar_addcarryx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_25519_scalar_addcarryx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_25519_scalar_addcarryx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_25519_scalar_addcarryx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_25519_scalar_subborrowx_u64(&x9, &x10, 0x0, x1, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_subborrowx_u64(&x11, &x12, x10, x3, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_subborrowx_u64(&x13, &x14, x12, x5, 0x0); + fiat_25519_scalar_subborrowx_u64(&x15, &x16, x14, x7, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_subborrowx_u64(&x17, &x18, x16, x8, 0x0); + fiat_25519_scalar_cmovznz_u64(&x19, x18, x9, x1); + fiat_25519_scalar_cmovznz_u64(&x20, x18, x11, x3); + fiat_25519_scalar_cmovznz_u64(&x21, x18, x13, x5); + fiat_25519_scalar_cmovznz_u64(&x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/* + * The function fiat_25519_scalar_sub subtracts two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_sub(fiat_25519_scalar_montgomery_domain_field_element out1, const fiat_25519_scalar_montgomery_domain_field_element arg1, const fiat_25519_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_25519_scalar_uint1 x2; + uint64_t x3; + fiat_25519_scalar_uint1 x4; + uint64_t x5; + fiat_25519_scalar_uint1 x6; + uint64_t x7; + fiat_25519_scalar_uint1 x8; + uint64_t x9; + uint64_t x10; + fiat_25519_scalar_uint1 x11; + uint64_t x12; + fiat_25519_scalar_uint1 x13; + uint64_t x14; + fiat_25519_scalar_uint1 x15; + uint64_t x16; + fiat_25519_scalar_uint1 x17; + fiat_25519_scalar_subborrowx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_25519_scalar_subborrowx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_25519_scalar_subborrowx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_25519_scalar_subborrowx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_25519_scalar_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_25519_scalar_addcarryx_u64(&x10, &x11, 0x0, x1, (x9 & UINT64_C(0x5812631a5cf5d3ed))); + fiat_25519_scalar_addcarryx_u64(&x12, &x13, x11, x3, (x9 & UINT64_C(0x14def9dea2f79cd6))); + fiat_25519_scalar_addcarryx_u64(&x14, &x15, x13, x5, 0x0); + fiat_25519_scalar_addcarryx_u64(&x16, &x17, x15, x7, (x9 & UINT64_C(0x1000000000000000))); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/* + * The function fiat_25519_scalar_opp negates a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_opp(fiat_25519_scalar_montgomery_domain_field_element out1, const fiat_25519_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + fiat_25519_scalar_uint1 x2; + uint64_t x3; + fiat_25519_scalar_uint1 x4; + uint64_t x5; + fiat_25519_scalar_uint1 x6; + uint64_t x7; + fiat_25519_scalar_uint1 x8; + uint64_t x9; + uint64_t x10; + fiat_25519_scalar_uint1 x11; + uint64_t x12; + fiat_25519_scalar_uint1 x13; + uint64_t x14; + fiat_25519_scalar_uint1 x15; + uint64_t x16; + fiat_25519_scalar_uint1 x17; + fiat_25519_scalar_subborrowx_u64(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_25519_scalar_subborrowx_u64(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_25519_scalar_subborrowx_u64(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_25519_scalar_subborrowx_u64(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_25519_scalar_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_25519_scalar_addcarryx_u64(&x10, &x11, 0x0, x1, (x9 & UINT64_C(0x5812631a5cf5d3ed))); + fiat_25519_scalar_addcarryx_u64(&x12, &x13, x11, x3, (x9 & UINT64_C(0x14def9dea2f79cd6))); + fiat_25519_scalar_addcarryx_u64(&x14, &x15, x13, x5, 0x0); + fiat_25519_scalar_addcarryx_u64(&x16, &x17, x15, x7, (x9 & UINT64_C(0x1000000000000000))); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/* + * The function fiat_25519_scalar_from_montgomery translates a field element out of the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_from_montgomery(fiat_25519_scalar_non_montgomery_domain_field_element out1, const fiat_25519_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + fiat_25519_scalar_uint1 x11; + uint64_t x12; + fiat_25519_scalar_uint1 x13; + uint64_t x14; + fiat_25519_scalar_uint1 x15; + uint64_t x16; + fiat_25519_scalar_uint1 x17; + uint64_t x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + fiat_25519_scalar_uint1 x27; + uint64_t x28; + fiat_25519_scalar_uint1 x29; + uint64_t x30; + fiat_25519_scalar_uint1 x31; + uint64_t x32; + fiat_25519_scalar_uint1 x33; + uint64_t x34; + fiat_25519_scalar_uint1 x35; + uint64_t x36; + fiat_25519_scalar_uint1 x37; + uint64_t x38; + fiat_25519_scalar_uint1 x39; + uint64_t x40; + fiat_25519_scalar_uint1 x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + uint64_t x50; + fiat_25519_scalar_uint1 x51; + uint64_t x52; + fiat_25519_scalar_uint1 x53; + uint64_t x54; + fiat_25519_scalar_uint1 x55; + uint64_t x56; + fiat_25519_scalar_uint1 x57; + uint64_t x58; + fiat_25519_scalar_uint1 x59; + uint64_t x60; + fiat_25519_scalar_uint1 x61; + uint64_t x62; + fiat_25519_scalar_uint1 x63; + uint64_t x64; + fiat_25519_scalar_uint1 x65; + uint64_t x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + fiat_25519_scalar_uint1 x75; + uint64_t x76; + fiat_25519_scalar_uint1 x77; + uint64_t x78; + fiat_25519_scalar_uint1 x79; + uint64_t x80; + fiat_25519_scalar_uint1 x81; + uint64_t x82; + fiat_25519_scalar_uint1 x83; + uint64_t x84; + uint64_t x85; + fiat_25519_scalar_uint1 x86; + uint64_t x87; + fiat_25519_scalar_uint1 x88; + uint64_t x89; + fiat_25519_scalar_uint1 x90; + uint64_t x91; + fiat_25519_scalar_uint1 x92; + uint64_t x93; + fiat_25519_scalar_uint1 x94; + uint64_t x95; + uint64_t x96; + uint64_t x97; + uint64_t x98; + x1 = (arg1[0]); + fiat_25519_scalar_mulx_u64(&x2, &x3, x1, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x4, &x5, x2, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x6, &x7, x2, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x8, &x9, x2, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x10, &x11, 0x0, x9, x6); + fiat_25519_scalar_addcarryx_u64(&x12, &x13, 0x0, x1, x8); + fiat_25519_scalar_addcarryx_u64(&x14, &x15, x13, 0x0, x10); + fiat_25519_scalar_addcarryx_u64(&x16, &x17, 0x0, x14, (arg1[1])); + fiat_25519_scalar_mulx_u64(&x18, &x19, x16, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x20, &x21, x18, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x22, &x23, x18, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x24, &x25, x18, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x26, &x27, 0x0, x25, x22); + fiat_25519_scalar_addcarryx_u64(&x28, &x29, 0x0, x16, x24); + fiat_25519_scalar_addcarryx_u64(&x30, &x31, x29, (x17 + (x15 + (x11 + x7))), x26); + fiat_25519_scalar_addcarryx_u64(&x32, &x33, x31, x4, (x27 + x23)); + fiat_25519_scalar_addcarryx_u64(&x34, &x35, x33, x5, x20); + fiat_25519_scalar_addcarryx_u64(&x36, &x37, 0x0, x30, (arg1[2])); + fiat_25519_scalar_addcarryx_u64(&x38, &x39, x37, x32, 0x0); + fiat_25519_scalar_addcarryx_u64(&x40, &x41, x39, x34, 0x0); + fiat_25519_scalar_mulx_u64(&x42, &x43, x36, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x44, &x45, x42, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x46, &x47, x42, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x48, &x49, x42, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x50, &x51, 0x0, x49, x46); + fiat_25519_scalar_addcarryx_u64(&x52, &x53, 0x0, x36, x48); + fiat_25519_scalar_addcarryx_u64(&x54, &x55, x53, x38, x50); + fiat_25519_scalar_addcarryx_u64(&x56, &x57, x55, x40, (x51 + x47)); + fiat_25519_scalar_addcarryx_u64(&x58, &x59, x57, (x41 + (x35 + x21)), x44); + fiat_25519_scalar_addcarryx_u64(&x60, &x61, 0x0, x54, (arg1[3])); + fiat_25519_scalar_addcarryx_u64(&x62, &x63, x61, x56, 0x0); + fiat_25519_scalar_addcarryx_u64(&x64, &x65, x63, x58, 0x0); + fiat_25519_scalar_mulx_u64(&x66, &x67, x60, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x68, &x69, x66, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x70, &x71, x66, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x72, &x73, x66, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x74, &x75, 0x0, x73, x70); + fiat_25519_scalar_addcarryx_u64(&x76, &x77, 0x0, x60, x72); + fiat_25519_scalar_addcarryx_u64(&x78, &x79, x77, x62, x74); + fiat_25519_scalar_addcarryx_u64(&x80, &x81, x79, x64, (x75 + x71)); + fiat_25519_scalar_addcarryx_u64(&x82, &x83, x81, (x65 + (x59 + x45)), x68); + x84 = (x83 + x69); + fiat_25519_scalar_subborrowx_u64(&x85, &x86, 0x0, x78, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_subborrowx_u64(&x87, &x88, x86, x80, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_subborrowx_u64(&x89, &x90, x88, x82, 0x0); + fiat_25519_scalar_subborrowx_u64(&x91, &x92, x90, x84, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_subborrowx_u64(&x93, &x94, x92, 0x0, 0x0); + fiat_25519_scalar_cmovznz_u64(&x95, x94, x85, x78); + fiat_25519_scalar_cmovznz_u64(&x96, x94, x87, x80); + fiat_25519_scalar_cmovznz_u64(&x97, x94, x89, x82); + fiat_25519_scalar_cmovznz_u64(&x98, x94, x91, x84); + out1[0] = x95; + out1[1] = x96; + out1[2] = x97; + out1[3] = x98; +} + +/* + * The function fiat_25519_scalar_to_montgomery translates a field element into the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = eval arg1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_to_montgomery(fiat_25519_scalar_montgomery_domain_field_element out1, const fiat_25519_scalar_non_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_25519_scalar_uint1 x14; + uint64_t x15; + fiat_25519_scalar_uint1 x16; + uint64_t x17; + fiat_25519_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + fiat_25519_scalar_uint1 x28; + uint64_t x29; + fiat_25519_scalar_uint1 x30; + uint64_t x31; + fiat_25519_scalar_uint1 x32; + uint64_t x33; + fiat_25519_scalar_uint1 x34; + uint64_t x35; + fiat_25519_scalar_uint1 x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + fiat_25519_scalar_uint1 x46; + uint64_t x47; + fiat_25519_scalar_uint1 x48; + uint64_t x49; + fiat_25519_scalar_uint1 x50; + uint64_t x51; + fiat_25519_scalar_uint1 x52; + uint64_t x53; + fiat_25519_scalar_uint1 x54; + uint64_t x55; + fiat_25519_scalar_uint1 x56; + uint64_t x57; + fiat_25519_scalar_uint1 x58; + uint64_t x59; + uint64_t x60; + uint64_t x61; + uint64_t x62; + uint64_t x63; + uint64_t x64; + uint64_t x65; + uint64_t x66; + uint64_t x67; + fiat_25519_scalar_uint1 x68; + uint64_t x69; + fiat_25519_scalar_uint1 x70; + uint64_t x71; + fiat_25519_scalar_uint1 x72; + uint64_t x73; + fiat_25519_scalar_uint1 x74; + uint64_t x75; + fiat_25519_scalar_uint1 x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + uint64_t x81; + uint64_t x82; + uint64_t x83; + uint64_t x84; + uint64_t x85; + fiat_25519_scalar_uint1 x86; + uint64_t x87; + fiat_25519_scalar_uint1 x88; + uint64_t x89; + fiat_25519_scalar_uint1 x90; + uint64_t x91; + fiat_25519_scalar_uint1 x92; + uint64_t x93; + fiat_25519_scalar_uint1 x94; + uint64_t x95; + fiat_25519_scalar_uint1 x96; + uint64_t x97; + fiat_25519_scalar_uint1 x98; + uint64_t x99; + uint64_t x100; + uint64_t x101; + uint64_t x102; + uint64_t x103; + uint64_t x104; + uint64_t x105; + uint64_t x106; + uint64_t x107; + fiat_25519_scalar_uint1 x108; + uint64_t x109; + fiat_25519_scalar_uint1 x110; + uint64_t x111; + fiat_25519_scalar_uint1 x112; + uint64_t x113; + fiat_25519_scalar_uint1 x114; + uint64_t x115; + fiat_25519_scalar_uint1 x116; + uint64_t x117; + uint64_t x118; + uint64_t x119; + uint64_t x120; + uint64_t x121; + uint64_t x122; + uint64_t x123; + uint64_t x124; + uint64_t x125; + fiat_25519_scalar_uint1 x126; + uint64_t x127; + fiat_25519_scalar_uint1 x128; + uint64_t x129; + fiat_25519_scalar_uint1 x130; + uint64_t x131; + fiat_25519_scalar_uint1 x132; + uint64_t x133; + fiat_25519_scalar_uint1 x134; + uint64_t x135; + fiat_25519_scalar_uint1 x136; + uint64_t x137; + fiat_25519_scalar_uint1 x138; + uint64_t x139; + uint64_t x140; + uint64_t x141; + uint64_t x142; + uint64_t x143; + uint64_t x144; + uint64_t x145; + uint64_t x146; + uint64_t x147; + fiat_25519_scalar_uint1 x148; + uint64_t x149; + fiat_25519_scalar_uint1 x150; + uint64_t x151; + fiat_25519_scalar_uint1 x152; + uint64_t x153; + fiat_25519_scalar_uint1 x154; + uint64_t x155; + fiat_25519_scalar_uint1 x156; + uint64_t x157; + uint64_t x158; + fiat_25519_scalar_uint1 x159; + uint64_t x160; + fiat_25519_scalar_uint1 x161; + uint64_t x162; + fiat_25519_scalar_uint1 x163; + uint64_t x164; + fiat_25519_scalar_uint1 x165; + uint64_t x166; + fiat_25519_scalar_uint1 x167; + uint64_t x168; + uint64_t x169; + uint64_t x170; + uint64_t x171; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_25519_scalar_mulx_u64(&x5, &x6, x4, UINT64_C(0x399411b7c309a3d)); + fiat_25519_scalar_mulx_u64(&x7, &x8, x4, UINT64_C(0xceec73d217f5be65)); + fiat_25519_scalar_mulx_u64(&x9, &x10, x4, UINT64_C(0xd00e1ba768859347)); + fiat_25519_scalar_mulx_u64(&x11, &x12, x4, UINT64_C(0xa40611e3449c0f01)); + fiat_25519_scalar_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_25519_scalar_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_25519_scalar_addcarryx_u64(&x17, &x18, x16, x8, x5); + fiat_25519_scalar_mulx_u64(&x19, &x20, x11, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x21, &x22, x19, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x23, &x24, x19, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x25, &x26, x19, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x27, &x28, 0x0, x26, x23); + fiat_25519_scalar_addcarryx_u64(&x29, &x30, 0x0, x11, x25); + fiat_25519_scalar_addcarryx_u64(&x31, &x32, x30, x13, x27); + fiat_25519_scalar_addcarryx_u64(&x33, &x34, x32, x15, (x28 + x24)); + fiat_25519_scalar_addcarryx_u64(&x35, &x36, x34, x17, x21); + fiat_25519_scalar_mulx_u64(&x37, &x38, x1, UINT64_C(0x399411b7c309a3d)); + fiat_25519_scalar_mulx_u64(&x39, &x40, x1, UINT64_C(0xceec73d217f5be65)); + fiat_25519_scalar_mulx_u64(&x41, &x42, x1, UINT64_C(0xd00e1ba768859347)); + fiat_25519_scalar_mulx_u64(&x43, &x44, x1, UINT64_C(0xa40611e3449c0f01)); + fiat_25519_scalar_addcarryx_u64(&x45, &x46, 0x0, x44, x41); + fiat_25519_scalar_addcarryx_u64(&x47, &x48, x46, x42, x39); + fiat_25519_scalar_addcarryx_u64(&x49, &x50, x48, x40, x37); + fiat_25519_scalar_addcarryx_u64(&x51, &x52, 0x0, x31, x43); + fiat_25519_scalar_addcarryx_u64(&x53, &x54, x52, x33, x45); + fiat_25519_scalar_addcarryx_u64(&x55, &x56, x54, x35, x47); + fiat_25519_scalar_addcarryx_u64(&x57, &x58, x56, ((x36 + (x18 + x6)) + x22), x49); + fiat_25519_scalar_mulx_u64(&x59, &x60, x51, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x61, &x62, x59, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x63, &x64, x59, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x65, &x66, x59, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x67, &x68, 0x0, x66, x63); + fiat_25519_scalar_addcarryx_u64(&x69, &x70, 0x0, x51, x65); + fiat_25519_scalar_addcarryx_u64(&x71, &x72, x70, x53, x67); + fiat_25519_scalar_addcarryx_u64(&x73, &x74, x72, x55, (x68 + x64)); + fiat_25519_scalar_addcarryx_u64(&x75, &x76, x74, x57, x61); + fiat_25519_scalar_mulx_u64(&x77, &x78, x2, UINT64_C(0x399411b7c309a3d)); + fiat_25519_scalar_mulx_u64(&x79, &x80, x2, UINT64_C(0xceec73d217f5be65)); + fiat_25519_scalar_mulx_u64(&x81, &x82, x2, UINT64_C(0xd00e1ba768859347)); + fiat_25519_scalar_mulx_u64(&x83, &x84, x2, UINT64_C(0xa40611e3449c0f01)); + fiat_25519_scalar_addcarryx_u64(&x85, &x86, 0x0, x84, x81); + fiat_25519_scalar_addcarryx_u64(&x87, &x88, x86, x82, x79); + fiat_25519_scalar_addcarryx_u64(&x89, &x90, x88, x80, x77); + fiat_25519_scalar_addcarryx_u64(&x91, &x92, 0x0, x71, x83); + fiat_25519_scalar_addcarryx_u64(&x93, &x94, x92, x73, x85); + fiat_25519_scalar_addcarryx_u64(&x95, &x96, x94, x75, x87); + fiat_25519_scalar_addcarryx_u64(&x97, &x98, x96, ((x76 + (x58 + (x50 + x38))) + x62), x89); + fiat_25519_scalar_mulx_u64(&x99, &x100, x91, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x101, &x102, x99, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x103, &x104, x99, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x105, &x106, x99, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x107, &x108, 0x0, x106, x103); + fiat_25519_scalar_addcarryx_u64(&x109, &x110, 0x0, x91, x105); + fiat_25519_scalar_addcarryx_u64(&x111, &x112, x110, x93, x107); + fiat_25519_scalar_addcarryx_u64(&x113, &x114, x112, x95, (x108 + x104)); + fiat_25519_scalar_addcarryx_u64(&x115, &x116, x114, x97, x101); + fiat_25519_scalar_mulx_u64(&x117, &x118, x3, UINT64_C(0x399411b7c309a3d)); + fiat_25519_scalar_mulx_u64(&x119, &x120, x3, UINT64_C(0xceec73d217f5be65)); + fiat_25519_scalar_mulx_u64(&x121, &x122, x3, UINT64_C(0xd00e1ba768859347)); + fiat_25519_scalar_mulx_u64(&x123, &x124, x3, UINT64_C(0xa40611e3449c0f01)); + fiat_25519_scalar_addcarryx_u64(&x125, &x126, 0x0, x124, x121); + fiat_25519_scalar_addcarryx_u64(&x127, &x128, x126, x122, x119); + fiat_25519_scalar_addcarryx_u64(&x129, &x130, x128, x120, x117); + fiat_25519_scalar_addcarryx_u64(&x131, &x132, 0x0, x111, x123); + fiat_25519_scalar_addcarryx_u64(&x133, &x134, x132, x113, x125); + fiat_25519_scalar_addcarryx_u64(&x135, &x136, x134, x115, x127); + fiat_25519_scalar_addcarryx_u64(&x137, &x138, x136, ((x116 + (x98 + (x90 + x78))) + x102), x129); + fiat_25519_scalar_mulx_u64(&x139, &x140, x131, UINT64_C(0xd2b51da312547e1b)); + fiat_25519_scalar_mulx_u64(&x141, &x142, x139, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_mulx_u64(&x143, &x144, x139, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_mulx_u64(&x145, &x146, x139, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_addcarryx_u64(&x147, &x148, 0x0, x146, x143); + fiat_25519_scalar_addcarryx_u64(&x149, &x150, 0x0, x131, x145); + fiat_25519_scalar_addcarryx_u64(&x151, &x152, x150, x133, x147); + fiat_25519_scalar_addcarryx_u64(&x153, &x154, x152, x135, (x148 + x144)); + fiat_25519_scalar_addcarryx_u64(&x155, &x156, x154, x137, x141); + x157 = ((x156 + (x138 + (x130 + x118))) + x142); + fiat_25519_scalar_subborrowx_u64(&x158, &x159, 0x0, x151, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_subborrowx_u64(&x160, &x161, x159, x153, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_subborrowx_u64(&x162, &x163, x161, x155, 0x0); + fiat_25519_scalar_subborrowx_u64(&x164, &x165, x163, x157, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_subborrowx_u64(&x166, &x167, x165, 0x0, 0x0); + fiat_25519_scalar_cmovznz_u64(&x168, x167, x158, x151); + fiat_25519_scalar_cmovznz_u64(&x169, x167, x160, x153); + fiat_25519_scalar_cmovznz_u64(&x170, x167, x162, x155); + fiat_25519_scalar_cmovznz_u64(&x171, x167, x164, x157); + out1[0] = x168; + out1[1] = x169; + out1[2] = x170; + out1[3] = x171; +} + +/* + * The function fiat_25519_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_nonzero(uint64_t* out1, const uint64_t arg1[4]) { + uint64_t x1; + x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3])))); + *out1 = x1; +} + +/* + * The function fiat_25519_scalar_selectznz is a multi-limb conditional select. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_selectznz(uint64_t out1[4], fiat_25519_scalar_uint1 arg1, const uint64_t arg2[4], const uint64_t arg3[4]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + fiat_25519_scalar_cmovznz_u64(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_25519_scalar_cmovznz_u64(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_25519_scalar_cmovznz_u64(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_25519_scalar_cmovznz_u64(&x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/* + * The function fiat_25519_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1fffffffffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_to_bytes(uint8_t out1[32], const uint64_t arg1[4]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint8_t x5; + uint64_t x6; + uint8_t x7; + uint64_t x8; + uint8_t x9; + uint64_t x10; + uint8_t x11; + uint64_t x12; + uint8_t x13; + uint64_t x14; + uint8_t x15; + uint64_t x16; + uint8_t x17; + uint8_t x18; + uint8_t x19; + uint64_t x20; + uint8_t x21; + uint64_t x22; + uint8_t x23; + uint64_t x24; + uint8_t x25; + uint64_t x26; + uint8_t x27; + uint64_t x28; + uint8_t x29; + uint64_t x30; + uint8_t x31; + uint8_t x32; + uint8_t x33; + uint64_t x34; + uint8_t x35; + uint64_t x36; + uint8_t x37; + uint64_t x38; + uint8_t x39; + uint64_t x40; + uint8_t x41; + uint64_t x42; + uint8_t x43; + uint64_t x44; + uint8_t x45; + uint8_t x46; + uint8_t x47; + uint64_t x48; + uint8_t x49; + uint64_t x50; + uint8_t x51; + uint64_t x52; + uint8_t x53; + uint64_t x54; + uint8_t x55; + uint64_t x56; + uint8_t x57; + uint64_t x58; + uint8_t x59; + uint8_t x60; + x1 = (arg1[3]); + x2 = (arg1[2]); + x3 = (arg1[1]); + x4 = (arg1[0]); + x5 = (uint8_t)(x4 & UINT8_C(0xff)); + x6 = (x4 >> 8); + x7 = (uint8_t)(x6 & UINT8_C(0xff)); + x8 = (x6 >> 8); + x9 = (uint8_t)(x8 & UINT8_C(0xff)); + x10 = (x8 >> 8); + x11 = (uint8_t)(x10 & UINT8_C(0xff)); + x12 = (x10 >> 8); + x13 = (uint8_t)(x12 & UINT8_C(0xff)); + x14 = (x12 >> 8); + x15 = (uint8_t)(x14 & UINT8_C(0xff)); + x16 = (x14 >> 8); + x17 = (uint8_t)(x16 & UINT8_C(0xff)); + x18 = (uint8_t)(x16 >> 8); + x19 = (uint8_t)(x3 & UINT8_C(0xff)); + x20 = (x3 >> 8); + x21 = (uint8_t)(x20 & UINT8_C(0xff)); + x22 = (x20 >> 8); + x23 = (uint8_t)(x22 & UINT8_C(0xff)); + x24 = (x22 >> 8); + x25 = (uint8_t)(x24 & UINT8_C(0xff)); + x26 = (x24 >> 8); + x27 = (uint8_t)(x26 & UINT8_C(0xff)); + x28 = (x26 >> 8); + x29 = (uint8_t)(x28 & UINT8_C(0xff)); + x30 = (x28 >> 8); + x31 = (uint8_t)(x30 & UINT8_C(0xff)); + x32 = (uint8_t)(x30 >> 8); + x33 = (uint8_t)(x2 & UINT8_C(0xff)); + x34 = (x2 >> 8); + x35 = (uint8_t)(x34 & UINT8_C(0xff)); + x36 = (x34 >> 8); + x37 = (uint8_t)(x36 & UINT8_C(0xff)); + x38 = (x36 >> 8); + x39 = (uint8_t)(x38 & UINT8_C(0xff)); + x40 = (x38 >> 8); + x41 = (uint8_t)(x40 & UINT8_C(0xff)); + x42 = (x40 >> 8); + x43 = (uint8_t)(x42 & UINT8_C(0xff)); + x44 = (x42 >> 8); + x45 = (uint8_t)(x44 & UINT8_C(0xff)); + x46 = (uint8_t)(x44 >> 8); + x47 = (uint8_t)(x1 & UINT8_C(0xff)); + x48 = (x1 >> 8); + x49 = (uint8_t)(x48 & UINT8_C(0xff)); + x50 = (x48 >> 8); + x51 = (uint8_t)(x50 & UINT8_C(0xff)); + x52 = (x50 >> 8); + x53 = (uint8_t)(x52 & UINT8_C(0xff)); + x54 = (x52 >> 8); + x55 = (uint8_t)(x54 & UINT8_C(0xff)); + x56 = (x54 >> 8); + x57 = (uint8_t)(x56 & UINT8_C(0xff)); + x58 = (x56 >> 8); + x59 = (uint8_t)(x58 & UINT8_C(0xff)); + x60 = (uint8_t)(x58 >> 8); + out1[0] = x5; + out1[1] = x7; + out1[2] = x9; + out1[3] = x11; + out1[4] = x13; + out1[5] = x15; + out1[6] = x17; + out1[7] = x18; + out1[8] = x19; + out1[9] = x21; + out1[10] = x23; + out1[11] = x25; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x39; + out1[20] = x41; + out1[21] = x43; + out1[22] = x45; + out1[23] = x46; + out1[24] = x47; + out1[25] = x49; + out1[26] = x51; + out1[27] = x53; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; +} + +/* + * The function fiat_25519_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. + * + * Preconditions: + * 0 ≤ bytes_eval arg1 < m + * Postconditions: + * eval out1 mod m = bytes_eval arg1 mod m + * 0 ≤ eval out1 < m + * + * Input Bounds: + * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1fffffffffffffff]] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_from_bytes(uint64_t out1[4], const uint8_t arg1[32]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint8_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint8_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint8_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint8_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + uint64_t x54; + uint64_t x55; + uint64_t x56; + uint64_t x57; + uint64_t x58; + uint64_t x59; + uint64_t x60; + x1 = ((uint64_t)(arg1[31]) << 56); + x2 = ((uint64_t)(arg1[30]) << 48); + x3 = ((uint64_t)(arg1[29]) << 40); + x4 = ((uint64_t)(arg1[28]) << 32); + x5 = ((uint64_t)(arg1[27]) << 24); + x6 = ((uint64_t)(arg1[26]) << 16); + x7 = ((uint64_t)(arg1[25]) << 8); + x8 = (arg1[24]); + x9 = ((uint64_t)(arg1[23]) << 56); + x10 = ((uint64_t)(arg1[22]) << 48); + x11 = ((uint64_t)(arg1[21]) << 40); + x12 = ((uint64_t)(arg1[20]) << 32); + x13 = ((uint64_t)(arg1[19]) << 24); + x14 = ((uint64_t)(arg1[18]) << 16); + x15 = ((uint64_t)(arg1[17]) << 8); + x16 = (arg1[16]); + x17 = ((uint64_t)(arg1[15]) << 56); + x18 = ((uint64_t)(arg1[14]) << 48); + x19 = ((uint64_t)(arg1[13]) << 40); + x20 = ((uint64_t)(arg1[12]) << 32); + x21 = ((uint64_t)(arg1[11]) << 24); + x22 = ((uint64_t)(arg1[10]) << 16); + x23 = ((uint64_t)(arg1[9]) << 8); + x24 = (arg1[8]); + x25 = ((uint64_t)(arg1[7]) << 56); + x26 = ((uint64_t)(arg1[6]) << 48); + x27 = ((uint64_t)(arg1[5]) << 40); + x28 = ((uint64_t)(arg1[4]) << 32); + x29 = ((uint64_t)(arg1[3]) << 24); + x30 = ((uint64_t)(arg1[2]) << 16); + x31 = ((uint64_t)(arg1[1]) << 8); + x32 = (arg1[0]); + x33 = (x31 + (uint64_t)x32); + x34 = (x30 + x33); + x35 = (x29 + x34); + x36 = (x28 + x35); + x37 = (x27 + x36); + x38 = (x26 + x37); + x39 = (x25 + x38); + x40 = (x23 + (uint64_t)x24); + x41 = (x22 + x40); + x42 = (x21 + x41); + x43 = (x20 + x42); + x44 = (x19 + x43); + x45 = (x18 + x44); + x46 = (x17 + x45); + x47 = (x15 + (uint64_t)x16); + x48 = (x14 + x47); + x49 = (x13 + x48); + x50 = (x12 + x49); + x51 = (x11 + x50); + x52 = (x10 + x51); + x53 = (x9 + x52); + x54 = (x7 + (uint64_t)x8); + x55 = (x6 + x54); + x56 = (x5 + x55); + x57 = (x4 + x56); + x58 = (x3 + x57); + x59 = (x2 + x58); + x60 = (x1 + x59); + out1[0] = x39; + out1[1] = x46; + out1[2] = x53; + out1[3] = x60; +} + +/* + * The function fiat_25519_scalar_set_one returns the field element one in the Montgomery domain. + * + * Postconditions: + * eval (from_montgomery out1) mod m = 1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_set_one(fiat_25519_scalar_montgomery_domain_field_element out1) { + out1[0] = UINT64_C(0xd6ec31748d98951d); + out1[1] = UINT64_C(0xc6ef5bf4737dcf70); + out1[2] = UINT64_C(0xfffffffffffffffe); + out1[3] = UINT64_C(0xfffffffffffffff); +} + +/* + * The function fiat_25519_scalar_msat returns the saturated representation of the prime modulus. + * + * Postconditions: + * twos_complement_eval out1 = m + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_msat(uint64_t out1[5]) { + out1[0] = UINT64_C(0x5812631a5cf5d3ed); + out1[1] = UINT64_C(0x14def9dea2f79cd6); + out1[2] = 0x0; + out1[3] = UINT64_C(0x1000000000000000); + out1[4] = 0x0; +} + +/* + * The function fiat_25519_scalar_divstep computes a divstep. + * + * Preconditions: + * 0 ≤ eval arg4 < m + * 0 ≤ eval arg5 < m + * Postconditions: + * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) + * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) + * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) + * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) + * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) + * 0 ≤ eval out5 < m + * 0 ≤ eval out5 < m + * 0 ≤ eval out2 < m + * 0 ≤ eval out3 < m + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffffffffffff] + * arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_divstep(uint64_t* out1, uint64_t out2[5], uint64_t out3[5], uint64_t out4[4], uint64_t out5[4], uint64_t arg1, const uint64_t arg2[5], const uint64_t arg3[5], const uint64_t arg4[4], const uint64_t arg5[4]) { + uint64_t x1; + fiat_25519_scalar_uint1 x2; + fiat_25519_scalar_uint1 x3; + uint64_t x4; + fiat_25519_scalar_uint1 x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + fiat_25519_scalar_uint1 x13; + uint64_t x14; + fiat_25519_scalar_uint1 x15; + uint64_t x16; + fiat_25519_scalar_uint1 x17; + uint64_t x18; + fiat_25519_scalar_uint1 x19; + uint64_t x20; + fiat_25519_scalar_uint1 x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + fiat_25519_scalar_uint1 x32; + uint64_t x33; + fiat_25519_scalar_uint1 x34; + uint64_t x35; + fiat_25519_scalar_uint1 x36; + uint64_t x37; + fiat_25519_scalar_uint1 x38; + uint64_t x39; + fiat_25519_scalar_uint1 x40; + uint64_t x41; + fiat_25519_scalar_uint1 x42; + uint64_t x43; + fiat_25519_scalar_uint1 x44; + uint64_t x45; + fiat_25519_scalar_uint1 x46; + uint64_t x47; + fiat_25519_scalar_uint1 x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + fiat_25519_scalar_uint1 x54; + uint64_t x55; + fiat_25519_scalar_uint1 x56; + uint64_t x57; + fiat_25519_scalar_uint1 x58; + uint64_t x59; + fiat_25519_scalar_uint1 x60; + uint64_t x61; + uint64_t x62; + fiat_25519_scalar_uint1 x63; + uint64_t x64; + fiat_25519_scalar_uint1 x65; + uint64_t x66; + fiat_25519_scalar_uint1 x67; + uint64_t x68; + fiat_25519_scalar_uint1 x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + fiat_25519_scalar_uint1 x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + fiat_25519_scalar_uint1 x81; + uint64_t x82; + fiat_25519_scalar_uint1 x83; + uint64_t x84; + fiat_25519_scalar_uint1 x85; + uint64_t x86; + fiat_25519_scalar_uint1 x87; + uint64_t x88; + fiat_25519_scalar_uint1 x89; + uint64_t x90; + uint64_t x91; + uint64_t x92; + uint64_t x93; + uint64_t x94; + fiat_25519_scalar_uint1 x95; + uint64_t x96; + fiat_25519_scalar_uint1 x97; + uint64_t x98; + fiat_25519_scalar_uint1 x99; + uint64_t x100; + fiat_25519_scalar_uint1 x101; + uint64_t x102; + fiat_25519_scalar_uint1 x103; + uint64_t x104; + fiat_25519_scalar_uint1 x105; + uint64_t x106; + fiat_25519_scalar_uint1 x107; + uint64_t x108; + fiat_25519_scalar_uint1 x109; + uint64_t x110; + fiat_25519_scalar_uint1 x111; + uint64_t x112; + fiat_25519_scalar_uint1 x113; + uint64_t x114; + uint64_t x115; + uint64_t x116; + uint64_t x117; + uint64_t x118; + uint64_t x119; + uint64_t x120; + uint64_t x121; + uint64_t x122; + uint64_t x123; + uint64_t x124; + uint64_t x125; + uint64_t x126; + fiat_25519_scalar_addcarryx_u64(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_25519_scalar_uint1)((fiat_25519_scalar_uint1)(x1 >> 63) & (fiat_25519_scalar_uint1)((arg3[0]) & 0x1)); + fiat_25519_scalar_addcarryx_u64(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_25519_scalar_cmovznz_u64(&x6, x3, arg1, x4); + fiat_25519_scalar_cmovznz_u64(&x7, x3, (arg2[0]), (arg3[0])); + fiat_25519_scalar_cmovznz_u64(&x8, x3, (arg2[1]), (arg3[1])); + fiat_25519_scalar_cmovznz_u64(&x9, x3, (arg2[2]), (arg3[2])); + fiat_25519_scalar_cmovznz_u64(&x10, x3, (arg2[3]), (arg3[3])); + fiat_25519_scalar_cmovznz_u64(&x11, x3, (arg2[4]), (arg3[4])); + fiat_25519_scalar_addcarryx_u64(&x12, &x13, 0x0, 0x1, (~(arg2[0]))); + fiat_25519_scalar_addcarryx_u64(&x14, &x15, x13, 0x0, (~(arg2[1]))); + fiat_25519_scalar_addcarryx_u64(&x16, &x17, x15, 0x0, (~(arg2[2]))); + fiat_25519_scalar_addcarryx_u64(&x18, &x19, x17, 0x0, (~(arg2[3]))); + fiat_25519_scalar_addcarryx_u64(&x20, &x21, x19, 0x0, (~(arg2[4]))); + fiat_25519_scalar_cmovznz_u64(&x22, x3, (arg3[0]), x12); + fiat_25519_scalar_cmovznz_u64(&x23, x3, (arg3[1]), x14); + fiat_25519_scalar_cmovznz_u64(&x24, x3, (arg3[2]), x16); + fiat_25519_scalar_cmovznz_u64(&x25, x3, (arg3[3]), x18); + fiat_25519_scalar_cmovznz_u64(&x26, x3, (arg3[4]), x20); + fiat_25519_scalar_cmovznz_u64(&x27, x3, (arg4[0]), (arg5[0])); + fiat_25519_scalar_cmovznz_u64(&x28, x3, (arg4[1]), (arg5[1])); + fiat_25519_scalar_cmovznz_u64(&x29, x3, (arg4[2]), (arg5[2])); + fiat_25519_scalar_cmovznz_u64(&x30, x3, (arg4[3]), (arg5[3])); + fiat_25519_scalar_addcarryx_u64(&x31, &x32, 0x0, x27, x27); + fiat_25519_scalar_addcarryx_u64(&x33, &x34, x32, x28, x28); + fiat_25519_scalar_addcarryx_u64(&x35, &x36, x34, x29, x29); + fiat_25519_scalar_addcarryx_u64(&x37, &x38, x36, x30, x30); + fiat_25519_scalar_subborrowx_u64(&x39, &x40, 0x0, x31, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_subborrowx_u64(&x41, &x42, x40, x33, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_subborrowx_u64(&x43, &x44, x42, x35, 0x0); + fiat_25519_scalar_subborrowx_u64(&x45, &x46, x44, x37, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_subborrowx_u64(&x47, &x48, x46, x38, 0x0); + x49 = (arg4[3]); + x50 = (arg4[2]); + x51 = (arg4[1]); + x52 = (arg4[0]); + fiat_25519_scalar_subborrowx_u64(&x53, &x54, 0x0, 0x0, x52); + fiat_25519_scalar_subborrowx_u64(&x55, &x56, x54, 0x0, x51); + fiat_25519_scalar_subborrowx_u64(&x57, &x58, x56, 0x0, x50); + fiat_25519_scalar_subborrowx_u64(&x59, &x60, x58, 0x0, x49); + fiat_25519_scalar_cmovznz_u64(&x61, x60, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_25519_scalar_addcarryx_u64(&x62, &x63, 0x0, x53, (x61 & UINT64_C(0x5812631a5cf5d3ed))); + fiat_25519_scalar_addcarryx_u64(&x64, &x65, x63, x55, (x61 & UINT64_C(0x14def9dea2f79cd6))); + fiat_25519_scalar_addcarryx_u64(&x66, &x67, x65, x57, 0x0); + fiat_25519_scalar_addcarryx_u64(&x68, &x69, x67, x59, (x61 & UINT64_C(0x1000000000000000))); + fiat_25519_scalar_cmovznz_u64(&x70, x3, (arg5[0]), x62); + fiat_25519_scalar_cmovznz_u64(&x71, x3, (arg5[1]), x64); + fiat_25519_scalar_cmovznz_u64(&x72, x3, (arg5[2]), x66); + fiat_25519_scalar_cmovznz_u64(&x73, x3, (arg5[3]), x68); + x74 = (fiat_25519_scalar_uint1)(x22 & 0x1); + fiat_25519_scalar_cmovznz_u64(&x75, x74, 0x0, x7); + fiat_25519_scalar_cmovznz_u64(&x76, x74, 0x0, x8); + fiat_25519_scalar_cmovznz_u64(&x77, x74, 0x0, x9); + fiat_25519_scalar_cmovznz_u64(&x78, x74, 0x0, x10); + fiat_25519_scalar_cmovznz_u64(&x79, x74, 0x0, x11); + fiat_25519_scalar_addcarryx_u64(&x80, &x81, 0x0, x22, x75); + fiat_25519_scalar_addcarryx_u64(&x82, &x83, x81, x23, x76); + fiat_25519_scalar_addcarryx_u64(&x84, &x85, x83, x24, x77); + fiat_25519_scalar_addcarryx_u64(&x86, &x87, x85, x25, x78); + fiat_25519_scalar_addcarryx_u64(&x88, &x89, x87, x26, x79); + fiat_25519_scalar_cmovznz_u64(&x90, x74, 0x0, x27); + fiat_25519_scalar_cmovznz_u64(&x91, x74, 0x0, x28); + fiat_25519_scalar_cmovznz_u64(&x92, x74, 0x0, x29); + fiat_25519_scalar_cmovznz_u64(&x93, x74, 0x0, x30); + fiat_25519_scalar_addcarryx_u64(&x94, &x95, 0x0, x70, x90); + fiat_25519_scalar_addcarryx_u64(&x96, &x97, x95, x71, x91); + fiat_25519_scalar_addcarryx_u64(&x98, &x99, x97, x72, x92); + fiat_25519_scalar_addcarryx_u64(&x100, &x101, x99, x73, x93); + fiat_25519_scalar_subborrowx_u64(&x102, &x103, 0x0, x94, UINT64_C(0x5812631a5cf5d3ed)); + fiat_25519_scalar_subborrowx_u64(&x104, &x105, x103, x96, UINT64_C(0x14def9dea2f79cd6)); + fiat_25519_scalar_subborrowx_u64(&x106, &x107, x105, x98, 0x0); + fiat_25519_scalar_subborrowx_u64(&x108, &x109, x107, x100, UINT64_C(0x1000000000000000)); + fiat_25519_scalar_subborrowx_u64(&x110, &x111, x109, x101, 0x0); + fiat_25519_scalar_addcarryx_u64(&x112, &x113, 0x0, x6, 0x1); + x114 = ((x80 >> 1) | ((x82 << 63) & UINT64_C(0xffffffffffffffff))); + x115 = ((x82 >> 1) | ((x84 << 63) & UINT64_C(0xffffffffffffffff))); + x116 = ((x84 >> 1) | ((x86 << 63) & UINT64_C(0xffffffffffffffff))); + x117 = ((x86 >> 1) | ((x88 << 63) & UINT64_C(0xffffffffffffffff))); + x118 = ((x88 & UINT64_C(0x8000000000000000)) | (x88 >> 1)); + fiat_25519_scalar_cmovznz_u64(&x119, x48, x39, x31); + fiat_25519_scalar_cmovznz_u64(&x120, x48, x41, x33); + fiat_25519_scalar_cmovznz_u64(&x121, x48, x43, x35); + fiat_25519_scalar_cmovznz_u64(&x122, x48, x45, x37); + fiat_25519_scalar_cmovznz_u64(&x123, x111, x102, x94); + fiat_25519_scalar_cmovznz_u64(&x124, x111, x104, x96); + fiat_25519_scalar_cmovznz_u64(&x125, x111, x106, x98); + fiat_25519_scalar_cmovznz_u64(&x126, x111, x108, x100); + *out1 = x112; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out3[0] = x114; + out3[1] = x115; + out3[2] = x116; + out3[3] = x117; + out3[4] = x118; + out4[0] = x119; + out4[1] = x120; + out4[2] = x121; + out4[3] = x122; + out5[0] = x123; + out5[1] = x124; + out5[2] = x125; + out5[3] = x126; +} + +/* + * The function fiat_25519_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). + * + * Postconditions: + * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_25519_SCALAR_FIAT_INLINE void fiat_25519_scalar_divstep_precomp(uint64_t out1[4]) { + out1[0] = UINT64_C(0xd70af84436a7cb92); + out1[1] = UINT64_C(0x5f71c978b0b8b159); + out1[2] = UINT64_C(0xe76d816974947f1a); + out1[3] = UINT64_C(0x19a2d36f193e4ff); +} diff --git a/fiat-c/src/p256_scalar_32.c b/fiat-c/src/p256_scalar_32.c new file mode 100644 index 0000000000..78c43786fe --- /dev/null +++ b/fiat-c/src/p256_scalar_32.c @@ -0,0 +1,5558 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier p256_scalar 32 '2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: p256_scalar */ +/* machine_wordsize = 32 (from "32") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 (from "2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +typedef unsigned char fiat_p256_scalar_uint1; +typedef signed char fiat_p256_scalar_int1; +#if defined(__GNUC__) || defined(__clang__) +# define FIAT_P256_SCALAR_FIAT_INLINE __inline__ +#else +# define FIAT_P256_SCALAR_FIAT_INLINE +#endif + +/* The type fiat_p256_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +typedef uint32_t fiat_p256_scalar_montgomery_domain_field_element[8]; + +/* The type fiat_p256_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +typedef uint32_t fiat_p256_scalar_non_montgomery_domain_field_element[8]; + +#if (-1 & 3) != 3 +#error "This code only works on a two's complement system" +#endif + +#if !defined(FIAT_P256_SCALAR_NO_ASM) && (defined(__GNUC__) || defined(__clang__)) +static __inline__ uint32_t fiat_p256_scalar_value_barrier_u32(uint32_t a) { + __asm__("" : "+r"(a) : /* no inputs */); + return a; +} +#else +# define fiat_p256_scalar_value_barrier_u32(x) (x) +#endif + + +/* + * The function fiat_p256_scalar_addcarryx_u32 is an addition with carry. + * + * Postconditions: + * out1 = (arg1 + arg2 + arg3) mod 2^32 + * out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffff] + * arg3: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_addcarryx_u32(uint32_t* out1, fiat_p256_scalar_uint1* out2, fiat_p256_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + uint64_t x1; + uint32_t x2; + fiat_p256_scalar_uint1 x3; + x1 = ((arg1 + (uint64_t)arg2) + arg3); + x2 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + x3 = (fiat_p256_scalar_uint1)(x1 >> 32); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_p256_scalar_subborrowx_u32 is a subtraction with borrow. + * + * Postconditions: + * out1 = (-arg1 + arg2 + -arg3) mod 2^32 + * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffff] + * arg3: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_subborrowx_u32(uint32_t* out1, fiat_p256_scalar_uint1* out2, fiat_p256_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + int64_t x1; + fiat_p256_scalar_int1 x2; + uint32_t x3; + x1 = ((arg2 - (int64_t)arg1) - arg3); + x2 = (fiat_p256_scalar_int1)(x1 >> 32); + x3 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + *out1 = x3; + *out2 = (fiat_p256_scalar_uint1)(0x0 - x2); +} + +/* + * The function fiat_p256_scalar_mulx_u32 is a multiplication, returning the full double-width result. + * + * Postconditions: + * out1 = (arg1 * arg2) mod 2^32 + * out2 = ⌊arg1 * arg2 / 2^32⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffff] + * arg2: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [0x0 ~> 0xffffffff] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_mulx_u32(uint32_t* out1, uint32_t* out2, uint32_t arg1, uint32_t arg2) { + uint64_t x1; + uint32_t x2; + uint32_t x3; + x1 = ((uint64_t)arg1 * arg2); + x2 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + x3 = (uint32_t)(x1 >> 32); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_p256_scalar_cmovznz_u32 is a single-word conditional move. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffff] + * arg3: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_cmovznz_u32(uint32_t* out1, fiat_p256_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + fiat_p256_scalar_uint1 x1; + uint32_t x2; + uint32_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_p256_scalar_int1)(0x0 - x1) & UINT32_C(0xffffffff)); + x3 = ((fiat_p256_scalar_value_barrier_u32(x2) & arg3) | (fiat_p256_scalar_value_barrier_u32((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_p256_scalar_mul multiplies two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_mul(fiat_p256_scalar_montgomery_domain_field_element out1, const fiat_p256_scalar_montgomery_domain_field_element arg1, const fiat_p256_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + fiat_p256_scalar_uint1 x26; + uint32_t x27; + fiat_p256_scalar_uint1 x28; + uint32_t x29; + fiat_p256_scalar_uint1 x30; + uint32_t x31; + fiat_p256_scalar_uint1 x32; + uint32_t x33; + fiat_p256_scalar_uint1 x34; + uint32_t x35; + fiat_p256_scalar_uint1 x36; + uint32_t x37; + fiat_p256_scalar_uint1 x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + uint32_t x53; + uint32_t x54; + uint32_t x55; + uint32_t x56; + fiat_p256_scalar_uint1 x57; + uint32_t x58; + fiat_p256_scalar_uint1 x59; + uint32_t x60; + fiat_p256_scalar_uint1 x61; + uint32_t x62; + fiat_p256_scalar_uint1 x63; + uint32_t x64; + fiat_p256_scalar_uint1 x65; + uint32_t x66; + uint32_t x67; + fiat_p256_scalar_uint1 x68; + uint32_t x69; + fiat_p256_scalar_uint1 x70; + uint32_t x71; + fiat_p256_scalar_uint1 x72; + uint32_t x73; + fiat_p256_scalar_uint1 x74; + uint32_t x75; + fiat_p256_scalar_uint1 x76; + uint32_t x77; + fiat_p256_scalar_uint1 x78; + uint32_t x79; + fiat_p256_scalar_uint1 x80; + uint32_t x81; + fiat_p256_scalar_uint1 x82; + uint32_t x83; + fiat_p256_scalar_uint1 x84; + uint32_t x85; + uint32_t x86; + uint32_t x87; + uint32_t x88; + uint32_t x89; + uint32_t x90; + uint32_t x91; + uint32_t x92; + uint32_t x93; + uint32_t x94; + uint32_t x95; + uint32_t x96; + uint32_t x97; + uint32_t x98; + uint32_t x99; + uint32_t x100; + uint32_t x101; + fiat_p256_scalar_uint1 x102; + uint32_t x103; + fiat_p256_scalar_uint1 x104; + uint32_t x105; + fiat_p256_scalar_uint1 x106; + uint32_t x107; + fiat_p256_scalar_uint1 x108; + uint32_t x109; + fiat_p256_scalar_uint1 x110; + uint32_t x111; + fiat_p256_scalar_uint1 x112; + uint32_t x113; + fiat_p256_scalar_uint1 x114; + uint32_t x115; + uint32_t x116; + fiat_p256_scalar_uint1 x117; + uint32_t x118; + fiat_p256_scalar_uint1 x119; + uint32_t x120; + fiat_p256_scalar_uint1 x121; + uint32_t x122; + fiat_p256_scalar_uint1 x123; + uint32_t x124; + fiat_p256_scalar_uint1 x125; + uint32_t x126; + fiat_p256_scalar_uint1 x127; + uint32_t x128; + fiat_p256_scalar_uint1 x129; + uint32_t x130; + fiat_p256_scalar_uint1 x131; + uint32_t x132; + fiat_p256_scalar_uint1 x133; + uint32_t x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + uint32_t x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + uint32_t x145; + uint32_t x146; + uint32_t x147; + uint32_t x148; + uint32_t x149; + uint32_t x150; + fiat_p256_scalar_uint1 x151; + uint32_t x152; + fiat_p256_scalar_uint1 x153; + uint32_t x154; + fiat_p256_scalar_uint1 x155; + uint32_t x156; + fiat_p256_scalar_uint1 x157; + uint32_t x158; + fiat_p256_scalar_uint1 x159; + uint32_t x160; + uint32_t x161; + fiat_p256_scalar_uint1 x162; + uint32_t x163; + fiat_p256_scalar_uint1 x164; + uint32_t x165; + fiat_p256_scalar_uint1 x166; + uint32_t x167; + fiat_p256_scalar_uint1 x168; + uint32_t x169; + fiat_p256_scalar_uint1 x170; + uint32_t x171; + fiat_p256_scalar_uint1 x172; + uint32_t x173; + fiat_p256_scalar_uint1 x174; + uint32_t x175; + fiat_p256_scalar_uint1 x176; + uint32_t x177; + fiat_p256_scalar_uint1 x178; + uint32_t x179; + uint32_t x180; + uint32_t x181; + uint32_t x182; + uint32_t x183; + uint32_t x184; + uint32_t x185; + uint32_t x186; + uint32_t x187; + uint32_t x188; + uint32_t x189; + uint32_t x190; + uint32_t x191; + uint32_t x192; + uint32_t x193; + uint32_t x194; + uint32_t x195; + uint32_t x196; + fiat_p256_scalar_uint1 x197; + uint32_t x198; + fiat_p256_scalar_uint1 x199; + uint32_t x200; + fiat_p256_scalar_uint1 x201; + uint32_t x202; + fiat_p256_scalar_uint1 x203; + uint32_t x204; + fiat_p256_scalar_uint1 x205; + uint32_t x206; + fiat_p256_scalar_uint1 x207; + uint32_t x208; + fiat_p256_scalar_uint1 x209; + uint32_t x210; + uint32_t x211; + fiat_p256_scalar_uint1 x212; + uint32_t x213; + fiat_p256_scalar_uint1 x214; + uint32_t x215; + fiat_p256_scalar_uint1 x216; + uint32_t x217; + fiat_p256_scalar_uint1 x218; + uint32_t x219; + fiat_p256_scalar_uint1 x220; + uint32_t x221; + fiat_p256_scalar_uint1 x222; + uint32_t x223; + fiat_p256_scalar_uint1 x224; + uint32_t x225; + fiat_p256_scalar_uint1 x226; + uint32_t x227; + fiat_p256_scalar_uint1 x228; + uint32_t x229; + uint32_t x230; + uint32_t x231; + uint32_t x232; + uint32_t x233; + uint32_t x234; + uint32_t x235; + uint32_t x236; + uint32_t x237; + uint32_t x238; + uint32_t x239; + uint32_t x240; + uint32_t x241; + uint32_t x242; + uint32_t x243; + uint32_t x244; + uint32_t x245; + fiat_p256_scalar_uint1 x246; + uint32_t x247; + fiat_p256_scalar_uint1 x248; + uint32_t x249; + fiat_p256_scalar_uint1 x250; + uint32_t x251; + fiat_p256_scalar_uint1 x252; + uint32_t x253; + fiat_p256_scalar_uint1 x254; + uint32_t x255; + uint32_t x256; + fiat_p256_scalar_uint1 x257; + uint32_t x258; + fiat_p256_scalar_uint1 x259; + uint32_t x260; + fiat_p256_scalar_uint1 x261; + uint32_t x262; + fiat_p256_scalar_uint1 x263; + uint32_t x264; + fiat_p256_scalar_uint1 x265; + uint32_t x266; + fiat_p256_scalar_uint1 x267; + uint32_t x268; + fiat_p256_scalar_uint1 x269; + uint32_t x270; + fiat_p256_scalar_uint1 x271; + uint32_t x272; + fiat_p256_scalar_uint1 x273; + uint32_t x274; + uint32_t x275; + uint32_t x276; + uint32_t x277; + uint32_t x278; + uint32_t x279; + uint32_t x280; + uint32_t x281; + uint32_t x282; + uint32_t x283; + uint32_t x284; + uint32_t x285; + uint32_t x286; + uint32_t x287; + uint32_t x288; + uint32_t x289; + uint32_t x290; + uint32_t x291; + fiat_p256_scalar_uint1 x292; + uint32_t x293; + fiat_p256_scalar_uint1 x294; + uint32_t x295; + fiat_p256_scalar_uint1 x296; + uint32_t x297; + fiat_p256_scalar_uint1 x298; + uint32_t x299; + fiat_p256_scalar_uint1 x300; + uint32_t x301; + fiat_p256_scalar_uint1 x302; + uint32_t x303; + fiat_p256_scalar_uint1 x304; + uint32_t x305; + uint32_t x306; + fiat_p256_scalar_uint1 x307; + uint32_t x308; + fiat_p256_scalar_uint1 x309; + uint32_t x310; + fiat_p256_scalar_uint1 x311; + uint32_t x312; + fiat_p256_scalar_uint1 x313; + uint32_t x314; + fiat_p256_scalar_uint1 x315; + uint32_t x316; + fiat_p256_scalar_uint1 x317; + uint32_t x318; + fiat_p256_scalar_uint1 x319; + uint32_t x320; + fiat_p256_scalar_uint1 x321; + uint32_t x322; + fiat_p256_scalar_uint1 x323; + uint32_t x324; + uint32_t x325; + uint32_t x326; + uint32_t x327; + uint32_t x328; + uint32_t x329; + uint32_t x330; + uint32_t x331; + uint32_t x332; + uint32_t x333; + uint32_t x334; + uint32_t x335; + uint32_t x336; + uint32_t x337; + uint32_t x338; + uint32_t x339; + uint32_t x340; + fiat_p256_scalar_uint1 x341; + uint32_t x342; + fiat_p256_scalar_uint1 x343; + uint32_t x344; + fiat_p256_scalar_uint1 x345; + uint32_t x346; + fiat_p256_scalar_uint1 x347; + uint32_t x348; + fiat_p256_scalar_uint1 x349; + uint32_t x350; + uint32_t x351; + fiat_p256_scalar_uint1 x352; + uint32_t x353; + fiat_p256_scalar_uint1 x354; + uint32_t x355; + fiat_p256_scalar_uint1 x356; + uint32_t x357; + fiat_p256_scalar_uint1 x358; + uint32_t x359; + fiat_p256_scalar_uint1 x360; + uint32_t x361; + fiat_p256_scalar_uint1 x362; + uint32_t x363; + fiat_p256_scalar_uint1 x364; + uint32_t x365; + fiat_p256_scalar_uint1 x366; + uint32_t x367; + fiat_p256_scalar_uint1 x368; + uint32_t x369; + uint32_t x370; + uint32_t x371; + uint32_t x372; + uint32_t x373; + uint32_t x374; + uint32_t x375; + uint32_t x376; + uint32_t x377; + uint32_t x378; + uint32_t x379; + uint32_t x380; + uint32_t x381; + uint32_t x382; + uint32_t x383; + uint32_t x384; + uint32_t x385; + uint32_t x386; + fiat_p256_scalar_uint1 x387; + uint32_t x388; + fiat_p256_scalar_uint1 x389; + uint32_t x390; + fiat_p256_scalar_uint1 x391; + uint32_t x392; + fiat_p256_scalar_uint1 x393; + uint32_t x394; + fiat_p256_scalar_uint1 x395; + uint32_t x396; + fiat_p256_scalar_uint1 x397; + uint32_t x398; + fiat_p256_scalar_uint1 x399; + uint32_t x400; + uint32_t x401; + fiat_p256_scalar_uint1 x402; + uint32_t x403; + fiat_p256_scalar_uint1 x404; + uint32_t x405; + fiat_p256_scalar_uint1 x406; + uint32_t x407; + fiat_p256_scalar_uint1 x408; + uint32_t x409; + fiat_p256_scalar_uint1 x410; + uint32_t x411; + fiat_p256_scalar_uint1 x412; + uint32_t x413; + fiat_p256_scalar_uint1 x414; + uint32_t x415; + fiat_p256_scalar_uint1 x416; + uint32_t x417; + fiat_p256_scalar_uint1 x418; + uint32_t x419; + uint32_t x420; + uint32_t x421; + uint32_t x422; + uint32_t x423; + uint32_t x424; + uint32_t x425; + uint32_t x426; + uint32_t x427; + uint32_t x428; + uint32_t x429; + uint32_t x430; + uint32_t x431; + uint32_t x432; + uint32_t x433; + uint32_t x434; + uint32_t x435; + fiat_p256_scalar_uint1 x436; + uint32_t x437; + fiat_p256_scalar_uint1 x438; + uint32_t x439; + fiat_p256_scalar_uint1 x440; + uint32_t x441; + fiat_p256_scalar_uint1 x442; + uint32_t x443; + fiat_p256_scalar_uint1 x444; + uint32_t x445; + uint32_t x446; + fiat_p256_scalar_uint1 x447; + uint32_t x448; + fiat_p256_scalar_uint1 x449; + uint32_t x450; + fiat_p256_scalar_uint1 x451; + uint32_t x452; + fiat_p256_scalar_uint1 x453; + uint32_t x454; + fiat_p256_scalar_uint1 x455; + uint32_t x456; + fiat_p256_scalar_uint1 x457; + uint32_t x458; + fiat_p256_scalar_uint1 x459; + uint32_t x460; + fiat_p256_scalar_uint1 x461; + uint32_t x462; + fiat_p256_scalar_uint1 x463; + uint32_t x464; + uint32_t x465; + uint32_t x466; + uint32_t x467; + uint32_t x468; + uint32_t x469; + uint32_t x470; + uint32_t x471; + uint32_t x472; + uint32_t x473; + uint32_t x474; + uint32_t x475; + uint32_t x476; + uint32_t x477; + uint32_t x478; + uint32_t x479; + uint32_t x480; + uint32_t x481; + fiat_p256_scalar_uint1 x482; + uint32_t x483; + fiat_p256_scalar_uint1 x484; + uint32_t x485; + fiat_p256_scalar_uint1 x486; + uint32_t x487; + fiat_p256_scalar_uint1 x488; + uint32_t x489; + fiat_p256_scalar_uint1 x490; + uint32_t x491; + fiat_p256_scalar_uint1 x492; + uint32_t x493; + fiat_p256_scalar_uint1 x494; + uint32_t x495; + uint32_t x496; + fiat_p256_scalar_uint1 x497; + uint32_t x498; + fiat_p256_scalar_uint1 x499; + uint32_t x500; + fiat_p256_scalar_uint1 x501; + uint32_t x502; + fiat_p256_scalar_uint1 x503; + uint32_t x504; + fiat_p256_scalar_uint1 x505; + uint32_t x506; + fiat_p256_scalar_uint1 x507; + uint32_t x508; + fiat_p256_scalar_uint1 x509; + uint32_t x510; + fiat_p256_scalar_uint1 x511; + uint32_t x512; + fiat_p256_scalar_uint1 x513; + uint32_t x514; + uint32_t x515; + uint32_t x516; + uint32_t x517; + uint32_t x518; + uint32_t x519; + uint32_t x520; + uint32_t x521; + uint32_t x522; + uint32_t x523; + uint32_t x524; + uint32_t x525; + uint32_t x526; + uint32_t x527; + uint32_t x528; + uint32_t x529; + uint32_t x530; + fiat_p256_scalar_uint1 x531; + uint32_t x532; + fiat_p256_scalar_uint1 x533; + uint32_t x534; + fiat_p256_scalar_uint1 x535; + uint32_t x536; + fiat_p256_scalar_uint1 x537; + uint32_t x538; + fiat_p256_scalar_uint1 x539; + uint32_t x540; + uint32_t x541; + fiat_p256_scalar_uint1 x542; + uint32_t x543; + fiat_p256_scalar_uint1 x544; + uint32_t x545; + fiat_p256_scalar_uint1 x546; + uint32_t x547; + fiat_p256_scalar_uint1 x548; + uint32_t x549; + fiat_p256_scalar_uint1 x550; + uint32_t x551; + fiat_p256_scalar_uint1 x552; + uint32_t x553; + fiat_p256_scalar_uint1 x554; + uint32_t x555; + fiat_p256_scalar_uint1 x556; + uint32_t x557; + fiat_p256_scalar_uint1 x558; + uint32_t x559; + uint32_t x560; + uint32_t x561; + uint32_t x562; + uint32_t x563; + uint32_t x564; + uint32_t x565; + uint32_t x566; + uint32_t x567; + uint32_t x568; + uint32_t x569; + uint32_t x570; + uint32_t x571; + uint32_t x572; + uint32_t x573; + uint32_t x574; + uint32_t x575; + uint32_t x576; + fiat_p256_scalar_uint1 x577; + uint32_t x578; + fiat_p256_scalar_uint1 x579; + uint32_t x580; + fiat_p256_scalar_uint1 x581; + uint32_t x582; + fiat_p256_scalar_uint1 x583; + uint32_t x584; + fiat_p256_scalar_uint1 x585; + uint32_t x586; + fiat_p256_scalar_uint1 x587; + uint32_t x588; + fiat_p256_scalar_uint1 x589; + uint32_t x590; + uint32_t x591; + fiat_p256_scalar_uint1 x592; + uint32_t x593; + fiat_p256_scalar_uint1 x594; + uint32_t x595; + fiat_p256_scalar_uint1 x596; + uint32_t x597; + fiat_p256_scalar_uint1 x598; + uint32_t x599; + fiat_p256_scalar_uint1 x600; + uint32_t x601; + fiat_p256_scalar_uint1 x602; + uint32_t x603; + fiat_p256_scalar_uint1 x604; + uint32_t x605; + fiat_p256_scalar_uint1 x606; + uint32_t x607; + fiat_p256_scalar_uint1 x608; + uint32_t x609; + uint32_t x610; + uint32_t x611; + uint32_t x612; + uint32_t x613; + uint32_t x614; + uint32_t x615; + uint32_t x616; + uint32_t x617; + uint32_t x618; + uint32_t x619; + uint32_t x620; + uint32_t x621; + uint32_t x622; + uint32_t x623; + uint32_t x624; + uint32_t x625; + fiat_p256_scalar_uint1 x626; + uint32_t x627; + fiat_p256_scalar_uint1 x628; + uint32_t x629; + fiat_p256_scalar_uint1 x630; + uint32_t x631; + fiat_p256_scalar_uint1 x632; + uint32_t x633; + fiat_p256_scalar_uint1 x634; + uint32_t x635; + uint32_t x636; + fiat_p256_scalar_uint1 x637; + uint32_t x638; + fiat_p256_scalar_uint1 x639; + uint32_t x640; + fiat_p256_scalar_uint1 x641; + uint32_t x642; + fiat_p256_scalar_uint1 x643; + uint32_t x644; + fiat_p256_scalar_uint1 x645; + uint32_t x646; + fiat_p256_scalar_uint1 x647; + uint32_t x648; + fiat_p256_scalar_uint1 x649; + uint32_t x650; + fiat_p256_scalar_uint1 x651; + uint32_t x652; + fiat_p256_scalar_uint1 x653; + uint32_t x654; + uint32_t x655; + uint32_t x656; + uint32_t x657; + uint32_t x658; + uint32_t x659; + uint32_t x660; + uint32_t x661; + uint32_t x662; + uint32_t x663; + uint32_t x664; + uint32_t x665; + uint32_t x666; + uint32_t x667; + uint32_t x668; + uint32_t x669; + uint32_t x670; + uint32_t x671; + fiat_p256_scalar_uint1 x672; + uint32_t x673; + fiat_p256_scalar_uint1 x674; + uint32_t x675; + fiat_p256_scalar_uint1 x676; + uint32_t x677; + fiat_p256_scalar_uint1 x678; + uint32_t x679; + fiat_p256_scalar_uint1 x680; + uint32_t x681; + fiat_p256_scalar_uint1 x682; + uint32_t x683; + fiat_p256_scalar_uint1 x684; + uint32_t x685; + uint32_t x686; + fiat_p256_scalar_uint1 x687; + uint32_t x688; + fiat_p256_scalar_uint1 x689; + uint32_t x690; + fiat_p256_scalar_uint1 x691; + uint32_t x692; + fiat_p256_scalar_uint1 x693; + uint32_t x694; + fiat_p256_scalar_uint1 x695; + uint32_t x696; + fiat_p256_scalar_uint1 x697; + uint32_t x698; + fiat_p256_scalar_uint1 x699; + uint32_t x700; + fiat_p256_scalar_uint1 x701; + uint32_t x702; + fiat_p256_scalar_uint1 x703; + uint32_t x704; + uint32_t x705; + uint32_t x706; + uint32_t x707; + uint32_t x708; + uint32_t x709; + uint32_t x710; + uint32_t x711; + uint32_t x712; + uint32_t x713; + uint32_t x714; + uint32_t x715; + uint32_t x716; + uint32_t x717; + uint32_t x718; + uint32_t x719; + uint32_t x720; + fiat_p256_scalar_uint1 x721; + uint32_t x722; + fiat_p256_scalar_uint1 x723; + uint32_t x724; + fiat_p256_scalar_uint1 x725; + uint32_t x726; + fiat_p256_scalar_uint1 x727; + uint32_t x728; + fiat_p256_scalar_uint1 x729; + uint32_t x730; + uint32_t x731; + fiat_p256_scalar_uint1 x732; + uint32_t x733; + fiat_p256_scalar_uint1 x734; + uint32_t x735; + fiat_p256_scalar_uint1 x736; + uint32_t x737; + fiat_p256_scalar_uint1 x738; + uint32_t x739; + fiat_p256_scalar_uint1 x740; + uint32_t x741; + fiat_p256_scalar_uint1 x742; + uint32_t x743; + fiat_p256_scalar_uint1 x744; + uint32_t x745; + fiat_p256_scalar_uint1 x746; + uint32_t x747; + fiat_p256_scalar_uint1 x748; + uint32_t x749; + uint32_t x750; + fiat_p256_scalar_uint1 x751; + uint32_t x752; + fiat_p256_scalar_uint1 x753; + uint32_t x754; + fiat_p256_scalar_uint1 x755; + uint32_t x756; + fiat_p256_scalar_uint1 x757; + uint32_t x758; + fiat_p256_scalar_uint1 x759; + uint32_t x760; + fiat_p256_scalar_uint1 x761; + uint32_t x762; + fiat_p256_scalar_uint1 x763; + uint32_t x764; + fiat_p256_scalar_uint1 x765; + uint32_t x766; + fiat_p256_scalar_uint1 x767; + uint32_t x768; + uint32_t x769; + uint32_t x770; + uint32_t x771; + uint32_t x772; + uint32_t x773; + uint32_t x774; + uint32_t x775; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[6]); + x7 = (arg1[7]); + x8 = (arg1[0]); + fiat_p256_scalar_mulx_u32(&x9, &x10, x8, (arg2[7])); + fiat_p256_scalar_mulx_u32(&x11, &x12, x8, (arg2[6])); + fiat_p256_scalar_mulx_u32(&x13, &x14, x8, (arg2[5])); + fiat_p256_scalar_mulx_u32(&x15, &x16, x8, (arg2[4])); + fiat_p256_scalar_mulx_u32(&x17, &x18, x8, (arg2[3])); + fiat_p256_scalar_mulx_u32(&x19, &x20, x8, (arg2[2])); + fiat_p256_scalar_mulx_u32(&x21, &x22, x8, (arg2[1])); + fiat_p256_scalar_mulx_u32(&x23, &x24, x8, (arg2[0])); + fiat_p256_scalar_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_p256_scalar_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_p256_scalar_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_p256_scalar_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_p256_scalar_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_p256_scalar_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_p256_scalar_addcarryx_u32(&x37, &x38, x36, x12, x9); + x39 = (x38 + x10); + fiat_p256_scalar_mulx_u32(&x40, &x41, x23, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x42, &x43, x40, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x44, &x45, x40, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x46, &x47, x40, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x48, &x49, x40, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x50, &x51, x40, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x52, &x53, x40, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x54, &x55, x40, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x56, &x57, 0x0, x55, x52); + fiat_p256_scalar_addcarryx_u32(&x58, &x59, x57, x53, x50); + fiat_p256_scalar_addcarryx_u32(&x60, &x61, x59, x51, x48); + fiat_p256_scalar_addcarryx_u32(&x62, &x63, x61, x49, x46); + fiat_p256_scalar_addcarryx_u32(&x64, &x65, x63, x47, x44); + x66 = (x65 + x45); + fiat_p256_scalar_addcarryx_u32(&x67, &x68, 0x0, x23, x54); + fiat_p256_scalar_addcarryx_u32(&x69, &x70, x68, x25, x56); + fiat_p256_scalar_addcarryx_u32(&x71, &x72, x70, x27, x58); + fiat_p256_scalar_addcarryx_u32(&x73, &x74, x72, x29, x60); + fiat_p256_scalar_addcarryx_u32(&x75, &x76, x74, x31, x62); + fiat_p256_scalar_addcarryx_u32(&x77, &x78, x76, x33, x64); + fiat_p256_scalar_addcarryx_u32(&x79, &x80, x78, x35, x66); + fiat_p256_scalar_addcarryx_u32(&x81, &x82, x80, x37, x42); + fiat_p256_scalar_addcarryx_u32(&x83, &x84, x82, x39, x43); + fiat_p256_scalar_mulx_u32(&x85, &x86, x1, (arg2[7])); + fiat_p256_scalar_mulx_u32(&x87, &x88, x1, (arg2[6])); + fiat_p256_scalar_mulx_u32(&x89, &x90, x1, (arg2[5])); + fiat_p256_scalar_mulx_u32(&x91, &x92, x1, (arg2[4])); + fiat_p256_scalar_mulx_u32(&x93, &x94, x1, (arg2[3])); + fiat_p256_scalar_mulx_u32(&x95, &x96, x1, (arg2[2])); + fiat_p256_scalar_mulx_u32(&x97, &x98, x1, (arg2[1])); + fiat_p256_scalar_mulx_u32(&x99, &x100, x1, (arg2[0])); + fiat_p256_scalar_addcarryx_u32(&x101, &x102, 0x0, x100, x97); + fiat_p256_scalar_addcarryx_u32(&x103, &x104, x102, x98, x95); + fiat_p256_scalar_addcarryx_u32(&x105, &x106, x104, x96, x93); + fiat_p256_scalar_addcarryx_u32(&x107, &x108, x106, x94, x91); + fiat_p256_scalar_addcarryx_u32(&x109, &x110, x108, x92, x89); + fiat_p256_scalar_addcarryx_u32(&x111, &x112, x110, x90, x87); + fiat_p256_scalar_addcarryx_u32(&x113, &x114, x112, x88, x85); + x115 = (x114 + x86); + fiat_p256_scalar_addcarryx_u32(&x116, &x117, 0x0, x69, x99); + fiat_p256_scalar_addcarryx_u32(&x118, &x119, x117, x71, x101); + fiat_p256_scalar_addcarryx_u32(&x120, &x121, x119, x73, x103); + fiat_p256_scalar_addcarryx_u32(&x122, &x123, x121, x75, x105); + fiat_p256_scalar_addcarryx_u32(&x124, &x125, x123, x77, x107); + fiat_p256_scalar_addcarryx_u32(&x126, &x127, x125, x79, x109); + fiat_p256_scalar_addcarryx_u32(&x128, &x129, x127, x81, x111); + fiat_p256_scalar_addcarryx_u32(&x130, &x131, x129, x83, x113); + fiat_p256_scalar_addcarryx_u32(&x132, &x133, x131, x84, x115); + fiat_p256_scalar_mulx_u32(&x134, &x135, x116, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x136, &x137, x134, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x138, &x139, x134, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x140, &x141, x134, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x142, &x143, x134, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x144, &x145, x134, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x146, &x147, x134, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x148, &x149, x134, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x150, &x151, 0x0, x149, x146); + fiat_p256_scalar_addcarryx_u32(&x152, &x153, x151, x147, x144); + fiat_p256_scalar_addcarryx_u32(&x154, &x155, x153, x145, x142); + fiat_p256_scalar_addcarryx_u32(&x156, &x157, x155, x143, x140); + fiat_p256_scalar_addcarryx_u32(&x158, &x159, x157, x141, x138); + x160 = (x159 + x139); + fiat_p256_scalar_addcarryx_u32(&x161, &x162, 0x0, x116, x148); + fiat_p256_scalar_addcarryx_u32(&x163, &x164, x162, x118, x150); + fiat_p256_scalar_addcarryx_u32(&x165, &x166, x164, x120, x152); + fiat_p256_scalar_addcarryx_u32(&x167, &x168, x166, x122, x154); + fiat_p256_scalar_addcarryx_u32(&x169, &x170, x168, x124, x156); + fiat_p256_scalar_addcarryx_u32(&x171, &x172, x170, x126, x158); + fiat_p256_scalar_addcarryx_u32(&x173, &x174, x172, x128, x160); + fiat_p256_scalar_addcarryx_u32(&x175, &x176, x174, x130, x136); + fiat_p256_scalar_addcarryx_u32(&x177, &x178, x176, x132, x137); + x179 = ((uint32_t)x178 + x133); + fiat_p256_scalar_mulx_u32(&x180, &x181, x2, (arg2[7])); + fiat_p256_scalar_mulx_u32(&x182, &x183, x2, (arg2[6])); + fiat_p256_scalar_mulx_u32(&x184, &x185, x2, (arg2[5])); + fiat_p256_scalar_mulx_u32(&x186, &x187, x2, (arg2[4])); + fiat_p256_scalar_mulx_u32(&x188, &x189, x2, (arg2[3])); + fiat_p256_scalar_mulx_u32(&x190, &x191, x2, (arg2[2])); + fiat_p256_scalar_mulx_u32(&x192, &x193, x2, (arg2[1])); + fiat_p256_scalar_mulx_u32(&x194, &x195, x2, (arg2[0])); + fiat_p256_scalar_addcarryx_u32(&x196, &x197, 0x0, x195, x192); + fiat_p256_scalar_addcarryx_u32(&x198, &x199, x197, x193, x190); + fiat_p256_scalar_addcarryx_u32(&x200, &x201, x199, x191, x188); + fiat_p256_scalar_addcarryx_u32(&x202, &x203, x201, x189, x186); + fiat_p256_scalar_addcarryx_u32(&x204, &x205, x203, x187, x184); + fiat_p256_scalar_addcarryx_u32(&x206, &x207, x205, x185, x182); + fiat_p256_scalar_addcarryx_u32(&x208, &x209, x207, x183, x180); + x210 = (x209 + x181); + fiat_p256_scalar_addcarryx_u32(&x211, &x212, 0x0, x163, x194); + fiat_p256_scalar_addcarryx_u32(&x213, &x214, x212, x165, x196); + fiat_p256_scalar_addcarryx_u32(&x215, &x216, x214, x167, x198); + fiat_p256_scalar_addcarryx_u32(&x217, &x218, x216, x169, x200); + fiat_p256_scalar_addcarryx_u32(&x219, &x220, x218, x171, x202); + fiat_p256_scalar_addcarryx_u32(&x221, &x222, x220, x173, x204); + fiat_p256_scalar_addcarryx_u32(&x223, &x224, x222, x175, x206); + fiat_p256_scalar_addcarryx_u32(&x225, &x226, x224, x177, x208); + fiat_p256_scalar_addcarryx_u32(&x227, &x228, x226, x179, x210); + fiat_p256_scalar_mulx_u32(&x229, &x230, x211, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x231, &x232, x229, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x233, &x234, x229, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x235, &x236, x229, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x237, &x238, x229, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x239, &x240, x229, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x241, &x242, x229, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x243, &x244, x229, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x245, &x246, 0x0, x244, x241); + fiat_p256_scalar_addcarryx_u32(&x247, &x248, x246, x242, x239); + fiat_p256_scalar_addcarryx_u32(&x249, &x250, x248, x240, x237); + fiat_p256_scalar_addcarryx_u32(&x251, &x252, x250, x238, x235); + fiat_p256_scalar_addcarryx_u32(&x253, &x254, x252, x236, x233); + x255 = (x254 + x234); + fiat_p256_scalar_addcarryx_u32(&x256, &x257, 0x0, x211, x243); + fiat_p256_scalar_addcarryx_u32(&x258, &x259, x257, x213, x245); + fiat_p256_scalar_addcarryx_u32(&x260, &x261, x259, x215, x247); + fiat_p256_scalar_addcarryx_u32(&x262, &x263, x261, x217, x249); + fiat_p256_scalar_addcarryx_u32(&x264, &x265, x263, x219, x251); + fiat_p256_scalar_addcarryx_u32(&x266, &x267, x265, x221, x253); + fiat_p256_scalar_addcarryx_u32(&x268, &x269, x267, x223, x255); + fiat_p256_scalar_addcarryx_u32(&x270, &x271, x269, x225, x231); + fiat_p256_scalar_addcarryx_u32(&x272, &x273, x271, x227, x232); + x274 = ((uint32_t)x273 + x228); + fiat_p256_scalar_mulx_u32(&x275, &x276, x3, (arg2[7])); + fiat_p256_scalar_mulx_u32(&x277, &x278, x3, (arg2[6])); + fiat_p256_scalar_mulx_u32(&x279, &x280, x3, (arg2[5])); + fiat_p256_scalar_mulx_u32(&x281, &x282, x3, (arg2[4])); + fiat_p256_scalar_mulx_u32(&x283, &x284, x3, (arg2[3])); + fiat_p256_scalar_mulx_u32(&x285, &x286, x3, (arg2[2])); + fiat_p256_scalar_mulx_u32(&x287, &x288, x3, (arg2[1])); + fiat_p256_scalar_mulx_u32(&x289, &x290, x3, (arg2[0])); + fiat_p256_scalar_addcarryx_u32(&x291, &x292, 0x0, x290, x287); + fiat_p256_scalar_addcarryx_u32(&x293, &x294, x292, x288, x285); + fiat_p256_scalar_addcarryx_u32(&x295, &x296, x294, x286, x283); + fiat_p256_scalar_addcarryx_u32(&x297, &x298, x296, x284, x281); + fiat_p256_scalar_addcarryx_u32(&x299, &x300, x298, x282, x279); + fiat_p256_scalar_addcarryx_u32(&x301, &x302, x300, x280, x277); + fiat_p256_scalar_addcarryx_u32(&x303, &x304, x302, x278, x275); + x305 = (x304 + x276); + fiat_p256_scalar_addcarryx_u32(&x306, &x307, 0x0, x258, x289); + fiat_p256_scalar_addcarryx_u32(&x308, &x309, x307, x260, x291); + fiat_p256_scalar_addcarryx_u32(&x310, &x311, x309, x262, x293); + fiat_p256_scalar_addcarryx_u32(&x312, &x313, x311, x264, x295); + fiat_p256_scalar_addcarryx_u32(&x314, &x315, x313, x266, x297); + fiat_p256_scalar_addcarryx_u32(&x316, &x317, x315, x268, x299); + fiat_p256_scalar_addcarryx_u32(&x318, &x319, x317, x270, x301); + fiat_p256_scalar_addcarryx_u32(&x320, &x321, x319, x272, x303); + fiat_p256_scalar_addcarryx_u32(&x322, &x323, x321, x274, x305); + fiat_p256_scalar_mulx_u32(&x324, &x325, x306, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x326, &x327, x324, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x328, &x329, x324, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x330, &x331, x324, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x332, &x333, x324, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x334, &x335, x324, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x336, &x337, x324, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x338, &x339, x324, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x340, &x341, 0x0, x339, x336); + fiat_p256_scalar_addcarryx_u32(&x342, &x343, x341, x337, x334); + fiat_p256_scalar_addcarryx_u32(&x344, &x345, x343, x335, x332); + fiat_p256_scalar_addcarryx_u32(&x346, &x347, x345, x333, x330); + fiat_p256_scalar_addcarryx_u32(&x348, &x349, x347, x331, x328); + x350 = (x349 + x329); + fiat_p256_scalar_addcarryx_u32(&x351, &x352, 0x0, x306, x338); + fiat_p256_scalar_addcarryx_u32(&x353, &x354, x352, x308, x340); + fiat_p256_scalar_addcarryx_u32(&x355, &x356, x354, x310, x342); + fiat_p256_scalar_addcarryx_u32(&x357, &x358, x356, x312, x344); + fiat_p256_scalar_addcarryx_u32(&x359, &x360, x358, x314, x346); + fiat_p256_scalar_addcarryx_u32(&x361, &x362, x360, x316, x348); + fiat_p256_scalar_addcarryx_u32(&x363, &x364, x362, x318, x350); + fiat_p256_scalar_addcarryx_u32(&x365, &x366, x364, x320, x326); + fiat_p256_scalar_addcarryx_u32(&x367, &x368, x366, x322, x327); + x369 = ((uint32_t)x368 + x323); + fiat_p256_scalar_mulx_u32(&x370, &x371, x4, (arg2[7])); + fiat_p256_scalar_mulx_u32(&x372, &x373, x4, (arg2[6])); + fiat_p256_scalar_mulx_u32(&x374, &x375, x4, (arg2[5])); + fiat_p256_scalar_mulx_u32(&x376, &x377, x4, (arg2[4])); + fiat_p256_scalar_mulx_u32(&x378, &x379, x4, (arg2[3])); + fiat_p256_scalar_mulx_u32(&x380, &x381, x4, (arg2[2])); + fiat_p256_scalar_mulx_u32(&x382, &x383, x4, (arg2[1])); + fiat_p256_scalar_mulx_u32(&x384, &x385, x4, (arg2[0])); + fiat_p256_scalar_addcarryx_u32(&x386, &x387, 0x0, x385, x382); + fiat_p256_scalar_addcarryx_u32(&x388, &x389, x387, x383, x380); + fiat_p256_scalar_addcarryx_u32(&x390, &x391, x389, x381, x378); + fiat_p256_scalar_addcarryx_u32(&x392, &x393, x391, x379, x376); + fiat_p256_scalar_addcarryx_u32(&x394, &x395, x393, x377, x374); + fiat_p256_scalar_addcarryx_u32(&x396, &x397, x395, x375, x372); + fiat_p256_scalar_addcarryx_u32(&x398, &x399, x397, x373, x370); + x400 = (x399 + x371); + fiat_p256_scalar_addcarryx_u32(&x401, &x402, 0x0, x353, x384); + fiat_p256_scalar_addcarryx_u32(&x403, &x404, x402, x355, x386); + fiat_p256_scalar_addcarryx_u32(&x405, &x406, x404, x357, x388); + fiat_p256_scalar_addcarryx_u32(&x407, &x408, x406, x359, x390); + fiat_p256_scalar_addcarryx_u32(&x409, &x410, x408, x361, x392); + fiat_p256_scalar_addcarryx_u32(&x411, &x412, x410, x363, x394); + fiat_p256_scalar_addcarryx_u32(&x413, &x414, x412, x365, x396); + fiat_p256_scalar_addcarryx_u32(&x415, &x416, x414, x367, x398); + fiat_p256_scalar_addcarryx_u32(&x417, &x418, x416, x369, x400); + fiat_p256_scalar_mulx_u32(&x419, &x420, x401, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x421, &x422, x419, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x423, &x424, x419, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x425, &x426, x419, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x427, &x428, x419, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x429, &x430, x419, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x431, &x432, x419, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x433, &x434, x419, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x435, &x436, 0x0, x434, x431); + fiat_p256_scalar_addcarryx_u32(&x437, &x438, x436, x432, x429); + fiat_p256_scalar_addcarryx_u32(&x439, &x440, x438, x430, x427); + fiat_p256_scalar_addcarryx_u32(&x441, &x442, x440, x428, x425); + fiat_p256_scalar_addcarryx_u32(&x443, &x444, x442, x426, x423); + x445 = (x444 + x424); + fiat_p256_scalar_addcarryx_u32(&x446, &x447, 0x0, x401, x433); + fiat_p256_scalar_addcarryx_u32(&x448, &x449, x447, x403, x435); + fiat_p256_scalar_addcarryx_u32(&x450, &x451, x449, x405, x437); + fiat_p256_scalar_addcarryx_u32(&x452, &x453, x451, x407, x439); + fiat_p256_scalar_addcarryx_u32(&x454, &x455, x453, x409, x441); + fiat_p256_scalar_addcarryx_u32(&x456, &x457, x455, x411, x443); + fiat_p256_scalar_addcarryx_u32(&x458, &x459, x457, x413, x445); + fiat_p256_scalar_addcarryx_u32(&x460, &x461, x459, x415, x421); + fiat_p256_scalar_addcarryx_u32(&x462, &x463, x461, x417, x422); + x464 = ((uint32_t)x463 + x418); + fiat_p256_scalar_mulx_u32(&x465, &x466, x5, (arg2[7])); + fiat_p256_scalar_mulx_u32(&x467, &x468, x5, (arg2[6])); + fiat_p256_scalar_mulx_u32(&x469, &x470, x5, (arg2[5])); + fiat_p256_scalar_mulx_u32(&x471, &x472, x5, (arg2[4])); + fiat_p256_scalar_mulx_u32(&x473, &x474, x5, (arg2[3])); + fiat_p256_scalar_mulx_u32(&x475, &x476, x5, (arg2[2])); + fiat_p256_scalar_mulx_u32(&x477, &x478, x5, (arg2[1])); + fiat_p256_scalar_mulx_u32(&x479, &x480, x5, (arg2[0])); + fiat_p256_scalar_addcarryx_u32(&x481, &x482, 0x0, x480, x477); + fiat_p256_scalar_addcarryx_u32(&x483, &x484, x482, x478, x475); + fiat_p256_scalar_addcarryx_u32(&x485, &x486, x484, x476, x473); + fiat_p256_scalar_addcarryx_u32(&x487, &x488, x486, x474, x471); + fiat_p256_scalar_addcarryx_u32(&x489, &x490, x488, x472, x469); + fiat_p256_scalar_addcarryx_u32(&x491, &x492, x490, x470, x467); + fiat_p256_scalar_addcarryx_u32(&x493, &x494, x492, x468, x465); + x495 = (x494 + x466); + fiat_p256_scalar_addcarryx_u32(&x496, &x497, 0x0, x448, x479); + fiat_p256_scalar_addcarryx_u32(&x498, &x499, x497, x450, x481); + fiat_p256_scalar_addcarryx_u32(&x500, &x501, x499, x452, x483); + fiat_p256_scalar_addcarryx_u32(&x502, &x503, x501, x454, x485); + fiat_p256_scalar_addcarryx_u32(&x504, &x505, x503, x456, x487); + fiat_p256_scalar_addcarryx_u32(&x506, &x507, x505, x458, x489); + fiat_p256_scalar_addcarryx_u32(&x508, &x509, x507, x460, x491); + fiat_p256_scalar_addcarryx_u32(&x510, &x511, x509, x462, x493); + fiat_p256_scalar_addcarryx_u32(&x512, &x513, x511, x464, x495); + fiat_p256_scalar_mulx_u32(&x514, &x515, x496, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x516, &x517, x514, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x518, &x519, x514, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x520, &x521, x514, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x522, &x523, x514, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x524, &x525, x514, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x526, &x527, x514, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x528, &x529, x514, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x530, &x531, 0x0, x529, x526); + fiat_p256_scalar_addcarryx_u32(&x532, &x533, x531, x527, x524); + fiat_p256_scalar_addcarryx_u32(&x534, &x535, x533, x525, x522); + fiat_p256_scalar_addcarryx_u32(&x536, &x537, x535, x523, x520); + fiat_p256_scalar_addcarryx_u32(&x538, &x539, x537, x521, x518); + x540 = (x539 + x519); + fiat_p256_scalar_addcarryx_u32(&x541, &x542, 0x0, x496, x528); + fiat_p256_scalar_addcarryx_u32(&x543, &x544, x542, x498, x530); + fiat_p256_scalar_addcarryx_u32(&x545, &x546, x544, x500, x532); + fiat_p256_scalar_addcarryx_u32(&x547, &x548, x546, x502, x534); + fiat_p256_scalar_addcarryx_u32(&x549, &x550, x548, x504, x536); + fiat_p256_scalar_addcarryx_u32(&x551, &x552, x550, x506, x538); + fiat_p256_scalar_addcarryx_u32(&x553, &x554, x552, x508, x540); + fiat_p256_scalar_addcarryx_u32(&x555, &x556, x554, x510, x516); + fiat_p256_scalar_addcarryx_u32(&x557, &x558, x556, x512, x517); + x559 = ((uint32_t)x558 + x513); + fiat_p256_scalar_mulx_u32(&x560, &x561, x6, (arg2[7])); + fiat_p256_scalar_mulx_u32(&x562, &x563, x6, (arg2[6])); + fiat_p256_scalar_mulx_u32(&x564, &x565, x6, (arg2[5])); + fiat_p256_scalar_mulx_u32(&x566, &x567, x6, (arg2[4])); + fiat_p256_scalar_mulx_u32(&x568, &x569, x6, (arg2[3])); + fiat_p256_scalar_mulx_u32(&x570, &x571, x6, (arg2[2])); + fiat_p256_scalar_mulx_u32(&x572, &x573, x6, (arg2[1])); + fiat_p256_scalar_mulx_u32(&x574, &x575, x6, (arg2[0])); + fiat_p256_scalar_addcarryx_u32(&x576, &x577, 0x0, x575, x572); + fiat_p256_scalar_addcarryx_u32(&x578, &x579, x577, x573, x570); + fiat_p256_scalar_addcarryx_u32(&x580, &x581, x579, x571, x568); + fiat_p256_scalar_addcarryx_u32(&x582, &x583, x581, x569, x566); + fiat_p256_scalar_addcarryx_u32(&x584, &x585, x583, x567, x564); + fiat_p256_scalar_addcarryx_u32(&x586, &x587, x585, x565, x562); + fiat_p256_scalar_addcarryx_u32(&x588, &x589, x587, x563, x560); + x590 = (x589 + x561); + fiat_p256_scalar_addcarryx_u32(&x591, &x592, 0x0, x543, x574); + fiat_p256_scalar_addcarryx_u32(&x593, &x594, x592, x545, x576); + fiat_p256_scalar_addcarryx_u32(&x595, &x596, x594, x547, x578); + fiat_p256_scalar_addcarryx_u32(&x597, &x598, x596, x549, x580); + fiat_p256_scalar_addcarryx_u32(&x599, &x600, x598, x551, x582); + fiat_p256_scalar_addcarryx_u32(&x601, &x602, x600, x553, x584); + fiat_p256_scalar_addcarryx_u32(&x603, &x604, x602, x555, x586); + fiat_p256_scalar_addcarryx_u32(&x605, &x606, x604, x557, x588); + fiat_p256_scalar_addcarryx_u32(&x607, &x608, x606, x559, x590); + fiat_p256_scalar_mulx_u32(&x609, &x610, x591, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x611, &x612, x609, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x613, &x614, x609, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x615, &x616, x609, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x617, &x618, x609, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x619, &x620, x609, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x621, &x622, x609, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x623, &x624, x609, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x625, &x626, 0x0, x624, x621); + fiat_p256_scalar_addcarryx_u32(&x627, &x628, x626, x622, x619); + fiat_p256_scalar_addcarryx_u32(&x629, &x630, x628, x620, x617); + fiat_p256_scalar_addcarryx_u32(&x631, &x632, x630, x618, x615); + fiat_p256_scalar_addcarryx_u32(&x633, &x634, x632, x616, x613); + x635 = (x634 + x614); + fiat_p256_scalar_addcarryx_u32(&x636, &x637, 0x0, x591, x623); + fiat_p256_scalar_addcarryx_u32(&x638, &x639, x637, x593, x625); + fiat_p256_scalar_addcarryx_u32(&x640, &x641, x639, x595, x627); + fiat_p256_scalar_addcarryx_u32(&x642, &x643, x641, x597, x629); + fiat_p256_scalar_addcarryx_u32(&x644, &x645, x643, x599, x631); + fiat_p256_scalar_addcarryx_u32(&x646, &x647, x645, x601, x633); + fiat_p256_scalar_addcarryx_u32(&x648, &x649, x647, x603, x635); + fiat_p256_scalar_addcarryx_u32(&x650, &x651, x649, x605, x611); + fiat_p256_scalar_addcarryx_u32(&x652, &x653, x651, x607, x612); + x654 = ((uint32_t)x653 + x608); + fiat_p256_scalar_mulx_u32(&x655, &x656, x7, (arg2[7])); + fiat_p256_scalar_mulx_u32(&x657, &x658, x7, (arg2[6])); + fiat_p256_scalar_mulx_u32(&x659, &x660, x7, (arg2[5])); + fiat_p256_scalar_mulx_u32(&x661, &x662, x7, (arg2[4])); + fiat_p256_scalar_mulx_u32(&x663, &x664, x7, (arg2[3])); + fiat_p256_scalar_mulx_u32(&x665, &x666, x7, (arg2[2])); + fiat_p256_scalar_mulx_u32(&x667, &x668, x7, (arg2[1])); + fiat_p256_scalar_mulx_u32(&x669, &x670, x7, (arg2[0])); + fiat_p256_scalar_addcarryx_u32(&x671, &x672, 0x0, x670, x667); + fiat_p256_scalar_addcarryx_u32(&x673, &x674, x672, x668, x665); + fiat_p256_scalar_addcarryx_u32(&x675, &x676, x674, x666, x663); + fiat_p256_scalar_addcarryx_u32(&x677, &x678, x676, x664, x661); + fiat_p256_scalar_addcarryx_u32(&x679, &x680, x678, x662, x659); + fiat_p256_scalar_addcarryx_u32(&x681, &x682, x680, x660, x657); + fiat_p256_scalar_addcarryx_u32(&x683, &x684, x682, x658, x655); + x685 = (x684 + x656); + fiat_p256_scalar_addcarryx_u32(&x686, &x687, 0x0, x638, x669); + fiat_p256_scalar_addcarryx_u32(&x688, &x689, x687, x640, x671); + fiat_p256_scalar_addcarryx_u32(&x690, &x691, x689, x642, x673); + fiat_p256_scalar_addcarryx_u32(&x692, &x693, x691, x644, x675); + fiat_p256_scalar_addcarryx_u32(&x694, &x695, x693, x646, x677); + fiat_p256_scalar_addcarryx_u32(&x696, &x697, x695, x648, x679); + fiat_p256_scalar_addcarryx_u32(&x698, &x699, x697, x650, x681); + fiat_p256_scalar_addcarryx_u32(&x700, &x701, x699, x652, x683); + fiat_p256_scalar_addcarryx_u32(&x702, &x703, x701, x654, x685); + fiat_p256_scalar_mulx_u32(&x704, &x705, x686, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x706, &x707, x704, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x708, &x709, x704, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x710, &x711, x704, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x712, &x713, x704, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x714, &x715, x704, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x716, &x717, x704, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x718, &x719, x704, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x720, &x721, 0x0, x719, x716); + fiat_p256_scalar_addcarryx_u32(&x722, &x723, x721, x717, x714); + fiat_p256_scalar_addcarryx_u32(&x724, &x725, x723, x715, x712); + fiat_p256_scalar_addcarryx_u32(&x726, &x727, x725, x713, x710); + fiat_p256_scalar_addcarryx_u32(&x728, &x729, x727, x711, x708); + x730 = (x729 + x709); + fiat_p256_scalar_addcarryx_u32(&x731, &x732, 0x0, x686, x718); + fiat_p256_scalar_addcarryx_u32(&x733, &x734, x732, x688, x720); + fiat_p256_scalar_addcarryx_u32(&x735, &x736, x734, x690, x722); + fiat_p256_scalar_addcarryx_u32(&x737, &x738, x736, x692, x724); + fiat_p256_scalar_addcarryx_u32(&x739, &x740, x738, x694, x726); + fiat_p256_scalar_addcarryx_u32(&x741, &x742, x740, x696, x728); + fiat_p256_scalar_addcarryx_u32(&x743, &x744, x742, x698, x730); + fiat_p256_scalar_addcarryx_u32(&x745, &x746, x744, x700, x706); + fiat_p256_scalar_addcarryx_u32(&x747, &x748, x746, x702, x707); + x749 = ((uint32_t)x748 + x703); + fiat_p256_scalar_subborrowx_u32(&x750, &x751, 0x0, x733, UINT32_C(0xfc632551)); + fiat_p256_scalar_subborrowx_u32(&x752, &x753, x751, x735, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_subborrowx_u32(&x754, &x755, x753, x737, UINT32_C(0xa7179e84)); + fiat_p256_scalar_subborrowx_u32(&x756, &x757, x755, x739, UINT32_C(0xbce6faad)); + fiat_p256_scalar_subborrowx_u32(&x758, &x759, x757, x741, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x760, &x761, x759, x743, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x762, &x763, x761, x745, 0x0); + fiat_p256_scalar_subborrowx_u32(&x764, &x765, x763, x747, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x766, &x767, x765, x749, 0x0); + fiat_p256_scalar_cmovznz_u32(&x768, x767, x750, x733); + fiat_p256_scalar_cmovznz_u32(&x769, x767, x752, x735); + fiat_p256_scalar_cmovznz_u32(&x770, x767, x754, x737); + fiat_p256_scalar_cmovznz_u32(&x771, x767, x756, x739); + fiat_p256_scalar_cmovznz_u32(&x772, x767, x758, x741); + fiat_p256_scalar_cmovznz_u32(&x773, x767, x760, x743); + fiat_p256_scalar_cmovznz_u32(&x774, x767, x762, x745); + fiat_p256_scalar_cmovznz_u32(&x775, x767, x764, x747); + out1[0] = x768; + out1[1] = x769; + out1[2] = x770; + out1[3] = x771; + out1[4] = x772; + out1[5] = x773; + out1[6] = x774; + out1[7] = x775; +} + +/* + * The function fiat_p256_scalar_square squares a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_square(fiat_p256_scalar_montgomery_domain_field_element out1, const fiat_p256_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + fiat_p256_scalar_uint1 x26; + uint32_t x27; + fiat_p256_scalar_uint1 x28; + uint32_t x29; + fiat_p256_scalar_uint1 x30; + uint32_t x31; + fiat_p256_scalar_uint1 x32; + uint32_t x33; + fiat_p256_scalar_uint1 x34; + uint32_t x35; + fiat_p256_scalar_uint1 x36; + uint32_t x37; + fiat_p256_scalar_uint1 x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + uint32_t x53; + uint32_t x54; + uint32_t x55; + uint32_t x56; + fiat_p256_scalar_uint1 x57; + uint32_t x58; + fiat_p256_scalar_uint1 x59; + uint32_t x60; + fiat_p256_scalar_uint1 x61; + uint32_t x62; + fiat_p256_scalar_uint1 x63; + uint32_t x64; + fiat_p256_scalar_uint1 x65; + uint32_t x66; + uint32_t x67; + fiat_p256_scalar_uint1 x68; + uint32_t x69; + fiat_p256_scalar_uint1 x70; + uint32_t x71; + fiat_p256_scalar_uint1 x72; + uint32_t x73; + fiat_p256_scalar_uint1 x74; + uint32_t x75; + fiat_p256_scalar_uint1 x76; + uint32_t x77; + fiat_p256_scalar_uint1 x78; + uint32_t x79; + fiat_p256_scalar_uint1 x80; + uint32_t x81; + fiat_p256_scalar_uint1 x82; + uint32_t x83; + fiat_p256_scalar_uint1 x84; + uint32_t x85; + uint32_t x86; + uint32_t x87; + uint32_t x88; + uint32_t x89; + uint32_t x90; + uint32_t x91; + uint32_t x92; + uint32_t x93; + uint32_t x94; + uint32_t x95; + uint32_t x96; + uint32_t x97; + uint32_t x98; + uint32_t x99; + uint32_t x100; + uint32_t x101; + fiat_p256_scalar_uint1 x102; + uint32_t x103; + fiat_p256_scalar_uint1 x104; + uint32_t x105; + fiat_p256_scalar_uint1 x106; + uint32_t x107; + fiat_p256_scalar_uint1 x108; + uint32_t x109; + fiat_p256_scalar_uint1 x110; + uint32_t x111; + fiat_p256_scalar_uint1 x112; + uint32_t x113; + fiat_p256_scalar_uint1 x114; + uint32_t x115; + uint32_t x116; + fiat_p256_scalar_uint1 x117; + uint32_t x118; + fiat_p256_scalar_uint1 x119; + uint32_t x120; + fiat_p256_scalar_uint1 x121; + uint32_t x122; + fiat_p256_scalar_uint1 x123; + uint32_t x124; + fiat_p256_scalar_uint1 x125; + uint32_t x126; + fiat_p256_scalar_uint1 x127; + uint32_t x128; + fiat_p256_scalar_uint1 x129; + uint32_t x130; + fiat_p256_scalar_uint1 x131; + uint32_t x132; + fiat_p256_scalar_uint1 x133; + uint32_t x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + uint32_t x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + uint32_t x145; + uint32_t x146; + uint32_t x147; + uint32_t x148; + uint32_t x149; + uint32_t x150; + fiat_p256_scalar_uint1 x151; + uint32_t x152; + fiat_p256_scalar_uint1 x153; + uint32_t x154; + fiat_p256_scalar_uint1 x155; + uint32_t x156; + fiat_p256_scalar_uint1 x157; + uint32_t x158; + fiat_p256_scalar_uint1 x159; + uint32_t x160; + uint32_t x161; + fiat_p256_scalar_uint1 x162; + uint32_t x163; + fiat_p256_scalar_uint1 x164; + uint32_t x165; + fiat_p256_scalar_uint1 x166; + uint32_t x167; + fiat_p256_scalar_uint1 x168; + uint32_t x169; + fiat_p256_scalar_uint1 x170; + uint32_t x171; + fiat_p256_scalar_uint1 x172; + uint32_t x173; + fiat_p256_scalar_uint1 x174; + uint32_t x175; + fiat_p256_scalar_uint1 x176; + uint32_t x177; + fiat_p256_scalar_uint1 x178; + uint32_t x179; + uint32_t x180; + uint32_t x181; + uint32_t x182; + uint32_t x183; + uint32_t x184; + uint32_t x185; + uint32_t x186; + uint32_t x187; + uint32_t x188; + uint32_t x189; + uint32_t x190; + uint32_t x191; + uint32_t x192; + uint32_t x193; + uint32_t x194; + uint32_t x195; + uint32_t x196; + fiat_p256_scalar_uint1 x197; + uint32_t x198; + fiat_p256_scalar_uint1 x199; + uint32_t x200; + fiat_p256_scalar_uint1 x201; + uint32_t x202; + fiat_p256_scalar_uint1 x203; + uint32_t x204; + fiat_p256_scalar_uint1 x205; + uint32_t x206; + fiat_p256_scalar_uint1 x207; + uint32_t x208; + fiat_p256_scalar_uint1 x209; + uint32_t x210; + uint32_t x211; + fiat_p256_scalar_uint1 x212; + uint32_t x213; + fiat_p256_scalar_uint1 x214; + uint32_t x215; + fiat_p256_scalar_uint1 x216; + uint32_t x217; + fiat_p256_scalar_uint1 x218; + uint32_t x219; + fiat_p256_scalar_uint1 x220; + uint32_t x221; + fiat_p256_scalar_uint1 x222; + uint32_t x223; + fiat_p256_scalar_uint1 x224; + uint32_t x225; + fiat_p256_scalar_uint1 x226; + uint32_t x227; + fiat_p256_scalar_uint1 x228; + uint32_t x229; + uint32_t x230; + uint32_t x231; + uint32_t x232; + uint32_t x233; + uint32_t x234; + uint32_t x235; + uint32_t x236; + uint32_t x237; + uint32_t x238; + uint32_t x239; + uint32_t x240; + uint32_t x241; + uint32_t x242; + uint32_t x243; + uint32_t x244; + uint32_t x245; + fiat_p256_scalar_uint1 x246; + uint32_t x247; + fiat_p256_scalar_uint1 x248; + uint32_t x249; + fiat_p256_scalar_uint1 x250; + uint32_t x251; + fiat_p256_scalar_uint1 x252; + uint32_t x253; + fiat_p256_scalar_uint1 x254; + uint32_t x255; + uint32_t x256; + fiat_p256_scalar_uint1 x257; + uint32_t x258; + fiat_p256_scalar_uint1 x259; + uint32_t x260; + fiat_p256_scalar_uint1 x261; + uint32_t x262; + fiat_p256_scalar_uint1 x263; + uint32_t x264; + fiat_p256_scalar_uint1 x265; + uint32_t x266; + fiat_p256_scalar_uint1 x267; + uint32_t x268; + fiat_p256_scalar_uint1 x269; + uint32_t x270; + fiat_p256_scalar_uint1 x271; + uint32_t x272; + fiat_p256_scalar_uint1 x273; + uint32_t x274; + uint32_t x275; + uint32_t x276; + uint32_t x277; + uint32_t x278; + uint32_t x279; + uint32_t x280; + uint32_t x281; + uint32_t x282; + uint32_t x283; + uint32_t x284; + uint32_t x285; + uint32_t x286; + uint32_t x287; + uint32_t x288; + uint32_t x289; + uint32_t x290; + uint32_t x291; + fiat_p256_scalar_uint1 x292; + uint32_t x293; + fiat_p256_scalar_uint1 x294; + uint32_t x295; + fiat_p256_scalar_uint1 x296; + uint32_t x297; + fiat_p256_scalar_uint1 x298; + uint32_t x299; + fiat_p256_scalar_uint1 x300; + uint32_t x301; + fiat_p256_scalar_uint1 x302; + uint32_t x303; + fiat_p256_scalar_uint1 x304; + uint32_t x305; + uint32_t x306; + fiat_p256_scalar_uint1 x307; + uint32_t x308; + fiat_p256_scalar_uint1 x309; + uint32_t x310; + fiat_p256_scalar_uint1 x311; + uint32_t x312; + fiat_p256_scalar_uint1 x313; + uint32_t x314; + fiat_p256_scalar_uint1 x315; + uint32_t x316; + fiat_p256_scalar_uint1 x317; + uint32_t x318; + fiat_p256_scalar_uint1 x319; + uint32_t x320; + fiat_p256_scalar_uint1 x321; + uint32_t x322; + fiat_p256_scalar_uint1 x323; + uint32_t x324; + uint32_t x325; + uint32_t x326; + uint32_t x327; + uint32_t x328; + uint32_t x329; + uint32_t x330; + uint32_t x331; + uint32_t x332; + uint32_t x333; + uint32_t x334; + uint32_t x335; + uint32_t x336; + uint32_t x337; + uint32_t x338; + uint32_t x339; + uint32_t x340; + fiat_p256_scalar_uint1 x341; + uint32_t x342; + fiat_p256_scalar_uint1 x343; + uint32_t x344; + fiat_p256_scalar_uint1 x345; + uint32_t x346; + fiat_p256_scalar_uint1 x347; + uint32_t x348; + fiat_p256_scalar_uint1 x349; + uint32_t x350; + uint32_t x351; + fiat_p256_scalar_uint1 x352; + uint32_t x353; + fiat_p256_scalar_uint1 x354; + uint32_t x355; + fiat_p256_scalar_uint1 x356; + uint32_t x357; + fiat_p256_scalar_uint1 x358; + uint32_t x359; + fiat_p256_scalar_uint1 x360; + uint32_t x361; + fiat_p256_scalar_uint1 x362; + uint32_t x363; + fiat_p256_scalar_uint1 x364; + uint32_t x365; + fiat_p256_scalar_uint1 x366; + uint32_t x367; + fiat_p256_scalar_uint1 x368; + uint32_t x369; + uint32_t x370; + uint32_t x371; + uint32_t x372; + uint32_t x373; + uint32_t x374; + uint32_t x375; + uint32_t x376; + uint32_t x377; + uint32_t x378; + uint32_t x379; + uint32_t x380; + uint32_t x381; + uint32_t x382; + uint32_t x383; + uint32_t x384; + uint32_t x385; + uint32_t x386; + fiat_p256_scalar_uint1 x387; + uint32_t x388; + fiat_p256_scalar_uint1 x389; + uint32_t x390; + fiat_p256_scalar_uint1 x391; + uint32_t x392; + fiat_p256_scalar_uint1 x393; + uint32_t x394; + fiat_p256_scalar_uint1 x395; + uint32_t x396; + fiat_p256_scalar_uint1 x397; + uint32_t x398; + fiat_p256_scalar_uint1 x399; + uint32_t x400; + uint32_t x401; + fiat_p256_scalar_uint1 x402; + uint32_t x403; + fiat_p256_scalar_uint1 x404; + uint32_t x405; + fiat_p256_scalar_uint1 x406; + uint32_t x407; + fiat_p256_scalar_uint1 x408; + uint32_t x409; + fiat_p256_scalar_uint1 x410; + uint32_t x411; + fiat_p256_scalar_uint1 x412; + uint32_t x413; + fiat_p256_scalar_uint1 x414; + uint32_t x415; + fiat_p256_scalar_uint1 x416; + uint32_t x417; + fiat_p256_scalar_uint1 x418; + uint32_t x419; + uint32_t x420; + uint32_t x421; + uint32_t x422; + uint32_t x423; + uint32_t x424; + uint32_t x425; + uint32_t x426; + uint32_t x427; + uint32_t x428; + uint32_t x429; + uint32_t x430; + uint32_t x431; + uint32_t x432; + uint32_t x433; + uint32_t x434; + uint32_t x435; + fiat_p256_scalar_uint1 x436; + uint32_t x437; + fiat_p256_scalar_uint1 x438; + uint32_t x439; + fiat_p256_scalar_uint1 x440; + uint32_t x441; + fiat_p256_scalar_uint1 x442; + uint32_t x443; + fiat_p256_scalar_uint1 x444; + uint32_t x445; + uint32_t x446; + fiat_p256_scalar_uint1 x447; + uint32_t x448; + fiat_p256_scalar_uint1 x449; + uint32_t x450; + fiat_p256_scalar_uint1 x451; + uint32_t x452; + fiat_p256_scalar_uint1 x453; + uint32_t x454; + fiat_p256_scalar_uint1 x455; + uint32_t x456; + fiat_p256_scalar_uint1 x457; + uint32_t x458; + fiat_p256_scalar_uint1 x459; + uint32_t x460; + fiat_p256_scalar_uint1 x461; + uint32_t x462; + fiat_p256_scalar_uint1 x463; + uint32_t x464; + uint32_t x465; + uint32_t x466; + uint32_t x467; + uint32_t x468; + uint32_t x469; + uint32_t x470; + uint32_t x471; + uint32_t x472; + uint32_t x473; + uint32_t x474; + uint32_t x475; + uint32_t x476; + uint32_t x477; + uint32_t x478; + uint32_t x479; + uint32_t x480; + uint32_t x481; + fiat_p256_scalar_uint1 x482; + uint32_t x483; + fiat_p256_scalar_uint1 x484; + uint32_t x485; + fiat_p256_scalar_uint1 x486; + uint32_t x487; + fiat_p256_scalar_uint1 x488; + uint32_t x489; + fiat_p256_scalar_uint1 x490; + uint32_t x491; + fiat_p256_scalar_uint1 x492; + uint32_t x493; + fiat_p256_scalar_uint1 x494; + uint32_t x495; + uint32_t x496; + fiat_p256_scalar_uint1 x497; + uint32_t x498; + fiat_p256_scalar_uint1 x499; + uint32_t x500; + fiat_p256_scalar_uint1 x501; + uint32_t x502; + fiat_p256_scalar_uint1 x503; + uint32_t x504; + fiat_p256_scalar_uint1 x505; + uint32_t x506; + fiat_p256_scalar_uint1 x507; + uint32_t x508; + fiat_p256_scalar_uint1 x509; + uint32_t x510; + fiat_p256_scalar_uint1 x511; + uint32_t x512; + fiat_p256_scalar_uint1 x513; + uint32_t x514; + uint32_t x515; + uint32_t x516; + uint32_t x517; + uint32_t x518; + uint32_t x519; + uint32_t x520; + uint32_t x521; + uint32_t x522; + uint32_t x523; + uint32_t x524; + uint32_t x525; + uint32_t x526; + uint32_t x527; + uint32_t x528; + uint32_t x529; + uint32_t x530; + fiat_p256_scalar_uint1 x531; + uint32_t x532; + fiat_p256_scalar_uint1 x533; + uint32_t x534; + fiat_p256_scalar_uint1 x535; + uint32_t x536; + fiat_p256_scalar_uint1 x537; + uint32_t x538; + fiat_p256_scalar_uint1 x539; + uint32_t x540; + uint32_t x541; + fiat_p256_scalar_uint1 x542; + uint32_t x543; + fiat_p256_scalar_uint1 x544; + uint32_t x545; + fiat_p256_scalar_uint1 x546; + uint32_t x547; + fiat_p256_scalar_uint1 x548; + uint32_t x549; + fiat_p256_scalar_uint1 x550; + uint32_t x551; + fiat_p256_scalar_uint1 x552; + uint32_t x553; + fiat_p256_scalar_uint1 x554; + uint32_t x555; + fiat_p256_scalar_uint1 x556; + uint32_t x557; + fiat_p256_scalar_uint1 x558; + uint32_t x559; + uint32_t x560; + uint32_t x561; + uint32_t x562; + uint32_t x563; + uint32_t x564; + uint32_t x565; + uint32_t x566; + uint32_t x567; + uint32_t x568; + uint32_t x569; + uint32_t x570; + uint32_t x571; + uint32_t x572; + uint32_t x573; + uint32_t x574; + uint32_t x575; + uint32_t x576; + fiat_p256_scalar_uint1 x577; + uint32_t x578; + fiat_p256_scalar_uint1 x579; + uint32_t x580; + fiat_p256_scalar_uint1 x581; + uint32_t x582; + fiat_p256_scalar_uint1 x583; + uint32_t x584; + fiat_p256_scalar_uint1 x585; + uint32_t x586; + fiat_p256_scalar_uint1 x587; + uint32_t x588; + fiat_p256_scalar_uint1 x589; + uint32_t x590; + uint32_t x591; + fiat_p256_scalar_uint1 x592; + uint32_t x593; + fiat_p256_scalar_uint1 x594; + uint32_t x595; + fiat_p256_scalar_uint1 x596; + uint32_t x597; + fiat_p256_scalar_uint1 x598; + uint32_t x599; + fiat_p256_scalar_uint1 x600; + uint32_t x601; + fiat_p256_scalar_uint1 x602; + uint32_t x603; + fiat_p256_scalar_uint1 x604; + uint32_t x605; + fiat_p256_scalar_uint1 x606; + uint32_t x607; + fiat_p256_scalar_uint1 x608; + uint32_t x609; + uint32_t x610; + uint32_t x611; + uint32_t x612; + uint32_t x613; + uint32_t x614; + uint32_t x615; + uint32_t x616; + uint32_t x617; + uint32_t x618; + uint32_t x619; + uint32_t x620; + uint32_t x621; + uint32_t x622; + uint32_t x623; + uint32_t x624; + uint32_t x625; + fiat_p256_scalar_uint1 x626; + uint32_t x627; + fiat_p256_scalar_uint1 x628; + uint32_t x629; + fiat_p256_scalar_uint1 x630; + uint32_t x631; + fiat_p256_scalar_uint1 x632; + uint32_t x633; + fiat_p256_scalar_uint1 x634; + uint32_t x635; + uint32_t x636; + fiat_p256_scalar_uint1 x637; + uint32_t x638; + fiat_p256_scalar_uint1 x639; + uint32_t x640; + fiat_p256_scalar_uint1 x641; + uint32_t x642; + fiat_p256_scalar_uint1 x643; + uint32_t x644; + fiat_p256_scalar_uint1 x645; + uint32_t x646; + fiat_p256_scalar_uint1 x647; + uint32_t x648; + fiat_p256_scalar_uint1 x649; + uint32_t x650; + fiat_p256_scalar_uint1 x651; + uint32_t x652; + fiat_p256_scalar_uint1 x653; + uint32_t x654; + uint32_t x655; + uint32_t x656; + uint32_t x657; + uint32_t x658; + uint32_t x659; + uint32_t x660; + uint32_t x661; + uint32_t x662; + uint32_t x663; + uint32_t x664; + uint32_t x665; + uint32_t x666; + uint32_t x667; + uint32_t x668; + uint32_t x669; + uint32_t x670; + uint32_t x671; + fiat_p256_scalar_uint1 x672; + uint32_t x673; + fiat_p256_scalar_uint1 x674; + uint32_t x675; + fiat_p256_scalar_uint1 x676; + uint32_t x677; + fiat_p256_scalar_uint1 x678; + uint32_t x679; + fiat_p256_scalar_uint1 x680; + uint32_t x681; + fiat_p256_scalar_uint1 x682; + uint32_t x683; + fiat_p256_scalar_uint1 x684; + uint32_t x685; + uint32_t x686; + fiat_p256_scalar_uint1 x687; + uint32_t x688; + fiat_p256_scalar_uint1 x689; + uint32_t x690; + fiat_p256_scalar_uint1 x691; + uint32_t x692; + fiat_p256_scalar_uint1 x693; + uint32_t x694; + fiat_p256_scalar_uint1 x695; + uint32_t x696; + fiat_p256_scalar_uint1 x697; + uint32_t x698; + fiat_p256_scalar_uint1 x699; + uint32_t x700; + fiat_p256_scalar_uint1 x701; + uint32_t x702; + fiat_p256_scalar_uint1 x703; + uint32_t x704; + uint32_t x705; + uint32_t x706; + uint32_t x707; + uint32_t x708; + uint32_t x709; + uint32_t x710; + uint32_t x711; + uint32_t x712; + uint32_t x713; + uint32_t x714; + uint32_t x715; + uint32_t x716; + uint32_t x717; + uint32_t x718; + uint32_t x719; + uint32_t x720; + fiat_p256_scalar_uint1 x721; + uint32_t x722; + fiat_p256_scalar_uint1 x723; + uint32_t x724; + fiat_p256_scalar_uint1 x725; + uint32_t x726; + fiat_p256_scalar_uint1 x727; + uint32_t x728; + fiat_p256_scalar_uint1 x729; + uint32_t x730; + uint32_t x731; + fiat_p256_scalar_uint1 x732; + uint32_t x733; + fiat_p256_scalar_uint1 x734; + uint32_t x735; + fiat_p256_scalar_uint1 x736; + uint32_t x737; + fiat_p256_scalar_uint1 x738; + uint32_t x739; + fiat_p256_scalar_uint1 x740; + uint32_t x741; + fiat_p256_scalar_uint1 x742; + uint32_t x743; + fiat_p256_scalar_uint1 x744; + uint32_t x745; + fiat_p256_scalar_uint1 x746; + uint32_t x747; + fiat_p256_scalar_uint1 x748; + uint32_t x749; + uint32_t x750; + fiat_p256_scalar_uint1 x751; + uint32_t x752; + fiat_p256_scalar_uint1 x753; + uint32_t x754; + fiat_p256_scalar_uint1 x755; + uint32_t x756; + fiat_p256_scalar_uint1 x757; + uint32_t x758; + fiat_p256_scalar_uint1 x759; + uint32_t x760; + fiat_p256_scalar_uint1 x761; + uint32_t x762; + fiat_p256_scalar_uint1 x763; + uint32_t x764; + fiat_p256_scalar_uint1 x765; + uint32_t x766; + fiat_p256_scalar_uint1 x767; + uint32_t x768; + uint32_t x769; + uint32_t x770; + uint32_t x771; + uint32_t x772; + uint32_t x773; + uint32_t x774; + uint32_t x775; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[6]); + x7 = (arg1[7]); + x8 = (arg1[0]); + fiat_p256_scalar_mulx_u32(&x9, &x10, x8, (arg1[7])); + fiat_p256_scalar_mulx_u32(&x11, &x12, x8, (arg1[6])); + fiat_p256_scalar_mulx_u32(&x13, &x14, x8, (arg1[5])); + fiat_p256_scalar_mulx_u32(&x15, &x16, x8, (arg1[4])); + fiat_p256_scalar_mulx_u32(&x17, &x18, x8, (arg1[3])); + fiat_p256_scalar_mulx_u32(&x19, &x20, x8, (arg1[2])); + fiat_p256_scalar_mulx_u32(&x21, &x22, x8, (arg1[1])); + fiat_p256_scalar_mulx_u32(&x23, &x24, x8, (arg1[0])); + fiat_p256_scalar_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_p256_scalar_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_p256_scalar_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_p256_scalar_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_p256_scalar_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_p256_scalar_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_p256_scalar_addcarryx_u32(&x37, &x38, x36, x12, x9); + x39 = (x38 + x10); + fiat_p256_scalar_mulx_u32(&x40, &x41, x23, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x42, &x43, x40, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x44, &x45, x40, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x46, &x47, x40, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x48, &x49, x40, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x50, &x51, x40, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x52, &x53, x40, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x54, &x55, x40, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x56, &x57, 0x0, x55, x52); + fiat_p256_scalar_addcarryx_u32(&x58, &x59, x57, x53, x50); + fiat_p256_scalar_addcarryx_u32(&x60, &x61, x59, x51, x48); + fiat_p256_scalar_addcarryx_u32(&x62, &x63, x61, x49, x46); + fiat_p256_scalar_addcarryx_u32(&x64, &x65, x63, x47, x44); + x66 = (x65 + x45); + fiat_p256_scalar_addcarryx_u32(&x67, &x68, 0x0, x23, x54); + fiat_p256_scalar_addcarryx_u32(&x69, &x70, x68, x25, x56); + fiat_p256_scalar_addcarryx_u32(&x71, &x72, x70, x27, x58); + fiat_p256_scalar_addcarryx_u32(&x73, &x74, x72, x29, x60); + fiat_p256_scalar_addcarryx_u32(&x75, &x76, x74, x31, x62); + fiat_p256_scalar_addcarryx_u32(&x77, &x78, x76, x33, x64); + fiat_p256_scalar_addcarryx_u32(&x79, &x80, x78, x35, x66); + fiat_p256_scalar_addcarryx_u32(&x81, &x82, x80, x37, x42); + fiat_p256_scalar_addcarryx_u32(&x83, &x84, x82, x39, x43); + fiat_p256_scalar_mulx_u32(&x85, &x86, x1, (arg1[7])); + fiat_p256_scalar_mulx_u32(&x87, &x88, x1, (arg1[6])); + fiat_p256_scalar_mulx_u32(&x89, &x90, x1, (arg1[5])); + fiat_p256_scalar_mulx_u32(&x91, &x92, x1, (arg1[4])); + fiat_p256_scalar_mulx_u32(&x93, &x94, x1, (arg1[3])); + fiat_p256_scalar_mulx_u32(&x95, &x96, x1, (arg1[2])); + fiat_p256_scalar_mulx_u32(&x97, &x98, x1, (arg1[1])); + fiat_p256_scalar_mulx_u32(&x99, &x100, x1, (arg1[0])); + fiat_p256_scalar_addcarryx_u32(&x101, &x102, 0x0, x100, x97); + fiat_p256_scalar_addcarryx_u32(&x103, &x104, x102, x98, x95); + fiat_p256_scalar_addcarryx_u32(&x105, &x106, x104, x96, x93); + fiat_p256_scalar_addcarryx_u32(&x107, &x108, x106, x94, x91); + fiat_p256_scalar_addcarryx_u32(&x109, &x110, x108, x92, x89); + fiat_p256_scalar_addcarryx_u32(&x111, &x112, x110, x90, x87); + fiat_p256_scalar_addcarryx_u32(&x113, &x114, x112, x88, x85); + x115 = (x114 + x86); + fiat_p256_scalar_addcarryx_u32(&x116, &x117, 0x0, x69, x99); + fiat_p256_scalar_addcarryx_u32(&x118, &x119, x117, x71, x101); + fiat_p256_scalar_addcarryx_u32(&x120, &x121, x119, x73, x103); + fiat_p256_scalar_addcarryx_u32(&x122, &x123, x121, x75, x105); + fiat_p256_scalar_addcarryx_u32(&x124, &x125, x123, x77, x107); + fiat_p256_scalar_addcarryx_u32(&x126, &x127, x125, x79, x109); + fiat_p256_scalar_addcarryx_u32(&x128, &x129, x127, x81, x111); + fiat_p256_scalar_addcarryx_u32(&x130, &x131, x129, x83, x113); + fiat_p256_scalar_addcarryx_u32(&x132, &x133, x131, x84, x115); + fiat_p256_scalar_mulx_u32(&x134, &x135, x116, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x136, &x137, x134, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x138, &x139, x134, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x140, &x141, x134, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x142, &x143, x134, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x144, &x145, x134, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x146, &x147, x134, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x148, &x149, x134, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x150, &x151, 0x0, x149, x146); + fiat_p256_scalar_addcarryx_u32(&x152, &x153, x151, x147, x144); + fiat_p256_scalar_addcarryx_u32(&x154, &x155, x153, x145, x142); + fiat_p256_scalar_addcarryx_u32(&x156, &x157, x155, x143, x140); + fiat_p256_scalar_addcarryx_u32(&x158, &x159, x157, x141, x138); + x160 = (x159 + x139); + fiat_p256_scalar_addcarryx_u32(&x161, &x162, 0x0, x116, x148); + fiat_p256_scalar_addcarryx_u32(&x163, &x164, x162, x118, x150); + fiat_p256_scalar_addcarryx_u32(&x165, &x166, x164, x120, x152); + fiat_p256_scalar_addcarryx_u32(&x167, &x168, x166, x122, x154); + fiat_p256_scalar_addcarryx_u32(&x169, &x170, x168, x124, x156); + fiat_p256_scalar_addcarryx_u32(&x171, &x172, x170, x126, x158); + fiat_p256_scalar_addcarryx_u32(&x173, &x174, x172, x128, x160); + fiat_p256_scalar_addcarryx_u32(&x175, &x176, x174, x130, x136); + fiat_p256_scalar_addcarryx_u32(&x177, &x178, x176, x132, x137); + x179 = ((uint32_t)x178 + x133); + fiat_p256_scalar_mulx_u32(&x180, &x181, x2, (arg1[7])); + fiat_p256_scalar_mulx_u32(&x182, &x183, x2, (arg1[6])); + fiat_p256_scalar_mulx_u32(&x184, &x185, x2, (arg1[5])); + fiat_p256_scalar_mulx_u32(&x186, &x187, x2, (arg1[4])); + fiat_p256_scalar_mulx_u32(&x188, &x189, x2, (arg1[3])); + fiat_p256_scalar_mulx_u32(&x190, &x191, x2, (arg1[2])); + fiat_p256_scalar_mulx_u32(&x192, &x193, x2, (arg1[1])); + fiat_p256_scalar_mulx_u32(&x194, &x195, x2, (arg1[0])); + fiat_p256_scalar_addcarryx_u32(&x196, &x197, 0x0, x195, x192); + fiat_p256_scalar_addcarryx_u32(&x198, &x199, x197, x193, x190); + fiat_p256_scalar_addcarryx_u32(&x200, &x201, x199, x191, x188); + fiat_p256_scalar_addcarryx_u32(&x202, &x203, x201, x189, x186); + fiat_p256_scalar_addcarryx_u32(&x204, &x205, x203, x187, x184); + fiat_p256_scalar_addcarryx_u32(&x206, &x207, x205, x185, x182); + fiat_p256_scalar_addcarryx_u32(&x208, &x209, x207, x183, x180); + x210 = (x209 + x181); + fiat_p256_scalar_addcarryx_u32(&x211, &x212, 0x0, x163, x194); + fiat_p256_scalar_addcarryx_u32(&x213, &x214, x212, x165, x196); + fiat_p256_scalar_addcarryx_u32(&x215, &x216, x214, x167, x198); + fiat_p256_scalar_addcarryx_u32(&x217, &x218, x216, x169, x200); + fiat_p256_scalar_addcarryx_u32(&x219, &x220, x218, x171, x202); + fiat_p256_scalar_addcarryx_u32(&x221, &x222, x220, x173, x204); + fiat_p256_scalar_addcarryx_u32(&x223, &x224, x222, x175, x206); + fiat_p256_scalar_addcarryx_u32(&x225, &x226, x224, x177, x208); + fiat_p256_scalar_addcarryx_u32(&x227, &x228, x226, x179, x210); + fiat_p256_scalar_mulx_u32(&x229, &x230, x211, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x231, &x232, x229, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x233, &x234, x229, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x235, &x236, x229, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x237, &x238, x229, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x239, &x240, x229, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x241, &x242, x229, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x243, &x244, x229, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x245, &x246, 0x0, x244, x241); + fiat_p256_scalar_addcarryx_u32(&x247, &x248, x246, x242, x239); + fiat_p256_scalar_addcarryx_u32(&x249, &x250, x248, x240, x237); + fiat_p256_scalar_addcarryx_u32(&x251, &x252, x250, x238, x235); + fiat_p256_scalar_addcarryx_u32(&x253, &x254, x252, x236, x233); + x255 = (x254 + x234); + fiat_p256_scalar_addcarryx_u32(&x256, &x257, 0x0, x211, x243); + fiat_p256_scalar_addcarryx_u32(&x258, &x259, x257, x213, x245); + fiat_p256_scalar_addcarryx_u32(&x260, &x261, x259, x215, x247); + fiat_p256_scalar_addcarryx_u32(&x262, &x263, x261, x217, x249); + fiat_p256_scalar_addcarryx_u32(&x264, &x265, x263, x219, x251); + fiat_p256_scalar_addcarryx_u32(&x266, &x267, x265, x221, x253); + fiat_p256_scalar_addcarryx_u32(&x268, &x269, x267, x223, x255); + fiat_p256_scalar_addcarryx_u32(&x270, &x271, x269, x225, x231); + fiat_p256_scalar_addcarryx_u32(&x272, &x273, x271, x227, x232); + x274 = ((uint32_t)x273 + x228); + fiat_p256_scalar_mulx_u32(&x275, &x276, x3, (arg1[7])); + fiat_p256_scalar_mulx_u32(&x277, &x278, x3, (arg1[6])); + fiat_p256_scalar_mulx_u32(&x279, &x280, x3, (arg1[5])); + fiat_p256_scalar_mulx_u32(&x281, &x282, x3, (arg1[4])); + fiat_p256_scalar_mulx_u32(&x283, &x284, x3, (arg1[3])); + fiat_p256_scalar_mulx_u32(&x285, &x286, x3, (arg1[2])); + fiat_p256_scalar_mulx_u32(&x287, &x288, x3, (arg1[1])); + fiat_p256_scalar_mulx_u32(&x289, &x290, x3, (arg1[0])); + fiat_p256_scalar_addcarryx_u32(&x291, &x292, 0x0, x290, x287); + fiat_p256_scalar_addcarryx_u32(&x293, &x294, x292, x288, x285); + fiat_p256_scalar_addcarryx_u32(&x295, &x296, x294, x286, x283); + fiat_p256_scalar_addcarryx_u32(&x297, &x298, x296, x284, x281); + fiat_p256_scalar_addcarryx_u32(&x299, &x300, x298, x282, x279); + fiat_p256_scalar_addcarryx_u32(&x301, &x302, x300, x280, x277); + fiat_p256_scalar_addcarryx_u32(&x303, &x304, x302, x278, x275); + x305 = (x304 + x276); + fiat_p256_scalar_addcarryx_u32(&x306, &x307, 0x0, x258, x289); + fiat_p256_scalar_addcarryx_u32(&x308, &x309, x307, x260, x291); + fiat_p256_scalar_addcarryx_u32(&x310, &x311, x309, x262, x293); + fiat_p256_scalar_addcarryx_u32(&x312, &x313, x311, x264, x295); + fiat_p256_scalar_addcarryx_u32(&x314, &x315, x313, x266, x297); + fiat_p256_scalar_addcarryx_u32(&x316, &x317, x315, x268, x299); + fiat_p256_scalar_addcarryx_u32(&x318, &x319, x317, x270, x301); + fiat_p256_scalar_addcarryx_u32(&x320, &x321, x319, x272, x303); + fiat_p256_scalar_addcarryx_u32(&x322, &x323, x321, x274, x305); + fiat_p256_scalar_mulx_u32(&x324, &x325, x306, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x326, &x327, x324, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x328, &x329, x324, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x330, &x331, x324, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x332, &x333, x324, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x334, &x335, x324, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x336, &x337, x324, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x338, &x339, x324, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x340, &x341, 0x0, x339, x336); + fiat_p256_scalar_addcarryx_u32(&x342, &x343, x341, x337, x334); + fiat_p256_scalar_addcarryx_u32(&x344, &x345, x343, x335, x332); + fiat_p256_scalar_addcarryx_u32(&x346, &x347, x345, x333, x330); + fiat_p256_scalar_addcarryx_u32(&x348, &x349, x347, x331, x328); + x350 = (x349 + x329); + fiat_p256_scalar_addcarryx_u32(&x351, &x352, 0x0, x306, x338); + fiat_p256_scalar_addcarryx_u32(&x353, &x354, x352, x308, x340); + fiat_p256_scalar_addcarryx_u32(&x355, &x356, x354, x310, x342); + fiat_p256_scalar_addcarryx_u32(&x357, &x358, x356, x312, x344); + fiat_p256_scalar_addcarryx_u32(&x359, &x360, x358, x314, x346); + fiat_p256_scalar_addcarryx_u32(&x361, &x362, x360, x316, x348); + fiat_p256_scalar_addcarryx_u32(&x363, &x364, x362, x318, x350); + fiat_p256_scalar_addcarryx_u32(&x365, &x366, x364, x320, x326); + fiat_p256_scalar_addcarryx_u32(&x367, &x368, x366, x322, x327); + x369 = ((uint32_t)x368 + x323); + fiat_p256_scalar_mulx_u32(&x370, &x371, x4, (arg1[7])); + fiat_p256_scalar_mulx_u32(&x372, &x373, x4, (arg1[6])); + fiat_p256_scalar_mulx_u32(&x374, &x375, x4, (arg1[5])); + fiat_p256_scalar_mulx_u32(&x376, &x377, x4, (arg1[4])); + fiat_p256_scalar_mulx_u32(&x378, &x379, x4, (arg1[3])); + fiat_p256_scalar_mulx_u32(&x380, &x381, x4, (arg1[2])); + fiat_p256_scalar_mulx_u32(&x382, &x383, x4, (arg1[1])); + fiat_p256_scalar_mulx_u32(&x384, &x385, x4, (arg1[0])); + fiat_p256_scalar_addcarryx_u32(&x386, &x387, 0x0, x385, x382); + fiat_p256_scalar_addcarryx_u32(&x388, &x389, x387, x383, x380); + fiat_p256_scalar_addcarryx_u32(&x390, &x391, x389, x381, x378); + fiat_p256_scalar_addcarryx_u32(&x392, &x393, x391, x379, x376); + fiat_p256_scalar_addcarryx_u32(&x394, &x395, x393, x377, x374); + fiat_p256_scalar_addcarryx_u32(&x396, &x397, x395, x375, x372); + fiat_p256_scalar_addcarryx_u32(&x398, &x399, x397, x373, x370); + x400 = (x399 + x371); + fiat_p256_scalar_addcarryx_u32(&x401, &x402, 0x0, x353, x384); + fiat_p256_scalar_addcarryx_u32(&x403, &x404, x402, x355, x386); + fiat_p256_scalar_addcarryx_u32(&x405, &x406, x404, x357, x388); + fiat_p256_scalar_addcarryx_u32(&x407, &x408, x406, x359, x390); + fiat_p256_scalar_addcarryx_u32(&x409, &x410, x408, x361, x392); + fiat_p256_scalar_addcarryx_u32(&x411, &x412, x410, x363, x394); + fiat_p256_scalar_addcarryx_u32(&x413, &x414, x412, x365, x396); + fiat_p256_scalar_addcarryx_u32(&x415, &x416, x414, x367, x398); + fiat_p256_scalar_addcarryx_u32(&x417, &x418, x416, x369, x400); + fiat_p256_scalar_mulx_u32(&x419, &x420, x401, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x421, &x422, x419, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x423, &x424, x419, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x425, &x426, x419, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x427, &x428, x419, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x429, &x430, x419, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x431, &x432, x419, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x433, &x434, x419, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x435, &x436, 0x0, x434, x431); + fiat_p256_scalar_addcarryx_u32(&x437, &x438, x436, x432, x429); + fiat_p256_scalar_addcarryx_u32(&x439, &x440, x438, x430, x427); + fiat_p256_scalar_addcarryx_u32(&x441, &x442, x440, x428, x425); + fiat_p256_scalar_addcarryx_u32(&x443, &x444, x442, x426, x423); + x445 = (x444 + x424); + fiat_p256_scalar_addcarryx_u32(&x446, &x447, 0x0, x401, x433); + fiat_p256_scalar_addcarryx_u32(&x448, &x449, x447, x403, x435); + fiat_p256_scalar_addcarryx_u32(&x450, &x451, x449, x405, x437); + fiat_p256_scalar_addcarryx_u32(&x452, &x453, x451, x407, x439); + fiat_p256_scalar_addcarryx_u32(&x454, &x455, x453, x409, x441); + fiat_p256_scalar_addcarryx_u32(&x456, &x457, x455, x411, x443); + fiat_p256_scalar_addcarryx_u32(&x458, &x459, x457, x413, x445); + fiat_p256_scalar_addcarryx_u32(&x460, &x461, x459, x415, x421); + fiat_p256_scalar_addcarryx_u32(&x462, &x463, x461, x417, x422); + x464 = ((uint32_t)x463 + x418); + fiat_p256_scalar_mulx_u32(&x465, &x466, x5, (arg1[7])); + fiat_p256_scalar_mulx_u32(&x467, &x468, x5, (arg1[6])); + fiat_p256_scalar_mulx_u32(&x469, &x470, x5, (arg1[5])); + fiat_p256_scalar_mulx_u32(&x471, &x472, x5, (arg1[4])); + fiat_p256_scalar_mulx_u32(&x473, &x474, x5, (arg1[3])); + fiat_p256_scalar_mulx_u32(&x475, &x476, x5, (arg1[2])); + fiat_p256_scalar_mulx_u32(&x477, &x478, x5, (arg1[1])); + fiat_p256_scalar_mulx_u32(&x479, &x480, x5, (arg1[0])); + fiat_p256_scalar_addcarryx_u32(&x481, &x482, 0x0, x480, x477); + fiat_p256_scalar_addcarryx_u32(&x483, &x484, x482, x478, x475); + fiat_p256_scalar_addcarryx_u32(&x485, &x486, x484, x476, x473); + fiat_p256_scalar_addcarryx_u32(&x487, &x488, x486, x474, x471); + fiat_p256_scalar_addcarryx_u32(&x489, &x490, x488, x472, x469); + fiat_p256_scalar_addcarryx_u32(&x491, &x492, x490, x470, x467); + fiat_p256_scalar_addcarryx_u32(&x493, &x494, x492, x468, x465); + x495 = (x494 + x466); + fiat_p256_scalar_addcarryx_u32(&x496, &x497, 0x0, x448, x479); + fiat_p256_scalar_addcarryx_u32(&x498, &x499, x497, x450, x481); + fiat_p256_scalar_addcarryx_u32(&x500, &x501, x499, x452, x483); + fiat_p256_scalar_addcarryx_u32(&x502, &x503, x501, x454, x485); + fiat_p256_scalar_addcarryx_u32(&x504, &x505, x503, x456, x487); + fiat_p256_scalar_addcarryx_u32(&x506, &x507, x505, x458, x489); + fiat_p256_scalar_addcarryx_u32(&x508, &x509, x507, x460, x491); + fiat_p256_scalar_addcarryx_u32(&x510, &x511, x509, x462, x493); + fiat_p256_scalar_addcarryx_u32(&x512, &x513, x511, x464, x495); + fiat_p256_scalar_mulx_u32(&x514, &x515, x496, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x516, &x517, x514, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x518, &x519, x514, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x520, &x521, x514, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x522, &x523, x514, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x524, &x525, x514, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x526, &x527, x514, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x528, &x529, x514, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x530, &x531, 0x0, x529, x526); + fiat_p256_scalar_addcarryx_u32(&x532, &x533, x531, x527, x524); + fiat_p256_scalar_addcarryx_u32(&x534, &x535, x533, x525, x522); + fiat_p256_scalar_addcarryx_u32(&x536, &x537, x535, x523, x520); + fiat_p256_scalar_addcarryx_u32(&x538, &x539, x537, x521, x518); + x540 = (x539 + x519); + fiat_p256_scalar_addcarryx_u32(&x541, &x542, 0x0, x496, x528); + fiat_p256_scalar_addcarryx_u32(&x543, &x544, x542, x498, x530); + fiat_p256_scalar_addcarryx_u32(&x545, &x546, x544, x500, x532); + fiat_p256_scalar_addcarryx_u32(&x547, &x548, x546, x502, x534); + fiat_p256_scalar_addcarryx_u32(&x549, &x550, x548, x504, x536); + fiat_p256_scalar_addcarryx_u32(&x551, &x552, x550, x506, x538); + fiat_p256_scalar_addcarryx_u32(&x553, &x554, x552, x508, x540); + fiat_p256_scalar_addcarryx_u32(&x555, &x556, x554, x510, x516); + fiat_p256_scalar_addcarryx_u32(&x557, &x558, x556, x512, x517); + x559 = ((uint32_t)x558 + x513); + fiat_p256_scalar_mulx_u32(&x560, &x561, x6, (arg1[7])); + fiat_p256_scalar_mulx_u32(&x562, &x563, x6, (arg1[6])); + fiat_p256_scalar_mulx_u32(&x564, &x565, x6, (arg1[5])); + fiat_p256_scalar_mulx_u32(&x566, &x567, x6, (arg1[4])); + fiat_p256_scalar_mulx_u32(&x568, &x569, x6, (arg1[3])); + fiat_p256_scalar_mulx_u32(&x570, &x571, x6, (arg1[2])); + fiat_p256_scalar_mulx_u32(&x572, &x573, x6, (arg1[1])); + fiat_p256_scalar_mulx_u32(&x574, &x575, x6, (arg1[0])); + fiat_p256_scalar_addcarryx_u32(&x576, &x577, 0x0, x575, x572); + fiat_p256_scalar_addcarryx_u32(&x578, &x579, x577, x573, x570); + fiat_p256_scalar_addcarryx_u32(&x580, &x581, x579, x571, x568); + fiat_p256_scalar_addcarryx_u32(&x582, &x583, x581, x569, x566); + fiat_p256_scalar_addcarryx_u32(&x584, &x585, x583, x567, x564); + fiat_p256_scalar_addcarryx_u32(&x586, &x587, x585, x565, x562); + fiat_p256_scalar_addcarryx_u32(&x588, &x589, x587, x563, x560); + x590 = (x589 + x561); + fiat_p256_scalar_addcarryx_u32(&x591, &x592, 0x0, x543, x574); + fiat_p256_scalar_addcarryx_u32(&x593, &x594, x592, x545, x576); + fiat_p256_scalar_addcarryx_u32(&x595, &x596, x594, x547, x578); + fiat_p256_scalar_addcarryx_u32(&x597, &x598, x596, x549, x580); + fiat_p256_scalar_addcarryx_u32(&x599, &x600, x598, x551, x582); + fiat_p256_scalar_addcarryx_u32(&x601, &x602, x600, x553, x584); + fiat_p256_scalar_addcarryx_u32(&x603, &x604, x602, x555, x586); + fiat_p256_scalar_addcarryx_u32(&x605, &x606, x604, x557, x588); + fiat_p256_scalar_addcarryx_u32(&x607, &x608, x606, x559, x590); + fiat_p256_scalar_mulx_u32(&x609, &x610, x591, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x611, &x612, x609, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x613, &x614, x609, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x615, &x616, x609, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x617, &x618, x609, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x619, &x620, x609, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x621, &x622, x609, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x623, &x624, x609, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x625, &x626, 0x0, x624, x621); + fiat_p256_scalar_addcarryx_u32(&x627, &x628, x626, x622, x619); + fiat_p256_scalar_addcarryx_u32(&x629, &x630, x628, x620, x617); + fiat_p256_scalar_addcarryx_u32(&x631, &x632, x630, x618, x615); + fiat_p256_scalar_addcarryx_u32(&x633, &x634, x632, x616, x613); + x635 = (x634 + x614); + fiat_p256_scalar_addcarryx_u32(&x636, &x637, 0x0, x591, x623); + fiat_p256_scalar_addcarryx_u32(&x638, &x639, x637, x593, x625); + fiat_p256_scalar_addcarryx_u32(&x640, &x641, x639, x595, x627); + fiat_p256_scalar_addcarryx_u32(&x642, &x643, x641, x597, x629); + fiat_p256_scalar_addcarryx_u32(&x644, &x645, x643, x599, x631); + fiat_p256_scalar_addcarryx_u32(&x646, &x647, x645, x601, x633); + fiat_p256_scalar_addcarryx_u32(&x648, &x649, x647, x603, x635); + fiat_p256_scalar_addcarryx_u32(&x650, &x651, x649, x605, x611); + fiat_p256_scalar_addcarryx_u32(&x652, &x653, x651, x607, x612); + x654 = ((uint32_t)x653 + x608); + fiat_p256_scalar_mulx_u32(&x655, &x656, x7, (arg1[7])); + fiat_p256_scalar_mulx_u32(&x657, &x658, x7, (arg1[6])); + fiat_p256_scalar_mulx_u32(&x659, &x660, x7, (arg1[5])); + fiat_p256_scalar_mulx_u32(&x661, &x662, x7, (arg1[4])); + fiat_p256_scalar_mulx_u32(&x663, &x664, x7, (arg1[3])); + fiat_p256_scalar_mulx_u32(&x665, &x666, x7, (arg1[2])); + fiat_p256_scalar_mulx_u32(&x667, &x668, x7, (arg1[1])); + fiat_p256_scalar_mulx_u32(&x669, &x670, x7, (arg1[0])); + fiat_p256_scalar_addcarryx_u32(&x671, &x672, 0x0, x670, x667); + fiat_p256_scalar_addcarryx_u32(&x673, &x674, x672, x668, x665); + fiat_p256_scalar_addcarryx_u32(&x675, &x676, x674, x666, x663); + fiat_p256_scalar_addcarryx_u32(&x677, &x678, x676, x664, x661); + fiat_p256_scalar_addcarryx_u32(&x679, &x680, x678, x662, x659); + fiat_p256_scalar_addcarryx_u32(&x681, &x682, x680, x660, x657); + fiat_p256_scalar_addcarryx_u32(&x683, &x684, x682, x658, x655); + x685 = (x684 + x656); + fiat_p256_scalar_addcarryx_u32(&x686, &x687, 0x0, x638, x669); + fiat_p256_scalar_addcarryx_u32(&x688, &x689, x687, x640, x671); + fiat_p256_scalar_addcarryx_u32(&x690, &x691, x689, x642, x673); + fiat_p256_scalar_addcarryx_u32(&x692, &x693, x691, x644, x675); + fiat_p256_scalar_addcarryx_u32(&x694, &x695, x693, x646, x677); + fiat_p256_scalar_addcarryx_u32(&x696, &x697, x695, x648, x679); + fiat_p256_scalar_addcarryx_u32(&x698, &x699, x697, x650, x681); + fiat_p256_scalar_addcarryx_u32(&x700, &x701, x699, x652, x683); + fiat_p256_scalar_addcarryx_u32(&x702, &x703, x701, x654, x685); + fiat_p256_scalar_mulx_u32(&x704, &x705, x686, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x706, &x707, x704, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x708, &x709, x704, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x710, &x711, x704, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x712, &x713, x704, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x714, &x715, x704, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x716, &x717, x704, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x718, &x719, x704, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x720, &x721, 0x0, x719, x716); + fiat_p256_scalar_addcarryx_u32(&x722, &x723, x721, x717, x714); + fiat_p256_scalar_addcarryx_u32(&x724, &x725, x723, x715, x712); + fiat_p256_scalar_addcarryx_u32(&x726, &x727, x725, x713, x710); + fiat_p256_scalar_addcarryx_u32(&x728, &x729, x727, x711, x708); + x730 = (x729 + x709); + fiat_p256_scalar_addcarryx_u32(&x731, &x732, 0x0, x686, x718); + fiat_p256_scalar_addcarryx_u32(&x733, &x734, x732, x688, x720); + fiat_p256_scalar_addcarryx_u32(&x735, &x736, x734, x690, x722); + fiat_p256_scalar_addcarryx_u32(&x737, &x738, x736, x692, x724); + fiat_p256_scalar_addcarryx_u32(&x739, &x740, x738, x694, x726); + fiat_p256_scalar_addcarryx_u32(&x741, &x742, x740, x696, x728); + fiat_p256_scalar_addcarryx_u32(&x743, &x744, x742, x698, x730); + fiat_p256_scalar_addcarryx_u32(&x745, &x746, x744, x700, x706); + fiat_p256_scalar_addcarryx_u32(&x747, &x748, x746, x702, x707); + x749 = ((uint32_t)x748 + x703); + fiat_p256_scalar_subborrowx_u32(&x750, &x751, 0x0, x733, UINT32_C(0xfc632551)); + fiat_p256_scalar_subborrowx_u32(&x752, &x753, x751, x735, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_subborrowx_u32(&x754, &x755, x753, x737, UINT32_C(0xa7179e84)); + fiat_p256_scalar_subborrowx_u32(&x756, &x757, x755, x739, UINT32_C(0xbce6faad)); + fiat_p256_scalar_subborrowx_u32(&x758, &x759, x757, x741, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x760, &x761, x759, x743, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x762, &x763, x761, x745, 0x0); + fiat_p256_scalar_subborrowx_u32(&x764, &x765, x763, x747, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x766, &x767, x765, x749, 0x0); + fiat_p256_scalar_cmovznz_u32(&x768, x767, x750, x733); + fiat_p256_scalar_cmovznz_u32(&x769, x767, x752, x735); + fiat_p256_scalar_cmovznz_u32(&x770, x767, x754, x737); + fiat_p256_scalar_cmovznz_u32(&x771, x767, x756, x739); + fiat_p256_scalar_cmovznz_u32(&x772, x767, x758, x741); + fiat_p256_scalar_cmovznz_u32(&x773, x767, x760, x743); + fiat_p256_scalar_cmovznz_u32(&x774, x767, x762, x745); + fiat_p256_scalar_cmovznz_u32(&x775, x767, x764, x747); + out1[0] = x768; + out1[1] = x769; + out1[2] = x770; + out1[3] = x771; + out1[4] = x772; + out1[5] = x773; + out1[6] = x774; + out1[7] = x775; +} + +/* + * The function fiat_p256_scalar_add adds two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_add(fiat_p256_scalar_montgomery_domain_field_element out1, const fiat_p256_scalar_montgomery_domain_field_element arg1, const fiat_p256_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + fiat_p256_scalar_uint1 x2; + uint32_t x3; + fiat_p256_scalar_uint1 x4; + uint32_t x5; + fiat_p256_scalar_uint1 x6; + uint32_t x7; + fiat_p256_scalar_uint1 x8; + uint32_t x9; + fiat_p256_scalar_uint1 x10; + uint32_t x11; + fiat_p256_scalar_uint1 x12; + uint32_t x13; + fiat_p256_scalar_uint1 x14; + uint32_t x15; + fiat_p256_scalar_uint1 x16; + uint32_t x17; + fiat_p256_scalar_uint1 x18; + uint32_t x19; + fiat_p256_scalar_uint1 x20; + uint32_t x21; + fiat_p256_scalar_uint1 x22; + uint32_t x23; + fiat_p256_scalar_uint1 x24; + uint32_t x25; + fiat_p256_scalar_uint1 x26; + uint32_t x27; + fiat_p256_scalar_uint1 x28; + uint32_t x29; + fiat_p256_scalar_uint1 x30; + uint32_t x31; + fiat_p256_scalar_uint1 x32; + uint32_t x33; + fiat_p256_scalar_uint1 x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + uint32_t x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + fiat_p256_scalar_addcarryx_u32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_p256_scalar_addcarryx_u32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_p256_scalar_addcarryx_u32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_p256_scalar_addcarryx_u32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_p256_scalar_addcarryx_u32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_p256_scalar_addcarryx_u32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_p256_scalar_addcarryx_u32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + fiat_p256_scalar_addcarryx_u32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + fiat_p256_scalar_subborrowx_u32(&x17, &x18, 0x0, x1, UINT32_C(0xfc632551)); + fiat_p256_scalar_subborrowx_u32(&x19, &x20, x18, x3, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_subborrowx_u32(&x21, &x22, x20, x5, UINT32_C(0xa7179e84)); + fiat_p256_scalar_subborrowx_u32(&x23, &x24, x22, x7, UINT32_C(0xbce6faad)); + fiat_p256_scalar_subborrowx_u32(&x25, &x26, x24, x9, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x27, &x28, x26, x11, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x29, &x30, x28, x13, 0x0); + fiat_p256_scalar_subborrowx_u32(&x31, &x32, x30, x15, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x33, &x34, x32, x16, 0x0); + fiat_p256_scalar_cmovznz_u32(&x35, x34, x17, x1); + fiat_p256_scalar_cmovznz_u32(&x36, x34, x19, x3); + fiat_p256_scalar_cmovznz_u32(&x37, x34, x21, x5); + fiat_p256_scalar_cmovznz_u32(&x38, x34, x23, x7); + fiat_p256_scalar_cmovznz_u32(&x39, x34, x25, x9); + fiat_p256_scalar_cmovznz_u32(&x40, x34, x27, x11); + fiat_p256_scalar_cmovznz_u32(&x41, x34, x29, x13); + fiat_p256_scalar_cmovznz_u32(&x42, x34, x31, x15); + out1[0] = x35; + out1[1] = x36; + out1[2] = x37; + out1[3] = x38; + out1[4] = x39; + out1[5] = x40; + out1[6] = x41; + out1[7] = x42; +} + +/* + * The function fiat_p256_scalar_sub subtracts two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_sub(fiat_p256_scalar_montgomery_domain_field_element out1, const fiat_p256_scalar_montgomery_domain_field_element arg1, const fiat_p256_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + fiat_p256_scalar_uint1 x2; + uint32_t x3; + fiat_p256_scalar_uint1 x4; + uint32_t x5; + fiat_p256_scalar_uint1 x6; + uint32_t x7; + fiat_p256_scalar_uint1 x8; + uint32_t x9; + fiat_p256_scalar_uint1 x10; + uint32_t x11; + fiat_p256_scalar_uint1 x12; + uint32_t x13; + fiat_p256_scalar_uint1 x14; + uint32_t x15; + fiat_p256_scalar_uint1 x16; + uint32_t x17; + uint32_t x18; + fiat_p256_scalar_uint1 x19; + uint32_t x20; + fiat_p256_scalar_uint1 x21; + uint32_t x22; + fiat_p256_scalar_uint1 x23; + uint32_t x24; + fiat_p256_scalar_uint1 x25; + uint32_t x26; + fiat_p256_scalar_uint1 x27; + uint32_t x28; + fiat_p256_scalar_uint1 x29; + uint32_t x30; + fiat_p256_scalar_uint1 x31; + uint32_t x32; + fiat_p256_scalar_uint1 x33; + fiat_p256_scalar_subborrowx_u32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_p256_scalar_subborrowx_u32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_p256_scalar_subborrowx_u32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_p256_scalar_subborrowx_u32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_p256_scalar_subborrowx_u32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_p256_scalar_subborrowx_u32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_p256_scalar_subborrowx_u32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + fiat_p256_scalar_subborrowx_u32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + fiat_p256_scalar_cmovznz_u32(&x17, x16, 0x0, UINT32_C(0xffffffff)); + fiat_p256_scalar_addcarryx_u32(&x18, &x19, 0x0, x1, (x17 & UINT32_C(0xfc632551))); + fiat_p256_scalar_addcarryx_u32(&x20, &x21, x19, x3, (x17 & UINT32_C(0xf3b9cac2))); + fiat_p256_scalar_addcarryx_u32(&x22, &x23, x21, x5, (x17 & UINT32_C(0xa7179e84))); + fiat_p256_scalar_addcarryx_u32(&x24, &x25, x23, x7, (x17 & UINT32_C(0xbce6faad))); + fiat_p256_scalar_addcarryx_u32(&x26, &x27, x25, x9, x17); + fiat_p256_scalar_addcarryx_u32(&x28, &x29, x27, x11, x17); + fiat_p256_scalar_addcarryx_u32(&x30, &x31, x29, x13, 0x0); + fiat_p256_scalar_addcarryx_u32(&x32, &x33, x31, x15, x17); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/* + * The function fiat_p256_scalar_opp negates a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_opp(fiat_p256_scalar_montgomery_domain_field_element out1, const fiat_p256_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + fiat_p256_scalar_uint1 x2; + uint32_t x3; + fiat_p256_scalar_uint1 x4; + uint32_t x5; + fiat_p256_scalar_uint1 x6; + uint32_t x7; + fiat_p256_scalar_uint1 x8; + uint32_t x9; + fiat_p256_scalar_uint1 x10; + uint32_t x11; + fiat_p256_scalar_uint1 x12; + uint32_t x13; + fiat_p256_scalar_uint1 x14; + uint32_t x15; + fiat_p256_scalar_uint1 x16; + uint32_t x17; + uint32_t x18; + fiat_p256_scalar_uint1 x19; + uint32_t x20; + fiat_p256_scalar_uint1 x21; + uint32_t x22; + fiat_p256_scalar_uint1 x23; + uint32_t x24; + fiat_p256_scalar_uint1 x25; + uint32_t x26; + fiat_p256_scalar_uint1 x27; + uint32_t x28; + fiat_p256_scalar_uint1 x29; + uint32_t x30; + fiat_p256_scalar_uint1 x31; + uint32_t x32; + fiat_p256_scalar_uint1 x33; + fiat_p256_scalar_subborrowx_u32(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_p256_scalar_subborrowx_u32(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_p256_scalar_subborrowx_u32(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_p256_scalar_subborrowx_u32(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_p256_scalar_subborrowx_u32(&x9, &x10, x8, 0x0, (arg1[4])); + fiat_p256_scalar_subborrowx_u32(&x11, &x12, x10, 0x0, (arg1[5])); + fiat_p256_scalar_subborrowx_u32(&x13, &x14, x12, 0x0, (arg1[6])); + fiat_p256_scalar_subborrowx_u32(&x15, &x16, x14, 0x0, (arg1[7])); + fiat_p256_scalar_cmovznz_u32(&x17, x16, 0x0, UINT32_C(0xffffffff)); + fiat_p256_scalar_addcarryx_u32(&x18, &x19, 0x0, x1, (x17 & UINT32_C(0xfc632551))); + fiat_p256_scalar_addcarryx_u32(&x20, &x21, x19, x3, (x17 & UINT32_C(0xf3b9cac2))); + fiat_p256_scalar_addcarryx_u32(&x22, &x23, x21, x5, (x17 & UINT32_C(0xa7179e84))); + fiat_p256_scalar_addcarryx_u32(&x24, &x25, x23, x7, (x17 & UINT32_C(0xbce6faad))); + fiat_p256_scalar_addcarryx_u32(&x26, &x27, x25, x9, x17); + fiat_p256_scalar_addcarryx_u32(&x28, &x29, x27, x11, x17); + fiat_p256_scalar_addcarryx_u32(&x30, &x31, x29, x13, 0x0); + fiat_p256_scalar_addcarryx_u32(&x32, &x33, x31, x15, x17); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/* + * The function fiat_p256_scalar_from_montgomery translates a field element out of the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_from_montgomery(fiat_p256_scalar_non_montgomery_domain_field_element out1, const fiat_p256_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + fiat_p256_scalar_uint1 x19; + uint32_t x20; + fiat_p256_scalar_uint1 x21; + uint32_t x22; + fiat_p256_scalar_uint1 x23; + uint32_t x24; + fiat_p256_scalar_uint1 x25; + uint32_t x26; + fiat_p256_scalar_uint1 x27; + uint32_t x28; + fiat_p256_scalar_uint1 x29; + uint32_t x30; + fiat_p256_scalar_uint1 x31; + uint32_t x32; + fiat_p256_scalar_uint1 x33; + uint32_t x34; + fiat_p256_scalar_uint1 x35; + uint32_t x36; + fiat_p256_scalar_uint1 x37; + uint32_t x38; + fiat_p256_scalar_uint1 x39; + uint32_t x40; + fiat_p256_scalar_uint1 x41; + uint32_t x42; + fiat_p256_scalar_uint1 x43; + uint32_t x44; + fiat_p256_scalar_uint1 x45; + uint32_t x46; + fiat_p256_scalar_uint1 x47; + uint32_t x48; + fiat_p256_scalar_uint1 x49; + uint32_t x50; + fiat_p256_scalar_uint1 x51; + uint32_t x52; + fiat_p256_scalar_uint1 x53; + uint32_t x54; + fiat_p256_scalar_uint1 x55; + uint32_t x56; + fiat_p256_scalar_uint1 x57; + uint32_t x58; + fiat_p256_scalar_uint1 x59; + uint32_t x60; + uint32_t x61; + uint32_t x62; + uint32_t x63; + uint32_t x64; + uint32_t x65; + uint32_t x66; + uint32_t x67; + uint32_t x68; + uint32_t x69; + uint32_t x70; + uint32_t x71; + uint32_t x72; + uint32_t x73; + uint32_t x74; + uint32_t x75; + uint32_t x76; + fiat_p256_scalar_uint1 x77; + uint32_t x78; + fiat_p256_scalar_uint1 x79; + uint32_t x80; + fiat_p256_scalar_uint1 x81; + uint32_t x82; + fiat_p256_scalar_uint1 x83; + uint32_t x84; + fiat_p256_scalar_uint1 x85; + uint32_t x86; + fiat_p256_scalar_uint1 x87; + uint32_t x88; + fiat_p256_scalar_uint1 x89; + uint32_t x90; + fiat_p256_scalar_uint1 x91; + uint32_t x92; + fiat_p256_scalar_uint1 x93; + uint32_t x94; + fiat_p256_scalar_uint1 x95; + uint32_t x96; + fiat_p256_scalar_uint1 x97; + uint32_t x98; + fiat_p256_scalar_uint1 x99; + uint32_t x100; + fiat_p256_scalar_uint1 x101; + uint32_t x102; + fiat_p256_scalar_uint1 x103; + uint32_t x104; + fiat_p256_scalar_uint1 x105; + uint32_t x106; + fiat_p256_scalar_uint1 x107; + uint32_t x108; + fiat_p256_scalar_uint1 x109; + uint32_t x110; + fiat_p256_scalar_uint1 x111; + uint32_t x112; + fiat_p256_scalar_uint1 x113; + uint32_t x114; + fiat_p256_scalar_uint1 x115; + uint32_t x116; + fiat_p256_scalar_uint1 x117; + uint32_t x118; + fiat_p256_scalar_uint1 x119; + uint32_t x120; + uint32_t x121; + uint32_t x122; + uint32_t x123; + uint32_t x124; + uint32_t x125; + uint32_t x126; + uint32_t x127; + uint32_t x128; + uint32_t x129; + uint32_t x130; + uint32_t x131; + uint32_t x132; + uint32_t x133; + uint32_t x134; + uint32_t x135; + uint32_t x136; + fiat_p256_scalar_uint1 x137; + uint32_t x138; + fiat_p256_scalar_uint1 x139; + uint32_t x140; + fiat_p256_scalar_uint1 x141; + uint32_t x142; + fiat_p256_scalar_uint1 x143; + uint32_t x144; + fiat_p256_scalar_uint1 x145; + uint32_t x146; + fiat_p256_scalar_uint1 x147; + uint32_t x148; + fiat_p256_scalar_uint1 x149; + uint32_t x150; + fiat_p256_scalar_uint1 x151; + uint32_t x152; + fiat_p256_scalar_uint1 x153; + uint32_t x154; + fiat_p256_scalar_uint1 x155; + uint32_t x156; + fiat_p256_scalar_uint1 x157; + uint32_t x158; + fiat_p256_scalar_uint1 x159; + uint32_t x160; + fiat_p256_scalar_uint1 x161; + uint32_t x162; + fiat_p256_scalar_uint1 x163; + uint32_t x164; + fiat_p256_scalar_uint1 x165; + uint32_t x166; + fiat_p256_scalar_uint1 x167; + uint32_t x168; + fiat_p256_scalar_uint1 x169; + uint32_t x170; + fiat_p256_scalar_uint1 x171; + uint32_t x172; + fiat_p256_scalar_uint1 x173; + uint32_t x174; + fiat_p256_scalar_uint1 x175; + uint32_t x176; + fiat_p256_scalar_uint1 x177; + uint32_t x178; + fiat_p256_scalar_uint1 x179; + uint32_t x180; + uint32_t x181; + uint32_t x182; + uint32_t x183; + uint32_t x184; + uint32_t x185; + uint32_t x186; + uint32_t x187; + uint32_t x188; + uint32_t x189; + uint32_t x190; + uint32_t x191; + uint32_t x192; + uint32_t x193; + uint32_t x194; + uint32_t x195; + uint32_t x196; + fiat_p256_scalar_uint1 x197; + uint32_t x198; + fiat_p256_scalar_uint1 x199; + uint32_t x200; + fiat_p256_scalar_uint1 x201; + uint32_t x202; + fiat_p256_scalar_uint1 x203; + uint32_t x204; + fiat_p256_scalar_uint1 x205; + uint32_t x206; + fiat_p256_scalar_uint1 x207; + uint32_t x208; + fiat_p256_scalar_uint1 x209; + uint32_t x210; + fiat_p256_scalar_uint1 x211; + uint32_t x212; + fiat_p256_scalar_uint1 x213; + uint32_t x214; + fiat_p256_scalar_uint1 x215; + uint32_t x216; + fiat_p256_scalar_uint1 x217; + uint32_t x218; + fiat_p256_scalar_uint1 x219; + uint32_t x220; + fiat_p256_scalar_uint1 x221; + uint32_t x222; + fiat_p256_scalar_uint1 x223; + uint32_t x224; + fiat_p256_scalar_uint1 x225; + uint32_t x226; + fiat_p256_scalar_uint1 x227; + uint32_t x228; + fiat_p256_scalar_uint1 x229; + uint32_t x230; + fiat_p256_scalar_uint1 x231; + uint32_t x232; + fiat_p256_scalar_uint1 x233; + uint32_t x234; + fiat_p256_scalar_uint1 x235; + uint32_t x236; + fiat_p256_scalar_uint1 x237; + uint32_t x238; + fiat_p256_scalar_uint1 x239; + uint32_t x240; + uint32_t x241; + uint32_t x242; + uint32_t x243; + uint32_t x244; + uint32_t x245; + uint32_t x246; + uint32_t x247; + uint32_t x248; + uint32_t x249; + uint32_t x250; + uint32_t x251; + uint32_t x252; + uint32_t x253; + uint32_t x254; + uint32_t x255; + uint32_t x256; + fiat_p256_scalar_uint1 x257; + uint32_t x258; + fiat_p256_scalar_uint1 x259; + uint32_t x260; + fiat_p256_scalar_uint1 x261; + uint32_t x262; + fiat_p256_scalar_uint1 x263; + uint32_t x264; + fiat_p256_scalar_uint1 x265; + uint32_t x266; + fiat_p256_scalar_uint1 x267; + uint32_t x268; + fiat_p256_scalar_uint1 x269; + uint32_t x270; + fiat_p256_scalar_uint1 x271; + uint32_t x272; + fiat_p256_scalar_uint1 x273; + uint32_t x274; + fiat_p256_scalar_uint1 x275; + uint32_t x276; + fiat_p256_scalar_uint1 x277; + uint32_t x278; + fiat_p256_scalar_uint1 x279; + uint32_t x280; + fiat_p256_scalar_uint1 x281; + uint32_t x282; + fiat_p256_scalar_uint1 x283; + uint32_t x284; + fiat_p256_scalar_uint1 x285; + uint32_t x286; + fiat_p256_scalar_uint1 x287; + uint32_t x288; + fiat_p256_scalar_uint1 x289; + uint32_t x290; + fiat_p256_scalar_uint1 x291; + uint32_t x292; + fiat_p256_scalar_uint1 x293; + uint32_t x294; + fiat_p256_scalar_uint1 x295; + uint32_t x296; + fiat_p256_scalar_uint1 x297; + uint32_t x298; + fiat_p256_scalar_uint1 x299; + uint32_t x300; + uint32_t x301; + uint32_t x302; + uint32_t x303; + uint32_t x304; + uint32_t x305; + uint32_t x306; + uint32_t x307; + uint32_t x308; + uint32_t x309; + uint32_t x310; + uint32_t x311; + uint32_t x312; + uint32_t x313; + uint32_t x314; + uint32_t x315; + uint32_t x316; + fiat_p256_scalar_uint1 x317; + uint32_t x318; + fiat_p256_scalar_uint1 x319; + uint32_t x320; + fiat_p256_scalar_uint1 x321; + uint32_t x322; + fiat_p256_scalar_uint1 x323; + uint32_t x324; + fiat_p256_scalar_uint1 x325; + uint32_t x326; + fiat_p256_scalar_uint1 x327; + uint32_t x328; + fiat_p256_scalar_uint1 x329; + uint32_t x330; + fiat_p256_scalar_uint1 x331; + uint32_t x332; + fiat_p256_scalar_uint1 x333; + uint32_t x334; + fiat_p256_scalar_uint1 x335; + uint32_t x336; + fiat_p256_scalar_uint1 x337; + uint32_t x338; + fiat_p256_scalar_uint1 x339; + uint32_t x340; + fiat_p256_scalar_uint1 x341; + uint32_t x342; + fiat_p256_scalar_uint1 x343; + uint32_t x344; + fiat_p256_scalar_uint1 x345; + uint32_t x346; + fiat_p256_scalar_uint1 x347; + uint32_t x348; + fiat_p256_scalar_uint1 x349; + uint32_t x350; + fiat_p256_scalar_uint1 x351; + uint32_t x352; + fiat_p256_scalar_uint1 x353; + uint32_t x354; + fiat_p256_scalar_uint1 x355; + uint32_t x356; + fiat_p256_scalar_uint1 x357; + uint32_t x358; + fiat_p256_scalar_uint1 x359; + uint32_t x360; + uint32_t x361; + uint32_t x362; + uint32_t x363; + uint32_t x364; + uint32_t x365; + uint32_t x366; + uint32_t x367; + uint32_t x368; + uint32_t x369; + uint32_t x370; + uint32_t x371; + uint32_t x372; + uint32_t x373; + uint32_t x374; + uint32_t x375; + uint32_t x376; + fiat_p256_scalar_uint1 x377; + uint32_t x378; + fiat_p256_scalar_uint1 x379; + uint32_t x380; + fiat_p256_scalar_uint1 x381; + uint32_t x382; + fiat_p256_scalar_uint1 x383; + uint32_t x384; + fiat_p256_scalar_uint1 x385; + uint32_t x386; + fiat_p256_scalar_uint1 x387; + uint32_t x388; + fiat_p256_scalar_uint1 x389; + uint32_t x390; + fiat_p256_scalar_uint1 x391; + uint32_t x392; + fiat_p256_scalar_uint1 x393; + uint32_t x394; + fiat_p256_scalar_uint1 x395; + uint32_t x396; + fiat_p256_scalar_uint1 x397; + uint32_t x398; + fiat_p256_scalar_uint1 x399; + uint32_t x400; + fiat_p256_scalar_uint1 x401; + uint32_t x402; + fiat_p256_scalar_uint1 x403; + uint32_t x404; + fiat_p256_scalar_uint1 x405; + uint32_t x406; + fiat_p256_scalar_uint1 x407; + uint32_t x408; + fiat_p256_scalar_uint1 x409; + uint32_t x410; + fiat_p256_scalar_uint1 x411; + uint32_t x412; + fiat_p256_scalar_uint1 x413; + uint32_t x414; + fiat_p256_scalar_uint1 x415; + uint32_t x416; + fiat_p256_scalar_uint1 x417; + uint32_t x418; + fiat_p256_scalar_uint1 x419; + uint32_t x420; + uint32_t x421; + uint32_t x422; + uint32_t x423; + uint32_t x424; + uint32_t x425; + uint32_t x426; + uint32_t x427; + uint32_t x428; + uint32_t x429; + uint32_t x430; + uint32_t x431; + uint32_t x432; + uint32_t x433; + uint32_t x434; + uint32_t x435; + uint32_t x436; + fiat_p256_scalar_uint1 x437; + uint32_t x438; + fiat_p256_scalar_uint1 x439; + uint32_t x440; + fiat_p256_scalar_uint1 x441; + uint32_t x442; + fiat_p256_scalar_uint1 x443; + uint32_t x444; + fiat_p256_scalar_uint1 x445; + uint32_t x446; + fiat_p256_scalar_uint1 x447; + uint32_t x448; + fiat_p256_scalar_uint1 x449; + uint32_t x450; + fiat_p256_scalar_uint1 x451; + uint32_t x452; + fiat_p256_scalar_uint1 x453; + uint32_t x454; + fiat_p256_scalar_uint1 x455; + uint32_t x456; + fiat_p256_scalar_uint1 x457; + uint32_t x458; + fiat_p256_scalar_uint1 x459; + uint32_t x460; + fiat_p256_scalar_uint1 x461; + uint32_t x462; + fiat_p256_scalar_uint1 x463; + uint32_t x464; + fiat_p256_scalar_uint1 x465; + uint32_t x466; + fiat_p256_scalar_uint1 x467; + uint32_t x468; + fiat_p256_scalar_uint1 x469; + uint32_t x470; + fiat_p256_scalar_uint1 x471; + uint32_t x472; + fiat_p256_scalar_uint1 x473; + uint32_t x474; + fiat_p256_scalar_uint1 x475; + uint32_t x476; + fiat_p256_scalar_uint1 x477; + uint32_t x478; + fiat_p256_scalar_uint1 x479; + uint32_t x480; + fiat_p256_scalar_uint1 x481; + uint32_t x482; + uint32_t x483; + uint32_t x484; + uint32_t x485; + uint32_t x486; + uint32_t x487; + uint32_t x488; + uint32_t x489; + x1 = (arg1[0]); + fiat_p256_scalar_mulx_u32(&x2, &x3, x1, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x4, &x5, x2, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x6, &x7, x2, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x8, &x9, x2, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x10, &x11, x2, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x12, &x13, x2, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x14, &x15, x2, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x16, &x17, x2, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x18, &x19, 0x0, x17, x14); + fiat_p256_scalar_addcarryx_u32(&x20, &x21, x19, x15, x12); + fiat_p256_scalar_addcarryx_u32(&x22, &x23, x21, x13, x10); + fiat_p256_scalar_addcarryx_u32(&x24, &x25, x23, x11, x8); + fiat_p256_scalar_addcarryx_u32(&x26, &x27, x25, x9, x6); + fiat_p256_scalar_addcarryx_u32(&x28, &x29, 0x0, x1, x16); + fiat_p256_scalar_addcarryx_u32(&x30, &x31, x29, 0x0, x18); + fiat_p256_scalar_addcarryx_u32(&x32, &x33, x31, 0x0, x20); + fiat_p256_scalar_addcarryx_u32(&x34, &x35, x33, 0x0, x22); + fiat_p256_scalar_addcarryx_u32(&x36, &x37, x35, 0x0, x24); + fiat_p256_scalar_addcarryx_u32(&x38, &x39, x37, 0x0, x26); + fiat_p256_scalar_addcarryx_u32(&x40, &x41, x39, 0x0, (x27 + x7)); + fiat_p256_scalar_addcarryx_u32(&x42, &x43, x41, 0x0, x4); + fiat_p256_scalar_addcarryx_u32(&x44, &x45, 0x0, x30, (arg1[1])); + fiat_p256_scalar_addcarryx_u32(&x46, &x47, x45, x32, 0x0); + fiat_p256_scalar_addcarryx_u32(&x48, &x49, x47, x34, 0x0); + fiat_p256_scalar_addcarryx_u32(&x50, &x51, x49, x36, 0x0); + fiat_p256_scalar_addcarryx_u32(&x52, &x53, x51, x38, 0x0); + fiat_p256_scalar_addcarryx_u32(&x54, &x55, x53, x40, 0x0); + fiat_p256_scalar_addcarryx_u32(&x56, &x57, x55, x42, 0x0); + fiat_p256_scalar_addcarryx_u32(&x58, &x59, x57, (x43 + x5), 0x0); + fiat_p256_scalar_mulx_u32(&x60, &x61, x44, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x62, &x63, x60, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x64, &x65, x60, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x66, &x67, x60, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x68, &x69, x60, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x70, &x71, x60, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x72, &x73, x60, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x74, &x75, x60, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x76, &x77, 0x0, x75, x72); + fiat_p256_scalar_addcarryx_u32(&x78, &x79, x77, x73, x70); + fiat_p256_scalar_addcarryx_u32(&x80, &x81, x79, x71, x68); + fiat_p256_scalar_addcarryx_u32(&x82, &x83, x81, x69, x66); + fiat_p256_scalar_addcarryx_u32(&x84, &x85, x83, x67, x64); + fiat_p256_scalar_addcarryx_u32(&x86, &x87, 0x0, x44, x74); + fiat_p256_scalar_addcarryx_u32(&x88, &x89, x87, x46, x76); + fiat_p256_scalar_addcarryx_u32(&x90, &x91, x89, x48, x78); + fiat_p256_scalar_addcarryx_u32(&x92, &x93, x91, x50, x80); + fiat_p256_scalar_addcarryx_u32(&x94, &x95, x93, x52, x82); + fiat_p256_scalar_addcarryx_u32(&x96, &x97, x95, x54, x84); + fiat_p256_scalar_addcarryx_u32(&x98, &x99, x97, x56, (x85 + x65)); + fiat_p256_scalar_addcarryx_u32(&x100, &x101, x99, x58, x62); + fiat_p256_scalar_addcarryx_u32(&x102, &x103, x101, x59, x63); + fiat_p256_scalar_addcarryx_u32(&x104, &x105, 0x0, x88, (arg1[2])); + fiat_p256_scalar_addcarryx_u32(&x106, &x107, x105, x90, 0x0); + fiat_p256_scalar_addcarryx_u32(&x108, &x109, x107, x92, 0x0); + fiat_p256_scalar_addcarryx_u32(&x110, &x111, x109, x94, 0x0); + fiat_p256_scalar_addcarryx_u32(&x112, &x113, x111, x96, 0x0); + fiat_p256_scalar_addcarryx_u32(&x114, &x115, x113, x98, 0x0); + fiat_p256_scalar_addcarryx_u32(&x116, &x117, x115, x100, 0x0); + fiat_p256_scalar_addcarryx_u32(&x118, &x119, x117, x102, 0x0); + fiat_p256_scalar_mulx_u32(&x120, &x121, x104, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x122, &x123, x120, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x124, &x125, x120, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x126, &x127, x120, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x128, &x129, x120, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x130, &x131, x120, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x132, &x133, x120, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x134, &x135, x120, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x136, &x137, 0x0, x135, x132); + fiat_p256_scalar_addcarryx_u32(&x138, &x139, x137, x133, x130); + fiat_p256_scalar_addcarryx_u32(&x140, &x141, x139, x131, x128); + fiat_p256_scalar_addcarryx_u32(&x142, &x143, x141, x129, x126); + fiat_p256_scalar_addcarryx_u32(&x144, &x145, x143, x127, x124); + fiat_p256_scalar_addcarryx_u32(&x146, &x147, 0x0, x104, x134); + fiat_p256_scalar_addcarryx_u32(&x148, &x149, x147, x106, x136); + fiat_p256_scalar_addcarryx_u32(&x150, &x151, x149, x108, x138); + fiat_p256_scalar_addcarryx_u32(&x152, &x153, x151, x110, x140); + fiat_p256_scalar_addcarryx_u32(&x154, &x155, x153, x112, x142); + fiat_p256_scalar_addcarryx_u32(&x156, &x157, x155, x114, x144); + fiat_p256_scalar_addcarryx_u32(&x158, &x159, x157, x116, (x145 + x125)); + fiat_p256_scalar_addcarryx_u32(&x160, &x161, x159, x118, x122); + fiat_p256_scalar_addcarryx_u32(&x162, &x163, x161, ((uint32_t)x119 + x103), x123); + fiat_p256_scalar_addcarryx_u32(&x164, &x165, 0x0, x148, (arg1[3])); + fiat_p256_scalar_addcarryx_u32(&x166, &x167, x165, x150, 0x0); + fiat_p256_scalar_addcarryx_u32(&x168, &x169, x167, x152, 0x0); + fiat_p256_scalar_addcarryx_u32(&x170, &x171, x169, x154, 0x0); + fiat_p256_scalar_addcarryx_u32(&x172, &x173, x171, x156, 0x0); + fiat_p256_scalar_addcarryx_u32(&x174, &x175, x173, x158, 0x0); + fiat_p256_scalar_addcarryx_u32(&x176, &x177, x175, x160, 0x0); + fiat_p256_scalar_addcarryx_u32(&x178, &x179, x177, x162, 0x0); + fiat_p256_scalar_mulx_u32(&x180, &x181, x164, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x182, &x183, x180, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x184, &x185, x180, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x186, &x187, x180, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x188, &x189, x180, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x190, &x191, x180, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x192, &x193, x180, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x194, &x195, x180, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x196, &x197, 0x0, x195, x192); + fiat_p256_scalar_addcarryx_u32(&x198, &x199, x197, x193, x190); + fiat_p256_scalar_addcarryx_u32(&x200, &x201, x199, x191, x188); + fiat_p256_scalar_addcarryx_u32(&x202, &x203, x201, x189, x186); + fiat_p256_scalar_addcarryx_u32(&x204, &x205, x203, x187, x184); + fiat_p256_scalar_addcarryx_u32(&x206, &x207, 0x0, x164, x194); + fiat_p256_scalar_addcarryx_u32(&x208, &x209, x207, x166, x196); + fiat_p256_scalar_addcarryx_u32(&x210, &x211, x209, x168, x198); + fiat_p256_scalar_addcarryx_u32(&x212, &x213, x211, x170, x200); + fiat_p256_scalar_addcarryx_u32(&x214, &x215, x213, x172, x202); + fiat_p256_scalar_addcarryx_u32(&x216, &x217, x215, x174, x204); + fiat_p256_scalar_addcarryx_u32(&x218, &x219, x217, x176, (x205 + x185)); + fiat_p256_scalar_addcarryx_u32(&x220, &x221, x219, x178, x182); + fiat_p256_scalar_addcarryx_u32(&x222, &x223, x221, ((uint32_t)x179 + x163), x183); + fiat_p256_scalar_addcarryx_u32(&x224, &x225, 0x0, x208, (arg1[4])); + fiat_p256_scalar_addcarryx_u32(&x226, &x227, x225, x210, 0x0); + fiat_p256_scalar_addcarryx_u32(&x228, &x229, x227, x212, 0x0); + fiat_p256_scalar_addcarryx_u32(&x230, &x231, x229, x214, 0x0); + fiat_p256_scalar_addcarryx_u32(&x232, &x233, x231, x216, 0x0); + fiat_p256_scalar_addcarryx_u32(&x234, &x235, x233, x218, 0x0); + fiat_p256_scalar_addcarryx_u32(&x236, &x237, x235, x220, 0x0); + fiat_p256_scalar_addcarryx_u32(&x238, &x239, x237, x222, 0x0); + fiat_p256_scalar_mulx_u32(&x240, &x241, x224, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x242, &x243, x240, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x244, &x245, x240, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x246, &x247, x240, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x248, &x249, x240, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x250, &x251, x240, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x252, &x253, x240, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x254, &x255, x240, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x256, &x257, 0x0, x255, x252); + fiat_p256_scalar_addcarryx_u32(&x258, &x259, x257, x253, x250); + fiat_p256_scalar_addcarryx_u32(&x260, &x261, x259, x251, x248); + fiat_p256_scalar_addcarryx_u32(&x262, &x263, x261, x249, x246); + fiat_p256_scalar_addcarryx_u32(&x264, &x265, x263, x247, x244); + fiat_p256_scalar_addcarryx_u32(&x266, &x267, 0x0, x224, x254); + fiat_p256_scalar_addcarryx_u32(&x268, &x269, x267, x226, x256); + fiat_p256_scalar_addcarryx_u32(&x270, &x271, x269, x228, x258); + fiat_p256_scalar_addcarryx_u32(&x272, &x273, x271, x230, x260); + fiat_p256_scalar_addcarryx_u32(&x274, &x275, x273, x232, x262); + fiat_p256_scalar_addcarryx_u32(&x276, &x277, x275, x234, x264); + fiat_p256_scalar_addcarryx_u32(&x278, &x279, x277, x236, (x265 + x245)); + fiat_p256_scalar_addcarryx_u32(&x280, &x281, x279, x238, x242); + fiat_p256_scalar_addcarryx_u32(&x282, &x283, x281, ((uint32_t)x239 + x223), x243); + fiat_p256_scalar_addcarryx_u32(&x284, &x285, 0x0, x268, (arg1[5])); + fiat_p256_scalar_addcarryx_u32(&x286, &x287, x285, x270, 0x0); + fiat_p256_scalar_addcarryx_u32(&x288, &x289, x287, x272, 0x0); + fiat_p256_scalar_addcarryx_u32(&x290, &x291, x289, x274, 0x0); + fiat_p256_scalar_addcarryx_u32(&x292, &x293, x291, x276, 0x0); + fiat_p256_scalar_addcarryx_u32(&x294, &x295, x293, x278, 0x0); + fiat_p256_scalar_addcarryx_u32(&x296, &x297, x295, x280, 0x0); + fiat_p256_scalar_addcarryx_u32(&x298, &x299, x297, x282, 0x0); + fiat_p256_scalar_mulx_u32(&x300, &x301, x284, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x302, &x303, x300, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x304, &x305, x300, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x306, &x307, x300, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x308, &x309, x300, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x310, &x311, x300, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x312, &x313, x300, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x314, &x315, x300, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x316, &x317, 0x0, x315, x312); + fiat_p256_scalar_addcarryx_u32(&x318, &x319, x317, x313, x310); + fiat_p256_scalar_addcarryx_u32(&x320, &x321, x319, x311, x308); + fiat_p256_scalar_addcarryx_u32(&x322, &x323, x321, x309, x306); + fiat_p256_scalar_addcarryx_u32(&x324, &x325, x323, x307, x304); + fiat_p256_scalar_addcarryx_u32(&x326, &x327, 0x0, x284, x314); + fiat_p256_scalar_addcarryx_u32(&x328, &x329, x327, x286, x316); + fiat_p256_scalar_addcarryx_u32(&x330, &x331, x329, x288, x318); + fiat_p256_scalar_addcarryx_u32(&x332, &x333, x331, x290, x320); + fiat_p256_scalar_addcarryx_u32(&x334, &x335, x333, x292, x322); + fiat_p256_scalar_addcarryx_u32(&x336, &x337, x335, x294, x324); + fiat_p256_scalar_addcarryx_u32(&x338, &x339, x337, x296, (x325 + x305)); + fiat_p256_scalar_addcarryx_u32(&x340, &x341, x339, x298, x302); + fiat_p256_scalar_addcarryx_u32(&x342, &x343, x341, ((uint32_t)x299 + x283), x303); + fiat_p256_scalar_addcarryx_u32(&x344, &x345, 0x0, x328, (arg1[6])); + fiat_p256_scalar_addcarryx_u32(&x346, &x347, x345, x330, 0x0); + fiat_p256_scalar_addcarryx_u32(&x348, &x349, x347, x332, 0x0); + fiat_p256_scalar_addcarryx_u32(&x350, &x351, x349, x334, 0x0); + fiat_p256_scalar_addcarryx_u32(&x352, &x353, x351, x336, 0x0); + fiat_p256_scalar_addcarryx_u32(&x354, &x355, x353, x338, 0x0); + fiat_p256_scalar_addcarryx_u32(&x356, &x357, x355, x340, 0x0); + fiat_p256_scalar_addcarryx_u32(&x358, &x359, x357, x342, 0x0); + fiat_p256_scalar_mulx_u32(&x360, &x361, x344, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x362, &x363, x360, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x364, &x365, x360, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x366, &x367, x360, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x368, &x369, x360, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x370, &x371, x360, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x372, &x373, x360, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x374, &x375, x360, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x376, &x377, 0x0, x375, x372); + fiat_p256_scalar_addcarryx_u32(&x378, &x379, x377, x373, x370); + fiat_p256_scalar_addcarryx_u32(&x380, &x381, x379, x371, x368); + fiat_p256_scalar_addcarryx_u32(&x382, &x383, x381, x369, x366); + fiat_p256_scalar_addcarryx_u32(&x384, &x385, x383, x367, x364); + fiat_p256_scalar_addcarryx_u32(&x386, &x387, 0x0, x344, x374); + fiat_p256_scalar_addcarryx_u32(&x388, &x389, x387, x346, x376); + fiat_p256_scalar_addcarryx_u32(&x390, &x391, x389, x348, x378); + fiat_p256_scalar_addcarryx_u32(&x392, &x393, x391, x350, x380); + fiat_p256_scalar_addcarryx_u32(&x394, &x395, x393, x352, x382); + fiat_p256_scalar_addcarryx_u32(&x396, &x397, x395, x354, x384); + fiat_p256_scalar_addcarryx_u32(&x398, &x399, x397, x356, (x385 + x365)); + fiat_p256_scalar_addcarryx_u32(&x400, &x401, x399, x358, x362); + fiat_p256_scalar_addcarryx_u32(&x402, &x403, x401, ((uint32_t)x359 + x343), x363); + fiat_p256_scalar_addcarryx_u32(&x404, &x405, 0x0, x388, (arg1[7])); + fiat_p256_scalar_addcarryx_u32(&x406, &x407, x405, x390, 0x0); + fiat_p256_scalar_addcarryx_u32(&x408, &x409, x407, x392, 0x0); + fiat_p256_scalar_addcarryx_u32(&x410, &x411, x409, x394, 0x0); + fiat_p256_scalar_addcarryx_u32(&x412, &x413, x411, x396, 0x0); + fiat_p256_scalar_addcarryx_u32(&x414, &x415, x413, x398, 0x0); + fiat_p256_scalar_addcarryx_u32(&x416, &x417, x415, x400, 0x0); + fiat_p256_scalar_addcarryx_u32(&x418, &x419, x417, x402, 0x0); + fiat_p256_scalar_mulx_u32(&x420, &x421, x404, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x422, &x423, x420, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x424, &x425, x420, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x426, &x427, x420, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x428, &x429, x420, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x430, &x431, x420, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x432, &x433, x420, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x434, &x435, x420, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x436, &x437, 0x0, x435, x432); + fiat_p256_scalar_addcarryx_u32(&x438, &x439, x437, x433, x430); + fiat_p256_scalar_addcarryx_u32(&x440, &x441, x439, x431, x428); + fiat_p256_scalar_addcarryx_u32(&x442, &x443, x441, x429, x426); + fiat_p256_scalar_addcarryx_u32(&x444, &x445, x443, x427, x424); + fiat_p256_scalar_addcarryx_u32(&x446, &x447, 0x0, x404, x434); + fiat_p256_scalar_addcarryx_u32(&x448, &x449, x447, x406, x436); + fiat_p256_scalar_addcarryx_u32(&x450, &x451, x449, x408, x438); + fiat_p256_scalar_addcarryx_u32(&x452, &x453, x451, x410, x440); + fiat_p256_scalar_addcarryx_u32(&x454, &x455, x453, x412, x442); + fiat_p256_scalar_addcarryx_u32(&x456, &x457, x455, x414, x444); + fiat_p256_scalar_addcarryx_u32(&x458, &x459, x457, x416, (x445 + x425)); + fiat_p256_scalar_addcarryx_u32(&x460, &x461, x459, x418, x422); + fiat_p256_scalar_addcarryx_u32(&x462, &x463, x461, ((uint32_t)x419 + x403), x423); + fiat_p256_scalar_subborrowx_u32(&x464, &x465, 0x0, x448, UINT32_C(0xfc632551)); + fiat_p256_scalar_subborrowx_u32(&x466, &x467, x465, x450, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_subborrowx_u32(&x468, &x469, x467, x452, UINT32_C(0xa7179e84)); + fiat_p256_scalar_subborrowx_u32(&x470, &x471, x469, x454, UINT32_C(0xbce6faad)); + fiat_p256_scalar_subborrowx_u32(&x472, &x473, x471, x456, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x474, &x475, x473, x458, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x476, &x477, x475, x460, 0x0); + fiat_p256_scalar_subborrowx_u32(&x478, &x479, x477, x462, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x480, &x481, x479, x463, 0x0); + fiat_p256_scalar_cmovznz_u32(&x482, x481, x464, x448); + fiat_p256_scalar_cmovznz_u32(&x483, x481, x466, x450); + fiat_p256_scalar_cmovznz_u32(&x484, x481, x468, x452); + fiat_p256_scalar_cmovznz_u32(&x485, x481, x470, x454); + fiat_p256_scalar_cmovznz_u32(&x486, x481, x472, x456); + fiat_p256_scalar_cmovznz_u32(&x487, x481, x474, x458); + fiat_p256_scalar_cmovznz_u32(&x488, x481, x476, x460); + fiat_p256_scalar_cmovznz_u32(&x489, x481, x478, x462); + out1[0] = x482; + out1[1] = x483; + out1[2] = x484; + out1[3] = x485; + out1[4] = x486; + out1[5] = x487; + out1[6] = x488; + out1[7] = x489; +} + +/* + * The function fiat_p256_scalar_to_montgomery translates a field element into the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = eval arg1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_to_montgomery(fiat_p256_scalar_montgomery_domain_field_element out1, const fiat_p256_scalar_non_montgomery_domain_field_element arg1) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + fiat_p256_scalar_uint1 x26; + uint32_t x27; + fiat_p256_scalar_uint1 x28; + uint32_t x29; + fiat_p256_scalar_uint1 x30; + uint32_t x31; + fiat_p256_scalar_uint1 x32; + uint32_t x33; + fiat_p256_scalar_uint1 x34; + uint32_t x35; + fiat_p256_scalar_uint1 x36; + uint32_t x37; + fiat_p256_scalar_uint1 x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + uint32_t x53; + uint32_t x54; + uint32_t x55; + fiat_p256_scalar_uint1 x56; + uint32_t x57; + fiat_p256_scalar_uint1 x58; + uint32_t x59; + fiat_p256_scalar_uint1 x60; + uint32_t x61; + fiat_p256_scalar_uint1 x62; + uint32_t x63; + fiat_p256_scalar_uint1 x64; + uint32_t x65; + fiat_p256_scalar_uint1 x66; + uint32_t x67; + fiat_p256_scalar_uint1 x68; + uint32_t x69; + fiat_p256_scalar_uint1 x70; + uint32_t x71; + fiat_p256_scalar_uint1 x72; + uint32_t x73; + fiat_p256_scalar_uint1 x74; + uint32_t x75; + fiat_p256_scalar_uint1 x76; + uint32_t x77; + fiat_p256_scalar_uint1 x78; + uint32_t x79; + fiat_p256_scalar_uint1 x80; + uint32_t x81; + fiat_p256_scalar_uint1 x82; + uint32_t x83; + uint32_t x84; + uint32_t x85; + uint32_t x86; + uint32_t x87; + uint32_t x88; + uint32_t x89; + uint32_t x90; + uint32_t x91; + uint32_t x92; + uint32_t x93; + uint32_t x94; + uint32_t x95; + uint32_t x96; + uint32_t x97; + uint32_t x98; + uint32_t x99; + fiat_p256_scalar_uint1 x100; + uint32_t x101; + fiat_p256_scalar_uint1 x102; + uint32_t x103; + fiat_p256_scalar_uint1 x104; + uint32_t x105; + fiat_p256_scalar_uint1 x106; + uint32_t x107; + fiat_p256_scalar_uint1 x108; + uint32_t x109; + fiat_p256_scalar_uint1 x110; + uint32_t x111; + fiat_p256_scalar_uint1 x112; + uint32_t x113; + fiat_p256_scalar_uint1 x114; + uint32_t x115; + fiat_p256_scalar_uint1 x116; + uint32_t x117; + fiat_p256_scalar_uint1 x118; + uint32_t x119; + fiat_p256_scalar_uint1 x120; + uint32_t x121; + fiat_p256_scalar_uint1 x122; + uint32_t x123; + fiat_p256_scalar_uint1 x124; + uint32_t x125; + fiat_p256_scalar_uint1 x126; + uint32_t x127; + fiat_p256_scalar_uint1 x128; + uint32_t x129; + uint32_t x130; + uint32_t x131; + uint32_t x132; + uint32_t x133; + uint32_t x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + uint32_t x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + uint32_t x145; + fiat_p256_scalar_uint1 x146; + uint32_t x147; + fiat_p256_scalar_uint1 x148; + uint32_t x149; + fiat_p256_scalar_uint1 x150; + uint32_t x151; + fiat_p256_scalar_uint1 x152; + uint32_t x153; + fiat_p256_scalar_uint1 x154; + uint32_t x155; + fiat_p256_scalar_uint1 x156; + uint32_t x157; + fiat_p256_scalar_uint1 x158; + uint32_t x159; + fiat_p256_scalar_uint1 x160; + uint32_t x161; + fiat_p256_scalar_uint1 x162; + uint32_t x163; + fiat_p256_scalar_uint1 x164; + uint32_t x165; + fiat_p256_scalar_uint1 x166; + uint32_t x167; + fiat_p256_scalar_uint1 x168; + uint32_t x169; + fiat_p256_scalar_uint1 x170; + uint32_t x171; + fiat_p256_scalar_uint1 x172; + uint32_t x173; + uint32_t x174; + uint32_t x175; + uint32_t x176; + uint32_t x177; + uint32_t x178; + uint32_t x179; + uint32_t x180; + uint32_t x181; + uint32_t x182; + uint32_t x183; + uint32_t x184; + uint32_t x185; + uint32_t x186; + uint32_t x187; + uint32_t x188; + uint32_t x189; + fiat_p256_scalar_uint1 x190; + uint32_t x191; + fiat_p256_scalar_uint1 x192; + uint32_t x193; + fiat_p256_scalar_uint1 x194; + uint32_t x195; + fiat_p256_scalar_uint1 x196; + uint32_t x197; + fiat_p256_scalar_uint1 x198; + uint32_t x199; + fiat_p256_scalar_uint1 x200; + uint32_t x201; + fiat_p256_scalar_uint1 x202; + uint32_t x203; + fiat_p256_scalar_uint1 x204; + uint32_t x205; + fiat_p256_scalar_uint1 x206; + uint32_t x207; + fiat_p256_scalar_uint1 x208; + uint32_t x209; + fiat_p256_scalar_uint1 x210; + uint32_t x211; + fiat_p256_scalar_uint1 x212; + uint32_t x213; + fiat_p256_scalar_uint1 x214; + uint32_t x215; + fiat_p256_scalar_uint1 x216; + uint32_t x217; + fiat_p256_scalar_uint1 x218; + uint32_t x219; + uint32_t x220; + uint32_t x221; + uint32_t x222; + uint32_t x223; + uint32_t x224; + uint32_t x225; + uint32_t x226; + uint32_t x227; + uint32_t x228; + uint32_t x229; + uint32_t x230; + uint32_t x231; + uint32_t x232; + uint32_t x233; + uint32_t x234; + uint32_t x235; + fiat_p256_scalar_uint1 x236; + uint32_t x237; + fiat_p256_scalar_uint1 x238; + uint32_t x239; + fiat_p256_scalar_uint1 x240; + uint32_t x241; + fiat_p256_scalar_uint1 x242; + uint32_t x243; + fiat_p256_scalar_uint1 x244; + uint32_t x245; + fiat_p256_scalar_uint1 x246; + uint32_t x247; + fiat_p256_scalar_uint1 x248; + uint32_t x249; + fiat_p256_scalar_uint1 x250; + uint32_t x251; + fiat_p256_scalar_uint1 x252; + uint32_t x253; + fiat_p256_scalar_uint1 x254; + uint32_t x255; + fiat_p256_scalar_uint1 x256; + uint32_t x257; + fiat_p256_scalar_uint1 x258; + uint32_t x259; + fiat_p256_scalar_uint1 x260; + uint32_t x261; + fiat_p256_scalar_uint1 x262; + uint32_t x263; + uint32_t x264; + uint32_t x265; + uint32_t x266; + uint32_t x267; + uint32_t x268; + uint32_t x269; + uint32_t x270; + uint32_t x271; + uint32_t x272; + uint32_t x273; + uint32_t x274; + uint32_t x275; + uint32_t x276; + uint32_t x277; + uint32_t x278; + uint32_t x279; + fiat_p256_scalar_uint1 x280; + uint32_t x281; + fiat_p256_scalar_uint1 x282; + uint32_t x283; + fiat_p256_scalar_uint1 x284; + uint32_t x285; + fiat_p256_scalar_uint1 x286; + uint32_t x287; + fiat_p256_scalar_uint1 x288; + uint32_t x289; + fiat_p256_scalar_uint1 x290; + uint32_t x291; + fiat_p256_scalar_uint1 x292; + uint32_t x293; + fiat_p256_scalar_uint1 x294; + uint32_t x295; + fiat_p256_scalar_uint1 x296; + uint32_t x297; + fiat_p256_scalar_uint1 x298; + uint32_t x299; + fiat_p256_scalar_uint1 x300; + uint32_t x301; + fiat_p256_scalar_uint1 x302; + uint32_t x303; + fiat_p256_scalar_uint1 x304; + uint32_t x305; + fiat_p256_scalar_uint1 x306; + uint32_t x307; + fiat_p256_scalar_uint1 x308; + uint32_t x309; + uint32_t x310; + uint32_t x311; + uint32_t x312; + uint32_t x313; + uint32_t x314; + uint32_t x315; + uint32_t x316; + uint32_t x317; + uint32_t x318; + uint32_t x319; + uint32_t x320; + uint32_t x321; + uint32_t x322; + uint32_t x323; + uint32_t x324; + uint32_t x325; + fiat_p256_scalar_uint1 x326; + uint32_t x327; + fiat_p256_scalar_uint1 x328; + uint32_t x329; + fiat_p256_scalar_uint1 x330; + uint32_t x331; + fiat_p256_scalar_uint1 x332; + uint32_t x333; + fiat_p256_scalar_uint1 x334; + uint32_t x335; + fiat_p256_scalar_uint1 x336; + uint32_t x337; + fiat_p256_scalar_uint1 x338; + uint32_t x339; + fiat_p256_scalar_uint1 x340; + uint32_t x341; + fiat_p256_scalar_uint1 x342; + uint32_t x343; + fiat_p256_scalar_uint1 x344; + uint32_t x345; + fiat_p256_scalar_uint1 x346; + uint32_t x347; + fiat_p256_scalar_uint1 x348; + uint32_t x349; + fiat_p256_scalar_uint1 x350; + uint32_t x351; + fiat_p256_scalar_uint1 x352; + uint32_t x353; + uint32_t x354; + uint32_t x355; + uint32_t x356; + uint32_t x357; + uint32_t x358; + uint32_t x359; + uint32_t x360; + uint32_t x361; + uint32_t x362; + uint32_t x363; + uint32_t x364; + uint32_t x365; + uint32_t x366; + uint32_t x367; + uint32_t x368; + uint32_t x369; + fiat_p256_scalar_uint1 x370; + uint32_t x371; + fiat_p256_scalar_uint1 x372; + uint32_t x373; + fiat_p256_scalar_uint1 x374; + uint32_t x375; + fiat_p256_scalar_uint1 x376; + uint32_t x377; + fiat_p256_scalar_uint1 x378; + uint32_t x379; + fiat_p256_scalar_uint1 x380; + uint32_t x381; + fiat_p256_scalar_uint1 x382; + uint32_t x383; + fiat_p256_scalar_uint1 x384; + uint32_t x385; + fiat_p256_scalar_uint1 x386; + uint32_t x387; + fiat_p256_scalar_uint1 x388; + uint32_t x389; + fiat_p256_scalar_uint1 x390; + uint32_t x391; + fiat_p256_scalar_uint1 x392; + uint32_t x393; + fiat_p256_scalar_uint1 x394; + uint32_t x395; + fiat_p256_scalar_uint1 x396; + uint32_t x397; + fiat_p256_scalar_uint1 x398; + uint32_t x399; + uint32_t x400; + uint32_t x401; + uint32_t x402; + uint32_t x403; + uint32_t x404; + uint32_t x405; + uint32_t x406; + uint32_t x407; + uint32_t x408; + uint32_t x409; + uint32_t x410; + uint32_t x411; + uint32_t x412; + uint32_t x413; + uint32_t x414; + uint32_t x415; + fiat_p256_scalar_uint1 x416; + uint32_t x417; + fiat_p256_scalar_uint1 x418; + uint32_t x419; + fiat_p256_scalar_uint1 x420; + uint32_t x421; + fiat_p256_scalar_uint1 x422; + uint32_t x423; + fiat_p256_scalar_uint1 x424; + uint32_t x425; + fiat_p256_scalar_uint1 x426; + uint32_t x427; + fiat_p256_scalar_uint1 x428; + uint32_t x429; + fiat_p256_scalar_uint1 x430; + uint32_t x431; + fiat_p256_scalar_uint1 x432; + uint32_t x433; + fiat_p256_scalar_uint1 x434; + uint32_t x435; + fiat_p256_scalar_uint1 x436; + uint32_t x437; + fiat_p256_scalar_uint1 x438; + uint32_t x439; + fiat_p256_scalar_uint1 x440; + uint32_t x441; + fiat_p256_scalar_uint1 x442; + uint32_t x443; + uint32_t x444; + uint32_t x445; + uint32_t x446; + uint32_t x447; + uint32_t x448; + uint32_t x449; + uint32_t x450; + uint32_t x451; + uint32_t x452; + uint32_t x453; + uint32_t x454; + uint32_t x455; + uint32_t x456; + uint32_t x457; + uint32_t x458; + uint32_t x459; + fiat_p256_scalar_uint1 x460; + uint32_t x461; + fiat_p256_scalar_uint1 x462; + uint32_t x463; + fiat_p256_scalar_uint1 x464; + uint32_t x465; + fiat_p256_scalar_uint1 x466; + uint32_t x467; + fiat_p256_scalar_uint1 x468; + uint32_t x469; + fiat_p256_scalar_uint1 x470; + uint32_t x471; + fiat_p256_scalar_uint1 x472; + uint32_t x473; + fiat_p256_scalar_uint1 x474; + uint32_t x475; + fiat_p256_scalar_uint1 x476; + uint32_t x477; + fiat_p256_scalar_uint1 x478; + uint32_t x479; + fiat_p256_scalar_uint1 x480; + uint32_t x481; + fiat_p256_scalar_uint1 x482; + uint32_t x483; + fiat_p256_scalar_uint1 x484; + uint32_t x485; + fiat_p256_scalar_uint1 x486; + uint32_t x487; + fiat_p256_scalar_uint1 x488; + uint32_t x489; + uint32_t x490; + uint32_t x491; + uint32_t x492; + uint32_t x493; + uint32_t x494; + uint32_t x495; + uint32_t x496; + uint32_t x497; + uint32_t x498; + uint32_t x499; + uint32_t x500; + uint32_t x501; + uint32_t x502; + uint32_t x503; + uint32_t x504; + uint32_t x505; + fiat_p256_scalar_uint1 x506; + uint32_t x507; + fiat_p256_scalar_uint1 x508; + uint32_t x509; + fiat_p256_scalar_uint1 x510; + uint32_t x511; + fiat_p256_scalar_uint1 x512; + uint32_t x513; + fiat_p256_scalar_uint1 x514; + uint32_t x515; + fiat_p256_scalar_uint1 x516; + uint32_t x517; + fiat_p256_scalar_uint1 x518; + uint32_t x519; + fiat_p256_scalar_uint1 x520; + uint32_t x521; + fiat_p256_scalar_uint1 x522; + uint32_t x523; + fiat_p256_scalar_uint1 x524; + uint32_t x525; + fiat_p256_scalar_uint1 x526; + uint32_t x527; + fiat_p256_scalar_uint1 x528; + uint32_t x529; + fiat_p256_scalar_uint1 x530; + uint32_t x531; + fiat_p256_scalar_uint1 x532; + uint32_t x533; + uint32_t x534; + uint32_t x535; + uint32_t x536; + uint32_t x537; + uint32_t x538; + uint32_t x539; + uint32_t x540; + uint32_t x541; + uint32_t x542; + uint32_t x543; + uint32_t x544; + uint32_t x545; + uint32_t x546; + uint32_t x547; + uint32_t x548; + uint32_t x549; + fiat_p256_scalar_uint1 x550; + uint32_t x551; + fiat_p256_scalar_uint1 x552; + uint32_t x553; + fiat_p256_scalar_uint1 x554; + uint32_t x555; + fiat_p256_scalar_uint1 x556; + uint32_t x557; + fiat_p256_scalar_uint1 x558; + uint32_t x559; + fiat_p256_scalar_uint1 x560; + uint32_t x561; + fiat_p256_scalar_uint1 x562; + uint32_t x563; + fiat_p256_scalar_uint1 x564; + uint32_t x565; + fiat_p256_scalar_uint1 x566; + uint32_t x567; + fiat_p256_scalar_uint1 x568; + uint32_t x569; + fiat_p256_scalar_uint1 x570; + uint32_t x571; + fiat_p256_scalar_uint1 x572; + uint32_t x573; + fiat_p256_scalar_uint1 x574; + uint32_t x575; + fiat_p256_scalar_uint1 x576; + uint32_t x577; + fiat_p256_scalar_uint1 x578; + uint32_t x579; + uint32_t x580; + uint32_t x581; + uint32_t x582; + uint32_t x583; + uint32_t x584; + uint32_t x585; + uint32_t x586; + uint32_t x587; + uint32_t x588; + uint32_t x589; + uint32_t x590; + uint32_t x591; + uint32_t x592; + uint32_t x593; + uint32_t x594; + uint32_t x595; + fiat_p256_scalar_uint1 x596; + uint32_t x597; + fiat_p256_scalar_uint1 x598; + uint32_t x599; + fiat_p256_scalar_uint1 x600; + uint32_t x601; + fiat_p256_scalar_uint1 x602; + uint32_t x603; + fiat_p256_scalar_uint1 x604; + uint32_t x605; + fiat_p256_scalar_uint1 x606; + uint32_t x607; + fiat_p256_scalar_uint1 x608; + uint32_t x609; + fiat_p256_scalar_uint1 x610; + uint32_t x611; + fiat_p256_scalar_uint1 x612; + uint32_t x613; + fiat_p256_scalar_uint1 x614; + uint32_t x615; + fiat_p256_scalar_uint1 x616; + uint32_t x617; + fiat_p256_scalar_uint1 x618; + uint32_t x619; + fiat_p256_scalar_uint1 x620; + uint32_t x621; + fiat_p256_scalar_uint1 x622; + uint32_t x623; + uint32_t x624; + uint32_t x625; + uint32_t x626; + uint32_t x627; + uint32_t x628; + uint32_t x629; + uint32_t x630; + uint32_t x631; + uint32_t x632; + uint32_t x633; + uint32_t x634; + uint32_t x635; + uint32_t x636; + uint32_t x637; + uint32_t x638; + uint32_t x639; + fiat_p256_scalar_uint1 x640; + uint32_t x641; + fiat_p256_scalar_uint1 x642; + uint32_t x643; + fiat_p256_scalar_uint1 x644; + uint32_t x645; + fiat_p256_scalar_uint1 x646; + uint32_t x647; + fiat_p256_scalar_uint1 x648; + uint32_t x649; + fiat_p256_scalar_uint1 x650; + uint32_t x651; + fiat_p256_scalar_uint1 x652; + uint32_t x653; + fiat_p256_scalar_uint1 x654; + uint32_t x655; + fiat_p256_scalar_uint1 x656; + uint32_t x657; + fiat_p256_scalar_uint1 x658; + uint32_t x659; + fiat_p256_scalar_uint1 x660; + uint32_t x661; + fiat_p256_scalar_uint1 x662; + uint32_t x663; + fiat_p256_scalar_uint1 x664; + uint32_t x665; + fiat_p256_scalar_uint1 x666; + uint32_t x667; + fiat_p256_scalar_uint1 x668; + uint32_t x669; + uint32_t x670; + uint32_t x671; + uint32_t x672; + uint32_t x673; + uint32_t x674; + uint32_t x675; + uint32_t x676; + uint32_t x677; + uint32_t x678; + uint32_t x679; + uint32_t x680; + uint32_t x681; + uint32_t x682; + uint32_t x683; + uint32_t x684; + uint32_t x685; + fiat_p256_scalar_uint1 x686; + uint32_t x687; + fiat_p256_scalar_uint1 x688; + uint32_t x689; + fiat_p256_scalar_uint1 x690; + uint32_t x691; + fiat_p256_scalar_uint1 x692; + uint32_t x693; + fiat_p256_scalar_uint1 x694; + uint32_t x695; + fiat_p256_scalar_uint1 x696; + uint32_t x697; + fiat_p256_scalar_uint1 x698; + uint32_t x699; + fiat_p256_scalar_uint1 x700; + uint32_t x701; + fiat_p256_scalar_uint1 x702; + uint32_t x703; + fiat_p256_scalar_uint1 x704; + uint32_t x705; + fiat_p256_scalar_uint1 x706; + uint32_t x707; + fiat_p256_scalar_uint1 x708; + uint32_t x709; + fiat_p256_scalar_uint1 x710; + uint32_t x711; + fiat_p256_scalar_uint1 x712; + uint32_t x713; + fiat_p256_scalar_uint1 x714; + uint32_t x715; + fiat_p256_scalar_uint1 x716; + uint32_t x717; + fiat_p256_scalar_uint1 x718; + uint32_t x719; + fiat_p256_scalar_uint1 x720; + uint32_t x721; + fiat_p256_scalar_uint1 x722; + uint32_t x723; + fiat_p256_scalar_uint1 x724; + uint32_t x725; + fiat_p256_scalar_uint1 x726; + uint32_t x727; + fiat_p256_scalar_uint1 x728; + uint32_t x729; + fiat_p256_scalar_uint1 x730; + uint32_t x731; + uint32_t x732; + uint32_t x733; + uint32_t x734; + uint32_t x735; + uint32_t x736; + uint32_t x737; + uint32_t x738; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[6]); + x7 = (arg1[7]); + x8 = (arg1[0]); + fiat_p256_scalar_mulx_u32(&x9, &x10, x8, UINT32_C(0x66e12d94)); + fiat_p256_scalar_mulx_u32(&x11, &x12, x8, UINT32_C(0xf3d95620)); + fiat_p256_scalar_mulx_u32(&x13, &x14, x8, UINT32_C(0x2845b239)); + fiat_p256_scalar_mulx_u32(&x15, &x16, x8, UINT32_C(0x2b6bec59)); + fiat_p256_scalar_mulx_u32(&x17, &x18, x8, UINT32_C(0x4699799c)); + fiat_p256_scalar_mulx_u32(&x19, &x20, x8, UINT32_C(0x49bd6fa6)); + fiat_p256_scalar_mulx_u32(&x21, &x22, x8, UINT32_C(0x83244c95)); + fiat_p256_scalar_mulx_u32(&x23, &x24, x8, UINT32_C(0xbe79eea2)); + fiat_p256_scalar_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_p256_scalar_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_p256_scalar_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_p256_scalar_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_p256_scalar_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_p256_scalar_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_p256_scalar_addcarryx_u32(&x37, &x38, x36, x12, x9); + fiat_p256_scalar_mulx_u32(&x39, &x40, x23, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x41, &x42, x39, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x43, &x44, x39, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x45, &x46, x39, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x47, &x48, x39, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x49, &x50, x39, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x51, &x52, x39, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x53, &x54, x39, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x55, &x56, 0x0, x54, x51); + fiat_p256_scalar_addcarryx_u32(&x57, &x58, x56, x52, x49); + fiat_p256_scalar_addcarryx_u32(&x59, &x60, x58, x50, x47); + fiat_p256_scalar_addcarryx_u32(&x61, &x62, x60, x48, x45); + fiat_p256_scalar_addcarryx_u32(&x63, &x64, x62, x46, x43); + fiat_p256_scalar_addcarryx_u32(&x65, &x66, 0x0, x23, x53); + fiat_p256_scalar_addcarryx_u32(&x67, &x68, x66, x25, x55); + fiat_p256_scalar_addcarryx_u32(&x69, &x70, x68, x27, x57); + fiat_p256_scalar_addcarryx_u32(&x71, &x72, x70, x29, x59); + fiat_p256_scalar_addcarryx_u32(&x73, &x74, x72, x31, x61); + fiat_p256_scalar_addcarryx_u32(&x75, &x76, x74, x33, x63); + fiat_p256_scalar_addcarryx_u32(&x77, &x78, x76, x35, (x64 + x44)); + fiat_p256_scalar_addcarryx_u32(&x79, &x80, x78, x37, x41); + fiat_p256_scalar_addcarryx_u32(&x81, &x82, x80, (x38 + x10), x42); + fiat_p256_scalar_mulx_u32(&x83, &x84, x1, UINT32_C(0x66e12d94)); + fiat_p256_scalar_mulx_u32(&x85, &x86, x1, UINT32_C(0xf3d95620)); + fiat_p256_scalar_mulx_u32(&x87, &x88, x1, UINT32_C(0x2845b239)); + fiat_p256_scalar_mulx_u32(&x89, &x90, x1, UINT32_C(0x2b6bec59)); + fiat_p256_scalar_mulx_u32(&x91, &x92, x1, UINT32_C(0x4699799c)); + fiat_p256_scalar_mulx_u32(&x93, &x94, x1, UINT32_C(0x49bd6fa6)); + fiat_p256_scalar_mulx_u32(&x95, &x96, x1, UINT32_C(0x83244c95)); + fiat_p256_scalar_mulx_u32(&x97, &x98, x1, UINT32_C(0xbe79eea2)); + fiat_p256_scalar_addcarryx_u32(&x99, &x100, 0x0, x98, x95); + fiat_p256_scalar_addcarryx_u32(&x101, &x102, x100, x96, x93); + fiat_p256_scalar_addcarryx_u32(&x103, &x104, x102, x94, x91); + fiat_p256_scalar_addcarryx_u32(&x105, &x106, x104, x92, x89); + fiat_p256_scalar_addcarryx_u32(&x107, &x108, x106, x90, x87); + fiat_p256_scalar_addcarryx_u32(&x109, &x110, x108, x88, x85); + fiat_p256_scalar_addcarryx_u32(&x111, &x112, x110, x86, x83); + fiat_p256_scalar_addcarryx_u32(&x113, &x114, 0x0, x67, x97); + fiat_p256_scalar_addcarryx_u32(&x115, &x116, x114, x69, x99); + fiat_p256_scalar_addcarryx_u32(&x117, &x118, x116, x71, x101); + fiat_p256_scalar_addcarryx_u32(&x119, &x120, x118, x73, x103); + fiat_p256_scalar_addcarryx_u32(&x121, &x122, x120, x75, x105); + fiat_p256_scalar_addcarryx_u32(&x123, &x124, x122, x77, x107); + fiat_p256_scalar_addcarryx_u32(&x125, &x126, x124, x79, x109); + fiat_p256_scalar_addcarryx_u32(&x127, &x128, x126, x81, x111); + fiat_p256_scalar_mulx_u32(&x129, &x130, x113, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x131, &x132, x129, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x133, &x134, x129, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x135, &x136, x129, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x137, &x138, x129, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x139, &x140, x129, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x141, &x142, x129, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x143, &x144, x129, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x145, &x146, 0x0, x144, x141); + fiat_p256_scalar_addcarryx_u32(&x147, &x148, x146, x142, x139); + fiat_p256_scalar_addcarryx_u32(&x149, &x150, x148, x140, x137); + fiat_p256_scalar_addcarryx_u32(&x151, &x152, x150, x138, x135); + fiat_p256_scalar_addcarryx_u32(&x153, &x154, x152, x136, x133); + fiat_p256_scalar_addcarryx_u32(&x155, &x156, 0x0, x113, x143); + fiat_p256_scalar_addcarryx_u32(&x157, &x158, x156, x115, x145); + fiat_p256_scalar_addcarryx_u32(&x159, &x160, x158, x117, x147); + fiat_p256_scalar_addcarryx_u32(&x161, &x162, x160, x119, x149); + fiat_p256_scalar_addcarryx_u32(&x163, &x164, x162, x121, x151); + fiat_p256_scalar_addcarryx_u32(&x165, &x166, x164, x123, x153); + fiat_p256_scalar_addcarryx_u32(&x167, &x168, x166, x125, (x154 + x134)); + fiat_p256_scalar_addcarryx_u32(&x169, &x170, x168, x127, x131); + fiat_p256_scalar_addcarryx_u32(&x171, &x172, x170, (((uint32_t)x128 + x82) + (x112 + x84)), x132); + fiat_p256_scalar_mulx_u32(&x173, &x174, x2, UINT32_C(0x66e12d94)); + fiat_p256_scalar_mulx_u32(&x175, &x176, x2, UINT32_C(0xf3d95620)); + fiat_p256_scalar_mulx_u32(&x177, &x178, x2, UINT32_C(0x2845b239)); + fiat_p256_scalar_mulx_u32(&x179, &x180, x2, UINT32_C(0x2b6bec59)); + fiat_p256_scalar_mulx_u32(&x181, &x182, x2, UINT32_C(0x4699799c)); + fiat_p256_scalar_mulx_u32(&x183, &x184, x2, UINT32_C(0x49bd6fa6)); + fiat_p256_scalar_mulx_u32(&x185, &x186, x2, UINT32_C(0x83244c95)); + fiat_p256_scalar_mulx_u32(&x187, &x188, x2, UINT32_C(0xbe79eea2)); + fiat_p256_scalar_addcarryx_u32(&x189, &x190, 0x0, x188, x185); + fiat_p256_scalar_addcarryx_u32(&x191, &x192, x190, x186, x183); + fiat_p256_scalar_addcarryx_u32(&x193, &x194, x192, x184, x181); + fiat_p256_scalar_addcarryx_u32(&x195, &x196, x194, x182, x179); + fiat_p256_scalar_addcarryx_u32(&x197, &x198, x196, x180, x177); + fiat_p256_scalar_addcarryx_u32(&x199, &x200, x198, x178, x175); + fiat_p256_scalar_addcarryx_u32(&x201, &x202, x200, x176, x173); + fiat_p256_scalar_addcarryx_u32(&x203, &x204, 0x0, x157, x187); + fiat_p256_scalar_addcarryx_u32(&x205, &x206, x204, x159, x189); + fiat_p256_scalar_addcarryx_u32(&x207, &x208, x206, x161, x191); + fiat_p256_scalar_addcarryx_u32(&x209, &x210, x208, x163, x193); + fiat_p256_scalar_addcarryx_u32(&x211, &x212, x210, x165, x195); + fiat_p256_scalar_addcarryx_u32(&x213, &x214, x212, x167, x197); + fiat_p256_scalar_addcarryx_u32(&x215, &x216, x214, x169, x199); + fiat_p256_scalar_addcarryx_u32(&x217, &x218, x216, x171, x201); + fiat_p256_scalar_mulx_u32(&x219, &x220, x203, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x221, &x222, x219, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x223, &x224, x219, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x225, &x226, x219, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x227, &x228, x219, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x229, &x230, x219, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x231, &x232, x219, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x233, &x234, x219, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x235, &x236, 0x0, x234, x231); + fiat_p256_scalar_addcarryx_u32(&x237, &x238, x236, x232, x229); + fiat_p256_scalar_addcarryx_u32(&x239, &x240, x238, x230, x227); + fiat_p256_scalar_addcarryx_u32(&x241, &x242, x240, x228, x225); + fiat_p256_scalar_addcarryx_u32(&x243, &x244, x242, x226, x223); + fiat_p256_scalar_addcarryx_u32(&x245, &x246, 0x0, x203, x233); + fiat_p256_scalar_addcarryx_u32(&x247, &x248, x246, x205, x235); + fiat_p256_scalar_addcarryx_u32(&x249, &x250, x248, x207, x237); + fiat_p256_scalar_addcarryx_u32(&x251, &x252, x250, x209, x239); + fiat_p256_scalar_addcarryx_u32(&x253, &x254, x252, x211, x241); + fiat_p256_scalar_addcarryx_u32(&x255, &x256, x254, x213, x243); + fiat_p256_scalar_addcarryx_u32(&x257, &x258, x256, x215, (x244 + x224)); + fiat_p256_scalar_addcarryx_u32(&x259, &x260, x258, x217, x221); + fiat_p256_scalar_addcarryx_u32(&x261, &x262, x260, (((uint32_t)x218 + x172) + (x202 + x174)), x222); + fiat_p256_scalar_mulx_u32(&x263, &x264, x3, UINT32_C(0x66e12d94)); + fiat_p256_scalar_mulx_u32(&x265, &x266, x3, UINT32_C(0xf3d95620)); + fiat_p256_scalar_mulx_u32(&x267, &x268, x3, UINT32_C(0x2845b239)); + fiat_p256_scalar_mulx_u32(&x269, &x270, x3, UINT32_C(0x2b6bec59)); + fiat_p256_scalar_mulx_u32(&x271, &x272, x3, UINT32_C(0x4699799c)); + fiat_p256_scalar_mulx_u32(&x273, &x274, x3, UINT32_C(0x49bd6fa6)); + fiat_p256_scalar_mulx_u32(&x275, &x276, x3, UINT32_C(0x83244c95)); + fiat_p256_scalar_mulx_u32(&x277, &x278, x3, UINT32_C(0xbe79eea2)); + fiat_p256_scalar_addcarryx_u32(&x279, &x280, 0x0, x278, x275); + fiat_p256_scalar_addcarryx_u32(&x281, &x282, x280, x276, x273); + fiat_p256_scalar_addcarryx_u32(&x283, &x284, x282, x274, x271); + fiat_p256_scalar_addcarryx_u32(&x285, &x286, x284, x272, x269); + fiat_p256_scalar_addcarryx_u32(&x287, &x288, x286, x270, x267); + fiat_p256_scalar_addcarryx_u32(&x289, &x290, x288, x268, x265); + fiat_p256_scalar_addcarryx_u32(&x291, &x292, x290, x266, x263); + fiat_p256_scalar_addcarryx_u32(&x293, &x294, 0x0, x247, x277); + fiat_p256_scalar_addcarryx_u32(&x295, &x296, x294, x249, x279); + fiat_p256_scalar_addcarryx_u32(&x297, &x298, x296, x251, x281); + fiat_p256_scalar_addcarryx_u32(&x299, &x300, x298, x253, x283); + fiat_p256_scalar_addcarryx_u32(&x301, &x302, x300, x255, x285); + fiat_p256_scalar_addcarryx_u32(&x303, &x304, x302, x257, x287); + fiat_p256_scalar_addcarryx_u32(&x305, &x306, x304, x259, x289); + fiat_p256_scalar_addcarryx_u32(&x307, &x308, x306, x261, x291); + fiat_p256_scalar_mulx_u32(&x309, &x310, x293, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x311, &x312, x309, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x313, &x314, x309, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x315, &x316, x309, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x317, &x318, x309, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x319, &x320, x309, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x321, &x322, x309, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x323, &x324, x309, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x325, &x326, 0x0, x324, x321); + fiat_p256_scalar_addcarryx_u32(&x327, &x328, x326, x322, x319); + fiat_p256_scalar_addcarryx_u32(&x329, &x330, x328, x320, x317); + fiat_p256_scalar_addcarryx_u32(&x331, &x332, x330, x318, x315); + fiat_p256_scalar_addcarryx_u32(&x333, &x334, x332, x316, x313); + fiat_p256_scalar_addcarryx_u32(&x335, &x336, 0x0, x293, x323); + fiat_p256_scalar_addcarryx_u32(&x337, &x338, x336, x295, x325); + fiat_p256_scalar_addcarryx_u32(&x339, &x340, x338, x297, x327); + fiat_p256_scalar_addcarryx_u32(&x341, &x342, x340, x299, x329); + fiat_p256_scalar_addcarryx_u32(&x343, &x344, x342, x301, x331); + fiat_p256_scalar_addcarryx_u32(&x345, &x346, x344, x303, x333); + fiat_p256_scalar_addcarryx_u32(&x347, &x348, x346, x305, (x334 + x314)); + fiat_p256_scalar_addcarryx_u32(&x349, &x350, x348, x307, x311); + fiat_p256_scalar_addcarryx_u32(&x351, &x352, x350, (((uint32_t)x308 + x262) + (x292 + x264)), x312); + fiat_p256_scalar_mulx_u32(&x353, &x354, x4, UINT32_C(0x66e12d94)); + fiat_p256_scalar_mulx_u32(&x355, &x356, x4, UINT32_C(0xf3d95620)); + fiat_p256_scalar_mulx_u32(&x357, &x358, x4, UINT32_C(0x2845b239)); + fiat_p256_scalar_mulx_u32(&x359, &x360, x4, UINT32_C(0x2b6bec59)); + fiat_p256_scalar_mulx_u32(&x361, &x362, x4, UINT32_C(0x4699799c)); + fiat_p256_scalar_mulx_u32(&x363, &x364, x4, UINT32_C(0x49bd6fa6)); + fiat_p256_scalar_mulx_u32(&x365, &x366, x4, UINT32_C(0x83244c95)); + fiat_p256_scalar_mulx_u32(&x367, &x368, x4, UINT32_C(0xbe79eea2)); + fiat_p256_scalar_addcarryx_u32(&x369, &x370, 0x0, x368, x365); + fiat_p256_scalar_addcarryx_u32(&x371, &x372, x370, x366, x363); + fiat_p256_scalar_addcarryx_u32(&x373, &x374, x372, x364, x361); + fiat_p256_scalar_addcarryx_u32(&x375, &x376, x374, x362, x359); + fiat_p256_scalar_addcarryx_u32(&x377, &x378, x376, x360, x357); + fiat_p256_scalar_addcarryx_u32(&x379, &x380, x378, x358, x355); + fiat_p256_scalar_addcarryx_u32(&x381, &x382, x380, x356, x353); + fiat_p256_scalar_addcarryx_u32(&x383, &x384, 0x0, x337, x367); + fiat_p256_scalar_addcarryx_u32(&x385, &x386, x384, x339, x369); + fiat_p256_scalar_addcarryx_u32(&x387, &x388, x386, x341, x371); + fiat_p256_scalar_addcarryx_u32(&x389, &x390, x388, x343, x373); + fiat_p256_scalar_addcarryx_u32(&x391, &x392, x390, x345, x375); + fiat_p256_scalar_addcarryx_u32(&x393, &x394, x392, x347, x377); + fiat_p256_scalar_addcarryx_u32(&x395, &x396, x394, x349, x379); + fiat_p256_scalar_addcarryx_u32(&x397, &x398, x396, x351, x381); + fiat_p256_scalar_mulx_u32(&x399, &x400, x383, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x401, &x402, x399, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x403, &x404, x399, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x405, &x406, x399, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x407, &x408, x399, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x409, &x410, x399, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x411, &x412, x399, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x413, &x414, x399, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x415, &x416, 0x0, x414, x411); + fiat_p256_scalar_addcarryx_u32(&x417, &x418, x416, x412, x409); + fiat_p256_scalar_addcarryx_u32(&x419, &x420, x418, x410, x407); + fiat_p256_scalar_addcarryx_u32(&x421, &x422, x420, x408, x405); + fiat_p256_scalar_addcarryx_u32(&x423, &x424, x422, x406, x403); + fiat_p256_scalar_addcarryx_u32(&x425, &x426, 0x0, x383, x413); + fiat_p256_scalar_addcarryx_u32(&x427, &x428, x426, x385, x415); + fiat_p256_scalar_addcarryx_u32(&x429, &x430, x428, x387, x417); + fiat_p256_scalar_addcarryx_u32(&x431, &x432, x430, x389, x419); + fiat_p256_scalar_addcarryx_u32(&x433, &x434, x432, x391, x421); + fiat_p256_scalar_addcarryx_u32(&x435, &x436, x434, x393, x423); + fiat_p256_scalar_addcarryx_u32(&x437, &x438, x436, x395, (x424 + x404)); + fiat_p256_scalar_addcarryx_u32(&x439, &x440, x438, x397, x401); + fiat_p256_scalar_addcarryx_u32(&x441, &x442, x440, (((uint32_t)x398 + x352) + (x382 + x354)), x402); + fiat_p256_scalar_mulx_u32(&x443, &x444, x5, UINT32_C(0x66e12d94)); + fiat_p256_scalar_mulx_u32(&x445, &x446, x5, UINT32_C(0xf3d95620)); + fiat_p256_scalar_mulx_u32(&x447, &x448, x5, UINT32_C(0x2845b239)); + fiat_p256_scalar_mulx_u32(&x449, &x450, x5, UINT32_C(0x2b6bec59)); + fiat_p256_scalar_mulx_u32(&x451, &x452, x5, UINT32_C(0x4699799c)); + fiat_p256_scalar_mulx_u32(&x453, &x454, x5, UINT32_C(0x49bd6fa6)); + fiat_p256_scalar_mulx_u32(&x455, &x456, x5, UINT32_C(0x83244c95)); + fiat_p256_scalar_mulx_u32(&x457, &x458, x5, UINT32_C(0xbe79eea2)); + fiat_p256_scalar_addcarryx_u32(&x459, &x460, 0x0, x458, x455); + fiat_p256_scalar_addcarryx_u32(&x461, &x462, x460, x456, x453); + fiat_p256_scalar_addcarryx_u32(&x463, &x464, x462, x454, x451); + fiat_p256_scalar_addcarryx_u32(&x465, &x466, x464, x452, x449); + fiat_p256_scalar_addcarryx_u32(&x467, &x468, x466, x450, x447); + fiat_p256_scalar_addcarryx_u32(&x469, &x470, x468, x448, x445); + fiat_p256_scalar_addcarryx_u32(&x471, &x472, x470, x446, x443); + fiat_p256_scalar_addcarryx_u32(&x473, &x474, 0x0, x427, x457); + fiat_p256_scalar_addcarryx_u32(&x475, &x476, x474, x429, x459); + fiat_p256_scalar_addcarryx_u32(&x477, &x478, x476, x431, x461); + fiat_p256_scalar_addcarryx_u32(&x479, &x480, x478, x433, x463); + fiat_p256_scalar_addcarryx_u32(&x481, &x482, x480, x435, x465); + fiat_p256_scalar_addcarryx_u32(&x483, &x484, x482, x437, x467); + fiat_p256_scalar_addcarryx_u32(&x485, &x486, x484, x439, x469); + fiat_p256_scalar_addcarryx_u32(&x487, &x488, x486, x441, x471); + fiat_p256_scalar_mulx_u32(&x489, &x490, x473, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x491, &x492, x489, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x493, &x494, x489, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x495, &x496, x489, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x497, &x498, x489, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x499, &x500, x489, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x501, &x502, x489, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x503, &x504, x489, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x505, &x506, 0x0, x504, x501); + fiat_p256_scalar_addcarryx_u32(&x507, &x508, x506, x502, x499); + fiat_p256_scalar_addcarryx_u32(&x509, &x510, x508, x500, x497); + fiat_p256_scalar_addcarryx_u32(&x511, &x512, x510, x498, x495); + fiat_p256_scalar_addcarryx_u32(&x513, &x514, x512, x496, x493); + fiat_p256_scalar_addcarryx_u32(&x515, &x516, 0x0, x473, x503); + fiat_p256_scalar_addcarryx_u32(&x517, &x518, x516, x475, x505); + fiat_p256_scalar_addcarryx_u32(&x519, &x520, x518, x477, x507); + fiat_p256_scalar_addcarryx_u32(&x521, &x522, x520, x479, x509); + fiat_p256_scalar_addcarryx_u32(&x523, &x524, x522, x481, x511); + fiat_p256_scalar_addcarryx_u32(&x525, &x526, x524, x483, x513); + fiat_p256_scalar_addcarryx_u32(&x527, &x528, x526, x485, (x514 + x494)); + fiat_p256_scalar_addcarryx_u32(&x529, &x530, x528, x487, x491); + fiat_p256_scalar_addcarryx_u32(&x531, &x532, x530, (((uint32_t)x488 + x442) + (x472 + x444)), x492); + fiat_p256_scalar_mulx_u32(&x533, &x534, x6, UINT32_C(0x66e12d94)); + fiat_p256_scalar_mulx_u32(&x535, &x536, x6, UINT32_C(0xf3d95620)); + fiat_p256_scalar_mulx_u32(&x537, &x538, x6, UINT32_C(0x2845b239)); + fiat_p256_scalar_mulx_u32(&x539, &x540, x6, UINT32_C(0x2b6bec59)); + fiat_p256_scalar_mulx_u32(&x541, &x542, x6, UINT32_C(0x4699799c)); + fiat_p256_scalar_mulx_u32(&x543, &x544, x6, UINT32_C(0x49bd6fa6)); + fiat_p256_scalar_mulx_u32(&x545, &x546, x6, UINT32_C(0x83244c95)); + fiat_p256_scalar_mulx_u32(&x547, &x548, x6, UINT32_C(0xbe79eea2)); + fiat_p256_scalar_addcarryx_u32(&x549, &x550, 0x0, x548, x545); + fiat_p256_scalar_addcarryx_u32(&x551, &x552, x550, x546, x543); + fiat_p256_scalar_addcarryx_u32(&x553, &x554, x552, x544, x541); + fiat_p256_scalar_addcarryx_u32(&x555, &x556, x554, x542, x539); + fiat_p256_scalar_addcarryx_u32(&x557, &x558, x556, x540, x537); + fiat_p256_scalar_addcarryx_u32(&x559, &x560, x558, x538, x535); + fiat_p256_scalar_addcarryx_u32(&x561, &x562, x560, x536, x533); + fiat_p256_scalar_addcarryx_u32(&x563, &x564, 0x0, x517, x547); + fiat_p256_scalar_addcarryx_u32(&x565, &x566, x564, x519, x549); + fiat_p256_scalar_addcarryx_u32(&x567, &x568, x566, x521, x551); + fiat_p256_scalar_addcarryx_u32(&x569, &x570, x568, x523, x553); + fiat_p256_scalar_addcarryx_u32(&x571, &x572, x570, x525, x555); + fiat_p256_scalar_addcarryx_u32(&x573, &x574, x572, x527, x557); + fiat_p256_scalar_addcarryx_u32(&x575, &x576, x574, x529, x559); + fiat_p256_scalar_addcarryx_u32(&x577, &x578, x576, x531, x561); + fiat_p256_scalar_mulx_u32(&x579, &x580, x563, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x581, &x582, x579, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x583, &x584, x579, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x585, &x586, x579, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x587, &x588, x579, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x589, &x590, x579, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x591, &x592, x579, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x593, &x594, x579, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x595, &x596, 0x0, x594, x591); + fiat_p256_scalar_addcarryx_u32(&x597, &x598, x596, x592, x589); + fiat_p256_scalar_addcarryx_u32(&x599, &x600, x598, x590, x587); + fiat_p256_scalar_addcarryx_u32(&x601, &x602, x600, x588, x585); + fiat_p256_scalar_addcarryx_u32(&x603, &x604, x602, x586, x583); + fiat_p256_scalar_addcarryx_u32(&x605, &x606, 0x0, x563, x593); + fiat_p256_scalar_addcarryx_u32(&x607, &x608, x606, x565, x595); + fiat_p256_scalar_addcarryx_u32(&x609, &x610, x608, x567, x597); + fiat_p256_scalar_addcarryx_u32(&x611, &x612, x610, x569, x599); + fiat_p256_scalar_addcarryx_u32(&x613, &x614, x612, x571, x601); + fiat_p256_scalar_addcarryx_u32(&x615, &x616, x614, x573, x603); + fiat_p256_scalar_addcarryx_u32(&x617, &x618, x616, x575, (x604 + x584)); + fiat_p256_scalar_addcarryx_u32(&x619, &x620, x618, x577, x581); + fiat_p256_scalar_addcarryx_u32(&x621, &x622, x620, (((uint32_t)x578 + x532) + (x562 + x534)), x582); + fiat_p256_scalar_mulx_u32(&x623, &x624, x7, UINT32_C(0x66e12d94)); + fiat_p256_scalar_mulx_u32(&x625, &x626, x7, UINT32_C(0xf3d95620)); + fiat_p256_scalar_mulx_u32(&x627, &x628, x7, UINT32_C(0x2845b239)); + fiat_p256_scalar_mulx_u32(&x629, &x630, x7, UINT32_C(0x2b6bec59)); + fiat_p256_scalar_mulx_u32(&x631, &x632, x7, UINT32_C(0x4699799c)); + fiat_p256_scalar_mulx_u32(&x633, &x634, x7, UINT32_C(0x49bd6fa6)); + fiat_p256_scalar_mulx_u32(&x635, &x636, x7, UINT32_C(0x83244c95)); + fiat_p256_scalar_mulx_u32(&x637, &x638, x7, UINT32_C(0xbe79eea2)); + fiat_p256_scalar_addcarryx_u32(&x639, &x640, 0x0, x638, x635); + fiat_p256_scalar_addcarryx_u32(&x641, &x642, x640, x636, x633); + fiat_p256_scalar_addcarryx_u32(&x643, &x644, x642, x634, x631); + fiat_p256_scalar_addcarryx_u32(&x645, &x646, x644, x632, x629); + fiat_p256_scalar_addcarryx_u32(&x647, &x648, x646, x630, x627); + fiat_p256_scalar_addcarryx_u32(&x649, &x650, x648, x628, x625); + fiat_p256_scalar_addcarryx_u32(&x651, &x652, x650, x626, x623); + fiat_p256_scalar_addcarryx_u32(&x653, &x654, 0x0, x607, x637); + fiat_p256_scalar_addcarryx_u32(&x655, &x656, x654, x609, x639); + fiat_p256_scalar_addcarryx_u32(&x657, &x658, x656, x611, x641); + fiat_p256_scalar_addcarryx_u32(&x659, &x660, x658, x613, x643); + fiat_p256_scalar_addcarryx_u32(&x661, &x662, x660, x615, x645); + fiat_p256_scalar_addcarryx_u32(&x663, &x664, x662, x617, x647); + fiat_p256_scalar_addcarryx_u32(&x665, &x666, x664, x619, x649); + fiat_p256_scalar_addcarryx_u32(&x667, &x668, x666, x621, x651); + fiat_p256_scalar_mulx_u32(&x669, &x670, x653, UINT32_C(0xee00bc4f)); + fiat_p256_scalar_mulx_u32(&x671, &x672, x669, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x673, &x674, x669, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x675, &x676, x669, UINT32_C(0xffffffff)); + fiat_p256_scalar_mulx_u32(&x677, &x678, x669, UINT32_C(0xbce6faad)); + fiat_p256_scalar_mulx_u32(&x679, &x680, x669, UINT32_C(0xa7179e84)); + fiat_p256_scalar_mulx_u32(&x681, &x682, x669, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_mulx_u32(&x683, &x684, x669, UINT32_C(0xfc632551)); + fiat_p256_scalar_addcarryx_u32(&x685, &x686, 0x0, x684, x681); + fiat_p256_scalar_addcarryx_u32(&x687, &x688, x686, x682, x679); + fiat_p256_scalar_addcarryx_u32(&x689, &x690, x688, x680, x677); + fiat_p256_scalar_addcarryx_u32(&x691, &x692, x690, x678, x675); + fiat_p256_scalar_addcarryx_u32(&x693, &x694, x692, x676, x673); + fiat_p256_scalar_addcarryx_u32(&x695, &x696, 0x0, x653, x683); + fiat_p256_scalar_addcarryx_u32(&x697, &x698, x696, x655, x685); + fiat_p256_scalar_addcarryx_u32(&x699, &x700, x698, x657, x687); + fiat_p256_scalar_addcarryx_u32(&x701, &x702, x700, x659, x689); + fiat_p256_scalar_addcarryx_u32(&x703, &x704, x702, x661, x691); + fiat_p256_scalar_addcarryx_u32(&x705, &x706, x704, x663, x693); + fiat_p256_scalar_addcarryx_u32(&x707, &x708, x706, x665, (x694 + x674)); + fiat_p256_scalar_addcarryx_u32(&x709, &x710, x708, x667, x671); + fiat_p256_scalar_addcarryx_u32(&x711, &x712, x710, (((uint32_t)x668 + x622) + (x652 + x624)), x672); + fiat_p256_scalar_subborrowx_u32(&x713, &x714, 0x0, x697, UINT32_C(0xfc632551)); + fiat_p256_scalar_subborrowx_u32(&x715, &x716, x714, x699, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_subborrowx_u32(&x717, &x718, x716, x701, UINT32_C(0xa7179e84)); + fiat_p256_scalar_subborrowx_u32(&x719, &x720, x718, x703, UINT32_C(0xbce6faad)); + fiat_p256_scalar_subborrowx_u32(&x721, &x722, x720, x705, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x723, &x724, x722, x707, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x725, &x726, x724, x709, 0x0); + fiat_p256_scalar_subborrowx_u32(&x727, &x728, x726, x711, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x729, &x730, x728, x712, 0x0); + fiat_p256_scalar_cmovznz_u32(&x731, x730, x713, x697); + fiat_p256_scalar_cmovznz_u32(&x732, x730, x715, x699); + fiat_p256_scalar_cmovznz_u32(&x733, x730, x717, x701); + fiat_p256_scalar_cmovznz_u32(&x734, x730, x719, x703); + fiat_p256_scalar_cmovznz_u32(&x735, x730, x721, x705); + fiat_p256_scalar_cmovznz_u32(&x736, x730, x723, x707); + fiat_p256_scalar_cmovznz_u32(&x737, x730, x725, x709); + fiat_p256_scalar_cmovznz_u32(&x738, x730, x727, x711); + out1[0] = x731; + out1[1] = x732; + out1[2] = x733; + out1[3] = x734; + out1[4] = x735; + out1[5] = x736; + out1[6] = x737; + out1[7] = x738; +} + +/* + * The function fiat_p256_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_nonzero(uint32_t* out1, const uint32_t arg1[8]) { + uint32_t x1; + x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | (arg1[7])))))))); + *out1 = x1; +} + +/* + * The function fiat_p256_scalar_selectznz is a multi-limb conditional select. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_selectznz(uint32_t out1[8], fiat_p256_scalar_uint1 arg1, const uint32_t arg2[8], const uint32_t arg3[8]) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + fiat_p256_scalar_cmovznz_u32(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_p256_scalar_cmovznz_u32(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_p256_scalar_cmovznz_u32(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_p256_scalar_cmovznz_u32(&x4, arg1, (arg2[3]), (arg3[3])); + fiat_p256_scalar_cmovznz_u32(&x5, arg1, (arg2[4]), (arg3[4])); + fiat_p256_scalar_cmovznz_u32(&x6, arg1, (arg2[5]), (arg3[5])); + fiat_p256_scalar_cmovznz_u32(&x7, arg1, (arg2[6]), (arg3[6])); + fiat_p256_scalar_cmovznz_u32(&x8, arg1, (arg2[7]), (arg3[7])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; + out1[6] = x7; + out1[7] = x8; +} + +/* + * The function fiat_p256_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_to_bytes(uint8_t out1[32], const uint32_t arg1[8]) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint8_t x9; + uint32_t x10; + uint8_t x11; + uint32_t x12; + uint8_t x13; + uint8_t x14; + uint8_t x15; + uint32_t x16; + uint8_t x17; + uint32_t x18; + uint8_t x19; + uint8_t x20; + uint8_t x21; + uint32_t x22; + uint8_t x23; + uint32_t x24; + uint8_t x25; + uint8_t x26; + uint8_t x27; + uint32_t x28; + uint8_t x29; + uint32_t x30; + uint8_t x31; + uint8_t x32; + uint8_t x33; + uint32_t x34; + uint8_t x35; + uint32_t x36; + uint8_t x37; + uint8_t x38; + uint8_t x39; + uint32_t x40; + uint8_t x41; + uint32_t x42; + uint8_t x43; + uint8_t x44; + uint8_t x45; + uint32_t x46; + uint8_t x47; + uint32_t x48; + uint8_t x49; + uint8_t x50; + uint8_t x51; + uint32_t x52; + uint8_t x53; + uint32_t x54; + uint8_t x55; + uint8_t x56; + x1 = (arg1[7]); + x2 = (arg1[6]); + x3 = (arg1[5]); + x4 = (arg1[4]); + x5 = (arg1[3]); + x6 = (arg1[2]); + x7 = (arg1[1]); + x8 = (arg1[0]); + x9 = (uint8_t)(x8 & UINT8_C(0xff)); + x10 = (x8 >> 8); + x11 = (uint8_t)(x10 & UINT8_C(0xff)); + x12 = (x10 >> 8); + x13 = (uint8_t)(x12 & UINT8_C(0xff)); + x14 = (uint8_t)(x12 >> 8); + x15 = (uint8_t)(x7 & UINT8_C(0xff)); + x16 = (x7 >> 8); + x17 = (uint8_t)(x16 & UINT8_C(0xff)); + x18 = (x16 >> 8); + x19 = (uint8_t)(x18 & UINT8_C(0xff)); + x20 = (uint8_t)(x18 >> 8); + x21 = (uint8_t)(x6 & UINT8_C(0xff)); + x22 = (x6 >> 8); + x23 = (uint8_t)(x22 & UINT8_C(0xff)); + x24 = (x22 >> 8); + x25 = (uint8_t)(x24 & UINT8_C(0xff)); + x26 = (uint8_t)(x24 >> 8); + x27 = (uint8_t)(x5 & UINT8_C(0xff)); + x28 = (x5 >> 8); + x29 = (uint8_t)(x28 & UINT8_C(0xff)); + x30 = (x28 >> 8); + x31 = (uint8_t)(x30 & UINT8_C(0xff)); + x32 = (uint8_t)(x30 >> 8); + x33 = (uint8_t)(x4 & UINT8_C(0xff)); + x34 = (x4 >> 8); + x35 = (uint8_t)(x34 & UINT8_C(0xff)); + x36 = (x34 >> 8); + x37 = (uint8_t)(x36 & UINT8_C(0xff)); + x38 = (uint8_t)(x36 >> 8); + x39 = (uint8_t)(x3 & UINT8_C(0xff)); + x40 = (x3 >> 8); + x41 = (uint8_t)(x40 & UINT8_C(0xff)); + x42 = (x40 >> 8); + x43 = (uint8_t)(x42 & UINT8_C(0xff)); + x44 = (uint8_t)(x42 >> 8); + x45 = (uint8_t)(x2 & UINT8_C(0xff)); + x46 = (x2 >> 8); + x47 = (uint8_t)(x46 & UINT8_C(0xff)); + x48 = (x46 >> 8); + x49 = (uint8_t)(x48 & UINT8_C(0xff)); + x50 = (uint8_t)(x48 >> 8); + x51 = (uint8_t)(x1 & UINT8_C(0xff)); + x52 = (x1 >> 8); + x53 = (uint8_t)(x52 & UINT8_C(0xff)); + x54 = (x52 >> 8); + x55 = (uint8_t)(x54 & UINT8_C(0xff)); + x56 = (uint8_t)(x54 >> 8); + out1[0] = x9; + out1[1] = x11; + out1[2] = x13; + out1[3] = x14; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x26; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x38; + out1[20] = x39; + out1[21] = x41; + out1[22] = x43; + out1[23] = x44; + out1[24] = x45; + out1[25] = x47; + out1[26] = x49; + out1[27] = x50; + out1[28] = x51; + out1[29] = x53; + out1[30] = x55; + out1[31] = x56; +} + +/* + * The function fiat_p256_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. + * + * Preconditions: + * 0 ≤ bytes_eval arg1 < m + * Postconditions: + * eval out1 mod m = bytes_eval arg1 mod m + * 0 ≤ eval out1 < m + * + * Input Bounds: + * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_from_bytes(uint32_t out1[8], const uint8_t arg1[32]) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint8_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint8_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint8_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint8_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint8_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint8_t x24; + uint32_t x25; + uint32_t x26; + uint32_t x27; + uint8_t x28; + uint32_t x29; + uint32_t x30; + uint32_t x31; + uint8_t x32; + uint32_t x33; + uint32_t x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + uint32_t x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + uint32_t x53; + uint32_t x54; + uint32_t x55; + uint32_t x56; + x1 = ((uint32_t)(arg1[31]) << 24); + x2 = ((uint32_t)(arg1[30]) << 16); + x3 = ((uint32_t)(arg1[29]) << 8); + x4 = (arg1[28]); + x5 = ((uint32_t)(arg1[27]) << 24); + x6 = ((uint32_t)(arg1[26]) << 16); + x7 = ((uint32_t)(arg1[25]) << 8); + x8 = (arg1[24]); + x9 = ((uint32_t)(arg1[23]) << 24); + x10 = ((uint32_t)(arg1[22]) << 16); + x11 = ((uint32_t)(arg1[21]) << 8); + x12 = (arg1[20]); + x13 = ((uint32_t)(arg1[19]) << 24); + x14 = ((uint32_t)(arg1[18]) << 16); + x15 = ((uint32_t)(arg1[17]) << 8); + x16 = (arg1[16]); + x17 = ((uint32_t)(arg1[15]) << 24); + x18 = ((uint32_t)(arg1[14]) << 16); + x19 = ((uint32_t)(arg1[13]) << 8); + x20 = (arg1[12]); + x21 = ((uint32_t)(arg1[11]) << 24); + x22 = ((uint32_t)(arg1[10]) << 16); + x23 = ((uint32_t)(arg1[9]) << 8); + x24 = (arg1[8]); + x25 = ((uint32_t)(arg1[7]) << 24); + x26 = ((uint32_t)(arg1[6]) << 16); + x27 = ((uint32_t)(arg1[5]) << 8); + x28 = (arg1[4]); + x29 = ((uint32_t)(arg1[3]) << 24); + x30 = ((uint32_t)(arg1[2]) << 16); + x31 = ((uint32_t)(arg1[1]) << 8); + x32 = (arg1[0]); + x33 = (x31 + (uint32_t)x32); + x34 = (x30 + x33); + x35 = (x29 + x34); + x36 = (x27 + (uint32_t)x28); + x37 = (x26 + x36); + x38 = (x25 + x37); + x39 = (x23 + (uint32_t)x24); + x40 = (x22 + x39); + x41 = (x21 + x40); + x42 = (x19 + (uint32_t)x20); + x43 = (x18 + x42); + x44 = (x17 + x43); + x45 = (x15 + (uint32_t)x16); + x46 = (x14 + x45); + x47 = (x13 + x46); + x48 = (x11 + (uint32_t)x12); + x49 = (x10 + x48); + x50 = (x9 + x49); + x51 = (x7 + (uint32_t)x8); + x52 = (x6 + x51); + x53 = (x5 + x52); + x54 = (x3 + (uint32_t)x4); + x55 = (x2 + x54); + x56 = (x1 + x55); + out1[0] = x35; + out1[1] = x38; + out1[2] = x41; + out1[3] = x44; + out1[4] = x47; + out1[5] = x50; + out1[6] = x53; + out1[7] = x56; +} + +/* + * The function fiat_p256_scalar_set_one returns the field element one in the Montgomery domain. + * + * Postconditions: + * eval (from_montgomery out1) mod m = 1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_set_one(fiat_p256_scalar_montgomery_domain_field_element out1) { + out1[0] = UINT32_C(0x39cdaaf); + out1[1] = UINT32_C(0xc46353d); + out1[2] = UINT32_C(0x58e8617b); + out1[3] = UINT32_C(0x43190552); + out1[4] = 0x0; + out1[5] = 0x0; + out1[6] = UINT32_C(0xffffffff); + out1[7] = 0x0; +} + +/* + * The function fiat_p256_scalar_msat returns the saturated representation of the prime modulus. + * + * Postconditions: + * twos_complement_eval out1 = m + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_msat(uint32_t out1[9]) { + out1[0] = UINT32_C(0xfc632551); + out1[1] = UINT32_C(0xf3b9cac2); + out1[2] = UINT32_C(0xa7179e84); + out1[3] = UINT32_C(0xbce6faad); + out1[4] = UINT32_C(0xffffffff); + out1[5] = UINT32_C(0xffffffff); + out1[6] = 0x0; + out1[7] = UINT32_C(0xffffffff); + out1[8] = 0x0; +} + +/* + * The function fiat_p256_scalar_divstep computes a divstep. + * + * Preconditions: + * 0 ≤ eval arg4 < m + * 0 ≤ eval arg5 < m + * Postconditions: + * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) + * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) + * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) + * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) + * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) + * 0 ≤ eval out5 < m + * 0 ≤ eval out5 < m + * 0 ≤ eval out2 < m + * 0 ≤ eval out3 < m + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffff] + * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_divstep(uint32_t* out1, uint32_t out2[9], uint32_t out3[9], uint32_t out4[8], uint32_t out5[8], uint32_t arg1, const uint32_t arg2[9], const uint32_t arg3[9], const uint32_t arg4[8], const uint32_t arg5[8]) { + uint32_t x1; + fiat_p256_scalar_uint1 x2; + fiat_p256_scalar_uint1 x3; + uint32_t x4; + fiat_p256_scalar_uint1 x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + fiat_p256_scalar_uint1 x17; + uint32_t x18; + fiat_p256_scalar_uint1 x19; + uint32_t x20; + fiat_p256_scalar_uint1 x21; + uint32_t x22; + fiat_p256_scalar_uint1 x23; + uint32_t x24; + fiat_p256_scalar_uint1 x25; + uint32_t x26; + fiat_p256_scalar_uint1 x27; + uint32_t x28; + fiat_p256_scalar_uint1 x29; + uint32_t x30; + fiat_p256_scalar_uint1 x31; + uint32_t x32; + fiat_p256_scalar_uint1 x33; + uint32_t x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + uint32_t x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + fiat_p256_scalar_uint1 x52; + uint32_t x53; + fiat_p256_scalar_uint1 x54; + uint32_t x55; + fiat_p256_scalar_uint1 x56; + uint32_t x57; + fiat_p256_scalar_uint1 x58; + uint32_t x59; + fiat_p256_scalar_uint1 x60; + uint32_t x61; + fiat_p256_scalar_uint1 x62; + uint32_t x63; + fiat_p256_scalar_uint1 x64; + uint32_t x65; + fiat_p256_scalar_uint1 x66; + uint32_t x67; + fiat_p256_scalar_uint1 x68; + uint32_t x69; + fiat_p256_scalar_uint1 x70; + uint32_t x71; + fiat_p256_scalar_uint1 x72; + uint32_t x73; + fiat_p256_scalar_uint1 x74; + uint32_t x75; + fiat_p256_scalar_uint1 x76; + uint32_t x77; + fiat_p256_scalar_uint1 x78; + uint32_t x79; + fiat_p256_scalar_uint1 x80; + uint32_t x81; + fiat_p256_scalar_uint1 x82; + uint32_t x83; + fiat_p256_scalar_uint1 x84; + uint32_t x85; + uint32_t x86; + uint32_t x87; + uint32_t x88; + uint32_t x89; + uint32_t x90; + uint32_t x91; + uint32_t x92; + uint32_t x93; + fiat_p256_scalar_uint1 x94; + uint32_t x95; + fiat_p256_scalar_uint1 x96; + uint32_t x97; + fiat_p256_scalar_uint1 x98; + uint32_t x99; + fiat_p256_scalar_uint1 x100; + uint32_t x101; + fiat_p256_scalar_uint1 x102; + uint32_t x103; + fiat_p256_scalar_uint1 x104; + uint32_t x105; + fiat_p256_scalar_uint1 x106; + uint32_t x107; + fiat_p256_scalar_uint1 x108; + uint32_t x109; + uint32_t x110; + fiat_p256_scalar_uint1 x111; + uint32_t x112; + fiat_p256_scalar_uint1 x113; + uint32_t x114; + fiat_p256_scalar_uint1 x115; + uint32_t x116; + fiat_p256_scalar_uint1 x117; + uint32_t x118; + fiat_p256_scalar_uint1 x119; + uint32_t x120; + fiat_p256_scalar_uint1 x121; + uint32_t x122; + fiat_p256_scalar_uint1 x123; + uint32_t x124; + fiat_p256_scalar_uint1 x125; + uint32_t x126; + uint32_t x127; + uint32_t x128; + uint32_t x129; + uint32_t x130; + uint32_t x131; + uint32_t x132; + uint32_t x133; + fiat_p256_scalar_uint1 x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + uint32_t x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + fiat_p256_scalar_uint1 x145; + uint32_t x146; + fiat_p256_scalar_uint1 x147; + uint32_t x148; + fiat_p256_scalar_uint1 x149; + uint32_t x150; + fiat_p256_scalar_uint1 x151; + uint32_t x152; + fiat_p256_scalar_uint1 x153; + uint32_t x154; + fiat_p256_scalar_uint1 x155; + uint32_t x156; + fiat_p256_scalar_uint1 x157; + uint32_t x158; + fiat_p256_scalar_uint1 x159; + uint32_t x160; + fiat_p256_scalar_uint1 x161; + uint32_t x162; + uint32_t x163; + uint32_t x164; + uint32_t x165; + uint32_t x166; + uint32_t x167; + uint32_t x168; + uint32_t x169; + uint32_t x170; + fiat_p256_scalar_uint1 x171; + uint32_t x172; + fiat_p256_scalar_uint1 x173; + uint32_t x174; + fiat_p256_scalar_uint1 x175; + uint32_t x176; + fiat_p256_scalar_uint1 x177; + uint32_t x178; + fiat_p256_scalar_uint1 x179; + uint32_t x180; + fiat_p256_scalar_uint1 x181; + uint32_t x182; + fiat_p256_scalar_uint1 x183; + uint32_t x184; + fiat_p256_scalar_uint1 x185; + uint32_t x186; + fiat_p256_scalar_uint1 x187; + uint32_t x188; + fiat_p256_scalar_uint1 x189; + uint32_t x190; + fiat_p256_scalar_uint1 x191; + uint32_t x192; + fiat_p256_scalar_uint1 x193; + uint32_t x194; + fiat_p256_scalar_uint1 x195; + uint32_t x196; + fiat_p256_scalar_uint1 x197; + uint32_t x198; + fiat_p256_scalar_uint1 x199; + uint32_t x200; + fiat_p256_scalar_uint1 x201; + uint32_t x202; + fiat_p256_scalar_uint1 x203; + uint32_t x204; + fiat_p256_scalar_uint1 x205; + uint32_t x206; + uint32_t x207; + uint32_t x208; + uint32_t x209; + uint32_t x210; + uint32_t x211; + uint32_t x212; + uint32_t x213; + uint32_t x214; + uint32_t x215; + uint32_t x216; + uint32_t x217; + uint32_t x218; + uint32_t x219; + uint32_t x220; + uint32_t x221; + uint32_t x222; + uint32_t x223; + uint32_t x224; + uint32_t x225; + uint32_t x226; + uint32_t x227; + uint32_t x228; + uint32_t x229; + uint32_t x230; + fiat_p256_scalar_addcarryx_u32(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_p256_scalar_uint1)((fiat_p256_scalar_uint1)(x1 >> 31) & (fiat_p256_scalar_uint1)((arg3[0]) & 0x1)); + fiat_p256_scalar_addcarryx_u32(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_p256_scalar_cmovznz_u32(&x6, x3, arg1, x4); + fiat_p256_scalar_cmovznz_u32(&x7, x3, (arg2[0]), (arg3[0])); + fiat_p256_scalar_cmovznz_u32(&x8, x3, (arg2[1]), (arg3[1])); + fiat_p256_scalar_cmovznz_u32(&x9, x3, (arg2[2]), (arg3[2])); + fiat_p256_scalar_cmovznz_u32(&x10, x3, (arg2[3]), (arg3[3])); + fiat_p256_scalar_cmovznz_u32(&x11, x3, (arg2[4]), (arg3[4])); + fiat_p256_scalar_cmovznz_u32(&x12, x3, (arg2[5]), (arg3[5])); + fiat_p256_scalar_cmovznz_u32(&x13, x3, (arg2[6]), (arg3[6])); + fiat_p256_scalar_cmovznz_u32(&x14, x3, (arg2[7]), (arg3[7])); + fiat_p256_scalar_cmovznz_u32(&x15, x3, (arg2[8]), (arg3[8])); + fiat_p256_scalar_addcarryx_u32(&x16, &x17, 0x0, 0x1, (~(arg2[0]))); + fiat_p256_scalar_addcarryx_u32(&x18, &x19, x17, 0x0, (~(arg2[1]))); + fiat_p256_scalar_addcarryx_u32(&x20, &x21, x19, 0x0, (~(arg2[2]))); + fiat_p256_scalar_addcarryx_u32(&x22, &x23, x21, 0x0, (~(arg2[3]))); + fiat_p256_scalar_addcarryx_u32(&x24, &x25, x23, 0x0, (~(arg2[4]))); + fiat_p256_scalar_addcarryx_u32(&x26, &x27, x25, 0x0, (~(arg2[5]))); + fiat_p256_scalar_addcarryx_u32(&x28, &x29, x27, 0x0, (~(arg2[6]))); + fiat_p256_scalar_addcarryx_u32(&x30, &x31, x29, 0x0, (~(arg2[7]))); + fiat_p256_scalar_addcarryx_u32(&x32, &x33, x31, 0x0, (~(arg2[8]))); + fiat_p256_scalar_cmovznz_u32(&x34, x3, (arg3[0]), x16); + fiat_p256_scalar_cmovznz_u32(&x35, x3, (arg3[1]), x18); + fiat_p256_scalar_cmovznz_u32(&x36, x3, (arg3[2]), x20); + fiat_p256_scalar_cmovznz_u32(&x37, x3, (arg3[3]), x22); + fiat_p256_scalar_cmovznz_u32(&x38, x3, (arg3[4]), x24); + fiat_p256_scalar_cmovznz_u32(&x39, x3, (arg3[5]), x26); + fiat_p256_scalar_cmovznz_u32(&x40, x3, (arg3[6]), x28); + fiat_p256_scalar_cmovznz_u32(&x41, x3, (arg3[7]), x30); + fiat_p256_scalar_cmovznz_u32(&x42, x3, (arg3[8]), x32); + fiat_p256_scalar_cmovznz_u32(&x43, x3, (arg4[0]), (arg5[0])); + fiat_p256_scalar_cmovznz_u32(&x44, x3, (arg4[1]), (arg5[1])); + fiat_p256_scalar_cmovznz_u32(&x45, x3, (arg4[2]), (arg5[2])); + fiat_p256_scalar_cmovznz_u32(&x46, x3, (arg4[3]), (arg5[3])); + fiat_p256_scalar_cmovznz_u32(&x47, x3, (arg4[4]), (arg5[4])); + fiat_p256_scalar_cmovznz_u32(&x48, x3, (arg4[5]), (arg5[5])); + fiat_p256_scalar_cmovznz_u32(&x49, x3, (arg4[6]), (arg5[6])); + fiat_p256_scalar_cmovznz_u32(&x50, x3, (arg4[7]), (arg5[7])); + fiat_p256_scalar_addcarryx_u32(&x51, &x52, 0x0, x43, x43); + fiat_p256_scalar_addcarryx_u32(&x53, &x54, x52, x44, x44); + fiat_p256_scalar_addcarryx_u32(&x55, &x56, x54, x45, x45); + fiat_p256_scalar_addcarryx_u32(&x57, &x58, x56, x46, x46); + fiat_p256_scalar_addcarryx_u32(&x59, &x60, x58, x47, x47); + fiat_p256_scalar_addcarryx_u32(&x61, &x62, x60, x48, x48); + fiat_p256_scalar_addcarryx_u32(&x63, &x64, x62, x49, x49); + fiat_p256_scalar_addcarryx_u32(&x65, &x66, x64, x50, x50); + fiat_p256_scalar_subborrowx_u32(&x67, &x68, 0x0, x51, UINT32_C(0xfc632551)); + fiat_p256_scalar_subborrowx_u32(&x69, &x70, x68, x53, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_subborrowx_u32(&x71, &x72, x70, x55, UINT32_C(0xa7179e84)); + fiat_p256_scalar_subborrowx_u32(&x73, &x74, x72, x57, UINT32_C(0xbce6faad)); + fiat_p256_scalar_subborrowx_u32(&x75, &x76, x74, x59, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x77, &x78, x76, x61, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x79, &x80, x78, x63, 0x0); + fiat_p256_scalar_subborrowx_u32(&x81, &x82, x80, x65, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x83, &x84, x82, x66, 0x0); + x85 = (arg4[7]); + x86 = (arg4[6]); + x87 = (arg4[5]); + x88 = (arg4[4]); + x89 = (arg4[3]); + x90 = (arg4[2]); + x91 = (arg4[1]); + x92 = (arg4[0]); + fiat_p256_scalar_subborrowx_u32(&x93, &x94, 0x0, 0x0, x92); + fiat_p256_scalar_subborrowx_u32(&x95, &x96, x94, 0x0, x91); + fiat_p256_scalar_subborrowx_u32(&x97, &x98, x96, 0x0, x90); + fiat_p256_scalar_subborrowx_u32(&x99, &x100, x98, 0x0, x89); + fiat_p256_scalar_subborrowx_u32(&x101, &x102, x100, 0x0, x88); + fiat_p256_scalar_subborrowx_u32(&x103, &x104, x102, 0x0, x87); + fiat_p256_scalar_subborrowx_u32(&x105, &x106, x104, 0x0, x86); + fiat_p256_scalar_subborrowx_u32(&x107, &x108, x106, 0x0, x85); + fiat_p256_scalar_cmovznz_u32(&x109, x108, 0x0, UINT32_C(0xffffffff)); + fiat_p256_scalar_addcarryx_u32(&x110, &x111, 0x0, x93, (x109 & UINT32_C(0xfc632551))); + fiat_p256_scalar_addcarryx_u32(&x112, &x113, x111, x95, (x109 & UINT32_C(0xf3b9cac2))); + fiat_p256_scalar_addcarryx_u32(&x114, &x115, x113, x97, (x109 & UINT32_C(0xa7179e84))); + fiat_p256_scalar_addcarryx_u32(&x116, &x117, x115, x99, (x109 & UINT32_C(0xbce6faad))); + fiat_p256_scalar_addcarryx_u32(&x118, &x119, x117, x101, x109); + fiat_p256_scalar_addcarryx_u32(&x120, &x121, x119, x103, x109); + fiat_p256_scalar_addcarryx_u32(&x122, &x123, x121, x105, 0x0); + fiat_p256_scalar_addcarryx_u32(&x124, &x125, x123, x107, x109); + fiat_p256_scalar_cmovznz_u32(&x126, x3, (arg5[0]), x110); + fiat_p256_scalar_cmovznz_u32(&x127, x3, (arg5[1]), x112); + fiat_p256_scalar_cmovznz_u32(&x128, x3, (arg5[2]), x114); + fiat_p256_scalar_cmovznz_u32(&x129, x3, (arg5[3]), x116); + fiat_p256_scalar_cmovznz_u32(&x130, x3, (arg5[4]), x118); + fiat_p256_scalar_cmovznz_u32(&x131, x3, (arg5[5]), x120); + fiat_p256_scalar_cmovznz_u32(&x132, x3, (arg5[6]), x122); + fiat_p256_scalar_cmovznz_u32(&x133, x3, (arg5[7]), x124); + x134 = (fiat_p256_scalar_uint1)(x34 & 0x1); + fiat_p256_scalar_cmovznz_u32(&x135, x134, 0x0, x7); + fiat_p256_scalar_cmovznz_u32(&x136, x134, 0x0, x8); + fiat_p256_scalar_cmovznz_u32(&x137, x134, 0x0, x9); + fiat_p256_scalar_cmovznz_u32(&x138, x134, 0x0, x10); + fiat_p256_scalar_cmovznz_u32(&x139, x134, 0x0, x11); + fiat_p256_scalar_cmovznz_u32(&x140, x134, 0x0, x12); + fiat_p256_scalar_cmovznz_u32(&x141, x134, 0x0, x13); + fiat_p256_scalar_cmovznz_u32(&x142, x134, 0x0, x14); + fiat_p256_scalar_cmovznz_u32(&x143, x134, 0x0, x15); + fiat_p256_scalar_addcarryx_u32(&x144, &x145, 0x0, x34, x135); + fiat_p256_scalar_addcarryx_u32(&x146, &x147, x145, x35, x136); + fiat_p256_scalar_addcarryx_u32(&x148, &x149, x147, x36, x137); + fiat_p256_scalar_addcarryx_u32(&x150, &x151, x149, x37, x138); + fiat_p256_scalar_addcarryx_u32(&x152, &x153, x151, x38, x139); + fiat_p256_scalar_addcarryx_u32(&x154, &x155, x153, x39, x140); + fiat_p256_scalar_addcarryx_u32(&x156, &x157, x155, x40, x141); + fiat_p256_scalar_addcarryx_u32(&x158, &x159, x157, x41, x142); + fiat_p256_scalar_addcarryx_u32(&x160, &x161, x159, x42, x143); + fiat_p256_scalar_cmovznz_u32(&x162, x134, 0x0, x43); + fiat_p256_scalar_cmovznz_u32(&x163, x134, 0x0, x44); + fiat_p256_scalar_cmovznz_u32(&x164, x134, 0x0, x45); + fiat_p256_scalar_cmovznz_u32(&x165, x134, 0x0, x46); + fiat_p256_scalar_cmovznz_u32(&x166, x134, 0x0, x47); + fiat_p256_scalar_cmovznz_u32(&x167, x134, 0x0, x48); + fiat_p256_scalar_cmovznz_u32(&x168, x134, 0x0, x49); + fiat_p256_scalar_cmovznz_u32(&x169, x134, 0x0, x50); + fiat_p256_scalar_addcarryx_u32(&x170, &x171, 0x0, x126, x162); + fiat_p256_scalar_addcarryx_u32(&x172, &x173, x171, x127, x163); + fiat_p256_scalar_addcarryx_u32(&x174, &x175, x173, x128, x164); + fiat_p256_scalar_addcarryx_u32(&x176, &x177, x175, x129, x165); + fiat_p256_scalar_addcarryx_u32(&x178, &x179, x177, x130, x166); + fiat_p256_scalar_addcarryx_u32(&x180, &x181, x179, x131, x167); + fiat_p256_scalar_addcarryx_u32(&x182, &x183, x181, x132, x168); + fiat_p256_scalar_addcarryx_u32(&x184, &x185, x183, x133, x169); + fiat_p256_scalar_subborrowx_u32(&x186, &x187, 0x0, x170, UINT32_C(0xfc632551)); + fiat_p256_scalar_subborrowx_u32(&x188, &x189, x187, x172, UINT32_C(0xf3b9cac2)); + fiat_p256_scalar_subborrowx_u32(&x190, &x191, x189, x174, UINT32_C(0xa7179e84)); + fiat_p256_scalar_subborrowx_u32(&x192, &x193, x191, x176, UINT32_C(0xbce6faad)); + fiat_p256_scalar_subborrowx_u32(&x194, &x195, x193, x178, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x196, &x197, x195, x180, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x198, &x199, x197, x182, 0x0); + fiat_p256_scalar_subborrowx_u32(&x200, &x201, x199, x184, UINT32_C(0xffffffff)); + fiat_p256_scalar_subborrowx_u32(&x202, &x203, x201, x185, 0x0); + fiat_p256_scalar_addcarryx_u32(&x204, &x205, 0x0, x6, 0x1); + x206 = ((x144 >> 1) | ((x146 << 31) & UINT32_C(0xffffffff))); + x207 = ((x146 >> 1) | ((x148 << 31) & UINT32_C(0xffffffff))); + x208 = ((x148 >> 1) | ((x150 << 31) & UINT32_C(0xffffffff))); + x209 = ((x150 >> 1) | ((x152 << 31) & UINT32_C(0xffffffff))); + x210 = ((x152 >> 1) | ((x154 << 31) & UINT32_C(0xffffffff))); + x211 = ((x154 >> 1) | ((x156 << 31) & UINT32_C(0xffffffff))); + x212 = ((x156 >> 1) | ((x158 << 31) & UINT32_C(0xffffffff))); + x213 = ((x158 >> 1) | ((x160 << 31) & UINT32_C(0xffffffff))); + x214 = ((x160 & UINT32_C(0x80000000)) | (x160 >> 1)); + fiat_p256_scalar_cmovznz_u32(&x215, x84, x67, x51); + fiat_p256_scalar_cmovznz_u32(&x216, x84, x69, x53); + fiat_p256_scalar_cmovznz_u32(&x217, x84, x71, x55); + fiat_p256_scalar_cmovznz_u32(&x218, x84, x73, x57); + fiat_p256_scalar_cmovznz_u32(&x219, x84, x75, x59); + fiat_p256_scalar_cmovznz_u32(&x220, x84, x77, x61); + fiat_p256_scalar_cmovznz_u32(&x221, x84, x79, x63); + fiat_p256_scalar_cmovznz_u32(&x222, x84, x81, x65); + fiat_p256_scalar_cmovznz_u32(&x223, x203, x186, x170); + fiat_p256_scalar_cmovznz_u32(&x224, x203, x188, x172); + fiat_p256_scalar_cmovznz_u32(&x225, x203, x190, x174); + fiat_p256_scalar_cmovznz_u32(&x226, x203, x192, x176); + fiat_p256_scalar_cmovznz_u32(&x227, x203, x194, x178); + fiat_p256_scalar_cmovznz_u32(&x228, x203, x196, x180); + fiat_p256_scalar_cmovznz_u32(&x229, x203, x198, x182); + fiat_p256_scalar_cmovznz_u32(&x230, x203, x200, x184); + *out1 = x204; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out2[7] = x14; + out2[8] = x15; + out3[0] = x206; + out3[1] = x207; + out3[2] = x208; + out3[3] = x209; + out3[4] = x210; + out3[5] = x211; + out3[6] = x212; + out3[7] = x213; + out3[8] = x214; + out4[0] = x215; + out4[1] = x216; + out4[2] = x217; + out4[3] = x218; + out4[4] = x219; + out4[5] = x220; + out4[6] = x221; + out4[7] = x222; + out5[0] = x223; + out5[1] = x224; + out5[2] = x225; + out5[3] = x226; + out5[4] = x227; + out5[5] = x228; + out5[6] = x229; + out5[7] = x230; +} + +/* + * The function fiat_p256_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). + * + * Postconditions: + * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_divstep_precomp(uint32_t out1[8]) { + out1[0] = UINT32_C(0xb7fcfbb5); + out1[1] = UINT32_C(0xd739262f); + out1[2] = UINT32_C(0x20074414); + out1[3] = UINT32_C(0x8ac6f75d); + out1[4] = UINT32_C(0xb5e3c256); + out1[5] = UINT32_C(0xc67428bf); + out1[6] = UINT32_C(0xeda7aedf); + out1[7] = UINT32_C(0x444962f2); +} diff --git a/fiat-c/src/p256_scalar_64.c b/fiat-c/src/p256_scalar_64.c new file mode 100644 index 0000000000..97dcaca63c --- /dev/null +++ b/fiat-c/src/p256_scalar_64.c @@ -0,0 +1,2215 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier p256_scalar 64 '2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: p256_scalar */ +/* machine_wordsize = 64 (from "64") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 (from "2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +typedef unsigned char fiat_p256_scalar_uint1; +typedef signed char fiat_p256_scalar_int1; +#if defined(__GNUC__) || defined(__clang__) +# define FIAT_P256_SCALAR_FIAT_EXTENSION __extension__ +# define FIAT_P256_SCALAR_FIAT_INLINE __inline__ +#else +# define FIAT_P256_SCALAR_FIAT_EXTENSION +# define FIAT_P256_SCALAR_FIAT_INLINE +#endif + +FIAT_P256_SCALAR_FIAT_EXTENSION typedef signed __int128 fiat_p256_scalar_int128; +FIAT_P256_SCALAR_FIAT_EXTENSION typedef unsigned __int128 fiat_p256_scalar_uint128; + +/* The type fiat_p256_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +typedef uint64_t fiat_p256_scalar_montgomery_domain_field_element[4]; + +/* The type fiat_p256_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +typedef uint64_t fiat_p256_scalar_non_montgomery_domain_field_element[4]; + +#if (-1 & 3) != 3 +#error "This code only works on a two's complement system" +#endif + +#if !defined(FIAT_P256_SCALAR_NO_ASM) && (defined(__GNUC__) || defined(__clang__)) +static __inline__ uint64_t fiat_p256_scalar_value_barrier_u64(uint64_t a) { + __asm__("" : "+r"(a) : /* no inputs */); + return a; +} +#else +# define fiat_p256_scalar_value_barrier_u64(x) (x) +#endif + + +/* + * The function fiat_p256_scalar_addcarryx_u64 is an addition with carry. + * + * Postconditions: + * out1 = (arg1 + arg2 + arg3) mod 2^64 + * out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_addcarryx_u64(uint64_t* out1, fiat_p256_scalar_uint1* out2, fiat_p256_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_p256_scalar_uint128 x1; + uint64_t x2; + fiat_p256_scalar_uint1 x3; + x1 = ((arg1 + (fiat_p256_scalar_uint128)arg2) + arg3); + x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + x3 = (fiat_p256_scalar_uint1)(x1 >> 64); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_p256_scalar_subborrowx_u64 is a subtraction with borrow. + * + * Postconditions: + * out1 = (-arg1 + arg2 + -arg3) mod 2^64 + * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_subborrowx_u64(uint64_t* out1, fiat_p256_scalar_uint1* out2, fiat_p256_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_p256_scalar_int128 x1; + fiat_p256_scalar_int1 x2; + uint64_t x3; + x1 = ((arg2 - (fiat_p256_scalar_int128)arg1) - arg3); + x2 = (fiat_p256_scalar_int1)(x1 >> 64); + x3 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + *out1 = x3; + *out2 = (fiat_p256_scalar_uint1)(0x0 - x2); +} + +/* + * The function fiat_p256_scalar_mulx_u64 is a multiplication, returning the full double-width result. + * + * Postconditions: + * out1 = (arg1 * arg2) mod 2^64 + * out2 = ⌊arg1 * arg2 / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffffffffffff] + * arg2: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_mulx_u64(uint64_t* out1, uint64_t* out2, uint64_t arg1, uint64_t arg2) { + fiat_p256_scalar_uint128 x1; + uint64_t x2; + uint64_t x3; + x1 = ((fiat_p256_scalar_uint128)arg1 * arg2); + x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + x3 = (uint64_t)(x1 >> 64); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_p256_scalar_cmovznz_u64 is a single-word conditional move. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_cmovznz_u64(uint64_t* out1, fiat_p256_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_p256_scalar_uint1 x1; + uint64_t x2; + uint64_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_p256_scalar_int1)(0x0 - x1) & UINT64_C(0xffffffffffffffff)); + x3 = ((fiat_p256_scalar_value_barrier_u64(x2) & arg3) | (fiat_p256_scalar_value_barrier_u64((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_p256_scalar_mul multiplies two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_mul(fiat_p256_scalar_montgomery_domain_field_element out1, const fiat_p256_scalar_montgomery_domain_field_element arg1, const fiat_p256_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_p256_scalar_uint1 x14; + uint64_t x15; + fiat_p256_scalar_uint1 x16; + uint64_t x17; + fiat_p256_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + fiat_p256_scalar_uint1 x31; + uint64_t x32; + fiat_p256_scalar_uint1 x33; + uint64_t x34; + fiat_p256_scalar_uint1 x35; + uint64_t x36; + uint64_t x37; + fiat_p256_scalar_uint1 x38; + uint64_t x39; + fiat_p256_scalar_uint1 x40; + uint64_t x41; + fiat_p256_scalar_uint1 x42; + uint64_t x43; + fiat_p256_scalar_uint1 x44; + uint64_t x45; + fiat_p256_scalar_uint1 x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + uint64_t x54; + uint64_t x55; + fiat_p256_scalar_uint1 x56; + uint64_t x57; + fiat_p256_scalar_uint1 x58; + uint64_t x59; + fiat_p256_scalar_uint1 x60; + uint64_t x61; + uint64_t x62; + fiat_p256_scalar_uint1 x63; + uint64_t x64; + fiat_p256_scalar_uint1 x65; + uint64_t x66; + fiat_p256_scalar_uint1 x67; + uint64_t x68; + fiat_p256_scalar_uint1 x69; + uint64_t x70; + fiat_p256_scalar_uint1 x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + uint64_t x81; + uint64_t x82; + fiat_p256_scalar_uint1 x83; + uint64_t x84; + fiat_p256_scalar_uint1 x85; + uint64_t x86; + fiat_p256_scalar_uint1 x87; + uint64_t x88; + uint64_t x89; + fiat_p256_scalar_uint1 x90; + uint64_t x91; + fiat_p256_scalar_uint1 x92; + uint64_t x93; + fiat_p256_scalar_uint1 x94; + uint64_t x95; + fiat_p256_scalar_uint1 x96; + uint64_t x97; + fiat_p256_scalar_uint1 x98; + uint64_t x99; + uint64_t x100; + uint64_t x101; + uint64_t x102; + uint64_t x103; + uint64_t x104; + uint64_t x105; + uint64_t x106; + uint64_t x107; + uint64_t x108; + fiat_p256_scalar_uint1 x109; + uint64_t x110; + fiat_p256_scalar_uint1 x111; + uint64_t x112; + fiat_p256_scalar_uint1 x113; + uint64_t x114; + uint64_t x115; + fiat_p256_scalar_uint1 x116; + uint64_t x117; + fiat_p256_scalar_uint1 x118; + uint64_t x119; + fiat_p256_scalar_uint1 x120; + uint64_t x121; + fiat_p256_scalar_uint1 x122; + uint64_t x123; + fiat_p256_scalar_uint1 x124; + uint64_t x125; + uint64_t x126; + uint64_t x127; + uint64_t x128; + uint64_t x129; + uint64_t x130; + uint64_t x131; + uint64_t x132; + uint64_t x133; + uint64_t x134; + uint64_t x135; + fiat_p256_scalar_uint1 x136; + uint64_t x137; + fiat_p256_scalar_uint1 x138; + uint64_t x139; + fiat_p256_scalar_uint1 x140; + uint64_t x141; + uint64_t x142; + fiat_p256_scalar_uint1 x143; + uint64_t x144; + fiat_p256_scalar_uint1 x145; + uint64_t x146; + fiat_p256_scalar_uint1 x147; + uint64_t x148; + fiat_p256_scalar_uint1 x149; + uint64_t x150; + fiat_p256_scalar_uint1 x151; + uint64_t x152; + uint64_t x153; + uint64_t x154; + uint64_t x155; + uint64_t x156; + uint64_t x157; + uint64_t x158; + uint64_t x159; + uint64_t x160; + uint64_t x161; + fiat_p256_scalar_uint1 x162; + uint64_t x163; + fiat_p256_scalar_uint1 x164; + uint64_t x165; + fiat_p256_scalar_uint1 x166; + uint64_t x167; + uint64_t x168; + fiat_p256_scalar_uint1 x169; + uint64_t x170; + fiat_p256_scalar_uint1 x171; + uint64_t x172; + fiat_p256_scalar_uint1 x173; + uint64_t x174; + fiat_p256_scalar_uint1 x175; + uint64_t x176; + fiat_p256_scalar_uint1 x177; + uint64_t x178; + uint64_t x179; + uint64_t x180; + uint64_t x181; + uint64_t x182; + uint64_t x183; + uint64_t x184; + uint64_t x185; + uint64_t x186; + uint64_t x187; + uint64_t x188; + fiat_p256_scalar_uint1 x189; + uint64_t x190; + fiat_p256_scalar_uint1 x191; + uint64_t x192; + fiat_p256_scalar_uint1 x193; + uint64_t x194; + uint64_t x195; + fiat_p256_scalar_uint1 x196; + uint64_t x197; + fiat_p256_scalar_uint1 x198; + uint64_t x199; + fiat_p256_scalar_uint1 x200; + uint64_t x201; + fiat_p256_scalar_uint1 x202; + uint64_t x203; + fiat_p256_scalar_uint1 x204; + uint64_t x205; + uint64_t x206; + fiat_p256_scalar_uint1 x207; + uint64_t x208; + fiat_p256_scalar_uint1 x209; + uint64_t x210; + fiat_p256_scalar_uint1 x211; + uint64_t x212; + fiat_p256_scalar_uint1 x213; + uint64_t x214; + fiat_p256_scalar_uint1 x215; + uint64_t x216; + uint64_t x217; + uint64_t x218; + uint64_t x219; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_p256_scalar_mulx_u64(&x5, &x6, x4, (arg2[3])); + fiat_p256_scalar_mulx_u64(&x7, &x8, x4, (arg2[2])); + fiat_p256_scalar_mulx_u64(&x9, &x10, x4, (arg2[1])); + fiat_p256_scalar_mulx_u64(&x11, &x12, x4, (arg2[0])); + fiat_p256_scalar_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_p256_scalar_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_p256_scalar_addcarryx_u64(&x17, &x18, x16, x8, x5); + x19 = (x18 + x6); + fiat_p256_scalar_mulx_u64(&x20, &x21, x11, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x22, &x23, x20, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x24, &x25, x20, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x26, &x27, x20, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x28, &x29, x20, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x30, &x31, 0x0, x29, x26); + fiat_p256_scalar_addcarryx_u64(&x32, &x33, x31, x27, x24); + fiat_p256_scalar_addcarryx_u64(&x34, &x35, x33, x25, x22); + x36 = (x35 + x23); + fiat_p256_scalar_addcarryx_u64(&x37, &x38, 0x0, x11, x28); + fiat_p256_scalar_addcarryx_u64(&x39, &x40, x38, x13, x30); + fiat_p256_scalar_addcarryx_u64(&x41, &x42, x40, x15, x32); + fiat_p256_scalar_addcarryx_u64(&x43, &x44, x42, x17, x34); + fiat_p256_scalar_addcarryx_u64(&x45, &x46, x44, x19, x36); + fiat_p256_scalar_mulx_u64(&x47, &x48, x1, (arg2[3])); + fiat_p256_scalar_mulx_u64(&x49, &x50, x1, (arg2[2])); + fiat_p256_scalar_mulx_u64(&x51, &x52, x1, (arg2[1])); + fiat_p256_scalar_mulx_u64(&x53, &x54, x1, (arg2[0])); + fiat_p256_scalar_addcarryx_u64(&x55, &x56, 0x0, x54, x51); + fiat_p256_scalar_addcarryx_u64(&x57, &x58, x56, x52, x49); + fiat_p256_scalar_addcarryx_u64(&x59, &x60, x58, x50, x47); + x61 = (x60 + x48); + fiat_p256_scalar_addcarryx_u64(&x62, &x63, 0x0, x39, x53); + fiat_p256_scalar_addcarryx_u64(&x64, &x65, x63, x41, x55); + fiat_p256_scalar_addcarryx_u64(&x66, &x67, x65, x43, x57); + fiat_p256_scalar_addcarryx_u64(&x68, &x69, x67, x45, x59); + fiat_p256_scalar_addcarryx_u64(&x70, &x71, x69, x46, x61); + fiat_p256_scalar_mulx_u64(&x72, &x73, x62, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x74, &x75, x72, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x76, &x77, x72, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x78, &x79, x72, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x80, &x81, x72, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x82, &x83, 0x0, x81, x78); + fiat_p256_scalar_addcarryx_u64(&x84, &x85, x83, x79, x76); + fiat_p256_scalar_addcarryx_u64(&x86, &x87, x85, x77, x74); + x88 = (x87 + x75); + fiat_p256_scalar_addcarryx_u64(&x89, &x90, 0x0, x62, x80); + fiat_p256_scalar_addcarryx_u64(&x91, &x92, x90, x64, x82); + fiat_p256_scalar_addcarryx_u64(&x93, &x94, x92, x66, x84); + fiat_p256_scalar_addcarryx_u64(&x95, &x96, x94, x68, x86); + fiat_p256_scalar_addcarryx_u64(&x97, &x98, x96, x70, x88); + x99 = ((uint64_t)x98 + x71); + fiat_p256_scalar_mulx_u64(&x100, &x101, x2, (arg2[3])); + fiat_p256_scalar_mulx_u64(&x102, &x103, x2, (arg2[2])); + fiat_p256_scalar_mulx_u64(&x104, &x105, x2, (arg2[1])); + fiat_p256_scalar_mulx_u64(&x106, &x107, x2, (arg2[0])); + fiat_p256_scalar_addcarryx_u64(&x108, &x109, 0x0, x107, x104); + fiat_p256_scalar_addcarryx_u64(&x110, &x111, x109, x105, x102); + fiat_p256_scalar_addcarryx_u64(&x112, &x113, x111, x103, x100); + x114 = (x113 + x101); + fiat_p256_scalar_addcarryx_u64(&x115, &x116, 0x0, x91, x106); + fiat_p256_scalar_addcarryx_u64(&x117, &x118, x116, x93, x108); + fiat_p256_scalar_addcarryx_u64(&x119, &x120, x118, x95, x110); + fiat_p256_scalar_addcarryx_u64(&x121, &x122, x120, x97, x112); + fiat_p256_scalar_addcarryx_u64(&x123, &x124, x122, x99, x114); + fiat_p256_scalar_mulx_u64(&x125, &x126, x115, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x127, &x128, x125, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x129, &x130, x125, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x131, &x132, x125, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x133, &x134, x125, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x135, &x136, 0x0, x134, x131); + fiat_p256_scalar_addcarryx_u64(&x137, &x138, x136, x132, x129); + fiat_p256_scalar_addcarryx_u64(&x139, &x140, x138, x130, x127); + x141 = (x140 + x128); + fiat_p256_scalar_addcarryx_u64(&x142, &x143, 0x0, x115, x133); + fiat_p256_scalar_addcarryx_u64(&x144, &x145, x143, x117, x135); + fiat_p256_scalar_addcarryx_u64(&x146, &x147, x145, x119, x137); + fiat_p256_scalar_addcarryx_u64(&x148, &x149, x147, x121, x139); + fiat_p256_scalar_addcarryx_u64(&x150, &x151, x149, x123, x141); + x152 = ((uint64_t)x151 + x124); + fiat_p256_scalar_mulx_u64(&x153, &x154, x3, (arg2[3])); + fiat_p256_scalar_mulx_u64(&x155, &x156, x3, (arg2[2])); + fiat_p256_scalar_mulx_u64(&x157, &x158, x3, (arg2[1])); + fiat_p256_scalar_mulx_u64(&x159, &x160, x3, (arg2[0])); + fiat_p256_scalar_addcarryx_u64(&x161, &x162, 0x0, x160, x157); + fiat_p256_scalar_addcarryx_u64(&x163, &x164, x162, x158, x155); + fiat_p256_scalar_addcarryx_u64(&x165, &x166, x164, x156, x153); + x167 = (x166 + x154); + fiat_p256_scalar_addcarryx_u64(&x168, &x169, 0x0, x144, x159); + fiat_p256_scalar_addcarryx_u64(&x170, &x171, x169, x146, x161); + fiat_p256_scalar_addcarryx_u64(&x172, &x173, x171, x148, x163); + fiat_p256_scalar_addcarryx_u64(&x174, &x175, x173, x150, x165); + fiat_p256_scalar_addcarryx_u64(&x176, &x177, x175, x152, x167); + fiat_p256_scalar_mulx_u64(&x178, &x179, x168, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x180, &x181, x178, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x182, &x183, x178, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x184, &x185, x178, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x186, &x187, x178, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x188, &x189, 0x0, x187, x184); + fiat_p256_scalar_addcarryx_u64(&x190, &x191, x189, x185, x182); + fiat_p256_scalar_addcarryx_u64(&x192, &x193, x191, x183, x180); + x194 = (x193 + x181); + fiat_p256_scalar_addcarryx_u64(&x195, &x196, 0x0, x168, x186); + fiat_p256_scalar_addcarryx_u64(&x197, &x198, x196, x170, x188); + fiat_p256_scalar_addcarryx_u64(&x199, &x200, x198, x172, x190); + fiat_p256_scalar_addcarryx_u64(&x201, &x202, x200, x174, x192); + fiat_p256_scalar_addcarryx_u64(&x203, &x204, x202, x176, x194); + x205 = ((uint64_t)x204 + x177); + fiat_p256_scalar_subborrowx_u64(&x206, &x207, 0x0, x197, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_subborrowx_u64(&x208, &x209, x207, x199, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_subborrowx_u64(&x210, &x211, x209, x201, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_subborrowx_u64(&x212, &x213, x211, x203, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_subborrowx_u64(&x214, &x215, x213, x205, 0x0); + fiat_p256_scalar_cmovznz_u64(&x216, x215, x206, x197); + fiat_p256_scalar_cmovznz_u64(&x217, x215, x208, x199); + fiat_p256_scalar_cmovznz_u64(&x218, x215, x210, x201); + fiat_p256_scalar_cmovznz_u64(&x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/* + * The function fiat_p256_scalar_square squares a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_square(fiat_p256_scalar_montgomery_domain_field_element out1, const fiat_p256_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_p256_scalar_uint1 x14; + uint64_t x15; + fiat_p256_scalar_uint1 x16; + uint64_t x17; + fiat_p256_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + fiat_p256_scalar_uint1 x31; + uint64_t x32; + fiat_p256_scalar_uint1 x33; + uint64_t x34; + fiat_p256_scalar_uint1 x35; + uint64_t x36; + uint64_t x37; + fiat_p256_scalar_uint1 x38; + uint64_t x39; + fiat_p256_scalar_uint1 x40; + uint64_t x41; + fiat_p256_scalar_uint1 x42; + uint64_t x43; + fiat_p256_scalar_uint1 x44; + uint64_t x45; + fiat_p256_scalar_uint1 x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + uint64_t x54; + uint64_t x55; + fiat_p256_scalar_uint1 x56; + uint64_t x57; + fiat_p256_scalar_uint1 x58; + uint64_t x59; + fiat_p256_scalar_uint1 x60; + uint64_t x61; + uint64_t x62; + fiat_p256_scalar_uint1 x63; + uint64_t x64; + fiat_p256_scalar_uint1 x65; + uint64_t x66; + fiat_p256_scalar_uint1 x67; + uint64_t x68; + fiat_p256_scalar_uint1 x69; + uint64_t x70; + fiat_p256_scalar_uint1 x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + uint64_t x81; + uint64_t x82; + fiat_p256_scalar_uint1 x83; + uint64_t x84; + fiat_p256_scalar_uint1 x85; + uint64_t x86; + fiat_p256_scalar_uint1 x87; + uint64_t x88; + uint64_t x89; + fiat_p256_scalar_uint1 x90; + uint64_t x91; + fiat_p256_scalar_uint1 x92; + uint64_t x93; + fiat_p256_scalar_uint1 x94; + uint64_t x95; + fiat_p256_scalar_uint1 x96; + uint64_t x97; + fiat_p256_scalar_uint1 x98; + uint64_t x99; + uint64_t x100; + uint64_t x101; + uint64_t x102; + uint64_t x103; + uint64_t x104; + uint64_t x105; + uint64_t x106; + uint64_t x107; + uint64_t x108; + fiat_p256_scalar_uint1 x109; + uint64_t x110; + fiat_p256_scalar_uint1 x111; + uint64_t x112; + fiat_p256_scalar_uint1 x113; + uint64_t x114; + uint64_t x115; + fiat_p256_scalar_uint1 x116; + uint64_t x117; + fiat_p256_scalar_uint1 x118; + uint64_t x119; + fiat_p256_scalar_uint1 x120; + uint64_t x121; + fiat_p256_scalar_uint1 x122; + uint64_t x123; + fiat_p256_scalar_uint1 x124; + uint64_t x125; + uint64_t x126; + uint64_t x127; + uint64_t x128; + uint64_t x129; + uint64_t x130; + uint64_t x131; + uint64_t x132; + uint64_t x133; + uint64_t x134; + uint64_t x135; + fiat_p256_scalar_uint1 x136; + uint64_t x137; + fiat_p256_scalar_uint1 x138; + uint64_t x139; + fiat_p256_scalar_uint1 x140; + uint64_t x141; + uint64_t x142; + fiat_p256_scalar_uint1 x143; + uint64_t x144; + fiat_p256_scalar_uint1 x145; + uint64_t x146; + fiat_p256_scalar_uint1 x147; + uint64_t x148; + fiat_p256_scalar_uint1 x149; + uint64_t x150; + fiat_p256_scalar_uint1 x151; + uint64_t x152; + uint64_t x153; + uint64_t x154; + uint64_t x155; + uint64_t x156; + uint64_t x157; + uint64_t x158; + uint64_t x159; + uint64_t x160; + uint64_t x161; + fiat_p256_scalar_uint1 x162; + uint64_t x163; + fiat_p256_scalar_uint1 x164; + uint64_t x165; + fiat_p256_scalar_uint1 x166; + uint64_t x167; + uint64_t x168; + fiat_p256_scalar_uint1 x169; + uint64_t x170; + fiat_p256_scalar_uint1 x171; + uint64_t x172; + fiat_p256_scalar_uint1 x173; + uint64_t x174; + fiat_p256_scalar_uint1 x175; + uint64_t x176; + fiat_p256_scalar_uint1 x177; + uint64_t x178; + uint64_t x179; + uint64_t x180; + uint64_t x181; + uint64_t x182; + uint64_t x183; + uint64_t x184; + uint64_t x185; + uint64_t x186; + uint64_t x187; + uint64_t x188; + fiat_p256_scalar_uint1 x189; + uint64_t x190; + fiat_p256_scalar_uint1 x191; + uint64_t x192; + fiat_p256_scalar_uint1 x193; + uint64_t x194; + uint64_t x195; + fiat_p256_scalar_uint1 x196; + uint64_t x197; + fiat_p256_scalar_uint1 x198; + uint64_t x199; + fiat_p256_scalar_uint1 x200; + uint64_t x201; + fiat_p256_scalar_uint1 x202; + uint64_t x203; + fiat_p256_scalar_uint1 x204; + uint64_t x205; + uint64_t x206; + fiat_p256_scalar_uint1 x207; + uint64_t x208; + fiat_p256_scalar_uint1 x209; + uint64_t x210; + fiat_p256_scalar_uint1 x211; + uint64_t x212; + fiat_p256_scalar_uint1 x213; + uint64_t x214; + fiat_p256_scalar_uint1 x215; + uint64_t x216; + uint64_t x217; + uint64_t x218; + uint64_t x219; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_p256_scalar_mulx_u64(&x5, &x6, x4, (arg1[3])); + fiat_p256_scalar_mulx_u64(&x7, &x8, x4, (arg1[2])); + fiat_p256_scalar_mulx_u64(&x9, &x10, x4, (arg1[1])); + fiat_p256_scalar_mulx_u64(&x11, &x12, x4, (arg1[0])); + fiat_p256_scalar_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_p256_scalar_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_p256_scalar_addcarryx_u64(&x17, &x18, x16, x8, x5); + x19 = (x18 + x6); + fiat_p256_scalar_mulx_u64(&x20, &x21, x11, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x22, &x23, x20, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x24, &x25, x20, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x26, &x27, x20, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x28, &x29, x20, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x30, &x31, 0x0, x29, x26); + fiat_p256_scalar_addcarryx_u64(&x32, &x33, x31, x27, x24); + fiat_p256_scalar_addcarryx_u64(&x34, &x35, x33, x25, x22); + x36 = (x35 + x23); + fiat_p256_scalar_addcarryx_u64(&x37, &x38, 0x0, x11, x28); + fiat_p256_scalar_addcarryx_u64(&x39, &x40, x38, x13, x30); + fiat_p256_scalar_addcarryx_u64(&x41, &x42, x40, x15, x32); + fiat_p256_scalar_addcarryx_u64(&x43, &x44, x42, x17, x34); + fiat_p256_scalar_addcarryx_u64(&x45, &x46, x44, x19, x36); + fiat_p256_scalar_mulx_u64(&x47, &x48, x1, (arg1[3])); + fiat_p256_scalar_mulx_u64(&x49, &x50, x1, (arg1[2])); + fiat_p256_scalar_mulx_u64(&x51, &x52, x1, (arg1[1])); + fiat_p256_scalar_mulx_u64(&x53, &x54, x1, (arg1[0])); + fiat_p256_scalar_addcarryx_u64(&x55, &x56, 0x0, x54, x51); + fiat_p256_scalar_addcarryx_u64(&x57, &x58, x56, x52, x49); + fiat_p256_scalar_addcarryx_u64(&x59, &x60, x58, x50, x47); + x61 = (x60 + x48); + fiat_p256_scalar_addcarryx_u64(&x62, &x63, 0x0, x39, x53); + fiat_p256_scalar_addcarryx_u64(&x64, &x65, x63, x41, x55); + fiat_p256_scalar_addcarryx_u64(&x66, &x67, x65, x43, x57); + fiat_p256_scalar_addcarryx_u64(&x68, &x69, x67, x45, x59); + fiat_p256_scalar_addcarryx_u64(&x70, &x71, x69, x46, x61); + fiat_p256_scalar_mulx_u64(&x72, &x73, x62, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x74, &x75, x72, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x76, &x77, x72, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x78, &x79, x72, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x80, &x81, x72, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x82, &x83, 0x0, x81, x78); + fiat_p256_scalar_addcarryx_u64(&x84, &x85, x83, x79, x76); + fiat_p256_scalar_addcarryx_u64(&x86, &x87, x85, x77, x74); + x88 = (x87 + x75); + fiat_p256_scalar_addcarryx_u64(&x89, &x90, 0x0, x62, x80); + fiat_p256_scalar_addcarryx_u64(&x91, &x92, x90, x64, x82); + fiat_p256_scalar_addcarryx_u64(&x93, &x94, x92, x66, x84); + fiat_p256_scalar_addcarryx_u64(&x95, &x96, x94, x68, x86); + fiat_p256_scalar_addcarryx_u64(&x97, &x98, x96, x70, x88); + x99 = ((uint64_t)x98 + x71); + fiat_p256_scalar_mulx_u64(&x100, &x101, x2, (arg1[3])); + fiat_p256_scalar_mulx_u64(&x102, &x103, x2, (arg1[2])); + fiat_p256_scalar_mulx_u64(&x104, &x105, x2, (arg1[1])); + fiat_p256_scalar_mulx_u64(&x106, &x107, x2, (arg1[0])); + fiat_p256_scalar_addcarryx_u64(&x108, &x109, 0x0, x107, x104); + fiat_p256_scalar_addcarryx_u64(&x110, &x111, x109, x105, x102); + fiat_p256_scalar_addcarryx_u64(&x112, &x113, x111, x103, x100); + x114 = (x113 + x101); + fiat_p256_scalar_addcarryx_u64(&x115, &x116, 0x0, x91, x106); + fiat_p256_scalar_addcarryx_u64(&x117, &x118, x116, x93, x108); + fiat_p256_scalar_addcarryx_u64(&x119, &x120, x118, x95, x110); + fiat_p256_scalar_addcarryx_u64(&x121, &x122, x120, x97, x112); + fiat_p256_scalar_addcarryx_u64(&x123, &x124, x122, x99, x114); + fiat_p256_scalar_mulx_u64(&x125, &x126, x115, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x127, &x128, x125, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x129, &x130, x125, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x131, &x132, x125, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x133, &x134, x125, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x135, &x136, 0x0, x134, x131); + fiat_p256_scalar_addcarryx_u64(&x137, &x138, x136, x132, x129); + fiat_p256_scalar_addcarryx_u64(&x139, &x140, x138, x130, x127); + x141 = (x140 + x128); + fiat_p256_scalar_addcarryx_u64(&x142, &x143, 0x0, x115, x133); + fiat_p256_scalar_addcarryx_u64(&x144, &x145, x143, x117, x135); + fiat_p256_scalar_addcarryx_u64(&x146, &x147, x145, x119, x137); + fiat_p256_scalar_addcarryx_u64(&x148, &x149, x147, x121, x139); + fiat_p256_scalar_addcarryx_u64(&x150, &x151, x149, x123, x141); + x152 = ((uint64_t)x151 + x124); + fiat_p256_scalar_mulx_u64(&x153, &x154, x3, (arg1[3])); + fiat_p256_scalar_mulx_u64(&x155, &x156, x3, (arg1[2])); + fiat_p256_scalar_mulx_u64(&x157, &x158, x3, (arg1[1])); + fiat_p256_scalar_mulx_u64(&x159, &x160, x3, (arg1[0])); + fiat_p256_scalar_addcarryx_u64(&x161, &x162, 0x0, x160, x157); + fiat_p256_scalar_addcarryx_u64(&x163, &x164, x162, x158, x155); + fiat_p256_scalar_addcarryx_u64(&x165, &x166, x164, x156, x153); + x167 = (x166 + x154); + fiat_p256_scalar_addcarryx_u64(&x168, &x169, 0x0, x144, x159); + fiat_p256_scalar_addcarryx_u64(&x170, &x171, x169, x146, x161); + fiat_p256_scalar_addcarryx_u64(&x172, &x173, x171, x148, x163); + fiat_p256_scalar_addcarryx_u64(&x174, &x175, x173, x150, x165); + fiat_p256_scalar_addcarryx_u64(&x176, &x177, x175, x152, x167); + fiat_p256_scalar_mulx_u64(&x178, &x179, x168, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x180, &x181, x178, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x182, &x183, x178, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x184, &x185, x178, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x186, &x187, x178, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x188, &x189, 0x0, x187, x184); + fiat_p256_scalar_addcarryx_u64(&x190, &x191, x189, x185, x182); + fiat_p256_scalar_addcarryx_u64(&x192, &x193, x191, x183, x180); + x194 = (x193 + x181); + fiat_p256_scalar_addcarryx_u64(&x195, &x196, 0x0, x168, x186); + fiat_p256_scalar_addcarryx_u64(&x197, &x198, x196, x170, x188); + fiat_p256_scalar_addcarryx_u64(&x199, &x200, x198, x172, x190); + fiat_p256_scalar_addcarryx_u64(&x201, &x202, x200, x174, x192); + fiat_p256_scalar_addcarryx_u64(&x203, &x204, x202, x176, x194); + x205 = ((uint64_t)x204 + x177); + fiat_p256_scalar_subborrowx_u64(&x206, &x207, 0x0, x197, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_subborrowx_u64(&x208, &x209, x207, x199, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_subborrowx_u64(&x210, &x211, x209, x201, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_subborrowx_u64(&x212, &x213, x211, x203, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_subborrowx_u64(&x214, &x215, x213, x205, 0x0); + fiat_p256_scalar_cmovznz_u64(&x216, x215, x206, x197); + fiat_p256_scalar_cmovznz_u64(&x217, x215, x208, x199); + fiat_p256_scalar_cmovznz_u64(&x218, x215, x210, x201); + fiat_p256_scalar_cmovznz_u64(&x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/* + * The function fiat_p256_scalar_add adds two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_add(fiat_p256_scalar_montgomery_domain_field_element out1, const fiat_p256_scalar_montgomery_domain_field_element arg1, const fiat_p256_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_p256_scalar_uint1 x2; + uint64_t x3; + fiat_p256_scalar_uint1 x4; + uint64_t x5; + fiat_p256_scalar_uint1 x6; + uint64_t x7; + fiat_p256_scalar_uint1 x8; + uint64_t x9; + fiat_p256_scalar_uint1 x10; + uint64_t x11; + fiat_p256_scalar_uint1 x12; + uint64_t x13; + fiat_p256_scalar_uint1 x14; + uint64_t x15; + fiat_p256_scalar_uint1 x16; + uint64_t x17; + fiat_p256_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + fiat_p256_scalar_addcarryx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_p256_scalar_addcarryx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_p256_scalar_addcarryx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_p256_scalar_addcarryx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_p256_scalar_subborrowx_u64(&x9, &x10, 0x0, x1, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_subborrowx_u64(&x11, &x12, x10, x3, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_subborrowx_u64(&x13, &x14, x12, x5, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_subborrowx_u64(&x15, &x16, x14, x7, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_subborrowx_u64(&x17, &x18, x16, x8, 0x0); + fiat_p256_scalar_cmovznz_u64(&x19, x18, x9, x1); + fiat_p256_scalar_cmovznz_u64(&x20, x18, x11, x3); + fiat_p256_scalar_cmovznz_u64(&x21, x18, x13, x5); + fiat_p256_scalar_cmovznz_u64(&x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/* + * The function fiat_p256_scalar_sub subtracts two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_sub(fiat_p256_scalar_montgomery_domain_field_element out1, const fiat_p256_scalar_montgomery_domain_field_element arg1, const fiat_p256_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_p256_scalar_uint1 x2; + uint64_t x3; + fiat_p256_scalar_uint1 x4; + uint64_t x5; + fiat_p256_scalar_uint1 x6; + uint64_t x7; + fiat_p256_scalar_uint1 x8; + uint64_t x9; + uint64_t x10; + fiat_p256_scalar_uint1 x11; + uint64_t x12; + fiat_p256_scalar_uint1 x13; + uint64_t x14; + fiat_p256_scalar_uint1 x15; + uint64_t x16; + fiat_p256_scalar_uint1 x17; + fiat_p256_scalar_subborrowx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_p256_scalar_subborrowx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_p256_scalar_subborrowx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_p256_scalar_subborrowx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_p256_scalar_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_addcarryx_u64(&x10, &x11, 0x0, x1, (x9 & UINT64_C(0xf3b9cac2fc632551))); + fiat_p256_scalar_addcarryx_u64(&x12, &x13, x11, x3, (x9 & UINT64_C(0xbce6faada7179e84))); + fiat_p256_scalar_addcarryx_u64(&x14, &x15, x13, x5, x9); + fiat_p256_scalar_addcarryx_u64(&x16, &x17, x15, x7, (x9 & UINT64_C(0xffffffff00000000))); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/* + * The function fiat_p256_scalar_opp negates a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_opp(fiat_p256_scalar_montgomery_domain_field_element out1, const fiat_p256_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + fiat_p256_scalar_uint1 x2; + uint64_t x3; + fiat_p256_scalar_uint1 x4; + uint64_t x5; + fiat_p256_scalar_uint1 x6; + uint64_t x7; + fiat_p256_scalar_uint1 x8; + uint64_t x9; + uint64_t x10; + fiat_p256_scalar_uint1 x11; + uint64_t x12; + fiat_p256_scalar_uint1 x13; + uint64_t x14; + fiat_p256_scalar_uint1 x15; + uint64_t x16; + fiat_p256_scalar_uint1 x17; + fiat_p256_scalar_subborrowx_u64(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_p256_scalar_subborrowx_u64(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_p256_scalar_subborrowx_u64(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_p256_scalar_subborrowx_u64(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_p256_scalar_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_addcarryx_u64(&x10, &x11, 0x0, x1, (x9 & UINT64_C(0xf3b9cac2fc632551))); + fiat_p256_scalar_addcarryx_u64(&x12, &x13, x11, x3, (x9 & UINT64_C(0xbce6faada7179e84))); + fiat_p256_scalar_addcarryx_u64(&x14, &x15, x13, x5, x9); + fiat_p256_scalar_addcarryx_u64(&x16, &x17, x15, x7, (x9 & UINT64_C(0xffffffff00000000))); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/* + * The function fiat_p256_scalar_from_montgomery translates a field element out of the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_from_montgomery(fiat_p256_scalar_non_montgomery_domain_field_element out1, const fiat_p256_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + fiat_p256_scalar_uint1 x13; + uint64_t x14; + fiat_p256_scalar_uint1 x15; + uint64_t x16; + fiat_p256_scalar_uint1 x17; + uint64_t x18; + fiat_p256_scalar_uint1 x19; + uint64_t x20; + fiat_p256_scalar_uint1 x21; + uint64_t x22; + fiat_p256_scalar_uint1 x23; + uint64_t x24; + fiat_p256_scalar_uint1 x25; + uint64_t x26; + fiat_p256_scalar_uint1 x27; + uint64_t x28; + fiat_p256_scalar_uint1 x29; + uint64_t x30; + fiat_p256_scalar_uint1 x31; + uint64_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + fiat_p256_scalar_uint1 x43; + uint64_t x44; + fiat_p256_scalar_uint1 x45; + uint64_t x46; + fiat_p256_scalar_uint1 x47; + uint64_t x48; + fiat_p256_scalar_uint1 x49; + uint64_t x50; + fiat_p256_scalar_uint1 x51; + uint64_t x52; + fiat_p256_scalar_uint1 x53; + uint64_t x54; + fiat_p256_scalar_uint1 x55; + uint64_t x56; + fiat_p256_scalar_uint1 x57; + uint64_t x58; + fiat_p256_scalar_uint1 x59; + uint64_t x60; + fiat_p256_scalar_uint1 x61; + uint64_t x62; + uint64_t x63; + uint64_t x64; + uint64_t x65; + uint64_t x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + fiat_p256_scalar_uint1 x73; + uint64_t x74; + fiat_p256_scalar_uint1 x75; + uint64_t x76; + fiat_p256_scalar_uint1 x77; + uint64_t x78; + fiat_p256_scalar_uint1 x79; + uint64_t x80; + fiat_p256_scalar_uint1 x81; + uint64_t x82; + fiat_p256_scalar_uint1 x83; + uint64_t x84; + fiat_p256_scalar_uint1 x85; + uint64_t x86; + fiat_p256_scalar_uint1 x87; + uint64_t x88; + fiat_p256_scalar_uint1 x89; + uint64_t x90; + fiat_p256_scalar_uint1 x91; + uint64_t x92; + uint64_t x93; + uint64_t x94; + uint64_t x95; + uint64_t x96; + uint64_t x97; + uint64_t x98; + uint64_t x99; + uint64_t x100; + uint64_t x101; + uint64_t x102; + fiat_p256_scalar_uint1 x103; + uint64_t x104; + fiat_p256_scalar_uint1 x105; + uint64_t x106; + fiat_p256_scalar_uint1 x107; + uint64_t x108; + fiat_p256_scalar_uint1 x109; + uint64_t x110; + fiat_p256_scalar_uint1 x111; + uint64_t x112; + fiat_p256_scalar_uint1 x113; + uint64_t x114; + fiat_p256_scalar_uint1 x115; + uint64_t x116; + uint64_t x117; + fiat_p256_scalar_uint1 x118; + uint64_t x119; + fiat_p256_scalar_uint1 x120; + uint64_t x121; + fiat_p256_scalar_uint1 x122; + uint64_t x123; + fiat_p256_scalar_uint1 x124; + uint64_t x125; + fiat_p256_scalar_uint1 x126; + uint64_t x127; + uint64_t x128; + uint64_t x129; + uint64_t x130; + x1 = (arg1[0]); + fiat_p256_scalar_mulx_u64(&x2, &x3, x1, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x4, &x5, x2, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x6, &x7, x2, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x8, &x9, x2, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x10, &x11, x2, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x12, &x13, 0x0, x11, x8); + fiat_p256_scalar_addcarryx_u64(&x14, &x15, x13, x9, x6); + fiat_p256_scalar_addcarryx_u64(&x16, &x17, x15, x7, x4); + fiat_p256_scalar_addcarryx_u64(&x18, &x19, 0x0, x1, x10); + fiat_p256_scalar_addcarryx_u64(&x20, &x21, x19, 0x0, x12); + fiat_p256_scalar_addcarryx_u64(&x22, &x23, x21, 0x0, x14); + fiat_p256_scalar_addcarryx_u64(&x24, &x25, x23, 0x0, x16); + fiat_p256_scalar_addcarryx_u64(&x26, &x27, 0x0, x20, (arg1[1])); + fiat_p256_scalar_addcarryx_u64(&x28, &x29, x27, x22, 0x0); + fiat_p256_scalar_addcarryx_u64(&x30, &x31, x29, x24, 0x0); + fiat_p256_scalar_mulx_u64(&x32, &x33, x26, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x34, &x35, x32, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x36, &x37, x32, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x38, &x39, x32, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x40, &x41, x32, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x42, &x43, 0x0, x41, x38); + fiat_p256_scalar_addcarryx_u64(&x44, &x45, x43, x39, x36); + fiat_p256_scalar_addcarryx_u64(&x46, &x47, x45, x37, x34); + fiat_p256_scalar_addcarryx_u64(&x48, &x49, 0x0, x26, x40); + fiat_p256_scalar_addcarryx_u64(&x50, &x51, x49, x28, x42); + fiat_p256_scalar_addcarryx_u64(&x52, &x53, x51, x30, x44); + fiat_p256_scalar_addcarryx_u64(&x54, &x55, x53, (x31 + (x25 + (x17 + x5))), x46); + fiat_p256_scalar_addcarryx_u64(&x56, &x57, 0x0, x50, (arg1[2])); + fiat_p256_scalar_addcarryx_u64(&x58, &x59, x57, x52, 0x0); + fiat_p256_scalar_addcarryx_u64(&x60, &x61, x59, x54, 0x0); + fiat_p256_scalar_mulx_u64(&x62, &x63, x56, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x64, &x65, x62, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x66, &x67, x62, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x68, &x69, x62, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x70, &x71, x62, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x72, &x73, 0x0, x71, x68); + fiat_p256_scalar_addcarryx_u64(&x74, &x75, x73, x69, x66); + fiat_p256_scalar_addcarryx_u64(&x76, &x77, x75, x67, x64); + fiat_p256_scalar_addcarryx_u64(&x78, &x79, 0x0, x56, x70); + fiat_p256_scalar_addcarryx_u64(&x80, &x81, x79, x58, x72); + fiat_p256_scalar_addcarryx_u64(&x82, &x83, x81, x60, x74); + fiat_p256_scalar_addcarryx_u64(&x84, &x85, x83, (x61 + (x55 + (x47 + x35))), x76); + fiat_p256_scalar_addcarryx_u64(&x86, &x87, 0x0, x80, (arg1[3])); + fiat_p256_scalar_addcarryx_u64(&x88, &x89, x87, x82, 0x0); + fiat_p256_scalar_addcarryx_u64(&x90, &x91, x89, x84, 0x0); + fiat_p256_scalar_mulx_u64(&x92, &x93, x86, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x94, &x95, x92, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x96, &x97, x92, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x98, &x99, x92, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x100, &x101, x92, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x102, &x103, 0x0, x101, x98); + fiat_p256_scalar_addcarryx_u64(&x104, &x105, x103, x99, x96); + fiat_p256_scalar_addcarryx_u64(&x106, &x107, x105, x97, x94); + fiat_p256_scalar_addcarryx_u64(&x108, &x109, 0x0, x86, x100); + fiat_p256_scalar_addcarryx_u64(&x110, &x111, x109, x88, x102); + fiat_p256_scalar_addcarryx_u64(&x112, &x113, x111, x90, x104); + fiat_p256_scalar_addcarryx_u64(&x114, &x115, x113, (x91 + (x85 + (x77 + x65))), x106); + x116 = (x115 + (x107 + x95)); + fiat_p256_scalar_subborrowx_u64(&x117, &x118, 0x0, x110, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_subborrowx_u64(&x119, &x120, x118, x112, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_subborrowx_u64(&x121, &x122, x120, x114, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_subborrowx_u64(&x123, &x124, x122, x116, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_subborrowx_u64(&x125, &x126, x124, 0x0, 0x0); + fiat_p256_scalar_cmovznz_u64(&x127, x126, x117, x110); + fiat_p256_scalar_cmovznz_u64(&x128, x126, x119, x112); + fiat_p256_scalar_cmovznz_u64(&x129, x126, x121, x114); + fiat_p256_scalar_cmovznz_u64(&x130, x126, x123, x116); + out1[0] = x127; + out1[1] = x128; + out1[2] = x129; + out1[3] = x130; +} + +/* + * The function fiat_p256_scalar_to_montgomery translates a field element into the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = eval arg1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_to_montgomery(fiat_p256_scalar_montgomery_domain_field_element out1, const fiat_p256_scalar_non_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_p256_scalar_uint1 x14; + uint64_t x15; + fiat_p256_scalar_uint1 x16; + uint64_t x17; + fiat_p256_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + fiat_p256_scalar_uint1 x30; + uint64_t x31; + fiat_p256_scalar_uint1 x32; + uint64_t x33; + fiat_p256_scalar_uint1 x34; + uint64_t x35; + fiat_p256_scalar_uint1 x36; + uint64_t x37; + fiat_p256_scalar_uint1 x38; + uint64_t x39; + fiat_p256_scalar_uint1 x40; + uint64_t x41; + fiat_p256_scalar_uint1 x42; + uint64_t x43; + fiat_p256_scalar_uint1 x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + fiat_p256_scalar_uint1 x54; + uint64_t x55; + fiat_p256_scalar_uint1 x56; + uint64_t x57; + fiat_p256_scalar_uint1 x58; + uint64_t x59; + fiat_p256_scalar_uint1 x60; + uint64_t x61; + fiat_p256_scalar_uint1 x62; + uint64_t x63; + fiat_p256_scalar_uint1 x64; + uint64_t x65; + fiat_p256_scalar_uint1 x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + fiat_p256_scalar_uint1 x78; + uint64_t x79; + fiat_p256_scalar_uint1 x80; + uint64_t x81; + fiat_p256_scalar_uint1 x82; + uint64_t x83; + fiat_p256_scalar_uint1 x84; + uint64_t x85; + fiat_p256_scalar_uint1 x86; + uint64_t x87; + fiat_p256_scalar_uint1 x88; + uint64_t x89; + fiat_p256_scalar_uint1 x90; + uint64_t x91; + fiat_p256_scalar_uint1 x92; + uint64_t x93; + uint64_t x94; + uint64_t x95; + uint64_t x96; + uint64_t x97; + uint64_t x98; + uint64_t x99; + uint64_t x100; + uint64_t x101; + fiat_p256_scalar_uint1 x102; + uint64_t x103; + fiat_p256_scalar_uint1 x104; + uint64_t x105; + fiat_p256_scalar_uint1 x106; + uint64_t x107; + fiat_p256_scalar_uint1 x108; + uint64_t x109; + fiat_p256_scalar_uint1 x110; + uint64_t x111; + fiat_p256_scalar_uint1 x112; + uint64_t x113; + fiat_p256_scalar_uint1 x114; + uint64_t x115; + uint64_t x116; + uint64_t x117; + uint64_t x118; + uint64_t x119; + uint64_t x120; + uint64_t x121; + uint64_t x122; + uint64_t x123; + uint64_t x124; + uint64_t x125; + fiat_p256_scalar_uint1 x126; + uint64_t x127; + fiat_p256_scalar_uint1 x128; + uint64_t x129; + fiat_p256_scalar_uint1 x130; + uint64_t x131; + fiat_p256_scalar_uint1 x132; + uint64_t x133; + fiat_p256_scalar_uint1 x134; + uint64_t x135; + fiat_p256_scalar_uint1 x136; + uint64_t x137; + fiat_p256_scalar_uint1 x138; + uint64_t x139; + fiat_p256_scalar_uint1 x140; + uint64_t x141; + uint64_t x142; + uint64_t x143; + uint64_t x144; + uint64_t x145; + uint64_t x146; + uint64_t x147; + uint64_t x148; + uint64_t x149; + fiat_p256_scalar_uint1 x150; + uint64_t x151; + fiat_p256_scalar_uint1 x152; + uint64_t x153; + fiat_p256_scalar_uint1 x154; + uint64_t x155; + fiat_p256_scalar_uint1 x156; + uint64_t x157; + fiat_p256_scalar_uint1 x158; + uint64_t x159; + fiat_p256_scalar_uint1 x160; + uint64_t x161; + fiat_p256_scalar_uint1 x162; + uint64_t x163; + uint64_t x164; + uint64_t x165; + uint64_t x166; + uint64_t x167; + uint64_t x168; + uint64_t x169; + uint64_t x170; + uint64_t x171; + uint64_t x172; + uint64_t x173; + fiat_p256_scalar_uint1 x174; + uint64_t x175; + fiat_p256_scalar_uint1 x176; + uint64_t x177; + fiat_p256_scalar_uint1 x178; + uint64_t x179; + fiat_p256_scalar_uint1 x180; + uint64_t x181; + fiat_p256_scalar_uint1 x182; + uint64_t x183; + fiat_p256_scalar_uint1 x184; + uint64_t x185; + fiat_p256_scalar_uint1 x186; + uint64_t x187; + fiat_p256_scalar_uint1 x188; + uint64_t x189; + fiat_p256_scalar_uint1 x190; + uint64_t x191; + fiat_p256_scalar_uint1 x192; + uint64_t x193; + fiat_p256_scalar_uint1 x194; + uint64_t x195; + fiat_p256_scalar_uint1 x196; + uint64_t x197; + fiat_p256_scalar_uint1 x198; + uint64_t x199; + uint64_t x200; + uint64_t x201; + uint64_t x202; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_p256_scalar_mulx_u64(&x5, &x6, x4, UINT64_C(0x66e12d94f3d95620)); + fiat_p256_scalar_mulx_u64(&x7, &x8, x4, UINT64_C(0x2845b2392b6bec59)); + fiat_p256_scalar_mulx_u64(&x9, &x10, x4, UINT64_C(0x4699799c49bd6fa6)); + fiat_p256_scalar_mulx_u64(&x11, &x12, x4, UINT64_C(0x83244c95be79eea2)); + fiat_p256_scalar_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_p256_scalar_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_p256_scalar_addcarryx_u64(&x17, &x18, x16, x8, x5); + fiat_p256_scalar_mulx_u64(&x19, &x20, x11, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x21, &x22, x19, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x23, &x24, x19, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x25, &x26, x19, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x27, &x28, x19, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x29, &x30, 0x0, x28, x25); + fiat_p256_scalar_addcarryx_u64(&x31, &x32, x30, x26, x23); + fiat_p256_scalar_addcarryx_u64(&x33, &x34, x32, x24, x21); + fiat_p256_scalar_addcarryx_u64(&x35, &x36, 0x0, x11, x27); + fiat_p256_scalar_addcarryx_u64(&x37, &x38, x36, x13, x29); + fiat_p256_scalar_addcarryx_u64(&x39, &x40, x38, x15, x31); + fiat_p256_scalar_addcarryx_u64(&x41, &x42, x40, x17, x33); + fiat_p256_scalar_addcarryx_u64(&x43, &x44, x42, (x18 + x6), (x34 + x22)); + fiat_p256_scalar_mulx_u64(&x45, &x46, x1, UINT64_C(0x66e12d94f3d95620)); + fiat_p256_scalar_mulx_u64(&x47, &x48, x1, UINT64_C(0x2845b2392b6bec59)); + fiat_p256_scalar_mulx_u64(&x49, &x50, x1, UINT64_C(0x4699799c49bd6fa6)); + fiat_p256_scalar_mulx_u64(&x51, &x52, x1, UINT64_C(0x83244c95be79eea2)); + fiat_p256_scalar_addcarryx_u64(&x53, &x54, 0x0, x52, x49); + fiat_p256_scalar_addcarryx_u64(&x55, &x56, x54, x50, x47); + fiat_p256_scalar_addcarryx_u64(&x57, &x58, x56, x48, x45); + fiat_p256_scalar_addcarryx_u64(&x59, &x60, 0x0, x37, x51); + fiat_p256_scalar_addcarryx_u64(&x61, &x62, x60, x39, x53); + fiat_p256_scalar_addcarryx_u64(&x63, &x64, x62, x41, x55); + fiat_p256_scalar_addcarryx_u64(&x65, &x66, x64, x43, x57); + fiat_p256_scalar_mulx_u64(&x67, &x68, x59, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x69, &x70, x67, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x71, &x72, x67, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x73, &x74, x67, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x75, &x76, x67, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x77, &x78, 0x0, x76, x73); + fiat_p256_scalar_addcarryx_u64(&x79, &x80, x78, x74, x71); + fiat_p256_scalar_addcarryx_u64(&x81, &x82, x80, x72, x69); + fiat_p256_scalar_addcarryx_u64(&x83, &x84, 0x0, x59, x75); + fiat_p256_scalar_addcarryx_u64(&x85, &x86, x84, x61, x77); + fiat_p256_scalar_addcarryx_u64(&x87, &x88, x86, x63, x79); + fiat_p256_scalar_addcarryx_u64(&x89, &x90, x88, x65, x81); + fiat_p256_scalar_addcarryx_u64(&x91, &x92, x90, (((uint64_t)x66 + x44) + (x58 + x46)), (x82 + x70)); + fiat_p256_scalar_mulx_u64(&x93, &x94, x2, UINT64_C(0x66e12d94f3d95620)); + fiat_p256_scalar_mulx_u64(&x95, &x96, x2, UINT64_C(0x2845b2392b6bec59)); + fiat_p256_scalar_mulx_u64(&x97, &x98, x2, UINT64_C(0x4699799c49bd6fa6)); + fiat_p256_scalar_mulx_u64(&x99, &x100, x2, UINT64_C(0x83244c95be79eea2)); + fiat_p256_scalar_addcarryx_u64(&x101, &x102, 0x0, x100, x97); + fiat_p256_scalar_addcarryx_u64(&x103, &x104, x102, x98, x95); + fiat_p256_scalar_addcarryx_u64(&x105, &x106, x104, x96, x93); + fiat_p256_scalar_addcarryx_u64(&x107, &x108, 0x0, x85, x99); + fiat_p256_scalar_addcarryx_u64(&x109, &x110, x108, x87, x101); + fiat_p256_scalar_addcarryx_u64(&x111, &x112, x110, x89, x103); + fiat_p256_scalar_addcarryx_u64(&x113, &x114, x112, x91, x105); + fiat_p256_scalar_mulx_u64(&x115, &x116, x107, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x117, &x118, x115, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x119, &x120, x115, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x121, &x122, x115, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x123, &x124, x115, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x125, &x126, 0x0, x124, x121); + fiat_p256_scalar_addcarryx_u64(&x127, &x128, x126, x122, x119); + fiat_p256_scalar_addcarryx_u64(&x129, &x130, x128, x120, x117); + fiat_p256_scalar_addcarryx_u64(&x131, &x132, 0x0, x107, x123); + fiat_p256_scalar_addcarryx_u64(&x133, &x134, x132, x109, x125); + fiat_p256_scalar_addcarryx_u64(&x135, &x136, x134, x111, x127); + fiat_p256_scalar_addcarryx_u64(&x137, &x138, x136, x113, x129); + fiat_p256_scalar_addcarryx_u64(&x139, &x140, x138, (((uint64_t)x114 + x92) + (x106 + x94)), (x130 + x118)); + fiat_p256_scalar_mulx_u64(&x141, &x142, x3, UINT64_C(0x66e12d94f3d95620)); + fiat_p256_scalar_mulx_u64(&x143, &x144, x3, UINT64_C(0x2845b2392b6bec59)); + fiat_p256_scalar_mulx_u64(&x145, &x146, x3, UINT64_C(0x4699799c49bd6fa6)); + fiat_p256_scalar_mulx_u64(&x147, &x148, x3, UINT64_C(0x83244c95be79eea2)); + fiat_p256_scalar_addcarryx_u64(&x149, &x150, 0x0, x148, x145); + fiat_p256_scalar_addcarryx_u64(&x151, &x152, x150, x146, x143); + fiat_p256_scalar_addcarryx_u64(&x153, &x154, x152, x144, x141); + fiat_p256_scalar_addcarryx_u64(&x155, &x156, 0x0, x133, x147); + fiat_p256_scalar_addcarryx_u64(&x157, &x158, x156, x135, x149); + fiat_p256_scalar_addcarryx_u64(&x159, &x160, x158, x137, x151); + fiat_p256_scalar_addcarryx_u64(&x161, &x162, x160, x139, x153); + fiat_p256_scalar_mulx_u64(&x163, &x164, x155, UINT64_C(0xccd1c8aaee00bc4f)); + fiat_p256_scalar_mulx_u64(&x165, &x166, x163, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_mulx_u64(&x167, &x168, x163, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_mulx_u64(&x169, &x170, x163, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_mulx_u64(&x171, &x172, x163, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_addcarryx_u64(&x173, &x174, 0x0, x172, x169); + fiat_p256_scalar_addcarryx_u64(&x175, &x176, x174, x170, x167); + fiat_p256_scalar_addcarryx_u64(&x177, &x178, x176, x168, x165); + fiat_p256_scalar_addcarryx_u64(&x179, &x180, 0x0, x155, x171); + fiat_p256_scalar_addcarryx_u64(&x181, &x182, x180, x157, x173); + fiat_p256_scalar_addcarryx_u64(&x183, &x184, x182, x159, x175); + fiat_p256_scalar_addcarryx_u64(&x185, &x186, x184, x161, x177); + fiat_p256_scalar_addcarryx_u64(&x187, &x188, x186, (((uint64_t)x162 + x140) + (x154 + x142)), (x178 + x166)); + fiat_p256_scalar_subborrowx_u64(&x189, &x190, 0x0, x181, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_subborrowx_u64(&x191, &x192, x190, x183, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_subborrowx_u64(&x193, &x194, x192, x185, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_subborrowx_u64(&x195, &x196, x194, x187, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_subborrowx_u64(&x197, &x198, x196, x188, 0x0); + fiat_p256_scalar_cmovznz_u64(&x199, x198, x189, x181); + fiat_p256_scalar_cmovznz_u64(&x200, x198, x191, x183); + fiat_p256_scalar_cmovznz_u64(&x201, x198, x193, x185); + fiat_p256_scalar_cmovznz_u64(&x202, x198, x195, x187); + out1[0] = x199; + out1[1] = x200; + out1[2] = x201; + out1[3] = x202; +} + +/* + * The function fiat_p256_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_nonzero(uint64_t* out1, const uint64_t arg1[4]) { + uint64_t x1; + x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3])))); + *out1 = x1; +} + +/* + * The function fiat_p256_scalar_selectznz is a multi-limb conditional select. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_selectznz(uint64_t out1[4], fiat_p256_scalar_uint1 arg1, const uint64_t arg2[4], const uint64_t arg3[4]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + fiat_p256_scalar_cmovznz_u64(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_p256_scalar_cmovznz_u64(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_p256_scalar_cmovznz_u64(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_p256_scalar_cmovznz_u64(&x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/* + * The function fiat_p256_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_to_bytes(uint8_t out1[32], const uint64_t arg1[4]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint8_t x5; + uint64_t x6; + uint8_t x7; + uint64_t x8; + uint8_t x9; + uint64_t x10; + uint8_t x11; + uint64_t x12; + uint8_t x13; + uint64_t x14; + uint8_t x15; + uint64_t x16; + uint8_t x17; + uint8_t x18; + uint8_t x19; + uint64_t x20; + uint8_t x21; + uint64_t x22; + uint8_t x23; + uint64_t x24; + uint8_t x25; + uint64_t x26; + uint8_t x27; + uint64_t x28; + uint8_t x29; + uint64_t x30; + uint8_t x31; + uint8_t x32; + uint8_t x33; + uint64_t x34; + uint8_t x35; + uint64_t x36; + uint8_t x37; + uint64_t x38; + uint8_t x39; + uint64_t x40; + uint8_t x41; + uint64_t x42; + uint8_t x43; + uint64_t x44; + uint8_t x45; + uint8_t x46; + uint8_t x47; + uint64_t x48; + uint8_t x49; + uint64_t x50; + uint8_t x51; + uint64_t x52; + uint8_t x53; + uint64_t x54; + uint8_t x55; + uint64_t x56; + uint8_t x57; + uint64_t x58; + uint8_t x59; + uint8_t x60; + x1 = (arg1[3]); + x2 = (arg1[2]); + x3 = (arg1[1]); + x4 = (arg1[0]); + x5 = (uint8_t)(x4 & UINT8_C(0xff)); + x6 = (x4 >> 8); + x7 = (uint8_t)(x6 & UINT8_C(0xff)); + x8 = (x6 >> 8); + x9 = (uint8_t)(x8 & UINT8_C(0xff)); + x10 = (x8 >> 8); + x11 = (uint8_t)(x10 & UINT8_C(0xff)); + x12 = (x10 >> 8); + x13 = (uint8_t)(x12 & UINT8_C(0xff)); + x14 = (x12 >> 8); + x15 = (uint8_t)(x14 & UINT8_C(0xff)); + x16 = (x14 >> 8); + x17 = (uint8_t)(x16 & UINT8_C(0xff)); + x18 = (uint8_t)(x16 >> 8); + x19 = (uint8_t)(x3 & UINT8_C(0xff)); + x20 = (x3 >> 8); + x21 = (uint8_t)(x20 & UINT8_C(0xff)); + x22 = (x20 >> 8); + x23 = (uint8_t)(x22 & UINT8_C(0xff)); + x24 = (x22 >> 8); + x25 = (uint8_t)(x24 & UINT8_C(0xff)); + x26 = (x24 >> 8); + x27 = (uint8_t)(x26 & UINT8_C(0xff)); + x28 = (x26 >> 8); + x29 = (uint8_t)(x28 & UINT8_C(0xff)); + x30 = (x28 >> 8); + x31 = (uint8_t)(x30 & UINT8_C(0xff)); + x32 = (uint8_t)(x30 >> 8); + x33 = (uint8_t)(x2 & UINT8_C(0xff)); + x34 = (x2 >> 8); + x35 = (uint8_t)(x34 & UINT8_C(0xff)); + x36 = (x34 >> 8); + x37 = (uint8_t)(x36 & UINT8_C(0xff)); + x38 = (x36 >> 8); + x39 = (uint8_t)(x38 & UINT8_C(0xff)); + x40 = (x38 >> 8); + x41 = (uint8_t)(x40 & UINT8_C(0xff)); + x42 = (x40 >> 8); + x43 = (uint8_t)(x42 & UINT8_C(0xff)); + x44 = (x42 >> 8); + x45 = (uint8_t)(x44 & UINT8_C(0xff)); + x46 = (uint8_t)(x44 >> 8); + x47 = (uint8_t)(x1 & UINT8_C(0xff)); + x48 = (x1 >> 8); + x49 = (uint8_t)(x48 & UINT8_C(0xff)); + x50 = (x48 >> 8); + x51 = (uint8_t)(x50 & UINT8_C(0xff)); + x52 = (x50 >> 8); + x53 = (uint8_t)(x52 & UINT8_C(0xff)); + x54 = (x52 >> 8); + x55 = (uint8_t)(x54 & UINT8_C(0xff)); + x56 = (x54 >> 8); + x57 = (uint8_t)(x56 & UINT8_C(0xff)); + x58 = (x56 >> 8); + x59 = (uint8_t)(x58 & UINT8_C(0xff)); + x60 = (uint8_t)(x58 >> 8); + out1[0] = x5; + out1[1] = x7; + out1[2] = x9; + out1[3] = x11; + out1[4] = x13; + out1[5] = x15; + out1[6] = x17; + out1[7] = x18; + out1[8] = x19; + out1[9] = x21; + out1[10] = x23; + out1[11] = x25; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x39; + out1[20] = x41; + out1[21] = x43; + out1[22] = x45; + out1[23] = x46; + out1[24] = x47; + out1[25] = x49; + out1[26] = x51; + out1[27] = x53; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; +} + +/* + * The function fiat_p256_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. + * + * Preconditions: + * 0 ≤ bytes_eval arg1 < m + * Postconditions: + * eval out1 mod m = bytes_eval arg1 mod m + * 0 ≤ eval out1 < m + * + * Input Bounds: + * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_from_bytes(uint64_t out1[4], const uint8_t arg1[32]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint8_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint8_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint8_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint8_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + uint64_t x54; + uint64_t x55; + uint64_t x56; + uint64_t x57; + uint64_t x58; + uint64_t x59; + uint64_t x60; + x1 = ((uint64_t)(arg1[31]) << 56); + x2 = ((uint64_t)(arg1[30]) << 48); + x3 = ((uint64_t)(arg1[29]) << 40); + x4 = ((uint64_t)(arg1[28]) << 32); + x5 = ((uint64_t)(arg1[27]) << 24); + x6 = ((uint64_t)(arg1[26]) << 16); + x7 = ((uint64_t)(arg1[25]) << 8); + x8 = (arg1[24]); + x9 = ((uint64_t)(arg1[23]) << 56); + x10 = ((uint64_t)(arg1[22]) << 48); + x11 = ((uint64_t)(arg1[21]) << 40); + x12 = ((uint64_t)(arg1[20]) << 32); + x13 = ((uint64_t)(arg1[19]) << 24); + x14 = ((uint64_t)(arg1[18]) << 16); + x15 = ((uint64_t)(arg1[17]) << 8); + x16 = (arg1[16]); + x17 = ((uint64_t)(arg1[15]) << 56); + x18 = ((uint64_t)(arg1[14]) << 48); + x19 = ((uint64_t)(arg1[13]) << 40); + x20 = ((uint64_t)(arg1[12]) << 32); + x21 = ((uint64_t)(arg1[11]) << 24); + x22 = ((uint64_t)(arg1[10]) << 16); + x23 = ((uint64_t)(arg1[9]) << 8); + x24 = (arg1[8]); + x25 = ((uint64_t)(arg1[7]) << 56); + x26 = ((uint64_t)(arg1[6]) << 48); + x27 = ((uint64_t)(arg1[5]) << 40); + x28 = ((uint64_t)(arg1[4]) << 32); + x29 = ((uint64_t)(arg1[3]) << 24); + x30 = ((uint64_t)(arg1[2]) << 16); + x31 = ((uint64_t)(arg1[1]) << 8); + x32 = (arg1[0]); + x33 = (x31 + (uint64_t)x32); + x34 = (x30 + x33); + x35 = (x29 + x34); + x36 = (x28 + x35); + x37 = (x27 + x36); + x38 = (x26 + x37); + x39 = (x25 + x38); + x40 = (x23 + (uint64_t)x24); + x41 = (x22 + x40); + x42 = (x21 + x41); + x43 = (x20 + x42); + x44 = (x19 + x43); + x45 = (x18 + x44); + x46 = (x17 + x45); + x47 = (x15 + (uint64_t)x16); + x48 = (x14 + x47); + x49 = (x13 + x48); + x50 = (x12 + x49); + x51 = (x11 + x50); + x52 = (x10 + x51); + x53 = (x9 + x52); + x54 = (x7 + (uint64_t)x8); + x55 = (x6 + x54); + x56 = (x5 + x55); + x57 = (x4 + x56); + x58 = (x3 + x57); + x59 = (x2 + x58); + x60 = (x1 + x59); + out1[0] = x39; + out1[1] = x46; + out1[2] = x53; + out1[3] = x60; +} + +/* + * The function fiat_p256_scalar_set_one returns the field element one in the Montgomery domain. + * + * Postconditions: + * eval (from_montgomery out1) mod m = 1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_set_one(fiat_p256_scalar_montgomery_domain_field_element out1) { + out1[0] = UINT64_C(0xc46353d039cdaaf); + out1[1] = UINT64_C(0x4319055258e8617b); + out1[2] = 0x0; + out1[3] = UINT32_C(0xffffffff); +} + +/* + * The function fiat_p256_scalar_msat returns the saturated representation of the prime modulus. + * + * Postconditions: + * twos_complement_eval out1 = m + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_msat(uint64_t out1[5]) { + out1[0] = UINT64_C(0xf3b9cac2fc632551); + out1[1] = UINT64_C(0xbce6faada7179e84); + out1[2] = UINT64_C(0xffffffffffffffff); + out1[3] = UINT64_C(0xffffffff00000000); + out1[4] = 0x0; +} + +/* + * The function fiat_p256_scalar_divstep computes a divstep. + * + * Preconditions: + * 0 ≤ eval arg4 < m + * 0 ≤ eval arg5 < m + * Postconditions: + * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) + * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) + * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) + * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) + * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) + * 0 ≤ eval out5 < m + * 0 ≤ eval out5 < m + * 0 ≤ eval out2 < m + * 0 ≤ eval out3 < m + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffffffffffff] + * arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_divstep(uint64_t* out1, uint64_t out2[5], uint64_t out3[5], uint64_t out4[4], uint64_t out5[4], uint64_t arg1, const uint64_t arg2[5], const uint64_t arg3[5], const uint64_t arg4[4], const uint64_t arg5[4]) { + uint64_t x1; + fiat_p256_scalar_uint1 x2; + fiat_p256_scalar_uint1 x3; + uint64_t x4; + fiat_p256_scalar_uint1 x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + fiat_p256_scalar_uint1 x13; + uint64_t x14; + fiat_p256_scalar_uint1 x15; + uint64_t x16; + fiat_p256_scalar_uint1 x17; + uint64_t x18; + fiat_p256_scalar_uint1 x19; + uint64_t x20; + fiat_p256_scalar_uint1 x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + fiat_p256_scalar_uint1 x32; + uint64_t x33; + fiat_p256_scalar_uint1 x34; + uint64_t x35; + fiat_p256_scalar_uint1 x36; + uint64_t x37; + fiat_p256_scalar_uint1 x38; + uint64_t x39; + fiat_p256_scalar_uint1 x40; + uint64_t x41; + fiat_p256_scalar_uint1 x42; + uint64_t x43; + fiat_p256_scalar_uint1 x44; + uint64_t x45; + fiat_p256_scalar_uint1 x46; + uint64_t x47; + fiat_p256_scalar_uint1 x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + fiat_p256_scalar_uint1 x54; + uint64_t x55; + fiat_p256_scalar_uint1 x56; + uint64_t x57; + fiat_p256_scalar_uint1 x58; + uint64_t x59; + fiat_p256_scalar_uint1 x60; + uint64_t x61; + uint64_t x62; + fiat_p256_scalar_uint1 x63; + uint64_t x64; + fiat_p256_scalar_uint1 x65; + uint64_t x66; + fiat_p256_scalar_uint1 x67; + uint64_t x68; + fiat_p256_scalar_uint1 x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + fiat_p256_scalar_uint1 x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + fiat_p256_scalar_uint1 x81; + uint64_t x82; + fiat_p256_scalar_uint1 x83; + uint64_t x84; + fiat_p256_scalar_uint1 x85; + uint64_t x86; + fiat_p256_scalar_uint1 x87; + uint64_t x88; + fiat_p256_scalar_uint1 x89; + uint64_t x90; + uint64_t x91; + uint64_t x92; + uint64_t x93; + uint64_t x94; + fiat_p256_scalar_uint1 x95; + uint64_t x96; + fiat_p256_scalar_uint1 x97; + uint64_t x98; + fiat_p256_scalar_uint1 x99; + uint64_t x100; + fiat_p256_scalar_uint1 x101; + uint64_t x102; + fiat_p256_scalar_uint1 x103; + uint64_t x104; + fiat_p256_scalar_uint1 x105; + uint64_t x106; + fiat_p256_scalar_uint1 x107; + uint64_t x108; + fiat_p256_scalar_uint1 x109; + uint64_t x110; + fiat_p256_scalar_uint1 x111; + uint64_t x112; + fiat_p256_scalar_uint1 x113; + uint64_t x114; + uint64_t x115; + uint64_t x116; + uint64_t x117; + uint64_t x118; + uint64_t x119; + uint64_t x120; + uint64_t x121; + uint64_t x122; + uint64_t x123; + uint64_t x124; + uint64_t x125; + uint64_t x126; + fiat_p256_scalar_addcarryx_u64(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_p256_scalar_uint1)((fiat_p256_scalar_uint1)(x1 >> 63) & (fiat_p256_scalar_uint1)((arg3[0]) & 0x1)); + fiat_p256_scalar_addcarryx_u64(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_p256_scalar_cmovznz_u64(&x6, x3, arg1, x4); + fiat_p256_scalar_cmovznz_u64(&x7, x3, (arg2[0]), (arg3[0])); + fiat_p256_scalar_cmovznz_u64(&x8, x3, (arg2[1]), (arg3[1])); + fiat_p256_scalar_cmovznz_u64(&x9, x3, (arg2[2]), (arg3[2])); + fiat_p256_scalar_cmovznz_u64(&x10, x3, (arg2[3]), (arg3[3])); + fiat_p256_scalar_cmovznz_u64(&x11, x3, (arg2[4]), (arg3[4])); + fiat_p256_scalar_addcarryx_u64(&x12, &x13, 0x0, 0x1, (~(arg2[0]))); + fiat_p256_scalar_addcarryx_u64(&x14, &x15, x13, 0x0, (~(arg2[1]))); + fiat_p256_scalar_addcarryx_u64(&x16, &x17, x15, 0x0, (~(arg2[2]))); + fiat_p256_scalar_addcarryx_u64(&x18, &x19, x17, 0x0, (~(arg2[3]))); + fiat_p256_scalar_addcarryx_u64(&x20, &x21, x19, 0x0, (~(arg2[4]))); + fiat_p256_scalar_cmovznz_u64(&x22, x3, (arg3[0]), x12); + fiat_p256_scalar_cmovznz_u64(&x23, x3, (arg3[1]), x14); + fiat_p256_scalar_cmovznz_u64(&x24, x3, (arg3[2]), x16); + fiat_p256_scalar_cmovznz_u64(&x25, x3, (arg3[3]), x18); + fiat_p256_scalar_cmovznz_u64(&x26, x3, (arg3[4]), x20); + fiat_p256_scalar_cmovznz_u64(&x27, x3, (arg4[0]), (arg5[0])); + fiat_p256_scalar_cmovznz_u64(&x28, x3, (arg4[1]), (arg5[1])); + fiat_p256_scalar_cmovznz_u64(&x29, x3, (arg4[2]), (arg5[2])); + fiat_p256_scalar_cmovznz_u64(&x30, x3, (arg4[3]), (arg5[3])); + fiat_p256_scalar_addcarryx_u64(&x31, &x32, 0x0, x27, x27); + fiat_p256_scalar_addcarryx_u64(&x33, &x34, x32, x28, x28); + fiat_p256_scalar_addcarryx_u64(&x35, &x36, x34, x29, x29); + fiat_p256_scalar_addcarryx_u64(&x37, &x38, x36, x30, x30); + fiat_p256_scalar_subborrowx_u64(&x39, &x40, 0x0, x31, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_subborrowx_u64(&x41, &x42, x40, x33, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_subborrowx_u64(&x43, &x44, x42, x35, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_subborrowx_u64(&x45, &x46, x44, x37, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_subborrowx_u64(&x47, &x48, x46, x38, 0x0); + x49 = (arg4[3]); + x50 = (arg4[2]); + x51 = (arg4[1]); + x52 = (arg4[0]); + fiat_p256_scalar_subborrowx_u64(&x53, &x54, 0x0, 0x0, x52); + fiat_p256_scalar_subborrowx_u64(&x55, &x56, x54, 0x0, x51); + fiat_p256_scalar_subborrowx_u64(&x57, &x58, x56, 0x0, x50); + fiat_p256_scalar_subborrowx_u64(&x59, &x60, x58, 0x0, x49); + fiat_p256_scalar_cmovznz_u64(&x61, x60, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_addcarryx_u64(&x62, &x63, 0x0, x53, (x61 & UINT64_C(0xf3b9cac2fc632551))); + fiat_p256_scalar_addcarryx_u64(&x64, &x65, x63, x55, (x61 & UINT64_C(0xbce6faada7179e84))); + fiat_p256_scalar_addcarryx_u64(&x66, &x67, x65, x57, x61); + fiat_p256_scalar_addcarryx_u64(&x68, &x69, x67, x59, (x61 & UINT64_C(0xffffffff00000000))); + fiat_p256_scalar_cmovznz_u64(&x70, x3, (arg5[0]), x62); + fiat_p256_scalar_cmovznz_u64(&x71, x3, (arg5[1]), x64); + fiat_p256_scalar_cmovznz_u64(&x72, x3, (arg5[2]), x66); + fiat_p256_scalar_cmovznz_u64(&x73, x3, (arg5[3]), x68); + x74 = (fiat_p256_scalar_uint1)(x22 & 0x1); + fiat_p256_scalar_cmovznz_u64(&x75, x74, 0x0, x7); + fiat_p256_scalar_cmovznz_u64(&x76, x74, 0x0, x8); + fiat_p256_scalar_cmovznz_u64(&x77, x74, 0x0, x9); + fiat_p256_scalar_cmovznz_u64(&x78, x74, 0x0, x10); + fiat_p256_scalar_cmovznz_u64(&x79, x74, 0x0, x11); + fiat_p256_scalar_addcarryx_u64(&x80, &x81, 0x0, x22, x75); + fiat_p256_scalar_addcarryx_u64(&x82, &x83, x81, x23, x76); + fiat_p256_scalar_addcarryx_u64(&x84, &x85, x83, x24, x77); + fiat_p256_scalar_addcarryx_u64(&x86, &x87, x85, x25, x78); + fiat_p256_scalar_addcarryx_u64(&x88, &x89, x87, x26, x79); + fiat_p256_scalar_cmovznz_u64(&x90, x74, 0x0, x27); + fiat_p256_scalar_cmovznz_u64(&x91, x74, 0x0, x28); + fiat_p256_scalar_cmovznz_u64(&x92, x74, 0x0, x29); + fiat_p256_scalar_cmovznz_u64(&x93, x74, 0x0, x30); + fiat_p256_scalar_addcarryx_u64(&x94, &x95, 0x0, x70, x90); + fiat_p256_scalar_addcarryx_u64(&x96, &x97, x95, x71, x91); + fiat_p256_scalar_addcarryx_u64(&x98, &x99, x97, x72, x92); + fiat_p256_scalar_addcarryx_u64(&x100, &x101, x99, x73, x93); + fiat_p256_scalar_subborrowx_u64(&x102, &x103, 0x0, x94, UINT64_C(0xf3b9cac2fc632551)); + fiat_p256_scalar_subborrowx_u64(&x104, &x105, x103, x96, UINT64_C(0xbce6faada7179e84)); + fiat_p256_scalar_subborrowx_u64(&x106, &x107, x105, x98, UINT64_C(0xffffffffffffffff)); + fiat_p256_scalar_subborrowx_u64(&x108, &x109, x107, x100, UINT64_C(0xffffffff00000000)); + fiat_p256_scalar_subborrowx_u64(&x110, &x111, x109, x101, 0x0); + fiat_p256_scalar_addcarryx_u64(&x112, &x113, 0x0, x6, 0x1); + x114 = ((x80 >> 1) | ((x82 << 63) & UINT64_C(0xffffffffffffffff))); + x115 = ((x82 >> 1) | ((x84 << 63) & UINT64_C(0xffffffffffffffff))); + x116 = ((x84 >> 1) | ((x86 << 63) & UINT64_C(0xffffffffffffffff))); + x117 = ((x86 >> 1) | ((x88 << 63) & UINT64_C(0xffffffffffffffff))); + x118 = ((x88 & UINT64_C(0x8000000000000000)) | (x88 >> 1)); + fiat_p256_scalar_cmovznz_u64(&x119, x48, x39, x31); + fiat_p256_scalar_cmovznz_u64(&x120, x48, x41, x33); + fiat_p256_scalar_cmovznz_u64(&x121, x48, x43, x35); + fiat_p256_scalar_cmovznz_u64(&x122, x48, x45, x37); + fiat_p256_scalar_cmovznz_u64(&x123, x111, x102, x94); + fiat_p256_scalar_cmovznz_u64(&x124, x111, x104, x96); + fiat_p256_scalar_cmovznz_u64(&x125, x111, x106, x98); + fiat_p256_scalar_cmovznz_u64(&x126, x111, x108, x100); + *out1 = x112; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out3[0] = x114; + out3[1] = x115; + out3[2] = x116; + out3[3] = x117; + out3[4] = x118; + out4[0] = x119; + out4[1] = x120; + out4[2] = x121; + out4[3] = x122; + out5[0] = x123; + out5[1] = x124; + out5[2] = x125; + out5[3] = x126; +} + +/* + * The function fiat_p256_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). + * + * Postconditions: + * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P256_SCALAR_FIAT_INLINE void fiat_p256_scalar_divstep_precomp(uint64_t out1[4]) { + out1[0] = UINT64_C(0xd739262fb7fcfbb5); + out1[1] = UINT64_C(0x8ac6f75d20074414); + out1[2] = UINT64_C(0xc67428bfb5e3c256); + out1[3] = UINT64_C(0x444962f2eda7aedf); +} diff --git a/fiat-c/src/p384_scalar_32.c b/fiat-c/src/p384_scalar_32.c new file mode 100644 index 0000000000..d110884adf --- /dev/null +++ b/fiat-c/src/p384_scalar_32.c @@ -0,0 +1,11725 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier p384_scalar 32 '2^384 - 1388124618062372383947042015309946732620727252194336364173' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: p384_scalar */ +/* machine_wordsize = 32 (from "32") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from "2^384 - 1388124618062372383947042015309946732620727252194336364173") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) in */ +/* if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384 */ + +#include +typedef unsigned char fiat_p384_scalar_uint1; +typedef signed char fiat_p384_scalar_int1; +#if defined(__GNUC__) || defined(__clang__) +# define FIAT_P384_SCALAR_FIAT_INLINE __inline__ +#else +# define FIAT_P384_SCALAR_FIAT_INLINE +#endif + +/* The type fiat_p384_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +typedef uint32_t fiat_p384_scalar_montgomery_domain_field_element[12]; + +/* The type fiat_p384_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +typedef uint32_t fiat_p384_scalar_non_montgomery_domain_field_element[12]; + +#if (-1 & 3) != 3 +#error "This code only works on a two's complement system" +#endif + +#if !defined(FIAT_P384_SCALAR_NO_ASM) && (defined(__GNUC__) || defined(__clang__)) +static __inline__ uint32_t fiat_p384_scalar_value_barrier_u32(uint32_t a) { + __asm__("" : "+r"(a) : /* no inputs */); + return a; +} +#else +# define fiat_p384_scalar_value_barrier_u32(x) (x) +#endif + + +/* + * The function fiat_p384_scalar_addcarryx_u32 is an addition with carry. + * + * Postconditions: + * out1 = (arg1 + arg2 + arg3) mod 2^32 + * out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffff] + * arg3: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_addcarryx_u32(uint32_t* out1, fiat_p384_scalar_uint1* out2, fiat_p384_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + uint64_t x1; + uint32_t x2; + fiat_p384_scalar_uint1 x3; + x1 = ((arg1 + (uint64_t)arg2) + arg3); + x2 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + x3 = (fiat_p384_scalar_uint1)(x1 >> 32); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_p384_scalar_subborrowx_u32 is a subtraction with borrow. + * + * Postconditions: + * out1 = (-arg1 + arg2 + -arg3) mod 2^32 + * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffff] + * arg3: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_subborrowx_u32(uint32_t* out1, fiat_p384_scalar_uint1* out2, fiat_p384_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + int64_t x1; + fiat_p384_scalar_int1 x2; + uint32_t x3; + x1 = ((arg2 - (int64_t)arg1) - arg3); + x2 = (fiat_p384_scalar_int1)(x1 >> 32); + x3 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + *out1 = x3; + *out2 = (fiat_p384_scalar_uint1)(0x0 - x2); +} + +/* + * The function fiat_p384_scalar_mulx_u32 is a multiplication, returning the full double-width result. + * + * Postconditions: + * out1 = (arg1 * arg2) mod 2^32 + * out2 = ⌊arg1 * arg2 / 2^32⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffff] + * arg2: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [0x0 ~> 0xffffffff] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_mulx_u32(uint32_t* out1, uint32_t* out2, uint32_t arg1, uint32_t arg2) { + uint64_t x1; + uint32_t x2; + uint32_t x3; + x1 = ((uint64_t)arg1 * arg2); + x2 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + x3 = (uint32_t)(x1 >> 32); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_p384_scalar_cmovznz_u32 is a single-word conditional move. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffff] + * arg3: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_cmovznz_u32(uint32_t* out1, fiat_p384_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + fiat_p384_scalar_uint1 x1; + uint32_t x2; + uint32_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_p384_scalar_int1)(0x0 - x1) & UINT32_C(0xffffffff)); + x3 = ((fiat_p384_scalar_value_barrier_u32(x2) & arg3) | (fiat_p384_scalar_value_barrier_u32((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_p384_scalar_mul multiplies two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_mul(fiat_p384_scalar_montgomery_domain_field_element out1, const fiat_p384_scalar_montgomery_domain_field_element arg1, const fiat_p384_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + uint32_t x26; + uint32_t x27; + uint32_t x28; + uint32_t x29; + uint32_t x30; + uint32_t x31; + uint32_t x32; + uint32_t x33; + uint32_t x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + fiat_p384_scalar_uint1 x38; + uint32_t x39; + fiat_p384_scalar_uint1 x40; + uint32_t x41; + fiat_p384_scalar_uint1 x42; + uint32_t x43; + fiat_p384_scalar_uint1 x44; + uint32_t x45; + fiat_p384_scalar_uint1 x46; + uint32_t x47; + fiat_p384_scalar_uint1 x48; + uint32_t x49; + fiat_p384_scalar_uint1 x50; + uint32_t x51; + fiat_p384_scalar_uint1 x52; + uint32_t x53; + fiat_p384_scalar_uint1 x54; + uint32_t x55; + fiat_p384_scalar_uint1 x56; + uint32_t x57; + fiat_p384_scalar_uint1 x58; + uint32_t x59; + uint32_t x60; + uint32_t x61; + uint32_t x62; + uint32_t x63; + uint32_t x64; + uint32_t x65; + uint32_t x66; + uint32_t x67; + uint32_t x68; + uint32_t x69; + uint32_t x70; + uint32_t x71; + uint32_t x72; + uint32_t x73; + uint32_t x74; + uint32_t x75; + uint32_t x76; + uint32_t x77; + uint32_t x78; + uint32_t x79; + uint32_t x80; + uint32_t x81; + uint32_t x82; + uint32_t x83; + uint32_t x84; + uint32_t x85; + uint32_t x86; + fiat_p384_scalar_uint1 x87; + uint32_t x88; + fiat_p384_scalar_uint1 x89; + uint32_t x90; + fiat_p384_scalar_uint1 x91; + uint32_t x92; + fiat_p384_scalar_uint1 x93; + uint32_t x94; + fiat_p384_scalar_uint1 x95; + uint32_t x96; + fiat_p384_scalar_uint1 x97; + uint32_t x98; + fiat_p384_scalar_uint1 x99; + uint32_t x100; + fiat_p384_scalar_uint1 x101; + uint32_t x102; + fiat_p384_scalar_uint1 x103; + uint32_t x104; + fiat_p384_scalar_uint1 x105; + uint32_t x106; + fiat_p384_scalar_uint1 x107; + uint32_t x108; + uint32_t x109; + fiat_p384_scalar_uint1 x110; + uint32_t x111; + fiat_p384_scalar_uint1 x112; + uint32_t x113; + fiat_p384_scalar_uint1 x114; + uint32_t x115; + fiat_p384_scalar_uint1 x116; + uint32_t x117; + fiat_p384_scalar_uint1 x118; + uint32_t x119; + fiat_p384_scalar_uint1 x120; + uint32_t x121; + fiat_p384_scalar_uint1 x122; + uint32_t x123; + fiat_p384_scalar_uint1 x124; + uint32_t x125; + fiat_p384_scalar_uint1 x126; + uint32_t x127; + fiat_p384_scalar_uint1 x128; + uint32_t x129; + fiat_p384_scalar_uint1 x130; + uint32_t x131; + fiat_p384_scalar_uint1 x132; + uint32_t x133; + fiat_p384_scalar_uint1 x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + uint32_t x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + uint32_t x145; + uint32_t x146; + uint32_t x147; + uint32_t x148; + uint32_t x149; + uint32_t x150; + uint32_t x151; + uint32_t x152; + uint32_t x153; + uint32_t x154; + uint32_t x155; + uint32_t x156; + uint32_t x157; + uint32_t x158; + uint32_t x159; + fiat_p384_scalar_uint1 x160; + uint32_t x161; + fiat_p384_scalar_uint1 x162; + uint32_t x163; + fiat_p384_scalar_uint1 x164; + uint32_t x165; + fiat_p384_scalar_uint1 x166; + uint32_t x167; + fiat_p384_scalar_uint1 x168; + uint32_t x169; + fiat_p384_scalar_uint1 x170; + uint32_t x171; + fiat_p384_scalar_uint1 x172; + uint32_t x173; + fiat_p384_scalar_uint1 x174; + uint32_t x175; + fiat_p384_scalar_uint1 x176; + uint32_t x177; + fiat_p384_scalar_uint1 x178; + uint32_t x179; + fiat_p384_scalar_uint1 x180; + uint32_t x181; + uint32_t x182; + fiat_p384_scalar_uint1 x183; + uint32_t x184; + fiat_p384_scalar_uint1 x185; + uint32_t x186; + fiat_p384_scalar_uint1 x187; + uint32_t x188; + fiat_p384_scalar_uint1 x189; + uint32_t x190; + fiat_p384_scalar_uint1 x191; + uint32_t x192; + fiat_p384_scalar_uint1 x193; + uint32_t x194; + fiat_p384_scalar_uint1 x195; + uint32_t x196; + fiat_p384_scalar_uint1 x197; + uint32_t x198; + fiat_p384_scalar_uint1 x199; + uint32_t x200; + fiat_p384_scalar_uint1 x201; + uint32_t x202; + fiat_p384_scalar_uint1 x203; + uint32_t x204; + fiat_p384_scalar_uint1 x205; + uint32_t x206; + fiat_p384_scalar_uint1 x207; + uint32_t x208; + uint32_t x209; + uint32_t x210; + uint32_t x211; + uint32_t x212; + uint32_t x213; + uint32_t x214; + uint32_t x215; + uint32_t x216; + uint32_t x217; + uint32_t x218; + uint32_t x219; + uint32_t x220; + uint32_t x221; + uint32_t x222; + uint32_t x223; + uint32_t x224; + uint32_t x225; + uint32_t x226; + uint32_t x227; + uint32_t x228; + uint32_t x229; + uint32_t x230; + uint32_t x231; + uint32_t x232; + uint32_t x233; + uint32_t x234; + fiat_p384_scalar_uint1 x235; + uint32_t x236; + fiat_p384_scalar_uint1 x237; + uint32_t x238; + fiat_p384_scalar_uint1 x239; + uint32_t x240; + fiat_p384_scalar_uint1 x241; + uint32_t x242; + fiat_p384_scalar_uint1 x243; + uint32_t x244; + fiat_p384_scalar_uint1 x245; + uint32_t x246; + fiat_p384_scalar_uint1 x247; + uint32_t x248; + fiat_p384_scalar_uint1 x249; + uint32_t x250; + fiat_p384_scalar_uint1 x251; + uint32_t x252; + fiat_p384_scalar_uint1 x253; + uint32_t x254; + fiat_p384_scalar_uint1 x255; + uint32_t x256; + uint32_t x257; + fiat_p384_scalar_uint1 x258; + uint32_t x259; + fiat_p384_scalar_uint1 x260; + uint32_t x261; + fiat_p384_scalar_uint1 x262; + uint32_t x263; + fiat_p384_scalar_uint1 x264; + uint32_t x265; + fiat_p384_scalar_uint1 x266; + uint32_t x267; + fiat_p384_scalar_uint1 x268; + uint32_t x269; + fiat_p384_scalar_uint1 x270; + uint32_t x271; + fiat_p384_scalar_uint1 x272; + uint32_t x273; + fiat_p384_scalar_uint1 x274; + uint32_t x275; + fiat_p384_scalar_uint1 x276; + uint32_t x277; + fiat_p384_scalar_uint1 x278; + uint32_t x279; + fiat_p384_scalar_uint1 x280; + uint32_t x281; + fiat_p384_scalar_uint1 x282; + uint32_t x283; + uint32_t x284; + uint32_t x285; + uint32_t x286; + uint32_t x287; + uint32_t x288; + uint32_t x289; + uint32_t x290; + uint32_t x291; + uint32_t x292; + uint32_t x293; + uint32_t x294; + uint32_t x295; + uint32_t x296; + uint32_t x297; + uint32_t x298; + uint32_t x299; + uint32_t x300; + uint32_t x301; + uint32_t x302; + uint32_t x303; + uint32_t x304; + uint32_t x305; + uint32_t x306; + uint32_t x307; + uint32_t x308; + fiat_p384_scalar_uint1 x309; + uint32_t x310; + fiat_p384_scalar_uint1 x311; + uint32_t x312; + fiat_p384_scalar_uint1 x313; + uint32_t x314; + fiat_p384_scalar_uint1 x315; + uint32_t x316; + fiat_p384_scalar_uint1 x317; + uint32_t x318; + fiat_p384_scalar_uint1 x319; + uint32_t x320; + fiat_p384_scalar_uint1 x321; + uint32_t x322; + fiat_p384_scalar_uint1 x323; + uint32_t x324; + fiat_p384_scalar_uint1 x325; + uint32_t x326; + fiat_p384_scalar_uint1 x327; + uint32_t x328; + fiat_p384_scalar_uint1 x329; + uint32_t x330; + uint32_t x331; + fiat_p384_scalar_uint1 x332; + uint32_t x333; + fiat_p384_scalar_uint1 x334; + uint32_t x335; + fiat_p384_scalar_uint1 x336; + uint32_t x337; + fiat_p384_scalar_uint1 x338; + uint32_t x339; + fiat_p384_scalar_uint1 x340; + uint32_t x341; + fiat_p384_scalar_uint1 x342; + uint32_t x343; + fiat_p384_scalar_uint1 x344; + uint32_t x345; + fiat_p384_scalar_uint1 x346; + uint32_t x347; + fiat_p384_scalar_uint1 x348; + uint32_t x349; + fiat_p384_scalar_uint1 x350; + uint32_t x351; + fiat_p384_scalar_uint1 x352; + uint32_t x353; + fiat_p384_scalar_uint1 x354; + uint32_t x355; + fiat_p384_scalar_uint1 x356; + uint32_t x357; + uint32_t x358; + uint32_t x359; + uint32_t x360; + uint32_t x361; + uint32_t x362; + uint32_t x363; + uint32_t x364; + uint32_t x365; + uint32_t x366; + uint32_t x367; + uint32_t x368; + uint32_t x369; + uint32_t x370; + uint32_t x371; + uint32_t x372; + uint32_t x373; + uint32_t x374; + uint32_t x375; + uint32_t x376; + uint32_t x377; + uint32_t x378; + uint32_t x379; + uint32_t x380; + uint32_t x381; + uint32_t x382; + uint32_t x383; + fiat_p384_scalar_uint1 x384; + uint32_t x385; + fiat_p384_scalar_uint1 x386; + uint32_t x387; + fiat_p384_scalar_uint1 x388; + uint32_t x389; + fiat_p384_scalar_uint1 x390; + uint32_t x391; + fiat_p384_scalar_uint1 x392; + uint32_t x393; + fiat_p384_scalar_uint1 x394; + uint32_t x395; + fiat_p384_scalar_uint1 x396; + uint32_t x397; + fiat_p384_scalar_uint1 x398; + uint32_t x399; + fiat_p384_scalar_uint1 x400; + uint32_t x401; + fiat_p384_scalar_uint1 x402; + uint32_t x403; + fiat_p384_scalar_uint1 x404; + uint32_t x405; + uint32_t x406; + fiat_p384_scalar_uint1 x407; + uint32_t x408; + fiat_p384_scalar_uint1 x409; + uint32_t x410; + fiat_p384_scalar_uint1 x411; + uint32_t x412; + fiat_p384_scalar_uint1 x413; + uint32_t x414; + fiat_p384_scalar_uint1 x415; + uint32_t x416; + fiat_p384_scalar_uint1 x417; + uint32_t x418; + fiat_p384_scalar_uint1 x419; + uint32_t x420; + fiat_p384_scalar_uint1 x421; + uint32_t x422; + fiat_p384_scalar_uint1 x423; + uint32_t x424; + fiat_p384_scalar_uint1 x425; + uint32_t x426; + fiat_p384_scalar_uint1 x427; + uint32_t x428; + fiat_p384_scalar_uint1 x429; + uint32_t x430; + fiat_p384_scalar_uint1 x431; + uint32_t x432; + uint32_t x433; + uint32_t x434; + uint32_t x435; + uint32_t x436; + uint32_t x437; + uint32_t x438; + uint32_t x439; + uint32_t x440; + uint32_t x441; + uint32_t x442; + uint32_t x443; + uint32_t x444; + uint32_t x445; + uint32_t x446; + uint32_t x447; + uint32_t x448; + uint32_t x449; + uint32_t x450; + uint32_t x451; + uint32_t x452; + uint32_t x453; + uint32_t x454; + uint32_t x455; + uint32_t x456; + uint32_t x457; + fiat_p384_scalar_uint1 x458; + uint32_t x459; + fiat_p384_scalar_uint1 x460; + uint32_t x461; + fiat_p384_scalar_uint1 x462; + uint32_t x463; + fiat_p384_scalar_uint1 x464; + uint32_t x465; + fiat_p384_scalar_uint1 x466; + uint32_t x467; + fiat_p384_scalar_uint1 x468; + uint32_t x469; + fiat_p384_scalar_uint1 x470; + uint32_t x471; + fiat_p384_scalar_uint1 x472; + uint32_t x473; + fiat_p384_scalar_uint1 x474; + uint32_t x475; + fiat_p384_scalar_uint1 x476; + uint32_t x477; + fiat_p384_scalar_uint1 x478; + uint32_t x479; + uint32_t x480; + fiat_p384_scalar_uint1 x481; + uint32_t x482; + fiat_p384_scalar_uint1 x483; + uint32_t x484; + fiat_p384_scalar_uint1 x485; + uint32_t x486; + fiat_p384_scalar_uint1 x487; + uint32_t x488; + fiat_p384_scalar_uint1 x489; + uint32_t x490; + fiat_p384_scalar_uint1 x491; + uint32_t x492; + fiat_p384_scalar_uint1 x493; + uint32_t x494; + fiat_p384_scalar_uint1 x495; + uint32_t x496; + fiat_p384_scalar_uint1 x497; + uint32_t x498; + fiat_p384_scalar_uint1 x499; + uint32_t x500; + fiat_p384_scalar_uint1 x501; + uint32_t x502; + fiat_p384_scalar_uint1 x503; + uint32_t x504; + fiat_p384_scalar_uint1 x505; + uint32_t x506; + uint32_t x507; + uint32_t x508; + uint32_t x509; + uint32_t x510; + uint32_t x511; + uint32_t x512; + uint32_t x513; + uint32_t x514; + uint32_t x515; + uint32_t x516; + uint32_t x517; + uint32_t x518; + uint32_t x519; + uint32_t x520; + uint32_t x521; + uint32_t x522; + uint32_t x523; + uint32_t x524; + uint32_t x525; + uint32_t x526; + uint32_t x527; + uint32_t x528; + uint32_t x529; + uint32_t x530; + uint32_t x531; + uint32_t x532; + fiat_p384_scalar_uint1 x533; + uint32_t x534; + fiat_p384_scalar_uint1 x535; + uint32_t x536; + fiat_p384_scalar_uint1 x537; + uint32_t x538; + fiat_p384_scalar_uint1 x539; + uint32_t x540; + fiat_p384_scalar_uint1 x541; + uint32_t x542; + fiat_p384_scalar_uint1 x543; + uint32_t x544; + fiat_p384_scalar_uint1 x545; + uint32_t x546; + fiat_p384_scalar_uint1 x547; + uint32_t x548; + fiat_p384_scalar_uint1 x549; + uint32_t x550; + fiat_p384_scalar_uint1 x551; + uint32_t x552; + fiat_p384_scalar_uint1 x553; + uint32_t x554; + uint32_t x555; + fiat_p384_scalar_uint1 x556; + uint32_t x557; + fiat_p384_scalar_uint1 x558; + uint32_t x559; + fiat_p384_scalar_uint1 x560; + uint32_t x561; + fiat_p384_scalar_uint1 x562; + uint32_t x563; + fiat_p384_scalar_uint1 x564; + uint32_t x565; + fiat_p384_scalar_uint1 x566; + uint32_t x567; + fiat_p384_scalar_uint1 x568; + uint32_t x569; + fiat_p384_scalar_uint1 x570; + uint32_t x571; + fiat_p384_scalar_uint1 x572; + uint32_t x573; + fiat_p384_scalar_uint1 x574; + uint32_t x575; + fiat_p384_scalar_uint1 x576; + uint32_t x577; + fiat_p384_scalar_uint1 x578; + uint32_t x579; + fiat_p384_scalar_uint1 x580; + uint32_t x581; + uint32_t x582; + uint32_t x583; + uint32_t x584; + uint32_t x585; + uint32_t x586; + uint32_t x587; + uint32_t x588; + uint32_t x589; + uint32_t x590; + uint32_t x591; + uint32_t x592; + uint32_t x593; + uint32_t x594; + uint32_t x595; + uint32_t x596; + uint32_t x597; + uint32_t x598; + uint32_t x599; + uint32_t x600; + uint32_t x601; + uint32_t x602; + uint32_t x603; + uint32_t x604; + uint32_t x605; + uint32_t x606; + fiat_p384_scalar_uint1 x607; + uint32_t x608; + fiat_p384_scalar_uint1 x609; + uint32_t x610; + fiat_p384_scalar_uint1 x611; + uint32_t x612; + fiat_p384_scalar_uint1 x613; + uint32_t x614; + fiat_p384_scalar_uint1 x615; + uint32_t x616; + fiat_p384_scalar_uint1 x617; + uint32_t x618; + fiat_p384_scalar_uint1 x619; + uint32_t x620; + fiat_p384_scalar_uint1 x621; + uint32_t x622; + fiat_p384_scalar_uint1 x623; + uint32_t x624; + fiat_p384_scalar_uint1 x625; + uint32_t x626; + fiat_p384_scalar_uint1 x627; + uint32_t x628; + uint32_t x629; + fiat_p384_scalar_uint1 x630; + uint32_t x631; + fiat_p384_scalar_uint1 x632; + uint32_t x633; + fiat_p384_scalar_uint1 x634; + uint32_t x635; + fiat_p384_scalar_uint1 x636; + uint32_t x637; + fiat_p384_scalar_uint1 x638; + uint32_t x639; + fiat_p384_scalar_uint1 x640; + uint32_t x641; + fiat_p384_scalar_uint1 x642; + uint32_t x643; + fiat_p384_scalar_uint1 x644; + uint32_t x645; + fiat_p384_scalar_uint1 x646; + uint32_t x647; + fiat_p384_scalar_uint1 x648; + uint32_t x649; + fiat_p384_scalar_uint1 x650; + uint32_t x651; + fiat_p384_scalar_uint1 x652; + uint32_t x653; + fiat_p384_scalar_uint1 x654; + uint32_t x655; + uint32_t x656; + uint32_t x657; + uint32_t x658; + uint32_t x659; + uint32_t x660; + uint32_t x661; + uint32_t x662; + uint32_t x663; + uint32_t x664; + uint32_t x665; + uint32_t x666; + uint32_t x667; + uint32_t x668; + uint32_t x669; + uint32_t x670; + uint32_t x671; + uint32_t x672; + uint32_t x673; + uint32_t x674; + uint32_t x675; + uint32_t x676; + uint32_t x677; + uint32_t x678; + uint32_t x679; + uint32_t x680; + uint32_t x681; + fiat_p384_scalar_uint1 x682; + uint32_t x683; + fiat_p384_scalar_uint1 x684; + uint32_t x685; + fiat_p384_scalar_uint1 x686; + uint32_t x687; + fiat_p384_scalar_uint1 x688; + uint32_t x689; + fiat_p384_scalar_uint1 x690; + uint32_t x691; + fiat_p384_scalar_uint1 x692; + uint32_t x693; + fiat_p384_scalar_uint1 x694; + uint32_t x695; + fiat_p384_scalar_uint1 x696; + uint32_t x697; + fiat_p384_scalar_uint1 x698; + uint32_t x699; + fiat_p384_scalar_uint1 x700; + uint32_t x701; + fiat_p384_scalar_uint1 x702; + uint32_t x703; + uint32_t x704; + fiat_p384_scalar_uint1 x705; + uint32_t x706; + fiat_p384_scalar_uint1 x707; + uint32_t x708; + fiat_p384_scalar_uint1 x709; + uint32_t x710; + fiat_p384_scalar_uint1 x711; + uint32_t x712; + fiat_p384_scalar_uint1 x713; + uint32_t x714; + fiat_p384_scalar_uint1 x715; + uint32_t x716; + fiat_p384_scalar_uint1 x717; + uint32_t x718; + fiat_p384_scalar_uint1 x719; + uint32_t x720; + fiat_p384_scalar_uint1 x721; + uint32_t x722; + fiat_p384_scalar_uint1 x723; + uint32_t x724; + fiat_p384_scalar_uint1 x725; + uint32_t x726; + fiat_p384_scalar_uint1 x727; + uint32_t x728; + fiat_p384_scalar_uint1 x729; + uint32_t x730; + uint32_t x731; + uint32_t x732; + uint32_t x733; + uint32_t x734; + uint32_t x735; + uint32_t x736; + uint32_t x737; + uint32_t x738; + uint32_t x739; + uint32_t x740; + uint32_t x741; + uint32_t x742; + uint32_t x743; + uint32_t x744; + uint32_t x745; + uint32_t x746; + uint32_t x747; + uint32_t x748; + uint32_t x749; + uint32_t x750; + uint32_t x751; + uint32_t x752; + uint32_t x753; + uint32_t x754; + uint32_t x755; + fiat_p384_scalar_uint1 x756; + uint32_t x757; + fiat_p384_scalar_uint1 x758; + uint32_t x759; + fiat_p384_scalar_uint1 x760; + uint32_t x761; + fiat_p384_scalar_uint1 x762; + uint32_t x763; + fiat_p384_scalar_uint1 x764; + uint32_t x765; + fiat_p384_scalar_uint1 x766; + uint32_t x767; + fiat_p384_scalar_uint1 x768; + uint32_t x769; + fiat_p384_scalar_uint1 x770; + uint32_t x771; + fiat_p384_scalar_uint1 x772; + uint32_t x773; + fiat_p384_scalar_uint1 x774; + uint32_t x775; + fiat_p384_scalar_uint1 x776; + uint32_t x777; + uint32_t x778; + fiat_p384_scalar_uint1 x779; + uint32_t x780; + fiat_p384_scalar_uint1 x781; + uint32_t x782; + fiat_p384_scalar_uint1 x783; + uint32_t x784; + fiat_p384_scalar_uint1 x785; + uint32_t x786; + fiat_p384_scalar_uint1 x787; + uint32_t x788; + fiat_p384_scalar_uint1 x789; + uint32_t x790; + fiat_p384_scalar_uint1 x791; + uint32_t x792; + fiat_p384_scalar_uint1 x793; + uint32_t x794; + fiat_p384_scalar_uint1 x795; + uint32_t x796; + fiat_p384_scalar_uint1 x797; + uint32_t x798; + fiat_p384_scalar_uint1 x799; + uint32_t x800; + fiat_p384_scalar_uint1 x801; + uint32_t x802; + fiat_p384_scalar_uint1 x803; + uint32_t x804; + uint32_t x805; + uint32_t x806; + uint32_t x807; + uint32_t x808; + uint32_t x809; + uint32_t x810; + uint32_t x811; + uint32_t x812; + uint32_t x813; + uint32_t x814; + uint32_t x815; + uint32_t x816; + uint32_t x817; + uint32_t x818; + uint32_t x819; + uint32_t x820; + uint32_t x821; + uint32_t x822; + uint32_t x823; + uint32_t x824; + uint32_t x825; + uint32_t x826; + uint32_t x827; + uint32_t x828; + uint32_t x829; + uint32_t x830; + fiat_p384_scalar_uint1 x831; + uint32_t x832; + fiat_p384_scalar_uint1 x833; + uint32_t x834; + fiat_p384_scalar_uint1 x835; + uint32_t x836; + fiat_p384_scalar_uint1 x837; + uint32_t x838; + fiat_p384_scalar_uint1 x839; + uint32_t x840; + fiat_p384_scalar_uint1 x841; + uint32_t x842; + fiat_p384_scalar_uint1 x843; + uint32_t x844; + fiat_p384_scalar_uint1 x845; + uint32_t x846; + fiat_p384_scalar_uint1 x847; + uint32_t x848; + fiat_p384_scalar_uint1 x849; + uint32_t x850; + fiat_p384_scalar_uint1 x851; + uint32_t x852; + uint32_t x853; + fiat_p384_scalar_uint1 x854; + uint32_t x855; + fiat_p384_scalar_uint1 x856; + uint32_t x857; + fiat_p384_scalar_uint1 x858; + uint32_t x859; + fiat_p384_scalar_uint1 x860; + uint32_t x861; + fiat_p384_scalar_uint1 x862; + uint32_t x863; + fiat_p384_scalar_uint1 x864; + uint32_t x865; + fiat_p384_scalar_uint1 x866; + uint32_t x867; + fiat_p384_scalar_uint1 x868; + uint32_t x869; + fiat_p384_scalar_uint1 x870; + uint32_t x871; + fiat_p384_scalar_uint1 x872; + uint32_t x873; + fiat_p384_scalar_uint1 x874; + uint32_t x875; + fiat_p384_scalar_uint1 x876; + uint32_t x877; + fiat_p384_scalar_uint1 x878; + uint32_t x879; + uint32_t x880; + uint32_t x881; + uint32_t x882; + uint32_t x883; + uint32_t x884; + uint32_t x885; + uint32_t x886; + uint32_t x887; + uint32_t x888; + uint32_t x889; + uint32_t x890; + uint32_t x891; + uint32_t x892; + uint32_t x893; + uint32_t x894; + uint32_t x895; + uint32_t x896; + uint32_t x897; + uint32_t x898; + uint32_t x899; + uint32_t x900; + uint32_t x901; + uint32_t x902; + uint32_t x903; + uint32_t x904; + fiat_p384_scalar_uint1 x905; + uint32_t x906; + fiat_p384_scalar_uint1 x907; + uint32_t x908; + fiat_p384_scalar_uint1 x909; + uint32_t x910; + fiat_p384_scalar_uint1 x911; + uint32_t x912; + fiat_p384_scalar_uint1 x913; + uint32_t x914; + fiat_p384_scalar_uint1 x915; + uint32_t x916; + fiat_p384_scalar_uint1 x917; + uint32_t x918; + fiat_p384_scalar_uint1 x919; + uint32_t x920; + fiat_p384_scalar_uint1 x921; + uint32_t x922; + fiat_p384_scalar_uint1 x923; + uint32_t x924; + fiat_p384_scalar_uint1 x925; + uint32_t x926; + uint32_t x927; + fiat_p384_scalar_uint1 x928; + uint32_t x929; + fiat_p384_scalar_uint1 x930; + uint32_t x931; + fiat_p384_scalar_uint1 x932; + uint32_t x933; + fiat_p384_scalar_uint1 x934; + uint32_t x935; + fiat_p384_scalar_uint1 x936; + uint32_t x937; + fiat_p384_scalar_uint1 x938; + uint32_t x939; + fiat_p384_scalar_uint1 x940; + uint32_t x941; + fiat_p384_scalar_uint1 x942; + uint32_t x943; + fiat_p384_scalar_uint1 x944; + uint32_t x945; + fiat_p384_scalar_uint1 x946; + uint32_t x947; + fiat_p384_scalar_uint1 x948; + uint32_t x949; + fiat_p384_scalar_uint1 x950; + uint32_t x951; + fiat_p384_scalar_uint1 x952; + uint32_t x953; + uint32_t x954; + uint32_t x955; + uint32_t x956; + uint32_t x957; + uint32_t x958; + uint32_t x959; + uint32_t x960; + uint32_t x961; + uint32_t x962; + uint32_t x963; + uint32_t x964; + uint32_t x965; + uint32_t x966; + uint32_t x967; + uint32_t x968; + uint32_t x969; + uint32_t x970; + uint32_t x971; + uint32_t x972; + uint32_t x973; + uint32_t x974; + uint32_t x975; + uint32_t x976; + uint32_t x977; + uint32_t x978; + uint32_t x979; + fiat_p384_scalar_uint1 x980; + uint32_t x981; + fiat_p384_scalar_uint1 x982; + uint32_t x983; + fiat_p384_scalar_uint1 x984; + uint32_t x985; + fiat_p384_scalar_uint1 x986; + uint32_t x987; + fiat_p384_scalar_uint1 x988; + uint32_t x989; + fiat_p384_scalar_uint1 x990; + uint32_t x991; + fiat_p384_scalar_uint1 x992; + uint32_t x993; + fiat_p384_scalar_uint1 x994; + uint32_t x995; + fiat_p384_scalar_uint1 x996; + uint32_t x997; + fiat_p384_scalar_uint1 x998; + uint32_t x999; + fiat_p384_scalar_uint1 x1000; + uint32_t x1001; + uint32_t x1002; + fiat_p384_scalar_uint1 x1003; + uint32_t x1004; + fiat_p384_scalar_uint1 x1005; + uint32_t x1006; + fiat_p384_scalar_uint1 x1007; + uint32_t x1008; + fiat_p384_scalar_uint1 x1009; + uint32_t x1010; + fiat_p384_scalar_uint1 x1011; + uint32_t x1012; + fiat_p384_scalar_uint1 x1013; + uint32_t x1014; + fiat_p384_scalar_uint1 x1015; + uint32_t x1016; + fiat_p384_scalar_uint1 x1017; + uint32_t x1018; + fiat_p384_scalar_uint1 x1019; + uint32_t x1020; + fiat_p384_scalar_uint1 x1021; + uint32_t x1022; + fiat_p384_scalar_uint1 x1023; + uint32_t x1024; + fiat_p384_scalar_uint1 x1025; + uint32_t x1026; + fiat_p384_scalar_uint1 x1027; + uint32_t x1028; + uint32_t x1029; + uint32_t x1030; + uint32_t x1031; + uint32_t x1032; + uint32_t x1033; + uint32_t x1034; + uint32_t x1035; + uint32_t x1036; + uint32_t x1037; + uint32_t x1038; + uint32_t x1039; + uint32_t x1040; + uint32_t x1041; + uint32_t x1042; + uint32_t x1043; + uint32_t x1044; + uint32_t x1045; + uint32_t x1046; + uint32_t x1047; + uint32_t x1048; + uint32_t x1049; + uint32_t x1050; + uint32_t x1051; + uint32_t x1052; + uint32_t x1053; + fiat_p384_scalar_uint1 x1054; + uint32_t x1055; + fiat_p384_scalar_uint1 x1056; + uint32_t x1057; + fiat_p384_scalar_uint1 x1058; + uint32_t x1059; + fiat_p384_scalar_uint1 x1060; + uint32_t x1061; + fiat_p384_scalar_uint1 x1062; + uint32_t x1063; + fiat_p384_scalar_uint1 x1064; + uint32_t x1065; + fiat_p384_scalar_uint1 x1066; + uint32_t x1067; + fiat_p384_scalar_uint1 x1068; + uint32_t x1069; + fiat_p384_scalar_uint1 x1070; + uint32_t x1071; + fiat_p384_scalar_uint1 x1072; + uint32_t x1073; + fiat_p384_scalar_uint1 x1074; + uint32_t x1075; + uint32_t x1076; + fiat_p384_scalar_uint1 x1077; + uint32_t x1078; + fiat_p384_scalar_uint1 x1079; + uint32_t x1080; + fiat_p384_scalar_uint1 x1081; + uint32_t x1082; + fiat_p384_scalar_uint1 x1083; + uint32_t x1084; + fiat_p384_scalar_uint1 x1085; + uint32_t x1086; + fiat_p384_scalar_uint1 x1087; + uint32_t x1088; + fiat_p384_scalar_uint1 x1089; + uint32_t x1090; + fiat_p384_scalar_uint1 x1091; + uint32_t x1092; + fiat_p384_scalar_uint1 x1093; + uint32_t x1094; + fiat_p384_scalar_uint1 x1095; + uint32_t x1096; + fiat_p384_scalar_uint1 x1097; + uint32_t x1098; + fiat_p384_scalar_uint1 x1099; + uint32_t x1100; + fiat_p384_scalar_uint1 x1101; + uint32_t x1102; + uint32_t x1103; + uint32_t x1104; + uint32_t x1105; + uint32_t x1106; + uint32_t x1107; + uint32_t x1108; + uint32_t x1109; + uint32_t x1110; + uint32_t x1111; + uint32_t x1112; + uint32_t x1113; + uint32_t x1114; + uint32_t x1115; + uint32_t x1116; + uint32_t x1117; + uint32_t x1118; + uint32_t x1119; + uint32_t x1120; + uint32_t x1121; + uint32_t x1122; + uint32_t x1123; + uint32_t x1124; + uint32_t x1125; + uint32_t x1126; + uint32_t x1127; + uint32_t x1128; + fiat_p384_scalar_uint1 x1129; + uint32_t x1130; + fiat_p384_scalar_uint1 x1131; + uint32_t x1132; + fiat_p384_scalar_uint1 x1133; + uint32_t x1134; + fiat_p384_scalar_uint1 x1135; + uint32_t x1136; + fiat_p384_scalar_uint1 x1137; + uint32_t x1138; + fiat_p384_scalar_uint1 x1139; + uint32_t x1140; + fiat_p384_scalar_uint1 x1141; + uint32_t x1142; + fiat_p384_scalar_uint1 x1143; + uint32_t x1144; + fiat_p384_scalar_uint1 x1145; + uint32_t x1146; + fiat_p384_scalar_uint1 x1147; + uint32_t x1148; + fiat_p384_scalar_uint1 x1149; + uint32_t x1150; + uint32_t x1151; + fiat_p384_scalar_uint1 x1152; + uint32_t x1153; + fiat_p384_scalar_uint1 x1154; + uint32_t x1155; + fiat_p384_scalar_uint1 x1156; + uint32_t x1157; + fiat_p384_scalar_uint1 x1158; + uint32_t x1159; + fiat_p384_scalar_uint1 x1160; + uint32_t x1161; + fiat_p384_scalar_uint1 x1162; + uint32_t x1163; + fiat_p384_scalar_uint1 x1164; + uint32_t x1165; + fiat_p384_scalar_uint1 x1166; + uint32_t x1167; + fiat_p384_scalar_uint1 x1168; + uint32_t x1169; + fiat_p384_scalar_uint1 x1170; + uint32_t x1171; + fiat_p384_scalar_uint1 x1172; + uint32_t x1173; + fiat_p384_scalar_uint1 x1174; + uint32_t x1175; + fiat_p384_scalar_uint1 x1176; + uint32_t x1177; + uint32_t x1178; + uint32_t x1179; + uint32_t x1180; + uint32_t x1181; + uint32_t x1182; + uint32_t x1183; + uint32_t x1184; + uint32_t x1185; + uint32_t x1186; + uint32_t x1187; + uint32_t x1188; + uint32_t x1189; + uint32_t x1190; + uint32_t x1191; + uint32_t x1192; + uint32_t x1193; + uint32_t x1194; + uint32_t x1195; + uint32_t x1196; + uint32_t x1197; + uint32_t x1198; + uint32_t x1199; + uint32_t x1200; + uint32_t x1201; + uint32_t x1202; + fiat_p384_scalar_uint1 x1203; + uint32_t x1204; + fiat_p384_scalar_uint1 x1205; + uint32_t x1206; + fiat_p384_scalar_uint1 x1207; + uint32_t x1208; + fiat_p384_scalar_uint1 x1209; + uint32_t x1210; + fiat_p384_scalar_uint1 x1211; + uint32_t x1212; + fiat_p384_scalar_uint1 x1213; + uint32_t x1214; + fiat_p384_scalar_uint1 x1215; + uint32_t x1216; + fiat_p384_scalar_uint1 x1217; + uint32_t x1218; + fiat_p384_scalar_uint1 x1219; + uint32_t x1220; + fiat_p384_scalar_uint1 x1221; + uint32_t x1222; + fiat_p384_scalar_uint1 x1223; + uint32_t x1224; + uint32_t x1225; + fiat_p384_scalar_uint1 x1226; + uint32_t x1227; + fiat_p384_scalar_uint1 x1228; + uint32_t x1229; + fiat_p384_scalar_uint1 x1230; + uint32_t x1231; + fiat_p384_scalar_uint1 x1232; + uint32_t x1233; + fiat_p384_scalar_uint1 x1234; + uint32_t x1235; + fiat_p384_scalar_uint1 x1236; + uint32_t x1237; + fiat_p384_scalar_uint1 x1238; + uint32_t x1239; + fiat_p384_scalar_uint1 x1240; + uint32_t x1241; + fiat_p384_scalar_uint1 x1242; + uint32_t x1243; + fiat_p384_scalar_uint1 x1244; + uint32_t x1245; + fiat_p384_scalar_uint1 x1246; + uint32_t x1247; + fiat_p384_scalar_uint1 x1248; + uint32_t x1249; + fiat_p384_scalar_uint1 x1250; + uint32_t x1251; + uint32_t x1252; + uint32_t x1253; + uint32_t x1254; + uint32_t x1255; + uint32_t x1256; + uint32_t x1257; + uint32_t x1258; + uint32_t x1259; + uint32_t x1260; + uint32_t x1261; + uint32_t x1262; + uint32_t x1263; + uint32_t x1264; + uint32_t x1265; + uint32_t x1266; + uint32_t x1267; + uint32_t x1268; + uint32_t x1269; + uint32_t x1270; + uint32_t x1271; + uint32_t x1272; + uint32_t x1273; + uint32_t x1274; + uint32_t x1275; + uint32_t x1276; + uint32_t x1277; + fiat_p384_scalar_uint1 x1278; + uint32_t x1279; + fiat_p384_scalar_uint1 x1280; + uint32_t x1281; + fiat_p384_scalar_uint1 x1282; + uint32_t x1283; + fiat_p384_scalar_uint1 x1284; + uint32_t x1285; + fiat_p384_scalar_uint1 x1286; + uint32_t x1287; + fiat_p384_scalar_uint1 x1288; + uint32_t x1289; + fiat_p384_scalar_uint1 x1290; + uint32_t x1291; + fiat_p384_scalar_uint1 x1292; + uint32_t x1293; + fiat_p384_scalar_uint1 x1294; + uint32_t x1295; + fiat_p384_scalar_uint1 x1296; + uint32_t x1297; + fiat_p384_scalar_uint1 x1298; + uint32_t x1299; + uint32_t x1300; + fiat_p384_scalar_uint1 x1301; + uint32_t x1302; + fiat_p384_scalar_uint1 x1303; + uint32_t x1304; + fiat_p384_scalar_uint1 x1305; + uint32_t x1306; + fiat_p384_scalar_uint1 x1307; + uint32_t x1308; + fiat_p384_scalar_uint1 x1309; + uint32_t x1310; + fiat_p384_scalar_uint1 x1311; + uint32_t x1312; + fiat_p384_scalar_uint1 x1313; + uint32_t x1314; + fiat_p384_scalar_uint1 x1315; + uint32_t x1316; + fiat_p384_scalar_uint1 x1317; + uint32_t x1318; + fiat_p384_scalar_uint1 x1319; + uint32_t x1320; + fiat_p384_scalar_uint1 x1321; + uint32_t x1322; + fiat_p384_scalar_uint1 x1323; + uint32_t x1324; + fiat_p384_scalar_uint1 x1325; + uint32_t x1326; + uint32_t x1327; + uint32_t x1328; + uint32_t x1329; + uint32_t x1330; + uint32_t x1331; + uint32_t x1332; + uint32_t x1333; + uint32_t x1334; + uint32_t x1335; + uint32_t x1336; + uint32_t x1337; + uint32_t x1338; + uint32_t x1339; + uint32_t x1340; + uint32_t x1341; + uint32_t x1342; + uint32_t x1343; + uint32_t x1344; + uint32_t x1345; + uint32_t x1346; + uint32_t x1347; + uint32_t x1348; + uint32_t x1349; + uint32_t x1350; + uint32_t x1351; + fiat_p384_scalar_uint1 x1352; + uint32_t x1353; + fiat_p384_scalar_uint1 x1354; + uint32_t x1355; + fiat_p384_scalar_uint1 x1356; + uint32_t x1357; + fiat_p384_scalar_uint1 x1358; + uint32_t x1359; + fiat_p384_scalar_uint1 x1360; + uint32_t x1361; + fiat_p384_scalar_uint1 x1362; + uint32_t x1363; + fiat_p384_scalar_uint1 x1364; + uint32_t x1365; + fiat_p384_scalar_uint1 x1366; + uint32_t x1367; + fiat_p384_scalar_uint1 x1368; + uint32_t x1369; + fiat_p384_scalar_uint1 x1370; + uint32_t x1371; + fiat_p384_scalar_uint1 x1372; + uint32_t x1373; + uint32_t x1374; + fiat_p384_scalar_uint1 x1375; + uint32_t x1376; + fiat_p384_scalar_uint1 x1377; + uint32_t x1378; + fiat_p384_scalar_uint1 x1379; + uint32_t x1380; + fiat_p384_scalar_uint1 x1381; + uint32_t x1382; + fiat_p384_scalar_uint1 x1383; + uint32_t x1384; + fiat_p384_scalar_uint1 x1385; + uint32_t x1386; + fiat_p384_scalar_uint1 x1387; + uint32_t x1388; + fiat_p384_scalar_uint1 x1389; + uint32_t x1390; + fiat_p384_scalar_uint1 x1391; + uint32_t x1392; + fiat_p384_scalar_uint1 x1393; + uint32_t x1394; + fiat_p384_scalar_uint1 x1395; + uint32_t x1396; + fiat_p384_scalar_uint1 x1397; + uint32_t x1398; + fiat_p384_scalar_uint1 x1399; + uint32_t x1400; + uint32_t x1401; + uint32_t x1402; + uint32_t x1403; + uint32_t x1404; + uint32_t x1405; + uint32_t x1406; + uint32_t x1407; + uint32_t x1408; + uint32_t x1409; + uint32_t x1410; + uint32_t x1411; + uint32_t x1412; + uint32_t x1413; + uint32_t x1414; + uint32_t x1415; + uint32_t x1416; + uint32_t x1417; + uint32_t x1418; + uint32_t x1419; + uint32_t x1420; + uint32_t x1421; + uint32_t x1422; + uint32_t x1423; + uint32_t x1424; + uint32_t x1425; + uint32_t x1426; + fiat_p384_scalar_uint1 x1427; + uint32_t x1428; + fiat_p384_scalar_uint1 x1429; + uint32_t x1430; + fiat_p384_scalar_uint1 x1431; + uint32_t x1432; + fiat_p384_scalar_uint1 x1433; + uint32_t x1434; + fiat_p384_scalar_uint1 x1435; + uint32_t x1436; + fiat_p384_scalar_uint1 x1437; + uint32_t x1438; + fiat_p384_scalar_uint1 x1439; + uint32_t x1440; + fiat_p384_scalar_uint1 x1441; + uint32_t x1442; + fiat_p384_scalar_uint1 x1443; + uint32_t x1444; + fiat_p384_scalar_uint1 x1445; + uint32_t x1446; + fiat_p384_scalar_uint1 x1447; + uint32_t x1448; + uint32_t x1449; + fiat_p384_scalar_uint1 x1450; + uint32_t x1451; + fiat_p384_scalar_uint1 x1452; + uint32_t x1453; + fiat_p384_scalar_uint1 x1454; + uint32_t x1455; + fiat_p384_scalar_uint1 x1456; + uint32_t x1457; + fiat_p384_scalar_uint1 x1458; + uint32_t x1459; + fiat_p384_scalar_uint1 x1460; + uint32_t x1461; + fiat_p384_scalar_uint1 x1462; + uint32_t x1463; + fiat_p384_scalar_uint1 x1464; + uint32_t x1465; + fiat_p384_scalar_uint1 x1466; + uint32_t x1467; + fiat_p384_scalar_uint1 x1468; + uint32_t x1469; + fiat_p384_scalar_uint1 x1470; + uint32_t x1471; + fiat_p384_scalar_uint1 x1472; + uint32_t x1473; + fiat_p384_scalar_uint1 x1474; + uint32_t x1475; + uint32_t x1476; + uint32_t x1477; + uint32_t x1478; + uint32_t x1479; + uint32_t x1480; + uint32_t x1481; + uint32_t x1482; + uint32_t x1483; + uint32_t x1484; + uint32_t x1485; + uint32_t x1486; + uint32_t x1487; + uint32_t x1488; + uint32_t x1489; + uint32_t x1490; + uint32_t x1491; + uint32_t x1492; + uint32_t x1493; + uint32_t x1494; + uint32_t x1495; + uint32_t x1496; + uint32_t x1497; + uint32_t x1498; + uint32_t x1499; + uint32_t x1500; + fiat_p384_scalar_uint1 x1501; + uint32_t x1502; + fiat_p384_scalar_uint1 x1503; + uint32_t x1504; + fiat_p384_scalar_uint1 x1505; + uint32_t x1506; + fiat_p384_scalar_uint1 x1507; + uint32_t x1508; + fiat_p384_scalar_uint1 x1509; + uint32_t x1510; + fiat_p384_scalar_uint1 x1511; + uint32_t x1512; + fiat_p384_scalar_uint1 x1513; + uint32_t x1514; + fiat_p384_scalar_uint1 x1515; + uint32_t x1516; + fiat_p384_scalar_uint1 x1517; + uint32_t x1518; + fiat_p384_scalar_uint1 x1519; + uint32_t x1520; + fiat_p384_scalar_uint1 x1521; + uint32_t x1522; + uint32_t x1523; + fiat_p384_scalar_uint1 x1524; + uint32_t x1525; + fiat_p384_scalar_uint1 x1526; + uint32_t x1527; + fiat_p384_scalar_uint1 x1528; + uint32_t x1529; + fiat_p384_scalar_uint1 x1530; + uint32_t x1531; + fiat_p384_scalar_uint1 x1532; + uint32_t x1533; + fiat_p384_scalar_uint1 x1534; + uint32_t x1535; + fiat_p384_scalar_uint1 x1536; + uint32_t x1537; + fiat_p384_scalar_uint1 x1538; + uint32_t x1539; + fiat_p384_scalar_uint1 x1540; + uint32_t x1541; + fiat_p384_scalar_uint1 x1542; + uint32_t x1543; + fiat_p384_scalar_uint1 x1544; + uint32_t x1545; + fiat_p384_scalar_uint1 x1546; + uint32_t x1547; + fiat_p384_scalar_uint1 x1548; + uint32_t x1549; + uint32_t x1550; + uint32_t x1551; + uint32_t x1552; + uint32_t x1553; + uint32_t x1554; + uint32_t x1555; + uint32_t x1556; + uint32_t x1557; + uint32_t x1558; + uint32_t x1559; + uint32_t x1560; + uint32_t x1561; + uint32_t x1562; + uint32_t x1563; + uint32_t x1564; + uint32_t x1565; + uint32_t x1566; + uint32_t x1567; + uint32_t x1568; + uint32_t x1569; + uint32_t x1570; + uint32_t x1571; + uint32_t x1572; + uint32_t x1573; + uint32_t x1574; + uint32_t x1575; + fiat_p384_scalar_uint1 x1576; + uint32_t x1577; + fiat_p384_scalar_uint1 x1578; + uint32_t x1579; + fiat_p384_scalar_uint1 x1580; + uint32_t x1581; + fiat_p384_scalar_uint1 x1582; + uint32_t x1583; + fiat_p384_scalar_uint1 x1584; + uint32_t x1585; + fiat_p384_scalar_uint1 x1586; + uint32_t x1587; + fiat_p384_scalar_uint1 x1588; + uint32_t x1589; + fiat_p384_scalar_uint1 x1590; + uint32_t x1591; + fiat_p384_scalar_uint1 x1592; + uint32_t x1593; + fiat_p384_scalar_uint1 x1594; + uint32_t x1595; + fiat_p384_scalar_uint1 x1596; + uint32_t x1597; + uint32_t x1598; + fiat_p384_scalar_uint1 x1599; + uint32_t x1600; + fiat_p384_scalar_uint1 x1601; + uint32_t x1602; + fiat_p384_scalar_uint1 x1603; + uint32_t x1604; + fiat_p384_scalar_uint1 x1605; + uint32_t x1606; + fiat_p384_scalar_uint1 x1607; + uint32_t x1608; + fiat_p384_scalar_uint1 x1609; + uint32_t x1610; + fiat_p384_scalar_uint1 x1611; + uint32_t x1612; + fiat_p384_scalar_uint1 x1613; + uint32_t x1614; + fiat_p384_scalar_uint1 x1615; + uint32_t x1616; + fiat_p384_scalar_uint1 x1617; + uint32_t x1618; + fiat_p384_scalar_uint1 x1619; + uint32_t x1620; + fiat_p384_scalar_uint1 x1621; + uint32_t x1622; + fiat_p384_scalar_uint1 x1623; + uint32_t x1624; + uint32_t x1625; + uint32_t x1626; + uint32_t x1627; + uint32_t x1628; + uint32_t x1629; + uint32_t x1630; + uint32_t x1631; + uint32_t x1632; + uint32_t x1633; + uint32_t x1634; + uint32_t x1635; + uint32_t x1636; + uint32_t x1637; + uint32_t x1638; + uint32_t x1639; + uint32_t x1640; + uint32_t x1641; + uint32_t x1642; + uint32_t x1643; + uint32_t x1644; + uint32_t x1645; + uint32_t x1646; + uint32_t x1647; + uint32_t x1648; + uint32_t x1649; + fiat_p384_scalar_uint1 x1650; + uint32_t x1651; + fiat_p384_scalar_uint1 x1652; + uint32_t x1653; + fiat_p384_scalar_uint1 x1654; + uint32_t x1655; + fiat_p384_scalar_uint1 x1656; + uint32_t x1657; + fiat_p384_scalar_uint1 x1658; + uint32_t x1659; + fiat_p384_scalar_uint1 x1660; + uint32_t x1661; + fiat_p384_scalar_uint1 x1662; + uint32_t x1663; + fiat_p384_scalar_uint1 x1664; + uint32_t x1665; + fiat_p384_scalar_uint1 x1666; + uint32_t x1667; + fiat_p384_scalar_uint1 x1668; + uint32_t x1669; + fiat_p384_scalar_uint1 x1670; + uint32_t x1671; + uint32_t x1672; + fiat_p384_scalar_uint1 x1673; + uint32_t x1674; + fiat_p384_scalar_uint1 x1675; + uint32_t x1676; + fiat_p384_scalar_uint1 x1677; + uint32_t x1678; + fiat_p384_scalar_uint1 x1679; + uint32_t x1680; + fiat_p384_scalar_uint1 x1681; + uint32_t x1682; + fiat_p384_scalar_uint1 x1683; + uint32_t x1684; + fiat_p384_scalar_uint1 x1685; + uint32_t x1686; + fiat_p384_scalar_uint1 x1687; + uint32_t x1688; + fiat_p384_scalar_uint1 x1689; + uint32_t x1690; + fiat_p384_scalar_uint1 x1691; + uint32_t x1692; + fiat_p384_scalar_uint1 x1693; + uint32_t x1694; + fiat_p384_scalar_uint1 x1695; + uint32_t x1696; + fiat_p384_scalar_uint1 x1697; + uint32_t x1698; + uint32_t x1699; + uint32_t x1700; + uint32_t x1701; + uint32_t x1702; + uint32_t x1703; + uint32_t x1704; + uint32_t x1705; + uint32_t x1706; + uint32_t x1707; + uint32_t x1708; + uint32_t x1709; + uint32_t x1710; + uint32_t x1711; + uint32_t x1712; + uint32_t x1713; + uint32_t x1714; + uint32_t x1715; + uint32_t x1716; + uint32_t x1717; + uint32_t x1718; + uint32_t x1719; + uint32_t x1720; + uint32_t x1721; + uint32_t x1722; + uint32_t x1723; + uint32_t x1724; + fiat_p384_scalar_uint1 x1725; + uint32_t x1726; + fiat_p384_scalar_uint1 x1727; + uint32_t x1728; + fiat_p384_scalar_uint1 x1729; + uint32_t x1730; + fiat_p384_scalar_uint1 x1731; + uint32_t x1732; + fiat_p384_scalar_uint1 x1733; + uint32_t x1734; + fiat_p384_scalar_uint1 x1735; + uint32_t x1736; + fiat_p384_scalar_uint1 x1737; + uint32_t x1738; + fiat_p384_scalar_uint1 x1739; + uint32_t x1740; + fiat_p384_scalar_uint1 x1741; + uint32_t x1742; + fiat_p384_scalar_uint1 x1743; + uint32_t x1744; + fiat_p384_scalar_uint1 x1745; + uint32_t x1746; + uint32_t x1747; + fiat_p384_scalar_uint1 x1748; + uint32_t x1749; + fiat_p384_scalar_uint1 x1750; + uint32_t x1751; + fiat_p384_scalar_uint1 x1752; + uint32_t x1753; + fiat_p384_scalar_uint1 x1754; + uint32_t x1755; + fiat_p384_scalar_uint1 x1756; + uint32_t x1757; + fiat_p384_scalar_uint1 x1758; + uint32_t x1759; + fiat_p384_scalar_uint1 x1760; + uint32_t x1761; + fiat_p384_scalar_uint1 x1762; + uint32_t x1763; + fiat_p384_scalar_uint1 x1764; + uint32_t x1765; + fiat_p384_scalar_uint1 x1766; + uint32_t x1767; + fiat_p384_scalar_uint1 x1768; + uint32_t x1769; + fiat_p384_scalar_uint1 x1770; + uint32_t x1771; + fiat_p384_scalar_uint1 x1772; + uint32_t x1773; + uint32_t x1774; + fiat_p384_scalar_uint1 x1775; + uint32_t x1776; + fiat_p384_scalar_uint1 x1777; + uint32_t x1778; + fiat_p384_scalar_uint1 x1779; + uint32_t x1780; + fiat_p384_scalar_uint1 x1781; + uint32_t x1782; + fiat_p384_scalar_uint1 x1783; + uint32_t x1784; + fiat_p384_scalar_uint1 x1785; + uint32_t x1786; + fiat_p384_scalar_uint1 x1787; + uint32_t x1788; + fiat_p384_scalar_uint1 x1789; + uint32_t x1790; + fiat_p384_scalar_uint1 x1791; + uint32_t x1792; + fiat_p384_scalar_uint1 x1793; + uint32_t x1794; + fiat_p384_scalar_uint1 x1795; + uint32_t x1796; + fiat_p384_scalar_uint1 x1797; + uint32_t x1798; + fiat_p384_scalar_uint1 x1799; + uint32_t x1800; + uint32_t x1801; + uint32_t x1802; + uint32_t x1803; + uint32_t x1804; + uint32_t x1805; + uint32_t x1806; + uint32_t x1807; + uint32_t x1808; + uint32_t x1809; + uint32_t x1810; + uint32_t x1811; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[6]); + x7 = (arg1[7]); + x8 = (arg1[8]); + x9 = (arg1[9]); + x10 = (arg1[10]); + x11 = (arg1[11]); + x12 = (arg1[0]); + fiat_p384_scalar_mulx_u32(&x13, &x14, x12, (arg2[11])); + fiat_p384_scalar_mulx_u32(&x15, &x16, x12, (arg2[10])); + fiat_p384_scalar_mulx_u32(&x17, &x18, x12, (arg2[9])); + fiat_p384_scalar_mulx_u32(&x19, &x20, x12, (arg2[8])); + fiat_p384_scalar_mulx_u32(&x21, &x22, x12, (arg2[7])); + fiat_p384_scalar_mulx_u32(&x23, &x24, x12, (arg2[6])); + fiat_p384_scalar_mulx_u32(&x25, &x26, x12, (arg2[5])); + fiat_p384_scalar_mulx_u32(&x27, &x28, x12, (arg2[4])); + fiat_p384_scalar_mulx_u32(&x29, &x30, x12, (arg2[3])); + fiat_p384_scalar_mulx_u32(&x31, &x32, x12, (arg2[2])); + fiat_p384_scalar_mulx_u32(&x33, &x34, x12, (arg2[1])); + fiat_p384_scalar_mulx_u32(&x35, &x36, x12, (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x37, &x38, 0x0, x36, x33); + fiat_p384_scalar_addcarryx_u32(&x39, &x40, x38, x34, x31); + fiat_p384_scalar_addcarryx_u32(&x41, &x42, x40, x32, x29); + fiat_p384_scalar_addcarryx_u32(&x43, &x44, x42, x30, x27); + fiat_p384_scalar_addcarryx_u32(&x45, &x46, x44, x28, x25); + fiat_p384_scalar_addcarryx_u32(&x47, &x48, x46, x26, x23); + fiat_p384_scalar_addcarryx_u32(&x49, &x50, x48, x24, x21); + fiat_p384_scalar_addcarryx_u32(&x51, &x52, x50, x22, x19); + fiat_p384_scalar_addcarryx_u32(&x53, &x54, x52, x20, x17); + fiat_p384_scalar_addcarryx_u32(&x55, &x56, x54, x18, x15); + fiat_p384_scalar_addcarryx_u32(&x57, &x58, x56, x16, x13); + x59 = (x58 + x14); + fiat_p384_scalar_mulx_u32(&x60, &x61, x35, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x62, &x63, x60, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x64, &x65, x60, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x66, &x67, x60, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x68, &x69, x60, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x70, &x71, x60, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x72, &x73, x60, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x74, &x75, x60, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x76, &x77, x60, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x78, &x79, x60, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x80, &x81, x60, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x82, &x83, x60, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x84, &x85, x60, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x86, &x87, 0x0, x85, x82); + fiat_p384_scalar_addcarryx_u32(&x88, &x89, x87, x83, x80); + fiat_p384_scalar_addcarryx_u32(&x90, &x91, x89, x81, x78); + fiat_p384_scalar_addcarryx_u32(&x92, &x93, x91, x79, x76); + fiat_p384_scalar_addcarryx_u32(&x94, &x95, x93, x77, x74); + fiat_p384_scalar_addcarryx_u32(&x96, &x97, x95, x75, x72); + fiat_p384_scalar_addcarryx_u32(&x98, &x99, x97, x73, x70); + fiat_p384_scalar_addcarryx_u32(&x100, &x101, x99, x71, x68); + fiat_p384_scalar_addcarryx_u32(&x102, &x103, x101, x69, x66); + fiat_p384_scalar_addcarryx_u32(&x104, &x105, x103, x67, x64); + fiat_p384_scalar_addcarryx_u32(&x106, &x107, x105, x65, x62); + x108 = (x107 + x63); + fiat_p384_scalar_addcarryx_u32(&x109, &x110, 0x0, x35, x84); + fiat_p384_scalar_addcarryx_u32(&x111, &x112, x110, x37, x86); + fiat_p384_scalar_addcarryx_u32(&x113, &x114, x112, x39, x88); + fiat_p384_scalar_addcarryx_u32(&x115, &x116, x114, x41, x90); + fiat_p384_scalar_addcarryx_u32(&x117, &x118, x116, x43, x92); + fiat_p384_scalar_addcarryx_u32(&x119, &x120, x118, x45, x94); + fiat_p384_scalar_addcarryx_u32(&x121, &x122, x120, x47, x96); + fiat_p384_scalar_addcarryx_u32(&x123, &x124, x122, x49, x98); + fiat_p384_scalar_addcarryx_u32(&x125, &x126, x124, x51, x100); + fiat_p384_scalar_addcarryx_u32(&x127, &x128, x126, x53, x102); + fiat_p384_scalar_addcarryx_u32(&x129, &x130, x128, x55, x104); + fiat_p384_scalar_addcarryx_u32(&x131, &x132, x130, x57, x106); + fiat_p384_scalar_addcarryx_u32(&x133, &x134, x132, x59, x108); + fiat_p384_scalar_mulx_u32(&x135, &x136, x1, (arg2[11])); + fiat_p384_scalar_mulx_u32(&x137, &x138, x1, (arg2[10])); + fiat_p384_scalar_mulx_u32(&x139, &x140, x1, (arg2[9])); + fiat_p384_scalar_mulx_u32(&x141, &x142, x1, (arg2[8])); + fiat_p384_scalar_mulx_u32(&x143, &x144, x1, (arg2[7])); + fiat_p384_scalar_mulx_u32(&x145, &x146, x1, (arg2[6])); + fiat_p384_scalar_mulx_u32(&x147, &x148, x1, (arg2[5])); + fiat_p384_scalar_mulx_u32(&x149, &x150, x1, (arg2[4])); + fiat_p384_scalar_mulx_u32(&x151, &x152, x1, (arg2[3])); + fiat_p384_scalar_mulx_u32(&x153, &x154, x1, (arg2[2])); + fiat_p384_scalar_mulx_u32(&x155, &x156, x1, (arg2[1])); + fiat_p384_scalar_mulx_u32(&x157, &x158, x1, (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x159, &x160, 0x0, x158, x155); + fiat_p384_scalar_addcarryx_u32(&x161, &x162, x160, x156, x153); + fiat_p384_scalar_addcarryx_u32(&x163, &x164, x162, x154, x151); + fiat_p384_scalar_addcarryx_u32(&x165, &x166, x164, x152, x149); + fiat_p384_scalar_addcarryx_u32(&x167, &x168, x166, x150, x147); + fiat_p384_scalar_addcarryx_u32(&x169, &x170, x168, x148, x145); + fiat_p384_scalar_addcarryx_u32(&x171, &x172, x170, x146, x143); + fiat_p384_scalar_addcarryx_u32(&x173, &x174, x172, x144, x141); + fiat_p384_scalar_addcarryx_u32(&x175, &x176, x174, x142, x139); + fiat_p384_scalar_addcarryx_u32(&x177, &x178, x176, x140, x137); + fiat_p384_scalar_addcarryx_u32(&x179, &x180, x178, x138, x135); + x181 = (x180 + x136); + fiat_p384_scalar_addcarryx_u32(&x182, &x183, 0x0, x111, x157); + fiat_p384_scalar_addcarryx_u32(&x184, &x185, x183, x113, x159); + fiat_p384_scalar_addcarryx_u32(&x186, &x187, x185, x115, x161); + fiat_p384_scalar_addcarryx_u32(&x188, &x189, x187, x117, x163); + fiat_p384_scalar_addcarryx_u32(&x190, &x191, x189, x119, x165); + fiat_p384_scalar_addcarryx_u32(&x192, &x193, x191, x121, x167); + fiat_p384_scalar_addcarryx_u32(&x194, &x195, x193, x123, x169); + fiat_p384_scalar_addcarryx_u32(&x196, &x197, x195, x125, x171); + fiat_p384_scalar_addcarryx_u32(&x198, &x199, x197, x127, x173); + fiat_p384_scalar_addcarryx_u32(&x200, &x201, x199, x129, x175); + fiat_p384_scalar_addcarryx_u32(&x202, &x203, x201, x131, x177); + fiat_p384_scalar_addcarryx_u32(&x204, &x205, x203, x133, x179); + fiat_p384_scalar_addcarryx_u32(&x206, &x207, x205, x134, x181); + fiat_p384_scalar_mulx_u32(&x208, &x209, x182, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x210, &x211, x208, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x212, &x213, x208, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x214, &x215, x208, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x216, &x217, x208, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x218, &x219, x208, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x220, &x221, x208, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x222, &x223, x208, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x224, &x225, x208, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x226, &x227, x208, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x228, &x229, x208, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x230, &x231, x208, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x232, &x233, x208, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x234, &x235, 0x0, x233, x230); + fiat_p384_scalar_addcarryx_u32(&x236, &x237, x235, x231, x228); + fiat_p384_scalar_addcarryx_u32(&x238, &x239, x237, x229, x226); + fiat_p384_scalar_addcarryx_u32(&x240, &x241, x239, x227, x224); + fiat_p384_scalar_addcarryx_u32(&x242, &x243, x241, x225, x222); + fiat_p384_scalar_addcarryx_u32(&x244, &x245, x243, x223, x220); + fiat_p384_scalar_addcarryx_u32(&x246, &x247, x245, x221, x218); + fiat_p384_scalar_addcarryx_u32(&x248, &x249, x247, x219, x216); + fiat_p384_scalar_addcarryx_u32(&x250, &x251, x249, x217, x214); + fiat_p384_scalar_addcarryx_u32(&x252, &x253, x251, x215, x212); + fiat_p384_scalar_addcarryx_u32(&x254, &x255, x253, x213, x210); + x256 = (x255 + x211); + fiat_p384_scalar_addcarryx_u32(&x257, &x258, 0x0, x182, x232); + fiat_p384_scalar_addcarryx_u32(&x259, &x260, x258, x184, x234); + fiat_p384_scalar_addcarryx_u32(&x261, &x262, x260, x186, x236); + fiat_p384_scalar_addcarryx_u32(&x263, &x264, x262, x188, x238); + fiat_p384_scalar_addcarryx_u32(&x265, &x266, x264, x190, x240); + fiat_p384_scalar_addcarryx_u32(&x267, &x268, x266, x192, x242); + fiat_p384_scalar_addcarryx_u32(&x269, &x270, x268, x194, x244); + fiat_p384_scalar_addcarryx_u32(&x271, &x272, x270, x196, x246); + fiat_p384_scalar_addcarryx_u32(&x273, &x274, x272, x198, x248); + fiat_p384_scalar_addcarryx_u32(&x275, &x276, x274, x200, x250); + fiat_p384_scalar_addcarryx_u32(&x277, &x278, x276, x202, x252); + fiat_p384_scalar_addcarryx_u32(&x279, &x280, x278, x204, x254); + fiat_p384_scalar_addcarryx_u32(&x281, &x282, x280, x206, x256); + x283 = ((uint32_t)x282 + x207); + fiat_p384_scalar_mulx_u32(&x284, &x285, x2, (arg2[11])); + fiat_p384_scalar_mulx_u32(&x286, &x287, x2, (arg2[10])); + fiat_p384_scalar_mulx_u32(&x288, &x289, x2, (arg2[9])); + fiat_p384_scalar_mulx_u32(&x290, &x291, x2, (arg2[8])); + fiat_p384_scalar_mulx_u32(&x292, &x293, x2, (arg2[7])); + fiat_p384_scalar_mulx_u32(&x294, &x295, x2, (arg2[6])); + fiat_p384_scalar_mulx_u32(&x296, &x297, x2, (arg2[5])); + fiat_p384_scalar_mulx_u32(&x298, &x299, x2, (arg2[4])); + fiat_p384_scalar_mulx_u32(&x300, &x301, x2, (arg2[3])); + fiat_p384_scalar_mulx_u32(&x302, &x303, x2, (arg2[2])); + fiat_p384_scalar_mulx_u32(&x304, &x305, x2, (arg2[1])); + fiat_p384_scalar_mulx_u32(&x306, &x307, x2, (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x308, &x309, 0x0, x307, x304); + fiat_p384_scalar_addcarryx_u32(&x310, &x311, x309, x305, x302); + fiat_p384_scalar_addcarryx_u32(&x312, &x313, x311, x303, x300); + fiat_p384_scalar_addcarryx_u32(&x314, &x315, x313, x301, x298); + fiat_p384_scalar_addcarryx_u32(&x316, &x317, x315, x299, x296); + fiat_p384_scalar_addcarryx_u32(&x318, &x319, x317, x297, x294); + fiat_p384_scalar_addcarryx_u32(&x320, &x321, x319, x295, x292); + fiat_p384_scalar_addcarryx_u32(&x322, &x323, x321, x293, x290); + fiat_p384_scalar_addcarryx_u32(&x324, &x325, x323, x291, x288); + fiat_p384_scalar_addcarryx_u32(&x326, &x327, x325, x289, x286); + fiat_p384_scalar_addcarryx_u32(&x328, &x329, x327, x287, x284); + x330 = (x329 + x285); + fiat_p384_scalar_addcarryx_u32(&x331, &x332, 0x0, x259, x306); + fiat_p384_scalar_addcarryx_u32(&x333, &x334, x332, x261, x308); + fiat_p384_scalar_addcarryx_u32(&x335, &x336, x334, x263, x310); + fiat_p384_scalar_addcarryx_u32(&x337, &x338, x336, x265, x312); + fiat_p384_scalar_addcarryx_u32(&x339, &x340, x338, x267, x314); + fiat_p384_scalar_addcarryx_u32(&x341, &x342, x340, x269, x316); + fiat_p384_scalar_addcarryx_u32(&x343, &x344, x342, x271, x318); + fiat_p384_scalar_addcarryx_u32(&x345, &x346, x344, x273, x320); + fiat_p384_scalar_addcarryx_u32(&x347, &x348, x346, x275, x322); + fiat_p384_scalar_addcarryx_u32(&x349, &x350, x348, x277, x324); + fiat_p384_scalar_addcarryx_u32(&x351, &x352, x350, x279, x326); + fiat_p384_scalar_addcarryx_u32(&x353, &x354, x352, x281, x328); + fiat_p384_scalar_addcarryx_u32(&x355, &x356, x354, x283, x330); + fiat_p384_scalar_mulx_u32(&x357, &x358, x331, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x359, &x360, x357, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x361, &x362, x357, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x363, &x364, x357, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x365, &x366, x357, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x367, &x368, x357, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x369, &x370, x357, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x371, &x372, x357, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x373, &x374, x357, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x375, &x376, x357, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x377, &x378, x357, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x379, &x380, x357, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x381, &x382, x357, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x383, &x384, 0x0, x382, x379); + fiat_p384_scalar_addcarryx_u32(&x385, &x386, x384, x380, x377); + fiat_p384_scalar_addcarryx_u32(&x387, &x388, x386, x378, x375); + fiat_p384_scalar_addcarryx_u32(&x389, &x390, x388, x376, x373); + fiat_p384_scalar_addcarryx_u32(&x391, &x392, x390, x374, x371); + fiat_p384_scalar_addcarryx_u32(&x393, &x394, x392, x372, x369); + fiat_p384_scalar_addcarryx_u32(&x395, &x396, x394, x370, x367); + fiat_p384_scalar_addcarryx_u32(&x397, &x398, x396, x368, x365); + fiat_p384_scalar_addcarryx_u32(&x399, &x400, x398, x366, x363); + fiat_p384_scalar_addcarryx_u32(&x401, &x402, x400, x364, x361); + fiat_p384_scalar_addcarryx_u32(&x403, &x404, x402, x362, x359); + x405 = (x404 + x360); + fiat_p384_scalar_addcarryx_u32(&x406, &x407, 0x0, x331, x381); + fiat_p384_scalar_addcarryx_u32(&x408, &x409, x407, x333, x383); + fiat_p384_scalar_addcarryx_u32(&x410, &x411, x409, x335, x385); + fiat_p384_scalar_addcarryx_u32(&x412, &x413, x411, x337, x387); + fiat_p384_scalar_addcarryx_u32(&x414, &x415, x413, x339, x389); + fiat_p384_scalar_addcarryx_u32(&x416, &x417, x415, x341, x391); + fiat_p384_scalar_addcarryx_u32(&x418, &x419, x417, x343, x393); + fiat_p384_scalar_addcarryx_u32(&x420, &x421, x419, x345, x395); + fiat_p384_scalar_addcarryx_u32(&x422, &x423, x421, x347, x397); + fiat_p384_scalar_addcarryx_u32(&x424, &x425, x423, x349, x399); + fiat_p384_scalar_addcarryx_u32(&x426, &x427, x425, x351, x401); + fiat_p384_scalar_addcarryx_u32(&x428, &x429, x427, x353, x403); + fiat_p384_scalar_addcarryx_u32(&x430, &x431, x429, x355, x405); + x432 = ((uint32_t)x431 + x356); + fiat_p384_scalar_mulx_u32(&x433, &x434, x3, (arg2[11])); + fiat_p384_scalar_mulx_u32(&x435, &x436, x3, (arg2[10])); + fiat_p384_scalar_mulx_u32(&x437, &x438, x3, (arg2[9])); + fiat_p384_scalar_mulx_u32(&x439, &x440, x3, (arg2[8])); + fiat_p384_scalar_mulx_u32(&x441, &x442, x3, (arg2[7])); + fiat_p384_scalar_mulx_u32(&x443, &x444, x3, (arg2[6])); + fiat_p384_scalar_mulx_u32(&x445, &x446, x3, (arg2[5])); + fiat_p384_scalar_mulx_u32(&x447, &x448, x3, (arg2[4])); + fiat_p384_scalar_mulx_u32(&x449, &x450, x3, (arg2[3])); + fiat_p384_scalar_mulx_u32(&x451, &x452, x3, (arg2[2])); + fiat_p384_scalar_mulx_u32(&x453, &x454, x3, (arg2[1])); + fiat_p384_scalar_mulx_u32(&x455, &x456, x3, (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x457, &x458, 0x0, x456, x453); + fiat_p384_scalar_addcarryx_u32(&x459, &x460, x458, x454, x451); + fiat_p384_scalar_addcarryx_u32(&x461, &x462, x460, x452, x449); + fiat_p384_scalar_addcarryx_u32(&x463, &x464, x462, x450, x447); + fiat_p384_scalar_addcarryx_u32(&x465, &x466, x464, x448, x445); + fiat_p384_scalar_addcarryx_u32(&x467, &x468, x466, x446, x443); + fiat_p384_scalar_addcarryx_u32(&x469, &x470, x468, x444, x441); + fiat_p384_scalar_addcarryx_u32(&x471, &x472, x470, x442, x439); + fiat_p384_scalar_addcarryx_u32(&x473, &x474, x472, x440, x437); + fiat_p384_scalar_addcarryx_u32(&x475, &x476, x474, x438, x435); + fiat_p384_scalar_addcarryx_u32(&x477, &x478, x476, x436, x433); + x479 = (x478 + x434); + fiat_p384_scalar_addcarryx_u32(&x480, &x481, 0x0, x408, x455); + fiat_p384_scalar_addcarryx_u32(&x482, &x483, x481, x410, x457); + fiat_p384_scalar_addcarryx_u32(&x484, &x485, x483, x412, x459); + fiat_p384_scalar_addcarryx_u32(&x486, &x487, x485, x414, x461); + fiat_p384_scalar_addcarryx_u32(&x488, &x489, x487, x416, x463); + fiat_p384_scalar_addcarryx_u32(&x490, &x491, x489, x418, x465); + fiat_p384_scalar_addcarryx_u32(&x492, &x493, x491, x420, x467); + fiat_p384_scalar_addcarryx_u32(&x494, &x495, x493, x422, x469); + fiat_p384_scalar_addcarryx_u32(&x496, &x497, x495, x424, x471); + fiat_p384_scalar_addcarryx_u32(&x498, &x499, x497, x426, x473); + fiat_p384_scalar_addcarryx_u32(&x500, &x501, x499, x428, x475); + fiat_p384_scalar_addcarryx_u32(&x502, &x503, x501, x430, x477); + fiat_p384_scalar_addcarryx_u32(&x504, &x505, x503, x432, x479); + fiat_p384_scalar_mulx_u32(&x506, &x507, x480, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x508, &x509, x506, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x510, &x511, x506, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x512, &x513, x506, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x514, &x515, x506, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x516, &x517, x506, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x518, &x519, x506, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x520, &x521, x506, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x522, &x523, x506, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x524, &x525, x506, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x526, &x527, x506, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x528, &x529, x506, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x530, &x531, x506, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x532, &x533, 0x0, x531, x528); + fiat_p384_scalar_addcarryx_u32(&x534, &x535, x533, x529, x526); + fiat_p384_scalar_addcarryx_u32(&x536, &x537, x535, x527, x524); + fiat_p384_scalar_addcarryx_u32(&x538, &x539, x537, x525, x522); + fiat_p384_scalar_addcarryx_u32(&x540, &x541, x539, x523, x520); + fiat_p384_scalar_addcarryx_u32(&x542, &x543, x541, x521, x518); + fiat_p384_scalar_addcarryx_u32(&x544, &x545, x543, x519, x516); + fiat_p384_scalar_addcarryx_u32(&x546, &x547, x545, x517, x514); + fiat_p384_scalar_addcarryx_u32(&x548, &x549, x547, x515, x512); + fiat_p384_scalar_addcarryx_u32(&x550, &x551, x549, x513, x510); + fiat_p384_scalar_addcarryx_u32(&x552, &x553, x551, x511, x508); + x554 = (x553 + x509); + fiat_p384_scalar_addcarryx_u32(&x555, &x556, 0x0, x480, x530); + fiat_p384_scalar_addcarryx_u32(&x557, &x558, x556, x482, x532); + fiat_p384_scalar_addcarryx_u32(&x559, &x560, x558, x484, x534); + fiat_p384_scalar_addcarryx_u32(&x561, &x562, x560, x486, x536); + fiat_p384_scalar_addcarryx_u32(&x563, &x564, x562, x488, x538); + fiat_p384_scalar_addcarryx_u32(&x565, &x566, x564, x490, x540); + fiat_p384_scalar_addcarryx_u32(&x567, &x568, x566, x492, x542); + fiat_p384_scalar_addcarryx_u32(&x569, &x570, x568, x494, x544); + fiat_p384_scalar_addcarryx_u32(&x571, &x572, x570, x496, x546); + fiat_p384_scalar_addcarryx_u32(&x573, &x574, x572, x498, x548); + fiat_p384_scalar_addcarryx_u32(&x575, &x576, x574, x500, x550); + fiat_p384_scalar_addcarryx_u32(&x577, &x578, x576, x502, x552); + fiat_p384_scalar_addcarryx_u32(&x579, &x580, x578, x504, x554); + x581 = ((uint32_t)x580 + x505); + fiat_p384_scalar_mulx_u32(&x582, &x583, x4, (arg2[11])); + fiat_p384_scalar_mulx_u32(&x584, &x585, x4, (arg2[10])); + fiat_p384_scalar_mulx_u32(&x586, &x587, x4, (arg2[9])); + fiat_p384_scalar_mulx_u32(&x588, &x589, x4, (arg2[8])); + fiat_p384_scalar_mulx_u32(&x590, &x591, x4, (arg2[7])); + fiat_p384_scalar_mulx_u32(&x592, &x593, x4, (arg2[6])); + fiat_p384_scalar_mulx_u32(&x594, &x595, x4, (arg2[5])); + fiat_p384_scalar_mulx_u32(&x596, &x597, x4, (arg2[4])); + fiat_p384_scalar_mulx_u32(&x598, &x599, x4, (arg2[3])); + fiat_p384_scalar_mulx_u32(&x600, &x601, x4, (arg2[2])); + fiat_p384_scalar_mulx_u32(&x602, &x603, x4, (arg2[1])); + fiat_p384_scalar_mulx_u32(&x604, &x605, x4, (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x606, &x607, 0x0, x605, x602); + fiat_p384_scalar_addcarryx_u32(&x608, &x609, x607, x603, x600); + fiat_p384_scalar_addcarryx_u32(&x610, &x611, x609, x601, x598); + fiat_p384_scalar_addcarryx_u32(&x612, &x613, x611, x599, x596); + fiat_p384_scalar_addcarryx_u32(&x614, &x615, x613, x597, x594); + fiat_p384_scalar_addcarryx_u32(&x616, &x617, x615, x595, x592); + fiat_p384_scalar_addcarryx_u32(&x618, &x619, x617, x593, x590); + fiat_p384_scalar_addcarryx_u32(&x620, &x621, x619, x591, x588); + fiat_p384_scalar_addcarryx_u32(&x622, &x623, x621, x589, x586); + fiat_p384_scalar_addcarryx_u32(&x624, &x625, x623, x587, x584); + fiat_p384_scalar_addcarryx_u32(&x626, &x627, x625, x585, x582); + x628 = (x627 + x583); + fiat_p384_scalar_addcarryx_u32(&x629, &x630, 0x0, x557, x604); + fiat_p384_scalar_addcarryx_u32(&x631, &x632, x630, x559, x606); + fiat_p384_scalar_addcarryx_u32(&x633, &x634, x632, x561, x608); + fiat_p384_scalar_addcarryx_u32(&x635, &x636, x634, x563, x610); + fiat_p384_scalar_addcarryx_u32(&x637, &x638, x636, x565, x612); + fiat_p384_scalar_addcarryx_u32(&x639, &x640, x638, x567, x614); + fiat_p384_scalar_addcarryx_u32(&x641, &x642, x640, x569, x616); + fiat_p384_scalar_addcarryx_u32(&x643, &x644, x642, x571, x618); + fiat_p384_scalar_addcarryx_u32(&x645, &x646, x644, x573, x620); + fiat_p384_scalar_addcarryx_u32(&x647, &x648, x646, x575, x622); + fiat_p384_scalar_addcarryx_u32(&x649, &x650, x648, x577, x624); + fiat_p384_scalar_addcarryx_u32(&x651, &x652, x650, x579, x626); + fiat_p384_scalar_addcarryx_u32(&x653, &x654, x652, x581, x628); + fiat_p384_scalar_mulx_u32(&x655, &x656, x629, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x657, &x658, x655, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x659, &x660, x655, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x661, &x662, x655, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x663, &x664, x655, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x665, &x666, x655, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x667, &x668, x655, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x669, &x670, x655, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x671, &x672, x655, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x673, &x674, x655, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x675, &x676, x655, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x677, &x678, x655, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x679, &x680, x655, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x681, &x682, 0x0, x680, x677); + fiat_p384_scalar_addcarryx_u32(&x683, &x684, x682, x678, x675); + fiat_p384_scalar_addcarryx_u32(&x685, &x686, x684, x676, x673); + fiat_p384_scalar_addcarryx_u32(&x687, &x688, x686, x674, x671); + fiat_p384_scalar_addcarryx_u32(&x689, &x690, x688, x672, x669); + fiat_p384_scalar_addcarryx_u32(&x691, &x692, x690, x670, x667); + fiat_p384_scalar_addcarryx_u32(&x693, &x694, x692, x668, x665); + fiat_p384_scalar_addcarryx_u32(&x695, &x696, x694, x666, x663); + fiat_p384_scalar_addcarryx_u32(&x697, &x698, x696, x664, x661); + fiat_p384_scalar_addcarryx_u32(&x699, &x700, x698, x662, x659); + fiat_p384_scalar_addcarryx_u32(&x701, &x702, x700, x660, x657); + x703 = (x702 + x658); + fiat_p384_scalar_addcarryx_u32(&x704, &x705, 0x0, x629, x679); + fiat_p384_scalar_addcarryx_u32(&x706, &x707, x705, x631, x681); + fiat_p384_scalar_addcarryx_u32(&x708, &x709, x707, x633, x683); + fiat_p384_scalar_addcarryx_u32(&x710, &x711, x709, x635, x685); + fiat_p384_scalar_addcarryx_u32(&x712, &x713, x711, x637, x687); + fiat_p384_scalar_addcarryx_u32(&x714, &x715, x713, x639, x689); + fiat_p384_scalar_addcarryx_u32(&x716, &x717, x715, x641, x691); + fiat_p384_scalar_addcarryx_u32(&x718, &x719, x717, x643, x693); + fiat_p384_scalar_addcarryx_u32(&x720, &x721, x719, x645, x695); + fiat_p384_scalar_addcarryx_u32(&x722, &x723, x721, x647, x697); + fiat_p384_scalar_addcarryx_u32(&x724, &x725, x723, x649, x699); + fiat_p384_scalar_addcarryx_u32(&x726, &x727, x725, x651, x701); + fiat_p384_scalar_addcarryx_u32(&x728, &x729, x727, x653, x703); + x730 = ((uint32_t)x729 + x654); + fiat_p384_scalar_mulx_u32(&x731, &x732, x5, (arg2[11])); + fiat_p384_scalar_mulx_u32(&x733, &x734, x5, (arg2[10])); + fiat_p384_scalar_mulx_u32(&x735, &x736, x5, (arg2[9])); + fiat_p384_scalar_mulx_u32(&x737, &x738, x5, (arg2[8])); + fiat_p384_scalar_mulx_u32(&x739, &x740, x5, (arg2[7])); + fiat_p384_scalar_mulx_u32(&x741, &x742, x5, (arg2[6])); + fiat_p384_scalar_mulx_u32(&x743, &x744, x5, (arg2[5])); + fiat_p384_scalar_mulx_u32(&x745, &x746, x5, (arg2[4])); + fiat_p384_scalar_mulx_u32(&x747, &x748, x5, (arg2[3])); + fiat_p384_scalar_mulx_u32(&x749, &x750, x5, (arg2[2])); + fiat_p384_scalar_mulx_u32(&x751, &x752, x5, (arg2[1])); + fiat_p384_scalar_mulx_u32(&x753, &x754, x5, (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x755, &x756, 0x0, x754, x751); + fiat_p384_scalar_addcarryx_u32(&x757, &x758, x756, x752, x749); + fiat_p384_scalar_addcarryx_u32(&x759, &x760, x758, x750, x747); + fiat_p384_scalar_addcarryx_u32(&x761, &x762, x760, x748, x745); + fiat_p384_scalar_addcarryx_u32(&x763, &x764, x762, x746, x743); + fiat_p384_scalar_addcarryx_u32(&x765, &x766, x764, x744, x741); + fiat_p384_scalar_addcarryx_u32(&x767, &x768, x766, x742, x739); + fiat_p384_scalar_addcarryx_u32(&x769, &x770, x768, x740, x737); + fiat_p384_scalar_addcarryx_u32(&x771, &x772, x770, x738, x735); + fiat_p384_scalar_addcarryx_u32(&x773, &x774, x772, x736, x733); + fiat_p384_scalar_addcarryx_u32(&x775, &x776, x774, x734, x731); + x777 = (x776 + x732); + fiat_p384_scalar_addcarryx_u32(&x778, &x779, 0x0, x706, x753); + fiat_p384_scalar_addcarryx_u32(&x780, &x781, x779, x708, x755); + fiat_p384_scalar_addcarryx_u32(&x782, &x783, x781, x710, x757); + fiat_p384_scalar_addcarryx_u32(&x784, &x785, x783, x712, x759); + fiat_p384_scalar_addcarryx_u32(&x786, &x787, x785, x714, x761); + fiat_p384_scalar_addcarryx_u32(&x788, &x789, x787, x716, x763); + fiat_p384_scalar_addcarryx_u32(&x790, &x791, x789, x718, x765); + fiat_p384_scalar_addcarryx_u32(&x792, &x793, x791, x720, x767); + fiat_p384_scalar_addcarryx_u32(&x794, &x795, x793, x722, x769); + fiat_p384_scalar_addcarryx_u32(&x796, &x797, x795, x724, x771); + fiat_p384_scalar_addcarryx_u32(&x798, &x799, x797, x726, x773); + fiat_p384_scalar_addcarryx_u32(&x800, &x801, x799, x728, x775); + fiat_p384_scalar_addcarryx_u32(&x802, &x803, x801, x730, x777); + fiat_p384_scalar_mulx_u32(&x804, &x805, x778, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x806, &x807, x804, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x808, &x809, x804, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x810, &x811, x804, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x812, &x813, x804, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x814, &x815, x804, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x816, &x817, x804, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x818, &x819, x804, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x820, &x821, x804, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x822, &x823, x804, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x824, &x825, x804, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x826, &x827, x804, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x828, &x829, x804, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x830, &x831, 0x0, x829, x826); + fiat_p384_scalar_addcarryx_u32(&x832, &x833, x831, x827, x824); + fiat_p384_scalar_addcarryx_u32(&x834, &x835, x833, x825, x822); + fiat_p384_scalar_addcarryx_u32(&x836, &x837, x835, x823, x820); + fiat_p384_scalar_addcarryx_u32(&x838, &x839, x837, x821, x818); + fiat_p384_scalar_addcarryx_u32(&x840, &x841, x839, x819, x816); + fiat_p384_scalar_addcarryx_u32(&x842, &x843, x841, x817, x814); + fiat_p384_scalar_addcarryx_u32(&x844, &x845, x843, x815, x812); + fiat_p384_scalar_addcarryx_u32(&x846, &x847, x845, x813, x810); + fiat_p384_scalar_addcarryx_u32(&x848, &x849, x847, x811, x808); + fiat_p384_scalar_addcarryx_u32(&x850, &x851, x849, x809, x806); + x852 = (x851 + x807); + fiat_p384_scalar_addcarryx_u32(&x853, &x854, 0x0, x778, x828); + fiat_p384_scalar_addcarryx_u32(&x855, &x856, x854, x780, x830); + fiat_p384_scalar_addcarryx_u32(&x857, &x858, x856, x782, x832); + fiat_p384_scalar_addcarryx_u32(&x859, &x860, x858, x784, x834); + fiat_p384_scalar_addcarryx_u32(&x861, &x862, x860, x786, x836); + fiat_p384_scalar_addcarryx_u32(&x863, &x864, x862, x788, x838); + fiat_p384_scalar_addcarryx_u32(&x865, &x866, x864, x790, x840); + fiat_p384_scalar_addcarryx_u32(&x867, &x868, x866, x792, x842); + fiat_p384_scalar_addcarryx_u32(&x869, &x870, x868, x794, x844); + fiat_p384_scalar_addcarryx_u32(&x871, &x872, x870, x796, x846); + fiat_p384_scalar_addcarryx_u32(&x873, &x874, x872, x798, x848); + fiat_p384_scalar_addcarryx_u32(&x875, &x876, x874, x800, x850); + fiat_p384_scalar_addcarryx_u32(&x877, &x878, x876, x802, x852); + x879 = ((uint32_t)x878 + x803); + fiat_p384_scalar_mulx_u32(&x880, &x881, x6, (arg2[11])); + fiat_p384_scalar_mulx_u32(&x882, &x883, x6, (arg2[10])); + fiat_p384_scalar_mulx_u32(&x884, &x885, x6, (arg2[9])); + fiat_p384_scalar_mulx_u32(&x886, &x887, x6, (arg2[8])); + fiat_p384_scalar_mulx_u32(&x888, &x889, x6, (arg2[7])); + fiat_p384_scalar_mulx_u32(&x890, &x891, x6, (arg2[6])); + fiat_p384_scalar_mulx_u32(&x892, &x893, x6, (arg2[5])); + fiat_p384_scalar_mulx_u32(&x894, &x895, x6, (arg2[4])); + fiat_p384_scalar_mulx_u32(&x896, &x897, x6, (arg2[3])); + fiat_p384_scalar_mulx_u32(&x898, &x899, x6, (arg2[2])); + fiat_p384_scalar_mulx_u32(&x900, &x901, x6, (arg2[1])); + fiat_p384_scalar_mulx_u32(&x902, &x903, x6, (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x904, &x905, 0x0, x903, x900); + fiat_p384_scalar_addcarryx_u32(&x906, &x907, x905, x901, x898); + fiat_p384_scalar_addcarryx_u32(&x908, &x909, x907, x899, x896); + fiat_p384_scalar_addcarryx_u32(&x910, &x911, x909, x897, x894); + fiat_p384_scalar_addcarryx_u32(&x912, &x913, x911, x895, x892); + fiat_p384_scalar_addcarryx_u32(&x914, &x915, x913, x893, x890); + fiat_p384_scalar_addcarryx_u32(&x916, &x917, x915, x891, x888); + fiat_p384_scalar_addcarryx_u32(&x918, &x919, x917, x889, x886); + fiat_p384_scalar_addcarryx_u32(&x920, &x921, x919, x887, x884); + fiat_p384_scalar_addcarryx_u32(&x922, &x923, x921, x885, x882); + fiat_p384_scalar_addcarryx_u32(&x924, &x925, x923, x883, x880); + x926 = (x925 + x881); + fiat_p384_scalar_addcarryx_u32(&x927, &x928, 0x0, x855, x902); + fiat_p384_scalar_addcarryx_u32(&x929, &x930, x928, x857, x904); + fiat_p384_scalar_addcarryx_u32(&x931, &x932, x930, x859, x906); + fiat_p384_scalar_addcarryx_u32(&x933, &x934, x932, x861, x908); + fiat_p384_scalar_addcarryx_u32(&x935, &x936, x934, x863, x910); + fiat_p384_scalar_addcarryx_u32(&x937, &x938, x936, x865, x912); + fiat_p384_scalar_addcarryx_u32(&x939, &x940, x938, x867, x914); + fiat_p384_scalar_addcarryx_u32(&x941, &x942, x940, x869, x916); + fiat_p384_scalar_addcarryx_u32(&x943, &x944, x942, x871, x918); + fiat_p384_scalar_addcarryx_u32(&x945, &x946, x944, x873, x920); + fiat_p384_scalar_addcarryx_u32(&x947, &x948, x946, x875, x922); + fiat_p384_scalar_addcarryx_u32(&x949, &x950, x948, x877, x924); + fiat_p384_scalar_addcarryx_u32(&x951, &x952, x950, x879, x926); + fiat_p384_scalar_mulx_u32(&x953, &x954, x927, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x955, &x956, x953, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x957, &x958, x953, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x959, &x960, x953, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x961, &x962, x953, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x963, &x964, x953, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x965, &x966, x953, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x967, &x968, x953, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x969, &x970, x953, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x971, &x972, x953, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x973, &x974, x953, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x975, &x976, x953, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x977, &x978, x953, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x979, &x980, 0x0, x978, x975); + fiat_p384_scalar_addcarryx_u32(&x981, &x982, x980, x976, x973); + fiat_p384_scalar_addcarryx_u32(&x983, &x984, x982, x974, x971); + fiat_p384_scalar_addcarryx_u32(&x985, &x986, x984, x972, x969); + fiat_p384_scalar_addcarryx_u32(&x987, &x988, x986, x970, x967); + fiat_p384_scalar_addcarryx_u32(&x989, &x990, x988, x968, x965); + fiat_p384_scalar_addcarryx_u32(&x991, &x992, x990, x966, x963); + fiat_p384_scalar_addcarryx_u32(&x993, &x994, x992, x964, x961); + fiat_p384_scalar_addcarryx_u32(&x995, &x996, x994, x962, x959); + fiat_p384_scalar_addcarryx_u32(&x997, &x998, x996, x960, x957); + fiat_p384_scalar_addcarryx_u32(&x999, &x1000, x998, x958, x955); + x1001 = (x1000 + x956); + fiat_p384_scalar_addcarryx_u32(&x1002, &x1003, 0x0, x927, x977); + fiat_p384_scalar_addcarryx_u32(&x1004, &x1005, x1003, x929, x979); + fiat_p384_scalar_addcarryx_u32(&x1006, &x1007, x1005, x931, x981); + fiat_p384_scalar_addcarryx_u32(&x1008, &x1009, x1007, x933, x983); + fiat_p384_scalar_addcarryx_u32(&x1010, &x1011, x1009, x935, x985); + fiat_p384_scalar_addcarryx_u32(&x1012, &x1013, x1011, x937, x987); + fiat_p384_scalar_addcarryx_u32(&x1014, &x1015, x1013, x939, x989); + fiat_p384_scalar_addcarryx_u32(&x1016, &x1017, x1015, x941, x991); + fiat_p384_scalar_addcarryx_u32(&x1018, &x1019, x1017, x943, x993); + fiat_p384_scalar_addcarryx_u32(&x1020, &x1021, x1019, x945, x995); + fiat_p384_scalar_addcarryx_u32(&x1022, &x1023, x1021, x947, x997); + fiat_p384_scalar_addcarryx_u32(&x1024, &x1025, x1023, x949, x999); + fiat_p384_scalar_addcarryx_u32(&x1026, &x1027, x1025, x951, x1001); + x1028 = ((uint32_t)x1027 + x952); + fiat_p384_scalar_mulx_u32(&x1029, &x1030, x7, (arg2[11])); + fiat_p384_scalar_mulx_u32(&x1031, &x1032, x7, (arg2[10])); + fiat_p384_scalar_mulx_u32(&x1033, &x1034, x7, (arg2[9])); + fiat_p384_scalar_mulx_u32(&x1035, &x1036, x7, (arg2[8])); + fiat_p384_scalar_mulx_u32(&x1037, &x1038, x7, (arg2[7])); + fiat_p384_scalar_mulx_u32(&x1039, &x1040, x7, (arg2[6])); + fiat_p384_scalar_mulx_u32(&x1041, &x1042, x7, (arg2[5])); + fiat_p384_scalar_mulx_u32(&x1043, &x1044, x7, (arg2[4])); + fiat_p384_scalar_mulx_u32(&x1045, &x1046, x7, (arg2[3])); + fiat_p384_scalar_mulx_u32(&x1047, &x1048, x7, (arg2[2])); + fiat_p384_scalar_mulx_u32(&x1049, &x1050, x7, (arg2[1])); + fiat_p384_scalar_mulx_u32(&x1051, &x1052, x7, (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x1053, &x1054, 0x0, x1052, x1049); + fiat_p384_scalar_addcarryx_u32(&x1055, &x1056, x1054, x1050, x1047); + fiat_p384_scalar_addcarryx_u32(&x1057, &x1058, x1056, x1048, x1045); + fiat_p384_scalar_addcarryx_u32(&x1059, &x1060, x1058, x1046, x1043); + fiat_p384_scalar_addcarryx_u32(&x1061, &x1062, x1060, x1044, x1041); + fiat_p384_scalar_addcarryx_u32(&x1063, &x1064, x1062, x1042, x1039); + fiat_p384_scalar_addcarryx_u32(&x1065, &x1066, x1064, x1040, x1037); + fiat_p384_scalar_addcarryx_u32(&x1067, &x1068, x1066, x1038, x1035); + fiat_p384_scalar_addcarryx_u32(&x1069, &x1070, x1068, x1036, x1033); + fiat_p384_scalar_addcarryx_u32(&x1071, &x1072, x1070, x1034, x1031); + fiat_p384_scalar_addcarryx_u32(&x1073, &x1074, x1072, x1032, x1029); + x1075 = (x1074 + x1030); + fiat_p384_scalar_addcarryx_u32(&x1076, &x1077, 0x0, x1004, x1051); + fiat_p384_scalar_addcarryx_u32(&x1078, &x1079, x1077, x1006, x1053); + fiat_p384_scalar_addcarryx_u32(&x1080, &x1081, x1079, x1008, x1055); + fiat_p384_scalar_addcarryx_u32(&x1082, &x1083, x1081, x1010, x1057); + fiat_p384_scalar_addcarryx_u32(&x1084, &x1085, x1083, x1012, x1059); + fiat_p384_scalar_addcarryx_u32(&x1086, &x1087, x1085, x1014, x1061); + fiat_p384_scalar_addcarryx_u32(&x1088, &x1089, x1087, x1016, x1063); + fiat_p384_scalar_addcarryx_u32(&x1090, &x1091, x1089, x1018, x1065); + fiat_p384_scalar_addcarryx_u32(&x1092, &x1093, x1091, x1020, x1067); + fiat_p384_scalar_addcarryx_u32(&x1094, &x1095, x1093, x1022, x1069); + fiat_p384_scalar_addcarryx_u32(&x1096, &x1097, x1095, x1024, x1071); + fiat_p384_scalar_addcarryx_u32(&x1098, &x1099, x1097, x1026, x1073); + fiat_p384_scalar_addcarryx_u32(&x1100, &x1101, x1099, x1028, x1075); + fiat_p384_scalar_mulx_u32(&x1102, &x1103, x1076, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1104, &x1105, x1102, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1106, &x1107, x1102, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1108, &x1109, x1102, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1110, &x1111, x1102, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1112, &x1113, x1102, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1114, &x1115, x1102, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1116, &x1117, x1102, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1118, &x1119, x1102, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1120, &x1121, x1102, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1122, &x1123, x1102, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1124, &x1125, x1102, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1126, &x1127, x1102, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1128, &x1129, 0x0, x1127, x1124); + fiat_p384_scalar_addcarryx_u32(&x1130, &x1131, x1129, x1125, x1122); + fiat_p384_scalar_addcarryx_u32(&x1132, &x1133, x1131, x1123, x1120); + fiat_p384_scalar_addcarryx_u32(&x1134, &x1135, x1133, x1121, x1118); + fiat_p384_scalar_addcarryx_u32(&x1136, &x1137, x1135, x1119, x1116); + fiat_p384_scalar_addcarryx_u32(&x1138, &x1139, x1137, x1117, x1114); + fiat_p384_scalar_addcarryx_u32(&x1140, &x1141, x1139, x1115, x1112); + fiat_p384_scalar_addcarryx_u32(&x1142, &x1143, x1141, x1113, x1110); + fiat_p384_scalar_addcarryx_u32(&x1144, &x1145, x1143, x1111, x1108); + fiat_p384_scalar_addcarryx_u32(&x1146, &x1147, x1145, x1109, x1106); + fiat_p384_scalar_addcarryx_u32(&x1148, &x1149, x1147, x1107, x1104); + x1150 = (x1149 + x1105); + fiat_p384_scalar_addcarryx_u32(&x1151, &x1152, 0x0, x1076, x1126); + fiat_p384_scalar_addcarryx_u32(&x1153, &x1154, x1152, x1078, x1128); + fiat_p384_scalar_addcarryx_u32(&x1155, &x1156, x1154, x1080, x1130); + fiat_p384_scalar_addcarryx_u32(&x1157, &x1158, x1156, x1082, x1132); + fiat_p384_scalar_addcarryx_u32(&x1159, &x1160, x1158, x1084, x1134); + fiat_p384_scalar_addcarryx_u32(&x1161, &x1162, x1160, x1086, x1136); + fiat_p384_scalar_addcarryx_u32(&x1163, &x1164, x1162, x1088, x1138); + fiat_p384_scalar_addcarryx_u32(&x1165, &x1166, x1164, x1090, x1140); + fiat_p384_scalar_addcarryx_u32(&x1167, &x1168, x1166, x1092, x1142); + fiat_p384_scalar_addcarryx_u32(&x1169, &x1170, x1168, x1094, x1144); + fiat_p384_scalar_addcarryx_u32(&x1171, &x1172, x1170, x1096, x1146); + fiat_p384_scalar_addcarryx_u32(&x1173, &x1174, x1172, x1098, x1148); + fiat_p384_scalar_addcarryx_u32(&x1175, &x1176, x1174, x1100, x1150); + x1177 = ((uint32_t)x1176 + x1101); + fiat_p384_scalar_mulx_u32(&x1178, &x1179, x8, (arg2[11])); + fiat_p384_scalar_mulx_u32(&x1180, &x1181, x8, (arg2[10])); + fiat_p384_scalar_mulx_u32(&x1182, &x1183, x8, (arg2[9])); + fiat_p384_scalar_mulx_u32(&x1184, &x1185, x8, (arg2[8])); + fiat_p384_scalar_mulx_u32(&x1186, &x1187, x8, (arg2[7])); + fiat_p384_scalar_mulx_u32(&x1188, &x1189, x8, (arg2[6])); + fiat_p384_scalar_mulx_u32(&x1190, &x1191, x8, (arg2[5])); + fiat_p384_scalar_mulx_u32(&x1192, &x1193, x8, (arg2[4])); + fiat_p384_scalar_mulx_u32(&x1194, &x1195, x8, (arg2[3])); + fiat_p384_scalar_mulx_u32(&x1196, &x1197, x8, (arg2[2])); + fiat_p384_scalar_mulx_u32(&x1198, &x1199, x8, (arg2[1])); + fiat_p384_scalar_mulx_u32(&x1200, &x1201, x8, (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x1202, &x1203, 0x0, x1201, x1198); + fiat_p384_scalar_addcarryx_u32(&x1204, &x1205, x1203, x1199, x1196); + fiat_p384_scalar_addcarryx_u32(&x1206, &x1207, x1205, x1197, x1194); + fiat_p384_scalar_addcarryx_u32(&x1208, &x1209, x1207, x1195, x1192); + fiat_p384_scalar_addcarryx_u32(&x1210, &x1211, x1209, x1193, x1190); + fiat_p384_scalar_addcarryx_u32(&x1212, &x1213, x1211, x1191, x1188); + fiat_p384_scalar_addcarryx_u32(&x1214, &x1215, x1213, x1189, x1186); + fiat_p384_scalar_addcarryx_u32(&x1216, &x1217, x1215, x1187, x1184); + fiat_p384_scalar_addcarryx_u32(&x1218, &x1219, x1217, x1185, x1182); + fiat_p384_scalar_addcarryx_u32(&x1220, &x1221, x1219, x1183, x1180); + fiat_p384_scalar_addcarryx_u32(&x1222, &x1223, x1221, x1181, x1178); + x1224 = (x1223 + x1179); + fiat_p384_scalar_addcarryx_u32(&x1225, &x1226, 0x0, x1153, x1200); + fiat_p384_scalar_addcarryx_u32(&x1227, &x1228, x1226, x1155, x1202); + fiat_p384_scalar_addcarryx_u32(&x1229, &x1230, x1228, x1157, x1204); + fiat_p384_scalar_addcarryx_u32(&x1231, &x1232, x1230, x1159, x1206); + fiat_p384_scalar_addcarryx_u32(&x1233, &x1234, x1232, x1161, x1208); + fiat_p384_scalar_addcarryx_u32(&x1235, &x1236, x1234, x1163, x1210); + fiat_p384_scalar_addcarryx_u32(&x1237, &x1238, x1236, x1165, x1212); + fiat_p384_scalar_addcarryx_u32(&x1239, &x1240, x1238, x1167, x1214); + fiat_p384_scalar_addcarryx_u32(&x1241, &x1242, x1240, x1169, x1216); + fiat_p384_scalar_addcarryx_u32(&x1243, &x1244, x1242, x1171, x1218); + fiat_p384_scalar_addcarryx_u32(&x1245, &x1246, x1244, x1173, x1220); + fiat_p384_scalar_addcarryx_u32(&x1247, &x1248, x1246, x1175, x1222); + fiat_p384_scalar_addcarryx_u32(&x1249, &x1250, x1248, x1177, x1224); + fiat_p384_scalar_mulx_u32(&x1251, &x1252, x1225, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1253, &x1254, x1251, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1255, &x1256, x1251, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1257, &x1258, x1251, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1259, &x1260, x1251, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1261, &x1262, x1251, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1263, &x1264, x1251, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1265, &x1266, x1251, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1267, &x1268, x1251, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1269, &x1270, x1251, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1271, &x1272, x1251, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1273, &x1274, x1251, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1275, &x1276, x1251, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1277, &x1278, 0x0, x1276, x1273); + fiat_p384_scalar_addcarryx_u32(&x1279, &x1280, x1278, x1274, x1271); + fiat_p384_scalar_addcarryx_u32(&x1281, &x1282, x1280, x1272, x1269); + fiat_p384_scalar_addcarryx_u32(&x1283, &x1284, x1282, x1270, x1267); + fiat_p384_scalar_addcarryx_u32(&x1285, &x1286, x1284, x1268, x1265); + fiat_p384_scalar_addcarryx_u32(&x1287, &x1288, x1286, x1266, x1263); + fiat_p384_scalar_addcarryx_u32(&x1289, &x1290, x1288, x1264, x1261); + fiat_p384_scalar_addcarryx_u32(&x1291, &x1292, x1290, x1262, x1259); + fiat_p384_scalar_addcarryx_u32(&x1293, &x1294, x1292, x1260, x1257); + fiat_p384_scalar_addcarryx_u32(&x1295, &x1296, x1294, x1258, x1255); + fiat_p384_scalar_addcarryx_u32(&x1297, &x1298, x1296, x1256, x1253); + x1299 = (x1298 + x1254); + fiat_p384_scalar_addcarryx_u32(&x1300, &x1301, 0x0, x1225, x1275); + fiat_p384_scalar_addcarryx_u32(&x1302, &x1303, x1301, x1227, x1277); + fiat_p384_scalar_addcarryx_u32(&x1304, &x1305, x1303, x1229, x1279); + fiat_p384_scalar_addcarryx_u32(&x1306, &x1307, x1305, x1231, x1281); + fiat_p384_scalar_addcarryx_u32(&x1308, &x1309, x1307, x1233, x1283); + fiat_p384_scalar_addcarryx_u32(&x1310, &x1311, x1309, x1235, x1285); + fiat_p384_scalar_addcarryx_u32(&x1312, &x1313, x1311, x1237, x1287); + fiat_p384_scalar_addcarryx_u32(&x1314, &x1315, x1313, x1239, x1289); + fiat_p384_scalar_addcarryx_u32(&x1316, &x1317, x1315, x1241, x1291); + fiat_p384_scalar_addcarryx_u32(&x1318, &x1319, x1317, x1243, x1293); + fiat_p384_scalar_addcarryx_u32(&x1320, &x1321, x1319, x1245, x1295); + fiat_p384_scalar_addcarryx_u32(&x1322, &x1323, x1321, x1247, x1297); + fiat_p384_scalar_addcarryx_u32(&x1324, &x1325, x1323, x1249, x1299); + x1326 = ((uint32_t)x1325 + x1250); + fiat_p384_scalar_mulx_u32(&x1327, &x1328, x9, (arg2[11])); + fiat_p384_scalar_mulx_u32(&x1329, &x1330, x9, (arg2[10])); + fiat_p384_scalar_mulx_u32(&x1331, &x1332, x9, (arg2[9])); + fiat_p384_scalar_mulx_u32(&x1333, &x1334, x9, (arg2[8])); + fiat_p384_scalar_mulx_u32(&x1335, &x1336, x9, (arg2[7])); + fiat_p384_scalar_mulx_u32(&x1337, &x1338, x9, (arg2[6])); + fiat_p384_scalar_mulx_u32(&x1339, &x1340, x9, (arg2[5])); + fiat_p384_scalar_mulx_u32(&x1341, &x1342, x9, (arg2[4])); + fiat_p384_scalar_mulx_u32(&x1343, &x1344, x9, (arg2[3])); + fiat_p384_scalar_mulx_u32(&x1345, &x1346, x9, (arg2[2])); + fiat_p384_scalar_mulx_u32(&x1347, &x1348, x9, (arg2[1])); + fiat_p384_scalar_mulx_u32(&x1349, &x1350, x9, (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x1351, &x1352, 0x0, x1350, x1347); + fiat_p384_scalar_addcarryx_u32(&x1353, &x1354, x1352, x1348, x1345); + fiat_p384_scalar_addcarryx_u32(&x1355, &x1356, x1354, x1346, x1343); + fiat_p384_scalar_addcarryx_u32(&x1357, &x1358, x1356, x1344, x1341); + fiat_p384_scalar_addcarryx_u32(&x1359, &x1360, x1358, x1342, x1339); + fiat_p384_scalar_addcarryx_u32(&x1361, &x1362, x1360, x1340, x1337); + fiat_p384_scalar_addcarryx_u32(&x1363, &x1364, x1362, x1338, x1335); + fiat_p384_scalar_addcarryx_u32(&x1365, &x1366, x1364, x1336, x1333); + fiat_p384_scalar_addcarryx_u32(&x1367, &x1368, x1366, x1334, x1331); + fiat_p384_scalar_addcarryx_u32(&x1369, &x1370, x1368, x1332, x1329); + fiat_p384_scalar_addcarryx_u32(&x1371, &x1372, x1370, x1330, x1327); + x1373 = (x1372 + x1328); + fiat_p384_scalar_addcarryx_u32(&x1374, &x1375, 0x0, x1302, x1349); + fiat_p384_scalar_addcarryx_u32(&x1376, &x1377, x1375, x1304, x1351); + fiat_p384_scalar_addcarryx_u32(&x1378, &x1379, x1377, x1306, x1353); + fiat_p384_scalar_addcarryx_u32(&x1380, &x1381, x1379, x1308, x1355); + fiat_p384_scalar_addcarryx_u32(&x1382, &x1383, x1381, x1310, x1357); + fiat_p384_scalar_addcarryx_u32(&x1384, &x1385, x1383, x1312, x1359); + fiat_p384_scalar_addcarryx_u32(&x1386, &x1387, x1385, x1314, x1361); + fiat_p384_scalar_addcarryx_u32(&x1388, &x1389, x1387, x1316, x1363); + fiat_p384_scalar_addcarryx_u32(&x1390, &x1391, x1389, x1318, x1365); + fiat_p384_scalar_addcarryx_u32(&x1392, &x1393, x1391, x1320, x1367); + fiat_p384_scalar_addcarryx_u32(&x1394, &x1395, x1393, x1322, x1369); + fiat_p384_scalar_addcarryx_u32(&x1396, &x1397, x1395, x1324, x1371); + fiat_p384_scalar_addcarryx_u32(&x1398, &x1399, x1397, x1326, x1373); + fiat_p384_scalar_mulx_u32(&x1400, &x1401, x1374, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1402, &x1403, x1400, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1404, &x1405, x1400, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1406, &x1407, x1400, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1408, &x1409, x1400, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1410, &x1411, x1400, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1412, &x1413, x1400, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1414, &x1415, x1400, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1416, &x1417, x1400, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1418, &x1419, x1400, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1420, &x1421, x1400, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1422, &x1423, x1400, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1424, &x1425, x1400, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1426, &x1427, 0x0, x1425, x1422); + fiat_p384_scalar_addcarryx_u32(&x1428, &x1429, x1427, x1423, x1420); + fiat_p384_scalar_addcarryx_u32(&x1430, &x1431, x1429, x1421, x1418); + fiat_p384_scalar_addcarryx_u32(&x1432, &x1433, x1431, x1419, x1416); + fiat_p384_scalar_addcarryx_u32(&x1434, &x1435, x1433, x1417, x1414); + fiat_p384_scalar_addcarryx_u32(&x1436, &x1437, x1435, x1415, x1412); + fiat_p384_scalar_addcarryx_u32(&x1438, &x1439, x1437, x1413, x1410); + fiat_p384_scalar_addcarryx_u32(&x1440, &x1441, x1439, x1411, x1408); + fiat_p384_scalar_addcarryx_u32(&x1442, &x1443, x1441, x1409, x1406); + fiat_p384_scalar_addcarryx_u32(&x1444, &x1445, x1443, x1407, x1404); + fiat_p384_scalar_addcarryx_u32(&x1446, &x1447, x1445, x1405, x1402); + x1448 = (x1447 + x1403); + fiat_p384_scalar_addcarryx_u32(&x1449, &x1450, 0x0, x1374, x1424); + fiat_p384_scalar_addcarryx_u32(&x1451, &x1452, x1450, x1376, x1426); + fiat_p384_scalar_addcarryx_u32(&x1453, &x1454, x1452, x1378, x1428); + fiat_p384_scalar_addcarryx_u32(&x1455, &x1456, x1454, x1380, x1430); + fiat_p384_scalar_addcarryx_u32(&x1457, &x1458, x1456, x1382, x1432); + fiat_p384_scalar_addcarryx_u32(&x1459, &x1460, x1458, x1384, x1434); + fiat_p384_scalar_addcarryx_u32(&x1461, &x1462, x1460, x1386, x1436); + fiat_p384_scalar_addcarryx_u32(&x1463, &x1464, x1462, x1388, x1438); + fiat_p384_scalar_addcarryx_u32(&x1465, &x1466, x1464, x1390, x1440); + fiat_p384_scalar_addcarryx_u32(&x1467, &x1468, x1466, x1392, x1442); + fiat_p384_scalar_addcarryx_u32(&x1469, &x1470, x1468, x1394, x1444); + fiat_p384_scalar_addcarryx_u32(&x1471, &x1472, x1470, x1396, x1446); + fiat_p384_scalar_addcarryx_u32(&x1473, &x1474, x1472, x1398, x1448); + x1475 = ((uint32_t)x1474 + x1399); + fiat_p384_scalar_mulx_u32(&x1476, &x1477, x10, (arg2[11])); + fiat_p384_scalar_mulx_u32(&x1478, &x1479, x10, (arg2[10])); + fiat_p384_scalar_mulx_u32(&x1480, &x1481, x10, (arg2[9])); + fiat_p384_scalar_mulx_u32(&x1482, &x1483, x10, (arg2[8])); + fiat_p384_scalar_mulx_u32(&x1484, &x1485, x10, (arg2[7])); + fiat_p384_scalar_mulx_u32(&x1486, &x1487, x10, (arg2[6])); + fiat_p384_scalar_mulx_u32(&x1488, &x1489, x10, (arg2[5])); + fiat_p384_scalar_mulx_u32(&x1490, &x1491, x10, (arg2[4])); + fiat_p384_scalar_mulx_u32(&x1492, &x1493, x10, (arg2[3])); + fiat_p384_scalar_mulx_u32(&x1494, &x1495, x10, (arg2[2])); + fiat_p384_scalar_mulx_u32(&x1496, &x1497, x10, (arg2[1])); + fiat_p384_scalar_mulx_u32(&x1498, &x1499, x10, (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x1500, &x1501, 0x0, x1499, x1496); + fiat_p384_scalar_addcarryx_u32(&x1502, &x1503, x1501, x1497, x1494); + fiat_p384_scalar_addcarryx_u32(&x1504, &x1505, x1503, x1495, x1492); + fiat_p384_scalar_addcarryx_u32(&x1506, &x1507, x1505, x1493, x1490); + fiat_p384_scalar_addcarryx_u32(&x1508, &x1509, x1507, x1491, x1488); + fiat_p384_scalar_addcarryx_u32(&x1510, &x1511, x1509, x1489, x1486); + fiat_p384_scalar_addcarryx_u32(&x1512, &x1513, x1511, x1487, x1484); + fiat_p384_scalar_addcarryx_u32(&x1514, &x1515, x1513, x1485, x1482); + fiat_p384_scalar_addcarryx_u32(&x1516, &x1517, x1515, x1483, x1480); + fiat_p384_scalar_addcarryx_u32(&x1518, &x1519, x1517, x1481, x1478); + fiat_p384_scalar_addcarryx_u32(&x1520, &x1521, x1519, x1479, x1476); + x1522 = (x1521 + x1477); + fiat_p384_scalar_addcarryx_u32(&x1523, &x1524, 0x0, x1451, x1498); + fiat_p384_scalar_addcarryx_u32(&x1525, &x1526, x1524, x1453, x1500); + fiat_p384_scalar_addcarryx_u32(&x1527, &x1528, x1526, x1455, x1502); + fiat_p384_scalar_addcarryx_u32(&x1529, &x1530, x1528, x1457, x1504); + fiat_p384_scalar_addcarryx_u32(&x1531, &x1532, x1530, x1459, x1506); + fiat_p384_scalar_addcarryx_u32(&x1533, &x1534, x1532, x1461, x1508); + fiat_p384_scalar_addcarryx_u32(&x1535, &x1536, x1534, x1463, x1510); + fiat_p384_scalar_addcarryx_u32(&x1537, &x1538, x1536, x1465, x1512); + fiat_p384_scalar_addcarryx_u32(&x1539, &x1540, x1538, x1467, x1514); + fiat_p384_scalar_addcarryx_u32(&x1541, &x1542, x1540, x1469, x1516); + fiat_p384_scalar_addcarryx_u32(&x1543, &x1544, x1542, x1471, x1518); + fiat_p384_scalar_addcarryx_u32(&x1545, &x1546, x1544, x1473, x1520); + fiat_p384_scalar_addcarryx_u32(&x1547, &x1548, x1546, x1475, x1522); + fiat_p384_scalar_mulx_u32(&x1549, &x1550, x1523, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1551, &x1552, x1549, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1553, &x1554, x1549, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1555, &x1556, x1549, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1557, &x1558, x1549, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1559, &x1560, x1549, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1561, &x1562, x1549, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1563, &x1564, x1549, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1565, &x1566, x1549, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1567, &x1568, x1549, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1569, &x1570, x1549, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1571, &x1572, x1549, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1573, &x1574, x1549, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1575, &x1576, 0x0, x1574, x1571); + fiat_p384_scalar_addcarryx_u32(&x1577, &x1578, x1576, x1572, x1569); + fiat_p384_scalar_addcarryx_u32(&x1579, &x1580, x1578, x1570, x1567); + fiat_p384_scalar_addcarryx_u32(&x1581, &x1582, x1580, x1568, x1565); + fiat_p384_scalar_addcarryx_u32(&x1583, &x1584, x1582, x1566, x1563); + fiat_p384_scalar_addcarryx_u32(&x1585, &x1586, x1584, x1564, x1561); + fiat_p384_scalar_addcarryx_u32(&x1587, &x1588, x1586, x1562, x1559); + fiat_p384_scalar_addcarryx_u32(&x1589, &x1590, x1588, x1560, x1557); + fiat_p384_scalar_addcarryx_u32(&x1591, &x1592, x1590, x1558, x1555); + fiat_p384_scalar_addcarryx_u32(&x1593, &x1594, x1592, x1556, x1553); + fiat_p384_scalar_addcarryx_u32(&x1595, &x1596, x1594, x1554, x1551); + x1597 = (x1596 + x1552); + fiat_p384_scalar_addcarryx_u32(&x1598, &x1599, 0x0, x1523, x1573); + fiat_p384_scalar_addcarryx_u32(&x1600, &x1601, x1599, x1525, x1575); + fiat_p384_scalar_addcarryx_u32(&x1602, &x1603, x1601, x1527, x1577); + fiat_p384_scalar_addcarryx_u32(&x1604, &x1605, x1603, x1529, x1579); + fiat_p384_scalar_addcarryx_u32(&x1606, &x1607, x1605, x1531, x1581); + fiat_p384_scalar_addcarryx_u32(&x1608, &x1609, x1607, x1533, x1583); + fiat_p384_scalar_addcarryx_u32(&x1610, &x1611, x1609, x1535, x1585); + fiat_p384_scalar_addcarryx_u32(&x1612, &x1613, x1611, x1537, x1587); + fiat_p384_scalar_addcarryx_u32(&x1614, &x1615, x1613, x1539, x1589); + fiat_p384_scalar_addcarryx_u32(&x1616, &x1617, x1615, x1541, x1591); + fiat_p384_scalar_addcarryx_u32(&x1618, &x1619, x1617, x1543, x1593); + fiat_p384_scalar_addcarryx_u32(&x1620, &x1621, x1619, x1545, x1595); + fiat_p384_scalar_addcarryx_u32(&x1622, &x1623, x1621, x1547, x1597); + x1624 = ((uint32_t)x1623 + x1548); + fiat_p384_scalar_mulx_u32(&x1625, &x1626, x11, (arg2[11])); + fiat_p384_scalar_mulx_u32(&x1627, &x1628, x11, (arg2[10])); + fiat_p384_scalar_mulx_u32(&x1629, &x1630, x11, (arg2[9])); + fiat_p384_scalar_mulx_u32(&x1631, &x1632, x11, (arg2[8])); + fiat_p384_scalar_mulx_u32(&x1633, &x1634, x11, (arg2[7])); + fiat_p384_scalar_mulx_u32(&x1635, &x1636, x11, (arg2[6])); + fiat_p384_scalar_mulx_u32(&x1637, &x1638, x11, (arg2[5])); + fiat_p384_scalar_mulx_u32(&x1639, &x1640, x11, (arg2[4])); + fiat_p384_scalar_mulx_u32(&x1641, &x1642, x11, (arg2[3])); + fiat_p384_scalar_mulx_u32(&x1643, &x1644, x11, (arg2[2])); + fiat_p384_scalar_mulx_u32(&x1645, &x1646, x11, (arg2[1])); + fiat_p384_scalar_mulx_u32(&x1647, &x1648, x11, (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x1649, &x1650, 0x0, x1648, x1645); + fiat_p384_scalar_addcarryx_u32(&x1651, &x1652, x1650, x1646, x1643); + fiat_p384_scalar_addcarryx_u32(&x1653, &x1654, x1652, x1644, x1641); + fiat_p384_scalar_addcarryx_u32(&x1655, &x1656, x1654, x1642, x1639); + fiat_p384_scalar_addcarryx_u32(&x1657, &x1658, x1656, x1640, x1637); + fiat_p384_scalar_addcarryx_u32(&x1659, &x1660, x1658, x1638, x1635); + fiat_p384_scalar_addcarryx_u32(&x1661, &x1662, x1660, x1636, x1633); + fiat_p384_scalar_addcarryx_u32(&x1663, &x1664, x1662, x1634, x1631); + fiat_p384_scalar_addcarryx_u32(&x1665, &x1666, x1664, x1632, x1629); + fiat_p384_scalar_addcarryx_u32(&x1667, &x1668, x1666, x1630, x1627); + fiat_p384_scalar_addcarryx_u32(&x1669, &x1670, x1668, x1628, x1625); + x1671 = (x1670 + x1626); + fiat_p384_scalar_addcarryx_u32(&x1672, &x1673, 0x0, x1600, x1647); + fiat_p384_scalar_addcarryx_u32(&x1674, &x1675, x1673, x1602, x1649); + fiat_p384_scalar_addcarryx_u32(&x1676, &x1677, x1675, x1604, x1651); + fiat_p384_scalar_addcarryx_u32(&x1678, &x1679, x1677, x1606, x1653); + fiat_p384_scalar_addcarryx_u32(&x1680, &x1681, x1679, x1608, x1655); + fiat_p384_scalar_addcarryx_u32(&x1682, &x1683, x1681, x1610, x1657); + fiat_p384_scalar_addcarryx_u32(&x1684, &x1685, x1683, x1612, x1659); + fiat_p384_scalar_addcarryx_u32(&x1686, &x1687, x1685, x1614, x1661); + fiat_p384_scalar_addcarryx_u32(&x1688, &x1689, x1687, x1616, x1663); + fiat_p384_scalar_addcarryx_u32(&x1690, &x1691, x1689, x1618, x1665); + fiat_p384_scalar_addcarryx_u32(&x1692, &x1693, x1691, x1620, x1667); + fiat_p384_scalar_addcarryx_u32(&x1694, &x1695, x1693, x1622, x1669); + fiat_p384_scalar_addcarryx_u32(&x1696, &x1697, x1695, x1624, x1671); + fiat_p384_scalar_mulx_u32(&x1698, &x1699, x1672, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1700, &x1701, x1698, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1702, &x1703, x1698, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1704, &x1705, x1698, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1706, &x1707, x1698, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1708, &x1709, x1698, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1710, &x1711, x1698, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1712, &x1713, x1698, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1714, &x1715, x1698, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1716, &x1717, x1698, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1718, &x1719, x1698, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1720, &x1721, x1698, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1722, &x1723, x1698, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1724, &x1725, 0x0, x1723, x1720); + fiat_p384_scalar_addcarryx_u32(&x1726, &x1727, x1725, x1721, x1718); + fiat_p384_scalar_addcarryx_u32(&x1728, &x1729, x1727, x1719, x1716); + fiat_p384_scalar_addcarryx_u32(&x1730, &x1731, x1729, x1717, x1714); + fiat_p384_scalar_addcarryx_u32(&x1732, &x1733, x1731, x1715, x1712); + fiat_p384_scalar_addcarryx_u32(&x1734, &x1735, x1733, x1713, x1710); + fiat_p384_scalar_addcarryx_u32(&x1736, &x1737, x1735, x1711, x1708); + fiat_p384_scalar_addcarryx_u32(&x1738, &x1739, x1737, x1709, x1706); + fiat_p384_scalar_addcarryx_u32(&x1740, &x1741, x1739, x1707, x1704); + fiat_p384_scalar_addcarryx_u32(&x1742, &x1743, x1741, x1705, x1702); + fiat_p384_scalar_addcarryx_u32(&x1744, &x1745, x1743, x1703, x1700); + x1746 = (x1745 + x1701); + fiat_p384_scalar_addcarryx_u32(&x1747, &x1748, 0x0, x1672, x1722); + fiat_p384_scalar_addcarryx_u32(&x1749, &x1750, x1748, x1674, x1724); + fiat_p384_scalar_addcarryx_u32(&x1751, &x1752, x1750, x1676, x1726); + fiat_p384_scalar_addcarryx_u32(&x1753, &x1754, x1752, x1678, x1728); + fiat_p384_scalar_addcarryx_u32(&x1755, &x1756, x1754, x1680, x1730); + fiat_p384_scalar_addcarryx_u32(&x1757, &x1758, x1756, x1682, x1732); + fiat_p384_scalar_addcarryx_u32(&x1759, &x1760, x1758, x1684, x1734); + fiat_p384_scalar_addcarryx_u32(&x1761, &x1762, x1760, x1686, x1736); + fiat_p384_scalar_addcarryx_u32(&x1763, &x1764, x1762, x1688, x1738); + fiat_p384_scalar_addcarryx_u32(&x1765, &x1766, x1764, x1690, x1740); + fiat_p384_scalar_addcarryx_u32(&x1767, &x1768, x1766, x1692, x1742); + fiat_p384_scalar_addcarryx_u32(&x1769, &x1770, x1768, x1694, x1744); + fiat_p384_scalar_addcarryx_u32(&x1771, &x1772, x1770, x1696, x1746); + x1773 = ((uint32_t)x1772 + x1697); + fiat_p384_scalar_subborrowx_u32(&x1774, &x1775, 0x0, x1749, UINT32_C(0xccc52973)); + fiat_p384_scalar_subborrowx_u32(&x1776, &x1777, x1775, x1751, UINT32_C(0xecec196a)); + fiat_p384_scalar_subborrowx_u32(&x1778, &x1779, x1777, x1753, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_subborrowx_u32(&x1780, &x1781, x1779, x1755, UINT32_C(0x581a0db2)); + fiat_p384_scalar_subborrowx_u32(&x1782, &x1783, x1781, x1757, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_subborrowx_u32(&x1784, &x1785, x1783, x1759, UINT32_C(0xc7634d81)); + fiat_p384_scalar_subborrowx_u32(&x1786, &x1787, x1785, x1761, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1788, &x1789, x1787, x1763, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1790, &x1791, x1789, x1765, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1792, &x1793, x1791, x1767, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1794, &x1795, x1793, x1769, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1796, &x1797, x1795, x1771, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1798, &x1799, x1797, x1773, 0x0); + fiat_p384_scalar_cmovznz_u32(&x1800, x1799, x1774, x1749); + fiat_p384_scalar_cmovznz_u32(&x1801, x1799, x1776, x1751); + fiat_p384_scalar_cmovznz_u32(&x1802, x1799, x1778, x1753); + fiat_p384_scalar_cmovznz_u32(&x1803, x1799, x1780, x1755); + fiat_p384_scalar_cmovznz_u32(&x1804, x1799, x1782, x1757); + fiat_p384_scalar_cmovznz_u32(&x1805, x1799, x1784, x1759); + fiat_p384_scalar_cmovznz_u32(&x1806, x1799, x1786, x1761); + fiat_p384_scalar_cmovznz_u32(&x1807, x1799, x1788, x1763); + fiat_p384_scalar_cmovznz_u32(&x1808, x1799, x1790, x1765); + fiat_p384_scalar_cmovznz_u32(&x1809, x1799, x1792, x1767); + fiat_p384_scalar_cmovznz_u32(&x1810, x1799, x1794, x1769); + fiat_p384_scalar_cmovznz_u32(&x1811, x1799, x1796, x1771); + out1[0] = x1800; + out1[1] = x1801; + out1[2] = x1802; + out1[3] = x1803; + out1[4] = x1804; + out1[5] = x1805; + out1[6] = x1806; + out1[7] = x1807; + out1[8] = x1808; + out1[9] = x1809; + out1[10] = x1810; + out1[11] = x1811; +} + +/* + * The function fiat_p384_scalar_square squares a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_square(fiat_p384_scalar_montgomery_domain_field_element out1, const fiat_p384_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + uint32_t x26; + uint32_t x27; + uint32_t x28; + uint32_t x29; + uint32_t x30; + uint32_t x31; + uint32_t x32; + uint32_t x33; + uint32_t x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + fiat_p384_scalar_uint1 x38; + uint32_t x39; + fiat_p384_scalar_uint1 x40; + uint32_t x41; + fiat_p384_scalar_uint1 x42; + uint32_t x43; + fiat_p384_scalar_uint1 x44; + uint32_t x45; + fiat_p384_scalar_uint1 x46; + uint32_t x47; + fiat_p384_scalar_uint1 x48; + uint32_t x49; + fiat_p384_scalar_uint1 x50; + uint32_t x51; + fiat_p384_scalar_uint1 x52; + uint32_t x53; + fiat_p384_scalar_uint1 x54; + uint32_t x55; + fiat_p384_scalar_uint1 x56; + uint32_t x57; + fiat_p384_scalar_uint1 x58; + uint32_t x59; + uint32_t x60; + uint32_t x61; + uint32_t x62; + uint32_t x63; + uint32_t x64; + uint32_t x65; + uint32_t x66; + uint32_t x67; + uint32_t x68; + uint32_t x69; + uint32_t x70; + uint32_t x71; + uint32_t x72; + uint32_t x73; + uint32_t x74; + uint32_t x75; + uint32_t x76; + uint32_t x77; + uint32_t x78; + uint32_t x79; + uint32_t x80; + uint32_t x81; + uint32_t x82; + uint32_t x83; + uint32_t x84; + uint32_t x85; + uint32_t x86; + fiat_p384_scalar_uint1 x87; + uint32_t x88; + fiat_p384_scalar_uint1 x89; + uint32_t x90; + fiat_p384_scalar_uint1 x91; + uint32_t x92; + fiat_p384_scalar_uint1 x93; + uint32_t x94; + fiat_p384_scalar_uint1 x95; + uint32_t x96; + fiat_p384_scalar_uint1 x97; + uint32_t x98; + fiat_p384_scalar_uint1 x99; + uint32_t x100; + fiat_p384_scalar_uint1 x101; + uint32_t x102; + fiat_p384_scalar_uint1 x103; + uint32_t x104; + fiat_p384_scalar_uint1 x105; + uint32_t x106; + fiat_p384_scalar_uint1 x107; + uint32_t x108; + uint32_t x109; + fiat_p384_scalar_uint1 x110; + uint32_t x111; + fiat_p384_scalar_uint1 x112; + uint32_t x113; + fiat_p384_scalar_uint1 x114; + uint32_t x115; + fiat_p384_scalar_uint1 x116; + uint32_t x117; + fiat_p384_scalar_uint1 x118; + uint32_t x119; + fiat_p384_scalar_uint1 x120; + uint32_t x121; + fiat_p384_scalar_uint1 x122; + uint32_t x123; + fiat_p384_scalar_uint1 x124; + uint32_t x125; + fiat_p384_scalar_uint1 x126; + uint32_t x127; + fiat_p384_scalar_uint1 x128; + uint32_t x129; + fiat_p384_scalar_uint1 x130; + uint32_t x131; + fiat_p384_scalar_uint1 x132; + uint32_t x133; + fiat_p384_scalar_uint1 x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + uint32_t x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + uint32_t x145; + uint32_t x146; + uint32_t x147; + uint32_t x148; + uint32_t x149; + uint32_t x150; + uint32_t x151; + uint32_t x152; + uint32_t x153; + uint32_t x154; + uint32_t x155; + uint32_t x156; + uint32_t x157; + uint32_t x158; + uint32_t x159; + fiat_p384_scalar_uint1 x160; + uint32_t x161; + fiat_p384_scalar_uint1 x162; + uint32_t x163; + fiat_p384_scalar_uint1 x164; + uint32_t x165; + fiat_p384_scalar_uint1 x166; + uint32_t x167; + fiat_p384_scalar_uint1 x168; + uint32_t x169; + fiat_p384_scalar_uint1 x170; + uint32_t x171; + fiat_p384_scalar_uint1 x172; + uint32_t x173; + fiat_p384_scalar_uint1 x174; + uint32_t x175; + fiat_p384_scalar_uint1 x176; + uint32_t x177; + fiat_p384_scalar_uint1 x178; + uint32_t x179; + fiat_p384_scalar_uint1 x180; + uint32_t x181; + uint32_t x182; + fiat_p384_scalar_uint1 x183; + uint32_t x184; + fiat_p384_scalar_uint1 x185; + uint32_t x186; + fiat_p384_scalar_uint1 x187; + uint32_t x188; + fiat_p384_scalar_uint1 x189; + uint32_t x190; + fiat_p384_scalar_uint1 x191; + uint32_t x192; + fiat_p384_scalar_uint1 x193; + uint32_t x194; + fiat_p384_scalar_uint1 x195; + uint32_t x196; + fiat_p384_scalar_uint1 x197; + uint32_t x198; + fiat_p384_scalar_uint1 x199; + uint32_t x200; + fiat_p384_scalar_uint1 x201; + uint32_t x202; + fiat_p384_scalar_uint1 x203; + uint32_t x204; + fiat_p384_scalar_uint1 x205; + uint32_t x206; + fiat_p384_scalar_uint1 x207; + uint32_t x208; + uint32_t x209; + uint32_t x210; + uint32_t x211; + uint32_t x212; + uint32_t x213; + uint32_t x214; + uint32_t x215; + uint32_t x216; + uint32_t x217; + uint32_t x218; + uint32_t x219; + uint32_t x220; + uint32_t x221; + uint32_t x222; + uint32_t x223; + uint32_t x224; + uint32_t x225; + uint32_t x226; + uint32_t x227; + uint32_t x228; + uint32_t x229; + uint32_t x230; + uint32_t x231; + uint32_t x232; + uint32_t x233; + uint32_t x234; + fiat_p384_scalar_uint1 x235; + uint32_t x236; + fiat_p384_scalar_uint1 x237; + uint32_t x238; + fiat_p384_scalar_uint1 x239; + uint32_t x240; + fiat_p384_scalar_uint1 x241; + uint32_t x242; + fiat_p384_scalar_uint1 x243; + uint32_t x244; + fiat_p384_scalar_uint1 x245; + uint32_t x246; + fiat_p384_scalar_uint1 x247; + uint32_t x248; + fiat_p384_scalar_uint1 x249; + uint32_t x250; + fiat_p384_scalar_uint1 x251; + uint32_t x252; + fiat_p384_scalar_uint1 x253; + uint32_t x254; + fiat_p384_scalar_uint1 x255; + uint32_t x256; + uint32_t x257; + fiat_p384_scalar_uint1 x258; + uint32_t x259; + fiat_p384_scalar_uint1 x260; + uint32_t x261; + fiat_p384_scalar_uint1 x262; + uint32_t x263; + fiat_p384_scalar_uint1 x264; + uint32_t x265; + fiat_p384_scalar_uint1 x266; + uint32_t x267; + fiat_p384_scalar_uint1 x268; + uint32_t x269; + fiat_p384_scalar_uint1 x270; + uint32_t x271; + fiat_p384_scalar_uint1 x272; + uint32_t x273; + fiat_p384_scalar_uint1 x274; + uint32_t x275; + fiat_p384_scalar_uint1 x276; + uint32_t x277; + fiat_p384_scalar_uint1 x278; + uint32_t x279; + fiat_p384_scalar_uint1 x280; + uint32_t x281; + fiat_p384_scalar_uint1 x282; + uint32_t x283; + uint32_t x284; + uint32_t x285; + uint32_t x286; + uint32_t x287; + uint32_t x288; + uint32_t x289; + uint32_t x290; + uint32_t x291; + uint32_t x292; + uint32_t x293; + uint32_t x294; + uint32_t x295; + uint32_t x296; + uint32_t x297; + uint32_t x298; + uint32_t x299; + uint32_t x300; + uint32_t x301; + uint32_t x302; + uint32_t x303; + uint32_t x304; + uint32_t x305; + uint32_t x306; + uint32_t x307; + uint32_t x308; + fiat_p384_scalar_uint1 x309; + uint32_t x310; + fiat_p384_scalar_uint1 x311; + uint32_t x312; + fiat_p384_scalar_uint1 x313; + uint32_t x314; + fiat_p384_scalar_uint1 x315; + uint32_t x316; + fiat_p384_scalar_uint1 x317; + uint32_t x318; + fiat_p384_scalar_uint1 x319; + uint32_t x320; + fiat_p384_scalar_uint1 x321; + uint32_t x322; + fiat_p384_scalar_uint1 x323; + uint32_t x324; + fiat_p384_scalar_uint1 x325; + uint32_t x326; + fiat_p384_scalar_uint1 x327; + uint32_t x328; + fiat_p384_scalar_uint1 x329; + uint32_t x330; + uint32_t x331; + fiat_p384_scalar_uint1 x332; + uint32_t x333; + fiat_p384_scalar_uint1 x334; + uint32_t x335; + fiat_p384_scalar_uint1 x336; + uint32_t x337; + fiat_p384_scalar_uint1 x338; + uint32_t x339; + fiat_p384_scalar_uint1 x340; + uint32_t x341; + fiat_p384_scalar_uint1 x342; + uint32_t x343; + fiat_p384_scalar_uint1 x344; + uint32_t x345; + fiat_p384_scalar_uint1 x346; + uint32_t x347; + fiat_p384_scalar_uint1 x348; + uint32_t x349; + fiat_p384_scalar_uint1 x350; + uint32_t x351; + fiat_p384_scalar_uint1 x352; + uint32_t x353; + fiat_p384_scalar_uint1 x354; + uint32_t x355; + fiat_p384_scalar_uint1 x356; + uint32_t x357; + uint32_t x358; + uint32_t x359; + uint32_t x360; + uint32_t x361; + uint32_t x362; + uint32_t x363; + uint32_t x364; + uint32_t x365; + uint32_t x366; + uint32_t x367; + uint32_t x368; + uint32_t x369; + uint32_t x370; + uint32_t x371; + uint32_t x372; + uint32_t x373; + uint32_t x374; + uint32_t x375; + uint32_t x376; + uint32_t x377; + uint32_t x378; + uint32_t x379; + uint32_t x380; + uint32_t x381; + uint32_t x382; + uint32_t x383; + fiat_p384_scalar_uint1 x384; + uint32_t x385; + fiat_p384_scalar_uint1 x386; + uint32_t x387; + fiat_p384_scalar_uint1 x388; + uint32_t x389; + fiat_p384_scalar_uint1 x390; + uint32_t x391; + fiat_p384_scalar_uint1 x392; + uint32_t x393; + fiat_p384_scalar_uint1 x394; + uint32_t x395; + fiat_p384_scalar_uint1 x396; + uint32_t x397; + fiat_p384_scalar_uint1 x398; + uint32_t x399; + fiat_p384_scalar_uint1 x400; + uint32_t x401; + fiat_p384_scalar_uint1 x402; + uint32_t x403; + fiat_p384_scalar_uint1 x404; + uint32_t x405; + uint32_t x406; + fiat_p384_scalar_uint1 x407; + uint32_t x408; + fiat_p384_scalar_uint1 x409; + uint32_t x410; + fiat_p384_scalar_uint1 x411; + uint32_t x412; + fiat_p384_scalar_uint1 x413; + uint32_t x414; + fiat_p384_scalar_uint1 x415; + uint32_t x416; + fiat_p384_scalar_uint1 x417; + uint32_t x418; + fiat_p384_scalar_uint1 x419; + uint32_t x420; + fiat_p384_scalar_uint1 x421; + uint32_t x422; + fiat_p384_scalar_uint1 x423; + uint32_t x424; + fiat_p384_scalar_uint1 x425; + uint32_t x426; + fiat_p384_scalar_uint1 x427; + uint32_t x428; + fiat_p384_scalar_uint1 x429; + uint32_t x430; + fiat_p384_scalar_uint1 x431; + uint32_t x432; + uint32_t x433; + uint32_t x434; + uint32_t x435; + uint32_t x436; + uint32_t x437; + uint32_t x438; + uint32_t x439; + uint32_t x440; + uint32_t x441; + uint32_t x442; + uint32_t x443; + uint32_t x444; + uint32_t x445; + uint32_t x446; + uint32_t x447; + uint32_t x448; + uint32_t x449; + uint32_t x450; + uint32_t x451; + uint32_t x452; + uint32_t x453; + uint32_t x454; + uint32_t x455; + uint32_t x456; + uint32_t x457; + fiat_p384_scalar_uint1 x458; + uint32_t x459; + fiat_p384_scalar_uint1 x460; + uint32_t x461; + fiat_p384_scalar_uint1 x462; + uint32_t x463; + fiat_p384_scalar_uint1 x464; + uint32_t x465; + fiat_p384_scalar_uint1 x466; + uint32_t x467; + fiat_p384_scalar_uint1 x468; + uint32_t x469; + fiat_p384_scalar_uint1 x470; + uint32_t x471; + fiat_p384_scalar_uint1 x472; + uint32_t x473; + fiat_p384_scalar_uint1 x474; + uint32_t x475; + fiat_p384_scalar_uint1 x476; + uint32_t x477; + fiat_p384_scalar_uint1 x478; + uint32_t x479; + uint32_t x480; + fiat_p384_scalar_uint1 x481; + uint32_t x482; + fiat_p384_scalar_uint1 x483; + uint32_t x484; + fiat_p384_scalar_uint1 x485; + uint32_t x486; + fiat_p384_scalar_uint1 x487; + uint32_t x488; + fiat_p384_scalar_uint1 x489; + uint32_t x490; + fiat_p384_scalar_uint1 x491; + uint32_t x492; + fiat_p384_scalar_uint1 x493; + uint32_t x494; + fiat_p384_scalar_uint1 x495; + uint32_t x496; + fiat_p384_scalar_uint1 x497; + uint32_t x498; + fiat_p384_scalar_uint1 x499; + uint32_t x500; + fiat_p384_scalar_uint1 x501; + uint32_t x502; + fiat_p384_scalar_uint1 x503; + uint32_t x504; + fiat_p384_scalar_uint1 x505; + uint32_t x506; + uint32_t x507; + uint32_t x508; + uint32_t x509; + uint32_t x510; + uint32_t x511; + uint32_t x512; + uint32_t x513; + uint32_t x514; + uint32_t x515; + uint32_t x516; + uint32_t x517; + uint32_t x518; + uint32_t x519; + uint32_t x520; + uint32_t x521; + uint32_t x522; + uint32_t x523; + uint32_t x524; + uint32_t x525; + uint32_t x526; + uint32_t x527; + uint32_t x528; + uint32_t x529; + uint32_t x530; + uint32_t x531; + uint32_t x532; + fiat_p384_scalar_uint1 x533; + uint32_t x534; + fiat_p384_scalar_uint1 x535; + uint32_t x536; + fiat_p384_scalar_uint1 x537; + uint32_t x538; + fiat_p384_scalar_uint1 x539; + uint32_t x540; + fiat_p384_scalar_uint1 x541; + uint32_t x542; + fiat_p384_scalar_uint1 x543; + uint32_t x544; + fiat_p384_scalar_uint1 x545; + uint32_t x546; + fiat_p384_scalar_uint1 x547; + uint32_t x548; + fiat_p384_scalar_uint1 x549; + uint32_t x550; + fiat_p384_scalar_uint1 x551; + uint32_t x552; + fiat_p384_scalar_uint1 x553; + uint32_t x554; + uint32_t x555; + fiat_p384_scalar_uint1 x556; + uint32_t x557; + fiat_p384_scalar_uint1 x558; + uint32_t x559; + fiat_p384_scalar_uint1 x560; + uint32_t x561; + fiat_p384_scalar_uint1 x562; + uint32_t x563; + fiat_p384_scalar_uint1 x564; + uint32_t x565; + fiat_p384_scalar_uint1 x566; + uint32_t x567; + fiat_p384_scalar_uint1 x568; + uint32_t x569; + fiat_p384_scalar_uint1 x570; + uint32_t x571; + fiat_p384_scalar_uint1 x572; + uint32_t x573; + fiat_p384_scalar_uint1 x574; + uint32_t x575; + fiat_p384_scalar_uint1 x576; + uint32_t x577; + fiat_p384_scalar_uint1 x578; + uint32_t x579; + fiat_p384_scalar_uint1 x580; + uint32_t x581; + uint32_t x582; + uint32_t x583; + uint32_t x584; + uint32_t x585; + uint32_t x586; + uint32_t x587; + uint32_t x588; + uint32_t x589; + uint32_t x590; + uint32_t x591; + uint32_t x592; + uint32_t x593; + uint32_t x594; + uint32_t x595; + uint32_t x596; + uint32_t x597; + uint32_t x598; + uint32_t x599; + uint32_t x600; + uint32_t x601; + uint32_t x602; + uint32_t x603; + uint32_t x604; + uint32_t x605; + uint32_t x606; + fiat_p384_scalar_uint1 x607; + uint32_t x608; + fiat_p384_scalar_uint1 x609; + uint32_t x610; + fiat_p384_scalar_uint1 x611; + uint32_t x612; + fiat_p384_scalar_uint1 x613; + uint32_t x614; + fiat_p384_scalar_uint1 x615; + uint32_t x616; + fiat_p384_scalar_uint1 x617; + uint32_t x618; + fiat_p384_scalar_uint1 x619; + uint32_t x620; + fiat_p384_scalar_uint1 x621; + uint32_t x622; + fiat_p384_scalar_uint1 x623; + uint32_t x624; + fiat_p384_scalar_uint1 x625; + uint32_t x626; + fiat_p384_scalar_uint1 x627; + uint32_t x628; + uint32_t x629; + fiat_p384_scalar_uint1 x630; + uint32_t x631; + fiat_p384_scalar_uint1 x632; + uint32_t x633; + fiat_p384_scalar_uint1 x634; + uint32_t x635; + fiat_p384_scalar_uint1 x636; + uint32_t x637; + fiat_p384_scalar_uint1 x638; + uint32_t x639; + fiat_p384_scalar_uint1 x640; + uint32_t x641; + fiat_p384_scalar_uint1 x642; + uint32_t x643; + fiat_p384_scalar_uint1 x644; + uint32_t x645; + fiat_p384_scalar_uint1 x646; + uint32_t x647; + fiat_p384_scalar_uint1 x648; + uint32_t x649; + fiat_p384_scalar_uint1 x650; + uint32_t x651; + fiat_p384_scalar_uint1 x652; + uint32_t x653; + fiat_p384_scalar_uint1 x654; + uint32_t x655; + uint32_t x656; + uint32_t x657; + uint32_t x658; + uint32_t x659; + uint32_t x660; + uint32_t x661; + uint32_t x662; + uint32_t x663; + uint32_t x664; + uint32_t x665; + uint32_t x666; + uint32_t x667; + uint32_t x668; + uint32_t x669; + uint32_t x670; + uint32_t x671; + uint32_t x672; + uint32_t x673; + uint32_t x674; + uint32_t x675; + uint32_t x676; + uint32_t x677; + uint32_t x678; + uint32_t x679; + uint32_t x680; + uint32_t x681; + fiat_p384_scalar_uint1 x682; + uint32_t x683; + fiat_p384_scalar_uint1 x684; + uint32_t x685; + fiat_p384_scalar_uint1 x686; + uint32_t x687; + fiat_p384_scalar_uint1 x688; + uint32_t x689; + fiat_p384_scalar_uint1 x690; + uint32_t x691; + fiat_p384_scalar_uint1 x692; + uint32_t x693; + fiat_p384_scalar_uint1 x694; + uint32_t x695; + fiat_p384_scalar_uint1 x696; + uint32_t x697; + fiat_p384_scalar_uint1 x698; + uint32_t x699; + fiat_p384_scalar_uint1 x700; + uint32_t x701; + fiat_p384_scalar_uint1 x702; + uint32_t x703; + uint32_t x704; + fiat_p384_scalar_uint1 x705; + uint32_t x706; + fiat_p384_scalar_uint1 x707; + uint32_t x708; + fiat_p384_scalar_uint1 x709; + uint32_t x710; + fiat_p384_scalar_uint1 x711; + uint32_t x712; + fiat_p384_scalar_uint1 x713; + uint32_t x714; + fiat_p384_scalar_uint1 x715; + uint32_t x716; + fiat_p384_scalar_uint1 x717; + uint32_t x718; + fiat_p384_scalar_uint1 x719; + uint32_t x720; + fiat_p384_scalar_uint1 x721; + uint32_t x722; + fiat_p384_scalar_uint1 x723; + uint32_t x724; + fiat_p384_scalar_uint1 x725; + uint32_t x726; + fiat_p384_scalar_uint1 x727; + uint32_t x728; + fiat_p384_scalar_uint1 x729; + uint32_t x730; + uint32_t x731; + uint32_t x732; + uint32_t x733; + uint32_t x734; + uint32_t x735; + uint32_t x736; + uint32_t x737; + uint32_t x738; + uint32_t x739; + uint32_t x740; + uint32_t x741; + uint32_t x742; + uint32_t x743; + uint32_t x744; + uint32_t x745; + uint32_t x746; + uint32_t x747; + uint32_t x748; + uint32_t x749; + uint32_t x750; + uint32_t x751; + uint32_t x752; + uint32_t x753; + uint32_t x754; + uint32_t x755; + fiat_p384_scalar_uint1 x756; + uint32_t x757; + fiat_p384_scalar_uint1 x758; + uint32_t x759; + fiat_p384_scalar_uint1 x760; + uint32_t x761; + fiat_p384_scalar_uint1 x762; + uint32_t x763; + fiat_p384_scalar_uint1 x764; + uint32_t x765; + fiat_p384_scalar_uint1 x766; + uint32_t x767; + fiat_p384_scalar_uint1 x768; + uint32_t x769; + fiat_p384_scalar_uint1 x770; + uint32_t x771; + fiat_p384_scalar_uint1 x772; + uint32_t x773; + fiat_p384_scalar_uint1 x774; + uint32_t x775; + fiat_p384_scalar_uint1 x776; + uint32_t x777; + uint32_t x778; + fiat_p384_scalar_uint1 x779; + uint32_t x780; + fiat_p384_scalar_uint1 x781; + uint32_t x782; + fiat_p384_scalar_uint1 x783; + uint32_t x784; + fiat_p384_scalar_uint1 x785; + uint32_t x786; + fiat_p384_scalar_uint1 x787; + uint32_t x788; + fiat_p384_scalar_uint1 x789; + uint32_t x790; + fiat_p384_scalar_uint1 x791; + uint32_t x792; + fiat_p384_scalar_uint1 x793; + uint32_t x794; + fiat_p384_scalar_uint1 x795; + uint32_t x796; + fiat_p384_scalar_uint1 x797; + uint32_t x798; + fiat_p384_scalar_uint1 x799; + uint32_t x800; + fiat_p384_scalar_uint1 x801; + uint32_t x802; + fiat_p384_scalar_uint1 x803; + uint32_t x804; + uint32_t x805; + uint32_t x806; + uint32_t x807; + uint32_t x808; + uint32_t x809; + uint32_t x810; + uint32_t x811; + uint32_t x812; + uint32_t x813; + uint32_t x814; + uint32_t x815; + uint32_t x816; + uint32_t x817; + uint32_t x818; + uint32_t x819; + uint32_t x820; + uint32_t x821; + uint32_t x822; + uint32_t x823; + uint32_t x824; + uint32_t x825; + uint32_t x826; + uint32_t x827; + uint32_t x828; + uint32_t x829; + uint32_t x830; + fiat_p384_scalar_uint1 x831; + uint32_t x832; + fiat_p384_scalar_uint1 x833; + uint32_t x834; + fiat_p384_scalar_uint1 x835; + uint32_t x836; + fiat_p384_scalar_uint1 x837; + uint32_t x838; + fiat_p384_scalar_uint1 x839; + uint32_t x840; + fiat_p384_scalar_uint1 x841; + uint32_t x842; + fiat_p384_scalar_uint1 x843; + uint32_t x844; + fiat_p384_scalar_uint1 x845; + uint32_t x846; + fiat_p384_scalar_uint1 x847; + uint32_t x848; + fiat_p384_scalar_uint1 x849; + uint32_t x850; + fiat_p384_scalar_uint1 x851; + uint32_t x852; + uint32_t x853; + fiat_p384_scalar_uint1 x854; + uint32_t x855; + fiat_p384_scalar_uint1 x856; + uint32_t x857; + fiat_p384_scalar_uint1 x858; + uint32_t x859; + fiat_p384_scalar_uint1 x860; + uint32_t x861; + fiat_p384_scalar_uint1 x862; + uint32_t x863; + fiat_p384_scalar_uint1 x864; + uint32_t x865; + fiat_p384_scalar_uint1 x866; + uint32_t x867; + fiat_p384_scalar_uint1 x868; + uint32_t x869; + fiat_p384_scalar_uint1 x870; + uint32_t x871; + fiat_p384_scalar_uint1 x872; + uint32_t x873; + fiat_p384_scalar_uint1 x874; + uint32_t x875; + fiat_p384_scalar_uint1 x876; + uint32_t x877; + fiat_p384_scalar_uint1 x878; + uint32_t x879; + uint32_t x880; + uint32_t x881; + uint32_t x882; + uint32_t x883; + uint32_t x884; + uint32_t x885; + uint32_t x886; + uint32_t x887; + uint32_t x888; + uint32_t x889; + uint32_t x890; + uint32_t x891; + uint32_t x892; + uint32_t x893; + uint32_t x894; + uint32_t x895; + uint32_t x896; + uint32_t x897; + uint32_t x898; + uint32_t x899; + uint32_t x900; + uint32_t x901; + uint32_t x902; + uint32_t x903; + uint32_t x904; + fiat_p384_scalar_uint1 x905; + uint32_t x906; + fiat_p384_scalar_uint1 x907; + uint32_t x908; + fiat_p384_scalar_uint1 x909; + uint32_t x910; + fiat_p384_scalar_uint1 x911; + uint32_t x912; + fiat_p384_scalar_uint1 x913; + uint32_t x914; + fiat_p384_scalar_uint1 x915; + uint32_t x916; + fiat_p384_scalar_uint1 x917; + uint32_t x918; + fiat_p384_scalar_uint1 x919; + uint32_t x920; + fiat_p384_scalar_uint1 x921; + uint32_t x922; + fiat_p384_scalar_uint1 x923; + uint32_t x924; + fiat_p384_scalar_uint1 x925; + uint32_t x926; + uint32_t x927; + fiat_p384_scalar_uint1 x928; + uint32_t x929; + fiat_p384_scalar_uint1 x930; + uint32_t x931; + fiat_p384_scalar_uint1 x932; + uint32_t x933; + fiat_p384_scalar_uint1 x934; + uint32_t x935; + fiat_p384_scalar_uint1 x936; + uint32_t x937; + fiat_p384_scalar_uint1 x938; + uint32_t x939; + fiat_p384_scalar_uint1 x940; + uint32_t x941; + fiat_p384_scalar_uint1 x942; + uint32_t x943; + fiat_p384_scalar_uint1 x944; + uint32_t x945; + fiat_p384_scalar_uint1 x946; + uint32_t x947; + fiat_p384_scalar_uint1 x948; + uint32_t x949; + fiat_p384_scalar_uint1 x950; + uint32_t x951; + fiat_p384_scalar_uint1 x952; + uint32_t x953; + uint32_t x954; + uint32_t x955; + uint32_t x956; + uint32_t x957; + uint32_t x958; + uint32_t x959; + uint32_t x960; + uint32_t x961; + uint32_t x962; + uint32_t x963; + uint32_t x964; + uint32_t x965; + uint32_t x966; + uint32_t x967; + uint32_t x968; + uint32_t x969; + uint32_t x970; + uint32_t x971; + uint32_t x972; + uint32_t x973; + uint32_t x974; + uint32_t x975; + uint32_t x976; + uint32_t x977; + uint32_t x978; + uint32_t x979; + fiat_p384_scalar_uint1 x980; + uint32_t x981; + fiat_p384_scalar_uint1 x982; + uint32_t x983; + fiat_p384_scalar_uint1 x984; + uint32_t x985; + fiat_p384_scalar_uint1 x986; + uint32_t x987; + fiat_p384_scalar_uint1 x988; + uint32_t x989; + fiat_p384_scalar_uint1 x990; + uint32_t x991; + fiat_p384_scalar_uint1 x992; + uint32_t x993; + fiat_p384_scalar_uint1 x994; + uint32_t x995; + fiat_p384_scalar_uint1 x996; + uint32_t x997; + fiat_p384_scalar_uint1 x998; + uint32_t x999; + fiat_p384_scalar_uint1 x1000; + uint32_t x1001; + uint32_t x1002; + fiat_p384_scalar_uint1 x1003; + uint32_t x1004; + fiat_p384_scalar_uint1 x1005; + uint32_t x1006; + fiat_p384_scalar_uint1 x1007; + uint32_t x1008; + fiat_p384_scalar_uint1 x1009; + uint32_t x1010; + fiat_p384_scalar_uint1 x1011; + uint32_t x1012; + fiat_p384_scalar_uint1 x1013; + uint32_t x1014; + fiat_p384_scalar_uint1 x1015; + uint32_t x1016; + fiat_p384_scalar_uint1 x1017; + uint32_t x1018; + fiat_p384_scalar_uint1 x1019; + uint32_t x1020; + fiat_p384_scalar_uint1 x1021; + uint32_t x1022; + fiat_p384_scalar_uint1 x1023; + uint32_t x1024; + fiat_p384_scalar_uint1 x1025; + uint32_t x1026; + fiat_p384_scalar_uint1 x1027; + uint32_t x1028; + uint32_t x1029; + uint32_t x1030; + uint32_t x1031; + uint32_t x1032; + uint32_t x1033; + uint32_t x1034; + uint32_t x1035; + uint32_t x1036; + uint32_t x1037; + uint32_t x1038; + uint32_t x1039; + uint32_t x1040; + uint32_t x1041; + uint32_t x1042; + uint32_t x1043; + uint32_t x1044; + uint32_t x1045; + uint32_t x1046; + uint32_t x1047; + uint32_t x1048; + uint32_t x1049; + uint32_t x1050; + uint32_t x1051; + uint32_t x1052; + uint32_t x1053; + fiat_p384_scalar_uint1 x1054; + uint32_t x1055; + fiat_p384_scalar_uint1 x1056; + uint32_t x1057; + fiat_p384_scalar_uint1 x1058; + uint32_t x1059; + fiat_p384_scalar_uint1 x1060; + uint32_t x1061; + fiat_p384_scalar_uint1 x1062; + uint32_t x1063; + fiat_p384_scalar_uint1 x1064; + uint32_t x1065; + fiat_p384_scalar_uint1 x1066; + uint32_t x1067; + fiat_p384_scalar_uint1 x1068; + uint32_t x1069; + fiat_p384_scalar_uint1 x1070; + uint32_t x1071; + fiat_p384_scalar_uint1 x1072; + uint32_t x1073; + fiat_p384_scalar_uint1 x1074; + uint32_t x1075; + uint32_t x1076; + fiat_p384_scalar_uint1 x1077; + uint32_t x1078; + fiat_p384_scalar_uint1 x1079; + uint32_t x1080; + fiat_p384_scalar_uint1 x1081; + uint32_t x1082; + fiat_p384_scalar_uint1 x1083; + uint32_t x1084; + fiat_p384_scalar_uint1 x1085; + uint32_t x1086; + fiat_p384_scalar_uint1 x1087; + uint32_t x1088; + fiat_p384_scalar_uint1 x1089; + uint32_t x1090; + fiat_p384_scalar_uint1 x1091; + uint32_t x1092; + fiat_p384_scalar_uint1 x1093; + uint32_t x1094; + fiat_p384_scalar_uint1 x1095; + uint32_t x1096; + fiat_p384_scalar_uint1 x1097; + uint32_t x1098; + fiat_p384_scalar_uint1 x1099; + uint32_t x1100; + fiat_p384_scalar_uint1 x1101; + uint32_t x1102; + uint32_t x1103; + uint32_t x1104; + uint32_t x1105; + uint32_t x1106; + uint32_t x1107; + uint32_t x1108; + uint32_t x1109; + uint32_t x1110; + uint32_t x1111; + uint32_t x1112; + uint32_t x1113; + uint32_t x1114; + uint32_t x1115; + uint32_t x1116; + uint32_t x1117; + uint32_t x1118; + uint32_t x1119; + uint32_t x1120; + uint32_t x1121; + uint32_t x1122; + uint32_t x1123; + uint32_t x1124; + uint32_t x1125; + uint32_t x1126; + uint32_t x1127; + uint32_t x1128; + fiat_p384_scalar_uint1 x1129; + uint32_t x1130; + fiat_p384_scalar_uint1 x1131; + uint32_t x1132; + fiat_p384_scalar_uint1 x1133; + uint32_t x1134; + fiat_p384_scalar_uint1 x1135; + uint32_t x1136; + fiat_p384_scalar_uint1 x1137; + uint32_t x1138; + fiat_p384_scalar_uint1 x1139; + uint32_t x1140; + fiat_p384_scalar_uint1 x1141; + uint32_t x1142; + fiat_p384_scalar_uint1 x1143; + uint32_t x1144; + fiat_p384_scalar_uint1 x1145; + uint32_t x1146; + fiat_p384_scalar_uint1 x1147; + uint32_t x1148; + fiat_p384_scalar_uint1 x1149; + uint32_t x1150; + uint32_t x1151; + fiat_p384_scalar_uint1 x1152; + uint32_t x1153; + fiat_p384_scalar_uint1 x1154; + uint32_t x1155; + fiat_p384_scalar_uint1 x1156; + uint32_t x1157; + fiat_p384_scalar_uint1 x1158; + uint32_t x1159; + fiat_p384_scalar_uint1 x1160; + uint32_t x1161; + fiat_p384_scalar_uint1 x1162; + uint32_t x1163; + fiat_p384_scalar_uint1 x1164; + uint32_t x1165; + fiat_p384_scalar_uint1 x1166; + uint32_t x1167; + fiat_p384_scalar_uint1 x1168; + uint32_t x1169; + fiat_p384_scalar_uint1 x1170; + uint32_t x1171; + fiat_p384_scalar_uint1 x1172; + uint32_t x1173; + fiat_p384_scalar_uint1 x1174; + uint32_t x1175; + fiat_p384_scalar_uint1 x1176; + uint32_t x1177; + uint32_t x1178; + uint32_t x1179; + uint32_t x1180; + uint32_t x1181; + uint32_t x1182; + uint32_t x1183; + uint32_t x1184; + uint32_t x1185; + uint32_t x1186; + uint32_t x1187; + uint32_t x1188; + uint32_t x1189; + uint32_t x1190; + uint32_t x1191; + uint32_t x1192; + uint32_t x1193; + uint32_t x1194; + uint32_t x1195; + uint32_t x1196; + uint32_t x1197; + uint32_t x1198; + uint32_t x1199; + uint32_t x1200; + uint32_t x1201; + uint32_t x1202; + fiat_p384_scalar_uint1 x1203; + uint32_t x1204; + fiat_p384_scalar_uint1 x1205; + uint32_t x1206; + fiat_p384_scalar_uint1 x1207; + uint32_t x1208; + fiat_p384_scalar_uint1 x1209; + uint32_t x1210; + fiat_p384_scalar_uint1 x1211; + uint32_t x1212; + fiat_p384_scalar_uint1 x1213; + uint32_t x1214; + fiat_p384_scalar_uint1 x1215; + uint32_t x1216; + fiat_p384_scalar_uint1 x1217; + uint32_t x1218; + fiat_p384_scalar_uint1 x1219; + uint32_t x1220; + fiat_p384_scalar_uint1 x1221; + uint32_t x1222; + fiat_p384_scalar_uint1 x1223; + uint32_t x1224; + uint32_t x1225; + fiat_p384_scalar_uint1 x1226; + uint32_t x1227; + fiat_p384_scalar_uint1 x1228; + uint32_t x1229; + fiat_p384_scalar_uint1 x1230; + uint32_t x1231; + fiat_p384_scalar_uint1 x1232; + uint32_t x1233; + fiat_p384_scalar_uint1 x1234; + uint32_t x1235; + fiat_p384_scalar_uint1 x1236; + uint32_t x1237; + fiat_p384_scalar_uint1 x1238; + uint32_t x1239; + fiat_p384_scalar_uint1 x1240; + uint32_t x1241; + fiat_p384_scalar_uint1 x1242; + uint32_t x1243; + fiat_p384_scalar_uint1 x1244; + uint32_t x1245; + fiat_p384_scalar_uint1 x1246; + uint32_t x1247; + fiat_p384_scalar_uint1 x1248; + uint32_t x1249; + fiat_p384_scalar_uint1 x1250; + uint32_t x1251; + uint32_t x1252; + uint32_t x1253; + uint32_t x1254; + uint32_t x1255; + uint32_t x1256; + uint32_t x1257; + uint32_t x1258; + uint32_t x1259; + uint32_t x1260; + uint32_t x1261; + uint32_t x1262; + uint32_t x1263; + uint32_t x1264; + uint32_t x1265; + uint32_t x1266; + uint32_t x1267; + uint32_t x1268; + uint32_t x1269; + uint32_t x1270; + uint32_t x1271; + uint32_t x1272; + uint32_t x1273; + uint32_t x1274; + uint32_t x1275; + uint32_t x1276; + uint32_t x1277; + fiat_p384_scalar_uint1 x1278; + uint32_t x1279; + fiat_p384_scalar_uint1 x1280; + uint32_t x1281; + fiat_p384_scalar_uint1 x1282; + uint32_t x1283; + fiat_p384_scalar_uint1 x1284; + uint32_t x1285; + fiat_p384_scalar_uint1 x1286; + uint32_t x1287; + fiat_p384_scalar_uint1 x1288; + uint32_t x1289; + fiat_p384_scalar_uint1 x1290; + uint32_t x1291; + fiat_p384_scalar_uint1 x1292; + uint32_t x1293; + fiat_p384_scalar_uint1 x1294; + uint32_t x1295; + fiat_p384_scalar_uint1 x1296; + uint32_t x1297; + fiat_p384_scalar_uint1 x1298; + uint32_t x1299; + uint32_t x1300; + fiat_p384_scalar_uint1 x1301; + uint32_t x1302; + fiat_p384_scalar_uint1 x1303; + uint32_t x1304; + fiat_p384_scalar_uint1 x1305; + uint32_t x1306; + fiat_p384_scalar_uint1 x1307; + uint32_t x1308; + fiat_p384_scalar_uint1 x1309; + uint32_t x1310; + fiat_p384_scalar_uint1 x1311; + uint32_t x1312; + fiat_p384_scalar_uint1 x1313; + uint32_t x1314; + fiat_p384_scalar_uint1 x1315; + uint32_t x1316; + fiat_p384_scalar_uint1 x1317; + uint32_t x1318; + fiat_p384_scalar_uint1 x1319; + uint32_t x1320; + fiat_p384_scalar_uint1 x1321; + uint32_t x1322; + fiat_p384_scalar_uint1 x1323; + uint32_t x1324; + fiat_p384_scalar_uint1 x1325; + uint32_t x1326; + uint32_t x1327; + uint32_t x1328; + uint32_t x1329; + uint32_t x1330; + uint32_t x1331; + uint32_t x1332; + uint32_t x1333; + uint32_t x1334; + uint32_t x1335; + uint32_t x1336; + uint32_t x1337; + uint32_t x1338; + uint32_t x1339; + uint32_t x1340; + uint32_t x1341; + uint32_t x1342; + uint32_t x1343; + uint32_t x1344; + uint32_t x1345; + uint32_t x1346; + uint32_t x1347; + uint32_t x1348; + uint32_t x1349; + uint32_t x1350; + uint32_t x1351; + fiat_p384_scalar_uint1 x1352; + uint32_t x1353; + fiat_p384_scalar_uint1 x1354; + uint32_t x1355; + fiat_p384_scalar_uint1 x1356; + uint32_t x1357; + fiat_p384_scalar_uint1 x1358; + uint32_t x1359; + fiat_p384_scalar_uint1 x1360; + uint32_t x1361; + fiat_p384_scalar_uint1 x1362; + uint32_t x1363; + fiat_p384_scalar_uint1 x1364; + uint32_t x1365; + fiat_p384_scalar_uint1 x1366; + uint32_t x1367; + fiat_p384_scalar_uint1 x1368; + uint32_t x1369; + fiat_p384_scalar_uint1 x1370; + uint32_t x1371; + fiat_p384_scalar_uint1 x1372; + uint32_t x1373; + uint32_t x1374; + fiat_p384_scalar_uint1 x1375; + uint32_t x1376; + fiat_p384_scalar_uint1 x1377; + uint32_t x1378; + fiat_p384_scalar_uint1 x1379; + uint32_t x1380; + fiat_p384_scalar_uint1 x1381; + uint32_t x1382; + fiat_p384_scalar_uint1 x1383; + uint32_t x1384; + fiat_p384_scalar_uint1 x1385; + uint32_t x1386; + fiat_p384_scalar_uint1 x1387; + uint32_t x1388; + fiat_p384_scalar_uint1 x1389; + uint32_t x1390; + fiat_p384_scalar_uint1 x1391; + uint32_t x1392; + fiat_p384_scalar_uint1 x1393; + uint32_t x1394; + fiat_p384_scalar_uint1 x1395; + uint32_t x1396; + fiat_p384_scalar_uint1 x1397; + uint32_t x1398; + fiat_p384_scalar_uint1 x1399; + uint32_t x1400; + uint32_t x1401; + uint32_t x1402; + uint32_t x1403; + uint32_t x1404; + uint32_t x1405; + uint32_t x1406; + uint32_t x1407; + uint32_t x1408; + uint32_t x1409; + uint32_t x1410; + uint32_t x1411; + uint32_t x1412; + uint32_t x1413; + uint32_t x1414; + uint32_t x1415; + uint32_t x1416; + uint32_t x1417; + uint32_t x1418; + uint32_t x1419; + uint32_t x1420; + uint32_t x1421; + uint32_t x1422; + uint32_t x1423; + uint32_t x1424; + uint32_t x1425; + uint32_t x1426; + fiat_p384_scalar_uint1 x1427; + uint32_t x1428; + fiat_p384_scalar_uint1 x1429; + uint32_t x1430; + fiat_p384_scalar_uint1 x1431; + uint32_t x1432; + fiat_p384_scalar_uint1 x1433; + uint32_t x1434; + fiat_p384_scalar_uint1 x1435; + uint32_t x1436; + fiat_p384_scalar_uint1 x1437; + uint32_t x1438; + fiat_p384_scalar_uint1 x1439; + uint32_t x1440; + fiat_p384_scalar_uint1 x1441; + uint32_t x1442; + fiat_p384_scalar_uint1 x1443; + uint32_t x1444; + fiat_p384_scalar_uint1 x1445; + uint32_t x1446; + fiat_p384_scalar_uint1 x1447; + uint32_t x1448; + uint32_t x1449; + fiat_p384_scalar_uint1 x1450; + uint32_t x1451; + fiat_p384_scalar_uint1 x1452; + uint32_t x1453; + fiat_p384_scalar_uint1 x1454; + uint32_t x1455; + fiat_p384_scalar_uint1 x1456; + uint32_t x1457; + fiat_p384_scalar_uint1 x1458; + uint32_t x1459; + fiat_p384_scalar_uint1 x1460; + uint32_t x1461; + fiat_p384_scalar_uint1 x1462; + uint32_t x1463; + fiat_p384_scalar_uint1 x1464; + uint32_t x1465; + fiat_p384_scalar_uint1 x1466; + uint32_t x1467; + fiat_p384_scalar_uint1 x1468; + uint32_t x1469; + fiat_p384_scalar_uint1 x1470; + uint32_t x1471; + fiat_p384_scalar_uint1 x1472; + uint32_t x1473; + fiat_p384_scalar_uint1 x1474; + uint32_t x1475; + uint32_t x1476; + uint32_t x1477; + uint32_t x1478; + uint32_t x1479; + uint32_t x1480; + uint32_t x1481; + uint32_t x1482; + uint32_t x1483; + uint32_t x1484; + uint32_t x1485; + uint32_t x1486; + uint32_t x1487; + uint32_t x1488; + uint32_t x1489; + uint32_t x1490; + uint32_t x1491; + uint32_t x1492; + uint32_t x1493; + uint32_t x1494; + uint32_t x1495; + uint32_t x1496; + uint32_t x1497; + uint32_t x1498; + uint32_t x1499; + uint32_t x1500; + fiat_p384_scalar_uint1 x1501; + uint32_t x1502; + fiat_p384_scalar_uint1 x1503; + uint32_t x1504; + fiat_p384_scalar_uint1 x1505; + uint32_t x1506; + fiat_p384_scalar_uint1 x1507; + uint32_t x1508; + fiat_p384_scalar_uint1 x1509; + uint32_t x1510; + fiat_p384_scalar_uint1 x1511; + uint32_t x1512; + fiat_p384_scalar_uint1 x1513; + uint32_t x1514; + fiat_p384_scalar_uint1 x1515; + uint32_t x1516; + fiat_p384_scalar_uint1 x1517; + uint32_t x1518; + fiat_p384_scalar_uint1 x1519; + uint32_t x1520; + fiat_p384_scalar_uint1 x1521; + uint32_t x1522; + uint32_t x1523; + fiat_p384_scalar_uint1 x1524; + uint32_t x1525; + fiat_p384_scalar_uint1 x1526; + uint32_t x1527; + fiat_p384_scalar_uint1 x1528; + uint32_t x1529; + fiat_p384_scalar_uint1 x1530; + uint32_t x1531; + fiat_p384_scalar_uint1 x1532; + uint32_t x1533; + fiat_p384_scalar_uint1 x1534; + uint32_t x1535; + fiat_p384_scalar_uint1 x1536; + uint32_t x1537; + fiat_p384_scalar_uint1 x1538; + uint32_t x1539; + fiat_p384_scalar_uint1 x1540; + uint32_t x1541; + fiat_p384_scalar_uint1 x1542; + uint32_t x1543; + fiat_p384_scalar_uint1 x1544; + uint32_t x1545; + fiat_p384_scalar_uint1 x1546; + uint32_t x1547; + fiat_p384_scalar_uint1 x1548; + uint32_t x1549; + uint32_t x1550; + uint32_t x1551; + uint32_t x1552; + uint32_t x1553; + uint32_t x1554; + uint32_t x1555; + uint32_t x1556; + uint32_t x1557; + uint32_t x1558; + uint32_t x1559; + uint32_t x1560; + uint32_t x1561; + uint32_t x1562; + uint32_t x1563; + uint32_t x1564; + uint32_t x1565; + uint32_t x1566; + uint32_t x1567; + uint32_t x1568; + uint32_t x1569; + uint32_t x1570; + uint32_t x1571; + uint32_t x1572; + uint32_t x1573; + uint32_t x1574; + uint32_t x1575; + fiat_p384_scalar_uint1 x1576; + uint32_t x1577; + fiat_p384_scalar_uint1 x1578; + uint32_t x1579; + fiat_p384_scalar_uint1 x1580; + uint32_t x1581; + fiat_p384_scalar_uint1 x1582; + uint32_t x1583; + fiat_p384_scalar_uint1 x1584; + uint32_t x1585; + fiat_p384_scalar_uint1 x1586; + uint32_t x1587; + fiat_p384_scalar_uint1 x1588; + uint32_t x1589; + fiat_p384_scalar_uint1 x1590; + uint32_t x1591; + fiat_p384_scalar_uint1 x1592; + uint32_t x1593; + fiat_p384_scalar_uint1 x1594; + uint32_t x1595; + fiat_p384_scalar_uint1 x1596; + uint32_t x1597; + uint32_t x1598; + fiat_p384_scalar_uint1 x1599; + uint32_t x1600; + fiat_p384_scalar_uint1 x1601; + uint32_t x1602; + fiat_p384_scalar_uint1 x1603; + uint32_t x1604; + fiat_p384_scalar_uint1 x1605; + uint32_t x1606; + fiat_p384_scalar_uint1 x1607; + uint32_t x1608; + fiat_p384_scalar_uint1 x1609; + uint32_t x1610; + fiat_p384_scalar_uint1 x1611; + uint32_t x1612; + fiat_p384_scalar_uint1 x1613; + uint32_t x1614; + fiat_p384_scalar_uint1 x1615; + uint32_t x1616; + fiat_p384_scalar_uint1 x1617; + uint32_t x1618; + fiat_p384_scalar_uint1 x1619; + uint32_t x1620; + fiat_p384_scalar_uint1 x1621; + uint32_t x1622; + fiat_p384_scalar_uint1 x1623; + uint32_t x1624; + uint32_t x1625; + uint32_t x1626; + uint32_t x1627; + uint32_t x1628; + uint32_t x1629; + uint32_t x1630; + uint32_t x1631; + uint32_t x1632; + uint32_t x1633; + uint32_t x1634; + uint32_t x1635; + uint32_t x1636; + uint32_t x1637; + uint32_t x1638; + uint32_t x1639; + uint32_t x1640; + uint32_t x1641; + uint32_t x1642; + uint32_t x1643; + uint32_t x1644; + uint32_t x1645; + uint32_t x1646; + uint32_t x1647; + uint32_t x1648; + uint32_t x1649; + fiat_p384_scalar_uint1 x1650; + uint32_t x1651; + fiat_p384_scalar_uint1 x1652; + uint32_t x1653; + fiat_p384_scalar_uint1 x1654; + uint32_t x1655; + fiat_p384_scalar_uint1 x1656; + uint32_t x1657; + fiat_p384_scalar_uint1 x1658; + uint32_t x1659; + fiat_p384_scalar_uint1 x1660; + uint32_t x1661; + fiat_p384_scalar_uint1 x1662; + uint32_t x1663; + fiat_p384_scalar_uint1 x1664; + uint32_t x1665; + fiat_p384_scalar_uint1 x1666; + uint32_t x1667; + fiat_p384_scalar_uint1 x1668; + uint32_t x1669; + fiat_p384_scalar_uint1 x1670; + uint32_t x1671; + uint32_t x1672; + fiat_p384_scalar_uint1 x1673; + uint32_t x1674; + fiat_p384_scalar_uint1 x1675; + uint32_t x1676; + fiat_p384_scalar_uint1 x1677; + uint32_t x1678; + fiat_p384_scalar_uint1 x1679; + uint32_t x1680; + fiat_p384_scalar_uint1 x1681; + uint32_t x1682; + fiat_p384_scalar_uint1 x1683; + uint32_t x1684; + fiat_p384_scalar_uint1 x1685; + uint32_t x1686; + fiat_p384_scalar_uint1 x1687; + uint32_t x1688; + fiat_p384_scalar_uint1 x1689; + uint32_t x1690; + fiat_p384_scalar_uint1 x1691; + uint32_t x1692; + fiat_p384_scalar_uint1 x1693; + uint32_t x1694; + fiat_p384_scalar_uint1 x1695; + uint32_t x1696; + fiat_p384_scalar_uint1 x1697; + uint32_t x1698; + uint32_t x1699; + uint32_t x1700; + uint32_t x1701; + uint32_t x1702; + uint32_t x1703; + uint32_t x1704; + uint32_t x1705; + uint32_t x1706; + uint32_t x1707; + uint32_t x1708; + uint32_t x1709; + uint32_t x1710; + uint32_t x1711; + uint32_t x1712; + uint32_t x1713; + uint32_t x1714; + uint32_t x1715; + uint32_t x1716; + uint32_t x1717; + uint32_t x1718; + uint32_t x1719; + uint32_t x1720; + uint32_t x1721; + uint32_t x1722; + uint32_t x1723; + uint32_t x1724; + fiat_p384_scalar_uint1 x1725; + uint32_t x1726; + fiat_p384_scalar_uint1 x1727; + uint32_t x1728; + fiat_p384_scalar_uint1 x1729; + uint32_t x1730; + fiat_p384_scalar_uint1 x1731; + uint32_t x1732; + fiat_p384_scalar_uint1 x1733; + uint32_t x1734; + fiat_p384_scalar_uint1 x1735; + uint32_t x1736; + fiat_p384_scalar_uint1 x1737; + uint32_t x1738; + fiat_p384_scalar_uint1 x1739; + uint32_t x1740; + fiat_p384_scalar_uint1 x1741; + uint32_t x1742; + fiat_p384_scalar_uint1 x1743; + uint32_t x1744; + fiat_p384_scalar_uint1 x1745; + uint32_t x1746; + uint32_t x1747; + fiat_p384_scalar_uint1 x1748; + uint32_t x1749; + fiat_p384_scalar_uint1 x1750; + uint32_t x1751; + fiat_p384_scalar_uint1 x1752; + uint32_t x1753; + fiat_p384_scalar_uint1 x1754; + uint32_t x1755; + fiat_p384_scalar_uint1 x1756; + uint32_t x1757; + fiat_p384_scalar_uint1 x1758; + uint32_t x1759; + fiat_p384_scalar_uint1 x1760; + uint32_t x1761; + fiat_p384_scalar_uint1 x1762; + uint32_t x1763; + fiat_p384_scalar_uint1 x1764; + uint32_t x1765; + fiat_p384_scalar_uint1 x1766; + uint32_t x1767; + fiat_p384_scalar_uint1 x1768; + uint32_t x1769; + fiat_p384_scalar_uint1 x1770; + uint32_t x1771; + fiat_p384_scalar_uint1 x1772; + uint32_t x1773; + uint32_t x1774; + fiat_p384_scalar_uint1 x1775; + uint32_t x1776; + fiat_p384_scalar_uint1 x1777; + uint32_t x1778; + fiat_p384_scalar_uint1 x1779; + uint32_t x1780; + fiat_p384_scalar_uint1 x1781; + uint32_t x1782; + fiat_p384_scalar_uint1 x1783; + uint32_t x1784; + fiat_p384_scalar_uint1 x1785; + uint32_t x1786; + fiat_p384_scalar_uint1 x1787; + uint32_t x1788; + fiat_p384_scalar_uint1 x1789; + uint32_t x1790; + fiat_p384_scalar_uint1 x1791; + uint32_t x1792; + fiat_p384_scalar_uint1 x1793; + uint32_t x1794; + fiat_p384_scalar_uint1 x1795; + uint32_t x1796; + fiat_p384_scalar_uint1 x1797; + uint32_t x1798; + fiat_p384_scalar_uint1 x1799; + uint32_t x1800; + uint32_t x1801; + uint32_t x1802; + uint32_t x1803; + uint32_t x1804; + uint32_t x1805; + uint32_t x1806; + uint32_t x1807; + uint32_t x1808; + uint32_t x1809; + uint32_t x1810; + uint32_t x1811; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[6]); + x7 = (arg1[7]); + x8 = (arg1[8]); + x9 = (arg1[9]); + x10 = (arg1[10]); + x11 = (arg1[11]); + x12 = (arg1[0]); + fiat_p384_scalar_mulx_u32(&x13, &x14, x12, (arg1[11])); + fiat_p384_scalar_mulx_u32(&x15, &x16, x12, (arg1[10])); + fiat_p384_scalar_mulx_u32(&x17, &x18, x12, (arg1[9])); + fiat_p384_scalar_mulx_u32(&x19, &x20, x12, (arg1[8])); + fiat_p384_scalar_mulx_u32(&x21, &x22, x12, (arg1[7])); + fiat_p384_scalar_mulx_u32(&x23, &x24, x12, (arg1[6])); + fiat_p384_scalar_mulx_u32(&x25, &x26, x12, (arg1[5])); + fiat_p384_scalar_mulx_u32(&x27, &x28, x12, (arg1[4])); + fiat_p384_scalar_mulx_u32(&x29, &x30, x12, (arg1[3])); + fiat_p384_scalar_mulx_u32(&x31, &x32, x12, (arg1[2])); + fiat_p384_scalar_mulx_u32(&x33, &x34, x12, (arg1[1])); + fiat_p384_scalar_mulx_u32(&x35, &x36, x12, (arg1[0])); + fiat_p384_scalar_addcarryx_u32(&x37, &x38, 0x0, x36, x33); + fiat_p384_scalar_addcarryx_u32(&x39, &x40, x38, x34, x31); + fiat_p384_scalar_addcarryx_u32(&x41, &x42, x40, x32, x29); + fiat_p384_scalar_addcarryx_u32(&x43, &x44, x42, x30, x27); + fiat_p384_scalar_addcarryx_u32(&x45, &x46, x44, x28, x25); + fiat_p384_scalar_addcarryx_u32(&x47, &x48, x46, x26, x23); + fiat_p384_scalar_addcarryx_u32(&x49, &x50, x48, x24, x21); + fiat_p384_scalar_addcarryx_u32(&x51, &x52, x50, x22, x19); + fiat_p384_scalar_addcarryx_u32(&x53, &x54, x52, x20, x17); + fiat_p384_scalar_addcarryx_u32(&x55, &x56, x54, x18, x15); + fiat_p384_scalar_addcarryx_u32(&x57, &x58, x56, x16, x13); + x59 = (x58 + x14); + fiat_p384_scalar_mulx_u32(&x60, &x61, x35, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x62, &x63, x60, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x64, &x65, x60, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x66, &x67, x60, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x68, &x69, x60, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x70, &x71, x60, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x72, &x73, x60, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x74, &x75, x60, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x76, &x77, x60, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x78, &x79, x60, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x80, &x81, x60, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x82, &x83, x60, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x84, &x85, x60, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x86, &x87, 0x0, x85, x82); + fiat_p384_scalar_addcarryx_u32(&x88, &x89, x87, x83, x80); + fiat_p384_scalar_addcarryx_u32(&x90, &x91, x89, x81, x78); + fiat_p384_scalar_addcarryx_u32(&x92, &x93, x91, x79, x76); + fiat_p384_scalar_addcarryx_u32(&x94, &x95, x93, x77, x74); + fiat_p384_scalar_addcarryx_u32(&x96, &x97, x95, x75, x72); + fiat_p384_scalar_addcarryx_u32(&x98, &x99, x97, x73, x70); + fiat_p384_scalar_addcarryx_u32(&x100, &x101, x99, x71, x68); + fiat_p384_scalar_addcarryx_u32(&x102, &x103, x101, x69, x66); + fiat_p384_scalar_addcarryx_u32(&x104, &x105, x103, x67, x64); + fiat_p384_scalar_addcarryx_u32(&x106, &x107, x105, x65, x62); + x108 = (x107 + x63); + fiat_p384_scalar_addcarryx_u32(&x109, &x110, 0x0, x35, x84); + fiat_p384_scalar_addcarryx_u32(&x111, &x112, x110, x37, x86); + fiat_p384_scalar_addcarryx_u32(&x113, &x114, x112, x39, x88); + fiat_p384_scalar_addcarryx_u32(&x115, &x116, x114, x41, x90); + fiat_p384_scalar_addcarryx_u32(&x117, &x118, x116, x43, x92); + fiat_p384_scalar_addcarryx_u32(&x119, &x120, x118, x45, x94); + fiat_p384_scalar_addcarryx_u32(&x121, &x122, x120, x47, x96); + fiat_p384_scalar_addcarryx_u32(&x123, &x124, x122, x49, x98); + fiat_p384_scalar_addcarryx_u32(&x125, &x126, x124, x51, x100); + fiat_p384_scalar_addcarryx_u32(&x127, &x128, x126, x53, x102); + fiat_p384_scalar_addcarryx_u32(&x129, &x130, x128, x55, x104); + fiat_p384_scalar_addcarryx_u32(&x131, &x132, x130, x57, x106); + fiat_p384_scalar_addcarryx_u32(&x133, &x134, x132, x59, x108); + fiat_p384_scalar_mulx_u32(&x135, &x136, x1, (arg1[11])); + fiat_p384_scalar_mulx_u32(&x137, &x138, x1, (arg1[10])); + fiat_p384_scalar_mulx_u32(&x139, &x140, x1, (arg1[9])); + fiat_p384_scalar_mulx_u32(&x141, &x142, x1, (arg1[8])); + fiat_p384_scalar_mulx_u32(&x143, &x144, x1, (arg1[7])); + fiat_p384_scalar_mulx_u32(&x145, &x146, x1, (arg1[6])); + fiat_p384_scalar_mulx_u32(&x147, &x148, x1, (arg1[5])); + fiat_p384_scalar_mulx_u32(&x149, &x150, x1, (arg1[4])); + fiat_p384_scalar_mulx_u32(&x151, &x152, x1, (arg1[3])); + fiat_p384_scalar_mulx_u32(&x153, &x154, x1, (arg1[2])); + fiat_p384_scalar_mulx_u32(&x155, &x156, x1, (arg1[1])); + fiat_p384_scalar_mulx_u32(&x157, &x158, x1, (arg1[0])); + fiat_p384_scalar_addcarryx_u32(&x159, &x160, 0x0, x158, x155); + fiat_p384_scalar_addcarryx_u32(&x161, &x162, x160, x156, x153); + fiat_p384_scalar_addcarryx_u32(&x163, &x164, x162, x154, x151); + fiat_p384_scalar_addcarryx_u32(&x165, &x166, x164, x152, x149); + fiat_p384_scalar_addcarryx_u32(&x167, &x168, x166, x150, x147); + fiat_p384_scalar_addcarryx_u32(&x169, &x170, x168, x148, x145); + fiat_p384_scalar_addcarryx_u32(&x171, &x172, x170, x146, x143); + fiat_p384_scalar_addcarryx_u32(&x173, &x174, x172, x144, x141); + fiat_p384_scalar_addcarryx_u32(&x175, &x176, x174, x142, x139); + fiat_p384_scalar_addcarryx_u32(&x177, &x178, x176, x140, x137); + fiat_p384_scalar_addcarryx_u32(&x179, &x180, x178, x138, x135); + x181 = (x180 + x136); + fiat_p384_scalar_addcarryx_u32(&x182, &x183, 0x0, x111, x157); + fiat_p384_scalar_addcarryx_u32(&x184, &x185, x183, x113, x159); + fiat_p384_scalar_addcarryx_u32(&x186, &x187, x185, x115, x161); + fiat_p384_scalar_addcarryx_u32(&x188, &x189, x187, x117, x163); + fiat_p384_scalar_addcarryx_u32(&x190, &x191, x189, x119, x165); + fiat_p384_scalar_addcarryx_u32(&x192, &x193, x191, x121, x167); + fiat_p384_scalar_addcarryx_u32(&x194, &x195, x193, x123, x169); + fiat_p384_scalar_addcarryx_u32(&x196, &x197, x195, x125, x171); + fiat_p384_scalar_addcarryx_u32(&x198, &x199, x197, x127, x173); + fiat_p384_scalar_addcarryx_u32(&x200, &x201, x199, x129, x175); + fiat_p384_scalar_addcarryx_u32(&x202, &x203, x201, x131, x177); + fiat_p384_scalar_addcarryx_u32(&x204, &x205, x203, x133, x179); + fiat_p384_scalar_addcarryx_u32(&x206, &x207, x205, x134, x181); + fiat_p384_scalar_mulx_u32(&x208, &x209, x182, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x210, &x211, x208, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x212, &x213, x208, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x214, &x215, x208, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x216, &x217, x208, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x218, &x219, x208, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x220, &x221, x208, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x222, &x223, x208, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x224, &x225, x208, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x226, &x227, x208, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x228, &x229, x208, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x230, &x231, x208, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x232, &x233, x208, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x234, &x235, 0x0, x233, x230); + fiat_p384_scalar_addcarryx_u32(&x236, &x237, x235, x231, x228); + fiat_p384_scalar_addcarryx_u32(&x238, &x239, x237, x229, x226); + fiat_p384_scalar_addcarryx_u32(&x240, &x241, x239, x227, x224); + fiat_p384_scalar_addcarryx_u32(&x242, &x243, x241, x225, x222); + fiat_p384_scalar_addcarryx_u32(&x244, &x245, x243, x223, x220); + fiat_p384_scalar_addcarryx_u32(&x246, &x247, x245, x221, x218); + fiat_p384_scalar_addcarryx_u32(&x248, &x249, x247, x219, x216); + fiat_p384_scalar_addcarryx_u32(&x250, &x251, x249, x217, x214); + fiat_p384_scalar_addcarryx_u32(&x252, &x253, x251, x215, x212); + fiat_p384_scalar_addcarryx_u32(&x254, &x255, x253, x213, x210); + x256 = (x255 + x211); + fiat_p384_scalar_addcarryx_u32(&x257, &x258, 0x0, x182, x232); + fiat_p384_scalar_addcarryx_u32(&x259, &x260, x258, x184, x234); + fiat_p384_scalar_addcarryx_u32(&x261, &x262, x260, x186, x236); + fiat_p384_scalar_addcarryx_u32(&x263, &x264, x262, x188, x238); + fiat_p384_scalar_addcarryx_u32(&x265, &x266, x264, x190, x240); + fiat_p384_scalar_addcarryx_u32(&x267, &x268, x266, x192, x242); + fiat_p384_scalar_addcarryx_u32(&x269, &x270, x268, x194, x244); + fiat_p384_scalar_addcarryx_u32(&x271, &x272, x270, x196, x246); + fiat_p384_scalar_addcarryx_u32(&x273, &x274, x272, x198, x248); + fiat_p384_scalar_addcarryx_u32(&x275, &x276, x274, x200, x250); + fiat_p384_scalar_addcarryx_u32(&x277, &x278, x276, x202, x252); + fiat_p384_scalar_addcarryx_u32(&x279, &x280, x278, x204, x254); + fiat_p384_scalar_addcarryx_u32(&x281, &x282, x280, x206, x256); + x283 = ((uint32_t)x282 + x207); + fiat_p384_scalar_mulx_u32(&x284, &x285, x2, (arg1[11])); + fiat_p384_scalar_mulx_u32(&x286, &x287, x2, (arg1[10])); + fiat_p384_scalar_mulx_u32(&x288, &x289, x2, (arg1[9])); + fiat_p384_scalar_mulx_u32(&x290, &x291, x2, (arg1[8])); + fiat_p384_scalar_mulx_u32(&x292, &x293, x2, (arg1[7])); + fiat_p384_scalar_mulx_u32(&x294, &x295, x2, (arg1[6])); + fiat_p384_scalar_mulx_u32(&x296, &x297, x2, (arg1[5])); + fiat_p384_scalar_mulx_u32(&x298, &x299, x2, (arg1[4])); + fiat_p384_scalar_mulx_u32(&x300, &x301, x2, (arg1[3])); + fiat_p384_scalar_mulx_u32(&x302, &x303, x2, (arg1[2])); + fiat_p384_scalar_mulx_u32(&x304, &x305, x2, (arg1[1])); + fiat_p384_scalar_mulx_u32(&x306, &x307, x2, (arg1[0])); + fiat_p384_scalar_addcarryx_u32(&x308, &x309, 0x0, x307, x304); + fiat_p384_scalar_addcarryx_u32(&x310, &x311, x309, x305, x302); + fiat_p384_scalar_addcarryx_u32(&x312, &x313, x311, x303, x300); + fiat_p384_scalar_addcarryx_u32(&x314, &x315, x313, x301, x298); + fiat_p384_scalar_addcarryx_u32(&x316, &x317, x315, x299, x296); + fiat_p384_scalar_addcarryx_u32(&x318, &x319, x317, x297, x294); + fiat_p384_scalar_addcarryx_u32(&x320, &x321, x319, x295, x292); + fiat_p384_scalar_addcarryx_u32(&x322, &x323, x321, x293, x290); + fiat_p384_scalar_addcarryx_u32(&x324, &x325, x323, x291, x288); + fiat_p384_scalar_addcarryx_u32(&x326, &x327, x325, x289, x286); + fiat_p384_scalar_addcarryx_u32(&x328, &x329, x327, x287, x284); + x330 = (x329 + x285); + fiat_p384_scalar_addcarryx_u32(&x331, &x332, 0x0, x259, x306); + fiat_p384_scalar_addcarryx_u32(&x333, &x334, x332, x261, x308); + fiat_p384_scalar_addcarryx_u32(&x335, &x336, x334, x263, x310); + fiat_p384_scalar_addcarryx_u32(&x337, &x338, x336, x265, x312); + fiat_p384_scalar_addcarryx_u32(&x339, &x340, x338, x267, x314); + fiat_p384_scalar_addcarryx_u32(&x341, &x342, x340, x269, x316); + fiat_p384_scalar_addcarryx_u32(&x343, &x344, x342, x271, x318); + fiat_p384_scalar_addcarryx_u32(&x345, &x346, x344, x273, x320); + fiat_p384_scalar_addcarryx_u32(&x347, &x348, x346, x275, x322); + fiat_p384_scalar_addcarryx_u32(&x349, &x350, x348, x277, x324); + fiat_p384_scalar_addcarryx_u32(&x351, &x352, x350, x279, x326); + fiat_p384_scalar_addcarryx_u32(&x353, &x354, x352, x281, x328); + fiat_p384_scalar_addcarryx_u32(&x355, &x356, x354, x283, x330); + fiat_p384_scalar_mulx_u32(&x357, &x358, x331, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x359, &x360, x357, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x361, &x362, x357, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x363, &x364, x357, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x365, &x366, x357, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x367, &x368, x357, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x369, &x370, x357, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x371, &x372, x357, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x373, &x374, x357, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x375, &x376, x357, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x377, &x378, x357, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x379, &x380, x357, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x381, &x382, x357, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x383, &x384, 0x0, x382, x379); + fiat_p384_scalar_addcarryx_u32(&x385, &x386, x384, x380, x377); + fiat_p384_scalar_addcarryx_u32(&x387, &x388, x386, x378, x375); + fiat_p384_scalar_addcarryx_u32(&x389, &x390, x388, x376, x373); + fiat_p384_scalar_addcarryx_u32(&x391, &x392, x390, x374, x371); + fiat_p384_scalar_addcarryx_u32(&x393, &x394, x392, x372, x369); + fiat_p384_scalar_addcarryx_u32(&x395, &x396, x394, x370, x367); + fiat_p384_scalar_addcarryx_u32(&x397, &x398, x396, x368, x365); + fiat_p384_scalar_addcarryx_u32(&x399, &x400, x398, x366, x363); + fiat_p384_scalar_addcarryx_u32(&x401, &x402, x400, x364, x361); + fiat_p384_scalar_addcarryx_u32(&x403, &x404, x402, x362, x359); + x405 = (x404 + x360); + fiat_p384_scalar_addcarryx_u32(&x406, &x407, 0x0, x331, x381); + fiat_p384_scalar_addcarryx_u32(&x408, &x409, x407, x333, x383); + fiat_p384_scalar_addcarryx_u32(&x410, &x411, x409, x335, x385); + fiat_p384_scalar_addcarryx_u32(&x412, &x413, x411, x337, x387); + fiat_p384_scalar_addcarryx_u32(&x414, &x415, x413, x339, x389); + fiat_p384_scalar_addcarryx_u32(&x416, &x417, x415, x341, x391); + fiat_p384_scalar_addcarryx_u32(&x418, &x419, x417, x343, x393); + fiat_p384_scalar_addcarryx_u32(&x420, &x421, x419, x345, x395); + fiat_p384_scalar_addcarryx_u32(&x422, &x423, x421, x347, x397); + fiat_p384_scalar_addcarryx_u32(&x424, &x425, x423, x349, x399); + fiat_p384_scalar_addcarryx_u32(&x426, &x427, x425, x351, x401); + fiat_p384_scalar_addcarryx_u32(&x428, &x429, x427, x353, x403); + fiat_p384_scalar_addcarryx_u32(&x430, &x431, x429, x355, x405); + x432 = ((uint32_t)x431 + x356); + fiat_p384_scalar_mulx_u32(&x433, &x434, x3, (arg1[11])); + fiat_p384_scalar_mulx_u32(&x435, &x436, x3, (arg1[10])); + fiat_p384_scalar_mulx_u32(&x437, &x438, x3, (arg1[9])); + fiat_p384_scalar_mulx_u32(&x439, &x440, x3, (arg1[8])); + fiat_p384_scalar_mulx_u32(&x441, &x442, x3, (arg1[7])); + fiat_p384_scalar_mulx_u32(&x443, &x444, x3, (arg1[6])); + fiat_p384_scalar_mulx_u32(&x445, &x446, x3, (arg1[5])); + fiat_p384_scalar_mulx_u32(&x447, &x448, x3, (arg1[4])); + fiat_p384_scalar_mulx_u32(&x449, &x450, x3, (arg1[3])); + fiat_p384_scalar_mulx_u32(&x451, &x452, x3, (arg1[2])); + fiat_p384_scalar_mulx_u32(&x453, &x454, x3, (arg1[1])); + fiat_p384_scalar_mulx_u32(&x455, &x456, x3, (arg1[0])); + fiat_p384_scalar_addcarryx_u32(&x457, &x458, 0x0, x456, x453); + fiat_p384_scalar_addcarryx_u32(&x459, &x460, x458, x454, x451); + fiat_p384_scalar_addcarryx_u32(&x461, &x462, x460, x452, x449); + fiat_p384_scalar_addcarryx_u32(&x463, &x464, x462, x450, x447); + fiat_p384_scalar_addcarryx_u32(&x465, &x466, x464, x448, x445); + fiat_p384_scalar_addcarryx_u32(&x467, &x468, x466, x446, x443); + fiat_p384_scalar_addcarryx_u32(&x469, &x470, x468, x444, x441); + fiat_p384_scalar_addcarryx_u32(&x471, &x472, x470, x442, x439); + fiat_p384_scalar_addcarryx_u32(&x473, &x474, x472, x440, x437); + fiat_p384_scalar_addcarryx_u32(&x475, &x476, x474, x438, x435); + fiat_p384_scalar_addcarryx_u32(&x477, &x478, x476, x436, x433); + x479 = (x478 + x434); + fiat_p384_scalar_addcarryx_u32(&x480, &x481, 0x0, x408, x455); + fiat_p384_scalar_addcarryx_u32(&x482, &x483, x481, x410, x457); + fiat_p384_scalar_addcarryx_u32(&x484, &x485, x483, x412, x459); + fiat_p384_scalar_addcarryx_u32(&x486, &x487, x485, x414, x461); + fiat_p384_scalar_addcarryx_u32(&x488, &x489, x487, x416, x463); + fiat_p384_scalar_addcarryx_u32(&x490, &x491, x489, x418, x465); + fiat_p384_scalar_addcarryx_u32(&x492, &x493, x491, x420, x467); + fiat_p384_scalar_addcarryx_u32(&x494, &x495, x493, x422, x469); + fiat_p384_scalar_addcarryx_u32(&x496, &x497, x495, x424, x471); + fiat_p384_scalar_addcarryx_u32(&x498, &x499, x497, x426, x473); + fiat_p384_scalar_addcarryx_u32(&x500, &x501, x499, x428, x475); + fiat_p384_scalar_addcarryx_u32(&x502, &x503, x501, x430, x477); + fiat_p384_scalar_addcarryx_u32(&x504, &x505, x503, x432, x479); + fiat_p384_scalar_mulx_u32(&x506, &x507, x480, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x508, &x509, x506, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x510, &x511, x506, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x512, &x513, x506, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x514, &x515, x506, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x516, &x517, x506, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x518, &x519, x506, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x520, &x521, x506, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x522, &x523, x506, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x524, &x525, x506, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x526, &x527, x506, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x528, &x529, x506, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x530, &x531, x506, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x532, &x533, 0x0, x531, x528); + fiat_p384_scalar_addcarryx_u32(&x534, &x535, x533, x529, x526); + fiat_p384_scalar_addcarryx_u32(&x536, &x537, x535, x527, x524); + fiat_p384_scalar_addcarryx_u32(&x538, &x539, x537, x525, x522); + fiat_p384_scalar_addcarryx_u32(&x540, &x541, x539, x523, x520); + fiat_p384_scalar_addcarryx_u32(&x542, &x543, x541, x521, x518); + fiat_p384_scalar_addcarryx_u32(&x544, &x545, x543, x519, x516); + fiat_p384_scalar_addcarryx_u32(&x546, &x547, x545, x517, x514); + fiat_p384_scalar_addcarryx_u32(&x548, &x549, x547, x515, x512); + fiat_p384_scalar_addcarryx_u32(&x550, &x551, x549, x513, x510); + fiat_p384_scalar_addcarryx_u32(&x552, &x553, x551, x511, x508); + x554 = (x553 + x509); + fiat_p384_scalar_addcarryx_u32(&x555, &x556, 0x0, x480, x530); + fiat_p384_scalar_addcarryx_u32(&x557, &x558, x556, x482, x532); + fiat_p384_scalar_addcarryx_u32(&x559, &x560, x558, x484, x534); + fiat_p384_scalar_addcarryx_u32(&x561, &x562, x560, x486, x536); + fiat_p384_scalar_addcarryx_u32(&x563, &x564, x562, x488, x538); + fiat_p384_scalar_addcarryx_u32(&x565, &x566, x564, x490, x540); + fiat_p384_scalar_addcarryx_u32(&x567, &x568, x566, x492, x542); + fiat_p384_scalar_addcarryx_u32(&x569, &x570, x568, x494, x544); + fiat_p384_scalar_addcarryx_u32(&x571, &x572, x570, x496, x546); + fiat_p384_scalar_addcarryx_u32(&x573, &x574, x572, x498, x548); + fiat_p384_scalar_addcarryx_u32(&x575, &x576, x574, x500, x550); + fiat_p384_scalar_addcarryx_u32(&x577, &x578, x576, x502, x552); + fiat_p384_scalar_addcarryx_u32(&x579, &x580, x578, x504, x554); + x581 = ((uint32_t)x580 + x505); + fiat_p384_scalar_mulx_u32(&x582, &x583, x4, (arg1[11])); + fiat_p384_scalar_mulx_u32(&x584, &x585, x4, (arg1[10])); + fiat_p384_scalar_mulx_u32(&x586, &x587, x4, (arg1[9])); + fiat_p384_scalar_mulx_u32(&x588, &x589, x4, (arg1[8])); + fiat_p384_scalar_mulx_u32(&x590, &x591, x4, (arg1[7])); + fiat_p384_scalar_mulx_u32(&x592, &x593, x4, (arg1[6])); + fiat_p384_scalar_mulx_u32(&x594, &x595, x4, (arg1[5])); + fiat_p384_scalar_mulx_u32(&x596, &x597, x4, (arg1[4])); + fiat_p384_scalar_mulx_u32(&x598, &x599, x4, (arg1[3])); + fiat_p384_scalar_mulx_u32(&x600, &x601, x4, (arg1[2])); + fiat_p384_scalar_mulx_u32(&x602, &x603, x4, (arg1[1])); + fiat_p384_scalar_mulx_u32(&x604, &x605, x4, (arg1[0])); + fiat_p384_scalar_addcarryx_u32(&x606, &x607, 0x0, x605, x602); + fiat_p384_scalar_addcarryx_u32(&x608, &x609, x607, x603, x600); + fiat_p384_scalar_addcarryx_u32(&x610, &x611, x609, x601, x598); + fiat_p384_scalar_addcarryx_u32(&x612, &x613, x611, x599, x596); + fiat_p384_scalar_addcarryx_u32(&x614, &x615, x613, x597, x594); + fiat_p384_scalar_addcarryx_u32(&x616, &x617, x615, x595, x592); + fiat_p384_scalar_addcarryx_u32(&x618, &x619, x617, x593, x590); + fiat_p384_scalar_addcarryx_u32(&x620, &x621, x619, x591, x588); + fiat_p384_scalar_addcarryx_u32(&x622, &x623, x621, x589, x586); + fiat_p384_scalar_addcarryx_u32(&x624, &x625, x623, x587, x584); + fiat_p384_scalar_addcarryx_u32(&x626, &x627, x625, x585, x582); + x628 = (x627 + x583); + fiat_p384_scalar_addcarryx_u32(&x629, &x630, 0x0, x557, x604); + fiat_p384_scalar_addcarryx_u32(&x631, &x632, x630, x559, x606); + fiat_p384_scalar_addcarryx_u32(&x633, &x634, x632, x561, x608); + fiat_p384_scalar_addcarryx_u32(&x635, &x636, x634, x563, x610); + fiat_p384_scalar_addcarryx_u32(&x637, &x638, x636, x565, x612); + fiat_p384_scalar_addcarryx_u32(&x639, &x640, x638, x567, x614); + fiat_p384_scalar_addcarryx_u32(&x641, &x642, x640, x569, x616); + fiat_p384_scalar_addcarryx_u32(&x643, &x644, x642, x571, x618); + fiat_p384_scalar_addcarryx_u32(&x645, &x646, x644, x573, x620); + fiat_p384_scalar_addcarryx_u32(&x647, &x648, x646, x575, x622); + fiat_p384_scalar_addcarryx_u32(&x649, &x650, x648, x577, x624); + fiat_p384_scalar_addcarryx_u32(&x651, &x652, x650, x579, x626); + fiat_p384_scalar_addcarryx_u32(&x653, &x654, x652, x581, x628); + fiat_p384_scalar_mulx_u32(&x655, &x656, x629, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x657, &x658, x655, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x659, &x660, x655, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x661, &x662, x655, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x663, &x664, x655, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x665, &x666, x655, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x667, &x668, x655, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x669, &x670, x655, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x671, &x672, x655, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x673, &x674, x655, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x675, &x676, x655, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x677, &x678, x655, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x679, &x680, x655, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x681, &x682, 0x0, x680, x677); + fiat_p384_scalar_addcarryx_u32(&x683, &x684, x682, x678, x675); + fiat_p384_scalar_addcarryx_u32(&x685, &x686, x684, x676, x673); + fiat_p384_scalar_addcarryx_u32(&x687, &x688, x686, x674, x671); + fiat_p384_scalar_addcarryx_u32(&x689, &x690, x688, x672, x669); + fiat_p384_scalar_addcarryx_u32(&x691, &x692, x690, x670, x667); + fiat_p384_scalar_addcarryx_u32(&x693, &x694, x692, x668, x665); + fiat_p384_scalar_addcarryx_u32(&x695, &x696, x694, x666, x663); + fiat_p384_scalar_addcarryx_u32(&x697, &x698, x696, x664, x661); + fiat_p384_scalar_addcarryx_u32(&x699, &x700, x698, x662, x659); + fiat_p384_scalar_addcarryx_u32(&x701, &x702, x700, x660, x657); + x703 = (x702 + x658); + fiat_p384_scalar_addcarryx_u32(&x704, &x705, 0x0, x629, x679); + fiat_p384_scalar_addcarryx_u32(&x706, &x707, x705, x631, x681); + fiat_p384_scalar_addcarryx_u32(&x708, &x709, x707, x633, x683); + fiat_p384_scalar_addcarryx_u32(&x710, &x711, x709, x635, x685); + fiat_p384_scalar_addcarryx_u32(&x712, &x713, x711, x637, x687); + fiat_p384_scalar_addcarryx_u32(&x714, &x715, x713, x639, x689); + fiat_p384_scalar_addcarryx_u32(&x716, &x717, x715, x641, x691); + fiat_p384_scalar_addcarryx_u32(&x718, &x719, x717, x643, x693); + fiat_p384_scalar_addcarryx_u32(&x720, &x721, x719, x645, x695); + fiat_p384_scalar_addcarryx_u32(&x722, &x723, x721, x647, x697); + fiat_p384_scalar_addcarryx_u32(&x724, &x725, x723, x649, x699); + fiat_p384_scalar_addcarryx_u32(&x726, &x727, x725, x651, x701); + fiat_p384_scalar_addcarryx_u32(&x728, &x729, x727, x653, x703); + x730 = ((uint32_t)x729 + x654); + fiat_p384_scalar_mulx_u32(&x731, &x732, x5, (arg1[11])); + fiat_p384_scalar_mulx_u32(&x733, &x734, x5, (arg1[10])); + fiat_p384_scalar_mulx_u32(&x735, &x736, x5, (arg1[9])); + fiat_p384_scalar_mulx_u32(&x737, &x738, x5, (arg1[8])); + fiat_p384_scalar_mulx_u32(&x739, &x740, x5, (arg1[7])); + fiat_p384_scalar_mulx_u32(&x741, &x742, x5, (arg1[6])); + fiat_p384_scalar_mulx_u32(&x743, &x744, x5, (arg1[5])); + fiat_p384_scalar_mulx_u32(&x745, &x746, x5, (arg1[4])); + fiat_p384_scalar_mulx_u32(&x747, &x748, x5, (arg1[3])); + fiat_p384_scalar_mulx_u32(&x749, &x750, x5, (arg1[2])); + fiat_p384_scalar_mulx_u32(&x751, &x752, x5, (arg1[1])); + fiat_p384_scalar_mulx_u32(&x753, &x754, x5, (arg1[0])); + fiat_p384_scalar_addcarryx_u32(&x755, &x756, 0x0, x754, x751); + fiat_p384_scalar_addcarryx_u32(&x757, &x758, x756, x752, x749); + fiat_p384_scalar_addcarryx_u32(&x759, &x760, x758, x750, x747); + fiat_p384_scalar_addcarryx_u32(&x761, &x762, x760, x748, x745); + fiat_p384_scalar_addcarryx_u32(&x763, &x764, x762, x746, x743); + fiat_p384_scalar_addcarryx_u32(&x765, &x766, x764, x744, x741); + fiat_p384_scalar_addcarryx_u32(&x767, &x768, x766, x742, x739); + fiat_p384_scalar_addcarryx_u32(&x769, &x770, x768, x740, x737); + fiat_p384_scalar_addcarryx_u32(&x771, &x772, x770, x738, x735); + fiat_p384_scalar_addcarryx_u32(&x773, &x774, x772, x736, x733); + fiat_p384_scalar_addcarryx_u32(&x775, &x776, x774, x734, x731); + x777 = (x776 + x732); + fiat_p384_scalar_addcarryx_u32(&x778, &x779, 0x0, x706, x753); + fiat_p384_scalar_addcarryx_u32(&x780, &x781, x779, x708, x755); + fiat_p384_scalar_addcarryx_u32(&x782, &x783, x781, x710, x757); + fiat_p384_scalar_addcarryx_u32(&x784, &x785, x783, x712, x759); + fiat_p384_scalar_addcarryx_u32(&x786, &x787, x785, x714, x761); + fiat_p384_scalar_addcarryx_u32(&x788, &x789, x787, x716, x763); + fiat_p384_scalar_addcarryx_u32(&x790, &x791, x789, x718, x765); + fiat_p384_scalar_addcarryx_u32(&x792, &x793, x791, x720, x767); + fiat_p384_scalar_addcarryx_u32(&x794, &x795, x793, x722, x769); + fiat_p384_scalar_addcarryx_u32(&x796, &x797, x795, x724, x771); + fiat_p384_scalar_addcarryx_u32(&x798, &x799, x797, x726, x773); + fiat_p384_scalar_addcarryx_u32(&x800, &x801, x799, x728, x775); + fiat_p384_scalar_addcarryx_u32(&x802, &x803, x801, x730, x777); + fiat_p384_scalar_mulx_u32(&x804, &x805, x778, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x806, &x807, x804, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x808, &x809, x804, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x810, &x811, x804, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x812, &x813, x804, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x814, &x815, x804, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x816, &x817, x804, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x818, &x819, x804, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x820, &x821, x804, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x822, &x823, x804, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x824, &x825, x804, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x826, &x827, x804, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x828, &x829, x804, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x830, &x831, 0x0, x829, x826); + fiat_p384_scalar_addcarryx_u32(&x832, &x833, x831, x827, x824); + fiat_p384_scalar_addcarryx_u32(&x834, &x835, x833, x825, x822); + fiat_p384_scalar_addcarryx_u32(&x836, &x837, x835, x823, x820); + fiat_p384_scalar_addcarryx_u32(&x838, &x839, x837, x821, x818); + fiat_p384_scalar_addcarryx_u32(&x840, &x841, x839, x819, x816); + fiat_p384_scalar_addcarryx_u32(&x842, &x843, x841, x817, x814); + fiat_p384_scalar_addcarryx_u32(&x844, &x845, x843, x815, x812); + fiat_p384_scalar_addcarryx_u32(&x846, &x847, x845, x813, x810); + fiat_p384_scalar_addcarryx_u32(&x848, &x849, x847, x811, x808); + fiat_p384_scalar_addcarryx_u32(&x850, &x851, x849, x809, x806); + x852 = (x851 + x807); + fiat_p384_scalar_addcarryx_u32(&x853, &x854, 0x0, x778, x828); + fiat_p384_scalar_addcarryx_u32(&x855, &x856, x854, x780, x830); + fiat_p384_scalar_addcarryx_u32(&x857, &x858, x856, x782, x832); + fiat_p384_scalar_addcarryx_u32(&x859, &x860, x858, x784, x834); + fiat_p384_scalar_addcarryx_u32(&x861, &x862, x860, x786, x836); + fiat_p384_scalar_addcarryx_u32(&x863, &x864, x862, x788, x838); + fiat_p384_scalar_addcarryx_u32(&x865, &x866, x864, x790, x840); + fiat_p384_scalar_addcarryx_u32(&x867, &x868, x866, x792, x842); + fiat_p384_scalar_addcarryx_u32(&x869, &x870, x868, x794, x844); + fiat_p384_scalar_addcarryx_u32(&x871, &x872, x870, x796, x846); + fiat_p384_scalar_addcarryx_u32(&x873, &x874, x872, x798, x848); + fiat_p384_scalar_addcarryx_u32(&x875, &x876, x874, x800, x850); + fiat_p384_scalar_addcarryx_u32(&x877, &x878, x876, x802, x852); + x879 = ((uint32_t)x878 + x803); + fiat_p384_scalar_mulx_u32(&x880, &x881, x6, (arg1[11])); + fiat_p384_scalar_mulx_u32(&x882, &x883, x6, (arg1[10])); + fiat_p384_scalar_mulx_u32(&x884, &x885, x6, (arg1[9])); + fiat_p384_scalar_mulx_u32(&x886, &x887, x6, (arg1[8])); + fiat_p384_scalar_mulx_u32(&x888, &x889, x6, (arg1[7])); + fiat_p384_scalar_mulx_u32(&x890, &x891, x6, (arg1[6])); + fiat_p384_scalar_mulx_u32(&x892, &x893, x6, (arg1[5])); + fiat_p384_scalar_mulx_u32(&x894, &x895, x6, (arg1[4])); + fiat_p384_scalar_mulx_u32(&x896, &x897, x6, (arg1[3])); + fiat_p384_scalar_mulx_u32(&x898, &x899, x6, (arg1[2])); + fiat_p384_scalar_mulx_u32(&x900, &x901, x6, (arg1[1])); + fiat_p384_scalar_mulx_u32(&x902, &x903, x6, (arg1[0])); + fiat_p384_scalar_addcarryx_u32(&x904, &x905, 0x0, x903, x900); + fiat_p384_scalar_addcarryx_u32(&x906, &x907, x905, x901, x898); + fiat_p384_scalar_addcarryx_u32(&x908, &x909, x907, x899, x896); + fiat_p384_scalar_addcarryx_u32(&x910, &x911, x909, x897, x894); + fiat_p384_scalar_addcarryx_u32(&x912, &x913, x911, x895, x892); + fiat_p384_scalar_addcarryx_u32(&x914, &x915, x913, x893, x890); + fiat_p384_scalar_addcarryx_u32(&x916, &x917, x915, x891, x888); + fiat_p384_scalar_addcarryx_u32(&x918, &x919, x917, x889, x886); + fiat_p384_scalar_addcarryx_u32(&x920, &x921, x919, x887, x884); + fiat_p384_scalar_addcarryx_u32(&x922, &x923, x921, x885, x882); + fiat_p384_scalar_addcarryx_u32(&x924, &x925, x923, x883, x880); + x926 = (x925 + x881); + fiat_p384_scalar_addcarryx_u32(&x927, &x928, 0x0, x855, x902); + fiat_p384_scalar_addcarryx_u32(&x929, &x930, x928, x857, x904); + fiat_p384_scalar_addcarryx_u32(&x931, &x932, x930, x859, x906); + fiat_p384_scalar_addcarryx_u32(&x933, &x934, x932, x861, x908); + fiat_p384_scalar_addcarryx_u32(&x935, &x936, x934, x863, x910); + fiat_p384_scalar_addcarryx_u32(&x937, &x938, x936, x865, x912); + fiat_p384_scalar_addcarryx_u32(&x939, &x940, x938, x867, x914); + fiat_p384_scalar_addcarryx_u32(&x941, &x942, x940, x869, x916); + fiat_p384_scalar_addcarryx_u32(&x943, &x944, x942, x871, x918); + fiat_p384_scalar_addcarryx_u32(&x945, &x946, x944, x873, x920); + fiat_p384_scalar_addcarryx_u32(&x947, &x948, x946, x875, x922); + fiat_p384_scalar_addcarryx_u32(&x949, &x950, x948, x877, x924); + fiat_p384_scalar_addcarryx_u32(&x951, &x952, x950, x879, x926); + fiat_p384_scalar_mulx_u32(&x953, &x954, x927, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x955, &x956, x953, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x957, &x958, x953, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x959, &x960, x953, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x961, &x962, x953, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x963, &x964, x953, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x965, &x966, x953, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x967, &x968, x953, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x969, &x970, x953, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x971, &x972, x953, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x973, &x974, x953, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x975, &x976, x953, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x977, &x978, x953, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x979, &x980, 0x0, x978, x975); + fiat_p384_scalar_addcarryx_u32(&x981, &x982, x980, x976, x973); + fiat_p384_scalar_addcarryx_u32(&x983, &x984, x982, x974, x971); + fiat_p384_scalar_addcarryx_u32(&x985, &x986, x984, x972, x969); + fiat_p384_scalar_addcarryx_u32(&x987, &x988, x986, x970, x967); + fiat_p384_scalar_addcarryx_u32(&x989, &x990, x988, x968, x965); + fiat_p384_scalar_addcarryx_u32(&x991, &x992, x990, x966, x963); + fiat_p384_scalar_addcarryx_u32(&x993, &x994, x992, x964, x961); + fiat_p384_scalar_addcarryx_u32(&x995, &x996, x994, x962, x959); + fiat_p384_scalar_addcarryx_u32(&x997, &x998, x996, x960, x957); + fiat_p384_scalar_addcarryx_u32(&x999, &x1000, x998, x958, x955); + x1001 = (x1000 + x956); + fiat_p384_scalar_addcarryx_u32(&x1002, &x1003, 0x0, x927, x977); + fiat_p384_scalar_addcarryx_u32(&x1004, &x1005, x1003, x929, x979); + fiat_p384_scalar_addcarryx_u32(&x1006, &x1007, x1005, x931, x981); + fiat_p384_scalar_addcarryx_u32(&x1008, &x1009, x1007, x933, x983); + fiat_p384_scalar_addcarryx_u32(&x1010, &x1011, x1009, x935, x985); + fiat_p384_scalar_addcarryx_u32(&x1012, &x1013, x1011, x937, x987); + fiat_p384_scalar_addcarryx_u32(&x1014, &x1015, x1013, x939, x989); + fiat_p384_scalar_addcarryx_u32(&x1016, &x1017, x1015, x941, x991); + fiat_p384_scalar_addcarryx_u32(&x1018, &x1019, x1017, x943, x993); + fiat_p384_scalar_addcarryx_u32(&x1020, &x1021, x1019, x945, x995); + fiat_p384_scalar_addcarryx_u32(&x1022, &x1023, x1021, x947, x997); + fiat_p384_scalar_addcarryx_u32(&x1024, &x1025, x1023, x949, x999); + fiat_p384_scalar_addcarryx_u32(&x1026, &x1027, x1025, x951, x1001); + x1028 = ((uint32_t)x1027 + x952); + fiat_p384_scalar_mulx_u32(&x1029, &x1030, x7, (arg1[11])); + fiat_p384_scalar_mulx_u32(&x1031, &x1032, x7, (arg1[10])); + fiat_p384_scalar_mulx_u32(&x1033, &x1034, x7, (arg1[9])); + fiat_p384_scalar_mulx_u32(&x1035, &x1036, x7, (arg1[8])); + fiat_p384_scalar_mulx_u32(&x1037, &x1038, x7, (arg1[7])); + fiat_p384_scalar_mulx_u32(&x1039, &x1040, x7, (arg1[6])); + fiat_p384_scalar_mulx_u32(&x1041, &x1042, x7, (arg1[5])); + fiat_p384_scalar_mulx_u32(&x1043, &x1044, x7, (arg1[4])); + fiat_p384_scalar_mulx_u32(&x1045, &x1046, x7, (arg1[3])); + fiat_p384_scalar_mulx_u32(&x1047, &x1048, x7, (arg1[2])); + fiat_p384_scalar_mulx_u32(&x1049, &x1050, x7, (arg1[1])); + fiat_p384_scalar_mulx_u32(&x1051, &x1052, x7, (arg1[0])); + fiat_p384_scalar_addcarryx_u32(&x1053, &x1054, 0x0, x1052, x1049); + fiat_p384_scalar_addcarryx_u32(&x1055, &x1056, x1054, x1050, x1047); + fiat_p384_scalar_addcarryx_u32(&x1057, &x1058, x1056, x1048, x1045); + fiat_p384_scalar_addcarryx_u32(&x1059, &x1060, x1058, x1046, x1043); + fiat_p384_scalar_addcarryx_u32(&x1061, &x1062, x1060, x1044, x1041); + fiat_p384_scalar_addcarryx_u32(&x1063, &x1064, x1062, x1042, x1039); + fiat_p384_scalar_addcarryx_u32(&x1065, &x1066, x1064, x1040, x1037); + fiat_p384_scalar_addcarryx_u32(&x1067, &x1068, x1066, x1038, x1035); + fiat_p384_scalar_addcarryx_u32(&x1069, &x1070, x1068, x1036, x1033); + fiat_p384_scalar_addcarryx_u32(&x1071, &x1072, x1070, x1034, x1031); + fiat_p384_scalar_addcarryx_u32(&x1073, &x1074, x1072, x1032, x1029); + x1075 = (x1074 + x1030); + fiat_p384_scalar_addcarryx_u32(&x1076, &x1077, 0x0, x1004, x1051); + fiat_p384_scalar_addcarryx_u32(&x1078, &x1079, x1077, x1006, x1053); + fiat_p384_scalar_addcarryx_u32(&x1080, &x1081, x1079, x1008, x1055); + fiat_p384_scalar_addcarryx_u32(&x1082, &x1083, x1081, x1010, x1057); + fiat_p384_scalar_addcarryx_u32(&x1084, &x1085, x1083, x1012, x1059); + fiat_p384_scalar_addcarryx_u32(&x1086, &x1087, x1085, x1014, x1061); + fiat_p384_scalar_addcarryx_u32(&x1088, &x1089, x1087, x1016, x1063); + fiat_p384_scalar_addcarryx_u32(&x1090, &x1091, x1089, x1018, x1065); + fiat_p384_scalar_addcarryx_u32(&x1092, &x1093, x1091, x1020, x1067); + fiat_p384_scalar_addcarryx_u32(&x1094, &x1095, x1093, x1022, x1069); + fiat_p384_scalar_addcarryx_u32(&x1096, &x1097, x1095, x1024, x1071); + fiat_p384_scalar_addcarryx_u32(&x1098, &x1099, x1097, x1026, x1073); + fiat_p384_scalar_addcarryx_u32(&x1100, &x1101, x1099, x1028, x1075); + fiat_p384_scalar_mulx_u32(&x1102, &x1103, x1076, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1104, &x1105, x1102, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1106, &x1107, x1102, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1108, &x1109, x1102, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1110, &x1111, x1102, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1112, &x1113, x1102, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1114, &x1115, x1102, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1116, &x1117, x1102, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1118, &x1119, x1102, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1120, &x1121, x1102, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1122, &x1123, x1102, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1124, &x1125, x1102, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1126, &x1127, x1102, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1128, &x1129, 0x0, x1127, x1124); + fiat_p384_scalar_addcarryx_u32(&x1130, &x1131, x1129, x1125, x1122); + fiat_p384_scalar_addcarryx_u32(&x1132, &x1133, x1131, x1123, x1120); + fiat_p384_scalar_addcarryx_u32(&x1134, &x1135, x1133, x1121, x1118); + fiat_p384_scalar_addcarryx_u32(&x1136, &x1137, x1135, x1119, x1116); + fiat_p384_scalar_addcarryx_u32(&x1138, &x1139, x1137, x1117, x1114); + fiat_p384_scalar_addcarryx_u32(&x1140, &x1141, x1139, x1115, x1112); + fiat_p384_scalar_addcarryx_u32(&x1142, &x1143, x1141, x1113, x1110); + fiat_p384_scalar_addcarryx_u32(&x1144, &x1145, x1143, x1111, x1108); + fiat_p384_scalar_addcarryx_u32(&x1146, &x1147, x1145, x1109, x1106); + fiat_p384_scalar_addcarryx_u32(&x1148, &x1149, x1147, x1107, x1104); + x1150 = (x1149 + x1105); + fiat_p384_scalar_addcarryx_u32(&x1151, &x1152, 0x0, x1076, x1126); + fiat_p384_scalar_addcarryx_u32(&x1153, &x1154, x1152, x1078, x1128); + fiat_p384_scalar_addcarryx_u32(&x1155, &x1156, x1154, x1080, x1130); + fiat_p384_scalar_addcarryx_u32(&x1157, &x1158, x1156, x1082, x1132); + fiat_p384_scalar_addcarryx_u32(&x1159, &x1160, x1158, x1084, x1134); + fiat_p384_scalar_addcarryx_u32(&x1161, &x1162, x1160, x1086, x1136); + fiat_p384_scalar_addcarryx_u32(&x1163, &x1164, x1162, x1088, x1138); + fiat_p384_scalar_addcarryx_u32(&x1165, &x1166, x1164, x1090, x1140); + fiat_p384_scalar_addcarryx_u32(&x1167, &x1168, x1166, x1092, x1142); + fiat_p384_scalar_addcarryx_u32(&x1169, &x1170, x1168, x1094, x1144); + fiat_p384_scalar_addcarryx_u32(&x1171, &x1172, x1170, x1096, x1146); + fiat_p384_scalar_addcarryx_u32(&x1173, &x1174, x1172, x1098, x1148); + fiat_p384_scalar_addcarryx_u32(&x1175, &x1176, x1174, x1100, x1150); + x1177 = ((uint32_t)x1176 + x1101); + fiat_p384_scalar_mulx_u32(&x1178, &x1179, x8, (arg1[11])); + fiat_p384_scalar_mulx_u32(&x1180, &x1181, x8, (arg1[10])); + fiat_p384_scalar_mulx_u32(&x1182, &x1183, x8, (arg1[9])); + fiat_p384_scalar_mulx_u32(&x1184, &x1185, x8, (arg1[8])); + fiat_p384_scalar_mulx_u32(&x1186, &x1187, x8, (arg1[7])); + fiat_p384_scalar_mulx_u32(&x1188, &x1189, x8, (arg1[6])); + fiat_p384_scalar_mulx_u32(&x1190, &x1191, x8, (arg1[5])); + fiat_p384_scalar_mulx_u32(&x1192, &x1193, x8, (arg1[4])); + fiat_p384_scalar_mulx_u32(&x1194, &x1195, x8, (arg1[3])); + fiat_p384_scalar_mulx_u32(&x1196, &x1197, x8, (arg1[2])); + fiat_p384_scalar_mulx_u32(&x1198, &x1199, x8, (arg1[1])); + fiat_p384_scalar_mulx_u32(&x1200, &x1201, x8, (arg1[0])); + fiat_p384_scalar_addcarryx_u32(&x1202, &x1203, 0x0, x1201, x1198); + fiat_p384_scalar_addcarryx_u32(&x1204, &x1205, x1203, x1199, x1196); + fiat_p384_scalar_addcarryx_u32(&x1206, &x1207, x1205, x1197, x1194); + fiat_p384_scalar_addcarryx_u32(&x1208, &x1209, x1207, x1195, x1192); + fiat_p384_scalar_addcarryx_u32(&x1210, &x1211, x1209, x1193, x1190); + fiat_p384_scalar_addcarryx_u32(&x1212, &x1213, x1211, x1191, x1188); + fiat_p384_scalar_addcarryx_u32(&x1214, &x1215, x1213, x1189, x1186); + fiat_p384_scalar_addcarryx_u32(&x1216, &x1217, x1215, x1187, x1184); + fiat_p384_scalar_addcarryx_u32(&x1218, &x1219, x1217, x1185, x1182); + fiat_p384_scalar_addcarryx_u32(&x1220, &x1221, x1219, x1183, x1180); + fiat_p384_scalar_addcarryx_u32(&x1222, &x1223, x1221, x1181, x1178); + x1224 = (x1223 + x1179); + fiat_p384_scalar_addcarryx_u32(&x1225, &x1226, 0x0, x1153, x1200); + fiat_p384_scalar_addcarryx_u32(&x1227, &x1228, x1226, x1155, x1202); + fiat_p384_scalar_addcarryx_u32(&x1229, &x1230, x1228, x1157, x1204); + fiat_p384_scalar_addcarryx_u32(&x1231, &x1232, x1230, x1159, x1206); + fiat_p384_scalar_addcarryx_u32(&x1233, &x1234, x1232, x1161, x1208); + fiat_p384_scalar_addcarryx_u32(&x1235, &x1236, x1234, x1163, x1210); + fiat_p384_scalar_addcarryx_u32(&x1237, &x1238, x1236, x1165, x1212); + fiat_p384_scalar_addcarryx_u32(&x1239, &x1240, x1238, x1167, x1214); + fiat_p384_scalar_addcarryx_u32(&x1241, &x1242, x1240, x1169, x1216); + fiat_p384_scalar_addcarryx_u32(&x1243, &x1244, x1242, x1171, x1218); + fiat_p384_scalar_addcarryx_u32(&x1245, &x1246, x1244, x1173, x1220); + fiat_p384_scalar_addcarryx_u32(&x1247, &x1248, x1246, x1175, x1222); + fiat_p384_scalar_addcarryx_u32(&x1249, &x1250, x1248, x1177, x1224); + fiat_p384_scalar_mulx_u32(&x1251, &x1252, x1225, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1253, &x1254, x1251, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1255, &x1256, x1251, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1257, &x1258, x1251, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1259, &x1260, x1251, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1261, &x1262, x1251, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1263, &x1264, x1251, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1265, &x1266, x1251, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1267, &x1268, x1251, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1269, &x1270, x1251, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1271, &x1272, x1251, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1273, &x1274, x1251, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1275, &x1276, x1251, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1277, &x1278, 0x0, x1276, x1273); + fiat_p384_scalar_addcarryx_u32(&x1279, &x1280, x1278, x1274, x1271); + fiat_p384_scalar_addcarryx_u32(&x1281, &x1282, x1280, x1272, x1269); + fiat_p384_scalar_addcarryx_u32(&x1283, &x1284, x1282, x1270, x1267); + fiat_p384_scalar_addcarryx_u32(&x1285, &x1286, x1284, x1268, x1265); + fiat_p384_scalar_addcarryx_u32(&x1287, &x1288, x1286, x1266, x1263); + fiat_p384_scalar_addcarryx_u32(&x1289, &x1290, x1288, x1264, x1261); + fiat_p384_scalar_addcarryx_u32(&x1291, &x1292, x1290, x1262, x1259); + fiat_p384_scalar_addcarryx_u32(&x1293, &x1294, x1292, x1260, x1257); + fiat_p384_scalar_addcarryx_u32(&x1295, &x1296, x1294, x1258, x1255); + fiat_p384_scalar_addcarryx_u32(&x1297, &x1298, x1296, x1256, x1253); + x1299 = (x1298 + x1254); + fiat_p384_scalar_addcarryx_u32(&x1300, &x1301, 0x0, x1225, x1275); + fiat_p384_scalar_addcarryx_u32(&x1302, &x1303, x1301, x1227, x1277); + fiat_p384_scalar_addcarryx_u32(&x1304, &x1305, x1303, x1229, x1279); + fiat_p384_scalar_addcarryx_u32(&x1306, &x1307, x1305, x1231, x1281); + fiat_p384_scalar_addcarryx_u32(&x1308, &x1309, x1307, x1233, x1283); + fiat_p384_scalar_addcarryx_u32(&x1310, &x1311, x1309, x1235, x1285); + fiat_p384_scalar_addcarryx_u32(&x1312, &x1313, x1311, x1237, x1287); + fiat_p384_scalar_addcarryx_u32(&x1314, &x1315, x1313, x1239, x1289); + fiat_p384_scalar_addcarryx_u32(&x1316, &x1317, x1315, x1241, x1291); + fiat_p384_scalar_addcarryx_u32(&x1318, &x1319, x1317, x1243, x1293); + fiat_p384_scalar_addcarryx_u32(&x1320, &x1321, x1319, x1245, x1295); + fiat_p384_scalar_addcarryx_u32(&x1322, &x1323, x1321, x1247, x1297); + fiat_p384_scalar_addcarryx_u32(&x1324, &x1325, x1323, x1249, x1299); + x1326 = ((uint32_t)x1325 + x1250); + fiat_p384_scalar_mulx_u32(&x1327, &x1328, x9, (arg1[11])); + fiat_p384_scalar_mulx_u32(&x1329, &x1330, x9, (arg1[10])); + fiat_p384_scalar_mulx_u32(&x1331, &x1332, x9, (arg1[9])); + fiat_p384_scalar_mulx_u32(&x1333, &x1334, x9, (arg1[8])); + fiat_p384_scalar_mulx_u32(&x1335, &x1336, x9, (arg1[7])); + fiat_p384_scalar_mulx_u32(&x1337, &x1338, x9, (arg1[6])); + fiat_p384_scalar_mulx_u32(&x1339, &x1340, x9, (arg1[5])); + fiat_p384_scalar_mulx_u32(&x1341, &x1342, x9, (arg1[4])); + fiat_p384_scalar_mulx_u32(&x1343, &x1344, x9, (arg1[3])); + fiat_p384_scalar_mulx_u32(&x1345, &x1346, x9, (arg1[2])); + fiat_p384_scalar_mulx_u32(&x1347, &x1348, x9, (arg1[1])); + fiat_p384_scalar_mulx_u32(&x1349, &x1350, x9, (arg1[0])); + fiat_p384_scalar_addcarryx_u32(&x1351, &x1352, 0x0, x1350, x1347); + fiat_p384_scalar_addcarryx_u32(&x1353, &x1354, x1352, x1348, x1345); + fiat_p384_scalar_addcarryx_u32(&x1355, &x1356, x1354, x1346, x1343); + fiat_p384_scalar_addcarryx_u32(&x1357, &x1358, x1356, x1344, x1341); + fiat_p384_scalar_addcarryx_u32(&x1359, &x1360, x1358, x1342, x1339); + fiat_p384_scalar_addcarryx_u32(&x1361, &x1362, x1360, x1340, x1337); + fiat_p384_scalar_addcarryx_u32(&x1363, &x1364, x1362, x1338, x1335); + fiat_p384_scalar_addcarryx_u32(&x1365, &x1366, x1364, x1336, x1333); + fiat_p384_scalar_addcarryx_u32(&x1367, &x1368, x1366, x1334, x1331); + fiat_p384_scalar_addcarryx_u32(&x1369, &x1370, x1368, x1332, x1329); + fiat_p384_scalar_addcarryx_u32(&x1371, &x1372, x1370, x1330, x1327); + x1373 = (x1372 + x1328); + fiat_p384_scalar_addcarryx_u32(&x1374, &x1375, 0x0, x1302, x1349); + fiat_p384_scalar_addcarryx_u32(&x1376, &x1377, x1375, x1304, x1351); + fiat_p384_scalar_addcarryx_u32(&x1378, &x1379, x1377, x1306, x1353); + fiat_p384_scalar_addcarryx_u32(&x1380, &x1381, x1379, x1308, x1355); + fiat_p384_scalar_addcarryx_u32(&x1382, &x1383, x1381, x1310, x1357); + fiat_p384_scalar_addcarryx_u32(&x1384, &x1385, x1383, x1312, x1359); + fiat_p384_scalar_addcarryx_u32(&x1386, &x1387, x1385, x1314, x1361); + fiat_p384_scalar_addcarryx_u32(&x1388, &x1389, x1387, x1316, x1363); + fiat_p384_scalar_addcarryx_u32(&x1390, &x1391, x1389, x1318, x1365); + fiat_p384_scalar_addcarryx_u32(&x1392, &x1393, x1391, x1320, x1367); + fiat_p384_scalar_addcarryx_u32(&x1394, &x1395, x1393, x1322, x1369); + fiat_p384_scalar_addcarryx_u32(&x1396, &x1397, x1395, x1324, x1371); + fiat_p384_scalar_addcarryx_u32(&x1398, &x1399, x1397, x1326, x1373); + fiat_p384_scalar_mulx_u32(&x1400, &x1401, x1374, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1402, &x1403, x1400, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1404, &x1405, x1400, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1406, &x1407, x1400, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1408, &x1409, x1400, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1410, &x1411, x1400, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1412, &x1413, x1400, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1414, &x1415, x1400, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1416, &x1417, x1400, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1418, &x1419, x1400, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1420, &x1421, x1400, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1422, &x1423, x1400, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1424, &x1425, x1400, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1426, &x1427, 0x0, x1425, x1422); + fiat_p384_scalar_addcarryx_u32(&x1428, &x1429, x1427, x1423, x1420); + fiat_p384_scalar_addcarryx_u32(&x1430, &x1431, x1429, x1421, x1418); + fiat_p384_scalar_addcarryx_u32(&x1432, &x1433, x1431, x1419, x1416); + fiat_p384_scalar_addcarryx_u32(&x1434, &x1435, x1433, x1417, x1414); + fiat_p384_scalar_addcarryx_u32(&x1436, &x1437, x1435, x1415, x1412); + fiat_p384_scalar_addcarryx_u32(&x1438, &x1439, x1437, x1413, x1410); + fiat_p384_scalar_addcarryx_u32(&x1440, &x1441, x1439, x1411, x1408); + fiat_p384_scalar_addcarryx_u32(&x1442, &x1443, x1441, x1409, x1406); + fiat_p384_scalar_addcarryx_u32(&x1444, &x1445, x1443, x1407, x1404); + fiat_p384_scalar_addcarryx_u32(&x1446, &x1447, x1445, x1405, x1402); + x1448 = (x1447 + x1403); + fiat_p384_scalar_addcarryx_u32(&x1449, &x1450, 0x0, x1374, x1424); + fiat_p384_scalar_addcarryx_u32(&x1451, &x1452, x1450, x1376, x1426); + fiat_p384_scalar_addcarryx_u32(&x1453, &x1454, x1452, x1378, x1428); + fiat_p384_scalar_addcarryx_u32(&x1455, &x1456, x1454, x1380, x1430); + fiat_p384_scalar_addcarryx_u32(&x1457, &x1458, x1456, x1382, x1432); + fiat_p384_scalar_addcarryx_u32(&x1459, &x1460, x1458, x1384, x1434); + fiat_p384_scalar_addcarryx_u32(&x1461, &x1462, x1460, x1386, x1436); + fiat_p384_scalar_addcarryx_u32(&x1463, &x1464, x1462, x1388, x1438); + fiat_p384_scalar_addcarryx_u32(&x1465, &x1466, x1464, x1390, x1440); + fiat_p384_scalar_addcarryx_u32(&x1467, &x1468, x1466, x1392, x1442); + fiat_p384_scalar_addcarryx_u32(&x1469, &x1470, x1468, x1394, x1444); + fiat_p384_scalar_addcarryx_u32(&x1471, &x1472, x1470, x1396, x1446); + fiat_p384_scalar_addcarryx_u32(&x1473, &x1474, x1472, x1398, x1448); + x1475 = ((uint32_t)x1474 + x1399); + fiat_p384_scalar_mulx_u32(&x1476, &x1477, x10, (arg1[11])); + fiat_p384_scalar_mulx_u32(&x1478, &x1479, x10, (arg1[10])); + fiat_p384_scalar_mulx_u32(&x1480, &x1481, x10, (arg1[9])); + fiat_p384_scalar_mulx_u32(&x1482, &x1483, x10, (arg1[8])); + fiat_p384_scalar_mulx_u32(&x1484, &x1485, x10, (arg1[7])); + fiat_p384_scalar_mulx_u32(&x1486, &x1487, x10, (arg1[6])); + fiat_p384_scalar_mulx_u32(&x1488, &x1489, x10, (arg1[5])); + fiat_p384_scalar_mulx_u32(&x1490, &x1491, x10, (arg1[4])); + fiat_p384_scalar_mulx_u32(&x1492, &x1493, x10, (arg1[3])); + fiat_p384_scalar_mulx_u32(&x1494, &x1495, x10, (arg1[2])); + fiat_p384_scalar_mulx_u32(&x1496, &x1497, x10, (arg1[1])); + fiat_p384_scalar_mulx_u32(&x1498, &x1499, x10, (arg1[0])); + fiat_p384_scalar_addcarryx_u32(&x1500, &x1501, 0x0, x1499, x1496); + fiat_p384_scalar_addcarryx_u32(&x1502, &x1503, x1501, x1497, x1494); + fiat_p384_scalar_addcarryx_u32(&x1504, &x1505, x1503, x1495, x1492); + fiat_p384_scalar_addcarryx_u32(&x1506, &x1507, x1505, x1493, x1490); + fiat_p384_scalar_addcarryx_u32(&x1508, &x1509, x1507, x1491, x1488); + fiat_p384_scalar_addcarryx_u32(&x1510, &x1511, x1509, x1489, x1486); + fiat_p384_scalar_addcarryx_u32(&x1512, &x1513, x1511, x1487, x1484); + fiat_p384_scalar_addcarryx_u32(&x1514, &x1515, x1513, x1485, x1482); + fiat_p384_scalar_addcarryx_u32(&x1516, &x1517, x1515, x1483, x1480); + fiat_p384_scalar_addcarryx_u32(&x1518, &x1519, x1517, x1481, x1478); + fiat_p384_scalar_addcarryx_u32(&x1520, &x1521, x1519, x1479, x1476); + x1522 = (x1521 + x1477); + fiat_p384_scalar_addcarryx_u32(&x1523, &x1524, 0x0, x1451, x1498); + fiat_p384_scalar_addcarryx_u32(&x1525, &x1526, x1524, x1453, x1500); + fiat_p384_scalar_addcarryx_u32(&x1527, &x1528, x1526, x1455, x1502); + fiat_p384_scalar_addcarryx_u32(&x1529, &x1530, x1528, x1457, x1504); + fiat_p384_scalar_addcarryx_u32(&x1531, &x1532, x1530, x1459, x1506); + fiat_p384_scalar_addcarryx_u32(&x1533, &x1534, x1532, x1461, x1508); + fiat_p384_scalar_addcarryx_u32(&x1535, &x1536, x1534, x1463, x1510); + fiat_p384_scalar_addcarryx_u32(&x1537, &x1538, x1536, x1465, x1512); + fiat_p384_scalar_addcarryx_u32(&x1539, &x1540, x1538, x1467, x1514); + fiat_p384_scalar_addcarryx_u32(&x1541, &x1542, x1540, x1469, x1516); + fiat_p384_scalar_addcarryx_u32(&x1543, &x1544, x1542, x1471, x1518); + fiat_p384_scalar_addcarryx_u32(&x1545, &x1546, x1544, x1473, x1520); + fiat_p384_scalar_addcarryx_u32(&x1547, &x1548, x1546, x1475, x1522); + fiat_p384_scalar_mulx_u32(&x1549, &x1550, x1523, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1551, &x1552, x1549, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1553, &x1554, x1549, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1555, &x1556, x1549, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1557, &x1558, x1549, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1559, &x1560, x1549, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1561, &x1562, x1549, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1563, &x1564, x1549, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1565, &x1566, x1549, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1567, &x1568, x1549, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1569, &x1570, x1549, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1571, &x1572, x1549, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1573, &x1574, x1549, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1575, &x1576, 0x0, x1574, x1571); + fiat_p384_scalar_addcarryx_u32(&x1577, &x1578, x1576, x1572, x1569); + fiat_p384_scalar_addcarryx_u32(&x1579, &x1580, x1578, x1570, x1567); + fiat_p384_scalar_addcarryx_u32(&x1581, &x1582, x1580, x1568, x1565); + fiat_p384_scalar_addcarryx_u32(&x1583, &x1584, x1582, x1566, x1563); + fiat_p384_scalar_addcarryx_u32(&x1585, &x1586, x1584, x1564, x1561); + fiat_p384_scalar_addcarryx_u32(&x1587, &x1588, x1586, x1562, x1559); + fiat_p384_scalar_addcarryx_u32(&x1589, &x1590, x1588, x1560, x1557); + fiat_p384_scalar_addcarryx_u32(&x1591, &x1592, x1590, x1558, x1555); + fiat_p384_scalar_addcarryx_u32(&x1593, &x1594, x1592, x1556, x1553); + fiat_p384_scalar_addcarryx_u32(&x1595, &x1596, x1594, x1554, x1551); + x1597 = (x1596 + x1552); + fiat_p384_scalar_addcarryx_u32(&x1598, &x1599, 0x0, x1523, x1573); + fiat_p384_scalar_addcarryx_u32(&x1600, &x1601, x1599, x1525, x1575); + fiat_p384_scalar_addcarryx_u32(&x1602, &x1603, x1601, x1527, x1577); + fiat_p384_scalar_addcarryx_u32(&x1604, &x1605, x1603, x1529, x1579); + fiat_p384_scalar_addcarryx_u32(&x1606, &x1607, x1605, x1531, x1581); + fiat_p384_scalar_addcarryx_u32(&x1608, &x1609, x1607, x1533, x1583); + fiat_p384_scalar_addcarryx_u32(&x1610, &x1611, x1609, x1535, x1585); + fiat_p384_scalar_addcarryx_u32(&x1612, &x1613, x1611, x1537, x1587); + fiat_p384_scalar_addcarryx_u32(&x1614, &x1615, x1613, x1539, x1589); + fiat_p384_scalar_addcarryx_u32(&x1616, &x1617, x1615, x1541, x1591); + fiat_p384_scalar_addcarryx_u32(&x1618, &x1619, x1617, x1543, x1593); + fiat_p384_scalar_addcarryx_u32(&x1620, &x1621, x1619, x1545, x1595); + fiat_p384_scalar_addcarryx_u32(&x1622, &x1623, x1621, x1547, x1597); + x1624 = ((uint32_t)x1623 + x1548); + fiat_p384_scalar_mulx_u32(&x1625, &x1626, x11, (arg1[11])); + fiat_p384_scalar_mulx_u32(&x1627, &x1628, x11, (arg1[10])); + fiat_p384_scalar_mulx_u32(&x1629, &x1630, x11, (arg1[9])); + fiat_p384_scalar_mulx_u32(&x1631, &x1632, x11, (arg1[8])); + fiat_p384_scalar_mulx_u32(&x1633, &x1634, x11, (arg1[7])); + fiat_p384_scalar_mulx_u32(&x1635, &x1636, x11, (arg1[6])); + fiat_p384_scalar_mulx_u32(&x1637, &x1638, x11, (arg1[5])); + fiat_p384_scalar_mulx_u32(&x1639, &x1640, x11, (arg1[4])); + fiat_p384_scalar_mulx_u32(&x1641, &x1642, x11, (arg1[3])); + fiat_p384_scalar_mulx_u32(&x1643, &x1644, x11, (arg1[2])); + fiat_p384_scalar_mulx_u32(&x1645, &x1646, x11, (arg1[1])); + fiat_p384_scalar_mulx_u32(&x1647, &x1648, x11, (arg1[0])); + fiat_p384_scalar_addcarryx_u32(&x1649, &x1650, 0x0, x1648, x1645); + fiat_p384_scalar_addcarryx_u32(&x1651, &x1652, x1650, x1646, x1643); + fiat_p384_scalar_addcarryx_u32(&x1653, &x1654, x1652, x1644, x1641); + fiat_p384_scalar_addcarryx_u32(&x1655, &x1656, x1654, x1642, x1639); + fiat_p384_scalar_addcarryx_u32(&x1657, &x1658, x1656, x1640, x1637); + fiat_p384_scalar_addcarryx_u32(&x1659, &x1660, x1658, x1638, x1635); + fiat_p384_scalar_addcarryx_u32(&x1661, &x1662, x1660, x1636, x1633); + fiat_p384_scalar_addcarryx_u32(&x1663, &x1664, x1662, x1634, x1631); + fiat_p384_scalar_addcarryx_u32(&x1665, &x1666, x1664, x1632, x1629); + fiat_p384_scalar_addcarryx_u32(&x1667, &x1668, x1666, x1630, x1627); + fiat_p384_scalar_addcarryx_u32(&x1669, &x1670, x1668, x1628, x1625); + x1671 = (x1670 + x1626); + fiat_p384_scalar_addcarryx_u32(&x1672, &x1673, 0x0, x1600, x1647); + fiat_p384_scalar_addcarryx_u32(&x1674, &x1675, x1673, x1602, x1649); + fiat_p384_scalar_addcarryx_u32(&x1676, &x1677, x1675, x1604, x1651); + fiat_p384_scalar_addcarryx_u32(&x1678, &x1679, x1677, x1606, x1653); + fiat_p384_scalar_addcarryx_u32(&x1680, &x1681, x1679, x1608, x1655); + fiat_p384_scalar_addcarryx_u32(&x1682, &x1683, x1681, x1610, x1657); + fiat_p384_scalar_addcarryx_u32(&x1684, &x1685, x1683, x1612, x1659); + fiat_p384_scalar_addcarryx_u32(&x1686, &x1687, x1685, x1614, x1661); + fiat_p384_scalar_addcarryx_u32(&x1688, &x1689, x1687, x1616, x1663); + fiat_p384_scalar_addcarryx_u32(&x1690, &x1691, x1689, x1618, x1665); + fiat_p384_scalar_addcarryx_u32(&x1692, &x1693, x1691, x1620, x1667); + fiat_p384_scalar_addcarryx_u32(&x1694, &x1695, x1693, x1622, x1669); + fiat_p384_scalar_addcarryx_u32(&x1696, &x1697, x1695, x1624, x1671); + fiat_p384_scalar_mulx_u32(&x1698, &x1699, x1672, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1700, &x1701, x1698, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1702, &x1703, x1698, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1704, &x1705, x1698, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1706, &x1707, x1698, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1708, &x1709, x1698, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1710, &x1711, x1698, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1712, &x1713, x1698, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1714, &x1715, x1698, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1716, &x1717, x1698, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1718, &x1719, x1698, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1720, &x1721, x1698, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1722, &x1723, x1698, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1724, &x1725, 0x0, x1723, x1720); + fiat_p384_scalar_addcarryx_u32(&x1726, &x1727, x1725, x1721, x1718); + fiat_p384_scalar_addcarryx_u32(&x1728, &x1729, x1727, x1719, x1716); + fiat_p384_scalar_addcarryx_u32(&x1730, &x1731, x1729, x1717, x1714); + fiat_p384_scalar_addcarryx_u32(&x1732, &x1733, x1731, x1715, x1712); + fiat_p384_scalar_addcarryx_u32(&x1734, &x1735, x1733, x1713, x1710); + fiat_p384_scalar_addcarryx_u32(&x1736, &x1737, x1735, x1711, x1708); + fiat_p384_scalar_addcarryx_u32(&x1738, &x1739, x1737, x1709, x1706); + fiat_p384_scalar_addcarryx_u32(&x1740, &x1741, x1739, x1707, x1704); + fiat_p384_scalar_addcarryx_u32(&x1742, &x1743, x1741, x1705, x1702); + fiat_p384_scalar_addcarryx_u32(&x1744, &x1745, x1743, x1703, x1700); + x1746 = (x1745 + x1701); + fiat_p384_scalar_addcarryx_u32(&x1747, &x1748, 0x0, x1672, x1722); + fiat_p384_scalar_addcarryx_u32(&x1749, &x1750, x1748, x1674, x1724); + fiat_p384_scalar_addcarryx_u32(&x1751, &x1752, x1750, x1676, x1726); + fiat_p384_scalar_addcarryx_u32(&x1753, &x1754, x1752, x1678, x1728); + fiat_p384_scalar_addcarryx_u32(&x1755, &x1756, x1754, x1680, x1730); + fiat_p384_scalar_addcarryx_u32(&x1757, &x1758, x1756, x1682, x1732); + fiat_p384_scalar_addcarryx_u32(&x1759, &x1760, x1758, x1684, x1734); + fiat_p384_scalar_addcarryx_u32(&x1761, &x1762, x1760, x1686, x1736); + fiat_p384_scalar_addcarryx_u32(&x1763, &x1764, x1762, x1688, x1738); + fiat_p384_scalar_addcarryx_u32(&x1765, &x1766, x1764, x1690, x1740); + fiat_p384_scalar_addcarryx_u32(&x1767, &x1768, x1766, x1692, x1742); + fiat_p384_scalar_addcarryx_u32(&x1769, &x1770, x1768, x1694, x1744); + fiat_p384_scalar_addcarryx_u32(&x1771, &x1772, x1770, x1696, x1746); + x1773 = ((uint32_t)x1772 + x1697); + fiat_p384_scalar_subborrowx_u32(&x1774, &x1775, 0x0, x1749, UINT32_C(0xccc52973)); + fiat_p384_scalar_subborrowx_u32(&x1776, &x1777, x1775, x1751, UINT32_C(0xecec196a)); + fiat_p384_scalar_subborrowx_u32(&x1778, &x1779, x1777, x1753, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_subborrowx_u32(&x1780, &x1781, x1779, x1755, UINT32_C(0x581a0db2)); + fiat_p384_scalar_subborrowx_u32(&x1782, &x1783, x1781, x1757, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_subborrowx_u32(&x1784, &x1785, x1783, x1759, UINT32_C(0xc7634d81)); + fiat_p384_scalar_subborrowx_u32(&x1786, &x1787, x1785, x1761, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1788, &x1789, x1787, x1763, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1790, &x1791, x1789, x1765, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1792, &x1793, x1791, x1767, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1794, &x1795, x1793, x1769, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1796, &x1797, x1795, x1771, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1798, &x1799, x1797, x1773, 0x0); + fiat_p384_scalar_cmovznz_u32(&x1800, x1799, x1774, x1749); + fiat_p384_scalar_cmovznz_u32(&x1801, x1799, x1776, x1751); + fiat_p384_scalar_cmovznz_u32(&x1802, x1799, x1778, x1753); + fiat_p384_scalar_cmovznz_u32(&x1803, x1799, x1780, x1755); + fiat_p384_scalar_cmovznz_u32(&x1804, x1799, x1782, x1757); + fiat_p384_scalar_cmovznz_u32(&x1805, x1799, x1784, x1759); + fiat_p384_scalar_cmovznz_u32(&x1806, x1799, x1786, x1761); + fiat_p384_scalar_cmovznz_u32(&x1807, x1799, x1788, x1763); + fiat_p384_scalar_cmovznz_u32(&x1808, x1799, x1790, x1765); + fiat_p384_scalar_cmovznz_u32(&x1809, x1799, x1792, x1767); + fiat_p384_scalar_cmovznz_u32(&x1810, x1799, x1794, x1769); + fiat_p384_scalar_cmovznz_u32(&x1811, x1799, x1796, x1771); + out1[0] = x1800; + out1[1] = x1801; + out1[2] = x1802; + out1[3] = x1803; + out1[4] = x1804; + out1[5] = x1805; + out1[6] = x1806; + out1[7] = x1807; + out1[8] = x1808; + out1[9] = x1809; + out1[10] = x1810; + out1[11] = x1811; +} + +/* + * The function fiat_p384_scalar_add adds two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_add(fiat_p384_scalar_montgomery_domain_field_element out1, const fiat_p384_scalar_montgomery_domain_field_element arg1, const fiat_p384_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + fiat_p384_scalar_uint1 x2; + uint32_t x3; + fiat_p384_scalar_uint1 x4; + uint32_t x5; + fiat_p384_scalar_uint1 x6; + uint32_t x7; + fiat_p384_scalar_uint1 x8; + uint32_t x9; + fiat_p384_scalar_uint1 x10; + uint32_t x11; + fiat_p384_scalar_uint1 x12; + uint32_t x13; + fiat_p384_scalar_uint1 x14; + uint32_t x15; + fiat_p384_scalar_uint1 x16; + uint32_t x17; + fiat_p384_scalar_uint1 x18; + uint32_t x19; + fiat_p384_scalar_uint1 x20; + uint32_t x21; + fiat_p384_scalar_uint1 x22; + uint32_t x23; + fiat_p384_scalar_uint1 x24; + uint32_t x25; + fiat_p384_scalar_uint1 x26; + uint32_t x27; + fiat_p384_scalar_uint1 x28; + uint32_t x29; + fiat_p384_scalar_uint1 x30; + uint32_t x31; + fiat_p384_scalar_uint1 x32; + uint32_t x33; + fiat_p384_scalar_uint1 x34; + uint32_t x35; + fiat_p384_scalar_uint1 x36; + uint32_t x37; + fiat_p384_scalar_uint1 x38; + uint32_t x39; + fiat_p384_scalar_uint1 x40; + uint32_t x41; + fiat_p384_scalar_uint1 x42; + uint32_t x43; + fiat_p384_scalar_uint1 x44; + uint32_t x45; + fiat_p384_scalar_uint1 x46; + uint32_t x47; + fiat_p384_scalar_uint1 x48; + uint32_t x49; + fiat_p384_scalar_uint1 x50; + uint32_t x51; + uint32_t x52; + uint32_t x53; + uint32_t x54; + uint32_t x55; + uint32_t x56; + uint32_t x57; + uint32_t x58; + uint32_t x59; + uint32_t x60; + uint32_t x61; + uint32_t x62; + fiat_p384_scalar_addcarryx_u32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_p384_scalar_addcarryx_u32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_p384_scalar_addcarryx_u32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_p384_scalar_addcarryx_u32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_p384_scalar_addcarryx_u32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_p384_scalar_addcarryx_u32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_p384_scalar_addcarryx_u32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + fiat_p384_scalar_addcarryx_u32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + fiat_p384_scalar_addcarryx_u32(&x17, &x18, x16, (arg1[8]), (arg2[8])); + fiat_p384_scalar_addcarryx_u32(&x19, &x20, x18, (arg1[9]), (arg2[9])); + fiat_p384_scalar_addcarryx_u32(&x21, &x22, x20, (arg1[10]), (arg2[10])); + fiat_p384_scalar_addcarryx_u32(&x23, &x24, x22, (arg1[11]), (arg2[11])); + fiat_p384_scalar_subborrowx_u32(&x25, &x26, 0x0, x1, UINT32_C(0xccc52973)); + fiat_p384_scalar_subborrowx_u32(&x27, &x28, x26, x3, UINT32_C(0xecec196a)); + fiat_p384_scalar_subborrowx_u32(&x29, &x30, x28, x5, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_subborrowx_u32(&x31, &x32, x30, x7, UINT32_C(0x581a0db2)); + fiat_p384_scalar_subborrowx_u32(&x33, &x34, x32, x9, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_subborrowx_u32(&x35, &x36, x34, x11, UINT32_C(0xc7634d81)); + fiat_p384_scalar_subborrowx_u32(&x37, &x38, x36, x13, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x39, &x40, x38, x15, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x41, &x42, x40, x17, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x43, &x44, x42, x19, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x45, &x46, x44, x21, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x47, &x48, x46, x23, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x49, &x50, x48, x24, 0x0); + fiat_p384_scalar_cmovznz_u32(&x51, x50, x25, x1); + fiat_p384_scalar_cmovznz_u32(&x52, x50, x27, x3); + fiat_p384_scalar_cmovznz_u32(&x53, x50, x29, x5); + fiat_p384_scalar_cmovznz_u32(&x54, x50, x31, x7); + fiat_p384_scalar_cmovznz_u32(&x55, x50, x33, x9); + fiat_p384_scalar_cmovznz_u32(&x56, x50, x35, x11); + fiat_p384_scalar_cmovznz_u32(&x57, x50, x37, x13); + fiat_p384_scalar_cmovznz_u32(&x58, x50, x39, x15); + fiat_p384_scalar_cmovznz_u32(&x59, x50, x41, x17); + fiat_p384_scalar_cmovznz_u32(&x60, x50, x43, x19); + fiat_p384_scalar_cmovznz_u32(&x61, x50, x45, x21); + fiat_p384_scalar_cmovznz_u32(&x62, x50, x47, x23); + out1[0] = x51; + out1[1] = x52; + out1[2] = x53; + out1[3] = x54; + out1[4] = x55; + out1[5] = x56; + out1[6] = x57; + out1[7] = x58; + out1[8] = x59; + out1[9] = x60; + out1[10] = x61; + out1[11] = x62; +} + +/* + * The function fiat_p384_scalar_sub subtracts two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_sub(fiat_p384_scalar_montgomery_domain_field_element out1, const fiat_p384_scalar_montgomery_domain_field_element arg1, const fiat_p384_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + fiat_p384_scalar_uint1 x2; + uint32_t x3; + fiat_p384_scalar_uint1 x4; + uint32_t x5; + fiat_p384_scalar_uint1 x6; + uint32_t x7; + fiat_p384_scalar_uint1 x8; + uint32_t x9; + fiat_p384_scalar_uint1 x10; + uint32_t x11; + fiat_p384_scalar_uint1 x12; + uint32_t x13; + fiat_p384_scalar_uint1 x14; + uint32_t x15; + fiat_p384_scalar_uint1 x16; + uint32_t x17; + fiat_p384_scalar_uint1 x18; + uint32_t x19; + fiat_p384_scalar_uint1 x20; + uint32_t x21; + fiat_p384_scalar_uint1 x22; + uint32_t x23; + fiat_p384_scalar_uint1 x24; + uint32_t x25; + uint32_t x26; + fiat_p384_scalar_uint1 x27; + uint32_t x28; + fiat_p384_scalar_uint1 x29; + uint32_t x30; + fiat_p384_scalar_uint1 x31; + uint32_t x32; + fiat_p384_scalar_uint1 x33; + uint32_t x34; + fiat_p384_scalar_uint1 x35; + uint32_t x36; + fiat_p384_scalar_uint1 x37; + uint32_t x38; + fiat_p384_scalar_uint1 x39; + uint32_t x40; + fiat_p384_scalar_uint1 x41; + uint32_t x42; + fiat_p384_scalar_uint1 x43; + uint32_t x44; + fiat_p384_scalar_uint1 x45; + uint32_t x46; + fiat_p384_scalar_uint1 x47; + uint32_t x48; + fiat_p384_scalar_uint1 x49; + fiat_p384_scalar_subborrowx_u32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_p384_scalar_subborrowx_u32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_p384_scalar_subborrowx_u32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_p384_scalar_subborrowx_u32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_p384_scalar_subborrowx_u32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_p384_scalar_subborrowx_u32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_p384_scalar_subborrowx_u32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + fiat_p384_scalar_subborrowx_u32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + fiat_p384_scalar_subborrowx_u32(&x17, &x18, x16, (arg1[8]), (arg2[8])); + fiat_p384_scalar_subborrowx_u32(&x19, &x20, x18, (arg1[9]), (arg2[9])); + fiat_p384_scalar_subborrowx_u32(&x21, &x22, x20, (arg1[10]), (arg2[10])); + fiat_p384_scalar_subborrowx_u32(&x23, &x24, x22, (arg1[11]), (arg2[11])); + fiat_p384_scalar_cmovznz_u32(&x25, x24, 0x0, UINT32_C(0xffffffff)); + fiat_p384_scalar_addcarryx_u32(&x26, &x27, 0x0, x1, (x25 & UINT32_C(0xccc52973))); + fiat_p384_scalar_addcarryx_u32(&x28, &x29, x27, x3, (x25 & UINT32_C(0xecec196a))); + fiat_p384_scalar_addcarryx_u32(&x30, &x31, x29, x5, (x25 & UINT32_C(0x48b0a77a))); + fiat_p384_scalar_addcarryx_u32(&x32, &x33, x31, x7, (x25 & UINT32_C(0x581a0db2))); + fiat_p384_scalar_addcarryx_u32(&x34, &x35, x33, x9, (x25 & UINT32_C(0xf4372ddf))); + fiat_p384_scalar_addcarryx_u32(&x36, &x37, x35, x11, (x25 & UINT32_C(0xc7634d81))); + fiat_p384_scalar_addcarryx_u32(&x38, &x39, x37, x13, x25); + fiat_p384_scalar_addcarryx_u32(&x40, &x41, x39, x15, x25); + fiat_p384_scalar_addcarryx_u32(&x42, &x43, x41, x17, x25); + fiat_p384_scalar_addcarryx_u32(&x44, &x45, x43, x19, x25); + fiat_p384_scalar_addcarryx_u32(&x46, &x47, x45, x21, x25); + fiat_p384_scalar_addcarryx_u32(&x48, &x49, x47, x23, x25); + out1[0] = x26; + out1[1] = x28; + out1[2] = x30; + out1[3] = x32; + out1[4] = x34; + out1[5] = x36; + out1[6] = x38; + out1[7] = x40; + out1[8] = x42; + out1[9] = x44; + out1[10] = x46; + out1[11] = x48; +} + +/* + * The function fiat_p384_scalar_opp negates a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_opp(fiat_p384_scalar_montgomery_domain_field_element out1, const fiat_p384_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + fiat_p384_scalar_uint1 x2; + uint32_t x3; + fiat_p384_scalar_uint1 x4; + uint32_t x5; + fiat_p384_scalar_uint1 x6; + uint32_t x7; + fiat_p384_scalar_uint1 x8; + uint32_t x9; + fiat_p384_scalar_uint1 x10; + uint32_t x11; + fiat_p384_scalar_uint1 x12; + uint32_t x13; + fiat_p384_scalar_uint1 x14; + uint32_t x15; + fiat_p384_scalar_uint1 x16; + uint32_t x17; + fiat_p384_scalar_uint1 x18; + uint32_t x19; + fiat_p384_scalar_uint1 x20; + uint32_t x21; + fiat_p384_scalar_uint1 x22; + uint32_t x23; + fiat_p384_scalar_uint1 x24; + uint32_t x25; + uint32_t x26; + fiat_p384_scalar_uint1 x27; + uint32_t x28; + fiat_p384_scalar_uint1 x29; + uint32_t x30; + fiat_p384_scalar_uint1 x31; + uint32_t x32; + fiat_p384_scalar_uint1 x33; + uint32_t x34; + fiat_p384_scalar_uint1 x35; + uint32_t x36; + fiat_p384_scalar_uint1 x37; + uint32_t x38; + fiat_p384_scalar_uint1 x39; + uint32_t x40; + fiat_p384_scalar_uint1 x41; + uint32_t x42; + fiat_p384_scalar_uint1 x43; + uint32_t x44; + fiat_p384_scalar_uint1 x45; + uint32_t x46; + fiat_p384_scalar_uint1 x47; + uint32_t x48; + fiat_p384_scalar_uint1 x49; + fiat_p384_scalar_subborrowx_u32(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_p384_scalar_subborrowx_u32(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_p384_scalar_subborrowx_u32(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_p384_scalar_subborrowx_u32(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_p384_scalar_subborrowx_u32(&x9, &x10, x8, 0x0, (arg1[4])); + fiat_p384_scalar_subborrowx_u32(&x11, &x12, x10, 0x0, (arg1[5])); + fiat_p384_scalar_subborrowx_u32(&x13, &x14, x12, 0x0, (arg1[6])); + fiat_p384_scalar_subborrowx_u32(&x15, &x16, x14, 0x0, (arg1[7])); + fiat_p384_scalar_subborrowx_u32(&x17, &x18, x16, 0x0, (arg1[8])); + fiat_p384_scalar_subborrowx_u32(&x19, &x20, x18, 0x0, (arg1[9])); + fiat_p384_scalar_subborrowx_u32(&x21, &x22, x20, 0x0, (arg1[10])); + fiat_p384_scalar_subborrowx_u32(&x23, &x24, x22, 0x0, (arg1[11])); + fiat_p384_scalar_cmovznz_u32(&x25, x24, 0x0, UINT32_C(0xffffffff)); + fiat_p384_scalar_addcarryx_u32(&x26, &x27, 0x0, x1, (x25 & UINT32_C(0xccc52973))); + fiat_p384_scalar_addcarryx_u32(&x28, &x29, x27, x3, (x25 & UINT32_C(0xecec196a))); + fiat_p384_scalar_addcarryx_u32(&x30, &x31, x29, x5, (x25 & UINT32_C(0x48b0a77a))); + fiat_p384_scalar_addcarryx_u32(&x32, &x33, x31, x7, (x25 & UINT32_C(0x581a0db2))); + fiat_p384_scalar_addcarryx_u32(&x34, &x35, x33, x9, (x25 & UINT32_C(0xf4372ddf))); + fiat_p384_scalar_addcarryx_u32(&x36, &x37, x35, x11, (x25 & UINT32_C(0xc7634d81))); + fiat_p384_scalar_addcarryx_u32(&x38, &x39, x37, x13, x25); + fiat_p384_scalar_addcarryx_u32(&x40, &x41, x39, x15, x25); + fiat_p384_scalar_addcarryx_u32(&x42, &x43, x41, x17, x25); + fiat_p384_scalar_addcarryx_u32(&x44, &x45, x43, x19, x25); + fiat_p384_scalar_addcarryx_u32(&x46, &x47, x45, x21, x25); + fiat_p384_scalar_addcarryx_u32(&x48, &x49, x47, x23, x25); + out1[0] = x26; + out1[1] = x28; + out1[2] = x30; + out1[3] = x32; + out1[4] = x34; + out1[5] = x36; + out1[6] = x38; + out1[7] = x40; + out1[8] = x42; + out1[9] = x44; + out1[10] = x46; + out1[11] = x48; +} + +/* + * The function fiat_p384_scalar_from_montgomery translates a field element out of the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^12) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_from_montgomery(fiat_p384_scalar_non_montgomery_domain_field_element out1, const fiat_p384_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + uint32_t x26; + uint32_t x27; + uint32_t x28; + fiat_p384_scalar_uint1 x29; + uint32_t x30; + fiat_p384_scalar_uint1 x31; + uint32_t x32; + fiat_p384_scalar_uint1 x33; + uint32_t x34; + fiat_p384_scalar_uint1 x35; + uint32_t x36; + fiat_p384_scalar_uint1 x37; + uint32_t x38; + fiat_p384_scalar_uint1 x39; + uint32_t x40; + fiat_p384_scalar_uint1 x41; + uint32_t x42; + fiat_p384_scalar_uint1 x43; + uint32_t x44; + fiat_p384_scalar_uint1 x45; + uint32_t x46; + fiat_p384_scalar_uint1 x47; + uint32_t x48; + fiat_p384_scalar_uint1 x49; + uint32_t x50; + fiat_p384_scalar_uint1 x51; + uint32_t x52; + fiat_p384_scalar_uint1 x53; + uint32_t x54; + fiat_p384_scalar_uint1 x55; + uint32_t x56; + fiat_p384_scalar_uint1 x57; + uint32_t x58; + fiat_p384_scalar_uint1 x59; + uint32_t x60; + fiat_p384_scalar_uint1 x61; + uint32_t x62; + fiat_p384_scalar_uint1 x63; + uint32_t x64; + fiat_p384_scalar_uint1 x65; + uint32_t x66; + fiat_p384_scalar_uint1 x67; + uint32_t x68; + fiat_p384_scalar_uint1 x69; + uint32_t x70; + fiat_p384_scalar_uint1 x71; + uint32_t x72; + fiat_p384_scalar_uint1 x73; + uint32_t x74; + fiat_p384_scalar_uint1 x75; + uint32_t x76; + fiat_p384_scalar_uint1 x77; + uint32_t x78; + fiat_p384_scalar_uint1 x79; + uint32_t x80; + fiat_p384_scalar_uint1 x81; + uint32_t x82; + fiat_p384_scalar_uint1 x83; + uint32_t x84; + fiat_p384_scalar_uint1 x85; + uint32_t x86; + fiat_p384_scalar_uint1 x87; + uint32_t x88; + fiat_p384_scalar_uint1 x89; + uint32_t x90; + fiat_p384_scalar_uint1 x91; + uint32_t x92; + fiat_p384_scalar_uint1 x93; + uint32_t x94; + fiat_p384_scalar_uint1 x95; + uint32_t x96; + fiat_p384_scalar_uint1 x97; + uint32_t x98; + fiat_p384_scalar_uint1 x99; + uint32_t x100; + uint32_t x101; + uint32_t x102; + uint32_t x103; + uint32_t x104; + uint32_t x105; + uint32_t x106; + uint32_t x107; + uint32_t x108; + uint32_t x109; + uint32_t x110; + uint32_t x111; + uint32_t x112; + uint32_t x113; + uint32_t x114; + uint32_t x115; + uint32_t x116; + uint32_t x117; + uint32_t x118; + uint32_t x119; + uint32_t x120; + uint32_t x121; + uint32_t x122; + uint32_t x123; + uint32_t x124; + uint32_t x125; + uint32_t x126; + fiat_p384_scalar_uint1 x127; + uint32_t x128; + fiat_p384_scalar_uint1 x129; + uint32_t x130; + fiat_p384_scalar_uint1 x131; + uint32_t x132; + fiat_p384_scalar_uint1 x133; + uint32_t x134; + fiat_p384_scalar_uint1 x135; + uint32_t x136; + fiat_p384_scalar_uint1 x137; + uint32_t x138; + fiat_p384_scalar_uint1 x139; + uint32_t x140; + fiat_p384_scalar_uint1 x141; + uint32_t x142; + fiat_p384_scalar_uint1 x143; + uint32_t x144; + fiat_p384_scalar_uint1 x145; + uint32_t x146; + fiat_p384_scalar_uint1 x147; + uint32_t x148; + fiat_p384_scalar_uint1 x149; + uint32_t x150; + fiat_p384_scalar_uint1 x151; + uint32_t x152; + fiat_p384_scalar_uint1 x153; + uint32_t x154; + fiat_p384_scalar_uint1 x155; + uint32_t x156; + fiat_p384_scalar_uint1 x157; + uint32_t x158; + fiat_p384_scalar_uint1 x159; + uint32_t x160; + fiat_p384_scalar_uint1 x161; + uint32_t x162; + fiat_p384_scalar_uint1 x163; + uint32_t x164; + fiat_p384_scalar_uint1 x165; + uint32_t x166; + fiat_p384_scalar_uint1 x167; + uint32_t x168; + fiat_p384_scalar_uint1 x169; + uint32_t x170; + fiat_p384_scalar_uint1 x171; + uint32_t x172; + fiat_p384_scalar_uint1 x173; + uint32_t x174; + fiat_p384_scalar_uint1 x175; + uint32_t x176; + fiat_p384_scalar_uint1 x177; + uint32_t x178; + fiat_p384_scalar_uint1 x179; + uint32_t x180; + fiat_p384_scalar_uint1 x181; + uint32_t x182; + fiat_p384_scalar_uint1 x183; + uint32_t x184; + fiat_p384_scalar_uint1 x185; + uint32_t x186; + fiat_p384_scalar_uint1 x187; + uint32_t x188; + fiat_p384_scalar_uint1 x189; + uint32_t x190; + fiat_p384_scalar_uint1 x191; + uint32_t x192; + fiat_p384_scalar_uint1 x193; + uint32_t x194; + fiat_p384_scalar_uint1 x195; + uint32_t x196; + fiat_p384_scalar_uint1 x197; + uint32_t x198; + uint32_t x199; + uint32_t x200; + uint32_t x201; + uint32_t x202; + uint32_t x203; + uint32_t x204; + uint32_t x205; + uint32_t x206; + uint32_t x207; + uint32_t x208; + uint32_t x209; + uint32_t x210; + uint32_t x211; + uint32_t x212; + uint32_t x213; + uint32_t x214; + uint32_t x215; + uint32_t x216; + uint32_t x217; + uint32_t x218; + uint32_t x219; + uint32_t x220; + uint32_t x221; + uint32_t x222; + uint32_t x223; + uint32_t x224; + fiat_p384_scalar_uint1 x225; + uint32_t x226; + fiat_p384_scalar_uint1 x227; + uint32_t x228; + fiat_p384_scalar_uint1 x229; + uint32_t x230; + fiat_p384_scalar_uint1 x231; + uint32_t x232; + fiat_p384_scalar_uint1 x233; + uint32_t x234; + fiat_p384_scalar_uint1 x235; + uint32_t x236; + fiat_p384_scalar_uint1 x237; + uint32_t x238; + fiat_p384_scalar_uint1 x239; + uint32_t x240; + fiat_p384_scalar_uint1 x241; + uint32_t x242; + fiat_p384_scalar_uint1 x243; + uint32_t x244; + fiat_p384_scalar_uint1 x245; + uint32_t x246; + fiat_p384_scalar_uint1 x247; + uint32_t x248; + fiat_p384_scalar_uint1 x249; + uint32_t x250; + fiat_p384_scalar_uint1 x251; + uint32_t x252; + fiat_p384_scalar_uint1 x253; + uint32_t x254; + fiat_p384_scalar_uint1 x255; + uint32_t x256; + fiat_p384_scalar_uint1 x257; + uint32_t x258; + fiat_p384_scalar_uint1 x259; + uint32_t x260; + fiat_p384_scalar_uint1 x261; + uint32_t x262; + fiat_p384_scalar_uint1 x263; + uint32_t x264; + fiat_p384_scalar_uint1 x265; + uint32_t x266; + fiat_p384_scalar_uint1 x267; + uint32_t x268; + fiat_p384_scalar_uint1 x269; + uint32_t x270; + fiat_p384_scalar_uint1 x271; + uint32_t x272; + fiat_p384_scalar_uint1 x273; + uint32_t x274; + fiat_p384_scalar_uint1 x275; + uint32_t x276; + fiat_p384_scalar_uint1 x277; + uint32_t x278; + fiat_p384_scalar_uint1 x279; + uint32_t x280; + fiat_p384_scalar_uint1 x281; + uint32_t x282; + fiat_p384_scalar_uint1 x283; + uint32_t x284; + fiat_p384_scalar_uint1 x285; + uint32_t x286; + fiat_p384_scalar_uint1 x287; + uint32_t x288; + fiat_p384_scalar_uint1 x289; + uint32_t x290; + fiat_p384_scalar_uint1 x291; + uint32_t x292; + fiat_p384_scalar_uint1 x293; + uint32_t x294; + fiat_p384_scalar_uint1 x295; + uint32_t x296; + uint32_t x297; + uint32_t x298; + uint32_t x299; + uint32_t x300; + uint32_t x301; + uint32_t x302; + uint32_t x303; + uint32_t x304; + uint32_t x305; + uint32_t x306; + uint32_t x307; + uint32_t x308; + uint32_t x309; + uint32_t x310; + uint32_t x311; + uint32_t x312; + uint32_t x313; + uint32_t x314; + uint32_t x315; + uint32_t x316; + uint32_t x317; + uint32_t x318; + uint32_t x319; + uint32_t x320; + uint32_t x321; + uint32_t x322; + fiat_p384_scalar_uint1 x323; + uint32_t x324; + fiat_p384_scalar_uint1 x325; + uint32_t x326; + fiat_p384_scalar_uint1 x327; + uint32_t x328; + fiat_p384_scalar_uint1 x329; + uint32_t x330; + fiat_p384_scalar_uint1 x331; + uint32_t x332; + fiat_p384_scalar_uint1 x333; + uint32_t x334; + fiat_p384_scalar_uint1 x335; + uint32_t x336; + fiat_p384_scalar_uint1 x337; + uint32_t x338; + fiat_p384_scalar_uint1 x339; + uint32_t x340; + fiat_p384_scalar_uint1 x341; + uint32_t x342; + fiat_p384_scalar_uint1 x343; + uint32_t x344; + fiat_p384_scalar_uint1 x345; + uint32_t x346; + fiat_p384_scalar_uint1 x347; + uint32_t x348; + fiat_p384_scalar_uint1 x349; + uint32_t x350; + fiat_p384_scalar_uint1 x351; + uint32_t x352; + fiat_p384_scalar_uint1 x353; + uint32_t x354; + fiat_p384_scalar_uint1 x355; + uint32_t x356; + fiat_p384_scalar_uint1 x357; + uint32_t x358; + fiat_p384_scalar_uint1 x359; + uint32_t x360; + fiat_p384_scalar_uint1 x361; + uint32_t x362; + fiat_p384_scalar_uint1 x363; + uint32_t x364; + fiat_p384_scalar_uint1 x365; + uint32_t x366; + fiat_p384_scalar_uint1 x367; + uint32_t x368; + fiat_p384_scalar_uint1 x369; + uint32_t x370; + fiat_p384_scalar_uint1 x371; + uint32_t x372; + fiat_p384_scalar_uint1 x373; + uint32_t x374; + fiat_p384_scalar_uint1 x375; + uint32_t x376; + fiat_p384_scalar_uint1 x377; + uint32_t x378; + fiat_p384_scalar_uint1 x379; + uint32_t x380; + fiat_p384_scalar_uint1 x381; + uint32_t x382; + fiat_p384_scalar_uint1 x383; + uint32_t x384; + fiat_p384_scalar_uint1 x385; + uint32_t x386; + fiat_p384_scalar_uint1 x387; + uint32_t x388; + fiat_p384_scalar_uint1 x389; + uint32_t x390; + fiat_p384_scalar_uint1 x391; + uint32_t x392; + fiat_p384_scalar_uint1 x393; + uint32_t x394; + uint32_t x395; + uint32_t x396; + uint32_t x397; + uint32_t x398; + uint32_t x399; + uint32_t x400; + uint32_t x401; + uint32_t x402; + uint32_t x403; + uint32_t x404; + uint32_t x405; + uint32_t x406; + uint32_t x407; + uint32_t x408; + uint32_t x409; + uint32_t x410; + uint32_t x411; + uint32_t x412; + uint32_t x413; + uint32_t x414; + uint32_t x415; + uint32_t x416; + uint32_t x417; + uint32_t x418; + uint32_t x419; + uint32_t x420; + fiat_p384_scalar_uint1 x421; + uint32_t x422; + fiat_p384_scalar_uint1 x423; + uint32_t x424; + fiat_p384_scalar_uint1 x425; + uint32_t x426; + fiat_p384_scalar_uint1 x427; + uint32_t x428; + fiat_p384_scalar_uint1 x429; + uint32_t x430; + fiat_p384_scalar_uint1 x431; + uint32_t x432; + fiat_p384_scalar_uint1 x433; + uint32_t x434; + fiat_p384_scalar_uint1 x435; + uint32_t x436; + fiat_p384_scalar_uint1 x437; + uint32_t x438; + fiat_p384_scalar_uint1 x439; + uint32_t x440; + fiat_p384_scalar_uint1 x441; + uint32_t x442; + fiat_p384_scalar_uint1 x443; + uint32_t x444; + fiat_p384_scalar_uint1 x445; + uint32_t x446; + fiat_p384_scalar_uint1 x447; + uint32_t x448; + fiat_p384_scalar_uint1 x449; + uint32_t x450; + fiat_p384_scalar_uint1 x451; + uint32_t x452; + fiat_p384_scalar_uint1 x453; + uint32_t x454; + fiat_p384_scalar_uint1 x455; + uint32_t x456; + fiat_p384_scalar_uint1 x457; + uint32_t x458; + fiat_p384_scalar_uint1 x459; + uint32_t x460; + fiat_p384_scalar_uint1 x461; + uint32_t x462; + fiat_p384_scalar_uint1 x463; + uint32_t x464; + fiat_p384_scalar_uint1 x465; + uint32_t x466; + fiat_p384_scalar_uint1 x467; + uint32_t x468; + fiat_p384_scalar_uint1 x469; + uint32_t x470; + fiat_p384_scalar_uint1 x471; + uint32_t x472; + fiat_p384_scalar_uint1 x473; + uint32_t x474; + fiat_p384_scalar_uint1 x475; + uint32_t x476; + fiat_p384_scalar_uint1 x477; + uint32_t x478; + fiat_p384_scalar_uint1 x479; + uint32_t x480; + fiat_p384_scalar_uint1 x481; + uint32_t x482; + fiat_p384_scalar_uint1 x483; + uint32_t x484; + fiat_p384_scalar_uint1 x485; + uint32_t x486; + fiat_p384_scalar_uint1 x487; + uint32_t x488; + fiat_p384_scalar_uint1 x489; + uint32_t x490; + fiat_p384_scalar_uint1 x491; + uint32_t x492; + uint32_t x493; + uint32_t x494; + uint32_t x495; + uint32_t x496; + uint32_t x497; + uint32_t x498; + uint32_t x499; + uint32_t x500; + uint32_t x501; + uint32_t x502; + uint32_t x503; + uint32_t x504; + uint32_t x505; + uint32_t x506; + uint32_t x507; + uint32_t x508; + uint32_t x509; + uint32_t x510; + uint32_t x511; + uint32_t x512; + uint32_t x513; + uint32_t x514; + uint32_t x515; + uint32_t x516; + uint32_t x517; + uint32_t x518; + fiat_p384_scalar_uint1 x519; + uint32_t x520; + fiat_p384_scalar_uint1 x521; + uint32_t x522; + fiat_p384_scalar_uint1 x523; + uint32_t x524; + fiat_p384_scalar_uint1 x525; + uint32_t x526; + fiat_p384_scalar_uint1 x527; + uint32_t x528; + fiat_p384_scalar_uint1 x529; + uint32_t x530; + fiat_p384_scalar_uint1 x531; + uint32_t x532; + fiat_p384_scalar_uint1 x533; + uint32_t x534; + fiat_p384_scalar_uint1 x535; + uint32_t x536; + fiat_p384_scalar_uint1 x537; + uint32_t x538; + fiat_p384_scalar_uint1 x539; + uint32_t x540; + fiat_p384_scalar_uint1 x541; + uint32_t x542; + fiat_p384_scalar_uint1 x543; + uint32_t x544; + fiat_p384_scalar_uint1 x545; + uint32_t x546; + fiat_p384_scalar_uint1 x547; + uint32_t x548; + fiat_p384_scalar_uint1 x549; + uint32_t x550; + fiat_p384_scalar_uint1 x551; + uint32_t x552; + fiat_p384_scalar_uint1 x553; + uint32_t x554; + fiat_p384_scalar_uint1 x555; + uint32_t x556; + fiat_p384_scalar_uint1 x557; + uint32_t x558; + fiat_p384_scalar_uint1 x559; + uint32_t x560; + fiat_p384_scalar_uint1 x561; + uint32_t x562; + fiat_p384_scalar_uint1 x563; + uint32_t x564; + fiat_p384_scalar_uint1 x565; + uint32_t x566; + fiat_p384_scalar_uint1 x567; + uint32_t x568; + fiat_p384_scalar_uint1 x569; + uint32_t x570; + fiat_p384_scalar_uint1 x571; + uint32_t x572; + fiat_p384_scalar_uint1 x573; + uint32_t x574; + fiat_p384_scalar_uint1 x575; + uint32_t x576; + fiat_p384_scalar_uint1 x577; + uint32_t x578; + fiat_p384_scalar_uint1 x579; + uint32_t x580; + fiat_p384_scalar_uint1 x581; + uint32_t x582; + fiat_p384_scalar_uint1 x583; + uint32_t x584; + fiat_p384_scalar_uint1 x585; + uint32_t x586; + fiat_p384_scalar_uint1 x587; + uint32_t x588; + fiat_p384_scalar_uint1 x589; + uint32_t x590; + uint32_t x591; + uint32_t x592; + uint32_t x593; + uint32_t x594; + uint32_t x595; + uint32_t x596; + uint32_t x597; + uint32_t x598; + uint32_t x599; + uint32_t x600; + uint32_t x601; + uint32_t x602; + uint32_t x603; + uint32_t x604; + uint32_t x605; + uint32_t x606; + uint32_t x607; + uint32_t x608; + uint32_t x609; + uint32_t x610; + uint32_t x611; + uint32_t x612; + uint32_t x613; + uint32_t x614; + uint32_t x615; + uint32_t x616; + fiat_p384_scalar_uint1 x617; + uint32_t x618; + fiat_p384_scalar_uint1 x619; + uint32_t x620; + fiat_p384_scalar_uint1 x621; + uint32_t x622; + fiat_p384_scalar_uint1 x623; + uint32_t x624; + fiat_p384_scalar_uint1 x625; + uint32_t x626; + fiat_p384_scalar_uint1 x627; + uint32_t x628; + fiat_p384_scalar_uint1 x629; + uint32_t x630; + fiat_p384_scalar_uint1 x631; + uint32_t x632; + fiat_p384_scalar_uint1 x633; + uint32_t x634; + fiat_p384_scalar_uint1 x635; + uint32_t x636; + fiat_p384_scalar_uint1 x637; + uint32_t x638; + fiat_p384_scalar_uint1 x639; + uint32_t x640; + fiat_p384_scalar_uint1 x641; + uint32_t x642; + fiat_p384_scalar_uint1 x643; + uint32_t x644; + fiat_p384_scalar_uint1 x645; + uint32_t x646; + fiat_p384_scalar_uint1 x647; + uint32_t x648; + fiat_p384_scalar_uint1 x649; + uint32_t x650; + fiat_p384_scalar_uint1 x651; + uint32_t x652; + fiat_p384_scalar_uint1 x653; + uint32_t x654; + fiat_p384_scalar_uint1 x655; + uint32_t x656; + fiat_p384_scalar_uint1 x657; + uint32_t x658; + fiat_p384_scalar_uint1 x659; + uint32_t x660; + fiat_p384_scalar_uint1 x661; + uint32_t x662; + fiat_p384_scalar_uint1 x663; + uint32_t x664; + fiat_p384_scalar_uint1 x665; + uint32_t x666; + fiat_p384_scalar_uint1 x667; + uint32_t x668; + fiat_p384_scalar_uint1 x669; + uint32_t x670; + fiat_p384_scalar_uint1 x671; + uint32_t x672; + fiat_p384_scalar_uint1 x673; + uint32_t x674; + fiat_p384_scalar_uint1 x675; + uint32_t x676; + fiat_p384_scalar_uint1 x677; + uint32_t x678; + fiat_p384_scalar_uint1 x679; + uint32_t x680; + fiat_p384_scalar_uint1 x681; + uint32_t x682; + fiat_p384_scalar_uint1 x683; + uint32_t x684; + fiat_p384_scalar_uint1 x685; + uint32_t x686; + fiat_p384_scalar_uint1 x687; + uint32_t x688; + uint32_t x689; + uint32_t x690; + uint32_t x691; + uint32_t x692; + uint32_t x693; + uint32_t x694; + uint32_t x695; + uint32_t x696; + uint32_t x697; + uint32_t x698; + uint32_t x699; + uint32_t x700; + uint32_t x701; + uint32_t x702; + uint32_t x703; + uint32_t x704; + uint32_t x705; + uint32_t x706; + uint32_t x707; + uint32_t x708; + uint32_t x709; + uint32_t x710; + uint32_t x711; + uint32_t x712; + uint32_t x713; + uint32_t x714; + fiat_p384_scalar_uint1 x715; + uint32_t x716; + fiat_p384_scalar_uint1 x717; + uint32_t x718; + fiat_p384_scalar_uint1 x719; + uint32_t x720; + fiat_p384_scalar_uint1 x721; + uint32_t x722; + fiat_p384_scalar_uint1 x723; + uint32_t x724; + fiat_p384_scalar_uint1 x725; + uint32_t x726; + fiat_p384_scalar_uint1 x727; + uint32_t x728; + fiat_p384_scalar_uint1 x729; + uint32_t x730; + fiat_p384_scalar_uint1 x731; + uint32_t x732; + fiat_p384_scalar_uint1 x733; + uint32_t x734; + fiat_p384_scalar_uint1 x735; + uint32_t x736; + fiat_p384_scalar_uint1 x737; + uint32_t x738; + fiat_p384_scalar_uint1 x739; + uint32_t x740; + fiat_p384_scalar_uint1 x741; + uint32_t x742; + fiat_p384_scalar_uint1 x743; + uint32_t x744; + fiat_p384_scalar_uint1 x745; + uint32_t x746; + fiat_p384_scalar_uint1 x747; + uint32_t x748; + fiat_p384_scalar_uint1 x749; + uint32_t x750; + fiat_p384_scalar_uint1 x751; + uint32_t x752; + fiat_p384_scalar_uint1 x753; + uint32_t x754; + fiat_p384_scalar_uint1 x755; + uint32_t x756; + fiat_p384_scalar_uint1 x757; + uint32_t x758; + fiat_p384_scalar_uint1 x759; + uint32_t x760; + fiat_p384_scalar_uint1 x761; + uint32_t x762; + fiat_p384_scalar_uint1 x763; + uint32_t x764; + fiat_p384_scalar_uint1 x765; + uint32_t x766; + fiat_p384_scalar_uint1 x767; + uint32_t x768; + fiat_p384_scalar_uint1 x769; + uint32_t x770; + fiat_p384_scalar_uint1 x771; + uint32_t x772; + fiat_p384_scalar_uint1 x773; + uint32_t x774; + fiat_p384_scalar_uint1 x775; + uint32_t x776; + fiat_p384_scalar_uint1 x777; + uint32_t x778; + fiat_p384_scalar_uint1 x779; + uint32_t x780; + fiat_p384_scalar_uint1 x781; + uint32_t x782; + fiat_p384_scalar_uint1 x783; + uint32_t x784; + fiat_p384_scalar_uint1 x785; + uint32_t x786; + uint32_t x787; + uint32_t x788; + uint32_t x789; + uint32_t x790; + uint32_t x791; + uint32_t x792; + uint32_t x793; + uint32_t x794; + uint32_t x795; + uint32_t x796; + uint32_t x797; + uint32_t x798; + uint32_t x799; + uint32_t x800; + uint32_t x801; + uint32_t x802; + uint32_t x803; + uint32_t x804; + uint32_t x805; + uint32_t x806; + uint32_t x807; + uint32_t x808; + uint32_t x809; + uint32_t x810; + uint32_t x811; + uint32_t x812; + fiat_p384_scalar_uint1 x813; + uint32_t x814; + fiat_p384_scalar_uint1 x815; + uint32_t x816; + fiat_p384_scalar_uint1 x817; + uint32_t x818; + fiat_p384_scalar_uint1 x819; + uint32_t x820; + fiat_p384_scalar_uint1 x821; + uint32_t x822; + fiat_p384_scalar_uint1 x823; + uint32_t x824; + fiat_p384_scalar_uint1 x825; + uint32_t x826; + fiat_p384_scalar_uint1 x827; + uint32_t x828; + fiat_p384_scalar_uint1 x829; + uint32_t x830; + fiat_p384_scalar_uint1 x831; + uint32_t x832; + fiat_p384_scalar_uint1 x833; + uint32_t x834; + fiat_p384_scalar_uint1 x835; + uint32_t x836; + fiat_p384_scalar_uint1 x837; + uint32_t x838; + fiat_p384_scalar_uint1 x839; + uint32_t x840; + fiat_p384_scalar_uint1 x841; + uint32_t x842; + fiat_p384_scalar_uint1 x843; + uint32_t x844; + fiat_p384_scalar_uint1 x845; + uint32_t x846; + fiat_p384_scalar_uint1 x847; + uint32_t x848; + fiat_p384_scalar_uint1 x849; + uint32_t x850; + fiat_p384_scalar_uint1 x851; + uint32_t x852; + fiat_p384_scalar_uint1 x853; + uint32_t x854; + fiat_p384_scalar_uint1 x855; + uint32_t x856; + fiat_p384_scalar_uint1 x857; + uint32_t x858; + fiat_p384_scalar_uint1 x859; + uint32_t x860; + fiat_p384_scalar_uint1 x861; + uint32_t x862; + fiat_p384_scalar_uint1 x863; + uint32_t x864; + fiat_p384_scalar_uint1 x865; + uint32_t x866; + fiat_p384_scalar_uint1 x867; + uint32_t x868; + fiat_p384_scalar_uint1 x869; + uint32_t x870; + fiat_p384_scalar_uint1 x871; + uint32_t x872; + fiat_p384_scalar_uint1 x873; + uint32_t x874; + fiat_p384_scalar_uint1 x875; + uint32_t x876; + fiat_p384_scalar_uint1 x877; + uint32_t x878; + fiat_p384_scalar_uint1 x879; + uint32_t x880; + fiat_p384_scalar_uint1 x881; + uint32_t x882; + fiat_p384_scalar_uint1 x883; + uint32_t x884; + uint32_t x885; + uint32_t x886; + uint32_t x887; + uint32_t x888; + uint32_t x889; + uint32_t x890; + uint32_t x891; + uint32_t x892; + uint32_t x893; + uint32_t x894; + uint32_t x895; + uint32_t x896; + uint32_t x897; + uint32_t x898; + uint32_t x899; + uint32_t x900; + uint32_t x901; + uint32_t x902; + uint32_t x903; + uint32_t x904; + uint32_t x905; + uint32_t x906; + uint32_t x907; + uint32_t x908; + uint32_t x909; + uint32_t x910; + fiat_p384_scalar_uint1 x911; + uint32_t x912; + fiat_p384_scalar_uint1 x913; + uint32_t x914; + fiat_p384_scalar_uint1 x915; + uint32_t x916; + fiat_p384_scalar_uint1 x917; + uint32_t x918; + fiat_p384_scalar_uint1 x919; + uint32_t x920; + fiat_p384_scalar_uint1 x921; + uint32_t x922; + fiat_p384_scalar_uint1 x923; + uint32_t x924; + fiat_p384_scalar_uint1 x925; + uint32_t x926; + fiat_p384_scalar_uint1 x927; + uint32_t x928; + fiat_p384_scalar_uint1 x929; + uint32_t x930; + fiat_p384_scalar_uint1 x931; + uint32_t x932; + fiat_p384_scalar_uint1 x933; + uint32_t x934; + fiat_p384_scalar_uint1 x935; + uint32_t x936; + fiat_p384_scalar_uint1 x937; + uint32_t x938; + fiat_p384_scalar_uint1 x939; + uint32_t x940; + fiat_p384_scalar_uint1 x941; + uint32_t x942; + fiat_p384_scalar_uint1 x943; + uint32_t x944; + fiat_p384_scalar_uint1 x945; + uint32_t x946; + fiat_p384_scalar_uint1 x947; + uint32_t x948; + fiat_p384_scalar_uint1 x949; + uint32_t x950; + fiat_p384_scalar_uint1 x951; + uint32_t x952; + fiat_p384_scalar_uint1 x953; + uint32_t x954; + fiat_p384_scalar_uint1 x955; + uint32_t x956; + fiat_p384_scalar_uint1 x957; + uint32_t x958; + fiat_p384_scalar_uint1 x959; + uint32_t x960; + fiat_p384_scalar_uint1 x961; + uint32_t x962; + fiat_p384_scalar_uint1 x963; + uint32_t x964; + fiat_p384_scalar_uint1 x965; + uint32_t x966; + fiat_p384_scalar_uint1 x967; + uint32_t x968; + fiat_p384_scalar_uint1 x969; + uint32_t x970; + fiat_p384_scalar_uint1 x971; + uint32_t x972; + fiat_p384_scalar_uint1 x973; + uint32_t x974; + fiat_p384_scalar_uint1 x975; + uint32_t x976; + fiat_p384_scalar_uint1 x977; + uint32_t x978; + fiat_p384_scalar_uint1 x979; + uint32_t x980; + fiat_p384_scalar_uint1 x981; + uint32_t x982; + uint32_t x983; + uint32_t x984; + uint32_t x985; + uint32_t x986; + uint32_t x987; + uint32_t x988; + uint32_t x989; + uint32_t x990; + uint32_t x991; + uint32_t x992; + uint32_t x993; + uint32_t x994; + uint32_t x995; + uint32_t x996; + uint32_t x997; + uint32_t x998; + uint32_t x999; + uint32_t x1000; + uint32_t x1001; + uint32_t x1002; + uint32_t x1003; + uint32_t x1004; + uint32_t x1005; + uint32_t x1006; + uint32_t x1007; + uint32_t x1008; + fiat_p384_scalar_uint1 x1009; + uint32_t x1010; + fiat_p384_scalar_uint1 x1011; + uint32_t x1012; + fiat_p384_scalar_uint1 x1013; + uint32_t x1014; + fiat_p384_scalar_uint1 x1015; + uint32_t x1016; + fiat_p384_scalar_uint1 x1017; + uint32_t x1018; + fiat_p384_scalar_uint1 x1019; + uint32_t x1020; + fiat_p384_scalar_uint1 x1021; + uint32_t x1022; + fiat_p384_scalar_uint1 x1023; + uint32_t x1024; + fiat_p384_scalar_uint1 x1025; + uint32_t x1026; + fiat_p384_scalar_uint1 x1027; + uint32_t x1028; + fiat_p384_scalar_uint1 x1029; + uint32_t x1030; + fiat_p384_scalar_uint1 x1031; + uint32_t x1032; + fiat_p384_scalar_uint1 x1033; + uint32_t x1034; + fiat_p384_scalar_uint1 x1035; + uint32_t x1036; + fiat_p384_scalar_uint1 x1037; + uint32_t x1038; + fiat_p384_scalar_uint1 x1039; + uint32_t x1040; + fiat_p384_scalar_uint1 x1041; + uint32_t x1042; + fiat_p384_scalar_uint1 x1043; + uint32_t x1044; + fiat_p384_scalar_uint1 x1045; + uint32_t x1046; + fiat_p384_scalar_uint1 x1047; + uint32_t x1048; + fiat_p384_scalar_uint1 x1049; + uint32_t x1050; + fiat_p384_scalar_uint1 x1051; + uint32_t x1052; + fiat_p384_scalar_uint1 x1053; + uint32_t x1054; + fiat_p384_scalar_uint1 x1055; + uint32_t x1056; + fiat_p384_scalar_uint1 x1057; + uint32_t x1058; + fiat_p384_scalar_uint1 x1059; + uint32_t x1060; + fiat_p384_scalar_uint1 x1061; + uint32_t x1062; + fiat_p384_scalar_uint1 x1063; + uint32_t x1064; + fiat_p384_scalar_uint1 x1065; + uint32_t x1066; + fiat_p384_scalar_uint1 x1067; + uint32_t x1068; + fiat_p384_scalar_uint1 x1069; + uint32_t x1070; + fiat_p384_scalar_uint1 x1071; + uint32_t x1072; + fiat_p384_scalar_uint1 x1073; + uint32_t x1074; + fiat_p384_scalar_uint1 x1075; + uint32_t x1076; + fiat_p384_scalar_uint1 x1077; + uint32_t x1078; + fiat_p384_scalar_uint1 x1079; + uint32_t x1080; + uint32_t x1081; + uint32_t x1082; + uint32_t x1083; + uint32_t x1084; + uint32_t x1085; + uint32_t x1086; + uint32_t x1087; + uint32_t x1088; + uint32_t x1089; + uint32_t x1090; + uint32_t x1091; + uint32_t x1092; + uint32_t x1093; + uint32_t x1094; + uint32_t x1095; + uint32_t x1096; + uint32_t x1097; + uint32_t x1098; + uint32_t x1099; + uint32_t x1100; + uint32_t x1101; + uint32_t x1102; + uint32_t x1103; + uint32_t x1104; + uint32_t x1105; + uint32_t x1106; + fiat_p384_scalar_uint1 x1107; + uint32_t x1108; + fiat_p384_scalar_uint1 x1109; + uint32_t x1110; + fiat_p384_scalar_uint1 x1111; + uint32_t x1112; + fiat_p384_scalar_uint1 x1113; + uint32_t x1114; + fiat_p384_scalar_uint1 x1115; + uint32_t x1116; + fiat_p384_scalar_uint1 x1117; + uint32_t x1118; + fiat_p384_scalar_uint1 x1119; + uint32_t x1120; + fiat_p384_scalar_uint1 x1121; + uint32_t x1122; + fiat_p384_scalar_uint1 x1123; + uint32_t x1124; + fiat_p384_scalar_uint1 x1125; + uint32_t x1126; + fiat_p384_scalar_uint1 x1127; + uint32_t x1128; + fiat_p384_scalar_uint1 x1129; + uint32_t x1130; + fiat_p384_scalar_uint1 x1131; + uint32_t x1132; + fiat_p384_scalar_uint1 x1133; + uint32_t x1134; + fiat_p384_scalar_uint1 x1135; + uint32_t x1136; + fiat_p384_scalar_uint1 x1137; + uint32_t x1138; + fiat_p384_scalar_uint1 x1139; + uint32_t x1140; + fiat_p384_scalar_uint1 x1141; + uint32_t x1142; + fiat_p384_scalar_uint1 x1143; + uint32_t x1144; + fiat_p384_scalar_uint1 x1145; + uint32_t x1146; + fiat_p384_scalar_uint1 x1147; + uint32_t x1148; + fiat_p384_scalar_uint1 x1149; + uint32_t x1150; + fiat_p384_scalar_uint1 x1151; + uint32_t x1152; + fiat_p384_scalar_uint1 x1153; + uint32_t x1154; + fiat_p384_scalar_uint1 x1155; + uint32_t x1156; + fiat_p384_scalar_uint1 x1157; + uint32_t x1158; + fiat_p384_scalar_uint1 x1159; + uint32_t x1160; + fiat_p384_scalar_uint1 x1161; + uint32_t x1162; + fiat_p384_scalar_uint1 x1163; + uint32_t x1164; + fiat_p384_scalar_uint1 x1165; + uint32_t x1166; + fiat_p384_scalar_uint1 x1167; + uint32_t x1168; + fiat_p384_scalar_uint1 x1169; + uint32_t x1170; + fiat_p384_scalar_uint1 x1171; + uint32_t x1172; + fiat_p384_scalar_uint1 x1173; + uint32_t x1174; + fiat_p384_scalar_uint1 x1175; + uint32_t x1176; + fiat_p384_scalar_uint1 x1177; + uint32_t x1178; + fiat_p384_scalar_uint1 x1179; + uint32_t x1180; + uint32_t x1181; + uint32_t x1182; + uint32_t x1183; + uint32_t x1184; + uint32_t x1185; + uint32_t x1186; + uint32_t x1187; + uint32_t x1188; + uint32_t x1189; + uint32_t x1190; + uint32_t x1191; + x1 = (arg1[0]); + fiat_p384_scalar_mulx_u32(&x2, &x3, x1, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x4, &x5, x2, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x6, &x7, x2, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x8, &x9, x2, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x10, &x11, x2, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x12, &x13, x2, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x14, &x15, x2, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x16, &x17, x2, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x18, &x19, x2, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x20, &x21, x2, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x22, &x23, x2, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x24, &x25, x2, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x26, &x27, x2, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x28, &x29, 0x0, x27, x24); + fiat_p384_scalar_addcarryx_u32(&x30, &x31, x29, x25, x22); + fiat_p384_scalar_addcarryx_u32(&x32, &x33, x31, x23, x20); + fiat_p384_scalar_addcarryx_u32(&x34, &x35, x33, x21, x18); + fiat_p384_scalar_addcarryx_u32(&x36, &x37, x35, x19, x16); + fiat_p384_scalar_addcarryx_u32(&x38, &x39, x37, x17, x14); + fiat_p384_scalar_addcarryx_u32(&x40, &x41, x39, x15, x12); + fiat_p384_scalar_addcarryx_u32(&x42, &x43, x41, x13, x10); + fiat_p384_scalar_addcarryx_u32(&x44, &x45, x43, x11, x8); + fiat_p384_scalar_addcarryx_u32(&x46, &x47, x45, x9, x6); + fiat_p384_scalar_addcarryx_u32(&x48, &x49, x47, x7, x4); + fiat_p384_scalar_addcarryx_u32(&x50, &x51, 0x0, x1, x26); + fiat_p384_scalar_addcarryx_u32(&x52, &x53, x51, 0x0, x28); + fiat_p384_scalar_addcarryx_u32(&x54, &x55, x53, 0x0, x30); + fiat_p384_scalar_addcarryx_u32(&x56, &x57, x55, 0x0, x32); + fiat_p384_scalar_addcarryx_u32(&x58, &x59, x57, 0x0, x34); + fiat_p384_scalar_addcarryx_u32(&x60, &x61, x59, 0x0, x36); + fiat_p384_scalar_addcarryx_u32(&x62, &x63, x61, 0x0, x38); + fiat_p384_scalar_addcarryx_u32(&x64, &x65, x63, 0x0, x40); + fiat_p384_scalar_addcarryx_u32(&x66, &x67, x65, 0x0, x42); + fiat_p384_scalar_addcarryx_u32(&x68, &x69, x67, 0x0, x44); + fiat_p384_scalar_addcarryx_u32(&x70, &x71, x69, 0x0, x46); + fiat_p384_scalar_addcarryx_u32(&x72, &x73, x71, 0x0, x48); + fiat_p384_scalar_addcarryx_u32(&x74, &x75, x73, 0x0, (x49 + x5)); + fiat_p384_scalar_addcarryx_u32(&x76, &x77, 0x0, x52, (arg1[1])); + fiat_p384_scalar_addcarryx_u32(&x78, &x79, x77, x54, 0x0); + fiat_p384_scalar_addcarryx_u32(&x80, &x81, x79, x56, 0x0); + fiat_p384_scalar_addcarryx_u32(&x82, &x83, x81, x58, 0x0); + fiat_p384_scalar_addcarryx_u32(&x84, &x85, x83, x60, 0x0); + fiat_p384_scalar_addcarryx_u32(&x86, &x87, x85, x62, 0x0); + fiat_p384_scalar_addcarryx_u32(&x88, &x89, x87, x64, 0x0); + fiat_p384_scalar_addcarryx_u32(&x90, &x91, x89, x66, 0x0); + fiat_p384_scalar_addcarryx_u32(&x92, &x93, x91, x68, 0x0); + fiat_p384_scalar_addcarryx_u32(&x94, &x95, x93, x70, 0x0); + fiat_p384_scalar_addcarryx_u32(&x96, &x97, x95, x72, 0x0); + fiat_p384_scalar_addcarryx_u32(&x98, &x99, x97, x74, 0x0); + fiat_p384_scalar_mulx_u32(&x100, &x101, x76, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x102, &x103, x100, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x104, &x105, x100, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x106, &x107, x100, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x108, &x109, x100, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x110, &x111, x100, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x112, &x113, x100, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x114, &x115, x100, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x116, &x117, x100, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x118, &x119, x100, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x120, &x121, x100, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x122, &x123, x100, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x124, &x125, x100, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x126, &x127, 0x0, x125, x122); + fiat_p384_scalar_addcarryx_u32(&x128, &x129, x127, x123, x120); + fiat_p384_scalar_addcarryx_u32(&x130, &x131, x129, x121, x118); + fiat_p384_scalar_addcarryx_u32(&x132, &x133, x131, x119, x116); + fiat_p384_scalar_addcarryx_u32(&x134, &x135, x133, x117, x114); + fiat_p384_scalar_addcarryx_u32(&x136, &x137, x135, x115, x112); + fiat_p384_scalar_addcarryx_u32(&x138, &x139, x137, x113, x110); + fiat_p384_scalar_addcarryx_u32(&x140, &x141, x139, x111, x108); + fiat_p384_scalar_addcarryx_u32(&x142, &x143, x141, x109, x106); + fiat_p384_scalar_addcarryx_u32(&x144, &x145, x143, x107, x104); + fiat_p384_scalar_addcarryx_u32(&x146, &x147, x145, x105, x102); + fiat_p384_scalar_addcarryx_u32(&x148, &x149, 0x0, x76, x124); + fiat_p384_scalar_addcarryx_u32(&x150, &x151, x149, x78, x126); + fiat_p384_scalar_addcarryx_u32(&x152, &x153, x151, x80, x128); + fiat_p384_scalar_addcarryx_u32(&x154, &x155, x153, x82, x130); + fiat_p384_scalar_addcarryx_u32(&x156, &x157, x155, x84, x132); + fiat_p384_scalar_addcarryx_u32(&x158, &x159, x157, x86, x134); + fiat_p384_scalar_addcarryx_u32(&x160, &x161, x159, x88, x136); + fiat_p384_scalar_addcarryx_u32(&x162, &x163, x161, x90, x138); + fiat_p384_scalar_addcarryx_u32(&x164, &x165, x163, x92, x140); + fiat_p384_scalar_addcarryx_u32(&x166, &x167, x165, x94, x142); + fiat_p384_scalar_addcarryx_u32(&x168, &x169, x167, x96, x144); + fiat_p384_scalar_addcarryx_u32(&x170, &x171, x169, x98, x146); + fiat_p384_scalar_addcarryx_u32(&x172, &x173, x171, ((uint32_t)x99 + x75), (x147 + x103)); + fiat_p384_scalar_addcarryx_u32(&x174, &x175, 0x0, x150, (arg1[2])); + fiat_p384_scalar_addcarryx_u32(&x176, &x177, x175, x152, 0x0); + fiat_p384_scalar_addcarryx_u32(&x178, &x179, x177, x154, 0x0); + fiat_p384_scalar_addcarryx_u32(&x180, &x181, x179, x156, 0x0); + fiat_p384_scalar_addcarryx_u32(&x182, &x183, x181, x158, 0x0); + fiat_p384_scalar_addcarryx_u32(&x184, &x185, x183, x160, 0x0); + fiat_p384_scalar_addcarryx_u32(&x186, &x187, x185, x162, 0x0); + fiat_p384_scalar_addcarryx_u32(&x188, &x189, x187, x164, 0x0); + fiat_p384_scalar_addcarryx_u32(&x190, &x191, x189, x166, 0x0); + fiat_p384_scalar_addcarryx_u32(&x192, &x193, x191, x168, 0x0); + fiat_p384_scalar_addcarryx_u32(&x194, &x195, x193, x170, 0x0); + fiat_p384_scalar_addcarryx_u32(&x196, &x197, x195, x172, 0x0); + fiat_p384_scalar_mulx_u32(&x198, &x199, x174, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x200, &x201, x198, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x202, &x203, x198, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x204, &x205, x198, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x206, &x207, x198, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x208, &x209, x198, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x210, &x211, x198, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x212, &x213, x198, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x214, &x215, x198, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x216, &x217, x198, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x218, &x219, x198, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x220, &x221, x198, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x222, &x223, x198, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x224, &x225, 0x0, x223, x220); + fiat_p384_scalar_addcarryx_u32(&x226, &x227, x225, x221, x218); + fiat_p384_scalar_addcarryx_u32(&x228, &x229, x227, x219, x216); + fiat_p384_scalar_addcarryx_u32(&x230, &x231, x229, x217, x214); + fiat_p384_scalar_addcarryx_u32(&x232, &x233, x231, x215, x212); + fiat_p384_scalar_addcarryx_u32(&x234, &x235, x233, x213, x210); + fiat_p384_scalar_addcarryx_u32(&x236, &x237, x235, x211, x208); + fiat_p384_scalar_addcarryx_u32(&x238, &x239, x237, x209, x206); + fiat_p384_scalar_addcarryx_u32(&x240, &x241, x239, x207, x204); + fiat_p384_scalar_addcarryx_u32(&x242, &x243, x241, x205, x202); + fiat_p384_scalar_addcarryx_u32(&x244, &x245, x243, x203, x200); + fiat_p384_scalar_addcarryx_u32(&x246, &x247, 0x0, x174, x222); + fiat_p384_scalar_addcarryx_u32(&x248, &x249, x247, x176, x224); + fiat_p384_scalar_addcarryx_u32(&x250, &x251, x249, x178, x226); + fiat_p384_scalar_addcarryx_u32(&x252, &x253, x251, x180, x228); + fiat_p384_scalar_addcarryx_u32(&x254, &x255, x253, x182, x230); + fiat_p384_scalar_addcarryx_u32(&x256, &x257, x255, x184, x232); + fiat_p384_scalar_addcarryx_u32(&x258, &x259, x257, x186, x234); + fiat_p384_scalar_addcarryx_u32(&x260, &x261, x259, x188, x236); + fiat_p384_scalar_addcarryx_u32(&x262, &x263, x261, x190, x238); + fiat_p384_scalar_addcarryx_u32(&x264, &x265, x263, x192, x240); + fiat_p384_scalar_addcarryx_u32(&x266, &x267, x265, x194, x242); + fiat_p384_scalar_addcarryx_u32(&x268, &x269, x267, x196, x244); + fiat_p384_scalar_addcarryx_u32(&x270, &x271, x269, ((uint32_t)x197 + x173), (x245 + x201)); + fiat_p384_scalar_addcarryx_u32(&x272, &x273, 0x0, x248, (arg1[3])); + fiat_p384_scalar_addcarryx_u32(&x274, &x275, x273, x250, 0x0); + fiat_p384_scalar_addcarryx_u32(&x276, &x277, x275, x252, 0x0); + fiat_p384_scalar_addcarryx_u32(&x278, &x279, x277, x254, 0x0); + fiat_p384_scalar_addcarryx_u32(&x280, &x281, x279, x256, 0x0); + fiat_p384_scalar_addcarryx_u32(&x282, &x283, x281, x258, 0x0); + fiat_p384_scalar_addcarryx_u32(&x284, &x285, x283, x260, 0x0); + fiat_p384_scalar_addcarryx_u32(&x286, &x287, x285, x262, 0x0); + fiat_p384_scalar_addcarryx_u32(&x288, &x289, x287, x264, 0x0); + fiat_p384_scalar_addcarryx_u32(&x290, &x291, x289, x266, 0x0); + fiat_p384_scalar_addcarryx_u32(&x292, &x293, x291, x268, 0x0); + fiat_p384_scalar_addcarryx_u32(&x294, &x295, x293, x270, 0x0); + fiat_p384_scalar_mulx_u32(&x296, &x297, x272, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x298, &x299, x296, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x300, &x301, x296, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x302, &x303, x296, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x304, &x305, x296, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x306, &x307, x296, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x308, &x309, x296, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x310, &x311, x296, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x312, &x313, x296, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x314, &x315, x296, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x316, &x317, x296, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x318, &x319, x296, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x320, &x321, x296, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x322, &x323, 0x0, x321, x318); + fiat_p384_scalar_addcarryx_u32(&x324, &x325, x323, x319, x316); + fiat_p384_scalar_addcarryx_u32(&x326, &x327, x325, x317, x314); + fiat_p384_scalar_addcarryx_u32(&x328, &x329, x327, x315, x312); + fiat_p384_scalar_addcarryx_u32(&x330, &x331, x329, x313, x310); + fiat_p384_scalar_addcarryx_u32(&x332, &x333, x331, x311, x308); + fiat_p384_scalar_addcarryx_u32(&x334, &x335, x333, x309, x306); + fiat_p384_scalar_addcarryx_u32(&x336, &x337, x335, x307, x304); + fiat_p384_scalar_addcarryx_u32(&x338, &x339, x337, x305, x302); + fiat_p384_scalar_addcarryx_u32(&x340, &x341, x339, x303, x300); + fiat_p384_scalar_addcarryx_u32(&x342, &x343, x341, x301, x298); + fiat_p384_scalar_addcarryx_u32(&x344, &x345, 0x0, x272, x320); + fiat_p384_scalar_addcarryx_u32(&x346, &x347, x345, x274, x322); + fiat_p384_scalar_addcarryx_u32(&x348, &x349, x347, x276, x324); + fiat_p384_scalar_addcarryx_u32(&x350, &x351, x349, x278, x326); + fiat_p384_scalar_addcarryx_u32(&x352, &x353, x351, x280, x328); + fiat_p384_scalar_addcarryx_u32(&x354, &x355, x353, x282, x330); + fiat_p384_scalar_addcarryx_u32(&x356, &x357, x355, x284, x332); + fiat_p384_scalar_addcarryx_u32(&x358, &x359, x357, x286, x334); + fiat_p384_scalar_addcarryx_u32(&x360, &x361, x359, x288, x336); + fiat_p384_scalar_addcarryx_u32(&x362, &x363, x361, x290, x338); + fiat_p384_scalar_addcarryx_u32(&x364, &x365, x363, x292, x340); + fiat_p384_scalar_addcarryx_u32(&x366, &x367, x365, x294, x342); + fiat_p384_scalar_addcarryx_u32(&x368, &x369, x367, ((uint32_t)x295 + x271), (x343 + x299)); + fiat_p384_scalar_addcarryx_u32(&x370, &x371, 0x0, x346, (arg1[4])); + fiat_p384_scalar_addcarryx_u32(&x372, &x373, x371, x348, 0x0); + fiat_p384_scalar_addcarryx_u32(&x374, &x375, x373, x350, 0x0); + fiat_p384_scalar_addcarryx_u32(&x376, &x377, x375, x352, 0x0); + fiat_p384_scalar_addcarryx_u32(&x378, &x379, x377, x354, 0x0); + fiat_p384_scalar_addcarryx_u32(&x380, &x381, x379, x356, 0x0); + fiat_p384_scalar_addcarryx_u32(&x382, &x383, x381, x358, 0x0); + fiat_p384_scalar_addcarryx_u32(&x384, &x385, x383, x360, 0x0); + fiat_p384_scalar_addcarryx_u32(&x386, &x387, x385, x362, 0x0); + fiat_p384_scalar_addcarryx_u32(&x388, &x389, x387, x364, 0x0); + fiat_p384_scalar_addcarryx_u32(&x390, &x391, x389, x366, 0x0); + fiat_p384_scalar_addcarryx_u32(&x392, &x393, x391, x368, 0x0); + fiat_p384_scalar_mulx_u32(&x394, &x395, x370, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x396, &x397, x394, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x398, &x399, x394, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x400, &x401, x394, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x402, &x403, x394, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x404, &x405, x394, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x406, &x407, x394, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x408, &x409, x394, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x410, &x411, x394, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x412, &x413, x394, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x414, &x415, x394, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x416, &x417, x394, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x418, &x419, x394, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x420, &x421, 0x0, x419, x416); + fiat_p384_scalar_addcarryx_u32(&x422, &x423, x421, x417, x414); + fiat_p384_scalar_addcarryx_u32(&x424, &x425, x423, x415, x412); + fiat_p384_scalar_addcarryx_u32(&x426, &x427, x425, x413, x410); + fiat_p384_scalar_addcarryx_u32(&x428, &x429, x427, x411, x408); + fiat_p384_scalar_addcarryx_u32(&x430, &x431, x429, x409, x406); + fiat_p384_scalar_addcarryx_u32(&x432, &x433, x431, x407, x404); + fiat_p384_scalar_addcarryx_u32(&x434, &x435, x433, x405, x402); + fiat_p384_scalar_addcarryx_u32(&x436, &x437, x435, x403, x400); + fiat_p384_scalar_addcarryx_u32(&x438, &x439, x437, x401, x398); + fiat_p384_scalar_addcarryx_u32(&x440, &x441, x439, x399, x396); + fiat_p384_scalar_addcarryx_u32(&x442, &x443, 0x0, x370, x418); + fiat_p384_scalar_addcarryx_u32(&x444, &x445, x443, x372, x420); + fiat_p384_scalar_addcarryx_u32(&x446, &x447, x445, x374, x422); + fiat_p384_scalar_addcarryx_u32(&x448, &x449, x447, x376, x424); + fiat_p384_scalar_addcarryx_u32(&x450, &x451, x449, x378, x426); + fiat_p384_scalar_addcarryx_u32(&x452, &x453, x451, x380, x428); + fiat_p384_scalar_addcarryx_u32(&x454, &x455, x453, x382, x430); + fiat_p384_scalar_addcarryx_u32(&x456, &x457, x455, x384, x432); + fiat_p384_scalar_addcarryx_u32(&x458, &x459, x457, x386, x434); + fiat_p384_scalar_addcarryx_u32(&x460, &x461, x459, x388, x436); + fiat_p384_scalar_addcarryx_u32(&x462, &x463, x461, x390, x438); + fiat_p384_scalar_addcarryx_u32(&x464, &x465, x463, x392, x440); + fiat_p384_scalar_addcarryx_u32(&x466, &x467, x465, ((uint32_t)x393 + x369), (x441 + x397)); + fiat_p384_scalar_addcarryx_u32(&x468, &x469, 0x0, x444, (arg1[5])); + fiat_p384_scalar_addcarryx_u32(&x470, &x471, x469, x446, 0x0); + fiat_p384_scalar_addcarryx_u32(&x472, &x473, x471, x448, 0x0); + fiat_p384_scalar_addcarryx_u32(&x474, &x475, x473, x450, 0x0); + fiat_p384_scalar_addcarryx_u32(&x476, &x477, x475, x452, 0x0); + fiat_p384_scalar_addcarryx_u32(&x478, &x479, x477, x454, 0x0); + fiat_p384_scalar_addcarryx_u32(&x480, &x481, x479, x456, 0x0); + fiat_p384_scalar_addcarryx_u32(&x482, &x483, x481, x458, 0x0); + fiat_p384_scalar_addcarryx_u32(&x484, &x485, x483, x460, 0x0); + fiat_p384_scalar_addcarryx_u32(&x486, &x487, x485, x462, 0x0); + fiat_p384_scalar_addcarryx_u32(&x488, &x489, x487, x464, 0x0); + fiat_p384_scalar_addcarryx_u32(&x490, &x491, x489, x466, 0x0); + fiat_p384_scalar_mulx_u32(&x492, &x493, x468, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x494, &x495, x492, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x496, &x497, x492, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x498, &x499, x492, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x500, &x501, x492, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x502, &x503, x492, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x504, &x505, x492, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x506, &x507, x492, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x508, &x509, x492, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x510, &x511, x492, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x512, &x513, x492, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x514, &x515, x492, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x516, &x517, x492, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x518, &x519, 0x0, x517, x514); + fiat_p384_scalar_addcarryx_u32(&x520, &x521, x519, x515, x512); + fiat_p384_scalar_addcarryx_u32(&x522, &x523, x521, x513, x510); + fiat_p384_scalar_addcarryx_u32(&x524, &x525, x523, x511, x508); + fiat_p384_scalar_addcarryx_u32(&x526, &x527, x525, x509, x506); + fiat_p384_scalar_addcarryx_u32(&x528, &x529, x527, x507, x504); + fiat_p384_scalar_addcarryx_u32(&x530, &x531, x529, x505, x502); + fiat_p384_scalar_addcarryx_u32(&x532, &x533, x531, x503, x500); + fiat_p384_scalar_addcarryx_u32(&x534, &x535, x533, x501, x498); + fiat_p384_scalar_addcarryx_u32(&x536, &x537, x535, x499, x496); + fiat_p384_scalar_addcarryx_u32(&x538, &x539, x537, x497, x494); + fiat_p384_scalar_addcarryx_u32(&x540, &x541, 0x0, x468, x516); + fiat_p384_scalar_addcarryx_u32(&x542, &x543, x541, x470, x518); + fiat_p384_scalar_addcarryx_u32(&x544, &x545, x543, x472, x520); + fiat_p384_scalar_addcarryx_u32(&x546, &x547, x545, x474, x522); + fiat_p384_scalar_addcarryx_u32(&x548, &x549, x547, x476, x524); + fiat_p384_scalar_addcarryx_u32(&x550, &x551, x549, x478, x526); + fiat_p384_scalar_addcarryx_u32(&x552, &x553, x551, x480, x528); + fiat_p384_scalar_addcarryx_u32(&x554, &x555, x553, x482, x530); + fiat_p384_scalar_addcarryx_u32(&x556, &x557, x555, x484, x532); + fiat_p384_scalar_addcarryx_u32(&x558, &x559, x557, x486, x534); + fiat_p384_scalar_addcarryx_u32(&x560, &x561, x559, x488, x536); + fiat_p384_scalar_addcarryx_u32(&x562, &x563, x561, x490, x538); + fiat_p384_scalar_addcarryx_u32(&x564, &x565, x563, ((uint32_t)x491 + x467), (x539 + x495)); + fiat_p384_scalar_addcarryx_u32(&x566, &x567, 0x0, x542, (arg1[6])); + fiat_p384_scalar_addcarryx_u32(&x568, &x569, x567, x544, 0x0); + fiat_p384_scalar_addcarryx_u32(&x570, &x571, x569, x546, 0x0); + fiat_p384_scalar_addcarryx_u32(&x572, &x573, x571, x548, 0x0); + fiat_p384_scalar_addcarryx_u32(&x574, &x575, x573, x550, 0x0); + fiat_p384_scalar_addcarryx_u32(&x576, &x577, x575, x552, 0x0); + fiat_p384_scalar_addcarryx_u32(&x578, &x579, x577, x554, 0x0); + fiat_p384_scalar_addcarryx_u32(&x580, &x581, x579, x556, 0x0); + fiat_p384_scalar_addcarryx_u32(&x582, &x583, x581, x558, 0x0); + fiat_p384_scalar_addcarryx_u32(&x584, &x585, x583, x560, 0x0); + fiat_p384_scalar_addcarryx_u32(&x586, &x587, x585, x562, 0x0); + fiat_p384_scalar_addcarryx_u32(&x588, &x589, x587, x564, 0x0); + fiat_p384_scalar_mulx_u32(&x590, &x591, x566, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x592, &x593, x590, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x594, &x595, x590, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x596, &x597, x590, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x598, &x599, x590, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x600, &x601, x590, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x602, &x603, x590, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x604, &x605, x590, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x606, &x607, x590, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x608, &x609, x590, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x610, &x611, x590, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x612, &x613, x590, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x614, &x615, x590, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x616, &x617, 0x0, x615, x612); + fiat_p384_scalar_addcarryx_u32(&x618, &x619, x617, x613, x610); + fiat_p384_scalar_addcarryx_u32(&x620, &x621, x619, x611, x608); + fiat_p384_scalar_addcarryx_u32(&x622, &x623, x621, x609, x606); + fiat_p384_scalar_addcarryx_u32(&x624, &x625, x623, x607, x604); + fiat_p384_scalar_addcarryx_u32(&x626, &x627, x625, x605, x602); + fiat_p384_scalar_addcarryx_u32(&x628, &x629, x627, x603, x600); + fiat_p384_scalar_addcarryx_u32(&x630, &x631, x629, x601, x598); + fiat_p384_scalar_addcarryx_u32(&x632, &x633, x631, x599, x596); + fiat_p384_scalar_addcarryx_u32(&x634, &x635, x633, x597, x594); + fiat_p384_scalar_addcarryx_u32(&x636, &x637, x635, x595, x592); + fiat_p384_scalar_addcarryx_u32(&x638, &x639, 0x0, x566, x614); + fiat_p384_scalar_addcarryx_u32(&x640, &x641, x639, x568, x616); + fiat_p384_scalar_addcarryx_u32(&x642, &x643, x641, x570, x618); + fiat_p384_scalar_addcarryx_u32(&x644, &x645, x643, x572, x620); + fiat_p384_scalar_addcarryx_u32(&x646, &x647, x645, x574, x622); + fiat_p384_scalar_addcarryx_u32(&x648, &x649, x647, x576, x624); + fiat_p384_scalar_addcarryx_u32(&x650, &x651, x649, x578, x626); + fiat_p384_scalar_addcarryx_u32(&x652, &x653, x651, x580, x628); + fiat_p384_scalar_addcarryx_u32(&x654, &x655, x653, x582, x630); + fiat_p384_scalar_addcarryx_u32(&x656, &x657, x655, x584, x632); + fiat_p384_scalar_addcarryx_u32(&x658, &x659, x657, x586, x634); + fiat_p384_scalar_addcarryx_u32(&x660, &x661, x659, x588, x636); + fiat_p384_scalar_addcarryx_u32(&x662, &x663, x661, ((uint32_t)x589 + x565), (x637 + x593)); + fiat_p384_scalar_addcarryx_u32(&x664, &x665, 0x0, x640, (arg1[7])); + fiat_p384_scalar_addcarryx_u32(&x666, &x667, x665, x642, 0x0); + fiat_p384_scalar_addcarryx_u32(&x668, &x669, x667, x644, 0x0); + fiat_p384_scalar_addcarryx_u32(&x670, &x671, x669, x646, 0x0); + fiat_p384_scalar_addcarryx_u32(&x672, &x673, x671, x648, 0x0); + fiat_p384_scalar_addcarryx_u32(&x674, &x675, x673, x650, 0x0); + fiat_p384_scalar_addcarryx_u32(&x676, &x677, x675, x652, 0x0); + fiat_p384_scalar_addcarryx_u32(&x678, &x679, x677, x654, 0x0); + fiat_p384_scalar_addcarryx_u32(&x680, &x681, x679, x656, 0x0); + fiat_p384_scalar_addcarryx_u32(&x682, &x683, x681, x658, 0x0); + fiat_p384_scalar_addcarryx_u32(&x684, &x685, x683, x660, 0x0); + fiat_p384_scalar_addcarryx_u32(&x686, &x687, x685, x662, 0x0); + fiat_p384_scalar_mulx_u32(&x688, &x689, x664, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x690, &x691, x688, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x692, &x693, x688, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x694, &x695, x688, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x696, &x697, x688, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x698, &x699, x688, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x700, &x701, x688, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x702, &x703, x688, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x704, &x705, x688, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x706, &x707, x688, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x708, &x709, x688, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x710, &x711, x688, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x712, &x713, x688, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x714, &x715, 0x0, x713, x710); + fiat_p384_scalar_addcarryx_u32(&x716, &x717, x715, x711, x708); + fiat_p384_scalar_addcarryx_u32(&x718, &x719, x717, x709, x706); + fiat_p384_scalar_addcarryx_u32(&x720, &x721, x719, x707, x704); + fiat_p384_scalar_addcarryx_u32(&x722, &x723, x721, x705, x702); + fiat_p384_scalar_addcarryx_u32(&x724, &x725, x723, x703, x700); + fiat_p384_scalar_addcarryx_u32(&x726, &x727, x725, x701, x698); + fiat_p384_scalar_addcarryx_u32(&x728, &x729, x727, x699, x696); + fiat_p384_scalar_addcarryx_u32(&x730, &x731, x729, x697, x694); + fiat_p384_scalar_addcarryx_u32(&x732, &x733, x731, x695, x692); + fiat_p384_scalar_addcarryx_u32(&x734, &x735, x733, x693, x690); + fiat_p384_scalar_addcarryx_u32(&x736, &x737, 0x0, x664, x712); + fiat_p384_scalar_addcarryx_u32(&x738, &x739, x737, x666, x714); + fiat_p384_scalar_addcarryx_u32(&x740, &x741, x739, x668, x716); + fiat_p384_scalar_addcarryx_u32(&x742, &x743, x741, x670, x718); + fiat_p384_scalar_addcarryx_u32(&x744, &x745, x743, x672, x720); + fiat_p384_scalar_addcarryx_u32(&x746, &x747, x745, x674, x722); + fiat_p384_scalar_addcarryx_u32(&x748, &x749, x747, x676, x724); + fiat_p384_scalar_addcarryx_u32(&x750, &x751, x749, x678, x726); + fiat_p384_scalar_addcarryx_u32(&x752, &x753, x751, x680, x728); + fiat_p384_scalar_addcarryx_u32(&x754, &x755, x753, x682, x730); + fiat_p384_scalar_addcarryx_u32(&x756, &x757, x755, x684, x732); + fiat_p384_scalar_addcarryx_u32(&x758, &x759, x757, x686, x734); + fiat_p384_scalar_addcarryx_u32(&x760, &x761, x759, ((uint32_t)x687 + x663), (x735 + x691)); + fiat_p384_scalar_addcarryx_u32(&x762, &x763, 0x0, x738, (arg1[8])); + fiat_p384_scalar_addcarryx_u32(&x764, &x765, x763, x740, 0x0); + fiat_p384_scalar_addcarryx_u32(&x766, &x767, x765, x742, 0x0); + fiat_p384_scalar_addcarryx_u32(&x768, &x769, x767, x744, 0x0); + fiat_p384_scalar_addcarryx_u32(&x770, &x771, x769, x746, 0x0); + fiat_p384_scalar_addcarryx_u32(&x772, &x773, x771, x748, 0x0); + fiat_p384_scalar_addcarryx_u32(&x774, &x775, x773, x750, 0x0); + fiat_p384_scalar_addcarryx_u32(&x776, &x777, x775, x752, 0x0); + fiat_p384_scalar_addcarryx_u32(&x778, &x779, x777, x754, 0x0); + fiat_p384_scalar_addcarryx_u32(&x780, &x781, x779, x756, 0x0); + fiat_p384_scalar_addcarryx_u32(&x782, &x783, x781, x758, 0x0); + fiat_p384_scalar_addcarryx_u32(&x784, &x785, x783, x760, 0x0); + fiat_p384_scalar_mulx_u32(&x786, &x787, x762, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x788, &x789, x786, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x790, &x791, x786, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x792, &x793, x786, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x794, &x795, x786, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x796, &x797, x786, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x798, &x799, x786, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x800, &x801, x786, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x802, &x803, x786, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x804, &x805, x786, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x806, &x807, x786, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x808, &x809, x786, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x810, &x811, x786, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x812, &x813, 0x0, x811, x808); + fiat_p384_scalar_addcarryx_u32(&x814, &x815, x813, x809, x806); + fiat_p384_scalar_addcarryx_u32(&x816, &x817, x815, x807, x804); + fiat_p384_scalar_addcarryx_u32(&x818, &x819, x817, x805, x802); + fiat_p384_scalar_addcarryx_u32(&x820, &x821, x819, x803, x800); + fiat_p384_scalar_addcarryx_u32(&x822, &x823, x821, x801, x798); + fiat_p384_scalar_addcarryx_u32(&x824, &x825, x823, x799, x796); + fiat_p384_scalar_addcarryx_u32(&x826, &x827, x825, x797, x794); + fiat_p384_scalar_addcarryx_u32(&x828, &x829, x827, x795, x792); + fiat_p384_scalar_addcarryx_u32(&x830, &x831, x829, x793, x790); + fiat_p384_scalar_addcarryx_u32(&x832, &x833, x831, x791, x788); + fiat_p384_scalar_addcarryx_u32(&x834, &x835, 0x0, x762, x810); + fiat_p384_scalar_addcarryx_u32(&x836, &x837, x835, x764, x812); + fiat_p384_scalar_addcarryx_u32(&x838, &x839, x837, x766, x814); + fiat_p384_scalar_addcarryx_u32(&x840, &x841, x839, x768, x816); + fiat_p384_scalar_addcarryx_u32(&x842, &x843, x841, x770, x818); + fiat_p384_scalar_addcarryx_u32(&x844, &x845, x843, x772, x820); + fiat_p384_scalar_addcarryx_u32(&x846, &x847, x845, x774, x822); + fiat_p384_scalar_addcarryx_u32(&x848, &x849, x847, x776, x824); + fiat_p384_scalar_addcarryx_u32(&x850, &x851, x849, x778, x826); + fiat_p384_scalar_addcarryx_u32(&x852, &x853, x851, x780, x828); + fiat_p384_scalar_addcarryx_u32(&x854, &x855, x853, x782, x830); + fiat_p384_scalar_addcarryx_u32(&x856, &x857, x855, x784, x832); + fiat_p384_scalar_addcarryx_u32(&x858, &x859, x857, ((uint32_t)x785 + x761), (x833 + x789)); + fiat_p384_scalar_addcarryx_u32(&x860, &x861, 0x0, x836, (arg1[9])); + fiat_p384_scalar_addcarryx_u32(&x862, &x863, x861, x838, 0x0); + fiat_p384_scalar_addcarryx_u32(&x864, &x865, x863, x840, 0x0); + fiat_p384_scalar_addcarryx_u32(&x866, &x867, x865, x842, 0x0); + fiat_p384_scalar_addcarryx_u32(&x868, &x869, x867, x844, 0x0); + fiat_p384_scalar_addcarryx_u32(&x870, &x871, x869, x846, 0x0); + fiat_p384_scalar_addcarryx_u32(&x872, &x873, x871, x848, 0x0); + fiat_p384_scalar_addcarryx_u32(&x874, &x875, x873, x850, 0x0); + fiat_p384_scalar_addcarryx_u32(&x876, &x877, x875, x852, 0x0); + fiat_p384_scalar_addcarryx_u32(&x878, &x879, x877, x854, 0x0); + fiat_p384_scalar_addcarryx_u32(&x880, &x881, x879, x856, 0x0); + fiat_p384_scalar_addcarryx_u32(&x882, &x883, x881, x858, 0x0); + fiat_p384_scalar_mulx_u32(&x884, &x885, x860, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x886, &x887, x884, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x888, &x889, x884, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x890, &x891, x884, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x892, &x893, x884, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x894, &x895, x884, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x896, &x897, x884, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x898, &x899, x884, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x900, &x901, x884, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x902, &x903, x884, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x904, &x905, x884, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x906, &x907, x884, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x908, &x909, x884, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x910, &x911, 0x0, x909, x906); + fiat_p384_scalar_addcarryx_u32(&x912, &x913, x911, x907, x904); + fiat_p384_scalar_addcarryx_u32(&x914, &x915, x913, x905, x902); + fiat_p384_scalar_addcarryx_u32(&x916, &x917, x915, x903, x900); + fiat_p384_scalar_addcarryx_u32(&x918, &x919, x917, x901, x898); + fiat_p384_scalar_addcarryx_u32(&x920, &x921, x919, x899, x896); + fiat_p384_scalar_addcarryx_u32(&x922, &x923, x921, x897, x894); + fiat_p384_scalar_addcarryx_u32(&x924, &x925, x923, x895, x892); + fiat_p384_scalar_addcarryx_u32(&x926, &x927, x925, x893, x890); + fiat_p384_scalar_addcarryx_u32(&x928, &x929, x927, x891, x888); + fiat_p384_scalar_addcarryx_u32(&x930, &x931, x929, x889, x886); + fiat_p384_scalar_addcarryx_u32(&x932, &x933, 0x0, x860, x908); + fiat_p384_scalar_addcarryx_u32(&x934, &x935, x933, x862, x910); + fiat_p384_scalar_addcarryx_u32(&x936, &x937, x935, x864, x912); + fiat_p384_scalar_addcarryx_u32(&x938, &x939, x937, x866, x914); + fiat_p384_scalar_addcarryx_u32(&x940, &x941, x939, x868, x916); + fiat_p384_scalar_addcarryx_u32(&x942, &x943, x941, x870, x918); + fiat_p384_scalar_addcarryx_u32(&x944, &x945, x943, x872, x920); + fiat_p384_scalar_addcarryx_u32(&x946, &x947, x945, x874, x922); + fiat_p384_scalar_addcarryx_u32(&x948, &x949, x947, x876, x924); + fiat_p384_scalar_addcarryx_u32(&x950, &x951, x949, x878, x926); + fiat_p384_scalar_addcarryx_u32(&x952, &x953, x951, x880, x928); + fiat_p384_scalar_addcarryx_u32(&x954, &x955, x953, x882, x930); + fiat_p384_scalar_addcarryx_u32(&x956, &x957, x955, ((uint32_t)x883 + x859), (x931 + x887)); + fiat_p384_scalar_addcarryx_u32(&x958, &x959, 0x0, x934, (arg1[10])); + fiat_p384_scalar_addcarryx_u32(&x960, &x961, x959, x936, 0x0); + fiat_p384_scalar_addcarryx_u32(&x962, &x963, x961, x938, 0x0); + fiat_p384_scalar_addcarryx_u32(&x964, &x965, x963, x940, 0x0); + fiat_p384_scalar_addcarryx_u32(&x966, &x967, x965, x942, 0x0); + fiat_p384_scalar_addcarryx_u32(&x968, &x969, x967, x944, 0x0); + fiat_p384_scalar_addcarryx_u32(&x970, &x971, x969, x946, 0x0); + fiat_p384_scalar_addcarryx_u32(&x972, &x973, x971, x948, 0x0); + fiat_p384_scalar_addcarryx_u32(&x974, &x975, x973, x950, 0x0); + fiat_p384_scalar_addcarryx_u32(&x976, &x977, x975, x952, 0x0); + fiat_p384_scalar_addcarryx_u32(&x978, &x979, x977, x954, 0x0); + fiat_p384_scalar_addcarryx_u32(&x980, &x981, x979, x956, 0x0); + fiat_p384_scalar_mulx_u32(&x982, &x983, x958, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x984, &x985, x982, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x986, &x987, x982, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x988, &x989, x982, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x990, &x991, x982, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x992, &x993, x982, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x994, &x995, x982, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x996, &x997, x982, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x998, &x999, x982, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1000, &x1001, x982, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1002, &x1003, x982, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1004, &x1005, x982, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1006, &x1007, x982, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1008, &x1009, 0x0, x1007, x1004); + fiat_p384_scalar_addcarryx_u32(&x1010, &x1011, x1009, x1005, x1002); + fiat_p384_scalar_addcarryx_u32(&x1012, &x1013, x1011, x1003, x1000); + fiat_p384_scalar_addcarryx_u32(&x1014, &x1015, x1013, x1001, x998); + fiat_p384_scalar_addcarryx_u32(&x1016, &x1017, x1015, x999, x996); + fiat_p384_scalar_addcarryx_u32(&x1018, &x1019, x1017, x997, x994); + fiat_p384_scalar_addcarryx_u32(&x1020, &x1021, x1019, x995, x992); + fiat_p384_scalar_addcarryx_u32(&x1022, &x1023, x1021, x993, x990); + fiat_p384_scalar_addcarryx_u32(&x1024, &x1025, x1023, x991, x988); + fiat_p384_scalar_addcarryx_u32(&x1026, &x1027, x1025, x989, x986); + fiat_p384_scalar_addcarryx_u32(&x1028, &x1029, x1027, x987, x984); + fiat_p384_scalar_addcarryx_u32(&x1030, &x1031, 0x0, x958, x1006); + fiat_p384_scalar_addcarryx_u32(&x1032, &x1033, x1031, x960, x1008); + fiat_p384_scalar_addcarryx_u32(&x1034, &x1035, x1033, x962, x1010); + fiat_p384_scalar_addcarryx_u32(&x1036, &x1037, x1035, x964, x1012); + fiat_p384_scalar_addcarryx_u32(&x1038, &x1039, x1037, x966, x1014); + fiat_p384_scalar_addcarryx_u32(&x1040, &x1041, x1039, x968, x1016); + fiat_p384_scalar_addcarryx_u32(&x1042, &x1043, x1041, x970, x1018); + fiat_p384_scalar_addcarryx_u32(&x1044, &x1045, x1043, x972, x1020); + fiat_p384_scalar_addcarryx_u32(&x1046, &x1047, x1045, x974, x1022); + fiat_p384_scalar_addcarryx_u32(&x1048, &x1049, x1047, x976, x1024); + fiat_p384_scalar_addcarryx_u32(&x1050, &x1051, x1049, x978, x1026); + fiat_p384_scalar_addcarryx_u32(&x1052, &x1053, x1051, x980, x1028); + fiat_p384_scalar_addcarryx_u32(&x1054, &x1055, x1053, ((uint32_t)x981 + x957), (x1029 + x985)); + fiat_p384_scalar_addcarryx_u32(&x1056, &x1057, 0x0, x1032, (arg1[11])); + fiat_p384_scalar_addcarryx_u32(&x1058, &x1059, x1057, x1034, 0x0); + fiat_p384_scalar_addcarryx_u32(&x1060, &x1061, x1059, x1036, 0x0); + fiat_p384_scalar_addcarryx_u32(&x1062, &x1063, x1061, x1038, 0x0); + fiat_p384_scalar_addcarryx_u32(&x1064, &x1065, x1063, x1040, 0x0); + fiat_p384_scalar_addcarryx_u32(&x1066, &x1067, x1065, x1042, 0x0); + fiat_p384_scalar_addcarryx_u32(&x1068, &x1069, x1067, x1044, 0x0); + fiat_p384_scalar_addcarryx_u32(&x1070, &x1071, x1069, x1046, 0x0); + fiat_p384_scalar_addcarryx_u32(&x1072, &x1073, x1071, x1048, 0x0); + fiat_p384_scalar_addcarryx_u32(&x1074, &x1075, x1073, x1050, 0x0); + fiat_p384_scalar_addcarryx_u32(&x1076, &x1077, x1075, x1052, 0x0); + fiat_p384_scalar_addcarryx_u32(&x1078, &x1079, x1077, x1054, 0x0); + fiat_p384_scalar_mulx_u32(&x1080, &x1081, x1056, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1082, &x1083, x1080, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1084, &x1085, x1080, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1086, &x1087, x1080, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1088, &x1089, x1080, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1090, &x1091, x1080, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1092, &x1093, x1080, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1094, &x1095, x1080, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1096, &x1097, x1080, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1098, &x1099, x1080, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1100, &x1101, x1080, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1102, &x1103, x1080, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1104, &x1105, x1080, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1106, &x1107, 0x0, x1105, x1102); + fiat_p384_scalar_addcarryx_u32(&x1108, &x1109, x1107, x1103, x1100); + fiat_p384_scalar_addcarryx_u32(&x1110, &x1111, x1109, x1101, x1098); + fiat_p384_scalar_addcarryx_u32(&x1112, &x1113, x1111, x1099, x1096); + fiat_p384_scalar_addcarryx_u32(&x1114, &x1115, x1113, x1097, x1094); + fiat_p384_scalar_addcarryx_u32(&x1116, &x1117, x1115, x1095, x1092); + fiat_p384_scalar_addcarryx_u32(&x1118, &x1119, x1117, x1093, x1090); + fiat_p384_scalar_addcarryx_u32(&x1120, &x1121, x1119, x1091, x1088); + fiat_p384_scalar_addcarryx_u32(&x1122, &x1123, x1121, x1089, x1086); + fiat_p384_scalar_addcarryx_u32(&x1124, &x1125, x1123, x1087, x1084); + fiat_p384_scalar_addcarryx_u32(&x1126, &x1127, x1125, x1085, x1082); + fiat_p384_scalar_addcarryx_u32(&x1128, &x1129, 0x0, x1056, x1104); + fiat_p384_scalar_addcarryx_u32(&x1130, &x1131, x1129, x1058, x1106); + fiat_p384_scalar_addcarryx_u32(&x1132, &x1133, x1131, x1060, x1108); + fiat_p384_scalar_addcarryx_u32(&x1134, &x1135, x1133, x1062, x1110); + fiat_p384_scalar_addcarryx_u32(&x1136, &x1137, x1135, x1064, x1112); + fiat_p384_scalar_addcarryx_u32(&x1138, &x1139, x1137, x1066, x1114); + fiat_p384_scalar_addcarryx_u32(&x1140, &x1141, x1139, x1068, x1116); + fiat_p384_scalar_addcarryx_u32(&x1142, &x1143, x1141, x1070, x1118); + fiat_p384_scalar_addcarryx_u32(&x1144, &x1145, x1143, x1072, x1120); + fiat_p384_scalar_addcarryx_u32(&x1146, &x1147, x1145, x1074, x1122); + fiat_p384_scalar_addcarryx_u32(&x1148, &x1149, x1147, x1076, x1124); + fiat_p384_scalar_addcarryx_u32(&x1150, &x1151, x1149, x1078, x1126); + fiat_p384_scalar_addcarryx_u32(&x1152, &x1153, x1151, ((uint32_t)x1079 + x1055), (x1127 + x1083)); + fiat_p384_scalar_subborrowx_u32(&x1154, &x1155, 0x0, x1130, UINT32_C(0xccc52973)); + fiat_p384_scalar_subborrowx_u32(&x1156, &x1157, x1155, x1132, UINT32_C(0xecec196a)); + fiat_p384_scalar_subborrowx_u32(&x1158, &x1159, x1157, x1134, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_subborrowx_u32(&x1160, &x1161, x1159, x1136, UINT32_C(0x581a0db2)); + fiat_p384_scalar_subborrowx_u32(&x1162, &x1163, x1161, x1138, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_subborrowx_u32(&x1164, &x1165, x1163, x1140, UINT32_C(0xc7634d81)); + fiat_p384_scalar_subborrowx_u32(&x1166, &x1167, x1165, x1142, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1168, &x1169, x1167, x1144, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1170, &x1171, x1169, x1146, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1172, &x1173, x1171, x1148, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1174, &x1175, x1173, x1150, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1176, &x1177, x1175, x1152, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1178, &x1179, x1177, x1153, 0x0); + fiat_p384_scalar_cmovznz_u32(&x1180, x1179, x1154, x1130); + fiat_p384_scalar_cmovznz_u32(&x1181, x1179, x1156, x1132); + fiat_p384_scalar_cmovznz_u32(&x1182, x1179, x1158, x1134); + fiat_p384_scalar_cmovznz_u32(&x1183, x1179, x1160, x1136); + fiat_p384_scalar_cmovznz_u32(&x1184, x1179, x1162, x1138); + fiat_p384_scalar_cmovznz_u32(&x1185, x1179, x1164, x1140); + fiat_p384_scalar_cmovznz_u32(&x1186, x1179, x1166, x1142); + fiat_p384_scalar_cmovznz_u32(&x1187, x1179, x1168, x1144); + fiat_p384_scalar_cmovznz_u32(&x1188, x1179, x1170, x1146); + fiat_p384_scalar_cmovznz_u32(&x1189, x1179, x1172, x1148); + fiat_p384_scalar_cmovznz_u32(&x1190, x1179, x1174, x1150); + fiat_p384_scalar_cmovznz_u32(&x1191, x1179, x1176, x1152); + out1[0] = x1180; + out1[1] = x1181; + out1[2] = x1182; + out1[3] = x1183; + out1[4] = x1184; + out1[5] = x1185; + out1[6] = x1186; + out1[7] = x1187; + out1[8] = x1188; + out1[9] = x1189; + out1[10] = x1190; + out1[11] = x1191; +} + +/* + * The function fiat_p384_scalar_to_montgomery translates a field element into the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = eval arg1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_to_montgomery(fiat_p384_scalar_montgomery_domain_field_element out1, const fiat_p384_scalar_non_montgomery_domain_field_element arg1) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + uint32_t x26; + uint32_t x27; + uint32_t x28; + uint32_t x29; + uint32_t x30; + uint32_t x31; + uint32_t x32; + uint32_t x33; + uint32_t x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + fiat_p384_scalar_uint1 x38; + uint32_t x39; + fiat_p384_scalar_uint1 x40; + uint32_t x41; + fiat_p384_scalar_uint1 x42; + uint32_t x43; + fiat_p384_scalar_uint1 x44; + uint32_t x45; + fiat_p384_scalar_uint1 x46; + uint32_t x47; + fiat_p384_scalar_uint1 x48; + uint32_t x49; + fiat_p384_scalar_uint1 x50; + uint32_t x51; + fiat_p384_scalar_uint1 x52; + uint32_t x53; + fiat_p384_scalar_uint1 x54; + uint32_t x55; + fiat_p384_scalar_uint1 x56; + uint32_t x57; + fiat_p384_scalar_uint1 x58; + uint32_t x59; + uint32_t x60; + uint32_t x61; + uint32_t x62; + uint32_t x63; + uint32_t x64; + uint32_t x65; + uint32_t x66; + uint32_t x67; + uint32_t x68; + uint32_t x69; + uint32_t x70; + uint32_t x71; + uint32_t x72; + uint32_t x73; + uint32_t x74; + uint32_t x75; + uint32_t x76; + uint32_t x77; + uint32_t x78; + uint32_t x79; + uint32_t x80; + uint32_t x81; + uint32_t x82; + uint32_t x83; + uint32_t x84; + uint32_t x85; + fiat_p384_scalar_uint1 x86; + uint32_t x87; + fiat_p384_scalar_uint1 x88; + uint32_t x89; + fiat_p384_scalar_uint1 x90; + uint32_t x91; + fiat_p384_scalar_uint1 x92; + uint32_t x93; + fiat_p384_scalar_uint1 x94; + uint32_t x95; + fiat_p384_scalar_uint1 x96; + uint32_t x97; + fiat_p384_scalar_uint1 x98; + uint32_t x99; + fiat_p384_scalar_uint1 x100; + uint32_t x101; + fiat_p384_scalar_uint1 x102; + uint32_t x103; + fiat_p384_scalar_uint1 x104; + uint32_t x105; + fiat_p384_scalar_uint1 x106; + uint32_t x107; + fiat_p384_scalar_uint1 x108; + uint32_t x109; + fiat_p384_scalar_uint1 x110; + uint32_t x111; + fiat_p384_scalar_uint1 x112; + uint32_t x113; + fiat_p384_scalar_uint1 x114; + uint32_t x115; + fiat_p384_scalar_uint1 x116; + uint32_t x117; + fiat_p384_scalar_uint1 x118; + uint32_t x119; + fiat_p384_scalar_uint1 x120; + uint32_t x121; + fiat_p384_scalar_uint1 x122; + uint32_t x123; + fiat_p384_scalar_uint1 x124; + uint32_t x125; + fiat_p384_scalar_uint1 x126; + uint32_t x127; + fiat_p384_scalar_uint1 x128; + uint32_t x129; + fiat_p384_scalar_uint1 x130; + uint32_t x131; + fiat_p384_scalar_uint1 x132; + uint32_t x133; + uint32_t x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + uint32_t x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + uint32_t x145; + uint32_t x146; + uint32_t x147; + uint32_t x148; + uint32_t x149; + uint32_t x150; + uint32_t x151; + uint32_t x152; + uint32_t x153; + uint32_t x154; + uint32_t x155; + uint32_t x156; + uint32_t x157; + fiat_p384_scalar_uint1 x158; + uint32_t x159; + fiat_p384_scalar_uint1 x160; + uint32_t x161; + fiat_p384_scalar_uint1 x162; + uint32_t x163; + fiat_p384_scalar_uint1 x164; + uint32_t x165; + fiat_p384_scalar_uint1 x166; + uint32_t x167; + fiat_p384_scalar_uint1 x168; + uint32_t x169; + fiat_p384_scalar_uint1 x170; + uint32_t x171; + fiat_p384_scalar_uint1 x172; + uint32_t x173; + fiat_p384_scalar_uint1 x174; + uint32_t x175; + fiat_p384_scalar_uint1 x176; + uint32_t x177; + fiat_p384_scalar_uint1 x178; + uint32_t x179; + fiat_p384_scalar_uint1 x180; + uint32_t x181; + fiat_p384_scalar_uint1 x182; + uint32_t x183; + fiat_p384_scalar_uint1 x184; + uint32_t x185; + fiat_p384_scalar_uint1 x186; + uint32_t x187; + fiat_p384_scalar_uint1 x188; + uint32_t x189; + fiat_p384_scalar_uint1 x190; + uint32_t x191; + fiat_p384_scalar_uint1 x192; + uint32_t x193; + fiat_p384_scalar_uint1 x194; + uint32_t x195; + fiat_p384_scalar_uint1 x196; + uint32_t x197; + fiat_p384_scalar_uint1 x198; + uint32_t x199; + fiat_p384_scalar_uint1 x200; + uint32_t x201; + fiat_p384_scalar_uint1 x202; + uint32_t x203; + uint32_t x204; + uint32_t x205; + uint32_t x206; + uint32_t x207; + uint32_t x208; + uint32_t x209; + uint32_t x210; + uint32_t x211; + uint32_t x212; + uint32_t x213; + uint32_t x214; + uint32_t x215; + uint32_t x216; + uint32_t x217; + uint32_t x218; + uint32_t x219; + uint32_t x220; + uint32_t x221; + uint32_t x222; + uint32_t x223; + uint32_t x224; + uint32_t x225; + uint32_t x226; + uint32_t x227; + uint32_t x228; + uint32_t x229; + fiat_p384_scalar_uint1 x230; + uint32_t x231; + fiat_p384_scalar_uint1 x232; + uint32_t x233; + fiat_p384_scalar_uint1 x234; + uint32_t x235; + fiat_p384_scalar_uint1 x236; + uint32_t x237; + fiat_p384_scalar_uint1 x238; + uint32_t x239; + fiat_p384_scalar_uint1 x240; + uint32_t x241; + fiat_p384_scalar_uint1 x242; + uint32_t x243; + fiat_p384_scalar_uint1 x244; + uint32_t x245; + fiat_p384_scalar_uint1 x246; + uint32_t x247; + fiat_p384_scalar_uint1 x248; + uint32_t x249; + fiat_p384_scalar_uint1 x250; + uint32_t x251; + fiat_p384_scalar_uint1 x252; + uint32_t x253; + fiat_p384_scalar_uint1 x254; + uint32_t x255; + fiat_p384_scalar_uint1 x256; + uint32_t x257; + fiat_p384_scalar_uint1 x258; + uint32_t x259; + fiat_p384_scalar_uint1 x260; + uint32_t x261; + fiat_p384_scalar_uint1 x262; + uint32_t x263; + fiat_p384_scalar_uint1 x264; + uint32_t x265; + fiat_p384_scalar_uint1 x266; + uint32_t x267; + fiat_p384_scalar_uint1 x268; + uint32_t x269; + fiat_p384_scalar_uint1 x270; + uint32_t x271; + fiat_p384_scalar_uint1 x272; + uint32_t x273; + fiat_p384_scalar_uint1 x274; + uint32_t x275; + fiat_p384_scalar_uint1 x276; + uint32_t x277; + uint32_t x278; + uint32_t x279; + uint32_t x280; + uint32_t x281; + uint32_t x282; + uint32_t x283; + uint32_t x284; + uint32_t x285; + uint32_t x286; + uint32_t x287; + uint32_t x288; + uint32_t x289; + uint32_t x290; + uint32_t x291; + uint32_t x292; + uint32_t x293; + uint32_t x294; + uint32_t x295; + uint32_t x296; + uint32_t x297; + uint32_t x298; + uint32_t x299; + uint32_t x300; + uint32_t x301; + fiat_p384_scalar_uint1 x302; + uint32_t x303; + fiat_p384_scalar_uint1 x304; + uint32_t x305; + fiat_p384_scalar_uint1 x306; + uint32_t x307; + fiat_p384_scalar_uint1 x308; + uint32_t x309; + fiat_p384_scalar_uint1 x310; + uint32_t x311; + fiat_p384_scalar_uint1 x312; + uint32_t x313; + fiat_p384_scalar_uint1 x314; + uint32_t x315; + fiat_p384_scalar_uint1 x316; + uint32_t x317; + fiat_p384_scalar_uint1 x318; + uint32_t x319; + fiat_p384_scalar_uint1 x320; + uint32_t x321; + fiat_p384_scalar_uint1 x322; + uint32_t x323; + fiat_p384_scalar_uint1 x324; + uint32_t x325; + fiat_p384_scalar_uint1 x326; + uint32_t x327; + fiat_p384_scalar_uint1 x328; + uint32_t x329; + fiat_p384_scalar_uint1 x330; + uint32_t x331; + fiat_p384_scalar_uint1 x332; + uint32_t x333; + fiat_p384_scalar_uint1 x334; + uint32_t x335; + fiat_p384_scalar_uint1 x336; + uint32_t x337; + fiat_p384_scalar_uint1 x338; + uint32_t x339; + fiat_p384_scalar_uint1 x340; + uint32_t x341; + fiat_p384_scalar_uint1 x342; + uint32_t x343; + fiat_p384_scalar_uint1 x344; + uint32_t x345; + fiat_p384_scalar_uint1 x346; + uint32_t x347; + uint32_t x348; + uint32_t x349; + uint32_t x350; + uint32_t x351; + uint32_t x352; + uint32_t x353; + uint32_t x354; + uint32_t x355; + uint32_t x356; + uint32_t x357; + uint32_t x358; + uint32_t x359; + uint32_t x360; + uint32_t x361; + uint32_t x362; + uint32_t x363; + uint32_t x364; + uint32_t x365; + uint32_t x366; + uint32_t x367; + uint32_t x368; + uint32_t x369; + uint32_t x370; + uint32_t x371; + uint32_t x372; + uint32_t x373; + fiat_p384_scalar_uint1 x374; + uint32_t x375; + fiat_p384_scalar_uint1 x376; + uint32_t x377; + fiat_p384_scalar_uint1 x378; + uint32_t x379; + fiat_p384_scalar_uint1 x380; + uint32_t x381; + fiat_p384_scalar_uint1 x382; + uint32_t x383; + fiat_p384_scalar_uint1 x384; + uint32_t x385; + fiat_p384_scalar_uint1 x386; + uint32_t x387; + fiat_p384_scalar_uint1 x388; + uint32_t x389; + fiat_p384_scalar_uint1 x390; + uint32_t x391; + fiat_p384_scalar_uint1 x392; + uint32_t x393; + fiat_p384_scalar_uint1 x394; + uint32_t x395; + fiat_p384_scalar_uint1 x396; + uint32_t x397; + fiat_p384_scalar_uint1 x398; + uint32_t x399; + fiat_p384_scalar_uint1 x400; + uint32_t x401; + fiat_p384_scalar_uint1 x402; + uint32_t x403; + fiat_p384_scalar_uint1 x404; + uint32_t x405; + fiat_p384_scalar_uint1 x406; + uint32_t x407; + fiat_p384_scalar_uint1 x408; + uint32_t x409; + fiat_p384_scalar_uint1 x410; + uint32_t x411; + fiat_p384_scalar_uint1 x412; + uint32_t x413; + fiat_p384_scalar_uint1 x414; + uint32_t x415; + fiat_p384_scalar_uint1 x416; + uint32_t x417; + fiat_p384_scalar_uint1 x418; + uint32_t x419; + fiat_p384_scalar_uint1 x420; + uint32_t x421; + uint32_t x422; + uint32_t x423; + uint32_t x424; + uint32_t x425; + uint32_t x426; + uint32_t x427; + uint32_t x428; + uint32_t x429; + uint32_t x430; + uint32_t x431; + uint32_t x432; + uint32_t x433; + uint32_t x434; + uint32_t x435; + uint32_t x436; + uint32_t x437; + uint32_t x438; + uint32_t x439; + uint32_t x440; + uint32_t x441; + uint32_t x442; + uint32_t x443; + uint32_t x444; + uint32_t x445; + fiat_p384_scalar_uint1 x446; + uint32_t x447; + fiat_p384_scalar_uint1 x448; + uint32_t x449; + fiat_p384_scalar_uint1 x450; + uint32_t x451; + fiat_p384_scalar_uint1 x452; + uint32_t x453; + fiat_p384_scalar_uint1 x454; + uint32_t x455; + fiat_p384_scalar_uint1 x456; + uint32_t x457; + fiat_p384_scalar_uint1 x458; + uint32_t x459; + fiat_p384_scalar_uint1 x460; + uint32_t x461; + fiat_p384_scalar_uint1 x462; + uint32_t x463; + fiat_p384_scalar_uint1 x464; + uint32_t x465; + fiat_p384_scalar_uint1 x466; + uint32_t x467; + fiat_p384_scalar_uint1 x468; + uint32_t x469; + fiat_p384_scalar_uint1 x470; + uint32_t x471; + fiat_p384_scalar_uint1 x472; + uint32_t x473; + fiat_p384_scalar_uint1 x474; + uint32_t x475; + fiat_p384_scalar_uint1 x476; + uint32_t x477; + fiat_p384_scalar_uint1 x478; + uint32_t x479; + fiat_p384_scalar_uint1 x480; + uint32_t x481; + fiat_p384_scalar_uint1 x482; + uint32_t x483; + fiat_p384_scalar_uint1 x484; + uint32_t x485; + fiat_p384_scalar_uint1 x486; + uint32_t x487; + fiat_p384_scalar_uint1 x488; + uint32_t x489; + fiat_p384_scalar_uint1 x490; + uint32_t x491; + uint32_t x492; + uint32_t x493; + uint32_t x494; + uint32_t x495; + uint32_t x496; + uint32_t x497; + uint32_t x498; + uint32_t x499; + uint32_t x500; + uint32_t x501; + uint32_t x502; + uint32_t x503; + uint32_t x504; + uint32_t x505; + uint32_t x506; + uint32_t x507; + uint32_t x508; + uint32_t x509; + uint32_t x510; + uint32_t x511; + uint32_t x512; + uint32_t x513; + uint32_t x514; + uint32_t x515; + uint32_t x516; + uint32_t x517; + fiat_p384_scalar_uint1 x518; + uint32_t x519; + fiat_p384_scalar_uint1 x520; + uint32_t x521; + fiat_p384_scalar_uint1 x522; + uint32_t x523; + fiat_p384_scalar_uint1 x524; + uint32_t x525; + fiat_p384_scalar_uint1 x526; + uint32_t x527; + fiat_p384_scalar_uint1 x528; + uint32_t x529; + fiat_p384_scalar_uint1 x530; + uint32_t x531; + fiat_p384_scalar_uint1 x532; + uint32_t x533; + fiat_p384_scalar_uint1 x534; + uint32_t x535; + fiat_p384_scalar_uint1 x536; + uint32_t x537; + fiat_p384_scalar_uint1 x538; + uint32_t x539; + fiat_p384_scalar_uint1 x540; + uint32_t x541; + fiat_p384_scalar_uint1 x542; + uint32_t x543; + fiat_p384_scalar_uint1 x544; + uint32_t x545; + fiat_p384_scalar_uint1 x546; + uint32_t x547; + fiat_p384_scalar_uint1 x548; + uint32_t x549; + fiat_p384_scalar_uint1 x550; + uint32_t x551; + fiat_p384_scalar_uint1 x552; + uint32_t x553; + fiat_p384_scalar_uint1 x554; + uint32_t x555; + fiat_p384_scalar_uint1 x556; + uint32_t x557; + fiat_p384_scalar_uint1 x558; + uint32_t x559; + fiat_p384_scalar_uint1 x560; + uint32_t x561; + fiat_p384_scalar_uint1 x562; + uint32_t x563; + fiat_p384_scalar_uint1 x564; + uint32_t x565; + uint32_t x566; + uint32_t x567; + uint32_t x568; + uint32_t x569; + uint32_t x570; + uint32_t x571; + uint32_t x572; + uint32_t x573; + uint32_t x574; + uint32_t x575; + uint32_t x576; + uint32_t x577; + uint32_t x578; + uint32_t x579; + uint32_t x580; + uint32_t x581; + uint32_t x582; + uint32_t x583; + uint32_t x584; + uint32_t x585; + uint32_t x586; + uint32_t x587; + uint32_t x588; + uint32_t x589; + fiat_p384_scalar_uint1 x590; + uint32_t x591; + fiat_p384_scalar_uint1 x592; + uint32_t x593; + fiat_p384_scalar_uint1 x594; + uint32_t x595; + fiat_p384_scalar_uint1 x596; + uint32_t x597; + fiat_p384_scalar_uint1 x598; + uint32_t x599; + fiat_p384_scalar_uint1 x600; + uint32_t x601; + fiat_p384_scalar_uint1 x602; + uint32_t x603; + fiat_p384_scalar_uint1 x604; + uint32_t x605; + fiat_p384_scalar_uint1 x606; + uint32_t x607; + fiat_p384_scalar_uint1 x608; + uint32_t x609; + fiat_p384_scalar_uint1 x610; + uint32_t x611; + fiat_p384_scalar_uint1 x612; + uint32_t x613; + fiat_p384_scalar_uint1 x614; + uint32_t x615; + fiat_p384_scalar_uint1 x616; + uint32_t x617; + fiat_p384_scalar_uint1 x618; + uint32_t x619; + fiat_p384_scalar_uint1 x620; + uint32_t x621; + fiat_p384_scalar_uint1 x622; + uint32_t x623; + fiat_p384_scalar_uint1 x624; + uint32_t x625; + fiat_p384_scalar_uint1 x626; + uint32_t x627; + fiat_p384_scalar_uint1 x628; + uint32_t x629; + fiat_p384_scalar_uint1 x630; + uint32_t x631; + fiat_p384_scalar_uint1 x632; + uint32_t x633; + fiat_p384_scalar_uint1 x634; + uint32_t x635; + uint32_t x636; + uint32_t x637; + uint32_t x638; + uint32_t x639; + uint32_t x640; + uint32_t x641; + uint32_t x642; + uint32_t x643; + uint32_t x644; + uint32_t x645; + uint32_t x646; + uint32_t x647; + uint32_t x648; + uint32_t x649; + uint32_t x650; + uint32_t x651; + uint32_t x652; + uint32_t x653; + uint32_t x654; + uint32_t x655; + uint32_t x656; + uint32_t x657; + uint32_t x658; + uint32_t x659; + uint32_t x660; + uint32_t x661; + fiat_p384_scalar_uint1 x662; + uint32_t x663; + fiat_p384_scalar_uint1 x664; + uint32_t x665; + fiat_p384_scalar_uint1 x666; + uint32_t x667; + fiat_p384_scalar_uint1 x668; + uint32_t x669; + fiat_p384_scalar_uint1 x670; + uint32_t x671; + fiat_p384_scalar_uint1 x672; + uint32_t x673; + fiat_p384_scalar_uint1 x674; + uint32_t x675; + fiat_p384_scalar_uint1 x676; + uint32_t x677; + fiat_p384_scalar_uint1 x678; + uint32_t x679; + fiat_p384_scalar_uint1 x680; + uint32_t x681; + fiat_p384_scalar_uint1 x682; + uint32_t x683; + fiat_p384_scalar_uint1 x684; + uint32_t x685; + fiat_p384_scalar_uint1 x686; + uint32_t x687; + fiat_p384_scalar_uint1 x688; + uint32_t x689; + fiat_p384_scalar_uint1 x690; + uint32_t x691; + fiat_p384_scalar_uint1 x692; + uint32_t x693; + fiat_p384_scalar_uint1 x694; + uint32_t x695; + fiat_p384_scalar_uint1 x696; + uint32_t x697; + fiat_p384_scalar_uint1 x698; + uint32_t x699; + fiat_p384_scalar_uint1 x700; + uint32_t x701; + fiat_p384_scalar_uint1 x702; + uint32_t x703; + fiat_p384_scalar_uint1 x704; + uint32_t x705; + fiat_p384_scalar_uint1 x706; + uint32_t x707; + fiat_p384_scalar_uint1 x708; + uint32_t x709; + uint32_t x710; + uint32_t x711; + uint32_t x712; + uint32_t x713; + uint32_t x714; + uint32_t x715; + uint32_t x716; + uint32_t x717; + uint32_t x718; + uint32_t x719; + uint32_t x720; + uint32_t x721; + uint32_t x722; + uint32_t x723; + uint32_t x724; + uint32_t x725; + uint32_t x726; + uint32_t x727; + uint32_t x728; + uint32_t x729; + uint32_t x730; + uint32_t x731; + uint32_t x732; + uint32_t x733; + fiat_p384_scalar_uint1 x734; + uint32_t x735; + fiat_p384_scalar_uint1 x736; + uint32_t x737; + fiat_p384_scalar_uint1 x738; + uint32_t x739; + fiat_p384_scalar_uint1 x740; + uint32_t x741; + fiat_p384_scalar_uint1 x742; + uint32_t x743; + fiat_p384_scalar_uint1 x744; + uint32_t x745; + fiat_p384_scalar_uint1 x746; + uint32_t x747; + fiat_p384_scalar_uint1 x748; + uint32_t x749; + fiat_p384_scalar_uint1 x750; + uint32_t x751; + fiat_p384_scalar_uint1 x752; + uint32_t x753; + fiat_p384_scalar_uint1 x754; + uint32_t x755; + fiat_p384_scalar_uint1 x756; + uint32_t x757; + fiat_p384_scalar_uint1 x758; + uint32_t x759; + fiat_p384_scalar_uint1 x760; + uint32_t x761; + fiat_p384_scalar_uint1 x762; + uint32_t x763; + fiat_p384_scalar_uint1 x764; + uint32_t x765; + fiat_p384_scalar_uint1 x766; + uint32_t x767; + fiat_p384_scalar_uint1 x768; + uint32_t x769; + fiat_p384_scalar_uint1 x770; + uint32_t x771; + fiat_p384_scalar_uint1 x772; + uint32_t x773; + fiat_p384_scalar_uint1 x774; + uint32_t x775; + fiat_p384_scalar_uint1 x776; + uint32_t x777; + fiat_p384_scalar_uint1 x778; + uint32_t x779; + uint32_t x780; + uint32_t x781; + uint32_t x782; + uint32_t x783; + uint32_t x784; + uint32_t x785; + uint32_t x786; + uint32_t x787; + uint32_t x788; + uint32_t x789; + uint32_t x790; + uint32_t x791; + uint32_t x792; + uint32_t x793; + uint32_t x794; + uint32_t x795; + uint32_t x796; + uint32_t x797; + uint32_t x798; + uint32_t x799; + uint32_t x800; + uint32_t x801; + uint32_t x802; + uint32_t x803; + uint32_t x804; + uint32_t x805; + fiat_p384_scalar_uint1 x806; + uint32_t x807; + fiat_p384_scalar_uint1 x808; + uint32_t x809; + fiat_p384_scalar_uint1 x810; + uint32_t x811; + fiat_p384_scalar_uint1 x812; + uint32_t x813; + fiat_p384_scalar_uint1 x814; + uint32_t x815; + fiat_p384_scalar_uint1 x816; + uint32_t x817; + fiat_p384_scalar_uint1 x818; + uint32_t x819; + fiat_p384_scalar_uint1 x820; + uint32_t x821; + fiat_p384_scalar_uint1 x822; + uint32_t x823; + fiat_p384_scalar_uint1 x824; + uint32_t x825; + fiat_p384_scalar_uint1 x826; + uint32_t x827; + fiat_p384_scalar_uint1 x828; + uint32_t x829; + fiat_p384_scalar_uint1 x830; + uint32_t x831; + fiat_p384_scalar_uint1 x832; + uint32_t x833; + fiat_p384_scalar_uint1 x834; + uint32_t x835; + fiat_p384_scalar_uint1 x836; + uint32_t x837; + fiat_p384_scalar_uint1 x838; + uint32_t x839; + fiat_p384_scalar_uint1 x840; + uint32_t x841; + fiat_p384_scalar_uint1 x842; + uint32_t x843; + fiat_p384_scalar_uint1 x844; + uint32_t x845; + fiat_p384_scalar_uint1 x846; + uint32_t x847; + fiat_p384_scalar_uint1 x848; + uint32_t x849; + fiat_p384_scalar_uint1 x850; + uint32_t x851; + fiat_p384_scalar_uint1 x852; + uint32_t x853; + uint32_t x854; + uint32_t x855; + uint32_t x856; + uint32_t x857; + uint32_t x858; + uint32_t x859; + uint32_t x860; + uint32_t x861; + uint32_t x862; + uint32_t x863; + uint32_t x864; + uint32_t x865; + uint32_t x866; + uint32_t x867; + uint32_t x868; + uint32_t x869; + uint32_t x870; + uint32_t x871; + uint32_t x872; + uint32_t x873; + uint32_t x874; + uint32_t x875; + uint32_t x876; + uint32_t x877; + fiat_p384_scalar_uint1 x878; + uint32_t x879; + fiat_p384_scalar_uint1 x880; + uint32_t x881; + fiat_p384_scalar_uint1 x882; + uint32_t x883; + fiat_p384_scalar_uint1 x884; + uint32_t x885; + fiat_p384_scalar_uint1 x886; + uint32_t x887; + fiat_p384_scalar_uint1 x888; + uint32_t x889; + fiat_p384_scalar_uint1 x890; + uint32_t x891; + fiat_p384_scalar_uint1 x892; + uint32_t x893; + fiat_p384_scalar_uint1 x894; + uint32_t x895; + fiat_p384_scalar_uint1 x896; + uint32_t x897; + fiat_p384_scalar_uint1 x898; + uint32_t x899; + fiat_p384_scalar_uint1 x900; + uint32_t x901; + fiat_p384_scalar_uint1 x902; + uint32_t x903; + fiat_p384_scalar_uint1 x904; + uint32_t x905; + fiat_p384_scalar_uint1 x906; + uint32_t x907; + fiat_p384_scalar_uint1 x908; + uint32_t x909; + fiat_p384_scalar_uint1 x910; + uint32_t x911; + fiat_p384_scalar_uint1 x912; + uint32_t x913; + fiat_p384_scalar_uint1 x914; + uint32_t x915; + fiat_p384_scalar_uint1 x916; + uint32_t x917; + fiat_p384_scalar_uint1 x918; + uint32_t x919; + fiat_p384_scalar_uint1 x920; + uint32_t x921; + fiat_p384_scalar_uint1 x922; + uint32_t x923; + uint32_t x924; + uint32_t x925; + uint32_t x926; + uint32_t x927; + uint32_t x928; + uint32_t x929; + uint32_t x930; + uint32_t x931; + uint32_t x932; + uint32_t x933; + uint32_t x934; + uint32_t x935; + uint32_t x936; + uint32_t x937; + uint32_t x938; + uint32_t x939; + uint32_t x940; + uint32_t x941; + uint32_t x942; + uint32_t x943; + uint32_t x944; + uint32_t x945; + uint32_t x946; + uint32_t x947; + uint32_t x948; + uint32_t x949; + fiat_p384_scalar_uint1 x950; + uint32_t x951; + fiat_p384_scalar_uint1 x952; + uint32_t x953; + fiat_p384_scalar_uint1 x954; + uint32_t x955; + fiat_p384_scalar_uint1 x956; + uint32_t x957; + fiat_p384_scalar_uint1 x958; + uint32_t x959; + fiat_p384_scalar_uint1 x960; + uint32_t x961; + fiat_p384_scalar_uint1 x962; + uint32_t x963; + fiat_p384_scalar_uint1 x964; + uint32_t x965; + fiat_p384_scalar_uint1 x966; + uint32_t x967; + fiat_p384_scalar_uint1 x968; + uint32_t x969; + fiat_p384_scalar_uint1 x970; + uint32_t x971; + fiat_p384_scalar_uint1 x972; + uint32_t x973; + fiat_p384_scalar_uint1 x974; + uint32_t x975; + fiat_p384_scalar_uint1 x976; + uint32_t x977; + fiat_p384_scalar_uint1 x978; + uint32_t x979; + fiat_p384_scalar_uint1 x980; + uint32_t x981; + fiat_p384_scalar_uint1 x982; + uint32_t x983; + fiat_p384_scalar_uint1 x984; + uint32_t x985; + fiat_p384_scalar_uint1 x986; + uint32_t x987; + fiat_p384_scalar_uint1 x988; + uint32_t x989; + fiat_p384_scalar_uint1 x990; + uint32_t x991; + fiat_p384_scalar_uint1 x992; + uint32_t x993; + fiat_p384_scalar_uint1 x994; + uint32_t x995; + fiat_p384_scalar_uint1 x996; + uint32_t x997; + uint32_t x998; + uint32_t x999; + uint32_t x1000; + uint32_t x1001; + uint32_t x1002; + uint32_t x1003; + uint32_t x1004; + uint32_t x1005; + uint32_t x1006; + uint32_t x1007; + uint32_t x1008; + uint32_t x1009; + uint32_t x1010; + uint32_t x1011; + uint32_t x1012; + uint32_t x1013; + uint32_t x1014; + uint32_t x1015; + uint32_t x1016; + uint32_t x1017; + uint32_t x1018; + uint32_t x1019; + uint32_t x1020; + uint32_t x1021; + fiat_p384_scalar_uint1 x1022; + uint32_t x1023; + fiat_p384_scalar_uint1 x1024; + uint32_t x1025; + fiat_p384_scalar_uint1 x1026; + uint32_t x1027; + fiat_p384_scalar_uint1 x1028; + uint32_t x1029; + fiat_p384_scalar_uint1 x1030; + uint32_t x1031; + fiat_p384_scalar_uint1 x1032; + uint32_t x1033; + fiat_p384_scalar_uint1 x1034; + uint32_t x1035; + fiat_p384_scalar_uint1 x1036; + uint32_t x1037; + fiat_p384_scalar_uint1 x1038; + uint32_t x1039; + fiat_p384_scalar_uint1 x1040; + uint32_t x1041; + fiat_p384_scalar_uint1 x1042; + uint32_t x1043; + fiat_p384_scalar_uint1 x1044; + uint32_t x1045; + fiat_p384_scalar_uint1 x1046; + uint32_t x1047; + fiat_p384_scalar_uint1 x1048; + uint32_t x1049; + fiat_p384_scalar_uint1 x1050; + uint32_t x1051; + fiat_p384_scalar_uint1 x1052; + uint32_t x1053; + fiat_p384_scalar_uint1 x1054; + uint32_t x1055; + fiat_p384_scalar_uint1 x1056; + uint32_t x1057; + fiat_p384_scalar_uint1 x1058; + uint32_t x1059; + fiat_p384_scalar_uint1 x1060; + uint32_t x1061; + fiat_p384_scalar_uint1 x1062; + uint32_t x1063; + fiat_p384_scalar_uint1 x1064; + uint32_t x1065; + fiat_p384_scalar_uint1 x1066; + uint32_t x1067; + uint32_t x1068; + uint32_t x1069; + uint32_t x1070; + uint32_t x1071; + uint32_t x1072; + uint32_t x1073; + uint32_t x1074; + uint32_t x1075; + uint32_t x1076; + uint32_t x1077; + uint32_t x1078; + uint32_t x1079; + uint32_t x1080; + uint32_t x1081; + uint32_t x1082; + uint32_t x1083; + uint32_t x1084; + uint32_t x1085; + uint32_t x1086; + uint32_t x1087; + uint32_t x1088; + uint32_t x1089; + uint32_t x1090; + uint32_t x1091; + uint32_t x1092; + uint32_t x1093; + fiat_p384_scalar_uint1 x1094; + uint32_t x1095; + fiat_p384_scalar_uint1 x1096; + uint32_t x1097; + fiat_p384_scalar_uint1 x1098; + uint32_t x1099; + fiat_p384_scalar_uint1 x1100; + uint32_t x1101; + fiat_p384_scalar_uint1 x1102; + uint32_t x1103; + fiat_p384_scalar_uint1 x1104; + uint32_t x1105; + fiat_p384_scalar_uint1 x1106; + uint32_t x1107; + fiat_p384_scalar_uint1 x1108; + uint32_t x1109; + fiat_p384_scalar_uint1 x1110; + uint32_t x1111; + fiat_p384_scalar_uint1 x1112; + uint32_t x1113; + fiat_p384_scalar_uint1 x1114; + uint32_t x1115; + fiat_p384_scalar_uint1 x1116; + uint32_t x1117; + fiat_p384_scalar_uint1 x1118; + uint32_t x1119; + fiat_p384_scalar_uint1 x1120; + uint32_t x1121; + fiat_p384_scalar_uint1 x1122; + uint32_t x1123; + fiat_p384_scalar_uint1 x1124; + uint32_t x1125; + fiat_p384_scalar_uint1 x1126; + uint32_t x1127; + fiat_p384_scalar_uint1 x1128; + uint32_t x1129; + fiat_p384_scalar_uint1 x1130; + uint32_t x1131; + fiat_p384_scalar_uint1 x1132; + uint32_t x1133; + fiat_p384_scalar_uint1 x1134; + uint32_t x1135; + fiat_p384_scalar_uint1 x1136; + uint32_t x1137; + fiat_p384_scalar_uint1 x1138; + uint32_t x1139; + fiat_p384_scalar_uint1 x1140; + uint32_t x1141; + uint32_t x1142; + uint32_t x1143; + uint32_t x1144; + uint32_t x1145; + uint32_t x1146; + uint32_t x1147; + uint32_t x1148; + uint32_t x1149; + uint32_t x1150; + uint32_t x1151; + uint32_t x1152; + uint32_t x1153; + uint32_t x1154; + uint32_t x1155; + uint32_t x1156; + uint32_t x1157; + uint32_t x1158; + uint32_t x1159; + uint32_t x1160; + uint32_t x1161; + uint32_t x1162; + uint32_t x1163; + uint32_t x1164; + uint32_t x1165; + fiat_p384_scalar_uint1 x1166; + uint32_t x1167; + fiat_p384_scalar_uint1 x1168; + uint32_t x1169; + fiat_p384_scalar_uint1 x1170; + uint32_t x1171; + fiat_p384_scalar_uint1 x1172; + uint32_t x1173; + fiat_p384_scalar_uint1 x1174; + uint32_t x1175; + fiat_p384_scalar_uint1 x1176; + uint32_t x1177; + fiat_p384_scalar_uint1 x1178; + uint32_t x1179; + fiat_p384_scalar_uint1 x1180; + uint32_t x1181; + fiat_p384_scalar_uint1 x1182; + uint32_t x1183; + fiat_p384_scalar_uint1 x1184; + uint32_t x1185; + fiat_p384_scalar_uint1 x1186; + uint32_t x1187; + fiat_p384_scalar_uint1 x1188; + uint32_t x1189; + fiat_p384_scalar_uint1 x1190; + uint32_t x1191; + fiat_p384_scalar_uint1 x1192; + uint32_t x1193; + fiat_p384_scalar_uint1 x1194; + uint32_t x1195; + fiat_p384_scalar_uint1 x1196; + uint32_t x1197; + fiat_p384_scalar_uint1 x1198; + uint32_t x1199; + fiat_p384_scalar_uint1 x1200; + uint32_t x1201; + fiat_p384_scalar_uint1 x1202; + uint32_t x1203; + fiat_p384_scalar_uint1 x1204; + uint32_t x1205; + fiat_p384_scalar_uint1 x1206; + uint32_t x1207; + fiat_p384_scalar_uint1 x1208; + uint32_t x1209; + fiat_p384_scalar_uint1 x1210; + uint32_t x1211; + uint32_t x1212; + uint32_t x1213; + uint32_t x1214; + uint32_t x1215; + uint32_t x1216; + uint32_t x1217; + uint32_t x1218; + uint32_t x1219; + uint32_t x1220; + uint32_t x1221; + uint32_t x1222; + uint32_t x1223; + uint32_t x1224; + uint32_t x1225; + uint32_t x1226; + uint32_t x1227; + uint32_t x1228; + uint32_t x1229; + uint32_t x1230; + uint32_t x1231; + uint32_t x1232; + uint32_t x1233; + uint32_t x1234; + uint32_t x1235; + uint32_t x1236; + uint32_t x1237; + fiat_p384_scalar_uint1 x1238; + uint32_t x1239; + fiat_p384_scalar_uint1 x1240; + uint32_t x1241; + fiat_p384_scalar_uint1 x1242; + uint32_t x1243; + fiat_p384_scalar_uint1 x1244; + uint32_t x1245; + fiat_p384_scalar_uint1 x1246; + uint32_t x1247; + fiat_p384_scalar_uint1 x1248; + uint32_t x1249; + fiat_p384_scalar_uint1 x1250; + uint32_t x1251; + fiat_p384_scalar_uint1 x1252; + uint32_t x1253; + fiat_p384_scalar_uint1 x1254; + uint32_t x1255; + fiat_p384_scalar_uint1 x1256; + uint32_t x1257; + fiat_p384_scalar_uint1 x1258; + uint32_t x1259; + fiat_p384_scalar_uint1 x1260; + uint32_t x1261; + fiat_p384_scalar_uint1 x1262; + uint32_t x1263; + fiat_p384_scalar_uint1 x1264; + uint32_t x1265; + fiat_p384_scalar_uint1 x1266; + uint32_t x1267; + fiat_p384_scalar_uint1 x1268; + uint32_t x1269; + fiat_p384_scalar_uint1 x1270; + uint32_t x1271; + fiat_p384_scalar_uint1 x1272; + uint32_t x1273; + fiat_p384_scalar_uint1 x1274; + uint32_t x1275; + fiat_p384_scalar_uint1 x1276; + uint32_t x1277; + fiat_p384_scalar_uint1 x1278; + uint32_t x1279; + fiat_p384_scalar_uint1 x1280; + uint32_t x1281; + fiat_p384_scalar_uint1 x1282; + uint32_t x1283; + fiat_p384_scalar_uint1 x1284; + uint32_t x1285; + uint32_t x1286; + uint32_t x1287; + uint32_t x1288; + uint32_t x1289; + uint32_t x1290; + uint32_t x1291; + uint32_t x1292; + uint32_t x1293; + uint32_t x1294; + uint32_t x1295; + uint32_t x1296; + uint32_t x1297; + uint32_t x1298; + uint32_t x1299; + uint32_t x1300; + uint32_t x1301; + uint32_t x1302; + uint32_t x1303; + uint32_t x1304; + uint32_t x1305; + uint32_t x1306; + uint32_t x1307; + uint32_t x1308; + uint32_t x1309; + fiat_p384_scalar_uint1 x1310; + uint32_t x1311; + fiat_p384_scalar_uint1 x1312; + uint32_t x1313; + fiat_p384_scalar_uint1 x1314; + uint32_t x1315; + fiat_p384_scalar_uint1 x1316; + uint32_t x1317; + fiat_p384_scalar_uint1 x1318; + uint32_t x1319; + fiat_p384_scalar_uint1 x1320; + uint32_t x1321; + fiat_p384_scalar_uint1 x1322; + uint32_t x1323; + fiat_p384_scalar_uint1 x1324; + uint32_t x1325; + fiat_p384_scalar_uint1 x1326; + uint32_t x1327; + fiat_p384_scalar_uint1 x1328; + uint32_t x1329; + fiat_p384_scalar_uint1 x1330; + uint32_t x1331; + fiat_p384_scalar_uint1 x1332; + uint32_t x1333; + fiat_p384_scalar_uint1 x1334; + uint32_t x1335; + fiat_p384_scalar_uint1 x1336; + uint32_t x1337; + fiat_p384_scalar_uint1 x1338; + uint32_t x1339; + fiat_p384_scalar_uint1 x1340; + uint32_t x1341; + fiat_p384_scalar_uint1 x1342; + uint32_t x1343; + fiat_p384_scalar_uint1 x1344; + uint32_t x1345; + fiat_p384_scalar_uint1 x1346; + uint32_t x1347; + fiat_p384_scalar_uint1 x1348; + uint32_t x1349; + fiat_p384_scalar_uint1 x1350; + uint32_t x1351; + fiat_p384_scalar_uint1 x1352; + uint32_t x1353; + fiat_p384_scalar_uint1 x1354; + uint32_t x1355; + uint32_t x1356; + uint32_t x1357; + uint32_t x1358; + uint32_t x1359; + uint32_t x1360; + uint32_t x1361; + uint32_t x1362; + uint32_t x1363; + uint32_t x1364; + uint32_t x1365; + uint32_t x1366; + uint32_t x1367; + uint32_t x1368; + uint32_t x1369; + uint32_t x1370; + uint32_t x1371; + uint32_t x1372; + uint32_t x1373; + uint32_t x1374; + uint32_t x1375; + uint32_t x1376; + uint32_t x1377; + uint32_t x1378; + uint32_t x1379; + uint32_t x1380; + uint32_t x1381; + fiat_p384_scalar_uint1 x1382; + uint32_t x1383; + fiat_p384_scalar_uint1 x1384; + uint32_t x1385; + fiat_p384_scalar_uint1 x1386; + uint32_t x1387; + fiat_p384_scalar_uint1 x1388; + uint32_t x1389; + fiat_p384_scalar_uint1 x1390; + uint32_t x1391; + fiat_p384_scalar_uint1 x1392; + uint32_t x1393; + fiat_p384_scalar_uint1 x1394; + uint32_t x1395; + fiat_p384_scalar_uint1 x1396; + uint32_t x1397; + fiat_p384_scalar_uint1 x1398; + uint32_t x1399; + fiat_p384_scalar_uint1 x1400; + uint32_t x1401; + fiat_p384_scalar_uint1 x1402; + uint32_t x1403; + fiat_p384_scalar_uint1 x1404; + uint32_t x1405; + fiat_p384_scalar_uint1 x1406; + uint32_t x1407; + fiat_p384_scalar_uint1 x1408; + uint32_t x1409; + fiat_p384_scalar_uint1 x1410; + uint32_t x1411; + fiat_p384_scalar_uint1 x1412; + uint32_t x1413; + fiat_p384_scalar_uint1 x1414; + uint32_t x1415; + fiat_p384_scalar_uint1 x1416; + uint32_t x1417; + fiat_p384_scalar_uint1 x1418; + uint32_t x1419; + fiat_p384_scalar_uint1 x1420; + uint32_t x1421; + fiat_p384_scalar_uint1 x1422; + uint32_t x1423; + fiat_p384_scalar_uint1 x1424; + uint32_t x1425; + fiat_p384_scalar_uint1 x1426; + uint32_t x1427; + fiat_p384_scalar_uint1 x1428; + uint32_t x1429; + uint32_t x1430; + uint32_t x1431; + uint32_t x1432; + uint32_t x1433; + uint32_t x1434; + uint32_t x1435; + uint32_t x1436; + uint32_t x1437; + uint32_t x1438; + uint32_t x1439; + uint32_t x1440; + uint32_t x1441; + uint32_t x1442; + uint32_t x1443; + uint32_t x1444; + uint32_t x1445; + uint32_t x1446; + uint32_t x1447; + uint32_t x1448; + uint32_t x1449; + uint32_t x1450; + uint32_t x1451; + uint32_t x1452; + uint32_t x1453; + fiat_p384_scalar_uint1 x1454; + uint32_t x1455; + fiat_p384_scalar_uint1 x1456; + uint32_t x1457; + fiat_p384_scalar_uint1 x1458; + uint32_t x1459; + fiat_p384_scalar_uint1 x1460; + uint32_t x1461; + fiat_p384_scalar_uint1 x1462; + uint32_t x1463; + fiat_p384_scalar_uint1 x1464; + uint32_t x1465; + fiat_p384_scalar_uint1 x1466; + uint32_t x1467; + fiat_p384_scalar_uint1 x1468; + uint32_t x1469; + fiat_p384_scalar_uint1 x1470; + uint32_t x1471; + fiat_p384_scalar_uint1 x1472; + uint32_t x1473; + fiat_p384_scalar_uint1 x1474; + uint32_t x1475; + fiat_p384_scalar_uint1 x1476; + uint32_t x1477; + fiat_p384_scalar_uint1 x1478; + uint32_t x1479; + fiat_p384_scalar_uint1 x1480; + uint32_t x1481; + fiat_p384_scalar_uint1 x1482; + uint32_t x1483; + fiat_p384_scalar_uint1 x1484; + uint32_t x1485; + fiat_p384_scalar_uint1 x1486; + uint32_t x1487; + fiat_p384_scalar_uint1 x1488; + uint32_t x1489; + fiat_p384_scalar_uint1 x1490; + uint32_t x1491; + fiat_p384_scalar_uint1 x1492; + uint32_t x1493; + fiat_p384_scalar_uint1 x1494; + uint32_t x1495; + fiat_p384_scalar_uint1 x1496; + uint32_t x1497; + fiat_p384_scalar_uint1 x1498; + uint32_t x1499; + uint32_t x1500; + uint32_t x1501; + uint32_t x1502; + uint32_t x1503; + uint32_t x1504; + uint32_t x1505; + uint32_t x1506; + uint32_t x1507; + uint32_t x1508; + uint32_t x1509; + uint32_t x1510; + uint32_t x1511; + uint32_t x1512; + uint32_t x1513; + uint32_t x1514; + uint32_t x1515; + uint32_t x1516; + uint32_t x1517; + uint32_t x1518; + uint32_t x1519; + uint32_t x1520; + uint32_t x1521; + uint32_t x1522; + uint32_t x1523; + uint32_t x1524; + uint32_t x1525; + fiat_p384_scalar_uint1 x1526; + uint32_t x1527; + fiat_p384_scalar_uint1 x1528; + uint32_t x1529; + fiat_p384_scalar_uint1 x1530; + uint32_t x1531; + fiat_p384_scalar_uint1 x1532; + uint32_t x1533; + fiat_p384_scalar_uint1 x1534; + uint32_t x1535; + fiat_p384_scalar_uint1 x1536; + uint32_t x1537; + fiat_p384_scalar_uint1 x1538; + uint32_t x1539; + fiat_p384_scalar_uint1 x1540; + uint32_t x1541; + fiat_p384_scalar_uint1 x1542; + uint32_t x1543; + fiat_p384_scalar_uint1 x1544; + uint32_t x1545; + fiat_p384_scalar_uint1 x1546; + uint32_t x1547; + fiat_p384_scalar_uint1 x1548; + uint32_t x1549; + fiat_p384_scalar_uint1 x1550; + uint32_t x1551; + fiat_p384_scalar_uint1 x1552; + uint32_t x1553; + fiat_p384_scalar_uint1 x1554; + uint32_t x1555; + fiat_p384_scalar_uint1 x1556; + uint32_t x1557; + fiat_p384_scalar_uint1 x1558; + uint32_t x1559; + fiat_p384_scalar_uint1 x1560; + uint32_t x1561; + fiat_p384_scalar_uint1 x1562; + uint32_t x1563; + fiat_p384_scalar_uint1 x1564; + uint32_t x1565; + fiat_p384_scalar_uint1 x1566; + uint32_t x1567; + fiat_p384_scalar_uint1 x1568; + uint32_t x1569; + fiat_p384_scalar_uint1 x1570; + uint32_t x1571; + fiat_p384_scalar_uint1 x1572; + uint32_t x1573; + uint32_t x1574; + uint32_t x1575; + uint32_t x1576; + uint32_t x1577; + uint32_t x1578; + uint32_t x1579; + uint32_t x1580; + uint32_t x1581; + uint32_t x1582; + uint32_t x1583; + uint32_t x1584; + uint32_t x1585; + uint32_t x1586; + uint32_t x1587; + uint32_t x1588; + uint32_t x1589; + uint32_t x1590; + uint32_t x1591; + uint32_t x1592; + uint32_t x1593; + uint32_t x1594; + uint32_t x1595; + uint32_t x1596; + uint32_t x1597; + fiat_p384_scalar_uint1 x1598; + uint32_t x1599; + fiat_p384_scalar_uint1 x1600; + uint32_t x1601; + fiat_p384_scalar_uint1 x1602; + uint32_t x1603; + fiat_p384_scalar_uint1 x1604; + uint32_t x1605; + fiat_p384_scalar_uint1 x1606; + uint32_t x1607; + fiat_p384_scalar_uint1 x1608; + uint32_t x1609; + fiat_p384_scalar_uint1 x1610; + uint32_t x1611; + fiat_p384_scalar_uint1 x1612; + uint32_t x1613; + fiat_p384_scalar_uint1 x1614; + uint32_t x1615; + fiat_p384_scalar_uint1 x1616; + uint32_t x1617; + fiat_p384_scalar_uint1 x1618; + uint32_t x1619; + fiat_p384_scalar_uint1 x1620; + uint32_t x1621; + fiat_p384_scalar_uint1 x1622; + uint32_t x1623; + fiat_p384_scalar_uint1 x1624; + uint32_t x1625; + fiat_p384_scalar_uint1 x1626; + uint32_t x1627; + fiat_p384_scalar_uint1 x1628; + uint32_t x1629; + fiat_p384_scalar_uint1 x1630; + uint32_t x1631; + fiat_p384_scalar_uint1 x1632; + uint32_t x1633; + fiat_p384_scalar_uint1 x1634; + uint32_t x1635; + fiat_p384_scalar_uint1 x1636; + uint32_t x1637; + fiat_p384_scalar_uint1 x1638; + uint32_t x1639; + fiat_p384_scalar_uint1 x1640; + uint32_t x1641; + fiat_p384_scalar_uint1 x1642; + uint32_t x1643; + uint32_t x1644; + uint32_t x1645; + uint32_t x1646; + uint32_t x1647; + uint32_t x1648; + uint32_t x1649; + uint32_t x1650; + uint32_t x1651; + uint32_t x1652; + uint32_t x1653; + uint32_t x1654; + uint32_t x1655; + uint32_t x1656; + uint32_t x1657; + uint32_t x1658; + uint32_t x1659; + uint32_t x1660; + uint32_t x1661; + uint32_t x1662; + uint32_t x1663; + uint32_t x1664; + uint32_t x1665; + uint32_t x1666; + uint32_t x1667; + uint32_t x1668; + uint32_t x1669; + fiat_p384_scalar_uint1 x1670; + uint32_t x1671; + fiat_p384_scalar_uint1 x1672; + uint32_t x1673; + fiat_p384_scalar_uint1 x1674; + uint32_t x1675; + fiat_p384_scalar_uint1 x1676; + uint32_t x1677; + fiat_p384_scalar_uint1 x1678; + uint32_t x1679; + fiat_p384_scalar_uint1 x1680; + uint32_t x1681; + fiat_p384_scalar_uint1 x1682; + uint32_t x1683; + fiat_p384_scalar_uint1 x1684; + uint32_t x1685; + fiat_p384_scalar_uint1 x1686; + uint32_t x1687; + fiat_p384_scalar_uint1 x1688; + uint32_t x1689; + fiat_p384_scalar_uint1 x1690; + uint32_t x1691; + fiat_p384_scalar_uint1 x1692; + uint32_t x1693; + fiat_p384_scalar_uint1 x1694; + uint32_t x1695; + fiat_p384_scalar_uint1 x1696; + uint32_t x1697; + fiat_p384_scalar_uint1 x1698; + uint32_t x1699; + fiat_p384_scalar_uint1 x1700; + uint32_t x1701; + fiat_p384_scalar_uint1 x1702; + uint32_t x1703; + fiat_p384_scalar_uint1 x1704; + uint32_t x1705; + fiat_p384_scalar_uint1 x1706; + uint32_t x1707; + fiat_p384_scalar_uint1 x1708; + uint32_t x1709; + fiat_p384_scalar_uint1 x1710; + uint32_t x1711; + fiat_p384_scalar_uint1 x1712; + uint32_t x1713; + fiat_p384_scalar_uint1 x1714; + uint32_t x1715; + fiat_p384_scalar_uint1 x1716; + uint32_t x1717; + fiat_p384_scalar_uint1 x1718; + uint32_t x1719; + fiat_p384_scalar_uint1 x1720; + uint32_t x1721; + fiat_p384_scalar_uint1 x1722; + uint32_t x1723; + fiat_p384_scalar_uint1 x1724; + uint32_t x1725; + fiat_p384_scalar_uint1 x1726; + uint32_t x1727; + fiat_p384_scalar_uint1 x1728; + uint32_t x1729; + fiat_p384_scalar_uint1 x1730; + uint32_t x1731; + fiat_p384_scalar_uint1 x1732; + uint32_t x1733; + fiat_p384_scalar_uint1 x1734; + uint32_t x1735; + fiat_p384_scalar_uint1 x1736; + uint32_t x1737; + fiat_p384_scalar_uint1 x1738; + uint32_t x1739; + fiat_p384_scalar_uint1 x1740; + uint32_t x1741; + fiat_p384_scalar_uint1 x1742; + uint32_t x1743; + uint32_t x1744; + uint32_t x1745; + uint32_t x1746; + uint32_t x1747; + uint32_t x1748; + uint32_t x1749; + uint32_t x1750; + uint32_t x1751; + uint32_t x1752; + uint32_t x1753; + uint32_t x1754; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[6]); + x7 = (arg1[7]); + x8 = (arg1[8]); + x9 = (arg1[9]); + x10 = (arg1[10]); + x11 = (arg1[11]); + x12 = (arg1[0]); + fiat_p384_scalar_mulx_u32(&x13, &x14, x12, UINT32_C(0xc84ee01)); + fiat_p384_scalar_mulx_u32(&x15, &x16, x12, UINT32_C(0x2b39bf21)); + fiat_p384_scalar_mulx_u32(&x17, &x18, x12, UINT32_C(0x3fb05b7a)); + fiat_p384_scalar_mulx_u32(&x19, &x20, x12, UINT32_C(0x28266895)); + fiat_p384_scalar_mulx_u32(&x21, &x22, x12, UINT32_C(0xd40d4917)); + fiat_p384_scalar_mulx_u32(&x23, &x24, x12, UINT32_C(0x4aab1cc5)); + fiat_p384_scalar_mulx_u32(&x25, &x26, x12, UINT32_C(0xbc3e483a)); + fiat_p384_scalar_mulx_u32(&x27, &x28, x12, UINT32_C(0xfcb82947)); + fiat_p384_scalar_mulx_u32(&x29, &x30, x12, UINT32_C(0xff3d81e5)); + fiat_p384_scalar_mulx_u32(&x31, &x32, x12, UINT32_C(0xdf1aa419)); + fiat_p384_scalar_mulx_u32(&x33, &x34, x12, UINT32_C(0x2d319b24)); + fiat_p384_scalar_mulx_u32(&x35, &x36, x12, UINT32_C(0x19b409a9)); + fiat_p384_scalar_addcarryx_u32(&x37, &x38, 0x0, x36, x33); + fiat_p384_scalar_addcarryx_u32(&x39, &x40, x38, x34, x31); + fiat_p384_scalar_addcarryx_u32(&x41, &x42, x40, x32, x29); + fiat_p384_scalar_addcarryx_u32(&x43, &x44, x42, x30, x27); + fiat_p384_scalar_addcarryx_u32(&x45, &x46, x44, x28, x25); + fiat_p384_scalar_addcarryx_u32(&x47, &x48, x46, x26, x23); + fiat_p384_scalar_addcarryx_u32(&x49, &x50, x48, x24, x21); + fiat_p384_scalar_addcarryx_u32(&x51, &x52, x50, x22, x19); + fiat_p384_scalar_addcarryx_u32(&x53, &x54, x52, x20, x17); + fiat_p384_scalar_addcarryx_u32(&x55, &x56, x54, x18, x15); + fiat_p384_scalar_addcarryx_u32(&x57, &x58, x56, x16, x13); + fiat_p384_scalar_mulx_u32(&x59, &x60, x35, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x61, &x62, x59, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x63, &x64, x59, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x65, &x66, x59, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x67, &x68, x59, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x69, &x70, x59, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x71, &x72, x59, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x73, &x74, x59, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x75, &x76, x59, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x77, &x78, x59, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x79, &x80, x59, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x81, &x82, x59, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x83, &x84, x59, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x85, &x86, 0x0, x84, x81); + fiat_p384_scalar_addcarryx_u32(&x87, &x88, x86, x82, x79); + fiat_p384_scalar_addcarryx_u32(&x89, &x90, x88, x80, x77); + fiat_p384_scalar_addcarryx_u32(&x91, &x92, x90, x78, x75); + fiat_p384_scalar_addcarryx_u32(&x93, &x94, x92, x76, x73); + fiat_p384_scalar_addcarryx_u32(&x95, &x96, x94, x74, x71); + fiat_p384_scalar_addcarryx_u32(&x97, &x98, x96, x72, x69); + fiat_p384_scalar_addcarryx_u32(&x99, &x100, x98, x70, x67); + fiat_p384_scalar_addcarryx_u32(&x101, &x102, x100, x68, x65); + fiat_p384_scalar_addcarryx_u32(&x103, &x104, x102, x66, x63); + fiat_p384_scalar_addcarryx_u32(&x105, &x106, x104, x64, x61); + fiat_p384_scalar_addcarryx_u32(&x107, &x108, 0x0, x35, x83); + fiat_p384_scalar_addcarryx_u32(&x109, &x110, x108, x37, x85); + fiat_p384_scalar_addcarryx_u32(&x111, &x112, x110, x39, x87); + fiat_p384_scalar_addcarryx_u32(&x113, &x114, x112, x41, x89); + fiat_p384_scalar_addcarryx_u32(&x115, &x116, x114, x43, x91); + fiat_p384_scalar_addcarryx_u32(&x117, &x118, x116, x45, x93); + fiat_p384_scalar_addcarryx_u32(&x119, &x120, x118, x47, x95); + fiat_p384_scalar_addcarryx_u32(&x121, &x122, x120, x49, x97); + fiat_p384_scalar_addcarryx_u32(&x123, &x124, x122, x51, x99); + fiat_p384_scalar_addcarryx_u32(&x125, &x126, x124, x53, x101); + fiat_p384_scalar_addcarryx_u32(&x127, &x128, x126, x55, x103); + fiat_p384_scalar_addcarryx_u32(&x129, &x130, x128, x57, x105); + fiat_p384_scalar_addcarryx_u32(&x131, &x132, x130, (x58 + x14), (x106 + x62)); + fiat_p384_scalar_mulx_u32(&x133, &x134, x1, UINT32_C(0xc84ee01)); + fiat_p384_scalar_mulx_u32(&x135, &x136, x1, UINT32_C(0x2b39bf21)); + fiat_p384_scalar_mulx_u32(&x137, &x138, x1, UINT32_C(0x3fb05b7a)); + fiat_p384_scalar_mulx_u32(&x139, &x140, x1, UINT32_C(0x28266895)); + fiat_p384_scalar_mulx_u32(&x141, &x142, x1, UINT32_C(0xd40d4917)); + fiat_p384_scalar_mulx_u32(&x143, &x144, x1, UINT32_C(0x4aab1cc5)); + fiat_p384_scalar_mulx_u32(&x145, &x146, x1, UINT32_C(0xbc3e483a)); + fiat_p384_scalar_mulx_u32(&x147, &x148, x1, UINT32_C(0xfcb82947)); + fiat_p384_scalar_mulx_u32(&x149, &x150, x1, UINT32_C(0xff3d81e5)); + fiat_p384_scalar_mulx_u32(&x151, &x152, x1, UINT32_C(0xdf1aa419)); + fiat_p384_scalar_mulx_u32(&x153, &x154, x1, UINT32_C(0x2d319b24)); + fiat_p384_scalar_mulx_u32(&x155, &x156, x1, UINT32_C(0x19b409a9)); + fiat_p384_scalar_addcarryx_u32(&x157, &x158, 0x0, x156, x153); + fiat_p384_scalar_addcarryx_u32(&x159, &x160, x158, x154, x151); + fiat_p384_scalar_addcarryx_u32(&x161, &x162, x160, x152, x149); + fiat_p384_scalar_addcarryx_u32(&x163, &x164, x162, x150, x147); + fiat_p384_scalar_addcarryx_u32(&x165, &x166, x164, x148, x145); + fiat_p384_scalar_addcarryx_u32(&x167, &x168, x166, x146, x143); + fiat_p384_scalar_addcarryx_u32(&x169, &x170, x168, x144, x141); + fiat_p384_scalar_addcarryx_u32(&x171, &x172, x170, x142, x139); + fiat_p384_scalar_addcarryx_u32(&x173, &x174, x172, x140, x137); + fiat_p384_scalar_addcarryx_u32(&x175, &x176, x174, x138, x135); + fiat_p384_scalar_addcarryx_u32(&x177, &x178, x176, x136, x133); + fiat_p384_scalar_addcarryx_u32(&x179, &x180, 0x0, x109, x155); + fiat_p384_scalar_addcarryx_u32(&x181, &x182, x180, x111, x157); + fiat_p384_scalar_addcarryx_u32(&x183, &x184, x182, x113, x159); + fiat_p384_scalar_addcarryx_u32(&x185, &x186, x184, x115, x161); + fiat_p384_scalar_addcarryx_u32(&x187, &x188, x186, x117, x163); + fiat_p384_scalar_addcarryx_u32(&x189, &x190, x188, x119, x165); + fiat_p384_scalar_addcarryx_u32(&x191, &x192, x190, x121, x167); + fiat_p384_scalar_addcarryx_u32(&x193, &x194, x192, x123, x169); + fiat_p384_scalar_addcarryx_u32(&x195, &x196, x194, x125, x171); + fiat_p384_scalar_addcarryx_u32(&x197, &x198, x196, x127, x173); + fiat_p384_scalar_addcarryx_u32(&x199, &x200, x198, x129, x175); + fiat_p384_scalar_addcarryx_u32(&x201, &x202, x200, x131, x177); + fiat_p384_scalar_mulx_u32(&x203, &x204, x179, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x205, &x206, x203, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x207, &x208, x203, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x209, &x210, x203, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x211, &x212, x203, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x213, &x214, x203, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x215, &x216, x203, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x217, &x218, x203, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x219, &x220, x203, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x221, &x222, x203, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x223, &x224, x203, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x225, &x226, x203, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x227, &x228, x203, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x229, &x230, 0x0, x228, x225); + fiat_p384_scalar_addcarryx_u32(&x231, &x232, x230, x226, x223); + fiat_p384_scalar_addcarryx_u32(&x233, &x234, x232, x224, x221); + fiat_p384_scalar_addcarryx_u32(&x235, &x236, x234, x222, x219); + fiat_p384_scalar_addcarryx_u32(&x237, &x238, x236, x220, x217); + fiat_p384_scalar_addcarryx_u32(&x239, &x240, x238, x218, x215); + fiat_p384_scalar_addcarryx_u32(&x241, &x242, x240, x216, x213); + fiat_p384_scalar_addcarryx_u32(&x243, &x244, x242, x214, x211); + fiat_p384_scalar_addcarryx_u32(&x245, &x246, x244, x212, x209); + fiat_p384_scalar_addcarryx_u32(&x247, &x248, x246, x210, x207); + fiat_p384_scalar_addcarryx_u32(&x249, &x250, x248, x208, x205); + fiat_p384_scalar_addcarryx_u32(&x251, &x252, 0x0, x179, x227); + fiat_p384_scalar_addcarryx_u32(&x253, &x254, x252, x181, x229); + fiat_p384_scalar_addcarryx_u32(&x255, &x256, x254, x183, x231); + fiat_p384_scalar_addcarryx_u32(&x257, &x258, x256, x185, x233); + fiat_p384_scalar_addcarryx_u32(&x259, &x260, x258, x187, x235); + fiat_p384_scalar_addcarryx_u32(&x261, &x262, x260, x189, x237); + fiat_p384_scalar_addcarryx_u32(&x263, &x264, x262, x191, x239); + fiat_p384_scalar_addcarryx_u32(&x265, &x266, x264, x193, x241); + fiat_p384_scalar_addcarryx_u32(&x267, &x268, x266, x195, x243); + fiat_p384_scalar_addcarryx_u32(&x269, &x270, x268, x197, x245); + fiat_p384_scalar_addcarryx_u32(&x271, &x272, x270, x199, x247); + fiat_p384_scalar_addcarryx_u32(&x273, &x274, x272, x201, x249); + fiat_p384_scalar_addcarryx_u32(&x275, &x276, x274, (((uint32_t)x202 + x132) + (x178 + x134)), (x250 + x206)); + fiat_p384_scalar_mulx_u32(&x277, &x278, x2, UINT32_C(0xc84ee01)); + fiat_p384_scalar_mulx_u32(&x279, &x280, x2, UINT32_C(0x2b39bf21)); + fiat_p384_scalar_mulx_u32(&x281, &x282, x2, UINT32_C(0x3fb05b7a)); + fiat_p384_scalar_mulx_u32(&x283, &x284, x2, UINT32_C(0x28266895)); + fiat_p384_scalar_mulx_u32(&x285, &x286, x2, UINT32_C(0xd40d4917)); + fiat_p384_scalar_mulx_u32(&x287, &x288, x2, UINT32_C(0x4aab1cc5)); + fiat_p384_scalar_mulx_u32(&x289, &x290, x2, UINT32_C(0xbc3e483a)); + fiat_p384_scalar_mulx_u32(&x291, &x292, x2, UINT32_C(0xfcb82947)); + fiat_p384_scalar_mulx_u32(&x293, &x294, x2, UINT32_C(0xff3d81e5)); + fiat_p384_scalar_mulx_u32(&x295, &x296, x2, UINT32_C(0xdf1aa419)); + fiat_p384_scalar_mulx_u32(&x297, &x298, x2, UINT32_C(0x2d319b24)); + fiat_p384_scalar_mulx_u32(&x299, &x300, x2, UINT32_C(0x19b409a9)); + fiat_p384_scalar_addcarryx_u32(&x301, &x302, 0x0, x300, x297); + fiat_p384_scalar_addcarryx_u32(&x303, &x304, x302, x298, x295); + fiat_p384_scalar_addcarryx_u32(&x305, &x306, x304, x296, x293); + fiat_p384_scalar_addcarryx_u32(&x307, &x308, x306, x294, x291); + fiat_p384_scalar_addcarryx_u32(&x309, &x310, x308, x292, x289); + fiat_p384_scalar_addcarryx_u32(&x311, &x312, x310, x290, x287); + fiat_p384_scalar_addcarryx_u32(&x313, &x314, x312, x288, x285); + fiat_p384_scalar_addcarryx_u32(&x315, &x316, x314, x286, x283); + fiat_p384_scalar_addcarryx_u32(&x317, &x318, x316, x284, x281); + fiat_p384_scalar_addcarryx_u32(&x319, &x320, x318, x282, x279); + fiat_p384_scalar_addcarryx_u32(&x321, &x322, x320, x280, x277); + fiat_p384_scalar_addcarryx_u32(&x323, &x324, 0x0, x253, x299); + fiat_p384_scalar_addcarryx_u32(&x325, &x326, x324, x255, x301); + fiat_p384_scalar_addcarryx_u32(&x327, &x328, x326, x257, x303); + fiat_p384_scalar_addcarryx_u32(&x329, &x330, x328, x259, x305); + fiat_p384_scalar_addcarryx_u32(&x331, &x332, x330, x261, x307); + fiat_p384_scalar_addcarryx_u32(&x333, &x334, x332, x263, x309); + fiat_p384_scalar_addcarryx_u32(&x335, &x336, x334, x265, x311); + fiat_p384_scalar_addcarryx_u32(&x337, &x338, x336, x267, x313); + fiat_p384_scalar_addcarryx_u32(&x339, &x340, x338, x269, x315); + fiat_p384_scalar_addcarryx_u32(&x341, &x342, x340, x271, x317); + fiat_p384_scalar_addcarryx_u32(&x343, &x344, x342, x273, x319); + fiat_p384_scalar_addcarryx_u32(&x345, &x346, x344, x275, x321); + fiat_p384_scalar_mulx_u32(&x347, &x348, x323, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x349, &x350, x347, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x351, &x352, x347, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x353, &x354, x347, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x355, &x356, x347, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x357, &x358, x347, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x359, &x360, x347, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x361, &x362, x347, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x363, &x364, x347, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x365, &x366, x347, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x367, &x368, x347, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x369, &x370, x347, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x371, &x372, x347, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x373, &x374, 0x0, x372, x369); + fiat_p384_scalar_addcarryx_u32(&x375, &x376, x374, x370, x367); + fiat_p384_scalar_addcarryx_u32(&x377, &x378, x376, x368, x365); + fiat_p384_scalar_addcarryx_u32(&x379, &x380, x378, x366, x363); + fiat_p384_scalar_addcarryx_u32(&x381, &x382, x380, x364, x361); + fiat_p384_scalar_addcarryx_u32(&x383, &x384, x382, x362, x359); + fiat_p384_scalar_addcarryx_u32(&x385, &x386, x384, x360, x357); + fiat_p384_scalar_addcarryx_u32(&x387, &x388, x386, x358, x355); + fiat_p384_scalar_addcarryx_u32(&x389, &x390, x388, x356, x353); + fiat_p384_scalar_addcarryx_u32(&x391, &x392, x390, x354, x351); + fiat_p384_scalar_addcarryx_u32(&x393, &x394, x392, x352, x349); + fiat_p384_scalar_addcarryx_u32(&x395, &x396, 0x0, x323, x371); + fiat_p384_scalar_addcarryx_u32(&x397, &x398, x396, x325, x373); + fiat_p384_scalar_addcarryx_u32(&x399, &x400, x398, x327, x375); + fiat_p384_scalar_addcarryx_u32(&x401, &x402, x400, x329, x377); + fiat_p384_scalar_addcarryx_u32(&x403, &x404, x402, x331, x379); + fiat_p384_scalar_addcarryx_u32(&x405, &x406, x404, x333, x381); + fiat_p384_scalar_addcarryx_u32(&x407, &x408, x406, x335, x383); + fiat_p384_scalar_addcarryx_u32(&x409, &x410, x408, x337, x385); + fiat_p384_scalar_addcarryx_u32(&x411, &x412, x410, x339, x387); + fiat_p384_scalar_addcarryx_u32(&x413, &x414, x412, x341, x389); + fiat_p384_scalar_addcarryx_u32(&x415, &x416, x414, x343, x391); + fiat_p384_scalar_addcarryx_u32(&x417, &x418, x416, x345, x393); + fiat_p384_scalar_addcarryx_u32(&x419, &x420, x418, (((uint32_t)x346 + x276) + (x322 + x278)), (x394 + x350)); + fiat_p384_scalar_mulx_u32(&x421, &x422, x3, UINT32_C(0xc84ee01)); + fiat_p384_scalar_mulx_u32(&x423, &x424, x3, UINT32_C(0x2b39bf21)); + fiat_p384_scalar_mulx_u32(&x425, &x426, x3, UINT32_C(0x3fb05b7a)); + fiat_p384_scalar_mulx_u32(&x427, &x428, x3, UINT32_C(0x28266895)); + fiat_p384_scalar_mulx_u32(&x429, &x430, x3, UINT32_C(0xd40d4917)); + fiat_p384_scalar_mulx_u32(&x431, &x432, x3, UINT32_C(0x4aab1cc5)); + fiat_p384_scalar_mulx_u32(&x433, &x434, x3, UINT32_C(0xbc3e483a)); + fiat_p384_scalar_mulx_u32(&x435, &x436, x3, UINT32_C(0xfcb82947)); + fiat_p384_scalar_mulx_u32(&x437, &x438, x3, UINT32_C(0xff3d81e5)); + fiat_p384_scalar_mulx_u32(&x439, &x440, x3, UINT32_C(0xdf1aa419)); + fiat_p384_scalar_mulx_u32(&x441, &x442, x3, UINT32_C(0x2d319b24)); + fiat_p384_scalar_mulx_u32(&x443, &x444, x3, UINT32_C(0x19b409a9)); + fiat_p384_scalar_addcarryx_u32(&x445, &x446, 0x0, x444, x441); + fiat_p384_scalar_addcarryx_u32(&x447, &x448, x446, x442, x439); + fiat_p384_scalar_addcarryx_u32(&x449, &x450, x448, x440, x437); + fiat_p384_scalar_addcarryx_u32(&x451, &x452, x450, x438, x435); + fiat_p384_scalar_addcarryx_u32(&x453, &x454, x452, x436, x433); + fiat_p384_scalar_addcarryx_u32(&x455, &x456, x454, x434, x431); + fiat_p384_scalar_addcarryx_u32(&x457, &x458, x456, x432, x429); + fiat_p384_scalar_addcarryx_u32(&x459, &x460, x458, x430, x427); + fiat_p384_scalar_addcarryx_u32(&x461, &x462, x460, x428, x425); + fiat_p384_scalar_addcarryx_u32(&x463, &x464, x462, x426, x423); + fiat_p384_scalar_addcarryx_u32(&x465, &x466, x464, x424, x421); + fiat_p384_scalar_addcarryx_u32(&x467, &x468, 0x0, x397, x443); + fiat_p384_scalar_addcarryx_u32(&x469, &x470, x468, x399, x445); + fiat_p384_scalar_addcarryx_u32(&x471, &x472, x470, x401, x447); + fiat_p384_scalar_addcarryx_u32(&x473, &x474, x472, x403, x449); + fiat_p384_scalar_addcarryx_u32(&x475, &x476, x474, x405, x451); + fiat_p384_scalar_addcarryx_u32(&x477, &x478, x476, x407, x453); + fiat_p384_scalar_addcarryx_u32(&x479, &x480, x478, x409, x455); + fiat_p384_scalar_addcarryx_u32(&x481, &x482, x480, x411, x457); + fiat_p384_scalar_addcarryx_u32(&x483, &x484, x482, x413, x459); + fiat_p384_scalar_addcarryx_u32(&x485, &x486, x484, x415, x461); + fiat_p384_scalar_addcarryx_u32(&x487, &x488, x486, x417, x463); + fiat_p384_scalar_addcarryx_u32(&x489, &x490, x488, x419, x465); + fiat_p384_scalar_mulx_u32(&x491, &x492, x467, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x493, &x494, x491, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x495, &x496, x491, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x497, &x498, x491, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x499, &x500, x491, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x501, &x502, x491, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x503, &x504, x491, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x505, &x506, x491, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x507, &x508, x491, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x509, &x510, x491, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x511, &x512, x491, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x513, &x514, x491, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x515, &x516, x491, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x517, &x518, 0x0, x516, x513); + fiat_p384_scalar_addcarryx_u32(&x519, &x520, x518, x514, x511); + fiat_p384_scalar_addcarryx_u32(&x521, &x522, x520, x512, x509); + fiat_p384_scalar_addcarryx_u32(&x523, &x524, x522, x510, x507); + fiat_p384_scalar_addcarryx_u32(&x525, &x526, x524, x508, x505); + fiat_p384_scalar_addcarryx_u32(&x527, &x528, x526, x506, x503); + fiat_p384_scalar_addcarryx_u32(&x529, &x530, x528, x504, x501); + fiat_p384_scalar_addcarryx_u32(&x531, &x532, x530, x502, x499); + fiat_p384_scalar_addcarryx_u32(&x533, &x534, x532, x500, x497); + fiat_p384_scalar_addcarryx_u32(&x535, &x536, x534, x498, x495); + fiat_p384_scalar_addcarryx_u32(&x537, &x538, x536, x496, x493); + fiat_p384_scalar_addcarryx_u32(&x539, &x540, 0x0, x467, x515); + fiat_p384_scalar_addcarryx_u32(&x541, &x542, x540, x469, x517); + fiat_p384_scalar_addcarryx_u32(&x543, &x544, x542, x471, x519); + fiat_p384_scalar_addcarryx_u32(&x545, &x546, x544, x473, x521); + fiat_p384_scalar_addcarryx_u32(&x547, &x548, x546, x475, x523); + fiat_p384_scalar_addcarryx_u32(&x549, &x550, x548, x477, x525); + fiat_p384_scalar_addcarryx_u32(&x551, &x552, x550, x479, x527); + fiat_p384_scalar_addcarryx_u32(&x553, &x554, x552, x481, x529); + fiat_p384_scalar_addcarryx_u32(&x555, &x556, x554, x483, x531); + fiat_p384_scalar_addcarryx_u32(&x557, &x558, x556, x485, x533); + fiat_p384_scalar_addcarryx_u32(&x559, &x560, x558, x487, x535); + fiat_p384_scalar_addcarryx_u32(&x561, &x562, x560, x489, x537); + fiat_p384_scalar_addcarryx_u32(&x563, &x564, x562, (((uint32_t)x490 + x420) + (x466 + x422)), (x538 + x494)); + fiat_p384_scalar_mulx_u32(&x565, &x566, x4, UINT32_C(0xc84ee01)); + fiat_p384_scalar_mulx_u32(&x567, &x568, x4, UINT32_C(0x2b39bf21)); + fiat_p384_scalar_mulx_u32(&x569, &x570, x4, UINT32_C(0x3fb05b7a)); + fiat_p384_scalar_mulx_u32(&x571, &x572, x4, UINT32_C(0x28266895)); + fiat_p384_scalar_mulx_u32(&x573, &x574, x4, UINT32_C(0xd40d4917)); + fiat_p384_scalar_mulx_u32(&x575, &x576, x4, UINT32_C(0x4aab1cc5)); + fiat_p384_scalar_mulx_u32(&x577, &x578, x4, UINT32_C(0xbc3e483a)); + fiat_p384_scalar_mulx_u32(&x579, &x580, x4, UINT32_C(0xfcb82947)); + fiat_p384_scalar_mulx_u32(&x581, &x582, x4, UINT32_C(0xff3d81e5)); + fiat_p384_scalar_mulx_u32(&x583, &x584, x4, UINT32_C(0xdf1aa419)); + fiat_p384_scalar_mulx_u32(&x585, &x586, x4, UINT32_C(0x2d319b24)); + fiat_p384_scalar_mulx_u32(&x587, &x588, x4, UINT32_C(0x19b409a9)); + fiat_p384_scalar_addcarryx_u32(&x589, &x590, 0x0, x588, x585); + fiat_p384_scalar_addcarryx_u32(&x591, &x592, x590, x586, x583); + fiat_p384_scalar_addcarryx_u32(&x593, &x594, x592, x584, x581); + fiat_p384_scalar_addcarryx_u32(&x595, &x596, x594, x582, x579); + fiat_p384_scalar_addcarryx_u32(&x597, &x598, x596, x580, x577); + fiat_p384_scalar_addcarryx_u32(&x599, &x600, x598, x578, x575); + fiat_p384_scalar_addcarryx_u32(&x601, &x602, x600, x576, x573); + fiat_p384_scalar_addcarryx_u32(&x603, &x604, x602, x574, x571); + fiat_p384_scalar_addcarryx_u32(&x605, &x606, x604, x572, x569); + fiat_p384_scalar_addcarryx_u32(&x607, &x608, x606, x570, x567); + fiat_p384_scalar_addcarryx_u32(&x609, &x610, x608, x568, x565); + fiat_p384_scalar_addcarryx_u32(&x611, &x612, 0x0, x541, x587); + fiat_p384_scalar_addcarryx_u32(&x613, &x614, x612, x543, x589); + fiat_p384_scalar_addcarryx_u32(&x615, &x616, x614, x545, x591); + fiat_p384_scalar_addcarryx_u32(&x617, &x618, x616, x547, x593); + fiat_p384_scalar_addcarryx_u32(&x619, &x620, x618, x549, x595); + fiat_p384_scalar_addcarryx_u32(&x621, &x622, x620, x551, x597); + fiat_p384_scalar_addcarryx_u32(&x623, &x624, x622, x553, x599); + fiat_p384_scalar_addcarryx_u32(&x625, &x626, x624, x555, x601); + fiat_p384_scalar_addcarryx_u32(&x627, &x628, x626, x557, x603); + fiat_p384_scalar_addcarryx_u32(&x629, &x630, x628, x559, x605); + fiat_p384_scalar_addcarryx_u32(&x631, &x632, x630, x561, x607); + fiat_p384_scalar_addcarryx_u32(&x633, &x634, x632, x563, x609); + fiat_p384_scalar_mulx_u32(&x635, &x636, x611, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x637, &x638, x635, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x639, &x640, x635, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x641, &x642, x635, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x643, &x644, x635, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x645, &x646, x635, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x647, &x648, x635, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x649, &x650, x635, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x651, &x652, x635, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x653, &x654, x635, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x655, &x656, x635, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x657, &x658, x635, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x659, &x660, x635, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x661, &x662, 0x0, x660, x657); + fiat_p384_scalar_addcarryx_u32(&x663, &x664, x662, x658, x655); + fiat_p384_scalar_addcarryx_u32(&x665, &x666, x664, x656, x653); + fiat_p384_scalar_addcarryx_u32(&x667, &x668, x666, x654, x651); + fiat_p384_scalar_addcarryx_u32(&x669, &x670, x668, x652, x649); + fiat_p384_scalar_addcarryx_u32(&x671, &x672, x670, x650, x647); + fiat_p384_scalar_addcarryx_u32(&x673, &x674, x672, x648, x645); + fiat_p384_scalar_addcarryx_u32(&x675, &x676, x674, x646, x643); + fiat_p384_scalar_addcarryx_u32(&x677, &x678, x676, x644, x641); + fiat_p384_scalar_addcarryx_u32(&x679, &x680, x678, x642, x639); + fiat_p384_scalar_addcarryx_u32(&x681, &x682, x680, x640, x637); + fiat_p384_scalar_addcarryx_u32(&x683, &x684, 0x0, x611, x659); + fiat_p384_scalar_addcarryx_u32(&x685, &x686, x684, x613, x661); + fiat_p384_scalar_addcarryx_u32(&x687, &x688, x686, x615, x663); + fiat_p384_scalar_addcarryx_u32(&x689, &x690, x688, x617, x665); + fiat_p384_scalar_addcarryx_u32(&x691, &x692, x690, x619, x667); + fiat_p384_scalar_addcarryx_u32(&x693, &x694, x692, x621, x669); + fiat_p384_scalar_addcarryx_u32(&x695, &x696, x694, x623, x671); + fiat_p384_scalar_addcarryx_u32(&x697, &x698, x696, x625, x673); + fiat_p384_scalar_addcarryx_u32(&x699, &x700, x698, x627, x675); + fiat_p384_scalar_addcarryx_u32(&x701, &x702, x700, x629, x677); + fiat_p384_scalar_addcarryx_u32(&x703, &x704, x702, x631, x679); + fiat_p384_scalar_addcarryx_u32(&x705, &x706, x704, x633, x681); + fiat_p384_scalar_addcarryx_u32(&x707, &x708, x706, (((uint32_t)x634 + x564) + (x610 + x566)), (x682 + x638)); + fiat_p384_scalar_mulx_u32(&x709, &x710, x5, UINT32_C(0xc84ee01)); + fiat_p384_scalar_mulx_u32(&x711, &x712, x5, UINT32_C(0x2b39bf21)); + fiat_p384_scalar_mulx_u32(&x713, &x714, x5, UINT32_C(0x3fb05b7a)); + fiat_p384_scalar_mulx_u32(&x715, &x716, x5, UINT32_C(0x28266895)); + fiat_p384_scalar_mulx_u32(&x717, &x718, x5, UINT32_C(0xd40d4917)); + fiat_p384_scalar_mulx_u32(&x719, &x720, x5, UINT32_C(0x4aab1cc5)); + fiat_p384_scalar_mulx_u32(&x721, &x722, x5, UINT32_C(0xbc3e483a)); + fiat_p384_scalar_mulx_u32(&x723, &x724, x5, UINT32_C(0xfcb82947)); + fiat_p384_scalar_mulx_u32(&x725, &x726, x5, UINT32_C(0xff3d81e5)); + fiat_p384_scalar_mulx_u32(&x727, &x728, x5, UINT32_C(0xdf1aa419)); + fiat_p384_scalar_mulx_u32(&x729, &x730, x5, UINT32_C(0x2d319b24)); + fiat_p384_scalar_mulx_u32(&x731, &x732, x5, UINT32_C(0x19b409a9)); + fiat_p384_scalar_addcarryx_u32(&x733, &x734, 0x0, x732, x729); + fiat_p384_scalar_addcarryx_u32(&x735, &x736, x734, x730, x727); + fiat_p384_scalar_addcarryx_u32(&x737, &x738, x736, x728, x725); + fiat_p384_scalar_addcarryx_u32(&x739, &x740, x738, x726, x723); + fiat_p384_scalar_addcarryx_u32(&x741, &x742, x740, x724, x721); + fiat_p384_scalar_addcarryx_u32(&x743, &x744, x742, x722, x719); + fiat_p384_scalar_addcarryx_u32(&x745, &x746, x744, x720, x717); + fiat_p384_scalar_addcarryx_u32(&x747, &x748, x746, x718, x715); + fiat_p384_scalar_addcarryx_u32(&x749, &x750, x748, x716, x713); + fiat_p384_scalar_addcarryx_u32(&x751, &x752, x750, x714, x711); + fiat_p384_scalar_addcarryx_u32(&x753, &x754, x752, x712, x709); + fiat_p384_scalar_addcarryx_u32(&x755, &x756, 0x0, x685, x731); + fiat_p384_scalar_addcarryx_u32(&x757, &x758, x756, x687, x733); + fiat_p384_scalar_addcarryx_u32(&x759, &x760, x758, x689, x735); + fiat_p384_scalar_addcarryx_u32(&x761, &x762, x760, x691, x737); + fiat_p384_scalar_addcarryx_u32(&x763, &x764, x762, x693, x739); + fiat_p384_scalar_addcarryx_u32(&x765, &x766, x764, x695, x741); + fiat_p384_scalar_addcarryx_u32(&x767, &x768, x766, x697, x743); + fiat_p384_scalar_addcarryx_u32(&x769, &x770, x768, x699, x745); + fiat_p384_scalar_addcarryx_u32(&x771, &x772, x770, x701, x747); + fiat_p384_scalar_addcarryx_u32(&x773, &x774, x772, x703, x749); + fiat_p384_scalar_addcarryx_u32(&x775, &x776, x774, x705, x751); + fiat_p384_scalar_addcarryx_u32(&x777, &x778, x776, x707, x753); + fiat_p384_scalar_mulx_u32(&x779, &x780, x755, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x781, &x782, x779, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x783, &x784, x779, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x785, &x786, x779, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x787, &x788, x779, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x789, &x790, x779, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x791, &x792, x779, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x793, &x794, x779, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x795, &x796, x779, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x797, &x798, x779, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x799, &x800, x779, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x801, &x802, x779, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x803, &x804, x779, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x805, &x806, 0x0, x804, x801); + fiat_p384_scalar_addcarryx_u32(&x807, &x808, x806, x802, x799); + fiat_p384_scalar_addcarryx_u32(&x809, &x810, x808, x800, x797); + fiat_p384_scalar_addcarryx_u32(&x811, &x812, x810, x798, x795); + fiat_p384_scalar_addcarryx_u32(&x813, &x814, x812, x796, x793); + fiat_p384_scalar_addcarryx_u32(&x815, &x816, x814, x794, x791); + fiat_p384_scalar_addcarryx_u32(&x817, &x818, x816, x792, x789); + fiat_p384_scalar_addcarryx_u32(&x819, &x820, x818, x790, x787); + fiat_p384_scalar_addcarryx_u32(&x821, &x822, x820, x788, x785); + fiat_p384_scalar_addcarryx_u32(&x823, &x824, x822, x786, x783); + fiat_p384_scalar_addcarryx_u32(&x825, &x826, x824, x784, x781); + fiat_p384_scalar_addcarryx_u32(&x827, &x828, 0x0, x755, x803); + fiat_p384_scalar_addcarryx_u32(&x829, &x830, x828, x757, x805); + fiat_p384_scalar_addcarryx_u32(&x831, &x832, x830, x759, x807); + fiat_p384_scalar_addcarryx_u32(&x833, &x834, x832, x761, x809); + fiat_p384_scalar_addcarryx_u32(&x835, &x836, x834, x763, x811); + fiat_p384_scalar_addcarryx_u32(&x837, &x838, x836, x765, x813); + fiat_p384_scalar_addcarryx_u32(&x839, &x840, x838, x767, x815); + fiat_p384_scalar_addcarryx_u32(&x841, &x842, x840, x769, x817); + fiat_p384_scalar_addcarryx_u32(&x843, &x844, x842, x771, x819); + fiat_p384_scalar_addcarryx_u32(&x845, &x846, x844, x773, x821); + fiat_p384_scalar_addcarryx_u32(&x847, &x848, x846, x775, x823); + fiat_p384_scalar_addcarryx_u32(&x849, &x850, x848, x777, x825); + fiat_p384_scalar_addcarryx_u32(&x851, &x852, x850, (((uint32_t)x778 + x708) + (x754 + x710)), (x826 + x782)); + fiat_p384_scalar_mulx_u32(&x853, &x854, x6, UINT32_C(0xc84ee01)); + fiat_p384_scalar_mulx_u32(&x855, &x856, x6, UINT32_C(0x2b39bf21)); + fiat_p384_scalar_mulx_u32(&x857, &x858, x6, UINT32_C(0x3fb05b7a)); + fiat_p384_scalar_mulx_u32(&x859, &x860, x6, UINT32_C(0x28266895)); + fiat_p384_scalar_mulx_u32(&x861, &x862, x6, UINT32_C(0xd40d4917)); + fiat_p384_scalar_mulx_u32(&x863, &x864, x6, UINT32_C(0x4aab1cc5)); + fiat_p384_scalar_mulx_u32(&x865, &x866, x6, UINT32_C(0xbc3e483a)); + fiat_p384_scalar_mulx_u32(&x867, &x868, x6, UINT32_C(0xfcb82947)); + fiat_p384_scalar_mulx_u32(&x869, &x870, x6, UINT32_C(0xff3d81e5)); + fiat_p384_scalar_mulx_u32(&x871, &x872, x6, UINT32_C(0xdf1aa419)); + fiat_p384_scalar_mulx_u32(&x873, &x874, x6, UINT32_C(0x2d319b24)); + fiat_p384_scalar_mulx_u32(&x875, &x876, x6, UINT32_C(0x19b409a9)); + fiat_p384_scalar_addcarryx_u32(&x877, &x878, 0x0, x876, x873); + fiat_p384_scalar_addcarryx_u32(&x879, &x880, x878, x874, x871); + fiat_p384_scalar_addcarryx_u32(&x881, &x882, x880, x872, x869); + fiat_p384_scalar_addcarryx_u32(&x883, &x884, x882, x870, x867); + fiat_p384_scalar_addcarryx_u32(&x885, &x886, x884, x868, x865); + fiat_p384_scalar_addcarryx_u32(&x887, &x888, x886, x866, x863); + fiat_p384_scalar_addcarryx_u32(&x889, &x890, x888, x864, x861); + fiat_p384_scalar_addcarryx_u32(&x891, &x892, x890, x862, x859); + fiat_p384_scalar_addcarryx_u32(&x893, &x894, x892, x860, x857); + fiat_p384_scalar_addcarryx_u32(&x895, &x896, x894, x858, x855); + fiat_p384_scalar_addcarryx_u32(&x897, &x898, x896, x856, x853); + fiat_p384_scalar_addcarryx_u32(&x899, &x900, 0x0, x829, x875); + fiat_p384_scalar_addcarryx_u32(&x901, &x902, x900, x831, x877); + fiat_p384_scalar_addcarryx_u32(&x903, &x904, x902, x833, x879); + fiat_p384_scalar_addcarryx_u32(&x905, &x906, x904, x835, x881); + fiat_p384_scalar_addcarryx_u32(&x907, &x908, x906, x837, x883); + fiat_p384_scalar_addcarryx_u32(&x909, &x910, x908, x839, x885); + fiat_p384_scalar_addcarryx_u32(&x911, &x912, x910, x841, x887); + fiat_p384_scalar_addcarryx_u32(&x913, &x914, x912, x843, x889); + fiat_p384_scalar_addcarryx_u32(&x915, &x916, x914, x845, x891); + fiat_p384_scalar_addcarryx_u32(&x917, &x918, x916, x847, x893); + fiat_p384_scalar_addcarryx_u32(&x919, &x920, x918, x849, x895); + fiat_p384_scalar_addcarryx_u32(&x921, &x922, x920, x851, x897); + fiat_p384_scalar_mulx_u32(&x923, &x924, x899, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x925, &x926, x923, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x927, &x928, x923, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x929, &x930, x923, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x931, &x932, x923, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x933, &x934, x923, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x935, &x936, x923, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x937, &x938, x923, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x939, &x940, x923, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x941, &x942, x923, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x943, &x944, x923, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x945, &x946, x923, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x947, &x948, x923, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x949, &x950, 0x0, x948, x945); + fiat_p384_scalar_addcarryx_u32(&x951, &x952, x950, x946, x943); + fiat_p384_scalar_addcarryx_u32(&x953, &x954, x952, x944, x941); + fiat_p384_scalar_addcarryx_u32(&x955, &x956, x954, x942, x939); + fiat_p384_scalar_addcarryx_u32(&x957, &x958, x956, x940, x937); + fiat_p384_scalar_addcarryx_u32(&x959, &x960, x958, x938, x935); + fiat_p384_scalar_addcarryx_u32(&x961, &x962, x960, x936, x933); + fiat_p384_scalar_addcarryx_u32(&x963, &x964, x962, x934, x931); + fiat_p384_scalar_addcarryx_u32(&x965, &x966, x964, x932, x929); + fiat_p384_scalar_addcarryx_u32(&x967, &x968, x966, x930, x927); + fiat_p384_scalar_addcarryx_u32(&x969, &x970, x968, x928, x925); + fiat_p384_scalar_addcarryx_u32(&x971, &x972, 0x0, x899, x947); + fiat_p384_scalar_addcarryx_u32(&x973, &x974, x972, x901, x949); + fiat_p384_scalar_addcarryx_u32(&x975, &x976, x974, x903, x951); + fiat_p384_scalar_addcarryx_u32(&x977, &x978, x976, x905, x953); + fiat_p384_scalar_addcarryx_u32(&x979, &x980, x978, x907, x955); + fiat_p384_scalar_addcarryx_u32(&x981, &x982, x980, x909, x957); + fiat_p384_scalar_addcarryx_u32(&x983, &x984, x982, x911, x959); + fiat_p384_scalar_addcarryx_u32(&x985, &x986, x984, x913, x961); + fiat_p384_scalar_addcarryx_u32(&x987, &x988, x986, x915, x963); + fiat_p384_scalar_addcarryx_u32(&x989, &x990, x988, x917, x965); + fiat_p384_scalar_addcarryx_u32(&x991, &x992, x990, x919, x967); + fiat_p384_scalar_addcarryx_u32(&x993, &x994, x992, x921, x969); + fiat_p384_scalar_addcarryx_u32(&x995, &x996, x994, (((uint32_t)x922 + x852) + (x898 + x854)), (x970 + x926)); + fiat_p384_scalar_mulx_u32(&x997, &x998, x7, UINT32_C(0xc84ee01)); + fiat_p384_scalar_mulx_u32(&x999, &x1000, x7, UINT32_C(0x2b39bf21)); + fiat_p384_scalar_mulx_u32(&x1001, &x1002, x7, UINT32_C(0x3fb05b7a)); + fiat_p384_scalar_mulx_u32(&x1003, &x1004, x7, UINT32_C(0x28266895)); + fiat_p384_scalar_mulx_u32(&x1005, &x1006, x7, UINT32_C(0xd40d4917)); + fiat_p384_scalar_mulx_u32(&x1007, &x1008, x7, UINT32_C(0x4aab1cc5)); + fiat_p384_scalar_mulx_u32(&x1009, &x1010, x7, UINT32_C(0xbc3e483a)); + fiat_p384_scalar_mulx_u32(&x1011, &x1012, x7, UINT32_C(0xfcb82947)); + fiat_p384_scalar_mulx_u32(&x1013, &x1014, x7, UINT32_C(0xff3d81e5)); + fiat_p384_scalar_mulx_u32(&x1015, &x1016, x7, UINT32_C(0xdf1aa419)); + fiat_p384_scalar_mulx_u32(&x1017, &x1018, x7, UINT32_C(0x2d319b24)); + fiat_p384_scalar_mulx_u32(&x1019, &x1020, x7, UINT32_C(0x19b409a9)); + fiat_p384_scalar_addcarryx_u32(&x1021, &x1022, 0x0, x1020, x1017); + fiat_p384_scalar_addcarryx_u32(&x1023, &x1024, x1022, x1018, x1015); + fiat_p384_scalar_addcarryx_u32(&x1025, &x1026, x1024, x1016, x1013); + fiat_p384_scalar_addcarryx_u32(&x1027, &x1028, x1026, x1014, x1011); + fiat_p384_scalar_addcarryx_u32(&x1029, &x1030, x1028, x1012, x1009); + fiat_p384_scalar_addcarryx_u32(&x1031, &x1032, x1030, x1010, x1007); + fiat_p384_scalar_addcarryx_u32(&x1033, &x1034, x1032, x1008, x1005); + fiat_p384_scalar_addcarryx_u32(&x1035, &x1036, x1034, x1006, x1003); + fiat_p384_scalar_addcarryx_u32(&x1037, &x1038, x1036, x1004, x1001); + fiat_p384_scalar_addcarryx_u32(&x1039, &x1040, x1038, x1002, x999); + fiat_p384_scalar_addcarryx_u32(&x1041, &x1042, x1040, x1000, x997); + fiat_p384_scalar_addcarryx_u32(&x1043, &x1044, 0x0, x973, x1019); + fiat_p384_scalar_addcarryx_u32(&x1045, &x1046, x1044, x975, x1021); + fiat_p384_scalar_addcarryx_u32(&x1047, &x1048, x1046, x977, x1023); + fiat_p384_scalar_addcarryx_u32(&x1049, &x1050, x1048, x979, x1025); + fiat_p384_scalar_addcarryx_u32(&x1051, &x1052, x1050, x981, x1027); + fiat_p384_scalar_addcarryx_u32(&x1053, &x1054, x1052, x983, x1029); + fiat_p384_scalar_addcarryx_u32(&x1055, &x1056, x1054, x985, x1031); + fiat_p384_scalar_addcarryx_u32(&x1057, &x1058, x1056, x987, x1033); + fiat_p384_scalar_addcarryx_u32(&x1059, &x1060, x1058, x989, x1035); + fiat_p384_scalar_addcarryx_u32(&x1061, &x1062, x1060, x991, x1037); + fiat_p384_scalar_addcarryx_u32(&x1063, &x1064, x1062, x993, x1039); + fiat_p384_scalar_addcarryx_u32(&x1065, &x1066, x1064, x995, x1041); + fiat_p384_scalar_mulx_u32(&x1067, &x1068, x1043, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1069, &x1070, x1067, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1071, &x1072, x1067, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1073, &x1074, x1067, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1075, &x1076, x1067, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1077, &x1078, x1067, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1079, &x1080, x1067, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1081, &x1082, x1067, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1083, &x1084, x1067, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1085, &x1086, x1067, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1087, &x1088, x1067, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1089, &x1090, x1067, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1091, &x1092, x1067, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1093, &x1094, 0x0, x1092, x1089); + fiat_p384_scalar_addcarryx_u32(&x1095, &x1096, x1094, x1090, x1087); + fiat_p384_scalar_addcarryx_u32(&x1097, &x1098, x1096, x1088, x1085); + fiat_p384_scalar_addcarryx_u32(&x1099, &x1100, x1098, x1086, x1083); + fiat_p384_scalar_addcarryx_u32(&x1101, &x1102, x1100, x1084, x1081); + fiat_p384_scalar_addcarryx_u32(&x1103, &x1104, x1102, x1082, x1079); + fiat_p384_scalar_addcarryx_u32(&x1105, &x1106, x1104, x1080, x1077); + fiat_p384_scalar_addcarryx_u32(&x1107, &x1108, x1106, x1078, x1075); + fiat_p384_scalar_addcarryx_u32(&x1109, &x1110, x1108, x1076, x1073); + fiat_p384_scalar_addcarryx_u32(&x1111, &x1112, x1110, x1074, x1071); + fiat_p384_scalar_addcarryx_u32(&x1113, &x1114, x1112, x1072, x1069); + fiat_p384_scalar_addcarryx_u32(&x1115, &x1116, 0x0, x1043, x1091); + fiat_p384_scalar_addcarryx_u32(&x1117, &x1118, x1116, x1045, x1093); + fiat_p384_scalar_addcarryx_u32(&x1119, &x1120, x1118, x1047, x1095); + fiat_p384_scalar_addcarryx_u32(&x1121, &x1122, x1120, x1049, x1097); + fiat_p384_scalar_addcarryx_u32(&x1123, &x1124, x1122, x1051, x1099); + fiat_p384_scalar_addcarryx_u32(&x1125, &x1126, x1124, x1053, x1101); + fiat_p384_scalar_addcarryx_u32(&x1127, &x1128, x1126, x1055, x1103); + fiat_p384_scalar_addcarryx_u32(&x1129, &x1130, x1128, x1057, x1105); + fiat_p384_scalar_addcarryx_u32(&x1131, &x1132, x1130, x1059, x1107); + fiat_p384_scalar_addcarryx_u32(&x1133, &x1134, x1132, x1061, x1109); + fiat_p384_scalar_addcarryx_u32(&x1135, &x1136, x1134, x1063, x1111); + fiat_p384_scalar_addcarryx_u32(&x1137, &x1138, x1136, x1065, x1113); + fiat_p384_scalar_addcarryx_u32(&x1139, &x1140, x1138, (((uint32_t)x1066 + x996) + (x1042 + x998)), (x1114 + x1070)); + fiat_p384_scalar_mulx_u32(&x1141, &x1142, x8, UINT32_C(0xc84ee01)); + fiat_p384_scalar_mulx_u32(&x1143, &x1144, x8, UINT32_C(0x2b39bf21)); + fiat_p384_scalar_mulx_u32(&x1145, &x1146, x8, UINT32_C(0x3fb05b7a)); + fiat_p384_scalar_mulx_u32(&x1147, &x1148, x8, UINT32_C(0x28266895)); + fiat_p384_scalar_mulx_u32(&x1149, &x1150, x8, UINT32_C(0xd40d4917)); + fiat_p384_scalar_mulx_u32(&x1151, &x1152, x8, UINT32_C(0x4aab1cc5)); + fiat_p384_scalar_mulx_u32(&x1153, &x1154, x8, UINT32_C(0xbc3e483a)); + fiat_p384_scalar_mulx_u32(&x1155, &x1156, x8, UINT32_C(0xfcb82947)); + fiat_p384_scalar_mulx_u32(&x1157, &x1158, x8, UINT32_C(0xff3d81e5)); + fiat_p384_scalar_mulx_u32(&x1159, &x1160, x8, UINT32_C(0xdf1aa419)); + fiat_p384_scalar_mulx_u32(&x1161, &x1162, x8, UINT32_C(0x2d319b24)); + fiat_p384_scalar_mulx_u32(&x1163, &x1164, x8, UINT32_C(0x19b409a9)); + fiat_p384_scalar_addcarryx_u32(&x1165, &x1166, 0x0, x1164, x1161); + fiat_p384_scalar_addcarryx_u32(&x1167, &x1168, x1166, x1162, x1159); + fiat_p384_scalar_addcarryx_u32(&x1169, &x1170, x1168, x1160, x1157); + fiat_p384_scalar_addcarryx_u32(&x1171, &x1172, x1170, x1158, x1155); + fiat_p384_scalar_addcarryx_u32(&x1173, &x1174, x1172, x1156, x1153); + fiat_p384_scalar_addcarryx_u32(&x1175, &x1176, x1174, x1154, x1151); + fiat_p384_scalar_addcarryx_u32(&x1177, &x1178, x1176, x1152, x1149); + fiat_p384_scalar_addcarryx_u32(&x1179, &x1180, x1178, x1150, x1147); + fiat_p384_scalar_addcarryx_u32(&x1181, &x1182, x1180, x1148, x1145); + fiat_p384_scalar_addcarryx_u32(&x1183, &x1184, x1182, x1146, x1143); + fiat_p384_scalar_addcarryx_u32(&x1185, &x1186, x1184, x1144, x1141); + fiat_p384_scalar_addcarryx_u32(&x1187, &x1188, 0x0, x1117, x1163); + fiat_p384_scalar_addcarryx_u32(&x1189, &x1190, x1188, x1119, x1165); + fiat_p384_scalar_addcarryx_u32(&x1191, &x1192, x1190, x1121, x1167); + fiat_p384_scalar_addcarryx_u32(&x1193, &x1194, x1192, x1123, x1169); + fiat_p384_scalar_addcarryx_u32(&x1195, &x1196, x1194, x1125, x1171); + fiat_p384_scalar_addcarryx_u32(&x1197, &x1198, x1196, x1127, x1173); + fiat_p384_scalar_addcarryx_u32(&x1199, &x1200, x1198, x1129, x1175); + fiat_p384_scalar_addcarryx_u32(&x1201, &x1202, x1200, x1131, x1177); + fiat_p384_scalar_addcarryx_u32(&x1203, &x1204, x1202, x1133, x1179); + fiat_p384_scalar_addcarryx_u32(&x1205, &x1206, x1204, x1135, x1181); + fiat_p384_scalar_addcarryx_u32(&x1207, &x1208, x1206, x1137, x1183); + fiat_p384_scalar_addcarryx_u32(&x1209, &x1210, x1208, x1139, x1185); + fiat_p384_scalar_mulx_u32(&x1211, &x1212, x1187, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1213, &x1214, x1211, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1215, &x1216, x1211, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1217, &x1218, x1211, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1219, &x1220, x1211, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1221, &x1222, x1211, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1223, &x1224, x1211, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1225, &x1226, x1211, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1227, &x1228, x1211, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1229, &x1230, x1211, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1231, &x1232, x1211, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1233, &x1234, x1211, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1235, &x1236, x1211, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1237, &x1238, 0x0, x1236, x1233); + fiat_p384_scalar_addcarryx_u32(&x1239, &x1240, x1238, x1234, x1231); + fiat_p384_scalar_addcarryx_u32(&x1241, &x1242, x1240, x1232, x1229); + fiat_p384_scalar_addcarryx_u32(&x1243, &x1244, x1242, x1230, x1227); + fiat_p384_scalar_addcarryx_u32(&x1245, &x1246, x1244, x1228, x1225); + fiat_p384_scalar_addcarryx_u32(&x1247, &x1248, x1246, x1226, x1223); + fiat_p384_scalar_addcarryx_u32(&x1249, &x1250, x1248, x1224, x1221); + fiat_p384_scalar_addcarryx_u32(&x1251, &x1252, x1250, x1222, x1219); + fiat_p384_scalar_addcarryx_u32(&x1253, &x1254, x1252, x1220, x1217); + fiat_p384_scalar_addcarryx_u32(&x1255, &x1256, x1254, x1218, x1215); + fiat_p384_scalar_addcarryx_u32(&x1257, &x1258, x1256, x1216, x1213); + fiat_p384_scalar_addcarryx_u32(&x1259, &x1260, 0x0, x1187, x1235); + fiat_p384_scalar_addcarryx_u32(&x1261, &x1262, x1260, x1189, x1237); + fiat_p384_scalar_addcarryx_u32(&x1263, &x1264, x1262, x1191, x1239); + fiat_p384_scalar_addcarryx_u32(&x1265, &x1266, x1264, x1193, x1241); + fiat_p384_scalar_addcarryx_u32(&x1267, &x1268, x1266, x1195, x1243); + fiat_p384_scalar_addcarryx_u32(&x1269, &x1270, x1268, x1197, x1245); + fiat_p384_scalar_addcarryx_u32(&x1271, &x1272, x1270, x1199, x1247); + fiat_p384_scalar_addcarryx_u32(&x1273, &x1274, x1272, x1201, x1249); + fiat_p384_scalar_addcarryx_u32(&x1275, &x1276, x1274, x1203, x1251); + fiat_p384_scalar_addcarryx_u32(&x1277, &x1278, x1276, x1205, x1253); + fiat_p384_scalar_addcarryx_u32(&x1279, &x1280, x1278, x1207, x1255); + fiat_p384_scalar_addcarryx_u32(&x1281, &x1282, x1280, x1209, x1257); + fiat_p384_scalar_addcarryx_u32(&x1283, &x1284, x1282, (((uint32_t)x1210 + x1140) + (x1186 + x1142)), (x1258 + x1214)); + fiat_p384_scalar_mulx_u32(&x1285, &x1286, x9, UINT32_C(0xc84ee01)); + fiat_p384_scalar_mulx_u32(&x1287, &x1288, x9, UINT32_C(0x2b39bf21)); + fiat_p384_scalar_mulx_u32(&x1289, &x1290, x9, UINT32_C(0x3fb05b7a)); + fiat_p384_scalar_mulx_u32(&x1291, &x1292, x9, UINT32_C(0x28266895)); + fiat_p384_scalar_mulx_u32(&x1293, &x1294, x9, UINT32_C(0xd40d4917)); + fiat_p384_scalar_mulx_u32(&x1295, &x1296, x9, UINT32_C(0x4aab1cc5)); + fiat_p384_scalar_mulx_u32(&x1297, &x1298, x9, UINT32_C(0xbc3e483a)); + fiat_p384_scalar_mulx_u32(&x1299, &x1300, x9, UINT32_C(0xfcb82947)); + fiat_p384_scalar_mulx_u32(&x1301, &x1302, x9, UINT32_C(0xff3d81e5)); + fiat_p384_scalar_mulx_u32(&x1303, &x1304, x9, UINT32_C(0xdf1aa419)); + fiat_p384_scalar_mulx_u32(&x1305, &x1306, x9, UINT32_C(0x2d319b24)); + fiat_p384_scalar_mulx_u32(&x1307, &x1308, x9, UINT32_C(0x19b409a9)); + fiat_p384_scalar_addcarryx_u32(&x1309, &x1310, 0x0, x1308, x1305); + fiat_p384_scalar_addcarryx_u32(&x1311, &x1312, x1310, x1306, x1303); + fiat_p384_scalar_addcarryx_u32(&x1313, &x1314, x1312, x1304, x1301); + fiat_p384_scalar_addcarryx_u32(&x1315, &x1316, x1314, x1302, x1299); + fiat_p384_scalar_addcarryx_u32(&x1317, &x1318, x1316, x1300, x1297); + fiat_p384_scalar_addcarryx_u32(&x1319, &x1320, x1318, x1298, x1295); + fiat_p384_scalar_addcarryx_u32(&x1321, &x1322, x1320, x1296, x1293); + fiat_p384_scalar_addcarryx_u32(&x1323, &x1324, x1322, x1294, x1291); + fiat_p384_scalar_addcarryx_u32(&x1325, &x1326, x1324, x1292, x1289); + fiat_p384_scalar_addcarryx_u32(&x1327, &x1328, x1326, x1290, x1287); + fiat_p384_scalar_addcarryx_u32(&x1329, &x1330, x1328, x1288, x1285); + fiat_p384_scalar_addcarryx_u32(&x1331, &x1332, 0x0, x1261, x1307); + fiat_p384_scalar_addcarryx_u32(&x1333, &x1334, x1332, x1263, x1309); + fiat_p384_scalar_addcarryx_u32(&x1335, &x1336, x1334, x1265, x1311); + fiat_p384_scalar_addcarryx_u32(&x1337, &x1338, x1336, x1267, x1313); + fiat_p384_scalar_addcarryx_u32(&x1339, &x1340, x1338, x1269, x1315); + fiat_p384_scalar_addcarryx_u32(&x1341, &x1342, x1340, x1271, x1317); + fiat_p384_scalar_addcarryx_u32(&x1343, &x1344, x1342, x1273, x1319); + fiat_p384_scalar_addcarryx_u32(&x1345, &x1346, x1344, x1275, x1321); + fiat_p384_scalar_addcarryx_u32(&x1347, &x1348, x1346, x1277, x1323); + fiat_p384_scalar_addcarryx_u32(&x1349, &x1350, x1348, x1279, x1325); + fiat_p384_scalar_addcarryx_u32(&x1351, &x1352, x1350, x1281, x1327); + fiat_p384_scalar_addcarryx_u32(&x1353, &x1354, x1352, x1283, x1329); + fiat_p384_scalar_mulx_u32(&x1355, &x1356, x1331, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1357, &x1358, x1355, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1359, &x1360, x1355, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1361, &x1362, x1355, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1363, &x1364, x1355, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1365, &x1366, x1355, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1367, &x1368, x1355, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1369, &x1370, x1355, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1371, &x1372, x1355, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1373, &x1374, x1355, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1375, &x1376, x1355, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1377, &x1378, x1355, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1379, &x1380, x1355, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1381, &x1382, 0x0, x1380, x1377); + fiat_p384_scalar_addcarryx_u32(&x1383, &x1384, x1382, x1378, x1375); + fiat_p384_scalar_addcarryx_u32(&x1385, &x1386, x1384, x1376, x1373); + fiat_p384_scalar_addcarryx_u32(&x1387, &x1388, x1386, x1374, x1371); + fiat_p384_scalar_addcarryx_u32(&x1389, &x1390, x1388, x1372, x1369); + fiat_p384_scalar_addcarryx_u32(&x1391, &x1392, x1390, x1370, x1367); + fiat_p384_scalar_addcarryx_u32(&x1393, &x1394, x1392, x1368, x1365); + fiat_p384_scalar_addcarryx_u32(&x1395, &x1396, x1394, x1366, x1363); + fiat_p384_scalar_addcarryx_u32(&x1397, &x1398, x1396, x1364, x1361); + fiat_p384_scalar_addcarryx_u32(&x1399, &x1400, x1398, x1362, x1359); + fiat_p384_scalar_addcarryx_u32(&x1401, &x1402, x1400, x1360, x1357); + fiat_p384_scalar_addcarryx_u32(&x1403, &x1404, 0x0, x1331, x1379); + fiat_p384_scalar_addcarryx_u32(&x1405, &x1406, x1404, x1333, x1381); + fiat_p384_scalar_addcarryx_u32(&x1407, &x1408, x1406, x1335, x1383); + fiat_p384_scalar_addcarryx_u32(&x1409, &x1410, x1408, x1337, x1385); + fiat_p384_scalar_addcarryx_u32(&x1411, &x1412, x1410, x1339, x1387); + fiat_p384_scalar_addcarryx_u32(&x1413, &x1414, x1412, x1341, x1389); + fiat_p384_scalar_addcarryx_u32(&x1415, &x1416, x1414, x1343, x1391); + fiat_p384_scalar_addcarryx_u32(&x1417, &x1418, x1416, x1345, x1393); + fiat_p384_scalar_addcarryx_u32(&x1419, &x1420, x1418, x1347, x1395); + fiat_p384_scalar_addcarryx_u32(&x1421, &x1422, x1420, x1349, x1397); + fiat_p384_scalar_addcarryx_u32(&x1423, &x1424, x1422, x1351, x1399); + fiat_p384_scalar_addcarryx_u32(&x1425, &x1426, x1424, x1353, x1401); + fiat_p384_scalar_addcarryx_u32(&x1427, &x1428, x1426, (((uint32_t)x1354 + x1284) + (x1330 + x1286)), (x1402 + x1358)); + fiat_p384_scalar_mulx_u32(&x1429, &x1430, x10, UINT32_C(0xc84ee01)); + fiat_p384_scalar_mulx_u32(&x1431, &x1432, x10, UINT32_C(0x2b39bf21)); + fiat_p384_scalar_mulx_u32(&x1433, &x1434, x10, UINT32_C(0x3fb05b7a)); + fiat_p384_scalar_mulx_u32(&x1435, &x1436, x10, UINT32_C(0x28266895)); + fiat_p384_scalar_mulx_u32(&x1437, &x1438, x10, UINT32_C(0xd40d4917)); + fiat_p384_scalar_mulx_u32(&x1439, &x1440, x10, UINT32_C(0x4aab1cc5)); + fiat_p384_scalar_mulx_u32(&x1441, &x1442, x10, UINT32_C(0xbc3e483a)); + fiat_p384_scalar_mulx_u32(&x1443, &x1444, x10, UINT32_C(0xfcb82947)); + fiat_p384_scalar_mulx_u32(&x1445, &x1446, x10, UINT32_C(0xff3d81e5)); + fiat_p384_scalar_mulx_u32(&x1447, &x1448, x10, UINT32_C(0xdf1aa419)); + fiat_p384_scalar_mulx_u32(&x1449, &x1450, x10, UINT32_C(0x2d319b24)); + fiat_p384_scalar_mulx_u32(&x1451, &x1452, x10, UINT32_C(0x19b409a9)); + fiat_p384_scalar_addcarryx_u32(&x1453, &x1454, 0x0, x1452, x1449); + fiat_p384_scalar_addcarryx_u32(&x1455, &x1456, x1454, x1450, x1447); + fiat_p384_scalar_addcarryx_u32(&x1457, &x1458, x1456, x1448, x1445); + fiat_p384_scalar_addcarryx_u32(&x1459, &x1460, x1458, x1446, x1443); + fiat_p384_scalar_addcarryx_u32(&x1461, &x1462, x1460, x1444, x1441); + fiat_p384_scalar_addcarryx_u32(&x1463, &x1464, x1462, x1442, x1439); + fiat_p384_scalar_addcarryx_u32(&x1465, &x1466, x1464, x1440, x1437); + fiat_p384_scalar_addcarryx_u32(&x1467, &x1468, x1466, x1438, x1435); + fiat_p384_scalar_addcarryx_u32(&x1469, &x1470, x1468, x1436, x1433); + fiat_p384_scalar_addcarryx_u32(&x1471, &x1472, x1470, x1434, x1431); + fiat_p384_scalar_addcarryx_u32(&x1473, &x1474, x1472, x1432, x1429); + fiat_p384_scalar_addcarryx_u32(&x1475, &x1476, 0x0, x1405, x1451); + fiat_p384_scalar_addcarryx_u32(&x1477, &x1478, x1476, x1407, x1453); + fiat_p384_scalar_addcarryx_u32(&x1479, &x1480, x1478, x1409, x1455); + fiat_p384_scalar_addcarryx_u32(&x1481, &x1482, x1480, x1411, x1457); + fiat_p384_scalar_addcarryx_u32(&x1483, &x1484, x1482, x1413, x1459); + fiat_p384_scalar_addcarryx_u32(&x1485, &x1486, x1484, x1415, x1461); + fiat_p384_scalar_addcarryx_u32(&x1487, &x1488, x1486, x1417, x1463); + fiat_p384_scalar_addcarryx_u32(&x1489, &x1490, x1488, x1419, x1465); + fiat_p384_scalar_addcarryx_u32(&x1491, &x1492, x1490, x1421, x1467); + fiat_p384_scalar_addcarryx_u32(&x1493, &x1494, x1492, x1423, x1469); + fiat_p384_scalar_addcarryx_u32(&x1495, &x1496, x1494, x1425, x1471); + fiat_p384_scalar_addcarryx_u32(&x1497, &x1498, x1496, x1427, x1473); + fiat_p384_scalar_mulx_u32(&x1499, &x1500, x1475, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1501, &x1502, x1499, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1503, &x1504, x1499, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1505, &x1506, x1499, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1507, &x1508, x1499, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1509, &x1510, x1499, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1511, &x1512, x1499, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1513, &x1514, x1499, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1515, &x1516, x1499, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1517, &x1518, x1499, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1519, &x1520, x1499, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1521, &x1522, x1499, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1523, &x1524, x1499, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1525, &x1526, 0x0, x1524, x1521); + fiat_p384_scalar_addcarryx_u32(&x1527, &x1528, x1526, x1522, x1519); + fiat_p384_scalar_addcarryx_u32(&x1529, &x1530, x1528, x1520, x1517); + fiat_p384_scalar_addcarryx_u32(&x1531, &x1532, x1530, x1518, x1515); + fiat_p384_scalar_addcarryx_u32(&x1533, &x1534, x1532, x1516, x1513); + fiat_p384_scalar_addcarryx_u32(&x1535, &x1536, x1534, x1514, x1511); + fiat_p384_scalar_addcarryx_u32(&x1537, &x1538, x1536, x1512, x1509); + fiat_p384_scalar_addcarryx_u32(&x1539, &x1540, x1538, x1510, x1507); + fiat_p384_scalar_addcarryx_u32(&x1541, &x1542, x1540, x1508, x1505); + fiat_p384_scalar_addcarryx_u32(&x1543, &x1544, x1542, x1506, x1503); + fiat_p384_scalar_addcarryx_u32(&x1545, &x1546, x1544, x1504, x1501); + fiat_p384_scalar_addcarryx_u32(&x1547, &x1548, 0x0, x1475, x1523); + fiat_p384_scalar_addcarryx_u32(&x1549, &x1550, x1548, x1477, x1525); + fiat_p384_scalar_addcarryx_u32(&x1551, &x1552, x1550, x1479, x1527); + fiat_p384_scalar_addcarryx_u32(&x1553, &x1554, x1552, x1481, x1529); + fiat_p384_scalar_addcarryx_u32(&x1555, &x1556, x1554, x1483, x1531); + fiat_p384_scalar_addcarryx_u32(&x1557, &x1558, x1556, x1485, x1533); + fiat_p384_scalar_addcarryx_u32(&x1559, &x1560, x1558, x1487, x1535); + fiat_p384_scalar_addcarryx_u32(&x1561, &x1562, x1560, x1489, x1537); + fiat_p384_scalar_addcarryx_u32(&x1563, &x1564, x1562, x1491, x1539); + fiat_p384_scalar_addcarryx_u32(&x1565, &x1566, x1564, x1493, x1541); + fiat_p384_scalar_addcarryx_u32(&x1567, &x1568, x1566, x1495, x1543); + fiat_p384_scalar_addcarryx_u32(&x1569, &x1570, x1568, x1497, x1545); + fiat_p384_scalar_addcarryx_u32(&x1571, &x1572, x1570, (((uint32_t)x1498 + x1428) + (x1474 + x1430)), (x1546 + x1502)); + fiat_p384_scalar_mulx_u32(&x1573, &x1574, x11, UINT32_C(0xc84ee01)); + fiat_p384_scalar_mulx_u32(&x1575, &x1576, x11, UINT32_C(0x2b39bf21)); + fiat_p384_scalar_mulx_u32(&x1577, &x1578, x11, UINT32_C(0x3fb05b7a)); + fiat_p384_scalar_mulx_u32(&x1579, &x1580, x11, UINT32_C(0x28266895)); + fiat_p384_scalar_mulx_u32(&x1581, &x1582, x11, UINT32_C(0xd40d4917)); + fiat_p384_scalar_mulx_u32(&x1583, &x1584, x11, UINT32_C(0x4aab1cc5)); + fiat_p384_scalar_mulx_u32(&x1585, &x1586, x11, UINT32_C(0xbc3e483a)); + fiat_p384_scalar_mulx_u32(&x1587, &x1588, x11, UINT32_C(0xfcb82947)); + fiat_p384_scalar_mulx_u32(&x1589, &x1590, x11, UINT32_C(0xff3d81e5)); + fiat_p384_scalar_mulx_u32(&x1591, &x1592, x11, UINT32_C(0xdf1aa419)); + fiat_p384_scalar_mulx_u32(&x1593, &x1594, x11, UINT32_C(0x2d319b24)); + fiat_p384_scalar_mulx_u32(&x1595, &x1596, x11, UINT32_C(0x19b409a9)); + fiat_p384_scalar_addcarryx_u32(&x1597, &x1598, 0x0, x1596, x1593); + fiat_p384_scalar_addcarryx_u32(&x1599, &x1600, x1598, x1594, x1591); + fiat_p384_scalar_addcarryx_u32(&x1601, &x1602, x1600, x1592, x1589); + fiat_p384_scalar_addcarryx_u32(&x1603, &x1604, x1602, x1590, x1587); + fiat_p384_scalar_addcarryx_u32(&x1605, &x1606, x1604, x1588, x1585); + fiat_p384_scalar_addcarryx_u32(&x1607, &x1608, x1606, x1586, x1583); + fiat_p384_scalar_addcarryx_u32(&x1609, &x1610, x1608, x1584, x1581); + fiat_p384_scalar_addcarryx_u32(&x1611, &x1612, x1610, x1582, x1579); + fiat_p384_scalar_addcarryx_u32(&x1613, &x1614, x1612, x1580, x1577); + fiat_p384_scalar_addcarryx_u32(&x1615, &x1616, x1614, x1578, x1575); + fiat_p384_scalar_addcarryx_u32(&x1617, &x1618, x1616, x1576, x1573); + fiat_p384_scalar_addcarryx_u32(&x1619, &x1620, 0x0, x1549, x1595); + fiat_p384_scalar_addcarryx_u32(&x1621, &x1622, x1620, x1551, x1597); + fiat_p384_scalar_addcarryx_u32(&x1623, &x1624, x1622, x1553, x1599); + fiat_p384_scalar_addcarryx_u32(&x1625, &x1626, x1624, x1555, x1601); + fiat_p384_scalar_addcarryx_u32(&x1627, &x1628, x1626, x1557, x1603); + fiat_p384_scalar_addcarryx_u32(&x1629, &x1630, x1628, x1559, x1605); + fiat_p384_scalar_addcarryx_u32(&x1631, &x1632, x1630, x1561, x1607); + fiat_p384_scalar_addcarryx_u32(&x1633, &x1634, x1632, x1563, x1609); + fiat_p384_scalar_addcarryx_u32(&x1635, &x1636, x1634, x1565, x1611); + fiat_p384_scalar_addcarryx_u32(&x1637, &x1638, x1636, x1567, x1613); + fiat_p384_scalar_addcarryx_u32(&x1639, &x1640, x1638, x1569, x1615); + fiat_p384_scalar_addcarryx_u32(&x1641, &x1642, x1640, x1571, x1617); + fiat_p384_scalar_mulx_u32(&x1643, &x1644, x1619, UINT32_C(0xe88fdc45)); + fiat_p384_scalar_mulx_u32(&x1645, &x1646, x1643, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1647, &x1648, x1643, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1649, &x1650, x1643, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1651, &x1652, x1643, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1653, &x1654, x1643, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1655, &x1656, x1643, UINT32_C(0xffffffff)); + fiat_p384_scalar_mulx_u32(&x1657, &x1658, x1643, UINT32_C(0xc7634d81)); + fiat_p384_scalar_mulx_u32(&x1659, &x1660, x1643, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_mulx_u32(&x1661, &x1662, x1643, UINT32_C(0x581a0db2)); + fiat_p384_scalar_mulx_u32(&x1663, &x1664, x1643, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_mulx_u32(&x1665, &x1666, x1643, UINT32_C(0xecec196a)); + fiat_p384_scalar_mulx_u32(&x1667, &x1668, x1643, UINT32_C(0xccc52973)); + fiat_p384_scalar_addcarryx_u32(&x1669, &x1670, 0x0, x1668, x1665); + fiat_p384_scalar_addcarryx_u32(&x1671, &x1672, x1670, x1666, x1663); + fiat_p384_scalar_addcarryx_u32(&x1673, &x1674, x1672, x1664, x1661); + fiat_p384_scalar_addcarryx_u32(&x1675, &x1676, x1674, x1662, x1659); + fiat_p384_scalar_addcarryx_u32(&x1677, &x1678, x1676, x1660, x1657); + fiat_p384_scalar_addcarryx_u32(&x1679, &x1680, x1678, x1658, x1655); + fiat_p384_scalar_addcarryx_u32(&x1681, &x1682, x1680, x1656, x1653); + fiat_p384_scalar_addcarryx_u32(&x1683, &x1684, x1682, x1654, x1651); + fiat_p384_scalar_addcarryx_u32(&x1685, &x1686, x1684, x1652, x1649); + fiat_p384_scalar_addcarryx_u32(&x1687, &x1688, x1686, x1650, x1647); + fiat_p384_scalar_addcarryx_u32(&x1689, &x1690, x1688, x1648, x1645); + fiat_p384_scalar_addcarryx_u32(&x1691, &x1692, 0x0, x1619, x1667); + fiat_p384_scalar_addcarryx_u32(&x1693, &x1694, x1692, x1621, x1669); + fiat_p384_scalar_addcarryx_u32(&x1695, &x1696, x1694, x1623, x1671); + fiat_p384_scalar_addcarryx_u32(&x1697, &x1698, x1696, x1625, x1673); + fiat_p384_scalar_addcarryx_u32(&x1699, &x1700, x1698, x1627, x1675); + fiat_p384_scalar_addcarryx_u32(&x1701, &x1702, x1700, x1629, x1677); + fiat_p384_scalar_addcarryx_u32(&x1703, &x1704, x1702, x1631, x1679); + fiat_p384_scalar_addcarryx_u32(&x1705, &x1706, x1704, x1633, x1681); + fiat_p384_scalar_addcarryx_u32(&x1707, &x1708, x1706, x1635, x1683); + fiat_p384_scalar_addcarryx_u32(&x1709, &x1710, x1708, x1637, x1685); + fiat_p384_scalar_addcarryx_u32(&x1711, &x1712, x1710, x1639, x1687); + fiat_p384_scalar_addcarryx_u32(&x1713, &x1714, x1712, x1641, x1689); + fiat_p384_scalar_addcarryx_u32(&x1715, &x1716, x1714, (((uint32_t)x1642 + x1572) + (x1618 + x1574)), (x1690 + x1646)); + fiat_p384_scalar_subborrowx_u32(&x1717, &x1718, 0x0, x1693, UINT32_C(0xccc52973)); + fiat_p384_scalar_subborrowx_u32(&x1719, &x1720, x1718, x1695, UINT32_C(0xecec196a)); + fiat_p384_scalar_subborrowx_u32(&x1721, &x1722, x1720, x1697, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_subborrowx_u32(&x1723, &x1724, x1722, x1699, UINT32_C(0x581a0db2)); + fiat_p384_scalar_subborrowx_u32(&x1725, &x1726, x1724, x1701, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_subborrowx_u32(&x1727, &x1728, x1726, x1703, UINT32_C(0xc7634d81)); + fiat_p384_scalar_subborrowx_u32(&x1729, &x1730, x1728, x1705, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1731, &x1732, x1730, x1707, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1733, &x1734, x1732, x1709, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1735, &x1736, x1734, x1711, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1737, &x1738, x1736, x1713, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1739, &x1740, x1738, x1715, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x1741, &x1742, x1740, x1716, 0x0); + fiat_p384_scalar_cmovznz_u32(&x1743, x1742, x1717, x1693); + fiat_p384_scalar_cmovznz_u32(&x1744, x1742, x1719, x1695); + fiat_p384_scalar_cmovznz_u32(&x1745, x1742, x1721, x1697); + fiat_p384_scalar_cmovznz_u32(&x1746, x1742, x1723, x1699); + fiat_p384_scalar_cmovznz_u32(&x1747, x1742, x1725, x1701); + fiat_p384_scalar_cmovznz_u32(&x1748, x1742, x1727, x1703); + fiat_p384_scalar_cmovznz_u32(&x1749, x1742, x1729, x1705); + fiat_p384_scalar_cmovznz_u32(&x1750, x1742, x1731, x1707); + fiat_p384_scalar_cmovznz_u32(&x1751, x1742, x1733, x1709); + fiat_p384_scalar_cmovznz_u32(&x1752, x1742, x1735, x1711); + fiat_p384_scalar_cmovznz_u32(&x1753, x1742, x1737, x1713); + fiat_p384_scalar_cmovznz_u32(&x1754, x1742, x1739, x1715); + out1[0] = x1743; + out1[1] = x1744; + out1[2] = x1745; + out1[3] = x1746; + out1[4] = x1747; + out1[5] = x1748; + out1[6] = x1749; + out1[7] = x1750; + out1[8] = x1751; + out1[9] = x1752; + out1[10] = x1753; + out1[11] = x1754; +} + +/* + * The function fiat_p384_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_nonzero(uint32_t* out1, const uint32_t arg1[12]) { + uint32_t x1; + x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | ((arg1[7]) | ((arg1[8]) | ((arg1[9]) | ((arg1[10]) | (arg1[11])))))))))))); + *out1 = x1; +} + +/* + * The function fiat_p384_scalar_selectznz is a multi-limb conditional select. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_selectznz(uint32_t out1[12], fiat_p384_scalar_uint1 arg1, const uint32_t arg2[12], const uint32_t arg3[12]) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + fiat_p384_scalar_cmovznz_u32(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_p384_scalar_cmovznz_u32(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_p384_scalar_cmovznz_u32(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_p384_scalar_cmovznz_u32(&x4, arg1, (arg2[3]), (arg3[3])); + fiat_p384_scalar_cmovznz_u32(&x5, arg1, (arg2[4]), (arg3[4])); + fiat_p384_scalar_cmovznz_u32(&x6, arg1, (arg2[5]), (arg3[5])); + fiat_p384_scalar_cmovznz_u32(&x7, arg1, (arg2[6]), (arg3[6])); + fiat_p384_scalar_cmovznz_u32(&x8, arg1, (arg2[7]), (arg3[7])); + fiat_p384_scalar_cmovznz_u32(&x9, arg1, (arg2[8]), (arg3[8])); + fiat_p384_scalar_cmovznz_u32(&x10, arg1, (arg2[9]), (arg3[9])); + fiat_p384_scalar_cmovznz_u32(&x11, arg1, (arg2[10]), (arg3[10])); + fiat_p384_scalar_cmovznz_u32(&x12, arg1, (arg2[11]), (arg3[11])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; + out1[6] = x7; + out1[7] = x8; + out1[8] = x9; + out1[9] = x10; + out1[10] = x11; + out1[11] = x12; +} + +/* + * The function fiat_p384_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47] + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_to_bytes(uint8_t out1[48], const uint32_t arg1[12]) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint8_t x13; + uint32_t x14; + uint8_t x15; + uint32_t x16; + uint8_t x17; + uint8_t x18; + uint8_t x19; + uint32_t x20; + uint8_t x21; + uint32_t x22; + uint8_t x23; + uint8_t x24; + uint8_t x25; + uint32_t x26; + uint8_t x27; + uint32_t x28; + uint8_t x29; + uint8_t x30; + uint8_t x31; + uint32_t x32; + uint8_t x33; + uint32_t x34; + uint8_t x35; + uint8_t x36; + uint8_t x37; + uint32_t x38; + uint8_t x39; + uint32_t x40; + uint8_t x41; + uint8_t x42; + uint8_t x43; + uint32_t x44; + uint8_t x45; + uint32_t x46; + uint8_t x47; + uint8_t x48; + uint8_t x49; + uint32_t x50; + uint8_t x51; + uint32_t x52; + uint8_t x53; + uint8_t x54; + uint8_t x55; + uint32_t x56; + uint8_t x57; + uint32_t x58; + uint8_t x59; + uint8_t x60; + uint8_t x61; + uint32_t x62; + uint8_t x63; + uint32_t x64; + uint8_t x65; + uint8_t x66; + uint8_t x67; + uint32_t x68; + uint8_t x69; + uint32_t x70; + uint8_t x71; + uint8_t x72; + uint8_t x73; + uint32_t x74; + uint8_t x75; + uint32_t x76; + uint8_t x77; + uint8_t x78; + uint8_t x79; + uint32_t x80; + uint8_t x81; + uint32_t x82; + uint8_t x83; + uint8_t x84; + x1 = (arg1[11]); + x2 = (arg1[10]); + x3 = (arg1[9]); + x4 = (arg1[8]); + x5 = (arg1[7]); + x6 = (arg1[6]); + x7 = (arg1[5]); + x8 = (arg1[4]); + x9 = (arg1[3]); + x10 = (arg1[2]); + x11 = (arg1[1]); + x12 = (arg1[0]); + x13 = (uint8_t)(x12 & UINT8_C(0xff)); + x14 = (x12 >> 8); + x15 = (uint8_t)(x14 & UINT8_C(0xff)); + x16 = (x14 >> 8); + x17 = (uint8_t)(x16 & UINT8_C(0xff)); + x18 = (uint8_t)(x16 >> 8); + x19 = (uint8_t)(x11 & UINT8_C(0xff)); + x20 = (x11 >> 8); + x21 = (uint8_t)(x20 & UINT8_C(0xff)); + x22 = (x20 >> 8); + x23 = (uint8_t)(x22 & UINT8_C(0xff)); + x24 = (uint8_t)(x22 >> 8); + x25 = (uint8_t)(x10 & UINT8_C(0xff)); + x26 = (x10 >> 8); + x27 = (uint8_t)(x26 & UINT8_C(0xff)); + x28 = (x26 >> 8); + x29 = (uint8_t)(x28 & UINT8_C(0xff)); + x30 = (uint8_t)(x28 >> 8); + x31 = (uint8_t)(x9 & UINT8_C(0xff)); + x32 = (x9 >> 8); + x33 = (uint8_t)(x32 & UINT8_C(0xff)); + x34 = (x32 >> 8); + x35 = (uint8_t)(x34 & UINT8_C(0xff)); + x36 = (uint8_t)(x34 >> 8); + x37 = (uint8_t)(x8 & UINT8_C(0xff)); + x38 = (x8 >> 8); + x39 = (uint8_t)(x38 & UINT8_C(0xff)); + x40 = (x38 >> 8); + x41 = (uint8_t)(x40 & UINT8_C(0xff)); + x42 = (uint8_t)(x40 >> 8); + x43 = (uint8_t)(x7 & UINT8_C(0xff)); + x44 = (x7 >> 8); + x45 = (uint8_t)(x44 & UINT8_C(0xff)); + x46 = (x44 >> 8); + x47 = (uint8_t)(x46 & UINT8_C(0xff)); + x48 = (uint8_t)(x46 >> 8); + x49 = (uint8_t)(x6 & UINT8_C(0xff)); + x50 = (x6 >> 8); + x51 = (uint8_t)(x50 & UINT8_C(0xff)); + x52 = (x50 >> 8); + x53 = (uint8_t)(x52 & UINT8_C(0xff)); + x54 = (uint8_t)(x52 >> 8); + x55 = (uint8_t)(x5 & UINT8_C(0xff)); + x56 = (x5 >> 8); + x57 = (uint8_t)(x56 & UINT8_C(0xff)); + x58 = (x56 >> 8); + x59 = (uint8_t)(x58 & UINT8_C(0xff)); + x60 = (uint8_t)(x58 >> 8); + x61 = (uint8_t)(x4 & UINT8_C(0xff)); + x62 = (x4 >> 8); + x63 = (uint8_t)(x62 & UINT8_C(0xff)); + x64 = (x62 >> 8); + x65 = (uint8_t)(x64 & UINT8_C(0xff)); + x66 = (uint8_t)(x64 >> 8); + x67 = (uint8_t)(x3 & UINT8_C(0xff)); + x68 = (x3 >> 8); + x69 = (uint8_t)(x68 & UINT8_C(0xff)); + x70 = (x68 >> 8); + x71 = (uint8_t)(x70 & UINT8_C(0xff)); + x72 = (uint8_t)(x70 >> 8); + x73 = (uint8_t)(x2 & UINT8_C(0xff)); + x74 = (x2 >> 8); + x75 = (uint8_t)(x74 & UINT8_C(0xff)); + x76 = (x74 >> 8); + x77 = (uint8_t)(x76 & UINT8_C(0xff)); + x78 = (uint8_t)(x76 >> 8); + x79 = (uint8_t)(x1 & UINT8_C(0xff)); + x80 = (x1 >> 8); + x81 = (uint8_t)(x80 & UINT8_C(0xff)); + x82 = (x80 >> 8); + x83 = (uint8_t)(x82 & UINT8_C(0xff)); + x84 = (uint8_t)(x82 >> 8); + out1[0] = x13; + out1[1] = x15; + out1[2] = x17; + out1[3] = x18; + out1[4] = x19; + out1[5] = x21; + out1[6] = x23; + out1[7] = x24; + out1[8] = x25; + out1[9] = x27; + out1[10] = x29; + out1[11] = x30; + out1[12] = x31; + out1[13] = x33; + out1[14] = x35; + out1[15] = x36; + out1[16] = x37; + out1[17] = x39; + out1[18] = x41; + out1[19] = x42; + out1[20] = x43; + out1[21] = x45; + out1[22] = x47; + out1[23] = x48; + out1[24] = x49; + out1[25] = x51; + out1[26] = x53; + out1[27] = x54; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; + out1[32] = x61; + out1[33] = x63; + out1[34] = x65; + out1[35] = x66; + out1[36] = x67; + out1[37] = x69; + out1[38] = x71; + out1[39] = x72; + out1[40] = x73; + out1[41] = x75; + out1[42] = x77; + out1[43] = x78; + out1[44] = x79; + out1[45] = x81; + out1[46] = x83; + out1[47] = x84; +} + +/* + * The function fiat_p384_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. + * + * Preconditions: + * 0 ≤ bytes_eval arg1 < m + * Postconditions: + * eval out1 mod m = bytes_eval arg1 mod m + * 0 ≤ eval out1 < m + * + * Input Bounds: + * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_from_bytes(uint32_t out1[12], const uint8_t arg1[48]) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint8_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint8_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint8_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint8_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint8_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint8_t x24; + uint32_t x25; + uint32_t x26; + uint32_t x27; + uint8_t x28; + uint32_t x29; + uint32_t x30; + uint32_t x31; + uint8_t x32; + uint32_t x33; + uint32_t x34; + uint32_t x35; + uint8_t x36; + uint32_t x37; + uint32_t x38; + uint32_t x39; + uint8_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint8_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint8_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + uint32_t x53; + uint32_t x54; + uint32_t x55; + uint32_t x56; + uint32_t x57; + uint32_t x58; + uint32_t x59; + uint32_t x60; + uint32_t x61; + uint32_t x62; + uint32_t x63; + uint32_t x64; + uint32_t x65; + uint32_t x66; + uint32_t x67; + uint32_t x68; + uint32_t x69; + uint32_t x70; + uint32_t x71; + uint32_t x72; + uint32_t x73; + uint32_t x74; + uint32_t x75; + uint32_t x76; + uint32_t x77; + uint32_t x78; + uint32_t x79; + uint32_t x80; + uint32_t x81; + uint32_t x82; + uint32_t x83; + uint32_t x84; + x1 = ((uint32_t)(arg1[47]) << 24); + x2 = ((uint32_t)(arg1[46]) << 16); + x3 = ((uint32_t)(arg1[45]) << 8); + x4 = (arg1[44]); + x5 = ((uint32_t)(arg1[43]) << 24); + x6 = ((uint32_t)(arg1[42]) << 16); + x7 = ((uint32_t)(arg1[41]) << 8); + x8 = (arg1[40]); + x9 = ((uint32_t)(arg1[39]) << 24); + x10 = ((uint32_t)(arg1[38]) << 16); + x11 = ((uint32_t)(arg1[37]) << 8); + x12 = (arg1[36]); + x13 = ((uint32_t)(arg1[35]) << 24); + x14 = ((uint32_t)(arg1[34]) << 16); + x15 = ((uint32_t)(arg1[33]) << 8); + x16 = (arg1[32]); + x17 = ((uint32_t)(arg1[31]) << 24); + x18 = ((uint32_t)(arg1[30]) << 16); + x19 = ((uint32_t)(arg1[29]) << 8); + x20 = (arg1[28]); + x21 = ((uint32_t)(arg1[27]) << 24); + x22 = ((uint32_t)(arg1[26]) << 16); + x23 = ((uint32_t)(arg1[25]) << 8); + x24 = (arg1[24]); + x25 = ((uint32_t)(arg1[23]) << 24); + x26 = ((uint32_t)(arg1[22]) << 16); + x27 = ((uint32_t)(arg1[21]) << 8); + x28 = (arg1[20]); + x29 = ((uint32_t)(arg1[19]) << 24); + x30 = ((uint32_t)(arg1[18]) << 16); + x31 = ((uint32_t)(arg1[17]) << 8); + x32 = (arg1[16]); + x33 = ((uint32_t)(arg1[15]) << 24); + x34 = ((uint32_t)(arg1[14]) << 16); + x35 = ((uint32_t)(arg1[13]) << 8); + x36 = (arg1[12]); + x37 = ((uint32_t)(arg1[11]) << 24); + x38 = ((uint32_t)(arg1[10]) << 16); + x39 = ((uint32_t)(arg1[9]) << 8); + x40 = (arg1[8]); + x41 = ((uint32_t)(arg1[7]) << 24); + x42 = ((uint32_t)(arg1[6]) << 16); + x43 = ((uint32_t)(arg1[5]) << 8); + x44 = (arg1[4]); + x45 = ((uint32_t)(arg1[3]) << 24); + x46 = ((uint32_t)(arg1[2]) << 16); + x47 = ((uint32_t)(arg1[1]) << 8); + x48 = (arg1[0]); + x49 = (x47 + (uint32_t)x48); + x50 = (x46 + x49); + x51 = (x45 + x50); + x52 = (x43 + (uint32_t)x44); + x53 = (x42 + x52); + x54 = (x41 + x53); + x55 = (x39 + (uint32_t)x40); + x56 = (x38 + x55); + x57 = (x37 + x56); + x58 = (x35 + (uint32_t)x36); + x59 = (x34 + x58); + x60 = (x33 + x59); + x61 = (x31 + (uint32_t)x32); + x62 = (x30 + x61); + x63 = (x29 + x62); + x64 = (x27 + (uint32_t)x28); + x65 = (x26 + x64); + x66 = (x25 + x65); + x67 = (x23 + (uint32_t)x24); + x68 = (x22 + x67); + x69 = (x21 + x68); + x70 = (x19 + (uint32_t)x20); + x71 = (x18 + x70); + x72 = (x17 + x71); + x73 = (x15 + (uint32_t)x16); + x74 = (x14 + x73); + x75 = (x13 + x74); + x76 = (x11 + (uint32_t)x12); + x77 = (x10 + x76); + x78 = (x9 + x77); + x79 = (x7 + (uint32_t)x8); + x80 = (x6 + x79); + x81 = (x5 + x80); + x82 = (x3 + (uint32_t)x4); + x83 = (x2 + x82); + x84 = (x1 + x83); + out1[0] = x51; + out1[1] = x54; + out1[2] = x57; + out1[3] = x60; + out1[4] = x63; + out1[5] = x66; + out1[6] = x69; + out1[7] = x72; + out1[8] = x75; + out1[9] = x78; + out1[10] = x81; + out1[11] = x84; +} + +/* + * The function fiat_p384_scalar_set_one returns the field element one in the Montgomery domain. + * + * Postconditions: + * eval (from_montgomery out1) mod m = 1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_set_one(fiat_p384_scalar_montgomery_domain_field_element out1) { + out1[0] = UINT32_C(0x333ad68d); + out1[1] = UINT32_C(0x1313e695); + out1[2] = UINT32_C(0xb74f5885); + out1[3] = UINT32_C(0xa7e5f24d); + out1[4] = UINT32_C(0xbc8d220); + out1[5] = UINT32_C(0x389cb27e); + out1[6] = 0x0; + out1[7] = 0x0; + out1[8] = 0x0; + out1[9] = 0x0; + out1[10] = 0x0; + out1[11] = 0x0; +} + +/* + * The function fiat_p384_scalar_msat returns the saturated representation of the prime modulus. + * + * Postconditions: + * twos_complement_eval out1 = m + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_msat(uint32_t out1[13]) { + out1[0] = UINT32_C(0xccc52973); + out1[1] = UINT32_C(0xecec196a); + out1[2] = UINT32_C(0x48b0a77a); + out1[3] = UINT32_C(0x581a0db2); + out1[4] = UINT32_C(0xf4372ddf); + out1[5] = UINT32_C(0xc7634d81); + out1[6] = UINT32_C(0xffffffff); + out1[7] = UINT32_C(0xffffffff); + out1[8] = UINT32_C(0xffffffff); + out1[9] = UINT32_C(0xffffffff); + out1[10] = UINT32_C(0xffffffff); + out1[11] = UINT32_C(0xffffffff); + out1[12] = 0x0; +} + +/* + * The function fiat_p384_scalar_divstep computes a divstep. + * + * Preconditions: + * 0 ≤ eval arg4 < m + * 0 ≤ eval arg5 < m + * Postconditions: + * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) + * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) + * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) + * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) + * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) + * 0 ≤ eval out5 < m + * 0 ≤ eval out5 < m + * 0 ≤ eval out2 < m + * 0 ≤ eval out3 < m + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffff] + * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_divstep(uint32_t* out1, uint32_t out2[13], uint32_t out3[13], uint32_t out4[12], uint32_t out5[12], uint32_t arg1, const uint32_t arg2[13], const uint32_t arg3[13], const uint32_t arg4[12], const uint32_t arg5[12]) { + uint32_t x1; + fiat_p384_scalar_uint1 x2; + fiat_p384_scalar_uint1 x3; + uint32_t x4; + fiat_p384_scalar_uint1 x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + fiat_p384_scalar_uint1 x21; + uint32_t x22; + fiat_p384_scalar_uint1 x23; + uint32_t x24; + fiat_p384_scalar_uint1 x25; + uint32_t x26; + fiat_p384_scalar_uint1 x27; + uint32_t x28; + fiat_p384_scalar_uint1 x29; + uint32_t x30; + fiat_p384_scalar_uint1 x31; + uint32_t x32; + fiat_p384_scalar_uint1 x33; + uint32_t x34; + fiat_p384_scalar_uint1 x35; + uint32_t x36; + fiat_p384_scalar_uint1 x37; + uint32_t x38; + fiat_p384_scalar_uint1 x39; + uint32_t x40; + fiat_p384_scalar_uint1 x41; + uint32_t x42; + fiat_p384_scalar_uint1 x43; + uint32_t x44; + fiat_p384_scalar_uint1 x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + uint32_t x53; + uint32_t x54; + uint32_t x55; + uint32_t x56; + uint32_t x57; + uint32_t x58; + uint32_t x59; + uint32_t x60; + uint32_t x61; + uint32_t x62; + uint32_t x63; + uint32_t x64; + uint32_t x65; + uint32_t x66; + uint32_t x67; + uint32_t x68; + uint32_t x69; + uint32_t x70; + uint32_t x71; + fiat_p384_scalar_uint1 x72; + uint32_t x73; + fiat_p384_scalar_uint1 x74; + uint32_t x75; + fiat_p384_scalar_uint1 x76; + uint32_t x77; + fiat_p384_scalar_uint1 x78; + uint32_t x79; + fiat_p384_scalar_uint1 x80; + uint32_t x81; + fiat_p384_scalar_uint1 x82; + uint32_t x83; + fiat_p384_scalar_uint1 x84; + uint32_t x85; + fiat_p384_scalar_uint1 x86; + uint32_t x87; + fiat_p384_scalar_uint1 x88; + uint32_t x89; + fiat_p384_scalar_uint1 x90; + uint32_t x91; + fiat_p384_scalar_uint1 x92; + uint32_t x93; + fiat_p384_scalar_uint1 x94; + uint32_t x95; + fiat_p384_scalar_uint1 x96; + uint32_t x97; + fiat_p384_scalar_uint1 x98; + uint32_t x99; + fiat_p384_scalar_uint1 x100; + uint32_t x101; + fiat_p384_scalar_uint1 x102; + uint32_t x103; + fiat_p384_scalar_uint1 x104; + uint32_t x105; + fiat_p384_scalar_uint1 x106; + uint32_t x107; + fiat_p384_scalar_uint1 x108; + uint32_t x109; + fiat_p384_scalar_uint1 x110; + uint32_t x111; + fiat_p384_scalar_uint1 x112; + uint32_t x113; + fiat_p384_scalar_uint1 x114; + uint32_t x115; + fiat_p384_scalar_uint1 x116; + uint32_t x117; + fiat_p384_scalar_uint1 x118; + uint32_t x119; + fiat_p384_scalar_uint1 x120; + uint32_t x121; + uint32_t x122; + uint32_t x123; + uint32_t x124; + uint32_t x125; + uint32_t x126; + uint32_t x127; + uint32_t x128; + uint32_t x129; + uint32_t x130; + uint32_t x131; + uint32_t x132; + uint32_t x133; + fiat_p384_scalar_uint1 x134; + uint32_t x135; + fiat_p384_scalar_uint1 x136; + uint32_t x137; + fiat_p384_scalar_uint1 x138; + uint32_t x139; + fiat_p384_scalar_uint1 x140; + uint32_t x141; + fiat_p384_scalar_uint1 x142; + uint32_t x143; + fiat_p384_scalar_uint1 x144; + uint32_t x145; + fiat_p384_scalar_uint1 x146; + uint32_t x147; + fiat_p384_scalar_uint1 x148; + uint32_t x149; + fiat_p384_scalar_uint1 x150; + uint32_t x151; + fiat_p384_scalar_uint1 x152; + uint32_t x153; + fiat_p384_scalar_uint1 x154; + uint32_t x155; + fiat_p384_scalar_uint1 x156; + uint32_t x157; + uint32_t x158; + fiat_p384_scalar_uint1 x159; + uint32_t x160; + fiat_p384_scalar_uint1 x161; + uint32_t x162; + fiat_p384_scalar_uint1 x163; + uint32_t x164; + fiat_p384_scalar_uint1 x165; + uint32_t x166; + fiat_p384_scalar_uint1 x167; + uint32_t x168; + fiat_p384_scalar_uint1 x169; + uint32_t x170; + fiat_p384_scalar_uint1 x171; + uint32_t x172; + fiat_p384_scalar_uint1 x173; + uint32_t x174; + fiat_p384_scalar_uint1 x175; + uint32_t x176; + fiat_p384_scalar_uint1 x177; + uint32_t x178; + fiat_p384_scalar_uint1 x179; + uint32_t x180; + fiat_p384_scalar_uint1 x181; + uint32_t x182; + uint32_t x183; + uint32_t x184; + uint32_t x185; + uint32_t x186; + uint32_t x187; + uint32_t x188; + uint32_t x189; + uint32_t x190; + uint32_t x191; + uint32_t x192; + uint32_t x193; + fiat_p384_scalar_uint1 x194; + uint32_t x195; + uint32_t x196; + uint32_t x197; + uint32_t x198; + uint32_t x199; + uint32_t x200; + uint32_t x201; + uint32_t x202; + uint32_t x203; + uint32_t x204; + uint32_t x205; + uint32_t x206; + uint32_t x207; + uint32_t x208; + fiat_p384_scalar_uint1 x209; + uint32_t x210; + fiat_p384_scalar_uint1 x211; + uint32_t x212; + fiat_p384_scalar_uint1 x213; + uint32_t x214; + fiat_p384_scalar_uint1 x215; + uint32_t x216; + fiat_p384_scalar_uint1 x217; + uint32_t x218; + fiat_p384_scalar_uint1 x219; + uint32_t x220; + fiat_p384_scalar_uint1 x221; + uint32_t x222; + fiat_p384_scalar_uint1 x223; + uint32_t x224; + fiat_p384_scalar_uint1 x225; + uint32_t x226; + fiat_p384_scalar_uint1 x227; + uint32_t x228; + fiat_p384_scalar_uint1 x229; + uint32_t x230; + fiat_p384_scalar_uint1 x231; + uint32_t x232; + fiat_p384_scalar_uint1 x233; + uint32_t x234; + uint32_t x235; + uint32_t x236; + uint32_t x237; + uint32_t x238; + uint32_t x239; + uint32_t x240; + uint32_t x241; + uint32_t x242; + uint32_t x243; + uint32_t x244; + uint32_t x245; + uint32_t x246; + fiat_p384_scalar_uint1 x247; + uint32_t x248; + fiat_p384_scalar_uint1 x249; + uint32_t x250; + fiat_p384_scalar_uint1 x251; + uint32_t x252; + fiat_p384_scalar_uint1 x253; + uint32_t x254; + fiat_p384_scalar_uint1 x255; + uint32_t x256; + fiat_p384_scalar_uint1 x257; + uint32_t x258; + fiat_p384_scalar_uint1 x259; + uint32_t x260; + fiat_p384_scalar_uint1 x261; + uint32_t x262; + fiat_p384_scalar_uint1 x263; + uint32_t x264; + fiat_p384_scalar_uint1 x265; + uint32_t x266; + fiat_p384_scalar_uint1 x267; + uint32_t x268; + fiat_p384_scalar_uint1 x269; + uint32_t x270; + fiat_p384_scalar_uint1 x271; + uint32_t x272; + fiat_p384_scalar_uint1 x273; + uint32_t x274; + fiat_p384_scalar_uint1 x275; + uint32_t x276; + fiat_p384_scalar_uint1 x277; + uint32_t x278; + fiat_p384_scalar_uint1 x279; + uint32_t x280; + fiat_p384_scalar_uint1 x281; + uint32_t x282; + fiat_p384_scalar_uint1 x283; + uint32_t x284; + fiat_p384_scalar_uint1 x285; + uint32_t x286; + fiat_p384_scalar_uint1 x287; + uint32_t x288; + fiat_p384_scalar_uint1 x289; + uint32_t x290; + fiat_p384_scalar_uint1 x291; + uint32_t x292; + fiat_p384_scalar_uint1 x293; + uint32_t x294; + fiat_p384_scalar_uint1 x295; + uint32_t x296; + fiat_p384_scalar_uint1 x297; + uint32_t x298; + uint32_t x299; + uint32_t x300; + uint32_t x301; + uint32_t x302; + uint32_t x303; + uint32_t x304; + uint32_t x305; + uint32_t x306; + uint32_t x307; + uint32_t x308; + uint32_t x309; + uint32_t x310; + uint32_t x311; + uint32_t x312; + uint32_t x313; + uint32_t x314; + uint32_t x315; + uint32_t x316; + uint32_t x317; + uint32_t x318; + uint32_t x319; + uint32_t x320; + uint32_t x321; + uint32_t x322; + uint32_t x323; + uint32_t x324; + uint32_t x325; + uint32_t x326; + uint32_t x327; + uint32_t x328; + uint32_t x329; + uint32_t x330; + uint32_t x331; + uint32_t x332; + uint32_t x333; + uint32_t x334; + fiat_p384_scalar_addcarryx_u32(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_p384_scalar_uint1)((fiat_p384_scalar_uint1)(x1 >> 31) & (fiat_p384_scalar_uint1)((arg3[0]) & 0x1)); + fiat_p384_scalar_addcarryx_u32(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_p384_scalar_cmovznz_u32(&x6, x3, arg1, x4); + fiat_p384_scalar_cmovznz_u32(&x7, x3, (arg2[0]), (arg3[0])); + fiat_p384_scalar_cmovznz_u32(&x8, x3, (arg2[1]), (arg3[1])); + fiat_p384_scalar_cmovznz_u32(&x9, x3, (arg2[2]), (arg3[2])); + fiat_p384_scalar_cmovznz_u32(&x10, x3, (arg2[3]), (arg3[3])); + fiat_p384_scalar_cmovznz_u32(&x11, x3, (arg2[4]), (arg3[4])); + fiat_p384_scalar_cmovznz_u32(&x12, x3, (arg2[5]), (arg3[5])); + fiat_p384_scalar_cmovznz_u32(&x13, x3, (arg2[6]), (arg3[6])); + fiat_p384_scalar_cmovznz_u32(&x14, x3, (arg2[7]), (arg3[7])); + fiat_p384_scalar_cmovznz_u32(&x15, x3, (arg2[8]), (arg3[8])); + fiat_p384_scalar_cmovznz_u32(&x16, x3, (arg2[9]), (arg3[9])); + fiat_p384_scalar_cmovznz_u32(&x17, x3, (arg2[10]), (arg3[10])); + fiat_p384_scalar_cmovznz_u32(&x18, x3, (arg2[11]), (arg3[11])); + fiat_p384_scalar_cmovznz_u32(&x19, x3, (arg2[12]), (arg3[12])); + fiat_p384_scalar_addcarryx_u32(&x20, &x21, 0x0, 0x1, (~(arg2[0]))); + fiat_p384_scalar_addcarryx_u32(&x22, &x23, x21, 0x0, (~(arg2[1]))); + fiat_p384_scalar_addcarryx_u32(&x24, &x25, x23, 0x0, (~(arg2[2]))); + fiat_p384_scalar_addcarryx_u32(&x26, &x27, x25, 0x0, (~(arg2[3]))); + fiat_p384_scalar_addcarryx_u32(&x28, &x29, x27, 0x0, (~(arg2[4]))); + fiat_p384_scalar_addcarryx_u32(&x30, &x31, x29, 0x0, (~(arg2[5]))); + fiat_p384_scalar_addcarryx_u32(&x32, &x33, x31, 0x0, (~(arg2[6]))); + fiat_p384_scalar_addcarryx_u32(&x34, &x35, x33, 0x0, (~(arg2[7]))); + fiat_p384_scalar_addcarryx_u32(&x36, &x37, x35, 0x0, (~(arg2[8]))); + fiat_p384_scalar_addcarryx_u32(&x38, &x39, x37, 0x0, (~(arg2[9]))); + fiat_p384_scalar_addcarryx_u32(&x40, &x41, x39, 0x0, (~(arg2[10]))); + fiat_p384_scalar_addcarryx_u32(&x42, &x43, x41, 0x0, (~(arg2[11]))); + fiat_p384_scalar_addcarryx_u32(&x44, &x45, x43, 0x0, (~(arg2[12]))); + fiat_p384_scalar_cmovznz_u32(&x46, x3, (arg3[0]), x20); + fiat_p384_scalar_cmovznz_u32(&x47, x3, (arg3[1]), x22); + fiat_p384_scalar_cmovznz_u32(&x48, x3, (arg3[2]), x24); + fiat_p384_scalar_cmovznz_u32(&x49, x3, (arg3[3]), x26); + fiat_p384_scalar_cmovznz_u32(&x50, x3, (arg3[4]), x28); + fiat_p384_scalar_cmovznz_u32(&x51, x3, (arg3[5]), x30); + fiat_p384_scalar_cmovznz_u32(&x52, x3, (arg3[6]), x32); + fiat_p384_scalar_cmovznz_u32(&x53, x3, (arg3[7]), x34); + fiat_p384_scalar_cmovznz_u32(&x54, x3, (arg3[8]), x36); + fiat_p384_scalar_cmovznz_u32(&x55, x3, (arg3[9]), x38); + fiat_p384_scalar_cmovznz_u32(&x56, x3, (arg3[10]), x40); + fiat_p384_scalar_cmovznz_u32(&x57, x3, (arg3[11]), x42); + fiat_p384_scalar_cmovznz_u32(&x58, x3, (arg3[12]), x44); + fiat_p384_scalar_cmovznz_u32(&x59, x3, (arg4[0]), (arg5[0])); + fiat_p384_scalar_cmovznz_u32(&x60, x3, (arg4[1]), (arg5[1])); + fiat_p384_scalar_cmovznz_u32(&x61, x3, (arg4[2]), (arg5[2])); + fiat_p384_scalar_cmovznz_u32(&x62, x3, (arg4[3]), (arg5[3])); + fiat_p384_scalar_cmovznz_u32(&x63, x3, (arg4[4]), (arg5[4])); + fiat_p384_scalar_cmovznz_u32(&x64, x3, (arg4[5]), (arg5[5])); + fiat_p384_scalar_cmovznz_u32(&x65, x3, (arg4[6]), (arg5[6])); + fiat_p384_scalar_cmovznz_u32(&x66, x3, (arg4[7]), (arg5[7])); + fiat_p384_scalar_cmovznz_u32(&x67, x3, (arg4[8]), (arg5[8])); + fiat_p384_scalar_cmovznz_u32(&x68, x3, (arg4[9]), (arg5[9])); + fiat_p384_scalar_cmovznz_u32(&x69, x3, (arg4[10]), (arg5[10])); + fiat_p384_scalar_cmovznz_u32(&x70, x3, (arg4[11]), (arg5[11])); + fiat_p384_scalar_addcarryx_u32(&x71, &x72, 0x0, x59, x59); + fiat_p384_scalar_addcarryx_u32(&x73, &x74, x72, x60, x60); + fiat_p384_scalar_addcarryx_u32(&x75, &x76, x74, x61, x61); + fiat_p384_scalar_addcarryx_u32(&x77, &x78, x76, x62, x62); + fiat_p384_scalar_addcarryx_u32(&x79, &x80, x78, x63, x63); + fiat_p384_scalar_addcarryx_u32(&x81, &x82, x80, x64, x64); + fiat_p384_scalar_addcarryx_u32(&x83, &x84, x82, x65, x65); + fiat_p384_scalar_addcarryx_u32(&x85, &x86, x84, x66, x66); + fiat_p384_scalar_addcarryx_u32(&x87, &x88, x86, x67, x67); + fiat_p384_scalar_addcarryx_u32(&x89, &x90, x88, x68, x68); + fiat_p384_scalar_addcarryx_u32(&x91, &x92, x90, x69, x69); + fiat_p384_scalar_addcarryx_u32(&x93, &x94, x92, x70, x70); + fiat_p384_scalar_subborrowx_u32(&x95, &x96, 0x0, x71, UINT32_C(0xccc52973)); + fiat_p384_scalar_subborrowx_u32(&x97, &x98, x96, x73, UINT32_C(0xecec196a)); + fiat_p384_scalar_subborrowx_u32(&x99, &x100, x98, x75, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_subborrowx_u32(&x101, &x102, x100, x77, UINT32_C(0x581a0db2)); + fiat_p384_scalar_subborrowx_u32(&x103, &x104, x102, x79, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_subborrowx_u32(&x105, &x106, x104, x81, UINT32_C(0xc7634d81)); + fiat_p384_scalar_subborrowx_u32(&x107, &x108, x106, x83, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x109, &x110, x108, x85, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x111, &x112, x110, x87, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x113, &x114, x112, x89, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x115, &x116, x114, x91, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x117, &x118, x116, x93, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x119, &x120, x118, x94, 0x0); + x121 = (arg4[11]); + x122 = (arg4[10]); + x123 = (arg4[9]); + x124 = (arg4[8]); + x125 = (arg4[7]); + x126 = (arg4[6]); + x127 = (arg4[5]); + x128 = (arg4[4]); + x129 = (arg4[3]); + x130 = (arg4[2]); + x131 = (arg4[1]); + x132 = (arg4[0]); + fiat_p384_scalar_subborrowx_u32(&x133, &x134, 0x0, 0x0, x132); + fiat_p384_scalar_subborrowx_u32(&x135, &x136, x134, 0x0, x131); + fiat_p384_scalar_subborrowx_u32(&x137, &x138, x136, 0x0, x130); + fiat_p384_scalar_subborrowx_u32(&x139, &x140, x138, 0x0, x129); + fiat_p384_scalar_subborrowx_u32(&x141, &x142, x140, 0x0, x128); + fiat_p384_scalar_subborrowx_u32(&x143, &x144, x142, 0x0, x127); + fiat_p384_scalar_subborrowx_u32(&x145, &x146, x144, 0x0, x126); + fiat_p384_scalar_subborrowx_u32(&x147, &x148, x146, 0x0, x125); + fiat_p384_scalar_subborrowx_u32(&x149, &x150, x148, 0x0, x124); + fiat_p384_scalar_subborrowx_u32(&x151, &x152, x150, 0x0, x123); + fiat_p384_scalar_subborrowx_u32(&x153, &x154, x152, 0x0, x122); + fiat_p384_scalar_subborrowx_u32(&x155, &x156, x154, 0x0, x121); + fiat_p384_scalar_cmovznz_u32(&x157, x156, 0x0, UINT32_C(0xffffffff)); + fiat_p384_scalar_addcarryx_u32(&x158, &x159, 0x0, x133, (x157 & UINT32_C(0xccc52973))); + fiat_p384_scalar_addcarryx_u32(&x160, &x161, x159, x135, (x157 & UINT32_C(0xecec196a))); + fiat_p384_scalar_addcarryx_u32(&x162, &x163, x161, x137, (x157 & UINT32_C(0x48b0a77a))); + fiat_p384_scalar_addcarryx_u32(&x164, &x165, x163, x139, (x157 & UINT32_C(0x581a0db2))); + fiat_p384_scalar_addcarryx_u32(&x166, &x167, x165, x141, (x157 & UINT32_C(0xf4372ddf))); + fiat_p384_scalar_addcarryx_u32(&x168, &x169, x167, x143, (x157 & UINT32_C(0xc7634d81))); + fiat_p384_scalar_addcarryx_u32(&x170, &x171, x169, x145, x157); + fiat_p384_scalar_addcarryx_u32(&x172, &x173, x171, x147, x157); + fiat_p384_scalar_addcarryx_u32(&x174, &x175, x173, x149, x157); + fiat_p384_scalar_addcarryx_u32(&x176, &x177, x175, x151, x157); + fiat_p384_scalar_addcarryx_u32(&x178, &x179, x177, x153, x157); + fiat_p384_scalar_addcarryx_u32(&x180, &x181, x179, x155, x157); + fiat_p384_scalar_cmovznz_u32(&x182, x3, (arg5[0]), x158); + fiat_p384_scalar_cmovznz_u32(&x183, x3, (arg5[1]), x160); + fiat_p384_scalar_cmovznz_u32(&x184, x3, (arg5[2]), x162); + fiat_p384_scalar_cmovznz_u32(&x185, x3, (arg5[3]), x164); + fiat_p384_scalar_cmovznz_u32(&x186, x3, (arg5[4]), x166); + fiat_p384_scalar_cmovznz_u32(&x187, x3, (arg5[5]), x168); + fiat_p384_scalar_cmovznz_u32(&x188, x3, (arg5[6]), x170); + fiat_p384_scalar_cmovznz_u32(&x189, x3, (arg5[7]), x172); + fiat_p384_scalar_cmovznz_u32(&x190, x3, (arg5[8]), x174); + fiat_p384_scalar_cmovznz_u32(&x191, x3, (arg5[9]), x176); + fiat_p384_scalar_cmovznz_u32(&x192, x3, (arg5[10]), x178); + fiat_p384_scalar_cmovznz_u32(&x193, x3, (arg5[11]), x180); + x194 = (fiat_p384_scalar_uint1)(x46 & 0x1); + fiat_p384_scalar_cmovznz_u32(&x195, x194, 0x0, x7); + fiat_p384_scalar_cmovznz_u32(&x196, x194, 0x0, x8); + fiat_p384_scalar_cmovznz_u32(&x197, x194, 0x0, x9); + fiat_p384_scalar_cmovznz_u32(&x198, x194, 0x0, x10); + fiat_p384_scalar_cmovznz_u32(&x199, x194, 0x0, x11); + fiat_p384_scalar_cmovznz_u32(&x200, x194, 0x0, x12); + fiat_p384_scalar_cmovznz_u32(&x201, x194, 0x0, x13); + fiat_p384_scalar_cmovznz_u32(&x202, x194, 0x0, x14); + fiat_p384_scalar_cmovznz_u32(&x203, x194, 0x0, x15); + fiat_p384_scalar_cmovznz_u32(&x204, x194, 0x0, x16); + fiat_p384_scalar_cmovznz_u32(&x205, x194, 0x0, x17); + fiat_p384_scalar_cmovznz_u32(&x206, x194, 0x0, x18); + fiat_p384_scalar_cmovznz_u32(&x207, x194, 0x0, x19); + fiat_p384_scalar_addcarryx_u32(&x208, &x209, 0x0, x46, x195); + fiat_p384_scalar_addcarryx_u32(&x210, &x211, x209, x47, x196); + fiat_p384_scalar_addcarryx_u32(&x212, &x213, x211, x48, x197); + fiat_p384_scalar_addcarryx_u32(&x214, &x215, x213, x49, x198); + fiat_p384_scalar_addcarryx_u32(&x216, &x217, x215, x50, x199); + fiat_p384_scalar_addcarryx_u32(&x218, &x219, x217, x51, x200); + fiat_p384_scalar_addcarryx_u32(&x220, &x221, x219, x52, x201); + fiat_p384_scalar_addcarryx_u32(&x222, &x223, x221, x53, x202); + fiat_p384_scalar_addcarryx_u32(&x224, &x225, x223, x54, x203); + fiat_p384_scalar_addcarryx_u32(&x226, &x227, x225, x55, x204); + fiat_p384_scalar_addcarryx_u32(&x228, &x229, x227, x56, x205); + fiat_p384_scalar_addcarryx_u32(&x230, &x231, x229, x57, x206); + fiat_p384_scalar_addcarryx_u32(&x232, &x233, x231, x58, x207); + fiat_p384_scalar_cmovznz_u32(&x234, x194, 0x0, x59); + fiat_p384_scalar_cmovznz_u32(&x235, x194, 0x0, x60); + fiat_p384_scalar_cmovznz_u32(&x236, x194, 0x0, x61); + fiat_p384_scalar_cmovznz_u32(&x237, x194, 0x0, x62); + fiat_p384_scalar_cmovznz_u32(&x238, x194, 0x0, x63); + fiat_p384_scalar_cmovznz_u32(&x239, x194, 0x0, x64); + fiat_p384_scalar_cmovznz_u32(&x240, x194, 0x0, x65); + fiat_p384_scalar_cmovznz_u32(&x241, x194, 0x0, x66); + fiat_p384_scalar_cmovznz_u32(&x242, x194, 0x0, x67); + fiat_p384_scalar_cmovznz_u32(&x243, x194, 0x0, x68); + fiat_p384_scalar_cmovznz_u32(&x244, x194, 0x0, x69); + fiat_p384_scalar_cmovznz_u32(&x245, x194, 0x0, x70); + fiat_p384_scalar_addcarryx_u32(&x246, &x247, 0x0, x182, x234); + fiat_p384_scalar_addcarryx_u32(&x248, &x249, x247, x183, x235); + fiat_p384_scalar_addcarryx_u32(&x250, &x251, x249, x184, x236); + fiat_p384_scalar_addcarryx_u32(&x252, &x253, x251, x185, x237); + fiat_p384_scalar_addcarryx_u32(&x254, &x255, x253, x186, x238); + fiat_p384_scalar_addcarryx_u32(&x256, &x257, x255, x187, x239); + fiat_p384_scalar_addcarryx_u32(&x258, &x259, x257, x188, x240); + fiat_p384_scalar_addcarryx_u32(&x260, &x261, x259, x189, x241); + fiat_p384_scalar_addcarryx_u32(&x262, &x263, x261, x190, x242); + fiat_p384_scalar_addcarryx_u32(&x264, &x265, x263, x191, x243); + fiat_p384_scalar_addcarryx_u32(&x266, &x267, x265, x192, x244); + fiat_p384_scalar_addcarryx_u32(&x268, &x269, x267, x193, x245); + fiat_p384_scalar_subborrowx_u32(&x270, &x271, 0x0, x246, UINT32_C(0xccc52973)); + fiat_p384_scalar_subborrowx_u32(&x272, &x273, x271, x248, UINT32_C(0xecec196a)); + fiat_p384_scalar_subborrowx_u32(&x274, &x275, x273, x250, UINT32_C(0x48b0a77a)); + fiat_p384_scalar_subborrowx_u32(&x276, &x277, x275, x252, UINT32_C(0x581a0db2)); + fiat_p384_scalar_subborrowx_u32(&x278, &x279, x277, x254, UINT32_C(0xf4372ddf)); + fiat_p384_scalar_subborrowx_u32(&x280, &x281, x279, x256, UINT32_C(0xc7634d81)); + fiat_p384_scalar_subborrowx_u32(&x282, &x283, x281, x258, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x284, &x285, x283, x260, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x286, &x287, x285, x262, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x288, &x289, x287, x264, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x290, &x291, x289, x266, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x292, &x293, x291, x268, UINT32_C(0xffffffff)); + fiat_p384_scalar_subborrowx_u32(&x294, &x295, x293, x269, 0x0); + fiat_p384_scalar_addcarryx_u32(&x296, &x297, 0x0, x6, 0x1); + x298 = ((x208 >> 1) | ((x210 << 31) & UINT32_C(0xffffffff))); + x299 = ((x210 >> 1) | ((x212 << 31) & UINT32_C(0xffffffff))); + x300 = ((x212 >> 1) | ((x214 << 31) & UINT32_C(0xffffffff))); + x301 = ((x214 >> 1) | ((x216 << 31) & UINT32_C(0xffffffff))); + x302 = ((x216 >> 1) | ((x218 << 31) & UINT32_C(0xffffffff))); + x303 = ((x218 >> 1) | ((x220 << 31) & UINT32_C(0xffffffff))); + x304 = ((x220 >> 1) | ((x222 << 31) & UINT32_C(0xffffffff))); + x305 = ((x222 >> 1) | ((x224 << 31) & UINT32_C(0xffffffff))); + x306 = ((x224 >> 1) | ((x226 << 31) & UINT32_C(0xffffffff))); + x307 = ((x226 >> 1) | ((x228 << 31) & UINT32_C(0xffffffff))); + x308 = ((x228 >> 1) | ((x230 << 31) & UINT32_C(0xffffffff))); + x309 = ((x230 >> 1) | ((x232 << 31) & UINT32_C(0xffffffff))); + x310 = ((x232 & UINT32_C(0x80000000)) | (x232 >> 1)); + fiat_p384_scalar_cmovznz_u32(&x311, x120, x95, x71); + fiat_p384_scalar_cmovznz_u32(&x312, x120, x97, x73); + fiat_p384_scalar_cmovznz_u32(&x313, x120, x99, x75); + fiat_p384_scalar_cmovznz_u32(&x314, x120, x101, x77); + fiat_p384_scalar_cmovznz_u32(&x315, x120, x103, x79); + fiat_p384_scalar_cmovznz_u32(&x316, x120, x105, x81); + fiat_p384_scalar_cmovznz_u32(&x317, x120, x107, x83); + fiat_p384_scalar_cmovznz_u32(&x318, x120, x109, x85); + fiat_p384_scalar_cmovznz_u32(&x319, x120, x111, x87); + fiat_p384_scalar_cmovznz_u32(&x320, x120, x113, x89); + fiat_p384_scalar_cmovznz_u32(&x321, x120, x115, x91); + fiat_p384_scalar_cmovznz_u32(&x322, x120, x117, x93); + fiat_p384_scalar_cmovznz_u32(&x323, x295, x270, x246); + fiat_p384_scalar_cmovznz_u32(&x324, x295, x272, x248); + fiat_p384_scalar_cmovznz_u32(&x325, x295, x274, x250); + fiat_p384_scalar_cmovznz_u32(&x326, x295, x276, x252); + fiat_p384_scalar_cmovznz_u32(&x327, x295, x278, x254); + fiat_p384_scalar_cmovznz_u32(&x328, x295, x280, x256); + fiat_p384_scalar_cmovznz_u32(&x329, x295, x282, x258); + fiat_p384_scalar_cmovznz_u32(&x330, x295, x284, x260); + fiat_p384_scalar_cmovznz_u32(&x331, x295, x286, x262); + fiat_p384_scalar_cmovznz_u32(&x332, x295, x288, x264); + fiat_p384_scalar_cmovznz_u32(&x333, x295, x290, x266); + fiat_p384_scalar_cmovznz_u32(&x334, x295, x292, x268); + *out1 = x296; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out2[7] = x14; + out2[8] = x15; + out2[9] = x16; + out2[10] = x17; + out2[11] = x18; + out2[12] = x19; + out3[0] = x298; + out3[1] = x299; + out3[2] = x300; + out3[3] = x301; + out3[4] = x302; + out3[5] = x303; + out3[6] = x304; + out3[7] = x305; + out3[8] = x306; + out3[9] = x307; + out3[10] = x308; + out3[11] = x309; + out3[12] = x310; + out4[0] = x311; + out4[1] = x312; + out4[2] = x313; + out4[3] = x314; + out4[4] = x315; + out4[5] = x316; + out4[6] = x317; + out4[7] = x318; + out4[8] = x319; + out4[9] = x320; + out4[10] = x321; + out4[11] = x322; + out5[0] = x323; + out5[1] = x324; + out5[2] = x325; + out5[3] = x326; + out5[4] = x327; + out5[5] = x328; + out5[6] = x329; + out5[7] = x330; + out5[8] = x331; + out5[9] = x332; + out5[10] = x333; + out5[11] = x334; +} + +/* + * The function fiat_p384_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). + * + * Postconditions: + * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_divstep_precomp(uint32_t out1[12]) { + out1[0] = UINT32_C(0xe6045b6a); + out1[1] = UINT32_C(0x49589ae0); + out1[2] = UINT32_C(0x870040ed); + out1[3] = UINT32_C(0x3c9a5352); + out1[4] = UINT32_C(0x977dc242); + out1[5] = UINT32_C(0xdacb097e); + out1[6] = UINT32_C(0xd1ecbe36); + out1[7] = UINT32_C(0xb5ab30a6); + out1[8] = UINT32_C(0x1f959973); + out1[9] = UINT32_C(0x97d7a108); + out1[10] = UINT32_C(0xd27192bc); + out1[11] = UINT32_C(0x2ba012f8); +} diff --git a/fiat-c/src/p384_scalar_64.c b/fiat-c/src/p384_scalar_64.c new file mode 100644 index 0000000000..eb84893334 --- /dev/null +++ b/fiat-c/src/p384_scalar_64.c @@ -0,0 +1,3924 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier p384_scalar 64 '2^384 - 1388124618062372383947042015309946732620727252194336364173' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: p384_scalar */ +/* machine_wordsize = 64 (from "64") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from "2^384 - 1388124618062372383947042015309946732620727252194336364173") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) in */ +/* if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384 */ + +#include +typedef unsigned char fiat_p384_scalar_uint1; +typedef signed char fiat_p384_scalar_int1; +#if defined(__GNUC__) || defined(__clang__) +# define FIAT_P384_SCALAR_FIAT_EXTENSION __extension__ +# define FIAT_P384_SCALAR_FIAT_INLINE __inline__ +#else +# define FIAT_P384_SCALAR_FIAT_EXTENSION +# define FIAT_P384_SCALAR_FIAT_INLINE +#endif + +FIAT_P384_SCALAR_FIAT_EXTENSION typedef signed __int128 fiat_p384_scalar_int128; +FIAT_P384_SCALAR_FIAT_EXTENSION typedef unsigned __int128 fiat_p384_scalar_uint128; + +/* The type fiat_p384_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +typedef uint64_t fiat_p384_scalar_montgomery_domain_field_element[6]; + +/* The type fiat_p384_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +typedef uint64_t fiat_p384_scalar_non_montgomery_domain_field_element[6]; + +#if (-1 & 3) != 3 +#error "This code only works on a two's complement system" +#endif + +#if !defined(FIAT_P384_SCALAR_NO_ASM) && (defined(__GNUC__) || defined(__clang__)) +static __inline__ uint64_t fiat_p384_scalar_value_barrier_u64(uint64_t a) { + __asm__("" : "+r"(a) : /* no inputs */); + return a; +} +#else +# define fiat_p384_scalar_value_barrier_u64(x) (x) +#endif + + +/* + * The function fiat_p384_scalar_addcarryx_u64 is an addition with carry. + * + * Postconditions: + * out1 = (arg1 + arg2 + arg3) mod 2^64 + * out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_addcarryx_u64(uint64_t* out1, fiat_p384_scalar_uint1* out2, fiat_p384_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_p384_scalar_uint128 x1; + uint64_t x2; + fiat_p384_scalar_uint1 x3; + x1 = ((arg1 + (fiat_p384_scalar_uint128)arg2) + arg3); + x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + x3 = (fiat_p384_scalar_uint1)(x1 >> 64); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_p384_scalar_subborrowx_u64 is a subtraction with borrow. + * + * Postconditions: + * out1 = (-arg1 + arg2 + -arg3) mod 2^64 + * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_subborrowx_u64(uint64_t* out1, fiat_p384_scalar_uint1* out2, fiat_p384_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_p384_scalar_int128 x1; + fiat_p384_scalar_int1 x2; + uint64_t x3; + x1 = ((arg2 - (fiat_p384_scalar_int128)arg1) - arg3); + x2 = (fiat_p384_scalar_int1)(x1 >> 64); + x3 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + *out1 = x3; + *out2 = (fiat_p384_scalar_uint1)(0x0 - x2); +} + +/* + * The function fiat_p384_scalar_mulx_u64 is a multiplication, returning the full double-width result. + * + * Postconditions: + * out1 = (arg1 * arg2) mod 2^64 + * out2 = ⌊arg1 * arg2 / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffffffffffff] + * arg2: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_mulx_u64(uint64_t* out1, uint64_t* out2, uint64_t arg1, uint64_t arg2) { + fiat_p384_scalar_uint128 x1; + uint64_t x2; + uint64_t x3; + x1 = ((fiat_p384_scalar_uint128)arg1 * arg2); + x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + x3 = (uint64_t)(x1 >> 64); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_p384_scalar_cmovznz_u64 is a single-word conditional move. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_cmovznz_u64(uint64_t* out1, fiat_p384_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_p384_scalar_uint1 x1; + uint64_t x2; + uint64_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_p384_scalar_int1)(0x0 - x1) & UINT64_C(0xffffffffffffffff)); + x3 = ((fiat_p384_scalar_value_barrier_u64(x2) & arg3) | (fiat_p384_scalar_value_barrier_u64((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_p384_scalar_mul multiplies two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_mul(fiat_p384_scalar_montgomery_domain_field_element out1, const fiat_p384_scalar_montgomery_domain_field_element arg1, const fiat_p384_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint64_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + fiat_p384_scalar_uint1 x20; + uint64_t x21; + fiat_p384_scalar_uint1 x22; + uint64_t x23; + fiat_p384_scalar_uint1 x24; + uint64_t x25; + fiat_p384_scalar_uint1 x26; + uint64_t x27; + fiat_p384_scalar_uint1 x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint64_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + fiat_p384_scalar_uint1 x45; + uint64_t x46; + fiat_p384_scalar_uint1 x47; + uint64_t x48; + fiat_p384_scalar_uint1 x49; + uint64_t x50; + fiat_p384_scalar_uint1 x51; + uint64_t x52; + fiat_p384_scalar_uint1 x53; + uint64_t x54; + uint64_t x55; + fiat_p384_scalar_uint1 x56; + uint64_t x57; + fiat_p384_scalar_uint1 x58; + uint64_t x59; + fiat_p384_scalar_uint1 x60; + uint64_t x61; + fiat_p384_scalar_uint1 x62; + uint64_t x63; + fiat_p384_scalar_uint1 x64; + uint64_t x65; + fiat_p384_scalar_uint1 x66; + uint64_t x67; + fiat_p384_scalar_uint1 x68; + uint64_t x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + uint64_t x81; + fiat_p384_scalar_uint1 x82; + uint64_t x83; + fiat_p384_scalar_uint1 x84; + uint64_t x85; + fiat_p384_scalar_uint1 x86; + uint64_t x87; + fiat_p384_scalar_uint1 x88; + uint64_t x89; + fiat_p384_scalar_uint1 x90; + uint64_t x91; + uint64_t x92; + fiat_p384_scalar_uint1 x93; + uint64_t x94; + fiat_p384_scalar_uint1 x95; + uint64_t x96; + fiat_p384_scalar_uint1 x97; + uint64_t x98; + fiat_p384_scalar_uint1 x99; + uint64_t x100; + fiat_p384_scalar_uint1 x101; + uint64_t x102; + fiat_p384_scalar_uint1 x103; + uint64_t x104; + fiat_p384_scalar_uint1 x105; + uint64_t x106; + uint64_t x107; + uint64_t x108; + uint64_t x109; + uint64_t x110; + uint64_t x111; + uint64_t x112; + uint64_t x113; + uint64_t x114; + uint64_t x115; + uint64_t x116; + uint64_t x117; + uint64_t x118; + uint64_t x119; + uint64_t x120; + fiat_p384_scalar_uint1 x121; + uint64_t x122; + fiat_p384_scalar_uint1 x123; + uint64_t x124; + fiat_p384_scalar_uint1 x125; + uint64_t x126; + fiat_p384_scalar_uint1 x127; + uint64_t x128; + fiat_p384_scalar_uint1 x129; + uint64_t x130; + uint64_t x131; + fiat_p384_scalar_uint1 x132; + uint64_t x133; + fiat_p384_scalar_uint1 x134; + uint64_t x135; + fiat_p384_scalar_uint1 x136; + uint64_t x137; + fiat_p384_scalar_uint1 x138; + uint64_t x139; + fiat_p384_scalar_uint1 x140; + uint64_t x141; + fiat_p384_scalar_uint1 x142; + uint64_t x143; + fiat_p384_scalar_uint1 x144; + uint64_t x145; + uint64_t x146; + uint64_t x147; + uint64_t x148; + uint64_t x149; + uint64_t x150; + uint64_t x151; + uint64_t x152; + uint64_t x153; + uint64_t x154; + uint64_t x155; + uint64_t x156; + uint64_t x157; + uint64_t x158; + fiat_p384_scalar_uint1 x159; + uint64_t x160; + fiat_p384_scalar_uint1 x161; + uint64_t x162; + fiat_p384_scalar_uint1 x163; + uint64_t x164; + fiat_p384_scalar_uint1 x165; + uint64_t x166; + fiat_p384_scalar_uint1 x167; + uint64_t x168; + uint64_t x169; + fiat_p384_scalar_uint1 x170; + uint64_t x171; + fiat_p384_scalar_uint1 x172; + uint64_t x173; + fiat_p384_scalar_uint1 x174; + uint64_t x175; + fiat_p384_scalar_uint1 x176; + uint64_t x177; + fiat_p384_scalar_uint1 x178; + uint64_t x179; + fiat_p384_scalar_uint1 x180; + uint64_t x181; + fiat_p384_scalar_uint1 x182; + uint64_t x183; + uint64_t x184; + uint64_t x185; + uint64_t x186; + uint64_t x187; + uint64_t x188; + uint64_t x189; + uint64_t x190; + uint64_t x191; + uint64_t x192; + uint64_t x193; + uint64_t x194; + uint64_t x195; + uint64_t x196; + uint64_t x197; + fiat_p384_scalar_uint1 x198; + uint64_t x199; + fiat_p384_scalar_uint1 x200; + uint64_t x201; + fiat_p384_scalar_uint1 x202; + uint64_t x203; + fiat_p384_scalar_uint1 x204; + uint64_t x205; + fiat_p384_scalar_uint1 x206; + uint64_t x207; + uint64_t x208; + fiat_p384_scalar_uint1 x209; + uint64_t x210; + fiat_p384_scalar_uint1 x211; + uint64_t x212; + fiat_p384_scalar_uint1 x213; + uint64_t x214; + fiat_p384_scalar_uint1 x215; + uint64_t x216; + fiat_p384_scalar_uint1 x217; + uint64_t x218; + fiat_p384_scalar_uint1 x219; + uint64_t x220; + fiat_p384_scalar_uint1 x221; + uint64_t x222; + uint64_t x223; + uint64_t x224; + uint64_t x225; + uint64_t x226; + uint64_t x227; + uint64_t x228; + uint64_t x229; + uint64_t x230; + uint64_t x231; + uint64_t x232; + uint64_t x233; + uint64_t x234; + uint64_t x235; + fiat_p384_scalar_uint1 x236; + uint64_t x237; + fiat_p384_scalar_uint1 x238; + uint64_t x239; + fiat_p384_scalar_uint1 x240; + uint64_t x241; + fiat_p384_scalar_uint1 x242; + uint64_t x243; + fiat_p384_scalar_uint1 x244; + uint64_t x245; + uint64_t x246; + fiat_p384_scalar_uint1 x247; + uint64_t x248; + fiat_p384_scalar_uint1 x249; + uint64_t x250; + fiat_p384_scalar_uint1 x251; + uint64_t x252; + fiat_p384_scalar_uint1 x253; + uint64_t x254; + fiat_p384_scalar_uint1 x255; + uint64_t x256; + fiat_p384_scalar_uint1 x257; + uint64_t x258; + fiat_p384_scalar_uint1 x259; + uint64_t x260; + uint64_t x261; + uint64_t x262; + uint64_t x263; + uint64_t x264; + uint64_t x265; + uint64_t x266; + uint64_t x267; + uint64_t x268; + uint64_t x269; + uint64_t x270; + uint64_t x271; + uint64_t x272; + uint64_t x273; + uint64_t x274; + fiat_p384_scalar_uint1 x275; + uint64_t x276; + fiat_p384_scalar_uint1 x277; + uint64_t x278; + fiat_p384_scalar_uint1 x279; + uint64_t x280; + fiat_p384_scalar_uint1 x281; + uint64_t x282; + fiat_p384_scalar_uint1 x283; + uint64_t x284; + uint64_t x285; + fiat_p384_scalar_uint1 x286; + uint64_t x287; + fiat_p384_scalar_uint1 x288; + uint64_t x289; + fiat_p384_scalar_uint1 x290; + uint64_t x291; + fiat_p384_scalar_uint1 x292; + uint64_t x293; + fiat_p384_scalar_uint1 x294; + uint64_t x295; + fiat_p384_scalar_uint1 x296; + uint64_t x297; + fiat_p384_scalar_uint1 x298; + uint64_t x299; + uint64_t x300; + uint64_t x301; + uint64_t x302; + uint64_t x303; + uint64_t x304; + uint64_t x305; + uint64_t x306; + uint64_t x307; + uint64_t x308; + uint64_t x309; + uint64_t x310; + uint64_t x311; + uint64_t x312; + fiat_p384_scalar_uint1 x313; + uint64_t x314; + fiat_p384_scalar_uint1 x315; + uint64_t x316; + fiat_p384_scalar_uint1 x317; + uint64_t x318; + fiat_p384_scalar_uint1 x319; + uint64_t x320; + fiat_p384_scalar_uint1 x321; + uint64_t x322; + uint64_t x323; + fiat_p384_scalar_uint1 x324; + uint64_t x325; + fiat_p384_scalar_uint1 x326; + uint64_t x327; + fiat_p384_scalar_uint1 x328; + uint64_t x329; + fiat_p384_scalar_uint1 x330; + uint64_t x331; + fiat_p384_scalar_uint1 x332; + uint64_t x333; + fiat_p384_scalar_uint1 x334; + uint64_t x335; + fiat_p384_scalar_uint1 x336; + uint64_t x337; + uint64_t x338; + uint64_t x339; + uint64_t x340; + uint64_t x341; + uint64_t x342; + uint64_t x343; + uint64_t x344; + uint64_t x345; + uint64_t x346; + uint64_t x347; + uint64_t x348; + uint64_t x349; + uint64_t x350; + uint64_t x351; + fiat_p384_scalar_uint1 x352; + uint64_t x353; + fiat_p384_scalar_uint1 x354; + uint64_t x355; + fiat_p384_scalar_uint1 x356; + uint64_t x357; + fiat_p384_scalar_uint1 x358; + uint64_t x359; + fiat_p384_scalar_uint1 x360; + uint64_t x361; + uint64_t x362; + fiat_p384_scalar_uint1 x363; + uint64_t x364; + fiat_p384_scalar_uint1 x365; + uint64_t x366; + fiat_p384_scalar_uint1 x367; + uint64_t x368; + fiat_p384_scalar_uint1 x369; + uint64_t x370; + fiat_p384_scalar_uint1 x371; + uint64_t x372; + fiat_p384_scalar_uint1 x373; + uint64_t x374; + fiat_p384_scalar_uint1 x375; + uint64_t x376; + uint64_t x377; + uint64_t x378; + uint64_t x379; + uint64_t x380; + uint64_t x381; + uint64_t x382; + uint64_t x383; + uint64_t x384; + uint64_t x385; + uint64_t x386; + uint64_t x387; + uint64_t x388; + uint64_t x389; + fiat_p384_scalar_uint1 x390; + uint64_t x391; + fiat_p384_scalar_uint1 x392; + uint64_t x393; + fiat_p384_scalar_uint1 x394; + uint64_t x395; + fiat_p384_scalar_uint1 x396; + uint64_t x397; + fiat_p384_scalar_uint1 x398; + uint64_t x399; + uint64_t x400; + fiat_p384_scalar_uint1 x401; + uint64_t x402; + fiat_p384_scalar_uint1 x403; + uint64_t x404; + fiat_p384_scalar_uint1 x405; + uint64_t x406; + fiat_p384_scalar_uint1 x407; + uint64_t x408; + fiat_p384_scalar_uint1 x409; + uint64_t x410; + fiat_p384_scalar_uint1 x411; + uint64_t x412; + fiat_p384_scalar_uint1 x413; + uint64_t x414; + uint64_t x415; + uint64_t x416; + uint64_t x417; + uint64_t x418; + uint64_t x419; + uint64_t x420; + uint64_t x421; + uint64_t x422; + uint64_t x423; + uint64_t x424; + uint64_t x425; + uint64_t x426; + uint64_t x427; + uint64_t x428; + fiat_p384_scalar_uint1 x429; + uint64_t x430; + fiat_p384_scalar_uint1 x431; + uint64_t x432; + fiat_p384_scalar_uint1 x433; + uint64_t x434; + fiat_p384_scalar_uint1 x435; + uint64_t x436; + fiat_p384_scalar_uint1 x437; + uint64_t x438; + uint64_t x439; + fiat_p384_scalar_uint1 x440; + uint64_t x441; + fiat_p384_scalar_uint1 x442; + uint64_t x443; + fiat_p384_scalar_uint1 x444; + uint64_t x445; + fiat_p384_scalar_uint1 x446; + uint64_t x447; + fiat_p384_scalar_uint1 x448; + uint64_t x449; + fiat_p384_scalar_uint1 x450; + uint64_t x451; + fiat_p384_scalar_uint1 x452; + uint64_t x453; + uint64_t x454; + fiat_p384_scalar_uint1 x455; + uint64_t x456; + fiat_p384_scalar_uint1 x457; + uint64_t x458; + fiat_p384_scalar_uint1 x459; + uint64_t x460; + fiat_p384_scalar_uint1 x461; + uint64_t x462; + fiat_p384_scalar_uint1 x463; + uint64_t x464; + fiat_p384_scalar_uint1 x465; + uint64_t x466; + fiat_p384_scalar_uint1 x467; + uint64_t x468; + uint64_t x469; + uint64_t x470; + uint64_t x471; + uint64_t x472; + uint64_t x473; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[0]); + fiat_p384_scalar_mulx_u64(&x7, &x8, x6, (arg2[5])); + fiat_p384_scalar_mulx_u64(&x9, &x10, x6, (arg2[4])); + fiat_p384_scalar_mulx_u64(&x11, &x12, x6, (arg2[3])); + fiat_p384_scalar_mulx_u64(&x13, &x14, x6, (arg2[2])); + fiat_p384_scalar_mulx_u64(&x15, &x16, x6, (arg2[1])); + fiat_p384_scalar_mulx_u64(&x17, &x18, x6, (arg2[0])); + fiat_p384_scalar_addcarryx_u64(&x19, &x20, 0x0, x18, x15); + fiat_p384_scalar_addcarryx_u64(&x21, &x22, x20, x16, x13); + fiat_p384_scalar_addcarryx_u64(&x23, &x24, x22, x14, x11); + fiat_p384_scalar_addcarryx_u64(&x25, &x26, x24, x12, x9); + fiat_p384_scalar_addcarryx_u64(&x27, &x28, x26, x10, x7); + x29 = (x28 + x8); + fiat_p384_scalar_mulx_u64(&x30, &x31, x17, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x32, &x33, x30, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x34, &x35, x30, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x36, &x37, x30, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x38, &x39, x30, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x40, &x41, x30, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x42, &x43, x30, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x44, &x45, 0x0, x43, x40); + fiat_p384_scalar_addcarryx_u64(&x46, &x47, x45, x41, x38); + fiat_p384_scalar_addcarryx_u64(&x48, &x49, x47, x39, x36); + fiat_p384_scalar_addcarryx_u64(&x50, &x51, x49, x37, x34); + fiat_p384_scalar_addcarryx_u64(&x52, &x53, x51, x35, x32); + x54 = (x53 + x33); + fiat_p384_scalar_addcarryx_u64(&x55, &x56, 0x0, x17, x42); + fiat_p384_scalar_addcarryx_u64(&x57, &x58, x56, x19, x44); + fiat_p384_scalar_addcarryx_u64(&x59, &x60, x58, x21, x46); + fiat_p384_scalar_addcarryx_u64(&x61, &x62, x60, x23, x48); + fiat_p384_scalar_addcarryx_u64(&x63, &x64, x62, x25, x50); + fiat_p384_scalar_addcarryx_u64(&x65, &x66, x64, x27, x52); + fiat_p384_scalar_addcarryx_u64(&x67, &x68, x66, x29, x54); + fiat_p384_scalar_mulx_u64(&x69, &x70, x1, (arg2[5])); + fiat_p384_scalar_mulx_u64(&x71, &x72, x1, (arg2[4])); + fiat_p384_scalar_mulx_u64(&x73, &x74, x1, (arg2[3])); + fiat_p384_scalar_mulx_u64(&x75, &x76, x1, (arg2[2])); + fiat_p384_scalar_mulx_u64(&x77, &x78, x1, (arg2[1])); + fiat_p384_scalar_mulx_u64(&x79, &x80, x1, (arg2[0])); + fiat_p384_scalar_addcarryx_u64(&x81, &x82, 0x0, x80, x77); + fiat_p384_scalar_addcarryx_u64(&x83, &x84, x82, x78, x75); + fiat_p384_scalar_addcarryx_u64(&x85, &x86, x84, x76, x73); + fiat_p384_scalar_addcarryx_u64(&x87, &x88, x86, x74, x71); + fiat_p384_scalar_addcarryx_u64(&x89, &x90, x88, x72, x69); + x91 = (x90 + x70); + fiat_p384_scalar_addcarryx_u64(&x92, &x93, 0x0, x57, x79); + fiat_p384_scalar_addcarryx_u64(&x94, &x95, x93, x59, x81); + fiat_p384_scalar_addcarryx_u64(&x96, &x97, x95, x61, x83); + fiat_p384_scalar_addcarryx_u64(&x98, &x99, x97, x63, x85); + fiat_p384_scalar_addcarryx_u64(&x100, &x101, x99, x65, x87); + fiat_p384_scalar_addcarryx_u64(&x102, &x103, x101, x67, x89); + fiat_p384_scalar_addcarryx_u64(&x104, &x105, x103, x68, x91); + fiat_p384_scalar_mulx_u64(&x106, &x107, x92, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x108, &x109, x106, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x110, &x111, x106, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x112, &x113, x106, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x114, &x115, x106, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x116, &x117, x106, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x118, &x119, x106, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x120, &x121, 0x0, x119, x116); + fiat_p384_scalar_addcarryx_u64(&x122, &x123, x121, x117, x114); + fiat_p384_scalar_addcarryx_u64(&x124, &x125, x123, x115, x112); + fiat_p384_scalar_addcarryx_u64(&x126, &x127, x125, x113, x110); + fiat_p384_scalar_addcarryx_u64(&x128, &x129, x127, x111, x108); + x130 = (x129 + x109); + fiat_p384_scalar_addcarryx_u64(&x131, &x132, 0x0, x92, x118); + fiat_p384_scalar_addcarryx_u64(&x133, &x134, x132, x94, x120); + fiat_p384_scalar_addcarryx_u64(&x135, &x136, x134, x96, x122); + fiat_p384_scalar_addcarryx_u64(&x137, &x138, x136, x98, x124); + fiat_p384_scalar_addcarryx_u64(&x139, &x140, x138, x100, x126); + fiat_p384_scalar_addcarryx_u64(&x141, &x142, x140, x102, x128); + fiat_p384_scalar_addcarryx_u64(&x143, &x144, x142, x104, x130); + x145 = ((uint64_t)x144 + x105); + fiat_p384_scalar_mulx_u64(&x146, &x147, x2, (arg2[5])); + fiat_p384_scalar_mulx_u64(&x148, &x149, x2, (arg2[4])); + fiat_p384_scalar_mulx_u64(&x150, &x151, x2, (arg2[3])); + fiat_p384_scalar_mulx_u64(&x152, &x153, x2, (arg2[2])); + fiat_p384_scalar_mulx_u64(&x154, &x155, x2, (arg2[1])); + fiat_p384_scalar_mulx_u64(&x156, &x157, x2, (arg2[0])); + fiat_p384_scalar_addcarryx_u64(&x158, &x159, 0x0, x157, x154); + fiat_p384_scalar_addcarryx_u64(&x160, &x161, x159, x155, x152); + fiat_p384_scalar_addcarryx_u64(&x162, &x163, x161, x153, x150); + fiat_p384_scalar_addcarryx_u64(&x164, &x165, x163, x151, x148); + fiat_p384_scalar_addcarryx_u64(&x166, &x167, x165, x149, x146); + x168 = (x167 + x147); + fiat_p384_scalar_addcarryx_u64(&x169, &x170, 0x0, x133, x156); + fiat_p384_scalar_addcarryx_u64(&x171, &x172, x170, x135, x158); + fiat_p384_scalar_addcarryx_u64(&x173, &x174, x172, x137, x160); + fiat_p384_scalar_addcarryx_u64(&x175, &x176, x174, x139, x162); + fiat_p384_scalar_addcarryx_u64(&x177, &x178, x176, x141, x164); + fiat_p384_scalar_addcarryx_u64(&x179, &x180, x178, x143, x166); + fiat_p384_scalar_addcarryx_u64(&x181, &x182, x180, x145, x168); + fiat_p384_scalar_mulx_u64(&x183, &x184, x169, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x185, &x186, x183, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x187, &x188, x183, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x189, &x190, x183, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x191, &x192, x183, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x193, &x194, x183, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x195, &x196, x183, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x197, &x198, 0x0, x196, x193); + fiat_p384_scalar_addcarryx_u64(&x199, &x200, x198, x194, x191); + fiat_p384_scalar_addcarryx_u64(&x201, &x202, x200, x192, x189); + fiat_p384_scalar_addcarryx_u64(&x203, &x204, x202, x190, x187); + fiat_p384_scalar_addcarryx_u64(&x205, &x206, x204, x188, x185); + x207 = (x206 + x186); + fiat_p384_scalar_addcarryx_u64(&x208, &x209, 0x0, x169, x195); + fiat_p384_scalar_addcarryx_u64(&x210, &x211, x209, x171, x197); + fiat_p384_scalar_addcarryx_u64(&x212, &x213, x211, x173, x199); + fiat_p384_scalar_addcarryx_u64(&x214, &x215, x213, x175, x201); + fiat_p384_scalar_addcarryx_u64(&x216, &x217, x215, x177, x203); + fiat_p384_scalar_addcarryx_u64(&x218, &x219, x217, x179, x205); + fiat_p384_scalar_addcarryx_u64(&x220, &x221, x219, x181, x207); + x222 = ((uint64_t)x221 + x182); + fiat_p384_scalar_mulx_u64(&x223, &x224, x3, (arg2[5])); + fiat_p384_scalar_mulx_u64(&x225, &x226, x3, (arg2[4])); + fiat_p384_scalar_mulx_u64(&x227, &x228, x3, (arg2[3])); + fiat_p384_scalar_mulx_u64(&x229, &x230, x3, (arg2[2])); + fiat_p384_scalar_mulx_u64(&x231, &x232, x3, (arg2[1])); + fiat_p384_scalar_mulx_u64(&x233, &x234, x3, (arg2[0])); + fiat_p384_scalar_addcarryx_u64(&x235, &x236, 0x0, x234, x231); + fiat_p384_scalar_addcarryx_u64(&x237, &x238, x236, x232, x229); + fiat_p384_scalar_addcarryx_u64(&x239, &x240, x238, x230, x227); + fiat_p384_scalar_addcarryx_u64(&x241, &x242, x240, x228, x225); + fiat_p384_scalar_addcarryx_u64(&x243, &x244, x242, x226, x223); + x245 = (x244 + x224); + fiat_p384_scalar_addcarryx_u64(&x246, &x247, 0x0, x210, x233); + fiat_p384_scalar_addcarryx_u64(&x248, &x249, x247, x212, x235); + fiat_p384_scalar_addcarryx_u64(&x250, &x251, x249, x214, x237); + fiat_p384_scalar_addcarryx_u64(&x252, &x253, x251, x216, x239); + fiat_p384_scalar_addcarryx_u64(&x254, &x255, x253, x218, x241); + fiat_p384_scalar_addcarryx_u64(&x256, &x257, x255, x220, x243); + fiat_p384_scalar_addcarryx_u64(&x258, &x259, x257, x222, x245); + fiat_p384_scalar_mulx_u64(&x260, &x261, x246, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x262, &x263, x260, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x264, &x265, x260, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x266, &x267, x260, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x268, &x269, x260, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x270, &x271, x260, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x272, &x273, x260, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x274, &x275, 0x0, x273, x270); + fiat_p384_scalar_addcarryx_u64(&x276, &x277, x275, x271, x268); + fiat_p384_scalar_addcarryx_u64(&x278, &x279, x277, x269, x266); + fiat_p384_scalar_addcarryx_u64(&x280, &x281, x279, x267, x264); + fiat_p384_scalar_addcarryx_u64(&x282, &x283, x281, x265, x262); + x284 = (x283 + x263); + fiat_p384_scalar_addcarryx_u64(&x285, &x286, 0x0, x246, x272); + fiat_p384_scalar_addcarryx_u64(&x287, &x288, x286, x248, x274); + fiat_p384_scalar_addcarryx_u64(&x289, &x290, x288, x250, x276); + fiat_p384_scalar_addcarryx_u64(&x291, &x292, x290, x252, x278); + fiat_p384_scalar_addcarryx_u64(&x293, &x294, x292, x254, x280); + fiat_p384_scalar_addcarryx_u64(&x295, &x296, x294, x256, x282); + fiat_p384_scalar_addcarryx_u64(&x297, &x298, x296, x258, x284); + x299 = ((uint64_t)x298 + x259); + fiat_p384_scalar_mulx_u64(&x300, &x301, x4, (arg2[5])); + fiat_p384_scalar_mulx_u64(&x302, &x303, x4, (arg2[4])); + fiat_p384_scalar_mulx_u64(&x304, &x305, x4, (arg2[3])); + fiat_p384_scalar_mulx_u64(&x306, &x307, x4, (arg2[2])); + fiat_p384_scalar_mulx_u64(&x308, &x309, x4, (arg2[1])); + fiat_p384_scalar_mulx_u64(&x310, &x311, x4, (arg2[0])); + fiat_p384_scalar_addcarryx_u64(&x312, &x313, 0x0, x311, x308); + fiat_p384_scalar_addcarryx_u64(&x314, &x315, x313, x309, x306); + fiat_p384_scalar_addcarryx_u64(&x316, &x317, x315, x307, x304); + fiat_p384_scalar_addcarryx_u64(&x318, &x319, x317, x305, x302); + fiat_p384_scalar_addcarryx_u64(&x320, &x321, x319, x303, x300); + x322 = (x321 + x301); + fiat_p384_scalar_addcarryx_u64(&x323, &x324, 0x0, x287, x310); + fiat_p384_scalar_addcarryx_u64(&x325, &x326, x324, x289, x312); + fiat_p384_scalar_addcarryx_u64(&x327, &x328, x326, x291, x314); + fiat_p384_scalar_addcarryx_u64(&x329, &x330, x328, x293, x316); + fiat_p384_scalar_addcarryx_u64(&x331, &x332, x330, x295, x318); + fiat_p384_scalar_addcarryx_u64(&x333, &x334, x332, x297, x320); + fiat_p384_scalar_addcarryx_u64(&x335, &x336, x334, x299, x322); + fiat_p384_scalar_mulx_u64(&x337, &x338, x323, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x339, &x340, x337, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x341, &x342, x337, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x343, &x344, x337, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x345, &x346, x337, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x347, &x348, x337, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x349, &x350, x337, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x351, &x352, 0x0, x350, x347); + fiat_p384_scalar_addcarryx_u64(&x353, &x354, x352, x348, x345); + fiat_p384_scalar_addcarryx_u64(&x355, &x356, x354, x346, x343); + fiat_p384_scalar_addcarryx_u64(&x357, &x358, x356, x344, x341); + fiat_p384_scalar_addcarryx_u64(&x359, &x360, x358, x342, x339); + x361 = (x360 + x340); + fiat_p384_scalar_addcarryx_u64(&x362, &x363, 0x0, x323, x349); + fiat_p384_scalar_addcarryx_u64(&x364, &x365, x363, x325, x351); + fiat_p384_scalar_addcarryx_u64(&x366, &x367, x365, x327, x353); + fiat_p384_scalar_addcarryx_u64(&x368, &x369, x367, x329, x355); + fiat_p384_scalar_addcarryx_u64(&x370, &x371, x369, x331, x357); + fiat_p384_scalar_addcarryx_u64(&x372, &x373, x371, x333, x359); + fiat_p384_scalar_addcarryx_u64(&x374, &x375, x373, x335, x361); + x376 = ((uint64_t)x375 + x336); + fiat_p384_scalar_mulx_u64(&x377, &x378, x5, (arg2[5])); + fiat_p384_scalar_mulx_u64(&x379, &x380, x5, (arg2[4])); + fiat_p384_scalar_mulx_u64(&x381, &x382, x5, (arg2[3])); + fiat_p384_scalar_mulx_u64(&x383, &x384, x5, (arg2[2])); + fiat_p384_scalar_mulx_u64(&x385, &x386, x5, (arg2[1])); + fiat_p384_scalar_mulx_u64(&x387, &x388, x5, (arg2[0])); + fiat_p384_scalar_addcarryx_u64(&x389, &x390, 0x0, x388, x385); + fiat_p384_scalar_addcarryx_u64(&x391, &x392, x390, x386, x383); + fiat_p384_scalar_addcarryx_u64(&x393, &x394, x392, x384, x381); + fiat_p384_scalar_addcarryx_u64(&x395, &x396, x394, x382, x379); + fiat_p384_scalar_addcarryx_u64(&x397, &x398, x396, x380, x377); + x399 = (x398 + x378); + fiat_p384_scalar_addcarryx_u64(&x400, &x401, 0x0, x364, x387); + fiat_p384_scalar_addcarryx_u64(&x402, &x403, x401, x366, x389); + fiat_p384_scalar_addcarryx_u64(&x404, &x405, x403, x368, x391); + fiat_p384_scalar_addcarryx_u64(&x406, &x407, x405, x370, x393); + fiat_p384_scalar_addcarryx_u64(&x408, &x409, x407, x372, x395); + fiat_p384_scalar_addcarryx_u64(&x410, &x411, x409, x374, x397); + fiat_p384_scalar_addcarryx_u64(&x412, &x413, x411, x376, x399); + fiat_p384_scalar_mulx_u64(&x414, &x415, x400, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x416, &x417, x414, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x418, &x419, x414, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x420, &x421, x414, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x422, &x423, x414, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x424, &x425, x414, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x426, &x427, x414, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x428, &x429, 0x0, x427, x424); + fiat_p384_scalar_addcarryx_u64(&x430, &x431, x429, x425, x422); + fiat_p384_scalar_addcarryx_u64(&x432, &x433, x431, x423, x420); + fiat_p384_scalar_addcarryx_u64(&x434, &x435, x433, x421, x418); + fiat_p384_scalar_addcarryx_u64(&x436, &x437, x435, x419, x416); + x438 = (x437 + x417); + fiat_p384_scalar_addcarryx_u64(&x439, &x440, 0x0, x400, x426); + fiat_p384_scalar_addcarryx_u64(&x441, &x442, x440, x402, x428); + fiat_p384_scalar_addcarryx_u64(&x443, &x444, x442, x404, x430); + fiat_p384_scalar_addcarryx_u64(&x445, &x446, x444, x406, x432); + fiat_p384_scalar_addcarryx_u64(&x447, &x448, x446, x408, x434); + fiat_p384_scalar_addcarryx_u64(&x449, &x450, x448, x410, x436); + fiat_p384_scalar_addcarryx_u64(&x451, &x452, x450, x412, x438); + x453 = ((uint64_t)x452 + x413); + fiat_p384_scalar_subborrowx_u64(&x454, &x455, 0x0, x441, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_subborrowx_u64(&x456, &x457, x455, x443, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_subborrowx_u64(&x458, &x459, x457, x445, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_subborrowx_u64(&x460, &x461, x459, x447, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x462, &x463, x461, x449, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x464, &x465, x463, x451, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x466, &x467, x465, x453, 0x0); + fiat_p384_scalar_cmovznz_u64(&x468, x467, x454, x441); + fiat_p384_scalar_cmovznz_u64(&x469, x467, x456, x443); + fiat_p384_scalar_cmovznz_u64(&x470, x467, x458, x445); + fiat_p384_scalar_cmovznz_u64(&x471, x467, x460, x447); + fiat_p384_scalar_cmovznz_u64(&x472, x467, x462, x449); + fiat_p384_scalar_cmovznz_u64(&x473, x467, x464, x451); + out1[0] = x468; + out1[1] = x469; + out1[2] = x470; + out1[3] = x471; + out1[4] = x472; + out1[5] = x473; +} + +/* + * The function fiat_p384_scalar_square squares a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_square(fiat_p384_scalar_montgomery_domain_field_element out1, const fiat_p384_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint64_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + fiat_p384_scalar_uint1 x20; + uint64_t x21; + fiat_p384_scalar_uint1 x22; + uint64_t x23; + fiat_p384_scalar_uint1 x24; + uint64_t x25; + fiat_p384_scalar_uint1 x26; + uint64_t x27; + fiat_p384_scalar_uint1 x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint64_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + fiat_p384_scalar_uint1 x45; + uint64_t x46; + fiat_p384_scalar_uint1 x47; + uint64_t x48; + fiat_p384_scalar_uint1 x49; + uint64_t x50; + fiat_p384_scalar_uint1 x51; + uint64_t x52; + fiat_p384_scalar_uint1 x53; + uint64_t x54; + uint64_t x55; + fiat_p384_scalar_uint1 x56; + uint64_t x57; + fiat_p384_scalar_uint1 x58; + uint64_t x59; + fiat_p384_scalar_uint1 x60; + uint64_t x61; + fiat_p384_scalar_uint1 x62; + uint64_t x63; + fiat_p384_scalar_uint1 x64; + uint64_t x65; + fiat_p384_scalar_uint1 x66; + uint64_t x67; + fiat_p384_scalar_uint1 x68; + uint64_t x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + uint64_t x81; + fiat_p384_scalar_uint1 x82; + uint64_t x83; + fiat_p384_scalar_uint1 x84; + uint64_t x85; + fiat_p384_scalar_uint1 x86; + uint64_t x87; + fiat_p384_scalar_uint1 x88; + uint64_t x89; + fiat_p384_scalar_uint1 x90; + uint64_t x91; + uint64_t x92; + fiat_p384_scalar_uint1 x93; + uint64_t x94; + fiat_p384_scalar_uint1 x95; + uint64_t x96; + fiat_p384_scalar_uint1 x97; + uint64_t x98; + fiat_p384_scalar_uint1 x99; + uint64_t x100; + fiat_p384_scalar_uint1 x101; + uint64_t x102; + fiat_p384_scalar_uint1 x103; + uint64_t x104; + fiat_p384_scalar_uint1 x105; + uint64_t x106; + uint64_t x107; + uint64_t x108; + uint64_t x109; + uint64_t x110; + uint64_t x111; + uint64_t x112; + uint64_t x113; + uint64_t x114; + uint64_t x115; + uint64_t x116; + uint64_t x117; + uint64_t x118; + uint64_t x119; + uint64_t x120; + fiat_p384_scalar_uint1 x121; + uint64_t x122; + fiat_p384_scalar_uint1 x123; + uint64_t x124; + fiat_p384_scalar_uint1 x125; + uint64_t x126; + fiat_p384_scalar_uint1 x127; + uint64_t x128; + fiat_p384_scalar_uint1 x129; + uint64_t x130; + uint64_t x131; + fiat_p384_scalar_uint1 x132; + uint64_t x133; + fiat_p384_scalar_uint1 x134; + uint64_t x135; + fiat_p384_scalar_uint1 x136; + uint64_t x137; + fiat_p384_scalar_uint1 x138; + uint64_t x139; + fiat_p384_scalar_uint1 x140; + uint64_t x141; + fiat_p384_scalar_uint1 x142; + uint64_t x143; + fiat_p384_scalar_uint1 x144; + uint64_t x145; + uint64_t x146; + uint64_t x147; + uint64_t x148; + uint64_t x149; + uint64_t x150; + uint64_t x151; + uint64_t x152; + uint64_t x153; + uint64_t x154; + uint64_t x155; + uint64_t x156; + uint64_t x157; + uint64_t x158; + fiat_p384_scalar_uint1 x159; + uint64_t x160; + fiat_p384_scalar_uint1 x161; + uint64_t x162; + fiat_p384_scalar_uint1 x163; + uint64_t x164; + fiat_p384_scalar_uint1 x165; + uint64_t x166; + fiat_p384_scalar_uint1 x167; + uint64_t x168; + uint64_t x169; + fiat_p384_scalar_uint1 x170; + uint64_t x171; + fiat_p384_scalar_uint1 x172; + uint64_t x173; + fiat_p384_scalar_uint1 x174; + uint64_t x175; + fiat_p384_scalar_uint1 x176; + uint64_t x177; + fiat_p384_scalar_uint1 x178; + uint64_t x179; + fiat_p384_scalar_uint1 x180; + uint64_t x181; + fiat_p384_scalar_uint1 x182; + uint64_t x183; + uint64_t x184; + uint64_t x185; + uint64_t x186; + uint64_t x187; + uint64_t x188; + uint64_t x189; + uint64_t x190; + uint64_t x191; + uint64_t x192; + uint64_t x193; + uint64_t x194; + uint64_t x195; + uint64_t x196; + uint64_t x197; + fiat_p384_scalar_uint1 x198; + uint64_t x199; + fiat_p384_scalar_uint1 x200; + uint64_t x201; + fiat_p384_scalar_uint1 x202; + uint64_t x203; + fiat_p384_scalar_uint1 x204; + uint64_t x205; + fiat_p384_scalar_uint1 x206; + uint64_t x207; + uint64_t x208; + fiat_p384_scalar_uint1 x209; + uint64_t x210; + fiat_p384_scalar_uint1 x211; + uint64_t x212; + fiat_p384_scalar_uint1 x213; + uint64_t x214; + fiat_p384_scalar_uint1 x215; + uint64_t x216; + fiat_p384_scalar_uint1 x217; + uint64_t x218; + fiat_p384_scalar_uint1 x219; + uint64_t x220; + fiat_p384_scalar_uint1 x221; + uint64_t x222; + uint64_t x223; + uint64_t x224; + uint64_t x225; + uint64_t x226; + uint64_t x227; + uint64_t x228; + uint64_t x229; + uint64_t x230; + uint64_t x231; + uint64_t x232; + uint64_t x233; + uint64_t x234; + uint64_t x235; + fiat_p384_scalar_uint1 x236; + uint64_t x237; + fiat_p384_scalar_uint1 x238; + uint64_t x239; + fiat_p384_scalar_uint1 x240; + uint64_t x241; + fiat_p384_scalar_uint1 x242; + uint64_t x243; + fiat_p384_scalar_uint1 x244; + uint64_t x245; + uint64_t x246; + fiat_p384_scalar_uint1 x247; + uint64_t x248; + fiat_p384_scalar_uint1 x249; + uint64_t x250; + fiat_p384_scalar_uint1 x251; + uint64_t x252; + fiat_p384_scalar_uint1 x253; + uint64_t x254; + fiat_p384_scalar_uint1 x255; + uint64_t x256; + fiat_p384_scalar_uint1 x257; + uint64_t x258; + fiat_p384_scalar_uint1 x259; + uint64_t x260; + uint64_t x261; + uint64_t x262; + uint64_t x263; + uint64_t x264; + uint64_t x265; + uint64_t x266; + uint64_t x267; + uint64_t x268; + uint64_t x269; + uint64_t x270; + uint64_t x271; + uint64_t x272; + uint64_t x273; + uint64_t x274; + fiat_p384_scalar_uint1 x275; + uint64_t x276; + fiat_p384_scalar_uint1 x277; + uint64_t x278; + fiat_p384_scalar_uint1 x279; + uint64_t x280; + fiat_p384_scalar_uint1 x281; + uint64_t x282; + fiat_p384_scalar_uint1 x283; + uint64_t x284; + uint64_t x285; + fiat_p384_scalar_uint1 x286; + uint64_t x287; + fiat_p384_scalar_uint1 x288; + uint64_t x289; + fiat_p384_scalar_uint1 x290; + uint64_t x291; + fiat_p384_scalar_uint1 x292; + uint64_t x293; + fiat_p384_scalar_uint1 x294; + uint64_t x295; + fiat_p384_scalar_uint1 x296; + uint64_t x297; + fiat_p384_scalar_uint1 x298; + uint64_t x299; + uint64_t x300; + uint64_t x301; + uint64_t x302; + uint64_t x303; + uint64_t x304; + uint64_t x305; + uint64_t x306; + uint64_t x307; + uint64_t x308; + uint64_t x309; + uint64_t x310; + uint64_t x311; + uint64_t x312; + fiat_p384_scalar_uint1 x313; + uint64_t x314; + fiat_p384_scalar_uint1 x315; + uint64_t x316; + fiat_p384_scalar_uint1 x317; + uint64_t x318; + fiat_p384_scalar_uint1 x319; + uint64_t x320; + fiat_p384_scalar_uint1 x321; + uint64_t x322; + uint64_t x323; + fiat_p384_scalar_uint1 x324; + uint64_t x325; + fiat_p384_scalar_uint1 x326; + uint64_t x327; + fiat_p384_scalar_uint1 x328; + uint64_t x329; + fiat_p384_scalar_uint1 x330; + uint64_t x331; + fiat_p384_scalar_uint1 x332; + uint64_t x333; + fiat_p384_scalar_uint1 x334; + uint64_t x335; + fiat_p384_scalar_uint1 x336; + uint64_t x337; + uint64_t x338; + uint64_t x339; + uint64_t x340; + uint64_t x341; + uint64_t x342; + uint64_t x343; + uint64_t x344; + uint64_t x345; + uint64_t x346; + uint64_t x347; + uint64_t x348; + uint64_t x349; + uint64_t x350; + uint64_t x351; + fiat_p384_scalar_uint1 x352; + uint64_t x353; + fiat_p384_scalar_uint1 x354; + uint64_t x355; + fiat_p384_scalar_uint1 x356; + uint64_t x357; + fiat_p384_scalar_uint1 x358; + uint64_t x359; + fiat_p384_scalar_uint1 x360; + uint64_t x361; + uint64_t x362; + fiat_p384_scalar_uint1 x363; + uint64_t x364; + fiat_p384_scalar_uint1 x365; + uint64_t x366; + fiat_p384_scalar_uint1 x367; + uint64_t x368; + fiat_p384_scalar_uint1 x369; + uint64_t x370; + fiat_p384_scalar_uint1 x371; + uint64_t x372; + fiat_p384_scalar_uint1 x373; + uint64_t x374; + fiat_p384_scalar_uint1 x375; + uint64_t x376; + uint64_t x377; + uint64_t x378; + uint64_t x379; + uint64_t x380; + uint64_t x381; + uint64_t x382; + uint64_t x383; + uint64_t x384; + uint64_t x385; + uint64_t x386; + uint64_t x387; + uint64_t x388; + uint64_t x389; + fiat_p384_scalar_uint1 x390; + uint64_t x391; + fiat_p384_scalar_uint1 x392; + uint64_t x393; + fiat_p384_scalar_uint1 x394; + uint64_t x395; + fiat_p384_scalar_uint1 x396; + uint64_t x397; + fiat_p384_scalar_uint1 x398; + uint64_t x399; + uint64_t x400; + fiat_p384_scalar_uint1 x401; + uint64_t x402; + fiat_p384_scalar_uint1 x403; + uint64_t x404; + fiat_p384_scalar_uint1 x405; + uint64_t x406; + fiat_p384_scalar_uint1 x407; + uint64_t x408; + fiat_p384_scalar_uint1 x409; + uint64_t x410; + fiat_p384_scalar_uint1 x411; + uint64_t x412; + fiat_p384_scalar_uint1 x413; + uint64_t x414; + uint64_t x415; + uint64_t x416; + uint64_t x417; + uint64_t x418; + uint64_t x419; + uint64_t x420; + uint64_t x421; + uint64_t x422; + uint64_t x423; + uint64_t x424; + uint64_t x425; + uint64_t x426; + uint64_t x427; + uint64_t x428; + fiat_p384_scalar_uint1 x429; + uint64_t x430; + fiat_p384_scalar_uint1 x431; + uint64_t x432; + fiat_p384_scalar_uint1 x433; + uint64_t x434; + fiat_p384_scalar_uint1 x435; + uint64_t x436; + fiat_p384_scalar_uint1 x437; + uint64_t x438; + uint64_t x439; + fiat_p384_scalar_uint1 x440; + uint64_t x441; + fiat_p384_scalar_uint1 x442; + uint64_t x443; + fiat_p384_scalar_uint1 x444; + uint64_t x445; + fiat_p384_scalar_uint1 x446; + uint64_t x447; + fiat_p384_scalar_uint1 x448; + uint64_t x449; + fiat_p384_scalar_uint1 x450; + uint64_t x451; + fiat_p384_scalar_uint1 x452; + uint64_t x453; + uint64_t x454; + fiat_p384_scalar_uint1 x455; + uint64_t x456; + fiat_p384_scalar_uint1 x457; + uint64_t x458; + fiat_p384_scalar_uint1 x459; + uint64_t x460; + fiat_p384_scalar_uint1 x461; + uint64_t x462; + fiat_p384_scalar_uint1 x463; + uint64_t x464; + fiat_p384_scalar_uint1 x465; + uint64_t x466; + fiat_p384_scalar_uint1 x467; + uint64_t x468; + uint64_t x469; + uint64_t x470; + uint64_t x471; + uint64_t x472; + uint64_t x473; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[0]); + fiat_p384_scalar_mulx_u64(&x7, &x8, x6, (arg1[5])); + fiat_p384_scalar_mulx_u64(&x9, &x10, x6, (arg1[4])); + fiat_p384_scalar_mulx_u64(&x11, &x12, x6, (arg1[3])); + fiat_p384_scalar_mulx_u64(&x13, &x14, x6, (arg1[2])); + fiat_p384_scalar_mulx_u64(&x15, &x16, x6, (arg1[1])); + fiat_p384_scalar_mulx_u64(&x17, &x18, x6, (arg1[0])); + fiat_p384_scalar_addcarryx_u64(&x19, &x20, 0x0, x18, x15); + fiat_p384_scalar_addcarryx_u64(&x21, &x22, x20, x16, x13); + fiat_p384_scalar_addcarryx_u64(&x23, &x24, x22, x14, x11); + fiat_p384_scalar_addcarryx_u64(&x25, &x26, x24, x12, x9); + fiat_p384_scalar_addcarryx_u64(&x27, &x28, x26, x10, x7); + x29 = (x28 + x8); + fiat_p384_scalar_mulx_u64(&x30, &x31, x17, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x32, &x33, x30, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x34, &x35, x30, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x36, &x37, x30, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x38, &x39, x30, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x40, &x41, x30, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x42, &x43, x30, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x44, &x45, 0x0, x43, x40); + fiat_p384_scalar_addcarryx_u64(&x46, &x47, x45, x41, x38); + fiat_p384_scalar_addcarryx_u64(&x48, &x49, x47, x39, x36); + fiat_p384_scalar_addcarryx_u64(&x50, &x51, x49, x37, x34); + fiat_p384_scalar_addcarryx_u64(&x52, &x53, x51, x35, x32); + x54 = (x53 + x33); + fiat_p384_scalar_addcarryx_u64(&x55, &x56, 0x0, x17, x42); + fiat_p384_scalar_addcarryx_u64(&x57, &x58, x56, x19, x44); + fiat_p384_scalar_addcarryx_u64(&x59, &x60, x58, x21, x46); + fiat_p384_scalar_addcarryx_u64(&x61, &x62, x60, x23, x48); + fiat_p384_scalar_addcarryx_u64(&x63, &x64, x62, x25, x50); + fiat_p384_scalar_addcarryx_u64(&x65, &x66, x64, x27, x52); + fiat_p384_scalar_addcarryx_u64(&x67, &x68, x66, x29, x54); + fiat_p384_scalar_mulx_u64(&x69, &x70, x1, (arg1[5])); + fiat_p384_scalar_mulx_u64(&x71, &x72, x1, (arg1[4])); + fiat_p384_scalar_mulx_u64(&x73, &x74, x1, (arg1[3])); + fiat_p384_scalar_mulx_u64(&x75, &x76, x1, (arg1[2])); + fiat_p384_scalar_mulx_u64(&x77, &x78, x1, (arg1[1])); + fiat_p384_scalar_mulx_u64(&x79, &x80, x1, (arg1[0])); + fiat_p384_scalar_addcarryx_u64(&x81, &x82, 0x0, x80, x77); + fiat_p384_scalar_addcarryx_u64(&x83, &x84, x82, x78, x75); + fiat_p384_scalar_addcarryx_u64(&x85, &x86, x84, x76, x73); + fiat_p384_scalar_addcarryx_u64(&x87, &x88, x86, x74, x71); + fiat_p384_scalar_addcarryx_u64(&x89, &x90, x88, x72, x69); + x91 = (x90 + x70); + fiat_p384_scalar_addcarryx_u64(&x92, &x93, 0x0, x57, x79); + fiat_p384_scalar_addcarryx_u64(&x94, &x95, x93, x59, x81); + fiat_p384_scalar_addcarryx_u64(&x96, &x97, x95, x61, x83); + fiat_p384_scalar_addcarryx_u64(&x98, &x99, x97, x63, x85); + fiat_p384_scalar_addcarryx_u64(&x100, &x101, x99, x65, x87); + fiat_p384_scalar_addcarryx_u64(&x102, &x103, x101, x67, x89); + fiat_p384_scalar_addcarryx_u64(&x104, &x105, x103, x68, x91); + fiat_p384_scalar_mulx_u64(&x106, &x107, x92, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x108, &x109, x106, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x110, &x111, x106, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x112, &x113, x106, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x114, &x115, x106, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x116, &x117, x106, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x118, &x119, x106, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x120, &x121, 0x0, x119, x116); + fiat_p384_scalar_addcarryx_u64(&x122, &x123, x121, x117, x114); + fiat_p384_scalar_addcarryx_u64(&x124, &x125, x123, x115, x112); + fiat_p384_scalar_addcarryx_u64(&x126, &x127, x125, x113, x110); + fiat_p384_scalar_addcarryx_u64(&x128, &x129, x127, x111, x108); + x130 = (x129 + x109); + fiat_p384_scalar_addcarryx_u64(&x131, &x132, 0x0, x92, x118); + fiat_p384_scalar_addcarryx_u64(&x133, &x134, x132, x94, x120); + fiat_p384_scalar_addcarryx_u64(&x135, &x136, x134, x96, x122); + fiat_p384_scalar_addcarryx_u64(&x137, &x138, x136, x98, x124); + fiat_p384_scalar_addcarryx_u64(&x139, &x140, x138, x100, x126); + fiat_p384_scalar_addcarryx_u64(&x141, &x142, x140, x102, x128); + fiat_p384_scalar_addcarryx_u64(&x143, &x144, x142, x104, x130); + x145 = ((uint64_t)x144 + x105); + fiat_p384_scalar_mulx_u64(&x146, &x147, x2, (arg1[5])); + fiat_p384_scalar_mulx_u64(&x148, &x149, x2, (arg1[4])); + fiat_p384_scalar_mulx_u64(&x150, &x151, x2, (arg1[3])); + fiat_p384_scalar_mulx_u64(&x152, &x153, x2, (arg1[2])); + fiat_p384_scalar_mulx_u64(&x154, &x155, x2, (arg1[1])); + fiat_p384_scalar_mulx_u64(&x156, &x157, x2, (arg1[0])); + fiat_p384_scalar_addcarryx_u64(&x158, &x159, 0x0, x157, x154); + fiat_p384_scalar_addcarryx_u64(&x160, &x161, x159, x155, x152); + fiat_p384_scalar_addcarryx_u64(&x162, &x163, x161, x153, x150); + fiat_p384_scalar_addcarryx_u64(&x164, &x165, x163, x151, x148); + fiat_p384_scalar_addcarryx_u64(&x166, &x167, x165, x149, x146); + x168 = (x167 + x147); + fiat_p384_scalar_addcarryx_u64(&x169, &x170, 0x0, x133, x156); + fiat_p384_scalar_addcarryx_u64(&x171, &x172, x170, x135, x158); + fiat_p384_scalar_addcarryx_u64(&x173, &x174, x172, x137, x160); + fiat_p384_scalar_addcarryx_u64(&x175, &x176, x174, x139, x162); + fiat_p384_scalar_addcarryx_u64(&x177, &x178, x176, x141, x164); + fiat_p384_scalar_addcarryx_u64(&x179, &x180, x178, x143, x166); + fiat_p384_scalar_addcarryx_u64(&x181, &x182, x180, x145, x168); + fiat_p384_scalar_mulx_u64(&x183, &x184, x169, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x185, &x186, x183, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x187, &x188, x183, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x189, &x190, x183, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x191, &x192, x183, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x193, &x194, x183, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x195, &x196, x183, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x197, &x198, 0x0, x196, x193); + fiat_p384_scalar_addcarryx_u64(&x199, &x200, x198, x194, x191); + fiat_p384_scalar_addcarryx_u64(&x201, &x202, x200, x192, x189); + fiat_p384_scalar_addcarryx_u64(&x203, &x204, x202, x190, x187); + fiat_p384_scalar_addcarryx_u64(&x205, &x206, x204, x188, x185); + x207 = (x206 + x186); + fiat_p384_scalar_addcarryx_u64(&x208, &x209, 0x0, x169, x195); + fiat_p384_scalar_addcarryx_u64(&x210, &x211, x209, x171, x197); + fiat_p384_scalar_addcarryx_u64(&x212, &x213, x211, x173, x199); + fiat_p384_scalar_addcarryx_u64(&x214, &x215, x213, x175, x201); + fiat_p384_scalar_addcarryx_u64(&x216, &x217, x215, x177, x203); + fiat_p384_scalar_addcarryx_u64(&x218, &x219, x217, x179, x205); + fiat_p384_scalar_addcarryx_u64(&x220, &x221, x219, x181, x207); + x222 = ((uint64_t)x221 + x182); + fiat_p384_scalar_mulx_u64(&x223, &x224, x3, (arg1[5])); + fiat_p384_scalar_mulx_u64(&x225, &x226, x3, (arg1[4])); + fiat_p384_scalar_mulx_u64(&x227, &x228, x3, (arg1[3])); + fiat_p384_scalar_mulx_u64(&x229, &x230, x3, (arg1[2])); + fiat_p384_scalar_mulx_u64(&x231, &x232, x3, (arg1[1])); + fiat_p384_scalar_mulx_u64(&x233, &x234, x3, (arg1[0])); + fiat_p384_scalar_addcarryx_u64(&x235, &x236, 0x0, x234, x231); + fiat_p384_scalar_addcarryx_u64(&x237, &x238, x236, x232, x229); + fiat_p384_scalar_addcarryx_u64(&x239, &x240, x238, x230, x227); + fiat_p384_scalar_addcarryx_u64(&x241, &x242, x240, x228, x225); + fiat_p384_scalar_addcarryx_u64(&x243, &x244, x242, x226, x223); + x245 = (x244 + x224); + fiat_p384_scalar_addcarryx_u64(&x246, &x247, 0x0, x210, x233); + fiat_p384_scalar_addcarryx_u64(&x248, &x249, x247, x212, x235); + fiat_p384_scalar_addcarryx_u64(&x250, &x251, x249, x214, x237); + fiat_p384_scalar_addcarryx_u64(&x252, &x253, x251, x216, x239); + fiat_p384_scalar_addcarryx_u64(&x254, &x255, x253, x218, x241); + fiat_p384_scalar_addcarryx_u64(&x256, &x257, x255, x220, x243); + fiat_p384_scalar_addcarryx_u64(&x258, &x259, x257, x222, x245); + fiat_p384_scalar_mulx_u64(&x260, &x261, x246, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x262, &x263, x260, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x264, &x265, x260, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x266, &x267, x260, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x268, &x269, x260, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x270, &x271, x260, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x272, &x273, x260, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x274, &x275, 0x0, x273, x270); + fiat_p384_scalar_addcarryx_u64(&x276, &x277, x275, x271, x268); + fiat_p384_scalar_addcarryx_u64(&x278, &x279, x277, x269, x266); + fiat_p384_scalar_addcarryx_u64(&x280, &x281, x279, x267, x264); + fiat_p384_scalar_addcarryx_u64(&x282, &x283, x281, x265, x262); + x284 = (x283 + x263); + fiat_p384_scalar_addcarryx_u64(&x285, &x286, 0x0, x246, x272); + fiat_p384_scalar_addcarryx_u64(&x287, &x288, x286, x248, x274); + fiat_p384_scalar_addcarryx_u64(&x289, &x290, x288, x250, x276); + fiat_p384_scalar_addcarryx_u64(&x291, &x292, x290, x252, x278); + fiat_p384_scalar_addcarryx_u64(&x293, &x294, x292, x254, x280); + fiat_p384_scalar_addcarryx_u64(&x295, &x296, x294, x256, x282); + fiat_p384_scalar_addcarryx_u64(&x297, &x298, x296, x258, x284); + x299 = ((uint64_t)x298 + x259); + fiat_p384_scalar_mulx_u64(&x300, &x301, x4, (arg1[5])); + fiat_p384_scalar_mulx_u64(&x302, &x303, x4, (arg1[4])); + fiat_p384_scalar_mulx_u64(&x304, &x305, x4, (arg1[3])); + fiat_p384_scalar_mulx_u64(&x306, &x307, x4, (arg1[2])); + fiat_p384_scalar_mulx_u64(&x308, &x309, x4, (arg1[1])); + fiat_p384_scalar_mulx_u64(&x310, &x311, x4, (arg1[0])); + fiat_p384_scalar_addcarryx_u64(&x312, &x313, 0x0, x311, x308); + fiat_p384_scalar_addcarryx_u64(&x314, &x315, x313, x309, x306); + fiat_p384_scalar_addcarryx_u64(&x316, &x317, x315, x307, x304); + fiat_p384_scalar_addcarryx_u64(&x318, &x319, x317, x305, x302); + fiat_p384_scalar_addcarryx_u64(&x320, &x321, x319, x303, x300); + x322 = (x321 + x301); + fiat_p384_scalar_addcarryx_u64(&x323, &x324, 0x0, x287, x310); + fiat_p384_scalar_addcarryx_u64(&x325, &x326, x324, x289, x312); + fiat_p384_scalar_addcarryx_u64(&x327, &x328, x326, x291, x314); + fiat_p384_scalar_addcarryx_u64(&x329, &x330, x328, x293, x316); + fiat_p384_scalar_addcarryx_u64(&x331, &x332, x330, x295, x318); + fiat_p384_scalar_addcarryx_u64(&x333, &x334, x332, x297, x320); + fiat_p384_scalar_addcarryx_u64(&x335, &x336, x334, x299, x322); + fiat_p384_scalar_mulx_u64(&x337, &x338, x323, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x339, &x340, x337, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x341, &x342, x337, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x343, &x344, x337, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x345, &x346, x337, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x347, &x348, x337, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x349, &x350, x337, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x351, &x352, 0x0, x350, x347); + fiat_p384_scalar_addcarryx_u64(&x353, &x354, x352, x348, x345); + fiat_p384_scalar_addcarryx_u64(&x355, &x356, x354, x346, x343); + fiat_p384_scalar_addcarryx_u64(&x357, &x358, x356, x344, x341); + fiat_p384_scalar_addcarryx_u64(&x359, &x360, x358, x342, x339); + x361 = (x360 + x340); + fiat_p384_scalar_addcarryx_u64(&x362, &x363, 0x0, x323, x349); + fiat_p384_scalar_addcarryx_u64(&x364, &x365, x363, x325, x351); + fiat_p384_scalar_addcarryx_u64(&x366, &x367, x365, x327, x353); + fiat_p384_scalar_addcarryx_u64(&x368, &x369, x367, x329, x355); + fiat_p384_scalar_addcarryx_u64(&x370, &x371, x369, x331, x357); + fiat_p384_scalar_addcarryx_u64(&x372, &x373, x371, x333, x359); + fiat_p384_scalar_addcarryx_u64(&x374, &x375, x373, x335, x361); + x376 = ((uint64_t)x375 + x336); + fiat_p384_scalar_mulx_u64(&x377, &x378, x5, (arg1[5])); + fiat_p384_scalar_mulx_u64(&x379, &x380, x5, (arg1[4])); + fiat_p384_scalar_mulx_u64(&x381, &x382, x5, (arg1[3])); + fiat_p384_scalar_mulx_u64(&x383, &x384, x5, (arg1[2])); + fiat_p384_scalar_mulx_u64(&x385, &x386, x5, (arg1[1])); + fiat_p384_scalar_mulx_u64(&x387, &x388, x5, (arg1[0])); + fiat_p384_scalar_addcarryx_u64(&x389, &x390, 0x0, x388, x385); + fiat_p384_scalar_addcarryx_u64(&x391, &x392, x390, x386, x383); + fiat_p384_scalar_addcarryx_u64(&x393, &x394, x392, x384, x381); + fiat_p384_scalar_addcarryx_u64(&x395, &x396, x394, x382, x379); + fiat_p384_scalar_addcarryx_u64(&x397, &x398, x396, x380, x377); + x399 = (x398 + x378); + fiat_p384_scalar_addcarryx_u64(&x400, &x401, 0x0, x364, x387); + fiat_p384_scalar_addcarryx_u64(&x402, &x403, x401, x366, x389); + fiat_p384_scalar_addcarryx_u64(&x404, &x405, x403, x368, x391); + fiat_p384_scalar_addcarryx_u64(&x406, &x407, x405, x370, x393); + fiat_p384_scalar_addcarryx_u64(&x408, &x409, x407, x372, x395); + fiat_p384_scalar_addcarryx_u64(&x410, &x411, x409, x374, x397); + fiat_p384_scalar_addcarryx_u64(&x412, &x413, x411, x376, x399); + fiat_p384_scalar_mulx_u64(&x414, &x415, x400, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x416, &x417, x414, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x418, &x419, x414, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x420, &x421, x414, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x422, &x423, x414, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x424, &x425, x414, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x426, &x427, x414, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x428, &x429, 0x0, x427, x424); + fiat_p384_scalar_addcarryx_u64(&x430, &x431, x429, x425, x422); + fiat_p384_scalar_addcarryx_u64(&x432, &x433, x431, x423, x420); + fiat_p384_scalar_addcarryx_u64(&x434, &x435, x433, x421, x418); + fiat_p384_scalar_addcarryx_u64(&x436, &x437, x435, x419, x416); + x438 = (x437 + x417); + fiat_p384_scalar_addcarryx_u64(&x439, &x440, 0x0, x400, x426); + fiat_p384_scalar_addcarryx_u64(&x441, &x442, x440, x402, x428); + fiat_p384_scalar_addcarryx_u64(&x443, &x444, x442, x404, x430); + fiat_p384_scalar_addcarryx_u64(&x445, &x446, x444, x406, x432); + fiat_p384_scalar_addcarryx_u64(&x447, &x448, x446, x408, x434); + fiat_p384_scalar_addcarryx_u64(&x449, &x450, x448, x410, x436); + fiat_p384_scalar_addcarryx_u64(&x451, &x452, x450, x412, x438); + x453 = ((uint64_t)x452 + x413); + fiat_p384_scalar_subborrowx_u64(&x454, &x455, 0x0, x441, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_subborrowx_u64(&x456, &x457, x455, x443, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_subborrowx_u64(&x458, &x459, x457, x445, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_subborrowx_u64(&x460, &x461, x459, x447, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x462, &x463, x461, x449, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x464, &x465, x463, x451, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x466, &x467, x465, x453, 0x0); + fiat_p384_scalar_cmovznz_u64(&x468, x467, x454, x441); + fiat_p384_scalar_cmovznz_u64(&x469, x467, x456, x443); + fiat_p384_scalar_cmovznz_u64(&x470, x467, x458, x445); + fiat_p384_scalar_cmovznz_u64(&x471, x467, x460, x447); + fiat_p384_scalar_cmovznz_u64(&x472, x467, x462, x449); + fiat_p384_scalar_cmovznz_u64(&x473, x467, x464, x451); + out1[0] = x468; + out1[1] = x469; + out1[2] = x470; + out1[3] = x471; + out1[4] = x472; + out1[5] = x473; +} + +/* + * The function fiat_p384_scalar_add adds two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_add(fiat_p384_scalar_montgomery_domain_field_element out1, const fiat_p384_scalar_montgomery_domain_field_element arg1, const fiat_p384_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_p384_scalar_uint1 x2; + uint64_t x3; + fiat_p384_scalar_uint1 x4; + uint64_t x5; + fiat_p384_scalar_uint1 x6; + uint64_t x7; + fiat_p384_scalar_uint1 x8; + uint64_t x9; + fiat_p384_scalar_uint1 x10; + uint64_t x11; + fiat_p384_scalar_uint1 x12; + uint64_t x13; + fiat_p384_scalar_uint1 x14; + uint64_t x15; + fiat_p384_scalar_uint1 x16; + uint64_t x17; + fiat_p384_scalar_uint1 x18; + uint64_t x19; + fiat_p384_scalar_uint1 x20; + uint64_t x21; + fiat_p384_scalar_uint1 x22; + uint64_t x23; + fiat_p384_scalar_uint1 x24; + uint64_t x25; + fiat_p384_scalar_uint1 x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint64_t x32; + fiat_p384_scalar_addcarryx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_p384_scalar_addcarryx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_p384_scalar_addcarryx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_p384_scalar_addcarryx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_p384_scalar_addcarryx_u64(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_p384_scalar_addcarryx_u64(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_p384_scalar_subborrowx_u64(&x13, &x14, 0x0, x1, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_subborrowx_u64(&x15, &x16, x14, x3, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_subborrowx_u64(&x17, &x18, x16, x5, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_subborrowx_u64(&x19, &x20, x18, x7, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x21, &x22, x20, x9, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x23, &x24, x22, x11, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x25, &x26, x24, x12, 0x0); + fiat_p384_scalar_cmovznz_u64(&x27, x26, x13, x1); + fiat_p384_scalar_cmovznz_u64(&x28, x26, x15, x3); + fiat_p384_scalar_cmovznz_u64(&x29, x26, x17, x5); + fiat_p384_scalar_cmovznz_u64(&x30, x26, x19, x7); + fiat_p384_scalar_cmovznz_u64(&x31, x26, x21, x9); + fiat_p384_scalar_cmovznz_u64(&x32, x26, x23, x11); + out1[0] = x27; + out1[1] = x28; + out1[2] = x29; + out1[3] = x30; + out1[4] = x31; + out1[5] = x32; +} + +/* + * The function fiat_p384_scalar_sub subtracts two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_sub(fiat_p384_scalar_montgomery_domain_field_element out1, const fiat_p384_scalar_montgomery_domain_field_element arg1, const fiat_p384_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_p384_scalar_uint1 x2; + uint64_t x3; + fiat_p384_scalar_uint1 x4; + uint64_t x5; + fiat_p384_scalar_uint1 x6; + uint64_t x7; + fiat_p384_scalar_uint1 x8; + uint64_t x9; + fiat_p384_scalar_uint1 x10; + uint64_t x11; + fiat_p384_scalar_uint1 x12; + uint64_t x13; + uint64_t x14; + fiat_p384_scalar_uint1 x15; + uint64_t x16; + fiat_p384_scalar_uint1 x17; + uint64_t x18; + fiat_p384_scalar_uint1 x19; + uint64_t x20; + fiat_p384_scalar_uint1 x21; + uint64_t x22; + fiat_p384_scalar_uint1 x23; + uint64_t x24; + fiat_p384_scalar_uint1 x25; + fiat_p384_scalar_subborrowx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_p384_scalar_subborrowx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_p384_scalar_subborrowx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_p384_scalar_subborrowx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_p384_scalar_subborrowx_u64(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_p384_scalar_subborrowx_u64(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_p384_scalar_cmovznz_u64(&x13, x12, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_addcarryx_u64(&x14, &x15, 0x0, x1, (x13 & UINT64_C(0xecec196accc52973))); + fiat_p384_scalar_addcarryx_u64(&x16, &x17, x15, x3, (x13 & UINT64_C(0x581a0db248b0a77a))); + fiat_p384_scalar_addcarryx_u64(&x18, &x19, x17, x5, (x13 & UINT64_C(0xc7634d81f4372ddf))); + fiat_p384_scalar_addcarryx_u64(&x20, &x21, x19, x7, x13); + fiat_p384_scalar_addcarryx_u64(&x22, &x23, x21, x9, x13); + fiat_p384_scalar_addcarryx_u64(&x24, &x25, x23, x11, x13); + out1[0] = x14; + out1[1] = x16; + out1[2] = x18; + out1[3] = x20; + out1[4] = x22; + out1[5] = x24; +} + +/* + * The function fiat_p384_scalar_opp negates a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_opp(fiat_p384_scalar_montgomery_domain_field_element out1, const fiat_p384_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + fiat_p384_scalar_uint1 x2; + uint64_t x3; + fiat_p384_scalar_uint1 x4; + uint64_t x5; + fiat_p384_scalar_uint1 x6; + uint64_t x7; + fiat_p384_scalar_uint1 x8; + uint64_t x9; + fiat_p384_scalar_uint1 x10; + uint64_t x11; + fiat_p384_scalar_uint1 x12; + uint64_t x13; + uint64_t x14; + fiat_p384_scalar_uint1 x15; + uint64_t x16; + fiat_p384_scalar_uint1 x17; + uint64_t x18; + fiat_p384_scalar_uint1 x19; + uint64_t x20; + fiat_p384_scalar_uint1 x21; + uint64_t x22; + fiat_p384_scalar_uint1 x23; + uint64_t x24; + fiat_p384_scalar_uint1 x25; + fiat_p384_scalar_subborrowx_u64(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_p384_scalar_subborrowx_u64(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_p384_scalar_subborrowx_u64(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_p384_scalar_subborrowx_u64(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_p384_scalar_subborrowx_u64(&x9, &x10, x8, 0x0, (arg1[4])); + fiat_p384_scalar_subborrowx_u64(&x11, &x12, x10, 0x0, (arg1[5])); + fiat_p384_scalar_cmovznz_u64(&x13, x12, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_addcarryx_u64(&x14, &x15, 0x0, x1, (x13 & UINT64_C(0xecec196accc52973))); + fiat_p384_scalar_addcarryx_u64(&x16, &x17, x15, x3, (x13 & UINT64_C(0x581a0db248b0a77a))); + fiat_p384_scalar_addcarryx_u64(&x18, &x19, x17, x5, (x13 & UINT64_C(0xc7634d81f4372ddf))); + fiat_p384_scalar_addcarryx_u64(&x20, &x21, x19, x7, x13); + fiat_p384_scalar_addcarryx_u64(&x22, &x23, x21, x9, x13); + fiat_p384_scalar_addcarryx_u64(&x24, &x25, x23, x11, x13); + out1[0] = x14; + out1[1] = x16; + out1[2] = x18; + out1[3] = x20; + out1[4] = x22; + out1[5] = x24; +} + +/* + * The function fiat_p384_scalar_from_montgomery translates a field element out of the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^6) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_from_montgomery(fiat_p384_scalar_non_montgomery_domain_field_element out1, const fiat_p384_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint64_t x16; + fiat_p384_scalar_uint1 x17; + uint64_t x18; + fiat_p384_scalar_uint1 x19; + uint64_t x20; + fiat_p384_scalar_uint1 x21; + uint64_t x22; + fiat_p384_scalar_uint1 x23; + uint64_t x24; + fiat_p384_scalar_uint1 x25; + uint64_t x26; + fiat_p384_scalar_uint1 x27; + uint64_t x28; + fiat_p384_scalar_uint1 x29; + uint64_t x30; + fiat_p384_scalar_uint1 x31; + uint64_t x32; + fiat_p384_scalar_uint1 x33; + uint64_t x34; + fiat_p384_scalar_uint1 x35; + uint64_t x36; + fiat_p384_scalar_uint1 x37; + uint64_t x38; + fiat_p384_scalar_uint1 x39; + uint64_t x40; + fiat_p384_scalar_uint1 x41; + uint64_t x42; + fiat_p384_scalar_uint1 x43; + uint64_t x44; + fiat_p384_scalar_uint1 x45; + uint64_t x46; + fiat_p384_scalar_uint1 x47; + uint64_t x48; + fiat_p384_scalar_uint1 x49; + uint64_t x50; + fiat_p384_scalar_uint1 x51; + uint64_t x52; + uint64_t x53; + uint64_t x54; + uint64_t x55; + uint64_t x56; + uint64_t x57; + uint64_t x58; + uint64_t x59; + uint64_t x60; + uint64_t x61; + uint64_t x62; + uint64_t x63; + uint64_t x64; + uint64_t x65; + uint64_t x66; + fiat_p384_scalar_uint1 x67; + uint64_t x68; + fiat_p384_scalar_uint1 x69; + uint64_t x70; + fiat_p384_scalar_uint1 x71; + uint64_t x72; + fiat_p384_scalar_uint1 x73; + uint64_t x74; + fiat_p384_scalar_uint1 x75; + uint64_t x76; + fiat_p384_scalar_uint1 x77; + uint64_t x78; + fiat_p384_scalar_uint1 x79; + uint64_t x80; + fiat_p384_scalar_uint1 x81; + uint64_t x82; + fiat_p384_scalar_uint1 x83; + uint64_t x84; + fiat_p384_scalar_uint1 x85; + uint64_t x86; + fiat_p384_scalar_uint1 x87; + uint64_t x88; + fiat_p384_scalar_uint1 x89; + uint64_t x90; + fiat_p384_scalar_uint1 x91; + uint64_t x92; + fiat_p384_scalar_uint1 x93; + uint64_t x94; + fiat_p384_scalar_uint1 x95; + uint64_t x96; + fiat_p384_scalar_uint1 x97; + uint64_t x98; + fiat_p384_scalar_uint1 x99; + uint64_t x100; + fiat_p384_scalar_uint1 x101; + uint64_t x102; + uint64_t x103; + uint64_t x104; + uint64_t x105; + uint64_t x106; + uint64_t x107; + uint64_t x108; + uint64_t x109; + uint64_t x110; + uint64_t x111; + uint64_t x112; + uint64_t x113; + uint64_t x114; + uint64_t x115; + uint64_t x116; + fiat_p384_scalar_uint1 x117; + uint64_t x118; + fiat_p384_scalar_uint1 x119; + uint64_t x120; + fiat_p384_scalar_uint1 x121; + uint64_t x122; + fiat_p384_scalar_uint1 x123; + uint64_t x124; + fiat_p384_scalar_uint1 x125; + uint64_t x126; + fiat_p384_scalar_uint1 x127; + uint64_t x128; + fiat_p384_scalar_uint1 x129; + uint64_t x130; + fiat_p384_scalar_uint1 x131; + uint64_t x132; + fiat_p384_scalar_uint1 x133; + uint64_t x134; + fiat_p384_scalar_uint1 x135; + uint64_t x136; + fiat_p384_scalar_uint1 x137; + uint64_t x138; + fiat_p384_scalar_uint1 x139; + uint64_t x140; + fiat_p384_scalar_uint1 x141; + uint64_t x142; + fiat_p384_scalar_uint1 x143; + uint64_t x144; + fiat_p384_scalar_uint1 x145; + uint64_t x146; + fiat_p384_scalar_uint1 x147; + uint64_t x148; + fiat_p384_scalar_uint1 x149; + uint64_t x150; + fiat_p384_scalar_uint1 x151; + uint64_t x152; + uint64_t x153; + uint64_t x154; + uint64_t x155; + uint64_t x156; + uint64_t x157; + uint64_t x158; + uint64_t x159; + uint64_t x160; + uint64_t x161; + uint64_t x162; + uint64_t x163; + uint64_t x164; + uint64_t x165; + uint64_t x166; + fiat_p384_scalar_uint1 x167; + uint64_t x168; + fiat_p384_scalar_uint1 x169; + uint64_t x170; + fiat_p384_scalar_uint1 x171; + uint64_t x172; + fiat_p384_scalar_uint1 x173; + uint64_t x174; + fiat_p384_scalar_uint1 x175; + uint64_t x176; + fiat_p384_scalar_uint1 x177; + uint64_t x178; + fiat_p384_scalar_uint1 x179; + uint64_t x180; + fiat_p384_scalar_uint1 x181; + uint64_t x182; + fiat_p384_scalar_uint1 x183; + uint64_t x184; + fiat_p384_scalar_uint1 x185; + uint64_t x186; + fiat_p384_scalar_uint1 x187; + uint64_t x188; + fiat_p384_scalar_uint1 x189; + uint64_t x190; + fiat_p384_scalar_uint1 x191; + uint64_t x192; + fiat_p384_scalar_uint1 x193; + uint64_t x194; + fiat_p384_scalar_uint1 x195; + uint64_t x196; + fiat_p384_scalar_uint1 x197; + uint64_t x198; + fiat_p384_scalar_uint1 x199; + uint64_t x200; + fiat_p384_scalar_uint1 x201; + uint64_t x202; + uint64_t x203; + uint64_t x204; + uint64_t x205; + uint64_t x206; + uint64_t x207; + uint64_t x208; + uint64_t x209; + uint64_t x210; + uint64_t x211; + uint64_t x212; + uint64_t x213; + uint64_t x214; + uint64_t x215; + uint64_t x216; + fiat_p384_scalar_uint1 x217; + uint64_t x218; + fiat_p384_scalar_uint1 x219; + uint64_t x220; + fiat_p384_scalar_uint1 x221; + uint64_t x222; + fiat_p384_scalar_uint1 x223; + uint64_t x224; + fiat_p384_scalar_uint1 x225; + uint64_t x226; + fiat_p384_scalar_uint1 x227; + uint64_t x228; + fiat_p384_scalar_uint1 x229; + uint64_t x230; + fiat_p384_scalar_uint1 x231; + uint64_t x232; + fiat_p384_scalar_uint1 x233; + uint64_t x234; + fiat_p384_scalar_uint1 x235; + uint64_t x236; + fiat_p384_scalar_uint1 x237; + uint64_t x238; + fiat_p384_scalar_uint1 x239; + uint64_t x240; + fiat_p384_scalar_uint1 x241; + uint64_t x242; + fiat_p384_scalar_uint1 x243; + uint64_t x244; + fiat_p384_scalar_uint1 x245; + uint64_t x246; + fiat_p384_scalar_uint1 x247; + uint64_t x248; + fiat_p384_scalar_uint1 x249; + uint64_t x250; + fiat_p384_scalar_uint1 x251; + uint64_t x252; + uint64_t x253; + uint64_t x254; + uint64_t x255; + uint64_t x256; + uint64_t x257; + uint64_t x258; + uint64_t x259; + uint64_t x260; + uint64_t x261; + uint64_t x262; + uint64_t x263; + uint64_t x264; + uint64_t x265; + uint64_t x266; + fiat_p384_scalar_uint1 x267; + uint64_t x268; + fiat_p384_scalar_uint1 x269; + uint64_t x270; + fiat_p384_scalar_uint1 x271; + uint64_t x272; + fiat_p384_scalar_uint1 x273; + uint64_t x274; + fiat_p384_scalar_uint1 x275; + uint64_t x276; + fiat_p384_scalar_uint1 x277; + uint64_t x278; + fiat_p384_scalar_uint1 x279; + uint64_t x280; + fiat_p384_scalar_uint1 x281; + uint64_t x282; + fiat_p384_scalar_uint1 x283; + uint64_t x284; + fiat_p384_scalar_uint1 x285; + uint64_t x286; + fiat_p384_scalar_uint1 x287; + uint64_t x288; + fiat_p384_scalar_uint1 x289; + uint64_t x290; + fiat_p384_scalar_uint1 x291; + uint64_t x292; + fiat_p384_scalar_uint1 x293; + uint64_t x294; + fiat_p384_scalar_uint1 x295; + uint64_t x296; + fiat_p384_scalar_uint1 x297; + uint64_t x298; + fiat_p384_scalar_uint1 x299; + uint64_t x300; + fiat_p384_scalar_uint1 x301; + uint64_t x302; + fiat_p384_scalar_uint1 x303; + uint64_t x304; + uint64_t x305; + uint64_t x306; + uint64_t x307; + uint64_t x308; + uint64_t x309; + x1 = (arg1[0]); + fiat_p384_scalar_mulx_u64(&x2, &x3, x1, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x4, &x5, x2, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x6, &x7, x2, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x8, &x9, x2, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x10, &x11, x2, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x12, &x13, x2, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x14, &x15, x2, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x16, &x17, 0x0, x15, x12); + fiat_p384_scalar_addcarryx_u64(&x18, &x19, x17, x13, x10); + fiat_p384_scalar_addcarryx_u64(&x20, &x21, x19, x11, x8); + fiat_p384_scalar_addcarryx_u64(&x22, &x23, x21, x9, x6); + fiat_p384_scalar_addcarryx_u64(&x24, &x25, x23, x7, x4); + fiat_p384_scalar_addcarryx_u64(&x26, &x27, 0x0, x1, x14); + fiat_p384_scalar_addcarryx_u64(&x28, &x29, x27, 0x0, x16); + fiat_p384_scalar_addcarryx_u64(&x30, &x31, x29, 0x0, x18); + fiat_p384_scalar_addcarryx_u64(&x32, &x33, x31, 0x0, x20); + fiat_p384_scalar_addcarryx_u64(&x34, &x35, x33, 0x0, x22); + fiat_p384_scalar_addcarryx_u64(&x36, &x37, x35, 0x0, x24); + fiat_p384_scalar_addcarryx_u64(&x38, &x39, x37, 0x0, (x25 + x5)); + fiat_p384_scalar_addcarryx_u64(&x40, &x41, 0x0, x28, (arg1[1])); + fiat_p384_scalar_addcarryx_u64(&x42, &x43, x41, x30, 0x0); + fiat_p384_scalar_addcarryx_u64(&x44, &x45, x43, x32, 0x0); + fiat_p384_scalar_addcarryx_u64(&x46, &x47, x45, x34, 0x0); + fiat_p384_scalar_addcarryx_u64(&x48, &x49, x47, x36, 0x0); + fiat_p384_scalar_addcarryx_u64(&x50, &x51, x49, x38, 0x0); + fiat_p384_scalar_mulx_u64(&x52, &x53, x40, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x54, &x55, x52, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x56, &x57, x52, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x58, &x59, x52, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x60, &x61, x52, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x62, &x63, x52, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x64, &x65, x52, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x66, &x67, 0x0, x65, x62); + fiat_p384_scalar_addcarryx_u64(&x68, &x69, x67, x63, x60); + fiat_p384_scalar_addcarryx_u64(&x70, &x71, x69, x61, x58); + fiat_p384_scalar_addcarryx_u64(&x72, &x73, x71, x59, x56); + fiat_p384_scalar_addcarryx_u64(&x74, &x75, x73, x57, x54); + fiat_p384_scalar_addcarryx_u64(&x76, &x77, 0x0, x40, x64); + fiat_p384_scalar_addcarryx_u64(&x78, &x79, x77, x42, x66); + fiat_p384_scalar_addcarryx_u64(&x80, &x81, x79, x44, x68); + fiat_p384_scalar_addcarryx_u64(&x82, &x83, x81, x46, x70); + fiat_p384_scalar_addcarryx_u64(&x84, &x85, x83, x48, x72); + fiat_p384_scalar_addcarryx_u64(&x86, &x87, x85, x50, x74); + fiat_p384_scalar_addcarryx_u64(&x88, &x89, x87, ((uint64_t)x51 + x39), (x75 + x55)); + fiat_p384_scalar_addcarryx_u64(&x90, &x91, 0x0, x78, (arg1[2])); + fiat_p384_scalar_addcarryx_u64(&x92, &x93, x91, x80, 0x0); + fiat_p384_scalar_addcarryx_u64(&x94, &x95, x93, x82, 0x0); + fiat_p384_scalar_addcarryx_u64(&x96, &x97, x95, x84, 0x0); + fiat_p384_scalar_addcarryx_u64(&x98, &x99, x97, x86, 0x0); + fiat_p384_scalar_addcarryx_u64(&x100, &x101, x99, x88, 0x0); + fiat_p384_scalar_mulx_u64(&x102, &x103, x90, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x104, &x105, x102, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x106, &x107, x102, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x108, &x109, x102, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x110, &x111, x102, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x112, &x113, x102, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x114, &x115, x102, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x116, &x117, 0x0, x115, x112); + fiat_p384_scalar_addcarryx_u64(&x118, &x119, x117, x113, x110); + fiat_p384_scalar_addcarryx_u64(&x120, &x121, x119, x111, x108); + fiat_p384_scalar_addcarryx_u64(&x122, &x123, x121, x109, x106); + fiat_p384_scalar_addcarryx_u64(&x124, &x125, x123, x107, x104); + fiat_p384_scalar_addcarryx_u64(&x126, &x127, 0x0, x90, x114); + fiat_p384_scalar_addcarryx_u64(&x128, &x129, x127, x92, x116); + fiat_p384_scalar_addcarryx_u64(&x130, &x131, x129, x94, x118); + fiat_p384_scalar_addcarryx_u64(&x132, &x133, x131, x96, x120); + fiat_p384_scalar_addcarryx_u64(&x134, &x135, x133, x98, x122); + fiat_p384_scalar_addcarryx_u64(&x136, &x137, x135, x100, x124); + fiat_p384_scalar_addcarryx_u64(&x138, &x139, x137, ((uint64_t)x101 + x89), (x125 + x105)); + fiat_p384_scalar_addcarryx_u64(&x140, &x141, 0x0, x128, (arg1[3])); + fiat_p384_scalar_addcarryx_u64(&x142, &x143, x141, x130, 0x0); + fiat_p384_scalar_addcarryx_u64(&x144, &x145, x143, x132, 0x0); + fiat_p384_scalar_addcarryx_u64(&x146, &x147, x145, x134, 0x0); + fiat_p384_scalar_addcarryx_u64(&x148, &x149, x147, x136, 0x0); + fiat_p384_scalar_addcarryx_u64(&x150, &x151, x149, x138, 0x0); + fiat_p384_scalar_mulx_u64(&x152, &x153, x140, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x154, &x155, x152, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x156, &x157, x152, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x158, &x159, x152, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x160, &x161, x152, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x162, &x163, x152, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x164, &x165, x152, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x166, &x167, 0x0, x165, x162); + fiat_p384_scalar_addcarryx_u64(&x168, &x169, x167, x163, x160); + fiat_p384_scalar_addcarryx_u64(&x170, &x171, x169, x161, x158); + fiat_p384_scalar_addcarryx_u64(&x172, &x173, x171, x159, x156); + fiat_p384_scalar_addcarryx_u64(&x174, &x175, x173, x157, x154); + fiat_p384_scalar_addcarryx_u64(&x176, &x177, 0x0, x140, x164); + fiat_p384_scalar_addcarryx_u64(&x178, &x179, x177, x142, x166); + fiat_p384_scalar_addcarryx_u64(&x180, &x181, x179, x144, x168); + fiat_p384_scalar_addcarryx_u64(&x182, &x183, x181, x146, x170); + fiat_p384_scalar_addcarryx_u64(&x184, &x185, x183, x148, x172); + fiat_p384_scalar_addcarryx_u64(&x186, &x187, x185, x150, x174); + fiat_p384_scalar_addcarryx_u64(&x188, &x189, x187, ((uint64_t)x151 + x139), (x175 + x155)); + fiat_p384_scalar_addcarryx_u64(&x190, &x191, 0x0, x178, (arg1[4])); + fiat_p384_scalar_addcarryx_u64(&x192, &x193, x191, x180, 0x0); + fiat_p384_scalar_addcarryx_u64(&x194, &x195, x193, x182, 0x0); + fiat_p384_scalar_addcarryx_u64(&x196, &x197, x195, x184, 0x0); + fiat_p384_scalar_addcarryx_u64(&x198, &x199, x197, x186, 0x0); + fiat_p384_scalar_addcarryx_u64(&x200, &x201, x199, x188, 0x0); + fiat_p384_scalar_mulx_u64(&x202, &x203, x190, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x204, &x205, x202, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x206, &x207, x202, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x208, &x209, x202, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x210, &x211, x202, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x212, &x213, x202, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x214, &x215, x202, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x216, &x217, 0x0, x215, x212); + fiat_p384_scalar_addcarryx_u64(&x218, &x219, x217, x213, x210); + fiat_p384_scalar_addcarryx_u64(&x220, &x221, x219, x211, x208); + fiat_p384_scalar_addcarryx_u64(&x222, &x223, x221, x209, x206); + fiat_p384_scalar_addcarryx_u64(&x224, &x225, x223, x207, x204); + fiat_p384_scalar_addcarryx_u64(&x226, &x227, 0x0, x190, x214); + fiat_p384_scalar_addcarryx_u64(&x228, &x229, x227, x192, x216); + fiat_p384_scalar_addcarryx_u64(&x230, &x231, x229, x194, x218); + fiat_p384_scalar_addcarryx_u64(&x232, &x233, x231, x196, x220); + fiat_p384_scalar_addcarryx_u64(&x234, &x235, x233, x198, x222); + fiat_p384_scalar_addcarryx_u64(&x236, &x237, x235, x200, x224); + fiat_p384_scalar_addcarryx_u64(&x238, &x239, x237, ((uint64_t)x201 + x189), (x225 + x205)); + fiat_p384_scalar_addcarryx_u64(&x240, &x241, 0x0, x228, (arg1[5])); + fiat_p384_scalar_addcarryx_u64(&x242, &x243, x241, x230, 0x0); + fiat_p384_scalar_addcarryx_u64(&x244, &x245, x243, x232, 0x0); + fiat_p384_scalar_addcarryx_u64(&x246, &x247, x245, x234, 0x0); + fiat_p384_scalar_addcarryx_u64(&x248, &x249, x247, x236, 0x0); + fiat_p384_scalar_addcarryx_u64(&x250, &x251, x249, x238, 0x0); + fiat_p384_scalar_mulx_u64(&x252, &x253, x240, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x254, &x255, x252, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x256, &x257, x252, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x258, &x259, x252, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x260, &x261, x252, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x262, &x263, x252, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x264, &x265, x252, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x266, &x267, 0x0, x265, x262); + fiat_p384_scalar_addcarryx_u64(&x268, &x269, x267, x263, x260); + fiat_p384_scalar_addcarryx_u64(&x270, &x271, x269, x261, x258); + fiat_p384_scalar_addcarryx_u64(&x272, &x273, x271, x259, x256); + fiat_p384_scalar_addcarryx_u64(&x274, &x275, x273, x257, x254); + fiat_p384_scalar_addcarryx_u64(&x276, &x277, 0x0, x240, x264); + fiat_p384_scalar_addcarryx_u64(&x278, &x279, x277, x242, x266); + fiat_p384_scalar_addcarryx_u64(&x280, &x281, x279, x244, x268); + fiat_p384_scalar_addcarryx_u64(&x282, &x283, x281, x246, x270); + fiat_p384_scalar_addcarryx_u64(&x284, &x285, x283, x248, x272); + fiat_p384_scalar_addcarryx_u64(&x286, &x287, x285, x250, x274); + fiat_p384_scalar_addcarryx_u64(&x288, &x289, x287, ((uint64_t)x251 + x239), (x275 + x255)); + fiat_p384_scalar_subborrowx_u64(&x290, &x291, 0x0, x278, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_subborrowx_u64(&x292, &x293, x291, x280, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_subborrowx_u64(&x294, &x295, x293, x282, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_subborrowx_u64(&x296, &x297, x295, x284, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x298, &x299, x297, x286, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x300, &x301, x299, x288, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x302, &x303, x301, x289, 0x0); + fiat_p384_scalar_cmovznz_u64(&x304, x303, x290, x278); + fiat_p384_scalar_cmovznz_u64(&x305, x303, x292, x280); + fiat_p384_scalar_cmovznz_u64(&x306, x303, x294, x282); + fiat_p384_scalar_cmovznz_u64(&x307, x303, x296, x284); + fiat_p384_scalar_cmovznz_u64(&x308, x303, x298, x286); + fiat_p384_scalar_cmovznz_u64(&x309, x303, x300, x288); + out1[0] = x304; + out1[1] = x305; + out1[2] = x306; + out1[3] = x307; + out1[4] = x308; + out1[5] = x309; +} + +/* + * The function fiat_p384_scalar_to_montgomery translates a field element into the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = eval arg1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_to_montgomery(fiat_p384_scalar_montgomery_domain_field_element out1, const fiat_p384_scalar_non_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint64_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + fiat_p384_scalar_uint1 x20; + uint64_t x21; + fiat_p384_scalar_uint1 x22; + uint64_t x23; + fiat_p384_scalar_uint1 x24; + uint64_t x25; + fiat_p384_scalar_uint1 x26; + uint64_t x27; + fiat_p384_scalar_uint1 x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint64_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + fiat_p384_scalar_uint1 x44; + uint64_t x45; + fiat_p384_scalar_uint1 x46; + uint64_t x47; + fiat_p384_scalar_uint1 x48; + uint64_t x49; + fiat_p384_scalar_uint1 x50; + uint64_t x51; + fiat_p384_scalar_uint1 x52; + uint64_t x53; + fiat_p384_scalar_uint1 x54; + uint64_t x55; + fiat_p384_scalar_uint1 x56; + uint64_t x57; + fiat_p384_scalar_uint1 x58; + uint64_t x59; + fiat_p384_scalar_uint1 x60; + uint64_t x61; + fiat_p384_scalar_uint1 x62; + uint64_t x63; + fiat_p384_scalar_uint1 x64; + uint64_t x65; + fiat_p384_scalar_uint1 x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + fiat_p384_scalar_uint1 x80; + uint64_t x81; + fiat_p384_scalar_uint1 x82; + uint64_t x83; + fiat_p384_scalar_uint1 x84; + uint64_t x85; + fiat_p384_scalar_uint1 x86; + uint64_t x87; + fiat_p384_scalar_uint1 x88; + uint64_t x89; + fiat_p384_scalar_uint1 x90; + uint64_t x91; + fiat_p384_scalar_uint1 x92; + uint64_t x93; + fiat_p384_scalar_uint1 x94; + uint64_t x95; + fiat_p384_scalar_uint1 x96; + uint64_t x97; + fiat_p384_scalar_uint1 x98; + uint64_t x99; + fiat_p384_scalar_uint1 x100; + uint64_t x101; + uint64_t x102; + uint64_t x103; + uint64_t x104; + uint64_t x105; + uint64_t x106; + uint64_t x107; + uint64_t x108; + uint64_t x109; + uint64_t x110; + uint64_t x111; + uint64_t x112; + uint64_t x113; + uint64_t x114; + uint64_t x115; + fiat_p384_scalar_uint1 x116; + uint64_t x117; + fiat_p384_scalar_uint1 x118; + uint64_t x119; + fiat_p384_scalar_uint1 x120; + uint64_t x121; + fiat_p384_scalar_uint1 x122; + uint64_t x123; + fiat_p384_scalar_uint1 x124; + uint64_t x125; + fiat_p384_scalar_uint1 x126; + uint64_t x127; + fiat_p384_scalar_uint1 x128; + uint64_t x129; + fiat_p384_scalar_uint1 x130; + uint64_t x131; + fiat_p384_scalar_uint1 x132; + uint64_t x133; + fiat_p384_scalar_uint1 x134; + uint64_t x135; + fiat_p384_scalar_uint1 x136; + uint64_t x137; + fiat_p384_scalar_uint1 x138; + uint64_t x139; + uint64_t x140; + uint64_t x141; + uint64_t x142; + uint64_t x143; + uint64_t x144; + uint64_t x145; + uint64_t x146; + uint64_t x147; + uint64_t x148; + uint64_t x149; + uint64_t x150; + uint64_t x151; + fiat_p384_scalar_uint1 x152; + uint64_t x153; + fiat_p384_scalar_uint1 x154; + uint64_t x155; + fiat_p384_scalar_uint1 x156; + uint64_t x157; + fiat_p384_scalar_uint1 x158; + uint64_t x159; + fiat_p384_scalar_uint1 x160; + uint64_t x161; + fiat_p384_scalar_uint1 x162; + uint64_t x163; + fiat_p384_scalar_uint1 x164; + uint64_t x165; + fiat_p384_scalar_uint1 x166; + uint64_t x167; + fiat_p384_scalar_uint1 x168; + uint64_t x169; + fiat_p384_scalar_uint1 x170; + uint64_t x171; + fiat_p384_scalar_uint1 x172; + uint64_t x173; + uint64_t x174; + uint64_t x175; + uint64_t x176; + uint64_t x177; + uint64_t x178; + uint64_t x179; + uint64_t x180; + uint64_t x181; + uint64_t x182; + uint64_t x183; + uint64_t x184; + uint64_t x185; + uint64_t x186; + uint64_t x187; + fiat_p384_scalar_uint1 x188; + uint64_t x189; + fiat_p384_scalar_uint1 x190; + uint64_t x191; + fiat_p384_scalar_uint1 x192; + uint64_t x193; + fiat_p384_scalar_uint1 x194; + uint64_t x195; + fiat_p384_scalar_uint1 x196; + uint64_t x197; + fiat_p384_scalar_uint1 x198; + uint64_t x199; + fiat_p384_scalar_uint1 x200; + uint64_t x201; + fiat_p384_scalar_uint1 x202; + uint64_t x203; + fiat_p384_scalar_uint1 x204; + uint64_t x205; + fiat_p384_scalar_uint1 x206; + uint64_t x207; + fiat_p384_scalar_uint1 x208; + uint64_t x209; + fiat_p384_scalar_uint1 x210; + uint64_t x211; + uint64_t x212; + uint64_t x213; + uint64_t x214; + uint64_t x215; + uint64_t x216; + uint64_t x217; + uint64_t x218; + uint64_t x219; + uint64_t x220; + uint64_t x221; + uint64_t x222; + uint64_t x223; + fiat_p384_scalar_uint1 x224; + uint64_t x225; + fiat_p384_scalar_uint1 x226; + uint64_t x227; + fiat_p384_scalar_uint1 x228; + uint64_t x229; + fiat_p384_scalar_uint1 x230; + uint64_t x231; + fiat_p384_scalar_uint1 x232; + uint64_t x233; + fiat_p384_scalar_uint1 x234; + uint64_t x235; + fiat_p384_scalar_uint1 x236; + uint64_t x237; + fiat_p384_scalar_uint1 x238; + uint64_t x239; + fiat_p384_scalar_uint1 x240; + uint64_t x241; + fiat_p384_scalar_uint1 x242; + uint64_t x243; + fiat_p384_scalar_uint1 x244; + uint64_t x245; + uint64_t x246; + uint64_t x247; + uint64_t x248; + uint64_t x249; + uint64_t x250; + uint64_t x251; + uint64_t x252; + uint64_t x253; + uint64_t x254; + uint64_t x255; + uint64_t x256; + uint64_t x257; + uint64_t x258; + uint64_t x259; + fiat_p384_scalar_uint1 x260; + uint64_t x261; + fiat_p384_scalar_uint1 x262; + uint64_t x263; + fiat_p384_scalar_uint1 x264; + uint64_t x265; + fiat_p384_scalar_uint1 x266; + uint64_t x267; + fiat_p384_scalar_uint1 x268; + uint64_t x269; + fiat_p384_scalar_uint1 x270; + uint64_t x271; + fiat_p384_scalar_uint1 x272; + uint64_t x273; + fiat_p384_scalar_uint1 x274; + uint64_t x275; + fiat_p384_scalar_uint1 x276; + uint64_t x277; + fiat_p384_scalar_uint1 x278; + uint64_t x279; + fiat_p384_scalar_uint1 x280; + uint64_t x281; + fiat_p384_scalar_uint1 x282; + uint64_t x283; + uint64_t x284; + uint64_t x285; + uint64_t x286; + uint64_t x287; + uint64_t x288; + uint64_t x289; + uint64_t x290; + uint64_t x291; + uint64_t x292; + uint64_t x293; + uint64_t x294; + uint64_t x295; + fiat_p384_scalar_uint1 x296; + uint64_t x297; + fiat_p384_scalar_uint1 x298; + uint64_t x299; + fiat_p384_scalar_uint1 x300; + uint64_t x301; + fiat_p384_scalar_uint1 x302; + uint64_t x303; + fiat_p384_scalar_uint1 x304; + uint64_t x305; + fiat_p384_scalar_uint1 x306; + uint64_t x307; + fiat_p384_scalar_uint1 x308; + uint64_t x309; + fiat_p384_scalar_uint1 x310; + uint64_t x311; + fiat_p384_scalar_uint1 x312; + uint64_t x313; + fiat_p384_scalar_uint1 x314; + uint64_t x315; + fiat_p384_scalar_uint1 x316; + uint64_t x317; + uint64_t x318; + uint64_t x319; + uint64_t x320; + uint64_t x321; + uint64_t x322; + uint64_t x323; + uint64_t x324; + uint64_t x325; + uint64_t x326; + uint64_t x327; + uint64_t x328; + uint64_t x329; + uint64_t x330; + uint64_t x331; + fiat_p384_scalar_uint1 x332; + uint64_t x333; + fiat_p384_scalar_uint1 x334; + uint64_t x335; + fiat_p384_scalar_uint1 x336; + uint64_t x337; + fiat_p384_scalar_uint1 x338; + uint64_t x339; + fiat_p384_scalar_uint1 x340; + uint64_t x341; + fiat_p384_scalar_uint1 x342; + uint64_t x343; + fiat_p384_scalar_uint1 x344; + uint64_t x345; + fiat_p384_scalar_uint1 x346; + uint64_t x347; + fiat_p384_scalar_uint1 x348; + uint64_t x349; + fiat_p384_scalar_uint1 x350; + uint64_t x351; + fiat_p384_scalar_uint1 x352; + uint64_t x353; + fiat_p384_scalar_uint1 x354; + uint64_t x355; + uint64_t x356; + uint64_t x357; + uint64_t x358; + uint64_t x359; + uint64_t x360; + uint64_t x361; + uint64_t x362; + uint64_t x363; + uint64_t x364; + uint64_t x365; + uint64_t x366; + uint64_t x367; + fiat_p384_scalar_uint1 x368; + uint64_t x369; + fiat_p384_scalar_uint1 x370; + uint64_t x371; + fiat_p384_scalar_uint1 x372; + uint64_t x373; + fiat_p384_scalar_uint1 x374; + uint64_t x375; + fiat_p384_scalar_uint1 x376; + uint64_t x377; + fiat_p384_scalar_uint1 x378; + uint64_t x379; + fiat_p384_scalar_uint1 x380; + uint64_t x381; + fiat_p384_scalar_uint1 x382; + uint64_t x383; + fiat_p384_scalar_uint1 x384; + uint64_t x385; + fiat_p384_scalar_uint1 x386; + uint64_t x387; + fiat_p384_scalar_uint1 x388; + uint64_t x389; + uint64_t x390; + uint64_t x391; + uint64_t x392; + uint64_t x393; + uint64_t x394; + uint64_t x395; + uint64_t x396; + uint64_t x397; + uint64_t x398; + uint64_t x399; + uint64_t x400; + uint64_t x401; + uint64_t x402; + uint64_t x403; + fiat_p384_scalar_uint1 x404; + uint64_t x405; + fiat_p384_scalar_uint1 x406; + uint64_t x407; + fiat_p384_scalar_uint1 x408; + uint64_t x409; + fiat_p384_scalar_uint1 x410; + uint64_t x411; + fiat_p384_scalar_uint1 x412; + uint64_t x413; + fiat_p384_scalar_uint1 x414; + uint64_t x415; + fiat_p384_scalar_uint1 x416; + uint64_t x417; + fiat_p384_scalar_uint1 x418; + uint64_t x419; + fiat_p384_scalar_uint1 x420; + uint64_t x421; + fiat_p384_scalar_uint1 x422; + uint64_t x423; + fiat_p384_scalar_uint1 x424; + uint64_t x425; + fiat_p384_scalar_uint1 x426; + uint64_t x427; + fiat_p384_scalar_uint1 x428; + uint64_t x429; + fiat_p384_scalar_uint1 x430; + uint64_t x431; + fiat_p384_scalar_uint1 x432; + uint64_t x433; + fiat_p384_scalar_uint1 x434; + uint64_t x435; + fiat_p384_scalar_uint1 x436; + uint64_t x437; + fiat_p384_scalar_uint1 x438; + uint64_t x439; + fiat_p384_scalar_uint1 x440; + uint64_t x441; + uint64_t x442; + uint64_t x443; + uint64_t x444; + uint64_t x445; + uint64_t x446; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[0]); + fiat_p384_scalar_mulx_u64(&x7, &x8, x6, UINT64_C(0xc84ee012b39bf21)); + fiat_p384_scalar_mulx_u64(&x9, &x10, x6, UINT64_C(0x3fb05b7a28266895)); + fiat_p384_scalar_mulx_u64(&x11, &x12, x6, UINT64_C(0xd40d49174aab1cc5)); + fiat_p384_scalar_mulx_u64(&x13, &x14, x6, UINT64_C(0xbc3e483afcb82947)); + fiat_p384_scalar_mulx_u64(&x15, &x16, x6, UINT64_C(0xff3d81e5df1aa419)); + fiat_p384_scalar_mulx_u64(&x17, &x18, x6, UINT64_C(0x2d319b2419b409a9)); + fiat_p384_scalar_addcarryx_u64(&x19, &x20, 0x0, x18, x15); + fiat_p384_scalar_addcarryx_u64(&x21, &x22, x20, x16, x13); + fiat_p384_scalar_addcarryx_u64(&x23, &x24, x22, x14, x11); + fiat_p384_scalar_addcarryx_u64(&x25, &x26, x24, x12, x9); + fiat_p384_scalar_addcarryx_u64(&x27, &x28, x26, x10, x7); + fiat_p384_scalar_mulx_u64(&x29, &x30, x17, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x31, &x32, x29, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x33, &x34, x29, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x35, &x36, x29, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x37, &x38, x29, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x39, &x40, x29, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x41, &x42, x29, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x43, &x44, 0x0, x42, x39); + fiat_p384_scalar_addcarryx_u64(&x45, &x46, x44, x40, x37); + fiat_p384_scalar_addcarryx_u64(&x47, &x48, x46, x38, x35); + fiat_p384_scalar_addcarryx_u64(&x49, &x50, x48, x36, x33); + fiat_p384_scalar_addcarryx_u64(&x51, &x52, x50, x34, x31); + fiat_p384_scalar_addcarryx_u64(&x53, &x54, 0x0, x17, x41); + fiat_p384_scalar_addcarryx_u64(&x55, &x56, x54, x19, x43); + fiat_p384_scalar_addcarryx_u64(&x57, &x58, x56, x21, x45); + fiat_p384_scalar_addcarryx_u64(&x59, &x60, x58, x23, x47); + fiat_p384_scalar_addcarryx_u64(&x61, &x62, x60, x25, x49); + fiat_p384_scalar_addcarryx_u64(&x63, &x64, x62, x27, x51); + fiat_p384_scalar_addcarryx_u64(&x65, &x66, x64, (x28 + x8), (x52 + x32)); + fiat_p384_scalar_mulx_u64(&x67, &x68, x1, UINT64_C(0xc84ee012b39bf21)); + fiat_p384_scalar_mulx_u64(&x69, &x70, x1, UINT64_C(0x3fb05b7a28266895)); + fiat_p384_scalar_mulx_u64(&x71, &x72, x1, UINT64_C(0xd40d49174aab1cc5)); + fiat_p384_scalar_mulx_u64(&x73, &x74, x1, UINT64_C(0xbc3e483afcb82947)); + fiat_p384_scalar_mulx_u64(&x75, &x76, x1, UINT64_C(0xff3d81e5df1aa419)); + fiat_p384_scalar_mulx_u64(&x77, &x78, x1, UINT64_C(0x2d319b2419b409a9)); + fiat_p384_scalar_addcarryx_u64(&x79, &x80, 0x0, x78, x75); + fiat_p384_scalar_addcarryx_u64(&x81, &x82, x80, x76, x73); + fiat_p384_scalar_addcarryx_u64(&x83, &x84, x82, x74, x71); + fiat_p384_scalar_addcarryx_u64(&x85, &x86, x84, x72, x69); + fiat_p384_scalar_addcarryx_u64(&x87, &x88, x86, x70, x67); + fiat_p384_scalar_addcarryx_u64(&x89, &x90, 0x0, x55, x77); + fiat_p384_scalar_addcarryx_u64(&x91, &x92, x90, x57, x79); + fiat_p384_scalar_addcarryx_u64(&x93, &x94, x92, x59, x81); + fiat_p384_scalar_addcarryx_u64(&x95, &x96, x94, x61, x83); + fiat_p384_scalar_addcarryx_u64(&x97, &x98, x96, x63, x85); + fiat_p384_scalar_addcarryx_u64(&x99, &x100, x98, x65, x87); + fiat_p384_scalar_mulx_u64(&x101, &x102, x89, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x103, &x104, x101, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x105, &x106, x101, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x107, &x108, x101, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x109, &x110, x101, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x111, &x112, x101, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x113, &x114, x101, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x115, &x116, 0x0, x114, x111); + fiat_p384_scalar_addcarryx_u64(&x117, &x118, x116, x112, x109); + fiat_p384_scalar_addcarryx_u64(&x119, &x120, x118, x110, x107); + fiat_p384_scalar_addcarryx_u64(&x121, &x122, x120, x108, x105); + fiat_p384_scalar_addcarryx_u64(&x123, &x124, x122, x106, x103); + fiat_p384_scalar_addcarryx_u64(&x125, &x126, 0x0, x89, x113); + fiat_p384_scalar_addcarryx_u64(&x127, &x128, x126, x91, x115); + fiat_p384_scalar_addcarryx_u64(&x129, &x130, x128, x93, x117); + fiat_p384_scalar_addcarryx_u64(&x131, &x132, x130, x95, x119); + fiat_p384_scalar_addcarryx_u64(&x133, &x134, x132, x97, x121); + fiat_p384_scalar_addcarryx_u64(&x135, &x136, x134, x99, x123); + fiat_p384_scalar_addcarryx_u64(&x137, &x138, x136, (((uint64_t)x100 + x66) + (x88 + x68)), (x124 + x104)); + fiat_p384_scalar_mulx_u64(&x139, &x140, x2, UINT64_C(0xc84ee012b39bf21)); + fiat_p384_scalar_mulx_u64(&x141, &x142, x2, UINT64_C(0x3fb05b7a28266895)); + fiat_p384_scalar_mulx_u64(&x143, &x144, x2, UINT64_C(0xd40d49174aab1cc5)); + fiat_p384_scalar_mulx_u64(&x145, &x146, x2, UINT64_C(0xbc3e483afcb82947)); + fiat_p384_scalar_mulx_u64(&x147, &x148, x2, UINT64_C(0xff3d81e5df1aa419)); + fiat_p384_scalar_mulx_u64(&x149, &x150, x2, UINT64_C(0x2d319b2419b409a9)); + fiat_p384_scalar_addcarryx_u64(&x151, &x152, 0x0, x150, x147); + fiat_p384_scalar_addcarryx_u64(&x153, &x154, x152, x148, x145); + fiat_p384_scalar_addcarryx_u64(&x155, &x156, x154, x146, x143); + fiat_p384_scalar_addcarryx_u64(&x157, &x158, x156, x144, x141); + fiat_p384_scalar_addcarryx_u64(&x159, &x160, x158, x142, x139); + fiat_p384_scalar_addcarryx_u64(&x161, &x162, 0x0, x127, x149); + fiat_p384_scalar_addcarryx_u64(&x163, &x164, x162, x129, x151); + fiat_p384_scalar_addcarryx_u64(&x165, &x166, x164, x131, x153); + fiat_p384_scalar_addcarryx_u64(&x167, &x168, x166, x133, x155); + fiat_p384_scalar_addcarryx_u64(&x169, &x170, x168, x135, x157); + fiat_p384_scalar_addcarryx_u64(&x171, &x172, x170, x137, x159); + fiat_p384_scalar_mulx_u64(&x173, &x174, x161, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x175, &x176, x173, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x177, &x178, x173, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x179, &x180, x173, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x181, &x182, x173, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x183, &x184, x173, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x185, &x186, x173, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x187, &x188, 0x0, x186, x183); + fiat_p384_scalar_addcarryx_u64(&x189, &x190, x188, x184, x181); + fiat_p384_scalar_addcarryx_u64(&x191, &x192, x190, x182, x179); + fiat_p384_scalar_addcarryx_u64(&x193, &x194, x192, x180, x177); + fiat_p384_scalar_addcarryx_u64(&x195, &x196, x194, x178, x175); + fiat_p384_scalar_addcarryx_u64(&x197, &x198, 0x0, x161, x185); + fiat_p384_scalar_addcarryx_u64(&x199, &x200, x198, x163, x187); + fiat_p384_scalar_addcarryx_u64(&x201, &x202, x200, x165, x189); + fiat_p384_scalar_addcarryx_u64(&x203, &x204, x202, x167, x191); + fiat_p384_scalar_addcarryx_u64(&x205, &x206, x204, x169, x193); + fiat_p384_scalar_addcarryx_u64(&x207, &x208, x206, x171, x195); + fiat_p384_scalar_addcarryx_u64(&x209, &x210, x208, (((uint64_t)x172 + x138) + (x160 + x140)), (x196 + x176)); + fiat_p384_scalar_mulx_u64(&x211, &x212, x3, UINT64_C(0xc84ee012b39bf21)); + fiat_p384_scalar_mulx_u64(&x213, &x214, x3, UINT64_C(0x3fb05b7a28266895)); + fiat_p384_scalar_mulx_u64(&x215, &x216, x3, UINT64_C(0xd40d49174aab1cc5)); + fiat_p384_scalar_mulx_u64(&x217, &x218, x3, UINT64_C(0xbc3e483afcb82947)); + fiat_p384_scalar_mulx_u64(&x219, &x220, x3, UINT64_C(0xff3d81e5df1aa419)); + fiat_p384_scalar_mulx_u64(&x221, &x222, x3, UINT64_C(0x2d319b2419b409a9)); + fiat_p384_scalar_addcarryx_u64(&x223, &x224, 0x0, x222, x219); + fiat_p384_scalar_addcarryx_u64(&x225, &x226, x224, x220, x217); + fiat_p384_scalar_addcarryx_u64(&x227, &x228, x226, x218, x215); + fiat_p384_scalar_addcarryx_u64(&x229, &x230, x228, x216, x213); + fiat_p384_scalar_addcarryx_u64(&x231, &x232, x230, x214, x211); + fiat_p384_scalar_addcarryx_u64(&x233, &x234, 0x0, x199, x221); + fiat_p384_scalar_addcarryx_u64(&x235, &x236, x234, x201, x223); + fiat_p384_scalar_addcarryx_u64(&x237, &x238, x236, x203, x225); + fiat_p384_scalar_addcarryx_u64(&x239, &x240, x238, x205, x227); + fiat_p384_scalar_addcarryx_u64(&x241, &x242, x240, x207, x229); + fiat_p384_scalar_addcarryx_u64(&x243, &x244, x242, x209, x231); + fiat_p384_scalar_mulx_u64(&x245, &x246, x233, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x247, &x248, x245, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x249, &x250, x245, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x251, &x252, x245, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x253, &x254, x245, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x255, &x256, x245, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x257, &x258, x245, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x259, &x260, 0x0, x258, x255); + fiat_p384_scalar_addcarryx_u64(&x261, &x262, x260, x256, x253); + fiat_p384_scalar_addcarryx_u64(&x263, &x264, x262, x254, x251); + fiat_p384_scalar_addcarryx_u64(&x265, &x266, x264, x252, x249); + fiat_p384_scalar_addcarryx_u64(&x267, &x268, x266, x250, x247); + fiat_p384_scalar_addcarryx_u64(&x269, &x270, 0x0, x233, x257); + fiat_p384_scalar_addcarryx_u64(&x271, &x272, x270, x235, x259); + fiat_p384_scalar_addcarryx_u64(&x273, &x274, x272, x237, x261); + fiat_p384_scalar_addcarryx_u64(&x275, &x276, x274, x239, x263); + fiat_p384_scalar_addcarryx_u64(&x277, &x278, x276, x241, x265); + fiat_p384_scalar_addcarryx_u64(&x279, &x280, x278, x243, x267); + fiat_p384_scalar_addcarryx_u64(&x281, &x282, x280, (((uint64_t)x244 + x210) + (x232 + x212)), (x268 + x248)); + fiat_p384_scalar_mulx_u64(&x283, &x284, x4, UINT64_C(0xc84ee012b39bf21)); + fiat_p384_scalar_mulx_u64(&x285, &x286, x4, UINT64_C(0x3fb05b7a28266895)); + fiat_p384_scalar_mulx_u64(&x287, &x288, x4, UINT64_C(0xd40d49174aab1cc5)); + fiat_p384_scalar_mulx_u64(&x289, &x290, x4, UINT64_C(0xbc3e483afcb82947)); + fiat_p384_scalar_mulx_u64(&x291, &x292, x4, UINT64_C(0xff3d81e5df1aa419)); + fiat_p384_scalar_mulx_u64(&x293, &x294, x4, UINT64_C(0x2d319b2419b409a9)); + fiat_p384_scalar_addcarryx_u64(&x295, &x296, 0x0, x294, x291); + fiat_p384_scalar_addcarryx_u64(&x297, &x298, x296, x292, x289); + fiat_p384_scalar_addcarryx_u64(&x299, &x300, x298, x290, x287); + fiat_p384_scalar_addcarryx_u64(&x301, &x302, x300, x288, x285); + fiat_p384_scalar_addcarryx_u64(&x303, &x304, x302, x286, x283); + fiat_p384_scalar_addcarryx_u64(&x305, &x306, 0x0, x271, x293); + fiat_p384_scalar_addcarryx_u64(&x307, &x308, x306, x273, x295); + fiat_p384_scalar_addcarryx_u64(&x309, &x310, x308, x275, x297); + fiat_p384_scalar_addcarryx_u64(&x311, &x312, x310, x277, x299); + fiat_p384_scalar_addcarryx_u64(&x313, &x314, x312, x279, x301); + fiat_p384_scalar_addcarryx_u64(&x315, &x316, x314, x281, x303); + fiat_p384_scalar_mulx_u64(&x317, &x318, x305, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x319, &x320, x317, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x321, &x322, x317, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x323, &x324, x317, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x325, &x326, x317, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x327, &x328, x317, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x329, &x330, x317, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x331, &x332, 0x0, x330, x327); + fiat_p384_scalar_addcarryx_u64(&x333, &x334, x332, x328, x325); + fiat_p384_scalar_addcarryx_u64(&x335, &x336, x334, x326, x323); + fiat_p384_scalar_addcarryx_u64(&x337, &x338, x336, x324, x321); + fiat_p384_scalar_addcarryx_u64(&x339, &x340, x338, x322, x319); + fiat_p384_scalar_addcarryx_u64(&x341, &x342, 0x0, x305, x329); + fiat_p384_scalar_addcarryx_u64(&x343, &x344, x342, x307, x331); + fiat_p384_scalar_addcarryx_u64(&x345, &x346, x344, x309, x333); + fiat_p384_scalar_addcarryx_u64(&x347, &x348, x346, x311, x335); + fiat_p384_scalar_addcarryx_u64(&x349, &x350, x348, x313, x337); + fiat_p384_scalar_addcarryx_u64(&x351, &x352, x350, x315, x339); + fiat_p384_scalar_addcarryx_u64(&x353, &x354, x352, (((uint64_t)x316 + x282) + (x304 + x284)), (x340 + x320)); + fiat_p384_scalar_mulx_u64(&x355, &x356, x5, UINT64_C(0xc84ee012b39bf21)); + fiat_p384_scalar_mulx_u64(&x357, &x358, x5, UINT64_C(0x3fb05b7a28266895)); + fiat_p384_scalar_mulx_u64(&x359, &x360, x5, UINT64_C(0xd40d49174aab1cc5)); + fiat_p384_scalar_mulx_u64(&x361, &x362, x5, UINT64_C(0xbc3e483afcb82947)); + fiat_p384_scalar_mulx_u64(&x363, &x364, x5, UINT64_C(0xff3d81e5df1aa419)); + fiat_p384_scalar_mulx_u64(&x365, &x366, x5, UINT64_C(0x2d319b2419b409a9)); + fiat_p384_scalar_addcarryx_u64(&x367, &x368, 0x0, x366, x363); + fiat_p384_scalar_addcarryx_u64(&x369, &x370, x368, x364, x361); + fiat_p384_scalar_addcarryx_u64(&x371, &x372, x370, x362, x359); + fiat_p384_scalar_addcarryx_u64(&x373, &x374, x372, x360, x357); + fiat_p384_scalar_addcarryx_u64(&x375, &x376, x374, x358, x355); + fiat_p384_scalar_addcarryx_u64(&x377, &x378, 0x0, x343, x365); + fiat_p384_scalar_addcarryx_u64(&x379, &x380, x378, x345, x367); + fiat_p384_scalar_addcarryx_u64(&x381, &x382, x380, x347, x369); + fiat_p384_scalar_addcarryx_u64(&x383, &x384, x382, x349, x371); + fiat_p384_scalar_addcarryx_u64(&x385, &x386, x384, x351, x373); + fiat_p384_scalar_addcarryx_u64(&x387, &x388, x386, x353, x375); + fiat_p384_scalar_mulx_u64(&x389, &x390, x377, UINT64_C(0x6ed46089e88fdc45)); + fiat_p384_scalar_mulx_u64(&x391, &x392, x389, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x393, &x394, x389, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x395, &x396, x389, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_mulx_u64(&x397, &x398, x389, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_mulx_u64(&x399, &x400, x389, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_mulx_u64(&x401, &x402, x389, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_addcarryx_u64(&x403, &x404, 0x0, x402, x399); + fiat_p384_scalar_addcarryx_u64(&x405, &x406, x404, x400, x397); + fiat_p384_scalar_addcarryx_u64(&x407, &x408, x406, x398, x395); + fiat_p384_scalar_addcarryx_u64(&x409, &x410, x408, x396, x393); + fiat_p384_scalar_addcarryx_u64(&x411, &x412, x410, x394, x391); + fiat_p384_scalar_addcarryx_u64(&x413, &x414, 0x0, x377, x401); + fiat_p384_scalar_addcarryx_u64(&x415, &x416, x414, x379, x403); + fiat_p384_scalar_addcarryx_u64(&x417, &x418, x416, x381, x405); + fiat_p384_scalar_addcarryx_u64(&x419, &x420, x418, x383, x407); + fiat_p384_scalar_addcarryx_u64(&x421, &x422, x420, x385, x409); + fiat_p384_scalar_addcarryx_u64(&x423, &x424, x422, x387, x411); + fiat_p384_scalar_addcarryx_u64(&x425, &x426, x424, (((uint64_t)x388 + x354) + (x376 + x356)), (x412 + x392)); + fiat_p384_scalar_subborrowx_u64(&x427, &x428, 0x0, x415, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_subborrowx_u64(&x429, &x430, x428, x417, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_subborrowx_u64(&x431, &x432, x430, x419, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_subborrowx_u64(&x433, &x434, x432, x421, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x435, &x436, x434, x423, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x437, &x438, x436, x425, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x439, &x440, x438, x426, 0x0); + fiat_p384_scalar_cmovznz_u64(&x441, x440, x427, x415); + fiat_p384_scalar_cmovznz_u64(&x442, x440, x429, x417); + fiat_p384_scalar_cmovznz_u64(&x443, x440, x431, x419); + fiat_p384_scalar_cmovznz_u64(&x444, x440, x433, x421); + fiat_p384_scalar_cmovznz_u64(&x445, x440, x435, x423); + fiat_p384_scalar_cmovznz_u64(&x446, x440, x437, x425); + out1[0] = x441; + out1[1] = x442; + out1[2] = x443; + out1[3] = x444; + out1[4] = x445; + out1[5] = x446; +} + +/* + * The function fiat_p384_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_nonzero(uint64_t* out1, const uint64_t arg1[6]) { + uint64_t x1; + x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | (arg1[5])))))); + *out1 = x1; +} + +/* + * The function fiat_p384_scalar_selectznz is a multi-limb conditional select. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_selectznz(uint64_t out1[6], fiat_p384_scalar_uint1 arg1, const uint64_t arg2[6], const uint64_t arg3[6]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + fiat_p384_scalar_cmovznz_u64(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_p384_scalar_cmovznz_u64(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_p384_scalar_cmovznz_u64(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_p384_scalar_cmovznz_u64(&x4, arg1, (arg2[3]), (arg3[3])); + fiat_p384_scalar_cmovznz_u64(&x5, arg1, (arg2[4]), (arg3[4])); + fiat_p384_scalar_cmovznz_u64(&x6, arg1, (arg2[5]), (arg3[5])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; +} + +/* + * The function fiat_p384_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47] + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_to_bytes(uint8_t out1[48], const uint64_t arg1[6]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint8_t x7; + uint64_t x8; + uint8_t x9; + uint64_t x10; + uint8_t x11; + uint64_t x12; + uint8_t x13; + uint64_t x14; + uint8_t x15; + uint64_t x16; + uint8_t x17; + uint64_t x18; + uint8_t x19; + uint8_t x20; + uint8_t x21; + uint64_t x22; + uint8_t x23; + uint64_t x24; + uint8_t x25; + uint64_t x26; + uint8_t x27; + uint64_t x28; + uint8_t x29; + uint64_t x30; + uint8_t x31; + uint64_t x32; + uint8_t x33; + uint8_t x34; + uint8_t x35; + uint64_t x36; + uint8_t x37; + uint64_t x38; + uint8_t x39; + uint64_t x40; + uint8_t x41; + uint64_t x42; + uint8_t x43; + uint64_t x44; + uint8_t x45; + uint64_t x46; + uint8_t x47; + uint8_t x48; + uint8_t x49; + uint64_t x50; + uint8_t x51; + uint64_t x52; + uint8_t x53; + uint64_t x54; + uint8_t x55; + uint64_t x56; + uint8_t x57; + uint64_t x58; + uint8_t x59; + uint64_t x60; + uint8_t x61; + uint8_t x62; + uint8_t x63; + uint64_t x64; + uint8_t x65; + uint64_t x66; + uint8_t x67; + uint64_t x68; + uint8_t x69; + uint64_t x70; + uint8_t x71; + uint64_t x72; + uint8_t x73; + uint64_t x74; + uint8_t x75; + uint8_t x76; + uint8_t x77; + uint64_t x78; + uint8_t x79; + uint64_t x80; + uint8_t x81; + uint64_t x82; + uint8_t x83; + uint64_t x84; + uint8_t x85; + uint64_t x86; + uint8_t x87; + uint64_t x88; + uint8_t x89; + uint8_t x90; + x1 = (arg1[5]); + x2 = (arg1[4]); + x3 = (arg1[3]); + x4 = (arg1[2]); + x5 = (arg1[1]); + x6 = (arg1[0]); + x7 = (uint8_t)(x6 & UINT8_C(0xff)); + x8 = (x6 >> 8); + x9 = (uint8_t)(x8 & UINT8_C(0xff)); + x10 = (x8 >> 8); + x11 = (uint8_t)(x10 & UINT8_C(0xff)); + x12 = (x10 >> 8); + x13 = (uint8_t)(x12 & UINT8_C(0xff)); + x14 = (x12 >> 8); + x15 = (uint8_t)(x14 & UINT8_C(0xff)); + x16 = (x14 >> 8); + x17 = (uint8_t)(x16 & UINT8_C(0xff)); + x18 = (x16 >> 8); + x19 = (uint8_t)(x18 & UINT8_C(0xff)); + x20 = (uint8_t)(x18 >> 8); + x21 = (uint8_t)(x5 & UINT8_C(0xff)); + x22 = (x5 >> 8); + x23 = (uint8_t)(x22 & UINT8_C(0xff)); + x24 = (x22 >> 8); + x25 = (uint8_t)(x24 & UINT8_C(0xff)); + x26 = (x24 >> 8); + x27 = (uint8_t)(x26 & UINT8_C(0xff)); + x28 = (x26 >> 8); + x29 = (uint8_t)(x28 & UINT8_C(0xff)); + x30 = (x28 >> 8); + x31 = (uint8_t)(x30 & UINT8_C(0xff)); + x32 = (x30 >> 8); + x33 = (uint8_t)(x32 & UINT8_C(0xff)); + x34 = (uint8_t)(x32 >> 8); + x35 = (uint8_t)(x4 & UINT8_C(0xff)); + x36 = (x4 >> 8); + x37 = (uint8_t)(x36 & UINT8_C(0xff)); + x38 = (x36 >> 8); + x39 = (uint8_t)(x38 & UINT8_C(0xff)); + x40 = (x38 >> 8); + x41 = (uint8_t)(x40 & UINT8_C(0xff)); + x42 = (x40 >> 8); + x43 = (uint8_t)(x42 & UINT8_C(0xff)); + x44 = (x42 >> 8); + x45 = (uint8_t)(x44 & UINT8_C(0xff)); + x46 = (x44 >> 8); + x47 = (uint8_t)(x46 & UINT8_C(0xff)); + x48 = (uint8_t)(x46 >> 8); + x49 = (uint8_t)(x3 & UINT8_C(0xff)); + x50 = (x3 >> 8); + x51 = (uint8_t)(x50 & UINT8_C(0xff)); + x52 = (x50 >> 8); + x53 = (uint8_t)(x52 & UINT8_C(0xff)); + x54 = (x52 >> 8); + x55 = (uint8_t)(x54 & UINT8_C(0xff)); + x56 = (x54 >> 8); + x57 = (uint8_t)(x56 & UINT8_C(0xff)); + x58 = (x56 >> 8); + x59 = (uint8_t)(x58 & UINT8_C(0xff)); + x60 = (x58 >> 8); + x61 = (uint8_t)(x60 & UINT8_C(0xff)); + x62 = (uint8_t)(x60 >> 8); + x63 = (uint8_t)(x2 & UINT8_C(0xff)); + x64 = (x2 >> 8); + x65 = (uint8_t)(x64 & UINT8_C(0xff)); + x66 = (x64 >> 8); + x67 = (uint8_t)(x66 & UINT8_C(0xff)); + x68 = (x66 >> 8); + x69 = (uint8_t)(x68 & UINT8_C(0xff)); + x70 = (x68 >> 8); + x71 = (uint8_t)(x70 & UINT8_C(0xff)); + x72 = (x70 >> 8); + x73 = (uint8_t)(x72 & UINT8_C(0xff)); + x74 = (x72 >> 8); + x75 = (uint8_t)(x74 & UINT8_C(0xff)); + x76 = (uint8_t)(x74 >> 8); + x77 = (uint8_t)(x1 & UINT8_C(0xff)); + x78 = (x1 >> 8); + x79 = (uint8_t)(x78 & UINT8_C(0xff)); + x80 = (x78 >> 8); + x81 = (uint8_t)(x80 & UINT8_C(0xff)); + x82 = (x80 >> 8); + x83 = (uint8_t)(x82 & UINT8_C(0xff)); + x84 = (x82 >> 8); + x85 = (uint8_t)(x84 & UINT8_C(0xff)); + x86 = (x84 >> 8); + x87 = (uint8_t)(x86 & UINT8_C(0xff)); + x88 = (x86 >> 8); + x89 = (uint8_t)(x88 & UINT8_C(0xff)); + x90 = (uint8_t)(x88 >> 8); + out1[0] = x7; + out1[1] = x9; + out1[2] = x11; + out1[3] = x13; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x27; + out1[12] = x29; + out1[13] = x31; + out1[14] = x33; + out1[15] = x34; + out1[16] = x35; + out1[17] = x37; + out1[18] = x39; + out1[19] = x41; + out1[20] = x43; + out1[21] = x45; + out1[22] = x47; + out1[23] = x48; + out1[24] = x49; + out1[25] = x51; + out1[26] = x53; + out1[27] = x55; + out1[28] = x57; + out1[29] = x59; + out1[30] = x61; + out1[31] = x62; + out1[32] = x63; + out1[33] = x65; + out1[34] = x67; + out1[35] = x69; + out1[36] = x71; + out1[37] = x73; + out1[38] = x75; + out1[39] = x76; + out1[40] = x77; + out1[41] = x79; + out1[42] = x81; + out1[43] = x83; + out1[44] = x85; + out1[45] = x87; + out1[46] = x89; + out1[47] = x90; +} + +/* + * The function fiat_p384_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. + * + * Preconditions: + * 0 ≤ bytes_eval arg1 < m + * Postconditions: + * eval out1 mod m = bytes_eval arg1 mod m + * 0 ≤ eval out1 < m + * + * Input Bounds: + * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_from_bytes(uint64_t out1[6], const uint8_t arg1[48]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint8_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint8_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint8_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint8_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint8_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + uint8_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + uint64_t x54; + uint64_t x55; + uint64_t x56; + uint64_t x57; + uint64_t x58; + uint64_t x59; + uint64_t x60; + uint64_t x61; + uint64_t x62; + uint64_t x63; + uint64_t x64; + uint64_t x65; + uint64_t x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + uint64_t x81; + uint64_t x82; + uint64_t x83; + uint64_t x84; + uint64_t x85; + uint64_t x86; + uint64_t x87; + uint64_t x88; + uint64_t x89; + uint64_t x90; + x1 = ((uint64_t)(arg1[47]) << 56); + x2 = ((uint64_t)(arg1[46]) << 48); + x3 = ((uint64_t)(arg1[45]) << 40); + x4 = ((uint64_t)(arg1[44]) << 32); + x5 = ((uint64_t)(arg1[43]) << 24); + x6 = ((uint64_t)(arg1[42]) << 16); + x7 = ((uint64_t)(arg1[41]) << 8); + x8 = (arg1[40]); + x9 = ((uint64_t)(arg1[39]) << 56); + x10 = ((uint64_t)(arg1[38]) << 48); + x11 = ((uint64_t)(arg1[37]) << 40); + x12 = ((uint64_t)(arg1[36]) << 32); + x13 = ((uint64_t)(arg1[35]) << 24); + x14 = ((uint64_t)(arg1[34]) << 16); + x15 = ((uint64_t)(arg1[33]) << 8); + x16 = (arg1[32]); + x17 = ((uint64_t)(arg1[31]) << 56); + x18 = ((uint64_t)(arg1[30]) << 48); + x19 = ((uint64_t)(arg1[29]) << 40); + x20 = ((uint64_t)(arg1[28]) << 32); + x21 = ((uint64_t)(arg1[27]) << 24); + x22 = ((uint64_t)(arg1[26]) << 16); + x23 = ((uint64_t)(arg1[25]) << 8); + x24 = (arg1[24]); + x25 = ((uint64_t)(arg1[23]) << 56); + x26 = ((uint64_t)(arg1[22]) << 48); + x27 = ((uint64_t)(arg1[21]) << 40); + x28 = ((uint64_t)(arg1[20]) << 32); + x29 = ((uint64_t)(arg1[19]) << 24); + x30 = ((uint64_t)(arg1[18]) << 16); + x31 = ((uint64_t)(arg1[17]) << 8); + x32 = (arg1[16]); + x33 = ((uint64_t)(arg1[15]) << 56); + x34 = ((uint64_t)(arg1[14]) << 48); + x35 = ((uint64_t)(arg1[13]) << 40); + x36 = ((uint64_t)(arg1[12]) << 32); + x37 = ((uint64_t)(arg1[11]) << 24); + x38 = ((uint64_t)(arg1[10]) << 16); + x39 = ((uint64_t)(arg1[9]) << 8); + x40 = (arg1[8]); + x41 = ((uint64_t)(arg1[7]) << 56); + x42 = ((uint64_t)(arg1[6]) << 48); + x43 = ((uint64_t)(arg1[5]) << 40); + x44 = ((uint64_t)(arg1[4]) << 32); + x45 = ((uint64_t)(arg1[3]) << 24); + x46 = ((uint64_t)(arg1[2]) << 16); + x47 = ((uint64_t)(arg1[1]) << 8); + x48 = (arg1[0]); + x49 = (x47 + (uint64_t)x48); + x50 = (x46 + x49); + x51 = (x45 + x50); + x52 = (x44 + x51); + x53 = (x43 + x52); + x54 = (x42 + x53); + x55 = (x41 + x54); + x56 = (x39 + (uint64_t)x40); + x57 = (x38 + x56); + x58 = (x37 + x57); + x59 = (x36 + x58); + x60 = (x35 + x59); + x61 = (x34 + x60); + x62 = (x33 + x61); + x63 = (x31 + (uint64_t)x32); + x64 = (x30 + x63); + x65 = (x29 + x64); + x66 = (x28 + x65); + x67 = (x27 + x66); + x68 = (x26 + x67); + x69 = (x25 + x68); + x70 = (x23 + (uint64_t)x24); + x71 = (x22 + x70); + x72 = (x21 + x71); + x73 = (x20 + x72); + x74 = (x19 + x73); + x75 = (x18 + x74); + x76 = (x17 + x75); + x77 = (x15 + (uint64_t)x16); + x78 = (x14 + x77); + x79 = (x13 + x78); + x80 = (x12 + x79); + x81 = (x11 + x80); + x82 = (x10 + x81); + x83 = (x9 + x82); + x84 = (x7 + (uint64_t)x8); + x85 = (x6 + x84); + x86 = (x5 + x85); + x87 = (x4 + x86); + x88 = (x3 + x87); + x89 = (x2 + x88); + x90 = (x1 + x89); + out1[0] = x55; + out1[1] = x62; + out1[2] = x69; + out1[3] = x76; + out1[4] = x83; + out1[5] = x90; +} + +/* + * The function fiat_p384_scalar_set_one returns the field element one in the Montgomery domain. + * + * Postconditions: + * eval (from_montgomery out1) mod m = 1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_set_one(fiat_p384_scalar_montgomery_domain_field_element out1) { + out1[0] = UINT64_C(0x1313e695333ad68d); + out1[1] = UINT64_C(0xa7e5f24db74f5885); + out1[2] = UINT64_C(0x389cb27e0bc8d220); + out1[3] = 0x0; + out1[4] = 0x0; + out1[5] = 0x0; +} + +/* + * The function fiat_p384_scalar_msat returns the saturated representation of the prime modulus. + * + * Postconditions: + * twos_complement_eval out1 = m + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_msat(uint64_t out1[7]) { + out1[0] = UINT64_C(0xecec196accc52973); + out1[1] = UINT64_C(0x581a0db248b0a77a); + out1[2] = UINT64_C(0xc7634d81f4372ddf); + out1[3] = UINT64_C(0xffffffffffffffff); + out1[4] = UINT64_C(0xffffffffffffffff); + out1[5] = UINT64_C(0xffffffffffffffff); + out1[6] = 0x0; +} + +/* + * The function fiat_p384_scalar_divstep computes a divstep. + * + * Preconditions: + * 0 ≤ eval arg4 < m + * 0 ≤ eval arg5 < m + * Postconditions: + * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) + * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) + * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) + * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) + * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) + * 0 ≤ eval out5 < m + * 0 ≤ eval out5 < m + * 0 ≤ eval out2 < m + * 0 ≤ eval out3 < m + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffffffffffff] + * arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_divstep(uint64_t* out1, uint64_t out2[7], uint64_t out3[7], uint64_t out4[6], uint64_t out5[6], uint64_t arg1, const uint64_t arg2[7], const uint64_t arg3[7], const uint64_t arg4[6], const uint64_t arg5[6]) { + uint64_t x1; + fiat_p384_scalar_uint1 x2; + fiat_p384_scalar_uint1 x3; + uint64_t x4; + fiat_p384_scalar_uint1 x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + fiat_p384_scalar_uint1 x15; + uint64_t x16; + fiat_p384_scalar_uint1 x17; + uint64_t x18; + fiat_p384_scalar_uint1 x19; + uint64_t x20; + fiat_p384_scalar_uint1 x21; + uint64_t x22; + fiat_p384_scalar_uint1 x23; + uint64_t x24; + fiat_p384_scalar_uint1 x25; + uint64_t x26; + fiat_p384_scalar_uint1 x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint64_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + fiat_p384_scalar_uint1 x42; + uint64_t x43; + fiat_p384_scalar_uint1 x44; + uint64_t x45; + fiat_p384_scalar_uint1 x46; + uint64_t x47; + fiat_p384_scalar_uint1 x48; + uint64_t x49; + fiat_p384_scalar_uint1 x50; + uint64_t x51; + fiat_p384_scalar_uint1 x52; + uint64_t x53; + fiat_p384_scalar_uint1 x54; + uint64_t x55; + fiat_p384_scalar_uint1 x56; + uint64_t x57; + fiat_p384_scalar_uint1 x58; + uint64_t x59; + fiat_p384_scalar_uint1 x60; + uint64_t x61; + fiat_p384_scalar_uint1 x62; + uint64_t x63; + fiat_p384_scalar_uint1 x64; + uint64_t x65; + fiat_p384_scalar_uint1 x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + fiat_p384_scalar_uint1 x74; + uint64_t x75; + fiat_p384_scalar_uint1 x76; + uint64_t x77; + fiat_p384_scalar_uint1 x78; + uint64_t x79; + fiat_p384_scalar_uint1 x80; + uint64_t x81; + fiat_p384_scalar_uint1 x82; + uint64_t x83; + fiat_p384_scalar_uint1 x84; + uint64_t x85; + uint64_t x86; + fiat_p384_scalar_uint1 x87; + uint64_t x88; + fiat_p384_scalar_uint1 x89; + uint64_t x90; + fiat_p384_scalar_uint1 x91; + uint64_t x92; + fiat_p384_scalar_uint1 x93; + uint64_t x94; + fiat_p384_scalar_uint1 x95; + uint64_t x96; + fiat_p384_scalar_uint1 x97; + uint64_t x98; + uint64_t x99; + uint64_t x100; + uint64_t x101; + uint64_t x102; + uint64_t x103; + fiat_p384_scalar_uint1 x104; + uint64_t x105; + uint64_t x106; + uint64_t x107; + uint64_t x108; + uint64_t x109; + uint64_t x110; + uint64_t x111; + uint64_t x112; + fiat_p384_scalar_uint1 x113; + uint64_t x114; + fiat_p384_scalar_uint1 x115; + uint64_t x116; + fiat_p384_scalar_uint1 x117; + uint64_t x118; + fiat_p384_scalar_uint1 x119; + uint64_t x120; + fiat_p384_scalar_uint1 x121; + uint64_t x122; + fiat_p384_scalar_uint1 x123; + uint64_t x124; + fiat_p384_scalar_uint1 x125; + uint64_t x126; + uint64_t x127; + uint64_t x128; + uint64_t x129; + uint64_t x130; + uint64_t x131; + uint64_t x132; + fiat_p384_scalar_uint1 x133; + uint64_t x134; + fiat_p384_scalar_uint1 x135; + uint64_t x136; + fiat_p384_scalar_uint1 x137; + uint64_t x138; + fiat_p384_scalar_uint1 x139; + uint64_t x140; + fiat_p384_scalar_uint1 x141; + uint64_t x142; + fiat_p384_scalar_uint1 x143; + uint64_t x144; + fiat_p384_scalar_uint1 x145; + uint64_t x146; + fiat_p384_scalar_uint1 x147; + uint64_t x148; + fiat_p384_scalar_uint1 x149; + uint64_t x150; + fiat_p384_scalar_uint1 x151; + uint64_t x152; + fiat_p384_scalar_uint1 x153; + uint64_t x154; + fiat_p384_scalar_uint1 x155; + uint64_t x156; + fiat_p384_scalar_uint1 x157; + uint64_t x158; + fiat_p384_scalar_uint1 x159; + uint64_t x160; + uint64_t x161; + uint64_t x162; + uint64_t x163; + uint64_t x164; + uint64_t x165; + uint64_t x166; + uint64_t x167; + uint64_t x168; + uint64_t x169; + uint64_t x170; + uint64_t x171; + uint64_t x172; + uint64_t x173; + uint64_t x174; + uint64_t x175; + uint64_t x176; + uint64_t x177; + uint64_t x178; + fiat_p384_scalar_addcarryx_u64(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_p384_scalar_uint1)((fiat_p384_scalar_uint1)(x1 >> 63) & (fiat_p384_scalar_uint1)((arg3[0]) & 0x1)); + fiat_p384_scalar_addcarryx_u64(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_p384_scalar_cmovznz_u64(&x6, x3, arg1, x4); + fiat_p384_scalar_cmovznz_u64(&x7, x3, (arg2[0]), (arg3[0])); + fiat_p384_scalar_cmovznz_u64(&x8, x3, (arg2[1]), (arg3[1])); + fiat_p384_scalar_cmovznz_u64(&x9, x3, (arg2[2]), (arg3[2])); + fiat_p384_scalar_cmovznz_u64(&x10, x3, (arg2[3]), (arg3[3])); + fiat_p384_scalar_cmovznz_u64(&x11, x3, (arg2[4]), (arg3[4])); + fiat_p384_scalar_cmovznz_u64(&x12, x3, (arg2[5]), (arg3[5])); + fiat_p384_scalar_cmovznz_u64(&x13, x3, (arg2[6]), (arg3[6])); + fiat_p384_scalar_addcarryx_u64(&x14, &x15, 0x0, 0x1, (~(arg2[0]))); + fiat_p384_scalar_addcarryx_u64(&x16, &x17, x15, 0x0, (~(arg2[1]))); + fiat_p384_scalar_addcarryx_u64(&x18, &x19, x17, 0x0, (~(arg2[2]))); + fiat_p384_scalar_addcarryx_u64(&x20, &x21, x19, 0x0, (~(arg2[3]))); + fiat_p384_scalar_addcarryx_u64(&x22, &x23, x21, 0x0, (~(arg2[4]))); + fiat_p384_scalar_addcarryx_u64(&x24, &x25, x23, 0x0, (~(arg2[5]))); + fiat_p384_scalar_addcarryx_u64(&x26, &x27, x25, 0x0, (~(arg2[6]))); + fiat_p384_scalar_cmovznz_u64(&x28, x3, (arg3[0]), x14); + fiat_p384_scalar_cmovznz_u64(&x29, x3, (arg3[1]), x16); + fiat_p384_scalar_cmovznz_u64(&x30, x3, (arg3[2]), x18); + fiat_p384_scalar_cmovznz_u64(&x31, x3, (arg3[3]), x20); + fiat_p384_scalar_cmovznz_u64(&x32, x3, (arg3[4]), x22); + fiat_p384_scalar_cmovznz_u64(&x33, x3, (arg3[5]), x24); + fiat_p384_scalar_cmovznz_u64(&x34, x3, (arg3[6]), x26); + fiat_p384_scalar_cmovznz_u64(&x35, x3, (arg4[0]), (arg5[0])); + fiat_p384_scalar_cmovznz_u64(&x36, x3, (arg4[1]), (arg5[1])); + fiat_p384_scalar_cmovznz_u64(&x37, x3, (arg4[2]), (arg5[2])); + fiat_p384_scalar_cmovznz_u64(&x38, x3, (arg4[3]), (arg5[3])); + fiat_p384_scalar_cmovznz_u64(&x39, x3, (arg4[4]), (arg5[4])); + fiat_p384_scalar_cmovznz_u64(&x40, x3, (arg4[5]), (arg5[5])); + fiat_p384_scalar_addcarryx_u64(&x41, &x42, 0x0, x35, x35); + fiat_p384_scalar_addcarryx_u64(&x43, &x44, x42, x36, x36); + fiat_p384_scalar_addcarryx_u64(&x45, &x46, x44, x37, x37); + fiat_p384_scalar_addcarryx_u64(&x47, &x48, x46, x38, x38); + fiat_p384_scalar_addcarryx_u64(&x49, &x50, x48, x39, x39); + fiat_p384_scalar_addcarryx_u64(&x51, &x52, x50, x40, x40); + fiat_p384_scalar_subborrowx_u64(&x53, &x54, 0x0, x41, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_subborrowx_u64(&x55, &x56, x54, x43, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_subborrowx_u64(&x57, &x58, x56, x45, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_subborrowx_u64(&x59, &x60, x58, x47, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x61, &x62, x60, x49, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x63, &x64, x62, x51, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x65, &x66, x64, x52, 0x0); + x67 = (arg4[5]); + x68 = (arg4[4]); + x69 = (arg4[3]); + x70 = (arg4[2]); + x71 = (arg4[1]); + x72 = (arg4[0]); + fiat_p384_scalar_subborrowx_u64(&x73, &x74, 0x0, 0x0, x72); + fiat_p384_scalar_subborrowx_u64(&x75, &x76, x74, 0x0, x71); + fiat_p384_scalar_subborrowx_u64(&x77, &x78, x76, 0x0, x70); + fiat_p384_scalar_subborrowx_u64(&x79, &x80, x78, 0x0, x69); + fiat_p384_scalar_subborrowx_u64(&x81, &x82, x80, 0x0, x68); + fiat_p384_scalar_subborrowx_u64(&x83, &x84, x82, 0x0, x67); + fiat_p384_scalar_cmovznz_u64(&x85, x84, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_addcarryx_u64(&x86, &x87, 0x0, x73, (x85 & UINT64_C(0xecec196accc52973))); + fiat_p384_scalar_addcarryx_u64(&x88, &x89, x87, x75, (x85 & UINT64_C(0x581a0db248b0a77a))); + fiat_p384_scalar_addcarryx_u64(&x90, &x91, x89, x77, (x85 & UINT64_C(0xc7634d81f4372ddf))); + fiat_p384_scalar_addcarryx_u64(&x92, &x93, x91, x79, x85); + fiat_p384_scalar_addcarryx_u64(&x94, &x95, x93, x81, x85); + fiat_p384_scalar_addcarryx_u64(&x96, &x97, x95, x83, x85); + fiat_p384_scalar_cmovznz_u64(&x98, x3, (arg5[0]), x86); + fiat_p384_scalar_cmovznz_u64(&x99, x3, (arg5[1]), x88); + fiat_p384_scalar_cmovznz_u64(&x100, x3, (arg5[2]), x90); + fiat_p384_scalar_cmovznz_u64(&x101, x3, (arg5[3]), x92); + fiat_p384_scalar_cmovznz_u64(&x102, x3, (arg5[4]), x94); + fiat_p384_scalar_cmovznz_u64(&x103, x3, (arg5[5]), x96); + x104 = (fiat_p384_scalar_uint1)(x28 & 0x1); + fiat_p384_scalar_cmovznz_u64(&x105, x104, 0x0, x7); + fiat_p384_scalar_cmovznz_u64(&x106, x104, 0x0, x8); + fiat_p384_scalar_cmovznz_u64(&x107, x104, 0x0, x9); + fiat_p384_scalar_cmovznz_u64(&x108, x104, 0x0, x10); + fiat_p384_scalar_cmovznz_u64(&x109, x104, 0x0, x11); + fiat_p384_scalar_cmovznz_u64(&x110, x104, 0x0, x12); + fiat_p384_scalar_cmovznz_u64(&x111, x104, 0x0, x13); + fiat_p384_scalar_addcarryx_u64(&x112, &x113, 0x0, x28, x105); + fiat_p384_scalar_addcarryx_u64(&x114, &x115, x113, x29, x106); + fiat_p384_scalar_addcarryx_u64(&x116, &x117, x115, x30, x107); + fiat_p384_scalar_addcarryx_u64(&x118, &x119, x117, x31, x108); + fiat_p384_scalar_addcarryx_u64(&x120, &x121, x119, x32, x109); + fiat_p384_scalar_addcarryx_u64(&x122, &x123, x121, x33, x110); + fiat_p384_scalar_addcarryx_u64(&x124, &x125, x123, x34, x111); + fiat_p384_scalar_cmovznz_u64(&x126, x104, 0x0, x35); + fiat_p384_scalar_cmovznz_u64(&x127, x104, 0x0, x36); + fiat_p384_scalar_cmovznz_u64(&x128, x104, 0x0, x37); + fiat_p384_scalar_cmovznz_u64(&x129, x104, 0x0, x38); + fiat_p384_scalar_cmovznz_u64(&x130, x104, 0x0, x39); + fiat_p384_scalar_cmovznz_u64(&x131, x104, 0x0, x40); + fiat_p384_scalar_addcarryx_u64(&x132, &x133, 0x0, x98, x126); + fiat_p384_scalar_addcarryx_u64(&x134, &x135, x133, x99, x127); + fiat_p384_scalar_addcarryx_u64(&x136, &x137, x135, x100, x128); + fiat_p384_scalar_addcarryx_u64(&x138, &x139, x137, x101, x129); + fiat_p384_scalar_addcarryx_u64(&x140, &x141, x139, x102, x130); + fiat_p384_scalar_addcarryx_u64(&x142, &x143, x141, x103, x131); + fiat_p384_scalar_subborrowx_u64(&x144, &x145, 0x0, x132, UINT64_C(0xecec196accc52973)); + fiat_p384_scalar_subborrowx_u64(&x146, &x147, x145, x134, UINT64_C(0x581a0db248b0a77a)); + fiat_p384_scalar_subborrowx_u64(&x148, &x149, x147, x136, UINT64_C(0xc7634d81f4372ddf)); + fiat_p384_scalar_subborrowx_u64(&x150, &x151, x149, x138, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x152, &x153, x151, x140, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x154, &x155, x153, x142, UINT64_C(0xffffffffffffffff)); + fiat_p384_scalar_subborrowx_u64(&x156, &x157, x155, x143, 0x0); + fiat_p384_scalar_addcarryx_u64(&x158, &x159, 0x0, x6, 0x1); + x160 = ((x112 >> 1) | ((x114 << 63) & UINT64_C(0xffffffffffffffff))); + x161 = ((x114 >> 1) | ((x116 << 63) & UINT64_C(0xffffffffffffffff))); + x162 = ((x116 >> 1) | ((x118 << 63) & UINT64_C(0xffffffffffffffff))); + x163 = ((x118 >> 1) | ((x120 << 63) & UINT64_C(0xffffffffffffffff))); + x164 = ((x120 >> 1) | ((x122 << 63) & UINT64_C(0xffffffffffffffff))); + x165 = ((x122 >> 1) | ((x124 << 63) & UINT64_C(0xffffffffffffffff))); + x166 = ((x124 & UINT64_C(0x8000000000000000)) | (x124 >> 1)); + fiat_p384_scalar_cmovznz_u64(&x167, x66, x53, x41); + fiat_p384_scalar_cmovznz_u64(&x168, x66, x55, x43); + fiat_p384_scalar_cmovznz_u64(&x169, x66, x57, x45); + fiat_p384_scalar_cmovznz_u64(&x170, x66, x59, x47); + fiat_p384_scalar_cmovznz_u64(&x171, x66, x61, x49); + fiat_p384_scalar_cmovznz_u64(&x172, x66, x63, x51); + fiat_p384_scalar_cmovznz_u64(&x173, x157, x144, x132); + fiat_p384_scalar_cmovznz_u64(&x174, x157, x146, x134); + fiat_p384_scalar_cmovznz_u64(&x175, x157, x148, x136); + fiat_p384_scalar_cmovznz_u64(&x176, x157, x150, x138); + fiat_p384_scalar_cmovznz_u64(&x177, x157, x152, x140); + fiat_p384_scalar_cmovznz_u64(&x178, x157, x154, x142); + *out1 = x158; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out3[0] = x160; + out3[1] = x161; + out3[2] = x162; + out3[3] = x163; + out3[4] = x164; + out3[5] = x165; + out3[6] = x166; + out4[0] = x167; + out4[1] = x168; + out4[2] = x169; + out4[3] = x170; + out4[4] = x171; + out4[5] = x172; + out5[0] = x173; + out5[1] = x174; + out5[2] = x175; + out5[3] = x176; + out5[4] = x177; + out5[5] = x178; +} + +/* + * The function fiat_p384_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). + * + * Postconditions: + * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P384_SCALAR_FIAT_INLINE void fiat_p384_scalar_divstep_precomp(uint64_t out1[6]) { + out1[0] = UINT64_C(0x49589ae0e6045b6a); + out1[1] = UINT64_C(0x3c9a5352870040ed); + out1[2] = UINT64_C(0xdacb097e977dc242); + out1[3] = UINT64_C(0xb5ab30a6d1ecbe36); + out1[4] = UINT64_C(0x97d7a1081f959973); + out1[5] = UINT64_C(0x2ba012f8d27192bc); +} diff --git a/fiat-c/src/secp256k1_scalar_32.c b/fiat-c/src/secp256k1_scalar_32.c new file mode 100644 index 0000000000..0f720380ef --- /dev/null +++ b/fiat-c/src/secp256k1_scalar_32.c @@ -0,0 +1,5849 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier secp256k1_scalar 32 '2^256 - 432420386565659656852420866394968145599' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: secp256k1_scalar */ +/* machine_wordsize = 32 (from "32") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141 (from "2^256 - 432420386565659656852420866394968145599") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +typedef unsigned char fiat_secp256k1_scalar_uint1; +typedef signed char fiat_secp256k1_scalar_int1; +#if defined(__GNUC__) || defined(__clang__) +# define FIAT_SECP256K1_SCALAR_FIAT_INLINE __inline__ +#else +# define FIAT_SECP256K1_SCALAR_FIAT_INLINE +#endif + +/* The type fiat_secp256k1_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +typedef uint32_t fiat_secp256k1_scalar_montgomery_domain_field_element[8]; + +/* The type fiat_secp256k1_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +typedef uint32_t fiat_secp256k1_scalar_non_montgomery_domain_field_element[8]; + +#if (-1 & 3) != 3 +#error "This code only works on a two's complement system" +#endif + +#if !defined(FIAT_SECP256K1_SCALAR_NO_ASM) && (defined(__GNUC__) || defined(__clang__)) +static __inline__ uint32_t fiat_secp256k1_scalar_value_barrier_u32(uint32_t a) { + __asm__("" : "+r"(a) : /* no inputs */); + return a; +} +#else +# define fiat_secp256k1_scalar_value_barrier_u32(x) (x) +#endif + + +/* + * The function fiat_secp256k1_scalar_addcarryx_u32 is an addition with carry. + * + * Postconditions: + * out1 = (arg1 + arg2 + arg3) mod 2^32 + * out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffff] + * arg3: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_addcarryx_u32(uint32_t* out1, fiat_secp256k1_scalar_uint1* out2, fiat_secp256k1_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + uint64_t x1; + uint32_t x2; + fiat_secp256k1_scalar_uint1 x3; + x1 = ((arg1 + (uint64_t)arg2) + arg3); + x2 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + x3 = (fiat_secp256k1_scalar_uint1)(x1 >> 32); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_secp256k1_scalar_subborrowx_u32 is a subtraction with borrow. + * + * Postconditions: + * out1 = (-arg1 + arg2 + -arg3) mod 2^32 + * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffff] + * arg3: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_subborrowx_u32(uint32_t* out1, fiat_secp256k1_scalar_uint1* out2, fiat_secp256k1_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + int64_t x1; + fiat_secp256k1_scalar_int1 x2; + uint32_t x3; + x1 = ((arg2 - (int64_t)arg1) - arg3); + x2 = (fiat_secp256k1_scalar_int1)(x1 >> 32); + x3 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + *out1 = x3; + *out2 = (fiat_secp256k1_scalar_uint1)(0x0 - x2); +} + +/* + * The function fiat_secp256k1_scalar_mulx_u32 is a multiplication, returning the full double-width result. + * + * Postconditions: + * out1 = (arg1 * arg2) mod 2^32 + * out2 = ⌊arg1 * arg2 / 2^32⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffff] + * arg2: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [0x0 ~> 0xffffffff] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_mulx_u32(uint32_t* out1, uint32_t* out2, uint32_t arg1, uint32_t arg2) { + uint64_t x1; + uint32_t x2; + uint32_t x3; + x1 = ((uint64_t)arg1 * arg2); + x2 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + x3 = (uint32_t)(x1 >> 32); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_secp256k1_scalar_cmovznz_u32 is a single-word conditional move. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffff] + * arg3: [0x0 ~> 0xffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_cmovznz_u32(uint32_t* out1, fiat_secp256k1_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + fiat_secp256k1_scalar_uint1 x1; + uint32_t x2; + uint32_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_secp256k1_scalar_int1)(0x0 - x1) & UINT32_C(0xffffffff)); + x3 = ((fiat_secp256k1_scalar_value_barrier_u32(x2) & arg3) | (fiat_secp256k1_scalar_value_barrier_u32((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_secp256k1_scalar_mul multiplies two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_mul(fiat_secp256k1_scalar_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + fiat_secp256k1_scalar_uint1 x26; + uint32_t x27; + fiat_secp256k1_scalar_uint1 x28; + uint32_t x29; + fiat_secp256k1_scalar_uint1 x30; + uint32_t x31; + fiat_secp256k1_scalar_uint1 x32; + uint32_t x33; + fiat_secp256k1_scalar_uint1 x34; + uint32_t x35; + fiat_secp256k1_scalar_uint1 x36; + uint32_t x37; + fiat_secp256k1_scalar_uint1 x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + uint32_t x53; + uint32_t x54; + uint32_t x55; + uint32_t x56; + uint32_t x57; + uint32_t x58; + fiat_secp256k1_scalar_uint1 x59; + uint32_t x60; + fiat_secp256k1_scalar_uint1 x61; + uint32_t x62; + fiat_secp256k1_scalar_uint1 x63; + uint32_t x64; + fiat_secp256k1_scalar_uint1 x65; + uint32_t x66; + fiat_secp256k1_scalar_uint1 x67; + uint32_t x68; + fiat_secp256k1_scalar_uint1 x69; + uint32_t x70; + fiat_secp256k1_scalar_uint1 x71; + uint32_t x72; + uint32_t x73; + fiat_secp256k1_scalar_uint1 x74; + uint32_t x75; + fiat_secp256k1_scalar_uint1 x76; + uint32_t x77; + fiat_secp256k1_scalar_uint1 x78; + uint32_t x79; + fiat_secp256k1_scalar_uint1 x80; + uint32_t x81; + fiat_secp256k1_scalar_uint1 x82; + uint32_t x83; + fiat_secp256k1_scalar_uint1 x84; + uint32_t x85; + fiat_secp256k1_scalar_uint1 x86; + uint32_t x87; + fiat_secp256k1_scalar_uint1 x88; + uint32_t x89; + fiat_secp256k1_scalar_uint1 x90; + uint32_t x91; + uint32_t x92; + uint32_t x93; + uint32_t x94; + uint32_t x95; + uint32_t x96; + uint32_t x97; + uint32_t x98; + uint32_t x99; + uint32_t x100; + uint32_t x101; + uint32_t x102; + uint32_t x103; + uint32_t x104; + uint32_t x105; + uint32_t x106; + uint32_t x107; + fiat_secp256k1_scalar_uint1 x108; + uint32_t x109; + fiat_secp256k1_scalar_uint1 x110; + uint32_t x111; + fiat_secp256k1_scalar_uint1 x112; + uint32_t x113; + fiat_secp256k1_scalar_uint1 x114; + uint32_t x115; + fiat_secp256k1_scalar_uint1 x116; + uint32_t x117; + fiat_secp256k1_scalar_uint1 x118; + uint32_t x119; + fiat_secp256k1_scalar_uint1 x120; + uint32_t x121; + uint32_t x122; + fiat_secp256k1_scalar_uint1 x123; + uint32_t x124; + fiat_secp256k1_scalar_uint1 x125; + uint32_t x126; + fiat_secp256k1_scalar_uint1 x127; + uint32_t x128; + fiat_secp256k1_scalar_uint1 x129; + uint32_t x130; + fiat_secp256k1_scalar_uint1 x131; + uint32_t x132; + fiat_secp256k1_scalar_uint1 x133; + uint32_t x134; + fiat_secp256k1_scalar_uint1 x135; + uint32_t x136; + fiat_secp256k1_scalar_uint1 x137; + uint32_t x138; + fiat_secp256k1_scalar_uint1 x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + uint32_t x145; + uint32_t x146; + uint32_t x147; + uint32_t x148; + uint32_t x149; + uint32_t x150; + uint32_t x151; + uint32_t x152; + uint32_t x153; + uint32_t x154; + uint32_t x155; + uint32_t x156; + uint32_t x157; + uint32_t x158; + fiat_secp256k1_scalar_uint1 x159; + uint32_t x160; + fiat_secp256k1_scalar_uint1 x161; + uint32_t x162; + fiat_secp256k1_scalar_uint1 x163; + uint32_t x164; + fiat_secp256k1_scalar_uint1 x165; + uint32_t x166; + fiat_secp256k1_scalar_uint1 x167; + uint32_t x168; + fiat_secp256k1_scalar_uint1 x169; + uint32_t x170; + fiat_secp256k1_scalar_uint1 x171; + uint32_t x172; + uint32_t x173; + fiat_secp256k1_scalar_uint1 x174; + uint32_t x175; + fiat_secp256k1_scalar_uint1 x176; + uint32_t x177; + fiat_secp256k1_scalar_uint1 x178; + uint32_t x179; + fiat_secp256k1_scalar_uint1 x180; + uint32_t x181; + fiat_secp256k1_scalar_uint1 x182; + uint32_t x183; + fiat_secp256k1_scalar_uint1 x184; + uint32_t x185; + fiat_secp256k1_scalar_uint1 x186; + uint32_t x187; + fiat_secp256k1_scalar_uint1 x188; + uint32_t x189; + fiat_secp256k1_scalar_uint1 x190; + uint32_t x191; + uint32_t x192; + uint32_t x193; + uint32_t x194; + uint32_t x195; + uint32_t x196; + uint32_t x197; + uint32_t x198; + uint32_t x199; + uint32_t x200; + uint32_t x201; + uint32_t x202; + uint32_t x203; + uint32_t x204; + uint32_t x205; + uint32_t x206; + uint32_t x207; + uint32_t x208; + fiat_secp256k1_scalar_uint1 x209; + uint32_t x210; + fiat_secp256k1_scalar_uint1 x211; + uint32_t x212; + fiat_secp256k1_scalar_uint1 x213; + uint32_t x214; + fiat_secp256k1_scalar_uint1 x215; + uint32_t x216; + fiat_secp256k1_scalar_uint1 x217; + uint32_t x218; + fiat_secp256k1_scalar_uint1 x219; + uint32_t x220; + fiat_secp256k1_scalar_uint1 x221; + uint32_t x222; + uint32_t x223; + fiat_secp256k1_scalar_uint1 x224; + uint32_t x225; + fiat_secp256k1_scalar_uint1 x226; + uint32_t x227; + fiat_secp256k1_scalar_uint1 x228; + uint32_t x229; + fiat_secp256k1_scalar_uint1 x230; + uint32_t x231; + fiat_secp256k1_scalar_uint1 x232; + uint32_t x233; + fiat_secp256k1_scalar_uint1 x234; + uint32_t x235; + fiat_secp256k1_scalar_uint1 x236; + uint32_t x237; + fiat_secp256k1_scalar_uint1 x238; + uint32_t x239; + fiat_secp256k1_scalar_uint1 x240; + uint32_t x241; + uint32_t x242; + uint32_t x243; + uint32_t x244; + uint32_t x245; + uint32_t x246; + uint32_t x247; + uint32_t x248; + uint32_t x249; + uint32_t x250; + uint32_t x251; + uint32_t x252; + uint32_t x253; + uint32_t x254; + uint32_t x255; + uint32_t x256; + uint32_t x257; + uint32_t x258; + uint32_t x259; + fiat_secp256k1_scalar_uint1 x260; + uint32_t x261; + fiat_secp256k1_scalar_uint1 x262; + uint32_t x263; + fiat_secp256k1_scalar_uint1 x264; + uint32_t x265; + fiat_secp256k1_scalar_uint1 x266; + uint32_t x267; + fiat_secp256k1_scalar_uint1 x268; + uint32_t x269; + fiat_secp256k1_scalar_uint1 x270; + uint32_t x271; + fiat_secp256k1_scalar_uint1 x272; + uint32_t x273; + uint32_t x274; + fiat_secp256k1_scalar_uint1 x275; + uint32_t x276; + fiat_secp256k1_scalar_uint1 x277; + uint32_t x278; + fiat_secp256k1_scalar_uint1 x279; + uint32_t x280; + fiat_secp256k1_scalar_uint1 x281; + uint32_t x282; + fiat_secp256k1_scalar_uint1 x283; + uint32_t x284; + fiat_secp256k1_scalar_uint1 x285; + uint32_t x286; + fiat_secp256k1_scalar_uint1 x287; + uint32_t x288; + fiat_secp256k1_scalar_uint1 x289; + uint32_t x290; + fiat_secp256k1_scalar_uint1 x291; + uint32_t x292; + uint32_t x293; + uint32_t x294; + uint32_t x295; + uint32_t x296; + uint32_t x297; + uint32_t x298; + uint32_t x299; + uint32_t x300; + uint32_t x301; + uint32_t x302; + uint32_t x303; + uint32_t x304; + uint32_t x305; + uint32_t x306; + uint32_t x307; + uint32_t x308; + uint32_t x309; + fiat_secp256k1_scalar_uint1 x310; + uint32_t x311; + fiat_secp256k1_scalar_uint1 x312; + uint32_t x313; + fiat_secp256k1_scalar_uint1 x314; + uint32_t x315; + fiat_secp256k1_scalar_uint1 x316; + uint32_t x317; + fiat_secp256k1_scalar_uint1 x318; + uint32_t x319; + fiat_secp256k1_scalar_uint1 x320; + uint32_t x321; + fiat_secp256k1_scalar_uint1 x322; + uint32_t x323; + uint32_t x324; + fiat_secp256k1_scalar_uint1 x325; + uint32_t x326; + fiat_secp256k1_scalar_uint1 x327; + uint32_t x328; + fiat_secp256k1_scalar_uint1 x329; + uint32_t x330; + fiat_secp256k1_scalar_uint1 x331; + uint32_t x332; + fiat_secp256k1_scalar_uint1 x333; + uint32_t x334; + fiat_secp256k1_scalar_uint1 x335; + uint32_t x336; + fiat_secp256k1_scalar_uint1 x337; + uint32_t x338; + fiat_secp256k1_scalar_uint1 x339; + uint32_t x340; + fiat_secp256k1_scalar_uint1 x341; + uint32_t x342; + uint32_t x343; + uint32_t x344; + uint32_t x345; + uint32_t x346; + uint32_t x347; + uint32_t x348; + uint32_t x349; + uint32_t x350; + uint32_t x351; + uint32_t x352; + uint32_t x353; + uint32_t x354; + uint32_t x355; + uint32_t x356; + uint32_t x357; + uint32_t x358; + uint32_t x359; + uint32_t x360; + fiat_secp256k1_scalar_uint1 x361; + uint32_t x362; + fiat_secp256k1_scalar_uint1 x363; + uint32_t x364; + fiat_secp256k1_scalar_uint1 x365; + uint32_t x366; + fiat_secp256k1_scalar_uint1 x367; + uint32_t x368; + fiat_secp256k1_scalar_uint1 x369; + uint32_t x370; + fiat_secp256k1_scalar_uint1 x371; + uint32_t x372; + fiat_secp256k1_scalar_uint1 x373; + uint32_t x374; + uint32_t x375; + fiat_secp256k1_scalar_uint1 x376; + uint32_t x377; + fiat_secp256k1_scalar_uint1 x378; + uint32_t x379; + fiat_secp256k1_scalar_uint1 x380; + uint32_t x381; + fiat_secp256k1_scalar_uint1 x382; + uint32_t x383; + fiat_secp256k1_scalar_uint1 x384; + uint32_t x385; + fiat_secp256k1_scalar_uint1 x386; + uint32_t x387; + fiat_secp256k1_scalar_uint1 x388; + uint32_t x389; + fiat_secp256k1_scalar_uint1 x390; + uint32_t x391; + fiat_secp256k1_scalar_uint1 x392; + uint32_t x393; + uint32_t x394; + uint32_t x395; + uint32_t x396; + uint32_t x397; + uint32_t x398; + uint32_t x399; + uint32_t x400; + uint32_t x401; + uint32_t x402; + uint32_t x403; + uint32_t x404; + uint32_t x405; + uint32_t x406; + uint32_t x407; + uint32_t x408; + uint32_t x409; + uint32_t x410; + fiat_secp256k1_scalar_uint1 x411; + uint32_t x412; + fiat_secp256k1_scalar_uint1 x413; + uint32_t x414; + fiat_secp256k1_scalar_uint1 x415; + uint32_t x416; + fiat_secp256k1_scalar_uint1 x417; + uint32_t x418; + fiat_secp256k1_scalar_uint1 x419; + uint32_t x420; + fiat_secp256k1_scalar_uint1 x421; + uint32_t x422; + fiat_secp256k1_scalar_uint1 x423; + uint32_t x424; + uint32_t x425; + fiat_secp256k1_scalar_uint1 x426; + uint32_t x427; + fiat_secp256k1_scalar_uint1 x428; + uint32_t x429; + fiat_secp256k1_scalar_uint1 x430; + uint32_t x431; + fiat_secp256k1_scalar_uint1 x432; + uint32_t x433; + fiat_secp256k1_scalar_uint1 x434; + uint32_t x435; + fiat_secp256k1_scalar_uint1 x436; + uint32_t x437; + fiat_secp256k1_scalar_uint1 x438; + uint32_t x439; + fiat_secp256k1_scalar_uint1 x440; + uint32_t x441; + fiat_secp256k1_scalar_uint1 x442; + uint32_t x443; + uint32_t x444; + uint32_t x445; + uint32_t x446; + uint32_t x447; + uint32_t x448; + uint32_t x449; + uint32_t x450; + uint32_t x451; + uint32_t x452; + uint32_t x453; + uint32_t x454; + uint32_t x455; + uint32_t x456; + uint32_t x457; + uint32_t x458; + uint32_t x459; + uint32_t x460; + uint32_t x461; + fiat_secp256k1_scalar_uint1 x462; + uint32_t x463; + fiat_secp256k1_scalar_uint1 x464; + uint32_t x465; + fiat_secp256k1_scalar_uint1 x466; + uint32_t x467; + fiat_secp256k1_scalar_uint1 x468; + uint32_t x469; + fiat_secp256k1_scalar_uint1 x470; + uint32_t x471; + fiat_secp256k1_scalar_uint1 x472; + uint32_t x473; + fiat_secp256k1_scalar_uint1 x474; + uint32_t x475; + uint32_t x476; + fiat_secp256k1_scalar_uint1 x477; + uint32_t x478; + fiat_secp256k1_scalar_uint1 x479; + uint32_t x480; + fiat_secp256k1_scalar_uint1 x481; + uint32_t x482; + fiat_secp256k1_scalar_uint1 x483; + uint32_t x484; + fiat_secp256k1_scalar_uint1 x485; + uint32_t x486; + fiat_secp256k1_scalar_uint1 x487; + uint32_t x488; + fiat_secp256k1_scalar_uint1 x489; + uint32_t x490; + fiat_secp256k1_scalar_uint1 x491; + uint32_t x492; + fiat_secp256k1_scalar_uint1 x493; + uint32_t x494; + uint32_t x495; + uint32_t x496; + uint32_t x497; + uint32_t x498; + uint32_t x499; + uint32_t x500; + uint32_t x501; + uint32_t x502; + uint32_t x503; + uint32_t x504; + uint32_t x505; + uint32_t x506; + uint32_t x507; + uint32_t x508; + uint32_t x509; + uint32_t x510; + uint32_t x511; + fiat_secp256k1_scalar_uint1 x512; + uint32_t x513; + fiat_secp256k1_scalar_uint1 x514; + uint32_t x515; + fiat_secp256k1_scalar_uint1 x516; + uint32_t x517; + fiat_secp256k1_scalar_uint1 x518; + uint32_t x519; + fiat_secp256k1_scalar_uint1 x520; + uint32_t x521; + fiat_secp256k1_scalar_uint1 x522; + uint32_t x523; + fiat_secp256k1_scalar_uint1 x524; + uint32_t x525; + uint32_t x526; + fiat_secp256k1_scalar_uint1 x527; + uint32_t x528; + fiat_secp256k1_scalar_uint1 x529; + uint32_t x530; + fiat_secp256k1_scalar_uint1 x531; + uint32_t x532; + fiat_secp256k1_scalar_uint1 x533; + uint32_t x534; + fiat_secp256k1_scalar_uint1 x535; + uint32_t x536; + fiat_secp256k1_scalar_uint1 x537; + uint32_t x538; + fiat_secp256k1_scalar_uint1 x539; + uint32_t x540; + fiat_secp256k1_scalar_uint1 x541; + uint32_t x542; + fiat_secp256k1_scalar_uint1 x543; + uint32_t x544; + uint32_t x545; + uint32_t x546; + uint32_t x547; + uint32_t x548; + uint32_t x549; + uint32_t x550; + uint32_t x551; + uint32_t x552; + uint32_t x553; + uint32_t x554; + uint32_t x555; + uint32_t x556; + uint32_t x557; + uint32_t x558; + uint32_t x559; + uint32_t x560; + uint32_t x561; + uint32_t x562; + fiat_secp256k1_scalar_uint1 x563; + uint32_t x564; + fiat_secp256k1_scalar_uint1 x565; + uint32_t x566; + fiat_secp256k1_scalar_uint1 x567; + uint32_t x568; + fiat_secp256k1_scalar_uint1 x569; + uint32_t x570; + fiat_secp256k1_scalar_uint1 x571; + uint32_t x572; + fiat_secp256k1_scalar_uint1 x573; + uint32_t x574; + fiat_secp256k1_scalar_uint1 x575; + uint32_t x576; + uint32_t x577; + fiat_secp256k1_scalar_uint1 x578; + uint32_t x579; + fiat_secp256k1_scalar_uint1 x580; + uint32_t x581; + fiat_secp256k1_scalar_uint1 x582; + uint32_t x583; + fiat_secp256k1_scalar_uint1 x584; + uint32_t x585; + fiat_secp256k1_scalar_uint1 x586; + uint32_t x587; + fiat_secp256k1_scalar_uint1 x588; + uint32_t x589; + fiat_secp256k1_scalar_uint1 x590; + uint32_t x591; + fiat_secp256k1_scalar_uint1 x592; + uint32_t x593; + fiat_secp256k1_scalar_uint1 x594; + uint32_t x595; + uint32_t x596; + uint32_t x597; + uint32_t x598; + uint32_t x599; + uint32_t x600; + uint32_t x601; + uint32_t x602; + uint32_t x603; + uint32_t x604; + uint32_t x605; + uint32_t x606; + uint32_t x607; + uint32_t x608; + uint32_t x609; + uint32_t x610; + uint32_t x611; + uint32_t x612; + fiat_secp256k1_scalar_uint1 x613; + uint32_t x614; + fiat_secp256k1_scalar_uint1 x615; + uint32_t x616; + fiat_secp256k1_scalar_uint1 x617; + uint32_t x618; + fiat_secp256k1_scalar_uint1 x619; + uint32_t x620; + fiat_secp256k1_scalar_uint1 x621; + uint32_t x622; + fiat_secp256k1_scalar_uint1 x623; + uint32_t x624; + fiat_secp256k1_scalar_uint1 x625; + uint32_t x626; + uint32_t x627; + fiat_secp256k1_scalar_uint1 x628; + uint32_t x629; + fiat_secp256k1_scalar_uint1 x630; + uint32_t x631; + fiat_secp256k1_scalar_uint1 x632; + uint32_t x633; + fiat_secp256k1_scalar_uint1 x634; + uint32_t x635; + fiat_secp256k1_scalar_uint1 x636; + uint32_t x637; + fiat_secp256k1_scalar_uint1 x638; + uint32_t x639; + fiat_secp256k1_scalar_uint1 x640; + uint32_t x641; + fiat_secp256k1_scalar_uint1 x642; + uint32_t x643; + fiat_secp256k1_scalar_uint1 x644; + uint32_t x645; + uint32_t x646; + uint32_t x647; + uint32_t x648; + uint32_t x649; + uint32_t x650; + uint32_t x651; + uint32_t x652; + uint32_t x653; + uint32_t x654; + uint32_t x655; + uint32_t x656; + uint32_t x657; + uint32_t x658; + uint32_t x659; + uint32_t x660; + uint32_t x661; + uint32_t x662; + uint32_t x663; + fiat_secp256k1_scalar_uint1 x664; + uint32_t x665; + fiat_secp256k1_scalar_uint1 x666; + uint32_t x667; + fiat_secp256k1_scalar_uint1 x668; + uint32_t x669; + fiat_secp256k1_scalar_uint1 x670; + uint32_t x671; + fiat_secp256k1_scalar_uint1 x672; + uint32_t x673; + fiat_secp256k1_scalar_uint1 x674; + uint32_t x675; + fiat_secp256k1_scalar_uint1 x676; + uint32_t x677; + uint32_t x678; + fiat_secp256k1_scalar_uint1 x679; + uint32_t x680; + fiat_secp256k1_scalar_uint1 x681; + uint32_t x682; + fiat_secp256k1_scalar_uint1 x683; + uint32_t x684; + fiat_secp256k1_scalar_uint1 x685; + uint32_t x686; + fiat_secp256k1_scalar_uint1 x687; + uint32_t x688; + fiat_secp256k1_scalar_uint1 x689; + uint32_t x690; + fiat_secp256k1_scalar_uint1 x691; + uint32_t x692; + fiat_secp256k1_scalar_uint1 x693; + uint32_t x694; + fiat_secp256k1_scalar_uint1 x695; + uint32_t x696; + uint32_t x697; + uint32_t x698; + uint32_t x699; + uint32_t x700; + uint32_t x701; + uint32_t x702; + uint32_t x703; + uint32_t x704; + uint32_t x705; + uint32_t x706; + uint32_t x707; + uint32_t x708; + uint32_t x709; + uint32_t x710; + uint32_t x711; + uint32_t x712; + uint32_t x713; + fiat_secp256k1_scalar_uint1 x714; + uint32_t x715; + fiat_secp256k1_scalar_uint1 x716; + uint32_t x717; + fiat_secp256k1_scalar_uint1 x718; + uint32_t x719; + fiat_secp256k1_scalar_uint1 x720; + uint32_t x721; + fiat_secp256k1_scalar_uint1 x722; + uint32_t x723; + fiat_secp256k1_scalar_uint1 x724; + uint32_t x725; + fiat_secp256k1_scalar_uint1 x726; + uint32_t x727; + uint32_t x728; + fiat_secp256k1_scalar_uint1 x729; + uint32_t x730; + fiat_secp256k1_scalar_uint1 x731; + uint32_t x732; + fiat_secp256k1_scalar_uint1 x733; + uint32_t x734; + fiat_secp256k1_scalar_uint1 x735; + uint32_t x736; + fiat_secp256k1_scalar_uint1 x737; + uint32_t x738; + fiat_secp256k1_scalar_uint1 x739; + uint32_t x740; + fiat_secp256k1_scalar_uint1 x741; + uint32_t x742; + fiat_secp256k1_scalar_uint1 x743; + uint32_t x744; + fiat_secp256k1_scalar_uint1 x745; + uint32_t x746; + uint32_t x747; + uint32_t x748; + uint32_t x749; + uint32_t x750; + uint32_t x751; + uint32_t x752; + uint32_t x753; + uint32_t x754; + uint32_t x755; + uint32_t x756; + uint32_t x757; + uint32_t x758; + uint32_t x759; + uint32_t x760; + uint32_t x761; + uint32_t x762; + uint32_t x763; + uint32_t x764; + fiat_secp256k1_scalar_uint1 x765; + uint32_t x766; + fiat_secp256k1_scalar_uint1 x767; + uint32_t x768; + fiat_secp256k1_scalar_uint1 x769; + uint32_t x770; + fiat_secp256k1_scalar_uint1 x771; + uint32_t x772; + fiat_secp256k1_scalar_uint1 x773; + uint32_t x774; + fiat_secp256k1_scalar_uint1 x775; + uint32_t x776; + fiat_secp256k1_scalar_uint1 x777; + uint32_t x778; + uint32_t x779; + fiat_secp256k1_scalar_uint1 x780; + uint32_t x781; + fiat_secp256k1_scalar_uint1 x782; + uint32_t x783; + fiat_secp256k1_scalar_uint1 x784; + uint32_t x785; + fiat_secp256k1_scalar_uint1 x786; + uint32_t x787; + fiat_secp256k1_scalar_uint1 x788; + uint32_t x789; + fiat_secp256k1_scalar_uint1 x790; + uint32_t x791; + fiat_secp256k1_scalar_uint1 x792; + uint32_t x793; + fiat_secp256k1_scalar_uint1 x794; + uint32_t x795; + fiat_secp256k1_scalar_uint1 x796; + uint32_t x797; + uint32_t x798; + fiat_secp256k1_scalar_uint1 x799; + uint32_t x800; + fiat_secp256k1_scalar_uint1 x801; + uint32_t x802; + fiat_secp256k1_scalar_uint1 x803; + uint32_t x804; + fiat_secp256k1_scalar_uint1 x805; + uint32_t x806; + fiat_secp256k1_scalar_uint1 x807; + uint32_t x808; + fiat_secp256k1_scalar_uint1 x809; + uint32_t x810; + fiat_secp256k1_scalar_uint1 x811; + uint32_t x812; + fiat_secp256k1_scalar_uint1 x813; + uint32_t x814; + fiat_secp256k1_scalar_uint1 x815; + uint32_t x816; + uint32_t x817; + uint32_t x818; + uint32_t x819; + uint32_t x820; + uint32_t x821; + uint32_t x822; + uint32_t x823; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[6]); + x7 = (arg1[7]); + x8 = (arg1[0]); + fiat_secp256k1_scalar_mulx_u32(&x9, &x10, x8, (arg2[7])); + fiat_secp256k1_scalar_mulx_u32(&x11, &x12, x8, (arg2[6])); + fiat_secp256k1_scalar_mulx_u32(&x13, &x14, x8, (arg2[5])); + fiat_secp256k1_scalar_mulx_u32(&x15, &x16, x8, (arg2[4])); + fiat_secp256k1_scalar_mulx_u32(&x17, &x18, x8, (arg2[3])); + fiat_secp256k1_scalar_mulx_u32(&x19, &x20, x8, (arg2[2])); + fiat_secp256k1_scalar_mulx_u32(&x21, &x22, x8, (arg2[1])); + fiat_secp256k1_scalar_mulx_u32(&x23, &x24, x8, (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_secp256k1_scalar_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_secp256k1_scalar_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_secp256k1_scalar_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_secp256k1_scalar_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_secp256k1_scalar_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_secp256k1_scalar_addcarryx_u32(&x37, &x38, x36, x12, x9); + x39 = (x38 + x10); + fiat_secp256k1_scalar_mulx_u32(&x40, &x41, x23, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x42, &x43, x40, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x44, &x45, x40, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x46, &x47, x40, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x48, &x49, x40, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x50, &x51, x40, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x52, &x53, x40, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x54, &x55, x40, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x56, &x57, x40, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x58, &x59, 0x0, x57, x54); + fiat_secp256k1_scalar_addcarryx_u32(&x60, &x61, x59, x55, x52); + fiat_secp256k1_scalar_addcarryx_u32(&x62, &x63, x61, x53, x50); + fiat_secp256k1_scalar_addcarryx_u32(&x64, &x65, x63, x51, x48); + fiat_secp256k1_scalar_addcarryx_u32(&x66, &x67, x65, x49, x46); + fiat_secp256k1_scalar_addcarryx_u32(&x68, &x69, x67, x47, x44); + fiat_secp256k1_scalar_addcarryx_u32(&x70, &x71, x69, x45, x42); + x72 = (x71 + x43); + fiat_secp256k1_scalar_addcarryx_u32(&x73, &x74, 0x0, x23, x56); + fiat_secp256k1_scalar_addcarryx_u32(&x75, &x76, x74, x25, x58); + fiat_secp256k1_scalar_addcarryx_u32(&x77, &x78, x76, x27, x60); + fiat_secp256k1_scalar_addcarryx_u32(&x79, &x80, x78, x29, x62); + fiat_secp256k1_scalar_addcarryx_u32(&x81, &x82, x80, x31, x64); + fiat_secp256k1_scalar_addcarryx_u32(&x83, &x84, x82, x33, x66); + fiat_secp256k1_scalar_addcarryx_u32(&x85, &x86, x84, x35, x68); + fiat_secp256k1_scalar_addcarryx_u32(&x87, &x88, x86, x37, x70); + fiat_secp256k1_scalar_addcarryx_u32(&x89, &x90, x88, x39, x72); + fiat_secp256k1_scalar_mulx_u32(&x91, &x92, x1, (arg2[7])); + fiat_secp256k1_scalar_mulx_u32(&x93, &x94, x1, (arg2[6])); + fiat_secp256k1_scalar_mulx_u32(&x95, &x96, x1, (arg2[5])); + fiat_secp256k1_scalar_mulx_u32(&x97, &x98, x1, (arg2[4])); + fiat_secp256k1_scalar_mulx_u32(&x99, &x100, x1, (arg2[3])); + fiat_secp256k1_scalar_mulx_u32(&x101, &x102, x1, (arg2[2])); + fiat_secp256k1_scalar_mulx_u32(&x103, &x104, x1, (arg2[1])); + fiat_secp256k1_scalar_mulx_u32(&x105, &x106, x1, (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x107, &x108, 0x0, x106, x103); + fiat_secp256k1_scalar_addcarryx_u32(&x109, &x110, x108, x104, x101); + fiat_secp256k1_scalar_addcarryx_u32(&x111, &x112, x110, x102, x99); + fiat_secp256k1_scalar_addcarryx_u32(&x113, &x114, x112, x100, x97); + fiat_secp256k1_scalar_addcarryx_u32(&x115, &x116, x114, x98, x95); + fiat_secp256k1_scalar_addcarryx_u32(&x117, &x118, x116, x96, x93); + fiat_secp256k1_scalar_addcarryx_u32(&x119, &x120, x118, x94, x91); + x121 = (x120 + x92); + fiat_secp256k1_scalar_addcarryx_u32(&x122, &x123, 0x0, x75, x105); + fiat_secp256k1_scalar_addcarryx_u32(&x124, &x125, x123, x77, x107); + fiat_secp256k1_scalar_addcarryx_u32(&x126, &x127, x125, x79, x109); + fiat_secp256k1_scalar_addcarryx_u32(&x128, &x129, x127, x81, x111); + fiat_secp256k1_scalar_addcarryx_u32(&x130, &x131, x129, x83, x113); + fiat_secp256k1_scalar_addcarryx_u32(&x132, &x133, x131, x85, x115); + fiat_secp256k1_scalar_addcarryx_u32(&x134, &x135, x133, x87, x117); + fiat_secp256k1_scalar_addcarryx_u32(&x136, &x137, x135, x89, x119); + fiat_secp256k1_scalar_addcarryx_u32(&x138, &x139, x137, x90, x121); + fiat_secp256k1_scalar_mulx_u32(&x140, &x141, x122, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x142, &x143, x140, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x144, &x145, x140, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x146, &x147, x140, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x148, &x149, x140, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x150, &x151, x140, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x152, &x153, x140, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x154, &x155, x140, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x156, &x157, x140, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x158, &x159, 0x0, x157, x154); + fiat_secp256k1_scalar_addcarryx_u32(&x160, &x161, x159, x155, x152); + fiat_secp256k1_scalar_addcarryx_u32(&x162, &x163, x161, x153, x150); + fiat_secp256k1_scalar_addcarryx_u32(&x164, &x165, x163, x151, x148); + fiat_secp256k1_scalar_addcarryx_u32(&x166, &x167, x165, x149, x146); + fiat_secp256k1_scalar_addcarryx_u32(&x168, &x169, x167, x147, x144); + fiat_secp256k1_scalar_addcarryx_u32(&x170, &x171, x169, x145, x142); + x172 = (x171 + x143); + fiat_secp256k1_scalar_addcarryx_u32(&x173, &x174, 0x0, x122, x156); + fiat_secp256k1_scalar_addcarryx_u32(&x175, &x176, x174, x124, x158); + fiat_secp256k1_scalar_addcarryx_u32(&x177, &x178, x176, x126, x160); + fiat_secp256k1_scalar_addcarryx_u32(&x179, &x180, x178, x128, x162); + fiat_secp256k1_scalar_addcarryx_u32(&x181, &x182, x180, x130, x164); + fiat_secp256k1_scalar_addcarryx_u32(&x183, &x184, x182, x132, x166); + fiat_secp256k1_scalar_addcarryx_u32(&x185, &x186, x184, x134, x168); + fiat_secp256k1_scalar_addcarryx_u32(&x187, &x188, x186, x136, x170); + fiat_secp256k1_scalar_addcarryx_u32(&x189, &x190, x188, x138, x172); + x191 = ((uint32_t)x190 + x139); + fiat_secp256k1_scalar_mulx_u32(&x192, &x193, x2, (arg2[7])); + fiat_secp256k1_scalar_mulx_u32(&x194, &x195, x2, (arg2[6])); + fiat_secp256k1_scalar_mulx_u32(&x196, &x197, x2, (arg2[5])); + fiat_secp256k1_scalar_mulx_u32(&x198, &x199, x2, (arg2[4])); + fiat_secp256k1_scalar_mulx_u32(&x200, &x201, x2, (arg2[3])); + fiat_secp256k1_scalar_mulx_u32(&x202, &x203, x2, (arg2[2])); + fiat_secp256k1_scalar_mulx_u32(&x204, &x205, x2, (arg2[1])); + fiat_secp256k1_scalar_mulx_u32(&x206, &x207, x2, (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x208, &x209, 0x0, x207, x204); + fiat_secp256k1_scalar_addcarryx_u32(&x210, &x211, x209, x205, x202); + fiat_secp256k1_scalar_addcarryx_u32(&x212, &x213, x211, x203, x200); + fiat_secp256k1_scalar_addcarryx_u32(&x214, &x215, x213, x201, x198); + fiat_secp256k1_scalar_addcarryx_u32(&x216, &x217, x215, x199, x196); + fiat_secp256k1_scalar_addcarryx_u32(&x218, &x219, x217, x197, x194); + fiat_secp256k1_scalar_addcarryx_u32(&x220, &x221, x219, x195, x192); + x222 = (x221 + x193); + fiat_secp256k1_scalar_addcarryx_u32(&x223, &x224, 0x0, x175, x206); + fiat_secp256k1_scalar_addcarryx_u32(&x225, &x226, x224, x177, x208); + fiat_secp256k1_scalar_addcarryx_u32(&x227, &x228, x226, x179, x210); + fiat_secp256k1_scalar_addcarryx_u32(&x229, &x230, x228, x181, x212); + fiat_secp256k1_scalar_addcarryx_u32(&x231, &x232, x230, x183, x214); + fiat_secp256k1_scalar_addcarryx_u32(&x233, &x234, x232, x185, x216); + fiat_secp256k1_scalar_addcarryx_u32(&x235, &x236, x234, x187, x218); + fiat_secp256k1_scalar_addcarryx_u32(&x237, &x238, x236, x189, x220); + fiat_secp256k1_scalar_addcarryx_u32(&x239, &x240, x238, x191, x222); + fiat_secp256k1_scalar_mulx_u32(&x241, &x242, x223, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x243, &x244, x241, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x245, &x246, x241, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x247, &x248, x241, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x249, &x250, x241, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x251, &x252, x241, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x253, &x254, x241, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x255, &x256, x241, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x257, &x258, x241, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x259, &x260, 0x0, x258, x255); + fiat_secp256k1_scalar_addcarryx_u32(&x261, &x262, x260, x256, x253); + fiat_secp256k1_scalar_addcarryx_u32(&x263, &x264, x262, x254, x251); + fiat_secp256k1_scalar_addcarryx_u32(&x265, &x266, x264, x252, x249); + fiat_secp256k1_scalar_addcarryx_u32(&x267, &x268, x266, x250, x247); + fiat_secp256k1_scalar_addcarryx_u32(&x269, &x270, x268, x248, x245); + fiat_secp256k1_scalar_addcarryx_u32(&x271, &x272, x270, x246, x243); + x273 = (x272 + x244); + fiat_secp256k1_scalar_addcarryx_u32(&x274, &x275, 0x0, x223, x257); + fiat_secp256k1_scalar_addcarryx_u32(&x276, &x277, x275, x225, x259); + fiat_secp256k1_scalar_addcarryx_u32(&x278, &x279, x277, x227, x261); + fiat_secp256k1_scalar_addcarryx_u32(&x280, &x281, x279, x229, x263); + fiat_secp256k1_scalar_addcarryx_u32(&x282, &x283, x281, x231, x265); + fiat_secp256k1_scalar_addcarryx_u32(&x284, &x285, x283, x233, x267); + fiat_secp256k1_scalar_addcarryx_u32(&x286, &x287, x285, x235, x269); + fiat_secp256k1_scalar_addcarryx_u32(&x288, &x289, x287, x237, x271); + fiat_secp256k1_scalar_addcarryx_u32(&x290, &x291, x289, x239, x273); + x292 = ((uint32_t)x291 + x240); + fiat_secp256k1_scalar_mulx_u32(&x293, &x294, x3, (arg2[7])); + fiat_secp256k1_scalar_mulx_u32(&x295, &x296, x3, (arg2[6])); + fiat_secp256k1_scalar_mulx_u32(&x297, &x298, x3, (arg2[5])); + fiat_secp256k1_scalar_mulx_u32(&x299, &x300, x3, (arg2[4])); + fiat_secp256k1_scalar_mulx_u32(&x301, &x302, x3, (arg2[3])); + fiat_secp256k1_scalar_mulx_u32(&x303, &x304, x3, (arg2[2])); + fiat_secp256k1_scalar_mulx_u32(&x305, &x306, x3, (arg2[1])); + fiat_secp256k1_scalar_mulx_u32(&x307, &x308, x3, (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x309, &x310, 0x0, x308, x305); + fiat_secp256k1_scalar_addcarryx_u32(&x311, &x312, x310, x306, x303); + fiat_secp256k1_scalar_addcarryx_u32(&x313, &x314, x312, x304, x301); + fiat_secp256k1_scalar_addcarryx_u32(&x315, &x316, x314, x302, x299); + fiat_secp256k1_scalar_addcarryx_u32(&x317, &x318, x316, x300, x297); + fiat_secp256k1_scalar_addcarryx_u32(&x319, &x320, x318, x298, x295); + fiat_secp256k1_scalar_addcarryx_u32(&x321, &x322, x320, x296, x293); + x323 = (x322 + x294); + fiat_secp256k1_scalar_addcarryx_u32(&x324, &x325, 0x0, x276, x307); + fiat_secp256k1_scalar_addcarryx_u32(&x326, &x327, x325, x278, x309); + fiat_secp256k1_scalar_addcarryx_u32(&x328, &x329, x327, x280, x311); + fiat_secp256k1_scalar_addcarryx_u32(&x330, &x331, x329, x282, x313); + fiat_secp256k1_scalar_addcarryx_u32(&x332, &x333, x331, x284, x315); + fiat_secp256k1_scalar_addcarryx_u32(&x334, &x335, x333, x286, x317); + fiat_secp256k1_scalar_addcarryx_u32(&x336, &x337, x335, x288, x319); + fiat_secp256k1_scalar_addcarryx_u32(&x338, &x339, x337, x290, x321); + fiat_secp256k1_scalar_addcarryx_u32(&x340, &x341, x339, x292, x323); + fiat_secp256k1_scalar_mulx_u32(&x342, &x343, x324, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x344, &x345, x342, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x346, &x347, x342, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x348, &x349, x342, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x350, &x351, x342, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x352, &x353, x342, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x354, &x355, x342, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x356, &x357, x342, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x358, &x359, x342, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x360, &x361, 0x0, x359, x356); + fiat_secp256k1_scalar_addcarryx_u32(&x362, &x363, x361, x357, x354); + fiat_secp256k1_scalar_addcarryx_u32(&x364, &x365, x363, x355, x352); + fiat_secp256k1_scalar_addcarryx_u32(&x366, &x367, x365, x353, x350); + fiat_secp256k1_scalar_addcarryx_u32(&x368, &x369, x367, x351, x348); + fiat_secp256k1_scalar_addcarryx_u32(&x370, &x371, x369, x349, x346); + fiat_secp256k1_scalar_addcarryx_u32(&x372, &x373, x371, x347, x344); + x374 = (x373 + x345); + fiat_secp256k1_scalar_addcarryx_u32(&x375, &x376, 0x0, x324, x358); + fiat_secp256k1_scalar_addcarryx_u32(&x377, &x378, x376, x326, x360); + fiat_secp256k1_scalar_addcarryx_u32(&x379, &x380, x378, x328, x362); + fiat_secp256k1_scalar_addcarryx_u32(&x381, &x382, x380, x330, x364); + fiat_secp256k1_scalar_addcarryx_u32(&x383, &x384, x382, x332, x366); + fiat_secp256k1_scalar_addcarryx_u32(&x385, &x386, x384, x334, x368); + fiat_secp256k1_scalar_addcarryx_u32(&x387, &x388, x386, x336, x370); + fiat_secp256k1_scalar_addcarryx_u32(&x389, &x390, x388, x338, x372); + fiat_secp256k1_scalar_addcarryx_u32(&x391, &x392, x390, x340, x374); + x393 = ((uint32_t)x392 + x341); + fiat_secp256k1_scalar_mulx_u32(&x394, &x395, x4, (arg2[7])); + fiat_secp256k1_scalar_mulx_u32(&x396, &x397, x4, (arg2[6])); + fiat_secp256k1_scalar_mulx_u32(&x398, &x399, x4, (arg2[5])); + fiat_secp256k1_scalar_mulx_u32(&x400, &x401, x4, (arg2[4])); + fiat_secp256k1_scalar_mulx_u32(&x402, &x403, x4, (arg2[3])); + fiat_secp256k1_scalar_mulx_u32(&x404, &x405, x4, (arg2[2])); + fiat_secp256k1_scalar_mulx_u32(&x406, &x407, x4, (arg2[1])); + fiat_secp256k1_scalar_mulx_u32(&x408, &x409, x4, (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x410, &x411, 0x0, x409, x406); + fiat_secp256k1_scalar_addcarryx_u32(&x412, &x413, x411, x407, x404); + fiat_secp256k1_scalar_addcarryx_u32(&x414, &x415, x413, x405, x402); + fiat_secp256k1_scalar_addcarryx_u32(&x416, &x417, x415, x403, x400); + fiat_secp256k1_scalar_addcarryx_u32(&x418, &x419, x417, x401, x398); + fiat_secp256k1_scalar_addcarryx_u32(&x420, &x421, x419, x399, x396); + fiat_secp256k1_scalar_addcarryx_u32(&x422, &x423, x421, x397, x394); + x424 = (x423 + x395); + fiat_secp256k1_scalar_addcarryx_u32(&x425, &x426, 0x0, x377, x408); + fiat_secp256k1_scalar_addcarryx_u32(&x427, &x428, x426, x379, x410); + fiat_secp256k1_scalar_addcarryx_u32(&x429, &x430, x428, x381, x412); + fiat_secp256k1_scalar_addcarryx_u32(&x431, &x432, x430, x383, x414); + fiat_secp256k1_scalar_addcarryx_u32(&x433, &x434, x432, x385, x416); + fiat_secp256k1_scalar_addcarryx_u32(&x435, &x436, x434, x387, x418); + fiat_secp256k1_scalar_addcarryx_u32(&x437, &x438, x436, x389, x420); + fiat_secp256k1_scalar_addcarryx_u32(&x439, &x440, x438, x391, x422); + fiat_secp256k1_scalar_addcarryx_u32(&x441, &x442, x440, x393, x424); + fiat_secp256k1_scalar_mulx_u32(&x443, &x444, x425, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x445, &x446, x443, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x447, &x448, x443, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x449, &x450, x443, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x451, &x452, x443, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x453, &x454, x443, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x455, &x456, x443, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x457, &x458, x443, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x459, &x460, x443, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x461, &x462, 0x0, x460, x457); + fiat_secp256k1_scalar_addcarryx_u32(&x463, &x464, x462, x458, x455); + fiat_secp256k1_scalar_addcarryx_u32(&x465, &x466, x464, x456, x453); + fiat_secp256k1_scalar_addcarryx_u32(&x467, &x468, x466, x454, x451); + fiat_secp256k1_scalar_addcarryx_u32(&x469, &x470, x468, x452, x449); + fiat_secp256k1_scalar_addcarryx_u32(&x471, &x472, x470, x450, x447); + fiat_secp256k1_scalar_addcarryx_u32(&x473, &x474, x472, x448, x445); + x475 = (x474 + x446); + fiat_secp256k1_scalar_addcarryx_u32(&x476, &x477, 0x0, x425, x459); + fiat_secp256k1_scalar_addcarryx_u32(&x478, &x479, x477, x427, x461); + fiat_secp256k1_scalar_addcarryx_u32(&x480, &x481, x479, x429, x463); + fiat_secp256k1_scalar_addcarryx_u32(&x482, &x483, x481, x431, x465); + fiat_secp256k1_scalar_addcarryx_u32(&x484, &x485, x483, x433, x467); + fiat_secp256k1_scalar_addcarryx_u32(&x486, &x487, x485, x435, x469); + fiat_secp256k1_scalar_addcarryx_u32(&x488, &x489, x487, x437, x471); + fiat_secp256k1_scalar_addcarryx_u32(&x490, &x491, x489, x439, x473); + fiat_secp256k1_scalar_addcarryx_u32(&x492, &x493, x491, x441, x475); + x494 = ((uint32_t)x493 + x442); + fiat_secp256k1_scalar_mulx_u32(&x495, &x496, x5, (arg2[7])); + fiat_secp256k1_scalar_mulx_u32(&x497, &x498, x5, (arg2[6])); + fiat_secp256k1_scalar_mulx_u32(&x499, &x500, x5, (arg2[5])); + fiat_secp256k1_scalar_mulx_u32(&x501, &x502, x5, (arg2[4])); + fiat_secp256k1_scalar_mulx_u32(&x503, &x504, x5, (arg2[3])); + fiat_secp256k1_scalar_mulx_u32(&x505, &x506, x5, (arg2[2])); + fiat_secp256k1_scalar_mulx_u32(&x507, &x508, x5, (arg2[1])); + fiat_secp256k1_scalar_mulx_u32(&x509, &x510, x5, (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x511, &x512, 0x0, x510, x507); + fiat_secp256k1_scalar_addcarryx_u32(&x513, &x514, x512, x508, x505); + fiat_secp256k1_scalar_addcarryx_u32(&x515, &x516, x514, x506, x503); + fiat_secp256k1_scalar_addcarryx_u32(&x517, &x518, x516, x504, x501); + fiat_secp256k1_scalar_addcarryx_u32(&x519, &x520, x518, x502, x499); + fiat_secp256k1_scalar_addcarryx_u32(&x521, &x522, x520, x500, x497); + fiat_secp256k1_scalar_addcarryx_u32(&x523, &x524, x522, x498, x495); + x525 = (x524 + x496); + fiat_secp256k1_scalar_addcarryx_u32(&x526, &x527, 0x0, x478, x509); + fiat_secp256k1_scalar_addcarryx_u32(&x528, &x529, x527, x480, x511); + fiat_secp256k1_scalar_addcarryx_u32(&x530, &x531, x529, x482, x513); + fiat_secp256k1_scalar_addcarryx_u32(&x532, &x533, x531, x484, x515); + fiat_secp256k1_scalar_addcarryx_u32(&x534, &x535, x533, x486, x517); + fiat_secp256k1_scalar_addcarryx_u32(&x536, &x537, x535, x488, x519); + fiat_secp256k1_scalar_addcarryx_u32(&x538, &x539, x537, x490, x521); + fiat_secp256k1_scalar_addcarryx_u32(&x540, &x541, x539, x492, x523); + fiat_secp256k1_scalar_addcarryx_u32(&x542, &x543, x541, x494, x525); + fiat_secp256k1_scalar_mulx_u32(&x544, &x545, x526, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x546, &x547, x544, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x548, &x549, x544, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x550, &x551, x544, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x552, &x553, x544, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x554, &x555, x544, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x556, &x557, x544, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x558, &x559, x544, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x560, &x561, x544, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x562, &x563, 0x0, x561, x558); + fiat_secp256k1_scalar_addcarryx_u32(&x564, &x565, x563, x559, x556); + fiat_secp256k1_scalar_addcarryx_u32(&x566, &x567, x565, x557, x554); + fiat_secp256k1_scalar_addcarryx_u32(&x568, &x569, x567, x555, x552); + fiat_secp256k1_scalar_addcarryx_u32(&x570, &x571, x569, x553, x550); + fiat_secp256k1_scalar_addcarryx_u32(&x572, &x573, x571, x551, x548); + fiat_secp256k1_scalar_addcarryx_u32(&x574, &x575, x573, x549, x546); + x576 = (x575 + x547); + fiat_secp256k1_scalar_addcarryx_u32(&x577, &x578, 0x0, x526, x560); + fiat_secp256k1_scalar_addcarryx_u32(&x579, &x580, x578, x528, x562); + fiat_secp256k1_scalar_addcarryx_u32(&x581, &x582, x580, x530, x564); + fiat_secp256k1_scalar_addcarryx_u32(&x583, &x584, x582, x532, x566); + fiat_secp256k1_scalar_addcarryx_u32(&x585, &x586, x584, x534, x568); + fiat_secp256k1_scalar_addcarryx_u32(&x587, &x588, x586, x536, x570); + fiat_secp256k1_scalar_addcarryx_u32(&x589, &x590, x588, x538, x572); + fiat_secp256k1_scalar_addcarryx_u32(&x591, &x592, x590, x540, x574); + fiat_secp256k1_scalar_addcarryx_u32(&x593, &x594, x592, x542, x576); + x595 = ((uint32_t)x594 + x543); + fiat_secp256k1_scalar_mulx_u32(&x596, &x597, x6, (arg2[7])); + fiat_secp256k1_scalar_mulx_u32(&x598, &x599, x6, (arg2[6])); + fiat_secp256k1_scalar_mulx_u32(&x600, &x601, x6, (arg2[5])); + fiat_secp256k1_scalar_mulx_u32(&x602, &x603, x6, (arg2[4])); + fiat_secp256k1_scalar_mulx_u32(&x604, &x605, x6, (arg2[3])); + fiat_secp256k1_scalar_mulx_u32(&x606, &x607, x6, (arg2[2])); + fiat_secp256k1_scalar_mulx_u32(&x608, &x609, x6, (arg2[1])); + fiat_secp256k1_scalar_mulx_u32(&x610, &x611, x6, (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x612, &x613, 0x0, x611, x608); + fiat_secp256k1_scalar_addcarryx_u32(&x614, &x615, x613, x609, x606); + fiat_secp256k1_scalar_addcarryx_u32(&x616, &x617, x615, x607, x604); + fiat_secp256k1_scalar_addcarryx_u32(&x618, &x619, x617, x605, x602); + fiat_secp256k1_scalar_addcarryx_u32(&x620, &x621, x619, x603, x600); + fiat_secp256k1_scalar_addcarryx_u32(&x622, &x623, x621, x601, x598); + fiat_secp256k1_scalar_addcarryx_u32(&x624, &x625, x623, x599, x596); + x626 = (x625 + x597); + fiat_secp256k1_scalar_addcarryx_u32(&x627, &x628, 0x0, x579, x610); + fiat_secp256k1_scalar_addcarryx_u32(&x629, &x630, x628, x581, x612); + fiat_secp256k1_scalar_addcarryx_u32(&x631, &x632, x630, x583, x614); + fiat_secp256k1_scalar_addcarryx_u32(&x633, &x634, x632, x585, x616); + fiat_secp256k1_scalar_addcarryx_u32(&x635, &x636, x634, x587, x618); + fiat_secp256k1_scalar_addcarryx_u32(&x637, &x638, x636, x589, x620); + fiat_secp256k1_scalar_addcarryx_u32(&x639, &x640, x638, x591, x622); + fiat_secp256k1_scalar_addcarryx_u32(&x641, &x642, x640, x593, x624); + fiat_secp256k1_scalar_addcarryx_u32(&x643, &x644, x642, x595, x626); + fiat_secp256k1_scalar_mulx_u32(&x645, &x646, x627, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x647, &x648, x645, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x649, &x650, x645, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x651, &x652, x645, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x653, &x654, x645, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x655, &x656, x645, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x657, &x658, x645, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x659, &x660, x645, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x661, &x662, x645, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x663, &x664, 0x0, x662, x659); + fiat_secp256k1_scalar_addcarryx_u32(&x665, &x666, x664, x660, x657); + fiat_secp256k1_scalar_addcarryx_u32(&x667, &x668, x666, x658, x655); + fiat_secp256k1_scalar_addcarryx_u32(&x669, &x670, x668, x656, x653); + fiat_secp256k1_scalar_addcarryx_u32(&x671, &x672, x670, x654, x651); + fiat_secp256k1_scalar_addcarryx_u32(&x673, &x674, x672, x652, x649); + fiat_secp256k1_scalar_addcarryx_u32(&x675, &x676, x674, x650, x647); + x677 = (x676 + x648); + fiat_secp256k1_scalar_addcarryx_u32(&x678, &x679, 0x0, x627, x661); + fiat_secp256k1_scalar_addcarryx_u32(&x680, &x681, x679, x629, x663); + fiat_secp256k1_scalar_addcarryx_u32(&x682, &x683, x681, x631, x665); + fiat_secp256k1_scalar_addcarryx_u32(&x684, &x685, x683, x633, x667); + fiat_secp256k1_scalar_addcarryx_u32(&x686, &x687, x685, x635, x669); + fiat_secp256k1_scalar_addcarryx_u32(&x688, &x689, x687, x637, x671); + fiat_secp256k1_scalar_addcarryx_u32(&x690, &x691, x689, x639, x673); + fiat_secp256k1_scalar_addcarryx_u32(&x692, &x693, x691, x641, x675); + fiat_secp256k1_scalar_addcarryx_u32(&x694, &x695, x693, x643, x677); + x696 = ((uint32_t)x695 + x644); + fiat_secp256k1_scalar_mulx_u32(&x697, &x698, x7, (arg2[7])); + fiat_secp256k1_scalar_mulx_u32(&x699, &x700, x7, (arg2[6])); + fiat_secp256k1_scalar_mulx_u32(&x701, &x702, x7, (arg2[5])); + fiat_secp256k1_scalar_mulx_u32(&x703, &x704, x7, (arg2[4])); + fiat_secp256k1_scalar_mulx_u32(&x705, &x706, x7, (arg2[3])); + fiat_secp256k1_scalar_mulx_u32(&x707, &x708, x7, (arg2[2])); + fiat_secp256k1_scalar_mulx_u32(&x709, &x710, x7, (arg2[1])); + fiat_secp256k1_scalar_mulx_u32(&x711, &x712, x7, (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x713, &x714, 0x0, x712, x709); + fiat_secp256k1_scalar_addcarryx_u32(&x715, &x716, x714, x710, x707); + fiat_secp256k1_scalar_addcarryx_u32(&x717, &x718, x716, x708, x705); + fiat_secp256k1_scalar_addcarryx_u32(&x719, &x720, x718, x706, x703); + fiat_secp256k1_scalar_addcarryx_u32(&x721, &x722, x720, x704, x701); + fiat_secp256k1_scalar_addcarryx_u32(&x723, &x724, x722, x702, x699); + fiat_secp256k1_scalar_addcarryx_u32(&x725, &x726, x724, x700, x697); + x727 = (x726 + x698); + fiat_secp256k1_scalar_addcarryx_u32(&x728, &x729, 0x0, x680, x711); + fiat_secp256k1_scalar_addcarryx_u32(&x730, &x731, x729, x682, x713); + fiat_secp256k1_scalar_addcarryx_u32(&x732, &x733, x731, x684, x715); + fiat_secp256k1_scalar_addcarryx_u32(&x734, &x735, x733, x686, x717); + fiat_secp256k1_scalar_addcarryx_u32(&x736, &x737, x735, x688, x719); + fiat_secp256k1_scalar_addcarryx_u32(&x738, &x739, x737, x690, x721); + fiat_secp256k1_scalar_addcarryx_u32(&x740, &x741, x739, x692, x723); + fiat_secp256k1_scalar_addcarryx_u32(&x742, &x743, x741, x694, x725); + fiat_secp256k1_scalar_addcarryx_u32(&x744, &x745, x743, x696, x727); + fiat_secp256k1_scalar_mulx_u32(&x746, &x747, x728, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x748, &x749, x746, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x750, &x751, x746, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x752, &x753, x746, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x754, &x755, x746, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x756, &x757, x746, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x758, &x759, x746, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x760, &x761, x746, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x762, &x763, x746, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x764, &x765, 0x0, x763, x760); + fiat_secp256k1_scalar_addcarryx_u32(&x766, &x767, x765, x761, x758); + fiat_secp256k1_scalar_addcarryx_u32(&x768, &x769, x767, x759, x756); + fiat_secp256k1_scalar_addcarryx_u32(&x770, &x771, x769, x757, x754); + fiat_secp256k1_scalar_addcarryx_u32(&x772, &x773, x771, x755, x752); + fiat_secp256k1_scalar_addcarryx_u32(&x774, &x775, x773, x753, x750); + fiat_secp256k1_scalar_addcarryx_u32(&x776, &x777, x775, x751, x748); + x778 = (x777 + x749); + fiat_secp256k1_scalar_addcarryx_u32(&x779, &x780, 0x0, x728, x762); + fiat_secp256k1_scalar_addcarryx_u32(&x781, &x782, x780, x730, x764); + fiat_secp256k1_scalar_addcarryx_u32(&x783, &x784, x782, x732, x766); + fiat_secp256k1_scalar_addcarryx_u32(&x785, &x786, x784, x734, x768); + fiat_secp256k1_scalar_addcarryx_u32(&x787, &x788, x786, x736, x770); + fiat_secp256k1_scalar_addcarryx_u32(&x789, &x790, x788, x738, x772); + fiat_secp256k1_scalar_addcarryx_u32(&x791, &x792, x790, x740, x774); + fiat_secp256k1_scalar_addcarryx_u32(&x793, &x794, x792, x742, x776); + fiat_secp256k1_scalar_addcarryx_u32(&x795, &x796, x794, x744, x778); + x797 = ((uint32_t)x796 + x745); + fiat_secp256k1_scalar_subborrowx_u32(&x798, &x799, 0x0, x781, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_subborrowx_u32(&x800, &x801, x799, x783, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_subborrowx_u32(&x802, &x803, x801, x785, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_subborrowx_u32(&x804, &x805, x803, x787, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_subborrowx_u32(&x806, &x807, x805, x789, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_subborrowx_u32(&x808, &x809, x807, x791, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x810, &x811, x809, x793, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x812, &x813, x811, x795, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x814, &x815, x813, x797, 0x0); + fiat_secp256k1_scalar_cmovznz_u32(&x816, x815, x798, x781); + fiat_secp256k1_scalar_cmovznz_u32(&x817, x815, x800, x783); + fiat_secp256k1_scalar_cmovznz_u32(&x818, x815, x802, x785); + fiat_secp256k1_scalar_cmovznz_u32(&x819, x815, x804, x787); + fiat_secp256k1_scalar_cmovznz_u32(&x820, x815, x806, x789); + fiat_secp256k1_scalar_cmovznz_u32(&x821, x815, x808, x791); + fiat_secp256k1_scalar_cmovznz_u32(&x822, x815, x810, x793); + fiat_secp256k1_scalar_cmovznz_u32(&x823, x815, x812, x795); + out1[0] = x816; + out1[1] = x817; + out1[2] = x818; + out1[3] = x819; + out1[4] = x820; + out1[5] = x821; + out1[6] = x822; + out1[7] = x823; +} + +/* + * The function fiat_secp256k1_scalar_square squares a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_square(fiat_secp256k1_scalar_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + fiat_secp256k1_scalar_uint1 x26; + uint32_t x27; + fiat_secp256k1_scalar_uint1 x28; + uint32_t x29; + fiat_secp256k1_scalar_uint1 x30; + uint32_t x31; + fiat_secp256k1_scalar_uint1 x32; + uint32_t x33; + fiat_secp256k1_scalar_uint1 x34; + uint32_t x35; + fiat_secp256k1_scalar_uint1 x36; + uint32_t x37; + fiat_secp256k1_scalar_uint1 x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + uint32_t x53; + uint32_t x54; + uint32_t x55; + uint32_t x56; + uint32_t x57; + uint32_t x58; + fiat_secp256k1_scalar_uint1 x59; + uint32_t x60; + fiat_secp256k1_scalar_uint1 x61; + uint32_t x62; + fiat_secp256k1_scalar_uint1 x63; + uint32_t x64; + fiat_secp256k1_scalar_uint1 x65; + uint32_t x66; + fiat_secp256k1_scalar_uint1 x67; + uint32_t x68; + fiat_secp256k1_scalar_uint1 x69; + uint32_t x70; + fiat_secp256k1_scalar_uint1 x71; + uint32_t x72; + uint32_t x73; + fiat_secp256k1_scalar_uint1 x74; + uint32_t x75; + fiat_secp256k1_scalar_uint1 x76; + uint32_t x77; + fiat_secp256k1_scalar_uint1 x78; + uint32_t x79; + fiat_secp256k1_scalar_uint1 x80; + uint32_t x81; + fiat_secp256k1_scalar_uint1 x82; + uint32_t x83; + fiat_secp256k1_scalar_uint1 x84; + uint32_t x85; + fiat_secp256k1_scalar_uint1 x86; + uint32_t x87; + fiat_secp256k1_scalar_uint1 x88; + uint32_t x89; + fiat_secp256k1_scalar_uint1 x90; + uint32_t x91; + uint32_t x92; + uint32_t x93; + uint32_t x94; + uint32_t x95; + uint32_t x96; + uint32_t x97; + uint32_t x98; + uint32_t x99; + uint32_t x100; + uint32_t x101; + uint32_t x102; + uint32_t x103; + uint32_t x104; + uint32_t x105; + uint32_t x106; + uint32_t x107; + fiat_secp256k1_scalar_uint1 x108; + uint32_t x109; + fiat_secp256k1_scalar_uint1 x110; + uint32_t x111; + fiat_secp256k1_scalar_uint1 x112; + uint32_t x113; + fiat_secp256k1_scalar_uint1 x114; + uint32_t x115; + fiat_secp256k1_scalar_uint1 x116; + uint32_t x117; + fiat_secp256k1_scalar_uint1 x118; + uint32_t x119; + fiat_secp256k1_scalar_uint1 x120; + uint32_t x121; + uint32_t x122; + fiat_secp256k1_scalar_uint1 x123; + uint32_t x124; + fiat_secp256k1_scalar_uint1 x125; + uint32_t x126; + fiat_secp256k1_scalar_uint1 x127; + uint32_t x128; + fiat_secp256k1_scalar_uint1 x129; + uint32_t x130; + fiat_secp256k1_scalar_uint1 x131; + uint32_t x132; + fiat_secp256k1_scalar_uint1 x133; + uint32_t x134; + fiat_secp256k1_scalar_uint1 x135; + uint32_t x136; + fiat_secp256k1_scalar_uint1 x137; + uint32_t x138; + fiat_secp256k1_scalar_uint1 x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + uint32_t x145; + uint32_t x146; + uint32_t x147; + uint32_t x148; + uint32_t x149; + uint32_t x150; + uint32_t x151; + uint32_t x152; + uint32_t x153; + uint32_t x154; + uint32_t x155; + uint32_t x156; + uint32_t x157; + uint32_t x158; + fiat_secp256k1_scalar_uint1 x159; + uint32_t x160; + fiat_secp256k1_scalar_uint1 x161; + uint32_t x162; + fiat_secp256k1_scalar_uint1 x163; + uint32_t x164; + fiat_secp256k1_scalar_uint1 x165; + uint32_t x166; + fiat_secp256k1_scalar_uint1 x167; + uint32_t x168; + fiat_secp256k1_scalar_uint1 x169; + uint32_t x170; + fiat_secp256k1_scalar_uint1 x171; + uint32_t x172; + uint32_t x173; + fiat_secp256k1_scalar_uint1 x174; + uint32_t x175; + fiat_secp256k1_scalar_uint1 x176; + uint32_t x177; + fiat_secp256k1_scalar_uint1 x178; + uint32_t x179; + fiat_secp256k1_scalar_uint1 x180; + uint32_t x181; + fiat_secp256k1_scalar_uint1 x182; + uint32_t x183; + fiat_secp256k1_scalar_uint1 x184; + uint32_t x185; + fiat_secp256k1_scalar_uint1 x186; + uint32_t x187; + fiat_secp256k1_scalar_uint1 x188; + uint32_t x189; + fiat_secp256k1_scalar_uint1 x190; + uint32_t x191; + uint32_t x192; + uint32_t x193; + uint32_t x194; + uint32_t x195; + uint32_t x196; + uint32_t x197; + uint32_t x198; + uint32_t x199; + uint32_t x200; + uint32_t x201; + uint32_t x202; + uint32_t x203; + uint32_t x204; + uint32_t x205; + uint32_t x206; + uint32_t x207; + uint32_t x208; + fiat_secp256k1_scalar_uint1 x209; + uint32_t x210; + fiat_secp256k1_scalar_uint1 x211; + uint32_t x212; + fiat_secp256k1_scalar_uint1 x213; + uint32_t x214; + fiat_secp256k1_scalar_uint1 x215; + uint32_t x216; + fiat_secp256k1_scalar_uint1 x217; + uint32_t x218; + fiat_secp256k1_scalar_uint1 x219; + uint32_t x220; + fiat_secp256k1_scalar_uint1 x221; + uint32_t x222; + uint32_t x223; + fiat_secp256k1_scalar_uint1 x224; + uint32_t x225; + fiat_secp256k1_scalar_uint1 x226; + uint32_t x227; + fiat_secp256k1_scalar_uint1 x228; + uint32_t x229; + fiat_secp256k1_scalar_uint1 x230; + uint32_t x231; + fiat_secp256k1_scalar_uint1 x232; + uint32_t x233; + fiat_secp256k1_scalar_uint1 x234; + uint32_t x235; + fiat_secp256k1_scalar_uint1 x236; + uint32_t x237; + fiat_secp256k1_scalar_uint1 x238; + uint32_t x239; + fiat_secp256k1_scalar_uint1 x240; + uint32_t x241; + uint32_t x242; + uint32_t x243; + uint32_t x244; + uint32_t x245; + uint32_t x246; + uint32_t x247; + uint32_t x248; + uint32_t x249; + uint32_t x250; + uint32_t x251; + uint32_t x252; + uint32_t x253; + uint32_t x254; + uint32_t x255; + uint32_t x256; + uint32_t x257; + uint32_t x258; + uint32_t x259; + fiat_secp256k1_scalar_uint1 x260; + uint32_t x261; + fiat_secp256k1_scalar_uint1 x262; + uint32_t x263; + fiat_secp256k1_scalar_uint1 x264; + uint32_t x265; + fiat_secp256k1_scalar_uint1 x266; + uint32_t x267; + fiat_secp256k1_scalar_uint1 x268; + uint32_t x269; + fiat_secp256k1_scalar_uint1 x270; + uint32_t x271; + fiat_secp256k1_scalar_uint1 x272; + uint32_t x273; + uint32_t x274; + fiat_secp256k1_scalar_uint1 x275; + uint32_t x276; + fiat_secp256k1_scalar_uint1 x277; + uint32_t x278; + fiat_secp256k1_scalar_uint1 x279; + uint32_t x280; + fiat_secp256k1_scalar_uint1 x281; + uint32_t x282; + fiat_secp256k1_scalar_uint1 x283; + uint32_t x284; + fiat_secp256k1_scalar_uint1 x285; + uint32_t x286; + fiat_secp256k1_scalar_uint1 x287; + uint32_t x288; + fiat_secp256k1_scalar_uint1 x289; + uint32_t x290; + fiat_secp256k1_scalar_uint1 x291; + uint32_t x292; + uint32_t x293; + uint32_t x294; + uint32_t x295; + uint32_t x296; + uint32_t x297; + uint32_t x298; + uint32_t x299; + uint32_t x300; + uint32_t x301; + uint32_t x302; + uint32_t x303; + uint32_t x304; + uint32_t x305; + uint32_t x306; + uint32_t x307; + uint32_t x308; + uint32_t x309; + fiat_secp256k1_scalar_uint1 x310; + uint32_t x311; + fiat_secp256k1_scalar_uint1 x312; + uint32_t x313; + fiat_secp256k1_scalar_uint1 x314; + uint32_t x315; + fiat_secp256k1_scalar_uint1 x316; + uint32_t x317; + fiat_secp256k1_scalar_uint1 x318; + uint32_t x319; + fiat_secp256k1_scalar_uint1 x320; + uint32_t x321; + fiat_secp256k1_scalar_uint1 x322; + uint32_t x323; + uint32_t x324; + fiat_secp256k1_scalar_uint1 x325; + uint32_t x326; + fiat_secp256k1_scalar_uint1 x327; + uint32_t x328; + fiat_secp256k1_scalar_uint1 x329; + uint32_t x330; + fiat_secp256k1_scalar_uint1 x331; + uint32_t x332; + fiat_secp256k1_scalar_uint1 x333; + uint32_t x334; + fiat_secp256k1_scalar_uint1 x335; + uint32_t x336; + fiat_secp256k1_scalar_uint1 x337; + uint32_t x338; + fiat_secp256k1_scalar_uint1 x339; + uint32_t x340; + fiat_secp256k1_scalar_uint1 x341; + uint32_t x342; + uint32_t x343; + uint32_t x344; + uint32_t x345; + uint32_t x346; + uint32_t x347; + uint32_t x348; + uint32_t x349; + uint32_t x350; + uint32_t x351; + uint32_t x352; + uint32_t x353; + uint32_t x354; + uint32_t x355; + uint32_t x356; + uint32_t x357; + uint32_t x358; + uint32_t x359; + uint32_t x360; + fiat_secp256k1_scalar_uint1 x361; + uint32_t x362; + fiat_secp256k1_scalar_uint1 x363; + uint32_t x364; + fiat_secp256k1_scalar_uint1 x365; + uint32_t x366; + fiat_secp256k1_scalar_uint1 x367; + uint32_t x368; + fiat_secp256k1_scalar_uint1 x369; + uint32_t x370; + fiat_secp256k1_scalar_uint1 x371; + uint32_t x372; + fiat_secp256k1_scalar_uint1 x373; + uint32_t x374; + uint32_t x375; + fiat_secp256k1_scalar_uint1 x376; + uint32_t x377; + fiat_secp256k1_scalar_uint1 x378; + uint32_t x379; + fiat_secp256k1_scalar_uint1 x380; + uint32_t x381; + fiat_secp256k1_scalar_uint1 x382; + uint32_t x383; + fiat_secp256k1_scalar_uint1 x384; + uint32_t x385; + fiat_secp256k1_scalar_uint1 x386; + uint32_t x387; + fiat_secp256k1_scalar_uint1 x388; + uint32_t x389; + fiat_secp256k1_scalar_uint1 x390; + uint32_t x391; + fiat_secp256k1_scalar_uint1 x392; + uint32_t x393; + uint32_t x394; + uint32_t x395; + uint32_t x396; + uint32_t x397; + uint32_t x398; + uint32_t x399; + uint32_t x400; + uint32_t x401; + uint32_t x402; + uint32_t x403; + uint32_t x404; + uint32_t x405; + uint32_t x406; + uint32_t x407; + uint32_t x408; + uint32_t x409; + uint32_t x410; + fiat_secp256k1_scalar_uint1 x411; + uint32_t x412; + fiat_secp256k1_scalar_uint1 x413; + uint32_t x414; + fiat_secp256k1_scalar_uint1 x415; + uint32_t x416; + fiat_secp256k1_scalar_uint1 x417; + uint32_t x418; + fiat_secp256k1_scalar_uint1 x419; + uint32_t x420; + fiat_secp256k1_scalar_uint1 x421; + uint32_t x422; + fiat_secp256k1_scalar_uint1 x423; + uint32_t x424; + uint32_t x425; + fiat_secp256k1_scalar_uint1 x426; + uint32_t x427; + fiat_secp256k1_scalar_uint1 x428; + uint32_t x429; + fiat_secp256k1_scalar_uint1 x430; + uint32_t x431; + fiat_secp256k1_scalar_uint1 x432; + uint32_t x433; + fiat_secp256k1_scalar_uint1 x434; + uint32_t x435; + fiat_secp256k1_scalar_uint1 x436; + uint32_t x437; + fiat_secp256k1_scalar_uint1 x438; + uint32_t x439; + fiat_secp256k1_scalar_uint1 x440; + uint32_t x441; + fiat_secp256k1_scalar_uint1 x442; + uint32_t x443; + uint32_t x444; + uint32_t x445; + uint32_t x446; + uint32_t x447; + uint32_t x448; + uint32_t x449; + uint32_t x450; + uint32_t x451; + uint32_t x452; + uint32_t x453; + uint32_t x454; + uint32_t x455; + uint32_t x456; + uint32_t x457; + uint32_t x458; + uint32_t x459; + uint32_t x460; + uint32_t x461; + fiat_secp256k1_scalar_uint1 x462; + uint32_t x463; + fiat_secp256k1_scalar_uint1 x464; + uint32_t x465; + fiat_secp256k1_scalar_uint1 x466; + uint32_t x467; + fiat_secp256k1_scalar_uint1 x468; + uint32_t x469; + fiat_secp256k1_scalar_uint1 x470; + uint32_t x471; + fiat_secp256k1_scalar_uint1 x472; + uint32_t x473; + fiat_secp256k1_scalar_uint1 x474; + uint32_t x475; + uint32_t x476; + fiat_secp256k1_scalar_uint1 x477; + uint32_t x478; + fiat_secp256k1_scalar_uint1 x479; + uint32_t x480; + fiat_secp256k1_scalar_uint1 x481; + uint32_t x482; + fiat_secp256k1_scalar_uint1 x483; + uint32_t x484; + fiat_secp256k1_scalar_uint1 x485; + uint32_t x486; + fiat_secp256k1_scalar_uint1 x487; + uint32_t x488; + fiat_secp256k1_scalar_uint1 x489; + uint32_t x490; + fiat_secp256k1_scalar_uint1 x491; + uint32_t x492; + fiat_secp256k1_scalar_uint1 x493; + uint32_t x494; + uint32_t x495; + uint32_t x496; + uint32_t x497; + uint32_t x498; + uint32_t x499; + uint32_t x500; + uint32_t x501; + uint32_t x502; + uint32_t x503; + uint32_t x504; + uint32_t x505; + uint32_t x506; + uint32_t x507; + uint32_t x508; + uint32_t x509; + uint32_t x510; + uint32_t x511; + fiat_secp256k1_scalar_uint1 x512; + uint32_t x513; + fiat_secp256k1_scalar_uint1 x514; + uint32_t x515; + fiat_secp256k1_scalar_uint1 x516; + uint32_t x517; + fiat_secp256k1_scalar_uint1 x518; + uint32_t x519; + fiat_secp256k1_scalar_uint1 x520; + uint32_t x521; + fiat_secp256k1_scalar_uint1 x522; + uint32_t x523; + fiat_secp256k1_scalar_uint1 x524; + uint32_t x525; + uint32_t x526; + fiat_secp256k1_scalar_uint1 x527; + uint32_t x528; + fiat_secp256k1_scalar_uint1 x529; + uint32_t x530; + fiat_secp256k1_scalar_uint1 x531; + uint32_t x532; + fiat_secp256k1_scalar_uint1 x533; + uint32_t x534; + fiat_secp256k1_scalar_uint1 x535; + uint32_t x536; + fiat_secp256k1_scalar_uint1 x537; + uint32_t x538; + fiat_secp256k1_scalar_uint1 x539; + uint32_t x540; + fiat_secp256k1_scalar_uint1 x541; + uint32_t x542; + fiat_secp256k1_scalar_uint1 x543; + uint32_t x544; + uint32_t x545; + uint32_t x546; + uint32_t x547; + uint32_t x548; + uint32_t x549; + uint32_t x550; + uint32_t x551; + uint32_t x552; + uint32_t x553; + uint32_t x554; + uint32_t x555; + uint32_t x556; + uint32_t x557; + uint32_t x558; + uint32_t x559; + uint32_t x560; + uint32_t x561; + uint32_t x562; + fiat_secp256k1_scalar_uint1 x563; + uint32_t x564; + fiat_secp256k1_scalar_uint1 x565; + uint32_t x566; + fiat_secp256k1_scalar_uint1 x567; + uint32_t x568; + fiat_secp256k1_scalar_uint1 x569; + uint32_t x570; + fiat_secp256k1_scalar_uint1 x571; + uint32_t x572; + fiat_secp256k1_scalar_uint1 x573; + uint32_t x574; + fiat_secp256k1_scalar_uint1 x575; + uint32_t x576; + uint32_t x577; + fiat_secp256k1_scalar_uint1 x578; + uint32_t x579; + fiat_secp256k1_scalar_uint1 x580; + uint32_t x581; + fiat_secp256k1_scalar_uint1 x582; + uint32_t x583; + fiat_secp256k1_scalar_uint1 x584; + uint32_t x585; + fiat_secp256k1_scalar_uint1 x586; + uint32_t x587; + fiat_secp256k1_scalar_uint1 x588; + uint32_t x589; + fiat_secp256k1_scalar_uint1 x590; + uint32_t x591; + fiat_secp256k1_scalar_uint1 x592; + uint32_t x593; + fiat_secp256k1_scalar_uint1 x594; + uint32_t x595; + uint32_t x596; + uint32_t x597; + uint32_t x598; + uint32_t x599; + uint32_t x600; + uint32_t x601; + uint32_t x602; + uint32_t x603; + uint32_t x604; + uint32_t x605; + uint32_t x606; + uint32_t x607; + uint32_t x608; + uint32_t x609; + uint32_t x610; + uint32_t x611; + uint32_t x612; + fiat_secp256k1_scalar_uint1 x613; + uint32_t x614; + fiat_secp256k1_scalar_uint1 x615; + uint32_t x616; + fiat_secp256k1_scalar_uint1 x617; + uint32_t x618; + fiat_secp256k1_scalar_uint1 x619; + uint32_t x620; + fiat_secp256k1_scalar_uint1 x621; + uint32_t x622; + fiat_secp256k1_scalar_uint1 x623; + uint32_t x624; + fiat_secp256k1_scalar_uint1 x625; + uint32_t x626; + uint32_t x627; + fiat_secp256k1_scalar_uint1 x628; + uint32_t x629; + fiat_secp256k1_scalar_uint1 x630; + uint32_t x631; + fiat_secp256k1_scalar_uint1 x632; + uint32_t x633; + fiat_secp256k1_scalar_uint1 x634; + uint32_t x635; + fiat_secp256k1_scalar_uint1 x636; + uint32_t x637; + fiat_secp256k1_scalar_uint1 x638; + uint32_t x639; + fiat_secp256k1_scalar_uint1 x640; + uint32_t x641; + fiat_secp256k1_scalar_uint1 x642; + uint32_t x643; + fiat_secp256k1_scalar_uint1 x644; + uint32_t x645; + uint32_t x646; + uint32_t x647; + uint32_t x648; + uint32_t x649; + uint32_t x650; + uint32_t x651; + uint32_t x652; + uint32_t x653; + uint32_t x654; + uint32_t x655; + uint32_t x656; + uint32_t x657; + uint32_t x658; + uint32_t x659; + uint32_t x660; + uint32_t x661; + uint32_t x662; + uint32_t x663; + fiat_secp256k1_scalar_uint1 x664; + uint32_t x665; + fiat_secp256k1_scalar_uint1 x666; + uint32_t x667; + fiat_secp256k1_scalar_uint1 x668; + uint32_t x669; + fiat_secp256k1_scalar_uint1 x670; + uint32_t x671; + fiat_secp256k1_scalar_uint1 x672; + uint32_t x673; + fiat_secp256k1_scalar_uint1 x674; + uint32_t x675; + fiat_secp256k1_scalar_uint1 x676; + uint32_t x677; + uint32_t x678; + fiat_secp256k1_scalar_uint1 x679; + uint32_t x680; + fiat_secp256k1_scalar_uint1 x681; + uint32_t x682; + fiat_secp256k1_scalar_uint1 x683; + uint32_t x684; + fiat_secp256k1_scalar_uint1 x685; + uint32_t x686; + fiat_secp256k1_scalar_uint1 x687; + uint32_t x688; + fiat_secp256k1_scalar_uint1 x689; + uint32_t x690; + fiat_secp256k1_scalar_uint1 x691; + uint32_t x692; + fiat_secp256k1_scalar_uint1 x693; + uint32_t x694; + fiat_secp256k1_scalar_uint1 x695; + uint32_t x696; + uint32_t x697; + uint32_t x698; + uint32_t x699; + uint32_t x700; + uint32_t x701; + uint32_t x702; + uint32_t x703; + uint32_t x704; + uint32_t x705; + uint32_t x706; + uint32_t x707; + uint32_t x708; + uint32_t x709; + uint32_t x710; + uint32_t x711; + uint32_t x712; + uint32_t x713; + fiat_secp256k1_scalar_uint1 x714; + uint32_t x715; + fiat_secp256k1_scalar_uint1 x716; + uint32_t x717; + fiat_secp256k1_scalar_uint1 x718; + uint32_t x719; + fiat_secp256k1_scalar_uint1 x720; + uint32_t x721; + fiat_secp256k1_scalar_uint1 x722; + uint32_t x723; + fiat_secp256k1_scalar_uint1 x724; + uint32_t x725; + fiat_secp256k1_scalar_uint1 x726; + uint32_t x727; + uint32_t x728; + fiat_secp256k1_scalar_uint1 x729; + uint32_t x730; + fiat_secp256k1_scalar_uint1 x731; + uint32_t x732; + fiat_secp256k1_scalar_uint1 x733; + uint32_t x734; + fiat_secp256k1_scalar_uint1 x735; + uint32_t x736; + fiat_secp256k1_scalar_uint1 x737; + uint32_t x738; + fiat_secp256k1_scalar_uint1 x739; + uint32_t x740; + fiat_secp256k1_scalar_uint1 x741; + uint32_t x742; + fiat_secp256k1_scalar_uint1 x743; + uint32_t x744; + fiat_secp256k1_scalar_uint1 x745; + uint32_t x746; + uint32_t x747; + uint32_t x748; + uint32_t x749; + uint32_t x750; + uint32_t x751; + uint32_t x752; + uint32_t x753; + uint32_t x754; + uint32_t x755; + uint32_t x756; + uint32_t x757; + uint32_t x758; + uint32_t x759; + uint32_t x760; + uint32_t x761; + uint32_t x762; + uint32_t x763; + uint32_t x764; + fiat_secp256k1_scalar_uint1 x765; + uint32_t x766; + fiat_secp256k1_scalar_uint1 x767; + uint32_t x768; + fiat_secp256k1_scalar_uint1 x769; + uint32_t x770; + fiat_secp256k1_scalar_uint1 x771; + uint32_t x772; + fiat_secp256k1_scalar_uint1 x773; + uint32_t x774; + fiat_secp256k1_scalar_uint1 x775; + uint32_t x776; + fiat_secp256k1_scalar_uint1 x777; + uint32_t x778; + uint32_t x779; + fiat_secp256k1_scalar_uint1 x780; + uint32_t x781; + fiat_secp256k1_scalar_uint1 x782; + uint32_t x783; + fiat_secp256k1_scalar_uint1 x784; + uint32_t x785; + fiat_secp256k1_scalar_uint1 x786; + uint32_t x787; + fiat_secp256k1_scalar_uint1 x788; + uint32_t x789; + fiat_secp256k1_scalar_uint1 x790; + uint32_t x791; + fiat_secp256k1_scalar_uint1 x792; + uint32_t x793; + fiat_secp256k1_scalar_uint1 x794; + uint32_t x795; + fiat_secp256k1_scalar_uint1 x796; + uint32_t x797; + uint32_t x798; + fiat_secp256k1_scalar_uint1 x799; + uint32_t x800; + fiat_secp256k1_scalar_uint1 x801; + uint32_t x802; + fiat_secp256k1_scalar_uint1 x803; + uint32_t x804; + fiat_secp256k1_scalar_uint1 x805; + uint32_t x806; + fiat_secp256k1_scalar_uint1 x807; + uint32_t x808; + fiat_secp256k1_scalar_uint1 x809; + uint32_t x810; + fiat_secp256k1_scalar_uint1 x811; + uint32_t x812; + fiat_secp256k1_scalar_uint1 x813; + uint32_t x814; + fiat_secp256k1_scalar_uint1 x815; + uint32_t x816; + uint32_t x817; + uint32_t x818; + uint32_t x819; + uint32_t x820; + uint32_t x821; + uint32_t x822; + uint32_t x823; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[6]); + x7 = (arg1[7]); + x8 = (arg1[0]); + fiat_secp256k1_scalar_mulx_u32(&x9, &x10, x8, (arg1[7])); + fiat_secp256k1_scalar_mulx_u32(&x11, &x12, x8, (arg1[6])); + fiat_secp256k1_scalar_mulx_u32(&x13, &x14, x8, (arg1[5])); + fiat_secp256k1_scalar_mulx_u32(&x15, &x16, x8, (arg1[4])); + fiat_secp256k1_scalar_mulx_u32(&x17, &x18, x8, (arg1[3])); + fiat_secp256k1_scalar_mulx_u32(&x19, &x20, x8, (arg1[2])); + fiat_secp256k1_scalar_mulx_u32(&x21, &x22, x8, (arg1[1])); + fiat_secp256k1_scalar_mulx_u32(&x23, &x24, x8, (arg1[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_secp256k1_scalar_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_secp256k1_scalar_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_secp256k1_scalar_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_secp256k1_scalar_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_secp256k1_scalar_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_secp256k1_scalar_addcarryx_u32(&x37, &x38, x36, x12, x9); + x39 = (x38 + x10); + fiat_secp256k1_scalar_mulx_u32(&x40, &x41, x23, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x42, &x43, x40, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x44, &x45, x40, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x46, &x47, x40, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x48, &x49, x40, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x50, &x51, x40, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x52, &x53, x40, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x54, &x55, x40, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x56, &x57, x40, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x58, &x59, 0x0, x57, x54); + fiat_secp256k1_scalar_addcarryx_u32(&x60, &x61, x59, x55, x52); + fiat_secp256k1_scalar_addcarryx_u32(&x62, &x63, x61, x53, x50); + fiat_secp256k1_scalar_addcarryx_u32(&x64, &x65, x63, x51, x48); + fiat_secp256k1_scalar_addcarryx_u32(&x66, &x67, x65, x49, x46); + fiat_secp256k1_scalar_addcarryx_u32(&x68, &x69, x67, x47, x44); + fiat_secp256k1_scalar_addcarryx_u32(&x70, &x71, x69, x45, x42); + x72 = (x71 + x43); + fiat_secp256k1_scalar_addcarryx_u32(&x73, &x74, 0x0, x23, x56); + fiat_secp256k1_scalar_addcarryx_u32(&x75, &x76, x74, x25, x58); + fiat_secp256k1_scalar_addcarryx_u32(&x77, &x78, x76, x27, x60); + fiat_secp256k1_scalar_addcarryx_u32(&x79, &x80, x78, x29, x62); + fiat_secp256k1_scalar_addcarryx_u32(&x81, &x82, x80, x31, x64); + fiat_secp256k1_scalar_addcarryx_u32(&x83, &x84, x82, x33, x66); + fiat_secp256k1_scalar_addcarryx_u32(&x85, &x86, x84, x35, x68); + fiat_secp256k1_scalar_addcarryx_u32(&x87, &x88, x86, x37, x70); + fiat_secp256k1_scalar_addcarryx_u32(&x89, &x90, x88, x39, x72); + fiat_secp256k1_scalar_mulx_u32(&x91, &x92, x1, (arg1[7])); + fiat_secp256k1_scalar_mulx_u32(&x93, &x94, x1, (arg1[6])); + fiat_secp256k1_scalar_mulx_u32(&x95, &x96, x1, (arg1[5])); + fiat_secp256k1_scalar_mulx_u32(&x97, &x98, x1, (arg1[4])); + fiat_secp256k1_scalar_mulx_u32(&x99, &x100, x1, (arg1[3])); + fiat_secp256k1_scalar_mulx_u32(&x101, &x102, x1, (arg1[2])); + fiat_secp256k1_scalar_mulx_u32(&x103, &x104, x1, (arg1[1])); + fiat_secp256k1_scalar_mulx_u32(&x105, &x106, x1, (arg1[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x107, &x108, 0x0, x106, x103); + fiat_secp256k1_scalar_addcarryx_u32(&x109, &x110, x108, x104, x101); + fiat_secp256k1_scalar_addcarryx_u32(&x111, &x112, x110, x102, x99); + fiat_secp256k1_scalar_addcarryx_u32(&x113, &x114, x112, x100, x97); + fiat_secp256k1_scalar_addcarryx_u32(&x115, &x116, x114, x98, x95); + fiat_secp256k1_scalar_addcarryx_u32(&x117, &x118, x116, x96, x93); + fiat_secp256k1_scalar_addcarryx_u32(&x119, &x120, x118, x94, x91); + x121 = (x120 + x92); + fiat_secp256k1_scalar_addcarryx_u32(&x122, &x123, 0x0, x75, x105); + fiat_secp256k1_scalar_addcarryx_u32(&x124, &x125, x123, x77, x107); + fiat_secp256k1_scalar_addcarryx_u32(&x126, &x127, x125, x79, x109); + fiat_secp256k1_scalar_addcarryx_u32(&x128, &x129, x127, x81, x111); + fiat_secp256k1_scalar_addcarryx_u32(&x130, &x131, x129, x83, x113); + fiat_secp256k1_scalar_addcarryx_u32(&x132, &x133, x131, x85, x115); + fiat_secp256k1_scalar_addcarryx_u32(&x134, &x135, x133, x87, x117); + fiat_secp256k1_scalar_addcarryx_u32(&x136, &x137, x135, x89, x119); + fiat_secp256k1_scalar_addcarryx_u32(&x138, &x139, x137, x90, x121); + fiat_secp256k1_scalar_mulx_u32(&x140, &x141, x122, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x142, &x143, x140, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x144, &x145, x140, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x146, &x147, x140, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x148, &x149, x140, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x150, &x151, x140, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x152, &x153, x140, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x154, &x155, x140, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x156, &x157, x140, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x158, &x159, 0x0, x157, x154); + fiat_secp256k1_scalar_addcarryx_u32(&x160, &x161, x159, x155, x152); + fiat_secp256k1_scalar_addcarryx_u32(&x162, &x163, x161, x153, x150); + fiat_secp256k1_scalar_addcarryx_u32(&x164, &x165, x163, x151, x148); + fiat_secp256k1_scalar_addcarryx_u32(&x166, &x167, x165, x149, x146); + fiat_secp256k1_scalar_addcarryx_u32(&x168, &x169, x167, x147, x144); + fiat_secp256k1_scalar_addcarryx_u32(&x170, &x171, x169, x145, x142); + x172 = (x171 + x143); + fiat_secp256k1_scalar_addcarryx_u32(&x173, &x174, 0x0, x122, x156); + fiat_secp256k1_scalar_addcarryx_u32(&x175, &x176, x174, x124, x158); + fiat_secp256k1_scalar_addcarryx_u32(&x177, &x178, x176, x126, x160); + fiat_secp256k1_scalar_addcarryx_u32(&x179, &x180, x178, x128, x162); + fiat_secp256k1_scalar_addcarryx_u32(&x181, &x182, x180, x130, x164); + fiat_secp256k1_scalar_addcarryx_u32(&x183, &x184, x182, x132, x166); + fiat_secp256k1_scalar_addcarryx_u32(&x185, &x186, x184, x134, x168); + fiat_secp256k1_scalar_addcarryx_u32(&x187, &x188, x186, x136, x170); + fiat_secp256k1_scalar_addcarryx_u32(&x189, &x190, x188, x138, x172); + x191 = ((uint32_t)x190 + x139); + fiat_secp256k1_scalar_mulx_u32(&x192, &x193, x2, (arg1[7])); + fiat_secp256k1_scalar_mulx_u32(&x194, &x195, x2, (arg1[6])); + fiat_secp256k1_scalar_mulx_u32(&x196, &x197, x2, (arg1[5])); + fiat_secp256k1_scalar_mulx_u32(&x198, &x199, x2, (arg1[4])); + fiat_secp256k1_scalar_mulx_u32(&x200, &x201, x2, (arg1[3])); + fiat_secp256k1_scalar_mulx_u32(&x202, &x203, x2, (arg1[2])); + fiat_secp256k1_scalar_mulx_u32(&x204, &x205, x2, (arg1[1])); + fiat_secp256k1_scalar_mulx_u32(&x206, &x207, x2, (arg1[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x208, &x209, 0x0, x207, x204); + fiat_secp256k1_scalar_addcarryx_u32(&x210, &x211, x209, x205, x202); + fiat_secp256k1_scalar_addcarryx_u32(&x212, &x213, x211, x203, x200); + fiat_secp256k1_scalar_addcarryx_u32(&x214, &x215, x213, x201, x198); + fiat_secp256k1_scalar_addcarryx_u32(&x216, &x217, x215, x199, x196); + fiat_secp256k1_scalar_addcarryx_u32(&x218, &x219, x217, x197, x194); + fiat_secp256k1_scalar_addcarryx_u32(&x220, &x221, x219, x195, x192); + x222 = (x221 + x193); + fiat_secp256k1_scalar_addcarryx_u32(&x223, &x224, 0x0, x175, x206); + fiat_secp256k1_scalar_addcarryx_u32(&x225, &x226, x224, x177, x208); + fiat_secp256k1_scalar_addcarryx_u32(&x227, &x228, x226, x179, x210); + fiat_secp256k1_scalar_addcarryx_u32(&x229, &x230, x228, x181, x212); + fiat_secp256k1_scalar_addcarryx_u32(&x231, &x232, x230, x183, x214); + fiat_secp256k1_scalar_addcarryx_u32(&x233, &x234, x232, x185, x216); + fiat_secp256k1_scalar_addcarryx_u32(&x235, &x236, x234, x187, x218); + fiat_secp256k1_scalar_addcarryx_u32(&x237, &x238, x236, x189, x220); + fiat_secp256k1_scalar_addcarryx_u32(&x239, &x240, x238, x191, x222); + fiat_secp256k1_scalar_mulx_u32(&x241, &x242, x223, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x243, &x244, x241, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x245, &x246, x241, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x247, &x248, x241, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x249, &x250, x241, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x251, &x252, x241, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x253, &x254, x241, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x255, &x256, x241, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x257, &x258, x241, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x259, &x260, 0x0, x258, x255); + fiat_secp256k1_scalar_addcarryx_u32(&x261, &x262, x260, x256, x253); + fiat_secp256k1_scalar_addcarryx_u32(&x263, &x264, x262, x254, x251); + fiat_secp256k1_scalar_addcarryx_u32(&x265, &x266, x264, x252, x249); + fiat_secp256k1_scalar_addcarryx_u32(&x267, &x268, x266, x250, x247); + fiat_secp256k1_scalar_addcarryx_u32(&x269, &x270, x268, x248, x245); + fiat_secp256k1_scalar_addcarryx_u32(&x271, &x272, x270, x246, x243); + x273 = (x272 + x244); + fiat_secp256k1_scalar_addcarryx_u32(&x274, &x275, 0x0, x223, x257); + fiat_secp256k1_scalar_addcarryx_u32(&x276, &x277, x275, x225, x259); + fiat_secp256k1_scalar_addcarryx_u32(&x278, &x279, x277, x227, x261); + fiat_secp256k1_scalar_addcarryx_u32(&x280, &x281, x279, x229, x263); + fiat_secp256k1_scalar_addcarryx_u32(&x282, &x283, x281, x231, x265); + fiat_secp256k1_scalar_addcarryx_u32(&x284, &x285, x283, x233, x267); + fiat_secp256k1_scalar_addcarryx_u32(&x286, &x287, x285, x235, x269); + fiat_secp256k1_scalar_addcarryx_u32(&x288, &x289, x287, x237, x271); + fiat_secp256k1_scalar_addcarryx_u32(&x290, &x291, x289, x239, x273); + x292 = ((uint32_t)x291 + x240); + fiat_secp256k1_scalar_mulx_u32(&x293, &x294, x3, (arg1[7])); + fiat_secp256k1_scalar_mulx_u32(&x295, &x296, x3, (arg1[6])); + fiat_secp256k1_scalar_mulx_u32(&x297, &x298, x3, (arg1[5])); + fiat_secp256k1_scalar_mulx_u32(&x299, &x300, x3, (arg1[4])); + fiat_secp256k1_scalar_mulx_u32(&x301, &x302, x3, (arg1[3])); + fiat_secp256k1_scalar_mulx_u32(&x303, &x304, x3, (arg1[2])); + fiat_secp256k1_scalar_mulx_u32(&x305, &x306, x3, (arg1[1])); + fiat_secp256k1_scalar_mulx_u32(&x307, &x308, x3, (arg1[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x309, &x310, 0x0, x308, x305); + fiat_secp256k1_scalar_addcarryx_u32(&x311, &x312, x310, x306, x303); + fiat_secp256k1_scalar_addcarryx_u32(&x313, &x314, x312, x304, x301); + fiat_secp256k1_scalar_addcarryx_u32(&x315, &x316, x314, x302, x299); + fiat_secp256k1_scalar_addcarryx_u32(&x317, &x318, x316, x300, x297); + fiat_secp256k1_scalar_addcarryx_u32(&x319, &x320, x318, x298, x295); + fiat_secp256k1_scalar_addcarryx_u32(&x321, &x322, x320, x296, x293); + x323 = (x322 + x294); + fiat_secp256k1_scalar_addcarryx_u32(&x324, &x325, 0x0, x276, x307); + fiat_secp256k1_scalar_addcarryx_u32(&x326, &x327, x325, x278, x309); + fiat_secp256k1_scalar_addcarryx_u32(&x328, &x329, x327, x280, x311); + fiat_secp256k1_scalar_addcarryx_u32(&x330, &x331, x329, x282, x313); + fiat_secp256k1_scalar_addcarryx_u32(&x332, &x333, x331, x284, x315); + fiat_secp256k1_scalar_addcarryx_u32(&x334, &x335, x333, x286, x317); + fiat_secp256k1_scalar_addcarryx_u32(&x336, &x337, x335, x288, x319); + fiat_secp256k1_scalar_addcarryx_u32(&x338, &x339, x337, x290, x321); + fiat_secp256k1_scalar_addcarryx_u32(&x340, &x341, x339, x292, x323); + fiat_secp256k1_scalar_mulx_u32(&x342, &x343, x324, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x344, &x345, x342, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x346, &x347, x342, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x348, &x349, x342, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x350, &x351, x342, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x352, &x353, x342, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x354, &x355, x342, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x356, &x357, x342, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x358, &x359, x342, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x360, &x361, 0x0, x359, x356); + fiat_secp256k1_scalar_addcarryx_u32(&x362, &x363, x361, x357, x354); + fiat_secp256k1_scalar_addcarryx_u32(&x364, &x365, x363, x355, x352); + fiat_secp256k1_scalar_addcarryx_u32(&x366, &x367, x365, x353, x350); + fiat_secp256k1_scalar_addcarryx_u32(&x368, &x369, x367, x351, x348); + fiat_secp256k1_scalar_addcarryx_u32(&x370, &x371, x369, x349, x346); + fiat_secp256k1_scalar_addcarryx_u32(&x372, &x373, x371, x347, x344); + x374 = (x373 + x345); + fiat_secp256k1_scalar_addcarryx_u32(&x375, &x376, 0x0, x324, x358); + fiat_secp256k1_scalar_addcarryx_u32(&x377, &x378, x376, x326, x360); + fiat_secp256k1_scalar_addcarryx_u32(&x379, &x380, x378, x328, x362); + fiat_secp256k1_scalar_addcarryx_u32(&x381, &x382, x380, x330, x364); + fiat_secp256k1_scalar_addcarryx_u32(&x383, &x384, x382, x332, x366); + fiat_secp256k1_scalar_addcarryx_u32(&x385, &x386, x384, x334, x368); + fiat_secp256k1_scalar_addcarryx_u32(&x387, &x388, x386, x336, x370); + fiat_secp256k1_scalar_addcarryx_u32(&x389, &x390, x388, x338, x372); + fiat_secp256k1_scalar_addcarryx_u32(&x391, &x392, x390, x340, x374); + x393 = ((uint32_t)x392 + x341); + fiat_secp256k1_scalar_mulx_u32(&x394, &x395, x4, (arg1[7])); + fiat_secp256k1_scalar_mulx_u32(&x396, &x397, x4, (arg1[6])); + fiat_secp256k1_scalar_mulx_u32(&x398, &x399, x4, (arg1[5])); + fiat_secp256k1_scalar_mulx_u32(&x400, &x401, x4, (arg1[4])); + fiat_secp256k1_scalar_mulx_u32(&x402, &x403, x4, (arg1[3])); + fiat_secp256k1_scalar_mulx_u32(&x404, &x405, x4, (arg1[2])); + fiat_secp256k1_scalar_mulx_u32(&x406, &x407, x4, (arg1[1])); + fiat_secp256k1_scalar_mulx_u32(&x408, &x409, x4, (arg1[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x410, &x411, 0x0, x409, x406); + fiat_secp256k1_scalar_addcarryx_u32(&x412, &x413, x411, x407, x404); + fiat_secp256k1_scalar_addcarryx_u32(&x414, &x415, x413, x405, x402); + fiat_secp256k1_scalar_addcarryx_u32(&x416, &x417, x415, x403, x400); + fiat_secp256k1_scalar_addcarryx_u32(&x418, &x419, x417, x401, x398); + fiat_secp256k1_scalar_addcarryx_u32(&x420, &x421, x419, x399, x396); + fiat_secp256k1_scalar_addcarryx_u32(&x422, &x423, x421, x397, x394); + x424 = (x423 + x395); + fiat_secp256k1_scalar_addcarryx_u32(&x425, &x426, 0x0, x377, x408); + fiat_secp256k1_scalar_addcarryx_u32(&x427, &x428, x426, x379, x410); + fiat_secp256k1_scalar_addcarryx_u32(&x429, &x430, x428, x381, x412); + fiat_secp256k1_scalar_addcarryx_u32(&x431, &x432, x430, x383, x414); + fiat_secp256k1_scalar_addcarryx_u32(&x433, &x434, x432, x385, x416); + fiat_secp256k1_scalar_addcarryx_u32(&x435, &x436, x434, x387, x418); + fiat_secp256k1_scalar_addcarryx_u32(&x437, &x438, x436, x389, x420); + fiat_secp256k1_scalar_addcarryx_u32(&x439, &x440, x438, x391, x422); + fiat_secp256k1_scalar_addcarryx_u32(&x441, &x442, x440, x393, x424); + fiat_secp256k1_scalar_mulx_u32(&x443, &x444, x425, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x445, &x446, x443, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x447, &x448, x443, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x449, &x450, x443, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x451, &x452, x443, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x453, &x454, x443, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x455, &x456, x443, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x457, &x458, x443, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x459, &x460, x443, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x461, &x462, 0x0, x460, x457); + fiat_secp256k1_scalar_addcarryx_u32(&x463, &x464, x462, x458, x455); + fiat_secp256k1_scalar_addcarryx_u32(&x465, &x466, x464, x456, x453); + fiat_secp256k1_scalar_addcarryx_u32(&x467, &x468, x466, x454, x451); + fiat_secp256k1_scalar_addcarryx_u32(&x469, &x470, x468, x452, x449); + fiat_secp256k1_scalar_addcarryx_u32(&x471, &x472, x470, x450, x447); + fiat_secp256k1_scalar_addcarryx_u32(&x473, &x474, x472, x448, x445); + x475 = (x474 + x446); + fiat_secp256k1_scalar_addcarryx_u32(&x476, &x477, 0x0, x425, x459); + fiat_secp256k1_scalar_addcarryx_u32(&x478, &x479, x477, x427, x461); + fiat_secp256k1_scalar_addcarryx_u32(&x480, &x481, x479, x429, x463); + fiat_secp256k1_scalar_addcarryx_u32(&x482, &x483, x481, x431, x465); + fiat_secp256k1_scalar_addcarryx_u32(&x484, &x485, x483, x433, x467); + fiat_secp256k1_scalar_addcarryx_u32(&x486, &x487, x485, x435, x469); + fiat_secp256k1_scalar_addcarryx_u32(&x488, &x489, x487, x437, x471); + fiat_secp256k1_scalar_addcarryx_u32(&x490, &x491, x489, x439, x473); + fiat_secp256k1_scalar_addcarryx_u32(&x492, &x493, x491, x441, x475); + x494 = ((uint32_t)x493 + x442); + fiat_secp256k1_scalar_mulx_u32(&x495, &x496, x5, (arg1[7])); + fiat_secp256k1_scalar_mulx_u32(&x497, &x498, x5, (arg1[6])); + fiat_secp256k1_scalar_mulx_u32(&x499, &x500, x5, (arg1[5])); + fiat_secp256k1_scalar_mulx_u32(&x501, &x502, x5, (arg1[4])); + fiat_secp256k1_scalar_mulx_u32(&x503, &x504, x5, (arg1[3])); + fiat_secp256k1_scalar_mulx_u32(&x505, &x506, x5, (arg1[2])); + fiat_secp256k1_scalar_mulx_u32(&x507, &x508, x5, (arg1[1])); + fiat_secp256k1_scalar_mulx_u32(&x509, &x510, x5, (arg1[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x511, &x512, 0x0, x510, x507); + fiat_secp256k1_scalar_addcarryx_u32(&x513, &x514, x512, x508, x505); + fiat_secp256k1_scalar_addcarryx_u32(&x515, &x516, x514, x506, x503); + fiat_secp256k1_scalar_addcarryx_u32(&x517, &x518, x516, x504, x501); + fiat_secp256k1_scalar_addcarryx_u32(&x519, &x520, x518, x502, x499); + fiat_secp256k1_scalar_addcarryx_u32(&x521, &x522, x520, x500, x497); + fiat_secp256k1_scalar_addcarryx_u32(&x523, &x524, x522, x498, x495); + x525 = (x524 + x496); + fiat_secp256k1_scalar_addcarryx_u32(&x526, &x527, 0x0, x478, x509); + fiat_secp256k1_scalar_addcarryx_u32(&x528, &x529, x527, x480, x511); + fiat_secp256k1_scalar_addcarryx_u32(&x530, &x531, x529, x482, x513); + fiat_secp256k1_scalar_addcarryx_u32(&x532, &x533, x531, x484, x515); + fiat_secp256k1_scalar_addcarryx_u32(&x534, &x535, x533, x486, x517); + fiat_secp256k1_scalar_addcarryx_u32(&x536, &x537, x535, x488, x519); + fiat_secp256k1_scalar_addcarryx_u32(&x538, &x539, x537, x490, x521); + fiat_secp256k1_scalar_addcarryx_u32(&x540, &x541, x539, x492, x523); + fiat_secp256k1_scalar_addcarryx_u32(&x542, &x543, x541, x494, x525); + fiat_secp256k1_scalar_mulx_u32(&x544, &x545, x526, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x546, &x547, x544, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x548, &x549, x544, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x550, &x551, x544, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x552, &x553, x544, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x554, &x555, x544, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x556, &x557, x544, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x558, &x559, x544, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x560, &x561, x544, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x562, &x563, 0x0, x561, x558); + fiat_secp256k1_scalar_addcarryx_u32(&x564, &x565, x563, x559, x556); + fiat_secp256k1_scalar_addcarryx_u32(&x566, &x567, x565, x557, x554); + fiat_secp256k1_scalar_addcarryx_u32(&x568, &x569, x567, x555, x552); + fiat_secp256k1_scalar_addcarryx_u32(&x570, &x571, x569, x553, x550); + fiat_secp256k1_scalar_addcarryx_u32(&x572, &x573, x571, x551, x548); + fiat_secp256k1_scalar_addcarryx_u32(&x574, &x575, x573, x549, x546); + x576 = (x575 + x547); + fiat_secp256k1_scalar_addcarryx_u32(&x577, &x578, 0x0, x526, x560); + fiat_secp256k1_scalar_addcarryx_u32(&x579, &x580, x578, x528, x562); + fiat_secp256k1_scalar_addcarryx_u32(&x581, &x582, x580, x530, x564); + fiat_secp256k1_scalar_addcarryx_u32(&x583, &x584, x582, x532, x566); + fiat_secp256k1_scalar_addcarryx_u32(&x585, &x586, x584, x534, x568); + fiat_secp256k1_scalar_addcarryx_u32(&x587, &x588, x586, x536, x570); + fiat_secp256k1_scalar_addcarryx_u32(&x589, &x590, x588, x538, x572); + fiat_secp256k1_scalar_addcarryx_u32(&x591, &x592, x590, x540, x574); + fiat_secp256k1_scalar_addcarryx_u32(&x593, &x594, x592, x542, x576); + x595 = ((uint32_t)x594 + x543); + fiat_secp256k1_scalar_mulx_u32(&x596, &x597, x6, (arg1[7])); + fiat_secp256k1_scalar_mulx_u32(&x598, &x599, x6, (arg1[6])); + fiat_secp256k1_scalar_mulx_u32(&x600, &x601, x6, (arg1[5])); + fiat_secp256k1_scalar_mulx_u32(&x602, &x603, x6, (arg1[4])); + fiat_secp256k1_scalar_mulx_u32(&x604, &x605, x6, (arg1[3])); + fiat_secp256k1_scalar_mulx_u32(&x606, &x607, x6, (arg1[2])); + fiat_secp256k1_scalar_mulx_u32(&x608, &x609, x6, (arg1[1])); + fiat_secp256k1_scalar_mulx_u32(&x610, &x611, x6, (arg1[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x612, &x613, 0x0, x611, x608); + fiat_secp256k1_scalar_addcarryx_u32(&x614, &x615, x613, x609, x606); + fiat_secp256k1_scalar_addcarryx_u32(&x616, &x617, x615, x607, x604); + fiat_secp256k1_scalar_addcarryx_u32(&x618, &x619, x617, x605, x602); + fiat_secp256k1_scalar_addcarryx_u32(&x620, &x621, x619, x603, x600); + fiat_secp256k1_scalar_addcarryx_u32(&x622, &x623, x621, x601, x598); + fiat_secp256k1_scalar_addcarryx_u32(&x624, &x625, x623, x599, x596); + x626 = (x625 + x597); + fiat_secp256k1_scalar_addcarryx_u32(&x627, &x628, 0x0, x579, x610); + fiat_secp256k1_scalar_addcarryx_u32(&x629, &x630, x628, x581, x612); + fiat_secp256k1_scalar_addcarryx_u32(&x631, &x632, x630, x583, x614); + fiat_secp256k1_scalar_addcarryx_u32(&x633, &x634, x632, x585, x616); + fiat_secp256k1_scalar_addcarryx_u32(&x635, &x636, x634, x587, x618); + fiat_secp256k1_scalar_addcarryx_u32(&x637, &x638, x636, x589, x620); + fiat_secp256k1_scalar_addcarryx_u32(&x639, &x640, x638, x591, x622); + fiat_secp256k1_scalar_addcarryx_u32(&x641, &x642, x640, x593, x624); + fiat_secp256k1_scalar_addcarryx_u32(&x643, &x644, x642, x595, x626); + fiat_secp256k1_scalar_mulx_u32(&x645, &x646, x627, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x647, &x648, x645, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x649, &x650, x645, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x651, &x652, x645, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x653, &x654, x645, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x655, &x656, x645, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x657, &x658, x645, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x659, &x660, x645, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x661, &x662, x645, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x663, &x664, 0x0, x662, x659); + fiat_secp256k1_scalar_addcarryx_u32(&x665, &x666, x664, x660, x657); + fiat_secp256k1_scalar_addcarryx_u32(&x667, &x668, x666, x658, x655); + fiat_secp256k1_scalar_addcarryx_u32(&x669, &x670, x668, x656, x653); + fiat_secp256k1_scalar_addcarryx_u32(&x671, &x672, x670, x654, x651); + fiat_secp256k1_scalar_addcarryx_u32(&x673, &x674, x672, x652, x649); + fiat_secp256k1_scalar_addcarryx_u32(&x675, &x676, x674, x650, x647); + x677 = (x676 + x648); + fiat_secp256k1_scalar_addcarryx_u32(&x678, &x679, 0x0, x627, x661); + fiat_secp256k1_scalar_addcarryx_u32(&x680, &x681, x679, x629, x663); + fiat_secp256k1_scalar_addcarryx_u32(&x682, &x683, x681, x631, x665); + fiat_secp256k1_scalar_addcarryx_u32(&x684, &x685, x683, x633, x667); + fiat_secp256k1_scalar_addcarryx_u32(&x686, &x687, x685, x635, x669); + fiat_secp256k1_scalar_addcarryx_u32(&x688, &x689, x687, x637, x671); + fiat_secp256k1_scalar_addcarryx_u32(&x690, &x691, x689, x639, x673); + fiat_secp256k1_scalar_addcarryx_u32(&x692, &x693, x691, x641, x675); + fiat_secp256k1_scalar_addcarryx_u32(&x694, &x695, x693, x643, x677); + x696 = ((uint32_t)x695 + x644); + fiat_secp256k1_scalar_mulx_u32(&x697, &x698, x7, (arg1[7])); + fiat_secp256k1_scalar_mulx_u32(&x699, &x700, x7, (arg1[6])); + fiat_secp256k1_scalar_mulx_u32(&x701, &x702, x7, (arg1[5])); + fiat_secp256k1_scalar_mulx_u32(&x703, &x704, x7, (arg1[4])); + fiat_secp256k1_scalar_mulx_u32(&x705, &x706, x7, (arg1[3])); + fiat_secp256k1_scalar_mulx_u32(&x707, &x708, x7, (arg1[2])); + fiat_secp256k1_scalar_mulx_u32(&x709, &x710, x7, (arg1[1])); + fiat_secp256k1_scalar_mulx_u32(&x711, &x712, x7, (arg1[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x713, &x714, 0x0, x712, x709); + fiat_secp256k1_scalar_addcarryx_u32(&x715, &x716, x714, x710, x707); + fiat_secp256k1_scalar_addcarryx_u32(&x717, &x718, x716, x708, x705); + fiat_secp256k1_scalar_addcarryx_u32(&x719, &x720, x718, x706, x703); + fiat_secp256k1_scalar_addcarryx_u32(&x721, &x722, x720, x704, x701); + fiat_secp256k1_scalar_addcarryx_u32(&x723, &x724, x722, x702, x699); + fiat_secp256k1_scalar_addcarryx_u32(&x725, &x726, x724, x700, x697); + x727 = (x726 + x698); + fiat_secp256k1_scalar_addcarryx_u32(&x728, &x729, 0x0, x680, x711); + fiat_secp256k1_scalar_addcarryx_u32(&x730, &x731, x729, x682, x713); + fiat_secp256k1_scalar_addcarryx_u32(&x732, &x733, x731, x684, x715); + fiat_secp256k1_scalar_addcarryx_u32(&x734, &x735, x733, x686, x717); + fiat_secp256k1_scalar_addcarryx_u32(&x736, &x737, x735, x688, x719); + fiat_secp256k1_scalar_addcarryx_u32(&x738, &x739, x737, x690, x721); + fiat_secp256k1_scalar_addcarryx_u32(&x740, &x741, x739, x692, x723); + fiat_secp256k1_scalar_addcarryx_u32(&x742, &x743, x741, x694, x725); + fiat_secp256k1_scalar_addcarryx_u32(&x744, &x745, x743, x696, x727); + fiat_secp256k1_scalar_mulx_u32(&x746, &x747, x728, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x748, &x749, x746, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x750, &x751, x746, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x752, &x753, x746, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x754, &x755, x746, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x756, &x757, x746, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x758, &x759, x746, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x760, &x761, x746, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x762, &x763, x746, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x764, &x765, 0x0, x763, x760); + fiat_secp256k1_scalar_addcarryx_u32(&x766, &x767, x765, x761, x758); + fiat_secp256k1_scalar_addcarryx_u32(&x768, &x769, x767, x759, x756); + fiat_secp256k1_scalar_addcarryx_u32(&x770, &x771, x769, x757, x754); + fiat_secp256k1_scalar_addcarryx_u32(&x772, &x773, x771, x755, x752); + fiat_secp256k1_scalar_addcarryx_u32(&x774, &x775, x773, x753, x750); + fiat_secp256k1_scalar_addcarryx_u32(&x776, &x777, x775, x751, x748); + x778 = (x777 + x749); + fiat_secp256k1_scalar_addcarryx_u32(&x779, &x780, 0x0, x728, x762); + fiat_secp256k1_scalar_addcarryx_u32(&x781, &x782, x780, x730, x764); + fiat_secp256k1_scalar_addcarryx_u32(&x783, &x784, x782, x732, x766); + fiat_secp256k1_scalar_addcarryx_u32(&x785, &x786, x784, x734, x768); + fiat_secp256k1_scalar_addcarryx_u32(&x787, &x788, x786, x736, x770); + fiat_secp256k1_scalar_addcarryx_u32(&x789, &x790, x788, x738, x772); + fiat_secp256k1_scalar_addcarryx_u32(&x791, &x792, x790, x740, x774); + fiat_secp256k1_scalar_addcarryx_u32(&x793, &x794, x792, x742, x776); + fiat_secp256k1_scalar_addcarryx_u32(&x795, &x796, x794, x744, x778); + x797 = ((uint32_t)x796 + x745); + fiat_secp256k1_scalar_subborrowx_u32(&x798, &x799, 0x0, x781, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_subborrowx_u32(&x800, &x801, x799, x783, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_subborrowx_u32(&x802, &x803, x801, x785, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_subborrowx_u32(&x804, &x805, x803, x787, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_subborrowx_u32(&x806, &x807, x805, x789, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_subborrowx_u32(&x808, &x809, x807, x791, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x810, &x811, x809, x793, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x812, &x813, x811, x795, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x814, &x815, x813, x797, 0x0); + fiat_secp256k1_scalar_cmovznz_u32(&x816, x815, x798, x781); + fiat_secp256k1_scalar_cmovznz_u32(&x817, x815, x800, x783); + fiat_secp256k1_scalar_cmovznz_u32(&x818, x815, x802, x785); + fiat_secp256k1_scalar_cmovznz_u32(&x819, x815, x804, x787); + fiat_secp256k1_scalar_cmovznz_u32(&x820, x815, x806, x789); + fiat_secp256k1_scalar_cmovznz_u32(&x821, x815, x808, x791); + fiat_secp256k1_scalar_cmovznz_u32(&x822, x815, x810, x793); + fiat_secp256k1_scalar_cmovznz_u32(&x823, x815, x812, x795); + out1[0] = x816; + out1[1] = x817; + out1[2] = x818; + out1[3] = x819; + out1[4] = x820; + out1[5] = x821; + out1[6] = x822; + out1[7] = x823; +} + +/* + * The function fiat_secp256k1_scalar_add adds two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_add(fiat_secp256k1_scalar_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + fiat_secp256k1_scalar_uint1 x2; + uint32_t x3; + fiat_secp256k1_scalar_uint1 x4; + uint32_t x5; + fiat_secp256k1_scalar_uint1 x6; + uint32_t x7; + fiat_secp256k1_scalar_uint1 x8; + uint32_t x9; + fiat_secp256k1_scalar_uint1 x10; + uint32_t x11; + fiat_secp256k1_scalar_uint1 x12; + uint32_t x13; + fiat_secp256k1_scalar_uint1 x14; + uint32_t x15; + fiat_secp256k1_scalar_uint1 x16; + uint32_t x17; + fiat_secp256k1_scalar_uint1 x18; + uint32_t x19; + fiat_secp256k1_scalar_uint1 x20; + uint32_t x21; + fiat_secp256k1_scalar_uint1 x22; + uint32_t x23; + fiat_secp256k1_scalar_uint1 x24; + uint32_t x25; + fiat_secp256k1_scalar_uint1 x26; + uint32_t x27; + fiat_secp256k1_scalar_uint1 x28; + uint32_t x29; + fiat_secp256k1_scalar_uint1 x30; + uint32_t x31; + fiat_secp256k1_scalar_uint1 x32; + uint32_t x33; + fiat_secp256k1_scalar_uint1 x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + uint32_t x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + fiat_secp256k1_scalar_addcarryx_u32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_secp256k1_scalar_addcarryx_u32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_secp256k1_scalar_addcarryx_u32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_secp256k1_scalar_addcarryx_u32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_secp256k1_scalar_addcarryx_u32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_secp256k1_scalar_addcarryx_u32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + fiat_secp256k1_scalar_addcarryx_u32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + fiat_secp256k1_scalar_subborrowx_u32(&x17, &x18, 0x0, x1, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_subborrowx_u32(&x19, &x20, x18, x3, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_subborrowx_u32(&x21, &x22, x20, x5, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_subborrowx_u32(&x23, &x24, x22, x7, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_subborrowx_u32(&x25, &x26, x24, x9, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_subborrowx_u32(&x27, &x28, x26, x11, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x29, &x30, x28, x13, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x31, &x32, x30, x15, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x33, &x34, x32, x16, 0x0); + fiat_secp256k1_scalar_cmovznz_u32(&x35, x34, x17, x1); + fiat_secp256k1_scalar_cmovznz_u32(&x36, x34, x19, x3); + fiat_secp256k1_scalar_cmovznz_u32(&x37, x34, x21, x5); + fiat_secp256k1_scalar_cmovznz_u32(&x38, x34, x23, x7); + fiat_secp256k1_scalar_cmovznz_u32(&x39, x34, x25, x9); + fiat_secp256k1_scalar_cmovznz_u32(&x40, x34, x27, x11); + fiat_secp256k1_scalar_cmovznz_u32(&x41, x34, x29, x13); + fiat_secp256k1_scalar_cmovznz_u32(&x42, x34, x31, x15); + out1[0] = x35; + out1[1] = x36; + out1[2] = x37; + out1[3] = x38; + out1[4] = x39; + out1[5] = x40; + out1[6] = x41; + out1[7] = x42; +} + +/* + * The function fiat_secp256k1_scalar_sub subtracts two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_sub(fiat_secp256k1_scalar_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + fiat_secp256k1_scalar_uint1 x2; + uint32_t x3; + fiat_secp256k1_scalar_uint1 x4; + uint32_t x5; + fiat_secp256k1_scalar_uint1 x6; + uint32_t x7; + fiat_secp256k1_scalar_uint1 x8; + uint32_t x9; + fiat_secp256k1_scalar_uint1 x10; + uint32_t x11; + fiat_secp256k1_scalar_uint1 x12; + uint32_t x13; + fiat_secp256k1_scalar_uint1 x14; + uint32_t x15; + fiat_secp256k1_scalar_uint1 x16; + uint32_t x17; + uint32_t x18; + fiat_secp256k1_scalar_uint1 x19; + uint32_t x20; + fiat_secp256k1_scalar_uint1 x21; + uint32_t x22; + fiat_secp256k1_scalar_uint1 x23; + uint32_t x24; + fiat_secp256k1_scalar_uint1 x25; + uint32_t x26; + fiat_secp256k1_scalar_uint1 x27; + uint32_t x28; + fiat_secp256k1_scalar_uint1 x29; + uint32_t x30; + fiat_secp256k1_scalar_uint1 x31; + uint32_t x32; + fiat_secp256k1_scalar_uint1 x33; + fiat_secp256k1_scalar_subborrowx_u32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_secp256k1_scalar_subborrowx_u32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_secp256k1_scalar_subborrowx_u32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_secp256k1_scalar_subborrowx_u32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_secp256k1_scalar_subborrowx_u32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_secp256k1_scalar_subborrowx_u32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_secp256k1_scalar_subborrowx_u32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + fiat_secp256k1_scalar_subborrowx_u32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + fiat_secp256k1_scalar_cmovznz_u32(&x17, x16, 0x0, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_addcarryx_u32(&x18, &x19, 0x0, x1, (x17 & UINT32_C(0xd0364141))); + fiat_secp256k1_scalar_addcarryx_u32(&x20, &x21, x19, x3, (x17 & UINT32_C(0xbfd25e8c))); + fiat_secp256k1_scalar_addcarryx_u32(&x22, &x23, x21, x5, (x17 & UINT32_C(0xaf48a03b))); + fiat_secp256k1_scalar_addcarryx_u32(&x24, &x25, x23, x7, (x17 & UINT32_C(0xbaaedce6))); + fiat_secp256k1_scalar_addcarryx_u32(&x26, &x27, x25, x9, (x17 & UINT32_C(0xfffffffe))); + fiat_secp256k1_scalar_addcarryx_u32(&x28, &x29, x27, x11, x17); + fiat_secp256k1_scalar_addcarryx_u32(&x30, &x31, x29, x13, x17); + fiat_secp256k1_scalar_addcarryx_u32(&x32, &x33, x31, x15, x17); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/* + * The function fiat_secp256k1_scalar_opp negates a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_opp(fiat_secp256k1_scalar_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + fiat_secp256k1_scalar_uint1 x2; + uint32_t x3; + fiat_secp256k1_scalar_uint1 x4; + uint32_t x5; + fiat_secp256k1_scalar_uint1 x6; + uint32_t x7; + fiat_secp256k1_scalar_uint1 x8; + uint32_t x9; + fiat_secp256k1_scalar_uint1 x10; + uint32_t x11; + fiat_secp256k1_scalar_uint1 x12; + uint32_t x13; + fiat_secp256k1_scalar_uint1 x14; + uint32_t x15; + fiat_secp256k1_scalar_uint1 x16; + uint32_t x17; + uint32_t x18; + fiat_secp256k1_scalar_uint1 x19; + uint32_t x20; + fiat_secp256k1_scalar_uint1 x21; + uint32_t x22; + fiat_secp256k1_scalar_uint1 x23; + uint32_t x24; + fiat_secp256k1_scalar_uint1 x25; + uint32_t x26; + fiat_secp256k1_scalar_uint1 x27; + uint32_t x28; + fiat_secp256k1_scalar_uint1 x29; + uint32_t x30; + fiat_secp256k1_scalar_uint1 x31; + uint32_t x32; + fiat_secp256k1_scalar_uint1 x33; + fiat_secp256k1_scalar_subborrowx_u32(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_secp256k1_scalar_subborrowx_u32(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_secp256k1_scalar_subborrowx_u32(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_secp256k1_scalar_subborrowx_u32(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_secp256k1_scalar_subborrowx_u32(&x9, &x10, x8, 0x0, (arg1[4])); + fiat_secp256k1_scalar_subborrowx_u32(&x11, &x12, x10, 0x0, (arg1[5])); + fiat_secp256k1_scalar_subborrowx_u32(&x13, &x14, x12, 0x0, (arg1[6])); + fiat_secp256k1_scalar_subborrowx_u32(&x15, &x16, x14, 0x0, (arg1[7])); + fiat_secp256k1_scalar_cmovznz_u32(&x17, x16, 0x0, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_addcarryx_u32(&x18, &x19, 0x0, x1, (x17 & UINT32_C(0xd0364141))); + fiat_secp256k1_scalar_addcarryx_u32(&x20, &x21, x19, x3, (x17 & UINT32_C(0xbfd25e8c))); + fiat_secp256k1_scalar_addcarryx_u32(&x22, &x23, x21, x5, (x17 & UINT32_C(0xaf48a03b))); + fiat_secp256k1_scalar_addcarryx_u32(&x24, &x25, x23, x7, (x17 & UINT32_C(0xbaaedce6))); + fiat_secp256k1_scalar_addcarryx_u32(&x26, &x27, x25, x9, (x17 & UINT32_C(0xfffffffe))); + fiat_secp256k1_scalar_addcarryx_u32(&x28, &x29, x27, x11, x17); + fiat_secp256k1_scalar_addcarryx_u32(&x30, &x31, x29, x13, x17); + fiat_secp256k1_scalar_addcarryx_u32(&x32, &x33, x31, x15, x17); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/* + * The function fiat_secp256k1_scalar_from_montgomery translates a field element out of the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_from_montgomery(fiat_secp256k1_scalar_non_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + fiat_secp256k1_scalar_uint1 x21; + uint32_t x22; + fiat_secp256k1_scalar_uint1 x23; + uint32_t x24; + fiat_secp256k1_scalar_uint1 x25; + uint32_t x26; + fiat_secp256k1_scalar_uint1 x27; + uint32_t x28; + fiat_secp256k1_scalar_uint1 x29; + uint32_t x30; + fiat_secp256k1_scalar_uint1 x31; + uint32_t x32; + fiat_secp256k1_scalar_uint1 x33; + uint32_t x34; + fiat_secp256k1_scalar_uint1 x35; + uint32_t x36; + fiat_secp256k1_scalar_uint1 x37; + uint32_t x38; + fiat_secp256k1_scalar_uint1 x39; + uint32_t x40; + fiat_secp256k1_scalar_uint1 x41; + uint32_t x42; + fiat_secp256k1_scalar_uint1 x43; + uint32_t x44; + fiat_secp256k1_scalar_uint1 x45; + uint32_t x46; + fiat_secp256k1_scalar_uint1 x47; + uint32_t x48; + fiat_secp256k1_scalar_uint1 x49; + uint32_t x50; + fiat_secp256k1_scalar_uint1 x51; + uint32_t x52; + fiat_secp256k1_scalar_uint1 x53; + uint32_t x54; + fiat_secp256k1_scalar_uint1 x55; + uint32_t x56; + fiat_secp256k1_scalar_uint1 x57; + uint32_t x58; + fiat_secp256k1_scalar_uint1 x59; + uint32_t x60; + fiat_secp256k1_scalar_uint1 x61; + uint32_t x62; + fiat_secp256k1_scalar_uint1 x63; + uint32_t x64; + fiat_secp256k1_scalar_uint1 x65; + uint32_t x66; + fiat_secp256k1_scalar_uint1 x67; + uint32_t x68; + uint32_t x69; + uint32_t x70; + uint32_t x71; + uint32_t x72; + uint32_t x73; + uint32_t x74; + uint32_t x75; + uint32_t x76; + uint32_t x77; + uint32_t x78; + uint32_t x79; + uint32_t x80; + uint32_t x81; + uint32_t x82; + uint32_t x83; + uint32_t x84; + uint32_t x85; + uint32_t x86; + fiat_secp256k1_scalar_uint1 x87; + uint32_t x88; + fiat_secp256k1_scalar_uint1 x89; + uint32_t x90; + fiat_secp256k1_scalar_uint1 x91; + uint32_t x92; + fiat_secp256k1_scalar_uint1 x93; + uint32_t x94; + fiat_secp256k1_scalar_uint1 x95; + uint32_t x96; + fiat_secp256k1_scalar_uint1 x97; + uint32_t x98; + fiat_secp256k1_scalar_uint1 x99; + uint32_t x100; + fiat_secp256k1_scalar_uint1 x101; + uint32_t x102; + fiat_secp256k1_scalar_uint1 x103; + uint32_t x104; + fiat_secp256k1_scalar_uint1 x105; + uint32_t x106; + fiat_secp256k1_scalar_uint1 x107; + uint32_t x108; + fiat_secp256k1_scalar_uint1 x109; + uint32_t x110; + fiat_secp256k1_scalar_uint1 x111; + uint32_t x112; + fiat_secp256k1_scalar_uint1 x113; + uint32_t x114; + fiat_secp256k1_scalar_uint1 x115; + uint32_t x116; + fiat_secp256k1_scalar_uint1 x117; + uint32_t x118; + fiat_secp256k1_scalar_uint1 x119; + uint32_t x120; + fiat_secp256k1_scalar_uint1 x121; + uint32_t x122; + fiat_secp256k1_scalar_uint1 x123; + uint32_t x124; + fiat_secp256k1_scalar_uint1 x125; + uint32_t x126; + fiat_secp256k1_scalar_uint1 x127; + uint32_t x128; + fiat_secp256k1_scalar_uint1 x129; + uint32_t x130; + fiat_secp256k1_scalar_uint1 x131; + uint32_t x132; + fiat_secp256k1_scalar_uint1 x133; + uint32_t x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + uint32_t x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + uint32_t x145; + uint32_t x146; + uint32_t x147; + uint32_t x148; + uint32_t x149; + uint32_t x150; + uint32_t x151; + uint32_t x152; + fiat_secp256k1_scalar_uint1 x153; + uint32_t x154; + fiat_secp256k1_scalar_uint1 x155; + uint32_t x156; + fiat_secp256k1_scalar_uint1 x157; + uint32_t x158; + fiat_secp256k1_scalar_uint1 x159; + uint32_t x160; + fiat_secp256k1_scalar_uint1 x161; + uint32_t x162; + fiat_secp256k1_scalar_uint1 x163; + uint32_t x164; + fiat_secp256k1_scalar_uint1 x165; + uint32_t x166; + fiat_secp256k1_scalar_uint1 x167; + uint32_t x168; + fiat_secp256k1_scalar_uint1 x169; + uint32_t x170; + fiat_secp256k1_scalar_uint1 x171; + uint32_t x172; + fiat_secp256k1_scalar_uint1 x173; + uint32_t x174; + fiat_secp256k1_scalar_uint1 x175; + uint32_t x176; + fiat_secp256k1_scalar_uint1 x177; + uint32_t x178; + fiat_secp256k1_scalar_uint1 x179; + uint32_t x180; + fiat_secp256k1_scalar_uint1 x181; + uint32_t x182; + fiat_secp256k1_scalar_uint1 x183; + uint32_t x184; + fiat_secp256k1_scalar_uint1 x185; + uint32_t x186; + fiat_secp256k1_scalar_uint1 x187; + uint32_t x188; + fiat_secp256k1_scalar_uint1 x189; + uint32_t x190; + fiat_secp256k1_scalar_uint1 x191; + uint32_t x192; + fiat_secp256k1_scalar_uint1 x193; + uint32_t x194; + fiat_secp256k1_scalar_uint1 x195; + uint32_t x196; + fiat_secp256k1_scalar_uint1 x197; + uint32_t x198; + fiat_secp256k1_scalar_uint1 x199; + uint32_t x200; + uint32_t x201; + uint32_t x202; + uint32_t x203; + uint32_t x204; + uint32_t x205; + uint32_t x206; + uint32_t x207; + uint32_t x208; + uint32_t x209; + uint32_t x210; + uint32_t x211; + uint32_t x212; + uint32_t x213; + uint32_t x214; + uint32_t x215; + uint32_t x216; + uint32_t x217; + uint32_t x218; + fiat_secp256k1_scalar_uint1 x219; + uint32_t x220; + fiat_secp256k1_scalar_uint1 x221; + uint32_t x222; + fiat_secp256k1_scalar_uint1 x223; + uint32_t x224; + fiat_secp256k1_scalar_uint1 x225; + uint32_t x226; + fiat_secp256k1_scalar_uint1 x227; + uint32_t x228; + fiat_secp256k1_scalar_uint1 x229; + uint32_t x230; + fiat_secp256k1_scalar_uint1 x231; + uint32_t x232; + fiat_secp256k1_scalar_uint1 x233; + uint32_t x234; + fiat_secp256k1_scalar_uint1 x235; + uint32_t x236; + fiat_secp256k1_scalar_uint1 x237; + uint32_t x238; + fiat_secp256k1_scalar_uint1 x239; + uint32_t x240; + fiat_secp256k1_scalar_uint1 x241; + uint32_t x242; + fiat_secp256k1_scalar_uint1 x243; + uint32_t x244; + fiat_secp256k1_scalar_uint1 x245; + uint32_t x246; + fiat_secp256k1_scalar_uint1 x247; + uint32_t x248; + fiat_secp256k1_scalar_uint1 x249; + uint32_t x250; + fiat_secp256k1_scalar_uint1 x251; + uint32_t x252; + fiat_secp256k1_scalar_uint1 x253; + uint32_t x254; + fiat_secp256k1_scalar_uint1 x255; + uint32_t x256; + fiat_secp256k1_scalar_uint1 x257; + uint32_t x258; + fiat_secp256k1_scalar_uint1 x259; + uint32_t x260; + fiat_secp256k1_scalar_uint1 x261; + uint32_t x262; + fiat_secp256k1_scalar_uint1 x263; + uint32_t x264; + fiat_secp256k1_scalar_uint1 x265; + uint32_t x266; + uint32_t x267; + uint32_t x268; + uint32_t x269; + uint32_t x270; + uint32_t x271; + uint32_t x272; + uint32_t x273; + uint32_t x274; + uint32_t x275; + uint32_t x276; + uint32_t x277; + uint32_t x278; + uint32_t x279; + uint32_t x280; + uint32_t x281; + uint32_t x282; + uint32_t x283; + uint32_t x284; + fiat_secp256k1_scalar_uint1 x285; + uint32_t x286; + fiat_secp256k1_scalar_uint1 x287; + uint32_t x288; + fiat_secp256k1_scalar_uint1 x289; + uint32_t x290; + fiat_secp256k1_scalar_uint1 x291; + uint32_t x292; + fiat_secp256k1_scalar_uint1 x293; + uint32_t x294; + fiat_secp256k1_scalar_uint1 x295; + uint32_t x296; + fiat_secp256k1_scalar_uint1 x297; + uint32_t x298; + fiat_secp256k1_scalar_uint1 x299; + uint32_t x300; + fiat_secp256k1_scalar_uint1 x301; + uint32_t x302; + fiat_secp256k1_scalar_uint1 x303; + uint32_t x304; + fiat_secp256k1_scalar_uint1 x305; + uint32_t x306; + fiat_secp256k1_scalar_uint1 x307; + uint32_t x308; + fiat_secp256k1_scalar_uint1 x309; + uint32_t x310; + fiat_secp256k1_scalar_uint1 x311; + uint32_t x312; + fiat_secp256k1_scalar_uint1 x313; + uint32_t x314; + fiat_secp256k1_scalar_uint1 x315; + uint32_t x316; + fiat_secp256k1_scalar_uint1 x317; + uint32_t x318; + fiat_secp256k1_scalar_uint1 x319; + uint32_t x320; + fiat_secp256k1_scalar_uint1 x321; + uint32_t x322; + fiat_secp256k1_scalar_uint1 x323; + uint32_t x324; + fiat_secp256k1_scalar_uint1 x325; + uint32_t x326; + fiat_secp256k1_scalar_uint1 x327; + uint32_t x328; + fiat_secp256k1_scalar_uint1 x329; + uint32_t x330; + fiat_secp256k1_scalar_uint1 x331; + uint32_t x332; + uint32_t x333; + uint32_t x334; + uint32_t x335; + uint32_t x336; + uint32_t x337; + uint32_t x338; + uint32_t x339; + uint32_t x340; + uint32_t x341; + uint32_t x342; + uint32_t x343; + uint32_t x344; + uint32_t x345; + uint32_t x346; + uint32_t x347; + uint32_t x348; + uint32_t x349; + uint32_t x350; + fiat_secp256k1_scalar_uint1 x351; + uint32_t x352; + fiat_secp256k1_scalar_uint1 x353; + uint32_t x354; + fiat_secp256k1_scalar_uint1 x355; + uint32_t x356; + fiat_secp256k1_scalar_uint1 x357; + uint32_t x358; + fiat_secp256k1_scalar_uint1 x359; + uint32_t x360; + fiat_secp256k1_scalar_uint1 x361; + uint32_t x362; + fiat_secp256k1_scalar_uint1 x363; + uint32_t x364; + fiat_secp256k1_scalar_uint1 x365; + uint32_t x366; + fiat_secp256k1_scalar_uint1 x367; + uint32_t x368; + fiat_secp256k1_scalar_uint1 x369; + uint32_t x370; + fiat_secp256k1_scalar_uint1 x371; + uint32_t x372; + fiat_secp256k1_scalar_uint1 x373; + uint32_t x374; + fiat_secp256k1_scalar_uint1 x375; + uint32_t x376; + fiat_secp256k1_scalar_uint1 x377; + uint32_t x378; + fiat_secp256k1_scalar_uint1 x379; + uint32_t x380; + fiat_secp256k1_scalar_uint1 x381; + uint32_t x382; + fiat_secp256k1_scalar_uint1 x383; + uint32_t x384; + fiat_secp256k1_scalar_uint1 x385; + uint32_t x386; + fiat_secp256k1_scalar_uint1 x387; + uint32_t x388; + fiat_secp256k1_scalar_uint1 x389; + uint32_t x390; + fiat_secp256k1_scalar_uint1 x391; + uint32_t x392; + fiat_secp256k1_scalar_uint1 x393; + uint32_t x394; + fiat_secp256k1_scalar_uint1 x395; + uint32_t x396; + fiat_secp256k1_scalar_uint1 x397; + uint32_t x398; + uint32_t x399; + uint32_t x400; + uint32_t x401; + uint32_t x402; + uint32_t x403; + uint32_t x404; + uint32_t x405; + uint32_t x406; + uint32_t x407; + uint32_t x408; + uint32_t x409; + uint32_t x410; + uint32_t x411; + uint32_t x412; + uint32_t x413; + uint32_t x414; + uint32_t x415; + uint32_t x416; + fiat_secp256k1_scalar_uint1 x417; + uint32_t x418; + fiat_secp256k1_scalar_uint1 x419; + uint32_t x420; + fiat_secp256k1_scalar_uint1 x421; + uint32_t x422; + fiat_secp256k1_scalar_uint1 x423; + uint32_t x424; + fiat_secp256k1_scalar_uint1 x425; + uint32_t x426; + fiat_secp256k1_scalar_uint1 x427; + uint32_t x428; + fiat_secp256k1_scalar_uint1 x429; + uint32_t x430; + fiat_secp256k1_scalar_uint1 x431; + uint32_t x432; + fiat_secp256k1_scalar_uint1 x433; + uint32_t x434; + fiat_secp256k1_scalar_uint1 x435; + uint32_t x436; + fiat_secp256k1_scalar_uint1 x437; + uint32_t x438; + fiat_secp256k1_scalar_uint1 x439; + uint32_t x440; + fiat_secp256k1_scalar_uint1 x441; + uint32_t x442; + fiat_secp256k1_scalar_uint1 x443; + uint32_t x444; + fiat_secp256k1_scalar_uint1 x445; + uint32_t x446; + fiat_secp256k1_scalar_uint1 x447; + uint32_t x448; + fiat_secp256k1_scalar_uint1 x449; + uint32_t x450; + fiat_secp256k1_scalar_uint1 x451; + uint32_t x452; + fiat_secp256k1_scalar_uint1 x453; + uint32_t x454; + fiat_secp256k1_scalar_uint1 x455; + uint32_t x456; + fiat_secp256k1_scalar_uint1 x457; + uint32_t x458; + fiat_secp256k1_scalar_uint1 x459; + uint32_t x460; + fiat_secp256k1_scalar_uint1 x461; + uint32_t x462; + fiat_secp256k1_scalar_uint1 x463; + uint32_t x464; + uint32_t x465; + uint32_t x466; + uint32_t x467; + uint32_t x468; + uint32_t x469; + uint32_t x470; + uint32_t x471; + uint32_t x472; + uint32_t x473; + uint32_t x474; + uint32_t x475; + uint32_t x476; + uint32_t x477; + uint32_t x478; + uint32_t x479; + uint32_t x480; + uint32_t x481; + uint32_t x482; + fiat_secp256k1_scalar_uint1 x483; + uint32_t x484; + fiat_secp256k1_scalar_uint1 x485; + uint32_t x486; + fiat_secp256k1_scalar_uint1 x487; + uint32_t x488; + fiat_secp256k1_scalar_uint1 x489; + uint32_t x490; + fiat_secp256k1_scalar_uint1 x491; + uint32_t x492; + fiat_secp256k1_scalar_uint1 x493; + uint32_t x494; + fiat_secp256k1_scalar_uint1 x495; + uint32_t x496; + fiat_secp256k1_scalar_uint1 x497; + uint32_t x498; + fiat_secp256k1_scalar_uint1 x499; + uint32_t x500; + fiat_secp256k1_scalar_uint1 x501; + uint32_t x502; + fiat_secp256k1_scalar_uint1 x503; + uint32_t x504; + fiat_secp256k1_scalar_uint1 x505; + uint32_t x506; + fiat_secp256k1_scalar_uint1 x507; + uint32_t x508; + fiat_secp256k1_scalar_uint1 x509; + uint32_t x510; + fiat_secp256k1_scalar_uint1 x511; + uint32_t x512; + fiat_secp256k1_scalar_uint1 x513; + uint32_t x514; + fiat_secp256k1_scalar_uint1 x515; + uint32_t x516; + fiat_secp256k1_scalar_uint1 x517; + uint32_t x518; + fiat_secp256k1_scalar_uint1 x519; + uint32_t x520; + fiat_secp256k1_scalar_uint1 x521; + uint32_t x522; + fiat_secp256k1_scalar_uint1 x523; + uint32_t x524; + fiat_secp256k1_scalar_uint1 x525; + uint32_t x526; + fiat_secp256k1_scalar_uint1 x527; + uint32_t x528; + fiat_secp256k1_scalar_uint1 x529; + uint32_t x530; + fiat_secp256k1_scalar_uint1 x531; + uint32_t x532; + uint32_t x533; + uint32_t x534; + uint32_t x535; + uint32_t x536; + uint32_t x537; + uint32_t x538; + uint32_t x539; + x1 = (arg1[0]); + fiat_secp256k1_scalar_mulx_u32(&x2, &x3, x1, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x4, &x5, x2, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x6, &x7, x2, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x8, &x9, x2, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x10, &x11, x2, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x12, &x13, x2, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x14, &x15, x2, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x16, &x17, x2, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x18, &x19, x2, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x20, &x21, 0x0, x19, x16); + fiat_secp256k1_scalar_addcarryx_u32(&x22, &x23, x21, x17, x14); + fiat_secp256k1_scalar_addcarryx_u32(&x24, &x25, x23, x15, x12); + fiat_secp256k1_scalar_addcarryx_u32(&x26, &x27, x25, x13, x10); + fiat_secp256k1_scalar_addcarryx_u32(&x28, &x29, x27, x11, x8); + fiat_secp256k1_scalar_addcarryx_u32(&x30, &x31, x29, x9, x6); + fiat_secp256k1_scalar_addcarryx_u32(&x32, &x33, x31, x7, x4); + fiat_secp256k1_scalar_addcarryx_u32(&x34, &x35, 0x0, x1, x18); + fiat_secp256k1_scalar_addcarryx_u32(&x36, &x37, x35, 0x0, x20); + fiat_secp256k1_scalar_addcarryx_u32(&x38, &x39, x37, 0x0, x22); + fiat_secp256k1_scalar_addcarryx_u32(&x40, &x41, x39, 0x0, x24); + fiat_secp256k1_scalar_addcarryx_u32(&x42, &x43, x41, 0x0, x26); + fiat_secp256k1_scalar_addcarryx_u32(&x44, &x45, x43, 0x0, x28); + fiat_secp256k1_scalar_addcarryx_u32(&x46, &x47, x45, 0x0, x30); + fiat_secp256k1_scalar_addcarryx_u32(&x48, &x49, x47, 0x0, x32); + fiat_secp256k1_scalar_addcarryx_u32(&x50, &x51, x49, 0x0, (x33 + x5)); + fiat_secp256k1_scalar_addcarryx_u32(&x52, &x53, 0x0, x36, (arg1[1])); + fiat_secp256k1_scalar_addcarryx_u32(&x54, &x55, x53, x38, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x56, &x57, x55, x40, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x58, &x59, x57, x42, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x60, &x61, x59, x44, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x62, &x63, x61, x46, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x64, &x65, x63, x48, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x66, &x67, x65, x50, 0x0); + fiat_secp256k1_scalar_mulx_u32(&x68, &x69, x52, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x70, &x71, x68, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x72, &x73, x68, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x74, &x75, x68, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x76, &x77, x68, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x78, &x79, x68, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x80, &x81, x68, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x82, &x83, x68, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x84, &x85, x68, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x86, &x87, 0x0, x85, x82); + fiat_secp256k1_scalar_addcarryx_u32(&x88, &x89, x87, x83, x80); + fiat_secp256k1_scalar_addcarryx_u32(&x90, &x91, x89, x81, x78); + fiat_secp256k1_scalar_addcarryx_u32(&x92, &x93, x91, x79, x76); + fiat_secp256k1_scalar_addcarryx_u32(&x94, &x95, x93, x77, x74); + fiat_secp256k1_scalar_addcarryx_u32(&x96, &x97, x95, x75, x72); + fiat_secp256k1_scalar_addcarryx_u32(&x98, &x99, x97, x73, x70); + fiat_secp256k1_scalar_addcarryx_u32(&x100, &x101, 0x0, x52, x84); + fiat_secp256k1_scalar_addcarryx_u32(&x102, &x103, x101, x54, x86); + fiat_secp256k1_scalar_addcarryx_u32(&x104, &x105, x103, x56, x88); + fiat_secp256k1_scalar_addcarryx_u32(&x106, &x107, x105, x58, x90); + fiat_secp256k1_scalar_addcarryx_u32(&x108, &x109, x107, x60, x92); + fiat_secp256k1_scalar_addcarryx_u32(&x110, &x111, x109, x62, x94); + fiat_secp256k1_scalar_addcarryx_u32(&x112, &x113, x111, x64, x96); + fiat_secp256k1_scalar_addcarryx_u32(&x114, &x115, x113, x66, x98); + fiat_secp256k1_scalar_addcarryx_u32(&x116, &x117, x115, ((uint32_t)x67 + x51), (x99 + x71)); + fiat_secp256k1_scalar_addcarryx_u32(&x118, &x119, 0x0, x102, (arg1[2])); + fiat_secp256k1_scalar_addcarryx_u32(&x120, &x121, x119, x104, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x122, &x123, x121, x106, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x124, &x125, x123, x108, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x126, &x127, x125, x110, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x128, &x129, x127, x112, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x130, &x131, x129, x114, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x132, &x133, x131, x116, 0x0); + fiat_secp256k1_scalar_mulx_u32(&x134, &x135, x118, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x136, &x137, x134, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x138, &x139, x134, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x140, &x141, x134, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x142, &x143, x134, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x144, &x145, x134, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x146, &x147, x134, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x148, &x149, x134, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x150, &x151, x134, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x152, &x153, 0x0, x151, x148); + fiat_secp256k1_scalar_addcarryx_u32(&x154, &x155, x153, x149, x146); + fiat_secp256k1_scalar_addcarryx_u32(&x156, &x157, x155, x147, x144); + fiat_secp256k1_scalar_addcarryx_u32(&x158, &x159, x157, x145, x142); + fiat_secp256k1_scalar_addcarryx_u32(&x160, &x161, x159, x143, x140); + fiat_secp256k1_scalar_addcarryx_u32(&x162, &x163, x161, x141, x138); + fiat_secp256k1_scalar_addcarryx_u32(&x164, &x165, x163, x139, x136); + fiat_secp256k1_scalar_addcarryx_u32(&x166, &x167, 0x0, x118, x150); + fiat_secp256k1_scalar_addcarryx_u32(&x168, &x169, x167, x120, x152); + fiat_secp256k1_scalar_addcarryx_u32(&x170, &x171, x169, x122, x154); + fiat_secp256k1_scalar_addcarryx_u32(&x172, &x173, x171, x124, x156); + fiat_secp256k1_scalar_addcarryx_u32(&x174, &x175, x173, x126, x158); + fiat_secp256k1_scalar_addcarryx_u32(&x176, &x177, x175, x128, x160); + fiat_secp256k1_scalar_addcarryx_u32(&x178, &x179, x177, x130, x162); + fiat_secp256k1_scalar_addcarryx_u32(&x180, &x181, x179, x132, x164); + fiat_secp256k1_scalar_addcarryx_u32(&x182, &x183, x181, ((uint32_t)x133 + x117), (x165 + x137)); + fiat_secp256k1_scalar_addcarryx_u32(&x184, &x185, 0x0, x168, (arg1[3])); + fiat_secp256k1_scalar_addcarryx_u32(&x186, &x187, x185, x170, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x188, &x189, x187, x172, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x190, &x191, x189, x174, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x192, &x193, x191, x176, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x194, &x195, x193, x178, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x196, &x197, x195, x180, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x198, &x199, x197, x182, 0x0); + fiat_secp256k1_scalar_mulx_u32(&x200, &x201, x184, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x202, &x203, x200, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x204, &x205, x200, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x206, &x207, x200, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x208, &x209, x200, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x210, &x211, x200, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x212, &x213, x200, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x214, &x215, x200, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x216, &x217, x200, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x218, &x219, 0x0, x217, x214); + fiat_secp256k1_scalar_addcarryx_u32(&x220, &x221, x219, x215, x212); + fiat_secp256k1_scalar_addcarryx_u32(&x222, &x223, x221, x213, x210); + fiat_secp256k1_scalar_addcarryx_u32(&x224, &x225, x223, x211, x208); + fiat_secp256k1_scalar_addcarryx_u32(&x226, &x227, x225, x209, x206); + fiat_secp256k1_scalar_addcarryx_u32(&x228, &x229, x227, x207, x204); + fiat_secp256k1_scalar_addcarryx_u32(&x230, &x231, x229, x205, x202); + fiat_secp256k1_scalar_addcarryx_u32(&x232, &x233, 0x0, x184, x216); + fiat_secp256k1_scalar_addcarryx_u32(&x234, &x235, x233, x186, x218); + fiat_secp256k1_scalar_addcarryx_u32(&x236, &x237, x235, x188, x220); + fiat_secp256k1_scalar_addcarryx_u32(&x238, &x239, x237, x190, x222); + fiat_secp256k1_scalar_addcarryx_u32(&x240, &x241, x239, x192, x224); + fiat_secp256k1_scalar_addcarryx_u32(&x242, &x243, x241, x194, x226); + fiat_secp256k1_scalar_addcarryx_u32(&x244, &x245, x243, x196, x228); + fiat_secp256k1_scalar_addcarryx_u32(&x246, &x247, x245, x198, x230); + fiat_secp256k1_scalar_addcarryx_u32(&x248, &x249, x247, ((uint32_t)x199 + x183), (x231 + x203)); + fiat_secp256k1_scalar_addcarryx_u32(&x250, &x251, 0x0, x234, (arg1[4])); + fiat_secp256k1_scalar_addcarryx_u32(&x252, &x253, x251, x236, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x254, &x255, x253, x238, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x256, &x257, x255, x240, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x258, &x259, x257, x242, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x260, &x261, x259, x244, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x262, &x263, x261, x246, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x264, &x265, x263, x248, 0x0); + fiat_secp256k1_scalar_mulx_u32(&x266, &x267, x250, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x268, &x269, x266, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x270, &x271, x266, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x272, &x273, x266, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x274, &x275, x266, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x276, &x277, x266, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x278, &x279, x266, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x280, &x281, x266, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x282, &x283, x266, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x284, &x285, 0x0, x283, x280); + fiat_secp256k1_scalar_addcarryx_u32(&x286, &x287, x285, x281, x278); + fiat_secp256k1_scalar_addcarryx_u32(&x288, &x289, x287, x279, x276); + fiat_secp256k1_scalar_addcarryx_u32(&x290, &x291, x289, x277, x274); + fiat_secp256k1_scalar_addcarryx_u32(&x292, &x293, x291, x275, x272); + fiat_secp256k1_scalar_addcarryx_u32(&x294, &x295, x293, x273, x270); + fiat_secp256k1_scalar_addcarryx_u32(&x296, &x297, x295, x271, x268); + fiat_secp256k1_scalar_addcarryx_u32(&x298, &x299, 0x0, x250, x282); + fiat_secp256k1_scalar_addcarryx_u32(&x300, &x301, x299, x252, x284); + fiat_secp256k1_scalar_addcarryx_u32(&x302, &x303, x301, x254, x286); + fiat_secp256k1_scalar_addcarryx_u32(&x304, &x305, x303, x256, x288); + fiat_secp256k1_scalar_addcarryx_u32(&x306, &x307, x305, x258, x290); + fiat_secp256k1_scalar_addcarryx_u32(&x308, &x309, x307, x260, x292); + fiat_secp256k1_scalar_addcarryx_u32(&x310, &x311, x309, x262, x294); + fiat_secp256k1_scalar_addcarryx_u32(&x312, &x313, x311, x264, x296); + fiat_secp256k1_scalar_addcarryx_u32(&x314, &x315, x313, ((uint32_t)x265 + x249), (x297 + x269)); + fiat_secp256k1_scalar_addcarryx_u32(&x316, &x317, 0x0, x300, (arg1[5])); + fiat_secp256k1_scalar_addcarryx_u32(&x318, &x319, x317, x302, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x320, &x321, x319, x304, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x322, &x323, x321, x306, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x324, &x325, x323, x308, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x326, &x327, x325, x310, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x328, &x329, x327, x312, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x330, &x331, x329, x314, 0x0); + fiat_secp256k1_scalar_mulx_u32(&x332, &x333, x316, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x334, &x335, x332, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x336, &x337, x332, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x338, &x339, x332, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x340, &x341, x332, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x342, &x343, x332, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x344, &x345, x332, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x346, &x347, x332, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x348, &x349, x332, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x350, &x351, 0x0, x349, x346); + fiat_secp256k1_scalar_addcarryx_u32(&x352, &x353, x351, x347, x344); + fiat_secp256k1_scalar_addcarryx_u32(&x354, &x355, x353, x345, x342); + fiat_secp256k1_scalar_addcarryx_u32(&x356, &x357, x355, x343, x340); + fiat_secp256k1_scalar_addcarryx_u32(&x358, &x359, x357, x341, x338); + fiat_secp256k1_scalar_addcarryx_u32(&x360, &x361, x359, x339, x336); + fiat_secp256k1_scalar_addcarryx_u32(&x362, &x363, x361, x337, x334); + fiat_secp256k1_scalar_addcarryx_u32(&x364, &x365, 0x0, x316, x348); + fiat_secp256k1_scalar_addcarryx_u32(&x366, &x367, x365, x318, x350); + fiat_secp256k1_scalar_addcarryx_u32(&x368, &x369, x367, x320, x352); + fiat_secp256k1_scalar_addcarryx_u32(&x370, &x371, x369, x322, x354); + fiat_secp256k1_scalar_addcarryx_u32(&x372, &x373, x371, x324, x356); + fiat_secp256k1_scalar_addcarryx_u32(&x374, &x375, x373, x326, x358); + fiat_secp256k1_scalar_addcarryx_u32(&x376, &x377, x375, x328, x360); + fiat_secp256k1_scalar_addcarryx_u32(&x378, &x379, x377, x330, x362); + fiat_secp256k1_scalar_addcarryx_u32(&x380, &x381, x379, ((uint32_t)x331 + x315), (x363 + x335)); + fiat_secp256k1_scalar_addcarryx_u32(&x382, &x383, 0x0, x366, (arg1[6])); + fiat_secp256k1_scalar_addcarryx_u32(&x384, &x385, x383, x368, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x386, &x387, x385, x370, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x388, &x389, x387, x372, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x390, &x391, x389, x374, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x392, &x393, x391, x376, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x394, &x395, x393, x378, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x396, &x397, x395, x380, 0x0); + fiat_secp256k1_scalar_mulx_u32(&x398, &x399, x382, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x400, &x401, x398, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x402, &x403, x398, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x404, &x405, x398, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x406, &x407, x398, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x408, &x409, x398, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x410, &x411, x398, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x412, &x413, x398, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x414, &x415, x398, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x416, &x417, 0x0, x415, x412); + fiat_secp256k1_scalar_addcarryx_u32(&x418, &x419, x417, x413, x410); + fiat_secp256k1_scalar_addcarryx_u32(&x420, &x421, x419, x411, x408); + fiat_secp256k1_scalar_addcarryx_u32(&x422, &x423, x421, x409, x406); + fiat_secp256k1_scalar_addcarryx_u32(&x424, &x425, x423, x407, x404); + fiat_secp256k1_scalar_addcarryx_u32(&x426, &x427, x425, x405, x402); + fiat_secp256k1_scalar_addcarryx_u32(&x428, &x429, x427, x403, x400); + fiat_secp256k1_scalar_addcarryx_u32(&x430, &x431, 0x0, x382, x414); + fiat_secp256k1_scalar_addcarryx_u32(&x432, &x433, x431, x384, x416); + fiat_secp256k1_scalar_addcarryx_u32(&x434, &x435, x433, x386, x418); + fiat_secp256k1_scalar_addcarryx_u32(&x436, &x437, x435, x388, x420); + fiat_secp256k1_scalar_addcarryx_u32(&x438, &x439, x437, x390, x422); + fiat_secp256k1_scalar_addcarryx_u32(&x440, &x441, x439, x392, x424); + fiat_secp256k1_scalar_addcarryx_u32(&x442, &x443, x441, x394, x426); + fiat_secp256k1_scalar_addcarryx_u32(&x444, &x445, x443, x396, x428); + fiat_secp256k1_scalar_addcarryx_u32(&x446, &x447, x445, ((uint32_t)x397 + x381), (x429 + x401)); + fiat_secp256k1_scalar_addcarryx_u32(&x448, &x449, 0x0, x432, (arg1[7])); + fiat_secp256k1_scalar_addcarryx_u32(&x450, &x451, x449, x434, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x452, &x453, x451, x436, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x454, &x455, x453, x438, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x456, &x457, x455, x440, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x458, &x459, x457, x442, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x460, &x461, x459, x444, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x462, &x463, x461, x446, 0x0); + fiat_secp256k1_scalar_mulx_u32(&x464, &x465, x448, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x466, &x467, x464, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x468, &x469, x464, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x470, &x471, x464, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x472, &x473, x464, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x474, &x475, x464, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x476, &x477, x464, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x478, &x479, x464, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x480, &x481, x464, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x482, &x483, 0x0, x481, x478); + fiat_secp256k1_scalar_addcarryx_u32(&x484, &x485, x483, x479, x476); + fiat_secp256k1_scalar_addcarryx_u32(&x486, &x487, x485, x477, x474); + fiat_secp256k1_scalar_addcarryx_u32(&x488, &x489, x487, x475, x472); + fiat_secp256k1_scalar_addcarryx_u32(&x490, &x491, x489, x473, x470); + fiat_secp256k1_scalar_addcarryx_u32(&x492, &x493, x491, x471, x468); + fiat_secp256k1_scalar_addcarryx_u32(&x494, &x495, x493, x469, x466); + fiat_secp256k1_scalar_addcarryx_u32(&x496, &x497, 0x0, x448, x480); + fiat_secp256k1_scalar_addcarryx_u32(&x498, &x499, x497, x450, x482); + fiat_secp256k1_scalar_addcarryx_u32(&x500, &x501, x499, x452, x484); + fiat_secp256k1_scalar_addcarryx_u32(&x502, &x503, x501, x454, x486); + fiat_secp256k1_scalar_addcarryx_u32(&x504, &x505, x503, x456, x488); + fiat_secp256k1_scalar_addcarryx_u32(&x506, &x507, x505, x458, x490); + fiat_secp256k1_scalar_addcarryx_u32(&x508, &x509, x507, x460, x492); + fiat_secp256k1_scalar_addcarryx_u32(&x510, &x511, x509, x462, x494); + fiat_secp256k1_scalar_addcarryx_u32(&x512, &x513, x511, ((uint32_t)x463 + x447), (x495 + x467)); + fiat_secp256k1_scalar_subborrowx_u32(&x514, &x515, 0x0, x498, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_subborrowx_u32(&x516, &x517, x515, x500, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_subborrowx_u32(&x518, &x519, x517, x502, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_subborrowx_u32(&x520, &x521, x519, x504, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_subborrowx_u32(&x522, &x523, x521, x506, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_subborrowx_u32(&x524, &x525, x523, x508, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x526, &x527, x525, x510, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x528, &x529, x527, x512, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x530, &x531, x529, x513, 0x0); + fiat_secp256k1_scalar_cmovznz_u32(&x532, x531, x514, x498); + fiat_secp256k1_scalar_cmovznz_u32(&x533, x531, x516, x500); + fiat_secp256k1_scalar_cmovznz_u32(&x534, x531, x518, x502); + fiat_secp256k1_scalar_cmovznz_u32(&x535, x531, x520, x504); + fiat_secp256k1_scalar_cmovznz_u32(&x536, x531, x522, x506); + fiat_secp256k1_scalar_cmovznz_u32(&x537, x531, x524, x508); + fiat_secp256k1_scalar_cmovznz_u32(&x538, x531, x526, x510); + fiat_secp256k1_scalar_cmovznz_u32(&x539, x531, x528, x512); + out1[0] = x532; + out1[1] = x533; + out1[2] = x534; + out1[3] = x535; + out1[4] = x536; + out1[5] = x537; + out1[6] = x538; + out1[7] = x539; +} + +/* + * The function fiat_secp256k1_scalar_to_montgomery translates a field element into the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = eval arg1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_to_montgomery(fiat_secp256k1_scalar_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_non_montgomery_domain_field_element arg1) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint32_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint32_t x24; + uint32_t x25; + fiat_secp256k1_scalar_uint1 x26; + uint32_t x27; + fiat_secp256k1_scalar_uint1 x28; + uint32_t x29; + fiat_secp256k1_scalar_uint1 x30; + uint32_t x31; + fiat_secp256k1_scalar_uint1 x32; + uint32_t x33; + fiat_secp256k1_scalar_uint1 x34; + uint32_t x35; + fiat_secp256k1_scalar_uint1 x36; + uint32_t x37; + fiat_secp256k1_scalar_uint1 x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + uint32_t x53; + uint32_t x54; + uint32_t x55; + uint32_t x56; + uint32_t x57; + fiat_secp256k1_scalar_uint1 x58; + uint32_t x59; + fiat_secp256k1_scalar_uint1 x60; + uint32_t x61; + fiat_secp256k1_scalar_uint1 x62; + uint32_t x63; + fiat_secp256k1_scalar_uint1 x64; + uint32_t x65; + fiat_secp256k1_scalar_uint1 x66; + uint32_t x67; + fiat_secp256k1_scalar_uint1 x68; + uint32_t x69; + fiat_secp256k1_scalar_uint1 x70; + uint32_t x71; + fiat_secp256k1_scalar_uint1 x72; + uint32_t x73; + fiat_secp256k1_scalar_uint1 x74; + uint32_t x75; + fiat_secp256k1_scalar_uint1 x76; + uint32_t x77; + fiat_secp256k1_scalar_uint1 x78; + uint32_t x79; + fiat_secp256k1_scalar_uint1 x80; + uint32_t x81; + fiat_secp256k1_scalar_uint1 x82; + uint32_t x83; + fiat_secp256k1_scalar_uint1 x84; + uint32_t x85; + fiat_secp256k1_scalar_uint1 x86; + uint32_t x87; + fiat_secp256k1_scalar_uint1 x88; + uint32_t x89; + uint32_t x90; + uint32_t x91; + uint32_t x92; + uint32_t x93; + uint32_t x94; + uint32_t x95; + uint32_t x96; + uint32_t x97; + uint32_t x98; + uint32_t x99; + uint32_t x100; + uint32_t x101; + uint32_t x102; + uint32_t x103; + uint32_t x104; + uint32_t x105; + fiat_secp256k1_scalar_uint1 x106; + uint32_t x107; + fiat_secp256k1_scalar_uint1 x108; + uint32_t x109; + fiat_secp256k1_scalar_uint1 x110; + uint32_t x111; + fiat_secp256k1_scalar_uint1 x112; + uint32_t x113; + fiat_secp256k1_scalar_uint1 x114; + uint32_t x115; + fiat_secp256k1_scalar_uint1 x116; + uint32_t x117; + fiat_secp256k1_scalar_uint1 x118; + uint32_t x119; + fiat_secp256k1_scalar_uint1 x120; + uint32_t x121; + fiat_secp256k1_scalar_uint1 x122; + uint32_t x123; + fiat_secp256k1_scalar_uint1 x124; + uint32_t x125; + fiat_secp256k1_scalar_uint1 x126; + uint32_t x127; + fiat_secp256k1_scalar_uint1 x128; + uint32_t x129; + fiat_secp256k1_scalar_uint1 x130; + uint32_t x131; + fiat_secp256k1_scalar_uint1 x132; + uint32_t x133; + fiat_secp256k1_scalar_uint1 x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + uint32_t x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + uint32_t x145; + uint32_t x146; + uint32_t x147; + uint32_t x148; + uint32_t x149; + uint32_t x150; + uint32_t x151; + uint32_t x152; + uint32_t x153; + fiat_secp256k1_scalar_uint1 x154; + uint32_t x155; + fiat_secp256k1_scalar_uint1 x156; + uint32_t x157; + fiat_secp256k1_scalar_uint1 x158; + uint32_t x159; + fiat_secp256k1_scalar_uint1 x160; + uint32_t x161; + fiat_secp256k1_scalar_uint1 x162; + uint32_t x163; + fiat_secp256k1_scalar_uint1 x164; + uint32_t x165; + fiat_secp256k1_scalar_uint1 x166; + uint32_t x167; + fiat_secp256k1_scalar_uint1 x168; + uint32_t x169; + fiat_secp256k1_scalar_uint1 x170; + uint32_t x171; + fiat_secp256k1_scalar_uint1 x172; + uint32_t x173; + fiat_secp256k1_scalar_uint1 x174; + uint32_t x175; + fiat_secp256k1_scalar_uint1 x176; + uint32_t x177; + fiat_secp256k1_scalar_uint1 x178; + uint32_t x179; + fiat_secp256k1_scalar_uint1 x180; + uint32_t x181; + fiat_secp256k1_scalar_uint1 x182; + uint32_t x183; + fiat_secp256k1_scalar_uint1 x184; + uint32_t x185; + uint32_t x186; + uint32_t x187; + uint32_t x188; + uint32_t x189; + uint32_t x190; + uint32_t x191; + uint32_t x192; + uint32_t x193; + uint32_t x194; + uint32_t x195; + uint32_t x196; + uint32_t x197; + uint32_t x198; + uint32_t x199; + uint32_t x200; + uint32_t x201; + fiat_secp256k1_scalar_uint1 x202; + uint32_t x203; + fiat_secp256k1_scalar_uint1 x204; + uint32_t x205; + fiat_secp256k1_scalar_uint1 x206; + uint32_t x207; + fiat_secp256k1_scalar_uint1 x208; + uint32_t x209; + fiat_secp256k1_scalar_uint1 x210; + uint32_t x211; + fiat_secp256k1_scalar_uint1 x212; + uint32_t x213; + fiat_secp256k1_scalar_uint1 x214; + uint32_t x215; + fiat_secp256k1_scalar_uint1 x216; + uint32_t x217; + fiat_secp256k1_scalar_uint1 x218; + uint32_t x219; + fiat_secp256k1_scalar_uint1 x220; + uint32_t x221; + fiat_secp256k1_scalar_uint1 x222; + uint32_t x223; + fiat_secp256k1_scalar_uint1 x224; + uint32_t x225; + fiat_secp256k1_scalar_uint1 x226; + uint32_t x227; + fiat_secp256k1_scalar_uint1 x228; + uint32_t x229; + fiat_secp256k1_scalar_uint1 x230; + uint32_t x231; + uint32_t x232; + uint32_t x233; + uint32_t x234; + uint32_t x235; + uint32_t x236; + uint32_t x237; + uint32_t x238; + uint32_t x239; + uint32_t x240; + uint32_t x241; + uint32_t x242; + uint32_t x243; + uint32_t x244; + uint32_t x245; + uint32_t x246; + uint32_t x247; + uint32_t x248; + uint32_t x249; + fiat_secp256k1_scalar_uint1 x250; + uint32_t x251; + fiat_secp256k1_scalar_uint1 x252; + uint32_t x253; + fiat_secp256k1_scalar_uint1 x254; + uint32_t x255; + fiat_secp256k1_scalar_uint1 x256; + uint32_t x257; + fiat_secp256k1_scalar_uint1 x258; + uint32_t x259; + fiat_secp256k1_scalar_uint1 x260; + uint32_t x261; + fiat_secp256k1_scalar_uint1 x262; + uint32_t x263; + fiat_secp256k1_scalar_uint1 x264; + uint32_t x265; + fiat_secp256k1_scalar_uint1 x266; + uint32_t x267; + fiat_secp256k1_scalar_uint1 x268; + uint32_t x269; + fiat_secp256k1_scalar_uint1 x270; + uint32_t x271; + fiat_secp256k1_scalar_uint1 x272; + uint32_t x273; + fiat_secp256k1_scalar_uint1 x274; + uint32_t x275; + fiat_secp256k1_scalar_uint1 x276; + uint32_t x277; + fiat_secp256k1_scalar_uint1 x278; + uint32_t x279; + fiat_secp256k1_scalar_uint1 x280; + uint32_t x281; + uint32_t x282; + uint32_t x283; + uint32_t x284; + uint32_t x285; + uint32_t x286; + uint32_t x287; + uint32_t x288; + uint32_t x289; + uint32_t x290; + uint32_t x291; + uint32_t x292; + uint32_t x293; + uint32_t x294; + uint32_t x295; + uint32_t x296; + uint32_t x297; + fiat_secp256k1_scalar_uint1 x298; + uint32_t x299; + fiat_secp256k1_scalar_uint1 x300; + uint32_t x301; + fiat_secp256k1_scalar_uint1 x302; + uint32_t x303; + fiat_secp256k1_scalar_uint1 x304; + uint32_t x305; + fiat_secp256k1_scalar_uint1 x306; + uint32_t x307; + fiat_secp256k1_scalar_uint1 x308; + uint32_t x309; + fiat_secp256k1_scalar_uint1 x310; + uint32_t x311; + fiat_secp256k1_scalar_uint1 x312; + uint32_t x313; + fiat_secp256k1_scalar_uint1 x314; + uint32_t x315; + fiat_secp256k1_scalar_uint1 x316; + uint32_t x317; + fiat_secp256k1_scalar_uint1 x318; + uint32_t x319; + fiat_secp256k1_scalar_uint1 x320; + uint32_t x321; + fiat_secp256k1_scalar_uint1 x322; + uint32_t x323; + fiat_secp256k1_scalar_uint1 x324; + uint32_t x325; + fiat_secp256k1_scalar_uint1 x326; + uint32_t x327; + uint32_t x328; + uint32_t x329; + uint32_t x330; + uint32_t x331; + uint32_t x332; + uint32_t x333; + uint32_t x334; + uint32_t x335; + uint32_t x336; + uint32_t x337; + uint32_t x338; + uint32_t x339; + uint32_t x340; + uint32_t x341; + uint32_t x342; + uint32_t x343; + uint32_t x344; + uint32_t x345; + fiat_secp256k1_scalar_uint1 x346; + uint32_t x347; + fiat_secp256k1_scalar_uint1 x348; + uint32_t x349; + fiat_secp256k1_scalar_uint1 x350; + uint32_t x351; + fiat_secp256k1_scalar_uint1 x352; + uint32_t x353; + fiat_secp256k1_scalar_uint1 x354; + uint32_t x355; + fiat_secp256k1_scalar_uint1 x356; + uint32_t x357; + fiat_secp256k1_scalar_uint1 x358; + uint32_t x359; + fiat_secp256k1_scalar_uint1 x360; + uint32_t x361; + fiat_secp256k1_scalar_uint1 x362; + uint32_t x363; + fiat_secp256k1_scalar_uint1 x364; + uint32_t x365; + fiat_secp256k1_scalar_uint1 x366; + uint32_t x367; + fiat_secp256k1_scalar_uint1 x368; + uint32_t x369; + fiat_secp256k1_scalar_uint1 x370; + uint32_t x371; + fiat_secp256k1_scalar_uint1 x372; + uint32_t x373; + fiat_secp256k1_scalar_uint1 x374; + uint32_t x375; + fiat_secp256k1_scalar_uint1 x376; + uint32_t x377; + uint32_t x378; + uint32_t x379; + uint32_t x380; + uint32_t x381; + uint32_t x382; + uint32_t x383; + uint32_t x384; + uint32_t x385; + uint32_t x386; + uint32_t x387; + uint32_t x388; + uint32_t x389; + uint32_t x390; + uint32_t x391; + uint32_t x392; + uint32_t x393; + fiat_secp256k1_scalar_uint1 x394; + uint32_t x395; + fiat_secp256k1_scalar_uint1 x396; + uint32_t x397; + fiat_secp256k1_scalar_uint1 x398; + uint32_t x399; + fiat_secp256k1_scalar_uint1 x400; + uint32_t x401; + fiat_secp256k1_scalar_uint1 x402; + uint32_t x403; + fiat_secp256k1_scalar_uint1 x404; + uint32_t x405; + fiat_secp256k1_scalar_uint1 x406; + uint32_t x407; + fiat_secp256k1_scalar_uint1 x408; + uint32_t x409; + fiat_secp256k1_scalar_uint1 x410; + uint32_t x411; + fiat_secp256k1_scalar_uint1 x412; + uint32_t x413; + fiat_secp256k1_scalar_uint1 x414; + uint32_t x415; + fiat_secp256k1_scalar_uint1 x416; + uint32_t x417; + fiat_secp256k1_scalar_uint1 x418; + uint32_t x419; + fiat_secp256k1_scalar_uint1 x420; + uint32_t x421; + fiat_secp256k1_scalar_uint1 x422; + uint32_t x423; + uint32_t x424; + uint32_t x425; + uint32_t x426; + uint32_t x427; + uint32_t x428; + uint32_t x429; + uint32_t x430; + uint32_t x431; + uint32_t x432; + uint32_t x433; + uint32_t x434; + uint32_t x435; + uint32_t x436; + uint32_t x437; + uint32_t x438; + uint32_t x439; + uint32_t x440; + uint32_t x441; + fiat_secp256k1_scalar_uint1 x442; + uint32_t x443; + fiat_secp256k1_scalar_uint1 x444; + uint32_t x445; + fiat_secp256k1_scalar_uint1 x446; + uint32_t x447; + fiat_secp256k1_scalar_uint1 x448; + uint32_t x449; + fiat_secp256k1_scalar_uint1 x450; + uint32_t x451; + fiat_secp256k1_scalar_uint1 x452; + uint32_t x453; + fiat_secp256k1_scalar_uint1 x454; + uint32_t x455; + fiat_secp256k1_scalar_uint1 x456; + uint32_t x457; + fiat_secp256k1_scalar_uint1 x458; + uint32_t x459; + fiat_secp256k1_scalar_uint1 x460; + uint32_t x461; + fiat_secp256k1_scalar_uint1 x462; + uint32_t x463; + fiat_secp256k1_scalar_uint1 x464; + uint32_t x465; + fiat_secp256k1_scalar_uint1 x466; + uint32_t x467; + fiat_secp256k1_scalar_uint1 x468; + uint32_t x469; + fiat_secp256k1_scalar_uint1 x470; + uint32_t x471; + fiat_secp256k1_scalar_uint1 x472; + uint32_t x473; + uint32_t x474; + uint32_t x475; + uint32_t x476; + uint32_t x477; + uint32_t x478; + uint32_t x479; + uint32_t x480; + uint32_t x481; + uint32_t x482; + uint32_t x483; + uint32_t x484; + uint32_t x485; + uint32_t x486; + uint32_t x487; + uint32_t x488; + uint32_t x489; + fiat_secp256k1_scalar_uint1 x490; + uint32_t x491; + fiat_secp256k1_scalar_uint1 x492; + uint32_t x493; + fiat_secp256k1_scalar_uint1 x494; + uint32_t x495; + fiat_secp256k1_scalar_uint1 x496; + uint32_t x497; + fiat_secp256k1_scalar_uint1 x498; + uint32_t x499; + fiat_secp256k1_scalar_uint1 x500; + uint32_t x501; + fiat_secp256k1_scalar_uint1 x502; + uint32_t x503; + fiat_secp256k1_scalar_uint1 x504; + uint32_t x505; + fiat_secp256k1_scalar_uint1 x506; + uint32_t x507; + fiat_secp256k1_scalar_uint1 x508; + uint32_t x509; + fiat_secp256k1_scalar_uint1 x510; + uint32_t x511; + fiat_secp256k1_scalar_uint1 x512; + uint32_t x513; + fiat_secp256k1_scalar_uint1 x514; + uint32_t x515; + fiat_secp256k1_scalar_uint1 x516; + uint32_t x517; + fiat_secp256k1_scalar_uint1 x518; + uint32_t x519; + uint32_t x520; + uint32_t x521; + uint32_t x522; + uint32_t x523; + uint32_t x524; + uint32_t x525; + uint32_t x526; + uint32_t x527; + uint32_t x528; + uint32_t x529; + uint32_t x530; + uint32_t x531; + uint32_t x532; + uint32_t x533; + uint32_t x534; + uint32_t x535; + uint32_t x536; + uint32_t x537; + fiat_secp256k1_scalar_uint1 x538; + uint32_t x539; + fiat_secp256k1_scalar_uint1 x540; + uint32_t x541; + fiat_secp256k1_scalar_uint1 x542; + uint32_t x543; + fiat_secp256k1_scalar_uint1 x544; + uint32_t x545; + fiat_secp256k1_scalar_uint1 x546; + uint32_t x547; + fiat_secp256k1_scalar_uint1 x548; + uint32_t x549; + fiat_secp256k1_scalar_uint1 x550; + uint32_t x551; + fiat_secp256k1_scalar_uint1 x552; + uint32_t x553; + fiat_secp256k1_scalar_uint1 x554; + uint32_t x555; + fiat_secp256k1_scalar_uint1 x556; + uint32_t x557; + fiat_secp256k1_scalar_uint1 x558; + uint32_t x559; + fiat_secp256k1_scalar_uint1 x560; + uint32_t x561; + fiat_secp256k1_scalar_uint1 x562; + uint32_t x563; + fiat_secp256k1_scalar_uint1 x564; + uint32_t x565; + fiat_secp256k1_scalar_uint1 x566; + uint32_t x567; + fiat_secp256k1_scalar_uint1 x568; + uint32_t x569; + uint32_t x570; + uint32_t x571; + uint32_t x572; + uint32_t x573; + uint32_t x574; + uint32_t x575; + uint32_t x576; + uint32_t x577; + uint32_t x578; + uint32_t x579; + uint32_t x580; + uint32_t x581; + uint32_t x582; + uint32_t x583; + uint32_t x584; + uint32_t x585; + fiat_secp256k1_scalar_uint1 x586; + uint32_t x587; + fiat_secp256k1_scalar_uint1 x588; + uint32_t x589; + fiat_secp256k1_scalar_uint1 x590; + uint32_t x591; + fiat_secp256k1_scalar_uint1 x592; + uint32_t x593; + fiat_secp256k1_scalar_uint1 x594; + uint32_t x595; + fiat_secp256k1_scalar_uint1 x596; + uint32_t x597; + fiat_secp256k1_scalar_uint1 x598; + uint32_t x599; + fiat_secp256k1_scalar_uint1 x600; + uint32_t x601; + fiat_secp256k1_scalar_uint1 x602; + uint32_t x603; + fiat_secp256k1_scalar_uint1 x604; + uint32_t x605; + fiat_secp256k1_scalar_uint1 x606; + uint32_t x607; + fiat_secp256k1_scalar_uint1 x608; + uint32_t x609; + fiat_secp256k1_scalar_uint1 x610; + uint32_t x611; + fiat_secp256k1_scalar_uint1 x612; + uint32_t x613; + fiat_secp256k1_scalar_uint1 x614; + uint32_t x615; + uint32_t x616; + uint32_t x617; + uint32_t x618; + uint32_t x619; + uint32_t x620; + uint32_t x621; + uint32_t x622; + uint32_t x623; + uint32_t x624; + uint32_t x625; + uint32_t x626; + uint32_t x627; + uint32_t x628; + uint32_t x629; + uint32_t x630; + uint32_t x631; + uint32_t x632; + uint32_t x633; + fiat_secp256k1_scalar_uint1 x634; + uint32_t x635; + fiat_secp256k1_scalar_uint1 x636; + uint32_t x637; + fiat_secp256k1_scalar_uint1 x638; + uint32_t x639; + fiat_secp256k1_scalar_uint1 x640; + uint32_t x641; + fiat_secp256k1_scalar_uint1 x642; + uint32_t x643; + fiat_secp256k1_scalar_uint1 x644; + uint32_t x645; + fiat_secp256k1_scalar_uint1 x646; + uint32_t x647; + fiat_secp256k1_scalar_uint1 x648; + uint32_t x649; + fiat_secp256k1_scalar_uint1 x650; + uint32_t x651; + fiat_secp256k1_scalar_uint1 x652; + uint32_t x653; + fiat_secp256k1_scalar_uint1 x654; + uint32_t x655; + fiat_secp256k1_scalar_uint1 x656; + uint32_t x657; + fiat_secp256k1_scalar_uint1 x658; + uint32_t x659; + fiat_secp256k1_scalar_uint1 x660; + uint32_t x661; + fiat_secp256k1_scalar_uint1 x662; + uint32_t x663; + fiat_secp256k1_scalar_uint1 x664; + uint32_t x665; + uint32_t x666; + uint32_t x667; + uint32_t x668; + uint32_t x669; + uint32_t x670; + uint32_t x671; + uint32_t x672; + uint32_t x673; + uint32_t x674; + uint32_t x675; + uint32_t x676; + uint32_t x677; + uint32_t x678; + uint32_t x679; + uint32_t x680; + uint32_t x681; + fiat_secp256k1_scalar_uint1 x682; + uint32_t x683; + fiat_secp256k1_scalar_uint1 x684; + uint32_t x685; + fiat_secp256k1_scalar_uint1 x686; + uint32_t x687; + fiat_secp256k1_scalar_uint1 x688; + uint32_t x689; + fiat_secp256k1_scalar_uint1 x690; + uint32_t x691; + fiat_secp256k1_scalar_uint1 x692; + uint32_t x693; + fiat_secp256k1_scalar_uint1 x694; + uint32_t x695; + fiat_secp256k1_scalar_uint1 x696; + uint32_t x697; + fiat_secp256k1_scalar_uint1 x698; + uint32_t x699; + fiat_secp256k1_scalar_uint1 x700; + uint32_t x701; + fiat_secp256k1_scalar_uint1 x702; + uint32_t x703; + fiat_secp256k1_scalar_uint1 x704; + uint32_t x705; + fiat_secp256k1_scalar_uint1 x706; + uint32_t x707; + fiat_secp256k1_scalar_uint1 x708; + uint32_t x709; + fiat_secp256k1_scalar_uint1 x710; + uint32_t x711; + uint32_t x712; + uint32_t x713; + uint32_t x714; + uint32_t x715; + uint32_t x716; + uint32_t x717; + uint32_t x718; + uint32_t x719; + uint32_t x720; + uint32_t x721; + uint32_t x722; + uint32_t x723; + uint32_t x724; + uint32_t x725; + uint32_t x726; + uint32_t x727; + uint32_t x728; + uint32_t x729; + fiat_secp256k1_scalar_uint1 x730; + uint32_t x731; + fiat_secp256k1_scalar_uint1 x732; + uint32_t x733; + fiat_secp256k1_scalar_uint1 x734; + uint32_t x735; + fiat_secp256k1_scalar_uint1 x736; + uint32_t x737; + fiat_secp256k1_scalar_uint1 x738; + uint32_t x739; + fiat_secp256k1_scalar_uint1 x740; + uint32_t x741; + fiat_secp256k1_scalar_uint1 x742; + uint32_t x743; + fiat_secp256k1_scalar_uint1 x744; + uint32_t x745; + fiat_secp256k1_scalar_uint1 x746; + uint32_t x747; + fiat_secp256k1_scalar_uint1 x748; + uint32_t x749; + fiat_secp256k1_scalar_uint1 x750; + uint32_t x751; + fiat_secp256k1_scalar_uint1 x752; + uint32_t x753; + fiat_secp256k1_scalar_uint1 x754; + uint32_t x755; + fiat_secp256k1_scalar_uint1 x756; + uint32_t x757; + fiat_secp256k1_scalar_uint1 x758; + uint32_t x759; + fiat_secp256k1_scalar_uint1 x760; + uint32_t x761; + fiat_secp256k1_scalar_uint1 x762; + uint32_t x763; + fiat_secp256k1_scalar_uint1 x764; + uint32_t x765; + fiat_secp256k1_scalar_uint1 x766; + uint32_t x767; + fiat_secp256k1_scalar_uint1 x768; + uint32_t x769; + fiat_secp256k1_scalar_uint1 x770; + uint32_t x771; + fiat_secp256k1_scalar_uint1 x772; + uint32_t x773; + fiat_secp256k1_scalar_uint1 x774; + uint32_t x775; + fiat_secp256k1_scalar_uint1 x776; + uint32_t x777; + fiat_secp256k1_scalar_uint1 x778; + uint32_t x779; + uint32_t x780; + uint32_t x781; + uint32_t x782; + uint32_t x783; + uint32_t x784; + uint32_t x785; + uint32_t x786; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[4]); + x5 = (arg1[5]); + x6 = (arg1[6]); + x7 = (arg1[7]); + x8 = (arg1[0]); + fiat_secp256k1_scalar_mulx_u32(&x9, &x10, x8, UINT32_C(0x9d671cd5)); + fiat_secp256k1_scalar_mulx_u32(&x11, &x12, x8, UINT32_C(0x81c69bc5)); + fiat_secp256k1_scalar_mulx_u32(&x13, &x14, x8, UINT32_C(0xe697f5e4)); + fiat_secp256k1_scalar_mulx_u32(&x15, &x16, x8, UINT32_C(0x5bcd07c6)); + fiat_secp256k1_scalar_mulx_u32(&x17, &x18, x8, UINT32_C(0x741496c2)); + fiat_secp256k1_scalar_mulx_u32(&x19, &x20, x8, UINT32_C(0xe7cf878)); + fiat_secp256k1_scalar_mulx_u32(&x21, &x22, x8, UINT32_C(0x896cf214)); + fiat_secp256k1_scalar_mulx_u32(&x23, &x24, x8, UINT32_C(0x67d7d140)); + fiat_secp256k1_scalar_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_secp256k1_scalar_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_secp256k1_scalar_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_secp256k1_scalar_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_secp256k1_scalar_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_secp256k1_scalar_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_secp256k1_scalar_addcarryx_u32(&x37, &x38, x36, x12, x9); + fiat_secp256k1_scalar_mulx_u32(&x39, &x40, x23, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x41, &x42, x39, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x43, &x44, x39, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x45, &x46, x39, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x47, &x48, x39, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x49, &x50, x39, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x51, &x52, x39, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x53, &x54, x39, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x55, &x56, x39, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x57, &x58, 0x0, x56, x53); + fiat_secp256k1_scalar_addcarryx_u32(&x59, &x60, x58, x54, x51); + fiat_secp256k1_scalar_addcarryx_u32(&x61, &x62, x60, x52, x49); + fiat_secp256k1_scalar_addcarryx_u32(&x63, &x64, x62, x50, x47); + fiat_secp256k1_scalar_addcarryx_u32(&x65, &x66, x64, x48, x45); + fiat_secp256k1_scalar_addcarryx_u32(&x67, &x68, x66, x46, x43); + fiat_secp256k1_scalar_addcarryx_u32(&x69, &x70, x68, x44, x41); + fiat_secp256k1_scalar_addcarryx_u32(&x71, &x72, 0x0, x23, x55); + fiat_secp256k1_scalar_addcarryx_u32(&x73, &x74, x72, x25, x57); + fiat_secp256k1_scalar_addcarryx_u32(&x75, &x76, x74, x27, x59); + fiat_secp256k1_scalar_addcarryx_u32(&x77, &x78, x76, x29, x61); + fiat_secp256k1_scalar_addcarryx_u32(&x79, &x80, x78, x31, x63); + fiat_secp256k1_scalar_addcarryx_u32(&x81, &x82, x80, x33, x65); + fiat_secp256k1_scalar_addcarryx_u32(&x83, &x84, x82, x35, x67); + fiat_secp256k1_scalar_addcarryx_u32(&x85, &x86, x84, x37, x69); + fiat_secp256k1_scalar_addcarryx_u32(&x87, &x88, x86, (x38 + x10), (x70 + x42)); + fiat_secp256k1_scalar_mulx_u32(&x89, &x90, x1, UINT32_C(0x9d671cd5)); + fiat_secp256k1_scalar_mulx_u32(&x91, &x92, x1, UINT32_C(0x81c69bc5)); + fiat_secp256k1_scalar_mulx_u32(&x93, &x94, x1, UINT32_C(0xe697f5e4)); + fiat_secp256k1_scalar_mulx_u32(&x95, &x96, x1, UINT32_C(0x5bcd07c6)); + fiat_secp256k1_scalar_mulx_u32(&x97, &x98, x1, UINT32_C(0x741496c2)); + fiat_secp256k1_scalar_mulx_u32(&x99, &x100, x1, UINT32_C(0xe7cf878)); + fiat_secp256k1_scalar_mulx_u32(&x101, &x102, x1, UINT32_C(0x896cf214)); + fiat_secp256k1_scalar_mulx_u32(&x103, &x104, x1, UINT32_C(0x67d7d140)); + fiat_secp256k1_scalar_addcarryx_u32(&x105, &x106, 0x0, x104, x101); + fiat_secp256k1_scalar_addcarryx_u32(&x107, &x108, x106, x102, x99); + fiat_secp256k1_scalar_addcarryx_u32(&x109, &x110, x108, x100, x97); + fiat_secp256k1_scalar_addcarryx_u32(&x111, &x112, x110, x98, x95); + fiat_secp256k1_scalar_addcarryx_u32(&x113, &x114, x112, x96, x93); + fiat_secp256k1_scalar_addcarryx_u32(&x115, &x116, x114, x94, x91); + fiat_secp256k1_scalar_addcarryx_u32(&x117, &x118, x116, x92, x89); + fiat_secp256k1_scalar_addcarryx_u32(&x119, &x120, 0x0, x73, x103); + fiat_secp256k1_scalar_addcarryx_u32(&x121, &x122, x120, x75, x105); + fiat_secp256k1_scalar_addcarryx_u32(&x123, &x124, x122, x77, x107); + fiat_secp256k1_scalar_addcarryx_u32(&x125, &x126, x124, x79, x109); + fiat_secp256k1_scalar_addcarryx_u32(&x127, &x128, x126, x81, x111); + fiat_secp256k1_scalar_addcarryx_u32(&x129, &x130, x128, x83, x113); + fiat_secp256k1_scalar_addcarryx_u32(&x131, &x132, x130, x85, x115); + fiat_secp256k1_scalar_addcarryx_u32(&x133, &x134, x132, x87, x117); + fiat_secp256k1_scalar_mulx_u32(&x135, &x136, x119, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x137, &x138, x135, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x139, &x140, x135, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x141, &x142, x135, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x143, &x144, x135, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x145, &x146, x135, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x147, &x148, x135, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x149, &x150, x135, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x151, &x152, x135, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x153, &x154, 0x0, x152, x149); + fiat_secp256k1_scalar_addcarryx_u32(&x155, &x156, x154, x150, x147); + fiat_secp256k1_scalar_addcarryx_u32(&x157, &x158, x156, x148, x145); + fiat_secp256k1_scalar_addcarryx_u32(&x159, &x160, x158, x146, x143); + fiat_secp256k1_scalar_addcarryx_u32(&x161, &x162, x160, x144, x141); + fiat_secp256k1_scalar_addcarryx_u32(&x163, &x164, x162, x142, x139); + fiat_secp256k1_scalar_addcarryx_u32(&x165, &x166, x164, x140, x137); + fiat_secp256k1_scalar_addcarryx_u32(&x167, &x168, 0x0, x119, x151); + fiat_secp256k1_scalar_addcarryx_u32(&x169, &x170, x168, x121, x153); + fiat_secp256k1_scalar_addcarryx_u32(&x171, &x172, x170, x123, x155); + fiat_secp256k1_scalar_addcarryx_u32(&x173, &x174, x172, x125, x157); + fiat_secp256k1_scalar_addcarryx_u32(&x175, &x176, x174, x127, x159); + fiat_secp256k1_scalar_addcarryx_u32(&x177, &x178, x176, x129, x161); + fiat_secp256k1_scalar_addcarryx_u32(&x179, &x180, x178, x131, x163); + fiat_secp256k1_scalar_addcarryx_u32(&x181, &x182, x180, x133, x165); + fiat_secp256k1_scalar_addcarryx_u32(&x183, &x184, x182, (((uint32_t)x134 + x88) + (x118 + x90)), (x166 + x138)); + fiat_secp256k1_scalar_mulx_u32(&x185, &x186, x2, UINT32_C(0x9d671cd5)); + fiat_secp256k1_scalar_mulx_u32(&x187, &x188, x2, UINT32_C(0x81c69bc5)); + fiat_secp256k1_scalar_mulx_u32(&x189, &x190, x2, UINT32_C(0xe697f5e4)); + fiat_secp256k1_scalar_mulx_u32(&x191, &x192, x2, UINT32_C(0x5bcd07c6)); + fiat_secp256k1_scalar_mulx_u32(&x193, &x194, x2, UINT32_C(0x741496c2)); + fiat_secp256k1_scalar_mulx_u32(&x195, &x196, x2, UINT32_C(0xe7cf878)); + fiat_secp256k1_scalar_mulx_u32(&x197, &x198, x2, UINT32_C(0x896cf214)); + fiat_secp256k1_scalar_mulx_u32(&x199, &x200, x2, UINT32_C(0x67d7d140)); + fiat_secp256k1_scalar_addcarryx_u32(&x201, &x202, 0x0, x200, x197); + fiat_secp256k1_scalar_addcarryx_u32(&x203, &x204, x202, x198, x195); + fiat_secp256k1_scalar_addcarryx_u32(&x205, &x206, x204, x196, x193); + fiat_secp256k1_scalar_addcarryx_u32(&x207, &x208, x206, x194, x191); + fiat_secp256k1_scalar_addcarryx_u32(&x209, &x210, x208, x192, x189); + fiat_secp256k1_scalar_addcarryx_u32(&x211, &x212, x210, x190, x187); + fiat_secp256k1_scalar_addcarryx_u32(&x213, &x214, x212, x188, x185); + fiat_secp256k1_scalar_addcarryx_u32(&x215, &x216, 0x0, x169, x199); + fiat_secp256k1_scalar_addcarryx_u32(&x217, &x218, x216, x171, x201); + fiat_secp256k1_scalar_addcarryx_u32(&x219, &x220, x218, x173, x203); + fiat_secp256k1_scalar_addcarryx_u32(&x221, &x222, x220, x175, x205); + fiat_secp256k1_scalar_addcarryx_u32(&x223, &x224, x222, x177, x207); + fiat_secp256k1_scalar_addcarryx_u32(&x225, &x226, x224, x179, x209); + fiat_secp256k1_scalar_addcarryx_u32(&x227, &x228, x226, x181, x211); + fiat_secp256k1_scalar_addcarryx_u32(&x229, &x230, x228, x183, x213); + fiat_secp256k1_scalar_mulx_u32(&x231, &x232, x215, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x233, &x234, x231, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x235, &x236, x231, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x237, &x238, x231, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x239, &x240, x231, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x241, &x242, x231, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x243, &x244, x231, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x245, &x246, x231, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x247, &x248, x231, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x249, &x250, 0x0, x248, x245); + fiat_secp256k1_scalar_addcarryx_u32(&x251, &x252, x250, x246, x243); + fiat_secp256k1_scalar_addcarryx_u32(&x253, &x254, x252, x244, x241); + fiat_secp256k1_scalar_addcarryx_u32(&x255, &x256, x254, x242, x239); + fiat_secp256k1_scalar_addcarryx_u32(&x257, &x258, x256, x240, x237); + fiat_secp256k1_scalar_addcarryx_u32(&x259, &x260, x258, x238, x235); + fiat_secp256k1_scalar_addcarryx_u32(&x261, &x262, x260, x236, x233); + fiat_secp256k1_scalar_addcarryx_u32(&x263, &x264, 0x0, x215, x247); + fiat_secp256k1_scalar_addcarryx_u32(&x265, &x266, x264, x217, x249); + fiat_secp256k1_scalar_addcarryx_u32(&x267, &x268, x266, x219, x251); + fiat_secp256k1_scalar_addcarryx_u32(&x269, &x270, x268, x221, x253); + fiat_secp256k1_scalar_addcarryx_u32(&x271, &x272, x270, x223, x255); + fiat_secp256k1_scalar_addcarryx_u32(&x273, &x274, x272, x225, x257); + fiat_secp256k1_scalar_addcarryx_u32(&x275, &x276, x274, x227, x259); + fiat_secp256k1_scalar_addcarryx_u32(&x277, &x278, x276, x229, x261); + fiat_secp256k1_scalar_addcarryx_u32(&x279, &x280, x278, (((uint32_t)x230 + x184) + (x214 + x186)), (x262 + x234)); + fiat_secp256k1_scalar_mulx_u32(&x281, &x282, x3, UINT32_C(0x9d671cd5)); + fiat_secp256k1_scalar_mulx_u32(&x283, &x284, x3, UINT32_C(0x81c69bc5)); + fiat_secp256k1_scalar_mulx_u32(&x285, &x286, x3, UINT32_C(0xe697f5e4)); + fiat_secp256k1_scalar_mulx_u32(&x287, &x288, x3, UINT32_C(0x5bcd07c6)); + fiat_secp256k1_scalar_mulx_u32(&x289, &x290, x3, UINT32_C(0x741496c2)); + fiat_secp256k1_scalar_mulx_u32(&x291, &x292, x3, UINT32_C(0xe7cf878)); + fiat_secp256k1_scalar_mulx_u32(&x293, &x294, x3, UINT32_C(0x896cf214)); + fiat_secp256k1_scalar_mulx_u32(&x295, &x296, x3, UINT32_C(0x67d7d140)); + fiat_secp256k1_scalar_addcarryx_u32(&x297, &x298, 0x0, x296, x293); + fiat_secp256k1_scalar_addcarryx_u32(&x299, &x300, x298, x294, x291); + fiat_secp256k1_scalar_addcarryx_u32(&x301, &x302, x300, x292, x289); + fiat_secp256k1_scalar_addcarryx_u32(&x303, &x304, x302, x290, x287); + fiat_secp256k1_scalar_addcarryx_u32(&x305, &x306, x304, x288, x285); + fiat_secp256k1_scalar_addcarryx_u32(&x307, &x308, x306, x286, x283); + fiat_secp256k1_scalar_addcarryx_u32(&x309, &x310, x308, x284, x281); + fiat_secp256k1_scalar_addcarryx_u32(&x311, &x312, 0x0, x265, x295); + fiat_secp256k1_scalar_addcarryx_u32(&x313, &x314, x312, x267, x297); + fiat_secp256k1_scalar_addcarryx_u32(&x315, &x316, x314, x269, x299); + fiat_secp256k1_scalar_addcarryx_u32(&x317, &x318, x316, x271, x301); + fiat_secp256k1_scalar_addcarryx_u32(&x319, &x320, x318, x273, x303); + fiat_secp256k1_scalar_addcarryx_u32(&x321, &x322, x320, x275, x305); + fiat_secp256k1_scalar_addcarryx_u32(&x323, &x324, x322, x277, x307); + fiat_secp256k1_scalar_addcarryx_u32(&x325, &x326, x324, x279, x309); + fiat_secp256k1_scalar_mulx_u32(&x327, &x328, x311, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x329, &x330, x327, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x331, &x332, x327, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x333, &x334, x327, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x335, &x336, x327, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x337, &x338, x327, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x339, &x340, x327, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x341, &x342, x327, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x343, &x344, x327, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x345, &x346, 0x0, x344, x341); + fiat_secp256k1_scalar_addcarryx_u32(&x347, &x348, x346, x342, x339); + fiat_secp256k1_scalar_addcarryx_u32(&x349, &x350, x348, x340, x337); + fiat_secp256k1_scalar_addcarryx_u32(&x351, &x352, x350, x338, x335); + fiat_secp256k1_scalar_addcarryx_u32(&x353, &x354, x352, x336, x333); + fiat_secp256k1_scalar_addcarryx_u32(&x355, &x356, x354, x334, x331); + fiat_secp256k1_scalar_addcarryx_u32(&x357, &x358, x356, x332, x329); + fiat_secp256k1_scalar_addcarryx_u32(&x359, &x360, 0x0, x311, x343); + fiat_secp256k1_scalar_addcarryx_u32(&x361, &x362, x360, x313, x345); + fiat_secp256k1_scalar_addcarryx_u32(&x363, &x364, x362, x315, x347); + fiat_secp256k1_scalar_addcarryx_u32(&x365, &x366, x364, x317, x349); + fiat_secp256k1_scalar_addcarryx_u32(&x367, &x368, x366, x319, x351); + fiat_secp256k1_scalar_addcarryx_u32(&x369, &x370, x368, x321, x353); + fiat_secp256k1_scalar_addcarryx_u32(&x371, &x372, x370, x323, x355); + fiat_secp256k1_scalar_addcarryx_u32(&x373, &x374, x372, x325, x357); + fiat_secp256k1_scalar_addcarryx_u32(&x375, &x376, x374, (((uint32_t)x326 + x280) + (x310 + x282)), (x358 + x330)); + fiat_secp256k1_scalar_mulx_u32(&x377, &x378, x4, UINT32_C(0x9d671cd5)); + fiat_secp256k1_scalar_mulx_u32(&x379, &x380, x4, UINT32_C(0x81c69bc5)); + fiat_secp256k1_scalar_mulx_u32(&x381, &x382, x4, UINT32_C(0xe697f5e4)); + fiat_secp256k1_scalar_mulx_u32(&x383, &x384, x4, UINT32_C(0x5bcd07c6)); + fiat_secp256k1_scalar_mulx_u32(&x385, &x386, x4, UINT32_C(0x741496c2)); + fiat_secp256k1_scalar_mulx_u32(&x387, &x388, x4, UINT32_C(0xe7cf878)); + fiat_secp256k1_scalar_mulx_u32(&x389, &x390, x4, UINT32_C(0x896cf214)); + fiat_secp256k1_scalar_mulx_u32(&x391, &x392, x4, UINT32_C(0x67d7d140)); + fiat_secp256k1_scalar_addcarryx_u32(&x393, &x394, 0x0, x392, x389); + fiat_secp256k1_scalar_addcarryx_u32(&x395, &x396, x394, x390, x387); + fiat_secp256k1_scalar_addcarryx_u32(&x397, &x398, x396, x388, x385); + fiat_secp256k1_scalar_addcarryx_u32(&x399, &x400, x398, x386, x383); + fiat_secp256k1_scalar_addcarryx_u32(&x401, &x402, x400, x384, x381); + fiat_secp256k1_scalar_addcarryx_u32(&x403, &x404, x402, x382, x379); + fiat_secp256k1_scalar_addcarryx_u32(&x405, &x406, x404, x380, x377); + fiat_secp256k1_scalar_addcarryx_u32(&x407, &x408, 0x0, x361, x391); + fiat_secp256k1_scalar_addcarryx_u32(&x409, &x410, x408, x363, x393); + fiat_secp256k1_scalar_addcarryx_u32(&x411, &x412, x410, x365, x395); + fiat_secp256k1_scalar_addcarryx_u32(&x413, &x414, x412, x367, x397); + fiat_secp256k1_scalar_addcarryx_u32(&x415, &x416, x414, x369, x399); + fiat_secp256k1_scalar_addcarryx_u32(&x417, &x418, x416, x371, x401); + fiat_secp256k1_scalar_addcarryx_u32(&x419, &x420, x418, x373, x403); + fiat_secp256k1_scalar_addcarryx_u32(&x421, &x422, x420, x375, x405); + fiat_secp256k1_scalar_mulx_u32(&x423, &x424, x407, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x425, &x426, x423, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x427, &x428, x423, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x429, &x430, x423, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x431, &x432, x423, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x433, &x434, x423, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x435, &x436, x423, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x437, &x438, x423, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x439, &x440, x423, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x441, &x442, 0x0, x440, x437); + fiat_secp256k1_scalar_addcarryx_u32(&x443, &x444, x442, x438, x435); + fiat_secp256k1_scalar_addcarryx_u32(&x445, &x446, x444, x436, x433); + fiat_secp256k1_scalar_addcarryx_u32(&x447, &x448, x446, x434, x431); + fiat_secp256k1_scalar_addcarryx_u32(&x449, &x450, x448, x432, x429); + fiat_secp256k1_scalar_addcarryx_u32(&x451, &x452, x450, x430, x427); + fiat_secp256k1_scalar_addcarryx_u32(&x453, &x454, x452, x428, x425); + fiat_secp256k1_scalar_addcarryx_u32(&x455, &x456, 0x0, x407, x439); + fiat_secp256k1_scalar_addcarryx_u32(&x457, &x458, x456, x409, x441); + fiat_secp256k1_scalar_addcarryx_u32(&x459, &x460, x458, x411, x443); + fiat_secp256k1_scalar_addcarryx_u32(&x461, &x462, x460, x413, x445); + fiat_secp256k1_scalar_addcarryx_u32(&x463, &x464, x462, x415, x447); + fiat_secp256k1_scalar_addcarryx_u32(&x465, &x466, x464, x417, x449); + fiat_secp256k1_scalar_addcarryx_u32(&x467, &x468, x466, x419, x451); + fiat_secp256k1_scalar_addcarryx_u32(&x469, &x470, x468, x421, x453); + fiat_secp256k1_scalar_addcarryx_u32(&x471, &x472, x470, (((uint32_t)x422 + x376) + (x406 + x378)), (x454 + x426)); + fiat_secp256k1_scalar_mulx_u32(&x473, &x474, x5, UINT32_C(0x9d671cd5)); + fiat_secp256k1_scalar_mulx_u32(&x475, &x476, x5, UINT32_C(0x81c69bc5)); + fiat_secp256k1_scalar_mulx_u32(&x477, &x478, x5, UINT32_C(0xe697f5e4)); + fiat_secp256k1_scalar_mulx_u32(&x479, &x480, x5, UINT32_C(0x5bcd07c6)); + fiat_secp256k1_scalar_mulx_u32(&x481, &x482, x5, UINT32_C(0x741496c2)); + fiat_secp256k1_scalar_mulx_u32(&x483, &x484, x5, UINT32_C(0xe7cf878)); + fiat_secp256k1_scalar_mulx_u32(&x485, &x486, x5, UINT32_C(0x896cf214)); + fiat_secp256k1_scalar_mulx_u32(&x487, &x488, x5, UINT32_C(0x67d7d140)); + fiat_secp256k1_scalar_addcarryx_u32(&x489, &x490, 0x0, x488, x485); + fiat_secp256k1_scalar_addcarryx_u32(&x491, &x492, x490, x486, x483); + fiat_secp256k1_scalar_addcarryx_u32(&x493, &x494, x492, x484, x481); + fiat_secp256k1_scalar_addcarryx_u32(&x495, &x496, x494, x482, x479); + fiat_secp256k1_scalar_addcarryx_u32(&x497, &x498, x496, x480, x477); + fiat_secp256k1_scalar_addcarryx_u32(&x499, &x500, x498, x478, x475); + fiat_secp256k1_scalar_addcarryx_u32(&x501, &x502, x500, x476, x473); + fiat_secp256k1_scalar_addcarryx_u32(&x503, &x504, 0x0, x457, x487); + fiat_secp256k1_scalar_addcarryx_u32(&x505, &x506, x504, x459, x489); + fiat_secp256k1_scalar_addcarryx_u32(&x507, &x508, x506, x461, x491); + fiat_secp256k1_scalar_addcarryx_u32(&x509, &x510, x508, x463, x493); + fiat_secp256k1_scalar_addcarryx_u32(&x511, &x512, x510, x465, x495); + fiat_secp256k1_scalar_addcarryx_u32(&x513, &x514, x512, x467, x497); + fiat_secp256k1_scalar_addcarryx_u32(&x515, &x516, x514, x469, x499); + fiat_secp256k1_scalar_addcarryx_u32(&x517, &x518, x516, x471, x501); + fiat_secp256k1_scalar_mulx_u32(&x519, &x520, x503, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x521, &x522, x519, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x523, &x524, x519, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x525, &x526, x519, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x527, &x528, x519, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x529, &x530, x519, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x531, &x532, x519, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x533, &x534, x519, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x535, &x536, x519, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x537, &x538, 0x0, x536, x533); + fiat_secp256k1_scalar_addcarryx_u32(&x539, &x540, x538, x534, x531); + fiat_secp256k1_scalar_addcarryx_u32(&x541, &x542, x540, x532, x529); + fiat_secp256k1_scalar_addcarryx_u32(&x543, &x544, x542, x530, x527); + fiat_secp256k1_scalar_addcarryx_u32(&x545, &x546, x544, x528, x525); + fiat_secp256k1_scalar_addcarryx_u32(&x547, &x548, x546, x526, x523); + fiat_secp256k1_scalar_addcarryx_u32(&x549, &x550, x548, x524, x521); + fiat_secp256k1_scalar_addcarryx_u32(&x551, &x552, 0x0, x503, x535); + fiat_secp256k1_scalar_addcarryx_u32(&x553, &x554, x552, x505, x537); + fiat_secp256k1_scalar_addcarryx_u32(&x555, &x556, x554, x507, x539); + fiat_secp256k1_scalar_addcarryx_u32(&x557, &x558, x556, x509, x541); + fiat_secp256k1_scalar_addcarryx_u32(&x559, &x560, x558, x511, x543); + fiat_secp256k1_scalar_addcarryx_u32(&x561, &x562, x560, x513, x545); + fiat_secp256k1_scalar_addcarryx_u32(&x563, &x564, x562, x515, x547); + fiat_secp256k1_scalar_addcarryx_u32(&x565, &x566, x564, x517, x549); + fiat_secp256k1_scalar_addcarryx_u32(&x567, &x568, x566, (((uint32_t)x518 + x472) + (x502 + x474)), (x550 + x522)); + fiat_secp256k1_scalar_mulx_u32(&x569, &x570, x6, UINT32_C(0x9d671cd5)); + fiat_secp256k1_scalar_mulx_u32(&x571, &x572, x6, UINT32_C(0x81c69bc5)); + fiat_secp256k1_scalar_mulx_u32(&x573, &x574, x6, UINT32_C(0xe697f5e4)); + fiat_secp256k1_scalar_mulx_u32(&x575, &x576, x6, UINT32_C(0x5bcd07c6)); + fiat_secp256k1_scalar_mulx_u32(&x577, &x578, x6, UINT32_C(0x741496c2)); + fiat_secp256k1_scalar_mulx_u32(&x579, &x580, x6, UINT32_C(0xe7cf878)); + fiat_secp256k1_scalar_mulx_u32(&x581, &x582, x6, UINT32_C(0x896cf214)); + fiat_secp256k1_scalar_mulx_u32(&x583, &x584, x6, UINT32_C(0x67d7d140)); + fiat_secp256k1_scalar_addcarryx_u32(&x585, &x586, 0x0, x584, x581); + fiat_secp256k1_scalar_addcarryx_u32(&x587, &x588, x586, x582, x579); + fiat_secp256k1_scalar_addcarryx_u32(&x589, &x590, x588, x580, x577); + fiat_secp256k1_scalar_addcarryx_u32(&x591, &x592, x590, x578, x575); + fiat_secp256k1_scalar_addcarryx_u32(&x593, &x594, x592, x576, x573); + fiat_secp256k1_scalar_addcarryx_u32(&x595, &x596, x594, x574, x571); + fiat_secp256k1_scalar_addcarryx_u32(&x597, &x598, x596, x572, x569); + fiat_secp256k1_scalar_addcarryx_u32(&x599, &x600, 0x0, x553, x583); + fiat_secp256k1_scalar_addcarryx_u32(&x601, &x602, x600, x555, x585); + fiat_secp256k1_scalar_addcarryx_u32(&x603, &x604, x602, x557, x587); + fiat_secp256k1_scalar_addcarryx_u32(&x605, &x606, x604, x559, x589); + fiat_secp256k1_scalar_addcarryx_u32(&x607, &x608, x606, x561, x591); + fiat_secp256k1_scalar_addcarryx_u32(&x609, &x610, x608, x563, x593); + fiat_secp256k1_scalar_addcarryx_u32(&x611, &x612, x610, x565, x595); + fiat_secp256k1_scalar_addcarryx_u32(&x613, &x614, x612, x567, x597); + fiat_secp256k1_scalar_mulx_u32(&x615, &x616, x599, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x617, &x618, x615, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x619, &x620, x615, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x621, &x622, x615, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x623, &x624, x615, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x625, &x626, x615, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x627, &x628, x615, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x629, &x630, x615, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x631, &x632, x615, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x633, &x634, 0x0, x632, x629); + fiat_secp256k1_scalar_addcarryx_u32(&x635, &x636, x634, x630, x627); + fiat_secp256k1_scalar_addcarryx_u32(&x637, &x638, x636, x628, x625); + fiat_secp256k1_scalar_addcarryx_u32(&x639, &x640, x638, x626, x623); + fiat_secp256k1_scalar_addcarryx_u32(&x641, &x642, x640, x624, x621); + fiat_secp256k1_scalar_addcarryx_u32(&x643, &x644, x642, x622, x619); + fiat_secp256k1_scalar_addcarryx_u32(&x645, &x646, x644, x620, x617); + fiat_secp256k1_scalar_addcarryx_u32(&x647, &x648, 0x0, x599, x631); + fiat_secp256k1_scalar_addcarryx_u32(&x649, &x650, x648, x601, x633); + fiat_secp256k1_scalar_addcarryx_u32(&x651, &x652, x650, x603, x635); + fiat_secp256k1_scalar_addcarryx_u32(&x653, &x654, x652, x605, x637); + fiat_secp256k1_scalar_addcarryx_u32(&x655, &x656, x654, x607, x639); + fiat_secp256k1_scalar_addcarryx_u32(&x657, &x658, x656, x609, x641); + fiat_secp256k1_scalar_addcarryx_u32(&x659, &x660, x658, x611, x643); + fiat_secp256k1_scalar_addcarryx_u32(&x661, &x662, x660, x613, x645); + fiat_secp256k1_scalar_addcarryx_u32(&x663, &x664, x662, (((uint32_t)x614 + x568) + (x598 + x570)), (x646 + x618)); + fiat_secp256k1_scalar_mulx_u32(&x665, &x666, x7, UINT32_C(0x9d671cd5)); + fiat_secp256k1_scalar_mulx_u32(&x667, &x668, x7, UINT32_C(0x81c69bc5)); + fiat_secp256k1_scalar_mulx_u32(&x669, &x670, x7, UINT32_C(0xe697f5e4)); + fiat_secp256k1_scalar_mulx_u32(&x671, &x672, x7, UINT32_C(0x5bcd07c6)); + fiat_secp256k1_scalar_mulx_u32(&x673, &x674, x7, UINT32_C(0x741496c2)); + fiat_secp256k1_scalar_mulx_u32(&x675, &x676, x7, UINT32_C(0xe7cf878)); + fiat_secp256k1_scalar_mulx_u32(&x677, &x678, x7, UINT32_C(0x896cf214)); + fiat_secp256k1_scalar_mulx_u32(&x679, &x680, x7, UINT32_C(0x67d7d140)); + fiat_secp256k1_scalar_addcarryx_u32(&x681, &x682, 0x0, x680, x677); + fiat_secp256k1_scalar_addcarryx_u32(&x683, &x684, x682, x678, x675); + fiat_secp256k1_scalar_addcarryx_u32(&x685, &x686, x684, x676, x673); + fiat_secp256k1_scalar_addcarryx_u32(&x687, &x688, x686, x674, x671); + fiat_secp256k1_scalar_addcarryx_u32(&x689, &x690, x688, x672, x669); + fiat_secp256k1_scalar_addcarryx_u32(&x691, &x692, x690, x670, x667); + fiat_secp256k1_scalar_addcarryx_u32(&x693, &x694, x692, x668, x665); + fiat_secp256k1_scalar_addcarryx_u32(&x695, &x696, 0x0, x649, x679); + fiat_secp256k1_scalar_addcarryx_u32(&x697, &x698, x696, x651, x681); + fiat_secp256k1_scalar_addcarryx_u32(&x699, &x700, x698, x653, x683); + fiat_secp256k1_scalar_addcarryx_u32(&x701, &x702, x700, x655, x685); + fiat_secp256k1_scalar_addcarryx_u32(&x703, &x704, x702, x657, x687); + fiat_secp256k1_scalar_addcarryx_u32(&x705, &x706, x704, x659, x689); + fiat_secp256k1_scalar_addcarryx_u32(&x707, &x708, x706, x661, x691); + fiat_secp256k1_scalar_addcarryx_u32(&x709, &x710, x708, x663, x693); + fiat_secp256k1_scalar_mulx_u32(&x711, &x712, x695, UINT32_C(0x5588b13f)); + fiat_secp256k1_scalar_mulx_u32(&x713, &x714, x711, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x715, &x716, x711, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x717, &x718, x711, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_mulx_u32(&x719, &x720, x711, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_mulx_u32(&x721, &x722, x711, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_mulx_u32(&x723, &x724, x711, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_mulx_u32(&x725, &x726, x711, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_mulx_u32(&x727, &x728, x711, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_addcarryx_u32(&x729, &x730, 0x0, x728, x725); + fiat_secp256k1_scalar_addcarryx_u32(&x731, &x732, x730, x726, x723); + fiat_secp256k1_scalar_addcarryx_u32(&x733, &x734, x732, x724, x721); + fiat_secp256k1_scalar_addcarryx_u32(&x735, &x736, x734, x722, x719); + fiat_secp256k1_scalar_addcarryx_u32(&x737, &x738, x736, x720, x717); + fiat_secp256k1_scalar_addcarryx_u32(&x739, &x740, x738, x718, x715); + fiat_secp256k1_scalar_addcarryx_u32(&x741, &x742, x740, x716, x713); + fiat_secp256k1_scalar_addcarryx_u32(&x743, &x744, 0x0, x695, x727); + fiat_secp256k1_scalar_addcarryx_u32(&x745, &x746, x744, x697, x729); + fiat_secp256k1_scalar_addcarryx_u32(&x747, &x748, x746, x699, x731); + fiat_secp256k1_scalar_addcarryx_u32(&x749, &x750, x748, x701, x733); + fiat_secp256k1_scalar_addcarryx_u32(&x751, &x752, x750, x703, x735); + fiat_secp256k1_scalar_addcarryx_u32(&x753, &x754, x752, x705, x737); + fiat_secp256k1_scalar_addcarryx_u32(&x755, &x756, x754, x707, x739); + fiat_secp256k1_scalar_addcarryx_u32(&x757, &x758, x756, x709, x741); + fiat_secp256k1_scalar_addcarryx_u32(&x759, &x760, x758, (((uint32_t)x710 + x664) + (x694 + x666)), (x742 + x714)); + fiat_secp256k1_scalar_subborrowx_u32(&x761, &x762, 0x0, x745, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_subborrowx_u32(&x763, &x764, x762, x747, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_subborrowx_u32(&x765, &x766, x764, x749, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_subborrowx_u32(&x767, &x768, x766, x751, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_subborrowx_u32(&x769, &x770, x768, x753, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_subborrowx_u32(&x771, &x772, x770, x755, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x773, &x774, x772, x757, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x775, &x776, x774, x759, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x777, &x778, x776, x760, 0x0); + fiat_secp256k1_scalar_cmovznz_u32(&x779, x778, x761, x745); + fiat_secp256k1_scalar_cmovznz_u32(&x780, x778, x763, x747); + fiat_secp256k1_scalar_cmovznz_u32(&x781, x778, x765, x749); + fiat_secp256k1_scalar_cmovznz_u32(&x782, x778, x767, x751); + fiat_secp256k1_scalar_cmovznz_u32(&x783, x778, x769, x753); + fiat_secp256k1_scalar_cmovznz_u32(&x784, x778, x771, x755); + fiat_secp256k1_scalar_cmovznz_u32(&x785, x778, x773, x757); + fiat_secp256k1_scalar_cmovznz_u32(&x786, x778, x775, x759); + out1[0] = x779; + out1[1] = x780; + out1[2] = x781; + out1[3] = x782; + out1[4] = x783; + out1[5] = x784; + out1[6] = x785; + out1[7] = x786; +} + +/* + * The function fiat_secp256k1_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_nonzero(uint32_t* out1, const uint32_t arg1[8]) { + uint32_t x1; + x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | (arg1[7])))))))); + *out1 = x1; +} + +/* + * The function fiat_secp256k1_scalar_selectznz is a multi-limb conditional select. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_selectznz(uint32_t out1[8], fiat_secp256k1_scalar_uint1 arg1, const uint32_t arg2[8], const uint32_t arg3[8]) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + fiat_secp256k1_scalar_cmovznz_u32(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_secp256k1_scalar_cmovznz_u32(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_secp256k1_scalar_cmovznz_u32(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_secp256k1_scalar_cmovznz_u32(&x4, arg1, (arg2[3]), (arg3[3])); + fiat_secp256k1_scalar_cmovznz_u32(&x5, arg1, (arg2[4]), (arg3[4])); + fiat_secp256k1_scalar_cmovznz_u32(&x6, arg1, (arg2[5]), (arg3[5])); + fiat_secp256k1_scalar_cmovznz_u32(&x7, arg1, (arg2[6]), (arg3[6])); + fiat_secp256k1_scalar_cmovznz_u32(&x8, arg1, (arg2[7]), (arg3[7])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; + out1[6] = x7; + out1[7] = x8; +} + +/* + * The function fiat_secp256k1_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_to_bytes(uint8_t out1[32], const uint32_t arg1[8]) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint32_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint8_t x9; + uint32_t x10; + uint8_t x11; + uint32_t x12; + uint8_t x13; + uint8_t x14; + uint8_t x15; + uint32_t x16; + uint8_t x17; + uint32_t x18; + uint8_t x19; + uint8_t x20; + uint8_t x21; + uint32_t x22; + uint8_t x23; + uint32_t x24; + uint8_t x25; + uint8_t x26; + uint8_t x27; + uint32_t x28; + uint8_t x29; + uint32_t x30; + uint8_t x31; + uint8_t x32; + uint8_t x33; + uint32_t x34; + uint8_t x35; + uint32_t x36; + uint8_t x37; + uint8_t x38; + uint8_t x39; + uint32_t x40; + uint8_t x41; + uint32_t x42; + uint8_t x43; + uint8_t x44; + uint8_t x45; + uint32_t x46; + uint8_t x47; + uint32_t x48; + uint8_t x49; + uint8_t x50; + uint8_t x51; + uint32_t x52; + uint8_t x53; + uint32_t x54; + uint8_t x55; + uint8_t x56; + x1 = (arg1[7]); + x2 = (arg1[6]); + x3 = (arg1[5]); + x4 = (arg1[4]); + x5 = (arg1[3]); + x6 = (arg1[2]); + x7 = (arg1[1]); + x8 = (arg1[0]); + x9 = (uint8_t)(x8 & UINT8_C(0xff)); + x10 = (x8 >> 8); + x11 = (uint8_t)(x10 & UINT8_C(0xff)); + x12 = (x10 >> 8); + x13 = (uint8_t)(x12 & UINT8_C(0xff)); + x14 = (uint8_t)(x12 >> 8); + x15 = (uint8_t)(x7 & UINT8_C(0xff)); + x16 = (x7 >> 8); + x17 = (uint8_t)(x16 & UINT8_C(0xff)); + x18 = (x16 >> 8); + x19 = (uint8_t)(x18 & UINT8_C(0xff)); + x20 = (uint8_t)(x18 >> 8); + x21 = (uint8_t)(x6 & UINT8_C(0xff)); + x22 = (x6 >> 8); + x23 = (uint8_t)(x22 & UINT8_C(0xff)); + x24 = (x22 >> 8); + x25 = (uint8_t)(x24 & UINT8_C(0xff)); + x26 = (uint8_t)(x24 >> 8); + x27 = (uint8_t)(x5 & UINT8_C(0xff)); + x28 = (x5 >> 8); + x29 = (uint8_t)(x28 & UINT8_C(0xff)); + x30 = (x28 >> 8); + x31 = (uint8_t)(x30 & UINT8_C(0xff)); + x32 = (uint8_t)(x30 >> 8); + x33 = (uint8_t)(x4 & UINT8_C(0xff)); + x34 = (x4 >> 8); + x35 = (uint8_t)(x34 & UINT8_C(0xff)); + x36 = (x34 >> 8); + x37 = (uint8_t)(x36 & UINT8_C(0xff)); + x38 = (uint8_t)(x36 >> 8); + x39 = (uint8_t)(x3 & UINT8_C(0xff)); + x40 = (x3 >> 8); + x41 = (uint8_t)(x40 & UINT8_C(0xff)); + x42 = (x40 >> 8); + x43 = (uint8_t)(x42 & UINT8_C(0xff)); + x44 = (uint8_t)(x42 >> 8); + x45 = (uint8_t)(x2 & UINT8_C(0xff)); + x46 = (x2 >> 8); + x47 = (uint8_t)(x46 & UINT8_C(0xff)); + x48 = (x46 >> 8); + x49 = (uint8_t)(x48 & UINT8_C(0xff)); + x50 = (uint8_t)(x48 >> 8); + x51 = (uint8_t)(x1 & UINT8_C(0xff)); + x52 = (x1 >> 8); + x53 = (uint8_t)(x52 & UINT8_C(0xff)); + x54 = (x52 >> 8); + x55 = (uint8_t)(x54 & UINT8_C(0xff)); + x56 = (uint8_t)(x54 >> 8); + out1[0] = x9; + out1[1] = x11; + out1[2] = x13; + out1[3] = x14; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x26; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x38; + out1[20] = x39; + out1[21] = x41; + out1[22] = x43; + out1[23] = x44; + out1[24] = x45; + out1[25] = x47; + out1[26] = x49; + out1[27] = x50; + out1[28] = x51; + out1[29] = x53; + out1[30] = x55; + out1[31] = x56; +} + +/* + * The function fiat_secp256k1_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. + * + * Preconditions: + * 0 ≤ bytes_eval arg1 < m + * Postconditions: + * eval out1 mod m = bytes_eval arg1 mod m + * 0 ≤ eval out1 < m + * + * Input Bounds: + * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_from_bytes(uint32_t out1[8], const uint8_t arg1[32]) { + uint32_t x1; + uint32_t x2; + uint32_t x3; + uint8_t x4; + uint32_t x5; + uint32_t x6; + uint32_t x7; + uint8_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint8_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint8_t x16; + uint32_t x17; + uint32_t x18; + uint32_t x19; + uint8_t x20; + uint32_t x21; + uint32_t x22; + uint32_t x23; + uint8_t x24; + uint32_t x25; + uint32_t x26; + uint32_t x27; + uint8_t x28; + uint32_t x29; + uint32_t x30; + uint32_t x31; + uint8_t x32; + uint32_t x33; + uint32_t x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + uint32_t x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + uint32_t x52; + uint32_t x53; + uint32_t x54; + uint32_t x55; + uint32_t x56; + x1 = ((uint32_t)(arg1[31]) << 24); + x2 = ((uint32_t)(arg1[30]) << 16); + x3 = ((uint32_t)(arg1[29]) << 8); + x4 = (arg1[28]); + x5 = ((uint32_t)(arg1[27]) << 24); + x6 = ((uint32_t)(arg1[26]) << 16); + x7 = ((uint32_t)(arg1[25]) << 8); + x8 = (arg1[24]); + x9 = ((uint32_t)(arg1[23]) << 24); + x10 = ((uint32_t)(arg1[22]) << 16); + x11 = ((uint32_t)(arg1[21]) << 8); + x12 = (arg1[20]); + x13 = ((uint32_t)(arg1[19]) << 24); + x14 = ((uint32_t)(arg1[18]) << 16); + x15 = ((uint32_t)(arg1[17]) << 8); + x16 = (arg1[16]); + x17 = ((uint32_t)(arg1[15]) << 24); + x18 = ((uint32_t)(arg1[14]) << 16); + x19 = ((uint32_t)(arg1[13]) << 8); + x20 = (arg1[12]); + x21 = ((uint32_t)(arg1[11]) << 24); + x22 = ((uint32_t)(arg1[10]) << 16); + x23 = ((uint32_t)(arg1[9]) << 8); + x24 = (arg1[8]); + x25 = ((uint32_t)(arg1[7]) << 24); + x26 = ((uint32_t)(arg1[6]) << 16); + x27 = ((uint32_t)(arg1[5]) << 8); + x28 = (arg1[4]); + x29 = ((uint32_t)(arg1[3]) << 24); + x30 = ((uint32_t)(arg1[2]) << 16); + x31 = ((uint32_t)(arg1[1]) << 8); + x32 = (arg1[0]); + x33 = (x31 + (uint32_t)x32); + x34 = (x30 + x33); + x35 = (x29 + x34); + x36 = (x27 + (uint32_t)x28); + x37 = (x26 + x36); + x38 = (x25 + x37); + x39 = (x23 + (uint32_t)x24); + x40 = (x22 + x39); + x41 = (x21 + x40); + x42 = (x19 + (uint32_t)x20); + x43 = (x18 + x42); + x44 = (x17 + x43); + x45 = (x15 + (uint32_t)x16); + x46 = (x14 + x45); + x47 = (x13 + x46); + x48 = (x11 + (uint32_t)x12); + x49 = (x10 + x48); + x50 = (x9 + x49); + x51 = (x7 + (uint32_t)x8); + x52 = (x6 + x51); + x53 = (x5 + x52); + x54 = (x3 + (uint32_t)x4); + x55 = (x2 + x54); + x56 = (x1 + x55); + out1[0] = x35; + out1[1] = x38; + out1[2] = x41; + out1[3] = x44; + out1[4] = x47; + out1[5] = x50; + out1[6] = x53; + out1[7] = x56; +} + +/* + * The function fiat_secp256k1_scalar_set_one returns the field element one in the Montgomery domain. + * + * Postconditions: + * eval (from_montgomery out1) mod m = 1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_set_one(fiat_secp256k1_scalar_montgomery_domain_field_element out1) { + out1[0] = UINT32_C(0x2fc9bebf); + out1[1] = UINT32_C(0x402da173); + out1[2] = UINT32_C(0x50b75fc4); + out1[3] = UINT32_C(0x45512319); + out1[4] = 0x1; + out1[5] = 0x0; + out1[6] = 0x0; + out1[7] = 0x0; +} + +/* + * The function fiat_secp256k1_scalar_msat returns the saturated representation of the prime modulus. + * + * Postconditions: + * twos_complement_eval out1 = m + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_msat(uint32_t out1[9]) { + out1[0] = UINT32_C(0xd0364141); + out1[1] = UINT32_C(0xbfd25e8c); + out1[2] = UINT32_C(0xaf48a03b); + out1[3] = UINT32_C(0xbaaedce6); + out1[4] = UINT32_C(0xfffffffe); + out1[5] = UINT32_C(0xffffffff); + out1[6] = UINT32_C(0xffffffff); + out1[7] = UINT32_C(0xffffffff); + out1[8] = 0x0; +} + +/* + * The function fiat_secp256k1_scalar_divstep computes a divstep. + * + * Preconditions: + * 0 ≤ eval arg4 < m + * 0 ≤ eval arg5 < m + * Postconditions: + * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) + * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) + * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) + * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) + * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) + * 0 ≤ eval out5 < m + * 0 ≤ eval out5 < m + * 0 ≤ eval out2 < m + * 0 ≤ eval out3 < m + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffff] + * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffff] + * out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + * out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_divstep(uint32_t* out1, uint32_t out2[9], uint32_t out3[9], uint32_t out4[8], uint32_t out5[8], uint32_t arg1, const uint32_t arg2[9], const uint32_t arg3[9], const uint32_t arg4[8], const uint32_t arg5[8]) { + uint32_t x1; + fiat_secp256k1_scalar_uint1 x2; + fiat_secp256k1_scalar_uint1 x3; + uint32_t x4; + fiat_secp256k1_scalar_uint1 x5; + uint32_t x6; + uint32_t x7; + uint32_t x8; + uint32_t x9; + uint32_t x10; + uint32_t x11; + uint32_t x12; + uint32_t x13; + uint32_t x14; + uint32_t x15; + uint32_t x16; + fiat_secp256k1_scalar_uint1 x17; + uint32_t x18; + fiat_secp256k1_scalar_uint1 x19; + uint32_t x20; + fiat_secp256k1_scalar_uint1 x21; + uint32_t x22; + fiat_secp256k1_scalar_uint1 x23; + uint32_t x24; + fiat_secp256k1_scalar_uint1 x25; + uint32_t x26; + fiat_secp256k1_scalar_uint1 x27; + uint32_t x28; + fiat_secp256k1_scalar_uint1 x29; + uint32_t x30; + fiat_secp256k1_scalar_uint1 x31; + uint32_t x32; + fiat_secp256k1_scalar_uint1 x33; + uint32_t x34; + uint32_t x35; + uint32_t x36; + uint32_t x37; + uint32_t x38; + uint32_t x39; + uint32_t x40; + uint32_t x41; + uint32_t x42; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + uint32_t x50; + uint32_t x51; + fiat_secp256k1_scalar_uint1 x52; + uint32_t x53; + fiat_secp256k1_scalar_uint1 x54; + uint32_t x55; + fiat_secp256k1_scalar_uint1 x56; + uint32_t x57; + fiat_secp256k1_scalar_uint1 x58; + uint32_t x59; + fiat_secp256k1_scalar_uint1 x60; + uint32_t x61; + fiat_secp256k1_scalar_uint1 x62; + uint32_t x63; + fiat_secp256k1_scalar_uint1 x64; + uint32_t x65; + fiat_secp256k1_scalar_uint1 x66; + uint32_t x67; + fiat_secp256k1_scalar_uint1 x68; + uint32_t x69; + fiat_secp256k1_scalar_uint1 x70; + uint32_t x71; + fiat_secp256k1_scalar_uint1 x72; + uint32_t x73; + fiat_secp256k1_scalar_uint1 x74; + uint32_t x75; + fiat_secp256k1_scalar_uint1 x76; + uint32_t x77; + fiat_secp256k1_scalar_uint1 x78; + uint32_t x79; + fiat_secp256k1_scalar_uint1 x80; + uint32_t x81; + fiat_secp256k1_scalar_uint1 x82; + uint32_t x83; + fiat_secp256k1_scalar_uint1 x84; + uint32_t x85; + uint32_t x86; + uint32_t x87; + uint32_t x88; + uint32_t x89; + uint32_t x90; + uint32_t x91; + uint32_t x92; + uint32_t x93; + fiat_secp256k1_scalar_uint1 x94; + uint32_t x95; + fiat_secp256k1_scalar_uint1 x96; + uint32_t x97; + fiat_secp256k1_scalar_uint1 x98; + uint32_t x99; + fiat_secp256k1_scalar_uint1 x100; + uint32_t x101; + fiat_secp256k1_scalar_uint1 x102; + uint32_t x103; + fiat_secp256k1_scalar_uint1 x104; + uint32_t x105; + fiat_secp256k1_scalar_uint1 x106; + uint32_t x107; + fiat_secp256k1_scalar_uint1 x108; + uint32_t x109; + uint32_t x110; + fiat_secp256k1_scalar_uint1 x111; + uint32_t x112; + fiat_secp256k1_scalar_uint1 x113; + uint32_t x114; + fiat_secp256k1_scalar_uint1 x115; + uint32_t x116; + fiat_secp256k1_scalar_uint1 x117; + uint32_t x118; + fiat_secp256k1_scalar_uint1 x119; + uint32_t x120; + fiat_secp256k1_scalar_uint1 x121; + uint32_t x122; + fiat_secp256k1_scalar_uint1 x123; + uint32_t x124; + fiat_secp256k1_scalar_uint1 x125; + uint32_t x126; + uint32_t x127; + uint32_t x128; + uint32_t x129; + uint32_t x130; + uint32_t x131; + uint32_t x132; + uint32_t x133; + fiat_secp256k1_scalar_uint1 x134; + uint32_t x135; + uint32_t x136; + uint32_t x137; + uint32_t x138; + uint32_t x139; + uint32_t x140; + uint32_t x141; + uint32_t x142; + uint32_t x143; + uint32_t x144; + fiat_secp256k1_scalar_uint1 x145; + uint32_t x146; + fiat_secp256k1_scalar_uint1 x147; + uint32_t x148; + fiat_secp256k1_scalar_uint1 x149; + uint32_t x150; + fiat_secp256k1_scalar_uint1 x151; + uint32_t x152; + fiat_secp256k1_scalar_uint1 x153; + uint32_t x154; + fiat_secp256k1_scalar_uint1 x155; + uint32_t x156; + fiat_secp256k1_scalar_uint1 x157; + uint32_t x158; + fiat_secp256k1_scalar_uint1 x159; + uint32_t x160; + fiat_secp256k1_scalar_uint1 x161; + uint32_t x162; + uint32_t x163; + uint32_t x164; + uint32_t x165; + uint32_t x166; + uint32_t x167; + uint32_t x168; + uint32_t x169; + uint32_t x170; + fiat_secp256k1_scalar_uint1 x171; + uint32_t x172; + fiat_secp256k1_scalar_uint1 x173; + uint32_t x174; + fiat_secp256k1_scalar_uint1 x175; + uint32_t x176; + fiat_secp256k1_scalar_uint1 x177; + uint32_t x178; + fiat_secp256k1_scalar_uint1 x179; + uint32_t x180; + fiat_secp256k1_scalar_uint1 x181; + uint32_t x182; + fiat_secp256k1_scalar_uint1 x183; + uint32_t x184; + fiat_secp256k1_scalar_uint1 x185; + uint32_t x186; + fiat_secp256k1_scalar_uint1 x187; + uint32_t x188; + fiat_secp256k1_scalar_uint1 x189; + uint32_t x190; + fiat_secp256k1_scalar_uint1 x191; + uint32_t x192; + fiat_secp256k1_scalar_uint1 x193; + uint32_t x194; + fiat_secp256k1_scalar_uint1 x195; + uint32_t x196; + fiat_secp256k1_scalar_uint1 x197; + uint32_t x198; + fiat_secp256k1_scalar_uint1 x199; + uint32_t x200; + fiat_secp256k1_scalar_uint1 x201; + uint32_t x202; + fiat_secp256k1_scalar_uint1 x203; + uint32_t x204; + fiat_secp256k1_scalar_uint1 x205; + uint32_t x206; + uint32_t x207; + uint32_t x208; + uint32_t x209; + uint32_t x210; + uint32_t x211; + uint32_t x212; + uint32_t x213; + uint32_t x214; + uint32_t x215; + uint32_t x216; + uint32_t x217; + uint32_t x218; + uint32_t x219; + uint32_t x220; + uint32_t x221; + uint32_t x222; + uint32_t x223; + uint32_t x224; + uint32_t x225; + uint32_t x226; + uint32_t x227; + uint32_t x228; + uint32_t x229; + uint32_t x230; + fiat_secp256k1_scalar_addcarryx_u32(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_secp256k1_scalar_uint1)((fiat_secp256k1_scalar_uint1)(x1 >> 31) & (fiat_secp256k1_scalar_uint1)((arg3[0]) & 0x1)); + fiat_secp256k1_scalar_addcarryx_u32(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_secp256k1_scalar_cmovznz_u32(&x6, x3, arg1, x4); + fiat_secp256k1_scalar_cmovznz_u32(&x7, x3, (arg2[0]), (arg3[0])); + fiat_secp256k1_scalar_cmovznz_u32(&x8, x3, (arg2[1]), (arg3[1])); + fiat_secp256k1_scalar_cmovznz_u32(&x9, x3, (arg2[2]), (arg3[2])); + fiat_secp256k1_scalar_cmovznz_u32(&x10, x3, (arg2[3]), (arg3[3])); + fiat_secp256k1_scalar_cmovznz_u32(&x11, x3, (arg2[4]), (arg3[4])); + fiat_secp256k1_scalar_cmovznz_u32(&x12, x3, (arg2[5]), (arg3[5])); + fiat_secp256k1_scalar_cmovznz_u32(&x13, x3, (arg2[6]), (arg3[6])); + fiat_secp256k1_scalar_cmovznz_u32(&x14, x3, (arg2[7]), (arg3[7])); + fiat_secp256k1_scalar_cmovznz_u32(&x15, x3, (arg2[8]), (arg3[8])); + fiat_secp256k1_scalar_addcarryx_u32(&x16, &x17, 0x0, 0x1, (~(arg2[0]))); + fiat_secp256k1_scalar_addcarryx_u32(&x18, &x19, x17, 0x0, (~(arg2[1]))); + fiat_secp256k1_scalar_addcarryx_u32(&x20, &x21, x19, 0x0, (~(arg2[2]))); + fiat_secp256k1_scalar_addcarryx_u32(&x22, &x23, x21, 0x0, (~(arg2[3]))); + fiat_secp256k1_scalar_addcarryx_u32(&x24, &x25, x23, 0x0, (~(arg2[4]))); + fiat_secp256k1_scalar_addcarryx_u32(&x26, &x27, x25, 0x0, (~(arg2[5]))); + fiat_secp256k1_scalar_addcarryx_u32(&x28, &x29, x27, 0x0, (~(arg2[6]))); + fiat_secp256k1_scalar_addcarryx_u32(&x30, &x31, x29, 0x0, (~(arg2[7]))); + fiat_secp256k1_scalar_addcarryx_u32(&x32, &x33, x31, 0x0, (~(arg2[8]))); + fiat_secp256k1_scalar_cmovznz_u32(&x34, x3, (arg3[0]), x16); + fiat_secp256k1_scalar_cmovznz_u32(&x35, x3, (arg3[1]), x18); + fiat_secp256k1_scalar_cmovznz_u32(&x36, x3, (arg3[2]), x20); + fiat_secp256k1_scalar_cmovznz_u32(&x37, x3, (arg3[3]), x22); + fiat_secp256k1_scalar_cmovznz_u32(&x38, x3, (arg3[4]), x24); + fiat_secp256k1_scalar_cmovznz_u32(&x39, x3, (arg3[5]), x26); + fiat_secp256k1_scalar_cmovznz_u32(&x40, x3, (arg3[6]), x28); + fiat_secp256k1_scalar_cmovznz_u32(&x41, x3, (arg3[7]), x30); + fiat_secp256k1_scalar_cmovznz_u32(&x42, x3, (arg3[8]), x32); + fiat_secp256k1_scalar_cmovznz_u32(&x43, x3, (arg4[0]), (arg5[0])); + fiat_secp256k1_scalar_cmovznz_u32(&x44, x3, (arg4[1]), (arg5[1])); + fiat_secp256k1_scalar_cmovznz_u32(&x45, x3, (arg4[2]), (arg5[2])); + fiat_secp256k1_scalar_cmovznz_u32(&x46, x3, (arg4[3]), (arg5[3])); + fiat_secp256k1_scalar_cmovznz_u32(&x47, x3, (arg4[4]), (arg5[4])); + fiat_secp256k1_scalar_cmovznz_u32(&x48, x3, (arg4[5]), (arg5[5])); + fiat_secp256k1_scalar_cmovznz_u32(&x49, x3, (arg4[6]), (arg5[6])); + fiat_secp256k1_scalar_cmovznz_u32(&x50, x3, (arg4[7]), (arg5[7])); + fiat_secp256k1_scalar_addcarryx_u32(&x51, &x52, 0x0, x43, x43); + fiat_secp256k1_scalar_addcarryx_u32(&x53, &x54, x52, x44, x44); + fiat_secp256k1_scalar_addcarryx_u32(&x55, &x56, x54, x45, x45); + fiat_secp256k1_scalar_addcarryx_u32(&x57, &x58, x56, x46, x46); + fiat_secp256k1_scalar_addcarryx_u32(&x59, &x60, x58, x47, x47); + fiat_secp256k1_scalar_addcarryx_u32(&x61, &x62, x60, x48, x48); + fiat_secp256k1_scalar_addcarryx_u32(&x63, &x64, x62, x49, x49); + fiat_secp256k1_scalar_addcarryx_u32(&x65, &x66, x64, x50, x50); + fiat_secp256k1_scalar_subborrowx_u32(&x67, &x68, 0x0, x51, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_subborrowx_u32(&x69, &x70, x68, x53, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_subborrowx_u32(&x71, &x72, x70, x55, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_subborrowx_u32(&x73, &x74, x72, x57, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_subborrowx_u32(&x75, &x76, x74, x59, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_subborrowx_u32(&x77, &x78, x76, x61, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x79, &x80, x78, x63, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x81, &x82, x80, x65, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x83, &x84, x82, x66, 0x0); + x85 = (arg4[7]); + x86 = (arg4[6]); + x87 = (arg4[5]); + x88 = (arg4[4]); + x89 = (arg4[3]); + x90 = (arg4[2]); + x91 = (arg4[1]); + x92 = (arg4[0]); + fiat_secp256k1_scalar_subborrowx_u32(&x93, &x94, 0x0, 0x0, x92); + fiat_secp256k1_scalar_subborrowx_u32(&x95, &x96, x94, 0x0, x91); + fiat_secp256k1_scalar_subborrowx_u32(&x97, &x98, x96, 0x0, x90); + fiat_secp256k1_scalar_subborrowx_u32(&x99, &x100, x98, 0x0, x89); + fiat_secp256k1_scalar_subborrowx_u32(&x101, &x102, x100, 0x0, x88); + fiat_secp256k1_scalar_subborrowx_u32(&x103, &x104, x102, 0x0, x87); + fiat_secp256k1_scalar_subborrowx_u32(&x105, &x106, x104, 0x0, x86); + fiat_secp256k1_scalar_subborrowx_u32(&x107, &x108, x106, 0x0, x85); + fiat_secp256k1_scalar_cmovznz_u32(&x109, x108, 0x0, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_addcarryx_u32(&x110, &x111, 0x0, x93, (x109 & UINT32_C(0xd0364141))); + fiat_secp256k1_scalar_addcarryx_u32(&x112, &x113, x111, x95, (x109 & UINT32_C(0xbfd25e8c))); + fiat_secp256k1_scalar_addcarryx_u32(&x114, &x115, x113, x97, (x109 & UINT32_C(0xaf48a03b))); + fiat_secp256k1_scalar_addcarryx_u32(&x116, &x117, x115, x99, (x109 & UINT32_C(0xbaaedce6))); + fiat_secp256k1_scalar_addcarryx_u32(&x118, &x119, x117, x101, (x109 & UINT32_C(0xfffffffe))); + fiat_secp256k1_scalar_addcarryx_u32(&x120, &x121, x119, x103, x109); + fiat_secp256k1_scalar_addcarryx_u32(&x122, &x123, x121, x105, x109); + fiat_secp256k1_scalar_addcarryx_u32(&x124, &x125, x123, x107, x109); + fiat_secp256k1_scalar_cmovznz_u32(&x126, x3, (arg5[0]), x110); + fiat_secp256k1_scalar_cmovznz_u32(&x127, x3, (arg5[1]), x112); + fiat_secp256k1_scalar_cmovznz_u32(&x128, x3, (arg5[2]), x114); + fiat_secp256k1_scalar_cmovznz_u32(&x129, x3, (arg5[3]), x116); + fiat_secp256k1_scalar_cmovznz_u32(&x130, x3, (arg5[4]), x118); + fiat_secp256k1_scalar_cmovznz_u32(&x131, x3, (arg5[5]), x120); + fiat_secp256k1_scalar_cmovznz_u32(&x132, x3, (arg5[6]), x122); + fiat_secp256k1_scalar_cmovznz_u32(&x133, x3, (arg5[7]), x124); + x134 = (fiat_secp256k1_scalar_uint1)(x34 & 0x1); + fiat_secp256k1_scalar_cmovznz_u32(&x135, x134, 0x0, x7); + fiat_secp256k1_scalar_cmovznz_u32(&x136, x134, 0x0, x8); + fiat_secp256k1_scalar_cmovznz_u32(&x137, x134, 0x0, x9); + fiat_secp256k1_scalar_cmovznz_u32(&x138, x134, 0x0, x10); + fiat_secp256k1_scalar_cmovznz_u32(&x139, x134, 0x0, x11); + fiat_secp256k1_scalar_cmovznz_u32(&x140, x134, 0x0, x12); + fiat_secp256k1_scalar_cmovznz_u32(&x141, x134, 0x0, x13); + fiat_secp256k1_scalar_cmovznz_u32(&x142, x134, 0x0, x14); + fiat_secp256k1_scalar_cmovznz_u32(&x143, x134, 0x0, x15); + fiat_secp256k1_scalar_addcarryx_u32(&x144, &x145, 0x0, x34, x135); + fiat_secp256k1_scalar_addcarryx_u32(&x146, &x147, x145, x35, x136); + fiat_secp256k1_scalar_addcarryx_u32(&x148, &x149, x147, x36, x137); + fiat_secp256k1_scalar_addcarryx_u32(&x150, &x151, x149, x37, x138); + fiat_secp256k1_scalar_addcarryx_u32(&x152, &x153, x151, x38, x139); + fiat_secp256k1_scalar_addcarryx_u32(&x154, &x155, x153, x39, x140); + fiat_secp256k1_scalar_addcarryx_u32(&x156, &x157, x155, x40, x141); + fiat_secp256k1_scalar_addcarryx_u32(&x158, &x159, x157, x41, x142); + fiat_secp256k1_scalar_addcarryx_u32(&x160, &x161, x159, x42, x143); + fiat_secp256k1_scalar_cmovznz_u32(&x162, x134, 0x0, x43); + fiat_secp256k1_scalar_cmovznz_u32(&x163, x134, 0x0, x44); + fiat_secp256k1_scalar_cmovznz_u32(&x164, x134, 0x0, x45); + fiat_secp256k1_scalar_cmovznz_u32(&x165, x134, 0x0, x46); + fiat_secp256k1_scalar_cmovznz_u32(&x166, x134, 0x0, x47); + fiat_secp256k1_scalar_cmovznz_u32(&x167, x134, 0x0, x48); + fiat_secp256k1_scalar_cmovznz_u32(&x168, x134, 0x0, x49); + fiat_secp256k1_scalar_cmovznz_u32(&x169, x134, 0x0, x50); + fiat_secp256k1_scalar_addcarryx_u32(&x170, &x171, 0x0, x126, x162); + fiat_secp256k1_scalar_addcarryx_u32(&x172, &x173, x171, x127, x163); + fiat_secp256k1_scalar_addcarryx_u32(&x174, &x175, x173, x128, x164); + fiat_secp256k1_scalar_addcarryx_u32(&x176, &x177, x175, x129, x165); + fiat_secp256k1_scalar_addcarryx_u32(&x178, &x179, x177, x130, x166); + fiat_secp256k1_scalar_addcarryx_u32(&x180, &x181, x179, x131, x167); + fiat_secp256k1_scalar_addcarryx_u32(&x182, &x183, x181, x132, x168); + fiat_secp256k1_scalar_addcarryx_u32(&x184, &x185, x183, x133, x169); + fiat_secp256k1_scalar_subborrowx_u32(&x186, &x187, 0x0, x170, UINT32_C(0xd0364141)); + fiat_secp256k1_scalar_subborrowx_u32(&x188, &x189, x187, x172, UINT32_C(0xbfd25e8c)); + fiat_secp256k1_scalar_subborrowx_u32(&x190, &x191, x189, x174, UINT32_C(0xaf48a03b)); + fiat_secp256k1_scalar_subborrowx_u32(&x192, &x193, x191, x176, UINT32_C(0xbaaedce6)); + fiat_secp256k1_scalar_subborrowx_u32(&x194, &x195, x193, x178, UINT32_C(0xfffffffe)); + fiat_secp256k1_scalar_subborrowx_u32(&x196, &x197, x195, x180, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x198, &x199, x197, x182, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x200, &x201, x199, x184, UINT32_C(0xffffffff)); + fiat_secp256k1_scalar_subborrowx_u32(&x202, &x203, x201, x185, 0x0); + fiat_secp256k1_scalar_addcarryx_u32(&x204, &x205, 0x0, x6, 0x1); + x206 = ((x144 >> 1) | ((x146 << 31) & UINT32_C(0xffffffff))); + x207 = ((x146 >> 1) | ((x148 << 31) & UINT32_C(0xffffffff))); + x208 = ((x148 >> 1) | ((x150 << 31) & UINT32_C(0xffffffff))); + x209 = ((x150 >> 1) | ((x152 << 31) & UINT32_C(0xffffffff))); + x210 = ((x152 >> 1) | ((x154 << 31) & UINT32_C(0xffffffff))); + x211 = ((x154 >> 1) | ((x156 << 31) & UINT32_C(0xffffffff))); + x212 = ((x156 >> 1) | ((x158 << 31) & UINT32_C(0xffffffff))); + x213 = ((x158 >> 1) | ((x160 << 31) & UINT32_C(0xffffffff))); + x214 = ((x160 & UINT32_C(0x80000000)) | (x160 >> 1)); + fiat_secp256k1_scalar_cmovznz_u32(&x215, x84, x67, x51); + fiat_secp256k1_scalar_cmovznz_u32(&x216, x84, x69, x53); + fiat_secp256k1_scalar_cmovznz_u32(&x217, x84, x71, x55); + fiat_secp256k1_scalar_cmovznz_u32(&x218, x84, x73, x57); + fiat_secp256k1_scalar_cmovznz_u32(&x219, x84, x75, x59); + fiat_secp256k1_scalar_cmovznz_u32(&x220, x84, x77, x61); + fiat_secp256k1_scalar_cmovznz_u32(&x221, x84, x79, x63); + fiat_secp256k1_scalar_cmovznz_u32(&x222, x84, x81, x65); + fiat_secp256k1_scalar_cmovznz_u32(&x223, x203, x186, x170); + fiat_secp256k1_scalar_cmovznz_u32(&x224, x203, x188, x172); + fiat_secp256k1_scalar_cmovznz_u32(&x225, x203, x190, x174); + fiat_secp256k1_scalar_cmovznz_u32(&x226, x203, x192, x176); + fiat_secp256k1_scalar_cmovznz_u32(&x227, x203, x194, x178); + fiat_secp256k1_scalar_cmovznz_u32(&x228, x203, x196, x180); + fiat_secp256k1_scalar_cmovznz_u32(&x229, x203, x198, x182); + fiat_secp256k1_scalar_cmovznz_u32(&x230, x203, x200, x184); + *out1 = x204; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out2[7] = x14; + out2[8] = x15; + out3[0] = x206; + out3[1] = x207; + out3[2] = x208; + out3[3] = x209; + out3[4] = x210; + out3[5] = x211; + out3[6] = x212; + out3[7] = x213; + out3[8] = x214; + out4[0] = x215; + out4[1] = x216; + out4[2] = x217; + out4[3] = x218; + out4[4] = x219; + out4[5] = x220; + out4[6] = x221; + out4[7] = x222; + out5[0] = x223; + out5[1] = x224; + out5[2] = x225; + out5[3] = x226; + out5[4] = x227; + out5[5] = x228; + out5[6] = x229; + out5[7] = x230; +} + +/* + * The function fiat_secp256k1_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). + * + * Postconditions: + * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_divstep_precomp(uint32_t out1[8]) { + out1[0] = UINT32_C(0x2b9cb4e9); + out1[1] = UINT32_C(0xd7431a4d); + out1[2] = UINT32_C(0x32d9c503); + out1[3] = UINT32_C(0xab67d35a); + out1[4] = UINT32_C(0x859ce35f); + out1[5] = UINT32_C(0xadf6c7e5); + out1[6] = UINT32_C(0x1df6c379); + out1[7] = UINT32_C(0x61544145); +} diff --git a/fiat-c/src/secp256k1_scalar_64.c b/fiat-c/src/secp256k1_scalar_64.c new file mode 100644 index 0000000000..cba5d58bef --- /dev/null +++ b/fiat-c/src/secp256k1_scalar_64.c @@ -0,0 +1,2234 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier secp256k1_scalar 64 '2^256 - 432420386565659656852420866394968145599' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: secp256k1_scalar */ +/* machine_wordsize = 64 (from "64") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141 (from "2^256 - 432420386565659656852420866394968145599") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +typedef unsigned char fiat_secp256k1_scalar_uint1; +typedef signed char fiat_secp256k1_scalar_int1; +#if defined(__GNUC__) || defined(__clang__) +# define FIAT_SECP256K1_SCALAR_FIAT_EXTENSION __extension__ +# define FIAT_SECP256K1_SCALAR_FIAT_INLINE __inline__ +#else +# define FIAT_SECP256K1_SCALAR_FIAT_EXTENSION +# define FIAT_SECP256K1_SCALAR_FIAT_INLINE +#endif + +FIAT_SECP256K1_SCALAR_FIAT_EXTENSION typedef signed __int128 fiat_secp256k1_scalar_int128; +FIAT_SECP256K1_SCALAR_FIAT_EXTENSION typedef unsigned __int128 fiat_secp256k1_scalar_uint128; + +/* The type fiat_secp256k1_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +typedef uint64_t fiat_secp256k1_scalar_montgomery_domain_field_element[4]; + +/* The type fiat_secp256k1_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +typedef uint64_t fiat_secp256k1_scalar_non_montgomery_domain_field_element[4]; + +#if (-1 & 3) != 3 +#error "This code only works on a two's complement system" +#endif + +#if !defined(FIAT_SECP256K1_SCALAR_NO_ASM) && (defined(__GNUC__) || defined(__clang__)) +static __inline__ uint64_t fiat_secp256k1_scalar_value_barrier_u64(uint64_t a) { + __asm__("" : "+r"(a) : /* no inputs */); + return a; +} +#else +# define fiat_secp256k1_scalar_value_barrier_u64(x) (x) +#endif + + +/* + * The function fiat_secp256k1_scalar_addcarryx_u64 is an addition with carry. + * + * Postconditions: + * out1 = (arg1 + arg2 + arg3) mod 2^64 + * out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_addcarryx_u64(uint64_t* out1, fiat_secp256k1_scalar_uint1* out2, fiat_secp256k1_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_secp256k1_scalar_uint128 x1; + uint64_t x2; + fiat_secp256k1_scalar_uint1 x3; + x1 = ((arg1 + (fiat_secp256k1_scalar_uint128)arg2) + arg3); + x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + x3 = (fiat_secp256k1_scalar_uint1)(x1 >> 64); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_secp256k1_scalar_subborrowx_u64 is a subtraction with borrow. + * + * Postconditions: + * out1 = (-arg1 + arg2 + -arg3) mod 2^64 + * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_subborrowx_u64(uint64_t* out1, fiat_secp256k1_scalar_uint1* out2, fiat_secp256k1_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_secp256k1_scalar_int128 x1; + fiat_secp256k1_scalar_int1 x2; + uint64_t x3; + x1 = ((arg2 - (fiat_secp256k1_scalar_int128)arg1) - arg3); + x2 = (fiat_secp256k1_scalar_int1)(x1 >> 64); + x3 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + *out1 = x3; + *out2 = (fiat_secp256k1_scalar_uint1)(0x0 - x2); +} + +/* + * The function fiat_secp256k1_scalar_mulx_u64 is a multiplication, returning the full double-width result. + * + * Postconditions: + * out1 = (arg1 * arg2) mod 2^64 + * out2 = ⌊arg1 * arg2 / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffffffffffff] + * arg2: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_mulx_u64(uint64_t* out1, uint64_t* out2, uint64_t arg1, uint64_t arg2) { + fiat_secp256k1_scalar_uint128 x1; + uint64_t x2; + uint64_t x3; + x1 = ((fiat_secp256k1_scalar_uint128)arg1 * arg2); + x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + x3 = (uint64_t)(x1 >> 64); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_secp256k1_scalar_cmovznz_u64 is a single-word conditional move. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_cmovznz_u64(uint64_t* out1, fiat_secp256k1_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_secp256k1_scalar_uint1 x1; + uint64_t x2; + uint64_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_secp256k1_scalar_int1)(0x0 - x1) & UINT64_C(0xffffffffffffffff)); + x3 = ((fiat_secp256k1_scalar_value_barrier_u64(x2) & arg3) | (fiat_secp256k1_scalar_value_barrier_u64((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_secp256k1_scalar_mul multiplies two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_mul(fiat_secp256k1_scalar_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_secp256k1_scalar_uint1 x14; + uint64_t x15; + fiat_secp256k1_scalar_uint1 x16; + uint64_t x17; + fiat_secp256k1_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + fiat_secp256k1_scalar_uint1 x31; + uint64_t x32; + fiat_secp256k1_scalar_uint1 x33; + uint64_t x34; + fiat_secp256k1_scalar_uint1 x35; + uint64_t x36; + uint64_t x37; + fiat_secp256k1_scalar_uint1 x38; + uint64_t x39; + fiat_secp256k1_scalar_uint1 x40; + uint64_t x41; + fiat_secp256k1_scalar_uint1 x42; + uint64_t x43; + fiat_secp256k1_scalar_uint1 x44; + uint64_t x45; + fiat_secp256k1_scalar_uint1 x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + uint64_t x54; + uint64_t x55; + fiat_secp256k1_scalar_uint1 x56; + uint64_t x57; + fiat_secp256k1_scalar_uint1 x58; + uint64_t x59; + fiat_secp256k1_scalar_uint1 x60; + uint64_t x61; + uint64_t x62; + fiat_secp256k1_scalar_uint1 x63; + uint64_t x64; + fiat_secp256k1_scalar_uint1 x65; + uint64_t x66; + fiat_secp256k1_scalar_uint1 x67; + uint64_t x68; + fiat_secp256k1_scalar_uint1 x69; + uint64_t x70; + fiat_secp256k1_scalar_uint1 x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + uint64_t x81; + uint64_t x82; + fiat_secp256k1_scalar_uint1 x83; + uint64_t x84; + fiat_secp256k1_scalar_uint1 x85; + uint64_t x86; + fiat_secp256k1_scalar_uint1 x87; + uint64_t x88; + uint64_t x89; + fiat_secp256k1_scalar_uint1 x90; + uint64_t x91; + fiat_secp256k1_scalar_uint1 x92; + uint64_t x93; + fiat_secp256k1_scalar_uint1 x94; + uint64_t x95; + fiat_secp256k1_scalar_uint1 x96; + uint64_t x97; + fiat_secp256k1_scalar_uint1 x98; + uint64_t x99; + uint64_t x100; + uint64_t x101; + uint64_t x102; + uint64_t x103; + uint64_t x104; + uint64_t x105; + uint64_t x106; + uint64_t x107; + uint64_t x108; + fiat_secp256k1_scalar_uint1 x109; + uint64_t x110; + fiat_secp256k1_scalar_uint1 x111; + uint64_t x112; + fiat_secp256k1_scalar_uint1 x113; + uint64_t x114; + uint64_t x115; + fiat_secp256k1_scalar_uint1 x116; + uint64_t x117; + fiat_secp256k1_scalar_uint1 x118; + uint64_t x119; + fiat_secp256k1_scalar_uint1 x120; + uint64_t x121; + fiat_secp256k1_scalar_uint1 x122; + uint64_t x123; + fiat_secp256k1_scalar_uint1 x124; + uint64_t x125; + uint64_t x126; + uint64_t x127; + uint64_t x128; + uint64_t x129; + uint64_t x130; + uint64_t x131; + uint64_t x132; + uint64_t x133; + uint64_t x134; + uint64_t x135; + fiat_secp256k1_scalar_uint1 x136; + uint64_t x137; + fiat_secp256k1_scalar_uint1 x138; + uint64_t x139; + fiat_secp256k1_scalar_uint1 x140; + uint64_t x141; + uint64_t x142; + fiat_secp256k1_scalar_uint1 x143; + uint64_t x144; + fiat_secp256k1_scalar_uint1 x145; + uint64_t x146; + fiat_secp256k1_scalar_uint1 x147; + uint64_t x148; + fiat_secp256k1_scalar_uint1 x149; + uint64_t x150; + fiat_secp256k1_scalar_uint1 x151; + uint64_t x152; + uint64_t x153; + uint64_t x154; + uint64_t x155; + uint64_t x156; + uint64_t x157; + uint64_t x158; + uint64_t x159; + uint64_t x160; + uint64_t x161; + fiat_secp256k1_scalar_uint1 x162; + uint64_t x163; + fiat_secp256k1_scalar_uint1 x164; + uint64_t x165; + fiat_secp256k1_scalar_uint1 x166; + uint64_t x167; + uint64_t x168; + fiat_secp256k1_scalar_uint1 x169; + uint64_t x170; + fiat_secp256k1_scalar_uint1 x171; + uint64_t x172; + fiat_secp256k1_scalar_uint1 x173; + uint64_t x174; + fiat_secp256k1_scalar_uint1 x175; + uint64_t x176; + fiat_secp256k1_scalar_uint1 x177; + uint64_t x178; + uint64_t x179; + uint64_t x180; + uint64_t x181; + uint64_t x182; + uint64_t x183; + uint64_t x184; + uint64_t x185; + uint64_t x186; + uint64_t x187; + uint64_t x188; + fiat_secp256k1_scalar_uint1 x189; + uint64_t x190; + fiat_secp256k1_scalar_uint1 x191; + uint64_t x192; + fiat_secp256k1_scalar_uint1 x193; + uint64_t x194; + uint64_t x195; + fiat_secp256k1_scalar_uint1 x196; + uint64_t x197; + fiat_secp256k1_scalar_uint1 x198; + uint64_t x199; + fiat_secp256k1_scalar_uint1 x200; + uint64_t x201; + fiat_secp256k1_scalar_uint1 x202; + uint64_t x203; + fiat_secp256k1_scalar_uint1 x204; + uint64_t x205; + uint64_t x206; + fiat_secp256k1_scalar_uint1 x207; + uint64_t x208; + fiat_secp256k1_scalar_uint1 x209; + uint64_t x210; + fiat_secp256k1_scalar_uint1 x211; + uint64_t x212; + fiat_secp256k1_scalar_uint1 x213; + uint64_t x214; + fiat_secp256k1_scalar_uint1 x215; + uint64_t x216; + uint64_t x217; + uint64_t x218; + uint64_t x219; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_secp256k1_scalar_mulx_u64(&x5, &x6, x4, (arg2[3])); + fiat_secp256k1_scalar_mulx_u64(&x7, &x8, x4, (arg2[2])); + fiat_secp256k1_scalar_mulx_u64(&x9, &x10, x4, (arg2[1])); + fiat_secp256k1_scalar_mulx_u64(&x11, &x12, x4, (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_secp256k1_scalar_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_secp256k1_scalar_addcarryx_u64(&x17, &x18, x16, x8, x5); + x19 = (x18 + x6); + fiat_secp256k1_scalar_mulx_u64(&x20, &x21, x11, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x22, &x23, x20, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x24, &x25, x20, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x26, &x27, x20, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x28, &x29, x20, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x30, &x31, 0x0, x29, x26); + fiat_secp256k1_scalar_addcarryx_u64(&x32, &x33, x31, x27, x24); + fiat_secp256k1_scalar_addcarryx_u64(&x34, &x35, x33, x25, x22); + x36 = (x35 + x23); + fiat_secp256k1_scalar_addcarryx_u64(&x37, &x38, 0x0, x11, x28); + fiat_secp256k1_scalar_addcarryx_u64(&x39, &x40, x38, x13, x30); + fiat_secp256k1_scalar_addcarryx_u64(&x41, &x42, x40, x15, x32); + fiat_secp256k1_scalar_addcarryx_u64(&x43, &x44, x42, x17, x34); + fiat_secp256k1_scalar_addcarryx_u64(&x45, &x46, x44, x19, x36); + fiat_secp256k1_scalar_mulx_u64(&x47, &x48, x1, (arg2[3])); + fiat_secp256k1_scalar_mulx_u64(&x49, &x50, x1, (arg2[2])); + fiat_secp256k1_scalar_mulx_u64(&x51, &x52, x1, (arg2[1])); + fiat_secp256k1_scalar_mulx_u64(&x53, &x54, x1, (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u64(&x55, &x56, 0x0, x54, x51); + fiat_secp256k1_scalar_addcarryx_u64(&x57, &x58, x56, x52, x49); + fiat_secp256k1_scalar_addcarryx_u64(&x59, &x60, x58, x50, x47); + x61 = (x60 + x48); + fiat_secp256k1_scalar_addcarryx_u64(&x62, &x63, 0x0, x39, x53); + fiat_secp256k1_scalar_addcarryx_u64(&x64, &x65, x63, x41, x55); + fiat_secp256k1_scalar_addcarryx_u64(&x66, &x67, x65, x43, x57); + fiat_secp256k1_scalar_addcarryx_u64(&x68, &x69, x67, x45, x59); + fiat_secp256k1_scalar_addcarryx_u64(&x70, &x71, x69, x46, x61); + fiat_secp256k1_scalar_mulx_u64(&x72, &x73, x62, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x74, &x75, x72, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x76, &x77, x72, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x78, &x79, x72, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x80, &x81, x72, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x82, &x83, 0x0, x81, x78); + fiat_secp256k1_scalar_addcarryx_u64(&x84, &x85, x83, x79, x76); + fiat_secp256k1_scalar_addcarryx_u64(&x86, &x87, x85, x77, x74); + x88 = (x87 + x75); + fiat_secp256k1_scalar_addcarryx_u64(&x89, &x90, 0x0, x62, x80); + fiat_secp256k1_scalar_addcarryx_u64(&x91, &x92, x90, x64, x82); + fiat_secp256k1_scalar_addcarryx_u64(&x93, &x94, x92, x66, x84); + fiat_secp256k1_scalar_addcarryx_u64(&x95, &x96, x94, x68, x86); + fiat_secp256k1_scalar_addcarryx_u64(&x97, &x98, x96, x70, x88); + x99 = ((uint64_t)x98 + x71); + fiat_secp256k1_scalar_mulx_u64(&x100, &x101, x2, (arg2[3])); + fiat_secp256k1_scalar_mulx_u64(&x102, &x103, x2, (arg2[2])); + fiat_secp256k1_scalar_mulx_u64(&x104, &x105, x2, (arg2[1])); + fiat_secp256k1_scalar_mulx_u64(&x106, &x107, x2, (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u64(&x108, &x109, 0x0, x107, x104); + fiat_secp256k1_scalar_addcarryx_u64(&x110, &x111, x109, x105, x102); + fiat_secp256k1_scalar_addcarryx_u64(&x112, &x113, x111, x103, x100); + x114 = (x113 + x101); + fiat_secp256k1_scalar_addcarryx_u64(&x115, &x116, 0x0, x91, x106); + fiat_secp256k1_scalar_addcarryx_u64(&x117, &x118, x116, x93, x108); + fiat_secp256k1_scalar_addcarryx_u64(&x119, &x120, x118, x95, x110); + fiat_secp256k1_scalar_addcarryx_u64(&x121, &x122, x120, x97, x112); + fiat_secp256k1_scalar_addcarryx_u64(&x123, &x124, x122, x99, x114); + fiat_secp256k1_scalar_mulx_u64(&x125, &x126, x115, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x127, &x128, x125, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x129, &x130, x125, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x131, &x132, x125, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x133, &x134, x125, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x135, &x136, 0x0, x134, x131); + fiat_secp256k1_scalar_addcarryx_u64(&x137, &x138, x136, x132, x129); + fiat_secp256k1_scalar_addcarryx_u64(&x139, &x140, x138, x130, x127); + x141 = (x140 + x128); + fiat_secp256k1_scalar_addcarryx_u64(&x142, &x143, 0x0, x115, x133); + fiat_secp256k1_scalar_addcarryx_u64(&x144, &x145, x143, x117, x135); + fiat_secp256k1_scalar_addcarryx_u64(&x146, &x147, x145, x119, x137); + fiat_secp256k1_scalar_addcarryx_u64(&x148, &x149, x147, x121, x139); + fiat_secp256k1_scalar_addcarryx_u64(&x150, &x151, x149, x123, x141); + x152 = ((uint64_t)x151 + x124); + fiat_secp256k1_scalar_mulx_u64(&x153, &x154, x3, (arg2[3])); + fiat_secp256k1_scalar_mulx_u64(&x155, &x156, x3, (arg2[2])); + fiat_secp256k1_scalar_mulx_u64(&x157, &x158, x3, (arg2[1])); + fiat_secp256k1_scalar_mulx_u64(&x159, &x160, x3, (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u64(&x161, &x162, 0x0, x160, x157); + fiat_secp256k1_scalar_addcarryx_u64(&x163, &x164, x162, x158, x155); + fiat_secp256k1_scalar_addcarryx_u64(&x165, &x166, x164, x156, x153); + x167 = (x166 + x154); + fiat_secp256k1_scalar_addcarryx_u64(&x168, &x169, 0x0, x144, x159); + fiat_secp256k1_scalar_addcarryx_u64(&x170, &x171, x169, x146, x161); + fiat_secp256k1_scalar_addcarryx_u64(&x172, &x173, x171, x148, x163); + fiat_secp256k1_scalar_addcarryx_u64(&x174, &x175, x173, x150, x165); + fiat_secp256k1_scalar_addcarryx_u64(&x176, &x177, x175, x152, x167); + fiat_secp256k1_scalar_mulx_u64(&x178, &x179, x168, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x180, &x181, x178, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x182, &x183, x178, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x184, &x185, x178, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x186, &x187, x178, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x188, &x189, 0x0, x187, x184); + fiat_secp256k1_scalar_addcarryx_u64(&x190, &x191, x189, x185, x182); + fiat_secp256k1_scalar_addcarryx_u64(&x192, &x193, x191, x183, x180); + x194 = (x193 + x181); + fiat_secp256k1_scalar_addcarryx_u64(&x195, &x196, 0x0, x168, x186); + fiat_secp256k1_scalar_addcarryx_u64(&x197, &x198, x196, x170, x188); + fiat_secp256k1_scalar_addcarryx_u64(&x199, &x200, x198, x172, x190); + fiat_secp256k1_scalar_addcarryx_u64(&x201, &x202, x200, x174, x192); + fiat_secp256k1_scalar_addcarryx_u64(&x203, &x204, x202, x176, x194); + x205 = ((uint64_t)x204 + x177); + fiat_secp256k1_scalar_subborrowx_u64(&x206, &x207, 0x0, x197, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_subborrowx_u64(&x208, &x209, x207, x199, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_subborrowx_u64(&x210, &x211, x209, x201, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_subborrowx_u64(&x212, &x213, x211, x203, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_subborrowx_u64(&x214, &x215, x213, x205, 0x0); + fiat_secp256k1_scalar_cmovznz_u64(&x216, x215, x206, x197); + fiat_secp256k1_scalar_cmovznz_u64(&x217, x215, x208, x199); + fiat_secp256k1_scalar_cmovznz_u64(&x218, x215, x210, x201); + fiat_secp256k1_scalar_cmovznz_u64(&x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/* + * The function fiat_secp256k1_scalar_square squares a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_square(fiat_secp256k1_scalar_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_secp256k1_scalar_uint1 x14; + uint64_t x15; + fiat_secp256k1_scalar_uint1 x16; + uint64_t x17; + fiat_secp256k1_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + fiat_secp256k1_scalar_uint1 x31; + uint64_t x32; + fiat_secp256k1_scalar_uint1 x33; + uint64_t x34; + fiat_secp256k1_scalar_uint1 x35; + uint64_t x36; + uint64_t x37; + fiat_secp256k1_scalar_uint1 x38; + uint64_t x39; + fiat_secp256k1_scalar_uint1 x40; + uint64_t x41; + fiat_secp256k1_scalar_uint1 x42; + uint64_t x43; + fiat_secp256k1_scalar_uint1 x44; + uint64_t x45; + fiat_secp256k1_scalar_uint1 x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + uint64_t x54; + uint64_t x55; + fiat_secp256k1_scalar_uint1 x56; + uint64_t x57; + fiat_secp256k1_scalar_uint1 x58; + uint64_t x59; + fiat_secp256k1_scalar_uint1 x60; + uint64_t x61; + uint64_t x62; + fiat_secp256k1_scalar_uint1 x63; + uint64_t x64; + fiat_secp256k1_scalar_uint1 x65; + uint64_t x66; + fiat_secp256k1_scalar_uint1 x67; + uint64_t x68; + fiat_secp256k1_scalar_uint1 x69; + uint64_t x70; + fiat_secp256k1_scalar_uint1 x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + uint64_t x81; + uint64_t x82; + fiat_secp256k1_scalar_uint1 x83; + uint64_t x84; + fiat_secp256k1_scalar_uint1 x85; + uint64_t x86; + fiat_secp256k1_scalar_uint1 x87; + uint64_t x88; + uint64_t x89; + fiat_secp256k1_scalar_uint1 x90; + uint64_t x91; + fiat_secp256k1_scalar_uint1 x92; + uint64_t x93; + fiat_secp256k1_scalar_uint1 x94; + uint64_t x95; + fiat_secp256k1_scalar_uint1 x96; + uint64_t x97; + fiat_secp256k1_scalar_uint1 x98; + uint64_t x99; + uint64_t x100; + uint64_t x101; + uint64_t x102; + uint64_t x103; + uint64_t x104; + uint64_t x105; + uint64_t x106; + uint64_t x107; + uint64_t x108; + fiat_secp256k1_scalar_uint1 x109; + uint64_t x110; + fiat_secp256k1_scalar_uint1 x111; + uint64_t x112; + fiat_secp256k1_scalar_uint1 x113; + uint64_t x114; + uint64_t x115; + fiat_secp256k1_scalar_uint1 x116; + uint64_t x117; + fiat_secp256k1_scalar_uint1 x118; + uint64_t x119; + fiat_secp256k1_scalar_uint1 x120; + uint64_t x121; + fiat_secp256k1_scalar_uint1 x122; + uint64_t x123; + fiat_secp256k1_scalar_uint1 x124; + uint64_t x125; + uint64_t x126; + uint64_t x127; + uint64_t x128; + uint64_t x129; + uint64_t x130; + uint64_t x131; + uint64_t x132; + uint64_t x133; + uint64_t x134; + uint64_t x135; + fiat_secp256k1_scalar_uint1 x136; + uint64_t x137; + fiat_secp256k1_scalar_uint1 x138; + uint64_t x139; + fiat_secp256k1_scalar_uint1 x140; + uint64_t x141; + uint64_t x142; + fiat_secp256k1_scalar_uint1 x143; + uint64_t x144; + fiat_secp256k1_scalar_uint1 x145; + uint64_t x146; + fiat_secp256k1_scalar_uint1 x147; + uint64_t x148; + fiat_secp256k1_scalar_uint1 x149; + uint64_t x150; + fiat_secp256k1_scalar_uint1 x151; + uint64_t x152; + uint64_t x153; + uint64_t x154; + uint64_t x155; + uint64_t x156; + uint64_t x157; + uint64_t x158; + uint64_t x159; + uint64_t x160; + uint64_t x161; + fiat_secp256k1_scalar_uint1 x162; + uint64_t x163; + fiat_secp256k1_scalar_uint1 x164; + uint64_t x165; + fiat_secp256k1_scalar_uint1 x166; + uint64_t x167; + uint64_t x168; + fiat_secp256k1_scalar_uint1 x169; + uint64_t x170; + fiat_secp256k1_scalar_uint1 x171; + uint64_t x172; + fiat_secp256k1_scalar_uint1 x173; + uint64_t x174; + fiat_secp256k1_scalar_uint1 x175; + uint64_t x176; + fiat_secp256k1_scalar_uint1 x177; + uint64_t x178; + uint64_t x179; + uint64_t x180; + uint64_t x181; + uint64_t x182; + uint64_t x183; + uint64_t x184; + uint64_t x185; + uint64_t x186; + uint64_t x187; + uint64_t x188; + fiat_secp256k1_scalar_uint1 x189; + uint64_t x190; + fiat_secp256k1_scalar_uint1 x191; + uint64_t x192; + fiat_secp256k1_scalar_uint1 x193; + uint64_t x194; + uint64_t x195; + fiat_secp256k1_scalar_uint1 x196; + uint64_t x197; + fiat_secp256k1_scalar_uint1 x198; + uint64_t x199; + fiat_secp256k1_scalar_uint1 x200; + uint64_t x201; + fiat_secp256k1_scalar_uint1 x202; + uint64_t x203; + fiat_secp256k1_scalar_uint1 x204; + uint64_t x205; + uint64_t x206; + fiat_secp256k1_scalar_uint1 x207; + uint64_t x208; + fiat_secp256k1_scalar_uint1 x209; + uint64_t x210; + fiat_secp256k1_scalar_uint1 x211; + uint64_t x212; + fiat_secp256k1_scalar_uint1 x213; + uint64_t x214; + fiat_secp256k1_scalar_uint1 x215; + uint64_t x216; + uint64_t x217; + uint64_t x218; + uint64_t x219; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_secp256k1_scalar_mulx_u64(&x5, &x6, x4, (arg1[3])); + fiat_secp256k1_scalar_mulx_u64(&x7, &x8, x4, (arg1[2])); + fiat_secp256k1_scalar_mulx_u64(&x9, &x10, x4, (arg1[1])); + fiat_secp256k1_scalar_mulx_u64(&x11, &x12, x4, (arg1[0])); + fiat_secp256k1_scalar_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_secp256k1_scalar_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_secp256k1_scalar_addcarryx_u64(&x17, &x18, x16, x8, x5); + x19 = (x18 + x6); + fiat_secp256k1_scalar_mulx_u64(&x20, &x21, x11, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x22, &x23, x20, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x24, &x25, x20, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x26, &x27, x20, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x28, &x29, x20, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x30, &x31, 0x0, x29, x26); + fiat_secp256k1_scalar_addcarryx_u64(&x32, &x33, x31, x27, x24); + fiat_secp256k1_scalar_addcarryx_u64(&x34, &x35, x33, x25, x22); + x36 = (x35 + x23); + fiat_secp256k1_scalar_addcarryx_u64(&x37, &x38, 0x0, x11, x28); + fiat_secp256k1_scalar_addcarryx_u64(&x39, &x40, x38, x13, x30); + fiat_secp256k1_scalar_addcarryx_u64(&x41, &x42, x40, x15, x32); + fiat_secp256k1_scalar_addcarryx_u64(&x43, &x44, x42, x17, x34); + fiat_secp256k1_scalar_addcarryx_u64(&x45, &x46, x44, x19, x36); + fiat_secp256k1_scalar_mulx_u64(&x47, &x48, x1, (arg1[3])); + fiat_secp256k1_scalar_mulx_u64(&x49, &x50, x1, (arg1[2])); + fiat_secp256k1_scalar_mulx_u64(&x51, &x52, x1, (arg1[1])); + fiat_secp256k1_scalar_mulx_u64(&x53, &x54, x1, (arg1[0])); + fiat_secp256k1_scalar_addcarryx_u64(&x55, &x56, 0x0, x54, x51); + fiat_secp256k1_scalar_addcarryx_u64(&x57, &x58, x56, x52, x49); + fiat_secp256k1_scalar_addcarryx_u64(&x59, &x60, x58, x50, x47); + x61 = (x60 + x48); + fiat_secp256k1_scalar_addcarryx_u64(&x62, &x63, 0x0, x39, x53); + fiat_secp256k1_scalar_addcarryx_u64(&x64, &x65, x63, x41, x55); + fiat_secp256k1_scalar_addcarryx_u64(&x66, &x67, x65, x43, x57); + fiat_secp256k1_scalar_addcarryx_u64(&x68, &x69, x67, x45, x59); + fiat_secp256k1_scalar_addcarryx_u64(&x70, &x71, x69, x46, x61); + fiat_secp256k1_scalar_mulx_u64(&x72, &x73, x62, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x74, &x75, x72, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x76, &x77, x72, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x78, &x79, x72, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x80, &x81, x72, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x82, &x83, 0x0, x81, x78); + fiat_secp256k1_scalar_addcarryx_u64(&x84, &x85, x83, x79, x76); + fiat_secp256k1_scalar_addcarryx_u64(&x86, &x87, x85, x77, x74); + x88 = (x87 + x75); + fiat_secp256k1_scalar_addcarryx_u64(&x89, &x90, 0x0, x62, x80); + fiat_secp256k1_scalar_addcarryx_u64(&x91, &x92, x90, x64, x82); + fiat_secp256k1_scalar_addcarryx_u64(&x93, &x94, x92, x66, x84); + fiat_secp256k1_scalar_addcarryx_u64(&x95, &x96, x94, x68, x86); + fiat_secp256k1_scalar_addcarryx_u64(&x97, &x98, x96, x70, x88); + x99 = ((uint64_t)x98 + x71); + fiat_secp256k1_scalar_mulx_u64(&x100, &x101, x2, (arg1[3])); + fiat_secp256k1_scalar_mulx_u64(&x102, &x103, x2, (arg1[2])); + fiat_secp256k1_scalar_mulx_u64(&x104, &x105, x2, (arg1[1])); + fiat_secp256k1_scalar_mulx_u64(&x106, &x107, x2, (arg1[0])); + fiat_secp256k1_scalar_addcarryx_u64(&x108, &x109, 0x0, x107, x104); + fiat_secp256k1_scalar_addcarryx_u64(&x110, &x111, x109, x105, x102); + fiat_secp256k1_scalar_addcarryx_u64(&x112, &x113, x111, x103, x100); + x114 = (x113 + x101); + fiat_secp256k1_scalar_addcarryx_u64(&x115, &x116, 0x0, x91, x106); + fiat_secp256k1_scalar_addcarryx_u64(&x117, &x118, x116, x93, x108); + fiat_secp256k1_scalar_addcarryx_u64(&x119, &x120, x118, x95, x110); + fiat_secp256k1_scalar_addcarryx_u64(&x121, &x122, x120, x97, x112); + fiat_secp256k1_scalar_addcarryx_u64(&x123, &x124, x122, x99, x114); + fiat_secp256k1_scalar_mulx_u64(&x125, &x126, x115, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x127, &x128, x125, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x129, &x130, x125, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x131, &x132, x125, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x133, &x134, x125, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x135, &x136, 0x0, x134, x131); + fiat_secp256k1_scalar_addcarryx_u64(&x137, &x138, x136, x132, x129); + fiat_secp256k1_scalar_addcarryx_u64(&x139, &x140, x138, x130, x127); + x141 = (x140 + x128); + fiat_secp256k1_scalar_addcarryx_u64(&x142, &x143, 0x0, x115, x133); + fiat_secp256k1_scalar_addcarryx_u64(&x144, &x145, x143, x117, x135); + fiat_secp256k1_scalar_addcarryx_u64(&x146, &x147, x145, x119, x137); + fiat_secp256k1_scalar_addcarryx_u64(&x148, &x149, x147, x121, x139); + fiat_secp256k1_scalar_addcarryx_u64(&x150, &x151, x149, x123, x141); + x152 = ((uint64_t)x151 + x124); + fiat_secp256k1_scalar_mulx_u64(&x153, &x154, x3, (arg1[3])); + fiat_secp256k1_scalar_mulx_u64(&x155, &x156, x3, (arg1[2])); + fiat_secp256k1_scalar_mulx_u64(&x157, &x158, x3, (arg1[1])); + fiat_secp256k1_scalar_mulx_u64(&x159, &x160, x3, (arg1[0])); + fiat_secp256k1_scalar_addcarryx_u64(&x161, &x162, 0x0, x160, x157); + fiat_secp256k1_scalar_addcarryx_u64(&x163, &x164, x162, x158, x155); + fiat_secp256k1_scalar_addcarryx_u64(&x165, &x166, x164, x156, x153); + x167 = (x166 + x154); + fiat_secp256k1_scalar_addcarryx_u64(&x168, &x169, 0x0, x144, x159); + fiat_secp256k1_scalar_addcarryx_u64(&x170, &x171, x169, x146, x161); + fiat_secp256k1_scalar_addcarryx_u64(&x172, &x173, x171, x148, x163); + fiat_secp256k1_scalar_addcarryx_u64(&x174, &x175, x173, x150, x165); + fiat_secp256k1_scalar_addcarryx_u64(&x176, &x177, x175, x152, x167); + fiat_secp256k1_scalar_mulx_u64(&x178, &x179, x168, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x180, &x181, x178, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x182, &x183, x178, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x184, &x185, x178, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x186, &x187, x178, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x188, &x189, 0x0, x187, x184); + fiat_secp256k1_scalar_addcarryx_u64(&x190, &x191, x189, x185, x182); + fiat_secp256k1_scalar_addcarryx_u64(&x192, &x193, x191, x183, x180); + x194 = (x193 + x181); + fiat_secp256k1_scalar_addcarryx_u64(&x195, &x196, 0x0, x168, x186); + fiat_secp256k1_scalar_addcarryx_u64(&x197, &x198, x196, x170, x188); + fiat_secp256k1_scalar_addcarryx_u64(&x199, &x200, x198, x172, x190); + fiat_secp256k1_scalar_addcarryx_u64(&x201, &x202, x200, x174, x192); + fiat_secp256k1_scalar_addcarryx_u64(&x203, &x204, x202, x176, x194); + x205 = ((uint64_t)x204 + x177); + fiat_secp256k1_scalar_subborrowx_u64(&x206, &x207, 0x0, x197, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_subborrowx_u64(&x208, &x209, x207, x199, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_subborrowx_u64(&x210, &x211, x209, x201, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_subborrowx_u64(&x212, &x213, x211, x203, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_subborrowx_u64(&x214, &x215, x213, x205, 0x0); + fiat_secp256k1_scalar_cmovznz_u64(&x216, x215, x206, x197); + fiat_secp256k1_scalar_cmovznz_u64(&x217, x215, x208, x199); + fiat_secp256k1_scalar_cmovznz_u64(&x218, x215, x210, x201); + fiat_secp256k1_scalar_cmovznz_u64(&x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/* + * The function fiat_secp256k1_scalar_add adds two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_add(fiat_secp256k1_scalar_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_secp256k1_scalar_uint1 x2; + uint64_t x3; + fiat_secp256k1_scalar_uint1 x4; + uint64_t x5; + fiat_secp256k1_scalar_uint1 x6; + uint64_t x7; + fiat_secp256k1_scalar_uint1 x8; + uint64_t x9; + fiat_secp256k1_scalar_uint1 x10; + uint64_t x11; + fiat_secp256k1_scalar_uint1 x12; + uint64_t x13; + fiat_secp256k1_scalar_uint1 x14; + uint64_t x15; + fiat_secp256k1_scalar_uint1 x16; + uint64_t x17; + fiat_secp256k1_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + fiat_secp256k1_scalar_addcarryx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_secp256k1_scalar_addcarryx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_secp256k1_scalar_addcarryx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_secp256k1_scalar_addcarryx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_secp256k1_scalar_subborrowx_u64(&x9, &x10, 0x0, x1, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_subborrowx_u64(&x11, &x12, x10, x3, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_subborrowx_u64(&x13, &x14, x12, x5, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_subborrowx_u64(&x15, &x16, x14, x7, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_subborrowx_u64(&x17, &x18, x16, x8, 0x0); + fiat_secp256k1_scalar_cmovznz_u64(&x19, x18, x9, x1); + fiat_secp256k1_scalar_cmovznz_u64(&x20, x18, x11, x3); + fiat_secp256k1_scalar_cmovznz_u64(&x21, x18, x13, x5); + fiat_secp256k1_scalar_cmovznz_u64(&x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/* + * The function fiat_secp256k1_scalar_sub subtracts two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_sub(fiat_secp256k1_scalar_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_secp256k1_scalar_uint1 x2; + uint64_t x3; + fiat_secp256k1_scalar_uint1 x4; + uint64_t x5; + fiat_secp256k1_scalar_uint1 x6; + uint64_t x7; + fiat_secp256k1_scalar_uint1 x8; + uint64_t x9; + uint64_t x10; + fiat_secp256k1_scalar_uint1 x11; + uint64_t x12; + fiat_secp256k1_scalar_uint1 x13; + uint64_t x14; + fiat_secp256k1_scalar_uint1 x15; + uint64_t x16; + fiat_secp256k1_scalar_uint1 x17; + fiat_secp256k1_scalar_subborrowx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_secp256k1_scalar_subborrowx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_secp256k1_scalar_subborrowx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_secp256k1_scalar_subborrowx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_secp256k1_scalar_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_addcarryx_u64(&x10, &x11, 0x0, x1, (x9 & UINT64_C(0xbfd25e8cd0364141))); + fiat_secp256k1_scalar_addcarryx_u64(&x12, &x13, x11, x3, (x9 & UINT64_C(0xbaaedce6af48a03b))); + fiat_secp256k1_scalar_addcarryx_u64(&x14, &x15, x13, x5, (x9 & UINT64_C(0xfffffffffffffffe))); + fiat_secp256k1_scalar_addcarryx_u64(&x16, &x17, x15, x7, x9); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/* + * The function fiat_secp256k1_scalar_opp negates a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_opp(fiat_secp256k1_scalar_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + fiat_secp256k1_scalar_uint1 x2; + uint64_t x3; + fiat_secp256k1_scalar_uint1 x4; + uint64_t x5; + fiat_secp256k1_scalar_uint1 x6; + uint64_t x7; + fiat_secp256k1_scalar_uint1 x8; + uint64_t x9; + uint64_t x10; + fiat_secp256k1_scalar_uint1 x11; + uint64_t x12; + fiat_secp256k1_scalar_uint1 x13; + uint64_t x14; + fiat_secp256k1_scalar_uint1 x15; + uint64_t x16; + fiat_secp256k1_scalar_uint1 x17; + fiat_secp256k1_scalar_subborrowx_u64(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_secp256k1_scalar_subborrowx_u64(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_secp256k1_scalar_subborrowx_u64(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_secp256k1_scalar_subborrowx_u64(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_secp256k1_scalar_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_addcarryx_u64(&x10, &x11, 0x0, x1, (x9 & UINT64_C(0xbfd25e8cd0364141))); + fiat_secp256k1_scalar_addcarryx_u64(&x12, &x13, x11, x3, (x9 & UINT64_C(0xbaaedce6af48a03b))); + fiat_secp256k1_scalar_addcarryx_u64(&x14, &x15, x13, x5, (x9 & UINT64_C(0xfffffffffffffffe))); + fiat_secp256k1_scalar_addcarryx_u64(&x16, &x17, x15, x7, x9); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/* + * The function fiat_secp256k1_scalar_from_montgomery translates a field element out of the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_from_montgomery(fiat_secp256k1_scalar_non_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + fiat_secp256k1_scalar_uint1 x13; + uint64_t x14; + fiat_secp256k1_scalar_uint1 x15; + uint64_t x16; + fiat_secp256k1_scalar_uint1 x17; + uint64_t x18; + fiat_secp256k1_scalar_uint1 x19; + uint64_t x20; + fiat_secp256k1_scalar_uint1 x21; + uint64_t x22; + fiat_secp256k1_scalar_uint1 x23; + uint64_t x24; + fiat_secp256k1_scalar_uint1 x25; + uint64_t x26; + fiat_secp256k1_scalar_uint1 x27; + uint64_t x28; + fiat_secp256k1_scalar_uint1 x29; + uint64_t x30; + fiat_secp256k1_scalar_uint1 x31; + uint64_t x32; + fiat_secp256k1_scalar_uint1 x33; + uint64_t x34; + fiat_secp256k1_scalar_uint1 x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + fiat_secp256k1_scalar_uint1 x47; + uint64_t x48; + fiat_secp256k1_scalar_uint1 x49; + uint64_t x50; + fiat_secp256k1_scalar_uint1 x51; + uint64_t x52; + fiat_secp256k1_scalar_uint1 x53; + uint64_t x54; + fiat_secp256k1_scalar_uint1 x55; + uint64_t x56; + fiat_secp256k1_scalar_uint1 x57; + uint64_t x58; + fiat_secp256k1_scalar_uint1 x59; + uint64_t x60; + fiat_secp256k1_scalar_uint1 x61; + uint64_t x62; + fiat_secp256k1_scalar_uint1 x63; + uint64_t x64; + fiat_secp256k1_scalar_uint1 x65; + uint64_t x66; + fiat_secp256k1_scalar_uint1 x67; + uint64_t x68; + fiat_secp256k1_scalar_uint1 x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + fiat_secp256k1_scalar_uint1 x81; + uint64_t x82; + fiat_secp256k1_scalar_uint1 x83; + uint64_t x84; + fiat_secp256k1_scalar_uint1 x85; + uint64_t x86; + fiat_secp256k1_scalar_uint1 x87; + uint64_t x88; + fiat_secp256k1_scalar_uint1 x89; + uint64_t x90; + fiat_secp256k1_scalar_uint1 x91; + uint64_t x92; + fiat_secp256k1_scalar_uint1 x93; + uint64_t x94; + fiat_secp256k1_scalar_uint1 x95; + uint64_t x96; + fiat_secp256k1_scalar_uint1 x97; + uint64_t x98; + fiat_secp256k1_scalar_uint1 x99; + uint64_t x100; + fiat_secp256k1_scalar_uint1 x101; + uint64_t x102; + fiat_secp256k1_scalar_uint1 x103; + uint64_t x104; + uint64_t x105; + uint64_t x106; + uint64_t x107; + uint64_t x108; + uint64_t x109; + uint64_t x110; + uint64_t x111; + uint64_t x112; + uint64_t x113; + uint64_t x114; + fiat_secp256k1_scalar_uint1 x115; + uint64_t x116; + fiat_secp256k1_scalar_uint1 x117; + uint64_t x118; + fiat_secp256k1_scalar_uint1 x119; + uint64_t x120; + fiat_secp256k1_scalar_uint1 x121; + uint64_t x122; + fiat_secp256k1_scalar_uint1 x123; + uint64_t x124; + fiat_secp256k1_scalar_uint1 x125; + uint64_t x126; + fiat_secp256k1_scalar_uint1 x127; + uint64_t x128; + fiat_secp256k1_scalar_uint1 x129; + uint64_t x130; + fiat_secp256k1_scalar_uint1 x131; + uint64_t x132; + fiat_secp256k1_scalar_uint1 x133; + uint64_t x134; + fiat_secp256k1_scalar_uint1 x135; + uint64_t x136; + fiat_secp256k1_scalar_uint1 x137; + uint64_t x138; + fiat_secp256k1_scalar_uint1 x139; + uint64_t x140; + uint64_t x141; + uint64_t x142; + uint64_t x143; + x1 = (arg1[0]); + fiat_secp256k1_scalar_mulx_u64(&x2, &x3, x1, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x4, &x5, x2, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x6, &x7, x2, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x8, &x9, x2, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x10, &x11, x2, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x12, &x13, 0x0, x11, x8); + fiat_secp256k1_scalar_addcarryx_u64(&x14, &x15, x13, x9, x6); + fiat_secp256k1_scalar_addcarryx_u64(&x16, &x17, x15, x7, x4); + fiat_secp256k1_scalar_addcarryx_u64(&x18, &x19, 0x0, x1, x10); + fiat_secp256k1_scalar_addcarryx_u64(&x20, &x21, x19, 0x0, x12); + fiat_secp256k1_scalar_addcarryx_u64(&x22, &x23, x21, 0x0, x14); + fiat_secp256k1_scalar_addcarryx_u64(&x24, &x25, x23, 0x0, x16); + fiat_secp256k1_scalar_addcarryx_u64(&x26, &x27, x25, 0x0, (x17 + x5)); + fiat_secp256k1_scalar_addcarryx_u64(&x28, &x29, 0x0, x20, (arg1[1])); + fiat_secp256k1_scalar_addcarryx_u64(&x30, &x31, x29, x22, 0x0); + fiat_secp256k1_scalar_addcarryx_u64(&x32, &x33, x31, x24, 0x0); + fiat_secp256k1_scalar_addcarryx_u64(&x34, &x35, x33, x26, 0x0); + fiat_secp256k1_scalar_mulx_u64(&x36, &x37, x28, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x38, &x39, x36, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x40, &x41, x36, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x42, &x43, x36, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x44, &x45, x36, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x46, &x47, 0x0, x45, x42); + fiat_secp256k1_scalar_addcarryx_u64(&x48, &x49, x47, x43, x40); + fiat_secp256k1_scalar_addcarryx_u64(&x50, &x51, x49, x41, x38); + fiat_secp256k1_scalar_addcarryx_u64(&x52, &x53, 0x0, x28, x44); + fiat_secp256k1_scalar_addcarryx_u64(&x54, &x55, x53, x30, x46); + fiat_secp256k1_scalar_addcarryx_u64(&x56, &x57, x55, x32, x48); + fiat_secp256k1_scalar_addcarryx_u64(&x58, &x59, x57, x34, x50); + fiat_secp256k1_scalar_addcarryx_u64(&x60, &x61, x59, ((uint64_t)x35 + x27), (x51 + x39)); + fiat_secp256k1_scalar_addcarryx_u64(&x62, &x63, 0x0, x54, (arg1[2])); + fiat_secp256k1_scalar_addcarryx_u64(&x64, &x65, x63, x56, 0x0); + fiat_secp256k1_scalar_addcarryx_u64(&x66, &x67, x65, x58, 0x0); + fiat_secp256k1_scalar_addcarryx_u64(&x68, &x69, x67, x60, 0x0); + fiat_secp256k1_scalar_mulx_u64(&x70, &x71, x62, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x72, &x73, x70, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x74, &x75, x70, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x76, &x77, x70, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x78, &x79, x70, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x80, &x81, 0x0, x79, x76); + fiat_secp256k1_scalar_addcarryx_u64(&x82, &x83, x81, x77, x74); + fiat_secp256k1_scalar_addcarryx_u64(&x84, &x85, x83, x75, x72); + fiat_secp256k1_scalar_addcarryx_u64(&x86, &x87, 0x0, x62, x78); + fiat_secp256k1_scalar_addcarryx_u64(&x88, &x89, x87, x64, x80); + fiat_secp256k1_scalar_addcarryx_u64(&x90, &x91, x89, x66, x82); + fiat_secp256k1_scalar_addcarryx_u64(&x92, &x93, x91, x68, x84); + fiat_secp256k1_scalar_addcarryx_u64(&x94, &x95, x93, ((uint64_t)x69 + x61), (x85 + x73)); + fiat_secp256k1_scalar_addcarryx_u64(&x96, &x97, 0x0, x88, (arg1[3])); + fiat_secp256k1_scalar_addcarryx_u64(&x98, &x99, x97, x90, 0x0); + fiat_secp256k1_scalar_addcarryx_u64(&x100, &x101, x99, x92, 0x0); + fiat_secp256k1_scalar_addcarryx_u64(&x102, &x103, x101, x94, 0x0); + fiat_secp256k1_scalar_mulx_u64(&x104, &x105, x96, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x106, &x107, x104, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x108, &x109, x104, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x110, &x111, x104, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x112, &x113, x104, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x114, &x115, 0x0, x113, x110); + fiat_secp256k1_scalar_addcarryx_u64(&x116, &x117, x115, x111, x108); + fiat_secp256k1_scalar_addcarryx_u64(&x118, &x119, x117, x109, x106); + fiat_secp256k1_scalar_addcarryx_u64(&x120, &x121, 0x0, x96, x112); + fiat_secp256k1_scalar_addcarryx_u64(&x122, &x123, x121, x98, x114); + fiat_secp256k1_scalar_addcarryx_u64(&x124, &x125, x123, x100, x116); + fiat_secp256k1_scalar_addcarryx_u64(&x126, &x127, x125, x102, x118); + fiat_secp256k1_scalar_addcarryx_u64(&x128, &x129, x127, ((uint64_t)x103 + x95), (x119 + x107)); + fiat_secp256k1_scalar_subborrowx_u64(&x130, &x131, 0x0, x122, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_subborrowx_u64(&x132, &x133, x131, x124, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_subborrowx_u64(&x134, &x135, x133, x126, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_subborrowx_u64(&x136, &x137, x135, x128, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_subborrowx_u64(&x138, &x139, x137, x129, 0x0); + fiat_secp256k1_scalar_cmovznz_u64(&x140, x139, x130, x122); + fiat_secp256k1_scalar_cmovznz_u64(&x141, x139, x132, x124); + fiat_secp256k1_scalar_cmovznz_u64(&x142, x139, x134, x126); + fiat_secp256k1_scalar_cmovznz_u64(&x143, x139, x136, x128); + out1[0] = x140; + out1[1] = x141; + out1[2] = x142; + out1[3] = x143; +} + +/* + * The function fiat_secp256k1_scalar_to_montgomery translates a field element into the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = eval arg1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_to_montgomery(fiat_secp256k1_scalar_montgomery_domain_field_element out1, const fiat_secp256k1_scalar_non_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_secp256k1_scalar_uint1 x14; + uint64_t x15; + fiat_secp256k1_scalar_uint1 x16; + uint64_t x17; + fiat_secp256k1_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + fiat_secp256k1_scalar_uint1 x30; + uint64_t x31; + fiat_secp256k1_scalar_uint1 x32; + uint64_t x33; + fiat_secp256k1_scalar_uint1 x34; + uint64_t x35; + fiat_secp256k1_scalar_uint1 x36; + uint64_t x37; + fiat_secp256k1_scalar_uint1 x38; + uint64_t x39; + fiat_secp256k1_scalar_uint1 x40; + uint64_t x41; + fiat_secp256k1_scalar_uint1 x42; + uint64_t x43; + fiat_secp256k1_scalar_uint1 x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + fiat_secp256k1_scalar_uint1 x54; + uint64_t x55; + fiat_secp256k1_scalar_uint1 x56; + uint64_t x57; + fiat_secp256k1_scalar_uint1 x58; + uint64_t x59; + fiat_secp256k1_scalar_uint1 x60; + uint64_t x61; + fiat_secp256k1_scalar_uint1 x62; + uint64_t x63; + fiat_secp256k1_scalar_uint1 x64; + uint64_t x65; + fiat_secp256k1_scalar_uint1 x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + uint64_t x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + fiat_secp256k1_scalar_uint1 x78; + uint64_t x79; + fiat_secp256k1_scalar_uint1 x80; + uint64_t x81; + fiat_secp256k1_scalar_uint1 x82; + uint64_t x83; + fiat_secp256k1_scalar_uint1 x84; + uint64_t x85; + fiat_secp256k1_scalar_uint1 x86; + uint64_t x87; + fiat_secp256k1_scalar_uint1 x88; + uint64_t x89; + fiat_secp256k1_scalar_uint1 x90; + uint64_t x91; + fiat_secp256k1_scalar_uint1 x92; + uint64_t x93; + uint64_t x94; + uint64_t x95; + uint64_t x96; + uint64_t x97; + uint64_t x98; + uint64_t x99; + uint64_t x100; + uint64_t x101; + fiat_secp256k1_scalar_uint1 x102; + uint64_t x103; + fiat_secp256k1_scalar_uint1 x104; + uint64_t x105; + fiat_secp256k1_scalar_uint1 x106; + uint64_t x107; + fiat_secp256k1_scalar_uint1 x108; + uint64_t x109; + fiat_secp256k1_scalar_uint1 x110; + uint64_t x111; + fiat_secp256k1_scalar_uint1 x112; + uint64_t x113; + fiat_secp256k1_scalar_uint1 x114; + uint64_t x115; + uint64_t x116; + uint64_t x117; + uint64_t x118; + uint64_t x119; + uint64_t x120; + uint64_t x121; + uint64_t x122; + uint64_t x123; + uint64_t x124; + uint64_t x125; + fiat_secp256k1_scalar_uint1 x126; + uint64_t x127; + fiat_secp256k1_scalar_uint1 x128; + uint64_t x129; + fiat_secp256k1_scalar_uint1 x130; + uint64_t x131; + fiat_secp256k1_scalar_uint1 x132; + uint64_t x133; + fiat_secp256k1_scalar_uint1 x134; + uint64_t x135; + fiat_secp256k1_scalar_uint1 x136; + uint64_t x137; + fiat_secp256k1_scalar_uint1 x138; + uint64_t x139; + fiat_secp256k1_scalar_uint1 x140; + uint64_t x141; + uint64_t x142; + uint64_t x143; + uint64_t x144; + uint64_t x145; + uint64_t x146; + uint64_t x147; + uint64_t x148; + uint64_t x149; + fiat_secp256k1_scalar_uint1 x150; + uint64_t x151; + fiat_secp256k1_scalar_uint1 x152; + uint64_t x153; + fiat_secp256k1_scalar_uint1 x154; + uint64_t x155; + fiat_secp256k1_scalar_uint1 x156; + uint64_t x157; + fiat_secp256k1_scalar_uint1 x158; + uint64_t x159; + fiat_secp256k1_scalar_uint1 x160; + uint64_t x161; + fiat_secp256k1_scalar_uint1 x162; + uint64_t x163; + uint64_t x164; + uint64_t x165; + uint64_t x166; + uint64_t x167; + uint64_t x168; + uint64_t x169; + uint64_t x170; + uint64_t x171; + uint64_t x172; + uint64_t x173; + fiat_secp256k1_scalar_uint1 x174; + uint64_t x175; + fiat_secp256k1_scalar_uint1 x176; + uint64_t x177; + fiat_secp256k1_scalar_uint1 x178; + uint64_t x179; + fiat_secp256k1_scalar_uint1 x180; + uint64_t x181; + fiat_secp256k1_scalar_uint1 x182; + uint64_t x183; + fiat_secp256k1_scalar_uint1 x184; + uint64_t x185; + fiat_secp256k1_scalar_uint1 x186; + uint64_t x187; + fiat_secp256k1_scalar_uint1 x188; + uint64_t x189; + fiat_secp256k1_scalar_uint1 x190; + uint64_t x191; + fiat_secp256k1_scalar_uint1 x192; + uint64_t x193; + fiat_secp256k1_scalar_uint1 x194; + uint64_t x195; + fiat_secp256k1_scalar_uint1 x196; + uint64_t x197; + fiat_secp256k1_scalar_uint1 x198; + uint64_t x199; + uint64_t x200; + uint64_t x201; + uint64_t x202; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_secp256k1_scalar_mulx_u64(&x5, &x6, x4, UINT64_C(0x9d671cd581c69bc5)); + fiat_secp256k1_scalar_mulx_u64(&x7, &x8, x4, UINT64_C(0xe697f5e45bcd07c6)); + fiat_secp256k1_scalar_mulx_u64(&x9, &x10, x4, UINT64_C(0x741496c20e7cf878)); + fiat_secp256k1_scalar_mulx_u64(&x11, &x12, x4, UINT64_C(0x896cf21467d7d140)); + fiat_secp256k1_scalar_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_secp256k1_scalar_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_secp256k1_scalar_addcarryx_u64(&x17, &x18, x16, x8, x5); + fiat_secp256k1_scalar_mulx_u64(&x19, &x20, x11, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x21, &x22, x19, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x23, &x24, x19, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x25, &x26, x19, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x27, &x28, x19, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x29, &x30, 0x0, x28, x25); + fiat_secp256k1_scalar_addcarryx_u64(&x31, &x32, x30, x26, x23); + fiat_secp256k1_scalar_addcarryx_u64(&x33, &x34, x32, x24, x21); + fiat_secp256k1_scalar_addcarryx_u64(&x35, &x36, 0x0, x11, x27); + fiat_secp256k1_scalar_addcarryx_u64(&x37, &x38, x36, x13, x29); + fiat_secp256k1_scalar_addcarryx_u64(&x39, &x40, x38, x15, x31); + fiat_secp256k1_scalar_addcarryx_u64(&x41, &x42, x40, x17, x33); + fiat_secp256k1_scalar_addcarryx_u64(&x43, &x44, x42, (x18 + x6), (x34 + x22)); + fiat_secp256k1_scalar_mulx_u64(&x45, &x46, x1, UINT64_C(0x9d671cd581c69bc5)); + fiat_secp256k1_scalar_mulx_u64(&x47, &x48, x1, UINT64_C(0xe697f5e45bcd07c6)); + fiat_secp256k1_scalar_mulx_u64(&x49, &x50, x1, UINT64_C(0x741496c20e7cf878)); + fiat_secp256k1_scalar_mulx_u64(&x51, &x52, x1, UINT64_C(0x896cf21467d7d140)); + fiat_secp256k1_scalar_addcarryx_u64(&x53, &x54, 0x0, x52, x49); + fiat_secp256k1_scalar_addcarryx_u64(&x55, &x56, x54, x50, x47); + fiat_secp256k1_scalar_addcarryx_u64(&x57, &x58, x56, x48, x45); + fiat_secp256k1_scalar_addcarryx_u64(&x59, &x60, 0x0, x37, x51); + fiat_secp256k1_scalar_addcarryx_u64(&x61, &x62, x60, x39, x53); + fiat_secp256k1_scalar_addcarryx_u64(&x63, &x64, x62, x41, x55); + fiat_secp256k1_scalar_addcarryx_u64(&x65, &x66, x64, x43, x57); + fiat_secp256k1_scalar_mulx_u64(&x67, &x68, x59, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x69, &x70, x67, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x71, &x72, x67, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x73, &x74, x67, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x75, &x76, x67, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x77, &x78, 0x0, x76, x73); + fiat_secp256k1_scalar_addcarryx_u64(&x79, &x80, x78, x74, x71); + fiat_secp256k1_scalar_addcarryx_u64(&x81, &x82, x80, x72, x69); + fiat_secp256k1_scalar_addcarryx_u64(&x83, &x84, 0x0, x59, x75); + fiat_secp256k1_scalar_addcarryx_u64(&x85, &x86, x84, x61, x77); + fiat_secp256k1_scalar_addcarryx_u64(&x87, &x88, x86, x63, x79); + fiat_secp256k1_scalar_addcarryx_u64(&x89, &x90, x88, x65, x81); + fiat_secp256k1_scalar_addcarryx_u64(&x91, &x92, x90, (((uint64_t)x66 + x44) + (x58 + x46)), (x82 + x70)); + fiat_secp256k1_scalar_mulx_u64(&x93, &x94, x2, UINT64_C(0x9d671cd581c69bc5)); + fiat_secp256k1_scalar_mulx_u64(&x95, &x96, x2, UINT64_C(0xe697f5e45bcd07c6)); + fiat_secp256k1_scalar_mulx_u64(&x97, &x98, x2, UINT64_C(0x741496c20e7cf878)); + fiat_secp256k1_scalar_mulx_u64(&x99, &x100, x2, UINT64_C(0x896cf21467d7d140)); + fiat_secp256k1_scalar_addcarryx_u64(&x101, &x102, 0x0, x100, x97); + fiat_secp256k1_scalar_addcarryx_u64(&x103, &x104, x102, x98, x95); + fiat_secp256k1_scalar_addcarryx_u64(&x105, &x106, x104, x96, x93); + fiat_secp256k1_scalar_addcarryx_u64(&x107, &x108, 0x0, x85, x99); + fiat_secp256k1_scalar_addcarryx_u64(&x109, &x110, x108, x87, x101); + fiat_secp256k1_scalar_addcarryx_u64(&x111, &x112, x110, x89, x103); + fiat_secp256k1_scalar_addcarryx_u64(&x113, &x114, x112, x91, x105); + fiat_secp256k1_scalar_mulx_u64(&x115, &x116, x107, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x117, &x118, x115, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x119, &x120, x115, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x121, &x122, x115, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x123, &x124, x115, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x125, &x126, 0x0, x124, x121); + fiat_secp256k1_scalar_addcarryx_u64(&x127, &x128, x126, x122, x119); + fiat_secp256k1_scalar_addcarryx_u64(&x129, &x130, x128, x120, x117); + fiat_secp256k1_scalar_addcarryx_u64(&x131, &x132, 0x0, x107, x123); + fiat_secp256k1_scalar_addcarryx_u64(&x133, &x134, x132, x109, x125); + fiat_secp256k1_scalar_addcarryx_u64(&x135, &x136, x134, x111, x127); + fiat_secp256k1_scalar_addcarryx_u64(&x137, &x138, x136, x113, x129); + fiat_secp256k1_scalar_addcarryx_u64(&x139, &x140, x138, (((uint64_t)x114 + x92) + (x106 + x94)), (x130 + x118)); + fiat_secp256k1_scalar_mulx_u64(&x141, &x142, x3, UINT64_C(0x9d671cd581c69bc5)); + fiat_secp256k1_scalar_mulx_u64(&x143, &x144, x3, UINT64_C(0xe697f5e45bcd07c6)); + fiat_secp256k1_scalar_mulx_u64(&x145, &x146, x3, UINT64_C(0x741496c20e7cf878)); + fiat_secp256k1_scalar_mulx_u64(&x147, &x148, x3, UINT64_C(0x896cf21467d7d140)); + fiat_secp256k1_scalar_addcarryx_u64(&x149, &x150, 0x0, x148, x145); + fiat_secp256k1_scalar_addcarryx_u64(&x151, &x152, x150, x146, x143); + fiat_secp256k1_scalar_addcarryx_u64(&x153, &x154, x152, x144, x141); + fiat_secp256k1_scalar_addcarryx_u64(&x155, &x156, 0x0, x133, x147); + fiat_secp256k1_scalar_addcarryx_u64(&x157, &x158, x156, x135, x149); + fiat_secp256k1_scalar_addcarryx_u64(&x159, &x160, x158, x137, x151); + fiat_secp256k1_scalar_addcarryx_u64(&x161, &x162, x160, x139, x153); + fiat_secp256k1_scalar_mulx_u64(&x163, &x164, x155, UINT64_C(0x4b0dff665588b13f)); + fiat_secp256k1_scalar_mulx_u64(&x165, &x166, x163, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_mulx_u64(&x167, &x168, x163, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_mulx_u64(&x169, &x170, x163, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_mulx_u64(&x171, &x172, x163, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_addcarryx_u64(&x173, &x174, 0x0, x172, x169); + fiat_secp256k1_scalar_addcarryx_u64(&x175, &x176, x174, x170, x167); + fiat_secp256k1_scalar_addcarryx_u64(&x177, &x178, x176, x168, x165); + fiat_secp256k1_scalar_addcarryx_u64(&x179, &x180, 0x0, x155, x171); + fiat_secp256k1_scalar_addcarryx_u64(&x181, &x182, x180, x157, x173); + fiat_secp256k1_scalar_addcarryx_u64(&x183, &x184, x182, x159, x175); + fiat_secp256k1_scalar_addcarryx_u64(&x185, &x186, x184, x161, x177); + fiat_secp256k1_scalar_addcarryx_u64(&x187, &x188, x186, (((uint64_t)x162 + x140) + (x154 + x142)), (x178 + x166)); + fiat_secp256k1_scalar_subborrowx_u64(&x189, &x190, 0x0, x181, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_subborrowx_u64(&x191, &x192, x190, x183, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_subborrowx_u64(&x193, &x194, x192, x185, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_subborrowx_u64(&x195, &x196, x194, x187, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_subborrowx_u64(&x197, &x198, x196, x188, 0x0); + fiat_secp256k1_scalar_cmovznz_u64(&x199, x198, x189, x181); + fiat_secp256k1_scalar_cmovznz_u64(&x200, x198, x191, x183); + fiat_secp256k1_scalar_cmovznz_u64(&x201, x198, x193, x185); + fiat_secp256k1_scalar_cmovznz_u64(&x202, x198, x195, x187); + out1[0] = x199; + out1[1] = x200; + out1[2] = x201; + out1[3] = x202; +} + +/* + * The function fiat_secp256k1_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_nonzero(uint64_t* out1, const uint64_t arg1[4]) { + uint64_t x1; + x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3])))); + *out1 = x1; +} + +/* + * The function fiat_secp256k1_scalar_selectznz is a multi-limb conditional select. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_selectznz(uint64_t out1[4], fiat_secp256k1_scalar_uint1 arg1, const uint64_t arg2[4], const uint64_t arg3[4]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + fiat_secp256k1_scalar_cmovznz_u64(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_secp256k1_scalar_cmovznz_u64(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_secp256k1_scalar_cmovznz_u64(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_secp256k1_scalar_cmovznz_u64(&x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/* + * The function fiat_secp256k1_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_to_bytes(uint8_t out1[32], const uint64_t arg1[4]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint8_t x5; + uint64_t x6; + uint8_t x7; + uint64_t x8; + uint8_t x9; + uint64_t x10; + uint8_t x11; + uint64_t x12; + uint8_t x13; + uint64_t x14; + uint8_t x15; + uint64_t x16; + uint8_t x17; + uint8_t x18; + uint8_t x19; + uint64_t x20; + uint8_t x21; + uint64_t x22; + uint8_t x23; + uint64_t x24; + uint8_t x25; + uint64_t x26; + uint8_t x27; + uint64_t x28; + uint8_t x29; + uint64_t x30; + uint8_t x31; + uint8_t x32; + uint8_t x33; + uint64_t x34; + uint8_t x35; + uint64_t x36; + uint8_t x37; + uint64_t x38; + uint8_t x39; + uint64_t x40; + uint8_t x41; + uint64_t x42; + uint8_t x43; + uint64_t x44; + uint8_t x45; + uint8_t x46; + uint8_t x47; + uint64_t x48; + uint8_t x49; + uint64_t x50; + uint8_t x51; + uint64_t x52; + uint8_t x53; + uint64_t x54; + uint8_t x55; + uint64_t x56; + uint8_t x57; + uint64_t x58; + uint8_t x59; + uint8_t x60; + x1 = (arg1[3]); + x2 = (arg1[2]); + x3 = (arg1[1]); + x4 = (arg1[0]); + x5 = (uint8_t)(x4 & UINT8_C(0xff)); + x6 = (x4 >> 8); + x7 = (uint8_t)(x6 & UINT8_C(0xff)); + x8 = (x6 >> 8); + x9 = (uint8_t)(x8 & UINT8_C(0xff)); + x10 = (x8 >> 8); + x11 = (uint8_t)(x10 & UINT8_C(0xff)); + x12 = (x10 >> 8); + x13 = (uint8_t)(x12 & UINT8_C(0xff)); + x14 = (x12 >> 8); + x15 = (uint8_t)(x14 & UINT8_C(0xff)); + x16 = (x14 >> 8); + x17 = (uint8_t)(x16 & UINT8_C(0xff)); + x18 = (uint8_t)(x16 >> 8); + x19 = (uint8_t)(x3 & UINT8_C(0xff)); + x20 = (x3 >> 8); + x21 = (uint8_t)(x20 & UINT8_C(0xff)); + x22 = (x20 >> 8); + x23 = (uint8_t)(x22 & UINT8_C(0xff)); + x24 = (x22 >> 8); + x25 = (uint8_t)(x24 & UINT8_C(0xff)); + x26 = (x24 >> 8); + x27 = (uint8_t)(x26 & UINT8_C(0xff)); + x28 = (x26 >> 8); + x29 = (uint8_t)(x28 & UINT8_C(0xff)); + x30 = (x28 >> 8); + x31 = (uint8_t)(x30 & UINT8_C(0xff)); + x32 = (uint8_t)(x30 >> 8); + x33 = (uint8_t)(x2 & UINT8_C(0xff)); + x34 = (x2 >> 8); + x35 = (uint8_t)(x34 & UINT8_C(0xff)); + x36 = (x34 >> 8); + x37 = (uint8_t)(x36 & UINT8_C(0xff)); + x38 = (x36 >> 8); + x39 = (uint8_t)(x38 & UINT8_C(0xff)); + x40 = (x38 >> 8); + x41 = (uint8_t)(x40 & UINT8_C(0xff)); + x42 = (x40 >> 8); + x43 = (uint8_t)(x42 & UINT8_C(0xff)); + x44 = (x42 >> 8); + x45 = (uint8_t)(x44 & UINT8_C(0xff)); + x46 = (uint8_t)(x44 >> 8); + x47 = (uint8_t)(x1 & UINT8_C(0xff)); + x48 = (x1 >> 8); + x49 = (uint8_t)(x48 & UINT8_C(0xff)); + x50 = (x48 >> 8); + x51 = (uint8_t)(x50 & UINT8_C(0xff)); + x52 = (x50 >> 8); + x53 = (uint8_t)(x52 & UINT8_C(0xff)); + x54 = (x52 >> 8); + x55 = (uint8_t)(x54 & UINT8_C(0xff)); + x56 = (x54 >> 8); + x57 = (uint8_t)(x56 & UINT8_C(0xff)); + x58 = (x56 >> 8); + x59 = (uint8_t)(x58 & UINT8_C(0xff)); + x60 = (uint8_t)(x58 >> 8); + out1[0] = x5; + out1[1] = x7; + out1[2] = x9; + out1[3] = x11; + out1[4] = x13; + out1[5] = x15; + out1[6] = x17; + out1[7] = x18; + out1[8] = x19; + out1[9] = x21; + out1[10] = x23; + out1[11] = x25; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x39; + out1[20] = x41; + out1[21] = x43; + out1[22] = x45; + out1[23] = x46; + out1[24] = x47; + out1[25] = x49; + out1[26] = x51; + out1[27] = x53; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; +} + +/* + * The function fiat_secp256k1_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. + * + * Preconditions: + * 0 ≤ bytes_eval arg1 < m + * Postconditions: + * eval out1 mod m = bytes_eval arg1 mod m + * 0 ≤ eval out1 < m + * + * Input Bounds: + * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_from_bytes(uint64_t out1[4], const uint8_t arg1[32]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint8_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint8_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint8_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint8_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + uint64_t x54; + uint64_t x55; + uint64_t x56; + uint64_t x57; + uint64_t x58; + uint64_t x59; + uint64_t x60; + x1 = ((uint64_t)(arg1[31]) << 56); + x2 = ((uint64_t)(arg1[30]) << 48); + x3 = ((uint64_t)(arg1[29]) << 40); + x4 = ((uint64_t)(arg1[28]) << 32); + x5 = ((uint64_t)(arg1[27]) << 24); + x6 = ((uint64_t)(arg1[26]) << 16); + x7 = ((uint64_t)(arg1[25]) << 8); + x8 = (arg1[24]); + x9 = ((uint64_t)(arg1[23]) << 56); + x10 = ((uint64_t)(arg1[22]) << 48); + x11 = ((uint64_t)(arg1[21]) << 40); + x12 = ((uint64_t)(arg1[20]) << 32); + x13 = ((uint64_t)(arg1[19]) << 24); + x14 = ((uint64_t)(arg1[18]) << 16); + x15 = ((uint64_t)(arg1[17]) << 8); + x16 = (arg1[16]); + x17 = ((uint64_t)(arg1[15]) << 56); + x18 = ((uint64_t)(arg1[14]) << 48); + x19 = ((uint64_t)(arg1[13]) << 40); + x20 = ((uint64_t)(arg1[12]) << 32); + x21 = ((uint64_t)(arg1[11]) << 24); + x22 = ((uint64_t)(arg1[10]) << 16); + x23 = ((uint64_t)(arg1[9]) << 8); + x24 = (arg1[8]); + x25 = ((uint64_t)(arg1[7]) << 56); + x26 = ((uint64_t)(arg1[6]) << 48); + x27 = ((uint64_t)(arg1[5]) << 40); + x28 = ((uint64_t)(arg1[4]) << 32); + x29 = ((uint64_t)(arg1[3]) << 24); + x30 = ((uint64_t)(arg1[2]) << 16); + x31 = ((uint64_t)(arg1[1]) << 8); + x32 = (arg1[0]); + x33 = (x31 + (uint64_t)x32); + x34 = (x30 + x33); + x35 = (x29 + x34); + x36 = (x28 + x35); + x37 = (x27 + x36); + x38 = (x26 + x37); + x39 = (x25 + x38); + x40 = (x23 + (uint64_t)x24); + x41 = (x22 + x40); + x42 = (x21 + x41); + x43 = (x20 + x42); + x44 = (x19 + x43); + x45 = (x18 + x44); + x46 = (x17 + x45); + x47 = (x15 + (uint64_t)x16); + x48 = (x14 + x47); + x49 = (x13 + x48); + x50 = (x12 + x49); + x51 = (x11 + x50); + x52 = (x10 + x51); + x53 = (x9 + x52); + x54 = (x7 + (uint64_t)x8); + x55 = (x6 + x54); + x56 = (x5 + x55); + x57 = (x4 + x56); + x58 = (x3 + x57); + x59 = (x2 + x58); + x60 = (x1 + x59); + out1[0] = x39; + out1[1] = x46; + out1[2] = x53; + out1[3] = x60; +} + +/* + * The function fiat_secp256k1_scalar_set_one returns the field element one in the Montgomery domain. + * + * Postconditions: + * eval (from_montgomery out1) mod m = 1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_set_one(fiat_secp256k1_scalar_montgomery_domain_field_element out1) { + out1[0] = UINT64_C(0x402da1732fc9bebf); + out1[1] = UINT64_C(0x4551231950b75fc4); + out1[2] = 0x1; + out1[3] = 0x0; +} + +/* + * The function fiat_secp256k1_scalar_msat returns the saturated representation of the prime modulus. + * + * Postconditions: + * twos_complement_eval out1 = m + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_msat(uint64_t out1[5]) { + out1[0] = UINT64_C(0xbfd25e8cd0364141); + out1[1] = UINT64_C(0xbaaedce6af48a03b); + out1[2] = UINT64_C(0xfffffffffffffffe); + out1[3] = UINT64_C(0xffffffffffffffff); + out1[4] = 0x0; +} + +/* + * The function fiat_secp256k1_scalar_divstep computes a divstep. + * + * Preconditions: + * 0 ≤ eval arg4 < m + * 0 ≤ eval arg5 < m + * Postconditions: + * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) + * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) + * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) + * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) + * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) + * 0 ≤ eval out5 < m + * 0 ≤ eval out5 < m + * 0 ≤ eval out2 < m + * 0 ≤ eval out3 < m + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffffffffffff] + * arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_divstep(uint64_t* out1, uint64_t out2[5], uint64_t out3[5], uint64_t out4[4], uint64_t out5[4], uint64_t arg1, const uint64_t arg2[5], const uint64_t arg3[5], const uint64_t arg4[4], const uint64_t arg5[4]) { + uint64_t x1; + fiat_secp256k1_scalar_uint1 x2; + fiat_secp256k1_scalar_uint1 x3; + uint64_t x4; + fiat_secp256k1_scalar_uint1 x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + fiat_secp256k1_scalar_uint1 x13; + uint64_t x14; + fiat_secp256k1_scalar_uint1 x15; + uint64_t x16; + fiat_secp256k1_scalar_uint1 x17; + uint64_t x18; + fiat_secp256k1_scalar_uint1 x19; + uint64_t x20; + fiat_secp256k1_scalar_uint1 x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + fiat_secp256k1_scalar_uint1 x32; + uint64_t x33; + fiat_secp256k1_scalar_uint1 x34; + uint64_t x35; + fiat_secp256k1_scalar_uint1 x36; + uint64_t x37; + fiat_secp256k1_scalar_uint1 x38; + uint64_t x39; + fiat_secp256k1_scalar_uint1 x40; + uint64_t x41; + fiat_secp256k1_scalar_uint1 x42; + uint64_t x43; + fiat_secp256k1_scalar_uint1 x44; + uint64_t x45; + fiat_secp256k1_scalar_uint1 x46; + uint64_t x47; + fiat_secp256k1_scalar_uint1 x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + fiat_secp256k1_scalar_uint1 x54; + uint64_t x55; + fiat_secp256k1_scalar_uint1 x56; + uint64_t x57; + fiat_secp256k1_scalar_uint1 x58; + uint64_t x59; + fiat_secp256k1_scalar_uint1 x60; + uint64_t x61; + uint64_t x62; + fiat_secp256k1_scalar_uint1 x63; + uint64_t x64; + fiat_secp256k1_scalar_uint1 x65; + uint64_t x66; + fiat_secp256k1_scalar_uint1 x67; + uint64_t x68; + fiat_secp256k1_scalar_uint1 x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + fiat_secp256k1_scalar_uint1 x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + fiat_secp256k1_scalar_uint1 x81; + uint64_t x82; + fiat_secp256k1_scalar_uint1 x83; + uint64_t x84; + fiat_secp256k1_scalar_uint1 x85; + uint64_t x86; + fiat_secp256k1_scalar_uint1 x87; + uint64_t x88; + fiat_secp256k1_scalar_uint1 x89; + uint64_t x90; + uint64_t x91; + uint64_t x92; + uint64_t x93; + uint64_t x94; + fiat_secp256k1_scalar_uint1 x95; + uint64_t x96; + fiat_secp256k1_scalar_uint1 x97; + uint64_t x98; + fiat_secp256k1_scalar_uint1 x99; + uint64_t x100; + fiat_secp256k1_scalar_uint1 x101; + uint64_t x102; + fiat_secp256k1_scalar_uint1 x103; + uint64_t x104; + fiat_secp256k1_scalar_uint1 x105; + uint64_t x106; + fiat_secp256k1_scalar_uint1 x107; + uint64_t x108; + fiat_secp256k1_scalar_uint1 x109; + uint64_t x110; + fiat_secp256k1_scalar_uint1 x111; + uint64_t x112; + fiat_secp256k1_scalar_uint1 x113; + uint64_t x114; + uint64_t x115; + uint64_t x116; + uint64_t x117; + uint64_t x118; + uint64_t x119; + uint64_t x120; + uint64_t x121; + uint64_t x122; + uint64_t x123; + uint64_t x124; + uint64_t x125; + uint64_t x126; + fiat_secp256k1_scalar_addcarryx_u64(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_secp256k1_scalar_uint1)((fiat_secp256k1_scalar_uint1)(x1 >> 63) & (fiat_secp256k1_scalar_uint1)((arg3[0]) & 0x1)); + fiat_secp256k1_scalar_addcarryx_u64(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_secp256k1_scalar_cmovznz_u64(&x6, x3, arg1, x4); + fiat_secp256k1_scalar_cmovznz_u64(&x7, x3, (arg2[0]), (arg3[0])); + fiat_secp256k1_scalar_cmovznz_u64(&x8, x3, (arg2[1]), (arg3[1])); + fiat_secp256k1_scalar_cmovznz_u64(&x9, x3, (arg2[2]), (arg3[2])); + fiat_secp256k1_scalar_cmovznz_u64(&x10, x3, (arg2[3]), (arg3[3])); + fiat_secp256k1_scalar_cmovznz_u64(&x11, x3, (arg2[4]), (arg3[4])); + fiat_secp256k1_scalar_addcarryx_u64(&x12, &x13, 0x0, 0x1, (~(arg2[0]))); + fiat_secp256k1_scalar_addcarryx_u64(&x14, &x15, x13, 0x0, (~(arg2[1]))); + fiat_secp256k1_scalar_addcarryx_u64(&x16, &x17, x15, 0x0, (~(arg2[2]))); + fiat_secp256k1_scalar_addcarryx_u64(&x18, &x19, x17, 0x0, (~(arg2[3]))); + fiat_secp256k1_scalar_addcarryx_u64(&x20, &x21, x19, 0x0, (~(arg2[4]))); + fiat_secp256k1_scalar_cmovznz_u64(&x22, x3, (arg3[0]), x12); + fiat_secp256k1_scalar_cmovznz_u64(&x23, x3, (arg3[1]), x14); + fiat_secp256k1_scalar_cmovznz_u64(&x24, x3, (arg3[2]), x16); + fiat_secp256k1_scalar_cmovznz_u64(&x25, x3, (arg3[3]), x18); + fiat_secp256k1_scalar_cmovznz_u64(&x26, x3, (arg3[4]), x20); + fiat_secp256k1_scalar_cmovznz_u64(&x27, x3, (arg4[0]), (arg5[0])); + fiat_secp256k1_scalar_cmovznz_u64(&x28, x3, (arg4[1]), (arg5[1])); + fiat_secp256k1_scalar_cmovznz_u64(&x29, x3, (arg4[2]), (arg5[2])); + fiat_secp256k1_scalar_cmovznz_u64(&x30, x3, (arg4[3]), (arg5[3])); + fiat_secp256k1_scalar_addcarryx_u64(&x31, &x32, 0x0, x27, x27); + fiat_secp256k1_scalar_addcarryx_u64(&x33, &x34, x32, x28, x28); + fiat_secp256k1_scalar_addcarryx_u64(&x35, &x36, x34, x29, x29); + fiat_secp256k1_scalar_addcarryx_u64(&x37, &x38, x36, x30, x30); + fiat_secp256k1_scalar_subborrowx_u64(&x39, &x40, 0x0, x31, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_subborrowx_u64(&x41, &x42, x40, x33, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_subborrowx_u64(&x43, &x44, x42, x35, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_subborrowx_u64(&x45, &x46, x44, x37, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_subborrowx_u64(&x47, &x48, x46, x38, 0x0); + x49 = (arg4[3]); + x50 = (arg4[2]); + x51 = (arg4[1]); + x52 = (arg4[0]); + fiat_secp256k1_scalar_subborrowx_u64(&x53, &x54, 0x0, 0x0, x52); + fiat_secp256k1_scalar_subborrowx_u64(&x55, &x56, x54, 0x0, x51); + fiat_secp256k1_scalar_subborrowx_u64(&x57, &x58, x56, 0x0, x50); + fiat_secp256k1_scalar_subborrowx_u64(&x59, &x60, x58, 0x0, x49); + fiat_secp256k1_scalar_cmovznz_u64(&x61, x60, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_addcarryx_u64(&x62, &x63, 0x0, x53, (x61 & UINT64_C(0xbfd25e8cd0364141))); + fiat_secp256k1_scalar_addcarryx_u64(&x64, &x65, x63, x55, (x61 & UINT64_C(0xbaaedce6af48a03b))); + fiat_secp256k1_scalar_addcarryx_u64(&x66, &x67, x65, x57, (x61 & UINT64_C(0xfffffffffffffffe))); + fiat_secp256k1_scalar_addcarryx_u64(&x68, &x69, x67, x59, x61); + fiat_secp256k1_scalar_cmovznz_u64(&x70, x3, (arg5[0]), x62); + fiat_secp256k1_scalar_cmovznz_u64(&x71, x3, (arg5[1]), x64); + fiat_secp256k1_scalar_cmovznz_u64(&x72, x3, (arg5[2]), x66); + fiat_secp256k1_scalar_cmovznz_u64(&x73, x3, (arg5[3]), x68); + x74 = (fiat_secp256k1_scalar_uint1)(x22 & 0x1); + fiat_secp256k1_scalar_cmovznz_u64(&x75, x74, 0x0, x7); + fiat_secp256k1_scalar_cmovznz_u64(&x76, x74, 0x0, x8); + fiat_secp256k1_scalar_cmovznz_u64(&x77, x74, 0x0, x9); + fiat_secp256k1_scalar_cmovznz_u64(&x78, x74, 0x0, x10); + fiat_secp256k1_scalar_cmovznz_u64(&x79, x74, 0x0, x11); + fiat_secp256k1_scalar_addcarryx_u64(&x80, &x81, 0x0, x22, x75); + fiat_secp256k1_scalar_addcarryx_u64(&x82, &x83, x81, x23, x76); + fiat_secp256k1_scalar_addcarryx_u64(&x84, &x85, x83, x24, x77); + fiat_secp256k1_scalar_addcarryx_u64(&x86, &x87, x85, x25, x78); + fiat_secp256k1_scalar_addcarryx_u64(&x88, &x89, x87, x26, x79); + fiat_secp256k1_scalar_cmovznz_u64(&x90, x74, 0x0, x27); + fiat_secp256k1_scalar_cmovznz_u64(&x91, x74, 0x0, x28); + fiat_secp256k1_scalar_cmovznz_u64(&x92, x74, 0x0, x29); + fiat_secp256k1_scalar_cmovznz_u64(&x93, x74, 0x0, x30); + fiat_secp256k1_scalar_addcarryx_u64(&x94, &x95, 0x0, x70, x90); + fiat_secp256k1_scalar_addcarryx_u64(&x96, &x97, x95, x71, x91); + fiat_secp256k1_scalar_addcarryx_u64(&x98, &x99, x97, x72, x92); + fiat_secp256k1_scalar_addcarryx_u64(&x100, &x101, x99, x73, x93); + fiat_secp256k1_scalar_subborrowx_u64(&x102, &x103, 0x0, x94, UINT64_C(0xbfd25e8cd0364141)); + fiat_secp256k1_scalar_subborrowx_u64(&x104, &x105, x103, x96, UINT64_C(0xbaaedce6af48a03b)); + fiat_secp256k1_scalar_subborrowx_u64(&x106, &x107, x105, x98, UINT64_C(0xfffffffffffffffe)); + fiat_secp256k1_scalar_subborrowx_u64(&x108, &x109, x107, x100, UINT64_C(0xffffffffffffffff)); + fiat_secp256k1_scalar_subborrowx_u64(&x110, &x111, x109, x101, 0x0); + fiat_secp256k1_scalar_addcarryx_u64(&x112, &x113, 0x0, x6, 0x1); + x114 = ((x80 >> 1) | ((x82 << 63) & UINT64_C(0xffffffffffffffff))); + x115 = ((x82 >> 1) | ((x84 << 63) & UINT64_C(0xffffffffffffffff))); + x116 = ((x84 >> 1) | ((x86 << 63) & UINT64_C(0xffffffffffffffff))); + x117 = ((x86 >> 1) | ((x88 << 63) & UINT64_C(0xffffffffffffffff))); + x118 = ((x88 & UINT64_C(0x8000000000000000)) | (x88 >> 1)); + fiat_secp256k1_scalar_cmovznz_u64(&x119, x48, x39, x31); + fiat_secp256k1_scalar_cmovznz_u64(&x120, x48, x41, x33); + fiat_secp256k1_scalar_cmovznz_u64(&x121, x48, x43, x35); + fiat_secp256k1_scalar_cmovznz_u64(&x122, x48, x45, x37); + fiat_secp256k1_scalar_cmovznz_u64(&x123, x111, x102, x94); + fiat_secp256k1_scalar_cmovznz_u64(&x124, x111, x104, x96); + fiat_secp256k1_scalar_cmovznz_u64(&x125, x111, x106, x98); + fiat_secp256k1_scalar_cmovznz_u64(&x126, x111, x108, x100); + *out1 = x112; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out3[0] = x114; + out3[1] = x115; + out3[2] = x116; + out3[3] = x117; + out3[4] = x118; + out4[0] = x119; + out4[1] = x120; + out4[2] = x121; + out4[3] = x122; + out5[0] = x123; + out5[1] = x124; + out5[2] = x125; + out5[3] = x126; +} + +/* + * The function fiat_secp256k1_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). + * + * Postconditions: + * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_SECP256K1_SCALAR_FIAT_INLINE void fiat_secp256k1_scalar_divstep_precomp(uint64_t out1[4]) { + out1[0] = UINT64_C(0xd7431a4d2b9cb4e9); + out1[1] = UINT64_C(0xab67d35a32d9c503); + out1[2] = UINT64_C(0xadf6c7e5859ce35f); + out1[3] = UINT64_C(0x615441451df6c379); +} diff --git a/fiat-go/32/curve25519scalar/curve25519scalar.go b/fiat-go/32/curve25519scalar/curve25519scalar.go new file mode 100644 index 0000000000..c2124f0054 --- /dev/null +++ b/fiat-go/32/curve25519scalar/curve25519scalar.go @@ -0,0 +1,4657 @@ +// Code generated by Fiat Cryptography. DO NOT EDIT. +// +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Go --relax-primitive-carry-to-bitwidth 32,64 --cmovznz-by-mul --internal-static --package-case flatcase --public-function-case UpperCamelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case camelCase --no-prefix-fiat --doc-newline-in-typedef-bounds --doc-prepend-header 'Code generated by Fiat Cryptography. DO NOT EDIT.' --doc-text-before-function-name '' --doc-text-before-type-name '' --package-name curve25519scalar '' 32 '2^252 + 27742317777372353535851937790883648493' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// +// curve description (via package name): curve25519scalar +// +// machine_wordsize = 32 (from "32") +// +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// +// m = 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed (from "2^252 + 27742317777372353535851937790883648493") +// +// +// +// NOTE: In addition to the bounds specified above each function, all +// +// functions synthesized for this Montgomery arithmetic require the +// +// input to be strictly less than the prime modulus (m), and also +// +// require the input to be in the unique saturated representation. +// +// All functions also ensure that these two properties are true of +// +// return values. +// +// +// +// Computed values: +// +// eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) +// +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +// +// twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in +// +// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 +package curve25519scalar + +import "math/bits" + +type uint1 uint64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 +type int1 int64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 + +// MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +type MontgomeryDomainFieldElement [8]uint32 + +// NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +type NonMontgomeryDomainFieldElement [8]uint32 + +// cmovznzU32 is a single-word conditional move. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [0x0 ~> 0xffffffff] +// arg3: [0x0 ~> 0xffffffff] +// Output Bounds: +// out1: [0x0 ~> 0xffffffff] +func cmovznzU32(out1 *uint32, arg1 uint1, arg2 uint32, arg3 uint32) { + x1 := (uint32(arg1) * 0xffffffff) + x2 := ((x1 & arg3) | ((^x1) & arg2)) + *out1 = x2 +} + +// Mul multiplies two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Mul(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[6] + x7 := arg1[7] + x8 := arg1[0] + var x9 uint32 + var x10 uint32 + x10, x9 = bits.Mul32(x8, arg2[7]) + var x11 uint32 + var x12 uint32 + x12, x11 = bits.Mul32(x8, arg2[6]) + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x8, arg2[5]) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x8, arg2[4]) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x8, arg2[3]) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x8, arg2[2]) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x8, arg2[1]) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x8, arg2[0]) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Add32(x24, x21, uint32(0x0)) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Add32(x22, x19, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Add32(x20, x17, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Add32(x18, x15, uint32(uint1(x30))) + var x33 uint32 + var x34 uint32 + x33, x34 = bits.Add32(x16, x13, uint32(uint1(x32))) + var x35 uint32 + var x36 uint32 + x35, x36 = bits.Add32(x14, x11, uint32(uint1(x34))) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Add32(x12, x9, uint32(uint1(x36))) + x39 := (uint32(uint1(x38)) + x10) + var x40 uint32 + _, x40 = bits.Mul32(x23, 0x12547e1b) + var x42 uint32 + var x43 uint32 + x43, x42 = bits.Mul32(x40, 0x10000000) + var x44 uint32 + var x45 uint32 + x45, x44 = bits.Mul32(x40, 0x14def9de) + var x46 uint32 + var x47 uint32 + x47, x46 = bits.Mul32(x40, 0xa2f79cd6) + var x48 uint32 + var x49 uint32 + x49, x48 = bits.Mul32(x40, 0x5812631a) + var x50 uint32 + var x51 uint32 + x51, x50 = bits.Mul32(x40, 0x5cf5d3ed) + var x52 uint32 + var x53 uint32 + x52, x53 = bits.Add32(x51, x48, uint32(0x0)) + var x54 uint32 + var x55 uint32 + x54, x55 = bits.Add32(x49, x46, uint32(uint1(x53))) + var x56 uint32 + var x57 uint32 + x56, x57 = bits.Add32(x47, x44, uint32(uint1(x55))) + x58 := (uint32(uint1(x57)) + x45) + var x60 uint32 + _, x60 = bits.Add32(x23, x50, uint32(0x0)) + var x61 uint32 + var x62 uint32 + x61, x62 = bits.Add32(x25, x52, uint32(uint1(x60))) + var x63 uint32 + var x64 uint32 + x63, x64 = bits.Add32(x27, x54, uint32(uint1(x62))) + var x65 uint32 + var x66 uint32 + x65, x66 = bits.Add32(x29, x56, uint32(uint1(x64))) + var x67 uint32 + var x68 uint32 + x67, x68 = bits.Add32(x31, x58, uint32(uint1(x66))) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Add32(x33, uint32(0x0), uint32(uint1(x68))) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Add32(x35, uint32(0x0), uint32(uint1(x70))) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Add32(x37, x42, uint32(uint1(x72))) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Add32(x39, x43, uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x78, x77 = bits.Mul32(x1, arg2[7]) + var x79 uint32 + var x80 uint32 + x80, x79 = bits.Mul32(x1, arg2[6]) + var x81 uint32 + var x82 uint32 + x82, x81 = bits.Mul32(x1, arg2[5]) + var x83 uint32 + var x84 uint32 + x84, x83 = bits.Mul32(x1, arg2[4]) + var x85 uint32 + var x86 uint32 + x86, x85 = bits.Mul32(x1, arg2[3]) + var x87 uint32 + var x88 uint32 + x88, x87 = bits.Mul32(x1, arg2[2]) + var x89 uint32 + var x90 uint32 + x90, x89 = bits.Mul32(x1, arg2[1]) + var x91 uint32 + var x92 uint32 + x92, x91 = bits.Mul32(x1, arg2[0]) + var x93 uint32 + var x94 uint32 + x93, x94 = bits.Add32(x92, x89, uint32(0x0)) + var x95 uint32 + var x96 uint32 + x95, x96 = bits.Add32(x90, x87, uint32(uint1(x94))) + var x97 uint32 + var x98 uint32 + x97, x98 = bits.Add32(x88, x85, uint32(uint1(x96))) + var x99 uint32 + var x100 uint32 + x99, x100 = bits.Add32(x86, x83, uint32(uint1(x98))) + var x101 uint32 + var x102 uint32 + x101, x102 = bits.Add32(x84, x81, uint32(uint1(x100))) + var x103 uint32 + var x104 uint32 + x103, x104 = bits.Add32(x82, x79, uint32(uint1(x102))) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Add32(x80, x77, uint32(uint1(x104))) + x107 := (uint32(uint1(x106)) + x78) + var x108 uint32 + var x109 uint32 + x108, x109 = bits.Add32(x61, x91, uint32(0x0)) + var x110 uint32 + var x111 uint32 + x110, x111 = bits.Add32(x63, x93, uint32(uint1(x109))) + var x112 uint32 + var x113 uint32 + x112, x113 = bits.Add32(x65, x95, uint32(uint1(x111))) + var x114 uint32 + var x115 uint32 + x114, x115 = bits.Add32(x67, x97, uint32(uint1(x113))) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32(x69, x99, uint32(uint1(x115))) + var x118 uint32 + var x119 uint32 + x118, x119 = bits.Add32(x71, x101, uint32(uint1(x117))) + var x120 uint32 + var x121 uint32 + x120, x121 = bits.Add32(x73, x103, uint32(uint1(x119))) + var x122 uint32 + var x123 uint32 + x122, x123 = bits.Add32(x75, x105, uint32(uint1(x121))) + var x124 uint32 + var x125 uint32 + x124, x125 = bits.Add32(uint32(uint1(x76)), x107, uint32(uint1(x123))) + var x126 uint32 + _, x126 = bits.Mul32(x108, 0x12547e1b) + var x128 uint32 + var x129 uint32 + x129, x128 = bits.Mul32(x126, 0x10000000) + var x130 uint32 + var x131 uint32 + x131, x130 = bits.Mul32(x126, 0x14def9de) + var x132 uint32 + var x133 uint32 + x133, x132 = bits.Mul32(x126, 0xa2f79cd6) + var x134 uint32 + var x135 uint32 + x135, x134 = bits.Mul32(x126, 0x5812631a) + var x136 uint32 + var x137 uint32 + x137, x136 = bits.Mul32(x126, 0x5cf5d3ed) + var x138 uint32 + var x139 uint32 + x138, x139 = bits.Add32(x137, x134, uint32(0x0)) + var x140 uint32 + var x141 uint32 + x140, x141 = bits.Add32(x135, x132, uint32(uint1(x139))) + var x142 uint32 + var x143 uint32 + x142, x143 = bits.Add32(x133, x130, uint32(uint1(x141))) + x144 := (uint32(uint1(x143)) + x131) + var x146 uint32 + _, x146 = bits.Add32(x108, x136, uint32(0x0)) + var x147 uint32 + var x148 uint32 + x147, x148 = bits.Add32(x110, x138, uint32(uint1(x146))) + var x149 uint32 + var x150 uint32 + x149, x150 = bits.Add32(x112, x140, uint32(uint1(x148))) + var x151 uint32 + var x152 uint32 + x151, x152 = bits.Add32(x114, x142, uint32(uint1(x150))) + var x153 uint32 + var x154 uint32 + x153, x154 = bits.Add32(x116, x144, uint32(uint1(x152))) + var x155 uint32 + var x156 uint32 + x155, x156 = bits.Add32(x118, uint32(0x0), uint32(uint1(x154))) + var x157 uint32 + var x158 uint32 + x157, x158 = bits.Add32(x120, uint32(0x0), uint32(uint1(x156))) + var x159 uint32 + var x160 uint32 + x159, x160 = bits.Add32(x122, x128, uint32(uint1(x158))) + var x161 uint32 + var x162 uint32 + x161, x162 = bits.Add32(x124, x129, uint32(uint1(x160))) + x163 := (uint32(uint1(x162)) + uint32(uint1(x125))) + var x164 uint32 + var x165 uint32 + x165, x164 = bits.Mul32(x2, arg2[7]) + var x166 uint32 + var x167 uint32 + x167, x166 = bits.Mul32(x2, arg2[6]) + var x168 uint32 + var x169 uint32 + x169, x168 = bits.Mul32(x2, arg2[5]) + var x170 uint32 + var x171 uint32 + x171, x170 = bits.Mul32(x2, arg2[4]) + var x172 uint32 + var x173 uint32 + x173, x172 = bits.Mul32(x2, arg2[3]) + var x174 uint32 + var x175 uint32 + x175, x174 = bits.Mul32(x2, arg2[2]) + var x176 uint32 + var x177 uint32 + x177, x176 = bits.Mul32(x2, arg2[1]) + var x178 uint32 + var x179 uint32 + x179, x178 = bits.Mul32(x2, arg2[0]) + var x180 uint32 + var x181 uint32 + x180, x181 = bits.Add32(x179, x176, uint32(0x0)) + var x182 uint32 + var x183 uint32 + x182, x183 = bits.Add32(x177, x174, uint32(uint1(x181))) + var x184 uint32 + var x185 uint32 + x184, x185 = bits.Add32(x175, x172, uint32(uint1(x183))) + var x186 uint32 + var x187 uint32 + x186, x187 = bits.Add32(x173, x170, uint32(uint1(x185))) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Add32(x171, x168, uint32(uint1(x187))) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Add32(x169, x166, uint32(uint1(x189))) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Add32(x167, x164, uint32(uint1(x191))) + x194 := (uint32(uint1(x193)) + x165) + var x195 uint32 + var x196 uint32 + x195, x196 = bits.Add32(x147, x178, uint32(0x0)) + var x197 uint32 + var x198 uint32 + x197, x198 = bits.Add32(x149, x180, uint32(uint1(x196))) + var x199 uint32 + var x200 uint32 + x199, x200 = bits.Add32(x151, x182, uint32(uint1(x198))) + var x201 uint32 + var x202 uint32 + x201, x202 = bits.Add32(x153, x184, uint32(uint1(x200))) + var x203 uint32 + var x204 uint32 + x203, x204 = bits.Add32(x155, x186, uint32(uint1(x202))) + var x205 uint32 + var x206 uint32 + x205, x206 = bits.Add32(x157, x188, uint32(uint1(x204))) + var x207 uint32 + var x208 uint32 + x207, x208 = bits.Add32(x159, x190, uint32(uint1(x206))) + var x209 uint32 + var x210 uint32 + x209, x210 = bits.Add32(x161, x192, uint32(uint1(x208))) + var x211 uint32 + var x212 uint32 + x211, x212 = bits.Add32(x163, x194, uint32(uint1(x210))) + var x213 uint32 + _, x213 = bits.Mul32(x195, 0x12547e1b) + var x215 uint32 + var x216 uint32 + x216, x215 = bits.Mul32(x213, 0x10000000) + var x217 uint32 + var x218 uint32 + x218, x217 = bits.Mul32(x213, 0x14def9de) + var x219 uint32 + var x220 uint32 + x220, x219 = bits.Mul32(x213, 0xa2f79cd6) + var x221 uint32 + var x222 uint32 + x222, x221 = bits.Mul32(x213, 0x5812631a) + var x223 uint32 + var x224 uint32 + x224, x223 = bits.Mul32(x213, 0x5cf5d3ed) + var x225 uint32 + var x226 uint32 + x225, x226 = bits.Add32(x224, x221, uint32(0x0)) + var x227 uint32 + var x228 uint32 + x227, x228 = bits.Add32(x222, x219, uint32(uint1(x226))) + var x229 uint32 + var x230 uint32 + x229, x230 = bits.Add32(x220, x217, uint32(uint1(x228))) + x231 := (uint32(uint1(x230)) + x218) + var x233 uint32 + _, x233 = bits.Add32(x195, x223, uint32(0x0)) + var x234 uint32 + var x235 uint32 + x234, x235 = bits.Add32(x197, x225, uint32(uint1(x233))) + var x236 uint32 + var x237 uint32 + x236, x237 = bits.Add32(x199, x227, uint32(uint1(x235))) + var x238 uint32 + var x239 uint32 + x238, x239 = bits.Add32(x201, x229, uint32(uint1(x237))) + var x240 uint32 + var x241 uint32 + x240, x241 = bits.Add32(x203, x231, uint32(uint1(x239))) + var x242 uint32 + var x243 uint32 + x242, x243 = bits.Add32(x205, uint32(0x0), uint32(uint1(x241))) + var x244 uint32 + var x245 uint32 + x244, x245 = bits.Add32(x207, uint32(0x0), uint32(uint1(x243))) + var x246 uint32 + var x247 uint32 + x246, x247 = bits.Add32(x209, x215, uint32(uint1(x245))) + var x248 uint32 + var x249 uint32 + x248, x249 = bits.Add32(x211, x216, uint32(uint1(x247))) + x250 := (uint32(uint1(x249)) + uint32(uint1(x212))) + var x251 uint32 + var x252 uint32 + x252, x251 = bits.Mul32(x3, arg2[7]) + var x253 uint32 + var x254 uint32 + x254, x253 = bits.Mul32(x3, arg2[6]) + var x255 uint32 + var x256 uint32 + x256, x255 = bits.Mul32(x3, arg2[5]) + var x257 uint32 + var x258 uint32 + x258, x257 = bits.Mul32(x3, arg2[4]) + var x259 uint32 + var x260 uint32 + x260, x259 = bits.Mul32(x3, arg2[3]) + var x261 uint32 + var x262 uint32 + x262, x261 = bits.Mul32(x3, arg2[2]) + var x263 uint32 + var x264 uint32 + x264, x263 = bits.Mul32(x3, arg2[1]) + var x265 uint32 + var x266 uint32 + x266, x265 = bits.Mul32(x3, arg2[0]) + var x267 uint32 + var x268 uint32 + x267, x268 = bits.Add32(x266, x263, uint32(0x0)) + var x269 uint32 + var x270 uint32 + x269, x270 = bits.Add32(x264, x261, uint32(uint1(x268))) + var x271 uint32 + var x272 uint32 + x271, x272 = bits.Add32(x262, x259, uint32(uint1(x270))) + var x273 uint32 + var x274 uint32 + x273, x274 = bits.Add32(x260, x257, uint32(uint1(x272))) + var x275 uint32 + var x276 uint32 + x275, x276 = bits.Add32(x258, x255, uint32(uint1(x274))) + var x277 uint32 + var x278 uint32 + x277, x278 = bits.Add32(x256, x253, uint32(uint1(x276))) + var x279 uint32 + var x280 uint32 + x279, x280 = bits.Add32(x254, x251, uint32(uint1(x278))) + x281 := (uint32(uint1(x280)) + x252) + var x282 uint32 + var x283 uint32 + x282, x283 = bits.Add32(x234, x265, uint32(0x0)) + var x284 uint32 + var x285 uint32 + x284, x285 = bits.Add32(x236, x267, uint32(uint1(x283))) + var x286 uint32 + var x287 uint32 + x286, x287 = bits.Add32(x238, x269, uint32(uint1(x285))) + var x288 uint32 + var x289 uint32 + x288, x289 = bits.Add32(x240, x271, uint32(uint1(x287))) + var x290 uint32 + var x291 uint32 + x290, x291 = bits.Add32(x242, x273, uint32(uint1(x289))) + var x292 uint32 + var x293 uint32 + x292, x293 = bits.Add32(x244, x275, uint32(uint1(x291))) + var x294 uint32 + var x295 uint32 + x294, x295 = bits.Add32(x246, x277, uint32(uint1(x293))) + var x296 uint32 + var x297 uint32 + x296, x297 = bits.Add32(x248, x279, uint32(uint1(x295))) + var x298 uint32 + var x299 uint32 + x298, x299 = bits.Add32(x250, x281, uint32(uint1(x297))) + var x300 uint32 + _, x300 = bits.Mul32(x282, 0x12547e1b) + var x302 uint32 + var x303 uint32 + x303, x302 = bits.Mul32(x300, 0x10000000) + var x304 uint32 + var x305 uint32 + x305, x304 = bits.Mul32(x300, 0x14def9de) + var x306 uint32 + var x307 uint32 + x307, x306 = bits.Mul32(x300, 0xa2f79cd6) + var x308 uint32 + var x309 uint32 + x309, x308 = bits.Mul32(x300, 0x5812631a) + var x310 uint32 + var x311 uint32 + x311, x310 = bits.Mul32(x300, 0x5cf5d3ed) + var x312 uint32 + var x313 uint32 + x312, x313 = bits.Add32(x311, x308, uint32(0x0)) + var x314 uint32 + var x315 uint32 + x314, x315 = bits.Add32(x309, x306, uint32(uint1(x313))) + var x316 uint32 + var x317 uint32 + x316, x317 = bits.Add32(x307, x304, uint32(uint1(x315))) + x318 := (uint32(uint1(x317)) + x305) + var x320 uint32 + _, x320 = bits.Add32(x282, x310, uint32(0x0)) + var x321 uint32 + var x322 uint32 + x321, x322 = bits.Add32(x284, x312, uint32(uint1(x320))) + var x323 uint32 + var x324 uint32 + x323, x324 = bits.Add32(x286, x314, uint32(uint1(x322))) + var x325 uint32 + var x326 uint32 + x325, x326 = bits.Add32(x288, x316, uint32(uint1(x324))) + var x327 uint32 + var x328 uint32 + x327, x328 = bits.Add32(x290, x318, uint32(uint1(x326))) + var x329 uint32 + var x330 uint32 + x329, x330 = bits.Add32(x292, uint32(0x0), uint32(uint1(x328))) + var x331 uint32 + var x332 uint32 + x331, x332 = bits.Add32(x294, uint32(0x0), uint32(uint1(x330))) + var x333 uint32 + var x334 uint32 + x333, x334 = bits.Add32(x296, x302, uint32(uint1(x332))) + var x335 uint32 + var x336 uint32 + x335, x336 = bits.Add32(x298, x303, uint32(uint1(x334))) + x337 := (uint32(uint1(x336)) + uint32(uint1(x299))) + var x338 uint32 + var x339 uint32 + x339, x338 = bits.Mul32(x4, arg2[7]) + var x340 uint32 + var x341 uint32 + x341, x340 = bits.Mul32(x4, arg2[6]) + var x342 uint32 + var x343 uint32 + x343, x342 = bits.Mul32(x4, arg2[5]) + var x344 uint32 + var x345 uint32 + x345, x344 = bits.Mul32(x4, arg2[4]) + var x346 uint32 + var x347 uint32 + x347, x346 = bits.Mul32(x4, arg2[3]) + var x348 uint32 + var x349 uint32 + x349, x348 = bits.Mul32(x4, arg2[2]) + var x350 uint32 + var x351 uint32 + x351, x350 = bits.Mul32(x4, arg2[1]) + var x352 uint32 + var x353 uint32 + x353, x352 = bits.Mul32(x4, arg2[0]) + var x354 uint32 + var x355 uint32 + x354, x355 = bits.Add32(x353, x350, uint32(0x0)) + var x356 uint32 + var x357 uint32 + x356, x357 = bits.Add32(x351, x348, uint32(uint1(x355))) + var x358 uint32 + var x359 uint32 + x358, x359 = bits.Add32(x349, x346, uint32(uint1(x357))) + var x360 uint32 + var x361 uint32 + x360, x361 = bits.Add32(x347, x344, uint32(uint1(x359))) + var x362 uint32 + var x363 uint32 + x362, x363 = bits.Add32(x345, x342, uint32(uint1(x361))) + var x364 uint32 + var x365 uint32 + x364, x365 = bits.Add32(x343, x340, uint32(uint1(x363))) + var x366 uint32 + var x367 uint32 + x366, x367 = bits.Add32(x341, x338, uint32(uint1(x365))) + x368 := (uint32(uint1(x367)) + x339) + var x369 uint32 + var x370 uint32 + x369, x370 = bits.Add32(x321, x352, uint32(0x0)) + var x371 uint32 + var x372 uint32 + x371, x372 = bits.Add32(x323, x354, uint32(uint1(x370))) + var x373 uint32 + var x374 uint32 + x373, x374 = bits.Add32(x325, x356, uint32(uint1(x372))) + var x375 uint32 + var x376 uint32 + x375, x376 = bits.Add32(x327, x358, uint32(uint1(x374))) + var x377 uint32 + var x378 uint32 + x377, x378 = bits.Add32(x329, x360, uint32(uint1(x376))) + var x379 uint32 + var x380 uint32 + x379, x380 = bits.Add32(x331, x362, uint32(uint1(x378))) + var x381 uint32 + var x382 uint32 + x381, x382 = bits.Add32(x333, x364, uint32(uint1(x380))) + var x383 uint32 + var x384 uint32 + x383, x384 = bits.Add32(x335, x366, uint32(uint1(x382))) + var x385 uint32 + var x386 uint32 + x385, x386 = bits.Add32(x337, x368, uint32(uint1(x384))) + var x387 uint32 + _, x387 = bits.Mul32(x369, 0x12547e1b) + var x389 uint32 + var x390 uint32 + x390, x389 = bits.Mul32(x387, 0x10000000) + var x391 uint32 + var x392 uint32 + x392, x391 = bits.Mul32(x387, 0x14def9de) + var x393 uint32 + var x394 uint32 + x394, x393 = bits.Mul32(x387, 0xa2f79cd6) + var x395 uint32 + var x396 uint32 + x396, x395 = bits.Mul32(x387, 0x5812631a) + var x397 uint32 + var x398 uint32 + x398, x397 = bits.Mul32(x387, 0x5cf5d3ed) + var x399 uint32 + var x400 uint32 + x399, x400 = bits.Add32(x398, x395, uint32(0x0)) + var x401 uint32 + var x402 uint32 + x401, x402 = bits.Add32(x396, x393, uint32(uint1(x400))) + var x403 uint32 + var x404 uint32 + x403, x404 = bits.Add32(x394, x391, uint32(uint1(x402))) + x405 := (uint32(uint1(x404)) + x392) + var x407 uint32 + _, x407 = bits.Add32(x369, x397, uint32(0x0)) + var x408 uint32 + var x409 uint32 + x408, x409 = bits.Add32(x371, x399, uint32(uint1(x407))) + var x410 uint32 + var x411 uint32 + x410, x411 = bits.Add32(x373, x401, uint32(uint1(x409))) + var x412 uint32 + var x413 uint32 + x412, x413 = bits.Add32(x375, x403, uint32(uint1(x411))) + var x414 uint32 + var x415 uint32 + x414, x415 = bits.Add32(x377, x405, uint32(uint1(x413))) + var x416 uint32 + var x417 uint32 + x416, x417 = bits.Add32(x379, uint32(0x0), uint32(uint1(x415))) + var x418 uint32 + var x419 uint32 + x418, x419 = bits.Add32(x381, uint32(0x0), uint32(uint1(x417))) + var x420 uint32 + var x421 uint32 + x420, x421 = bits.Add32(x383, x389, uint32(uint1(x419))) + var x422 uint32 + var x423 uint32 + x422, x423 = bits.Add32(x385, x390, uint32(uint1(x421))) + x424 := (uint32(uint1(x423)) + uint32(uint1(x386))) + var x425 uint32 + var x426 uint32 + x426, x425 = bits.Mul32(x5, arg2[7]) + var x427 uint32 + var x428 uint32 + x428, x427 = bits.Mul32(x5, arg2[6]) + var x429 uint32 + var x430 uint32 + x430, x429 = bits.Mul32(x5, arg2[5]) + var x431 uint32 + var x432 uint32 + x432, x431 = bits.Mul32(x5, arg2[4]) + var x433 uint32 + var x434 uint32 + x434, x433 = bits.Mul32(x5, arg2[3]) + var x435 uint32 + var x436 uint32 + x436, x435 = bits.Mul32(x5, arg2[2]) + var x437 uint32 + var x438 uint32 + x438, x437 = bits.Mul32(x5, arg2[1]) + var x439 uint32 + var x440 uint32 + x440, x439 = bits.Mul32(x5, arg2[0]) + var x441 uint32 + var x442 uint32 + x441, x442 = bits.Add32(x440, x437, uint32(0x0)) + var x443 uint32 + var x444 uint32 + x443, x444 = bits.Add32(x438, x435, uint32(uint1(x442))) + var x445 uint32 + var x446 uint32 + x445, x446 = bits.Add32(x436, x433, uint32(uint1(x444))) + var x447 uint32 + var x448 uint32 + x447, x448 = bits.Add32(x434, x431, uint32(uint1(x446))) + var x449 uint32 + var x450 uint32 + x449, x450 = bits.Add32(x432, x429, uint32(uint1(x448))) + var x451 uint32 + var x452 uint32 + x451, x452 = bits.Add32(x430, x427, uint32(uint1(x450))) + var x453 uint32 + var x454 uint32 + x453, x454 = bits.Add32(x428, x425, uint32(uint1(x452))) + x455 := (uint32(uint1(x454)) + x426) + var x456 uint32 + var x457 uint32 + x456, x457 = bits.Add32(x408, x439, uint32(0x0)) + var x458 uint32 + var x459 uint32 + x458, x459 = bits.Add32(x410, x441, uint32(uint1(x457))) + var x460 uint32 + var x461 uint32 + x460, x461 = bits.Add32(x412, x443, uint32(uint1(x459))) + var x462 uint32 + var x463 uint32 + x462, x463 = bits.Add32(x414, x445, uint32(uint1(x461))) + var x464 uint32 + var x465 uint32 + x464, x465 = bits.Add32(x416, x447, uint32(uint1(x463))) + var x466 uint32 + var x467 uint32 + x466, x467 = bits.Add32(x418, x449, uint32(uint1(x465))) + var x468 uint32 + var x469 uint32 + x468, x469 = bits.Add32(x420, x451, uint32(uint1(x467))) + var x470 uint32 + var x471 uint32 + x470, x471 = bits.Add32(x422, x453, uint32(uint1(x469))) + var x472 uint32 + var x473 uint32 + x472, x473 = bits.Add32(x424, x455, uint32(uint1(x471))) + var x474 uint32 + _, x474 = bits.Mul32(x456, 0x12547e1b) + var x476 uint32 + var x477 uint32 + x477, x476 = bits.Mul32(x474, 0x10000000) + var x478 uint32 + var x479 uint32 + x479, x478 = bits.Mul32(x474, 0x14def9de) + var x480 uint32 + var x481 uint32 + x481, x480 = bits.Mul32(x474, 0xa2f79cd6) + var x482 uint32 + var x483 uint32 + x483, x482 = bits.Mul32(x474, 0x5812631a) + var x484 uint32 + var x485 uint32 + x485, x484 = bits.Mul32(x474, 0x5cf5d3ed) + var x486 uint32 + var x487 uint32 + x486, x487 = bits.Add32(x485, x482, uint32(0x0)) + var x488 uint32 + var x489 uint32 + x488, x489 = bits.Add32(x483, x480, uint32(uint1(x487))) + var x490 uint32 + var x491 uint32 + x490, x491 = bits.Add32(x481, x478, uint32(uint1(x489))) + x492 := (uint32(uint1(x491)) + x479) + var x494 uint32 + _, x494 = bits.Add32(x456, x484, uint32(0x0)) + var x495 uint32 + var x496 uint32 + x495, x496 = bits.Add32(x458, x486, uint32(uint1(x494))) + var x497 uint32 + var x498 uint32 + x497, x498 = bits.Add32(x460, x488, uint32(uint1(x496))) + var x499 uint32 + var x500 uint32 + x499, x500 = bits.Add32(x462, x490, uint32(uint1(x498))) + var x501 uint32 + var x502 uint32 + x501, x502 = bits.Add32(x464, x492, uint32(uint1(x500))) + var x503 uint32 + var x504 uint32 + x503, x504 = bits.Add32(x466, uint32(0x0), uint32(uint1(x502))) + var x505 uint32 + var x506 uint32 + x505, x506 = bits.Add32(x468, uint32(0x0), uint32(uint1(x504))) + var x507 uint32 + var x508 uint32 + x507, x508 = bits.Add32(x470, x476, uint32(uint1(x506))) + var x509 uint32 + var x510 uint32 + x509, x510 = bits.Add32(x472, x477, uint32(uint1(x508))) + x511 := (uint32(uint1(x510)) + uint32(uint1(x473))) + var x512 uint32 + var x513 uint32 + x513, x512 = bits.Mul32(x6, arg2[7]) + var x514 uint32 + var x515 uint32 + x515, x514 = bits.Mul32(x6, arg2[6]) + var x516 uint32 + var x517 uint32 + x517, x516 = bits.Mul32(x6, arg2[5]) + var x518 uint32 + var x519 uint32 + x519, x518 = bits.Mul32(x6, arg2[4]) + var x520 uint32 + var x521 uint32 + x521, x520 = bits.Mul32(x6, arg2[3]) + var x522 uint32 + var x523 uint32 + x523, x522 = bits.Mul32(x6, arg2[2]) + var x524 uint32 + var x525 uint32 + x525, x524 = bits.Mul32(x6, arg2[1]) + var x526 uint32 + var x527 uint32 + x527, x526 = bits.Mul32(x6, arg2[0]) + var x528 uint32 + var x529 uint32 + x528, x529 = bits.Add32(x527, x524, uint32(0x0)) + var x530 uint32 + var x531 uint32 + x530, x531 = bits.Add32(x525, x522, uint32(uint1(x529))) + var x532 uint32 + var x533 uint32 + x532, x533 = bits.Add32(x523, x520, uint32(uint1(x531))) + var x534 uint32 + var x535 uint32 + x534, x535 = bits.Add32(x521, x518, uint32(uint1(x533))) + var x536 uint32 + var x537 uint32 + x536, x537 = bits.Add32(x519, x516, uint32(uint1(x535))) + var x538 uint32 + var x539 uint32 + x538, x539 = bits.Add32(x517, x514, uint32(uint1(x537))) + var x540 uint32 + var x541 uint32 + x540, x541 = bits.Add32(x515, x512, uint32(uint1(x539))) + x542 := (uint32(uint1(x541)) + x513) + var x543 uint32 + var x544 uint32 + x543, x544 = bits.Add32(x495, x526, uint32(0x0)) + var x545 uint32 + var x546 uint32 + x545, x546 = bits.Add32(x497, x528, uint32(uint1(x544))) + var x547 uint32 + var x548 uint32 + x547, x548 = bits.Add32(x499, x530, uint32(uint1(x546))) + var x549 uint32 + var x550 uint32 + x549, x550 = bits.Add32(x501, x532, uint32(uint1(x548))) + var x551 uint32 + var x552 uint32 + x551, x552 = bits.Add32(x503, x534, uint32(uint1(x550))) + var x553 uint32 + var x554 uint32 + x553, x554 = bits.Add32(x505, x536, uint32(uint1(x552))) + var x555 uint32 + var x556 uint32 + x555, x556 = bits.Add32(x507, x538, uint32(uint1(x554))) + var x557 uint32 + var x558 uint32 + x557, x558 = bits.Add32(x509, x540, uint32(uint1(x556))) + var x559 uint32 + var x560 uint32 + x559, x560 = bits.Add32(x511, x542, uint32(uint1(x558))) + var x561 uint32 + _, x561 = bits.Mul32(x543, 0x12547e1b) + var x563 uint32 + var x564 uint32 + x564, x563 = bits.Mul32(x561, 0x10000000) + var x565 uint32 + var x566 uint32 + x566, x565 = bits.Mul32(x561, 0x14def9de) + var x567 uint32 + var x568 uint32 + x568, x567 = bits.Mul32(x561, 0xa2f79cd6) + var x569 uint32 + var x570 uint32 + x570, x569 = bits.Mul32(x561, 0x5812631a) + var x571 uint32 + var x572 uint32 + x572, x571 = bits.Mul32(x561, 0x5cf5d3ed) + var x573 uint32 + var x574 uint32 + x573, x574 = bits.Add32(x572, x569, uint32(0x0)) + var x575 uint32 + var x576 uint32 + x575, x576 = bits.Add32(x570, x567, uint32(uint1(x574))) + var x577 uint32 + var x578 uint32 + x577, x578 = bits.Add32(x568, x565, uint32(uint1(x576))) + x579 := (uint32(uint1(x578)) + x566) + var x581 uint32 + _, x581 = bits.Add32(x543, x571, uint32(0x0)) + var x582 uint32 + var x583 uint32 + x582, x583 = bits.Add32(x545, x573, uint32(uint1(x581))) + var x584 uint32 + var x585 uint32 + x584, x585 = bits.Add32(x547, x575, uint32(uint1(x583))) + var x586 uint32 + var x587 uint32 + x586, x587 = bits.Add32(x549, x577, uint32(uint1(x585))) + var x588 uint32 + var x589 uint32 + x588, x589 = bits.Add32(x551, x579, uint32(uint1(x587))) + var x590 uint32 + var x591 uint32 + x590, x591 = bits.Add32(x553, uint32(0x0), uint32(uint1(x589))) + var x592 uint32 + var x593 uint32 + x592, x593 = bits.Add32(x555, uint32(0x0), uint32(uint1(x591))) + var x594 uint32 + var x595 uint32 + x594, x595 = bits.Add32(x557, x563, uint32(uint1(x593))) + var x596 uint32 + var x597 uint32 + x596, x597 = bits.Add32(x559, x564, uint32(uint1(x595))) + x598 := (uint32(uint1(x597)) + uint32(uint1(x560))) + var x599 uint32 + var x600 uint32 + x600, x599 = bits.Mul32(x7, arg2[7]) + var x601 uint32 + var x602 uint32 + x602, x601 = bits.Mul32(x7, arg2[6]) + var x603 uint32 + var x604 uint32 + x604, x603 = bits.Mul32(x7, arg2[5]) + var x605 uint32 + var x606 uint32 + x606, x605 = bits.Mul32(x7, arg2[4]) + var x607 uint32 + var x608 uint32 + x608, x607 = bits.Mul32(x7, arg2[3]) + var x609 uint32 + var x610 uint32 + x610, x609 = bits.Mul32(x7, arg2[2]) + var x611 uint32 + var x612 uint32 + x612, x611 = bits.Mul32(x7, arg2[1]) + var x613 uint32 + var x614 uint32 + x614, x613 = bits.Mul32(x7, arg2[0]) + var x615 uint32 + var x616 uint32 + x615, x616 = bits.Add32(x614, x611, uint32(0x0)) + var x617 uint32 + var x618 uint32 + x617, x618 = bits.Add32(x612, x609, uint32(uint1(x616))) + var x619 uint32 + var x620 uint32 + x619, x620 = bits.Add32(x610, x607, uint32(uint1(x618))) + var x621 uint32 + var x622 uint32 + x621, x622 = bits.Add32(x608, x605, uint32(uint1(x620))) + var x623 uint32 + var x624 uint32 + x623, x624 = bits.Add32(x606, x603, uint32(uint1(x622))) + var x625 uint32 + var x626 uint32 + x625, x626 = bits.Add32(x604, x601, uint32(uint1(x624))) + var x627 uint32 + var x628 uint32 + x627, x628 = bits.Add32(x602, x599, uint32(uint1(x626))) + x629 := (uint32(uint1(x628)) + x600) + var x630 uint32 + var x631 uint32 + x630, x631 = bits.Add32(x582, x613, uint32(0x0)) + var x632 uint32 + var x633 uint32 + x632, x633 = bits.Add32(x584, x615, uint32(uint1(x631))) + var x634 uint32 + var x635 uint32 + x634, x635 = bits.Add32(x586, x617, uint32(uint1(x633))) + var x636 uint32 + var x637 uint32 + x636, x637 = bits.Add32(x588, x619, uint32(uint1(x635))) + var x638 uint32 + var x639 uint32 + x638, x639 = bits.Add32(x590, x621, uint32(uint1(x637))) + var x640 uint32 + var x641 uint32 + x640, x641 = bits.Add32(x592, x623, uint32(uint1(x639))) + var x642 uint32 + var x643 uint32 + x642, x643 = bits.Add32(x594, x625, uint32(uint1(x641))) + var x644 uint32 + var x645 uint32 + x644, x645 = bits.Add32(x596, x627, uint32(uint1(x643))) + var x646 uint32 + var x647 uint32 + x646, x647 = bits.Add32(x598, x629, uint32(uint1(x645))) + var x648 uint32 + _, x648 = bits.Mul32(x630, 0x12547e1b) + var x650 uint32 + var x651 uint32 + x651, x650 = bits.Mul32(x648, 0x10000000) + var x652 uint32 + var x653 uint32 + x653, x652 = bits.Mul32(x648, 0x14def9de) + var x654 uint32 + var x655 uint32 + x655, x654 = bits.Mul32(x648, 0xa2f79cd6) + var x656 uint32 + var x657 uint32 + x657, x656 = bits.Mul32(x648, 0x5812631a) + var x658 uint32 + var x659 uint32 + x659, x658 = bits.Mul32(x648, 0x5cf5d3ed) + var x660 uint32 + var x661 uint32 + x660, x661 = bits.Add32(x659, x656, uint32(0x0)) + var x662 uint32 + var x663 uint32 + x662, x663 = bits.Add32(x657, x654, uint32(uint1(x661))) + var x664 uint32 + var x665 uint32 + x664, x665 = bits.Add32(x655, x652, uint32(uint1(x663))) + x666 := (uint32(uint1(x665)) + x653) + var x668 uint32 + _, x668 = bits.Add32(x630, x658, uint32(0x0)) + var x669 uint32 + var x670 uint32 + x669, x670 = bits.Add32(x632, x660, uint32(uint1(x668))) + var x671 uint32 + var x672 uint32 + x671, x672 = bits.Add32(x634, x662, uint32(uint1(x670))) + var x673 uint32 + var x674 uint32 + x673, x674 = bits.Add32(x636, x664, uint32(uint1(x672))) + var x675 uint32 + var x676 uint32 + x675, x676 = bits.Add32(x638, x666, uint32(uint1(x674))) + var x677 uint32 + var x678 uint32 + x677, x678 = bits.Add32(x640, uint32(0x0), uint32(uint1(x676))) + var x679 uint32 + var x680 uint32 + x679, x680 = bits.Add32(x642, uint32(0x0), uint32(uint1(x678))) + var x681 uint32 + var x682 uint32 + x681, x682 = bits.Add32(x644, x650, uint32(uint1(x680))) + var x683 uint32 + var x684 uint32 + x683, x684 = bits.Add32(x646, x651, uint32(uint1(x682))) + x685 := (uint32(uint1(x684)) + uint32(uint1(x647))) + var x686 uint32 + var x687 uint32 + x686, x687 = bits.Sub32(x669, 0x5cf5d3ed, uint32(0x0)) + var x688 uint32 + var x689 uint32 + x688, x689 = bits.Sub32(x671, 0x5812631a, uint32(uint1(x687))) + var x690 uint32 + var x691 uint32 + x690, x691 = bits.Sub32(x673, 0xa2f79cd6, uint32(uint1(x689))) + var x692 uint32 + var x693 uint32 + x692, x693 = bits.Sub32(x675, 0x14def9de, uint32(uint1(x691))) + var x694 uint32 + var x695 uint32 + x694, x695 = bits.Sub32(x677, uint32(0x0), uint32(uint1(x693))) + var x696 uint32 + var x697 uint32 + x696, x697 = bits.Sub32(x679, uint32(0x0), uint32(uint1(x695))) + var x698 uint32 + var x699 uint32 + x698, x699 = bits.Sub32(x681, uint32(0x0), uint32(uint1(x697))) + var x700 uint32 + var x701 uint32 + x700, x701 = bits.Sub32(x683, 0x10000000, uint32(uint1(x699))) + var x703 uint32 + _, x703 = bits.Sub32(x685, uint32(0x0), uint32(uint1(x701))) + var x704 uint32 + cmovznzU32(&x704, uint1(x703), x686, x669) + var x705 uint32 + cmovznzU32(&x705, uint1(x703), x688, x671) + var x706 uint32 + cmovznzU32(&x706, uint1(x703), x690, x673) + var x707 uint32 + cmovznzU32(&x707, uint1(x703), x692, x675) + var x708 uint32 + cmovznzU32(&x708, uint1(x703), x694, x677) + var x709 uint32 + cmovznzU32(&x709, uint1(x703), x696, x679) + var x710 uint32 + cmovznzU32(&x710, uint1(x703), x698, x681) + var x711 uint32 + cmovznzU32(&x711, uint1(x703), x700, x683) + out1[0] = x704 + out1[1] = x705 + out1[2] = x706 + out1[3] = x707 + out1[4] = x708 + out1[5] = x709 + out1[6] = x710 + out1[7] = x711 +} + +// Square squares a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +// 0 ≤ eval out1 < m +// +func Square(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[6] + x7 := arg1[7] + x8 := arg1[0] + var x9 uint32 + var x10 uint32 + x10, x9 = bits.Mul32(x8, arg1[7]) + var x11 uint32 + var x12 uint32 + x12, x11 = bits.Mul32(x8, arg1[6]) + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x8, arg1[5]) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x8, arg1[4]) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x8, arg1[3]) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x8, arg1[2]) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x8, arg1[1]) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x8, arg1[0]) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Add32(x24, x21, uint32(0x0)) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Add32(x22, x19, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Add32(x20, x17, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Add32(x18, x15, uint32(uint1(x30))) + var x33 uint32 + var x34 uint32 + x33, x34 = bits.Add32(x16, x13, uint32(uint1(x32))) + var x35 uint32 + var x36 uint32 + x35, x36 = bits.Add32(x14, x11, uint32(uint1(x34))) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Add32(x12, x9, uint32(uint1(x36))) + x39 := (uint32(uint1(x38)) + x10) + var x40 uint32 + _, x40 = bits.Mul32(x23, 0x12547e1b) + var x42 uint32 + var x43 uint32 + x43, x42 = bits.Mul32(x40, 0x10000000) + var x44 uint32 + var x45 uint32 + x45, x44 = bits.Mul32(x40, 0x14def9de) + var x46 uint32 + var x47 uint32 + x47, x46 = bits.Mul32(x40, 0xa2f79cd6) + var x48 uint32 + var x49 uint32 + x49, x48 = bits.Mul32(x40, 0x5812631a) + var x50 uint32 + var x51 uint32 + x51, x50 = bits.Mul32(x40, 0x5cf5d3ed) + var x52 uint32 + var x53 uint32 + x52, x53 = bits.Add32(x51, x48, uint32(0x0)) + var x54 uint32 + var x55 uint32 + x54, x55 = bits.Add32(x49, x46, uint32(uint1(x53))) + var x56 uint32 + var x57 uint32 + x56, x57 = bits.Add32(x47, x44, uint32(uint1(x55))) + x58 := (uint32(uint1(x57)) + x45) + var x60 uint32 + _, x60 = bits.Add32(x23, x50, uint32(0x0)) + var x61 uint32 + var x62 uint32 + x61, x62 = bits.Add32(x25, x52, uint32(uint1(x60))) + var x63 uint32 + var x64 uint32 + x63, x64 = bits.Add32(x27, x54, uint32(uint1(x62))) + var x65 uint32 + var x66 uint32 + x65, x66 = bits.Add32(x29, x56, uint32(uint1(x64))) + var x67 uint32 + var x68 uint32 + x67, x68 = bits.Add32(x31, x58, uint32(uint1(x66))) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Add32(x33, uint32(0x0), uint32(uint1(x68))) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Add32(x35, uint32(0x0), uint32(uint1(x70))) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Add32(x37, x42, uint32(uint1(x72))) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Add32(x39, x43, uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x78, x77 = bits.Mul32(x1, arg1[7]) + var x79 uint32 + var x80 uint32 + x80, x79 = bits.Mul32(x1, arg1[6]) + var x81 uint32 + var x82 uint32 + x82, x81 = bits.Mul32(x1, arg1[5]) + var x83 uint32 + var x84 uint32 + x84, x83 = bits.Mul32(x1, arg1[4]) + var x85 uint32 + var x86 uint32 + x86, x85 = bits.Mul32(x1, arg1[3]) + var x87 uint32 + var x88 uint32 + x88, x87 = bits.Mul32(x1, arg1[2]) + var x89 uint32 + var x90 uint32 + x90, x89 = bits.Mul32(x1, arg1[1]) + var x91 uint32 + var x92 uint32 + x92, x91 = bits.Mul32(x1, arg1[0]) + var x93 uint32 + var x94 uint32 + x93, x94 = bits.Add32(x92, x89, uint32(0x0)) + var x95 uint32 + var x96 uint32 + x95, x96 = bits.Add32(x90, x87, uint32(uint1(x94))) + var x97 uint32 + var x98 uint32 + x97, x98 = bits.Add32(x88, x85, uint32(uint1(x96))) + var x99 uint32 + var x100 uint32 + x99, x100 = bits.Add32(x86, x83, uint32(uint1(x98))) + var x101 uint32 + var x102 uint32 + x101, x102 = bits.Add32(x84, x81, uint32(uint1(x100))) + var x103 uint32 + var x104 uint32 + x103, x104 = bits.Add32(x82, x79, uint32(uint1(x102))) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Add32(x80, x77, uint32(uint1(x104))) + x107 := (uint32(uint1(x106)) + x78) + var x108 uint32 + var x109 uint32 + x108, x109 = bits.Add32(x61, x91, uint32(0x0)) + var x110 uint32 + var x111 uint32 + x110, x111 = bits.Add32(x63, x93, uint32(uint1(x109))) + var x112 uint32 + var x113 uint32 + x112, x113 = bits.Add32(x65, x95, uint32(uint1(x111))) + var x114 uint32 + var x115 uint32 + x114, x115 = bits.Add32(x67, x97, uint32(uint1(x113))) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32(x69, x99, uint32(uint1(x115))) + var x118 uint32 + var x119 uint32 + x118, x119 = bits.Add32(x71, x101, uint32(uint1(x117))) + var x120 uint32 + var x121 uint32 + x120, x121 = bits.Add32(x73, x103, uint32(uint1(x119))) + var x122 uint32 + var x123 uint32 + x122, x123 = bits.Add32(x75, x105, uint32(uint1(x121))) + var x124 uint32 + var x125 uint32 + x124, x125 = bits.Add32(uint32(uint1(x76)), x107, uint32(uint1(x123))) + var x126 uint32 + _, x126 = bits.Mul32(x108, 0x12547e1b) + var x128 uint32 + var x129 uint32 + x129, x128 = bits.Mul32(x126, 0x10000000) + var x130 uint32 + var x131 uint32 + x131, x130 = bits.Mul32(x126, 0x14def9de) + var x132 uint32 + var x133 uint32 + x133, x132 = bits.Mul32(x126, 0xa2f79cd6) + var x134 uint32 + var x135 uint32 + x135, x134 = bits.Mul32(x126, 0x5812631a) + var x136 uint32 + var x137 uint32 + x137, x136 = bits.Mul32(x126, 0x5cf5d3ed) + var x138 uint32 + var x139 uint32 + x138, x139 = bits.Add32(x137, x134, uint32(0x0)) + var x140 uint32 + var x141 uint32 + x140, x141 = bits.Add32(x135, x132, uint32(uint1(x139))) + var x142 uint32 + var x143 uint32 + x142, x143 = bits.Add32(x133, x130, uint32(uint1(x141))) + x144 := (uint32(uint1(x143)) + x131) + var x146 uint32 + _, x146 = bits.Add32(x108, x136, uint32(0x0)) + var x147 uint32 + var x148 uint32 + x147, x148 = bits.Add32(x110, x138, uint32(uint1(x146))) + var x149 uint32 + var x150 uint32 + x149, x150 = bits.Add32(x112, x140, uint32(uint1(x148))) + var x151 uint32 + var x152 uint32 + x151, x152 = bits.Add32(x114, x142, uint32(uint1(x150))) + var x153 uint32 + var x154 uint32 + x153, x154 = bits.Add32(x116, x144, uint32(uint1(x152))) + var x155 uint32 + var x156 uint32 + x155, x156 = bits.Add32(x118, uint32(0x0), uint32(uint1(x154))) + var x157 uint32 + var x158 uint32 + x157, x158 = bits.Add32(x120, uint32(0x0), uint32(uint1(x156))) + var x159 uint32 + var x160 uint32 + x159, x160 = bits.Add32(x122, x128, uint32(uint1(x158))) + var x161 uint32 + var x162 uint32 + x161, x162 = bits.Add32(x124, x129, uint32(uint1(x160))) + x163 := (uint32(uint1(x162)) + uint32(uint1(x125))) + var x164 uint32 + var x165 uint32 + x165, x164 = bits.Mul32(x2, arg1[7]) + var x166 uint32 + var x167 uint32 + x167, x166 = bits.Mul32(x2, arg1[6]) + var x168 uint32 + var x169 uint32 + x169, x168 = bits.Mul32(x2, arg1[5]) + var x170 uint32 + var x171 uint32 + x171, x170 = bits.Mul32(x2, arg1[4]) + var x172 uint32 + var x173 uint32 + x173, x172 = bits.Mul32(x2, arg1[3]) + var x174 uint32 + var x175 uint32 + x175, x174 = bits.Mul32(x2, arg1[2]) + var x176 uint32 + var x177 uint32 + x177, x176 = bits.Mul32(x2, arg1[1]) + var x178 uint32 + var x179 uint32 + x179, x178 = bits.Mul32(x2, arg1[0]) + var x180 uint32 + var x181 uint32 + x180, x181 = bits.Add32(x179, x176, uint32(0x0)) + var x182 uint32 + var x183 uint32 + x182, x183 = bits.Add32(x177, x174, uint32(uint1(x181))) + var x184 uint32 + var x185 uint32 + x184, x185 = bits.Add32(x175, x172, uint32(uint1(x183))) + var x186 uint32 + var x187 uint32 + x186, x187 = bits.Add32(x173, x170, uint32(uint1(x185))) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Add32(x171, x168, uint32(uint1(x187))) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Add32(x169, x166, uint32(uint1(x189))) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Add32(x167, x164, uint32(uint1(x191))) + x194 := (uint32(uint1(x193)) + x165) + var x195 uint32 + var x196 uint32 + x195, x196 = bits.Add32(x147, x178, uint32(0x0)) + var x197 uint32 + var x198 uint32 + x197, x198 = bits.Add32(x149, x180, uint32(uint1(x196))) + var x199 uint32 + var x200 uint32 + x199, x200 = bits.Add32(x151, x182, uint32(uint1(x198))) + var x201 uint32 + var x202 uint32 + x201, x202 = bits.Add32(x153, x184, uint32(uint1(x200))) + var x203 uint32 + var x204 uint32 + x203, x204 = bits.Add32(x155, x186, uint32(uint1(x202))) + var x205 uint32 + var x206 uint32 + x205, x206 = bits.Add32(x157, x188, uint32(uint1(x204))) + var x207 uint32 + var x208 uint32 + x207, x208 = bits.Add32(x159, x190, uint32(uint1(x206))) + var x209 uint32 + var x210 uint32 + x209, x210 = bits.Add32(x161, x192, uint32(uint1(x208))) + var x211 uint32 + var x212 uint32 + x211, x212 = bits.Add32(x163, x194, uint32(uint1(x210))) + var x213 uint32 + _, x213 = bits.Mul32(x195, 0x12547e1b) + var x215 uint32 + var x216 uint32 + x216, x215 = bits.Mul32(x213, 0x10000000) + var x217 uint32 + var x218 uint32 + x218, x217 = bits.Mul32(x213, 0x14def9de) + var x219 uint32 + var x220 uint32 + x220, x219 = bits.Mul32(x213, 0xa2f79cd6) + var x221 uint32 + var x222 uint32 + x222, x221 = bits.Mul32(x213, 0x5812631a) + var x223 uint32 + var x224 uint32 + x224, x223 = bits.Mul32(x213, 0x5cf5d3ed) + var x225 uint32 + var x226 uint32 + x225, x226 = bits.Add32(x224, x221, uint32(0x0)) + var x227 uint32 + var x228 uint32 + x227, x228 = bits.Add32(x222, x219, uint32(uint1(x226))) + var x229 uint32 + var x230 uint32 + x229, x230 = bits.Add32(x220, x217, uint32(uint1(x228))) + x231 := (uint32(uint1(x230)) + x218) + var x233 uint32 + _, x233 = bits.Add32(x195, x223, uint32(0x0)) + var x234 uint32 + var x235 uint32 + x234, x235 = bits.Add32(x197, x225, uint32(uint1(x233))) + var x236 uint32 + var x237 uint32 + x236, x237 = bits.Add32(x199, x227, uint32(uint1(x235))) + var x238 uint32 + var x239 uint32 + x238, x239 = bits.Add32(x201, x229, uint32(uint1(x237))) + var x240 uint32 + var x241 uint32 + x240, x241 = bits.Add32(x203, x231, uint32(uint1(x239))) + var x242 uint32 + var x243 uint32 + x242, x243 = bits.Add32(x205, uint32(0x0), uint32(uint1(x241))) + var x244 uint32 + var x245 uint32 + x244, x245 = bits.Add32(x207, uint32(0x0), uint32(uint1(x243))) + var x246 uint32 + var x247 uint32 + x246, x247 = bits.Add32(x209, x215, uint32(uint1(x245))) + var x248 uint32 + var x249 uint32 + x248, x249 = bits.Add32(x211, x216, uint32(uint1(x247))) + x250 := (uint32(uint1(x249)) + uint32(uint1(x212))) + var x251 uint32 + var x252 uint32 + x252, x251 = bits.Mul32(x3, arg1[7]) + var x253 uint32 + var x254 uint32 + x254, x253 = bits.Mul32(x3, arg1[6]) + var x255 uint32 + var x256 uint32 + x256, x255 = bits.Mul32(x3, arg1[5]) + var x257 uint32 + var x258 uint32 + x258, x257 = bits.Mul32(x3, arg1[4]) + var x259 uint32 + var x260 uint32 + x260, x259 = bits.Mul32(x3, arg1[3]) + var x261 uint32 + var x262 uint32 + x262, x261 = bits.Mul32(x3, arg1[2]) + var x263 uint32 + var x264 uint32 + x264, x263 = bits.Mul32(x3, arg1[1]) + var x265 uint32 + var x266 uint32 + x266, x265 = bits.Mul32(x3, arg1[0]) + var x267 uint32 + var x268 uint32 + x267, x268 = bits.Add32(x266, x263, uint32(0x0)) + var x269 uint32 + var x270 uint32 + x269, x270 = bits.Add32(x264, x261, uint32(uint1(x268))) + var x271 uint32 + var x272 uint32 + x271, x272 = bits.Add32(x262, x259, uint32(uint1(x270))) + var x273 uint32 + var x274 uint32 + x273, x274 = bits.Add32(x260, x257, uint32(uint1(x272))) + var x275 uint32 + var x276 uint32 + x275, x276 = bits.Add32(x258, x255, uint32(uint1(x274))) + var x277 uint32 + var x278 uint32 + x277, x278 = bits.Add32(x256, x253, uint32(uint1(x276))) + var x279 uint32 + var x280 uint32 + x279, x280 = bits.Add32(x254, x251, uint32(uint1(x278))) + x281 := (uint32(uint1(x280)) + x252) + var x282 uint32 + var x283 uint32 + x282, x283 = bits.Add32(x234, x265, uint32(0x0)) + var x284 uint32 + var x285 uint32 + x284, x285 = bits.Add32(x236, x267, uint32(uint1(x283))) + var x286 uint32 + var x287 uint32 + x286, x287 = bits.Add32(x238, x269, uint32(uint1(x285))) + var x288 uint32 + var x289 uint32 + x288, x289 = bits.Add32(x240, x271, uint32(uint1(x287))) + var x290 uint32 + var x291 uint32 + x290, x291 = bits.Add32(x242, x273, uint32(uint1(x289))) + var x292 uint32 + var x293 uint32 + x292, x293 = bits.Add32(x244, x275, uint32(uint1(x291))) + var x294 uint32 + var x295 uint32 + x294, x295 = bits.Add32(x246, x277, uint32(uint1(x293))) + var x296 uint32 + var x297 uint32 + x296, x297 = bits.Add32(x248, x279, uint32(uint1(x295))) + var x298 uint32 + var x299 uint32 + x298, x299 = bits.Add32(x250, x281, uint32(uint1(x297))) + var x300 uint32 + _, x300 = bits.Mul32(x282, 0x12547e1b) + var x302 uint32 + var x303 uint32 + x303, x302 = bits.Mul32(x300, 0x10000000) + var x304 uint32 + var x305 uint32 + x305, x304 = bits.Mul32(x300, 0x14def9de) + var x306 uint32 + var x307 uint32 + x307, x306 = bits.Mul32(x300, 0xa2f79cd6) + var x308 uint32 + var x309 uint32 + x309, x308 = bits.Mul32(x300, 0x5812631a) + var x310 uint32 + var x311 uint32 + x311, x310 = bits.Mul32(x300, 0x5cf5d3ed) + var x312 uint32 + var x313 uint32 + x312, x313 = bits.Add32(x311, x308, uint32(0x0)) + var x314 uint32 + var x315 uint32 + x314, x315 = bits.Add32(x309, x306, uint32(uint1(x313))) + var x316 uint32 + var x317 uint32 + x316, x317 = bits.Add32(x307, x304, uint32(uint1(x315))) + x318 := (uint32(uint1(x317)) + x305) + var x320 uint32 + _, x320 = bits.Add32(x282, x310, uint32(0x0)) + var x321 uint32 + var x322 uint32 + x321, x322 = bits.Add32(x284, x312, uint32(uint1(x320))) + var x323 uint32 + var x324 uint32 + x323, x324 = bits.Add32(x286, x314, uint32(uint1(x322))) + var x325 uint32 + var x326 uint32 + x325, x326 = bits.Add32(x288, x316, uint32(uint1(x324))) + var x327 uint32 + var x328 uint32 + x327, x328 = bits.Add32(x290, x318, uint32(uint1(x326))) + var x329 uint32 + var x330 uint32 + x329, x330 = bits.Add32(x292, uint32(0x0), uint32(uint1(x328))) + var x331 uint32 + var x332 uint32 + x331, x332 = bits.Add32(x294, uint32(0x0), uint32(uint1(x330))) + var x333 uint32 + var x334 uint32 + x333, x334 = bits.Add32(x296, x302, uint32(uint1(x332))) + var x335 uint32 + var x336 uint32 + x335, x336 = bits.Add32(x298, x303, uint32(uint1(x334))) + x337 := (uint32(uint1(x336)) + uint32(uint1(x299))) + var x338 uint32 + var x339 uint32 + x339, x338 = bits.Mul32(x4, arg1[7]) + var x340 uint32 + var x341 uint32 + x341, x340 = bits.Mul32(x4, arg1[6]) + var x342 uint32 + var x343 uint32 + x343, x342 = bits.Mul32(x4, arg1[5]) + var x344 uint32 + var x345 uint32 + x345, x344 = bits.Mul32(x4, arg1[4]) + var x346 uint32 + var x347 uint32 + x347, x346 = bits.Mul32(x4, arg1[3]) + var x348 uint32 + var x349 uint32 + x349, x348 = bits.Mul32(x4, arg1[2]) + var x350 uint32 + var x351 uint32 + x351, x350 = bits.Mul32(x4, arg1[1]) + var x352 uint32 + var x353 uint32 + x353, x352 = bits.Mul32(x4, arg1[0]) + var x354 uint32 + var x355 uint32 + x354, x355 = bits.Add32(x353, x350, uint32(0x0)) + var x356 uint32 + var x357 uint32 + x356, x357 = bits.Add32(x351, x348, uint32(uint1(x355))) + var x358 uint32 + var x359 uint32 + x358, x359 = bits.Add32(x349, x346, uint32(uint1(x357))) + var x360 uint32 + var x361 uint32 + x360, x361 = bits.Add32(x347, x344, uint32(uint1(x359))) + var x362 uint32 + var x363 uint32 + x362, x363 = bits.Add32(x345, x342, uint32(uint1(x361))) + var x364 uint32 + var x365 uint32 + x364, x365 = bits.Add32(x343, x340, uint32(uint1(x363))) + var x366 uint32 + var x367 uint32 + x366, x367 = bits.Add32(x341, x338, uint32(uint1(x365))) + x368 := (uint32(uint1(x367)) + x339) + var x369 uint32 + var x370 uint32 + x369, x370 = bits.Add32(x321, x352, uint32(0x0)) + var x371 uint32 + var x372 uint32 + x371, x372 = bits.Add32(x323, x354, uint32(uint1(x370))) + var x373 uint32 + var x374 uint32 + x373, x374 = bits.Add32(x325, x356, uint32(uint1(x372))) + var x375 uint32 + var x376 uint32 + x375, x376 = bits.Add32(x327, x358, uint32(uint1(x374))) + var x377 uint32 + var x378 uint32 + x377, x378 = bits.Add32(x329, x360, uint32(uint1(x376))) + var x379 uint32 + var x380 uint32 + x379, x380 = bits.Add32(x331, x362, uint32(uint1(x378))) + var x381 uint32 + var x382 uint32 + x381, x382 = bits.Add32(x333, x364, uint32(uint1(x380))) + var x383 uint32 + var x384 uint32 + x383, x384 = bits.Add32(x335, x366, uint32(uint1(x382))) + var x385 uint32 + var x386 uint32 + x385, x386 = bits.Add32(x337, x368, uint32(uint1(x384))) + var x387 uint32 + _, x387 = bits.Mul32(x369, 0x12547e1b) + var x389 uint32 + var x390 uint32 + x390, x389 = bits.Mul32(x387, 0x10000000) + var x391 uint32 + var x392 uint32 + x392, x391 = bits.Mul32(x387, 0x14def9de) + var x393 uint32 + var x394 uint32 + x394, x393 = bits.Mul32(x387, 0xa2f79cd6) + var x395 uint32 + var x396 uint32 + x396, x395 = bits.Mul32(x387, 0x5812631a) + var x397 uint32 + var x398 uint32 + x398, x397 = bits.Mul32(x387, 0x5cf5d3ed) + var x399 uint32 + var x400 uint32 + x399, x400 = bits.Add32(x398, x395, uint32(0x0)) + var x401 uint32 + var x402 uint32 + x401, x402 = bits.Add32(x396, x393, uint32(uint1(x400))) + var x403 uint32 + var x404 uint32 + x403, x404 = bits.Add32(x394, x391, uint32(uint1(x402))) + x405 := (uint32(uint1(x404)) + x392) + var x407 uint32 + _, x407 = bits.Add32(x369, x397, uint32(0x0)) + var x408 uint32 + var x409 uint32 + x408, x409 = bits.Add32(x371, x399, uint32(uint1(x407))) + var x410 uint32 + var x411 uint32 + x410, x411 = bits.Add32(x373, x401, uint32(uint1(x409))) + var x412 uint32 + var x413 uint32 + x412, x413 = bits.Add32(x375, x403, uint32(uint1(x411))) + var x414 uint32 + var x415 uint32 + x414, x415 = bits.Add32(x377, x405, uint32(uint1(x413))) + var x416 uint32 + var x417 uint32 + x416, x417 = bits.Add32(x379, uint32(0x0), uint32(uint1(x415))) + var x418 uint32 + var x419 uint32 + x418, x419 = bits.Add32(x381, uint32(0x0), uint32(uint1(x417))) + var x420 uint32 + var x421 uint32 + x420, x421 = bits.Add32(x383, x389, uint32(uint1(x419))) + var x422 uint32 + var x423 uint32 + x422, x423 = bits.Add32(x385, x390, uint32(uint1(x421))) + x424 := (uint32(uint1(x423)) + uint32(uint1(x386))) + var x425 uint32 + var x426 uint32 + x426, x425 = bits.Mul32(x5, arg1[7]) + var x427 uint32 + var x428 uint32 + x428, x427 = bits.Mul32(x5, arg1[6]) + var x429 uint32 + var x430 uint32 + x430, x429 = bits.Mul32(x5, arg1[5]) + var x431 uint32 + var x432 uint32 + x432, x431 = bits.Mul32(x5, arg1[4]) + var x433 uint32 + var x434 uint32 + x434, x433 = bits.Mul32(x5, arg1[3]) + var x435 uint32 + var x436 uint32 + x436, x435 = bits.Mul32(x5, arg1[2]) + var x437 uint32 + var x438 uint32 + x438, x437 = bits.Mul32(x5, arg1[1]) + var x439 uint32 + var x440 uint32 + x440, x439 = bits.Mul32(x5, arg1[0]) + var x441 uint32 + var x442 uint32 + x441, x442 = bits.Add32(x440, x437, uint32(0x0)) + var x443 uint32 + var x444 uint32 + x443, x444 = bits.Add32(x438, x435, uint32(uint1(x442))) + var x445 uint32 + var x446 uint32 + x445, x446 = bits.Add32(x436, x433, uint32(uint1(x444))) + var x447 uint32 + var x448 uint32 + x447, x448 = bits.Add32(x434, x431, uint32(uint1(x446))) + var x449 uint32 + var x450 uint32 + x449, x450 = bits.Add32(x432, x429, uint32(uint1(x448))) + var x451 uint32 + var x452 uint32 + x451, x452 = bits.Add32(x430, x427, uint32(uint1(x450))) + var x453 uint32 + var x454 uint32 + x453, x454 = bits.Add32(x428, x425, uint32(uint1(x452))) + x455 := (uint32(uint1(x454)) + x426) + var x456 uint32 + var x457 uint32 + x456, x457 = bits.Add32(x408, x439, uint32(0x0)) + var x458 uint32 + var x459 uint32 + x458, x459 = bits.Add32(x410, x441, uint32(uint1(x457))) + var x460 uint32 + var x461 uint32 + x460, x461 = bits.Add32(x412, x443, uint32(uint1(x459))) + var x462 uint32 + var x463 uint32 + x462, x463 = bits.Add32(x414, x445, uint32(uint1(x461))) + var x464 uint32 + var x465 uint32 + x464, x465 = bits.Add32(x416, x447, uint32(uint1(x463))) + var x466 uint32 + var x467 uint32 + x466, x467 = bits.Add32(x418, x449, uint32(uint1(x465))) + var x468 uint32 + var x469 uint32 + x468, x469 = bits.Add32(x420, x451, uint32(uint1(x467))) + var x470 uint32 + var x471 uint32 + x470, x471 = bits.Add32(x422, x453, uint32(uint1(x469))) + var x472 uint32 + var x473 uint32 + x472, x473 = bits.Add32(x424, x455, uint32(uint1(x471))) + var x474 uint32 + _, x474 = bits.Mul32(x456, 0x12547e1b) + var x476 uint32 + var x477 uint32 + x477, x476 = bits.Mul32(x474, 0x10000000) + var x478 uint32 + var x479 uint32 + x479, x478 = bits.Mul32(x474, 0x14def9de) + var x480 uint32 + var x481 uint32 + x481, x480 = bits.Mul32(x474, 0xa2f79cd6) + var x482 uint32 + var x483 uint32 + x483, x482 = bits.Mul32(x474, 0x5812631a) + var x484 uint32 + var x485 uint32 + x485, x484 = bits.Mul32(x474, 0x5cf5d3ed) + var x486 uint32 + var x487 uint32 + x486, x487 = bits.Add32(x485, x482, uint32(0x0)) + var x488 uint32 + var x489 uint32 + x488, x489 = bits.Add32(x483, x480, uint32(uint1(x487))) + var x490 uint32 + var x491 uint32 + x490, x491 = bits.Add32(x481, x478, uint32(uint1(x489))) + x492 := (uint32(uint1(x491)) + x479) + var x494 uint32 + _, x494 = bits.Add32(x456, x484, uint32(0x0)) + var x495 uint32 + var x496 uint32 + x495, x496 = bits.Add32(x458, x486, uint32(uint1(x494))) + var x497 uint32 + var x498 uint32 + x497, x498 = bits.Add32(x460, x488, uint32(uint1(x496))) + var x499 uint32 + var x500 uint32 + x499, x500 = bits.Add32(x462, x490, uint32(uint1(x498))) + var x501 uint32 + var x502 uint32 + x501, x502 = bits.Add32(x464, x492, uint32(uint1(x500))) + var x503 uint32 + var x504 uint32 + x503, x504 = bits.Add32(x466, uint32(0x0), uint32(uint1(x502))) + var x505 uint32 + var x506 uint32 + x505, x506 = bits.Add32(x468, uint32(0x0), uint32(uint1(x504))) + var x507 uint32 + var x508 uint32 + x507, x508 = bits.Add32(x470, x476, uint32(uint1(x506))) + var x509 uint32 + var x510 uint32 + x509, x510 = bits.Add32(x472, x477, uint32(uint1(x508))) + x511 := (uint32(uint1(x510)) + uint32(uint1(x473))) + var x512 uint32 + var x513 uint32 + x513, x512 = bits.Mul32(x6, arg1[7]) + var x514 uint32 + var x515 uint32 + x515, x514 = bits.Mul32(x6, arg1[6]) + var x516 uint32 + var x517 uint32 + x517, x516 = bits.Mul32(x6, arg1[5]) + var x518 uint32 + var x519 uint32 + x519, x518 = bits.Mul32(x6, arg1[4]) + var x520 uint32 + var x521 uint32 + x521, x520 = bits.Mul32(x6, arg1[3]) + var x522 uint32 + var x523 uint32 + x523, x522 = bits.Mul32(x6, arg1[2]) + var x524 uint32 + var x525 uint32 + x525, x524 = bits.Mul32(x6, arg1[1]) + var x526 uint32 + var x527 uint32 + x527, x526 = bits.Mul32(x6, arg1[0]) + var x528 uint32 + var x529 uint32 + x528, x529 = bits.Add32(x527, x524, uint32(0x0)) + var x530 uint32 + var x531 uint32 + x530, x531 = bits.Add32(x525, x522, uint32(uint1(x529))) + var x532 uint32 + var x533 uint32 + x532, x533 = bits.Add32(x523, x520, uint32(uint1(x531))) + var x534 uint32 + var x535 uint32 + x534, x535 = bits.Add32(x521, x518, uint32(uint1(x533))) + var x536 uint32 + var x537 uint32 + x536, x537 = bits.Add32(x519, x516, uint32(uint1(x535))) + var x538 uint32 + var x539 uint32 + x538, x539 = bits.Add32(x517, x514, uint32(uint1(x537))) + var x540 uint32 + var x541 uint32 + x540, x541 = bits.Add32(x515, x512, uint32(uint1(x539))) + x542 := (uint32(uint1(x541)) + x513) + var x543 uint32 + var x544 uint32 + x543, x544 = bits.Add32(x495, x526, uint32(0x0)) + var x545 uint32 + var x546 uint32 + x545, x546 = bits.Add32(x497, x528, uint32(uint1(x544))) + var x547 uint32 + var x548 uint32 + x547, x548 = bits.Add32(x499, x530, uint32(uint1(x546))) + var x549 uint32 + var x550 uint32 + x549, x550 = bits.Add32(x501, x532, uint32(uint1(x548))) + var x551 uint32 + var x552 uint32 + x551, x552 = bits.Add32(x503, x534, uint32(uint1(x550))) + var x553 uint32 + var x554 uint32 + x553, x554 = bits.Add32(x505, x536, uint32(uint1(x552))) + var x555 uint32 + var x556 uint32 + x555, x556 = bits.Add32(x507, x538, uint32(uint1(x554))) + var x557 uint32 + var x558 uint32 + x557, x558 = bits.Add32(x509, x540, uint32(uint1(x556))) + var x559 uint32 + var x560 uint32 + x559, x560 = bits.Add32(x511, x542, uint32(uint1(x558))) + var x561 uint32 + _, x561 = bits.Mul32(x543, 0x12547e1b) + var x563 uint32 + var x564 uint32 + x564, x563 = bits.Mul32(x561, 0x10000000) + var x565 uint32 + var x566 uint32 + x566, x565 = bits.Mul32(x561, 0x14def9de) + var x567 uint32 + var x568 uint32 + x568, x567 = bits.Mul32(x561, 0xa2f79cd6) + var x569 uint32 + var x570 uint32 + x570, x569 = bits.Mul32(x561, 0x5812631a) + var x571 uint32 + var x572 uint32 + x572, x571 = bits.Mul32(x561, 0x5cf5d3ed) + var x573 uint32 + var x574 uint32 + x573, x574 = bits.Add32(x572, x569, uint32(0x0)) + var x575 uint32 + var x576 uint32 + x575, x576 = bits.Add32(x570, x567, uint32(uint1(x574))) + var x577 uint32 + var x578 uint32 + x577, x578 = bits.Add32(x568, x565, uint32(uint1(x576))) + x579 := (uint32(uint1(x578)) + x566) + var x581 uint32 + _, x581 = bits.Add32(x543, x571, uint32(0x0)) + var x582 uint32 + var x583 uint32 + x582, x583 = bits.Add32(x545, x573, uint32(uint1(x581))) + var x584 uint32 + var x585 uint32 + x584, x585 = bits.Add32(x547, x575, uint32(uint1(x583))) + var x586 uint32 + var x587 uint32 + x586, x587 = bits.Add32(x549, x577, uint32(uint1(x585))) + var x588 uint32 + var x589 uint32 + x588, x589 = bits.Add32(x551, x579, uint32(uint1(x587))) + var x590 uint32 + var x591 uint32 + x590, x591 = bits.Add32(x553, uint32(0x0), uint32(uint1(x589))) + var x592 uint32 + var x593 uint32 + x592, x593 = bits.Add32(x555, uint32(0x0), uint32(uint1(x591))) + var x594 uint32 + var x595 uint32 + x594, x595 = bits.Add32(x557, x563, uint32(uint1(x593))) + var x596 uint32 + var x597 uint32 + x596, x597 = bits.Add32(x559, x564, uint32(uint1(x595))) + x598 := (uint32(uint1(x597)) + uint32(uint1(x560))) + var x599 uint32 + var x600 uint32 + x600, x599 = bits.Mul32(x7, arg1[7]) + var x601 uint32 + var x602 uint32 + x602, x601 = bits.Mul32(x7, arg1[6]) + var x603 uint32 + var x604 uint32 + x604, x603 = bits.Mul32(x7, arg1[5]) + var x605 uint32 + var x606 uint32 + x606, x605 = bits.Mul32(x7, arg1[4]) + var x607 uint32 + var x608 uint32 + x608, x607 = bits.Mul32(x7, arg1[3]) + var x609 uint32 + var x610 uint32 + x610, x609 = bits.Mul32(x7, arg1[2]) + var x611 uint32 + var x612 uint32 + x612, x611 = bits.Mul32(x7, arg1[1]) + var x613 uint32 + var x614 uint32 + x614, x613 = bits.Mul32(x7, arg1[0]) + var x615 uint32 + var x616 uint32 + x615, x616 = bits.Add32(x614, x611, uint32(0x0)) + var x617 uint32 + var x618 uint32 + x617, x618 = bits.Add32(x612, x609, uint32(uint1(x616))) + var x619 uint32 + var x620 uint32 + x619, x620 = bits.Add32(x610, x607, uint32(uint1(x618))) + var x621 uint32 + var x622 uint32 + x621, x622 = bits.Add32(x608, x605, uint32(uint1(x620))) + var x623 uint32 + var x624 uint32 + x623, x624 = bits.Add32(x606, x603, uint32(uint1(x622))) + var x625 uint32 + var x626 uint32 + x625, x626 = bits.Add32(x604, x601, uint32(uint1(x624))) + var x627 uint32 + var x628 uint32 + x627, x628 = bits.Add32(x602, x599, uint32(uint1(x626))) + x629 := (uint32(uint1(x628)) + x600) + var x630 uint32 + var x631 uint32 + x630, x631 = bits.Add32(x582, x613, uint32(0x0)) + var x632 uint32 + var x633 uint32 + x632, x633 = bits.Add32(x584, x615, uint32(uint1(x631))) + var x634 uint32 + var x635 uint32 + x634, x635 = bits.Add32(x586, x617, uint32(uint1(x633))) + var x636 uint32 + var x637 uint32 + x636, x637 = bits.Add32(x588, x619, uint32(uint1(x635))) + var x638 uint32 + var x639 uint32 + x638, x639 = bits.Add32(x590, x621, uint32(uint1(x637))) + var x640 uint32 + var x641 uint32 + x640, x641 = bits.Add32(x592, x623, uint32(uint1(x639))) + var x642 uint32 + var x643 uint32 + x642, x643 = bits.Add32(x594, x625, uint32(uint1(x641))) + var x644 uint32 + var x645 uint32 + x644, x645 = bits.Add32(x596, x627, uint32(uint1(x643))) + var x646 uint32 + var x647 uint32 + x646, x647 = bits.Add32(x598, x629, uint32(uint1(x645))) + var x648 uint32 + _, x648 = bits.Mul32(x630, 0x12547e1b) + var x650 uint32 + var x651 uint32 + x651, x650 = bits.Mul32(x648, 0x10000000) + var x652 uint32 + var x653 uint32 + x653, x652 = bits.Mul32(x648, 0x14def9de) + var x654 uint32 + var x655 uint32 + x655, x654 = bits.Mul32(x648, 0xa2f79cd6) + var x656 uint32 + var x657 uint32 + x657, x656 = bits.Mul32(x648, 0x5812631a) + var x658 uint32 + var x659 uint32 + x659, x658 = bits.Mul32(x648, 0x5cf5d3ed) + var x660 uint32 + var x661 uint32 + x660, x661 = bits.Add32(x659, x656, uint32(0x0)) + var x662 uint32 + var x663 uint32 + x662, x663 = bits.Add32(x657, x654, uint32(uint1(x661))) + var x664 uint32 + var x665 uint32 + x664, x665 = bits.Add32(x655, x652, uint32(uint1(x663))) + x666 := (uint32(uint1(x665)) + x653) + var x668 uint32 + _, x668 = bits.Add32(x630, x658, uint32(0x0)) + var x669 uint32 + var x670 uint32 + x669, x670 = bits.Add32(x632, x660, uint32(uint1(x668))) + var x671 uint32 + var x672 uint32 + x671, x672 = bits.Add32(x634, x662, uint32(uint1(x670))) + var x673 uint32 + var x674 uint32 + x673, x674 = bits.Add32(x636, x664, uint32(uint1(x672))) + var x675 uint32 + var x676 uint32 + x675, x676 = bits.Add32(x638, x666, uint32(uint1(x674))) + var x677 uint32 + var x678 uint32 + x677, x678 = bits.Add32(x640, uint32(0x0), uint32(uint1(x676))) + var x679 uint32 + var x680 uint32 + x679, x680 = bits.Add32(x642, uint32(0x0), uint32(uint1(x678))) + var x681 uint32 + var x682 uint32 + x681, x682 = bits.Add32(x644, x650, uint32(uint1(x680))) + var x683 uint32 + var x684 uint32 + x683, x684 = bits.Add32(x646, x651, uint32(uint1(x682))) + x685 := (uint32(uint1(x684)) + uint32(uint1(x647))) + var x686 uint32 + var x687 uint32 + x686, x687 = bits.Sub32(x669, 0x5cf5d3ed, uint32(0x0)) + var x688 uint32 + var x689 uint32 + x688, x689 = bits.Sub32(x671, 0x5812631a, uint32(uint1(x687))) + var x690 uint32 + var x691 uint32 + x690, x691 = bits.Sub32(x673, 0xa2f79cd6, uint32(uint1(x689))) + var x692 uint32 + var x693 uint32 + x692, x693 = bits.Sub32(x675, 0x14def9de, uint32(uint1(x691))) + var x694 uint32 + var x695 uint32 + x694, x695 = bits.Sub32(x677, uint32(0x0), uint32(uint1(x693))) + var x696 uint32 + var x697 uint32 + x696, x697 = bits.Sub32(x679, uint32(0x0), uint32(uint1(x695))) + var x698 uint32 + var x699 uint32 + x698, x699 = bits.Sub32(x681, uint32(0x0), uint32(uint1(x697))) + var x700 uint32 + var x701 uint32 + x700, x701 = bits.Sub32(x683, 0x10000000, uint32(uint1(x699))) + var x703 uint32 + _, x703 = bits.Sub32(x685, uint32(0x0), uint32(uint1(x701))) + var x704 uint32 + cmovznzU32(&x704, uint1(x703), x686, x669) + var x705 uint32 + cmovznzU32(&x705, uint1(x703), x688, x671) + var x706 uint32 + cmovznzU32(&x706, uint1(x703), x690, x673) + var x707 uint32 + cmovznzU32(&x707, uint1(x703), x692, x675) + var x708 uint32 + cmovznzU32(&x708, uint1(x703), x694, x677) + var x709 uint32 + cmovznzU32(&x709, uint1(x703), x696, x679) + var x710 uint32 + cmovznzU32(&x710, uint1(x703), x698, x681) + var x711 uint32 + cmovznzU32(&x711, uint1(x703), x700, x683) + out1[0] = x704 + out1[1] = x705 + out1[2] = x706 + out1[3] = x707 + out1[4] = x708 + out1[5] = x709 + out1[6] = x710 + out1[7] = x711 +} + +// Add adds two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Add(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint32 + var x2 uint32 + x1, x2 = bits.Add32(arg1[0], arg2[0], uint32(0x0)) + var x3 uint32 + var x4 uint32 + x3, x4 = bits.Add32(arg1[1], arg2[1], uint32(uint1(x2))) + var x5 uint32 + var x6 uint32 + x5, x6 = bits.Add32(arg1[2], arg2[2], uint32(uint1(x4))) + var x7 uint32 + var x8 uint32 + x7, x8 = bits.Add32(arg1[3], arg2[3], uint32(uint1(x6))) + var x9 uint32 + var x10 uint32 + x9, x10 = bits.Add32(arg1[4], arg2[4], uint32(uint1(x8))) + var x11 uint32 + var x12 uint32 + x11, x12 = bits.Add32(arg1[5], arg2[5], uint32(uint1(x10))) + var x13 uint32 + var x14 uint32 + x13, x14 = bits.Add32(arg1[6], arg2[6], uint32(uint1(x12))) + var x15 uint32 + var x16 uint32 + x15, x16 = bits.Add32(arg1[7], arg2[7], uint32(uint1(x14))) + var x17 uint32 + var x18 uint32 + x17, x18 = bits.Sub32(x1, 0x5cf5d3ed, uint32(0x0)) + var x19 uint32 + var x20 uint32 + x19, x20 = bits.Sub32(x3, 0x5812631a, uint32(uint1(x18))) + var x21 uint32 + var x22 uint32 + x21, x22 = bits.Sub32(x5, 0xa2f79cd6, uint32(uint1(x20))) + var x23 uint32 + var x24 uint32 + x23, x24 = bits.Sub32(x7, 0x14def9de, uint32(uint1(x22))) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Sub32(x9, uint32(0x0), uint32(uint1(x24))) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Sub32(x11, uint32(0x0), uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Sub32(x13, uint32(0x0), uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Sub32(x15, 0x10000000, uint32(uint1(x30))) + var x34 uint32 + _, x34 = bits.Sub32(uint32(uint1(x16)), uint32(0x0), uint32(uint1(x32))) + var x35 uint32 + cmovznzU32(&x35, uint1(x34), x17, x1) + var x36 uint32 + cmovznzU32(&x36, uint1(x34), x19, x3) + var x37 uint32 + cmovznzU32(&x37, uint1(x34), x21, x5) + var x38 uint32 + cmovznzU32(&x38, uint1(x34), x23, x7) + var x39 uint32 + cmovznzU32(&x39, uint1(x34), x25, x9) + var x40 uint32 + cmovznzU32(&x40, uint1(x34), x27, x11) + var x41 uint32 + cmovznzU32(&x41, uint1(x34), x29, x13) + var x42 uint32 + cmovznzU32(&x42, uint1(x34), x31, x15) + out1[0] = x35 + out1[1] = x36 + out1[2] = x37 + out1[3] = x38 + out1[4] = x39 + out1[5] = x40 + out1[6] = x41 + out1[7] = x42 +} + +// Sub subtracts two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Sub(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint32 + var x2 uint32 + x1, x2 = bits.Sub32(arg1[0], arg2[0], uint32(0x0)) + var x3 uint32 + var x4 uint32 + x3, x4 = bits.Sub32(arg1[1], arg2[1], uint32(uint1(x2))) + var x5 uint32 + var x6 uint32 + x5, x6 = bits.Sub32(arg1[2], arg2[2], uint32(uint1(x4))) + var x7 uint32 + var x8 uint32 + x7, x8 = bits.Sub32(arg1[3], arg2[3], uint32(uint1(x6))) + var x9 uint32 + var x10 uint32 + x9, x10 = bits.Sub32(arg1[4], arg2[4], uint32(uint1(x8))) + var x11 uint32 + var x12 uint32 + x11, x12 = bits.Sub32(arg1[5], arg2[5], uint32(uint1(x10))) + var x13 uint32 + var x14 uint32 + x13, x14 = bits.Sub32(arg1[6], arg2[6], uint32(uint1(x12))) + var x15 uint32 + var x16 uint32 + x15, x16 = bits.Sub32(arg1[7], arg2[7], uint32(uint1(x14))) + var x17 uint32 + cmovznzU32(&x17, uint1(x16), uint32(0x0), 0xffffffff) + var x18 uint32 + var x19 uint32 + x18, x19 = bits.Add32(x1, (x17 & 0x5cf5d3ed), uint32(0x0)) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x3, (x17 & 0x5812631a), uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x5, (x17 & 0xa2f79cd6), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x7, (x17 & 0x14def9de), uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(x9, uint32(0x0), uint32(uint1(x25))) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(x11, uint32(0x0), uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(x13, uint32(0x0), uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(x15, (x17 & 0x10000000), uint32(uint1(x31))) + out1[0] = x18 + out1[1] = x20 + out1[2] = x22 + out1[3] = x24 + out1[4] = x26 + out1[5] = x28 + out1[6] = x30 + out1[7] = x32 +} + +// Opp negates a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +// 0 ≤ eval out1 < m +// +func Opp(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + var x1 uint32 + var x2 uint32 + x1, x2 = bits.Sub32(uint32(0x0), arg1[0], uint32(0x0)) + var x3 uint32 + var x4 uint32 + x3, x4 = bits.Sub32(uint32(0x0), arg1[1], uint32(uint1(x2))) + var x5 uint32 + var x6 uint32 + x5, x6 = bits.Sub32(uint32(0x0), arg1[2], uint32(uint1(x4))) + var x7 uint32 + var x8 uint32 + x7, x8 = bits.Sub32(uint32(0x0), arg1[3], uint32(uint1(x6))) + var x9 uint32 + var x10 uint32 + x9, x10 = bits.Sub32(uint32(0x0), arg1[4], uint32(uint1(x8))) + var x11 uint32 + var x12 uint32 + x11, x12 = bits.Sub32(uint32(0x0), arg1[5], uint32(uint1(x10))) + var x13 uint32 + var x14 uint32 + x13, x14 = bits.Sub32(uint32(0x0), arg1[6], uint32(uint1(x12))) + var x15 uint32 + var x16 uint32 + x15, x16 = bits.Sub32(uint32(0x0), arg1[7], uint32(uint1(x14))) + var x17 uint32 + cmovznzU32(&x17, uint1(x16), uint32(0x0), 0xffffffff) + var x18 uint32 + var x19 uint32 + x18, x19 = bits.Add32(x1, (x17 & 0x5cf5d3ed), uint32(0x0)) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x3, (x17 & 0x5812631a), uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x5, (x17 & 0xa2f79cd6), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x7, (x17 & 0x14def9de), uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(x9, uint32(0x0), uint32(uint1(x25))) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(x11, uint32(0x0), uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(x13, uint32(0x0), uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(x15, (x17 & 0x10000000), uint32(uint1(x31))) + out1[0] = x18 + out1[1] = x20 + out1[2] = x22 + out1[3] = x24 + out1[4] = x26 + out1[5] = x28 + out1[6] = x30 + out1[7] = x32 +} + +// FromMontgomery translates a field element out of the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m +// 0 ≤ eval out1 < m +// +func FromMontgomery(out1 *NonMontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[0] + var x2 uint32 + _, x2 = bits.Mul32(x1, 0x12547e1b) + var x4 uint32 + var x5 uint32 + x5, x4 = bits.Mul32(x2, 0x10000000) + var x6 uint32 + var x7 uint32 + x7, x6 = bits.Mul32(x2, 0x14def9de) + var x8 uint32 + var x9 uint32 + x9, x8 = bits.Mul32(x2, 0xa2f79cd6) + var x10 uint32 + var x11 uint32 + x11, x10 = bits.Mul32(x2, 0x5812631a) + var x12 uint32 + var x13 uint32 + x13, x12 = bits.Mul32(x2, 0x5cf5d3ed) + var x14 uint32 + var x15 uint32 + x14, x15 = bits.Add32(x13, x10, uint32(0x0)) + var x16 uint32 + var x17 uint32 + x16, x17 = bits.Add32(x11, x8, uint32(uint1(x15))) + var x18 uint32 + var x19 uint32 + x18, x19 = bits.Add32(x9, x6, uint32(uint1(x17))) + var x21 uint32 + _, x21 = bits.Add32(x1, x12, uint32(0x0)) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(uint32(0x0), x14, uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(uint32(0x0), x16, uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(uint32(0x0), x18, uint32(uint1(x25))) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(x22, arg1[1], uint32(0x0)) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(x24, uint32(0x0), uint32(uint1(x29))) + var x32 uint32 + var x33 uint32 + x32, x33 = bits.Add32(x26, uint32(0x0), uint32(uint1(x31))) + var x34 uint32 + _, x34 = bits.Mul32(x28, 0x12547e1b) + var x36 uint32 + var x37 uint32 + x37, x36 = bits.Mul32(x34, 0x10000000) + var x38 uint32 + var x39 uint32 + x39, x38 = bits.Mul32(x34, 0x14def9de) + var x40 uint32 + var x41 uint32 + x41, x40 = bits.Mul32(x34, 0xa2f79cd6) + var x42 uint32 + var x43 uint32 + x43, x42 = bits.Mul32(x34, 0x5812631a) + var x44 uint32 + var x45 uint32 + x45, x44 = bits.Mul32(x34, 0x5cf5d3ed) + var x46 uint32 + var x47 uint32 + x46, x47 = bits.Add32(x45, x42, uint32(0x0)) + var x48 uint32 + var x49 uint32 + x48, x49 = bits.Add32(x43, x40, uint32(uint1(x47))) + var x50 uint32 + var x51 uint32 + x50, x51 = bits.Add32(x41, x38, uint32(uint1(x49))) + var x53 uint32 + _, x53 = bits.Add32(x28, x44, uint32(0x0)) + var x54 uint32 + var x55 uint32 + x54, x55 = bits.Add32(x30, x46, uint32(uint1(x53))) + var x56 uint32 + var x57 uint32 + x56, x57 = bits.Add32(x32, x48, uint32(uint1(x55))) + var x58 uint32 + var x59 uint32 + x58, x59 = bits.Add32((uint32(uint1(x33)) + (uint32(uint1(x27)) + (uint32(uint1(x19)) + x7))), x50, uint32(uint1(x57))) + var x60 uint32 + var x61 uint32 + x60, x61 = bits.Add32(x5, x36, uint32(0x0)) + var x62 uint32 + var x63 uint32 + x62, x63 = bits.Add32(x54, arg1[2], uint32(0x0)) + var x64 uint32 + var x65 uint32 + x64, x65 = bits.Add32(x56, uint32(0x0), uint32(uint1(x63))) + var x66 uint32 + var x67 uint32 + x66, x67 = bits.Add32(x58, uint32(0x0), uint32(uint1(x65))) + var x68 uint32 + _, x68 = bits.Mul32(x62, 0x12547e1b) + var x70 uint32 + var x71 uint32 + x71, x70 = bits.Mul32(x68, 0x10000000) + var x72 uint32 + var x73 uint32 + x73, x72 = bits.Mul32(x68, 0x14def9de) + var x74 uint32 + var x75 uint32 + x75, x74 = bits.Mul32(x68, 0xa2f79cd6) + var x76 uint32 + var x77 uint32 + x77, x76 = bits.Mul32(x68, 0x5812631a) + var x78 uint32 + var x79 uint32 + x79, x78 = bits.Mul32(x68, 0x5cf5d3ed) + var x80 uint32 + var x81 uint32 + x80, x81 = bits.Add32(x79, x76, uint32(0x0)) + var x82 uint32 + var x83 uint32 + x82, x83 = bits.Add32(x77, x74, uint32(uint1(x81))) + var x84 uint32 + var x85 uint32 + x84, x85 = bits.Add32(x75, x72, uint32(uint1(x83))) + var x87 uint32 + _, x87 = bits.Add32(x62, x78, uint32(0x0)) + var x88 uint32 + var x89 uint32 + x88, x89 = bits.Add32(x64, x80, uint32(uint1(x87))) + var x90 uint32 + var x91 uint32 + x90, x91 = bits.Add32(x66, x82, uint32(uint1(x89))) + var x92 uint32 + var x93 uint32 + x92, x93 = bits.Add32((uint32(uint1(x67)) + (uint32(uint1(x59)) + (uint32(uint1(x51)) + x39))), x84, uint32(uint1(x91))) + var x94 uint32 + var x95 uint32 + x94, x95 = bits.Add32((uint32(uint1(x61)) + x37), x70, uint32(0x0)) + var x96 uint32 + var x97 uint32 + x96, x97 = bits.Add32(x88, arg1[3], uint32(0x0)) + var x98 uint32 + var x99 uint32 + x98, x99 = bits.Add32(x90, uint32(0x0), uint32(uint1(x97))) + var x100 uint32 + var x101 uint32 + x100, x101 = bits.Add32(x92, uint32(0x0), uint32(uint1(x99))) + var x102 uint32 + _, x102 = bits.Mul32(x96, 0x12547e1b) + var x104 uint32 + var x105 uint32 + x105, x104 = bits.Mul32(x102, 0x10000000) + var x106 uint32 + var x107 uint32 + x107, x106 = bits.Mul32(x102, 0x14def9de) + var x108 uint32 + var x109 uint32 + x109, x108 = bits.Mul32(x102, 0xa2f79cd6) + var x110 uint32 + var x111 uint32 + x111, x110 = bits.Mul32(x102, 0x5812631a) + var x112 uint32 + var x113 uint32 + x113, x112 = bits.Mul32(x102, 0x5cf5d3ed) + var x114 uint32 + var x115 uint32 + x114, x115 = bits.Add32(x113, x110, uint32(0x0)) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32(x111, x108, uint32(uint1(x115))) + var x118 uint32 + var x119 uint32 + x118, x119 = bits.Add32(x109, x106, uint32(uint1(x117))) + var x121 uint32 + _, x121 = bits.Add32(x96, x112, uint32(0x0)) + var x122 uint32 + var x123 uint32 + x122, x123 = bits.Add32(x98, x114, uint32(uint1(x121))) + var x124 uint32 + var x125 uint32 + x124, x125 = bits.Add32(x100, x116, uint32(uint1(x123))) + var x126 uint32 + var x127 uint32 + x126, x127 = bits.Add32((uint32(uint1(x101)) + (uint32(uint1(x93)) + (uint32(uint1(x85)) + x73))), x118, uint32(uint1(x125))) + var x128 uint32 + var x129 uint32 + x128, x129 = bits.Add32(x4, (uint32(uint1(x119)) + x107), uint32(uint1(x127))) + var x130 uint32 + var x131 uint32 + x130, x131 = bits.Add32(x60, uint32(0x0), uint32(uint1(x129))) + var x132 uint32 + var x133 uint32 + x132, x133 = bits.Add32(x94, uint32(0x0), uint32(uint1(x131))) + var x134 uint32 + var x135 uint32 + x134, x135 = bits.Add32((uint32(uint1(x95)) + x71), x104, uint32(uint1(x133))) + var x136 uint32 + var x137 uint32 + x136, x137 = bits.Add32(x122, arg1[4], uint32(0x0)) + var x138 uint32 + var x139 uint32 + x138, x139 = bits.Add32(x124, uint32(0x0), uint32(uint1(x137))) + var x140 uint32 + var x141 uint32 + x140, x141 = bits.Add32(x126, uint32(0x0), uint32(uint1(x139))) + var x142 uint32 + var x143 uint32 + x142, x143 = bits.Add32(x128, uint32(0x0), uint32(uint1(x141))) + var x144 uint32 + var x145 uint32 + x144, x145 = bits.Add32(x130, uint32(0x0), uint32(uint1(x143))) + var x146 uint32 + var x147 uint32 + x146, x147 = bits.Add32(x132, uint32(0x0), uint32(uint1(x145))) + var x148 uint32 + var x149 uint32 + x148, x149 = bits.Add32(x134, uint32(0x0), uint32(uint1(x147))) + var x150 uint32 + _, x150 = bits.Mul32(x136, 0x12547e1b) + var x152 uint32 + var x153 uint32 + x153, x152 = bits.Mul32(x150, 0x10000000) + var x154 uint32 + var x155 uint32 + x155, x154 = bits.Mul32(x150, 0x14def9de) + var x156 uint32 + var x157 uint32 + x157, x156 = bits.Mul32(x150, 0xa2f79cd6) + var x158 uint32 + var x159 uint32 + x159, x158 = bits.Mul32(x150, 0x5812631a) + var x160 uint32 + var x161 uint32 + x161, x160 = bits.Mul32(x150, 0x5cf5d3ed) + var x162 uint32 + var x163 uint32 + x162, x163 = bits.Add32(x161, x158, uint32(0x0)) + var x164 uint32 + var x165 uint32 + x164, x165 = bits.Add32(x159, x156, uint32(uint1(x163))) + var x166 uint32 + var x167 uint32 + x166, x167 = bits.Add32(x157, x154, uint32(uint1(x165))) + var x169 uint32 + _, x169 = bits.Add32(x136, x160, uint32(0x0)) + var x170 uint32 + var x171 uint32 + x170, x171 = bits.Add32(x138, x162, uint32(uint1(x169))) + var x172 uint32 + var x173 uint32 + x172, x173 = bits.Add32(x140, x164, uint32(uint1(x171))) + var x174 uint32 + var x175 uint32 + x174, x175 = bits.Add32(x142, x166, uint32(uint1(x173))) + var x176 uint32 + var x177 uint32 + x176, x177 = bits.Add32(x144, (uint32(uint1(x167)) + x155), uint32(uint1(x175))) + var x178 uint32 + var x179 uint32 + x178, x179 = bits.Add32(x146, uint32(0x0), uint32(uint1(x177))) + var x180 uint32 + var x181 uint32 + x180, x181 = bits.Add32(x148, uint32(0x0), uint32(uint1(x179))) + var x182 uint32 + var x183 uint32 + x182, x183 = bits.Add32((uint32(uint1(x149)) + (uint32(uint1(x135)) + x105)), x152, uint32(uint1(x181))) + var x184 uint32 + var x185 uint32 + x184, x185 = bits.Add32(x170, arg1[5], uint32(0x0)) + var x186 uint32 + var x187 uint32 + x186, x187 = bits.Add32(x172, uint32(0x0), uint32(uint1(x185))) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Add32(x174, uint32(0x0), uint32(uint1(x187))) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Add32(x176, uint32(0x0), uint32(uint1(x189))) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Add32(x178, uint32(0x0), uint32(uint1(x191))) + var x194 uint32 + var x195 uint32 + x194, x195 = bits.Add32(x180, uint32(0x0), uint32(uint1(x193))) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Add32(x182, uint32(0x0), uint32(uint1(x195))) + var x198 uint32 + _, x198 = bits.Mul32(x184, 0x12547e1b) + var x200 uint32 + var x201 uint32 + x201, x200 = bits.Mul32(x198, 0x10000000) + var x202 uint32 + var x203 uint32 + x203, x202 = bits.Mul32(x198, 0x14def9de) + var x204 uint32 + var x205 uint32 + x205, x204 = bits.Mul32(x198, 0xa2f79cd6) + var x206 uint32 + var x207 uint32 + x207, x206 = bits.Mul32(x198, 0x5812631a) + var x208 uint32 + var x209 uint32 + x209, x208 = bits.Mul32(x198, 0x5cf5d3ed) + var x210 uint32 + var x211 uint32 + x210, x211 = bits.Add32(x209, x206, uint32(0x0)) + var x212 uint32 + var x213 uint32 + x212, x213 = bits.Add32(x207, x204, uint32(uint1(x211))) + var x214 uint32 + var x215 uint32 + x214, x215 = bits.Add32(x205, x202, uint32(uint1(x213))) + var x217 uint32 + _, x217 = bits.Add32(x184, x208, uint32(0x0)) + var x218 uint32 + var x219 uint32 + x218, x219 = bits.Add32(x186, x210, uint32(uint1(x217))) + var x220 uint32 + var x221 uint32 + x220, x221 = bits.Add32(x188, x212, uint32(uint1(x219))) + var x222 uint32 + var x223 uint32 + x222, x223 = bits.Add32(x190, x214, uint32(uint1(x221))) + var x224 uint32 + var x225 uint32 + x224, x225 = bits.Add32(x192, (uint32(uint1(x215)) + x203), uint32(uint1(x223))) + var x226 uint32 + var x227 uint32 + x226, x227 = bits.Add32(x194, uint32(0x0), uint32(uint1(x225))) + var x228 uint32 + var x229 uint32 + x228, x229 = bits.Add32(x196, uint32(0x0), uint32(uint1(x227))) + var x230 uint32 + var x231 uint32 + x230, x231 = bits.Add32((uint32(uint1(x197)) + (uint32(uint1(x183)) + x153)), x200, uint32(uint1(x229))) + var x232 uint32 + var x233 uint32 + x232, x233 = bits.Add32(x218, arg1[6], uint32(0x0)) + var x234 uint32 + var x235 uint32 + x234, x235 = bits.Add32(x220, uint32(0x0), uint32(uint1(x233))) + var x236 uint32 + var x237 uint32 + x236, x237 = bits.Add32(x222, uint32(0x0), uint32(uint1(x235))) + var x238 uint32 + var x239 uint32 + x238, x239 = bits.Add32(x224, uint32(0x0), uint32(uint1(x237))) + var x240 uint32 + var x241 uint32 + x240, x241 = bits.Add32(x226, uint32(0x0), uint32(uint1(x239))) + var x242 uint32 + var x243 uint32 + x242, x243 = bits.Add32(x228, uint32(0x0), uint32(uint1(x241))) + var x244 uint32 + var x245 uint32 + x244, x245 = bits.Add32(x230, uint32(0x0), uint32(uint1(x243))) + var x246 uint32 + _, x246 = bits.Mul32(x232, 0x12547e1b) + var x248 uint32 + var x249 uint32 + x249, x248 = bits.Mul32(x246, 0x10000000) + var x250 uint32 + var x251 uint32 + x251, x250 = bits.Mul32(x246, 0x14def9de) + var x252 uint32 + var x253 uint32 + x253, x252 = bits.Mul32(x246, 0xa2f79cd6) + var x254 uint32 + var x255 uint32 + x255, x254 = bits.Mul32(x246, 0x5812631a) + var x256 uint32 + var x257 uint32 + x257, x256 = bits.Mul32(x246, 0x5cf5d3ed) + var x258 uint32 + var x259 uint32 + x258, x259 = bits.Add32(x257, x254, uint32(0x0)) + var x260 uint32 + var x261 uint32 + x260, x261 = bits.Add32(x255, x252, uint32(uint1(x259))) + var x262 uint32 + var x263 uint32 + x262, x263 = bits.Add32(x253, x250, uint32(uint1(x261))) + var x265 uint32 + _, x265 = bits.Add32(x232, x256, uint32(0x0)) + var x266 uint32 + var x267 uint32 + x266, x267 = bits.Add32(x234, x258, uint32(uint1(x265))) + var x268 uint32 + var x269 uint32 + x268, x269 = bits.Add32(x236, x260, uint32(uint1(x267))) + var x270 uint32 + var x271 uint32 + x270, x271 = bits.Add32(x238, x262, uint32(uint1(x269))) + var x272 uint32 + var x273 uint32 + x272, x273 = bits.Add32(x240, (uint32(uint1(x263)) + x251), uint32(uint1(x271))) + var x274 uint32 + var x275 uint32 + x274, x275 = bits.Add32(x242, uint32(0x0), uint32(uint1(x273))) + var x276 uint32 + var x277 uint32 + x276, x277 = bits.Add32(x244, uint32(0x0), uint32(uint1(x275))) + var x278 uint32 + var x279 uint32 + x278, x279 = bits.Add32((uint32(uint1(x245)) + (uint32(uint1(x231)) + x201)), x248, uint32(uint1(x277))) + var x280 uint32 + var x281 uint32 + x280, x281 = bits.Add32(x266, arg1[7], uint32(0x0)) + var x282 uint32 + var x283 uint32 + x282, x283 = bits.Add32(x268, uint32(0x0), uint32(uint1(x281))) + var x284 uint32 + var x285 uint32 + x284, x285 = bits.Add32(x270, uint32(0x0), uint32(uint1(x283))) + var x286 uint32 + var x287 uint32 + x286, x287 = bits.Add32(x272, uint32(0x0), uint32(uint1(x285))) + var x288 uint32 + var x289 uint32 + x288, x289 = bits.Add32(x274, uint32(0x0), uint32(uint1(x287))) + var x290 uint32 + var x291 uint32 + x290, x291 = bits.Add32(x276, uint32(0x0), uint32(uint1(x289))) + var x292 uint32 + var x293 uint32 + x292, x293 = bits.Add32(x278, uint32(0x0), uint32(uint1(x291))) + var x294 uint32 + _, x294 = bits.Mul32(x280, 0x12547e1b) + var x296 uint32 + var x297 uint32 + x297, x296 = bits.Mul32(x294, 0x10000000) + var x298 uint32 + var x299 uint32 + x299, x298 = bits.Mul32(x294, 0x14def9de) + var x300 uint32 + var x301 uint32 + x301, x300 = bits.Mul32(x294, 0xa2f79cd6) + var x302 uint32 + var x303 uint32 + x303, x302 = bits.Mul32(x294, 0x5812631a) + var x304 uint32 + var x305 uint32 + x305, x304 = bits.Mul32(x294, 0x5cf5d3ed) + var x306 uint32 + var x307 uint32 + x306, x307 = bits.Add32(x305, x302, uint32(0x0)) + var x308 uint32 + var x309 uint32 + x308, x309 = bits.Add32(x303, x300, uint32(uint1(x307))) + var x310 uint32 + var x311 uint32 + x310, x311 = bits.Add32(x301, x298, uint32(uint1(x309))) + var x313 uint32 + _, x313 = bits.Add32(x280, x304, uint32(0x0)) + var x314 uint32 + var x315 uint32 + x314, x315 = bits.Add32(x282, x306, uint32(uint1(x313))) + var x316 uint32 + var x317 uint32 + x316, x317 = bits.Add32(x284, x308, uint32(uint1(x315))) + var x318 uint32 + var x319 uint32 + x318, x319 = bits.Add32(x286, x310, uint32(uint1(x317))) + var x320 uint32 + var x321 uint32 + x320, x321 = bits.Add32(x288, (uint32(uint1(x311)) + x299), uint32(uint1(x319))) + var x322 uint32 + var x323 uint32 + x322, x323 = bits.Add32(x290, uint32(0x0), uint32(uint1(x321))) + var x324 uint32 + var x325 uint32 + x324, x325 = bits.Add32(x292, uint32(0x0), uint32(uint1(x323))) + var x326 uint32 + var x327 uint32 + x326, x327 = bits.Add32((uint32(uint1(x293)) + (uint32(uint1(x279)) + x249)), x296, uint32(uint1(x325))) + x328 := (uint32(uint1(x327)) + x297) + var x329 uint32 + var x330 uint32 + x329, x330 = bits.Sub32(x314, 0x5cf5d3ed, uint32(0x0)) + var x331 uint32 + var x332 uint32 + x331, x332 = bits.Sub32(x316, 0x5812631a, uint32(uint1(x330))) + var x333 uint32 + var x334 uint32 + x333, x334 = bits.Sub32(x318, 0xa2f79cd6, uint32(uint1(x332))) + var x335 uint32 + var x336 uint32 + x335, x336 = bits.Sub32(x320, 0x14def9de, uint32(uint1(x334))) + var x337 uint32 + var x338 uint32 + x337, x338 = bits.Sub32(x322, uint32(0x0), uint32(uint1(x336))) + var x339 uint32 + var x340 uint32 + x339, x340 = bits.Sub32(x324, uint32(0x0), uint32(uint1(x338))) + var x341 uint32 + var x342 uint32 + x341, x342 = bits.Sub32(x326, uint32(0x0), uint32(uint1(x340))) + var x343 uint32 + var x344 uint32 + x343, x344 = bits.Sub32(x328, 0x10000000, uint32(uint1(x342))) + var x346 uint32 + _, x346 = bits.Sub32(uint32(0x0), uint32(0x0), uint32(uint1(x344))) + var x347 uint32 + cmovznzU32(&x347, uint1(x346), x329, x314) + var x348 uint32 + cmovznzU32(&x348, uint1(x346), x331, x316) + var x349 uint32 + cmovznzU32(&x349, uint1(x346), x333, x318) + var x350 uint32 + cmovznzU32(&x350, uint1(x346), x335, x320) + var x351 uint32 + cmovznzU32(&x351, uint1(x346), x337, x322) + var x352 uint32 + cmovznzU32(&x352, uint1(x346), x339, x324) + var x353 uint32 + cmovznzU32(&x353, uint1(x346), x341, x326) + var x354 uint32 + cmovznzU32(&x354, uint1(x346), x343, x328) + out1[0] = x347 + out1[1] = x348 + out1[2] = x349 + out1[3] = x350 + out1[4] = x351 + out1[5] = x352 + out1[6] = x353 + out1[7] = x354 +} + +// ToMontgomery translates a field element into the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = eval arg1 mod m +// 0 ≤ eval out1 < m +// +func ToMontgomery(out1 *MontgomeryDomainFieldElement, arg1 *NonMontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[6] + x7 := arg1[7] + x8 := arg1[0] + var x9 uint32 + var x10 uint32 + x10, x9 = bits.Mul32(x8, 0x399411b) + var x11 uint32 + var x12 uint32 + x12, x11 = bits.Mul32(x8, 0x7c309a3d) + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x8, 0xceec73d2) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x8, 0x17f5be65) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x8, 0xd00e1ba7) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x8, 0x68859347) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x8, 0xa40611e3) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x8, 0x449c0f01) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Add32(x24, x21, uint32(0x0)) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Add32(x22, x19, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Add32(x20, x17, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Add32(x18, x15, uint32(uint1(x30))) + var x33 uint32 + var x34 uint32 + x33, x34 = bits.Add32(x16, x13, uint32(uint1(x32))) + var x35 uint32 + var x36 uint32 + x35, x36 = bits.Add32(x14, x11, uint32(uint1(x34))) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Add32(x12, x9, uint32(uint1(x36))) + var x39 uint32 + _, x39 = bits.Mul32(x23, 0x12547e1b) + var x41 uint32 + var x42 uint32 + x42, x41 = bits.Mul32(x39, 0x10000000) + var x43 uint32 + var x44 uint32 + x44, x43 = bits.Mul32(x39, 0x14def9de) + var x45 uint32 + var x46 uint32 + x46, x45 = bits.Mul32(x39, 0xa2f79cd6) + var x47 uint32 + var x48 uint32 + x48, x47 = bits.Mul32(x39, 0x5812631a) + var x49 uint32 + var x50 uint32 + x50, x49 = bits.Mul32(x39, 0x5cf5d3ed) + var x51 uint32 + var x52 uint32 + x51, x52 = bits.Add32(x50, x47, uint32(0x0)) + var x53 uint32 + var x54 uint32 + x53, x54 = bits.Add32(x48, x45, uint32(uint1(x52))) + var x55 uint32 + var x56 uint32 + x55, x56 = bits.Add32(x46, x43, uint32(uint1(x54))) + var x58 uint32 + _, x58 = bits.Add32(x23, x49, uint32(0x0)) + var x59 uint32 + var x60 uint32 + x59, x60 = bits.Add32(x25, x51, uint32(uint1(x58))) + var x61 uint32 + var x62 uint32 + x61, x62 = bits.Add32(x27, x53, uint32(uint1(x60))) + var x63 uint32 + var x64 uint32 + x63, x64 = bits.Add32(x29, x55, uint32(uint1(x62))) + var x65 uint32 + var x66 uint32 + x65, x66 = bits.Add32(x31, (uint32(uint1(x56)) + x44), uint32(uint1(x64))) + var x67 uint32 + var x68 uint32 + x67, x68 = bits.Add32(x33, uint32(0x0), uint32(uint1(x66))) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Add32(x35, uint32(0x0), uint32(uint1(x68))) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Add32(x37, x41, uint32(uint1(x70))) + var x73 uint32 + var x74 uint32 + x74, x73 = bits.Mul32(x1, 0x399411b) + var x75 uint32 + var x76 uint32 + x76, x75 = bits.Mul32(x1, 0x7c309a3d) + var x77 uint32 + var x78 uint32 + x78, x77 = bits.Mul32(x1, 0xceec73d2) + var x79 uint32 + var x80 uint32 + x80, x79 = bits.Mul32(x1, 0x17f5be65) + var x81 uint32 + var x82 uint32 + x82, x81 = bits.Mul32(x1, 0xd00e1ba7) + var x83 uint32 + var x84 uint32 + x84, x83 = bits.Mul32(x1, 0x68859347) + var x85 uint32 + var x86 uint32 + x86, x85 = bits.Mul32(x1, 0xa40611e3) + var x87 uint32 + var x88 uint32 + x88, x87 = bits.Mul32(x1, 0x449c0f01) + var x89 uint32 + var x90 uint32 + x89, x90 = bits.Add32(x88, x85, uint32(0x0)) + var x91 uint32 + var x92 uint32 + x91, x92 = bits.Add32(x86, x83, uint32(uint1(x90))) + var x93 uint32 + var x94 uint32 + x93, x94 = bits.Add32(x84, x81, uint32(uint1(x92))) + var x95 uint32 + var x96 uint32 + x95, x96 = bits.Add32(x82, x79, uint32(uint1(x94))) + var x97 uint32 + var x98 uint32 + x97, x98 = bits.Add32(x80, x77, uint32(uint1(x96))) + var x99 uint32 + var x100 uint32 + x99, x100 = bits.Add32(x78, x75, uint32(uint1(x98))) + var x101 uint32 + var x102 uint32 + x101, x102 = bits.Add32(x76, x73, uint32(uint1(x100))) + var x103 uint32 + var x104 uint32 + x103, x104 = bits.Add32(x59, x87, uint32(0x0)) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Add32(x61, x89, uint32(uint1(x104))) + var x107 uint32 + var x108 uint32 + x107, x108 = bits.Add32(x63, x91, uint32(uint1(x106))) + var x109 uint32 + var x110 uint32 + x109, x110 = bits.Add32(x65, x93, uint32(uint1(x108))) + var x111 uint32 + var x112 uint32 + x111, x112 = bits.Add32(x67, x95, uint32(uint1(x110))) + var x113 uint32 + var x114 uint32 + x113, x114 = bits.Add32(x69, x97, uint32(uint1(x112))) + var x115 uint32 + var x116 uint32 + x115, x116 = bits.Add32(x71, x99, uint32(uint1(x114))) + var x117 uint32 + var x118 uint32 + x117, x118 = bits.Add32(((uint32(uint1(x72)) + (uint32(uint1(x38)) + x10)) + x42), x101, uint32(uint1(x116))) + var x119 uint32 + _, x119 = bits.Mul32(x103, 0x12547e1b) + var x121 uint32 + var x122 uint32 + x122, x121 = bits.Mul32(x119, 0x10000000) + var x123 uint32 + var x124 uint32 + x124, x123 = bits.Mul32(x119, 0x14def9de) + var x125 uint32 + var x126 uint32 + x126, x125 = bits.Mul32(x119, 0xa2f79cd6) + var x127 uint32 + var x128 uint32 + x128, x127 = bits.Mul32(x119, 0x5812631a) + var x129 uint32 + var x130 uint32 + x130, x129 = bits.Mul32(x119, 0x5cf5d3ed) + var x131 uint32 + var x132 uint32 + x131, x132 = bits.Add32(x130, x127, uint32(0x0)) + var x133 uint32 + var x134 uint32 + x133, x134 = bits.Add32(x128, x125, uint32(uint1(x132))) + var x135 uint32 + var x136 uint32 + x135, x136 = bits.Add32(x126, x123, uint32(uint1(x134))) + var x138 uint32 + _, x138 = bits.Add32(x103, x129, uint32(0x0)) + var x139 uint32 + var x140 uint32 + x139, x140 = bits.Add32(x105, x131, uint32(uint1(x138))) + var x141 uint32 + var x142 uint32 + x141, x142 = bits.Add32(x107, x133, uint32(uint1(x140))) + var x143 uint32 + var x144 uint32 + x143, x144 = bits.Add32(x109, x135, uint32(uint1(x142))) + var x145 uint32 + var x146 uint32 + x145, x146 = bits.Add32(x111, (uint32(uint1(x136)) + x124), uint32(uint1(x144))) + var x147 uint32 + var x148 uint32 + x147, x148 = bits.Add32(x113, uint32(0x0), uint32(uint1(x146))) + var x149 uint32 + var x150 uint32 + x149, x150 = bits.Add32(x115, uint32(0x0), uint32(uint1(x148))) + var x151 uint32 + var x152 uint32 + x151, x152 = bits.Add32(x117, x121, uint32(uint1(x150))) + var x153 uint32 + var x154 uint32 + x154, x153 = bits.Mul32(x2, 0x399411b) + var x155 uint32 + var x156 uint32 + x156, x155 = bits.Mul32(x2, 0x7c309a3d) + var x157 uint32 + var x158 uint32 + x158, x157 = bits.Mul32(x2, 0xceec73d2) + var x159 uint32 + var x160 uint32 + x160, x159 = bits.Mul32(x2, 0x17f5be65) + var x161 uint32 + var x162 uint32 + x162, x161 = bits.Mul32(x2, 0xd00e1ba7) + var x163 uint32 + var x164 uint32 + x164, x163 = bits.Mul32(x2, 0x68859347) + var x165 uint32 + var x166 uint32 + x166, x165 = bits.Mul32(x2, 0xa40611e3) + var x167 uint32 + var x168 uint32 + x168, x167 = bits.Mul32(x2, 0x449c0f01) + var x169 uint32 + var x170 uint32 + x169, x170 = bits.Add32(x168, x165, uint32(0x0)) + var x171 uint32 + var x172 uint32 + x171, x172 = bits.Add32(x166, x163, uint32(uint1(x170))) + var x173 uint32 + var x174 uint32 + x173, x174 = bits.Add32(x164, x161, uint32(uint1(x172))) + var x175 uint32 + var x176 uint32 + x175, x176 = bits.Add32(x162, x159, uint32(uint1(x174))) + var x177 uint32 + var x178 uint32 + x177, x178 = bits.Add32(x160, x157, uint32(uint1(x176))) + var x179 uint32 + var x180 uint32 + x179, x180 = bits.Add32(x158, x155, uint32(uint1(x178))) + var x181 uint32 + var x182 uint32 + x181, x182 = bits.Add32(x156, x153, uint32(uint1(x180))) + var x183 uint32 + var x184 uint32 + x183, x184 = bits.Add32(x139, x167, uint32(0x0)) + var x185 uint32 + var x186 uint32 + x185, x186 = bits.Add32(x141, x169, uint32(uint1(x184))) + var x187 uint32 + var x188 uint32 + x187, x188 = bits.Add32(x143, x171, uint32(uint1(x186))) + var x189 uint32 + var x190 uint32 + x189, x190 = bits.Add32(x145, x173, uint32(uint1(x188))) + var x191 uint32 + var x192 uint32 + x191, x192 = bits.Add32(x147, x175, uint32(uint1(x190))) + var x193 uint32 + var x194 uint32 + x193, x194 = bits.Add32(x149, x177, uint32(uint1(x192))) + var x195 uint32 + var x196 uint32 + x195, x196 = bits.Add32(x151, x179, uint32(uint1(x194))) + var x197 uint32 + var x198 uint32 + x197, x198 = bits.Add32(((uint32(uint1(x152)) + (uint32(uint1(x118)) + (uint32(uint1(x102)) + x74))) + x122), x181, uint32(uint1(x196))) + var x199 uint32 + _, x199 = bits.Mul32(x183, 0x12547e1b) + var x201 uint32 + var x202 uint32 + x202, x201 = bits.Mul32(x199, 0x10000000) + var x203 uint32 + var x204 uint32 + x204, x203 = bits.Mul32(x199, 0x14def9de) + var x205 uint32 + var x206 uint32 + x206, x205 = bits.Mul32(x199, 0xa2f79cd6) + var x207 uint32 + var x208 uint32 + x208, x207 = bits.Mul32(x199, 0x5812631a) + var x209 uint32 + var x210 uint32 + x210, x209 = bits.Mul32(x199, 0x5cf5d3ed) + var x211 uint32 + var x212 uint32 + x211, x212 = bits.Add32(x210, x207, uint32(0x0)) + var x213 uint32 + var x214 uint32 + x213, x214 = bits.Add32(x208, x205, uint32(uint1(x212))) + var x215 uint32 + var x216 uint32 + x215, x216 = bits.Add32(x206, x203, uint32(uint1(x214))) + var x218 uint32 + _, x218 = bits.Add32(x183, x209, uint32(0x0)) + var x219 uint32 + var x220 uint32 + x219, x220 = bits.Add32(x185, x211, uint32(uint1(x218))) + var x221 uint32 + var x222 uint32 + x221, x222 = bits.Add32(x187, x213, uint32(uint1(x220))) + var x223 uint32 + var x224 uint32 + x223, x224 = bits.Add32(x189, x215, uint32(uint1(x222))) + var x225 uint32 + var x226 uint32 + x225, x226 = bits.Add32(x191, (uint32(uint1(x216)) + x204), uint32(uint1(x224))) + var x227 uint32 + var x228 uint32 + x227, x228 = bits.Add32(x193, uint32(0x0), uint32(uint1(x226))) + var x229 uint32 + var x230 uint32 + x229, x230 = bits.Add32(x195, uint32(0x0), uint32(uint1(x228))) + var x231 uint32 + var x232 uint32 + x231, x232 = bits.Add32(x197, x201, uint32(uint1(x230))) + var x233 uint32 + var x234 uint32 + x234, x233 = bits.Mul32(x3, 0x399411b) + var x235 uint32 + var x236 uint32 + x236, x235 = bits.Mul32(x3, 0x7c309a3d) + var x237 uint32 + var x238 uint32 + x238, x237 = bits.Mul32(x3, 0xceec73d2) + var x239 uint32 + var x240 uint32 + x240, x239 = bits.Mul32(x3, 0x17f5be65) + var x241 uint32 + var x242 uint32 + x242, x241 = bits.Mul32(x3, 0xd00e1ba7) + var x243 uint32 + var x244 uint32 + x244, x243 = bits.Mul32(x3, 0x68859347) + var x245 uint32 + var x246 uint32 + x246, x245 = bits.Mul32(x3, 0xa40611e3) + var x247 uint32 + var x248 uint32 + x248, x247 = bits.Mul32(x3, 0x449c0f01) + var x249 uint32 + var x250 uint32 + x249, x250 = bits.Add32(x248, x245, uint32(0x0)) + var x251 uint32 + var x252 uint32 + x251, x252 = bits.Add32(x246, x243, uint32(uint1(x250))) + var x253 uint32 + var x254 uint32 + x253, x254 = bits.Add32(x244, x241, uint32(uint1(x252))) + var x255 uint32 + var x256 uint32 + x255, x256 = bits.Add32(x242, x239, uint32(uint1(x254))) + var x257 uint32 + var x258 uint32 + x257, x258 = bits.Add32(x240, x237, uint32(uint1(x256))) + var x259 uint32 + var x260 uint32 + x259, x260 = bits.Add32(x238, x235, uint32(uint1(x258))) + var x261 uint32 + var x262 uint32 + x261, x262 = bits.Add32(x236, x233, uint32(uint1(x260))) + var x263 uint32 + var x264 uint32 + x263, x264 = bits.Add32(x219, x247, uint32(0x0)) + var x265 uint32 + var x266 uint32 + x265, x266 = bits.Add32(x221, x249, uint32(uint1(x264))) + var x267 uint32 + var x268 uint32 + x267, x268 = bits.Add32(x223, x251, uint32(uint1(x266))) + var x269 uint32 + var x270 uint32 + x269, x270 = bits.Add32(x225, x253, uint32(uint1(x268))) + var x271 uint32 + var x272 uint32 + x271, x272 = bits.Add32(x227, x255, uint32(uint1(x270))) + var x273 uint32 + var x274 uint32 + x273, x274 = bits.Add32(x229, x257, uint32(uint1(x272))) + var x275 uint32 + var x276 uint32 + x275, x276 = bits.Add32(x231, x259, uint32(uint1(x274))) + var x277 uint32 + var x278 uint32 + x277, x278 = bits.Add32(((uint32(uint1(x232)) + (uint32(uint1(x198)) + (uint32(uint1(x182)) + x154))) + x202), x261, uint32(uint1(x276))) + var x279 uint32 + _, x279 = bits.Mul32(x263, 0x12547e1b) + var x281 uint32 + var x282 uint32 + x282, x281 = bits.Mul32(x279, 0x10000000) + var x283 uint32 + var x284 uint32 + x284, x283 = bits.Mul32(x279, 0x14def9de) + var x285 uint32 + var x286 uint32 + x286, x285 = bits.Mul32(x279, 0xa2f79cd6) + var x287 uint32 + var x288 uint32 + x288, x287 = bits.Mul32(x279, 0x5812631a) + var x289 uint32 + var x290 uint32 + x290, x289 = bits.Mul32(x279, 0x5cf5d3ed) + var x291 uint32 + var x292 uint32 + x291, x292 = bits.Add32(x290, x287, uint32(0x0)) + var x293 uint32 + var x294 uint32 + x293, x294 = bits.Add32(x288, x285, uint32(uint1(x292))) + var x295 uint32 + var x296 uint32 + x295, x296 = bits.Add32(x286, x283, uint32(uint1(x294))) + var x298 uint32 + _, x298 = bits.Add32(x263, x289, uint32(0x0)) + var x299 uint32 + var x300 uint32 + x299, x300 = bits.Add32(x265, x291, uint32(uint1(x298))) + var x301 uint32 + var x302 uint32 + x301, x302 = bits.Add32(x267, x293, uint32(uint1(x300))) + var x303 uint32 + var x304 uint32 + x303, x304 = bits.Add32(x269, x295, uint32(uint1(x302))) + var x305 uint32 + var x306 uint32 + x305, x306 = bits.Add32(x271, (uint32(uint1(x296)) + x284), uint32(uint1(x304))) + var x307 uint32 + var x308 uint32 + x307, x308 = bits.Add32(x273, uint32(0x0), uint32(uint1(x306))) + var x309 uint32 + var x310 uint32 + x309, x310 = bits.Add32(x275, uint32(0x0), uint32(uint1(x308))) + var x311 uint32 + var x312 uint32 + x311, x312 = bits.Add32(x277, x281, uint32(uint1(x310))) + var x313 uint32 + var x314 uint32 + x314, x313 = bits.Mul32(x4, 0x399411b) + var x315 uint32 + var x316 uint32 + x316, x315 = bits.Mul32(x4, 0x7c309a3d) + var x317 uint32 + var x318 uint32 + x318, x317 = bits.Mul32(x4, 0xceec73d2) + var x319 uint32 + var x320 uint32 + x320, x319 = bits.Mul32(x4, 0x17f5be65) + var x321 uint32 + var x322 uint32 + x322, x321 = bits.Mul32(x4, 0xd00e1ba7) + var x323 uint32 + var x324 uint32 + x324, x323 = bits.Mul32(x4, 0x68859347) + var x325 uint32 + var x326 uint32 + x326, x325 = bits.Mul32(x4, 0xa40611e3) + var x327 uint32 + var x328 uint32 + x328, x327 = bits.Mul32(x4, 0x449c0f01) + var x329 uint32 + var x330 uint32 + x329, x330 = bits.Add32(x328, x325, uint32(0x0)) + var x331 uint32 + var x332 uint32 + x331, x332 = bits.Add32(x326, x323, uint32(uint1(x330))) + var x333 uint32 + var x334 uint32 + x333, x334 = bits.Add32(x324, x321, uint32(uint1(x332))) + var x335 uint32 + var x336 uint32 + x335, x336 = bits.Add32(x322, x319, uint32(uint1(x334))) + var x337 uint32 + var x338 uint32 + x337, x338 = bits.Add32(x320, x317, uint32(uint1(x336))) + var x339 uint32 + var x340 uint32 + x339, x340 = bits.Add32(x318, x315, uint32(uint1(x338))) + var x341 uint32 + var x342 uint32 + x341, x342 = bits.Add32(x316, x313, uint32(uint1(x340))) + var x343 uint32 + var x344 uint32 + x343, x344 = bits.Add32(x299, x327, uint32(0x0)) + var x345 uint32 + var x346 uint32 + x345, x346 = bits.Add32(x301, x329, uint32(uint1(x344))) + var x347 uint32 + var x348 uint32 + x347, x348 = bits.Add32(x303, x331, uint32(uint1(x346))) + var x349 uint32 + var x350 uint32 + x349, x350 = bits.Add32(x305, x333, uint32(uint1(x348))) + var x351 uint32 + var x352 uint32 + x351, x352 = bits.Add32(x307, x335, uint32(uint1(x350))) + var x353 uint32 + var x354 uint32 + x353, x354 = bits.Add32(x309, x337, uint32(uint1(x352))) + var x355 uint32 + var x356 uint32 + x355, x356 = bits.Add32(x311, x339, uint32(uint1(x354))) + var x357 uint32 + var x358 uint32 + x357, x358 = bits.Add32(((uint32(uint1(x312)) + (uint32(uint1(x278)) + (uint32(uint1(x262)) + x234))) + x282), x341, uint32(uint1(x356))) + var x359 uint32 + _, x359 = bits.Mul32(x343, 0x12547e1b) + var x361 uint32 + var x362 uint32 + x362, x361 = bits.Mul32(x359, 0x10000000) + var x363 uint32 + var x364 uint32 + x364, x363 = bits.Mul32(x359, 0x14def9de) + var x365 uint32 + var x366 uint32 + x366, x365 = bits.Mul32(x359, 0xa2f79cd6) + var x367 uint32 + var x368 uint32 + x368, x367 = bits.Mul32(x359, 0x5812631a) + var x369 uint32 + var x370 uint32 + x370, x369 = bits.Mul32(x359, 0x5cf5d3ed) + var x371 uint32 + var x372 uint32 + x371, x372 = bits.Add32(x370, x367, uint32(0x0)) + var x373 uint32 + var x374 uint32 + x373, x374 = bits.Add32(x368, x365, uint32(uint1(x372))) + var x375 uint32 + var x376 uint32 + x375, x376 = bits.Add32(x366, x363, uint32(uint1(x374))) + var x378 uint32 + _, x378 = bits.Add32(x343, x369, uint32(0x0)) + var x379 uint32 + var x380 uint32 + x379, x380 = bits.Add32(x345, x371, uint32(uint1(x378))) + var x381 uint32 + var x382 uint32 + x381, x382 = bits.Add32(x347, x373, uint32(uint1(x380))) + var x383 uint32 + var x384 uint32 + x383, x384 = bits.Add32(x349, x375, uint32(uint1(x382))) + var x385 uint32 + var x386 uint32 + x385, x386 = bits.Add32(x351, (uint32(uint1(x376)) + x364), uint32(uint1(x384))) + var x387 uint32 + var x388 uint32 + x387, x388 = bits.Add32(x353, uint32(0x0), uint32(uint1(x386))) + var x389 uint32 + var x390 uint32 + x389, x390 = bits.Add32(x355, uint32(0x0), uint32(uint1(x388))) + var x391 uint32 + var x392 uint32 + x391, x392 = bits.Add32(x357, x361, uint32(uint1(x390))) + var x393 uint32 + var x394 uint32 + x394, x393 = bits.Mul32(x5, 0x399411b) + var x395 uint32 + var x396 uint32 + x396, x395 = bits.Mul32(x5, 0x7c309a3d) + var x397 uint32 + var x398 uint32 + x398, x397 = bits.Mul32(x5, 0xceec73d2) + var x399 uint32 + var x400 uint32 + x400, x399 = bits.Mul32(x5, 0x17f5be65) + var x401 uint32 + var x402 uint32 + x402, x401 = bits.Mul32(x5, 0xd00e1ba7) + var x403 uint32 + var x404 uint32 + x404, x403 = bits.Mul32(x5, 0x68859347) + var x405 uint32 + var x406 uint32 + x406, x405 = bits.Mul32(x5, 0xa40611e3) + var x407 uint32 + var x408 uint32 + x408, x407 = bits.Mul32(x5, 0x449c0f01) + var x409 uint32 + var x410 uint32 + x409, x410 = bits.Add32(x408, x405, uint32(0x0)) + var x411 uint32 + var x412 uint32 + x411, x412 = bits.Add32(x406, x403, uint32(uint1(x410))) + var x413 uint32 + var x414 uint32 + x413, x414 = bits.Add32(x404, x401, uint32(uint1(x412))) + var x415 uint32 + var x416 uint32 + x415, x416 = bits.Add32(x402, x399, uint32(uint1(x414))) + var x417 uint32 + var x418 uint32 + x417, x418 = bits.Add32(x400, x397, uint32(uint1(x416))) + var x419 uint32 + var x420 uint32 + x419, x420 = bits.Add32(x398, x395, uint32(uint1(x418))) + var x421 uint32 + var x422 uint32 + x421, x422 = bits.Add32(x396, x393, uint32(uint1(x420))) + var x423 uint32 + var x424 uint32 + x423, x424 = bits.Add32(x379, x407, uint32(0x0)) + var x425 uint32 + var x426 uint32 + x425, x426 = bits.Add32(x381, x409, uint32(uint1(x424))) + var x427 uint32 + var x428 uint32 + x427, x428 = bits.Add32(x383, x411, uint32(uint1(x426))) + var x429 uint32 + var x430 uint32 + x429, x430 = bits.Add32(x385, x413, uint32(uint1(x428))) + var x431 uint32 + var x432 uint32 + x431, x432 = bits.Add32(x387, x415, uint32(uint1(x430))) + var x433 uint32 + var x434 uint32 + x433, x434 = bits.Add32(x389, x417, uint32(uint1(x432))) + var x435 uint32 + var x436 uint32 + x435, x436 = bits.Add32(x391, x419, uint32(uint1(x434))) + var x437 uint32 + var x438 uint32 + x437, x438 = bits.Add32(((uint32(uint1(x392)) + (uint32(uint1(x358)) + (uint32(uint1(x342)) + x314))) + x362), x421, uint32(uint1(x436))) + var x439 uint32 + _, x439 = bits.Mul32(x423, 0x12547e1b) + var x441 uint32 + var x442 uint32 + x442, x441 = bits.Mul32(x439, 0x10000000) + var x443 uint32 + var x444 uint32 + x444, x443 = bits.Mul32(x439, 0x14def9de) + var x445 uint32 + var x446 uint32 + x446, x445 = bits.Mul32(x439, 0xa2f79cd6) + var x447 uint32 + var x448 uint32 + x448, x447 = bits.Mul32(x439, 0x5812631a) + var x449 uint32 + var x450 uint32 + x450, x449 = bits.Mul32(x439, 0x5cf5d3ed) + var x451 uint32 + var x452 uint32 + x451, x452 = bits.Add32(x450, x447, uint32(0x0)) + var x453 uint32 + var x454 uint32 + x453, x454 = bits.Add32(x448, x445, uint32(uint1(x452))) + var x455 uint32 + var x456 uint32 + x455, x456 = bits.Add32(x446, x443, uint32(uint1(x454))) + var x458 uint32 + _, x458 = bits.Add32(x423, x449, uint32(0x0)) + var x459 uint32 + var x460 uint32 + x459, x460 = bits.Add32(x425, x451, uint32(uint1(x458))) + var x461 uint32 + var x462 uint32 + x461, x462 = bits.Add32(x427, x453, uint32(uint1(x460))) + var x463 uint32 + var x464 uint32 + x463, x464 = bits.Add32(x429, x455, uint32(uint1(x462))) + var x465 uint32 + var x466 uint32 + x465, x466 = bits.Add32(x431, (uint32(uint1(x456)) + x444), uint32(uint1(x464))) + var x467 uint32 + var x468 uint32 + x467, x468 = bits.Add32(x433, uint32(0x0), uint32(uint1(x466))) + var x469 uint32 + var x470 uint32 + x469, x470 = bits.Add32(x435, uint32(0x0), uint32(uint1(x468))) + var x471 uint32 + var x472 uint32 + x471, x472 = bits.Add32(x437, x441, uint32(uint1(x470))) + var x473 uint32 + var x474 uint32 + x474, x473 = bits.Mul32(x6, 0x399411b) + var x475 uint32 + var x476 uint32 + x476, x475 = bits.Mul32(x6, 0x7c309a3d) + var x477 uint32 + var x478 uint32 + x478, x477 = bits.Mul32(x6, 0xceec73d2) + var x479 uint32 + var x480 uint32 + x480, x479 = bits.Mul32(x6, 0x17f5be65) + var x481 uint32 + var x482 uint32 + x482, x481 = bits.Mul32(x6, 0xd00e1ba7) + var x483 uint32 + var x484 uint32 + x484, x483 = bits.Mul32(x6, 0x68859347) + var x485 uint32 + var x486 uint32 + x486, x485 = bits.Mul32(x6, 0xa40611e3) + var x487 uint32 + var x488 uint32 + x488, x487 = bits.Mul32(x6, 0x449c0f01) + var x489 uint32 + var x490 uint32 + x489, x490 = bits.Add32(x488, x485, uint32(0x0)) + var x491 uint32 + var x492 uint32 + x491, x492 = bits.Add32(x486, x483, uint32(uint1(x490))) + var x493 uint32 + var x494 uint32 + x493, x494 = bits.Add32(x484, x481, uint32(uint1(x492))) + var x495 uint32 + var x496 uint32 + x495, x496 = bits.Add32(x482, x479, uint32(uint1(x494))) + var x497 uint32 + var x498 uint32 + x497, x498 = bits.Add32(x480, x477, uint32(uint1(x496))) + var x499 uint32 + var x500 uint32 + x499, x500 = bits.Add32(x478, x475, uint32(uint1(x498))) + var x501 uint32 + var x502 uint32 + x501, x502 = bits.Add32(x476, x473, uint32(uint1(x500))) + var x503 uint32 + var x504 uint32 + x503, x504 = bits.Add32(x459, x487, uint32(0x0)) + var x505 uint32 + var x506 uint32 + x505, x506 = bits.Add32(x461, x489, uint32(uint1(x504))) + var x507 uint32 + var x508 uint32 + x507, x508 = bits.Add32(x463, x491, uint32(uint1(x506))) + var x509 uint32 + var x510 uint32 + x509, x510 = bits.Add32(x465, x493, uint32(uint1(x508))) + var x511 uint32 + var x512 uint32 + x511, x512 = bits.Add32(x467, x495, uint32(uint1(x510))) + var x513 uint32 + var x514 uint32 + x513, x514 = bits.Add32(x469, x497, uint32(uint1(x512))) + var x515 uint32 + var x516 uint32 + x515, x516 = bits.Add32(x471, x499, uint32(uint1(x514))) + var x517 uint32 + var x518 uint32 + x517, x518 = bits.Add32(((uint32(uint1(x472)) + (uint32(uint1(x438)) + (uint32(uint1(x422)) + x394))) + x442), x501, uint32(uint1(x516))) + var x519 uint32 + _, x519 = bits.Mul32(x503, 0x12547e1b) + var x521 uint32 + var x522 uint32 + x522, x521 = bits.Mul32(x519, 0x10000000) + var x523 uint32 + var x524 uint32 + x524, x523 = bits.Mul32(x519, 0x14def9de) + var x525 uint32 + var x526 uint32 + x526, x525 = bits.Mul32(x519, 0xa2f79cd6) + var x527 uint32 + var x528 uint32 + x528, x527 = bits.Mul32(x519, 0x5812631a) + var x529 uint32 + var x530 uint32 + x530, x529 = bits.Mul32(x519, 0x5cf5d3ed) + var x531 uint32 + var x532 uint32 + x531, x532 = bits.Add32(x530, x527, uint32(0x0)) + var x533 uint32 + var x534 uint32 + x533, x534 = bits.Add32(x528, x525, uint32(uint1(x532))) + var x535 uint32 + var x536 uint32 + x535, x536 = bits.Add32(x526, x523, uint32(uint1(x534))) + var x538 uint32 + _, x538 = bits.Add32(x503, x529, uint32(0x0)) + var x539 uint32 + var x540 uint32 + x539, x540 = bits.Add32(x505, x531, uint32(uint1(x538))) + var x541 uint32 + var x542 uint32 + x541, x542 = bits.Add32(x507, x533, uint32(uint1(x540))) + var x543 uint32 + var x544 uint32 + x543, x544 = bits.Add32(x509, x535, uint32(uint1(x542))) + var x545 uint32 + var x546 uint32 + x545, x546 = bits.Add32(x511, (uint32(uint1(x536)) + x524), uint32(uint1(x544))) + var x547 uint32 + var x548 uint32 + x547, x548 = bits.Add32(x513, uint32(0x0), uint32(uint1(x546))) + var x549 uint32 + var x550 uint32 + x549, x550 = bits.Add32(x515, uint32(0x0), uint32(uint1(x548))) + var x551 uint32 + var x552 uint32 + x551, x552 = bits.Add32(x517, x521, uint32(uint1(x550))) + var x553 uint32 + var x554 uint32 + x554, x553 = bits.Mul32(x7, 0x399411b) + var x555 uint32 + var x556 uint32 + x556, x555 = bits.Mul32(x7, 0x7c309a3d) + var x557 uint32 + var x558 uint32 + x558, x557 = bits.Mul32(x7, 0xceec73d2) + var x559 uint32 + var x560 uint32 + x560, x559 = bits.Mul32(x7, 0x17f5be65) + var x561 uint32 + var x562 uint32 + x562, x561 = bits.Mul32(x7, 0xd00e1ba7) + var x563 uint32 + var x564 uint32 + x564, x563 = bits.Mul32(x7, 0x68859347) + var x565 uint32 + var x566 uint32 + x566, x565 = bits.Mul32(x7, 0xa40611e3) + var x567 uint32 + var x568 uint32 + x568, x567 = bits.Mul32(x7, 0x449c0f01) + var x569 uint32 + var x570 uint32 + x569, x570 = bits.Add32(x568, x565, uint32(0x0)) + var x571 uint32 + var x572 uint32 + x571, x572 = bits.Add32(x566, x563, uint32(uint1(x570))) + var x573 uint32 + var x574 uint32 + x573, x574 = bits.Add32(x564, x561, uint32(uint1(x572))) + var x575 uint32 + var x576 uint32 + x575, x576 = bits.Add32(x562, x559, uint32(uint1(x574))) + var x577 uint32 + var x578 uint32 + x577, x578 = bits.Add32(x560, x557, uint32(uint1(x576))) + var x579 uint32 + var x580 uint32 + x579, x580 = bits.Add32(x558, x555, uint32(uint1(x578))) + var x581 uint32 + var x582 uint32 + x581, x582 = bits.Add32(x556, x553, uint32(uint1(x580))) + var x583 uint32 + var x584 uint32 + x583, x584 = bits.Add32(x539, x567, uint32(0x0)) + var x585 uint32 + var x586 uint32 + x585, x586 = bits.Add32(x541, x569, uint32(uint1(x584))) + var x587 uint32 + var x588 uint32 + x587, x588 = bits.Add32(x543, x571, uint32(uint1(x586))) + var x589 uint32 + var x590 uint32 + x589, x590 = bits.Add32(x545, x573, uint32(uint1(x588))) + var x591 uint32 + var x592 uint32 + x591, x592 = bits.Add32(x547, x575, uint32(uint1(x590))) + var x593 uint32 + var x594 uint32 + x593, x594 = bits.Add32(x549, x577, uint32(uint1(x592))) + var x595 uint32 + var x596 uint32 + x595, x596 = bits.Add32(x551, x579, uint32(uint1(x594))) + var x597 uint32 + var x598 uint32 + x597, x598 = bits.Add32(((uint32(uint1(x552)) + (uint32(uint1(x518)) + (uint32(uint1(x502)) + x474))) + x522), x581, uint32(uint1(x596))) + var x599 uint32 + _, x599 = bits.Mul32(x583, 0x12547e1b) + var x601 uint32 + var x602 uint32 + x602, x601 = bits.Mul32(x599, 0x10000000) + var x603 uint32 + var x604 uint32 + x604, x603 = bits.Mul32(x599, 0x14def9de) + var x605 uint32 + var x606 uint32 + x606, x605 = bits.Mul32(x599, 0xa2f79cd6) + var x607 uint32 + var x608 uint32 + x608, x607 = bits.Mul32(x599, 0x5812631a) + var x609 uint32 + var x610 uint32 + x610, x609 = bits.Mul32(x599, 0x5cf5d3ed) + var x611 uint32 + var x612 uint32 + x611, x612 = bits.Add32(x610, x607, uint32(0x0)) + var x613 uint32 + var x614 uint32 + x613, x614 = bits.Add32(x608, x605, uint32(uint1(x612))) + var x615 uint32 + var x616 uint32 + x615, x616 = bits.Add32(x606, x603, uint32(uint1(x614))) + var x618 uint32 + _, x618 = bits.Add32(x583, x609, uint32(0x0)) + var x619 uint32 + var x620 uint32 + x619, x620 = bits.Add32(x585, x611, uint32(uint1(x618))) + var x621 uint32 + var x622 uint32 + x621, x622 = bits.Add32(x587, x613, uint32(uint1(x620))) + var x623 uint32 + var x624 uint32 + x623, x624 = bits.Add32(x589, x615, uint32(uint1(x622))) + var x625 uint32 + var x626 uint32 + x625, x626 = bits.Add32(x591, (uint32(uint1(x616)) + x604), uint32(uint1(x624))) + var x627 uint32 + var x628 uint32 + x627, x628 = bits.Add32(x593, uint32(0x0), uint32(uint1(x626))) + var x629 uint32 + var x630 uint32 + x629, x630 = bits.Add32(x595, uint32(0x0), uint32(uint1(x628))) + var x631 uint32 + var x632 uint32 + x631, x632 = bits.Add32(x597, x601, uint32(uint1(x630))) + x633 := ((uint32(uint1(x632)) + (uint32(uint1(x598)) + (uint32(uint1(x582)) + x554))) + x602) + var x634 uint32 + var x635 uint32 + x634, x635 = bits.Sub32(x619, 0x5cf5d3ed, uint32(0x0)) + var x636 uint32 + var x637 uint32 + x636, x637 = bits.Sub32(x621, 0x5812631a, uint32(uint1(x635))) + var x638 uint32 + var x639 uint32 + x638, x639 = bits.Sub32(x623, 0xa2f79cd6, uint32(uint1(x637))) + var x640 uint32 + var x641 uint32 + x640, x641 = bits.Sub32(x625, 0x14def9de, uint32(uint1(x639))) + var x642 uint32 + var x643 uint32 + x642, x643 = bits.Sub32(x627, uint32(0x0), uint32(uint1(x641))) + var x644 uint32 + var x645 uint32 + x644, x645 = bits.Sub32(x629, uint32(0x0), uint32(uint1(x643))) + var x646 uint32 + var x647 uint32 + x646, x647 = bits.Sub32(x631, uint32(0x0), uint32(uint1(x645))) + var x648 uint32 + var x649 uint32 + x648, x649 = bits.Sub32(x633, 0x10000000, uint32(uint1(x647))) + var x651 uint32 + _, x651 = bits.Sub32(uint32(0x0), uint32(0x0), uint32(uint1(x649))) + var x652 uint32 + cmovznzU32(&x652, uint1(x651), x634, x619) + var x653 uint32 + cmovznzU32(&x653, uint1(x651), x636, x621) + var x654 uint32 + cmovznzU32(&x654, uint1(x651), x638, x623) + var x655 uint32 + cmovznzU32(&x655, uint1(x651), x640, x625) + var x656 uint32 + cmovznzU32(&x656, uint1(x651), x642, x627) + var x657 uint32 + cmovznzU32(&x657, uint1(x651), x644, x629) + var x658 uint32 + cmovznzU32(&x658, uint1(x651), x646, x631) + var x659 uint32 + cmovznzU32(&x659, uint1(x651), x648, x633) + out1[0] = x652 + out1[1] = x653 + out1[2] = x654 + out1[3] = x655 + out1[4] = x656 + out1[5] = x657 + out1[6] = x658 + out1[7] = x659 +} + +// Nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffff] +func Nonzero(out1 *uint32, arg1 *[8]uint32) { + x1 := (arg1[0] | (arg1[1] | (arg1[2] | (arg1[3] | (arg1[4] | (arg1[5] | (arg1[6] | arg1[7]))))))) + *out1 = x1 +} + +// Selectznz is a multi-limb conditional select. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func Selectznz(out1 *[8]uint32, arg1 uint1, arg2 *[8]uint32, arg3 *[8]uint32) { + var x1 uint32 + cmovznzU32(&x1, arg1, arg2[0], arg3[0]) + var x2 uint32 + cmovznzU32(&x2, arg1, arg2[1], arg3[1]) + var x3 uint32 + cmovznzU32(&x3, arg1, arg2[2], arg3[2]) + var x4 uint32 + cmovznzU32(&x4, arg1, arg2[3], arg3[3]) + var x5 uint32 + cmovznzU32(&x5, arg1, arg2[4], arg3[4]) + var x6 uint32 + cmovznzU32(&x6, arg1, arg2[5], arg3[5]) + var x7 uint32 + cmovznzU32(&x7, arg1, arg2[6], arg3[6]) + var x8 uint32 + cmovznzU32(&x8, arg1, arg2[7], arg3[7]) + out1[0] = x1 + out1[1] = x2 + out1[2] = x3 + out1[3] = x4 + out1[4] = x5 + out1[5] = x6 + out1[6] = x7 + out1[7] = x8 +} + +// ToBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0x1fffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] +func ToBytes(out1 *[32]uint8, arg1 *[8]uint32) { + x1 := arg1[7] + x2 := arg1[6] + x3 := arg1[5] + x4 := arg1[4] + x5 := arg1[3] + x6 := arg1[2] + x7 := arg1[1] + x8 := arg1[0] + x9 := (uint8(x8) & 0xff) + x10 := (x8 >> 8) + x11 := (uint8(x10) & 0xff) + x12 := (x10 >> 8) + x13 := (uint8(x12) & 0xff) + x14 := uint8((x12 >> 8)) + x15 := (uint8(x7) & 0xff) + x16 := (x7 >> 8) + x17 := (uint8(x16) & 0xff) + x18 := (x16 >> 8) + x19 := (uint8(x18) & 0xff) + x20 := uint8((x18 >> 8)) + x21 := (uint8(x6) & 0xff) + x22 := (x6 >> 8) + x23 := (uint8(x22) & 0xff) + x24 := (x22 >> 8) + x25 := (uint8(x24) & 0xff) + x26 := uint8((x24 >> 8)) + x27 := (uint8(x5) & 0xff) + x28 := (x5 >> 8) + x29 := (uint8(x28) & 0xff) + x30 := (x28 >> 8) + x31 := (uint8(x30) & 0xff) + x32 := uint8((x30 >> 8)) + x33 := (uint8(x4) & 0xff) + x34 := (x4 >> 8) + x35 := (uint8(x34) & 0xff) + x36 := (x34 >> 8) + x37 := (uint8(x36) & 0xff) + x38 := uint8((x36 >> 8)) + x39 := (uint8(x3) & 0xff) + x40 := (x3 >> 8) + x41 := (uint8(x40) & 0xff) + x42 := (x40 >> 8) + x43 := (uint8(x42) & 0xff) + x44 := uint8((x42 >> 8)) + x45 := (uint8(x2) & 0xff) + x46 := (x2 >> 8) + x47 := (uint8(x46) & 0xff) + x48 := (x46 >> 8) + x49 := (uint8(x48) & 0xff) + x50 := uint8((x48 >> 8)) + x51 := (uint8(x1) & 0xff) + x52 := (x1 >> 8) + x53 := (uint8(x52) & 0xff) + x54 := (x52 >> 8) + x55 := (uint8(x54) & 0xff) + x56 := uint8((x54 >> 8)) + out1[0] = x9 + out1[1] = x11 + out1[2] = x13 + out1[3] = x14 + out1[4] = x15 + out1[5] = x17 + out1[6] = x19 + out1[7] = x20 + out1[8] = x21 + out1[9] = x23 + out1[10] = x25 + out1[11] = x26 + out1[12] = x27 + out1[13] = x29 + out1[14] = x31 + out1[15] = x32 + out1[16] = x33 + out1[17] = x35 + out1[18] = x37 + out1[19] = x38 + out1[20] = x39 + out1[21] = x41 + out1[22] = x43 + out1[23] = x44 + out1[24] = x45 + out1[25] = x47 + out1[26] = x49 + out1[27] = x50 + out1[28] = x51 + out1[29] = x53 + out1[30] = x55 + out1[31] = x56 +} + +// FromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +// +// Preconditions: +// 0 ≤ bytes_eval arg1 < m +// Postconditions: +// eval out1 mod m = bytes_eval arg1 mod m +// 0 ≤ eval out1 < m +// +// Input Bounds: +// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0x1fffffff]] +func FromBytes(out1 *[8]uint32, arg1 *[32]uint8) { + x1 := (uint32(arg1[31]) << 24) + x2 := (uint32(arg1[30]) << 16) + x3 := (uint32(arg1[29]) << 8) + x4 := arg1[28] + x5 := (uint32(arg1[27]) << 24) + x6 := (uint32(arg1[26]) << 16) + x7 := (uint32(arg1[25]) << 8) + x8 := arg1[24] + x9 := (uint32(arg1[23]) << 24) + x10 := (uint32(arg1[22]) << 16) + x11 := (uint32(arg1[21]) << 8) + x12 := arg1[20] + x13 := (uint32(arg1[19]) << 24) + x14 := (uint32(arg1[18]) << 16) + x15 := (uint32(arg1[17]) << 8) + x16 := arg1[16] + x17 := (uint32(arg1[15]) << 24) + x18 := (uint32(arg1[14]) << 16) + x19 := (uint32(arg1[13]) << 8) + x20 := arg1[12] + x21 := (uint32(arg1[11]) << 24) + x22 := (uint32(arg1[10]) << 16) + x23 := (uint32(arg1[9]) << 8) + x24 := arg1[8] + x25 := (uint32(arg1[7]) << 24) + x26 := (uint32(arg1[6]) << 16) + x27 := (uint32(arg1[5]) << 8) + x28 := arg1[4] + x29 := (uint32(arg1[3]) << 24) + x30 := (uint32(arg1[2]) << 16) + x31 := (uint32(arg1[1]) << 8) + x32 := arg1[0] + x33 := (x31 + uint32(x32)) + x34 := (x30 + x33) + x35 := (x29 + x34) + x36 := (x27 + uint32(x28)) + x37 := (x26 + x36) + x38 := (x25 + x37) + x39 := (x23 + uint32(x24)) + x40 := (x22 + x39) + x41 := (x21 + x40) + x42 := (x19 + uint32(x20)) + x43 := (x18 + x42) + x44 := (x17 + x43) + x45 := (x15 + uint32(x16)) + x46 := (x14 + x45) + x47 := (x13 + x46) + x48 := (x11 + uint32(x12)) + x49 := (x10 + x48) + x50 := (x9 + x49) + x51 := (x7 + uint32(x8)) + x52 := (x6 + x51) + x53 := (x5 + x52) + x54 := (x3 + uint32(x4)) + x55 := (x2 + x54) + x56 := (x1 + x55) + out1[0] = x35 + out1[1] = x38 + out1[2] = x41 + out1[3] = x44 + out1[4] = x47 + out1[5] = x50 + out1[6] = x53 + out1[7] = x56 +} + +// SetOne returns the field element one in the Montgomery domain. +// +// Postconditions: +// eval (from_montgomery out1) mod m = 1 mod m +// 0 ≤ eval out1 < m +// +func SetOne(out1 *MontgomeryDomainFieldElement) { + out1[0] = 0x8d98951d + out1[1] = 0xd6ec3174 + out1[2] = 0x737dcf70 + out1[3] = 0xc6ef5bf4 + out1[4] = 0xfffffffe + out1[5] = 0xffffffff + out1[6] = 0xffffffff + out1[7] = 0xfffffff +} + +// Msat returns the saturated representation of the prime modulus. +// +// Postconditions: +// twos_complement_eval out1 = m +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func Msat(out1 *[9]uint32) { + out1[0] = 0x5cf5d3ed + out1[1] = 0x5812631a + out1[2] = 0xa2f79cd6 + out1[3] = 0x14def9de + out1[4] = uint32(0x0) + out1[5] = uint32(0x0) + out1[6] = uint32(0x0) + out1[7] = 0x10000000 + out1[8] = uint32(0x0) +} + +// Divstep computes a divstep. +// +// Preconditions: +// 0 ≤ eval arg4 < m +// 0 ≤ eval arg5 < m +// Postconditions: +// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +// 0 ≤ eval out5 < m +// 0 ≤ eval out5 < m +// 0 ≤ eval out2 < m +// 0 ≤ eval out3 < m +// +// Input Bounds: +// arg1: [0x0 ~> 0xffffffff] +// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffff] +// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func Divstep(out1 *uint32, out2 *[9]uint32, out3 *[9]uint32, out4 *[8]uint32, out5 *[8]uint32, arg1 uint32, arg2 *[9]uint32, arg3 *[9]uint32, arg4 *[8]uint32, arg5 *[8]uint32) { + var x1 uint32 + x1, _ = bits.Add32((^arg1), uint32(0x1), uint32(0x0)) + x3 := (uint1((x1 >> 31)) & (uint1(arg3[0]) & 0x1)) + var x4 uint32 + x4, _ = bits.Add32((^arg1), uint32(0x1), uint32(0x0)) + var x6 uint32 + cmovznzU32(&x6, x3, arg1, x4) + var x7 uint32 + cmovznzU32(&x7, x3, arg2[0], arg3[0]) + var x8 uint32 + cmovznzU32(&x8, x3, arg2[1], arg3[1]) + var x9 uint32 + cmovznzU32(&x9, x3, arg2[2], arg3[2]) + var x10 uint32 + cmovznzU32(&x10, x3, arg2[3], arg3[3]) + var x11 uint32 + cmovznzU32(&x11, x3, arg2[4], arg3[4]) + var x12 uint32 + cmovznzU32(&x12, x3, arg2[5], arg3[5]) + var x13 uint32 + cmovznzU32(&x13, x3, arg2[6], arg3[6]) + var x14 uint32 + cmovznzU32(&x14, x3, arg2[7], arg3[7]) + var x15 uint32 + cmovznzU32(&x15, x3, arg2[8], arg3[8]) + var x16 uint32 + var x17 uint32 + x16, x17 = bits.Add32(uint32(0x1), (^arg2[0]), uint32(0x0)) + var x18 uint32 + var x19 uint32 + x18, x19 = bits.Add32(uint32(0x0), (^arg2[1]), uint32(uint1(x17))) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(uint32(0x0), (^arg2[2]), uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(uint32(0x0), (^arg2[3]), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(uint32(0x0), (^arg2[4]), uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(uint32(0x0), (^arg2[5]), uint32(uint1(x25))) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(uint32(0x0), (^arg2[6]), uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(uint32(0x0), (^arg2[7]), uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(uint32(0x0), (^arg2[8]), uint32(uint1(x31))) + var x34 uint32 + cmovznzU32(&x34, x3, arg3[0], x16) + var x35 uint32 + cmovznzU32(&x35, x3, arg3[1], x18) + var x36 uint32 + cmovznzU32(&x36, x3, arg3[2], x20) + var x37 uint32 + cmovznzU32(&x37, x3, arg3[3], x22) + var x38 uint32 + cmovznzU32(&x38, x3, arg3[4], x24) + var x39 uint32 + cmovznzU32(&x39, x3, arg3[5], x26) + var x40 uint32 + cmovznzU32(&x40, x3, arg3[6], x28) + var x41 uint32 + cmovznzU32(&x41, x3, arg3[7], x30) + var x42 uint32 + cmovznzU32(&x42, x3, arg3[8], x32) + var x43 uint32 + cmovznzU32(&x43, x3, arg4[0], arg5[0]) + var x44 uint32 + cmovznzU32(&x44, x3, arg4[1], arg5[1]) + var x45 uint32 + cmovznzU32(&x45, x3, arg4[2], arg5[2]) + var x46 uint32 + cmovznzU32(&x46, x3, arg4[3], arg5[3]) + var x47 uint32 + cmovznzU32(&x47, x3, arg4[4], arg5[4]) + var x48 uint32 + cmovznzU32(&x48, x3, arg4[5], arg5[5]) + var x49 uint32 + cmovznzU32(&x49, x3, arg4[6], arg5[6]) + var x50 uint32 + cmovznzU32(&x50, x3, arg4[7], arg5[7]) + var x51 uint32 + var x52 uint32 + x51, x52 = bits.Add32(x43, x43, uint32(0x0)) + var x53 uint32 + var x54 uint32 + x53, x54 = bits.Add32(x44, x44, uint32(uint1(x52))) + var x55 uint32 + var x56 uint32 + x55, x56 = bits.Add32(x45, x45, uint32(uint1(x54))) + var x57 uint32 + var x58 uint32 + x57, x58 = bits.Add32(x46, x46, uint32(uint1(x56))) + var x59 uint32 + var x60 uint32 + x59, x60 = bits.Add32(x47, x47, uint32(uint1(x58))) + var x61 uint32 + var x62 uint32 + x61, x62 = bits.Add32(x48, x48, uint32(uint1(x60))) + var x63 uint32 + var x64 uint32 + x63, x64 = bits.Add32(x49, x49, uint32(uint1(x62))) + var x65 uint32 + var x66 uint32 + x65, x66 = bits.Add32(x50, x50, uint32(uint1(x64))) + var x67 uint32 + var x68 uint32 + x67, x68 = bits.Sub32(x51, 0x5cf5d3ed, uint32(0x0)) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Sub32(x53, 0x5812631a, uint32(uint1(x68))) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Sub32(x55, 0xa2f79cd6, uint32(uint1(x70))) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Sub32(x57, 0x14def9de, uint32(uint1(x72))) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Sub32(x59, uint32(0x0), uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x77, x78 = bits.Sub32(x61, uint32(0x0), uint32(uint1(x76))) + var x79 uint32 + var x80 uint32 + x79, x80 = bits.Sub32(x63, uint32(0x0), uint32(uint1(x78))) + var x81 uint32 + var x82 uint32 + x81, x82 = bits.Sub32(x65, 0x10000000, uint32(uint1(x80))) + var x84 uint32 + _, x84 = bits.Sub32(uint32(uint1(x66)), uint32(0x0), uint32(uint1(x82))) + x85 := arg4[7] + x86 := arg4[6] + x87 := arg4[5] + x88 := arg4[4] + x89 := arg4[3] + x90 := arg4[2] + x91 := arg4[1] + x92 := arg4[0] + var x93 uint32 + var x94 uint32 + x93, x94 = bits.Sub32(uint32(0x0), x92, uint32(0x0)) + var x95 uint32 + var x96 uint32 + x95, x96 = bits.Sub32(uint32(0x0), x91, uint32(uint1(x94))) + var x97 uint32 + var x98 uint32 + x97, x98 = bits.Sub32(uint32(0x0), x90, uint32(uint1(x96))) + var x99 uint32 + var x100 uint32 + x99, x100 = bits.Sub32(uint32(0x0), x89, uint32(uint1(x98))) + var x101 uint32 + var x102 uint32 + x101, x102 = bits.Sub32(uint32(0x0), x88, uint32(uint1(x100))) + var x103 uint32 + var x104 uint32 + x103, x104 = bits.Sub32(uint32(0x0), x87, uint32(uint1(x102))) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Sub32(uint32(0x0), x86, uint32(uint1(x104))) + var x107 uint32 + var x108 uint32 + x107, x108 = bits.Sub32(uint32(0x0), x85, uint32(uint1(x106))) + var x109 uint32 + cmovznzU32(&x109, uint1(x108), uint32(0x0), 0xffffffff) + var x110 uint32 + var x111 uint32 + x110, x111 = bits.Add32(x93, (x109 & 0x5cf5d3ed), uint32(0x0)) + var x112 uint32 + var x113 uint32 + x112, x113 = bits.Add32(x95, (x109 & 0x5812631a), uint32(uint1(x111))) + var x114 uint32 + var x115 uint32 + x114, x115 = bits.Add32(x97, (x109 & 0xa2f79cd6), uint32(uint1(x113))) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32(x99, (x109 & 0x14def9de), uint32(uint1(x115))) + var x118 uint32 + var x119 uint32 + x118, x119 = bits.Add32(x101, uint32(0x0), uint32(uint1(x117))) + var x120 uint32 + var x121 uint32 + x120, x121 = bits.Add32(x103, uint32(0x0), uint32(uint1(x119))) + var x122 uint32 + var x123 uint32 + x122, x123 = bits.Add32(x105, uint32(0x0), uint32(uint1(x121))) + var x124 uint32 + x124, _ = bits.Add32(x107, (x109 & 0x10000000), uint32(uint1(x123))) + var x126 uint32 + cmovznzU32(&x126, x3, arg5[0], x110) + var x127 uint32 + cmovznzU32(&x127, x3, arg5[1], x112) + var x128 uint32 + cmovznzU32(&x128, x3, arg5[2], x114) + var x129 uint32 + cmovznzU32(&x129, x3, arg5[3], x116) + var x130 uint32 + cmovznzU32(&x130, x3, arg5[4], x118) + var x131 uint32 + cmovznzU32(&x131, x3, arg5[5], x120) + var x132 uint32 + cmovznzU32(&x132, x3, arg5[6], x122) + var x133 uint32 + cmovznzU32(&x133, x3, arg5[7], x124) + x134 := (uint1(x34) & 0x1) + var x135 uint32 + cmovznzU32(&x135, x134, uint32(0x0), x7) + var x136 uint32 + cmovznzU32(&x136, x134, uint32(0x0), x8) + var x137 uint32 + cmovznzU32(&x137, x134, uint32(0x0), x9) + var x138 uint32 + cmovznzU32(&x138, x134, uint32(0x0), x10) + var x139 uint32 + cmovznzU32(&x139, x134, uint32(0x0), x11) + var x140 uint32 + cmovznzU32(&x140, x134, uint32(0x0), x12) + var x141 uint32 + cmovznzU32(&x141, x134, uint32(0x0), x13) + var x142 uint32 + cmovznzU32(&x142, x134, uint32(0x0), x14) + var x143 uint32 + cmovznzU32(&x143, x134, uint32(0x0), x15) + var x144 uint32 + var x145 uint32 + x144, x145 = bits.Add32(x34, x135, uint32(0x0)) + var x146 uint32 + var x147 uint32 + x146, x147 = bits.Add32(x35, x136, uint32(uint1(x145))) + var x148 uint32 + var x149 uint32 + x148, x149 = bits.Add32(x36, x137, uint32(uint1(x147))) + var x150 uint32 + var x151 uint32 + x150, x151 = bits.Add32(x37, x138, uint32(uint1(x149))) + var x152 uint32 + var x153 uint32 + x152, x153 = bits.Add32(x38, x139, uint32(uint1(x151))) + var x154 uint32 + var x155 uint32 + x154, x155 = bits.Add32(x39, x140, uint32(uint1(x153))) + var x156 uint32 + var x157 uint32 + x156, x157 = bits.Add32(x40, x141, uint32(uint1(x155))) + var x158 uint32 + var x159 uint32 + x158, x159 = bits.Add32(x41, x142, uint32(uint1(x157))) + var x160 uint32 + x160, _ = bits.Add32(x42, x143, uint32(uint1(x159))) + var x162 uint32 + cmovznzU32(&x162, x134, uint32(0x0), x43) + var x163 uint32 + cmovznzU32(&x163, x134, uint32(0x0), x44) + var x164 uint32 + cmovznzU32(&x164, x134, uint32(0x0), x45) + var x165 uint32 + cmovznzU32(&x165, x134, uint32(0x0), x46) + var x166 uint32 + cmovznzU32(&x166, x134, uint32(0x0), x47) + var x167 uint32 + cmovznzU32(&x167, x134, uint32(0x0), x48) + var x168 uint32 + cmovznzU32(&x168, x134, uint32(0x0), x49) + var x169 uint32 + cmovznzU32(&x169, x134, uint32(0x0), x50) + var x170 uint32 + var x171 uint32 + x170, x171 = bits.Add32(x126, x162, uint32(0x0)) + var x172 uint32 + var x173 uint32 + x172, x173 = bits.Add32(x127, x163, uint32(uint1(x171))) + var x174 uint32 + var x175 uint32 + x174, x175 = bits.Add32(x128, x164, uint32(uint1(x173))) + var x176 uint32 + var x177 uint32 + x176, x177 = bits.Add32(x129, x165, uint32(uint1(x175))) + var x178 uint32 + var x179 uint32 + x178, x179 = bits.Add32(x130, x166, uint32(uint1(x177))) + var x180 uint32 + var x181 uint32 + x180, x181 = bits.Add32(x131, x167, uint32(uint1(x179))) + var x182 uint32 + var x183 uint32 + x182, x183 = bits.Add32(x132, x168, uint32(uint1(x181))) + var x184 uint32 + var x185 uint32 + x184, x185 = bits.Add32(x133, x169, uint32(uint1(x183))) + var x186 uint32 + var x187 uint32 + x186, x187 = bits.Sub32(x170, 0x5cf5d3ed, uint32(0x0)) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Sub32(x172, 0x5812631a, uint32(uint1(x187))) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Sub32(x174, 0xa2f79cd6, uint32(uint1(x189))) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Sub32(x176, 0x14def9de, uint32(uint1(x191))) + var x194 uint32 + var x195 uint32 + x194, x195 = bits.Sub32(x178, uint32(0x0), uint32(uint1(x193))) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Sub32(x180, uint32(0x0), uint32(uint1(x195))) + var x198 uint32 + var x199 uint32 + x198, x199 = bits.Sub32(x182, uint32(0x0), uint32(uint1(x197))) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Sub32(x184, 0x10000000, uint32(uint1(x199))) + var x203 uint32 + _, x203 = bits.Sub32(uint32(uint1(x185)), uint32(0x0), uint32(uint1(x201))) + var x204 uint32 + x204, _ = bits.Add32(x6, uint32(0x1), uint32(0x0)) + x206 := ((x144 >> 1) | ((x146 << 31) & 0xffffffff)) + x207 := ((x146 >> 1) | ((x148 << 31) & 0xffffffff)) + x208 := ((x148 >> 1) | ((x150 << 31) & 0xffffffff)) + x209 := ((x150 >> 1) | ((x152 << 31) & 0xffffffff)) + x210 := ((x152 >> 1) | ((x154 << 31) & 0xffffffff)) + x211 := ((x154 >> 1) | ((x156 << 31) & 0xffffffff)) + x212 := ((x156 >> 1) | ((x158 << 31) & 0xffffffff)) + x213 := ((x158 >> 1) | ((x160 << 31) & 0xffffffff)) + x214 := ((x160 & 0x80000000) | (x160 >> 1)) + var x215 uint32 + cmovznzU32(&x215, uint1(x84), x67, x51) + var x216 uint32 + cmovznzU32(&x216, uint1(x84), x69, x53) + var x217 uint32 + cmovznzU32(&x217, uint1(x84), x71, x55) + var x218 uint32 + cmovznzU32(&x218, uint1(x84), x73, x57) + var x219 uint32 + cmovznzU32(&x219, uint1(x84), x75, x59) + var x220 uint32 + cmovznzU32(&x220, uint1(x84), x77, x61) + var x221 uint32 + cmovznzU32(&x221, uint1(x84), x79, x63) + var x222 uint32 + cmovznzU32(&x222, uint1(x84), x81, x65) + var x223 uint32 + cmovznzU32(&x223, uint1(x203), x186, x170) + var x224 uint32 + cmovznzU32(&x224, uint1(x203), x188, x172) + var x225 uint32 + cmovznzU32(&x225, uint1(x203), x190, x174) + var x226 uint32 + cmovznzU32(&x226, uint1(x203), x192, x176) + var x227 uint32 + cmovznzU32(&x227, uint1(x203), x194, x178) + var x228 uint32 + cmovznzU32(&x228, uint1(x203), x196, x180) + var x229 uint32 + cmovznzU32(&x229, uint1(x203), x198, x182) + var x230 uint32 + cmovznzU32(&x230, uint1(x203), x200, x184) + *out1 = x204 + out2[0] = x7 + out2[1] = x8 + out2[2] = x9 + out2[3] = x10 + out2[4] = x11 + out2[5] = x12 + out2[6] = x13 + out2[7] = x14 + out2[8] = x15 + out3[0] = x206 + out3[1] = x207 + out3[2] = x208 + out3[3] = x209 + out3[4] = x210 + out3[5] = x211 + out3[6] = x212 + out3[7] = x213 + out3[8] = x214 + out4[0] = x215 + out4[1] = x216 + out4[2] = x217 + out4[3] = x218 + out4[4] = x219 + out4[5] = x220 + out4[6] = x221 + out4[7] = x222 + out5[0] = x223 + out5[1] = x224 + out5[2] = x225 + out5[3] = x226 + out5[4] = x227 + out5[5] = x228 + out5[6] = x229 + out5[7] = x230 +} + +// DivstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +// +// Postconditions: +// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func DivstepPrecomp(out1 *[8]uint32) { + out1[0] = 0x36a7cb92 + out1[1] = 0xd70af844 + out1[2] = 0xb0b8b159 + out1[3] = 0x5f71c978 + out1[4] = 0x74947f1a + out1[5] = 0xe76d8169 + out1[6] = 0xf193e4ff + out1[7] = 0x19a2d36 +} diff --git a/fiat-go/32/p256scalar/p256scalar.go b/fiat-go/32/p256scalar/p256scalar.go new file mode 100644 index 0000000000..94306c8bfa --- /dev/null +++ b/fiat-go/32/p256scalar/p256scalar.go @@ -0,0 +1,5171 @@ +// Code generated by Fiat Cryptography. DO NOT EDIT. +// +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Go --relax-primitive-carry-to-bitwidth 32,64 --cmovznz-by-mul --internal-static --package-case flatcase --public-function-case UpperCamelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case camelCase --no-prefix-fiat --doc-newline-in-typedef-bounds --doc-prepend-header 'Code generated by Fiat Cryptography. DO NOT EDIT.' --doc-text-before-function-name '' --doc-text-before-type-name '' --package-name p256scalar '' 32 '2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// +// curve description (via package name): p256scalar +// +// machine_wordsize = 32 (from "32") +// +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// +// m = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 (from "2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247") +// +// +// +// NOTE: In addition to the bounds specified above each function, all +// +// functions synthesized for this Montgomery arithmetic require the +// +// input to be strictly less than the prime modulus (m), and also +// +// require the input to be in the unique saturated representation. +// +// All functions also ensure that these two properties are true of +// +// return values. +// +// +// +// Computed values: +// +// eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) +// +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +// +// twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in +// +// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 +package p256scalar + +import "math/bits" + +type uint1 uint64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 +type int1 int64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 + +// MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +type MontgomeryDomainFieldElement [8]uint32 + +// NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +type NonMontgomeryDomainFieldElement [8]uint32 + +// cmovznzU32 is a single-word conditional move. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [0x0 ~> 0xffffffff] +// arg3: [0x0 ~> 0xffffffff] +// Output Bounds: +// out1: [0x0 ~> 0xffffffff] +func cmovznzU32(out1 *uint32, arg1 uint1, arg2 uint32, arg3 uint32) { + x1 := (uint32(arg1) * 0xffffffff) + x2 := ((x1 & arg3) | ((^x1) & arg2)) + *out1 = x2 +} + +// Mul multiplies two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Mul(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[6] + x7 := arg1[7] + x8 := arg1[0] + var x9 uint32 + var x10 uint32 + x10, x9 = bits.Mul32(x8, arg2[7]) + var x11 uint32 + var x12 uint32 + x12, x11 = bits.Mul32(x8, arg2[6]) + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x8, arg2[5]) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x8, arg2[4]) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x8, arg2[3]) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x8, arg2[2]) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x8, arg2[1]) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x8, arg2[0]) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Add32(x24, x21, uint32(0x0)) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Add32(x22, x19, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Add32(x20, x17, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Add32(x18, x15, uint32(uint1(x30))) + var x33 uint32 + var x34 uint32 + x33, x34 = bits.Add32(x16, x13, uint32(uint1(x32))) + var x35 uint32 + var x36 uint32 + x35, x36 = bits.Add32(x14, x11, uint32(uint1(x34))) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Add32(x12, x9, uint32(uint1(x36))) + x39 := (uint32(uint1(x38)) + x10) + var x40 uint32 + _, x40 = bits.Mul32(x23, 0xee00bc4f) + var x42 uint32 + var x43 uint32 + x43, x42 = bits.Mul32(x40, 0xffffffff) + var x44 uint32 + var x45 uint32 + x45, x44 = bits.Mul32(x40, 0xffffffff) + var x46 uint32 + var x47 uint32 + x47, x46 = bits.Mul32(x40, 0xffffffff) + var x48 uint32 + var x49 uint32 + x49, x48 = bits.Mul32(x40, 0xbce6faad) + var x50 uint32 + var x51 uint32 + x51, x50 = bits.Mul32(x40, 0xa7179e84) + var x52 uint32 + var x53 uint32 + x53, x52 = bits.Mul32(x40, 0xf3b9cac2) + var x54 uint32 + var x55 uint32 + x55, x54 = bits.Mul32(x40, 0xfc632551) + var x56 uint32 + var x57 uint32 + x56, x57 = bits.Add32(x55, x52, uint32(0x0)) + var x58 uint32 + var x59 uint32 + x58, x59 = bits.Add32(x53, x50, uint32(uint1(x57))) + var x60 uint32 + var x61 uint32 + x60, x61 = bits.Add32(x51, x48, uint32(uint1(x59))) + var x62 uint32 + var x63 uint32 + x62, x63 = bits.Add32(x49, x46, uint32(uint1(x61))) + var x64 uint32 + var x65 uint32 + x64, x65 = bits.Add32(x47, x44, uint32(uint1(x63))) + x66 := (uint32(uint1(x65)) + x45) + var x68 uint32 + _, x68 = bits.Add32(x23, x54, uint32(0x0)) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Add32(x25, x56, uint32(uint1(x68))) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Add32(x27, x58, uint32(uint1(x70))) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Add32(x29, x60, uint32(uint1(x72))) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Add32(x31, x62, uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x77, x78 = bits.Add32(x33, x64, uint32(uint1(x76))) + var x79 uint32 + var x80 uint32 + x79, x80 = bits.Add32(x35, x66, uint32(uint1(x78))) + var x81 uint32 + var x82 uint32 + x81, x82 = bits.Add32(x37, x42, uint32(uint1(x80))) + var x83 uint32 + var x84 uint32 + x83, x84 = bits.Add32(x39, x43, uint32(uint1(x82))) + var x85 uint32 + var x86 uint32 + x86, x85 = bits.Mul32(x1, arg2[7]) + var x87 uint32 + var x88 uint32 + x88, x87 = bits.Mul32(x1, arg2[6]) + var x89 uint32 + var x90 uint32 + x90, x89 = bits.Mul32(x1, arg2[5]) + var x91 uint32 + var x92 uint32 + x92, x91 = bits.Mul32(x1, arg2[4]) + var x93 uint32 + var x94 uint32 + x94, x93 = bits.Mul32(x1, arg2[3]) + var x95 uint32 + var x96 uint32 + x96, x95 = bits.Mul32(x1, arg2[2]) + var x97 uint32 + var x98 uint32 + x98, x97 = bits.Mul32(x1, arg2[1]) + var x99 uint32 + var x100 uint32 + x100, x99 = bits.Mul32(x1, arg2[0]) + var x101 uint32 + var x102 uint32 + x101, x102 = bits.Add32(x100, x97, uint32(0x0)) + var x103 uint32 + var x104 uint32 + x103, x104 = bits.Add32(x98, x95, uint32(uint1(x102))) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Add32(x96, x93, uint32(uint1(x104))) + var x107 uint32 + var x108 uint32 + x107, x108 = bits.Add32(x94, x91, uint32(uint1(x106))) + var x109 uint32 + var x110 uint32 + x109, x110 = bits.Add32(x92, x89, uint32(uint1(x108))) + var x111 uint32 + var x112 uint32 + x111, x112 = bits.Add32(x90, x87, uint32(uint1(x110))) + var x113 uint32 + var x114 uint32 + x113, x114 = bits.Add32(x88, x85, uint32(uint1(x112))) + x115 := (uint32(uint1(x114)) + x86) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32(x69, x99, uint32(0x0)) + var x118 uint32 + var x119 uint32 + x118, x119 = bits.Add32(x71, x101, uint32(uint1(x117))) + var x120 uint32 + var x121 uint32 + x120, x121 = bits.Add32(x73, x103, uint32(uint1(x119))) + var x122 uint32 + var x123 uint32 + x122, x123 = bits.Add32(x75, x105, uint32(uint1(x121))) + var x124 uint32 + var x125 uint32 + x124, x125 = bits.Add32(x77, x107, uint32(uint1(x123))) + var x126 uint32 + var x127 uint32 + x126, x127 = bits.Add32(x79, x109, uint32(uint1(x125))) + var x128 uint32 + var x129 uint32 + x128, x129 = bits.Add32(x81, x111, uint32(uint1(x127))) + var x130 uint32 + var x131 uint32 + x130, x131 = bits.Add32(x83, x113, uint32(uint1(x129))) + var x132 uint32 + var x133 uint32 + x132, x133 = bits.Add32(uint32(uint1(x84)), x115, uint32(uint1(x131))) + var x134 uint32 + _, x134 = bits.Mul32(x116, 0xee00bc4f) + var x136 uint32 + var x137 uint32 + x137, x136 = bits.Mul32(x134, 0xffffffff) + var x138 uint32 + var x139 uint32 + x139, x138 = bits.Mul32(x134, 0xffffffff) + var x140 uint32 + var x141 uint32 + x141, x140 = bits.Mul32(x134, 0xffffffff) + var x142 uint32 + var x143 uint32 + x143, x142 = bits.Mul32(x134, 0xbce6faad) + var x144 uint32 + var x145 uint32 + x145, x144 = bits.Mul32(x134, 0xa7179e84) + var x146 uint32 + var x147 uint32 + x147, x146 = bits.Mul32(x134, 0xf3b9cac2) + var x148 uint32 + var x149 uint32 + x149, x148 = bits.Mul32(x134, 0xfc632551) + var x150 uint32 + var x151 uint32 + x150, x151 = bits.Add32(x149, x146, uint32(0x0)) + var x152 uint32 + var x153 uint32 + x152, x153 = bits.Add32(x147, x144, uint32(uint1(x151))) + var x154 uint32 + var x155 uint32 + x154, x155 = bits.Add32(x145, x142, uint32(uint1(x153))) + var x156 uint32 + var x157 uint32 + x156, x157 = bits.Add32(x143, x140, uint32(uint1(x155))) + var x158 uint32 + var x159 uint32 + x158, x159 = bits.Add32(x141, x138, uint32(uint1(x157))) + x160 := (uint32(uint1(x159)) + x139) + var x162 uint32 + _, x162 = bits.Add32(x116, x148, uint32(0x0)) + var x163 uint32 + var x164 uint32 + x163, x164 = bits.Add32(x118, x150, uint32(uint1(x162))) + var x165 uint32 + var x166 uint32 + x165, x166 = bits.Add32(x120, x152, uint32(uint1(x164))) + var x167 uint32 + var x168 uint32 + x167, x168 = bits.Add32(x122, x154, uint32(uint1(x166))) + var x169 uint32 + var x170 uint32 + x169, x170 = bits.Add32(x124, x156, uint32(uint1(x168))) + var x171 uint32 + var x172 uint32 + x171, x172 = bits.Add32(x126, x158, uint32(uint1(x170))) + var x173 uint32 + var x174 uint32 + x173, x174 = bits.Add32(x128, x160, uint32(uint1(x172))) + var x175 uint32 + var x176 uint32 + x175, x176 = bits.Add32(x130, x136, uint32(uint1(x174))) + var x177 uint32 + var x178 uint32 + x177, x178 = bits.Add32(x132, x137, uint32(uint1(x176))) + x179 := (uint32(uint1(x178)) + uint32(uint1(x133))) + var x180 uint32 + var x181 uint32 + x181, x180 = bits.Mul32(x2, arg2[7]) + var x182 uint32 + var x183 uint32 + x183, x182 = bits.Mul32(x2, arg2[6]) + var x184 uint32 + var x185 uint32 + x185, x184 = bits.Mul32(x2, arg2[5]) + var x186 uint32 + var x187 uint32 + x187, x186 = bits.Mul32(x2, arg2[4]) + var x188 uint32 + var x189 uint32 + x189, x188 = bits.Mul32(x2, arg2[3]) + var x190 uint32 + var x191 uint32 + x191, x190 = bits.Mul32(x2, arg2[2]) + var x192 uint32 + var x193 uint32 + x193, x192 = bits.Mul32(x2, arg2[1]) + var x194 uint32 + var x195 uint32 + x195, x194 = bits.Mul32(x2, arg2[0]) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Add32(x195, x192, uint32(0x0)) + var x198 uint32 + var x199 uint32 + x198, x199 = bits.Add32(x193, x190, uint32(uint1(x197))) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Add32(x191, x188, uint32(uint1(x199))) + var x202 uint32 + var x203 uint32 + x202, x203 = bits.Add32(x189, x186, uint32(uint1(x201))) + var x204 uint32 + var x205 uint32 + x204, x205 = bits.Add32(x187, x184, uint32(uint1(x203))) + var x206 uint32 + var x207 uint32 + x206, x207 = bits.Add32(x185, x182, uint32(uint1(x205))) + var x208 uint32 + var x209 uint32 + x208, x209 = bits.Add32(x183, x180, uint32(uint1(x207))) + x210 := (uint32(uint1(x209)) + x181) + var x211 uint32 + var x212 uint32 + x211, x212 = bits.Add32(x163, x194, uint32(0x0)) + var x213 uint32 + var x214 uint32 + x213, x214 = bits.Add32(x165, x196, uint32(uint1(x212))) + var x215 uint32 + var x216 uint32 + x215, x216 = bits.Add32(x167, x198, uint32(uint1(x214))) + var x217 uint32 + var x218 uint32 + x217, x218 = bits.Add32(x169, x200, uint32(uint1(x216))) + var x219 uint32 + var x220 uint32 + x219, x220 = bits.Add32(x171, x202, uint32(uint1(x218))) + var x221 uint32 + var x222 uint32 + x221, x222 = bits.Add32(x173, x204, uint32(uint1(x220))) + var x223 uint32 + var x224 uint32 + x223, x224 = bits.Add32(x175, x206, uint32(uint1(x222))) + var x225 uint32 + var x226 uint32 + x225, x226 = bits.Add32(x177, x208, uint32(uint1(x224))) + var x227 uint32 + var x228 uint32 + x227, x228 = bits.Add32(x179, x210, uint32(uint1(x226))) + var x229 uint32 + _, x229 = bits.Mul32(x211, 0xee00bc4f) + var x231 uint32 + var x232 uint32 + x232, x231 = bits.Mul32(x229, 0xffffffff) + var x233 uint32 + var x234 uint32 + x234, x233 = bits.Mul32(x229, 0xffffffff) + var x235 uint32 + var x236 uint32 + x236, x235 = bits.Mul32(x229, 0xffffffff) + var x237 uint32 + var x238 uint32 + x238, x237 = bits.Mul32(x229, 0xbce6faad) + var x239 uint32 + var x240 uint32 + x240, x239 = bits.Mul32(x229, 0xa7179e84) + var x241 uint32 + var x242 uint32 + x242, x241 = bits.Mul32(x229, 0xf3b9cac2) + var x243 uint32 + var x244 uint32 + x244, x243 = bits.Mul32(x229, 0xfc632551) + var x245 uint32 + var x246 uint32 + x245, x246 = bits.Add32(x244, x241, uint32(0x0)) + var x247 uint32 + var x248 uint32 + x247, x248 = bits.Add32(x242, x239, uint32(uint1(x246))) + var x249 uint32 + var x250 uint32 + x249, x250 = bits.Add32(x240, x237, uint32(uint1(x248))) + var x251 uint32 + var x252 uint32 + x251, x252 = bits.Add32(x238, x235, uint32(uint1(x250))) + var x253 uint32 + var x254 uint32 + x253, x254 = bits.Add32(x236, x233, uint32(uint1(x252))) + x255 := (uint32(uint1(x254)) + x234) + var x257 uint32 + _, x257 = bits.Add32(x211, x243, uint32(0x0)) + var x258 uint32 + var x259 uint32 + x258, x259 = bits.Add32(x213, x245, uint32(uint1(x257))) + var x260 uint32 + var x261 uint32 + x260, x261 = bits.Add32(x215, x247, uint32(uint1(x259))) + var x262 uint32 + var x263 uint32 + x262, x263 = bits.Add32(x217, x249, uint32(uint1(x261))) + var x264 uint32 + var x265 uint32 + x264, x265 = bits.Add32(x219, x251, uint32(uint1(x263))) + var x266 uint32 + var x267 uint32 + x266, x267 = bits.Add32(x221, x253, uint32(uint1(x265))) + var x268 uint32 + var x269 uint32 + x268, x269 = bits.Add32(x223, x255, uint32(uint1(x267))) + var x270 uint32 + var x271 uint32 + x270, x271 = bits.Add32(x225, x231, uint32(uint1(x269))) + var x272 uint32 + var x273 uint32 + x272, x273 = bits.Add32(x227, x232, uint32(uint1(x271))) + x274 := (uint32(uint1(x273)) + uint32(uint1(x228))) + var x275 uint32 + var x276 uint32 + x276, x275 = bits.Mul32(x3, arg2[7]) + var x277 uint32 + var x278 uint32 + x278, x277 = bits.Mul32(x3, arg2[6]) + var x279 uint32 + var x280 uint32 + x280, x279 = bits.Mul32(x3, arg2[5]) + var x281 uint32 + var x282 uint32 + x282, x281 = bits.Mul32(x3, arg2[4]) + var x283 uint32 + var x284 uint32 + x284, x283 = bits.Mul32(x3, arg2[3]) + var x285 uint32 + var x286 uint32 + x286, x285 = bits.Mul32(x3, arg2[2]) + var x287 uint32 + var x288 uint32 + x288, x287 = bits.Mul32(x3, arg2[1]) + var x289 uint32 + var x290 uint32 + x290, x289 = bits.Mul32(x3, arg2[0]) + var x291 uint32 + var x292 uint32 + x291, x292 = bits.Add32(x290, x287, uint32(0x0)) + var x293 uint32 + var x294 uint32 + x293, x294 = bits.Add32(x288, x285, uint32(uint1(x292))) + var x295 uint32 + var x296 uint32 + x295, x296 = bits.Add32(x286, x283, uint32(uint1(x294))) + var x297 uint32 + var x298 uint32 + x297, x298 = bits.Add32(x284, x281, uint32(uint1(x296))) + var x299 uint32 + var x300 uint32 + x299, x300 = bits.Add32(x282, x279, uint32(uint1(x298))) + var x301 uint32 + var x302 uint32 + x301, x302 = bits.Add32(x280, x277, uint32(uint1(x300))) + var x303 uint32 + var x304 uint32 + x303, x304 = bits.Add32(x278, x275, uint32(uint1(x302))) + x305 := (uint32(uint1(x304)) + x276) + var x306 uint32 + var x307 uint32 + x306, x307 = bits.Add32(x258, x289, uint32(0x0)) + var x308 uint32 + var x309 uint32 + x308, x309 = bits.Add32(x260, x291, uint32(uint1(x307))) + var x310 uint32 + var x311 uint32 + x310, x311 = bits.Add32(x262, x293, uint32(uint1(x309))) + var x312 uint32 + var x313 uint32 + x312, x313 = bits.Add32(x264, x295, uint32(uint1(x311))) + var x314 uint32 + var x315 uint32 + x314, x315 = bits.Add32(x266, x297, uint32(uint1(x313))) + var x316 uint32 + var x317 uint32 + x316, x317 = bits.Add32(x268, x299, uint32(uint1(x315))) + var x318 uint32 + var x319 uint32 + x318, x319 = bits.Add32(x270, x301, uint32(uint1(x317))) + var x320 uint32 + var x321 uint32 + x320, x321 = bits.Add32(x272, x303, uint32(uint1(x319))) + var x322 uint32 + var x323 uint32 + x322, x323 = bits.Add32(x274, x305, uint32(uint1(x321))) + var x324 uint32 + _, x324 = bits.Mul32(x306, 0xee00bc4f) + var x326 uint32 + var x327 uint32 + x327, x326 = bits.Mul32(x324, 0xffffffff) + var x328 uint32 + var x329 uint32 + x329, x328 = bits.Mul32(x324, 0xffffffff) + var x330 uint32 + var x331 uint32 + x331, x330 = bits.Mul32(x324, 0xffffffff) + var x332 uint32 + var x333 uint32 + x333, x332 = bits.Mul32(x324, 0xbce6faad) + var x334 uint32 + var x335 uint32 + x335, x334 = bits.Mul32(x324, 0xa7179e84) + var x336 uint32 + var x337 uint32 + x337, x336 = bits.Mul32(x324, 0xf3b9cac2) + var x338 uint32 + var x339 uint32 + x339, x338 = bits.Mul32(x324, 0xfc632551) + var x340 uint32 + var x341 uint32 + x340, x341 = bits.Add32(x339, x336, uint32(0x0)) + var x342 uint32 + var x343 uint32 + x342, x343 = bits.Add32(x337, x334, uint32(uint1(x341))) + var x344 uint32 + var x345 uint32 + x344, x345 = bits.Add32(x335, x332, uint32(uint1(x343))) + var x346 uint32 + var x347 uint32 + x346, x347 = bits.Add32(x333, x330, uint32(uint1(x345))) + var x348 uint32 + var x349 uint32 + x348, x349 = bits.Add32(x331, x328, uint32(uint1(x347))) + x350 := (uint32(uint1(x349)) + x329) + var x352 uint32 + _, x352 = bits.Add32(x306, x338, uint32(0x0)) + var x353 uint32 + var x354 uint32 + x353, x354 = bits.Add32(x308, x340, uint32(uint1(x352))) + var x355 uint32 + var x356 uint32 + x355, x356 = bits.Add32(x310, x342, uint32(uint1(x354))) + var x357 uint32 + var x358 uint32 + x357, x358 = bits.Add32(x312, x344, uint32(uint1(x356))) + var x359 uint32 + var x360 uint32 + x359, x360 = bits.Add32(x314, x346, uint32(uint1(x358))) + var x361 uint32 + var x362 uint32 + x361, x362 = bits.Add32(x316, x348, uint32(uint1(x360))) + var x363 uint32 + var x364 uint32 + x363, x364 = bits.Add32(x318, x350, uint32(uint1(x362))) + var x365 uint32 + var x366 uint32 + x365, x366 = bits.Add32(x320, x326, uint32(uint1(x364))) + var x367 uint32 + var x368 uint32 + x367, x368 = bits.Add32(x322, x327, uint32(uint1(x366))) + x369 := (uint32(uint1(x368)) + uint32(uint1(x323))) + var x370 uint32 + var x371 uint32 + x371, x370 = bits.Mul32(x4, arg2[7]) + var x372 uint32 + var x373 uint32 + x373, x372 = bits.Mul32(x4, arg2[6]) + var x374 uint32 + var x375 uint32 + x375, x374 = bits.Mul32(x4, arg2[5]) + var x376 uint32 + var x377 uint32 + x377, x376 = bits.Mul32(x4, arg2[4]) + var x378 uint32 + var x379 uint32 + x379, x378 = bits.Mul32(x4, arg2[3]) + var x380 uint32 + var x381 uint32 + x381, x380 = bits.Mul32(x4, arg2[2]) + var x382 uint32 + var x383 uint32 + x383, x382 = bits.Mul32(x4, arg2[1]) + var x384 uint32 + var x385 uint32 + x385, x384 = bits.Mul32(x4, arg2[0]) + var x386 uint32 + var x387 uint32 + x386, x387 = bits.Add32(x385, x382, uint32(0x0)) + var x388 uint32 + var x389 uint32 + x388, x389 = bits.Add32(x383, x380, uint32(uint1(x387))) + var x390 uint32 + var x391 uint32 + x390, x391 = bits.Add32(x381, x378, uint32(uint1(x389))) + var x392 uint32 + var x393 uint32 + x392, x393 = bits.Add32(x379, x376, uint32(uint1(x391))) + var x394 uint32 + var x395 uint32 + x394, x395 = bits.Add32(x377, x374, uint32(uint1(x393))) + var x396 uint32 + var x397 uint32 + x396, x397 = bits.Add32(x375, x372, uint32(uint1(x395))) + var x398 uint32 + var x399 uint32 + x398, x399 = bits.Add32(x373, x370, uint32(uint1(x397))) + x400 := (uint32(uint1(x399)) + x371) + var x401 uint32 + var x402 uint32 + x401, x402 = bits.Add32(x353, x384, uint32(0x0)) + var x403 uint32 + var x404 uint32 + x403, x404 = bits.Add32(x355, x386, uint32(uint1(x402))) + var x405 uint32 + var x406 uint32 + x405, x406 = bits.Add32(x357, x388, uint32(uint1(x404))) + var x407 uint32 + var x408 uint32 + x407, x408 = bits.Add32(x359, x390, uint32(uint1(x406))) + var x409 uint32 + var x410 uint32 + x409, x410 = bits.Add32(x361, x392, uint32(uint1(x408))) + var x411 uint32 + var x412 uint32 + x411, x412 = bits.Add32(x363, x394, uint32(uint1(x410))) + var x413 uint32 + var x414 uint32 + x413, x414 = bits.Add32(x365, x396, uint32(uint1(x412))) + var x415 uint32 + var x416 uint32 + x415, x416 = bits.Add32(x367, x398, uint32(uint1(x414))) + var x417 uint32 + var x418 uint32 + x417, x418 = bits.Add32(x369, x400, uint32(uint1(x416))) + var x419 uint32 + _, x419 = bits.Mul32(x401, 0xee00bc4f) + var x421 uint32 + var x422 uint32 + x422, x421 = bits.Mul32(x419, 0xffffffff) + var x423 uint32 + var x424 uint32 + x424, x423 = bits.Mul32(x419, 0xffffffff) + var x425 uint32 + var x426 uint32 + x426, x425 = bits.Mul32(x419, 0xffffffff) + var x427 uint32 + var x428 uint32 + x428, x427 = bits.Mul32(x419, 0xbce6faad) + var x429 uint32 + var x430 uint32 + x430, x429 = bits.Mul32(x419, 0xa7179e84) + var x431 uint32 + var x432 uint32 + x432, x431 = bits.Mul32(x419, 0xf3b9cac2) + var x433 uint32 + var x434 uint32 + x434, x433 = bits.Mul32(x419, 0xfc632551) + var x435 uint32 + var x436 uint32 + x435, x436 = bits.Add32(x434, x431, uint32(0x0)) + var x437 uint32 + var x438 uint32 + x437, x438 = bits.Add32(x432, x429, uint32(uint1(x436))) + var x439 uint32 + var x440 uint32 + x439, x440 = bits.Add32(x430, x427, uint32(uint1(x438))) + var x441 uint32 + var x442 uint32 + x441, x442 = bits.Add32(x428, x425, uint32(uint1(x440))) + var x443 uint32 + var x444 uint32 + x443, x444 = bits.Add32(x426, x423, uint32(uint1(x442))) + x445 := (uint32(uint1(x444)) + x424) + var x447 uint32 + _, x447 = bits.Add32(x401, x433, uint32(0x0)) + var x448 uint32 + var x449 uint32 + x448, x449 = bits.Add32(x403, x435, uint32(uint1(x447))) + var x450 uint32 + var x451 uint32 + x450, x451 = bits.Add32(x405, x437, uint32(uint1(x449))) + var x452 uint32 + var x453 uint32 + x452, x453 = bits.Add32(x407, x439, uint32(uint1(x451))) + var x454 uint32 + var x455 uint32 + x454, x455 = bits.Add32(x409, x441, uint32(uint1(x453))) + var x456 uint32 + var x457 uint32 + x456, x457 = bits.Add32(x411, x443, uint32(uint1(x455))) + var x458 uint32 + var x459 uint32 + x458, x459 = bits.Add32(x413, x445, uint32(uint1(x457))) + var x460 uint32 + var x461 uint32 + x460, x461 = bits.Add32(x415, x421, uint32(uint1(x459))) + var x462 uint32 + var x463 uint32 + x462, x463 = bits.Add32(x417, x422, uint32(uint1(x461))) + x464 := (uint32(uint1(x463)) + uint32(uint1(x418))) + var x465 uint32 + var x466 uint32 + x466, x465 = bits.Mul32(x5, arg2[7]) + var x467 uint32 + var x468 uint32 + x468, x467 = bits.Mul32(x5, arg2[6]) + var x469 uint32 + var x470 uint32 + x470, x469 = bits.Mul32(x5, arg2[5]) + var x471 uint32 + var x472 uint32 + x472, x471 = bits.Mul32(x5, arg2[4]) + var x473 uint32 + var x474 uint32 + x474, x473 = bits.Mul32(x5, arg2[3]) + var x475 uint32 + var x476 uint32 + x476, x475 = bits.Mul32(x5, arg2[2]) + var x477 uint32 + var x478 uint32 + x478, x477 = bits.Mul32(x5, arg2[1]) + var x479 uint32 + var x480 uint32 + x480, x479 = bits.Mul32(x5, arg2[0]) + var x481 uint32 + var x482 uint32 + x481, x482 = bits.Add32(x480, x477, uint32(0x0)) + var x483 uint32 + var x484 uint32 + x483, x484 = bits.Add32(x478, x475, uint32(uint1(x482))) + var x485 uint32 + var x486 uint32 + x485, x486 = bits.Add32(x476, x473, uint32(uint1(x484))) + var x487 uint32 + var x488 uint32 + x487, x488 = bits.Add32(x474, x471, uint32(uint1(x486))) + var x489 uint32 + var x490 uint32 + x489, x490 = bits.Add32(x472, x469, uint32(uint1(x488))) + var x491 uint32 + var x492 uint32 + x491, x492 = bits.Add32(x470, x467, uint32(uint1(x490))) + var x493 uint32 + var x494 uint32 + x493, x494 = bits.Add32(x468, x465, uint32(uint1(x492))) + x495 := (uint32(uint1(x494)) + x466) + var x496 uint32 + var x497 uint32 + x496, x497 = bits.Add32(x448, x479, uint32(0x0)) + var x498 uint32 + var x499 uint32 + x498, x499 = bits.Add32(x450, x481, uint32(uint1(x497))) + var x500 uint32 + var x501 uint32 + x500, x501 = bits.Add32(x452, x483, uint32(uint1(x499))) + var x502 uint32 + var x503 uint32 + x502, x503 = bits.Add32(x454, x485, uint32(uint1(x501))) + var x504 uint32 + var x505 uint32 + x504, x505 = bits.Add32(x456, x487, uint32(uint1(x503))) + var x506 uint32 + var x507 uint32 + x506, x507 = bits.Add32(x458, x489, uint32(uint1(x505))) + var x508 uint32 + var x509 uint32 + x508, x509 = bits.Add32(x460, x491, uint32(uint1(x507))) + var x510 uint32 + var x511 uint32 + x510, x511 = bits.Add32(x462, x493, uint32(uint1(x509))) + var x512 uint32 + var x513 uint32 + x512, x513 = bits.Add32(x464, x495, uint32(uint1(x511))) + var x514 uint32 + _, x514 = bits.Mul32(x496, 0xee00bc4f) + var x516 uint32 + var x517 uint32 + x517, x516 = bits.Mul32(x514, 0xffffffff) + var x518 uint32 + var x519 uint32 + x519, x518 = bits.Mul32(x514, 0xffffffff) + var x520 uint32 + var x521 uint32 + x521, x520 = bits.Mul32(x514, 0xffffffff) + var x522 uint32 + var x523 uint32 + x523, x522 = bits.Mul32(x514, 0xbce6faad) + var x524 uint32 + var x525 uint32 + x525, x524 = bits.Mul32(x514, 0xa7179e84) + var x526 uint32 + var x527 uint32 + x527, x526 = bits.Mul32(x514, 0xf3b9cac2) + var x528 uint32 + var x529 uint32 + x529, x528 = bits.Mul32(x514, 0xfc632551) + var x530 uint32 + var x531 uint32 + x530, x531 = bits.Add32(x529, x526, uint32(0x0)) + var x532 uint32 + var x533 uint32 + x532, x533 = bits.Add32(x527, x524, uint32(uint1(x531))) + var x534 uint32 + var x535 uint32 + x534, x535 = bits.Add32(x525, x522, uint32(uint1(x533))) + var x536 uint32 + var x537 uint32 + x536, x537 = bits.Add32(x523, x520, uint32(uint1(x535))) + var x538 uint32 + var x539 uint32 + x538, x539 = bits.Add32(x521, x518, uint32(uint1(x537))) + x540 := (uint32(uint1(x539)) + x519) + var x542 uint32 + _, x542 = bits.Add32(x496, x528, uint32(0x0)) + var x543 uint32 + var x544 uint32 + x543, x544 = bits.Add32(x498, x530, uint32(uint1(x542))) + var x545 uint32 + var x546 uint32 + x545, x546 = bits.Add32(x500, x532, uint32(uint1(x544))) + var x547 uint32 + var x548 uint32 + x547, x548 = bits.Add32(x502, x534, uint32(uint1(x546))) + var x549 uint32 + var x550 uint32 + x549, x550 = bits.Add32(x504, x536, uint32(uint1(x548))) + var x551 uint32 + var x552 uint32 + x551, x552 = bits.Add32(x506, x538, uint32(uint1(x550))) + var x553 uint32 + var x554 uint32 + x553, x554 = bits.Add32(x508, x540, uint32(uint1(x552))) + var x555 uint32 + var x556 uint32 + x555, x556 = bits.Add32(x510, x516, uint32(uint1(x554))) + var x557 uint32 + var x558 uint32 + x557, x558 = bits.Add32(x512, x517, uint32(uint1(x556))) + x559 := (uint32(uint1(x558)) + uint32(uint1(x513))) + var x560 uint32 + var x561 uint32 + x561, x560 = bits.Mul32(x6, arg2[7]) + var x562 uint32 + var x563 uint32 + x563, x562 = bits.Mul32(x6, arg2[6]) + var x564 uint32 + var x565 uint32 + x565, x564 = bits.Mul32(x6, arg2[5]) + var x566 uint32 + var x567 uint32 + x567, x566 = bits.Mul32(x6, arg2[4]) + var x568 uint32 + var x569 uint32 + x569, x568 = bits.Mul32(x6, arg2[3]) + var x570 uint32 + var x571 uint32 + x571, x570 = bits.Mul32(x6, arg2[2]) + var x572 uint32 + var x573 uint32 + x573, x572 = bits.Mul32(x6, arg2[1]) + var x574 uint32 + var x575 uint32 + x575, x574 = bits.Mul32(x6, arg2[0]) + var x576 uint32 + var x577 uint32 + x576, x577 = bits.Add32(x575, x572, uint32(0x0)) + var x578 uint32 + var x579 uint32 + x578, x579 = bits.Add32(x573, x570, uint32(uint1(x577))) + var x580 uint32 + var x581 uint32 + x580, x581 = bits.Add32(x571, x568, uint32(uint1(x579))) + var x582 uint32 + var x583 uint32 + x582, x583 = bits.Add32(x569, x566, uint32(uint1(x581))) + var x584 uint32 + var x585 uint32 + x584, x585 = bits.Add32(x567, x564, uint32(uint1(x583))) + var x586 uint32 + var x587 uint32 + x586, x587 = bits.Add32(x565, x562, uint32(uint1(x585))) + var x588 uint32 + var x589 uint32 + x588, x589 = bits.Add32(x563, x560, uint32(uint1(x587))) + x590 := (uint32(uint1(x589)) + x561) + var x591 uint32 + var x592 uint32 + x591, x592 = bits.Add32(x543, x574, uint32(0x0)) + var x593 uint32 + var x594 uint32 + x593, x594 = bits.Add32(x545, x576, uint32(uint1(x592))) + var x595 uint32 + var x596 uint32 + x595, x596 = bits.Add32(x547, x578, uint32(uint1(x594))) + var x597 uint32 + var x598 uint32 + x597, x598 = bits.Add32(x549, x580, uint32(uint1(x596))) + var x599 uint32 + var x600 uint32 + x599, x600 = bits.Add32(x551, x582, uint32(uint1(x598))) + var x601 uint32 + var x602 uint32 + x601, x602 = bits.Add32(x553, x584, uint32(uint1(x600))) + var x603 uint32 + var x604 uint32 + x603, x604 = bits.Add32(x555, x586, uint32(uint1(x602))) + var x605 uint32 + var x606 uint32 + x605, x606 = bits.Add32(x557, x588, uint32(uint1(x604))) + var x607 uint32 + var x608 uint32 + x607, x608 = bits.Add32(x559, x590, uint32(uint1(x606))) + var x609 uint32 + _, x609 = bits.Mul32(x591, 0xee00bc4f) + var x611 uint32 + var x612 uint32 + x612, x611 = bits.Mul32(x609, 0xffffffff) + var x613 uint32 + var x614 uint32 + x614, x613 = bits.Mul32(x609, 0xffffffff) + var x615 uint32 + var x616 uint32 + x616, x615 = bits.Mul32(x609, 0xffffffff) + var x617 uint32 + var x618 uint32 + x618, x617 = bits.Mul32(x609, 0xbce6faad) + var x619 uint32 + var x620 uint32 + x620, x619 = bits.Mul32(x609, 0xa7179e84) + var x621 uint32 + var x622 uint32 + x622, x621 = bits.Mul32(x609, 0xf3b9cac2) + var x623 uint32 + var x624 uint32 + x624, x623 = bits.Mul32(x609, 0xfc632551) + var x625 uint32 + var x626 uint32 + x625, x626 = bits.Add32(x624, x621, uint32(0x0)) + var x627 uint32 + var x628 uint32 + x627, x628 = bits.Add32(x622, x619, uint32(uint1(x626))) + var x629 uint32 + var x630 uint32 + x629, x630 = bits.Add32(x620, x617, uint32(uint1(x628))) + var x631 uint32 + var x632 uint32 + x631, x632 = bits.Add32(x618, x615, uint32(uint1(x630))) + var x633 uint32 + var x634 uint32 + x633, x634 = bits.Add32(x616, x613, uint32(uint1(x632))) + x635 := (uint32(uint1(x634)) + x614) + var x637 uint32 + _, x637 = bits.Add32(x591, x623, uint32(0x0)) + var x638 uint32 + var x639 uint32 + x638, x639 = bits.Add32(x593, x625, uint32(uint1(x637))) + var x640 uint32 + var x641 uint32 + x640, x641 = bits.Add32(x595, x627, uint32(uint1(x639))) + var x642 uint32 + var x643 uint32 + x642, x643 = bits.Add32(x597, x629, uint32(uint1(x641))) + var x644 uint32 + var x645 uint32 + x644, x645 = bits.Add32(x599, x631, uint32(uint1(x643))) + var x646 uint32 + var x647 uint32 + x646, x647 = bits.Add32(x601, x633, uint32(uint1(x645))) + var x648 uint32 + var x649 uint32 + x648, x649 = bits.Add32(x603, x635, uint32(uint1(x647))) + var x650 uint32 + var x651 uint32 + x650, x651 = bits.Add32(x605, x611, uint32(uint1(x649))) + var x652 uint32 + var x653 uint32 + x652, x653 = bits.Add32(x607, x612, uint32(uint1(x651))) + x654 := (uint32(uint1(x653)) + uint32(uint1(x608))) + var x655 uint32 + var x656 uint32 + x656, x655 = bits.Mul32(x7, arg2[7]) + var x657 uint32 + var x658 uint32 + x658, x657 = bits.Mul32(x7, arg2[6]) + var x659 uint32 + var x660 uint32 + x660, x659 = bits.Mul32(x7, arg2[5]) + var x661 uint32 + var x662 uint32 + x662, x661 = bits.Mul32(x7, arg2[4]) + var x663 uint32 + var x664 uint32 + x664, x663 = bits.Mul32(x7, arg2[3]) + var x665 uint32 + var x666 uint32 + x666, x665 = bits.Mul32(x7, arg2[2]) + var x667 uint32 + var x668 uint32 + x668, x667 = bits.Mul32(x7, arg2[1]) + var x669 uint32 + var x670 uint32 + x670, x669 = bits.Mul32(x7, arg2[0]) + var x671 uint32 + var x672 uint32 + x671, x672 = bits.Add32(x670, x667, uint32(0x0)) + var x673 uint32 + var x674 uint32 + x673, x674 = bits.Add32(x668, x665, uint32(uint1(x672))) + var x675 uint32 + var x676 uint32 + x675, x676 = bits.Add32(x666, x663, uint32(uint1(x674))) + var x677 uint32 + var x678 uint32 + x677, x678 = bits.Add32(x664, x661, uint32(uint1(x676))) + var x679 uint32 + var x680 uint32 + x679, x680 = bits.Add32(x662, x659, uint32(uint1(x678))) + var x681 uint32 + var x682 uint32 + x681, x682 = bits.Add32(x660, x657, uint32(uint1(x680))) + var x683 uint32 + var x684 uint32 + x683, x684 = bits.Add32(x658, x655, uint32(uint1(x682))) + x685 := (uint32(uint1(x684)) + x656) + var x686 uint32 + var x687 uint32 + x686, x687 = bits.Add32(x638, x669, uint32(0x0)) + var x688 uint32 + var x689 uint32 + x688, x689 = bits.Add32(x640, x671, uint32(uint1(x687))) + var x690 uint32 + var x691 uint32 + x690, x691 = bits.Add32(x642, x673, uint32(uint1(x689))) + var x692 uint32 + var x693 uint32 + x692, x693 = bits.Add32(x644, x675, uint32(uint1(x691))) + var x694 uint32 + var x695 uint32 + x694, x695 = bits.Add32(x646, x677, uint32(uint1(x693))) + var x696 uint32 + var x697 uint32 + x696, x697 = bits.Add32(x648, x679, uint32(uint1(x695))) + var x698 uint32 + var x699 uint32 + x698, x699 = bits.Add32(x650, x681, uint32(uint1(x697))) + var x700 uint32 + var x701 uint32 + x700, x701 = bits.Add32(x652, x683, uint32(uint1(x699))) + var x702 uint32 + var x703 uint32 + x702, x703 = bits.Add32(x654, x685, uint32(uint1(x701))) + var x704 uint32 + _, x704 = bits.Mul32(x686, 0xee00bc4f) + var x706 uint32 + var x707 uint32 + x707, x706 = bits.Mul32(x704, 0xffffffff) + var x708 uint32 + var x709 uint32 + x709, x708 = bits.Mul32(x704, 0xffffffff) + var x710 uint32 + var x711 uint32 + x711, x710 = bits.Mul32(x704, 0xffffffff) + var x712 uint32 + var x713 uint32 + x713, x712 = bits.Mul32(x704, 0xbce6faad) + var x714 uint32 + var x715 uint32 + x715, x714 = bits.Mul32(x704, 0xa7179e84) + var x716 uint32 + var x717 uint32 + x717, x716 = bits.Mul32(x704, 0xf3b9cac2) + var x718 uint32 + var x719 uint32 + x719, x718 = bits.Mul32(x704, 0xfc632551) + var x720 uint32 + var x721 uint32 + x720, x721 = bits.Add32(x719, x716, uint32(0x0)) + var x722 uint32 + var x723 uint32 + x722, x723 = bits.Add32(x717, x714, uint32(uint1(x721))) + var x724 uint32 + var x725 uint32 + x724, x725 = bits.Add32(x715, x712, uint32(uint1(x723))) + var x726 uint32 + var x727 uint32 + x726, x727 = bits.Add32(x713, x710, uint32(uint1(x725))) + var x728 uint32 + var x729 uint32 + x728, x729 = bits.Add32(x711, x708, uint32(uint1(x727))) + x730 := (uint32(uint1(x729)) + x709) + var x732 uint32 + _, x732 = bits.Add32(x686, x718, uint32(0x0)) + var x733 uint32 + var x734 uint32 + x733, x734 = bits.Add32(x688, x720, uint32(uint1(x732))) + var x735 uint32 + var x736 uint32 + x735, x736 = bits.Add32(x690, x722, uint32(uint1(x734))) + var x737 uint32 + var x738 uint32 + x737, x738 = bits.Add32(x692, x724, uint32(uint1(x736))) + var x739 uint32 + var x740 uint32 + x739, x740 = bits.Add32(x694, x726, uint32(uint1(x738))) + var x741 uint32 + var x742 uint32 + x741, x742 = bits.Add32(x696, x728, uint32(uint1(x740))) + var x743 uint32 + var x744 uint32 + x743, x744 = bits.Add32(x698, x730, uint32(uint1(x742))) + var x745 uint32 + var x746 uint32 + x745, x746 = bits.Add32(x700, x706, uint32(uint1(x744))) + var x747 uint32 + var x748 uint32 + x747, x748 = bits.Add32(x702, x707, uint32(uint1(x746))) + x749 := (uint32(uint1(x748)) + uint32(uint1(x703))) + var x750 uint32 + var x751 uint32 + x750, x751 = bits.Sub32(x733, 0xfc632551, uint32(0x0)) + var x752 uint32 + var x753 uint32 + x752, x753 = bits.Sub32(x735, 0xf3b9cac2, uint32(uint1(x751))) + var x754 uint32 + var x755 uint32 + x754, x755 = bits.Sub32(x737, 0xa7179e84, uint32(uint1(x753))) + var x756 uint32 + var x757 uint32 + x756, x757 = bits.Sub32(x739, 0xbce6faad, uint32(uint1(x755))) + var x758 uint32 + var x759 uint32 + x758, x759 = bits.Sub32(x741, 0xffffffff, uint32(uint1(x757))) + var x760 uint32 + var x761 uint32 + x760, x761 = bits.Sub32(x743, 0xffffffff, uint32(uint1(x759))) + var x762 uint32 + var x763 uint32 + x762, x763 = bits.Sub32(x745, uint32(0x0), uint32(uint1(x761))) + var x764 uint32 + var x765 uint32 + x764, x765 = bits.Sub32(x747, 0xffffffff, uint32(uint1(x763))) + var x767 uint32 + _, x767 = bits.Sub32(x749, uint32(0x0), uint32(uint1(x765))) + var x768 uint32 + cmovznzU32(&x768, uint1(x767), x750, x733) + var x769 uint32 + cmovznzU32(&x769, uint1(x767), x752, x735) + var x770 uint32 + cmovznzU32(&x770, uint1(x767), x754, x737) + var x771 uint32 + cmovznzU32(&x771, uint1(x767), x756, x739) + var x772 uint32 + cmovznzU32(&x772, uint1(x767), x758, x741) + var x773 uint32 + cmovznzU32(&x773, uint1(x767), x760, x743) + var x774 uint32 + cmovznzU32(&x774, uint1(x767), x762, x745) + var x775 uint32 + cmovznzU32(&x775, uint1(x767), x764, x747) + out1[0] = x768 + out1[1] = x769 + out1[2] = x770 + out1[3] = x771 + out1[4] = x772 + out1[5] = x773 + out1[6] = x774 + out1[7] = x775 +} + +// Square squares a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +// 0 ≤ eval out1 < m +// +func Square(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[6] + x7 := arg1[7] + x8 := arg1[0] + var x9 uint32 + var x10 uint32 + x10, x9 = bits.Mul32(x8, arg1[7]) + var x11 uint32 + var x12 uint32 + x12, x11 = bits.Mul32(x8, arg1[6]) + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x8, arg1[5]) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x8, arg1[4]) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x8, arg1[3]) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x8, arg1[2]) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x8, arg1[1]) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x8, arg1[0]) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Add32(x24, x21, uint32(0x0)) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Add32(x22, x19, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Add32(x20, x17, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Add32(x18, x15, uint32(uint1(x30))) + var x33 uint32 + var x34 uint32 + x33, x34 = bits.Add32(x16, x13, uint32(uint1(x32))) + var x35 uint32 + var x36 uint32 + x35, x36 = bits.Add32(x14, x11, uint32(uint1(x34))) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Add32(x12, x9, uint32(uint1(x36))) + x39 := (uint32(uint1(x38)) + x10) + var x40 uint32 + _, x40 = bits.Mul32(x23, 0xee00bc4f) + var x42 uint32 + var x43 uint32 + x43, x42 = bits.Mul32(x40, 0xffffffff) + var x44 uint32 + var x45 uint32 + x45, x44 = bits.Mul32(x40, 0xffffffff) + var x46 uint32 + var x47 uint32 + x47, x46 = bits.Mul32(x40, 0xffffffff) + var x48 uint32 + var x49 uint32 + x49, x48 = bits.Mul32(x40, 0xbce6faad) + var x50 uint32 + var x51 uint32 + x51, x50 = bits.Mul32(x40, 0xa7179e84) + var x52 uint32 + var x53 uint32 + x53, x52 = bits.Mul32(x40, 0xf3b9cac2) + var x54 uint32 + var x55 uint32 + x55, x54 = bits.Mul32(x40, 0xfc632551) + var x56 uint32 + var x57 uint32 + x56, x57 = bits.Add32(x55, x52, uint32(0x0)) + var x58 uint32 + var x59 uint32 + x58, x59 = bits.Add32(x53, x50, uint32(uint1(x57))) + var x60 uint32 + var x61 uint32 + x60, x61 = bits.Add32(x51, x48, uint32(uint1(x59))) + var x62 uint32 + var x63 uint32 + x62, x63 = bits.Add32(x49, x46, uint32(uint1(x61))) + var x64 uint32 + var x65 uint32 + x64, x65 = bits.Add32(x47, x44, uint32(uint1(x63))) + x66 := (uint32(uint1(x65)) + x45) + var x68 uint32 + _, x68 = bits.Add32(x23, x54, uint32(0x0)) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Add32(x25, x56, uint32(uint1(x68))) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Add32(x27, x58, uint32(uint1(x70))) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Add32(x29, x60, uint32(uint1(x72))) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Add32(x31, x62, uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x77, x78 = bits.Add32(x33, x64, uint32(uint1(x76))) + var x79 uint32 + var x80 uint32 + x79, x80 = bits.Add32(x35, x66, uint32(uint1(x78))) + var x81 uint32 + var x82 uint32 + x81, x82 = bits.Add32(x37, x42, uint32(uint1(x80))) + var x83 uint32 + var x84 uint32 + x83, x84 = bits.Add32(x39, x43, uint32(uint1(x82))) + var x85 uint32 + var x86 uint32 + x86, x85 = bits.Mul32(x1, arg1[7]) + var x87 uint32 + var x88 uint32 + x88, x87 = bits.Mul32(x1, arg1[6]) + var x89 uint32 + var x90 uint32 + x90, x89 = bits.Mul32(x1, arg1[5]) + var x91 uint32 + var x92 uint32 + x92, x91 = bits.Mul32(x1, arg1[4]) + var x93 uint32 + var x94 uint32 + x94, x93 = bits.Mul32(x1, arg1[3]) + var x95 uint32 + var x96 uint32 + x96, x95 = bits.Mul32(x1, arg1[2]) + var x97 uint32 + var x98 uint32 + x98, x97 = bits.Mul32(x1, arg1[1]) + var x99 uint32 + var x100 uint32 + x100, x99 = bits.Mul32(x1, arg1[0]) + var x101 uint32 + var x102 uint32 + x101, x102 = bits.Add32(x100, x97, uint32(0x0)) + var x103 uint32 + var x104 uint32 + x103, x104 = bits.Add32(x98, x95, uint32(uint1(x102))) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Add32(x96, x93, uint32(uint1(x104))) + var x107 uint32 + var x108 uint32 + x107, x108 = bits.Add32(x94, x91, uint32(uint1(x106))) + var x109 uint32 + var x110 uint32 + x109, x110 = bits.Add32(x92, x89, uint32(uint1(x108))) + var x111 uint32 + var x112 uint32 + x111, x112 = bits.Add32(x90, x87, uint32(uint1(x110))) + var x113 uint32 + var x114 uint32 + x113, x114 = bits.Add32(x88, x85, uint32(uint1(x112))) + x115 := (uint32(uint1(x114)) + x86) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32(x69, x99, uint32(0x0)) + var x118 uint32 + var x119 uint32 + x118, x119 = bits.Add32(x71, x101, uint32(uint1(x117))) + var x120 uint32 + var x121 uint32 + x120, x121 = bits.Add32(x73, x103, uint32(uint1(x119))) + var x122 uint32 + var x123 uint32 + x122, x123 = bits.Add32(x75, x105, uint32(uint1(x121))) + var x124 uint32 + var x125 uint32 + x124, x125 = bits.Add32(x77, x107, uint32(uint1(x123))) + var x126 uint32 + var x127 uint32 + x126, x127 = bits.Add32(x79, x109, uint32(uint1(x125))) + var x128 uint32 + var x129 uint32 + x128, x129 = bits.Add32(x81, x111, uint32(uint1(x127))) + var x130 uint32 + var x131 uint32 + x130, x131 = bits.Add32(x83, x113, uint32(uint1(x129))) + var x132 uint32 + var x133 uint32 + x132, x133 = bits.Add32(uint32(uint1(x84)), x115, uint32(uint1(x131))) + var x134 uint32 + _, x134 = bits.Mul32(x116, 0xee00bc4f) + var x136 uint32 + var x137 uint32 + x137, x136 = bits.Mul32(x134, 0xffffffff) + var x138 uint32 + var x139 uint32 + x139, x138 = bits.Mul32(x134, 0xffffffff) + var x140 uint32 + var x141 uint32 + x141, x140 = bits.Mul32(x134, 0xffffffff) + var x142 uint32 + var x143 uint32 + x143, x142 = bits.Mul32(x134, 0xbce6faad) + var x144 uint32 + var x145 uint32 + x145, x144 = bits.Mul32(x134, 0xa7179e84) + var x146 uint32 + var x147 uint32 + x147, x146 = bits.Mul32(x134, 0xf3b9cac2) + var x148 uint32 + var x149 uint32 + x149, x148 = bits.Mul32(x134, 0xfc632551) + var x150 uint32 + var x151 uint32 + x150, x151 = bits.Add32(x149, x146, uint32(0x0)) + var x152 uint32 + var x153 uint32 + x152, x153 = bits.Add32(x147, x144, uint32(uint1(x151))) + var x154 uint32 + var x155 uint32 + x154, x155 = bits.Add32(x145, x142, uint32(uint1(x153))) + var x156 uint32 + var x157 uint32 + x156, x157 = bits.Add32(x143, x140, uint32(uint1(x155))) + var x158 uint32 + var x159 uint32 + x158, x159 = bits.Add32(x141, x138, uint32(uint1(x157))) + x160 := (uint32(uint1(x159)) + x139) + var x162 uint32 + _, x162 = bits.Add32(x116, x148, uint32(0x0)) + var x163 uint32 + var x164 uint32 + x163, x164 = bits.Add32(x118, x150, uint32(uint1(x162))) + var x165 uint32 + var x166 uint32 + x165, x166 = bits.Add32(x120, x152, uint32(uint1(x164))) + var x167 uint32 + var x168 uint32 + x167, x168 = bits.Add32(x122, x154, uint32(uint1(x166))) + var x169 uint32 + var x170 uint32 + x169, x170 = bits.Add32(x124, x156, uint32(uint1(x168))) + var x171 uint32 + var x172 uint32 + x171, x172 = bits.Add32(x126, x158, uint32(uint1(x170))) + var x173 uint32 + var x174 uint32 + x173, x174 = bits.Add32(x128, x160, uint32(uint1(x172))) + var x175 uint32 + var x176 uint32 + x175, x176 = bits.Add32(x130, x136, uint32(uint1(x174))) + var x177 uint32 + var x178 uint32 + x177, x178 = bits.Add32(x132, x137, uint32(uint1(x176))) + x179 := (uint32(uint1(x178)) + uint32(uint1(x133))) + var x180 uint32 + var x181 uint32 + x181, x180 = bits.Mul32(x2, arg1[7]) + var x182 uint32 + var x183 uint32 + x183, x182 = bits.Mul32(x2, arg1[6]) + var x184 uint32 + var x185 uint32 + x185, x184 = bits.Mul32(x2, arg1[5]) + var x186 uint32 + var x187 uint32 + x187, x186 = bits.Mul32(x2, arg1[4]) + var x188 uint32 + var x189 uint32 + x189, x188 = bits.Mul32(x2, arg1[3]) + var x190 uint32 + var x191 uint32 + x191, x190 = bits.Mul32(x2, arg1[2]) + var x192 uint32 + var x193 uint32 + x193, x192 = bits.Mul32(x2, arg1[1]) + var x194 uint32 + var x195 uint32 + x195, x194 = bits.Mul32(x2, arg1[0]) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Add32(x195, x192, uint32(0x0)) + var x198 uint32 + var x199 uint32 + x198, x199 = bits.Add32(x193, x190, uint32(uint1(x197))) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Add32(x191, x188, uint32(uint1(x199))) + var x202 uint32 + var x203 uint32 + x202, x203 = bits.Add32(x189, x186, uint32(uint1(x201))) + var x204 uint32 + var x205 uint32 + x204, x205 = bits.Add32(x187, x184, uint32(uint1(x203))) + var x206 uint32 + var x207 uint32 + x206, x207 = bits.Add32(x185, x182, uint32(uint1(x205))) + var x208 uint32 + var x209 uint32 + x208, x209 = bits.Add32(x183, x180, uint32(uint1(x207))) + x210 := (uint32(uint1(x209)) + x181) + var x211 uint32 + var x212 uint32 + x211, x212 = bits.Add32(x163, x194, uint32(0x0)) + var x213 uint32 + var x214 uint32 + x213, x214 = bits.Add32(x165, x196, uint32(uint1(x212))) + var x215 uint32 + var x216 uint32 + x215, x216 = bits.Add32(x167, x198, uint32(uint1(x214))) + var x217 uint32 + var x218 uint32 + x217, x218 = bits.Add32(x169, x200, uint32(uint1(x216))) + var x219 uint32 + var x220 uint32 + x219, x220 = bits.Add32(x171, x202, uint32(uint1(x218))) + var x221 uint32 + var x222 uint32 + x221, x222 = bits.Add32(x173, x204, uint32(uint1(x220))) + var x223 uint32 + var x224 uint32 + x223, x224 = bits.Add32(x175, x206, uint32(uint1(x222))) + var x225 uint32 + var x226 uint32 + x225, x226 = bits.Add32(x177, x208, uint32(uint1(x224))) + var x227 uint32 + var x228 uint32 + x227, x228 = bits.Add32(x179, x210, uint32(uint1(x226))) + var x229 uint32 + _, x229 = bits.Mul32(x211, 0xee00bc4f) + var x231 uint32 + var x232 uint32 + x232, x231 = bits.Mul32(x229, 0xffffffff) + var x233 uint32 + var x234 uint32 + x234, x233 = bits.Mul32(x229, 0xffffffff) + var x235 uint32 + var x236 uint32 + x236, x235 = bits.Mul32(x229, 0xffffffff) + var x237 uint32 + var x238 uint32 + x238, x237 = bits.Mul32(x229, 0xbce6faad) + var x239 uint32 + var x240 uint32 + x240, x239 = bits.Mul32(x229, 0xa7179e84) + var x241 uint32 + var x242 uint32 + x242, x241 = bits.Mul32(x229, 0xf3b9cac2) + var x243 uint32 + var x244 uint32 + x244, x243 = bits.Mul32(x229, 0xfc632551) + var x245 uint32 + var x246 uint32 + x245, x246 = bits.Add32(x244, x241, uint32(0x0)) + var x247 uint32 + var x248 uint32 + x247, x248 = bits.Add32(x242, x239, uint32(uint1(x246))) + var x249 uint32 + var x250 uint32 + x249, x250 = bits.Add32(x240, x237, uint32(uint1(x248))) + var x251 uint32 + var x252 uint32 + x251, x252 = bits.Add32(x238, x235, uint32(uint1(x250))) + var x253 uint32 + var x254 uint32 + x253, x254 = bits.Add32(x236, x233, uint32(uint1(x252))) + x255 := (uint32(uint1(x254)) + x234) + var x257 uint32 + _, x257 = bits.Add32(x211, x243, uint32(0x0)) + var x258 uint32 + var x259 uint32 + x258, x259 = bits.Add32(x213, x245, uint32(uint1(x257))) + var x260 uint32 + var x261 uint32 + x260, x261 = bits.Add32(x215, x247, uint32(uint1(x259))) + var x262 uint32 + var x263 uint32 + x262, x263 = bits.Add32(x217, x249, uint32(uint1(x261))) + var x264 uint32 + var x265 uint32 + x264, x265 = bits.Add32(x219, x251, uint32(uint1(x263))) + var x266 uint32 + var x267 uint32 + x266, x267 = bits.Add32(x221, x253, uint32(uint1(x265))) + var x268 uint32 + var x269 uint32 + x268, x269 = bits.Add32(x223, x255, uint32(uint1(x267))) + var x270 uint32 + var x271 uint32 + x270, x271 = bits.Add32(x225, x231, uint32(uint1(x269))) + var x272 uint32 + var x273 uint32 + x272, x273 = bits.Add32(x227, x232, uint32(uint1(x271))) + x274 := (uint32(uint1(x273)) + uint32(uint1(x228))) + var x275 uint32 + var x276 uint32 + x276, x275 = bits.Mul32(x3, arg1[7]) + var x277 uint32 + var x278 uint32 + x278, x277 = bits.Mul32(x3, arg1[6]) + var x279 uint32 + var x280 uint32 + x280, x279 = bits.Mul32(x3, arg1[5]) + var x281 uint32 + var x282 uint32 + x282, x281 = bits.Mul32(x3, arg1[4]) + var x283 uint32 + var x284 uint32 + x284, x283 = bits.Mul32(x3, arg1[3]) + var x285 uint32 + var x286 uint32 + x286, x285 = bits.Mul32(x3, arg1[2]) + var x287 uint32 + var x288 uint32 + x288, x287 = bits.Mul32(x3, arg1[1]) + var x289 uint32 + var x290 uint32 + x290, x289 = bits.Mul32(x3, arg1[0]) + var x291 uint32 + var x292 uint32 + x291, x292 = bits.Add32(x290, x287, uint32(0x0)) + var x293 uint32 + var x294 uint32 + x293, x294 = bits.Add32(x288, x285, uint32(uint1(x292))) + var x295 uint32 + var x296 uint32 + x295, x296 = bits.Add32(x286, x283, uint32(uint1(x294))) + var x297 uint32 + var x298 uint32 + x297, x298 = bits.Add32(x284, x281, uint32(uint1(x296))) + var x299 uint32 + var x300 uint32 + x299, x300 = bits.Add32(x282, x279, uint32(uint1(x298))) + var x301 uint32 + var x302 uint32 + x301, x302 = bits.Add32(x280, x277, uint32(uint1(x300))) + var x303 uint32 + var x304 uint32 + x303, x304 = bits.Add32(x278, x275, uint32(uint1(x302))) + x305 := (uint32(uint1(x304)) + x276) + var x306 uint32 + var x307 uint32 + x306, x307 = bits.Add32(x258, x289, uint32(0x0)) + var x308 uint32 + var x309 uint32 + x308, x309 = bits.Add32(x260, x291, uint32(uint1(x307))) + var x310 uint32 + var x311 uint32 + x310, x311 = bits.Add32(x262, x293, uint32(uint1(x309))) + var x312 uint32 + var x313 uint32 + x312, x313 = bits.Add32(x264, x295, uint32(uint1(x311))) + var x314 uint32 + var x315 uint32 + x314, x315 = bits.Add32(x266, x297, uint32(uint1(x313))) + var x316 uint32 + var x317 uint32 + x316, x317 = bits.Add32(x268, x299, uint32(uint1(x315))) + var x318 uint32 + var x319 uint32 + x318, x319 = bits.Add32(x270, x301, uint32(uint1(x317))) + var x320 uint32 + var x321 uint32 + x320, x321 = bits.Add32(x272, x303, uint32(uint1(x319))) + var x322 uint32 + var x323 uint32 + x322, x323 = bits.Add32(x274, x305, uint32(uint1(x321))) + var x324 uint32 + _, x324 = bits.Mul32(x306, 0xee00bc4f) + var x326 uint32 + var x327 uint32 + x327, x326 = bits.Mul32(x324, 0xffffffff) + var x328 uint32 + var x329 uint32 + x329, x328 = bits.Mul32(x324, 0xffffffff) + var x330 uint32 + var x331 uint32 + x331, x330 = bits.Mul32(x324, 0xffffffff) + var x332 uint32 + var x333 uint32 + x333, x332 = bits.Mul32(x324, 0xbce6faad) + var x334 uint32 + var x335 uint32 + x335, x334 = bits.Mul32(x324, 0xa7179e84) + var x336 uint32 + var x337 uint32 + x337, x336 = bits.Mul32(x324, 0xf3b9cac2) + var x338 uint32 + var x339 uint32 + x339, x338 = bits.Mul32(x324, 0xfc632551) + var x340 uint32 + var x341 uint32 + x340, x341 = bits.Add32(x339, x336, uint32(0x0)) + var x342 uint32 + var x343 uint32 + x342, x343 = bits.Add32(x337, x334, uint32(uint1(x341))) + var x344 uint32 + var x345 uint32 + x344, x345 = bits.Add32(x335, x332, uint32(uint1(x343))) + var x346 uint32 + var x347 uint32 + x346, x347 = bits.Add32(x333, x330, uint32(uint1(x345))) + var x348 uint32 + var x349 uint32 + x348, x349 = bits.Add32(x331, x328, uint32(uint1(x347))) + x350 := (uint32(uint1(x349)) + x329) + var x352 uint32 + _, x352 = bits.Add32(x306, x338, uint32(0x0)) + var x353 uint32 + var x354 uint32 + x353, x354 = bits.Add32(x308, x340, uint32(uint1(x352))) + var x355 uint32 + var x356 uint32 + x355, x356 = bits.Add32(x310, x342, uint32(uint1(x354))) + var x357 uint32 + var x358 uint32 + x357, x358 = bits.Add32(x312, x344, uint32(uint1(x356))) + var x359 uint32 + var x360 uint32 + x359, x360 = bits.Add32(x314, x346, uint32(uint1(x358))) + var x361 uint32 + var x362 uint32 + x361, x362 = bits.Add32(x316, x348, uint32(uint1(x360))) + var x363 uint32 + var x364 uint32 + x363, x364 = bits.Add32(x318, x350, uint32(uint1(x362))) + var x365 uint32 + var x366 uint32 + x365, x366 = bits.Add32(x320, x326, uint32(uint1(x364))) + var x367 uint32 + var x368 uint32 + x367, x368 = bits.Add32(x322, x327, uint32(uint1(x366))) + x369 := (uint32(uint1(x368)) + uint32(uint1(x323))) + var x370 uint32 + var x371 uint32 + x371, x370 = bits.Mul32(x4, arg1[7]) + var x372 uint32 + var x373 uint32 + x373, x372 = bits.Mul32(x4, arg1[6]) + var x374 uint32 + var x375 uint32 + x375, x374 = bits.Mul32(x4, arg1[5]) + var x376 uint32 + var x377 uint32 + x377, x376 = bits.Mul32(x4, arg1[4]) + var x378 uint32 + var x379 uint32 + x379, x378 = bits.Mul32(x4, arg1[3]) + var x380 uint32 + var x381 uint32 + x381, x380 = bits.Mul32(x4, arg1[2]) + var x382 uint32 + var x383 uint32 + x383, x382 = bits.Mul32(x4, arg1[1]) + var x384 uint32 + var x385 uint32 + x385, x384 = bits.Mul32(x4, arg1[0]) + var x386 uint32 + var x387 uint32 + x386, x387 = bits.Add32(x385, x382, uint32(0x0)) + var x388 uint32 + var x389 uint32 + x388, x389 = bits.Add32(x383, x380, uint32(uint1(x387))) + var x390 uint32 + var x391 uint32 + x390, x391 = bits.Add32(x381, x378, uint32(uint1(x389))) + var x392 uint32 + var x393 uint32 + x392, x393 = bits.Add32(x379, x376, uint32(uint1(x391))) + var x394 uint32 + var x395 uint32 + x394, x395 = bits.Add32(x377, x374, uint32(uint1(x393))) + var x396 uint32 + var x397 uint32 + x396, x397 = bits.Add32(x375, x372, uint32(uint1(x395))) + var x398 uint32 + var x399 uint32 + x398, x399 = bits.Add32(x373, x370, uint32(uint1(x397))) + x400 := (uint32(uint1(x399)) + x371) + var x401 uint32 + var x402 uint32 + x401, x402 = bits.Add32(x353, x384, uint32(0x0)) + var x403 uint32 + var x404 uint32 + x403, x404 = bits.Add32(x355, x386, uint32(uint1(x402))) + var x405 uint32 + var x406 uint32 + x405, x406 = bits.Add32(x357, x388, uint32(uint1(x404))) + var x407 uint32 + var x408 uint32 + x407, x408 = bits.Add32(x359, x390, uint32(uint1(x406))) + var x409 uint32 + var x410 uint32 + x409, x410 = bits.Add32(x361, x392, uint32(uint1(x408))) + var x411 uint32 + var x412 uint32 + x411, x412 = bits.Add32(x363, x394, uint32(uint1(x410))) + var x413 uint32 + var x414 uint32 + x413, x414 = bits.Add32(x365, x396, uint32(uint1(x412))) + var x415 uint32 + var x416 uint32 + x415, x416 = bits.Add32(x367, x398, uint32(uint1(x414))) + var x417 uint32 + var x418 uint32 + x417, x418 = bits.Add32(x369, x400, uint32(uint1(x416))) + var x419 uint32 + _, x419 = bits.Mul32(x401, 0xee00bc4f) + var x421 uint32 + var x422 uint32 + x422, x421 = bits.Mul32(x419, 0xffffffff) + var x423 uint32 + var x424 uint32 + x424, x423 = bits.Mul32(x419, 0xffffffff) + var x425 uint32 + var x426 uint32 + x426, x425 = bits.Mul32(x419, 0xffffffff) + var x427 uint32 + var x428 uint32 + x428, x427 = bits.Mul32(x419, 0xbce6faad) + var x429 uint32 + var x430 uint32 + x430, x429 = bits.Mul32(x419, 0xa7179e84) + var x431 uint32 + var x432 uint32 + x432, x431 = bits.Mul32(x419, 0xf3b9cac2) + var x433 uint32 + var x434 uint32 + x434, x433 = bits.Mul32(x419, 0xfc632551) + var x435 uint32 + var x436 uint32 + x435, x436 = bits.Add32(x434, x431, uint32(0x0)) + var x437 uint32 + var x438 uint32 + x437, x438 = bits.Add32(x432, x429, uint32(uint1(x436))) + var x439 uint32 + var x440 uint32 + x439, x440 = bits.Add32(x430, x427, uint32(uint1(x438))) + var x441 uint32 + var x442 uint32 + x441, x442 = bits.Add32(x428, x425, uint32(uint1(x440))) + var x443 uint32 + var x444 uint32 + x443, x444 = bits.Add32(x426, x423, uint32(uint1(x442))) + x445 := (uint32(uint1(x444)) + x424) + var x447 uint32 + _, x447 = bits.Add32(x401, x433, uint32(0x0)) + var x448 uint32 + var x449 uint32 + x448, x449 = bits.Add32(x403, x435, uint32(uint1(x447))) + var x450 uint32 + var x451 uint32 + x450, x451 = bits.Add32(x405, x437, uint32(uint1(x449))) + var x452 uint32 + var x453 uint32 + x452, x453 = bits.Add32(x407, x439, uint32(uint1(x451))) + var x454 uint32 + var x455 uint32 + x454, x455 = bits.Add32(x409, x441, uint32(uint1(x453))) + var x456 uint32 + var x457 uint32 + x456, x457 = bits.Add32(x411, x443, uint32(uint1(x455))) + var x458 uint32 + var x459 uint32 + x458, x459 = bits.Add32(x413, x445, uint32(uint1(x457))) + var x460 uint32 + var x461 uint32 + x460, x461 = bits.Add32(x415, x421, uint32(uint1(x459))) + var x462 uint32 + var x463 uint32 + x462, x463 = bits.Add32(x417, x422, uint32(uint1(x461))) + x464 := (uint32(uint1(x463)) + uint32(uint1(x418))) + var x465 uint32 + var x466 uint32 + x466, x465 = bits.Mul32(x5, arg1[7]) + var x467 uint32 + var x468 uint32 + x468, x467 = bits.Mul32(x5, arg1[6]) + var x469 uint32 + var x470 uint32 + x470, x469 = bits.Mul32(x5, arg1[5]) + var x471 uint32 + var x472 uint32 + x472, x471 = bits.Mul32(x5, arg1[4]) + var x473 uint32 + var x474 uint32 + x474, x473 = bits.Mul32(x5, arg1[3]) + var x475 uint32 + var x476 uint32 + x476, x475 = bits.Mul32(x5, arg1[2]) + var x477 uint32 + var x478 uint32 + x478, x477 = bits.Mul32(x5, arg1[1]) + var x479 uint32 + var x480 uint32 + x480, x479 = bits.Mul32(x5, arg1[0]) + var x481 uint32 + var x482 uint32 + x481, x482 = bits.Add32(x480, x477, uint32(0x0)) + var x483 uint32 + var x484 uint32 + x483, x484 = bits.Add32(x478, x475, uint32(uint1(x482))) + var x485 uint32 + var x486 uint32 + x485, x486 = bits.Add32(x476, x473, uint32(uint1(x484))) + var x487 uint32 + var x488 uint32 + x487, x488 = bits.Add32(x474, x471, uint32(uint1(x486))) + var x489 uint32 + var x490 uint32 + x489, x490 = bits.Add32(x472, x469, uint32(uint1(x488))) + var x491 uint32 + var x492 uint32 + x491, x492 = bits.Add32(x470, x467, uint32(uint1(x490))) + var x493 uint32 + var x494 uint32 + x493, x494 = bits.Add32(x468, x465, uint32(uint1(x492))) + x495 := (uint32(uint1(x494)) + x466) + var x496 uint32 + var x497 uint32 + x496, x497 = bits.Add32(x448, x479, uint32(0x0)) + var x498 uint32 + var x499 uint32 + x498, x499 = bits.Add32(x450, x481, uint32(uint1(x497))) + var x500 uint32 + var x501 uint32 + x500, x501 = bits.Add32(x452, x483, uint32(uint1(x499))) + var x502 uint32 + var x503 uint32 + x502, x503 = bits.Add32(x454, x485, uint32(uint1(x501))) + var x504 uint32 + var x505 uint32 + x504, x505 = bits.Add32(x456, x487, uint32(uint1(x503))) + var x506 uint32 + var x507 uint32 + x506, x507 = bits.Add32(x458, x489, uint32(uint1(x505))) + var x508 uint32 + var x509 uint32 + x508, x509 = bits.Add32(x460, x491, uint32(uint1(x507))) + var x510 uint32 + var x511 uint32 + x510, x511 = bits.Add32(x462, x493, uint32(uint1(x509))) + var x512 uint32 + var x513 uint32 + x512, x513 = bits.Add32(x464, x495, uint32(uint1(x511))) + var x514 uint32 + _, x514 = bits.Mul32(x496, 0xee00bc4f) + var x516 uint32 + var x517 uint32 + x517, x516 = bits.Mul32(x514, 0xffffffff) + var x518 uint32 + var x519 uint32 + x519, x518 = bits.Mul32(x514, 0xffffffff) + var x520 uint32 + var x521 uint32 + x521, x520 = bits.Mul32(x514, 0xffffffff) + var x522 uint32 + var x523 uint32 + x523, x522 = bits.Mul32(x514, 0xbce6faad) + var x524 uint32 + var x525 uint32 + x525, x524 = bits.Mul32(x514, 0xa7179e84) + var x526 uint32 + var x527 uint32 + x527, x526 = bits.Mul32(x514, 0xf3b9cac2) + var x528 uint32 + var x529 uint32 + x529, x528 = bits.Mul32(x514, 0xfc632551) + var x530 uint32 + var x531 uint32 + x530, x531 = bits.Add32(x529, x526, uint32(0x0)) + var x532 uint32 + var x533 uint32 + x532, x533 = bits.Add32(x527, x524, uint32(uint1(x531))) + var x534 uint32 + var x535 uint32 + x534, x535 = bits.Add32(x525, x522, uint32(uint1(x533))) + var x536 uint32 + var x537 uint32 + x536, x537 = bits.Add32(x523, x520, uint32(uint1(x535))) + var x538 uint32 + var x539 uint32 + x538, x539 = bits.Add32(x521, x518, uint32(uint1(x537))) + x540 := (uint32(uint1(x539)) + x519) + var x542 uint32 + _, x542 = bits.Add32(x496, x528, uint32(0x0)) + var x543 uint32 + var x544 uint32 + x543, x544 = bits.Add32(x498, x530, uint32(uint1(x542))) + var x545 uint32 + var x546 uint32 + x545, x546 = bits.Add32(x500, x532, uint32(uint1(x544))) + var x547 uint32 + var x548 uint32 + x547, x548 = bits.Add32(x502, x534, uint32(uint1(x546))) + var x549 uint32 + var x550 uint32 + x549, x550 = bits.Add32(x504, x536, uint32(uint1(x548))) + var x551 uint32 + var x552 uint32 + x551, x552 = bits.Add32(x506, x538, uint32(uint1(x550))) + var x553 uint32 + var x554 uint32 + x553, x554 = bits.Add32(x508, x540, uint32(uint1(x552))) + var x555 uint32 + var x556 uint32 + x555, x556 = bits.Add32(x510, x516, uint32(uint1(x554))) + var x557 uint32 + var x558 uint32 + x557, x558 = bits.Add32(x512, x517, uint32(uint1(x556))) + x559 := (uint32(uint1(x558)) + uint32(uint1(x513))) + var x560 uint32 + var x561 uint32 + x561, x560 = bits.Mul32(x6, arg1[7]) + var x562 uint32 + var x563 uint32 + x563, x562 = bits.Mul32(x6, arg1[6]) + var x564 uint32 + var x565 uint32 + x565, x564 = bits.Mul32(x6, arg1[5]) + var x566 uint32 + var x567 uint32 + x567, x566 = bits.Mul32(x6, arg1[4]) + var x568 uint32 + var x569 uint32 + x569, x568 = bits.Mul32(x6, arg1[3]) + var x570 uint32 + var x571 uint32 + x571, x570 = bits.Mul32(x6, arg1[2]) + var x572 uint32 + var x573 uint32 + x573, x572 = bits.Mul32(x6, arg1[1]) + var x574 uint32 + var x575 uint32 + x575, x574 = bits.Mul32(x6, arg1[0]) + var x576 uint32 + var x577 uint32 + x576, x577 = bits.Add32(x575, x572, uint32(0x0)) + var x578 uint32 + var x579 uint32 + x578, x579 = bits.Add32(x573, x570, uint32(uint1(x577))) + var x580 uint32 + var x581 uint32 + x580, x581 = bits.Add32(x571, x568, uint32(uint1(x579))) + var x582 uint32 + var x583 uint32 + x582, x583 = bits.Add32(x569, x566, uint32(uint1(x581))) + var x584 uint32 + var x585 uint32 + x584, x585 = bits.Add32(x567, x564, uint32(uint1(x583))) + var x586 uint32 + var x587 uint32 + x586, x587 = bits.Add32(x565, x562, uint32(uint1(x585))) + var x588 uint32 + var x589 uint32 + x588, x589 = bits.Add32(x563, x560, uint32(uint1(x587))) + x590 := (uint32(uint1(x589)) + x561) + var x591 uint32 + var x592 uint32 + x591, x592 = bits.Add32(x543, x574, uint32(0x0)) + var x593 uint32 + var x594 uint32 + x593, x594 = bits.Add32(x545, x576, uint32(uint1(x592))) + var x595 uint32 + var x596 uint32 + x595, x596 = bits.Add32(x547, x578, uint32(uint1(x594))) + var x597 uint32 + var x598 uint32 + x597, x598 = bits.Add32(x549, x580, uint32(uint1(x596))) + var x599 uint32 + var x600 uint32 + x599, x600 = bits.Add32(x551, x582, uint32(uint1(x598))) + var x601 uint32 + var x602 uint32 + x601, x602 = bits.Add32(x553, x584, uint32(uint1(x600))) + var x603 uint32 + var x604 uint32 + x603, x604 = bits.Add32(x555, x586, uint32(uint1(x602))) + var x605 uint32 + var x606 uint32 + x605, x606 = bits.Add32(x557, x588, uint32(uint1(x604))) + var x607 uint32 + var x608 uint32 + x607, x608 = bits.Add32(x559, x590, uint32(uint1(x606))) + var x609 uint32 + _, x609 = bits.Mul32(x591, 0xee00bc4f) + var x611 uint32 + var x612 uint32 + x612, x611 = bits.Mul32(x609, 0xffffffff) + var x613 uint32 + var x614 uint32 + x614, x613 = bits.Mul32(x609, 0xffffffff) + var x615 uint32 + var x616 uint32 + x616, x615 = bits.Mul32(x609, 0xffffffff) + var x617 uint32 + var x618 uint32 + x618, x617 = bits.Mul32(x609, 0xbce6faad) + var x619 uint32 + var x620 uint32 + x620, x619 = bits.Mul32(x609, 0xa7179e84) + var x621 uint32 + var x622 uint32 + x622, x621 = bits.Mul32(x609, 0xf3b9cac2) + var x623 uint32 + var x624 uint32 + x624, x623 = bits.Mul32(x609, 0xfc632551) + var x625 uint32 + var x626 uint32 + x625, x626 = bits.Add32(x624, x621, uint32(0x0)) + var x627 uint32 + var x628 uint32 + x627, x628 = bits.Add32(x622, x619, uint32(uint1(x626))) + var x629 uint32 + var x630 uint32 + x629, x630 = bits.Add32(x620, x617, uint32(uint1(x628))) + var x631 uint32 + var x632 uint32 + x631, x632 = bits.Add32(x618, x615, uint32(uint1(x630))) + var x633 uint32 + var x634 uint32 + x633, x634 = bits.Add32(x616, x613, uint32(uint1(x632))) + x635 := (uint32(uint1(x634)) + x614) + var x637 uint32 + _, x637 = bits.Add32(x591, x623, uint32(0x0)) + var x638 uint32 + var x639 uint32 + x638, x639 = bits.Add32(x593, x625, uint32(uint1(x637))) + var x640 uint32 + var x641 uint32 + x640, x641 = bits.Add32(x595, x627, uint32(uint1(x639))) + var x642 uint32 + var x643 uint32 + x642, x643 = bits.Add32(x597, x629, uint32(uint1(x641))) + var x644 uint32 + var x645 uint32 + x644, x645 = bits.Add32(x599, x631, uint32(uint1(x643))) + var x646 uint32 + var x647 uint32 + x646, x647 = bits.Add32(x601, x633, uint32(uint1(x645))) + var x648 uint32 + var x649 uint32 + x648, x649 = bits.Add32(x603, x635, uint32(uint1(x647))) + var x650 uint32 + var x651 uint32 + x650, x651 = bits.Add32(x605, x611, uint32(uint1(x649))) + var x652 uint32 + var x653 uint32 + x652, x653 = bits.Add32(x607, x612, uint32(uint1(x651))) + x654 := (uint32(uint1(x653)) + uint32(uint1(x608))) + var x655 uint32 + var x656 uint32 + x656, x655 = bits.Mul32(x7, arg1[7]) + var x657 uint32 + var x658 uint32 + x658, x657 = bits.Mul32(x7, arg1[6]) + var x659 uint32 + var x660 uint32 + x660, x659 = bits.Mul32(x7, arg1[5]) + var x661 uint32 + var x662 uint32 + x662, x661 = bits.Mul32(x7, arg1[4]) + var x663 uint32 + var x664 uint32 + x664, x663 = bits.Mul32(x7, arg1[3]) + var x665 uint32 + var x666 uint32 + x666, x665 = bits.Mul32(x7, arg1[2]) + var x667 uint32 + var x668 uint32 + x668, x667 = bits.Mul32(x7, arg1[1]) + var x669 uint32 + var x670 uint32 + x670, x669 = bits.Mul32(x7, arg1[0]) + var x671 uint32 + var x672 uint32 + x671, x672 = bits.Add32(x670, x667, uint32(0x0)) + var x673 uint32 + var x674 uint32 + x673, x674 = bits.Add32(x668, x665, uint32(uint1(x672))) + var x675 uint32 + var x676 uint32 + x675, x676 = bits.Add32(x666, x663, uint32(uint1(x674))) + var x677 uint32 + var x678 uint32 + x677, x678 = bits.Add32(x664, x661, uint32(uint1(x676))) + var x679 uint32 + var x680 uint32 + x679, x680 = bits.Add32(x662, x659, uint32(uint1(x678))) + var x681 uint32 + var x682 uint32 + x681, x682 = bits.Add32(x660, x657, uint32(uint1(x680))) + var x683 uint32 + var x684 uint32 + x683, x684 = bits.Add32(x658, x655, uint32(uint1(x682))) + x685 := (uint32(uint1(x684)) + x656) + var x686 uint32 + var x687 uint32 + x686, x687 = bits.Add32(x638, x669, uint32(0x0)) + var x688 uint32 + var x689 uint32 + x688, x689 = bits.Add32(x640, x671, uint32(uint1(x687))) + var x690 uint32 + var x691 uint32 + x690, x691 = bits.Add32(x642, x673, uint32(uint1(x689))) + var x692 uint32 + var x693 uint32 + x692, x693 = bits.Add32(x644, x675, uint32(uint1(x691))) + var x694 uint32 + var x695 uint32 + x694, x695 = bits.Add32(x646, x677, uint32(uint1(x693))) + var x696 uint32 + var x697 uint32 + x696, x697 = bits.Add32(x648, x679, uint32(uint1(x695))) + var x698 uint32 + var x699 uint32 + x698, x699 = bits.Add32(x650, x681, uint32(uint1(x697))) + var x700 uint32 + var x701 uint32 + x700, x701 = bits.Add32(x652, x683, uint32(uint1(x699))) + var x702 uint32 + var x703 uint32 + x702, x703 = bits.Add32(x654, x685, uint32(uint1(x701))) + var x704 uint32 + _, x704 = bits.Mul32(x686, 0xee00bc4f) + var x706 uint32 + var x707 uint32 + x707, x706 = bits.Mul32(x704, 0xffffffff) + var x708 uint32 + var x709 uint32 + x709, x708 = bits.Mul32(x704, 0xffffffff) + var x710 uint32 + var x711 uint32 + x711, x710 = bits.Mul32(x704, 0xffffffff) + var x712 uint32 + var x713 uint32 + x713, x712 = bits.Mul32(x704, 0xbce6faad) + var x714 uint32 + var x715 uint32 + x715, x714 = bits.Mul32(x704, 0xa7179e84) + var x716 uint32 + var x717 uint32 + x717, x716 = bits.Mul32(x704, 0xf3b9cac2) + var x718 uint32 + var x719 uint32 + x719, x718 = bits.Mul32(x704, 0xfc632551) + var x720 uint32 + var x721 uint32 + x720, x721 = bits.Add32(x719, x716, uint32(0x0)) + var x722 uint32 + var x723 uint32 + x722, x723 = bits.Add32(x717, x714, uint32(uint1(x721))) + var x724 uint32 + var x725 uint32 + x724, x725 = bits.Add32(x715, x712, uint32(uint1(x723))) + var x726 uint32 + var x727 uint32 + x726, x727 = bits.Add32(x713, x710, uint32(uint1(x725))) + var x728 uint32 + var x729 uint32 + x728, x729 = bits.Add32(x711, x708, uint32(uint1(x727))) + x730 := (uint32(uint1(x729)) + x709) + var x732 uint32 + _, x732 = bits.Add32(x686, x718, uint32(0x0)) + var x733 uint32 + var x734 uint32 + x733, x734 = bits.Add32(x688, x720, uint32(uint1(x732))) + var x735 uint32 + var x736 uint32 + x735, x736 = bits.Add32(x690, x722, uint32(uint1(x734))) + var x737 uint32 + var x738 uint32 + x737, x738 = bits.Add32(x692, x724, uint32(uint1(x736))) + var x739 uint32 + var x740 uint32 + x739, x740 = bits.Add32(x694, x726, uint32(uint1(x738))) + var x741 uint32 + var x742 uint32 + x741, x742 = bits.Add32(x696, x728, uint32(uint1(x740))) + var x743 uint32 + var x744 uint32 + x743, x744 = bits.Add32(x698, x730, uint32(uint1(x742))) + var x745 uint32 + var x746 uint32 + x745, x746 = bits.Add32(x700, x706, uint32(uint1(x744))) + var x747 uint32 + var x748 uint32 + x747, x748 = bits.Add32(x702, x707, uint32(uint1(x746))) + x749 := (uint32(uint1(x748)) + uint32(uint1(x703))) + var x750 uint32 + var x751 uint32 + x750, x751 = bits.Sub32(x733, 0xfc632551, uint32(0x0)) + var x752 uint32 + var x753 uint32 + x752, x753 = bits.Sub32(x735, 0xf3b9cac2, uint32(uint1(x751))) + var x754 uint32 + var x755 uint32 + x754, x755 = bits.Sub32(x737, 0xa7179e84, uint32(uint1(x753))) + var x756 uint32 + var x757 uint32 + x756, x757 = bits.Sub32(x739, 0xbce6faad, uint32(uint1(x755))) + var x758 uint32 + var x759 uint32 + x758, x759 = bits.Sub32(x741, 0xffffffff, uint32(uint1(x757))) + var x760 uint32 + var x761 uint32 + x760, x761 = bits.Sub32(x743, 0xffffffff, uint32(uint1(x759))) + var x762 uint32 + var x763 uint32 + x762, x763 = bits.Sub32(x745, uint32(0x0), uint32(uint1(x761))) + var x764 uint32 + var x765 uint32 + x764, x765 = bits.Sub32(x747, 0xffffffff, uint32(uint1(x763))) + var x767 uint32 + _, x767 = bits.Sub32(x749, uint32(0x0), uint32(uint1(x765))) + var x768 uint32 + cmovznzU32(&x768, uint1(x767), x750, x733) + var x769 uint32 + cmovznzU32(&x769, uint1(x767), x752, x735) + var x770 uint32 + cmovznzU32(&x770, uint1(x767), x754, x737) + var x771 uint32 + cmovznzU32(&x771, uint1(x767), x756, x739) + var x772 uint32 + cmovznzU32(&x772, uint1(x767), x758, x741) + var x773 uint32 + cmovznzU32(&x773, uint1(x767), x760, x743) + var x774 uint32 + cmovznzU32(&x774, uint1(x767), x762, x745) + var x775 uint32 + cmovznzU32(&x775, uint1(x767), x764, x747) + out1[0] = x768 + out1[1] = x769 + out1[2] = x770 + out1[3] = x771 + out1[4] = x772 + out1[5] = x773 + out1[6] = x774 + out1[7] = x775 +} + +// Add adds two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Add(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint32 + var x2 uint32 + x1, x2 = bits.Add32(arg1[0], arg2[0], uint32(0x0)) + var x3 uint32 + var x4 uint32 + x3, x4 = bits.Add32(arg1[1], arg2[1], uint32(uint1(x2))) + var x5 uint32 + var x6 uint32 + x5, x6 = bits.Add32(arg1[2], arg2[2], uint32(uint1(x4))) + var x7 uint32 + var x8 uint32 + x7, x8 = bits.Add32(arg1[3], arg2[3], uint32(uint1(x6))) + var x9 uint32 + var x10 uint32 + x9, x10 = bits.Add32(arg1[4], arg2[4], uint32(uint1(x8))) + var x11 uint32 + var x12 uint32 + x11, x12 = bits.Add32(arg1[5], arg2[5], uint32(uint1(x10))) + var x13 uint32 + var x14 uint32 + x13, x14 = bits.Add32(arg1[6], arg2[6], uint32(uint1(x12))) + var x15 uint32 + var x16 uint32 + x15, x16 = bits.Add32(arg1[7], arg2[7], uint32(uint1(x14))) + var x17 uint32 + var x18 uint32 + x17, x18 = bits.Sub32(x1, 0xfc632551, uint32(0x0)) + var x19 uint32 + var x20 uint32 + x19, x20 = bits.Sub32(x3, 0xf3b9cac2, uint32(uint1(x18))) + var x21 uint32 + var x22 uint32 + x21, x22 = bits.Sub32(x5, 0xa7179e84, uint32(uint1(x20))) + var x23 uint32 + var x24 uint32 + x23, x24 = bits.Sub32(x7, 0xbce6faad, uint32(uint1(x22))) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Sub32(x9, 0xffffffff, uint32(uint1(x24))) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Sub32(x11, 0xffffffff, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Sub32(x13, uint32(0x0), uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Sub32(x15, 0xffffffff, uint32(uint1(x30))) + var x34 uint32 + _, x34 = bits.Sub32(uint32(uint1(x16)), uint32(0x0), uint32(uint1(x32))) + var x35 uint32 + cmovznzU32(&x35, uint1(x34), x17, x1) + var x36 uint32 + cmovznzU32(&x36, uint1(x34), x19, x3) + var x37 uint32 + cmovznzU32(&x37, uint1(x34), x21, x5) + var x38 uint32 + cmovznzU32(&x38, uint1(x34), x23, x7) + var x39 uint32 + cmovznzU32(&x39, uint1(x34), x25, x9) + var x40 uint32 + cmovznzU32(&x40, uint1(x34), x27, x11) + var x41 uint32 + cmovznzU32(&x41, uint1(x34), x29, x13) + var x42 uint32 + cmovznzU32(&x42, uint1(x34), x31, x15) + out1[0] = x35 + out1[1] = x36 + out1[2] = x37 + out1[3] = x38 + out1[4] = x39 + out1[5] = x40 + out1[6] = x41 + out1[7] = x42 +} + +// Sub subtracts two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Sub(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint32 + var x2 uint32 + x1, x2 = bits.Sub32(arg1[0], arg2[0], uint32(0x0)) + var x3 uint32 + var x4 uint32 + x3, x4 = bits.Sub32(arg1[1], arg2[1], uint32(uint1(x2))) + var x5 uint32 + var x6 uint32 + x5, x6 = bits.Sub32(arg1[2], arg2[2], uint32(uint1(x4))) + var x7 uint32 + var x8 uint32 + x7, x8 = bits.Sub32(arg1[3], arg2[3], uint32(uint1(x6))) + var x9 uint32 + var x10 uint32 + x9, x10 = bits.Sub32(arg1[4], arg2[4], uint32(uint1(x8))) + var x11 uint32 + var x12 uint32 + x11, x12 = bits.Sub32(arg1[5], arg2[5], uint32(uint1(x10))) + var x13 uint32 + var x14 uint32 + x13, x14 = bits.Sub32(arg1[6], arg2[6], uint32(uint1(x12))) + var x15 uint32 + var x16 uint32 + x15, x16 = bits.Sub32(arg1[7], arg2[7], uint32(uint1(x14))) + var x17 uint32 + cmovznzU32(&x17, uint1(x16), uint32(0x0), 0xffffffff) + var x18 uint32 + var x19 uint32 + x18, x19 = bits.Add32(x1, (x17 & 0xfc632551), uint32(0x0)) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x3, (x17 & 0xf3b9cac2), uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x5, (x17 & 0xa7179e84), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x7, (x17 & 0xbce6faad), uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(x9, x17, uint32(uint1(x25))) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(x11, x17, uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(x13, uint32(0x0), uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(x15, x17, uint32(uint1(x31))) + out1[0] = x18 + out1[1] = x20 + out1[2] = x22 + out1[3] = x24 + out1[4] = x26 + out1[5] = x28 + out1[6] = x30 + out1[7] = x32 +} + +// Opp negates a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +// 0 ≤ eval out1 < m +// +func Opp(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + var x1 uint32 + var x2 uint32 + x1, x2 = bits.Sub32(uint32(0x0), arg1[0], uint32(0x0)) + var x3 uint32 + var x4 uint32 + x3, x4 = bits.Sub32(uint32(0x0), arg1[1], uint32(uint1(x2))) + var x5 uint32 + var x6 uint32 + x5, x6 = bits.Sub32(uint32(0x0), arg1[2], uint32(uint1(x4))) + var x7 uint32 + var x8 uint32 + x7, x8 = bits.Sub32(uint32(0x0), arg1[3], uint32(uint1(x6))) + var x9 uint32 + var x10 uint32 + x9, x10 = bits.Sub32(uint32(0x0), arg1[4], uint32(uint1(x8))) + var x11 uint32 + var x12 uint32 + x11, x12 = bits.Sub32(uint32(0x0), arg1[5], uint32(uint1(x10))) + var x13 uint32 + var x14 uint32 + x13, x14 = bits.Sub32(uint32(0x0), arg1[6], uint32(uint1(x12))) + var x15 uint32 + var x16 uint32 + x15, x16 = bits.Sub32(uint32(0x0), arg1[7], uint32(uint1(x14))) + var x17 uint32 + cmovznzU32(&x17, uint1(x16), uint32(0x0), 0xffffffff) + var x18 uint32 + var x19 uint32 + x18, x19 = bits.Add32(x1, (x17 & 0xfc632551), uint32(0x0)) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x3, (x17 & 0xf3b9cac2), uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x5, (x17 & 0xa7179e84), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x7, (x17 & 0xbce6faad), uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(x9, x17, uint32(uint1(x25))) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(x11, x17, uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(x13, uint32(0x0), uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(x15, x17, uint32(uint1(x31))) + out1[0] = x18 + out1[1] = x20 + out1[2] = x22 + out1[3] = x24 + out1[4] = x26 + out1[5] = x28 + out1[6] = x30 + out1[7] = x32 +} + +// FromMontgomery translates a field element out of the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m +// 0 ≤ eval out1 < m +// +func FromMontgomery(out1 *NonMontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[0] + var x2 uint32 + _, x2 = bits.Mul32(x1, 0xee00bc4f) + var x4 uint32 + var x5 uint32 + x5, x4 = bits.Mul32(x2, 0xffffffff) + var x6 uint32 + var x7 uint32 + x7, x6 = bits.Mul32(x2, 0xffffffff) + var x8 uint32 + var x9 uint32 + x9, x8 = bits.Mul32(x2, 0xffffffff) + var x10 uint32 + var x11 uint32 + x11, x10 = bits.Mul32(x2, 0xbce6faad) + var x12 uint32 + var x13 uint32 + x13, x12 = bits.Mul32(x2, 0xa7179e84) + var x14 uint32 + var x15 uint32 + x15, x14 = bits.Mul32(x2, 0xf3b9cac2) + var x16 uint32 + var x17 uint32 + x17, x16 = bits.Mul32(x2, 0xfc632551) + var x18 uint32 + var x19 uint32 + x18, x19 = bits.Add32(x17, x14, uint32(0x0)) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x15, x12, uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x13, x10, uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x11, x8, uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(x9, x6, uint32(uint1(x25))) + var x29 uint32 + _, x29 = bits.Add32(x1, x16, uint32(0x0)) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(uint32(0x0), x18, uint32(uint1(x29))) + var x32 uint32 + var x33 uint32 + x32, x33 = bits.Add32(uint32(0x0), x20, uint32(uint1(x31))) + var x34 uint32 + var x35 uint32 + x34, x35 = bits.Add32(uint32(0x0), x22, uint32(uint1(x33))) + var x36 uint32 + var x37 uint32 + x36, x37 = bits.Add32(uint32(0x0), x24, uint32(uint1(x35))) + var x38 uint32 + var x39 uint32 + x38, x39 = bits.Add32(uint32(0x0), x26, uint32(uint1(x37))) + var x40 uint32 + var x41 uint32 + x40, x41 = bits.Add32(uint32(0x0), (uint32(uint1(x27)) + x7), uint32(uint1(x39))) + var x42 uint32 + var x43 uint32 + x42, x43 = bits.Add32(uint32(0x0), x4, uint32(uint1(x41))) + var x44 uint32 + var x45 uint32 + x44, x45 = bits.Add32(x30, arg1[1], uint32(0x0)) + var x46 uint32 + var x47 uint32 + x46, x47 = bits.Add32(x32, uint32(0x0), uint32(uint1(x45))) + var x48 uint32 + var x49 uint32 + x48, x49 = bits.Add32(x34, uint32(0x0), uint32(uint1(x47))) + var x50 uint32 + var x51 uint32 + x50, x51 = bits.Add32(x36, uint32(0x0), uint32(uint1(x49))) + var x52 uint32 + var x53 uint32 + x52, x53 = bits.Add32(x38, uint32(0x0), uint32(uint1(x51))) + var x54 uint32 + var x55 uint32 + x54, x55 = bits.Add32(x40, uint32(0x0), uint32(uint1(x53))) + var x56 uint32 + var x57 uint32 + x56, x57 = bits.Add32(x42, uint32(0x0), uint32(uint1(x55))) + var x58 uint32 + var x59 uint32 + x58, x59 = bits.Add32((uint32(uint1(x43)) + x5), uint32(0x0), uint32(uint1(x57))) + var x60 uint32 + _, x60 = bits.Mul32(x44, 0xee00bc4f) + var x62 uint32 + var x63 uint32 + x63, x62 = bits.Mul32(x60, 0xffffffff) + var x64 uint32 + var x65 uint32 + x65, x64 = bits.Mul32(x60, 0xffffffff) + var x66 uint32 + var x67 uint32 + x67, x66 = bits.Mul32(x60, 0xffffffff) + var x68 uint32 + var x69 uint32 + x69, x68 = bits.Mul32(x60, 0xbce6faad) + var x70 uint32 + var x71 uint32 + x71, x70 = bits.Mul32(x60, 0xa7179e84) + var x72 uint32 + var x73 uint32 + x73, x72 = bits.Mul32(x60, 0xf3b9cac2) + var x74 uint32 + var x75 uint32 + x75, x74 = bits.Mul32(x60, 0xfc632551) + var x76 uint32 + var x77 uint32 + x76, x77 = bits.Add32(x75, x72, uint32(0x0)) + var x78 uint32 + var x79 uint32 + x78, x79 = bits.Add32(x73, x70, uint32(uint1(x77))) + var x80 uint32 + var x81 uint32 + x80, x81 = bits.Add32(x71, x68, uint32(uint1(x79))) + var x82 uint32 + var x83 uint32 + x82, x83 = bits.Add32(x69, x66, uint32(uint1(x81))) + var x84 uint32 + var x85 uint32 + x84, x85 = bits.Add32(x67, x64, uint32(uint1(x83))) + var x87 uint32 + _, x87 = bits.Add32(x44, x74, uint32(0x0)) + var x88 uint32 + var x89 uint32 + x88, x89 = bits.Add32(x46, x76, uint32(uint1(x87))) + var x90 uint32 + var x91 uint32 + x90, x91 = bits.Add32(x48, x78, uint32(uint1(x89))) + var x92 uint32 + var x93 uint32 + x92, x93 = bits.Add32(x50, x80, uint32(uint1(x91))) + var x94 uint32 + var x95 uint32 + x94, x95 = bits.Add32(x52, x82, uint32(uint1(x93))) + var x96 uint32 + var x97 uint32 + x96, x97 = bits.Add32(x54, x84, uint32(uint1(x95))) + var x98 uint32 + var x99 uint32 + x98, x99 = bits.Add32(x56, (uint32(uint1(x85)) + x65), uint32(uint1(x97))) + var x100 uint32 + var x101 uint32 + x100, x101 = bits.Add32(x58, x62, uint32(uint1(x99))) + var x102 uint32 + var x103 uint32 + x102, x103 = bits.Add32(uint32(uint1(x59)), x63, uint32(uint1(x101))) + var x104 uint32 + var x105 uint32 + x104, x105 = bits.Add32(x88, arg1[2], uint32(0x0)) + var x106 uint32 + var x107 uint32 + x106, x107 = bits.Add32(x90, uint32(0x0), uint32(uint1(x105))) + var x108 uint32 + var x109 uint32 + x108, x109 = bits.Add32(x92, uint32(0x0), uint32(uint1(x107))) + var x110 uint32 + var x111 uint32 + x110, x111 = bits.Add32(x94, uint32(0x0), uint32(uint1(x109))) + var x112 uint32 + var x113 uint32 + x112, x113 = bits.Add32(x96, uint32(0x0), uint32(uint1(x111))) + var x114 uint32 + var x115 uint32 + x114, x115 = bits.Add32(x98, uint32(0x0), uint32(uint1(x113))) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32(x100, uint32(0x0), uint32(uint1(x115))) + var x118 uint32 + var x119 uint32 + x118, x119 = bits.Add32(x102, uint32(0x0), uint32(uint1(x117))) + var x120 uint32 + _, x120 = bits.Mul32(x104, 0xee00bc4f) + var x122 uint32 + var x123 uint32 + x123, x122 = bits.Mul32(x120, 0xffffffff) + var x124 uint32 + var x125 uint32 + x125, x124 = bits.Mul32(x120, 0xffffffff) + var x126 uint32 + var x127 uint32 + x127, x126 = bits.Mul32(x120, 0xffffffff) + var x128 uint32 + var x129 uint32 + x129, x128 = bits.Mul32(x120, 0xbce6faad) + var x130 uint32 + var x131 uint32 + x131, x130 = bits.Mul32(x120, 0xa7179e84) + var x132 uint32 + var x133 uint32 + x133, x132 = bits.Mul32(x120, 0xf3b9cac2) + var x134 uint32 + var x135 uint32 + x135, x134 = bits.Mul32(x120, 0xfc632551) + var x136 uint32 + var x137 uint32 + x136, x137 = bits.Add32(x135, x132, uint32(0x0)) + var x138 uint32 + var x139 uint32 + x138, x139 = bits.Add32(x133, x130, uint32(uint1(x137))) + var x140 uint32 + var x141 uint32 + x140, x141 = bits.Add32(x131, x128, uint32(uint1(x139))) + var x142 uint32 + var x143 uint32 + x142, x143 = bits.Add32(x129, x126, uint32(uint1(x141))) + var x144 uint32 + var x145 uint32 + x144, x145 = bits.Add32(x127, x124, uint32(uint1(x143))) + var x147 uint32 + _, x147 = bits.Add32(x104, x134, uint32(0x0)) + var x148 uint32 + var x149 uint32 + x148, x149 = bits.Add32(x106, x136, uint32(uint1(x147))) + var x150 uint32 + var x151 uint32 + x150, x151 = bits.Add32(x108, x138, uint32(uint1(x149))) + var x152 uint32 + var x153 uint32 + x152, x153 = bits.Add32(x110, x140, uint32(uint1(x151))) + var x154 uint32 + var x155 uint32 + x154, x155 = bits.Add32(x112, x142, uint32(uint1(x153))) + var x156 uint32 + var x157 uint32 + x156, x157 = bits.Add32(x114, x144, uint32(uint1(x155))) + var x158 uint32 + var x159 uint32 + x158, x159 = bits.Add32(x116, (uint32(uint1(x145)) + x125), uint32(uint1(x157))) + var x160 uint32 + var x161 uint32 + x160, x161 = bits.Add32(x118, x122, uint32(uint1(x159))) + var x162 uint32 + var x163 uint32 + x162, x163 = bits.Add32((uint32(uint1(x119)) + uint32(uint1(x103))), x123, uint32(uint1(x161))) + var x164 uint32 + var x165 uint32 + x164, x165 = bits.Add32(x148, arg1[3], uint32(0x0)) + var x166 uint32 + var x167 uint32 + x166, x167 = bits.Add32(x150, uint32(0x0), uint32(uint1(x165))) + var x168 uint32 + var x169 uint32 + x168, x169 = bits.Add32(x152, uint32(0x0), uint32(uint1(x167))) + var x170 uint32 + var x171 uint32 + x170, x171 = bits.Add32(x154, uint32(0x0), uint32(uint1(x169))) + var x172 uint32 + var x173 uint32 + x172, x173 = bits.Add32(x156, uint32(0x0), uint32(uint1(x171))) + var x174 uint32 + var x175 uint32 + x174, x175 = bits.Add32(x158, uint32(0x0), uint32(uint1(x173))) + var x176 uint32 + var x177 uint32 + x176, x177 = bits.Add32(x160, uint32(0x0), uint32(uint1(x175))) + var x178 uint32 + var x179 uint32 + x178, x179 = bits.Add32(x162, uint32(0x0), uint32(uint1(x177))) + var x180 uint32 + _, x180 = bits.Mul32(x164, 0xee00bc4f) + var x182 uint32 + var x183 uint32 + x183, x182 = bits.Mul32(x180, 0xffffffff) + var x184 uint32 + var x185 uint32 + x185, x184 = bits.Mul32(x180, 0xffffffff) + var x186 uint32 + var x187 uint32 + x187, x186 = bits.Mul32(x180, 0xffffffff) + var x188 uint32 + var x189 uint32 + x189, x188 = bits.Mul32(x180, 0xbce6faad) + var x190 uint32 + var x191 uint32 + x191, x190 = bits.Mul32(x180, 0xa7179e84) + var x192 uint32 + var x193 uint32 + x193, x192 = bits.Mul32(x180, 0xf3b9cac2) + var x194 uint32 + var x195 uint32 + x195, x194 = bits.Mul32(x180, 0xfc632551) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Add32(x195, x192, uint32(0x0)) + var x198 uint32 + var x199 uint32 + x198, x199 = bits.Add32(x193, x190, uint32(uint1(x197))) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Add32(x191, x188, uint32(uint1(x199))) + var x202 uint32 + var x203 uint32 + x202, x203 = bits.Add32(x189, x186, uint32(uint1(x201))) + var x204 uint32 + var x205 uint32 + x204, x205 = bits.Add32(x187, x184, uint32(uint1(x203))) + var x207 uint32 + _, x207 = bits.Add32(x164, x194, uint32(0x0)) + var x208 uint32 + var x209 uint32 + x208, x209 = bits.Add32(x166, x196, uint32(uint1(x207))) + var x210 uint32 + var x211 uint32 + x210, x211 = bits.Add32(x168, x198, uint32(uint1(x209))) + var x212 uint32 + var x213 uint32 + x212, x213 = bits.Add32(x170, x200, uint32(uint1(x211))) + var x214 uint32 + var x215 uint32 + x214, x215 = bits.Add32(x172, x202, uint32(uint1(x213))) + var x216 uint32 + var x217 uint32 + x216, x217 = bits.Add32(x174, x204, uint32(uint1(x215))) + var x218 uint32 + var x219 uint32 + x218, x219 = bits.Add32(x176, (uint32(uint1(x205)) + x185), uint32(uint1(x217))) + var x220 uint32 + var x221 uint32 + x220, x221 = bits.Add32(x178, x182, uint32(uint1(x219))) + var x222 uint32 + var x223 uint32 + x222, x223 = bits.Add32((uint32(uint1(x179)) + uint32(uint1(x163))), x183, uint32(uint1(x221))) + var x224 uint32 + var x225 uint32 + x224, x225 = bits.Add32(x208, arg1[4], uint32(0x0)) + var x226 uint32 + var x227 uint32 + x226, x227 = bits.Add32(x210, uint32(0x0), uint32(uint1(x225))) + var x228 uint32 + var x229 uint32 + x228, x229 = bits.Add32(x212, uint32(0x0), uint32(uint1(x227))) + var x230 uint32 + var x231 uint32 + x230, x231 = bits.Add32(x214, uint32(0x0), uint32(uint1(x229))) + var x232 uint32 + var x233 uint32 + x232, x233 = bits.Add32(x216, uint32(0x0), uint32(uint1(x231))) + var x234 uint32 + var x235 uint32 + x234, x235 = bits.Add32(x218, uint32(0x0), uint32(uint1(x233))) + var x236 uint32 + var x237 uint32 + x236, x237 = bits.Add32(x220, uint32(0x0), uint32(uint1(x235))) + var x238 uint32 + var x239 uint32 + x238, x239 = bits.Add32(x222, uint32(0x0), uint32(uint1(x237))) + var x240 uint32 + _, x240 = bits.Mul32(x224, 0xee00bc4f) + var x242 uint32 + var x243 uint32 + x243, x242 = bits.Mul32(x240, 0xffffffff) + var x244 uint32 + var x245 uint32 + x245, x244 = bits.Mul32(x240, 0xffffffff) + var x246 uint32 + var x247 uint32 + x247, x246 = bits.Mul32(x240, 0xffffffff) + var x248 uint32 + var x249 uint32 + x249, x248 = bits.Mul32(x240, 0xbce6faad) + var x250 uint32 + var x251 uint32 + x251, x250 = bits.Mul32(x240, 0xa7179e84) + var x252 uint32 + var x253 uint32 + x253, x252 = bits.Mul32(x240, 0xf3b9cac2) + var x254 uint32 + var x255 uint32 + x255, x254 = bits.Mul32(x240, 0xfc632551) + var x256 uint32 + var x257 uint32 + x256, x257 = bits.Add32(x255, x252, uint32(0x0)) + var x258 uint32 + var x259 uint32 + x258, x259 = bits.Add32(x253, x250, uint32(uint1(x257))) + var x260 uint32 + var x261 uint32 + x260, x261 = bits.Add32(x251, x248, uint32(uint1(x259))) + var x262 uint32 + var x263 uint32 + x262, x263 = bits.Add32(x249, x246, uint32(uint1(x261))) + var x264 uint32 + var x265 uint32 + x264, x265 = bits.Add32(x247, x244, uint32(uint1(x263))) + var x267 uint32 + _, x267 = bits.Add32(x224, x254, uint32(0x0)) + var x268 uint32 + var x269 uint32 + x268, x269 = bits.Add32(x226, x256, uint32(uint1(x267))) + var x270 uint32 + var x271 uint32 + x270, x271 = bits.Add32(x228, x258, uint32(uint1(x269))) + var x272 uint32 + var x273 uint32 + x272, x273 = bits.Add32(x230, x260, uint32(uint1(x271))) + var x274 uint32 + var x275 uint32 + x274, x275 = bits.Add32(x232, x262, uint32(uint1(x273))) + var x276 uint32 + var x277 uint32 + x276, x277 = bits.Add32(x234, x264, uint32(uint1(x275))) + var x278 uint32 + var x279 uint32 + x278, x279 = bits.Add32(x236, (uint32(uint1(x265)) + x245), uint32(uint1(x277))) + var x280 uint32 + var x281 uint32 + x280, x281 = bits.Add32(x238, x242, uint32(uint1(x279))) + var x282 uint32 + var x283 uint32 + x282, x283 = bits.Add32((uint32(uint1(x239)) + uint32(uint1(x223))), x243, uint32(uint1(x281))) + var x284 uint32 + var x285 uint32 + x284, x285 = bits.Add32(x268, arg1[5], uint32(0x0)) + var x286 uint32 + var x287 uint32 + x286, x287 = bits.Add32(x270, uint32(0x0), uint32(uint1(x285))) + var x288 uint32 + var x289 uint32 + x288, x289 = bits.Add32(x272, uint32(0x0), uint32(uint1(x287))) + var x290 uint32 + var x291 uint32 + x290, x291 = bits.Add32(x274, uint32(0x0), uint32(uint1(x289))) + var x292 uint32 + var x293 uint32 + x292, x293 = bits.Add32(x276, uint32(0x0), uint32(uint1(x291))) + var x294 uint32 + var x295 uint32 + x294, x295 = bits.Add32(x278, uint32(0x0), uint32(uint1(x293))) + var x296 uint32 + var x297 uint32 + x296, x297 = bits.Add32(x280, uint32(0x0), uint32(uint1(x295))) + var x298 uint32 + var x299 uint32 + x298, x299 = bits.Add32(x282, uint32(0x0), uint32(uint1(x297))) + var x300 uint32 + _, x300 = bits.Mul32(x284, 0xee00bc4f) + var x302 uint32 + var x303 uint32 + x303, x302 = bits.Mul32(x300, 0xffffffff) + var x304 uint32 + var x305 uint32 + x305, x304 = bits.Mul32(x300, 0xffffffff) + var x306 uint32 + var x307 uint32 + x307, x306 = bits.Mul32(x300, 0xffffffff) + var x308 uint32 + var x309 uint32 + x309, x308 = bits.Mul32(x300, 0xbce6faad) + var x310 uint32 + var x311 uint32 + x311, x310 = bits.Mul32(x300, 0xa7179e84) + var x312 uint32 + var x313 uint32 + x313, x312 = bits.Mul32(x300, 0xf3b9cac2) + var x314 uint32 + var x315 uint32 + x315, x314 = bits.Mul32(x300, 0xfc632551) + var x316 uint32 + var x317 uint32 + x316, x317 = bits.Add32(x315, x312, uint32(0x0)) + var x318 uint32 + var x319 uint32 + x318, x319 = bits.Add32(x313, x310, uint32(uint1(x317))) + var x320 uint32 + var x321 uint32 + x320, x321 = bits.Add32(x311, x308, uint32(uint1(x319))) + var x322 uint32 + var x323 uint32 + x322, x323 = bits.Add32(x309, x306, uint32(uint1(x321))) + var x324 uint32 + var x325 uint32 + x324, x325 = bits.Add32(x307, x304, uint32(uint1(x323))) + var x327 uint32 + _, x327 = bits.Add32(x284, x314, uint32(0x0)) + var x328 uint32 + var x329 uint32 + x328, x329 = bits.Add32(x286, x316, uint32(uint1(x327))) + var x330 uint32 + var x331 uint32 + x330, x331 = bits.Add32(x288, x318, uint32(uint1(x329))) + var x332 uint32 + var x333 uint32 + x332, x333 = bits.Add32(x290, x320, uint32(uint1(x331))) + var x334 uint32 + var x335 uint32 + x334, x335 = bits.Add32(x292, x322, uint32(uint1(x333))) + var x336 uint32 + var x337 uint32 + x336, x337 = bits.Add32(x294, x324, uint32(uint1(x335))) + var x338 uint32 + var x339 uint32 + x338, x339 = bits.Add32(x296, (uint32(uint1(x325)) + x305), uint32(uint1(x337))) + var x340 uint32 + var x341 uint32 + x340, x341 = bits.Add32(x298, x302, uint32(uint1(x339))) + var x342 uint32 + var x343 uint32 + x342, x343 = bits.Add32((uint32(uint1(x299)) + uint32(uint1(x283))), x303, uint32(uint1(x341))) + var x344 uint32 + var x345 uint32 + x344, x345 = bits.Add32(x328, arg1[6], uint32(0x0)) + var x346 uint32 + var x347 uint32 + x346, x347 = bits.Add32(x330, uint32(0x0), uint32(uint1(x345))) + var x348 uint32 + var x349 uint32 + x348, x349 = bits.Add32(x332, uint32(0x0), uint32(uint1(x347))) + var x350 uint32 + var x351 uint32 + x350, x351 = bits.Add32(x334, uint32(0x0), uint32(uint1(x349))) + var x352 uint32 + var x353 uint32 + x352, x353 = bits.Add32(x336, uint32(0x0), uint32(uint1(x351))) + var x354 uint32 + var x355 uint32 + x354, x355 = bits.Add32(x338, uint32(0x0), uint32(uint1(x353))) + var x356 uint32 + var x357 uint32 + x356, x357 = bits.Add32(x340, uint32(0x0), uint32(uint1(x355))) + var x358 uint32 + var x359 uint32 + x358, x359 = bits.Add32(x342, uint32(0x0), uint32(uint1(x357))) + var x360 uint32 + _, x360 = bits.Mul32(x344, 0xee00bc4f) + var x362 uint32 + var x363 uint32 + x363, x362 = bits.Mul32(x360, 0xffffffff) + var x364 uint32 + var x365 uint32 + x365, x364 = bits.Mul32(x360, 0xffffffff) + var x366 uint32 + var x367 uint32 + x367, x366 = bits.Mul32(x360, 0xffffffff) + var x368 uint32 + var x369 uint32 + x369, x368 = bits.Mul32(x360, 0xbce6faad) + var x370 uint32 + var x371 uint32 + x371, x370 = bits.Mul32(x360, 0xa7179e84) + var x372 uint32 + var x373 uint32 + x373, x372 = bits.Mul32(x360, 0xf3b9cac2) + var x374 uint32 + var x375 uint32 + x375, x374 = bits.Mul32(x360, 0xfc632551) + var x376 uint32 + var x377 uint32 + x376, x377 = bits.Add32(x375, x372, uint32(0x0)) + var x378 uint32 + var x379 uint32 + x378, x379 = bits.Add32(x373, x370, uint32(uint1(x377))) + var x380 uint32 + var x381 uint32 + x380, x381 = bits.Add32(x371, x368, uint32(uint1(x379))) + var x382 uint32 + var x383 uint32 + x382, x383 = bits.Add32(x369, x366, uint32(uint1(x381))) + var x384 uint32 + var x385 uint32 + x384, x385 = bits.Add32(x367, x364, uint32(uint1(x383))) + var x387 uint32 + _, x387 = bits.Add32(x344, x374, uint32(0x0)) + var x388 uint32 + var x389 uint32 + x388, x389 = bits.Add32(x346, x376, uint32(uint1(x387))) + var x390 uint32 + var x391 uint32 + x390, x391 = bits.Add32(x348, x378, uint32(uint1(x389))) + var x392 uint32 + var x393 uint32 + x392, x393 = bits.Add32(x350, x380, uint32(uint1(x391))) + var x394 uint32 + var x395 uint32 + x394, x395 = bits.Add32(x352, x382, uint32(uint1(x393))) + var x396 uint32 + var x397 uint32 + x396, x397 = bits.Add32(x354, x384, uint32(uint1(x395))) + var x398 uint32 + var x399 uint32 + x398, x399 = bits.Add32(x356, (uint32(uint1(x385)) + x365), uint32(uint1(x397))) + var x400 uint32 + var x401 uint32 + x400, x401 = bits.Add32(x358, x362, uint32(uint1(x399))) + var x402 uint32 + var x403 uint32 + x402, x403 = bits.Add32((uint32(uint1(x359)) + uint32(uint1(x343))), x363, uint32(uint1(x401))) + var x404 uint32 + var x405 uint32 + x404, x405 = bits.Add32(x388, arg1[7], uint32(0x0)) + var x406 uint32 + var x407 uint32 + x406, x407 = bits.Add32(x390, uint32(0x0), uint32(uint1(x405))) + var x408 uint32 + var x409 uint32 + x408, x409 = bits.Add32(x392, uint32(0x0), uint32(uint1(x407))) + var x410 uint32 + var x411 uint32 + x410, x411 = bits.Add32(x394, uint32(0x0), uint32(uint1(x409))) + var x412 uint32 + var x413 uint32 + x412, x413 = bits.Add32(x396, uint32(0x0), uint32(uint1(x411))) + var x414 uint32 + var x415 uint32 + x414, x415 = bits.Add32(x398, uint32(0x0), uint32(uint1(x413))) + var x416 uint32 + var x417 uint32 + x416, x417 = bits.Add32(x400, uint32(0x0), uint32(uint1(x415))) + var x418 uint32 + var x419 uint32 + x418, x419 = bits.Add32(x402, uint32(0x0), uint32(uint1(x417))) + var x420 uint32 + _, x420 = bits.Mul32(x404, 0xee00bc4f) + var x422 uint32 + var x423 uint32 + x423, x422 = bits.Mul32(x420, 0xffffffff) + var x424 uint32 + var x425 uint32 + x425, x424 = bits.Mul32(x420, 0xffffffff) + var x426 uint32 + var x427 uint32 + x427, x426 = bits.Mul32(x420, 0xffffffff) + var x428 uint32 + var x429 uint32 + x429, x428 = bits.Mul32(x420, 0xbce6faad) + var x430 uint32 + var x431 uint32 + x431, x430 = bits.Mul32(x420, 0xa7179e84) + var x432 uint32 + var x433 uint32 + x433, x432 = bits.Mul32(x420, 0xf3b9cac2) + var x434 uint32 + var x435 uint32 + x435, x434 = bits.Mul32(x420, 0xfc632551) + var x436 uint32 + var x437 uint32 + x436, x437 = bits.Add32(x435, x432, uint32(0x0)) + var x438 uint32 + var x439 uint32 + x438, x439 = bits.Add32(x433, x430, uint32(uint1(x437))) + var x440 uint32 + var x441 uint32 + x440, x441 = bits.Add32(x431, x428, uint32(uint1(x439))) + var x442 uint32 + var x443 uint32 + x442, x443 = bits.Add32(x429, x426, uint32(uint1(x441))) + var x444 uint32 + var x445 uint32 + x444, x445 = bits.Add32(x427, x424, uint32(uint1(x443))) + var x447 uint32 + _, x447 = bits.Add32(x404, x434, uint32(0x0)) + var x448 uint32 + var x449 uint32 + x448, x449 = bits.Add32(x406, x436, uint32(uint1(x447))) + var x450 uint32 + var x451 uint32 + x450, x451 = bits.Add32(x408, x438, uint32(uint1(x449))) + var x452 uint32 + var x453 uint32 + x452, x453 = bits.Add32(x410, x440, uint32(uint1(x451))) + var x454 uint32 + var x455 uint32 + x454, x455 = bits.Add32(x412, x442, uint32(uint1(x453))) + var x456 uint32 + var x457 uint32 + x456, x457 = bits.Add32(x414, x444, uint32(uint1(x455))) + var x458 uint32 + var x459 uint32 + x458, x459 = bits.Add32(x416, (uint32(uint1(x445)) + x425), uint32(uint1(x457))) + var x460 uint32 + var x461 uint32 + x460, x461 = bits.Add32(x418, x422, uint32(uint1(x459))) + var x462 uint32 + var x463 uint32 + x462, x463 = bits.Add32((uint32(uint1(x419)) + uint32(uint1(x403))), x423, uint32(uint1(x461))) + var x464 uint32 + var x465 uint32 + x464, x465 = bits.Sub32(x448, 0xfc632551, uint32(0x0)) + var x466 uint32 + var x467 uint32 + x466, x467 = bits.Sub32(x450, 0xf3b9cac2, uint32(uint1(x465))) + var x468 uint32 + var x469 uint32 + x468, x469 = bits.Sub32(x452, 0xa7179e84, uint32(uint1(x467))) + var x470 uint32 + var x471 uint32 + x470, x471 = bits.Sub32(x454, 0xbce6faad, uint32(uint1(x469))) + var x472 uint32 + var x473 uint32 + x472, x473 = bits.Sub32(x456, 0xffffffff, uint32(uint1(x471))) + var x474 uint32 + var x475 uint32 + x474, x475 = bits.Sub32(x458, 0xffffffff, uint32(uint1(x473))) + var x476 uint32 + var x477 uint32 + x476, x477 = bits.Sub32(x460, uint32(0x0), uint32(uint1(x475))) + var x478 uint32 + var x479 uint32 + x478, x479 = bits.Sub32(x462, 0xffffffff, uint32(uint1(x477))) + var x481 uint32 + _, x481 = bits.Sub32(uint32(uint1(x463)), uint32(0x0), uint32(uint1(x479))) + var x482 uint32 + cmovznzU32(&x482, uint1(x481), x464, x448) + var x483 uint32 + cmovznzU32(&x483, uint1(x481), x466, x450) + var x484 uint32 + cmovznzU32(&x484, uint1(x481), x468, x452) + var x485 uint32 + cmovznzU32(&x485, uint1(x481), x470, x454) + var x486 uint32 + cmovznzU32(&x486, uint1(x481), x472, x456) + var x487 uint32 + cmovznzU32(&x487, uint1(x481), x474, x458) + var x488 uint32 + cmovznzU32(&x488, uint1(x481), x476, x460) + var x489 uint32 + cmovznzU32(&x489, uint1(x481), x478, x462) + out1[0] = x482 + out1[1] = x483 + out1[2] = x484 + out1[3] = x485 + out1[4] = x486 + out1[5] = x487 + out1[6] = x488 + out1[7] = x489 +} + +// ToMontgomery translates a field element into the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = eval arg1 mod m +// 0 ≤ eval out1 < m +// +func ToMontgomery(out1 *MontgomeryDomainFieldElement, arg1 *NonMontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[6] + x7 := arg1[7] + x8 := arg1[0] + var x9 uint32 + var x10 uint32 + x10, x9 = bits.Mul32(x8, 0x66e12d94) + var x11 uint32 + var x12 uint32 + x12, x11 = bits.Mul32(x8, 0xf3d95620) + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x8, 0x2845b239) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x8, 0x2b6bec59) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x8, 0x4699799c) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x8, 0x49bd6fa6) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x8, 0x83244c95) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x8, 0xbe79eea2) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Add32(x24, x21, uint32(0x0)) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Add32(x22, x19, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Add32(x20, x17, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Add32(x18, x15, uint32(uint1(x30))) + var x33 uint32 + var x34 uint32 + x33, x34 = bits.Add32(x16, x13, uint32(uint1(x32))) + var x35 uint32 + var x36 uint32 + x35, x36 = bits.Add32(x14, x11, uint32(uint1(x34))) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Add32(x12, x9, uint32(uint1(x36))) + var x39 uint32 + _, x39 = bits.Mul32(x23, 0xee00bc4f) + var x41 uint32 + var x42 uint32 + x42, x41 = bits.Mul32(x39, 0xffffffff) + var x43 uint32 + var x44 uint32 + x44, x43 = bits.Mul32(x39, 0xffffffff) + var x45 uint32 + var x46 uint32 + x46, x45 = bits.Mul32(x39, 0xffffffff) + var x47 uint32 + var x48 uint32 + x48, x47 = bits.Mul32(x39, 0xbce6faad) + var x49 uint32 + var x50 uint32 + x50, x49 = bits.Mul32(x39, 0xa7179e84) + var x51 uint32 + var x52 uint32 + x52, x51 = bits.Mul32(x39, 0xf3b9cac2) + var x53 uint32 + var x54 uint32 + x54, x53 = bits.Mul32(x39, 0xfc632551) + var x55 uint32 + var x56 uint32 + x55, x56 = bits.Add32(x54, x51, uint32(0x0)) + var x57 uint32 + var x58 uint32 + x57, x58 = bits.Add32(x52, x49, uint32(uint1(x56))) + var x59 uint32 + var x60 uint32 + x59, x60 = bits.Add32(x50, x47, uint32(uint1(x58))) + var x61 uint32 + var x62 uint32 + x61, x62 = bits.Add32(x48, x45, uint32(uint1(x60))) + var x63 uint32 + var x64 uint32 + x63, x64 = bits.Add32(x46, x43, uint32(uint1(x62))) + var x66 uint32 + _, x66 = bits.Add32(x23, x53, uint32(0x0)) + var x67 uint32 + var x68 uint32 + x67, x68 = bits.Add32(x25, x55, uint32(uint1(x66))) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Add32(x27, x57, uint32(uint1(x68))) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Add32(x29, x59, uint32(uint1(x70))) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Add32(x31, x61, uint32(uint1(x72))) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Add32(x33, x63, uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x77, x78 = bits.Add32(x35, (uint32(uint1(x64)) + x44), uint32(uint1(x76))) + var x79 uint32 + var x80 uint32 + x79, x80 = bits.Add32(x37, x41, uint32(uint1(x78))) + var x81 uint32 + var x82 uint32 + x81, x82 = bits.Add32((uint32(uint1(x38)) + x10), x42, uint32(uint1(x80))) + var x83 uint32 + var x84 uint32 + x84, x83 = bits.Mul32(x1, 0x66e12d94) + var x85 uint32 + var x86 uint32 + x86, x85 = bits.Mul32(x1, 0xf3d95620) + var x87 uint32 + var x88 uint32 + x88, x87 = bits.Mul32(x1, 0x2845b239) + var x89 uint32 + var x90 uint32 + x90, x89 = bits.Mul32(x1, 0x2b6bec59) + var x91 uint32 + var x92 uint32 + x92, x91 = bits.Mul32(x1, 0x4699799c) + var x93 uint32 + var x94 uint32 + x94, x93 = bits.Mul32(x1, 0x49bd6fa6) + var x95 uint32 + var x96 uint32 + x96, x95 = bits.Mul32(x1, 0x83244c95) + var x97 uint32 + var x98 uint32 + x98, x97 = bits.Mul32(x1, 0xbe79eea2) + var x99 uint32 + var x100 uint32 + x99, x100 = bits.Add32(x98, x95, uint32(0x0)) + var x101 uint32 + var x102 uint32 + x101, x102 = bits.Add32(x96, x93, uint32(uint1(x100))) + var x103 uint32 + var x104 uint32 + x103, x104 = bits.Add32(x94, x91, uint32(uint1(x102))) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Add32(x92, x89, uint32(uint1(x104))) + var x107 uint32 + var x108 uint32 + x107, x108 = bits.Add32(x90, x87, uint32(uint1(x106))) + var x109 uint32 + var x110 uint32 + x109, x110 = bits.Add32(x88, x85, uint32(uint1(x108))) + var x111 uint32 + var x112 uint32 + x111, x112 = bits.Add32(x86, x83, uint32(uint1(x110))) + var x113 uint32 + var x114 uint32 + x113, x114 = bits.Add32(x67, x97, uint32(0x0)) + var x115 uint32 + var x116 uint32 + x115, x116 = bits.Add32(x69, x99, uint32(uint1(x114))) + var x117 uint32 + var x118 uint32 + x117, x118 = bits.Add32(x71, x101, uint32(uint1(x116))) + var x119 uint32 + var x120 uint32 + x119, x120 = bits.Add32(x73, x103, uint32(uint1(x118))) + var x121 uint32 + var x122 uint32 + x121, x122 = bits.Add32(x75, x105, uint32(uint1(x120))) + var x123 uint32 + var x124 uint32 + x123, x124 = bits.Add32(x77, x107, uint32(uint1(x122))) + var x125 uint32 + var x126 uint32 + x125, x126 = bits.Add32(x79, x109, uint32(uint1(x124))) + var x127 uint32 + var x128 uint32 + x127, x128 = bits.Add32(x81, x111, uint32(uint1(x126))) + var x129 uint32 + _, x129 = bits.Mul32(x113, 0xee00bc4f) + var x131 uint32 + var x132 uint32 + x132, x131 = bits.Mul32(x129, 0xffffffff) + var x133 uint32 + var x134 uint32 + x134, x133 = bits.Mul32(x129, 0xffffffff) + var x135 uint32 + var x136 uint32 + x136, x135 = bits.Mul32(x129, 0xffffffff) + var x137 uint32 + var x138 uint32 + x138, x137 = bits.Mul32(x129, 0xbce6faad) + var x139 uint32 + var x140 uint32 + x140, x139 = bits.Mul32(x129, 0xa7179e84) + var x141 uint32 + var x142 uint32 + x142, x141 = bits.Mul32(x129, 0xf3b9cac2) + var x143 uint32 + var x144 uint32 + x144, x143 = bits.Mul32(x129, 0xfc632551) + var x145 uint32 + var x146 uint32 + x145, x146 = bits.Add32(x144, x141, uint32(0x0)) + var x147 uint32 + var x148 uint32 + x147, x148 = bits.Add32(x142, x139, uint32(uint1(x146))) + var x149 uint32 + var x150 uint32 + x149, x150 = bits.Add32(x140, x137, uint32(uint1(x148))) + var x151 uint32 + var x152 uint32 + x151, x152 = bits.Add32(x138, x135, uint32(uint1(x150))) + var x153 uint32 + var x154 uint32 + x153, x154 = bits.Add32(x136, x133, uint32(uint1(x152))) + var x156 uint32 + _, x156 = bits.Add32(x113, x143, uint32(0x0)) + var x157 uint32 + var x158 uint32 + x157, x158 = bits.Add32(x115, x145, uint32(uint1(x156))) + var x159 uint32 + var x160 uint32 + x159, x160 = bits.Add32(x117, x147, uint32(uint1(x158))) + var x161 uint32 + var x162 uint32 + x161, x162 = bits.Add32(x119, x149, uint32(uint1(x160))) + var x163 uint32 + var x164 uint32 + x163, x164 = bits.Add32(x121, x151, uint32(uint1(x162))) + var x165 uint32 + var x166 uint32 + x165, x166 = bits.Add32(x123, x153, uint32(uint1(x164))) + var x167 uint32 + var x168 uint32 + x167, x168 = bits.Add32(x125, (uint32(uint1(x154)) + x134), uint32(uint1(x166))) + var x169 uint32 + var x170 uint32 + x169, x170 = bits.Add32(x127, x131, uint32(uint1(x168))) + var x171 uint32 + var x172 uint32 + x171, x172 = bits.Add32(((uint32(uint1(x128)) + uint32(uint1(x82))) + (uint32(uint1(x112)) + x84)), x132, uint32(uint1(x170))) + var x173 uint32 + var x174 uint32 + x174, x173 = bits.Mul32(x2, 0x66e12d94) + var x175 uint32 + var x176 uint32 + x176, x175 = bits.Mul32(x2, 0xf3d95620) + var x177 uint32 + var x178 uint32 + x178, x177 = bits.Mul32(x2, 0x2845b239) + var x179 uint32 + var x180 uint32 + x180, x179 = bits.Mul32(x2, 0x2b6bec59) + var x181 uint32 + var x182 uint32 + x182, x181 = bits.Mul32(x2, 0x4699799c) + var x183 uint32 + var x184 uint32 + x184, x183 = bits.Mul32(x2, 0x49bd6fa6) + var x185 uint32 + var x186 uint32 + x186, x185 = bits.Mul32(x2, 0x83244c95) + var x187 uint32 + var x188 uint32 + x188, x187 = bits.Mul32(x2, 0xbe79eea2) + var x189 uint32 + var x190 uint32 + x189, x190 = bits.Add32(x188, x185, uint32(0x0)) + var x191 uint32 + var x192 uint32 + x191, x192 = bits.Add32(x186, x183, uint32(uint1(x190))) + var x193 uint32 + var x194 uint32 + x193, x194 = bits.Add32(x184, x181, uint32(uint1(x192))) + var x195 uint32 + var x196 uint32 + x195, x196 = bits.Add32(x182, x179, uint32(uint1(x194))) + var x197 uint32 + var x198 uint32 + x197, x198 = bits.Add32(x180, x177, uint32(uint1(x196))) + var x199 uint32 + var x200 uint32 + x199, x200 = bits.Add32(x178, x175, uint32(uint1(x198))) + var x201 uint32 + var x202 uint32 + x201, x202 = bits.Add32(x176, x173, uint32(uint1(x200))) + var x203 uint32 + var x204 uint32 + x203, x204 = bits.Add32(x157, x187, uint32(0x0)) + var x205 uint32 + var x206 uint32 + x205, x206 = bits.Add32(x159, x189, uint32(uint1(x204))) + var x207 uint32 + var x208 uint32 + x207, x208 = bits.Add32(x161, x191, uint32(uint1(x206))) + var x209 uint32 + var x210 uint32 + x209, x210 = bits.Add32(x163, x193, uint32(uint1(x208))) + var x211 uint32 + var x212 uint32 + x211, x212 = bits.Add32(x165, x195, uint32(uint1(x210))) + var x213 uint32 + var x214 uint32 + x213, x214 = bits.Add32(x167, x197, uint32(uint1(x212))) + var x215 uint32 + var x216 uint32 + x215, x216 = bits.Add32(x169, x199, uint32(uint1(x214))) + var x217 uint32 + var x218 uint32 + x217, x218 = bits.Add32(x171, x201, uint32(uint1(x216))) + var x219 uint32 + _, x219 = bits.Mul32(x203, 0xee00bc4f) + var x221 uint32 + var x222 uint32 + x222, x221 = bits.Mul32(x219, 0xffffffff) + var x223 uint32 + var x224 uint32 + x224, x223 = bits.Mul32(x219, 0xffffffff) + var x225 uint32 + var x226 uint32 + x226, x225 = bits.Mul32(x219, 0xffffffff) + var x227 uint32 + var x228 uint32 + x228, x227 = bits.Mul32(x219, 0xbce6faad) + var x229 uint32 + var x230 uint32 + x230, x229 = bits.Mul32(x219, 0xa7179e84) + var x231 uint32 + var x232 uint32 + x232, x231 = bits.Mul32(x219, 0xf3b9cac2) + var x233 uint32 + var x234 uint32 + x234, x233 = bits.Mul32(x219, 0xfc632551) + var x235 uint32 + var x236 uint32 + x235, x236 = bits.Add32(x234, x231, uint32(0x0)) + var x237 uint32 + var x238 uint32 + x237, x238 = bits.Add32(x232, x229, uint32(uint1(x236))) + var x239 uint32 + var x240 uint32 + x239, x240 = bits.Add32(x230, x227, uint32(uint1(x238))) + var x241 uint32 + var x242 uint32 + x241, x242 = bits.Add32(x228, x225, uint32(uint1(x240))) + var x243 uint32 + var x244 uint32 + x243, x244 = bits.Add32(x226, x223, uint32(uint1(x242))) + var x246 uint32 + _, x246 = bits.Add32(x203, x233, uint32(0x0)) + var x247 uint32 + var x248 uint32 + x247, x248 = bits.Add32(x205, x235, uint32(uint1(x246))) + var x249 uint32 + var x250 uint32 + x249, x250 = bits.Add32(x207, x237, uint32(uint1(x248))) + var x251 uint32 + var x252 uint32 + x251, x252 = bits.Add32(x209, x239, uint32(uint1(x250))) + var x253 uint32 + var x254 uint32 + x253, x254 = bits.Add32(x211, x241, uint32(uint1(x252))) + var x255 uint32 + var x256 uint32 + x255, x256 = bits.Add32(x213, x243, uint32(uint1(x254))) + var x257 uint32 + var x258 uint32 + x257, x258 = bits.Add32(x215, (uint32(uint1(x244)) + x224), uint32(uint1(x256))) + var x259 uint32 + var x260 uint32 + x259, x260 = bits.Add32(x217, x221, uint32(uint1(x258))) + var x261 uint32 + var x262 uint32 + x261, x262 = bits.Add32(((uint32(uint1(x218)) + uint32(uint1(x172))) + (uint32(uint1(x202)) + x174)), x222, uint32(uint1(x260))) + var x263 uint32 + var x264 uint32 + x264, x263 = bits.Mul32(x3, 0x66e12d94) + var x265 uint32 + var x266 uint32 + x266, x265 = bits.Mul32(x3, 0xf3d95620) + var x267 uint32 + var x268 uint32 + x268, x267 = bits.Mul32(x3, 0x2845b239) + var x269 uint32 + var x270 uint32 + x270, x269 = bits.Mul32(x3, 0x2b6bec59) + var x271 uint32 + var x272 uint32 + x272, x271 = bits.Mul32(x3, 0x4699799c) + var x273 uint32 + var x274 uint32 + x274, x273 = bits.Mul32(x3, 0x49bd6fa6) + var x275 uint32 + var x276 uint32 + x276, x275 = bits.Mul32(x3, 0x83244c95) + var x277 uint32 + var x278 uint32 + x278, x277 = bits.Mul32(x3, 0xbe79eea2) + var x279 uint32 + var x280 uint32 + x279, x280 = bits.Add32(x278, x275, uint32(0x0)) + var x281 uint32 + var x282 uint32 + x281, x282 = bits.Add32(x276, x273, uint32(uint1(x280))) + var x283 uint32 + var x284 uint32 + x283, x284 = bits.Add32(x274, x271, uint32(uint1(x282))) + var x285 uint32 + var x286 uint32 + x285, x286 = bits.Add32(x272, x269, uint32(uint1(x284))) + var x287 uint32 + var x288 uint32 + x287, x288 = bits.Add32(x270, x267, uint32(uint1(x286))) + var x289 uint32 + var x290 uint32 + x289, x290 = bits.Add32(x268, x265, uint32(uint1(x288))) + var x291 uint32 + var x292 uint32 + x291, x292 = bits.Add32(x266, x263, uint32(uint1(x290))) + var x293 uint32 + var x294 uint32 + x293, x294 = bits.Add32(x247, x277, uint32(0x0)) + var x295 uint32 + var x296 uint32 + x295, x296 = bits.Add32(x249, x279, uint32(uint1(x294))) + var x297 uint32 + var x298 uint32 + x297, x298 = bits.Add32(x251, x281, uint32(uint1(x296))) + var x299 uint32 + var x300 uint32 + x299, x300 = bits.Add32(x253, x283, uint32(uint1(x298))) + var x301 uint32 + var x302 uint32 + x301, x302 = bits.Add32(x255, x285, uint32(uint1(x300))) + var x303 uint32 + var x304 uint32 + x303, x304 = bits.Add32(x257, x287, uint32(uint1(x302))) + var x305 uint32 + var x306 uint32 + x305, x306 = bits.Add32(x259, x289, uint32(uint1(x304))) + var x307 uint32 + var x308 uint32 + x307, x308 = bits.Add32(x261, x291, uint32(uint1(x306))) + var x309 uint32 + _, x309 = bits.Mul32(x293, 0xee00bc4f) + var x311 uint32 + var x312 uint32 + x312, x311 = bits.Mul32(x309, 0xffffffff) + var x313 uint32 + var x314 uint32 + x314, x313 = bits.Mul32(x309, 0xffffffff) + var x315 uint32 + var x316 uint32 + x316, x315 = bits.Mul32(x309, 0xffffffff) + var x317 uint32 + var x318 uint32 + x318, x317 = bits.Mul32(x309, 0xbce6faad) + var x319 uint32 + var x320 uint32 + x320, x319 = bits.Mul32(x309, 0xa7179e84) + var x321 uint32 + var x322 uint32 + x322, x321 = bits.Mul32(x309, 0xf3b9cac2) + var x323 uint32 + var x324 uint32 + x324, x323 = bits.Mul32(x309, 0xfc632551) + var x325 uint32 + var x326 uint32 + x325, x326 = bits.Add32(x324, x321, uint32(0x0)) + var x327 uint32 + var x328 uint32 + x327, x328 = bits.Add32(x322, x319, uint32(uint1(x326))) + var x329 uint32 + var x330 uint32 + x329, x330 = bits.Add32(x320, x317, uint32(uint1(x328))) + var x331 uint32 + var x332 uint32 + x331, x332 = bits.Add32(x318, x315, uint32(uint1(x330))) + var x333 uint32 + var x334 uint32 + x333, x334 = bits.Add32(x316, x313, uint32(uint1(x332))) + var x336 uint32 + _, x336 = bits.Add32(x293, x323, uint32(0x0)) + var x337 uint32 + var x338 uint32 + x337, x338 = bits.Add32(x295, x325, uint32(uint1(x336))) + var x339 uint32 + var x340 uint32 + x339, x340 = bits.Add32(x297, x327, uint32(uint1(x338))) + var x341 uint32 + var x342 uint32 + x341, x342 = bits.Add32(x299, x329, uint32(uint1(x340))) + var x343 uint32 + var x344 uint32 + x343, x344 = bits.Add32(x301, x331, uint32(uint1(x342))) + var x345 uint32 + var x346 uint32 + x345, x346 = bits.Add32(x303, x333, uint32(uint1(x344))) + var x347 uint32 + var x348 uint32 + x347, x348 = bits.Add32(x305, (uint32(uint1(x334)) + x314), uint32(uint1(x346))) + var x349 uint32 + var x350 uint32 + x349, x350 = bits.Add32(x307, x311, uint32(uint1(x348))) + var x351 uint32 + var x352 uint32 + x351, x352 = bits.Add32(((uint32(uint1(x308)) + uint32(uint1(x262))) + (uint32(uint1(x292)) + x264)), x312, uint32(uint1(x350))) + var x353 uint32 + var x354 uint32 + x354, x353 = bits.Mul32(x4, 0x66e12d94) + var x355 uint32 + var x356 uint32 + x356, x355 = bits.Mul32(x4, 0xf3d95620) + var x357 uint32 + var x358 uint32 + x358, x357 = bits.Mul32(x4, 0x2845b239) + var x359 uint32 + var x360 uint32 + x360, x359 = bits.Mul32(x4, 0x2b6bec59) + var x361 uint32 + var x362 uint32 + x362, x361 = bits.Mul32(x4, 0x4699799c) + var x363 uint32 + var x364 uint32 + x364, x363 = bits.Mul32(x4, 0x49bd6fa6) + var x365 uint32 + var x366 uint32 + x366, x365 = bits.Mul32(x4, 0x83244c95) + var x367 uint32 + var x368 uint32 + x368, x367 = bits.Mul32(x4, 0xbe79eea2) + var x369 uint32 + var x370 uint32 + x369, x370 = bits.Add32(x368, x365, uint32(0x0)) + var x371 uint32 + var x372 uint32 + x371, x372 = bits.Add32(x366, x363, uint32(uint1(x370))) + var x373 uint32 + var x374 uint32 + x373, x374 = bits.Add32(x364, x361, uint32(uint1(x372))) + var x375 uint32 + var x376 uint32 + x375, x376 = bits.Add32(x362, x359, uint32(uint1(x374))) + var x377 uint32 + var x378 uint32 + x377, x378 = bits.Add32(x360, x357, uint32(uint1(x376))) + var x379 uint32 + var x380 uint32 + x379, x380 = bits.Add32(x358, x355, uint32(uint1(x378))) + var x381 uint32 + var x382 uint32 + x381, x382 = bits.Add32(x356, x353, uint32(uint1(x380))) + var x383 uint32 + var x384 uint32 + x383, x384 = bits.Add32(x337, x367, uint32(0x0)) + var x385 uint32 + var x386 uint32 + x385, x386 = bits.Add32(x339, x369, uint32(uint1(x384))) + var x387 uint32 + var x388 uint32 + x387, x388 = bits.Add32(x341, x371, uint32(uint1(x386))) + var x389 uint32 + var x390 uint32 + x389, x390 = bits.Add32(x343, x373, uint32(uint1(x388))) + var x391 uint32 + var x392 uint32 + x391, x392 = bits.Add32(x345, x375, uint32(uint1(x390))) + var x393 uint32 + var x394 uint32 + x393, x394 = bits.Add32(x347, x377, uint32(uint1(x392))) + var x395 uint32 + var x396 uint32 + x395, x396 = bits.Add32(x349, x379, uint32(uint1(x394))) + var x397 uint32 + var x398 uint32 + x397, x398 = bits.Add32(x351, x381, uint32(uint1(x396))) + var x399 uint32 + _, x399 = bits.Mul32(x383, 0xee00bc4f) + var x401 uint32 + var x402 uint32 + x402, x401 = bits.Mul32(x399, 0xffffffff) + var x403 uint32 + var x404 uint32 + x404, x403 = bits.Mul32(x399, 0xffffffff) + var x405 uint32 + var x406 uint32 + x406, x405 = bits.Mul32(x399, 0xffffffff) + var x407 uint32 + var x408 uint32 + x408, x407 = bits.Mul32(x399, 0xbce6faad) + var x409 uint32 + var x410 uint32 + x410, x409 = bits.Mul32(x399, 0xa7179e84) + var x411 uint32 + var x412 uint32 + x412, x411 = bits.Mul32(x399, 0xf3b9cac2) + var x413 uint32 + var x414 uint32 + x414, x413 = bits.Mul32(x399, 0xfc632551) + var x415 uint32 + var x416 uint32 + x415, x416 = bits.Add32(x414, x411, uint32(0x0)) + var x417 uint32 + var x418 uint32 + x417, x418 = bits.Add32(x412, x409, uint32(uint1(x416))) + var x419 uint32 + var x420 uint32 + x419, x420 = bits.Add32(x410, x407, uint32(uint1(x418))) + var x421 uint32 + var x422 uint32 + x421, x422 = bits.Add32(x408, x405, uint32(uint1(x420))) + var x423 uint32 + var x424 uint32 + x423, x424 = bits.Add32(x406, x403, uint32(uint1(x422))) + var x426 uint32 + _, x426 = bits.Add32(x383, x413, uint32(0x0)) + var x427 uint32 + var x428 uint32 + x427, x428 = bits.Add32(x385, x415, uint32(uint1(x426))) + var x429 uint32 + var x430 uint32 + x429, x430 = bits.Add32(x387, x417, uint32(uint1(x428))) + var x431 uint32 + var x432 uint32 + x431, x432 = bits.Add32(x389, x419, uint32(uint1(x430))) + var x433 uint32 + var x434 uint32 + x433, x434 = bits.Add32(x391, x421, uint32(uint1(x432))) + var x435 uint32 + var x436 uint32 + x435, x436 = bits.Add32(x393, x423, uint32(uint1(x434))) + var x437 uint32 + var x438 uint32 + x437, x438 = bits.Add32(x395, (uint32(uint1(x424)) + x404), uint32(uint1(x436))) + var x439 uint32 + var x440 uint32 + x439, x440 = bits.Add32(x397, x401, uint32(uint1(x438))) + var x441 uint32 + var x442 uint32 + x441, x442 = bits.Add32(((uint32(uint1(x398)) + uint32(uint1(x352))) + (uint32(uint1(x382)) + x354)), x402, uint32(uint1(x440))) + var x443 uint32 + var x444 uint32 + x444, x443 = bits.Mul32(x5, 0x66e12d94) + var x445 uint32 + var x446 uint32 + x446, x445 = bits.Mul32(x5, 0xf3d95620) + var x447 uint32 + var x448 uint32 + x448, x447 = bits.Mul32(x5, 0x2845b239) + var x449 uint32 + var x450 uint32 + x450, x449 = bits.Mul32(x5, 0x2b6bec59) + var x451 uint32 + var x452 uint32 + x452, x451 = bits.Mul32(x5, 0x4699799c) + var x453 uint32 + var x454 uint32 + x454, x453 = bits.Mul32(x5, 0x49bd6fa6) + var x455 uint32 + var x456 uint32 + x456, x455 = bits.Mul32(x5, 0x83244c95) + var x457 uint32 + var x458 uint32 + x458, x457 = bits.Mul32(x5, 0xbe79eea2) + var x459 uint32 + var x460 uint32 + x459, x460 = bits.Add32(x458, x455, uint32(0x0)) + var x461 uint32 + var x462 uint32 + x461, x462 = bits.Add32(x456, x453, uint32(uint1(x460))) + var x463 uint32 + var x464 uint32 + x463, x464 = bits.Add32(x454, x451, uint32(uint1(x462))) + var x465 uint32 + var x466 uint32 + x465, x466 = bits.Add32(x452, x449, uint32(uint1(x464))) + var x467 uint32 + var x468 uint32 + x467, x468 = bits.Add32(x450, x447, uint32(uint1(x466))) + var x469 uint32 + var x470 uint32 + x469, x470 = bits.Add32(x448, x445, uint32(uint1(x468))) + var x471 uint32 + var x472 uint32 + x471, x472 = bits.Add32(x446, x443, uint32(uint1(x470))) + var x473 uint32 + var x474 uint32 + x473, x474 = bits.Add32(x427, x457, uint32(0x0)) + var x475 uint32 + var x476 uint32 + x475, x476 = bits.Add32(x429, x459, uint32(uint1(x474))) + var x477 uint32 + var x478 uint32 + x477, x478 = bits.Add32(x431, x461, uint32(uint1(x476))) + var x479 uint32 + var x480 uint32 + x479, x480 = bits.Add32(x433, x463, uint32(uint1(x478))) + var x481 uint32 + var x482 uint32 + x481, x482 = bits.Add32(x435, x465, uint32(uint1(x480))) + var x483 uint32 + var x484 uint32 + x483, x484 = bits.Add32(x437, x467, uint32(uint1(x482))) + var x485 uint32 + var x486 uint32 + x485, x486 = bits.Add32(x439, x469, uint32(uint1(x484))) + var x487 uint32 + var x488 uint32 + x487, x488 = bits.Add32(x441, x471, uint32(uint1(x486))) + var x489 uint32 + _, x489 = bits.Mul32(x473, 0xee00bc4f) + var x491 uint32 + var x492 uint32 + x492, x491 = bits.Mul32(x489, 0xffffffff) + var x493 uint32 + var x494 uint32 + x494, x493 = bits.Mul32(x489, 0xffffffff) + var x495 uint32 + var x496 uint32 + x496, x495 = bits.Mul32(x489, 0xffffffff) + var x497 uint32 + var x498 uint32 + x498, x497 = bits.Mul32(x489, 0xbce6faad) + var x499 uint32 + var x500 uint32 + x500, x499 = bits.Mul32(x489, 0xa7179e84) + var x501 uint32 + var x502 uint32 + x502, x501 = bits.Mul32(x489, 0xf3b9cac2) + var x503 uint32 + var x504 uint32 + x504, x503 = bits.Mul32(x489, 0xfc632551) + var x505 uint32 + var x506 uint32 + x505, x506 = bits.Add32(x504, x501, uint32(0x0)) + var x507 uint32 + var x508 uint32 + x507, x508 = bits.Add32(x502, x499, uint32(uint1(x506))) + var x509 uint32 + var x510 uint32 + x509, x510 = bits.Add32(x500, x497, uint32(uint1(x508))) + var x511 uint32 + var x512 uint32 + x511, x512 = bits.Add32(x498, x495, uint32(uint1(x510))) + var x513 uint32 + var x514 uint32 + x513, x514 = bits.Add32(x496, x493, uint32(uint1(x512))) + var x516 uint32 + _, x516 = bits.Add32(x473, x503, uint32(0x0)) + var x517 uint32 + var x518 uint32 + x517, x518 = bits.Add32(x475, x505, uint32(uint1(x516))) + var x519 uint32 + var x520 uint32 + x519, x520 = bits.Add32(x477, x507, uint32(uint1(x518))) + var x521 uint32 + var x522 uint32 + x521, x522 = bits.Add32(x479, x509, uint32(uint1(x520))) + var x523 uint32 + var x524 uint32 + x523, x524 = bits.Add32(x481, x511, uint32(uint1(x522))) + var x525 uint32 + var x526 uint32 + x525, x526 = bits.Add32(x483, x513, uint32(uint1(x524))) + var x527 uint32 + var x528 uint32 + x527, x528 = bits.Add32(x485, (uint32(uint1(x514)) + x494), uint32(uint1(x526))) + var x529 uint32 + var x530 uint32 + x529, x530 = bits.Add32(x487, x491, uint32(uint1(x528))) + var x531 uint32 + var x532 uint32 + x531, x532 = bits.Add32(((uint32(uint1(x488)) + uint32(uint1(x442))) + (uint32(uint1(x472)) + x444)), x492, uint32(uint1(x530))) + var x533 uint32 + var x534 uint32 + x534, x533 = bits.Mul32(x6, 0x66e12d94) + var x535 uint32 + var x536 uint32 + x536, x535 = bits.Mul32(x6, 0xf3d95620) + var x537 uint32 + var x538 uint32 + x538, x537 = bits.Mul32(x6, 0x2845b239) + var x539 uint32 + var x540 uint32 + x540, x539 = bits.Mul32(x6, 0x2b6bec59) + var x541 uint32 + var x542 uint32 + x542, x541 = bits.Mul32(x6, 0x4699799c) + var x543 uint32 + var x544 uint32 + x544, x543 = bits.Mul32(x6, 0x49bd6fa6) + var x545 uint32 + var x546 uint32 + x546, x545 = bits.Mul32(x6, 0x83244c95) + var x547 uint32 + var x548 uint32 + x548, x547 = bits.Mul32(x6, 0xbe79eea2) + var x549 uint32 + var x550 uint32 + x549, x550 = bits.Add32(x548, x545, uint32(0x0)) + var x551 uint32 + var x552 uint32 + x551, x552 = bits.Add32(x546, x543, uint32(uint1(x550))) + var x553 uint32 + var x554 uint32 + x553, x554 = bits.Add32(x544, x541, uint32(uint1(x552))) + var x555 uint32 + var x556 uint32 + x555, x556 = bits.Add32(x542, x539, uint32(uint1(x554))) + var x557 uint32 + var x558 uint32 + x557, x558 = bits.Add32(x540, x537, uint32(uint1(x556))) + var x559 uint32 + var x560 uint32 + x559, x560 = bits.Add32(x538, x535, uint32(uint1(x558))) + var x561 uint32 + var x562 uint32 + x561, x562 = bits.Add32(x536, x533, uint32(uint1(x560))) + var x563 uint32 + var x564 uint32 + x563, x564 = bits.Add32(x517, x547, uint32(0x0)) + var x565 uint32 + var x566 uint32 + x565, x566 = bits.Add32(x519, x549, uint32(uint1(x564))) + var x567 uint32 + var x568 uint32 + x567, x568 = bits.Add32(x521, x551, uint32(uint1(x566))) + var x569 uint32 + var x570 uint32 + x569, x570 = bits.Add32(x523, x553, uint32(uint1(x568))) + var x571 uint32 + var x572 uint32 + x571, x572 = bits.Add32(x525, x555, uint32(uint1(x570))) + var x573 uint32 + var x574 uint32 + x573, x574 = bits.Add32(x527, x557, uint32(uint1(x572))) + var x575 uint32 + var x576 uint32 + x575, x576 = bits.Add32(x529, x559, uint32(uint1(x574))) + var x577 uint32 + var x578 uint32 + x577, x578 = bits.Add32(x531, x561, uint32(uint1(x576))) + var x579 uint32 + _, x579 = bits.Mul32(x563, 0xee00bc4f) + var x581 uint32 + var x582 uint32 + x582, x581 = bits.Mul32(x579, 0xffffffff) + var x583 uint32 + var x584 uint32 + x584, x583 = bits.Mul32(x579, 0xffffffff) + var x585 uint32 + var x586 uint32 + x586, x585 = bits.Mul32(x579, 0xffffffff) + var x587 uint32 + var x588 uint32 + x588, x587 = bits.Mul32(x579, 0xbce6faad) + var x589 uint32 + var x590 uint32 + x590, x589 = bits.Mul32(x579, 0xa7179e84) + var x591 uint32 + var x592 uint32 + x592, x591 = bits.Mul32(x579, 0xf3b9cac2) + var x593 uint32 + var x594 uint32 + x594, x593 = bits.Mul32(x579, 0xfc632551) + var x595 uint32 + var x596 uint32 + x595, x596 = bits.Add32(x594, x591, uint32(0x0)) + var x597 uint32 + var x598 uint32 + x597, x598 = bits.Add32(x592, x589, uint32(uint1(x596))) + var x599 uint32 + var x600 uint32 + x599, x600 = bits.Add32(x590, x587, uint32(uint1(x598))) + var x601 uint32 + var x602 uint32 + x601, x602 = bits.Add32(x588, x585, uint32(uint1(x600))) + var x603 uint32 + var x604 uint32 + x603, x604 = bits.Add32(x586, x583, uint32(uint1(x602))) + var x606 uint32 + _, x606 = bits.Add32(x563, x593, uint32(0x0)) + var x607 uint32 + var x608 uint32 + x607, x608 = bits.Add32(x565, x595, uint32(uint1(x606))) + var x609 uint32 + var x610 uint32 + x609, x610 = bits.Add32(x567, x597, uint32(uint1(x608))) + var x611 uint32 + var x612 uint32 + x611, x612 = bits.Add32(x569, x599, uint32(uint1(x610))) + var x613 uint32 + var x614 uint32 + x613, x614 = bits.Add32(x571, x601, uint32(uint1(x612))) + var x615 uint32 + var x616 uint32 + x615, x616 = bits.Add32(x573, x603, uint32(uint1(x614))) + var x617 uint32 + var x618 uint32 + x617, x618 = bits.Add32(x575, (uint32(uint1(x604)) + x584), uint32(uint1(x616))) + var x619 uint32 + var x620 uint32 + x619, x620 = bits.Add32(x577, x581, uint32(uint1(x618))) + var x621 uint32 + var x622 uint32 + x621, x622 = bits.Add32(((uint32(uint1(x578)) + uint32(uint1(x532))) + (uint32(uint1(x562)) + x534)), x582, uint32(uint1(x620))) + var x623 uint32 + var x624 uint32 + x624, x623 = bits.Mul32(x7, 0x66e12d94) + var x625 uint32 + var x626 uint32 + x626, x625 = bits.Mul32(x7, 0xf3d95620) + var x627 uint32 + var x628 uint32 + x628, x627 = bits.Mul32(x7, 0x2845b239) + var x629 uint32 + var x630 uint32 + x630, x629 = bits.Mul32(x7, 0x2b6bec59) + var x631 uint32 + var x632 uint32 + x632, x631 = bits.Mul32(x7, 0x4699799c) + var x633 uint32 + var x634 uint32 + x634, x633 = bits.Mul32(x7, 0x49bd6fa6) + var x635 uint32 + var x636 uint32 + x636, x635 = bits.Mul32(x7, 0x83244c95) + var x637 uint32 + var x638 uint32 + x638, x637 = bits.Mul32(x7, 0xbe79eea2) + var x639 uint32 + var x640 uint32 + x639, x640 = bits.Add32(x638, x635, uint32(0x0)) + var x641 uint32 + var x642 uint32 + x641, x642 = bits.Add32(x636, x633, uint32(uint1(x640))) + var x643 uint32 + var x644 uint32 + x643, x644 = bits.Add32(x634, x631, uint32(uint1(x642))) + var x645 uint32 + var x646 uint32 + x645, x646 = bits.Add32(x632, x629, uint32(uint1(x644))) + var x647 uint32 + var x648 uint32 + x647, x648 = bits.Add32(x630, x627, uint32(uint1(x646))) + var x649 uint32 + var x650 uint32 + x649, x650 = bits.Add32(x628, x625, uint32(uint1(x648))) + var x651 uint32 + var x652 uint32 + x651, x652 = bits.Add32(x626, x623, uint32(uint1(x650))) + var x653 uint32 + var x654 uint32 + x653, x654 = bits.Add32(x607, x637, uint32(0x0)) + var x655 uint32 + var x656 uint32 + x655, x656 = bits.Add32(x609, x639, uint32(uint1(x654))) + var x657 uint32 + var x658 uint32 + x657, x658 = bits.Add32(x611, x641, uint32(uint1(x656))) + var x659 uint32 + var x660 uint32 + x659, x660 = bits.Add32(x613, x643, uint32(uint1(x658))) + var x661 uint32 + var x662 uint32 + x661, x662 = bits.Add32(x615, x645, uint32(uint1(x660))) + var x663 uint32 + var x664 uint32 + x663, x664 = bits.Add32(x617, x647, uint32(uint1(x662))) + var x665 uint32 + var x666 uint32 + x665, x666 = bits.Add32(x619, x649, uint32(uint1(x664))) + var x667 uint32 + var x668 uint32 + x667, x668 = bits.Add32(x621, x651, uint32(uint1(x666))) + var x669 uint32 + _, x669 = bits.Mul32(x653, 0xee00bc4f) + var x671 uint32 + var x672 uint32 + x672, x671 = bits.Mul32(x669, 0xffffffff) + var x673 uint32 + var x674 uint32 + x674, x673 = bits.Mul32(x669, 0xffffffff) + var x675 uint32 + var x676 uint32 + x676, x675 = bits.Mul32(x669, 0xffffffff) + var x677 uint32 + var x678 uint32 + x678, x677 = bits.Mul32(x669, 0xbce6faad) + var x679 uint32 + var x680 uint32 + x680, x679 = bits.Mul32(x669, 0xa7179e84) + var x681 uint32 + var x682 uint32 + x682, x681 = bits.Mul32(x669, 0xf3b9cac2) + var x683 uint32 + var x684 uint32 + x684, x683 = bits.Mul32(x669, 0xfc632551) + var x685 uint32 + var x686 uint32 + x685, x686 = bits.Add32(x684, x681, uint32(0x0)) + var x687 uint32 + var x688 uint32 + x687, x688 = bits.Add32(x682, x679, uint32(uint1(x686))) + var x689 uint32 + var x690 uint32 + x689, x690 = bits.Add32(x680, x677, uint32(uint1(x688))) + var x691 uint32 + var x692 uint32 + x691, x692 = bits.Add32(x678, x675, uint32(uint1(x690))) + var x693 uint32 + var x694 uint32 + x693, x694 = bits.Add32(x676, x673, uint32(uint1(x692))) + var x696 uint32 + _, x696 = bits.Add32(x653, x683, uint32(0x0)) + var x697 uint32 + var x698 uint32 + x697, x698 = bits.Add32(x655, x685, uint32(uint1(x696))) + var x699 uint32 + var x700 uint32 + x699, x700 = bits.Add32(x657, x687, uint32(uint1(x698))) + var x701 uint32 + var x702 uint32 + x701, x702 = bits.Add32(x659, x689, uint32(uint1(x700))) + var x703 uint32 + var x704 uint32 + x703, x704 = bits.Add32(x661, x691, uint32(uint1(x702))) + var x705 uint32 + var x706 uint32 + x705, x706 = bits.Add32(x663, x693, uint32(uint1(x704))) + var x707 uint32 + var x708 uint32 + x707, x708 = bits.Add32(x665, (uint32(uint1(x694)) + x674), uint32(uint1(x706))) + var x709 uint32 + var x710 uint32 + x709, x710 = bits.Add32(x667, x671, uint32(uint1(x708))) + var x711 uint32 + var x712 uint32 + x711, x712 = bits.Add32(((uint32(uint1(x668)) + uint32(uint1(x622))) + (uint32(uint1(x652)) + x624)), x672, uint32(uint1(x710))) + var x713 uint32 + var x714 uint32 + x713, x714 = bits.Sub32(x697, 0xfc632551, uint32(0x0)) + var x715 uint32 + var x716 uint32 + x715, x716 = bits.Sub32(x699, 0xf3b9cac2, uint32(uint1(x714))) + var x717 uint32 + var x718 uint32 + x717, x718 = bits.Sub32(x701, 0xa7179e84, uint32(uint1(x716))) + var x719 uint32 + var x720 uint32 + x719, x720 = bits.Sub32(x703, 0xbce6faad, uint32(uint1(x718))) + var x721 uint32 + var x722 uint32 + x721, x722 = bits.Sub32(x705, 0xffffffff, uint32(uint1(x720))) + var x723 uint32 + var x724 uint32 + x723, x724 = bits.Sub32(x707, 0xffffffff, uint32(uint1(x722))) + var x725 uint32 + var x726 uint32 + x725, x726 = bits.Sub32(x709, uint32(0x0), uint32(uint1(x724))) + var x727 uint32 + var x728 uint32 + x727, x728 = bits.Sub32(x711, 0xffffffff, uint32(uint1(x726))) + var x730 uint32 + _, x730 = bits.Sub32(uint32(uint1(x712)), uint32(0x0), uint32(uint1(x728))) + var x731 uint32 + cmovznzU32(&x731, uint1(x730), x713, x697) + var x732 uint32 + cmovznzU32(&x732, uint1(x730), x715, x699) + var x733 uint32 + cmovznzU32(&x733, uint1(x730), x717, x701) + var x734 uint32 + cmovznzU32(&x734, uint1(x730), x719, x703) + var x735 uint32 + cmovznzU32(&x735, uint1(x730), x721, x705) + var x736 uint32 + cmovznzU32(&x736, uint1(x730), x723, x707) + var x737 uint32 + cmovznzU32(&x737, uint1(x730), x725, x709) + var x738 uint32 + cmovznzU32(&x738, uint1(x730), x727, x711) + out1[0] = x731 + out1[1] = x732 + out1[2] = x733 + out1[3] = x734 + out1[4] = x735 + out1[5] = x736 + out1[6] = x737 + out1[7] = x738 +} + +// Nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffff] +func Nonzero(out1 *uint32, arg1 *[8]uint32) { + x1 := (arg1[0] | (arg1[1] | (arg1[2] | (arg1[3] | (arg1[4] | (arg1[5] | (arg1[6] | arg1[7]))))))) + *out1 = x1 +} + +// Selectznz is a multi-limb conditional select. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func Selectznz(out1 *[8]uint32, arg1 uint1, arg2 *[8]uint32, arg3 *[8]uint32) { + var x1 uint32 + cmovznzU32(&x1, arg1, arg2[0], arg3[0]) + var x2 uint32 + cmovznzU32(&x2, arg1, arg2[1], arg3[1]) + var x3 uint32 + cmovznzU32(&x3, arg1, arg2[2], arg3[2]) + var x4 uint32 + cmovznzU32(&x4, arg1, arg2[3], arg3[3]) + var x5 uint32 + cmovznzU32(&x5, arg1, arg2[4], arg3[4]) + var x6 uint32 + cmovznzU32(&x6, arg1, arg2[5], arg3[5]) + var x7 uint32 + cmovznzU32(&x7, arg1, arg2[6], arg3[6]) + var x8 uint32 + cmovznzU32(&x8, arg1, arg2[7], arg3[7]) + out1[0] = x1 + out1[1] = x2 + out1[2] = x3 + out1[3] = x4 + out1[4] = x5 + out1[5] = x6 + out1[6] = x7 + out1[7] = x8 +} + +// ToBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +func ToBytes(out1 *[32]uint8, arg1 *[8]uint32) { + x1 := arg1[7] + x2 := arg1[6] + x3 := arg1[5] + x4 := arg1[4] + x5 := arg1[3] + x6 := arg1[2] + x7 := arg1[1] + x8 := arg1[0] + x9 := (uint8(x8) & 0xff) + x10 := (x8 >> 8) + x11 := (uint8(x10) & 0xff) + x12 := (x10 >> 8) + x13 := (uint8(x12) & 0xff) + x14 := uint8((x12 >> 8)) + x15 := (uint8(x7) & 0xff) + x16 := (x7 >> 8) + x17 := (uint8(x16) & 0xff) + x18 := (x16 >> 8) + x19 := (uint8(x18) & 0xff) + x20 := uint8((x18 >> 8)) + x21 := (uint8(x6) & 0xff) + x22 := (x6 >> 8) + x23 := (uint8(x22) & 0xff) + x24 := (x22 >> 8) + x25 := (uint8(x24) & 0xff) + x26 := uint8((x24 >> 8)) + x27 := (uint8(x5) & 0xff) + x28 := (x5 >> 8) + x29 := (uint8(x28) & 0xff) + x30 := (x28 >> 8) + x31 := (uint8(x30) & 0xff) + x32 := uint8((x30 >> 8)) + x33 := (uint8(x4) & 0xff) + x34 := (x4 >> 8) + x35 := (uint8(x34) & 0xff) + x36 := (x34 >> 8) + x37 := (uint8(x36) & 0xff) + x38 := uint8((x36 >> 8)) + x39 := (uint8(x3) & 0xff) + x40 := (x3 >> 8) + x41 := (uint8(x40) & 0xff) + x42 := (x40 >> 8) + x43 := (uint8(x42) & 0xff) + x44 := uint8((x42 >> 8)) + x45 := (uint8(x2) & 0xff) + x46 := (x2 >> 8) + x47 := (uint8(x46) & 0xff) + x48 := (x46 >> 8) + x49 := (uint8(x48) & 0xff) + x50 := uint8((x48 >> 8)) + x51 := (uint8(x1) & 0xff) + x52 := (x1 >> 8) + x53 := (uint8(x52) & 0xff) + x54 := (x52 >> 8) + x55 := (uint8(x54) & 0xff) + x56 := uint8((x54 >> 8)) + out1[0] = x9 + out1[1] = x11 + out1[2] = x13 + out1[3] = x14 + out1[4] = x15 + out1[5] = x17 + out1[6] = x19 + out1[7] = x20 + out1[8] = x21 + out1[9] = x23 + out1[10] = x25 + out1[11] = x26 + out1[12] = x27 + out1[13] = x29 + out1[14] = x31 + out1[15] = x32 + out1[16] = x33 + out1[17] = x35 + out1[18] = x37 + out1[19] = x38 + out1[20] = x39 + out1[21] = x41 + out1[22] = x43 + out1[23] = x44 + out1[24] = x45 + out1[25] = x47 + out1[26] = x49 + out1[27] = x50 + out1[28] = x51 + out1[29] = x53 + out1[30] = x55 + out1[31] = x56 +} + +// FromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +// +// Preconditions: +// 0 ≤ bytes_eval arg1 < m +// Postconditions: +// eval out1 mod m = bytes_eval arg1 mod m +// 0 ≤ eval out1 < m +// +// Input Bounds: +// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func FromBytes(out1 *[8]uint32, arg1 *[32]uint8) { + x1 := (uint32(arg1[31]) << 24) + x2 := (uint32(arg1[30]) << 16) + x3 := (uint32(arg1[29]) << 8) + x4 := arg1[28] + x5 := (uint32(arg1[27]) << 24) + x6 := (uint32(arg1[26]) << 16) + x7 := (uint32(arg1[25]) << 8) + x8 := arg1[24] + x9 := (uint32(arg1[23]) << 24) + x10 := (uint32(arg1[22]) << 16) + x11 := (uint32(arg1[21]) << 8) + x12 := arg1[20] + x13 := (uint32(arg1[19]) << 24) + x14 := (uint32(arg1[18]) << 16) + x15 := (uint32(arg1[17]) << 8) + x16 := arg1[16] + x17 := (uint32(arg1[15]) << 24) + x18 := (uint32(arg1[14]) << 16) + x19 := (uint32(arg1[13]) << 8) + x20 := arg1[12] + x21 := (uint32(arg1[11]) << 24) + x22 := (uint32(arg1[10]) << 16) + x23 := (uint32(arg1[9]) << 8) + x24 := arg1[8] + x25 := (uint32(arg1[7]) << 24) + x26 := (uint32(arg1[6]) << 16) + x27 := (uint32(arg1[5]) << 8) + x28 := arg1[4] + x29 := (uint32(arg1[3]) << 24) + x30 := (uint32(arg1[2]) << 16) + x31 := (uint32(arg1[1]) << 8) + x32 := arg1[0] + x33 := (x31 + uint32(x32)) + x34 := (x30 + x33) + x35 := (x29 + x34) + x36 := (x27 + uint32(x28)) + x37 := (x26 + x36) + x38 := (x25 + x37) + x39 := (x23 + uint32(x24)) + x40 := (x22 + x39) + x41 := (x21 + x40) + x42 := (x19 + uint32(x20)) + x43 := (x18 + x42) + x44 := (x17 + x43) + x45 := (x15 + uint32(x16)) + x46 := (x14 + x45) + x47 := (x13 + x46) + x48 := (x11 + uint32(x12)) + x49 := (x10 + x48) + x50 := (x9 + x49) + x51 := (x7 + uint32(x8)) + x52 := (x6 + x51) + x53 := (x5 + x52) + x54 := (x3 + uint32(x4)) + x55 := (x2 + x54) + x56 := (x1 + x55) + out1[0] = x35 + out1[1] = x38 + out1[2] = x41 + out1[3] = x44 + out1[4] = x47 + out1[5] = x50 + out1[6] = x53 + out1[7] = x56 +} + +// SetOne returns the field element one in the Montgomery domain. +// +// Postconditions: +// eval (from_montgomery out1) mod m = 1 mod m +// 0 ≤ eval out1 < m +// +func SetOne(out1 *MontgomeryDomainFieldElement) { + out1[0] = 0x39cdaaf + out1[1] = 0xc46353d + out1[2] = 0x58e8617b + out1[3] = 0x43190552 + out1[4] = uint32(0x0) + out1[5] = uint32(0x0) + out1[6] = 0xffffffff + out1[7] = uint32(0x0) +} + +// Msat returns the saturated representation of the prime modulus. +// +// Postconditions: +// twos_complement_eval out1 = m +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func Msat(out1 *[9]uint32) { + out1[0] = 0xfc632551 + out1[1] = 0xf3b9cac2 + out1[2] = 0xa7179e84 + out1[3] = 0xbce6faad + out1[4] = 0xffffffff + out1[5] = 0xffffffff + out1[6] = uint32(0x0) + out1[7] = 0xffffffff + out1[8] = uint32(0x0) +} + +// Divstep computes a divstep. +// +// Preconditions: +// 0 ≤ eval arg4 < m +// 0 ≤ eval arg5 < m +// Postconditions: +// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +// 0 ≤ eval out5 < m +// 0 ≤ eval out5 < m +// 0 ≤ eval out2 < m +// 0 ≤ eval out3 < m +// +// Input Bounds: +// arg1: [0x0 ~> 0xffffffff] +// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffff] +// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func Divstep(out1 *uint32, out2 *[9]uint32, out3 *[9]uint32, out4 *[8]uint32, out5 *[8]uint32, arg1 uint32, arg2 *[9]uint32, arg3 *[9]uint32, arg4 *[8]uint32, arg5 *[8]uint32) { + var x1 uint32 + x1, _ = bits.Add32((^arg1), uint32(0x1), uint32(0x0)) + x3 := (uint1((x1 >> 31)) & (uint1(arg3[0]) & 0x1)) + var x4 uint32 + x4, _ = bits.Add32((^arg1), uint32(0x1), uint32(0x0)) + var x6 uint32 + cmovznzU32(&x6, x3, arg1, x4) + var x7 uint32 + cmovznzU32(&x7, x3, arg2[0], arg3[0]) + var x8 uint32 + cmovznzU32(&x8, x3, arg2[1], arg3[1]) + var x9 uint32 + cmovznzU32(&x9, x3, arg2[2], arg3[2]) + var x10 uint32 + cmovznzU32(&x10, x3, arg2[3], arg3[3]) + var x11 uint32 + cmovznzU32(&x11, x3, arg2[4], arg3[4]) + var x12 uint32 + cmovznzU32(&x12, x3, arg2[5], arg3[5]) + var x13 uint32 + cmovznzU32(&x13, x3, arg2[6], arg3[6]) + var x14 uint32 + cmovznzU32(&x14, x3, arg2[7], arg3[7]) + var x15 uint32 + cmovznzU32(&x15, x3, arg2[8], arg3[8]) + var x16 uint32 + var x17 uint32 + x16, x17 = bits.Add32(uint32(0x1), (^arg2[0]), uint32(0x0)) + var x18 uint32 + var x19 uint32 + x18, x19 = bits.Add32(uint32(0x0), (^arg2[1]), uint32(uint1(x17))) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(uint32(0x0), (^arg2[2]), uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(uint32(0x0), (^arg2[3]), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(uint32(0x0), (^arg2[4]), uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(uint32(0x0), (^arg2[5]), uint32(uint1(x25))) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(uint32(0x0), (^arg2[6]), uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(uint32(0x0), (^arg2[7]), uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(uint32(0x0), (^arg2[8]), uint32(uint1(x31))) + var x34 uint32 + cmovznzU32(&x34, x3, arg3[0], x16) + var x35 uint32 + cmovznzU32(&x35, x3, arg3[1], x18) + var x36 uint32 + cmovznzU32(&x36, x3, arg3[2], x20) + var x37 uint32 + cmovznzU32(&x37, x3, arg3[3], x22) + var x38 uint32 + cmovznzU32(&x38, x3, arg3[4], x24) + var x39 uint32 + cmovznzU32(&x39, x3, arg3[5], x26) + var x40 uint32 + cmovznzU32(&x40, x3, arg3[6], x28) + var x41 uint32 + cmovznzU32(&x41, x3, arg3[7], x30) + var x42 uint32 + cmovznzU32(&x42, x3, arg3[8], x32) + var x43 uint32 + cmovznzU32(&x43, x3, arg4[0], arg5[0]) + var x44 uint32 + cmovznzU32(&x44, x3, arg4[1], arg5[1]) + var x45 uint32 + cmovznzU32(&x45, x3, arg4[2], arg5[2]) + var x46 uint32 + cmovznzU32(&x46, x3, arg4[3], arg5[3]) + var x47 uint32 + cmovznzU32(&x47, x3, arg4[4], arg5[4]) + var x48 uint32 + cmovznzU32(&x48, x3, arg4[5], arg5[5]) + var x49 uint32 + cmovznzU32(&x49, x3, arg4[6], arg5[6]) + var x50 uint32 + cmovznzU32(&x50, x3, arg4[7], arg5[7]) + var x51 uint32 + var x52 uint32 + x51, x52 = bits.Add32(x43, x43, uint32(0x0)) + var x53 uint32 + var x54 uint32 + x53, x54 = bits.Add32(x44, x44, uint32(uint1(x52))) + var x55 uint32 + var x56 uint32 + x55, x56 = bits.Add32(x45, x45, uint32(uint1(x54))) + var x57 uint32 + var x58 uint32 + x57, x58 = bits.Add32(x46, x46, uint32(uint1(x56))) + var x59 uint32 + var x60 uint32 + x59, x60 = bits.Add32(x47, x47, uint32(uint1(x58))) + var x61 uint32 + var x62 uint32 + x61, x62 = bits.Add32(x48, x48, uint32(uint1(x60))) + var x63 uint32 + var x64 uint32 + x63, x64 = bits.Add32(x49, x49, uint32(uint1(x62))) + var x65 uint32 + var x66 uint32 + x65, x66 = bits.Add32(x50, x50, uint32(uint1(x64))) + var x67 uint32 + var x68 uint32 + x67, x68 = bits.Sub32(x51, 0xfc632551, uint32(0x0)) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Sub32(x53, 0xf3b9cac2, uint32(uint1(x68))) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Sub32(x55, 0xa7179e84, uint32(uint1(x70))) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Sub32(x57, 0xbce6faad, uint32(uint1(x72))) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Sub32(x59, 0xffffffff, uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x77, x78 = bits.Sub32(x61, 0xffffffff, uint32(uint1(x76))) + var x79 uint32 + var x80 uint32 + x79, x80 = bits.Sub32(x63, uint32(0x0), uint32(uint1(x78))) + var x81 uint32 + var x82 uint32 + x81, x82 = bits.Sub32(x65, 0xffffffff, uint32(uint1(x80))) + var x84 uint32 + _, x84 = bits.Sub32(uint32(uint1(x66)), uint32(0x0), uint32(uint1(x82))) + x85 := arg4[7] + x86 := arg4[6] + x87 := arg4[5] + x88 := arg4[4] + x89 := arg4[3] + x90 := arg4[2] + x91 := arg4[1] + x92 := arg4[0] + var x93 uint32 + var x94 uint32 + x93, x94 = bits.Sub32(uint32(0x0), x92, uint32(0x0)) + var x95 uint32 + var x96 uint32 + x95, x96 = bits.Sub32(uint32(0x0), x91, uint32(uint1(x94))) + var x97 uint32 + var x98 uint32 + x97, x98 = bits.Sub32(uint32(0x0), x90, uint32(uint1(x96))) + var x99 uint32 + var x100 uint32 + x99, x100 = bits.Sub32(uint32(0x0), x89, uint32(uint1(x98))) + var x101 uint32 + var x102 uint32 + x101, x102 = bits.Sub32(uint32(0x0), x88, uint32(uint1(x100))) + var x103 uint32 + var x104 uint32 + x103, x104 = bits.Sub32(uint32(0x0), x87, uint32(uint1(x102))) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Sub32(uint32(0x0), x86, uint32(uint1(x104))) + var x107 uint32 + var x108 uint32 + x107, x108 = bits.Sub32(uint32(0x0), x85, uint32(uint1(x106))) + var x109 uint32 + cmovznzU32(&x109, uint1(x108), uint32(0x0), 0xffffffff) + var x110 uint32 + var x111 uint32 + x110, x111 = bits.Add32(x93, (x109 & 0xfc632551), uint32(0x0)) + var x112 uint32 + var x113 uint32 + x112, x113 = bits.Add32(x95, (x109 & 0xf3b9cac2), uint32(uint1(x111))) + var x114 uint32 + var x115 uint32 + x114, x115 = bits.Add32(x97, (x109 & 0xa7179e84), uint32(uint1(x113))) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32(x99, (x109 & 0xbce6faad), uint32(uint1(x115))) + var x118 uint32 + var x119 uint32 + x118, x119 = bits.Add32(x101, x109, uint32(uint1(x117))) + var x120 uint32 + var x121 uint32 + x120, x121 = bits.Add32(x103, x109, uint32(uint1(x119))) + var x122 uint32 + var x123 uint32 + x122, x123 = bits.Add32(x105, uint32(0x0), uint32(uint1(x121))) + var x124 uint32 + x124, _ = bits.Add32(x107, x109, uint32(uint1(x123))) + var x126 uint32 + cmovznzU32(&x126, x3, arg5[0], x110) + var x127 uint32 + cmovznzU32(&x127, x3, arg5[1], x112) + var x128 uint32 + cmovznzU32(&x128, x3, arg5[2], x114) + var x129 uint32 + cmovznzU32(&x129, x3, arg5[3], x116) + var x130 uint32 + cmovznzU32(&x130, x3, arg5[4], x118) + var x131 uint32 + cmovznzU32(&x131, x3, arg5[5], x120) + var x132 uint32 + cmovznzU32(&x132, x3, arg5[6], x122) + var x133 uint32 + cmovznzU32(&x133, x3, arg5[7], x124) + x134 := (uint1(x34) & 0x1) + var x135 uint32 + cmovznzU32(&x135, x134, uint32(0x0), x7) + var x136 uint32 + cmovznzU32(&x136, x134, uint32(0x0), x8) + var x137 uint32 + cmovznzU32(&x137, x134, uint32(0x0), x9) + var x138 uint32 + cmovznzU32(&x138, x134, uint32(0x0), x10) + var x139 uint32 + cmovznzU32(&x139, x134, uint32(0x0), x11) + var x140 uint32 + cmovznzU32(&x140, x134, uint32(0x0), x12) + var x141 uint32 + cmovznzU32(&x141, x134, uint32(0x0), x13) + var x142 uint32 + cmovznzU32(&x142, x134, uint32(0x0), x14) + var x143 uint32 + cmovznzU32(&x143, x134, uint32(0x0), x15) + var x144 uint32 + var x145 uint32 + x144, x145 = bits.Add32(x34, x135, uint32(0x0)) + var x146 uint32 + var x147 uint32 + x146, x147 = bits.Add32(x35, x136, uint32(uint1(x145))) + var x148 uint32 + var x149 uint32 + x148, x149 = bits.Add32(x36, x137, uint32(uint1(x147))) + var x150 uint32 + var x151 uint32 + x150, x151 = bits.Add32(x37, x138, uint32(uint1(x149))) + var x152 uint32 + var x153 uint32 + x152, x153 = bits.Add32(x38, x139, uint32(uint1(x151))) + var x154 uint32 + var x155 uint32 + x154, x155 = bits.Add32(x39, x140, uint32(uint1(x153))) + var x156 uint32 + var x157 uint32 + x156, x157 = bits.Add32(x40, x141, uint32(uint1(x155))) + var x158 uint32 + var x159 uint32 + x158, x159 = bits.Add32(x41, x142, uint32(uint1(x157))) + var x160 uint32 + x160, _ = bits.Add32(x42, x143, uint32(uint1(x159))) + var x162 uint32 + cmovznzU32(&x162, x134, uint32(0x0), x43) + var x163 uint32 + cmovznzU32(&x163, x134, uint32(0x0), x44) + var x164 uint32 + cmovznzU32(&x164, x134, uint32(0x0), x45) + var x165 uint32 + cmovznzU32(&x165, x134, uint32(0x0), x46) + var x166 uint32 + cmovznzU32(&x166, x134, uint32(0x0), x47) + var x167 uint32 + cmovznzU32(&x167, x134, uint32(0x0), x48) + var x168 uint32 + cmovznzU32(&x168, x134, uint32(0x0), x49) + var x169 uint32 + cmovznzU32(&x169, x134, uint32(0x0), x50) + var x170 uint32 + var x171 uint32 + x170, x171 = bits.Add32(x126, x162, uint32(0x0)) + var x172 uint32 + var x173 uint32 + x172, x173 = bits.Add32(x127, x163, uint32(uint1(x171))) + var x174 uint32 + var x175 uint32 + x174, x175 = bits.Add32(x128, x164, uint32(uint1(x173))) + var x176 uint32 + var x177 uint32 + x176, x177 = bits.Add32(x129, x165, uint32(uint1(x175))) + var x178 uint32 + var x179 uint32 + x178, x179 = bits.Add32(x130, x166, uint32(uint1(x177))) + var x180 uint32 + var x181 uint32 + x180, x181 = bits.Add32(x131, x167, uint32(uint1(x179))) + var x182 uint32 + var x183 uint32 + x182, x183 = bits.Add32(x132, x168, uint32(uint1(x181))) + var x184 uint32 + var x185 uint32 + x184, x185 = bits.Add32(x133, x169, uint32(uint1(x183))) + var x186 uint32 + var x187 uint32 + x186, x187 = bits.Sub32(x170, 0xfc632551, uint32(0x0)) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Sub32(x172, 0xf3b9cac2, uint32(uint1(x187))) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Sub32(x174, 0xa7179e84, uint32(uint1(x189))) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Sub32(x176, 0xbce6faad, uint32(uint1(x191))) + var x194 uint32 + var x195 uint32 + x194, x195 = bits.Sub32(x178, 0xffffffff, uint32(uint1(x193))) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Sub32(x180, 0xffffffff, uint32(uint1(x195))) + var x198 uint32 + var x199 uint32 + x198, x199 = bits.Sub32(x182, uint32(0x0), uint32(uint1(x197))) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Sub32(x184, 0xffffffff, uint32(uint1(x199))) + var x203 uint32 + _, x203 = bits.Sub32(uint32(uint1(x185)), uint32(0x0), uint32(uint1(x201))) + var x204 uint32 + x204, _ = bits.Add32(x6, uint32(0x1), uint32(0x0)) + x206 := ((x144 >> 1) | ((x146 << 31) & 0xffffffff)) + x207 := ((x146 >> 1) | ((x148 << 31) & 0xffffffff)) + x208 := ((x148 >> 1) | ((x150 << 31) & 0xffffffff)) + x209 := ((x150 >> 1) | ((x152 << 31) & 0xffffffff)) + x210 := ((x152 >> 1) | ((x154 << 31) & 0xffffffff)) + x211 := ((x154 >> 1) | ((x156 << 31) & 0xffffffff)) + x212 := ((x156 >> 1) | ((x158 << 31) & 0xffffffff)) + x213 := ((x158 >> 1) | ((x160 << 31) & 0xffffffff)) + x214 := ((x160 & 0x80000000) | (x160 >> 1)) + var x215 uint32 + cmovznzU32(&x215, uint1(x84), x67, x51) + var x216 uint32 + cmovznzU32(&x216, uint1(x84), x69, x53) + var x217 uint32 + cmovznzU32(&x217, uint1(x84), x71, x55) + var x218 uint32 + cmovznzU32(&x218, uint1(x84), x73, x57) + var x219 uint32 + cmovznzU32(&x219, uint1(x84), x75, x59) + var x220 uint32 + cmovznzU32(&x220, uint1(x84), x77, x61) + var x221 uint32 + cmovznzU32(&x221, uint1(x84), x79, x63) + var x222 uint32 + cmovznzU32(&x222, uint1(x84), x81, x65) + var x223 uint32 + cmovznzU32(&x223, uint1(x203), x186, x170) + var x224 uint32 + cmovznzU32(&x224, uint1(x203), x188, x172) + var x225 uint32 + cmovznzU32(&x225, uint1(x203), x190, x174) + var x226 uint32 + cmovznzU32(&x226, uint1(x203), x192, x176) + var x227 uint32 + cmovznzU32(&x227, uint1(x203), x194, x178) + var x228 uint32 + cmovznzU32(&x228, uint1(x203), x196, x180) + var x229 uint32 + cmovznzU32(&x229, uint1(x203), x198, x182) + var x230 uint32 + cmovznzU32(&x230, uint1(x203), x200, x184) + *out1 = x204 + out2[0] = x7 + out2[1] = x8 + out2[2] = x9 + out2[3] = x10 + out2[4] = x11 + out2[5] = x12 + out2[6] = x13 + out2[7] = x14 + out2[8] = x15 + out3[0] = x206 + out3[1] = x207 + out3[2] = x208 + out3[3] = x209 + out3[4] = x210 + out3[5] = x211 + out3[6] = x212 + out3[7] = x213 + out3[8] = x214 + out4[0] = x215 + out4[1] = x216 + out4[2] = x217 + out4[3] = x218 + out4[4] = x219 + out4[5] = x220 + out4[6] = x221 + out4[7] = x222 + out5[0] = x223 + out5[1] = x224 + out5[2] = x225 + out5[3] = x226 + out5[4] = x227 + out5[5] = x228 + out5[6] = x229 + out5[7] = x230 +} + +// DivstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +// +// Postconditions: +// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func DivstepPrecomp(out1 *[8]uint32) { + out1[0] = 0xb7fcfbb5 + out1[1] = 0xd739262f + out1[2] = 0x20074414 + out1[3] = 0x8ac6f75d + out1[4] = 0xb5e3c256 + out1[5] = 0xc67428bf + out1[6] = 0xeda7aedf + out1[7] = 0x444962f2 +} diff --git a/fiat-go/32/p384scalar/p384scalar.go b/fiat-go/32/p384scalar/p384scalar.go new file mode 100644 index 0000000000..f567181972 --- /dev/null +++ b/fiat-go/32/p384scalar/p384scalar.go @@ -0,0 +1,11206 @@ +// Code generated by Fiat Cryptography. DO NOT EDIT. +// +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Go --relax-primitive-carry-to-bitwidth 32,64 --cmovznz-by-mul --internal-static --package-case flatcase --public-function-case UpperCamelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case camelCase --no-prefix-fiat --doc-newline-in-typedef-bounds --doc-prepend-header 'Code generated by Fiat Cryptography. DO NOT EDIT.' --doc-text-before-function-name '' --doc-text-before-type-name '' --package-name p384scalar '' 32 '2^384 - 1388124618062372383947042015309946732620727252194336364173' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// +// curve description (via package name): p384scalar +// +// machine_wordsize = 32 (from "32") +// +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// +// m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from "2^384 - 1388124618062372383947042015309946732620727252194336364173") +// +// +// +// NOTE: In addition to the bounds specified above each function, all +// +// functions synthesized for this Montgomery arithmetic require the +// +// input to be strictly less than the prime modulus (m), and also +// +// require the input to be in the unique saturated representation. +// +// All functions also ensure that these two properties are true of +// +// return values. +// +// +// +// Computed values: +// +// eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) +// +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) +// +// twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) in +// +// if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384 +package p384scalar + +import "math/bits" + +type uint1 uint64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 +type int1 int64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 + +// MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +type MontgomeryDomainFieldElement [12]uint32 + +// NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +type NonMontgomeryDomainFieldElement [12]uint32 + +// cmovznzU32 is a single-word conditional move. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [0x0 ~> 0xffffffff] +// arg3: [0x0 ~> 0xffffffff] +// Output Bounds: +// out1: [0x0 ~> 0xffffffff] +func cmovznzU32(out1 *uint32, arg1 uint1, arg2 uint32, arg3 uint32) { + x1 := (uint32(arg1) * 0xffffffff) + x2 := ((x1 & arg3) | ((^x1) & arg2)) + *out1 = x2 +} + +// Mul multiplies two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Mul(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[6] + x7 := arg1[7] + x8 := arg1[8] + x9 := arg1[9] + x10 := arg1[10] + x11 := arg1[11] + x12 := arg1[0] + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x12, arg2[11]) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x12, arg2[10]) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x12, arg2[9]) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x12, arg2[8]) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x12, arg2[7]) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x12, arg2[6]) + var x25 uint32 + var x26 uint32 + x26, x25 = bits.Mul32(x12, arg2[5]) + var x27 uint32 + var x28 uint32 + x28, x27 = bits.Mul32(x12, arg2[4]) + var x29 uint32 + var x30 uint32 + x30, x29 = bits.Mul32(x12, arg2[3]) + var x31 uint32 + var x32 uint32 + x32, x31 = bits.Mul32(x12, arg2[2]) + var x33 uint32 + var x34 uint32 + x34, x33 = bits.Mul32(x12, arg2[1]) + var x35 uint32 + var x36 uint32 + x36, x35 = bits.Mul32(x12, arg2[0]) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Add32(x36, x33, uint32(0x0)) + var x39 uint32 + var x40 uint32 + x39, x40 = bits.Add32(x34, x31, uint32(uint1(x38))) + var x41 uint32 + var x42 uint32 + x41, x42 = bits.Add32(x32, x29, uint32(uint1(x40))) + var x43 uint32 + var x44 uint32 + x43, x44 = bits.Add32(x30, x27, uint32(uint1(x42))) + var x45 uint32 + var x46 uint32 + x45, x46 = bits.Add32(x28, x25, uint32(uint1(x44))) + var x47 uint32 + var x48 uint32 + x47, x48 = bits.Add32(x26, x23, uint32(uint1(x46))) + var x49 uint32 + var x50 uint32 + x49, x50 = bits.Add32(x24, x21, uint32(uint1(x48))) + var x51 uint32 + var x52 uint32 + x51, x52 = bits.Add32(x22, x19, uint32(uint1(x50))) + var x53 uint32 + var x54 uint32 + x53, x54 = bits.Add32(x20, x17, uint32(uint1(x52))) + var x55 uint32 + var x56 uint32 + x55, x56 = bits.Add32(x18, x15, uint32(uint1(x54))) + var x57 uint32 + var x58 uint32 + x57, x58 = bits.Add32(x16, x13, uint32(uint1(x56))) + x59 := (uint32(uint1(x58)) + x14) + var x60 uint32 + _, x60 = bits.Mul32(x35, 0xe88fdc45) + var x62 uint32 + var x63 uint32 + x63, x62 = bits.Mul32(x60, 0xffffffff) + var x64 uint32 + var x65 uint32 + x65, x64 = bits.Mul32(x60, 0xffffffff) + var x66 uint32 + var x67 uint32 + x67, x66 = bits.Mul32(x60, 0xffffffff) + var x68 uint32 + var x69 uint32 + x69, x68 = bits.Mul32(x60, 0xffffffff) + var x70 uint32 + var x71 uint32 + x71, x70 = bits.Mul32(x60, 0xffffffff) + var x72 uint32 + var x73 uint32 + x73, x72 = bits.Mul32(x60, 0xffffffff) + var x74 uint32 + var x75 uint32 + x75, x74 = bits.Mul32(x60, 0xc7634d81) + var x76 uint32 + var x77 uint32 + x77, x76 = bits.Mul32(x60, 0xf4372ddf) + var x78 uint32 + var x79 uint32 + x79, x78 = bits.Mul32(x60, 0x581a0db2) + var x80 uint32 + var x81 uint32 + x81, x80 = bits.Mul32(x60, 0x48b0a77a) + var x82 uint32 + var x83 uint32 + x83, x82 = bits.Mul32(x60, 0xecec196a) + var x84 uint32 + var x85 uint32 + x85, x84 = bits.Mul32(x60, 0xccc52973) + var x86 uint32 + var x87 uint32 + x86, x87 = bits.Add32(x85, x82, uint32(0x0)) + var x88 uint32 + var x89 uint32 + x88, x89 = bits.Add32(x83, x80, uint32(uint1(x87))) + var x90 uint32 + var x91 uint32 + x90, x91 = bits.Add32(x81, x78, uint32(uint1(x89))) + var x92 uint32 + var x93 uint32 + x92, x93 = bits.Add32(x79, x76, uint32(uint1(x91))) + var x94 uint32 + var x95 uint32 + x94, x95 = bits.Add32(x77, x74, uint32(uint1(x93))) + var x96 uint32 + var x97 uint32 + x96, x97 = bits.Add32(x75, x72, uint32(uint1(x95))) + var x98 uint32 + var x99 uint32 + x98, x99 = bits.Add32(x73, x70, uint32(uint1(x97))) + var x100 uint32 + var x101 uint32 + x100, x101 = bits.Add32(x71, x68, uint32(uint1(x99))) + var x102 uint32 + var x103 uint32 + x102, x103 = bits.Add32(x69, x66, uint32(uint1(x101))) + var x104 uint32 + var x105 uint32 + x104, x105 = bits.Add32(x67, x64, uint32(uint1(x103))) + var x106 uint32 + var x107 uint32 + x106, x107 = bits.Add32(x65, x62, uint32(uint1(x105))) + x108 := (uint32(uint1(x107)) + x63) + var x110 uint32 + _, x110 = bits.Add32(x35, x84, uint32(0x0)) + var x111 uint32 + var x112 uint32 + x111, x112 = bits.Add32(x37, x86, uint32(uint1(x110))) + var x113 uint32 + var x114 uint32 + x113, x114 = bits.Add32(x39, x88, uint32(uint1(x112))) + var x115 uint32 + var x116 uint32 + x115, x116 = bits.Add32(x41, x90, uint32(uint1(x114))) + var x117 uint32 + var x118 uint32 + x117, x118 = bits.Add32(x43, x92, uint32(uint1(x116))) + var x119 uint32 + var x120 uint32 + x119, x120 = bits.Add32(x45, x94, uint32(uint1(x118))) + var x121 uint32 + var x122 uint32 + x121, x122 = bits.Add32(x47, x96, uint32(uint1(x120))) + var x123 uint32 + var x124 uint32 + x123, x124 = bits.Add32(x49, x98, uint32(uint1(x122))) + var x125 uint32 + var x126 uint32 + x125, x126 = bits.Add32(x51, x100, uint32(uint1(x124))) + var x127 uint32 + var x128 uint32 + x127, x128 = bits.Add32(x53, x102, uint32(uint1(x126))) + var x129 uint32 + var x130 uint32 + x129, x130 = bits.Add32(x55, x104, uint32(uint1(x128))) + var x131 uint32 + var x132 uint32 + x131, x132 = bits.Add32(x57, x106, uint32(uint1(x130))) + var x133 uint32 + var x134 uint32 + x133, x134 = bits.Add32(x59, x108, uint32(uint1(x132))) + var x135 uint32 + var x136 uint32 + x136, x135 = bits.Mul32(x1, arg2[11]) + var x137 uint32 + var x138 uint32 + x138, x137 = bits.Mul32(x1, arg2[10]) + var x139 uint32 + var x140 uint32 + x140, x139 = bits.Mul32(x1, arg2[9]) + var x141 uint32 + var x142 uint32 + x142, x141 = bits.Mul32(x1, arg2[8]) + var x143 uint32 + var x144 uint32 + x144, x143 = bits.Mul32(x1, arg2[7]) + var x145 uint32 + var x146 uint32 + x146, x145 = bits.Mul32(x1, arg2[6]) + var x147 uint32 + var x148 uint32 + x148, x147 = bits.Mul32(x1, arg2[5]) + var x149 uint32 + var x150 uint32 + x150, x149 = bits.Mul32(x1, arg2[4]) + var x151 uint32 + var x152 uint32 + x152, x151 = bits.Mul32(x1, arg2[3]) + var x153 uint32 + var x154 uint32 + x154, x153 = bits.Mul32(x1, arg2[2]) + var x155 uint32 + var x156 uint32 + x156, x155 = bits.Mul32(x1, arg2[1]) + var x157 uint32 + var x158 uint32 + x158, x157 = bits.Mul32(x1, arg2[0]) + var x159 uint32 + var x160 uint32 + x159, x160 = bits.Add32(x158, x155, uint32(0x0)) + var x161 uint32 + var x162 uint32 + x161, x162 = bits.Add32(x156, x153, uint32(uint1(x160))) + var x163 uint32 + var x164 uint32 + x163, x164 = bits.Add32(x154, x151, uint32(uint1(x162))) + var x165 uint32 + var x166 uint32 + x165, x166 = bits.Add32(x152, x149, uint32(uint1(x164))) + var x167 uint32 + var x168 uint32 + x167, x168 = bits.Add32(x150, x147, uint32(uint1(x166))) + var x169 uint32 + var x170 uint32 + x169, x170 = bits.Add32(x148, x145, uint32(uint1(x168))) + var x171 uint32 + var x172 uint32 + x171, x172 = bits.Add32(x146, x143, uint32(uint1(x170))) + var x173 uint32 + var x174 uint32 + x173, x174 = bits.Add32(x144, x141, uint32(uint1(x172))) + var x175 uint32 + var x176 uint32 + x175, x176 = bits.Add32(x142, x139, uint32(uint1(x174))) + var x177 uint32 + var x178 uint32 + x177, x178 = bits.Add32(x140, x137, uint32(uint1(x176))) + var x179 uint32 + var x180 uint32 + x179, x180 = bits.Add32(x138, x135, uint32(uint1(x178))) + x181 := (uint32(uint1(x180)) + x136) + var x182 uint32 + var x183 uint32 + x182, x183 = bits.Add32(x111, x157, uint32(0x0)) + var x184 uint32 + var x185 uint32 + x184, x185 = bits.Add32(x113, x159, uint32(uint1(x183))) + var x186 uint32 + var x187 uint32 + x186, x187 = bits.Add32(x115, x161, uint32(uint1(x185))) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Add32(x117, x163, uint32(uint1(x187))) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Add32(x119, x165, uint32(uint1(x189))) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Add32(x121, x167, uint32(uint1(x191))) + var x194 uint32 + var x195 uint32 + x194, x195 = bits.Add32(x123, x169, uint32(uint1(x193))) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Add32(x125, x171, uint32(uint1(x195))) + var x198 uint32 + var x199 uint32 + x198, x199 = bits.Add32(x127, x173, uint32(uint1(x197))) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Add32(x129, x175, uint32(uint1(x199))) + var x202 uint32 + var x203 uint32 + x202, x203 = bits.Add32(x131, x177, uint32(uint1(x201))) + var x204 uint32 + var x205 uint32 + x204, x205 = bits.Add32(x133, x179, uint32(uint1(x203))) + var x206 uint32 + var x207 uint32 + x206, x207 = bits.Add32(uint32(uint1(x134)), x181, uint32(uint1(x205))) + var x208 uint32 + _, x208 = bits.Mul32(x182, 0xe88fdc45) + var x210 uint32 + var x211 uint32 + x211, x210 = bits.Mul32(x208, 0xffffffff) + var x212 uint32 + var x213 uint32 + x213, x212 = bits.Mul32(x208, 0xffffffff) + var x214 uint32 + var x215 uint32 + x215, x214 = bits.Mul32(x208, 0xffffffff) + var x216 uint32 + var x217 uint32 + x217, x216 = bits.Mul32(x208, 0xffffffff) + var x218 uint32 + var x219 uint32 + x219, x218 = bits.Mul32(x208, 0xffffffff) + var x220 uint32 + var x221 uint32 + x221, x220 = bits.Mul32(x208, 0xffffffff) + var x222 uint32 + var x223 uint32 + x223, x222 = bits.Mul32(x208, 0xc7634d81) + var x224 uint32 + var x225 uint32 + x225, x224 = bits.Mul32(x208, 0xf4372ddf) + var x226 uint32 + var x227 uint32 + x227, x226 = bits.Mul32(x208, 0x581a0db2) + var x228 uint32 + var x229 uint32 + x229, x228 = bits.Mul32(x208, 0x48b0a77a) + var x230 uint32 + var x231 uint32 + x231, x230 = bits.Mul32(x208, 0xecec196a) + var x232 uint32 + var x233 uint32 + x233, x232 = bits.Mul32(x208, 0xccc52973) + var x234 uint32 + var x235 uint32 + x234, x235 = bits.Add32(x233, x230, uint32(0x0)) + var x236 uint32 + var x237 uint32 + x236, x237 = bits.Add32(x231, x228, uint32(uint1(x235))) + var x238 uint32 + var x239 uint32 + x238, x239 = bits.Add32(x229, x226, uint32(uint1(x237))) + var x240 uint32 + var x241 uint32 + x240, x241 = bits.Add32(x227, x224, uint32(uint1(x239))) + var x242 uint32 + var x243 uint32 + x242, x243 = bits.Add32(x225, x222, uint32(uint1(x241))) + var x244 uint32 + var x245 uint32 + x244, x245 = bits.Add32(x223, x220, uint32(uint1(x243))) + var x246 uint32 + var x247 uint32 + x246, x247 = bits.Add32(x221, x218, uint32(uint1(x245))) + var x248 uint32 + var x249 uint32 + x248, x249 = bits.Add32(x219, x216, uint32(uint1(x247))) + var x250 uint32 + var x251 uint32 + x250, x251 = bits.Add32(x217, x214, uint32(uint1(x249))) + var x252 uint32 + var x253 uint32 + x252, x253 = bits.Add32(x215, x212, uint32(uint1(x251))) + var x254 uint32 + var x255 uint32 + x254, x255 = bits.Add32(x213, x210, uint32(uint1(x253))) + x256 := (uint32(uint1(x255)) + x211) + var x258 uint32 + _, x258 = bits.Add32(x182, x232, uint32(0x0)) + var x259 uint32 + var x260 uint32 + x259, x260 = bits.Add32(x184, x234, uint32(uint1(x258))) + var x261 uint32 + var x262 uint32 + x261, x262 = bits.Add32(x186, x236, uint32(uint1(x260))) + var x263 uint32 + var x264 uint32 + x263, x264 = bits.Add32(x188, x238, uint32(uint1(x262))) + var x265 uint32 + var x266 uint32 + x265, x266 = bits.Add32(x190, x240, uint32(uint1(x264))) + var x267 uint32 + var x268 uint32 + x267, x268 = bits.Add32(x192, x242, uint32(uint1(x266))) + var x269 uint32 + var x270 uint32 + x269, x270 = bits.Add32(x194, x244, uint32(uint1(x268))) + var x271 uint32 + var x272 uint32 + x271, x272 = bits.Add32(x196, x246, uint32(uint1(x270))) + var x273 uint32 + var x274 uint32 + x273, x274 = bits.Add32(x198, x248, uint32(uint1(x272))) + var x275 uint32 + var x276 uint32 + x275, x276 = bits.Add32(x200, x250, uint32(uint1(x274))) + var x277 uint32 + var x278 uint32 + x277, x278 = bits.Add32(x202, x252, uint32(uint1(x276))) + var x279 uint32 + var x280 uint32 + x279, x280 = bits.Add32(x204, x254, uint32(uint1(x278))) + var x281 uint32 + var x282 uint32 + x281, x282 = bits.Add32(x206, x256, uint32(uint1(x280))) + x283 := (uint32(uint1(x282)) + uint32(uint1(x207))) + var x284 uint32 + var x285 uint32 + x285, x284 = bits.Mul32(x2, arg2[11]) + var x286 uint32 + var x287 uint32 + x287, x286 = bits.Mul32(x2, arg2[10]) + var x288 uint32 + var x289 uint32 + x289, x288 = bits.Mul32(x2, arg2[9]) + var x290 uint32 + var x291 uint32 + x291, x290 = bits.Mul32(x2, arg2[8]) + var x292 uint32 + var x293 uint32 + x293, x292 = bits.Mul32(x2, arg2[7]) + var x294 uint32 + var x295 uint32 + x295, x294 = bits.Mul32(x2, arg2[6]) + var x296 uint32 + var x297 uint32 + x297, x296 = bits.Mul32(x2, arg2[5]) + var x298 uint32 + var x299 uint32 + x299, x298 = bits.Mul32(x2, arg2[4]) + var x300 uint32 + var x301 uint32 + x301, x300 = bits.Mul32(x2, arg2[3]) + var x302 uint32 + var x303 uint32 + x303, x302 = bits.Mul32(x2, arg2[2]) + var x304 uint32 + var x305 uint32 + x305, x304 = bits.Mul32(x2, arg2[1]) + var x306 uint32 + var x307 uint32 + x307, x306 = bits.Mul32(x2, arg2[0]) + var x308 uint32 + var x309 uint32 + x308, x309 = bits.Add32(x307, x304, uint32(0x0)) + var x310 uint32 + var x311 uint32 + x310, x311 = bits.Add32(x305, x302, uint32(uint1(x309))) + var x312 uint32 + var x313 uint32 + x312, x313 = bits.Add32(x303, x300, uint32(uint1(x311))) + var x314 uint32 + var x315 uint32 + x314, x315 = bits.Add32(x301, x298, uint32(uint1(x313))) + var x316 uint32 + var x317 uint32 + x316, x317 = bits.Add32(x299, x296, uint32(uint1(x315))) + var x318 uint32 + var x319 uint32 + x318, x319 = bits.Add32(x297, x294, uint32(uint1(x317))) + var x320 uint32 + var x321 uint32 + x320, x321 = bits.Add32(x295, x292, uint32(uint1(x319))) + var x322 uint32 + var x323 uint32 + x322, x323 = bits.Add32(x293, x290, uint32(uint1(x321))) + var x324 uint32 + var x325 uint32 + x324, x325 = bits.Add32(x291, x288, uint32(uint1(x323))) + var x326 uint32 + var x327 uint32 + x326, x327 = bits.Add32(x289, x286, uint32(uint1(x325))) + var x328 uint32 + var x329 uint32 + x328, x329 = bits.Add32(x287, x284, uint32(uint1(x327))) + x330 := (uint32(uint1(x329)) + x285) + var x331 uint32 + var x332 uint32 + x331, x332 = bits.Add32(x259, x306, uint32(0x0)) + var x333 uint32 + var x334 uint32 + x333, x334 = bits.Add32(x261, x308, uint32(uint1(x332))) + var x335 uint32 + var x336 uint32 + x335, x336 = bits.Add32(x263, x310, uint32(uint1(x334))) + var x337 uint32 + var x338 uint32 + x337, x338 = bits.Add32(x265, x312, uint32(uint1(x336))) + var x339 uint32 + var x340 uint32 + x339, x340 = bits.Add32(x267, x314, uint32(uint1(x338))) + var x341 uint32 + var x342 uint32 + x341, x342 = bits.Add32(x269, x316, uint32(uint1(x340))) + var x343 uint32 + var x344 uint32 + x343, x344 = bits.Add32(x271, x318, uint32(uint1(x342))) + var x345 uint32 + var x346 uint32 + x345, x346 = bits.Add32(x273, x320, uint32(uint1(x344))) + var x347 uint32 + var x348 uint32 + x347, x348 = bits.Add32(x275, x322, uint32(uint1(x346))) + var x349 uint32 + var x350 uint32 + x349, x350 = bits.Add32(x277, x324, uint32(uint1(x348))) + var x351 uint32 + var x352 uint32 + x351, x352 = bits.Add32(x279, x326, uint32(uint1(x350))) + var x353 uint32 + var x354 uint32 + x353, x354 = bits.Add32(x281, x328, uint32(uint1(x352))) + var x355 uint32 + var x356 uint32 + x355, x356 = bits.Add32(x283, x330, uint32(uint1(x354))) + var x357 uint32 + _, x357 = bits.Mul32(x331, 0xe88fdc45) + var x359 uint32 + var x360 uint32 + x360, x359 = bits.Mul32(x357, 0xffffffff) + var x361 uint32 + var x362 uint32 + x362, x361 = bits.Mul32(x357, 0xffffffff) + var x363 uint32 + var x364 uint32 + x364, x363 = bits.Mul32(x357, 0xffffffff) + var x365 uint32 + var x366 uint32 + x366, x365 = bits.Mul32(x357, 0xffffffff) + var x367 uint32 + var x368 uint32 + x368, x367 = bits.Mul32(x357, 0xffffffff) + var x369 uint32 + var x370 uint32 + x370, x369 = bits.Mul32(x357, 0xffffffff) + var x371 uint32 + var x372 uint32 + x372, x371 = bits.Mul32(x357, 0xc7634d81) + var x373 uint32 + var x374 uint32 + x374, x373 = bits.Mul32(x357, 0xf4372ddf) + var x375 uint32 + var x376 uint32 + x376, x375 = bits.Mul32(x357, 0x581a0db2) + var x377 uint32 + var x378 uint32 + x378, x377 = bits.Mul32(x357, 0x48b0a77a) + var x379 uint32 + var x380 uint32 + x380, x379 = bits.Mul32(x357, 0xecec196a) + var x381 uint32 + var x382 uint32 + x382, x381 = bits.Mul32(x357, 0xccc52973) + var x383 uint32 + var x384 uint32 + x383, x384 = bits.Add32(x382, x379, uint32(0x0)) + var x385 uint32 + var x386 uint32 + x385, x386 = bits.Add32(x380, x377, uint32(uint1(x384))) + var x387 uint32 + var x388 uint32 + x387, x388 = bits.Add32(x378, x375, uint32(uint1(x386))) + var x389 uint32 + var x390 uint32 + x389, x390 = bits.Add32(x376, x373, uint32(uint1(x388))) + var x391 uint32 + var x392 uint32 + x391, x392 = bits.Add32(x374, x371, uint32(uint1(x390))) + var x393 uint32 + var x394 uint32 + x393, x394 = bits.Add32(x372, x369, uint32(uint1(x392))) + var x395 uint32 + var x396 uint32 + x395, x396 = bits.Add32(x370, x367, uint32(uint1(x394))) + var x397 uint32 + var x398 uint32 + x397, x398 = bits.Add32(x368, x365, uint32(uint1(x396))) + var x399 uint32 + var x400 uint32 + x399, x400 = bits.Add32(x366, x363, uint32(uint1(x398))) + var x401 uint32 + var x402 uint32 + x401, x402 = bits.Add32(x364, x361, uint32(uint1(x400))) + var x403 uint32 + var x404 uint32 + x403, x404 = bits.Add32(x362, x359, uint32(uint1(x402))) + x405 := (uint32(uint1(x404)) + x360) + var x407 uint32 + _, x407 = bits.Add32(x331, x381, uint32(0x0)) + var x408 uint32 + var x409 uint32 + x408, x409 = bits.Add32(x333, x383, uint32(uint1(x407))) + var x410 uint32 + var x411 uint32 + x410, x411 = bits.Add32(x335, x385, uint32(uint1(x409))) + var x412 uint32 + var x413 uint32 + x412, x413 = bits.Add32(x337, x387, uint32(uint1(x411))) + var x414 uint32 + var x415 uint32 + x414, x415 = bits.Add32(x339, x389, uint32(uint1(x413))) + var x416 uint32 + var x417 uint32 + x416, x417 = bits.Add32(x341, x391, uint32(uint1(x415))) + var x418 uint32 + var x419 uint32 + x418, x419 = bits.Add32(x343, x393, uint32(uint1(x417))) + var x420 uint32 + var x421 uint32 + x420, x421 = bits.Add32(x345, x395, uint32(uint1(x419))) + var x422 uint32 + var x423 uint32 + x422, x423 = bits.Add32(x347, x397, uint32(uint1(x421))) + var x424 uint32 + var x425 uint32 + x424, x425 = bits.Add32(x349, x399, uint32(uint1(x423))) + var x426 uint32 + var x427 uint32 + x426, x427 = bits.Add32(x351, x401, uint32(uint1(x425))) + var x428 uint32 + var x429 uint32 + x428, x429 = bits.Add32(x353, x403, uint32(uint1(x427))) + var x430 uint32 + var x431 uint32 + x430, x431 = bits.Add32(x355, x405, uint32(uint1(x429))) + x432 := (uint32(uint1(x431)) + uint32(uint1(x356))) + var x433 uint32 + var x434 uint32 + x434, x433 = bits.Mul32(x3, arg2[11]) + var x435 uint32 + var x436 uint32 + x436, x435 = bits.Mul32(x3, arg2[10]) + var x437 uint32 + var x438 uint32 + x438, x437 = bits.Mul32(x3, arg2[9]) + var x439 uint32 + var x440 uint32 + x440, x439 = bits.Mul32(x3, arg2[8]) + var x441 uint32 + var x442 uint32 + x442, x441 = bits.Mul32(x3, arg2[7]) + var x443 uint32 + var x444 uint32 + x444, x443 = bits.Mul32(x3, arg2[6]) + var x445 uint32 + var x446 uint32 + x446, x445 = bits.Mul32(x3, arg2[5]) + var x447 uint32 + var x448 uint32 + x448, x447 = bits.Mul32(x3, arg2[4]) + var x449 uint32 + var x450 uint32 + x450, x449 = bits.Mul32(x3, arg2[3]) + var x451 uint32 + var x452 uint32 + x452, x451 = bits.Mul32(x3, arg2[2]) + var x453 uint32 + var x454 uint32 + x454, x453 = bits.Mul32(x3, arg2[1]) + var x455 uint32 + var x456 uint32 + x456, x455 = bits.Mul32(x3, arg2[0]) + var x457 uint32 + var x458 uint32 + x457, x458 = bits.Add32(x456, x453, uint32(0x0)) + var x459 uint32 + var x460 uint32 + x459, x460 = bits.Add32(x454, x451, uint32(uint1(x458))) + var x461 uint32 + var x462 uint32 + x461, x462 = bits.Add32(x452, x449, uint32(uint1(x460))) + var x463 uint32 + var x464 uint32 + x463, x464 = bits.Add32(x450, x447, uint32(uint1(x462))) + var x465 uint32 + var x466 uint32 + x465, x466 = bits.Add32(x448, x445, uint32(uint1(x464))) + var x467 uint32 + var x468 uint32 + x467, x468 = bits.Add32(x446, x443, uint32(uint1(x466))) + var x469 uint32 + var x470 uint32 + x469, x470 = bits.Add32(x444, x441, uint32(uint1(x468))) + var x471 uint32 + var x472 uint32 + x471, x472 = bits.Add32(x442, x439, uint32(uint1(x470))) + var x473 uint32 + var x474 uint32 + x473, x474 = bits.Add32(x440, x437, uint32(uint1(x472))) + var x475 uint32 + var x476 uint32 + x475, x476 = bits.Add32(x438, x435, uint32(uint1(x474))) + var x477 uint32 + var x478 uint32 + x477, x478 = bits.Add32(x436, x433, uint32(uint1(x476))) + x479 := (uint32(uint1(x478)) + x434) + var x480 uint32 + var x481 uint32 + x480, x481 = bits.Add32(x408, x455, uint32(0x0)) + var x482 uint32 + var x483 uint32 + x482, x483 = bits.Add32(x410, x457, uint32(uint1(x481))) + var x484 uint32 + var x485 uint32 + x484, x485 = bits.Add32(x412, x459, uint32(uint1(x483))) + var x486 uint32 + var x487 uint32 + x486, x487 = bits.Add32(x414, x461, uint32(uint1(x485))) + var x488 uint32 + var x489 uint32 + x488, x489 = bits.Add32(x416, x463, uint32(uint1(x487))) + var x490 uint32 + var x491 uint32 + x490, x491 = bits.Add32(x418, x465, uint32(uint1(x489))) + var x492 uint32 + var x493 uint32 + x492, x493 = bits.Add32(x420, x467, uint32(uint1(x491))) + var x494 uint32 + var x495 uint32 + x494, x495 = bits.Add32(x422, x469, uint32(uint1(x493))) + var x496 uint32 + var x497 uint32 + x496, x497 = bits.Add32(x424, x471, uint32(uint1(x495))) + var x498 uint32 + var x499 uint32 + x498, x499 = bits.Add32(x426, x473, uint32(uint1(x497))) + var x500 uint32 + var x501 uint32 + x500, x501 = bits.Add32(x428, x475, uint32(uint1(x499))) + var x502 uint32 + var x503 uint32 + x502, x503 = bits.Add32(x430, x477, uint32(uint1(x501))) + var x504 uint32 + var x505 uint32 + x504, x505 = bits.Add32(x432, x479, uint32(uint1(x503))) + var x506 uint32 + _, x506 = bits.Mul32(x480, 0xe88fdc45) + var x508 uint32 + var x509 uint32 + x509, x508 = bits.Mul32(x506, 0xffffffff) + var x510 uint32 + var x511 uint32 + x511, x510 = bits.Mul32(x506, 0xffffffff) + var x512 uint32 + var x513 uint32 + x513, x512 = bits.Mul32(x506, 0xffffffff) + var x514 uint32 + var x515 uint32 + x515, x514 = bits.Mul32(x506, 0xffffffff) + var x516 uint32 + var x517 uint32 + x517, x516 = bits.Mul32(x506, 0xffffffff) + var x518 uint32 + var x519 uint32 + x519, x518 = bits.Mul32(x506, 0xffffffff) + var x520 uint32 + var x521 uint32 + x521, x520 = bits.Mul32(x506, 0xc7634d81) + var x522 uint32 + var x523 uint32 + x523, x522 = bits.Mul32(x506, 0xf4372ddf) + var x524 uint32 + var x525 uint32 + x525, x524 = bits.Mul32(x506, 0x581a0db2) + var x526 uint32 + var x527 uint32 + x527, x526 = bits.Mul32(x506, 0x48b0a77a) + var x528 uint32 + var x529 uint32 + x529, x528 = bits.Mul32(x506, 0xecec196a) + var x530 uint32 + var x531 uint32 + x531, x530 = bits.Mul32(x506, 0xccc52973) + var x532 uint32 + var x533 uint32 + x532, x533 = bits.Add32(x531, x528, uint32(0x0)) + var x534 uint32 + var x535 uint32 + x534, x535 = bits.Add32(x529, x526, uint32(uint1(x533))) + var x536 uint32 + var x537 uint32 + x536, x537 = bits.Add32(x527, x524, uint32(uint1(x535))) + var x538 uint32 + var x539 uint32 + x538, x539 = bits.Add32(x525, x522, uint32(uint1(x537))) + var x540 uint32 + var x541 uint32 + x540, x541 = bits.Add32(x523, x520, uint32(uint1(x539))) + var x542 uint32 + var x543 uint32 + x542, x543 = bits.Add32(x521, x518, uint32(uint1(x541))) + var x544 uint32 + var x545 uint32 + x544, x545 = bits.Add32(x519, x516, uint32(uint1(x543))) + var x546 uint32 + var x547 uint32 + x546, x547 = bits.Add32(x517, x514, uint32(uint1(x545))) + var x548 uint32 + var x549 uint32 + x548, x549 = bits.Add32(x515, x512, uint32(uint1(x547))) + var x550 uint32 + var x551 uint32 + x550, x551 = bits.Add32(x513, x510, uint32(uint1(x549))) + var x552 uint32 + var x553 uint32 + x552, x553 = bits.Add32(x511, x508, uint32(uint1(x551))) + x554 := (uint32(uint1(x553)) + x509) + var x556 uint32 + _, x556 = bits.Add32(x480, x530, uint32(0x0)) + var x557 uint32 + var x558 uint32 + x557, x558 = bits.Add32(x482, x532, uint32(uint1(x556))) + var x559 uint32 + var x560 uint32 + x559, x560 = bits.Add32(x484, x534, uint32(uint1(x558))) + var x561 uint32 + var x562 uint32 + x561, x562 = bits.Add32(x486, x536, uint32(uint1(x560))) + var x563 uint32 + var x564 uint32 + x563, x564 = bits.Add32(x488, x538, uint32(uint1(x562))) + var x565 uint32 + var x566 uint32 + x565, x566 = bits.Add32(x490, x540, uint32(uint1(x564))) + var x567 uint32 + var x568 uint32 + x567, x568 = bits.Add32(x492, x542, uint32(uint1(x566))) + var x569 uint32 + var x570 uint32 + x569, x570 = bits.Add32(x494, x544, uint32(uint1(x568))) + var x571 uint32 + var x572 uint32 + x571, x572 = bits.Add32(x496, x546, uint32(uint1(x570))) + var x573 uint32 + var x574 uint32 + x573, x574 = bits.Add32(x498, x548, uint32(uint1(x572))) + var x575 uint32 + var x576 uint32 + x575, x576 = bits.Add32(x500, x550, uint32(uint1(x574))) + var x577 uint32 + var x578 uint32 + x577, x578 = bits.Add32(x502, x552, uint32(uint1(x576))) + var x579 uint32 + var x580 uint32 + x579, x580 = bits.Add32(x504, x554, uint32(uint1(x578))) + x581 := (uint32(uint1(x580)) + uint32(uint1(x505))) + var x582 uint32 + var x583 uint32 + x583, x582 = bits.Mul32(x4, arg2[11]) + var x584 uint32 + var x585 uint32 + x585, x584 = bits.Mul32(x4, arg2[10]) + var x586 uint32 + var x587 uint32 + x587, x586 = bits.Mul32(x4, arg2[9]) + var x588 uint32 + var x589 uint32 + x589, x588 = bits.Mul32(x4, arg2[8]) + var x590 uint32 + var x591 uint32 + x591, x590 = bits.Mul32(x4, arg2[7]) + var x592 uint32 + var x593 uint32 + x593, x592 = bits.Mul32(x4, arg2[6]) + var x594 uint32 + var x595 uint32 + x595, x594 = bits.Mul32(x4, arg2[5]) + var x596 uint32 + var x597 uint32 + x597, x596 = bits.Mul32(x4, arg2[4]) + var x598 uint32 + var x599 uint32 + x599, x598 = bits.Mul32(x4, arg2[3]) + var x600 uint32 + var x601 uint32 + x601, x600 = bits.Mul32(x4, arg2[2]) + var x602 uint32 + var x603 uint32 + x603, x602 = bits.Mul32(x4, arg2[1]) + var x604 uint32 + var x605 uint32 + x605, x604 = bits.Mul32(x4, arg2[0]) + var x606 uint32 + var x607 uint32 + x606, x607 = bits.Add32(x605, x602, uint32(0x0)) + var x608 uint32 + var x609 uint32 + x608, x609 = bits.Add32(x603, x600, uint32(uint1(x607))) + var x610 uint32 + var x611 uint32 + x610, x611 = bits.Add32(x601, x598, uint32(uint1(x609))) + var x612 uint32 + var x613 uint32 + x612, x613 = bits.Add32(x599, x596, uint32(uint1(x611))) + var x614 uint32 + var x615 uint32 + x614, x615 = bits.Add32(x597, x594, uint32(uint1(x613))) + var x616 uint32 + var x617 uint32 + x616, x617 = bits.Add32(x595, x592, uint32(uint1(x615))) + var x618 uint32 + var x619 uint32 + x618, x619 = bits.Add32(x593, x590, uint32(uint1(x617))) + var x620 uint32 + var x621 uint32 + x620, x621 = bits.Add32(x591, x588, uint32(uint1(x619))) + var x622 uint32 + var x623 uint32 + x622, x623 = bits.Add32(x589, x586, uint32(uint1(x621))) + var x624 uint32 + var x625 uint32 + x624, x625 = bits.Add32(x587, x584, uint32(uint1(x623))) + var x626 uint32 + var x627 uint32 + x626, x627 = bits.Add32(x585, x582, uint32(uint1(x625))) + x628 := (uint32(uint1(x627)) + x583) + var x629 uint32 + var x630 uint32 + x629, x630 = bits.Add32(x557, x604, uint32(0x0)) + var x631 uint32 + var x632 uint32 + x631, x632 = bits.Add32(x559, x606, uint32(uint1(x630))) + var x633 uint32 + var x634 uint32 + x633, x634 = bits.Add32(x561, x608, uint32(uint1(x632))) + var x635 uint32 + var x636 uint32 + x635, x636 = bits.Add32(x563, x610, uint32(uint1(x634))) + var x637 uint32 + var x638 uint32 + x637, x638 = bits.Add32(x565, x612, uint32(uint1(x636))) + var x639 uint32 + var x640 uint32 + x639, x640 = bits.Add32(x567, x614, uint32(uint1(x638))) + var x641 uint32 + var x642 uint32 + x641, x642 = bits.Add32(x569, x616, uint32(uint1(x640))) + var x643 uint32 + var x644 uint32 + x643, x644 = bits.Add32(x571, x618, uint32(uint1(x642))) + var x645 uint32 + var x646 uint32 + x645, x646 = bits.Add32(x573, x620, uint32(uint1(x644))) + var x647 uint32 + var x648 uint32 + x647, x648 = bits.Add32(x575, x622, uint32(uint1(x646))) + var x649 uint32 + var x650 uint32 + x649, x650 = bits.Add32(x577, x624, uint32(uint1(x648))) + var x651 uint32 + var x652 uint32 + x651, x652 = bits.Add32(x579, x626, uint32(uint1(x650))) + var x653 uint32 + var x654 uint32 + x653, x654 = bits.Add32(x581, x628, uint32(uint1(x652))) + var x655 uint32 + _, x655 = bits.Mul32(x629, 0xe88fdc45) + var x657 uint32 + var x658 uint32 + x658, x657 = bits.Mul32(x655, 0xffffffff) + var x659 uint32 + var x660 uint32 + x660, x659 = bits.Mul32(x655, 0xffffffff) + var x661 uint32 + var x662 uint32 + x662, x661 = bits.Mul32(x655, 0xffffffff) + var x663 uint32 + var x664 uint32 + x664, x663 = bits.Mul32(x655, 0xffffffff) + var x665 uint32 + var x666 uint32 + x666, x665 = bits.Mul32(x655, 0xffffffff) + var x667 uint32 + var x668 uint32 + x668, x667 = bits.Mul32(x655, 0xffffffff) + var x669 uint32 + var x670 uint32 + x670, x669 = bits.Mul32(x655, 0xc7634d81) + var x671 uint32 + var x672 uint32 + x672, x671 = bits.Mul32(x655, 0xf4372ddf) + var x673 uint32 + var x674 uint32 + x674, x673 = bits.Mul32(x655, 0x581a0db2) + var x675 uint32 + var x676 uint32 + x676, x675 = bits.Mul32(x655, 0x48b0a77a) + var x677 uint32 + var x678 uint32 + x678, x677 = bits.Mul32(x655, 0xecec196a) + var x679 uint32 + var x680 uint32 + x680, x679 = bits.Mul32(x655, 0xccc52973) + var x681 uint32 + var x682 uint32 + x681, x682 = bits.Add32(x680, x677, uint32(0x0)) + var x683 uint32 + var x684 uint32 + x683, x684 = bits.Add32(x678, x675, uint32(uint1(x682))) + var x685 uint32 + var x686 uint32 + x685, x686 = bits.Add32(x676, x673, uint32(uint1(x684))) + var x687 uint32 + var x688 uint32 + x687, x688 = bits.Add32(x674, x671, uint32(uint1(x686))) + var x689 uint32 + var x690 uint32 + x689, x690 = bits.Add32(x672, x669, uint32(uint1(x688))) + var x691 uint32 + var x692 uint32 + x691, x692 = bits.Add32(x670, x667, uint32(uint1(x690))) + var x693 uint32 + var x694 uint32 + x693, x694 = bits.Add32(x668, x665, uint32(uint1(x692))) + var x695 uint32 + var x696 uint32 + x695, x696 = bits.Add32(x666, x663, uint32(uint1(x694))) + var x697 uint32 + var x698 uint32 + x697, x698 = bits.Add32(x664, x661, uint32(uint1(x696))) + var x699 uint32 + var x700 uint32 + x699, x700 = bits.Add32(x662, x659, uint32(uint1(x698))) + var x701 uint32 + var x702 uint32 + x701, x702 = bits.Add32(x660, x657, uint32(uint1(x700))) + x703 := (uint32(uint1(x702)) + x658) + var x705 uint32 + _, x705 = bits.Add32(x629, x679, uint32(0x0)) + var x706 uint32 + var x707 uint32 + x706, x707 = bits.Add32(x631, x681, uint32(uint1(x705))) + var x708 uint32 + var x709 uint32 + x708, x709 = bits.Add32(x633, x683, uint32(uint1(x707))) + var x710 uint32 + var x711 uint32 + x710, x711 = bits.Add32(x635, x685, uint32(uint1(x709))) + var x712 uint32 + var x713 uint32 + x712, x713 = bits.Add32(x637, x687, uint32(uint1(x711))) + var x714 uint32 + var x715 uint32 + x714, x715 = bits.Add32(x639, x689, uint32(uint1(x713))) + var x716 uint32 + var x717 uint32 + x716, x717 = bits.Add32(x641, x691, uint32(uint1(x715))) + var x718 uint32 + var x719 uint32 + x718, x719 = bits.Add32(x643, x693, uint32(uint1(x717))) + var x720 uint32 + var x721 uint32 + x720, x721 = bits.Add32(x645, x695, uint32(uint1(x719))) + var x722 uint32 + var x723 uint32 + x722, x723 = bits.Add32(x647, x697, uint32(uint1(x721))) + var x724 uint32 + var x725 uint32 + x724, x725 = bits.Add32(x649, x699, uint32(uint1(x723))) + var x726 uint32 + var x727 uint32 + x726, x727 = bits.Add32(x651, x701, uint32(uint1(x725))) + var x728 uint32 + var x729 uint32 + x728, x729 = bits.Add32(x653, x703, uint32(uint1(x727))) + x730 := (uint32(uint1(x729)) + uint32(uint1(x654))) + var x731 uint32 + var x732 uint32 + x732, x731 = bits.Mul32(x5, arg2[11]) + var x733 uint32 + var x734 uint32 + x734, x733 = bits.Mul32(x5, arg2[10]) + var x735 uint32 + var x736 uint32 + x736, x735 = bits.Mul32(x5, arg2[9]) + var x737 uint32 + var x738 uint32 + x738, x737 = bits.Mul32(x5, arg2[8]) + var x739 uint32 + var x740 uint32 + x740, x739 = bits.Mul32(x5, arg2[7]) + var x741 uint32 + var x742 uint32 + x742, x741 = bits.Mul32(x5, arg2[6]) + var x743 uint32 + var x744 uint32 + x744, x743 = bits.Mul32(x5, arg2[5]) + var x745 uint32 + var x746 uint32 + x746, x745 = bits.Mul32(x5, arg2[4]) + var x747 uint32 + var x748 uint32 + x748, x747 = bits.Mul32(x5, arg2[3]) + var x749 uint32 + var x750 uint32 + x750, x749 = bits.Mul32(x5, arg2[2]) + var x751 uint32 + var x752 uint32 + x752, x751 = bits.Mul32(x5, arg2[1]) + var x753 uint32 + var x754 uint32 + x754, x753 = bits.Mul32(x5, arg2[0]) + var x755 uint32 + var x756 uint32 + x755, x756 = bits.Add32(x754, x751, uint32(0x0)) + var x757 uint32 + var x758 uint32 + x757, x758 = bits.Add32(x752, x749, uint32(uint1(x756))) + var x759 uint32 + var x760 uint32 + x759, x760 = bits.Add32(x750, x747, uint32(uint1(x758))) + var x761 uint32 + var x762 uint32 + x761, x762 = bits.Add32(x748, x745, uint32(uint1(x760))) + var x763 uint32 + var x764 uint32 + x763, x764 = bits.Add32(x746, x743, uint32(uint1(x762))) + var x765 uint32 + var x766 uint32 + x765, x766 = bits.Add32(x744, x741, uint32(uint1(x764))) + var x767 uint32 + var x768 uint32 + x767, x768 = bits.Add32(x742, x739, uint32(uint1(x766))) + var x769 uint32 + var x770 uint32 + x769, x770 = bits.Add32(x740, x737, uint32(uint1(x768))) + var x771 uint32 + var x772 uint32 + x771, x772 = bits.Add32(x738, x735, uint32(uint1(x770))) + var x773 uint32 + var x774 uint32 + x773, x774 = bits.Add32(x736, x733, uint32(uint1(x772))) + var x775 uint32 + var x776 uint32 + x775, x776 = bits.Add32(x734, x731, uint32(uint1(x774))) + x777 := (uint32(uint1(x776)) + x732) + var x778 uint32 + var x779 uint32 + x778, x779 = bits.Add32(x706, x753, uint32(0x0)) + var x780 uint32 + var x781 uint32 + x780, x781 = bits.Add32(x708, x755, uint32(uint1(x779))) + var x782 uint32 + var x783 uint32 + x782, x783 = bits.Add32(x710, x757, uint32(uint1(x781))) + var x784 uint32 + var x785 uint32 + x784, x785 = bits.Add32(x712, x759, uint32(uint1(x783))) + var x786 uint32 + var x787 uint32 + x786, x787 = bits.Add32(x714, x761, uint32(uint1(x785))) + var x788 uint32 + var x789 uint32 + x788, x789 = bits.Add32(x716, x763, uint32(uint1(x787))) + var x790 uint32 + var x791 uint32 + x790, x791 = bits.Add32(x718, x765, uint32(uint1(x789))) + var x792 uint32 + var x793 uint32 + x792, x793 = bits.Add32(x720, x767, uint32(uint1(x791))) + var x794 uint32 + var x795 uint32 + x794, x795 = bits.Add32(x722, x769, uint32(uint1(x793))) + var x796 uint32 + var x797 uint32 + x796, x797 = bits.Add32(x724, x771, uint32(uint1(x795))) + var x798 uint32 + var x799 uint32 + x798, x799 = bits.Add32(x726, x773, uint32(uint1(x797))) + var x800 uint32 + var x801 uint32 + x800, x801 = bits.Add32(x728, x775, uint32(uint1(x799))) + var x802 uint32 + var x803 uint32 + x802, x803 = bits.Add32(x730, x777, uint32(uint1(x801))) + var x804 uint32 + _, x804 = bits.Mul32(x778, 0xe88fdc45) + var x806 uint32 + var x807 uint32 + x807, x806 = bits.Mul32(x804, 0xffffffff) + var x808 uint32 + var x809 uint32 + x809, x808 = bits.Mul32(x804, 0xffffffff) + var x810 uint32 + var x811 uint32 + x811, x810 = bits.Mul32(x804, 0xffffffff) + var x812 uint32 + var x813 uint32 + x813, x812 = bits.Mul32(x804, 0xffffffff) + var x814 uint32 + var x815 uint32 + x815, x814 = bits.Mul32(x804, 0xffffffff) + var x816 uint32 + var x817 uint32 + x817, x816 = bits.Mul32(x804, 0xffffffff) + var x818 uint32 + var x819 uint32 + x819, x818 = bits.Mul32(x804, 0xc7634d81) + var x820 uint32 + var x821 uint32 + x821, x820 = bits.Mul32(x804, 0xf4372ddf) + var x822 uint32 + var x823 uint32 + x823, x822 = bits.Mul32(x804, 0x581a0db2) + var x824 uint32 + var x825 uint32 + x825, x824 = bits.Mul32(x804, 0x48b0a77a) + var x826 uint32 + var x827 uint32 + x827, x826 = bits.Mul32(x804, 0xecec196a) + var x828 uint32 + var x829 uint32 + x829, x828 = bits.Mul32(x804, 0xccc52973) + var x830 uint32 + var x831 uint32 + x830, x831 = bits.Add32(x829, x826, uint32(0x0)) + var x832 uint32 + var x833 uint32 + x832, x833 = bits.Add32(x827, x824, uint32(uint1(x831))) + var x834 uint32 + var x835 uint32 + x834, x835 = bits.Add32(x825, x822, uint32(uint1(x833))) + var x836 uint32 + var x837 uint32 + x836, x837 = bits.Add32(x823, x820, uint32(uint1(x835))) + var x838 uint32 + var x839 uint32 + x838, x839 = bits.Add32(x821, x818, uint32(uint1(x837))) + var x840 uint32 + var x841 uint32 + x840, x841 = bits.Add32(x819, x816, uint32(uint1(x839))) + var x842 uint32 + var x843 uint32 + x842, x843 = bits.Add32(x817, x814, uint32(uint1(x841))) + var x844 uint32 + var x845 uint32 + x844, x845 = bits.Add32(x815, x812, uint32(uint1(x843))) + var x846 uint32 + var x847 uint32 + x846, x847 = bits.Add32(x813, x810, uint32(uint1(x845))) + var x848 uint32 + var x849 uint32 + x848, x849 = bits.Add32(x811, x808, uint32(uint1(x847))) + var x850 uint32 + var x851 uint32 + x850, x851 = bits.Add32(x809, x806, uint32(uint1(x849))) + x852 := (uint32(uint1(x851)) + x807) + var x854 uint32 + _, x854 = bits.Add32(x778, x828, uint32(0x0)) + var x855 uint32 + var x856 uint32 + x855, x856 = bits.Add32(x780, x830, uint32(uint1(x854))) + var x857 uint32 + var x858 uint32 + x857, x858 = bits.Add32(x782, x832, uint32(uint1(x856))) + var x859 uint32 + var x860 uint32 + x859, x860 = bits.Add32(x784, x834, uint32(uint1(x858))) + var x861 uint32 + var x862 uint32 + x861, x862 = bits.Add32(x786, x836, uint32(uint1(x860))) + var x863 uint32 + var x864 uint32 + x863, x864 = bits.Add32(x788, x838, uint32(uint1(x862))) + var x865 uint32 + var x866 uint32 + x865, x866 = bits.Add32(x790, x840, uint32(uint1(x864))) + var x867 uint32 + var x868 uint32 + x867, x868 = bits.Add32(x792, x842, uint32(uint1(x866))) + var x869 uint32 + var x870 uint32 + x869, x870 = bits.Add32(x794, x844, uint32(uint1(x868))) + var x871 uint32 + var x872 uint32 + x871, x872 = bits.Add32(x796, x846, uint32(uint1(x870))) + var x873 uint32 + var x874 uint32 + x873, x874 = bits.Add32(x798, x848, uint32(uint1(x872))) + var x875 uint32 + var x876 uint32 + x875, x876 = bits.Add32(x800, x850, uint32(uint1(x874))) + var x877 uint32 + var x878 uint32 + x877, x878 = bits.Add32(x802, x852, uint32(uint1(x876))) + x879 := (uint32(uint1(x878)) + uint32(uint1(x803))) + var x880 uint32 + var x881 uint32 + x881, x880 = bits.Mul32(x6, arg2[11]) + var x882 uint32 + var x883 uint32 + x883, x882 = bits.Mul32(x6, arg2[10]) + var x884 uint32 + var x885 uint32 + x885, x884 = bits.Mul32(x6, arg2[9]) + var x886 uint32 + var x887 uint32 + x887, x886 = bits.Mul32(x6, arg2[8]) + var x888 uint32 + var x889 uint32 + x889, x888 = bits.Mul32(x6, arg2[7]) + var x890 uint32 + var x891 uint32 + x891, x890 = bits.Mul32(x6, arg2[6]) + var x892 uint32 + var x893 uint32 + x893, x892 = bits.Mul32(x6, arg2[5]) + var x894 uint32 + var x895 uint32 + x895, x894 = bits.Mul32(x6, arg2[4]) + var x896 uint32 + var x897 uint32 + x897, x896 = bits.Mul32(x6, arg2[3]) + var x898 uint32 + var x899 uint32 + x899, x898 = bits.Mul32(x6, arg2[2]) + var x900 uint32 + var x901 uint32 + x901, x900 = bits.Mul32(x6, arg2[1]) + var x902 uint32 + var x903 uint32 + x903, x902 = bits.Mul32(x6, arg2[0]) + var x904 uint32 + var x905 uint32 + x904, x905 = bits.Add32(x903, x900, uint32(0x0)) + var x906 uint32 + var x907 uint32 + x906, x907 = bits.Add32(x901, x898, uint32(uint1(x905))) + var x908 uint32 + var x909 uint32 + x908, x909 = bits.Add32(x899, x896, uint32(uint1(x907))) + var x910 uint32 + var x911 uint32 + x910, x911 = bits.Add32(x897, x894, uint32(uint1(x909))) + var x912 uint32 + var x913 uint32 + x912, x913 = bits.Add32(x895, x892, uint32(uint1(x911))) + var x914 uint32 + var x915 uint32 + x914, x915 = bits.Add32(x893, x890, uint32(uint1(x913))) + var x916 uint32 + var x917 uint32 + x916, x917 = bits.Add32(x891, x888, uint32(uint1(x915))) + var x918 uint32 + var x919 uint32 + x918, x919 = bits.Add32(x889, x886, uint32(uint1(x917))) + var x920 uint32 + var x921 uint32 + x920, x921 = bits.Add32(x887, x884, uint32(uint1(x919))) + var x922 uint32 + var x923 uint32 + x922, x923 = bits.Add32(x885, x882, uint32(uint1(x921))) + var x924 uint32 + var x925 uint32 + x924, x925 = bits.Add32(x883, x880, uint32(uint1(x923))) + x926 := (uint32(uint1(x925)) + x881) + var x927 uint32 + var x928 uint32 + x927, x928 = bits.Add32(x855, x902, uint32(0x0)) + var x929 uint32 + var x930 uint32 + x929, x930 = bits.Add32(x857, x904, uint32(uint1(x928))) + var x931 uint32 + var x932 uint32 + x931, x932 = bits.Add32(x859, x906, uint32(uint1(x930))) + var x933 uint32 + var x934 uint32 + x933, x934 = bits.Add32(x861, x908, uint32(uint1(x932))) + var x935 uint32 + var x936 uint32 + x935, x936 = bits.Add32(x863, x910, uint32(uint1(x934))) + var x937 uint32 + var x938 uint32 + x937, x938 = bits.Add32(x865, x912, uint32(uint1(x936))) + var x939 uint32 + var x940 uint32 + x939, x940 = bits.Add32(x867, x914, uint32(uint1(x938))) + var x941 uint32 + var x942 uint32 + x941, x942 = bits.Add32(x869, x916, uint32(uint1(x940))) + var x943 uint32 + var x944 uint32 + x943, x944 = bits.Add32(x871, x918, uint32(uint1(x942))) + var x945 uint32 + var x946 uint32 + x945, x946 = bits.Add32(x873, x920, uint32(uint1(x944))) + var x947 uint32 + var x948 uint32 + x947, x948 = bits.Add32(x875, x922, uint32(uint1(x946))) + var x949 uint32 + var x950 uint32 + x949, x950 = bits.Add32(x877, x924, uint32(uint1(x948))) + var x951 uint32 + var x952 uint32 + x951, x952 = bits.Add32(x879, x926, uint32(uint1(x950))) + var x953 uint32 + _, x953 = bits.Mul32(x927, 0xe88fdc45) + var x955 uint32 + var x956 uint32 + x956, x955 = bits.Mul32(x953, 0xffffffff) + var x957 uint32 + var x958 uint32 + x958, x957 = bits.Mul32(x953, 0xffffffff) + var x959 uint32 + var x960 uint32 + x960, x959 = bits.Mul32(x953, 0xffffffff) + var x961 uint32 + var x962 uint32 + x962, x961 = bits.Mul32(x953, 0xffffffff) + var x963 uint32 + var x964 uint32 + x964, x963 = bits.Mul32(x953, 0xffffffff) + var x965 uint32 + var x966 uint32 + x966, x965 = bits.Mul32(x953, 0xffffffff) + var x967 uint32 + var x968 uint32 + x968, x967 = bits.Mul32(x953, 0xc7634d81) + var x969 uint32 + var x970 uint32 + x970, x969 = bits.Mul32(x953, 0xf4372ddf) + var x971 uint32 + var x972 uint32 + x972, x971 = bits.Mul32(x953, 0x581a0db2) + var x973 uint32 + var x974 uint32 + x974, x973 = bits.Mul32(x953, 0x48b0a77a) + var x975 uint32 + var x976 uint32 + x976, x975 = bits.Mul32(x953, 0xecec196a) + var x977 uint32 + var x978 uint32 + x978, x977 = bits.Mul32(x953, 0xccc52973) + var x979 uint32 + var x980 uint32 + x979, x980 = bits.Add32(x978, x975, uint32(0x0)) + var x981 uint32 + var x982 uint32 + x981, x982 = bits.Add32(x976, x973, uint32(uint1(x980))) + var x983 uint32 + var x984 uint32 + x983, x984 = bits.Add32(x974, x971, uint32(uint1(x982))) + var x985 uint32 + var x986 uint32 + x985, x986 = bits.Add32(x972, x969, uint32(uint1(x984))) + var x987 uint32 + var x988 uint32 + x987, x988 = bits.Add32(x970, x967, uint32(uint1(x986))) + var x989 uint32 + var x990 uint32 + x989, x990 = bits.Add32(x968, x965, uint32(uint1(x988))) + var x991 uint32 + var x992 uint32 + x991, x992 = bits.Add32(x966, x963, uint32(uint1(x990))) + var x993 uint32 + var x994 uint32 + x993, x994 = bits.Add32(x964, x961, uint32(uint1(x992))) + var x995 uint32 + var x996 uint32 + x995, x996 = bits.Add32(x962, x959, uint32(uint1(x994))) + var x997 uint32 + var x998 uint32 + x997, x998 = bits.Add32(x960, x957, uint32(uint1(x996))) + var x999 uint32 + var x1000 uint32 + x999, x1000 = bits.Add32(x958, x955, uint32(uint1(x998))) + x1001 := (uint32(uint1(x1000)) + x956) + var x1003 uint32 + _, x1003 = bits.Add32(x927, x977, uint32(0x0)) + var x1004 uint32 + var x1005 uint32 + x1004, x1005 = bits.Add32(x929, x979, uint32(uint1(x1003))) + var x1006 uint32 + var x1007 uint32 + x1006, x1007 = bits.Add32(x931, x981, uint32(uint1(x1005))) + var x1008 uint32 + var x1009 uint32 + x1008, x1009 = bits.Add32(x933, x983, uint32(uint1(x1007))) + var x1010 uint32 + var x1011 uint32 + x1010, x1011 = bits.Add32(x935, x985, uint32(uint1(x1009))) + var x1012 uint32 + var x1013 uint32 + x1012, x1013 = bits.Add32(x937, x987, uint32(uint1(x1011))) + var x1014 uint32 + var x1015 uint32 + x1014, x1015 = bits.Add32(x939, x989, uint32(uint1(x1013))) + var x1016 uint32 + var x1017 uint32 + x1016, x1017 = bits.Add32(x941, x991, uint32(uint1(x1015))) + var x1018 uint32 + var x1019 uint32 + x1018, x1019 = bits.Add32(x943, x993, uint32(uint1(x1017))) + var x1020 uint32 + var x1021 uint32 + x1020, x1021 = bits.Add32(x945, x995, uint32(uint1(x1019))) + var x1022 uint32 + var x1023 uint32 + x1022, x1023 = bits.Add32(x947, x997, uint32(uint1(x1021))) + var x1024 uint32 + var x1025 uint32 + x1024, x1025 = bits.Add32(x949, x999, uint32(uint1(x1023))) + var x1026 uint32 + var x1027 uint32 + x1026, x1027 = bits.Add32(x951, x1001, uint32(uint1(x1025))) + x1028 := (uint32(uint1(x1027)) + uint32(uint1(x952))) + var x1029 uint32 + var x1030 uint32 + x1030, x1029 = bits.Mul32(x7, arg2[11]) + var x1031 uint32 + var x1032 uint32 + x1032, x1031 = bits.Mul32(x7, arg2[10]) + var x1033 uint32 + var x1034 uint32 + x1034, x1033 = bits.Mul32(x7, arg2[9]) + var x1035 uint32 + var x1036 uint32 + x1036, x1035 = bits.Mul32(x7, arg2[8]) + var x1037 uint32 + var x1038 uint32 + x1038, x1037 = bits.Mul32(x7, arg2[7]) + var x1039 uint32 + var x1040 uint32 + x1040, x1039 = bits.Mul32(x7, arg2[6]) + var x1041 uint32 + var x1042 uint32 + x1042, x1041 = bits.Mul32(x7, arg2[5]) + var x1043 uint32 + var x1044 uint32 + x1044, x1043 = bits.Mul32(x7, arg2[4]) + var x1045 uint32 + var x1046 uint32 + x1046, x1045 = bits.Mul32(x7, arg2[3]) + var x1047 uint32 + var x1048 uint32 + x1048, x1047 = bits.Mul32(x7, arg2[2]) + var x1049 uint32 + var x1050 uint32 + x1050, x1049 = bits.Mul32(x7, arg2[1]) + var x1051 uint32 + var x1052 uint32 + x1052, x1051 = bits.Mul32(x7, arg2[0]) + var x1053 uint32 + var x1054 uint32 + x1053, x1054 = bits.Add32(x1052, x1049, uint32(0x0)) + var x1055 uint32 + var x1056 uint32 + x1055, x1056 = bits.Add32(x1050, x1047, uint32(uint1(x1054))) + var x1057 uint32 + var x1058 uint32 + x1057, x1058 = bits.Add32(x1048, x1045, uint32(uint1(x1056))) + var x1059 uint32 + var x1060 uint32 + x1059, x1060 = bits.Add32(x1046, x1043, uint32(uint1(x1058))) + var x1061 uint32 + var x1062 uint32 + x1061, x1062 = bits.Add32(x1044, x1041, uint32(uint1(x1060))) + var x1063 uint32 + var x1064 uint32 + x1063, x1064 = bits.Add32(x1042, x1039, uint32(uint1(x1062))) + var x1065 uint32 + var x1066 uint32 + x1065, x1066 = bits.Add32(x1040, x1037, uint32(uint1(x1064))) + var x1067 uint32 + var x1068 uint32 + x1067, x1068 = bits.Add32(x1038, x1035, uint32(uint1(x1066))) + var x1069 uint32 + var x1070 uint32 + x1069, x1070 = bits.Add32(x1036, x1033, uint32(uint1(x1068))) + var x1071 uint32 + var x1072 uint32 + x1071, x1072 = bits.Add32(x1034, x1031, uint32(uint1(x1070))) + var x1073 uint32 + var x1074 uint32 + x1073, x1074 = bits.Add32(x1032, x1029, uint32(uint1(x1072))) + x1075 := (uint32(uint1(x1074)) + x1030) + var x1076 uint32 + var x1077 uint32 + x1076, x1077 = bits.Add32(x1004, x1051, uint32(0x0)) + var x1078 uint32 + var x1079 uint32 + x1078, x1079 = bits.Add32(x1006, x1053, uint32(uint1(x1077))) + var x1080 uint32 + var x1081 uint32 + x1080, x1081 = bits.Add32(x1008, x1055, uint32(uint1(x1079))) + var x1082 uint32 + var x1083 uint32 + x1082, x1083 = bits.Add32(x1010, x1057, uint32(uint1(x1081))) + var x1084 uint32 + var x1085 uint32 + x1084, x1085 = bits.Add32(x1012, x1059, uint32(uint1(x1083))) + var x1086 uint32 + var x1087 uint32 + x1086, x1087 = bits.Add32(x1014, x1061, uint32(uint1(x1085))) + var x1088 uint32 + var x1089 uint32 + x1088, x1089 = bits.Add32(x1016, x1063, uint32(uint1(x1087))) + var x1090 uint32 + var x1091 uint32 + x1090, x1091 = bits.Add32(x1018, x1065, uint32(uint1(x1089))) + var x1092 uint32 + var x1093 uint32 + x1092, x1093 = bits.Add32(x1020, x1067, uint32(uint1(x1091))) + var x1094 uint32 + var x1095 uint32 + x1094, x1095 = bits.Add32(x1022, x1069, uint32(uint1(x1093))) + var x1096 uint32 + var x1097 uint32 + x1096, x1097 = bits.Add32(x1024, x1071, uint32(uint1(x1095))) + var x1098 uint32 + var x1099 uint32 + x1098, x1099 = bits.Add32(x1026, x1073, uint32(uint1(x1097))) + var x1100 uint32 + var x1101 uint32 + x1100, x1101 = bits.Add32(x1028, x1075, uint32(uint1(x1099))) + var x1102 uint32 + _, x1102 = bits.Mul32(x1076, 0xe88fdc45) + var x1104 uint32 + var x1105 uint32 + x1105, x1104 = bits.Mul32(x1102, 0xffffffff) + var x1106 uint32 + var x1107 uint32 + x1107, x1106 = bits.Mul32(x1102, 0xffffffff) + var x1108 uint32 + var x1109 uint32 + x1109, x1108 = bits.Mul32(x1102, 0xffffffff) + var x1110 uint32 + var x1111 uint32 + x1111, x1110 = bits.Mul32(x1102, 0xffffffff) + var x1112 uint32 + var x1113 uint32 + x1113, x1112 = bits.Mul32(x1102, 0xffffffff) + var x1114 uint32 + var x1115 uint32 + x1115, x1114 = bits.Mul32(x1102, 0xffffffff) + var x1116 uint32 + var x1117 uint32 + x1117, x1116 = bits.Mul32(x1102, 0xc7634d81) + var x1118 uint32 + var x1119 uint32 + x1119, x1118 = bits.Mul32(x1102, 0xf4372ddf) + var x1120 uint32 + var x1121 uint32 + x1121, x1120 = bits.Mul32(x1102, 0x581a0db2) + var x1122 uint32 + var x1123 uint32 + x1123, x1122 = bits.Mul32(x1102, 0x48b0a77a) + var x1124 uint32 + var x1125 uint32 + x1125, x1124 = bits.Mul32(x1102, 0xecec196a) + var x1126 uint32 + var x1127 uint32 + x1127, x1126 = bits.Mul32(x1102, 0xccc52973) + var x1128 uint32 + var x1129 uint32 + x1128, x1129 = bits.Add32(x1127, x1124, uint32(0x0)) + var x1130 uint32 + var x1131 uint32 + x1130, x1131 = bits.Add32(x1125, x1122, uint32(uint1(x1129))) + var x1132 uint32 + var x1133 uint32 + x1132, x1133 = bits.Add32(x1123, x1120, uint32(uint1(x1131))) + var x1134 uint32 + var x1135 uint32 + x1134, x1135 = bits.Add32(x1121, x1118, uint32(uint1(x1133))) + var x1136 uint32 + var x1137 uint32 + x1136, x1137 = bits.Add32(x1119, x1116, uint32(uint1(x1135))) + var x1138 uint32 + var x1139 uint32 + x1138, x1139 = bits.Add32(x1117, x1114, uint32(uint1(x1137))) + var x1140 uint32 + var x1141 uint32 + x1140, x1141 = bits.Add32(x1115, x1112, uint32(uint1(x1139))) + var x1142 uint32 + var x1143 uint32 + x1142, x1143 = bits.Add32(x1113, x1110, uint32(uint1(x1141))) + var x1144 uint32 + var x1145 uint32 + x1144, x1145 = bits.Add32(x1111, x1108, uint32(uint1(x1143))) + var x1146 uint32 + var x1147 uint32 + x1146, x1147 = bits.Add32(x1109, x1106, uint32(uint1(x1145))) + var x1148 uint32 + var x1149 uint32 + x1148, x1149 = bits.Add32(x1107, x1104, uint32(uint1(x1147))) + x1150 := (uint32(uint1(x1149)) + x1105) + var x1152 uint32 + _, x1152 = bits.Add32(x1076, x1126, uint32(0x0)) + var x1153 uint32 + var x1154 uint32 + x1153, x1154 = bits.Add32(x1078, x1128, uint32(uint1(x1152))) + var x1155 uint32 + var x1156 uint32 + x1155, x1156 = bits.Add32(x1080, x1130, uint32(uint1(x1154))) + var x1157 uint32 + var x1158 uint32 + x1157, x1158 = bits.Add32(x1082, x1132, uint32(uint1(x1156))) + var x1159 uint32 + var x1160 uint32 + x1159, x1160 = bits.Add32(x1084, x1134, uint32(uint1(x1158))) + var x1161 uint32 + var x1162 uint32 + x1161, x1162 = bits.Add32(x1086, x1136, uint32(uint1(x1160))) + var x1163 uint32 + var x1164 uint32 + x1163, x1164 = bits.Add32(x1088, x1138, uint32(uint1(x1162))) + var x1165 uint32 + var x1166 uint32 + x1165, x1166 = bits.Add32(x1090, x1140, uint32(uint1(x1164))) + var x1167 uint32 + var x1168 uint32 + x1167, x1168 = bits.Add32(x1092, x1142, uint32(uint1(x1166))) + var x1169 uint32 + var x1170 uint32 + x1169, x1170 = bits.Add32(x1094, x1144, uint32(uint1(x1168))) + var x1171 uint32 + var x1172 uint32 + x1171, x1172 = bits.Add32(x1096, x1146, uint32(uint1(x1170))) + var x1173 uint32 + var x1174 uint32 + x1173, x1174 = bits.Add32(x1098, x1148, uint32(uint1(x1172))) + var x1175 uint32 + var x1176 uint32 + x1175, x1176 = bits.Add32(x1100, x1150, uint32(uint1(x1174))) + x1177 := (uint32(uint1(x1176)) + uint32(uint1(x1101))) + var x1178 uint32 + var x1179 uint32 + x1179, x1178 = bits.Mul32(x8, arg2[11]) + var x1180 uint32 + var x1181 uint32 + x1181, x1180 = bits.Mul32(x8, arg2[10]) + var x1182 uint32 + var x1183 uint32 + x1183, x1182 = bits.Mul32(x8, arg2[9]) + var x1184 uint32 + var x1185 uint32 + x1185, x1184 = bits.Mul32(x8, arg2[8]) + var x1186 uint32 + var x1187 uint32 + x1187, x1186 = bits.Mul32(x8, arg2[7]) + var x1188 uint32 + var x1189 uint32 + x1189, x1188 = bits.Mul32(x8, arg2[6]) + var x1190 uint32 + var x1191 uint32 + x1191, x1190 = bits.Mul32(x8, arg2[5]) + var x1192 uint32 + var x1193 uint32 + x1193, x1192 = bits.Mul32(x8, arg2[4]) + var x1194 uint32 + var x1195 uint32 + x1195, x1194 = bits.Mul32(x8, arg2[3]) + var x1196 uint32 + var x1197 uint32 + x1197, x1196 = bits.Mul32(x8, arg2[2]) + var x1198 uint32 + var x1199 uint32 + x1199, x1198 = bits.Mul32(x8, arg2[1]) + var x1200 uint32 + var x1201 uint32 + x1201, x1200 = bits.Mul32(x8, arg2[0]) + var x1202 uint32 + var x1203 uint32 + x1202, x1203 = bits.Add32(x1201, x1198, uint32(0x0)) + var x1204 uint32 + var x1205 uint32 + x1204, x1205 = bits.Add32(x1199, x1196, uint32(uint1(x1203))) + var x1206 uint32 + var x1207 uint32 + x1206, x1207 = bits.Add32(x1197, x1194, uint32(uint1(x1205))) + var x1208 uint32 + var x1209 uint32 + x1208, x1209 = bits.Add32(x1195, x1192, uint32(uint1(x1207))) + var x1210 uint32 + var x1211 uint32 + x1210, x1211 = bits.Add32(x1193, x1190, uint32(uint1(x1209))) + var x1212 uint32 + var x1213 uint32 + x1212, x1213 = bits.Add32(x1191, x1188, uint32(uint1(x1211))) + var x1214 uint32 + var x1215 uint32 + x1214, x1215 = bits.Add32(x1189, x1186, uint32(uint1(x1213))) + var x1216 uint32 + var x1217 uint32 + x1216, x1217 = bits.Add32(x1187, x1184, uint32(uint1(x1215))) + var x1218 uint32 + var x1219 uint32 + x1218, x1219 = bits.Add32(x1185, x1182, uint32(uint1(x1217))) + var x1220 uint32 + var x1221 uint32 + x1220, x1221 = bits.Add32(x1183, x1180, uint32(uint1(x1219))) + var x1222 uint32 + var x1223 uint32 + x1222, x1223 = bits.Add32(x1181, x1178, uint32(uint1(x1221))) + x1224 := (uint32(uint1(x1223)) + x1179) + var x1225 uint32 + var x1226 uint32 + x1225, x1226 = bits.Add32(x1153, x1200, uint32(0x0)) + var x1227 uint32 + var x1228 uint32 + x1227, x1228 = bits.Add32(x1155, x1202, uint32(uint1(x1226))) + var x1229 uint32 + var x1230 uint32 + x1229, x1230 = bits.Add32(x1157, x1204, uint32(uint1(x1228))) + var x1231 uint32 + var x1232 uint32 + x1231, x1232 = bits.Add32(x1159, x1206, uint32(uint1(x1230))) + var x1233 uint32 + var x1234 uint32 + x1233, x1234 = bits.Add32(x1161, x1208, uint32(uint1(x1232))) + var x1235 uint32 + var x1236 uint32 + x1235, x1236 = bits.Add32(x1163, x1210, uint32(uint1(x1234))) + var x1237 uint32 + var x1238 uint32 + x1237, x1238 = bits.Add32(x1165, x1212, uint32(uint1(x1236))) + var x1239 uint32 + var x1240 uint32 + x1239, x1240 = bits.Add32(x1167, x1214, uint32(uint1(x1238))) + var x1241 uint32 + var x1242 uint32 + x1241, x1242 = bits.Add32(x1169, x1216, uint32(uint1(x1240))) + var x1243 uint32 + var x1244 uint32 + x1243, x1244 = bits.Add32(x1171, x1218, uint32(uint1(x1242))) + var x1245 uint32 + var x1246 uint32 + x1245, x1246 = bits.Add32(x1173, x1220, uint32(uint1(x1244))) + var x1247 uint32 + var x1248 uint32 + x1247, x1248 = bits.Add32(x1175, x1222, uint32(uint1(x1246))) + var x1249 uint32 + var x1250 uint32 + x1249, x1250 = bits.Add32(x1177, x1224, uint32(uint1(x1248))) + var x1251 uint32 + _, x1251 = bits.Mul32(x1225, 0xe88fdc45) + var x1253 uint32 + var x1254 uint32 + x1254, x1253 = bits.Mul32(x1251, 0xffffffff) + var x1255 uint32 + var x1256 uint32 + x1256, x1255 = bits.Mul32(x1251, 0xffffffff) + var x1257 uint32 + var x1258 uint32 + x1258, x1257 = bits.Mul32(x1251, 0xffffffff) + var x1259 uint32 + var x1260 uint32 + x1260, x1259 = bits.Mul32(x1251, 0xffffffff) + var x1261 uint32 + var x1262 uint32 + x1262, x1261 = bits.Mul32(x1251, 0xffffffff) + var x1263 uint32 + var x1264 uint32 + x1264, x1263 = bits.Mul32(x1251, 0xffffffff) + var x1265 uint32 + var x1266 uint32 + x1266, x1265 = bits.Mul32(x1251, 0xc7634d81) + var x1267 uint32 + var x1268 uint32 + x1268, x1267 = bits.Mul32(x1251, 0xf4372ddf) + var x1269 uint32 + var x1270 uint32 + x1270, x1269 = bits.Mul32(x1251, 0x581a0db2) + var x1271 uint32 + var x1272 uint32 + x1272, x1271 = bits.Mul32(x1251, 0x48b0a77a) + var x1273 uint32 + var x1274 uint32 + x1274, x1273 = bits.Mul32(x1251, 0xecec196a) + var x1275 uint32 + var x1276 uint32 + x1276, x1275 = bits.Mul32(x1251, 0xccc52973) + var x1277 uint32 + var x1278 uint32 + x1277, x1278 = bits.Add32(x1276, x1273, uint32(0x0)) + var x1279 uint32 + var x1280 uint32 + x1279, x1280 = bits.Add32(x1274, x1271, uint32(uint1(x1278))) + var x1281 uint32 + var x1282 uint32 + x1281, x1282 = bits.Add32(x1272, x1269, uint32(uint1(x1280))) + var x1283 uint32 + var x1284 uint32 + x1283, x1284 = bits.Add32(x1270, x1267, uint32(uint1(x1282))) + var x1285 uint32 + var x1286 uint32 + x1285, x1286 = bits.Add32(x1268, x1265, uint32(uint1(x1284))) + var x1287 uint32 + var x1288 uint32 + x1287, x1288 = bits.Add32(x1266, x1263, uint32(uint1(x1286))) + var x1289 uint32 + var x1290 uint32 + x1289, x1290 = bits.Add32(x1264, x1261, uint32(uint1(x1288))) + var x1291 uint32 + var x1292 uint32 + x1291, x1292 = bits.Add32(x1262, x1259, uint32(uint1(x1290))) + var x1293 uint32 + var x1294 uint32 + x1293, x1294 = bits.Add32(x1260, x1257, uint32(uint1(x1292))) + var x1295 uint32 + var x1296 uint32 + x1295, x1296 = bits.Add32(x1258, x1255, uint32(uint1(x1294))) + var x1297 uint32 + var x1298 uint32 + x1297, x1298 = bits.Add32(x1256, x1253, uint32(uint1(x1296))) + x1299 := (uint32(uint1(x1298)) + x1254) + var x1301 uint32 + _, x1301 = bits.Add32(x1225, x1275, uint32(0x0)) + var x1302 uint32 + var x1303 uint32 + x1302, x1303 = bits.Add32(x1227, x1277, uint32(uint1(x1301))) + var x1304 uint32 + var x1305 uint32 + x1304, x1305 = bits.Add32(x1229, x1279, uint32(uint1(x1303))) + var x1306 uint32 + var x1307 uint32 + x1306, x1307 = bits.Add32(x1231, x1281, uint32(uint1(x1305))) + var x1308 uint32 + var x1309 uint32 + x1308, x1309 = bits.Add32(x1233, x1283, uint32(uint1(x1307))) + var x1310 uint32 + var x1311 uint32 + x1310, x1311 = bits.Add32(x1235, x1285, uint32(uint1(x1309))) + var x1312 uint32 + var x1313 uint32 + x1312, x1313 = bits.Add32(x1237, x1287, uint32(uint1(x1311))) + var x1314 uint32 + var x1315 uint32 + x1314, x1315 = bits.Add32(x1239, x1289, uint32(uint1(x1313))) + var x1316 uint32 + var x1317 uint32 + x1316, x1317 = bits.Add32(x1241, x1291, uint32(uint1(x1315))) + var x1318 uint32 + var x1319 uint32 + x1318, x1319 = bits.Add32(x1243, x1293, uint32(uint1(x1317))) + var x1320 uint32 + var x1321 uint32 + x1320, x1321 = bits.Add32(x1245, x1295, uint32(uint1(x1319))) + var x1322 uint32 + var x1323 uint32 + x1322, x1323 = bits.Add32(x1247, x1297, uint32(uint1(x1321))) + var x1324 uint32 + var x1325 uint32 + x1324, x1325 = bits.Add32(x1249, x1299, uint32(uint1(x1323))) + x1326 := (uint32(uint1(x1325)) + uint32(uint1(x1250))) + var x1327 uint32 + var x1328 uint32 + x1328, x1327 = bits.Mul32(x9, arg2[11]) + var x1329 uint32 + var x1330 uint32 + x1330, x1329 = bits.Mul32(x9, arg2[10]) + var x1331 uint32 + var x1332 uint32 + x1332, x1331 = bits.Mul32(x9, arg2[9]) + var x1333 uint32 + var x1334 uint32 + x1334, x1333 = bits.Mul32(x9, arg2[8]) + var x1335 uint32 + var x1336 uint32 + x1336, x1335 = bits.Mul32(x9, arg2[7]) + var x1337 uint32 + var x1338 uint32 + x1338, x1337 = bits.Mul32(x9, arg2[6]) + var x1339 uint32 + var x1340 uint32 + x1340, x1339 = bits.Mul32(x9, arg2[5]) + var x1341 uint32 + var x1342 uint32 + x1342, x1341 = bits.Mul32(x9, arg2[4]) + var x1343 uint32 + var x1344 uint32 + x1344, x1343 = bits.Mul32(x9, arg2[3]) + var x1345 uint32 + var x1346 uint32 + x1346, x1345 = bits.Mul32(x9, arg2[2]) + var x1347 uint32 + var x1348 uint32 + x1348, x1347 = bits.Mul32(x9, arg2[1]) + var x1349 uint32 + var x1350 uint32 + x1350, x1349 = bits.Mul32(x9, arg2[0]) + var x1351 uint32 + var x1352 uint32 + x1351, x1352 = bits.Add32(x1350, x1347, uint32(0x0)) + var x1353 uint32 + var x1354 uint32 + x1353, x1354 = bits.Add32(x1348, x1345, uint32(uint1(x1352))) + var x1355 uint32 + var x1356 uint32 + x1355, x1356 = bits.Add32(x1346, x1343, uint32(uint1(x1354))) + var x1357 uint32 + var x1358 uint32 + x1357, x1358 = bits.Add32(x1344, x1341, uint32(uint1(x1356))) + var x1359 uint32 + var x1360 uint32 + x1359, x1360 = bits.Add32(x1342, x1339, uint32(uint1(x1358))) + var x1361 uint32 + var x1362 uint32 + x1361, x1362 = bits.Add32(x1340, x1337, uint32(uint1(x1360))) + var x1363 uint32 + var x1364 uint32 + x1363, x1364 = bits.Add32(x1338, x1335, uint32(uint1(x1362))) + var x1365 uint32 + var x1366 uint32 + x1365, x1366 = bits.Add32(x1336, x1333, uint32(uint1(x1364))) + var x1367 uint32 + var x1368 uint32 + x1367, x1368 = bits.Add32(x1334, x1331, uint32(uint1(x1366))) + var x1369 uint32 + var x1370 uint32 + x1369, x1370 = bits.Add32(x1332, x1329, uint32(uint1(x1368))) + var x1371 uint32 + var x1372 uint32 + x1371, x1372 = bits.Add32(x1330, x1327, uint32(uint1(x1370))) + x1373 := (uint32(uint1(x1372)) + x1328) + var x1374 uint32 + var x1375 uint32 + x1374, x1375 = bits.Add32(x1302, x1349, uint32(0x0)) + var x1376 uint32 + var x1377 uint32 + x1376, x1377 = bits.Add32(x1304, x1351, uint32(uint1(x1375))) + var x1378 uint32 + var x1379 uint32 + x1378, x1379 = bits.Add32(x1306, x1353, uint32(uint1(x1377))) + var x1380 uint32 + var x1381 uint32 + x1380, x1381 = bits.Add32(x1308, x1355, uint32(uint1(x1379))) + var x1382 uint32 + var x1383 uint32 + x1382, x1383 = bits.Add32(x1310, x1357, uint32(uint1(x1381))) + var x1384 uint32 + var x1385 uint32 + x1384, x1385 = bits.Add32(x1312, x1359, uint32(uint1(x1383))) + var x1386 uint32 + var x1387 uint32 + x1386, x1387 = bits.Add32(x1314, x1361, uint32(uint1(x1385))) + var x1388 uint32 + var x1389 uint32 + x1388, x1389 = bits.Add32(x1316, x1363, uint32(uint1(x1387))) + var x1390 uint32 + var x1391 uint32 + x1390, x1391 = bits.Add32(x1318, x1365, uint32(uint1(x1389))) + var x1392 uint32 + var x1393 uint32 + x1392, x1393 = bits.Add32(x1320, x1367, uint32(uint1(x1391))) + var x1394 uint32 + var x1395 uint32 + x1394, x1395 = bits.Add32(x1322, x1369, uint32(uint1(x1393))) + var x1396 uint32 + var x1397 uint32 + x1396, x1397 = bits.Add32(x1324, x1371, uint32(uint1(x1395))) + var x1398 uint32 + var x1399 uint32 + x1398, x1399 = bits.Add32(x1326, x1373, uint32(uint1(x1397))) + var x1400 uint32 + _, x1400 = bits.Mul32(x1374, 0xe88fdc45) + var x1402 uint32 + var x1403 uint32 + x1403, x1402 = bits.Mul32(x1400, 0xffffffff) + var x1404 uint32 + var x1405 uint32 + x1405, x1404 = bits.Mul32(x1400, 0xffffffff) + var x1406 uint32 + var x1407 uint32 + x1407, x1406 = bits.Mul32(x1400, 0xffffffff) + var x1408 uint32 + var x1409 uint32 + x1409, x1408 = bits.Mul32(x1400, 0xffffffff) + var x1410 uint32 + var x1411 uint32 + x1411, x1410 = bits.Mul32(x1400, 0xffffffff) + var x1412 uint32 + var x1413 uint32 + x1413, x1412 = bits.Mul32(x1400, 0xffffffff) + var x1414 uint32 + var x1415 uint32 + x1415, x1414 = bits.Mul32(x1400, 0xc7634d81) + var x1416 uint32 + var x1417 uint32 + x1417, x1416 = bits.Mul32(x1400, 0xf4372ddf) + var x1418 uint32 + var x1419 uint32 + x1419, x1418 = bits.Mul32(x1400, 0x581a0db2) + var x1420 uint32 + var x1421 uint32 + x1421, x1420 = bits.Mul32(x1400, 0x48b0a77a) + var x1422 uint32 + var x1423 uint32 + x1423, x1422 = bits.Mul32(x1400, 0xecec196a) + var x1424 uint32 + var x1425 uint32 + x1425, x1424 = bits.Mul32(x1400, 0xccc52973) + var x1426 uint32 + var x1427 uint32 + x1426, x1427 = bits.Add32(x1425, x1422, uint32(0x0)) + var x1428 uint32 + var x1429 uint32 + x1428, x1429 = bits.Add32(x1423, x1420, uint32(uint1(x1427))) + var x1430 uint32 + var x1431 uint32 + x1430, x1431 = bits.Add32(x1421, x1418, uint32(uint1(x1429))) + var x1432 uint32 + var x1433 uint32 + x1432, x1433 = bits.Add32(x1419, x1416, uint32(uint1(x1431))) + var x1434 uint32 + var x1435 uint32 + x1434, x1435 = bits.Add32(x1417, x1414, uint32(uint1(x1433))) + var x1436 uint32 + var x1437 uint32 + x1436, x1437 = bits.Add32(x1415, x1412, uint32(uint1(x1435))) + var x1438 uint32 + var x1439 uint32 + x1438, x1439 = bits.Add32(x1413, x1410, uint32(uint1(x1437))) + var x1440 uint32 + var x1441 uint32 + x1440, x1441 = bits.Add32(x1411, x1408, uint32(uint1(x1439))) + var x1442 uint32 + var x1443 uint32 + x1442, x1443 = bits.Add32(x1409, x1406, uint32(uint1(x1441))) + var x1444 uint32 + var x1445 uint32 + x1444, x1445 = bits.Add32(x1407, x1404, uint32(uint1(x1443))) + var x1446 uint32 + var x1447 uint32 + x1446, x1447 = bits.Add32(x1405, x1402, uint32(uint1(x1445))) + x1448 := (uint32(uint1(x1447)) + x1403) + var x1450 uint32 + _, x1450 = bits.Add32(x1374, x1424, uint32(0x0)) + var x1451 uint32 + var x1452 uint32 + x1451, x1452 = bits.Add32(x1376, x1426, uint32(uint1(x1450))) + var x1453 uint32 + var x1454 uint32 + x1453, x1454 = bits.Add32(x1378, x1428, uint32(uint1(x1452))) + var x1455 uint32 + var x1456 uint32 + x1455, x1456 = bits.Add32(x1380, x1430, uint32(uint1(x1454))) + var x1457 uint32 + var x1458 uint32 + x1457, x1458 = bits.Add32(x1382, x1432, uint32(uint1(x1456))) + var x1459 uint32 + var x1460 uint32 + x1459, x1460 = bits.Add32(x1384, x1434, uint32(uint1(x1458))) + var x1461 uint32 + var x1462 uint32 + x1461, x1462 = bits.Add32(x1386, x1436, uint32(uint1(x1460))) + var x1463 uint32 + var x1464 uint32 + x1463, x1464 = bits.Add32(x1388, x1438, uint32(uint1(x1462))) + var x1465 uint32 + var x1466 uint32 + x1465, x1466 = bits.Add32(x1390, x1440, uint32(uint1(x1464))) + var x1467 uint32 + var x1468 uint32 + x1467, x1468 = bits.Add32(x1392, x1442, uint32(uint1(x1466))) + var x1469 uint32 + var x1470 uint32 + x1469, x1470 = bits.Add32(x1394, x1444, uint32(uint1(x1468))) + var x1471 uint32 + var x1472 uint32 + x1471, x1472 = bits.Add32(x1396, x1446, uint32(uint1(x1470))) + var x1473 uint32 + var x1474 uint32 + x1473, x1474 = bits.Add32(x1398, x1448, uint32(uint1(x1472))) + x1475 := (uint32(uint1(x1474)) + uint32(uint1(x1399))) + var x1476 uint32 + var x1477 uint32 + x1477, x1476 = bits.Mul32(x10, arg2[11]) + var x1478 uint32 + var x1479 uint32 + x1479, x1478 = bits.Mul32(x10, arg2[10]) + var x1480 uint32 + var x1481 uint32 + x1481, x1480 = bits.Mul32(x10, arg2[9]) + var x1482 uint32 + var x1483 uint32 + x1483, x1482 = bits.Mul32(x10, arg2[8]) + var x1484 uint32 + var x1485 uint32 + x1485, x1484 = bits.Mul32(x10, arg2[7]) + var x1486 uint32 + var x1487 uint32 + x1487, x1486 = bits.Mul32(x10, arg2[6]) + var x1488 uint32 + var x1489 uint32 + x1489, x1488 = bits.Mul32(x10, arg2[5]) + var x1490 uint32 + var x1491 uint32 + x1491, x1490 = bits.Mul32(x10, arg2[4]) + var x1492 uint32 + var x1493 uint32 + x1493, x1492 = bits.Mul32(x10, arg2[3]) + var x1494 uint32 + var x1495 uint32 + x1495, x1494 = bits.Mul32(x10, arg2[2]) + var x1496 uint32 + var x1497 uint32 + x1497, x1496 = bits.Mul32(x10, arg2[1]) + var x1498 uint32 + var x1499 uint32 + x1499, x1498 = bits.Mul32(x10, arg2[0]) + var x1500 uint32 + var x1501 uint32 + x1500, x1501 = bits.Add32(x1499, x1496, uint32(0x0)) + var x1502 uint32 + var x1503 uint32 + x1502, x1503 = bits.Add32(x1497, x1494, uint32(uint1(x1501))) + var x1504 uint32 + var x1505 uint32 + x1504, x1505 = bits.Add32(x1495, x1492, uint32(uint1(x1503))) + var x1506 uint32 + var x1507 uint32 + x1506, x1507 = bits.Add32(x1493, x1490, uint32(uint1(x1505))) + var x1508 uint32 + var x1509 uint32 + x1508, x1509 = bits.Add32(x1491, x1488, uint32(uint1(x1507))) + var x1510 uint32 + var x1511 uint32 + x1510, x1511 = bits.Add32(x1489, x1486, uint32(uint1(x1509))) + var x1512 uint32 + var x1513 uint32 + x1512, x1513 = bits.Add32(x1487, x1484, uint32(uint1(x1511))) + var x1514 uint32 + var x1515 uint32 + x1514, x1515 = bits.Add32(x1485, x1482, uint32(uint1(x1513))) + var x1516 uint32 + var x1517 uint32 + x1516, x1517 = bits.Add32(x1483, x1480, uint32(uint1(x1515))) + var x1518 uint32 + var x1519 uint32 + x1518, x1519 = bits.Add32(x1481, x1478, uint32(uint1(x1517))) + var x1520 uint32 + var x1521 uint32 + x1520, x1521 = bits.Add32(x1479, x1476, uint32(uint1(x1519))) + x1522 := (uint32(uint1(x1521)) + x1477) + var x1523 uint32 + var x1524 uint32 + x1523, x1524 = bits.Add32(x1451, x1498, uint32(0x0)) + var x1525 uint32 + var x1526 uint32 + x1525, x1526 = bits.Add32(x1453, x1500, uint32(uint1(x1524))) + var x1527 uint32 + var x1528 uint32 + x1527, x1528 = bits.Add32(x1455, x1502, uint32(uint1(x1526))) + var x1529 uint32 + var x1530 uint32 + x1529, x1530 = bits.Add32(x1457, x1504, uint32(uint1(x1528))) + var x1531 uint32 + var x1532 uint32 + x1531, x1532 = bits.Add32(x1459, x1506, uint32(uint1(x1530))) + var x1533 uint32 + var x1534 uint32 + x1533, x1534 = bits.Add32(x1461, x1508, uint32(uint1(x1532))) + var x1535 uint32 + var x1536 uint32 + x1535, x1536 = bits.Add32(x1463, x1510, uint32(uint1(x1534))) + var x1537 uint32 + var x1538 uint32 + x1537, x1538 = bits.Add32(x1465, x1512, uint32(uint1(x1536))) + var x1539 uint32 + var x1540 uint32 + x1539, x1540 = bits.Add32(x1467, x1514, uint32(uint1(x1538))) + var x1541 uint32 + var x1542 uint32 + x1541, x1542 = bits.Add32(x1469, x1516, uint32(uint1(x1540))) + var x1543 uint32 + var x1544 uint32 + x1543, x1544 = bits.Add32(x1471, x1518, uint32(uint1(x1542))) + var x1545 uint32 + var x1546 uint32 + x1545, x1546 = bits.Add32(x1473, x1520, uint32(uint1(x1544))) + var x1547 uint32 + var x1548 uint32 + x1547, x1548 = bits.Add32(x1475, x1522, uint32(uint1(x1546))) + var x1549 uint32 + _, x1549 = bits.Mul32(x1523, 0xe88fdc45) + var x1551 uint32 + var x1552 uint32 + x1552, x1551 = bits.Mul32(x1549, 0xffffffff) + var x1553 uint32 + var x1554 uint32 + x1554, x1553 = bits.Mul32(x1549, 0xffffffff) + var x1555 uint32 + var x1556 uint32 + x1556, x1555 = bits.Mul32(x1549, 0xffffffff) + var x1557 uint32 + var x1558 uint32 + x1558, x1557 = bits.Mul32(x1549, 0xffffffff) + var x1559 uint32 + var x1560 uint32 + x1560, x1559 = bits.Mul32(x1549, 0xffffffff) + var x1561 uint32 + var x1562 uint32 + x1562, x1561 = bits.Mul32(x1549, 0xffffffff) + var x1563 uint32 + var x1564 uint32 + x1564, x1563 = bits.Mul32(x1549, 0xc7634d81) + var x1565 uint32 + var x1566 uint32 + x1566, x1565 = bits.Mul32(x1549, 0xf4372ddf) + var x1567 uint32 + var x1568 uint32 + x1568, x1567 = bits.Mul32(x1549, 0x581a0db2) + var x1569 uint32 + var x1570 uint32 + x1570, x1569 = bits.Mul32(x1549, 0x48b0a77a) + var x1571 uint32 + var x1572 uint32 + x1572, x1571 = bits.Mul32(x1549, 0xecec196a) + var x1573 uint32 + var x1574 uint32 + x1574, x1573 = bits.Mul32(x1549, 0xccc52973) + var x1575 uint32 + var x1576 uint32 + x1575, x1576 = bits.Add32(x1574, x1571, uint32(0x0)) + var x1577 uint32 + var x1578 uint32 + x1577, x1578 = bits.Add32(x1572, x1569, uint32(uint1(x1576))) + var x1579 uint32 + var x1580 uint32 + x1579, x1580 = bits.Add32(x1570, x1567, uint32(uint1(x1578))) + var x1581 uint32 + var x1582 uint32 + x1581, x1582 = bits.Add32(x1568, x1565, uint32(uint1(x1580))) + var x1583 uint32 + var x1584 uint32 + x1583, x1584 = bits.Add32(x1566, x1563, uint32(uint1(x1582))) + var x1585 uint32 + var x1586 uint32 + x1585, x1586 = bits.Add32(x1564, x1561, uint32(uint1(x1584))) + var x1587 uint32 + var x1588 uint32 + x1587, x1588 = bits.Add32(x1562, x1559, uint32(uint1(x1586))) + var x1589 uint32 + var x1590 uint32 + x1589, x1590 = bits.Add32(x1560, x1557, uint32(uint1(x1588))) + var x1591 uint32 + var x1592 uint32 + x1591, x1592 = bits.Add32(x1558, x1555, uint32(uint1(x1590))) + var x1593 uint32 + var x1594 uint32 + x1593, x1594 = bits.Add32(x1556, x1553, uint32(uint1(x1592))) + var x1595 uint32 + var x1596 uint32 + x1595, x1596 = bits.Add32(x1554, x1551, uint32(uint1(x1594))) + x1597 := (uint32(uint1(x1596)) + x1552) + var x1599 uint32 + _, x1599 = bits.Add32(x1523, x1573, uint32(0x0)) + var x1600 uint32 + var x1601 uint32 + x1600, x1601 = bits.Add32(x1525, x1575, uint32(uint1(x1599))) + var x1602 uint32 + var x1603 uint32 + x1602, x1603 = bits.Add32(x1527, x1577, uint32(uint1(x1601))) + var x1604 uint32 + var x1605 uint32 + x1604, x1605 = bits.Add32(x1529, x1579, uint32(uint1(x1603))) + var x1606 uint32 + var x1607 uint32 + x1606, x1607 = bits.Add32(x1531, x1581, uint32(uint1(x1605))) + var x1608 uint32 + var x1609 uint32 + x1608, x1609 = bits.Add32(x1533, x1583, uint32(uint1(x1607))) + var x1610 uint32 + var x1611 uint32 + x1610, x1611 = bits.Add32(x1535, x1585, uint32(uint1(x1609))) + var x1612 uint32 + var x1613 uint32 + x1612, x1613 = bits.Add32(x1537, x1587, uint32(uint1(x1611))) + var x1614 uint32 + var x1615 uint32 + x1614, x1615 = bits.Add32(x1539, x1589, uint32(uint1(x1613))) + var x1616 uint32 + var x1617 uint32 + x1616, x1617 = bits.Add32(x1541, x1591, uint32(uint1(x1615))) + var x1618 uint32 + var x1619 uint32 + x1618, x1619 = bits.Add32(x1543, x1593, uint32(uint1(x1617))) + var x1620 uint32 + var x1621 uint32 + x1620, x1621 = bits.Add32(x1545, x1595, uint32(uint1(x1619))) + var x1622 uint32 + var x1623 uint32 + x1622, x1623 = bits.Add32(x1547, x1597, uint32(uint1(x1621))) + x1624 := (uint32(uint1(x1623)) + uint32(uint1(x1548))) + var x1625 uint32 + var x1626 uint32 + x1626, x1625 = bits.Mul32(x11, arg2[11]) + var x1627 uint32 + var x1628 uint32 + x1628, x1627 = bits.Mul32(x11, arg2[10]) + var x1629 uint32 + var x1630 uint32 + x1630, x1629 = bits.Mul32(x11, arg2[9]) + var x1631 uint32 + var x1632 uint32 + x1632, x1631 = bits.Mul32(x11, arg2[8]) + var x1633 uint32 + var x1634 uint32 + x1634, x1633 = bits.Mul32(x11, arg2[7]) + var x1635 uint32 + var x1636 uint32 + x1636, x1635 = bits.Mul32(x11, arg2[6]) + var x1637 uint32 + var x1638 uint32 + x1638, x1637 = bits.Mul32(x11, arg2[5]) + var x1639 uint32 + var x1640 uint32 + x1640, x1639 = bits.Mul32(x11, arg2[4]) + var x1641 uint32 + var x1642 uint32 + x1642, x1641 = bits.Mul32(x11, arg2[3]) + var x1643 uint32 + var x1644 uint32 + x1644, x1643 = bits.Mul32(x11, arg2[2]) + var x1645 uint32 + var x1646 uint32 + x1646, x1645 = bits.Mul32(x11, arg2[1]) + var x1647 uint32 + var x1648 uint32 + x1648, x1647 = bits.Mul32(x11, arg2[0]) + var x1649 uint32 + var x1650 uint32 + x1649, x1650 = bits.Add32(x1648, x1645, uint32(0x0)) + var x1651 uint32 + var x1652 uint32 + x1651, x1652 = bits.Add32(x1646, x1643, uint32(uint1(x1650))) + var x1653 uint32 + var x1654 uint32 + x1653, x1654 = bits.Add32(x1644, x1641, uint32(uint1(x1652))) + var x1655 uint32 + var x1656 uint32 + x1655, x1656 = bits.Add32(x1642, x1639, uint32(uint1(x1654))) + var x1657 uint32 + var x1658 uint32 + x1657, x1658 = bits.Add32(x1640, x1637, uint32(uint1(x1656))) + var x1659 uint32 + var x1660 uint32 + x1659, x1660 = bits.Add32(x1638, x1635, uint32(uint1(x1658))) + var x1661 uint32 + var x1662 uint32 + x1661, x1662 = bits.Add32(x1636, x1633, uint32(uint1(x1660))) + var x1663 uint32 + var x1664 uint32 + x1663, x1664 = bits.Add32(x1634, x1631, uint32(uint1(x1662))) + var x1665 uint32 + var x1666 uint32 + x1665, x1666 = bits.Add32(x1632, x1629, uint32(uint1(x1664))) + var x1667 uint32 + var x1668 uint32 + x1667, x1668 = bits.Add32(x1630, x1627, uint32(uint1(x1666))) + var x1669 uint32 + var x1670 uint32 + x1669, x1670 = bits.Add32(x1628, x1625, uint32(uint1(x1668))) + x1671 := (uint32(uint1(x1670)) + x1626) + var x1672 uint32 + var x1673 uint32 + x1672, x1673 = bits.Add32(x1600, x1647, uint32(0x0)) + var x1674 uint32 + var x1675 uint32 + x1674, x1675 = bits.Add32(x1602, x1649, uint32(uint1(x1673))) + var x1676 uint32 + var x1677 uint32 + x1676, x1677 = bits.Add32(x1604, x1651, uint32(uint1(x1675))) + var x1678 uint32 + var x1679 uint32 + x1678, x1679 = bits.Add32(x1606, x1653, uint32(uint1(x1677))) + var x1680 uint32 + var x1681 uint32 + x1680, x1681 = bits.Add32(x1608, x1655, uint32(uint1(x1679))) + var x1682 uint32 + var x1683 uint32 + x1682, x1683 = bits.Add32(x1610, x1657, uint32(uint1(x1681))) + var x1684 uint32 + var x1685 uint32 + x1684, x1685 = bits.Add32(x1612, x1659, uint32(uint1(x1683))) + var x1686 uint32 + var x1687 uint32 + x1686, x1687 = bits.Add32(x1614, x1661, uint32(uint1(x1685))) + var x1688 uint32 + var x1689 uint32 + x1688, x1689 = bits.Add32(x1616, x1663, uint32(uint1(x1687))) + var x1690 uint32 + var x1691 uint32 + x1690, x1691 = bits.Add32(x1618, x1665, uint32(uint1(x1689))) + var x1692 uint32 + var x1693 uint32 + x1692, x1693 = bits.Add32(x1620, x1667, uint32(uint1(x1691))) + var x1694 uint32 + var x1695 uint32 + x1694, x1695 = bits.Add32(x1622, x1669, uint32(uint1(x1693))) + var x1696 uint32 + var x1697 uint32 + x1696, x1697 = bits.Add32(x1624, x1671, uint32(uint1(x1695))) + var x1698 uint32 + _, x1698 = bits.Mul32(x1672, 0xe88fdc45) + var x1700 uint32 + var x1701 uint32 + x1701, x1700 = bits.Mul32(x1698, 0xffffffff) + var x1702 uint32 + var x1703 uint32 + x1703, x1702 = bits.Mul32(x1698, 0xffffffff) + var x1704 uint32 + var x1705 uint32 + x1705, x1704 = bits.Mul32(x1698, 0xffffffff) + var x1706 uint32 + var x1707 uint32 + x1707, x1706 = bits.Mul32(x1698, 0xffffffff) + var x1708 uint32 + var x1709 uint32 + x1709, x1708 = bits.Mul32(x1698, 0xffffffff) + var x1710 uint32 + var x1711 uint32 + x1711, x1710 = bits.Mul32(x1698, 0xffffffff) + var x1712 uint32 + var x1713 uint32 + x1713, x1712 = bits.Mul32(x1698, 0xc7634d81) + var x1714 uint32 + var x1715 uint32 + x1715, x1714 = bits.Mul32(x1698, 0xf4372ddf) + var x1716 uint32 + var x1717 uint32 + x1717, x1716 = bits.Mul32(x1698, 0x581a0db2) + var x1718 uint32 + var x1719 uint32 + x1719, x1718 = bits.Mul32(x1698, 0x48b0a77a) + var x1720 uint32 + var x1721 uint32 + x1721, x1720 = bits.Mul32(x1698, 0xecec196a) + var x1722 uint32 + var x1723 uint32 + x1723, x1722 = bits.Mul32(x1698, 0xccc52973) + var x1724 uint32 + var x1725 uint32 + x1724, x1725 = bits.Add32(x1723, x1720, uint32(0x0)) + var x1726 uint32 + var x1727 uint32 + x1726, x1727 = bits.Add32(x1721, x1718, uint32(uint1(x1725))) + var x1728 uint32 + var x1729 uint32 + x1728, x1729 = bits.Add32(x1719, x1716, uint32(uint1(x1727))) + var x1730 uint32 + var x1731 uint32 + x1730, x1731 = bits.Add32(x1717, x1714, uint32(uint1(x1729))) + var x1732 uint32 + var x1733 uint32 + x1732, x1733 = bits.Add32(x1715, x1712, uint32(uint1(x1731))) + var x1734 uint32 + var x1735 uint32 + x1734, x1735 = bits.Add32(x1713, x1710, uint32(uint1(x1733))) + var x1736 uint32 + var x1737 uint32 + x1736, x1737 = bits.Add32(x1711, x1708, uint32(uint1(x1735))) + var x1738 uint32 + var x1739 uint32 + x1738, x1739 = bits.Add32(x1709, x1706, uint32(uint1(x1737))) + var x1740 uint32 + var x1741 uint32 + x1740, x1741 = bits.Add32(x1707, x1704, uint32(uint1(x1739))) + var x1742 uint32 + var x1743 uint32 + x1742, x1743 = bits.Add32(x1705, x1702, uint32(uint1(x1741))) + var x1744 uint32 + var x1745 uint32 + x1744, x1745 = bits.Add32(x1703, x1700, uint32(uint1(x1743))) + x1746 := (uint32(uint1(x1745)) + x1701) + var x1748 uint32 + _, x1748 = bits.Add32(x1672, x1722, uint32(0x0)) + var x1749 uint32 + var x1750 uint32 + x1749, x1750 = bits.Add32(x1674, x1724, uint32(uint1(x1748))) + var x1751 uint32 + var x1752 uint32 + x1751, x1752 = bits.Add32(x1676, x1726, uint32(uint1(x1750))) + var x1753 uint32 + var x1754 uint32 + x1753, x1754 = bits.Add32(x1678, x1728, uint32(uint1(x1752))) + var x1755 uint32 + var x1756 uint32 + x1755, x1756 = bits.Add32(x1680, x1730, uint32(uint1(x1754))) + var x1757 uint32 + var x1758 uint32 + x1757, x1758 = bits.Add32(x1682, x1732, uint32(uint1(x1756))) + var x1759 uint32 + var x1760 uint32 + x1759, x1760 = bits.Add32(x1684, x1734, uint32(uint1(x1758))) + var x1761 uint32 + var x1762 uint32 + x1761, x1762 = bits.Add32(x1686, x1736, uint32(uint1(x1760))) + var x1763 uint32 + var x1764 uint32 + x1763, x1764 = bits.Add32(x1688, x1738, uint32(uint1(x1762))) + var x1765 uint32 + var x1766 uint32 + x1765, x1766 = bits.Add32(x1690, x1740, uint32(uint1(x1764))) + var x1767 uint32 + var x1768 uint32 + x1767, x1768 = bits.Add32(x1692, x1742, uint32(uint1(x1766))) + var x1769 uint32 + var x1770 uint32 + x1769, x1770 = bits.Add32(x1694, x1744, uint32(uint1(x1768))) + var x1771 uint32 + var x1772 uint32 + x1771, x1772 = bits.Add32(x1696, x1746, uint32(uint1(x1770))) + x1773 := (uint32(uint1(x1772)) + uint32(uint1(x1697))) + var x1774 uint32 + var x1775 uint32 + x1774, x1775 = bits.Sub32(x1749, 0xccc52973, uint32(0x0)) + var x1776 uint32 + var x1777 uint32 + x1776, x1777 = bits.Sub32(x1751, 0xecec196a, uint32(uint1(x1775))) + var x1778 uint32 + var x1779 uint32 + x1778, x1779 = bits.Sub32(x1753, 0x48b0a77a, uint32(uint1(x1777))) + var x1780 uint32 + var x1781 uint32 + x1780, x1781 = bits.Sub32(x1755, 0x581a0db2, uint32(uint1(x1779))) + var x1782 uint32 + var x1783 uint32 + x1782, x1783 = bits.Sub32(x1757, 0xf4372ddf, uint32(uint1(x1781))) + var x1784 uint32 + var x1785 uint32 + x1784, x1785 = bits.Sub32(x1759, 0xc7634d81, uint32(uint1(x1783))) + var x1786 uint32 + var x1787 uint32 + x1786, x1787 = bits.Sub32(x1761, 0xffffffff, uint32(uint1(x1785))) + var x1788 uint32 + var x1789 uint32 + x1788, x1789 = bits.Sub32(x1763, 0xffffffff, uint32(uint1(x1787))) + var x1790 uint32 + var x1791 uint32 + x1790, x1791 = bits.Sub32(x1765, 0xffffffff, uint32(uint1(x1789))) + var x1792 uint32 + var x1793 uint32 + x1792, x1793 = bits.Sub32(x1767, 0xffffffff, uint32(uint1(x1791))) + var x1794 uint32 + var x1795 uint32 + x1794, x1795 = bits.Sub32(x1769, 0xffffffff, uint32(uint1(x1793))) + var x1796 uint32 + var x1797 uint32 + x1796, x1797 = bits.Sub32(x1771, 0xffffffff, uint32(uint1(x1795))) + var x1799 uint32 + _, x1799 = bits.Sub32(x1773, uint32(0x0), uint32(uint1(x1797))) + var x1800 uint32 + cmovznzU32(&x1800, uint1(x1799), x1774, x1749) + var x1801 uint32 + cmovznzU32(&x1801, uint1(x1799), x1776, x1751) + var x1802 uint32 + cmovznzU32(&x1802, uint1(x1799), x1778, x1753) + var x1803 uint32 + cmovznzU32(&x1803, uint1(x1799), x1780, x1755) + var x1804 uint32 + cmovznzU32(&x1804, uint1(x1799), x1782, x1757) + var x1805 uint32 + cmovznzU32(&x1805, uint1(x1799), x1784, x1759) + var x1806 uint32 + cmovznzU32(&x1806, uint1(x1799), x1786, x1761) + var x1807 uint32 + cmovznzU32(&x1807, uint1(x1799), x1788, x1763) + var x1808 uint32 + cmovznzU32(&x1808, uint1(x1799), x1790, x1765) + var x1809 uint32 + cmovznzU32(&x1809, uint1(x1799), x1792, x1767) + var x1810 uint32 + cmovznzU32(&x1810, uint1(x1799), x1794, x1769) + var x1811 uint32 + cmovznzU32(&x1811, uint1(x1799), x1796, x1771) + out1[0] = x1800 + out1[1] = x1801 + out1[2] = x1802 + out1[3] = x1803 + out1[4] = x1804 + out1[5] = x1805 + out1[6] = x1806 + out1[7] = x1807 + out1[8] = x1808 + out1[9] = x1809 + out1[10] = x1810 + out1[11] = x1811 +} + +// Square squares a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +// 0 ≤ eval out1 < m +// +func Square(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[6] + x7 := arg1[7] + x8 := arg1[8] + x9 := arg1[9] + x10 := arg1[10] + x11 := arg1[11] + x12 := arg1[0] + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x12, arg1[11]) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x12, arg1[10]) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x12, arg1[9]) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x12, arg1[8]) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x12, arg1[7]) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x12, arg1[6]) + var x25 uint32 + var x26 uint32 + x26, x25 = bits.Mul32(x12, arg1[5]) + var x27 uint32 + var x28 uint32 + x28, x27 = bits.Mul32(x12, arg1[4]) + var x29 uint32 + var x30 uint32 + x30, x29 = bits.Mul32(x12, arg1[3]) + var x31 uint32 + var x32 uint32 + x32, x31 = bits.Mul32(x12, arg1[2]) + var x33 uint32 + var x34 uint32 + x34, x33 = bits.Mul32(x12, arg1[1]) + var x35 uint32 + var x36 uint32 + x36, x35 = bits.Mul32(x12, arg1[0]) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Add32(x36, x33, uint32(0x0)) + var x39 uint32 + var x40 uint32 + x39, x40 = bits.Add32(x34, x31, uint32(uint1(x38))) + var x41 uint32 + var x42 uint32 + x41, x42 = bits.Add32(x32, x29, uint32(uint1(x40))) + var x43 uint32 + var x44 uint32 + x43, x44 = bits.Add32(x30, x27, uint32(uint1(x42))) + var x45 uint32 + var x46 uint32 + x45, x46 = bits.Add32(x28, x25, uint32(uint1(x44))) + var x47 uint32 + var x48 uint32 + x47, x48 = bits.Add32(x26, x23, uint32(uint1(x46))) + var x49 uint32 + var x50 uint32 + x49, x50 = bits.Add32(x24, x21, uint32(uint1(x48))) + var x51 uint32 + var x52 uint32 + x51, x52 = bits.Add32(x22, x19, uint32(uint1(x50))) + var x53 uint32 + var x54 uint32 + x53, x54 = bits.Add32(x20, x17, uint32(uint1(x52))) + var x55 uint32 + var x56 uint32 + x55, x56 = bits.Add32(x18, x15, uint32(uint1(x54))) + var x57 uint32 + var x58 uint32 + x57, x58 = bits.Add32(x16, x13, uint32(uint1(x56))) + x59 := (uint32(uint1(x58)) + x14) + var x60 uint32 + _, x60 = bits.Mul32(x35, 0xe88fdc45) + var x62 uint32 + var x63 uint32 + x63, x62 = bits.Mul32(x60, 0xffffffff) + var x64 uint32 + var x65 uint32 + x65, x64 = bits.Mul32(x60, 0xffffffff) + var x66 uint32 + var x67 uint32 + x67, x66 = bits.Mul32(x60, 0xffffffff) + var x68 uint32 + var x69 uint32 + x69, x68 = bits.Mul32(x60, 0xffffffff) + var x70 uint32 + var x71 uint32 + x71, x70 = bits.Mul32(x60, 0xffffffff) + var x72 uint32 + var x73 uint32 + x73, x72 = bits.Mul32(x60, 0xffffffff) + var x74 uint32 + var x75 uint32 + x75, x74 = bits.Mul32(x60, 0xc7634d81) + var x76 uint32 + var x77 uint32 + x77, x76 = bits.Mul32(x60, 0xf4372ddf) + var x78 uint32 + var x79 uint32 + x79, x78 = bits.Mul32(x60, 0x581a0db2) + var x80 uint32 + var x81 uint32 + x81, x80 = bits.Mul32(x60, 0x48b0a77a) + var x82 uint32 + var x83 uint32 + x83, x82 = bits.Mul32(x60, 0xecec196a) + var x84 uint32 + var x85 uint32 + x85, x84 = bits.Mul32(x60, 0xccc52973) + var x86 uint32 + var x87 uint32 + x86, x87 = bits.Add32(x85, x82, uint32(0x0)) + var x88 uint32 + var x89 uint32 + x88, x89 = bits.Add32(x83, x80, uint32(uint1(x87))) + var x90 uint32 + var x91 uint32 + x90, x91 = bits.Add32(x81, x78, uint32(uint1(x89))) + var x92 uint32 + var x93 uint32 + x92, x93 = bits.Add32(x79, x76, uint32(uint1(x91))) + var x94 uint32 + var x95 uint32 + x94, x95 = bits.Add32(x77, x74, uint32(uint1(x93))) + var x96 uint32 + var x97 uint32 + x96, x97 = bits.Add32(x75, x72, uint32(uint1(x95))) + var x98 uint32 + var x99 uint32 + x98, x99 = bits.Add32(x73, x70, uint32(uint1(x97))) + var x100 uint32 + var x101 uint32 + x100, x101 = bits.Add32(x71, x68, uint32(uint1(x99))) + var x102 uint32 + var x103 uint32 + x102, x103 = bits.Add32(x69, x66, uint32(uint1(x101))) + var x104 uint32 + var x105 uint32 + x104, x105 = bits.Add32(x67, x64, uint32(uint1(x103))) + var x106 uint32 + var x107 uint32 + x106, x107 = bits.Add32(x65, x62, uint32(uint1(x105))) + x108 := (uint32(uint1(x107)) + x63) + var x110 uint32 + _, x110 = bits.Add32(x35, x84, uint32(0x0)) + var x111 uint32 + var x112 uint32 + x111, x112 = bits.Add32(x37, x86, uint32(uint1(x110))) + var x113 uint32 + var x114 uint32 + x113, x114 = bits.Add32(x39, x88, uint32(uint1(x112))) + var x115 uint32 + var x116 uint32 + x115, x116 = bits.Add32(x41, x90, uint32(uint1(x114))) + var x117 uint32 + var x118 uint32 + x117, x118 = bits.Add32(x43, x92, uint32(uint1(x116))) + var x119 uint32 + var x120 uint32 + x119, x120 = bits.Add32(x45, x94, uint32(uint1(x118))) + var x121 uint32 + var x122 uint32 + x121, x122 = bits.Add32(x47, x96, uint32(uint1(x120))) + var x123 uint32 + var x124 uint32 + x123, x124 = bits.Add32(x49, x98, uint32(uint1(x122))) + var x125 uint32 + var x126 uint32 + x125, x126 = bits.Add32(x51, x100, uint32(uint1(x124))) + var x127 uint32 + var x128 uint32 + x127, x128 = bits.Add32(x53, x102, uint32(uint1(x126))) + var x129 uint32 + var x130 uint32 + x129, x130 = bits.Add32(x55, x104, uint32(uint1(x128))) + var x131 uint32 + var x132 uint32 + x131, x132 = bits.Add32(x57, x106, uint32(uint1(x130))) + var x133 uint32 + var x134 uint32 + x133, x134 = bits.Add32(x59, x108, uint32(uint1(x132))) + var x135 uint32 + var x136 uint32 + x136, x135 = bits.Mul32(x1, arg1[11]) + var x137 uint32 + var x138 uint32 + x138, x137 = bits.Mul32(x1, arg1[10]) + var x139 uint32 + var x140 uint32 + x140, x139 = bits.Mul32(x1, arg1[9]) + var x141 uint32 + var x142 uint32 + x142, x141 = bits.Mul32(x1, arg1[8]) + var x143 uint32 + var x144 uint32 + x144, x143 = bits.Mul32(x1, arg1[7]) + var x145 uint32 + var x146 uint32 + x146, x145 = bits.Mul32(x1, arg1[6]) + var x147 uint32 + var x148 uint32 + x148, x147 = bits.Mul32(x1, arg1[5]) + var x149 uint32 + var x150 uint32 + x150, x149 = bits.Mul32(x1, arg1[4]) + var x151 uint32 + var x152 uint32 + x152, x151 = bits.Mul32(x1, arg1[3]) + var x153 uint32 + var x154 uint32 + x154, x153 = bits.Mul32(x1, arg1[2]) + var x155 uint32 + var x156 uint32 + x156, x155 = bits.Mul32(x1, arg1[1]) + var x157 uint32 + var x158 uint32 + x158, x157 = bits.Mul32(x1, arg1[0]) + var x159 uint32 + var x160 uint32 + x159, x160 = bits.Add32(x158, x155, uint32(0x0)) + var x161 uint32 + var x162 uint32 + x161, x162 = bits.Add32(x156, x153, uint32(uint1(x160))) + var x163 uint32 + var x164 uint32 + x163, x164 = bits.Add32(x154, x151, uint32(uint1(x162))) + var x165 uint32 + var x166 uint32 + x165, x166 = bits.Add32(x152, x149, uint32(uint1(x164))) + var x167 uint32 + var x168 uint32 + x167, x168 = bits.Add32(x150, x147, uint32(uint1(x166))) + var x169 uint32 + var x170 uint32 + x169, x170 = bits.Add32(x148, x145, uint32(uint1(x168))) + var x171 uint32 + var x172 uint32 + x171, x172 = bits.Add32(x146, x143, uint32(uint1(x170))) + var x173 uint32 + var x174 uint32 + x173, x174 = bits.Add32(x144, x141, uint32(uint1(x172))) + var x175 uint32 + var x176 uint32 + x175, x176 = bits.Add32(x142, x139, uint32(uint1(x174))) + var x177 uint32 + var x178 uint32 + x177, x178 = bits.Add32(x140, x137, uint32(uint1(x176))) + var x179 uint32 + var x180 uint32 + x179, x180 = bits.Add32(x138, x135, uint32(uint1(x178))) + x181 := (uint32(uint1(x180)) + x136) + var x182 uint32 + var x183 uint32 + x182, x183 = bits.Add32(x111, x157, uint32(0x0)) + var x184 uint32 + var x185 uint32 + x184, x185 = bits.Add32(x113, x159, uint32(uint1(x183))) + var x186 uint32 + var x187 uint32 + x186, x187 = bits.Add32(x115, x161, uint32(uint1(x185))) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Add32(x117, x163, uint32(uint1(x187))) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Add32(x119, x165, uint32(uint1(x189))) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Add32(x121, x167, uint32(uint1(x191))) + var x194 uint32 + var x195 uint32 + x194, x195 = bits.Add32(x123, x169, uint32(uint1(x193))) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Add32(x125, x171, uint32(uint1(x195))) + var x198 uint32 + var x199 uint32 + x198, x199 = bits.Add32(x127, x173, uint32(uint1(x197))) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Add32(x129, x175, uint32(uint1(x199))) + var x202 uint32 + var x203 uint32 + x202, x203 = bits.Add32(x131, x177, uint32(uint1(x201))) + var x204 uint32 + var x205 uint32 + x204, x205 = bits.Add32(x133, x179, uint32(uint1(x203))) + var x206 uint32 + var x207 uint32 + x206, x207 = bits.Add32(uint32(uint1(x134)), x181, uint32(uint1(x205))) + var x208 uint32 + _, x208 = bits.Mul32(x182, 0xe88fdc45) + var x210 uint32 + var x211 uint32 + x211, x210 = bits.Mul32(x208, 0xffffffff) + var x212 uint32 + var x213 uint32 + x213, x212 = bits.Mul32(x208, 0xffffffff) + var x214 uint32 + var x215 uint32 + x215, x214 = bits.Mul32(x208, 0xffffffff) + var x216 uint32 + var x217 uint32 + x217, x216 = bits.Mul32(x208, 0xffffffff) + var x218 uint32 + var x219 uint32 + x219, x218 = bits.Mul32(x208, 0xffffffff) + var x220 uint32 + var x221 uint32 + x221, x220 = bits.Mul32(x208, 0xffffffff) + var x222 uint32 + var x223 uint32 + x223, x222 = bits.Mul32(x208, 0xc7634d81) + var x224 uint32 + var x225 uint32 + x225, x224 = bits.Mul32(x208, 0xf4372ddf) + var x226 uint32 + var x227 uint32 + x227, x226 = bits.Mul32(x208, 0x581a0db2) + var x228 uint32 + var x229 uint32 + x229, x228 = bits.Mul32(x208, 0x48b0a77a) + var x230 uint32 + var x231 uint32 + x231, x230 = bits.Mul32(x208, 0xecec196a) + var x232 uint32 + var x233 uint32 + x233, x232 = bits.Mul32(x208, 0xccc52973) + var x234 uint32 + var x235 uint32 + x234, x235 = bits.Add32(x233, x230, uint32(0x0)) + var x236 uint32 + var x237 uint32 + x236, x237 = bits.Add32(x231, x228, uint32(uint1(x235))) + var x238 uint32 + var x239 uint32 + x238, x239 = bits.Add32(x229, x226, uint32(uint1(x237))) + var x240 uint32 + var x241 uint32 + x240, x241 = bits.Add32(x227, x224, uint32(uint1(x239))) + var x242 uint32 + var x243 uint32 + x242, x243 = bits.Add32(x225, x222, uint32(uint1(x241))) + var x244 uint32 + var x245 uint32 + x244, x245 = bits.Add32(x223, x220, uint32(uint1(x243))) + var x246 uint32 + var x247 uint32 + x246, x247 = bits.Add32(x221, x218, uint32(uint1(x245))) + var x248 uint32 + var x249 uint32 + x248, x249 = bits.Add32(x219, x216, uint32(uint1(x247))) + var x250 uint32 + var x251 uint32 + x250, x251 = bits.Add32(x217, x214, uint32(uint1(x249))) + var x252 uint32 + var x253 uint32 + x252, x253 = bits.Add32(x215, x212, uint32(uint1(x251))) + var x254 uint32 + var x255 uint32 + x254, x255 = bits.Add32(x213, x210, uint32(uint1(x253))) + x256 := (uint32(uint1(x255)) + x211) + var x258 uint32 + _, x258 = bits.Add32(x182, x232, uint32(0x0)) + var x259 uint32 + var x260 uint32 + x259, x260 = bits.Add32(x184, x234, uint32(uint1(x258))) + var x261 uint32 + var x262 uint32 + x261, x262 = bits.Add32(x186, x236, uint32(uint1(x260))) + var x263 uint32 + var x264 uint32 + x263, x264 = bits.Add32(x188, x238, uint32(uint1(x262))) + var x265 uint32 + var x266 uint32 + x265, x266 = bits.Add32(x190, x240, uint32(uint1(x264))) + var x267 uint32 + var x268 uint32 + x267, x268 = bits.Add32(x192, x242, uint32(uint1(x266))) + var x269 uint32 + var x270 uint32 + x269, x270 = bits.Add32(x194, x244, uint32(uint1(x268))) + var x271 uint32 + var x272 uint32 + x271, x272 = bits.Add32(x196, x246, uint32(uint1(x270))) + var x273 uint32 + var x274 uint32 + x273, x274 = bits.Add32(x198, x248, uint32(uint1(x272))) + var x275 uint32 + var x276 uint32 + x275, x276 = bits.Add32(x200, x250, uint32(uint1(x274))) + var x277 uint32 + var x278 uint32 + x277, x278 = bits.Add32(x202, x252, uint32(uint1(x276))) + var x279 uint32 + var x280 uint32 + x279, x280 = bits.Add32(x204, x254, uint32(uint1(x278))) + var x281 uint32 + var x282 uint32 + x281, x282 = bits.Add32(x206, x256, uint32(uint1(x280))) + x283 := (uint32(uint1(x282)) + uint32(uint1(x207))) + var x284 uint32 + var x285 uint32 + x285, x284 = bits.Mul32(x2, arg1[11]) + var x286 uint32 + var x287 uint32 + x287, x286 = bits.Mul32(x2, arg1[10]) + var x288 uint32 + var x289 uint32 + x289, x288 = bits.Mul32(x2, arg1[9]) + var x290 uint32 + var x291 uint32 + x291, x290 = bits.Mul32(x2, arg1[8]) + var x292 uint32 + var x293 uint32 + x293, x292 = bits.Mul32(x2, arg1[7]) + var x294 uint32 + var x295 uint32 + x295, x294 = bits.Mul32(x2, arg1[6]) + var x296 uint32 + var x297 uint32 + x297, x296 = bits.Mul32(x2, arg1[5]) + var x298 uint32 + var x299 uint32 + x299, x298 = bits.Mul32(x2, arg1[4]) + var x300 uint32 + var x301 uint32 + x301, x300 = bits.Mul32(x2, arg1[3]) + var x302 uint32 + var x303 uint32 + x303, x302 = bits.Mul32(x2, arg1[2]) + var x304 uint32 + var x305 uint32 + x305, x304 = bits.Mul32(x2, arg1[1]) + var x306 uint32 + var x307 uint32 + x307, x306 = bits.Mul32(x2, arg1[0]) + var x308 uint32 + var x309 uint32 + x308, x309 = bits.Add32(x307, x304, uint32(0x0)) + var x310 uint32 + var x311 uint32 + x310, x311 = bits.Add32(x305, x302, uint32(uint1(x309))) + var x312 uint32 + var x313 uint32 + x312, x313 = bits.Add32(x303, x300, uint32(uint1(x311))) + var x314 uint32 + var x315 uint32 + x314, x315 = bits.Add32(x301, x298, uint32(uint1(x313))) + var x316 uint32 + var x317 uint32 + x316, x317 = bits.Add32(x299, x296, uint32(uint1(x315))) + var x318 uint32 + var x319 uint32 + x318, x319 = bits.Add32(x297, x294, uint32(uint1(x317))) + var x320 uint32 + var x321 uint32 + x320, x321 = bits.Add32(x295, x292, uint32(uint1(x319))) + var x322 uint32 + var x323 uint32 + x322, x323 = bits.Add32(x293, x290, uint32(uint1(x321))) + var x324 uint32 + var x325 uint32 + x324, x325 = bits.Add32(x291, x288, uint32(uint1(x323))) + var x326 uint32 + var x327 uint32 + x326, x327 = bits.Add32(x289, x286, uint32(uint1(x325))) + var x328 uint32 + var x329 uint32 + x328, x329 = bits.Add32(x287, x284, uint32(uint1(x327))) + x330 := (uint32(uint1(x329)) + x285) + var x331 uint32 + var x332 uint32 + x331, x332 = bits.Add32(x259, x306, uint32(0x0)) + var x333 uint32 + var x334 uint32 + x333, x334 = bits.Add32(x261, x308, uint32(uint1(x332))) + var x335 uint32 + var x336 uint32 + x335, x336 = bits.Add32(x263, x310, uint32(uint1(x334))) + var x337 uint32 + var x338 uint32 + x337, x338 = bits.Add32(x265, x312, uint32(uint1(x336))) + var x339 uint32 + var x340 uint32 + x339, x340 = bits.Add32(x267, x314, uint32(uint1(x338))) + var x341 uint32 + var x342 uint32 + x341, x342 = bits.Add32(x269, x316, uint32(uint1(x340))) + var x343 uint32 + var x344 uint32 + x343, x344 = bits.Add32(x271, x318, uint32(uint1(x342))) + var x345 uint32 + var x346 uint32 + x345, x346 = bits.Add32(x273, x320, uint32(uint1(x344))) + var x347 uint32 + var x348 uint32 + x347, x348 = bits.Add32(x275, x322, uint32(uint1(x346))) + var x349 uint32 + var x350 uint32 + x349, x350 = bits.Add32(x277, x324, uint32(uint1(x348))) + var x351 uint32 + var x352 uint32 + x351, x352 = bits.Add32(x279, x326, uint32(uint1(x350))) + var x353 uint32 + var x354 uint32 + x353, x354 = bits.Add32(x281, x328, uint32(uint1(x352))) + var x355 uint32 + var x356 uint32 + x355, x356 = bits.Add32(x283, x330, uint32(uint1(x354))) + var x357 uint32 + _, x357 = bits.Mul32(x331, 0xe88fdc45) + var x359 uint32 + var x360 uint32 + x360, x359 = bits.Mul32(x357, 0xffffffff) + var x361 uint32 + var x362 uint32 + x362, x361 = bits.Mul32(x357, 0xffffffff) + var x363 uint32 + var x364 uint32 + x364, x363 = bits.Mul32(x357, 0xffffffff) + var x365 uint32 + var x366 uint32 + x366, x365 = bits.Mul32(x357, 0xffffffff) + var x367 uint32 + var x368 uint32 + x368, x367 = bits.Mul32(x357, 0xffffffff) + var x369 uint32 + var x370 uint32 + x370, x369 = bits.Mul32(x357, 0xffffffff) + var x371 uint32 + var x372 uint32 + x372, x371 = bits.Mul32(x357, 0xc7634d81) + var x373 uint32 + var x374 uint32 + x374, x373 = bits.Mul32(x357, 0xf4372ddf) + var x375 uint32 + var x376 uint32 + x376, x375 = bits.Mul32(x357, 0x581a0db2) + var x377 uint32 + var x378 uint32 + x378, x377 = bits.Mul32(x357, 0x48b0a77a) + var x379 uint32 + var x380 uint32 + x380, x379 = bits.Mul32(x357, 0xecec196a) + var x381 uint32 + var x382 uint32 + x382, x381 = bits.Mul32(x357, 0xccc52973) + var x383 uint32 + var x384 uint32 + x383, x384 = bits.Add32(x382, x379, uint32(0x0)) + var x385 uint32 + var x386 uint32 + x385, x386 = bits.Add32(x380, x377, uint32(uint1(x384))) + var x387 uint32 + var x388 uint32 + x387, x388 = bits.Add32(x378, x375, uint32(uint1(x386))) + var x389 uint32 + var x390 uint32 + x389, x390 = bits.Add32(x376, x373, uint32(uint1(x388))) + var x391 uint32 + var x392 uint32 + x391, x392 = bits.Add32(x374, x371, uint32(uint1(x390))) + var x393 uint32 + var x394 uint32 + x393, x394 = bits.Add32(x372, x369, uint32(uint1(x392))) + var x395 uint32 + var x396 uint32 + x395, x396 = bits.Add32(x370, x367, uint32(uint1(x394))) + var x397 uint32 + var x398 uint32 + x397, x398 = bits.Add32(x368, x365, uint32(uint1(x396))) + var x399 uint32 + var x400 uint32 + x399, x400 = bits.Add32(x366, x363, uint32(uint1(x398))) + var x401 uint32 + var x402 uint32 + x401, x402 = bits.Add32(x364, x361, uint32(uint1(x400))) + var x403 uint32 + var x404 uint32 + x403, x404 = bits.Add32(x362, x359, uint32(uint1(x402))) + x405 := (uint32(uint1(x404)) + x360) + var x407 uint32 + _, x407 = bits.Add32(x331, x381, uint32(0x0)) + var x408 uint32 + var x409 uint32 + x408, x409 = bits.Add32(x333, x383, uint32(uint1(x407))) + var x410 uint32 + var x411 uint32 + x410, x411 = bits.Add32(x335, x385, uint32(uint1(x409))) + var x412 uint32 + var x413 uint32 + x412, x413 = bits.Add32(x337, x387, uint32(uint1(x411))) + var x414 uint32 + var x415 uint32 + x414, x415 = bits.Add32(x339, x389, uint32(uint1(x413))) + var x416 uint32 + var x417 uint32 + x416, x417 = bits.Add32(x341, x391, uint32(uint1(x415))) + var x418 uint32 + var x419 uint32 + x418, x419 = bits.Add32(x343, x393, uint32(uint1(x417))) + var x420 uint32 + var x421 uint32 + x420, x421 = bits.Add32(x345, x395, uint32(uint1(x419))) + var x422 uint32 + var x423 uint32 + x422, x423 = bits.Add32(x347, x397, uint32(uint1(x421))) + var x424 uint32 + var x425 uint32 + x424, x425 = bits.Add32(x349, x399, uint32(uint1(x423))) + var x426 uint32 + var x427 uint32 + x426, x427 = bits.Add32(x351, x401, uint32(uint1(x425))) + var x428 uint32 + var x429 uint32 + x428, x429 = bits.Add32(x353, x403, uint32(uint1(x427))) + var x430 uint32 + var x431 uint32 + x430, x431 = bits.Add32(x355, x405, uint32(uint1(x429))) + x432 := (uint32(uint1(x431)) + uint32(uint1(x356))) + var x433 uint32 + var x434 uint32 + x434, x433 = bits.Mul32(x3, arg1[11]) + var x435 uint32 + var x436 uint32 + x436, x435 = bits.Mul32(x3, arg1[10]) + var x437 uint32 + var x438 uint32 + x438, x437 = bits.Mul32(x3, arg1[9]) + var x439 uint32 + var x440 uint32 + x440, x439 = bits.Mul32(x3, arg1[8]) + var x441 uint32 + var x442 uint32 + x442, x441 = bits.Mul32(x3, arg1[7]) + var x443 uint32 + var x444 uint32 + x444, x443 = bits.Mul32(x3, arg1[6]) + var x445 uint32 + var x446 uint32 + x446, x445 = bits.Mul32(x3, arg1[5]) + var x447 uint32 + var x448 uint32 + x448, x447 = bits.Mul32(x3, arg1[4]) + var x449 uint32 + var x450 uint32 + x450, x449 = bits.Mul32(x3, arg1[3]) + var x451 uint32 + var x452 uint32 + x452, x451 = bits.Mul32(x3, arg1[2]) + var x453 uint32 + var x454 uint32 + x454, x453 = bits.Mul32(x3, arg1[1]) + var x455 uint32 + var x456 uint32 + x456, x455 = bits.Mul32(x3, arg1[0]) + var x457 uint32 + var x458 uint32 + x457, x458 = bits.Add32(x456, x453, uint32(0x0)) + var x459 uint32 + var x460 uint32 + x459, x460 = bits.Add32(x454, x451, uint32(uint1(x458))) + var x461 uint32 + var x462 uint32 + x461, x462 = bits.Add32(x452, x449, uint32(uint1(x460))) + var x463 uint32 + var x464 uint32 + x463, x464 = bits.Add32(x450, x447, uint32(uint1(x462))) + var x465 uint32 + var x466 uint32 + x465, x466 = bits.Add32(x448, x445, uint32(uint1(x464))) + var x467 uint32 + var x468 uint32 + x467, x468 = bits.Add32(x446, x443, uint32(uint1(x466))) + var x469 uint32 + var x470 uint32 + x469, x470 = bits.Add32(x444, x441, uint32(uint1(x468))) + var x471 uint32 + var x472 uint32 + x471, x472 = bits.Add32(x442, x439, uint32(uint1(x470))) + var x473 uint32 + var x474 uint32 + x473, x474 = bits.Add32(x440, x437, uint32(uint1(x472))) + var x475 uint32 + var x476 uint32 + x475, x476 = bits.Add32(x438, x435, uint32(uint1(x474))) + var x477 uint32 + var x478 uint32 + x477, x478 = bits.Add32(x436, x433, uint32(uint1(x476))) + x479 := (uint32(uint1(x478)) + x434) + var x480 uint32 + var x481 uint32 + x480, x481 = bits.Add32(x408, x455, uint32(0x0)) + var x482 uint32 + var x483 uint32 + x482, x483 = bits.Add32(x410, x457, uint32(uint1(x481))) + var x484 uint32 + var x485 uint32 + x484, x485 = bits.Add32(x412, x459, uint32(uint1(x483))) + var x486 uint32 + var x487 uint32 + x486, x487 = bits.Add32(x414, x461, uint32(uint1(x485))) + var x488 uint32 + var x489 uint32 + x488, x489 = bits.Add32(x416, x463, uint32(uint1(x487))) + var x490 uint32 + var x491 uint32 + x490, x491 = bits.Add32(x418, x465, uint32(uint1(x489))) + var x492 uint32 + var x493 uint32 + x492, x493 = bits.Add32(x420, x467, uint32(uint1(x491))) + var x494 uint32 + var x495 uint32 + x494, x495 = bits.Add32(x422, x469, uint32(uint1(x493))) + var x496 uint32 + var x497 uint32 + x496, x497 = bits.Add32(x424, x471, uint32(uint1(x495))) + var x498 uint32 + var x499 uint32 + x498, x499 = bits.Add32(x426, x473, uint32(uint1(x497))) + var x500 uint32 + var x501 uint32 + x500, x501 = bits.Add32(x428, x475, uint32(uint1(x499))) + var x502 uint32 + var x503 uint32 + x502, x503 = bits.Add32(x430, x477, uint32(uint1(x501))) + var x504 uint32 + var x505 uint32 + x504, x505 = bits.Add32(x432, x479, uint32(uint1(x503))) + var x506 uint32 + _, x506 = bits.Mul32(x480, 0xe88fdc45) + var x508 uint32 + var x509 uint32 + x509, x508 = bits.Mul32(x506, 0xffffffff) + var x510 uint32 + var x511 uint32 + x511, x510 = bits.Mul32(x506, 0xffffffff) + var x512 uint32 + var x513 uint32 + x513, x512 = bits.Mul32(x506, 0xffffffff) + var x514 uint32 + var x515 uint32 + x515, x514 = bits.Mul32(x506, 0xffffffff) + var x516 uint32 + var x517 uint32 + x517, x516 = bits.Mul32(x506, 0xffffffff) + var x518 uint32 + var x519 uint32 + x519, x518 = bits.Mul32(x506, 0xffffffff) + var x520 uint32 + var x521 uint32 + x521, x520 = bits.Mul32(x506, 0xc7634d81) + var x522 uint32 + var x523 uint32 + x523, x522 = bits.Mul32(x506, 0xf4372ddf) + var x524 uint32 + var x525 uint32 + x525, x524 = bits.Mul32(x506, 0x581a0db2) + var x526 uint32 + var x527 uint32 + x527, x526 = bits.Mul32(x506, 0x48b0a77a) + var x528 uint32 + var x529 uint32 + x529, x528 = bits.Mul32(x506, 0xecec196a) + var x530 uint32 + var x531 uint32 + x531, x530 = bits.Mul32(x506, 0xccc52973) + var x532 uint32 + var x533 uint32 + x532, x533 = bits.Add32(x531, x528, uint32(0x0)) + var x534 uint32 + var x535 uint32 + x534, x535 = bits.Add32(x529, x526, uint32(uint1(x533))) + var x536 uint32 + var x537 uint32 + x536, x537 = bits.Add32(x527, x524, uint32(uint1(x535))) + var x538 uint32 + var x539 uint32 + x538, x539 = bits.Add32(x525, x522, uint32(uint1(x537))) + var x540 uint32 + var x541 uint32 + x540, x541 = bits.Add32(x523, x520, uint32(uint1(x539))) + var x542 uint32 + var x543 uint32 + x542, x543 = bits.Add32(x521, x518, uint32(uint1(x541))) + var x544 uint32 + var x545 uint32 + x544, x545 = bits.Add32(x519, x516, uint32(uint1(x543))) + var x546 uint32 + var x547 uint32 + x546, x547 = bits.Add32(x517, x514, uint32(uint1(x545))) + var x548 uint32 + var x549 uint32 + x548, x549 = bits.Add32(x515, x512, uint32(uint1(x547))) + var x550 uint32 + var x551 uint32 + x550, x551 = bits.Add32(x513, x510, uint32(uint1(x549))) + var x552 uint32 + var x553 uint32 + x552, x553 = bits.Add32(x511, x508, uint32(uint1(x551))) + x554 := (uint32(uint1(x553)) + x509) + var x556 uint32 + _, x556 = bits.Add32(x480, x530, uint32(0x0)) + var x557 uint32 + var x558 uint32 + x557, x558 = bits.Add32(x482, x532, uint32(uint1(x556))) + var x559 uint32 + var x560 uint32 + x559, x560 = bits.Add32(x484, x534, uint32(uint1(x558))) + var x561 uint32 + var x562 uint32 + x561, x562 = bits.Add32(x486, x536, uint32(uint1(x560))) + var x563 uint32 + var x564 uint32 + x563, x564 = bits.Add32(x488, x538, uint32(uint1(x562))) + var x565 uint32 + var x566 uint32 + x565, x566 = bits.Add32(x490, x540, uint32(uint1(x564))) + var x567 uint32 + var x568 uint32 + x567, x568 = bits.Add32(x492, x542, uint32(uint1(x566))) + var x569 uint32 + var x570 uint32 + x569, x570 = bits.Add32(x494, x544, uint32(uint1(x568))) + var x571 uint32 + var x572 uint32 + x571, x572 = bits.Add32(x496, x546, uint32(uint1(x570))) + var x573 uint32 + var x574 uint32 + x573, x574 = bits.Add32(x498, x548, uint32(uint1(x572))) + var x575 uint32 + var x576 uint32 + x575, x576 = bits.Add32(x500, x550, uint32(uint1(x574))) + var x577 uint32 + var x578 uint32 + x577, x578 = bits.Add32(x502, x552, uint32(uint1(x576))) + var x579 uint32 + var x580 uint32 + x579, x580 = bits.Add32(x504, x554, uint32(uint1(x578))) + x581 := (uint32(uint1(x580)) + uint32(uint1(x505))) + var x582 uint32 + var x583 uint32 + x583, x582 = bits.Mul32(x4, arg1[11]) + var x584 uint32 + var x585 uint32 + x585, x584 = bits.Mul32(x4, arg1[10]) + var x586 uint32 + var x587 uint32 + x587, x586 = bits.Mul32(x4, arg1[9]) + var x588 uint32 + var x589 uint32 + x589, x588 = bits.Mul32(x4, arg1[8]) + var x590 uint32 + var x591 uint32 + x591, x590 = bits.Mul32(x4, arg1[7]) + var x592 uint32 + var x593 uint32 + x593, x592 = bits.Mul32(x4, arg1[6]) + var x594 uint32 + var x595 uint32 + x595, x594 = bits.Mul32(x4, arg1[5]) + var x596 uint32 + var x597 uint32 + x597, x596 = bits.Mul32(x4, arg1[4]) + var x598 uint32 + var x599 uint32 + x599, x598 = bits.Mul32(x4, arg1[3]) + var x600 uint32 + var x601 uint32 + x601, x600 = bits.Mul32(x4, arg1[2]) + var x602 uint32 + var x603 uint32 + x603, x602 = bits.Mul32(x4, arg1[1]) + var x604 uint32 + var x605 uint32 + x605, x604 = bits.Mul32(x4, arg1[0]) + var x606 uint32 + var x607 uint32 + x606, x607 = bits.Add32(x605, x602, uint32(0x0)) + var x608 uint32 + var x609 uint32 + x608, x609 = bits.Add32(x603, x600, uint32(uint1(x607))) + var x610 uint32 + var x611 uint32 + x610, x611 = bits.Add32(x601, x598, uint32(uint1(x609))) + var x612 uint32 + var x613 uint32 + x612, x613 = bits.Add32(x599, x596, uint32(uint1(x611))) + var x614 uint32 + var x615 uint32 + x614, x615 = bits.Add32(x597, x594, uint32(uint1(x613))) + var x616 uint32 + var x617 uint32 + x616, x617 = bits.Add32(x595, x592, uint32(uint1(x615))) + var x618 uint32 + var x619 uint32 + x618, x619 = bits.Add32(x593, x590, uint32(uint1(x617))) + var x620 uint32 + var x621 uint32 + x620, x621 = bits.Add32(x591, x588, uint32(uint1(x619))) + var x622 uint32 + var x623 uint32 + x622, x623 = bits.Add32(x589, x586, uint32(uint1(x621))) + var x624 uint32 + var x625 uint32 + x624, x625 = bits.Add32(x587, x584, uint32(uint1(x623))) + var x626 uint32 + var x627 uint32 + x626, x627 = bits.Add32(x585, x582, uint32(uint1(x625))) + x628 := (uint32(uint1(x627)) + x583) + var x629 uint32 + var x630 uint32 + x629, x630 = bits.Add32(x557, x604, uint32(0x0)) + var x631 uint32 + var x632 uint32 + x631, x632 = bits.Add32(x559, x606, uint32(uint1(x630))) + var x633 uint32 + var x634 uint32 + x633, x634 = bits.Add32(x561, x608, uint32(uint1(x632))) + var x635 uint32 + var x636 uint32 + x635, x636 = bits.Add32(x563, x610, uint32(uint1(x634))) + var x637 uint32 + var x638 uint32 + x637, x638 = bits.Add32(x565, x612, uint32(uint1(x636))) + var x639 uint32 + var x640 uint32 + x639, x640 = bits.Add32(x567, x614, uint32(uint1(x638))) + var x641 uint32 + var x642 uint32 + x641, x642 = bits.Add32(x569, x616, uint32(uint1(x640))) + var x643 uint32 + var x644 uint32 + x643, x644 = bits.Add32(x571, x618, uint32(uint1(x642))) + var x645 uint32 + var x646 uint32 + x645, x646 = bits.Add32(x573, x620, uint32(uint1(x644))) + var x647 uint32 + var x648 uint32 + x647, x648 = bits.Add32(x575, x622, uint32(uint1(x646))) + var x649 uint32 + var x650 uint32 + x649, x650 = bits.Add32(x577, x624, uint32(uint1(x648))) + var x651 uint32 + var x652 uint32 + x651, x652 = bits.Add32(x579, x626, uint32(uint1(x650))) + var x653 uint32 + var x654 uint32 + x653, x654 = bits.Add32(x581, x628, uint32(uint1(x652))) + var x655 uint32 + _, x655 = bits.Mul32(x629, 0xe88fdc45) + var x657 uint32 + var x658 uint32 + x658, x657 = bits.Mul32(x655, 0xffffffff) + var x659 uint32 + var x660 uint32 + x660, x659 = bits.Mul32(x655, 0xffffffff) + var x661 uint32 + var x662 uint32 + x662, x661 = bits.Mul32(x655, 0xffffffff) + var x663 uint32 + var x664 uint32 + x664, x663 = bits.Mul32(x655, 0xffffffff) + var x665 uint32 + var x666 uint32 + x666, x665 = bits.Mul32(x655, 0xffffffff) + var x667 uint32 + var x668 uint32 + x668, x667 = bits.Mul32(x655, 0xffffffff) + var x669 uint32 + var x670 uint32 + x670, x669 = bits.Mul32(x655, 0xc7634d81) + var x671 uint32 + var x672 uint32 + x672, x671 = bits.Mul32(x655, 0xf4372ddf) + var x673 uint32 + var x674 uint32 + x674, x673 = bits.Mul32(x655, 0x581a0db2) + var x675 uint32 + var x676 uint32 + x676, x675 = bits.Mul32(x655, 0x48b0a77a) + var x677 uint32 + var x678 uint32 + x678, x677 = bits.Mul32(x655, 0xecec196a) + var x679 uint32 + var x680 uint32 + x680, x679 = bits.Mul32(x655, 0xccc52973) + var x681 uint32 + var x682 uint32 + x681, x682 = bits.Add32(x680, x677, uint32(0x0)) + var x683 uint32 + var x684 uint32 + x683, x684 = bits.Add32(x678, x675, uint32(uint1(x682))) + var x685 uint32 + var x686 uint32 + x685, x686 = bits.Add32(x676, x673, uint32(uint1(x684))) + var x687 uint32 + var x688 uint32 + x687, x688 = bits.Add32(x674, x671, uint32(uint1(x686))) + var x689 uint32 + var x690 uint32 + x689, x690 = bits.Add32(x672, x669, uint32(uint1(x688))) + var x691 uint32 + var x692 uint32 + x691, x692 = bits.Add32(x670, x667, uint32(uint1(x690))) + var x693 uint32 + var x694 uint32 + x693, x694 = bits.Add32(x668, x665, uint32(uint1(x692))) + var x695 uint32 + var x696 uint32 + x695, x696 = bits.Add32(x666, x663, uint32(uint1(x694))) + var x697 uint32 + var x698 uint32 + x697, x698 = bits.Add32(x664, x661, uint32(uint1(x696))) + var x699 uint32 + var x700 uint32 + x699, x700 = bits.Add32(x662, x659, uint32(uint1(x698))) + var x701 uint32 + var x702 uint32 + x701, x702 = bits.Add32(x660, x657, uint32(uint1(x700))) + x703 := (uint32(uint1(x702)) + x658) + var x705 uint32 + _, x705 = bits.Add32(x629, x679, uint32(0x0)) + var x706 uint32 + var x707 uint32 + x706, x707 = bits.Add32(x631, x681, uint32(uint1(x705))) + var x708 uint32 + var x709 uint32 + x708, x709 = bits.Add32(x633, x683, uint32(uint1(x707))) + var x710 uint32 + var x711 uint32 + x710, x711 = bits.Add32(x635, x685, uint32(uint1(x709))) + var x712 uint32 + var x713 uint32 + x712, x713 = bits.Add32(x637, x687, uint32(uint1(x711))) + var x714 uint32 + var x715 uint32 + x714, x715 = bits.Add32(x639, x689, uint32(uint1(x713))) + var x716 uint32 + var x717 uint32 + x716, x717 = bits.Add32(x641, x691, uint32(uint1(x715))) + var x718 uint32 + var x719 uint32 + x718, x719 = bits.Add32(x643, x693, uint32(uint1(x717))) + var x720 uint32 + var x721 uint32 + x720, x721 = bits.Add32(x645, x695, uint32(uint1(x719))) + var x722 uint32 + var x723 uint32 + x722, x723 = bits.Add32(x647, x697, uint32(uint1(x721))) + var x724 uint32 + var x725 uint32 + x724, x725 = bits.Add32(x649, x699, uint32(uint1(x723))) + var x726 uint32 + var x727 uint32 + x726, x727 = bits.Add32(x651, x701, uint32(uint1(x725))) + var x728 uint32 + var x729 uint32 + x728, x729 = bits.Add32(x653, x703, uint32(uint1(x727))) + x730 := (uint32(uint1(x729)) + uint32(uint1(x654))) + var x731 uint32 + var x732 uint32 + x732, x731 = bits.Mul32(x5, arg1[11]) + var x733 uint32 + var x734 uint32 + x734, x733 = bits.Mul32(x5, arg1[10]) + var x735 uint32 + var x736 uint32 + x736, x735 = bits.Mul32(x5, arg1[9]) + var x737 uint32 + var x738 uint32 + x738, x737 = bits.Mul32(x5, arg1[8]) + var x739 uint32 + var x740 uint32 + x740, x739 = bits.Mul32(x5, arg1[7]) + var x741 uint32 + var x742 uint32 + x742, x741 = bits.Mul32(x5, arg1[6]) + var x743 uint32 + var x744 uint32 + x744, x743 = bits.Mul32(x5, arg1[5]) + var x745 uint32 + var x746 uint32 + x746, x745 = bits.Mul32(x5, arg1[4]) + var x747 uint32 + var x748 uint32 + x748, x747 = bits.Mul32(x5, arg1[3]) + var x749 uint32 + var x750 uint32 + x750, x749 = bits.Mul32(x5, arg1[2]) + var x751 uint32 + var x752 uint32 + x752, x751 = bits.Mul32(x5, arg1[1]) + var x753 uint32 + var x754 uint32 + x754, x753 = bits.Mul32(x5, arg1[0]) + var x755 uint32 + var x756 uint32 + x755, x756 = bits.Add32(x754, x751, uint32(0x0)) + var x757 uint32 + var x758 uint32 + x757, x758 = bits.Add32(x752, x749, uint32(uint1(x756))) + var x759 uint32 + var x760 uint32 + x759, x760 = bits.Add32(x750, x747, uint32(uint1(x758))) + var x761 uint32 + var x762 uint32 + x761, x762 = bits.Add32(x748, x745, uint32(uint1(x760))) + var x763 uint32 + var x764 uint32 + x763, x764 = bits.Add32(x746, x743, uint32(uint1(x762))) + var x765 uint32 + var x766 uint32 + x765, x766 = bits.Add32(x744, x741, uint32(uint1(x764))) + var x767 uint32 + var x768 uint32 + x767, x768 = bits.Add32(x742, x739, uint32(uint1(x766))) + var x769 uint32 + var x770 uint32 + x769, x770 = bits.Add32(x740, x737, uint32(uint1(x768))) + var x771 uint32 + var x772 uint32 + x771, x772 = bits.Add32(x738, x735, uint32(uint1(x770))) + var x773 uint32 + var x774 uint32 + x773, x774 = bits.Add32(x736, x733, uint32(uint1(x772))) + var x775 uint32 + var x776 uint32 + x775, x776 = bits.Add32(x734, x731, uint32(uint1(x774))) + x777 := (uint32(uint1(x776)) + x732) + var x778 uint32 + var x779 uint32 + x778, x779 = bits.Add32(x706, x753, uint32(0x0)) + var x780 uint32 + var x781 uint32 + x780, x781 = bits.Add32(x708, x755, uint32(uint1(x779))) + var x782 uint32 + var x783 uint32 + x782, x783 = bits.Add32(x710, x757, uint32(uint1(x781))) + var x784 uint32 + var x785 uint32 + x784, x785 = bits.Add32(x712, x759, uint32(uint1(x783))) + var x786 uint32 + var x787 uint32 + x786, x787 = bits.Add32(x714, x761, uint32(uint1(x785))) + var x788 uint32 + var x789 uint32 + x788, x789 = bits.Add32(x716, x763, uint32(uint1(x787))) + var x790 uint32 + var x791 uint32 + x790, x791 = bits.Add32(x718, x765, uint32(uint1(x789))) + var x792 uint32 + var x793 uint32 + x792, x793 = bits.Add32(x720, x767, uint32(uint1(x791))) + var x794 uint32 + var x795 uint32 + x794, x795 = bits.Add32(x722, x769, uint32(uint1(x793))) + var x796 uint32 + var x797 uint32 + x796, x797 = bits.Add32(x724, x771, uint32(uint1(x795))) + var x798 uint32 + var x799 uint32 + x798, x799 = bits.Add32(x726, x773, uint32(uint1(x797))) + var x800 uint32 + var x801 uint32 + x800, x801 = bits.Add32(x728, x775, uint32(uint1(x799))) + var x802 uint32 + var x803 uint32 + x802, x803 = bits.Add32(x730, x777, uint32(uint1(x801))) + var x804 uint32 + _, x804 = bits.Mul32(x778, 0xe88fdc45) + var x806 uint32 + var x807 uint32 + x807, x806 = bits.Mul32(x804, 0xffffffff) + var x808 uint32 + var x809 uint32 + x809, x808 = bits.Mul32(x804, 0xffffffff) + var x810 uint32 + var x811 uint32 + x811, x810 = bits.Mul32(x804, 0xffffffff) + var x812 uint32 + var x813 uint32 + x813, x812 = bits.Mul32(x804, 0xffffffff) + var x814 uint32 + var x815 uint32 + x815, x814 = bits.Mul32(x804, 0xffffffff) + var x816 uint32 + var x817 uint32 + x817, x816 = bits.Mul32(x804, 0xffffffff) + var x818 uint32 + var x819 uint32 + x819, x818 = bits.Mul32(x804, 0xc7634d81) + var x820 uint32 + var x821 uint32 + x821, x820 = bits.Mul32(x804, 0xf4372ddf) + var x822 uint32 + var x823 uint32 + x823, x822 = bits.Mul32(x804, 0x581a0db2) + var x824 uint32 + var x825 uint32 + x825, x824 = bits.Mul32(x804, 0x48b0a77a) + var x826 uint32 + var x827 uint32 + x827, x826 = bits.Mul32(x804, 0xecec196a) + var x828 uint32 + var x829 uint32 + x829, x828 = bits.Mul32(x804, 0xccc52973) + var x830 uint32 + var x831 uint32 + x830, x831 = bits.Add32(x829, x826, uint32(0x0)) + var x832 uint32 + var x833 uint32 + x832, x833 = bits.Add32(x827, x824, uint32(uint1(x831))) + var x834 uint32 + var x835 uint32 + x834, x835 = bits.Add32(x825, x822, uint32(uint1(x833))) + var x836 uint32 + var x837 uint32 + x836, x837 = bits.Add32(x823, x820, uint32(uint1(x835))) + var x838 uint32 + var x839 uint32 + x838, x839 = bits.Add32(x821, x818, uint32(uint1(x837))) + var x840 uint32 + var x841 uint32 + x840, x841 = bits.Add32(x819, x816, uint32(uint1(x839))) + var x842 uint32 + var x843 uint32 + x842, x843 = bits.Add32(x817, x814, uint32(uint1(x841))) + var x844 uint32 + var x845 uint32 + x844, x845 = bits.Add32(x815, x812, uint32(uint1(x843))) + var x846 uint32 + var x847 uint32 + x846, x847 = bits.Add32(x813, x810, uint32(uint1(x845))) + var x848 uint32 + var x849 uint32 + x848, x849 = bits.Add32(x811, x808, uint32(uint1(x847))) + var x850 uint32 + var x851 uint32 + x850, x851 = bits.Add32(x809, x806, uint32(uint1(x849))) + x852 := (uint32(uint1(x851)) + x807) + var x854 uint32 + _, x854 = bits.Add32(x778, x828, uint32(0x0)) + var x855 uint32 + var x856 uint32 + x855, x856 = bits.Add32(x780, x830, uint32(uint1(x854))) + var x857 uint32 + var x858 uint32 + x857, x858 = bits.Add32(x782, x832, uint32(uint1(x856))) + var x859 uint32 + var x860 uint32 + x859, x860 = bits.Add32(x784, x834, uint32(uint1(x858))) + var x861 uint32 + var x862 uint32 + x861, x862 = bits.Add32(x786, x836, uint32(uint1(x860))) + var x863 uint32 + var x864 uint32 + x863, x864 = bits.Add32(x788, x838, uint32(uint1(x862))) + var x865 uint32 + var x866 uint32 + x865, x866 = bits.Add32(x790, x840, uint32(uint1(x864))) + var x867 uint32 + var x868 uint32 + x867, x868 = bits.Add32(x792, x842, uint32(uint1(x866))) + var x869 uint32 + var x870 uint32 + x869, x870 = bits.Add32(x794, x844, uint32(uint1(x868))) + var x871 uint32 + var x872 uint32 + x871, x872 = bits.Add32(x796, x846, uint32(uint1(x870))) + var x873 uint32 + var x874 uint32 + x873, x874 = bits.Add32(x798, x848, uint32(uint1(x872))) + var x875 uint32 + var x876 uint32 + x875, x876 = bits.Add32(x800, x850, uint32(uint1(x874))) + var x877 uint32 + var x878 uint32 + x877, x878 = bits.Add32(x802, x852, uint32(uint1(x876))) + x879 := (uint32(uint1(x878)) + uint32(uint1(x803))) + var x880 uint32 + var x881 uint32 + x881, x880 = bits.Mul32(x6, arg1[11]) + var x882 uint32 + var x883 uint32 + x883, x882 = bits.Mul32(x6, arg1[10]) + var x884 uint32 + var x885 uint32 + x885, x884 = bits.Mul32(x6, arg1[9]) + var x886 uint32 + var x887 uint32 + x887, x886 = bits.Mul32(x6, arg1[8]) + var x888 uint32 + var x889 uint32 + x889, x888 = bits.Mul32(x6, arg1[7]) + var x890 uint32 + var x891 uint32 + x891, x890 = bits.Mul32(x6, arg1[6]) + var x892 uint32 + var x893 uint32 + x893, x892 = bits.Mul32(x6, arg1[5]) + var x894 uint32 + var x895 uint32 + x895, x894 = bits.Mul32(x6, arg1[4]) + var x896 uint32 + var x897 uint32 + x897, x896 = bits.Mul32(x6, arg1[3]) + var x898 uint32 + var x899 uint32 + x899, x898 = bits.Mul32(x6, arg1[2]) + var x900 uint32 + var x901 uint32 + x901, x900 = bits.Mul32(x6, arg1[1]) + var x902 uint32 + var x903 uint32 + x903, x902 = bits.Mul32(x6, arg1[0]) + var x904 uint32 + var x905 uint32 + x904, x905 = bits.Add32(x903, x900, uint32(0x0)) + var x906 uint32 + var x907 uint32 + x906, x907 = bits.Add32(x901, x898, uint32(uint1(x905))) + var x908 uint32 + var x909 uint32 + x908, x909 = bits.Add32(x899, x896, uint32(uint1(x907))) + var x910 uint32 + var x911 uint32 + x910, x911 = bits.Add32(x897, x894, uint32(uint1(x909))) + var x912 uint32 + var x913 uint32 + x912, x913 = bits.Add32(x895, x892, uint32(uint1(x911))) + var x914 uint32 + var x915 uint32 + x914, x915 = bits.Add32(x893, x890, uint32(uint1(x913))) + var x916 uint32 + var x917 uint32 + x916, x917 = bits.Add32(x891, x888, uint32(uint1(x915))) + var x918 uint32 + var x919 uint32 + x918, x919 = bits.Add32(x889, x886, uint32(uint1(x917))) + var x920 uint32 + var x921 uint32 + x920, x921 = bits.Add32(x887, x884, uint32(uint1(x919))) + var x922 uint32 + var x923 uint32 + x922, x923 = bits.Add32(x885, x882, uint32(uint1(x921))) + var x924 uint32 + var x925 uint32 + x924, x925 = bits.Add32(x883, x880, uint32(uint1(x923))) + x926 := (uint32(uint1(x925)) + x881) + var x927 uint32 + var x928 uint32 + x927, x928 = bits.Add32(x855, x902, uint32(0x0)) + var x929 uint32 + var x930 uint32 + x929, x930 = bits.Add32(x857, x904, uint32(uint1(x928))) + var x931 uint32 + var x932 uint32 + x931, x932 = bits.Add32(x859, x906, uint32(uint1(x930))) + var x933 uint32 + var x934 uint32 + x933, x934 = bits.Add32(x861, x908, uint32(uint1(x932))) + var x935 uint32 + var x936 uint32 + x935, x936 = bits.Add32(x863, x910, uint32(uint1(x934))) + var x937 uint32 + var x938 uint32 + x937, x938 = bits.Add32(x865, x912, uint32(uint1(x936))) + var x939 uint32 + var x940 uint32 + x939, x940 = bits.Add32(x867, x914, uint32(uint1(x938))) + var x941 uint32 + var x942 uint32 + x941, x942 = bits.Add32(x869, x916, uint32(uint1(x940))) + var x943 uint32 + var x944 uint32 + x943, x944 = bits.Add32(x871, x918, uint32(uint1(x942))) + var x945 uint32 + var x946 uint32 + x945, x946 = bits.Add32(x873, x920, uint32(uint1(x944))) + var x947 uint32 + var x948 uint32 + x947, x948 = bits.Add32(x875, x922, uint32(uint1(x946))) + var x949 uint32 + var x950 uint32 + x949, x950 = bits.Add32(x877, x924, uint32(uint1(x948))) + var x951 uint32 + var x952 uint32 + x951, x952 = bits.Add32(x879, x926, uint32(uint1(x950))) + var x953 uint32 + _, x953 = bits.Mul32(x927, 0xe88fdc45) + var x955 uint32 + var x956 uint32 + x956, x955 = bits.Mul32(x953, 0xffffffff) + var x957 uint32 + var x958 uint32 + x958, x957 = bits.Mul32(x953, 0xffffffff) + var x959 uint32 + var x960 uint32 + x960, x959 = bits.Mul32(x953, 0xffffffff) + var x961 uint32 + var x962 uint32 + x962, x961 = bits.Mul32(x953, 0xffffffff) + var x963 uint32 + var x964 uint32 + x964, x963 = bits.Mul32(x953, 0xffffffff) + var x965 uint32 + var x966 uint32 + x966, x965 = bits.Mul32(x953, 0xffffffff) + var x967 uint32 + var x968 uint32 + x968, x967 = bits.Mul32(x953, 0xc7634d81) + var x969 uint32 + var x970 uint32 + x970, x969 = bits.Mul32(x953, 0xf4372ddf) + var x971 uint32 + var x972 uint32 + x972, x971 = bits.Mul32(x953, 0x581a0db2) + var x973 uint32 + var x974 uint32 + x974, x973 = bits.Mul32(x953, 0x48b0a77a) + var x975 uint32 + var x976 uint32 + x976, x975 = bits.Mul32(x953, 0xecec196a) + var x977 uint32 + var x978 uint32 + x978, x977 = bits.Mul32(x953, 0xccc52973) + var x979 uint32 + var x980 uint32 + x979, x980 = bits.Add32(x978, x975, uint32(0x0)) + var x981 uint32 + var x982 uint32 + x981, x982 = bits.Add32(x976, x973, uint32(uint1(x980))) + var x983 uint32 + var x984 uint32 + x983, x984 = bits.Add32(x974, x971, uint32(uint1(x982))) + var x985 uint32 + var x986 uint32 + x985, x986 = bits.Add32(x972, x969, uint32(uint1(x984))) + var x987 uint32 + var x988 uint32 + x987, x988 = bits.Add32(x970, x967, uint32(uint1(x986))) + var x989 uint32 + var x990 uint32 + x989, x990 = bits.Add32(x968, x965, uint32(uint1(x988))) + var x991 uint32 + var x992 uint32 + x991, x992 = bits.Add32(x966, x963, uint32(uint1(x990))) + var x993 uint32 + var x994 uint32 + x993, x994 = bits.Add32(x964, x961, uint32(uint1(x992))) + var x995 uint32 + var x996 uint32 + x995, x996 = bits.Add32(x962, x959, uint32(uint1(x994))) + var x997 uint32 + var x998 uint32 + x997, x998 = bits.Add32(x960, x957, uint32(uint1(x996))) + var x999 uint32 + var x1000 uint32 + x999, x1000 = bits.Add32(x958, x955, uint32(uint1(x998))) + x1001 := (uint32(uint1(x1000)) + x956) + var x1003 uint32 + _, x1003 = bits.Add32(x927, x977, uint32(0x0)) + var x1004 uint32 + var x1005 uint32 + x1004, x1005 = bits.Add32(x929, x979, uint32(uint1(x1003))) + var x1006 uint32 + var x1007 uint32 + x1006, x1007 = bits.Add32(x931, x981, uint32(uint1(x1005))) + var x1008 uint32 + var x1009 uint32 + x1008, x1009 = bits.Add32(x933, x983, uint32(uint1(x1007))) + var x1010 uint32 + var x1011 uint32 + x1010, x1011 = bits.Add32(x935, x985, uint32(uint1(x1009))) + var x1012 uint32 + var x1013 uint32 + x1012, x1013 = bits.Add32(x937, x987, uint32(uint1(x1011))) + var x1014 uint32 + var x1015 uint32 + x1014, x1015 = bits.Add32(x939, x989, uint32(uint1(x1013))) + var x1016 uint32 + var x1017 uint32 + x1016, x1017 = bits.Add32(x941, x991, uint32(uint1(x1015))) + var x1018 uint32 + var x1019 uint32 + x1018, x1019 = bits.Add32(x943, x993, uint32(uint1(x1017))) + var x1020 uint32 + var x1021 uint32 + x1020, x1021 = bits.Add32(x945, x995, uint32(uint1(x1019))) + var x1022 uint32 + var x1023 uint32 + x1022, x1023 = bits.Add32(x947, x997, uint32(uint1(x1021))) + var x1024 uint32 + var x1025 uint32 + x1024, x1025 = bits.Add32(x949, x999, uint32(uint1(x1023))) + var x1026 uint32 + var x1027 uint32 + x1026, x1027 = bits.Add32(x951, x1001, uint32(uint1(x1025))) + x1028 := (uint32(uint1(x1027)) + uint32(uint1(x952))) + var x1029 uint32 + var x1030 uint32 + x1030, x1029 = bits.Mul32(x7, arg1[11]) + var x1031 uint32 + var x1032 uint32 + x1032, x1031 = bits.Mul32(x7, arg1[10]) + var x1033 uint32 + var x1034 uint32 + x1034, x1033 = bits.Mul32(x7, arg1[9]) + var x1035 uint32 + var x1036 uint32 + x1036, x1035 = bits.Mul32(x7, arg1[8]) + var x1037 uint32 + var x1038 uint32 + x1038, x1037 = bits.Mul32(x7, arg1[7]) + var x1039 uint32 + var x1040 uint32 + x1040, x1039 = bits.Mul32(x7, arg1[6]) + var x1041 uint32 + var x1042 uint32 + x1042, x1041 = bits.Mul32(x7, arg1[5]) + var x1043 uint32 + var x1044 uint32 + x1044, x1043 = bits.Mul32(x7, arg1[4]) + var x1045 uint32 + var x1046 uint32 + x1046, x1045 = bits.Mul32(x7, arg1[3]) + var x1047 uint32 + var x1048 uint32 + x1048, x1047 = bits.Mul32(x7, arg1[2]) + var x1049 uint32 + var x1050 uint32 + x1050, x1049 = bits.Mul32(x7, arg1[1]) + var x1051 uint32 + var x1052 uint32 + x1052, x1051 = bits.Mul32(x7, arg1[0]) + var x1053 uint32 + var x1054 uint32 + x1053, x1054 = bits.Add32(x1052, x1049, uint32(0x0)) + var x1055 uint32 + var x1056 uint32 + x1055, x1056 = bits.Add32(x1050, x1047, uint32(uint1(x1054))) + var x1057 uint32 + var x1058 uint32 + x1057, x1058 = bits.Add32(x1048, x1045, uint32(uint1(x1056))) + var x1059 uint32 + var x1060 uint32 + x1059, x1060 = bits.Add32(x1046, x1043, uint32(uint1(x1058))) + var x1061 uint32 + var x1062 uint32 + x1061, x1062 = bits.Add32(x1044, x1041, uint32(uint1(x1060))) + var x1063 uint32 + var x1064 uint32 + x1063, x1064 = bits.Add32(x1042, x1039, uint32(uint1(x1062))) + var x1065 uint32 + var x1066 uint32 + x1065, x1066 = bits.Add32(x1040, x1037, uint32(uint1(x1064))) + var x1067 uint32 + var x1068 uint32 + x1067, x1068 = bits.Add32(x1038, x1035, uint32(uint1(x1066))) + var x1069 uint32 + var x1070 uint32 + x1069, x1070 = bits.Add32(x1036, x1033, uint32(uint1(x1068))) + var x1071 uint32 + var x1072 uint32 + x1071, x1072 = bits.Add32(x1034, x1031, uint32(uint1(x1070))) + var x1073 uint32 + var x1074 uint32 + x1073, x1074 = bits.Add32(x1032, x1029, uint32(uint1(x1072))) + x1075 := (uint32(uint1(x1074)) + x1030) + var x1076 uint32 + var x1077 uint32 + x1076, x1077 = bits.Add32(x1004, x1051, uint32(0x0)) + var x1078 uint32 + var x1079 uint32 + x1078, x1079 = bits.Add32(x1006, x1053, uint32(uint1(x1077))) + var x1080 uint32 + var x1081 uint32 + x1080, x1081 = bits.Add32(x1008, x1055, uint32(uint1(x1079))) + var x1082 uint32 + var x1083 uint32 + x1082, x1083 = bits.Add32(x1010, x1057, uint32(uint1(x1081))) + var x1084 uint32 + var x1085 uint32 + x1084, x1085 = bits.Add32(x1012, x1059, uint32(uint1(x1083))) + var x1086 uint32 + var x1087 uint32 + x1086, x1087 = bits.Add32(x1014, x1061, uint32(uint1(x1085))) + var x1088 uint32 + var x1089 uint32 + x1088, x1089 = bits.Add32(x1016, x1063, uint32(uint1(x1087))) + var x1090 uint32 + var x1091 uint32 + x1090, x1091 = bits.Add32(x1018, x1065, uint32(uint1(x1089))) + var x1092 uint32 + var x1093 uint32 + x1092, x1093 = bits.Add32(x1020, x1067, uint32(uint1(x1091))) + var x1094 uint32 + var x1095 uint32 + x1094, x1095 = bits.Add32(x1022, x1069, uint32(uint1(x1093))) + var x1096 uint32 + var x1097 uint32 + x1096, x1097 = bits.Add32(x1024, x1071, uint32(uint1(x1095))) + var x1098 uint32 + var x1099 uint32 + x1098, x1099 = bits.Add32(x1026, x1073, uint32(uint1(x1097))) + var x1100 uint32 + var x1101 uint32 + x1100, x1101 = bits.Add32(x1028, x1075, uint32(uint1(x1099))) + var x1102 uint32 + _, x1102 = bits.Mul32(x1076, 0xe88fdc45) + var x1104 uint32 + var x1105 uint32 + x1105, x1104 = bits.Mul32(x1102, 0xffffffff) + var x1106 uint32 + var x1107 uint32 + x1107, x1106 = bits.Mul32(x1102, 0xffffffff) + var x1108 uint32 + var x1109 uint32 + x1109, x1108 = bits.Mul32(x1102, 0xffffffff) + var x1110 uint32 + var x1111 uint32 + x1111, x1110 = bits.Mul32(x1102, 0xffffffff) + var x1112 uint32 + var x1113 uint32 + x1113, x1112 = bits.Mul32(x1102, 0xffffffff) + var x1114 uint32 + var x1115 uint32 + x1115, x1114 = bits.Mul32(x1102, 0xffffffff) + var x1116 uint32 + var x1117 uint32 + x1117, x1116 = bits.Mul32(x1102, 0xc7634d81) + var x1118 uint32 + var x1119 uint32 + x1119, x1118 = bits.Mul32(x1102, 0xf4372ddf) + var x1120 uint32 + var x1121 uint32 + x1121, x1120 = bits.Mul32(x1102, 0x581a0db2) + var x1122 uint32 + var x1123 uint32 + x1123, x1122 = bits.Mul32(x1102, 0x48b0a77a) + var x1124 uint32 + var x1125 uint32 + x1125, x1124 = bits.Mul32(x1102, 0xecec196a) + var x1126 uint32 + var x1127 uint32 + x1127, x1126 = bits.Mul32(x1102, 0xccc52973) + var x1128 uint32 + var x1129 uint32 + x1128, x1129 = bits.Add32(x1127, x1124, uint32(0x0)) + var x1130 uint32 + var x1131 uint32 + x1130, x1131 = bits.Add32(x1125, x1122, uint32(uint1(x1129))) + var x1132 uint32 + var x1133 uint32 + x1132, x1133 = bits.Add32(x1123, x1120, uint32(uint1(x1131))) + var x1134 uint32 + var x1135 uint32 + x1134, x1135 = bits.Add32(x1121, x1118, uint32(uint1(x1133))) + var x1136 uint32 + var x1137 uint32 + x1136, x1137 = bits.Add32(x1119, x1116, uint32(uint1(x1135))) + var x1138 uint32 + var x1139 uint32 + x1138, x1139 = bits.Add32(x1117, x1114, uint32(uint1(x1137))) + var x1140 uint32 + var x1141 uint32 + x1140, x1141 = bits.Add32(x1115, x1112, uint32(uint1(x1139))) + var x1142 uint32 + var x1143 uint32 + x1142, x1143 = bits.Add32(x1113, x1110, uint32(uint1(x1141))) + var x1144 uint32 + var x1145 uint32 + x1144, x1145 = bits.Add32(x1111, x1108, uint32(uint1(x1143))) + var x1146 uint32 + var x1147 uint32 + x1146, x1147 = bits.Add32(x1109, x1106, uint32(uint1(x1145))) + var x1148 uint32 + var x1149 uint32 + x1148, x1149 = bits.Add32(x1107, x1104, uint32(uint1(x1147))) + x1150 := (uint32(uint1(x1149)) + x1105) + var x1152 uint32 + _, x1152 = bits.Add32(x1076, x1126, uint32(0x0)) + var x1153 uint32 + var x1154 uint32 + x1153, x1154 = bits.Add32(x1078, x1128, uint32(uint1(x1152))) + var x1155 uint32 + var x1156 uint32 + x1155, x1156 = bits.Add32(x1080, x1130, uint32(uint1(x1154))) + var x1157 uint32 + var x1158 uint32 + x1157, x1158 = bits.Add32(x1082, x1132, uint32(uint1(x1156))) + var x1159 uint32 + var x1160 uint32 + x1159, x1160 = bits.Add32(x1084, x1134, uint32(uint1(x1158))) + var x1161 uint32 + var x1162 uint32 + x1161, x1162 = bits.Add32(x1086, x1136, uint32(uint1(x1160))) + var x1163 uint32 + var x1164 uint32 + x1163, x1164 = bits.Add32(x1088, x1138, uint32(uint1(x1162))) + var x1165 uint32 + var x1166 uint32 + x1165, x1166 = bits.Add32(x1090, x1140, uint32(uint1(x1164))) + var x1167 uint32 + var x1168 uint32 + x1167, x1168 = bits.Add32(x1092, x1142, uint32(uint1(x1166))) + var x1169 uint32 + var x1170 uint32 + x1169, x1170 = bits.Add32(x1094, x1144, uint32(uint1(x1168))) + var x1171 uint32 + var x1172 uint32 + x1171, x1172 = bits.Add32(x1096, x1146, uint32(uint1(x1170))) + var x1173 uint32 + var x1174 uint32 + x1173, x1174 = bits.Add32(x1098, x1148, uint32(uint1(x1172))) + var x1175 uint32 + var x1176 uint32 + x1175, x1176 = bits.Add32(x1100, x1150, uint32(uint1(x1174))) + x1177 := (uint32(uint1(x1176)) + uint32(uint1(x1101))) + var x1178 uint32 + var x1179 uint32 + x1179, x1178 = bits.Mul32(x8, arg1[11]) + var x1180 uint32 + var x1181 uint32 + x1181, x1180 = bits.Mul32(x8, arg1[10]) + var x1182 uint32 + var x1183 uint32 + x1183, x1182 = bits.Mul32(x8, arg1[9]) + var x1184 uint32 + var x1185 uint32 + x1185, x1184 = bits.Mul32(x8, arg1[8]) + var x1186 uint32 + var x1187 uint32 + x1187, x1186 = bits.Mul32(x8, arg1[7]) + var x1188 uint32 + var x1189 uint32 + x1189, x1188 = bits.Mul32(x8, arg1[6]) + var x1190 uint32 + var x1191 uint32 + x1191, x1190 = bits.Mul32(x8, arg1[5]) + var x1192 uint32 + var x1193 uint32 + x1193, x1192 = bits.Mul32(x8, arg1[4]) + var x1194 uint32 + var x1195 uint32 + x1195, x1194 = bits.Mul32(x8, arg1[3]) + var x1196 uint32 + var x1197 uint32 + x1197, x1196 = bits.Mul32(x8, arg1[2]) + var x1198 uint32 + var x1199 uint32 + x1199, x1198 = bits.Mul32(x8, arg1[1]) + var x1200 uint32 + var x1201 uint32 + x1201, x1200 = bits.Mul32(x8, arg1[0]) + var x1202 uint32 + var x1203 uint32 + x1202, x1203 = bits.Add32(x1201, x1198, uint32(0x0)) + var x1204 uint32 + var x1205 uint32 + x1204, x1205 = bits.Add32(x1199, x1196, uint32(uint1(x1203))) + var x1206 uint32 + var x1207 uint32 + x1206, x1207 = bits.Add32(x1197, x1194, uint32(uint1(x1205))) + var x1208 uint32 + var x1209 uint32 + x1208, x1209 = bits.Add32(x1195, x1192, uint32(uint1(x1207))) + var x1210 uint32 + var x1211 uint32 + x1210, x1211 = bits.Add32(x1193, x1190, uint32(uint1(x1209))) + var x1212 uint32 + var x1213 uint32 + x1212, x1213 = bits.Add32(x1191, x1188, uint32(uint1(x1211))) + var x1214 uint32 + var x1215 uint32 + x1214, x1215 = bits.Add32(x1189, x1186, uint32(uint1(x1213))) + var x1216 uint32 + var x1217 uint32 + x1216, x1217 = bits.Add32(x1187, x1184, uint32(uint1(x1215))) + var x1218 uint32 + var x1219 uint32 + x1218, x1219 = bits.Add32(x1185, x1182, uint32(uint1(x1217))) + var x1220 uint32 + var x1221 uint32 + x1220, x1221 = bits.Add32(x1183, x1180, uint32(uint1(x1219))) + var x1222 uint32 + var x1223 uint32 + x1222, x1223 = bits.Add32(x1181, x1178, uint32(uint1(x1221))) + x1224 := (uint32(uint1(x1223)) + x1179) + var x1225 uint32 + var x1226 uint32 + x1225, x1226 = bits.Add32(x1153, x1200, uint32(0x0)) + var x1227 uint32 + var x1228 uint32 + x1227, x1228 = bits.Add32(x1155, x1202, uint32(uint1(x1226))) + var x1229 uint32 + var x1230 uint32 + x1229, x1230 = bits.Add32(x1157, x1204, uint32(uint1(x1228))) + var x1231 uint32 + var x1232 uint32 + x1231, x1232 = bits.Add32(x1159, x1206, uint32(uint1(x1230))) + var x1233 uint32 + var x1234 uint32 + x1233, x1234 = bits.Add32(x1161, x1208, uint32(uint1(x1232))) + var x1235 uint32 + var x1236 uint32 + x1235, x1236 = bits.Add32(x1163, x1210, uint32(uint1(x1234))) + var x1237 uint32 + var x1238 uint32 + x1237, x1238 = bits.Add32(x1165, x1212, uint32(uint1(x1236))) + var x1239 uint32 + var x1240 uint32 + x1239, x1240 = bits.Add32(x1167, x1214, uint32(uint1(x1238))) + var x1241 uint32 + var x1242 uint32 + x1241, x1242 = bits.Add32(x1169, x1216, uint32(uint1(x1240))) + var x1243 uint32 + var x1244 uint32 + x1243, x1244 = bits.Add32(x1171, x1218, uint32(uint1(x1242))) + var x1245 uint32 + var x1246 uint32 + x1245, x1246 = bits.Add32(x1173, x1220, uint32(uint1(x1244))) + var x1247 uint32 + var x1248 uint32 + x1247, x1248 = bits.Add32(x1175, x1222, uint32(uint1(x1246))) + var x1249 uint32 + var x1250 uint32 + x1249, x1250 = bits.Add32(x1177, x1224, uint32(uint1(x1248))) + var x1251 uint32 + _, x1251 = bits.Mul32(x1225, 0xe88fdc45) + var x1253 uint32 + var x1254 uint32 + x1254, x1253 = bits.Mul32(x1251, 0xffffffff) + var x1255 uint32 + var x1256 uint32 + x1256, x1255 = bits.Mul32(x1251, 0xffffffff) + var x1257 uint32 + var x1258 uint32 + x1258, x1257 = bits.Mul32(x1251, 0xffffffff) + var x1259 uint32 + var x1260 uint32 + x1260, x1259 = bits.Mul32(x1251, 0xffffffff) + var x1261 uint32 + var x1262 uint32 + x1262, x1261 = bits.Mul32(x1251, 0xffffffff) + var x1263 uint32 + var x1264 uint32 + x1264, x1263 = bits.Mul32(x1251, 0xffffffff) + var x1265 uint32 + var x1266 uint32 + x1266, x1265 = bits.Mul32(x1251, 0xc7634d81) + var x1267 uint32 + var x1268 uint32 + x1268, x1267 = bits.Mul32(x1251, 0xf4372ddf) + var x1269 uint32 + var x1270 uint32 + x1270, x1269 = bits.Mul32(x1251, 0x581a0db2) + var x1271 uint32 + var x1272 uint32 + x1272, x1271 = bits.Mul32(x1251, 0x48b0a77a) + var x1273 uint32 + var x1274 uint32 + x1274, x1273 = bits.Mul32(x1251, 0xecec196a) + var x1275 uint32 + var x1276 uint32 + x1276, x1275 = bits.Mul32(x1251, 0xccc52973) + var x1277 uint32 + var x1278 uint32 + x1277, x1278 = bits.Add32(x1276, x1273, uint32(0x0)) + var x1279 uint32 + var x1280 uint32 + x1279, x1280 = bits.Add32(x1274, x1271, uint32(uint1(x1278))) + var x1281 uint32 + var x1282 uint32 + x1281, x1282 = bits.Add32(x1272, x1269, uint32(uint1(x1280))) + var x1283 uint32 + var x1284 uint32 + x1283, x1284 = bits.Add32(x1270, x1267, uint32(uint1(x1282))) + var x1285 uint32 + var x1286 uint32 + x1285, x1286 = bits.Add32(x1268, x1265, uint32(uint1(x1284))) + var x1287 uint32 + var x1288 uint32 + x1287, x1288 = bits.Add32(x1266, x1263, uint32(uint1(x1286))) + var x1289 uint32 + var x1290 uint32 + x1289, x1290 = bits.Add32(x1264, x1261, uint32(uint1(x1288))) + var x1291 uint32 + var x1292 uint32 + x1291, x1292 = bits.Add32(x1262, x1259, uint32(uint1(x1290))) + var x1293 uint32 + var x1294 uint32 + x1293, x1294 = bits.Add32(x1260, x1257, uint32(uint1(x1292))) + var x1295 uint32 + var x1296 uint32 + x1295, x1296 = bits.Add32(x1258, x1255, uint32(uint1(x1294))) + var x1297 uint32 + var x1298 uint32 + x1297, x1298 = bits.Add32(x1256, x1253, uint32(uint1(x1296))) + x1299 := (uint32(uint1(x1298)) + x1254) + var x1301 uint32 + _, x1301 = bits.Add32(x1225, x1275, uint32(0x0)) + var x1302 uint32 + var x1303 uint32 + x1302, x1303 = bits.Add32(x1227, x1277, uint32(uint1(x1301))) + var x1304 uint32 + var x1305 uint32 + x1304, x1305 = bits.Add32(x1229, x1279, uint32(uint1(x1303))) + var x1306 uint32 + var x1307 uint32 + x1306, x1307 = bits.Add32(x1231, x1281, uint32(uint1(x1305))) + var x1308 uint32 + var x1309 uint32 + x1308, x1309 = bits.Add32(x1233, x1283, uint32(uint1(x1307))) + var x1310 uint32 + var x1311 uint32 + x1310, x1311 = bits.Add32(x1235, x1285, uint32(uint1(x1309))) + var x1312 uint32 + var x1313 uint32 + x1312, x1313 = bits.Add32(x1237, x1287, uint32(uint1(x1311))) + var x1314 uint32 + var x1315 uint32 + x1314, x1315 = bits.Add32(x1239, x1289, uint32(uint1(x1313))) + var x1316 uint32 + var x1317 uint32 + x1316, x1317 = bits.Add32(x1241, x1291, uint32(uint1(x1315))) + var x1318 uint32 + var x1319 uint32 + x1318, x1319 = bits.Add32(x1243, x1293, uint32(uint1(x1317))) + var x1320 uint32 + var x1321 uint32 + x1320, x1321 = bits.Add32(x1245, x1295, uint32(uint1(x1319))) + var x1322 uint32 + var x1323 uint32 + x1322, x1323 = bits.Add32(x1247, x1297, uint32(uint1(x1321))) + var x1324 uint32 + var x1325 uint32 + x1324, x1325 = bits.Add32(x1249, x1299, uint32(uint1(x1323))) + x1326 := (uint32(uint1(x1325)) + uint32(uint1(x1250))) + var x1327 uint32 + var x1328 uint32 + x1328, x1327 = bits.Mul32(x9, arg1[11]) + var x1329 uint32 + var x1330 uint32 + x1330, x1329 = bits.Mul32(x9, arg1[10]) + var x1331 uint32 + var x1332 uint32 + x1332, x1331 = bits.Mul32(x9, arg1[9]) + var x1333 uint32 + var x1334 uint32 + x1334, x1333 = bits.Mul32(x9, arg1[8]) + var x1335 uint32 + var x1336 uint32 + x1336, x1335 = bits.Mul32(x9, arg1[7]) + var x1337 uint32 + var x1338 uint32 + x1338, x1337 = bits.Mul32(x9, arg1[6]) + var x1339 uint32 + var x1340 uint32 + x1340, x1339 = bits.Mul32(x9, arg1[5]) + var x1341 uint32 + var x1342 uint32 + x1342, x1341 = bits.Mul32(x9, arg1[4]) + var x1343 uint32 + var x1344 uint32 + x1344, x1343 = bits.Mul32(x9, arg1[3]) + var x1345 uint32 + var x1346 uint32 + x1346, x1345 = bits.Mul32(x9, arg1[2]) + var x1347 uint32 + var x1348 uint32 + x1348, x1347 = bits.Mul32(x9, arg1[1]) + var x1349 uint32 + var x1350 uint32 + x1350, x1349 = bits.Mul32(x9, arg1[0]) + var x1351 uint32 + var x1352 uint32 + x1351, x1352 = bits.Add32(x1350, x1347, uint32(0x0)) + var x1353 uint32 + var x1354 uint32 + x1353, x1354 = bits.Add32(x1348, x1345, uint32(uint1(x1352))) + var x1355 uint32 + var x1356 uint32 + x1355, x1356 = bits.Add32(x1346, x1343, uint32(uint1(x1354))) + var x1357 uint32 + var x1358 uint32 + x1357, x1358 = bits.Add32(x1344, x1341, uint32(uint1(x1356))) + var x1359 uint32 + var x1360 uint32 + x1359, x1360 = bits.Add32(x1342, x1339, uint32(uint1(x1358))) + var x1361 uint32 + var x1362 uint32 + x1361, x1362 = bits.Add32(x1340, x1337, uint32(uint1(x1360))) + var x1363 uint32 + var x1364 uint32 + x1363, x1364 = bits.Add32(x1338, x1335, uint32(uint1(x1362))) + var x1365 uint32 + var x1366 uint32 + x1365, x1366 = bits.Add32(x1336, x1333, uint32(uint1(x1364))) + var x1367 uint32 + var x1368 uint32 + x1367, x1368 = bits.Add32(x1334, x1331, uint32(uint1(x1366))) + var x1369 uint32 + var x1370 uint32 + x1369, x1370 = bits.Add32(x1332, x1329, uint32(uint1(x1368))) + var x1371 uint32 + var x1372 uint32 + x1371, x1372 = bits.Add32(x1330, x1327, uint32(uint1(x1370))) + x1373 := (uint32(uint1(x1372)) + x1328) + var x1374 uint32 + var x1375 uint32 + x1374, x1375 = bits.Add32(x1302, x1349, uint32(0x0)) + var x1376 uint32 + var x1377 uint32 + x1376, x1377 = bits.Add32(x1304, x1351, uint32(uint1(x1375))) + var x1378 uint32 + var x1379 uint32 + x1378, x1379 = bits.Add32(x1306, x1353, uint32(uint1(x1377))) + var x1380 uint32 + var x1381 uint32 + x1380, x1381 = bits.Add32(x1308, x1355, uint32(uint1(x1379))) + var x1382 uint32 + var x1383 uint32 + x1382, x1383 = bits.Add32(x1310, x1357, uint32(uint1(x1381))) + var x1384 uint32 + var x1385 uint32 + x1384, x1385 = bits.Add32(x1312, x1359, uint32(uint1(x1383))) + var x1386 uint32 + var x1387 uint32 + x1386, x1387 = bits.Add32(x1314, x1361, uint32(uint1(x1385))) + var x1388 uint32 + var x1389 uint32 + x1388, x1389 = bits.Add32(x1316, x1363, uint32(uint1(x1387))) + var x1390 uint32 + var x1391 uint32 + x1390, x1391 = bits.Add32(x1318, x1365, uint32(uint1(x1389))) + var x1392 uint32 + var x1393 uint32 + x1392, x1393 = bits.Add32(x1320, x1367, uint32(uint1(x1391))) + var x1394 uint32 + var x1395 uint32 + x1394, x1395 = bits.Add32(x1322, x1369, uint32(uint1(x1393))) + var x1396 uint32 + var x1397 uint32 + x1396, x1397 = bits.Add32(x1324, x1371, uint32(uint1(x1395))) + var x1398 uint32 + var x1399 uint32 + x1398, x1399 = bits.Add32(x1326, x1373, uint32(uint1(x1397))) + var x1400 uint32 + _, x1400 = bits.Mul32(x1374, 0xe88fdc45) + var x1402 uint32 + var x1403 uint32 + x1403, x1402 = bits.Mul32(x1400, 0xffffffff) + var x1404 uint32 + var x1405 uint32 + x1405, x1404 = bits.Mul32(x1400, 0xffffffff) + var x1406 uint32 + var x1407 uint32 + x1407, x1406 = bits.Mul32(x1400, 0xffffffff) + var x1408 uint32 + var x1409 uint32 + x1409, x1408 = bits.Mul32(x1400, 0xffffffff) + var x1410 uint32 + var x1411 uint32 + x1411, x1410 = bits.Mul32(x1400, 0xffffffff) + var x1412 uint32 + var x1413 uint32 + x1413, x1412 = bits.Mul32(x1400, 0xffffffff) + var x1414 uint32 + var x1415 uint32 + x1415, x1414 = bits.Mul32(x1400, 0xc7634d81) + var x1416 uint32 + var x1417 uint32 + x1417, x1416 = bits.Mul32(x1400, 0xf4372ddf) + var x1418 uint32 + var x1419 uint32 + x1419, x1418 = bits.Mul32(x1400, 0x581a0db2) + var x1420 uint32 + var x1421 uint32 + x1421, x1420 = bits.Mul32(x1400, 0x48b0a77a) + var x1422 uint32 + var x1423 uint32 + x1423, x1422 = bits.Mul32(x1400, 0xecec196a) + var x1424 uint32 + var x1425 uint32 + x1425, x1424 = bits.Mul32(x1400, 0xccc52973) + var x1426 uint32 + var x1427 uint32 + x1426, x1427 = bits.Add32(x1425, x1422, uint32(0x0)) + var x1428 uint32 + var x1429 uint32 + x1428, x1429 = bits.Add32(x1423, x1420, uint32(uint1(x1427))) + var x1430 uint32 + var x1431 uint32 + x1430, x1431 = bits.Add32(x1421, x1418, uint32(uint1(x1429))) + var x1432 uint32 + var x1433 uint32 + x1432, x1433 = bits.Add32(x1419, x1416, uint32(uint1(x1431))) + var x1434 uint32 + var x1435 uint32 + x1434, x1435 = bits.Add32(x1417, x1414, uint32(uint1(x1433))) + var x1436 uint32 + var x1437 uint32 + x1436, x1437 = bits.Add32(x1415, x1412, uint32(uint1(x1435))) + var x1438 uint32 + var x1439 uint32 + x1438, x1439 = bits.Add32(x1413, x1410, uint32(uint1(x1437))) + var x1440 uint32 + var x1441 uint32 + x1440, x1441 = bits.Add32(x1411, x1408, uint32(uint1(x1439))) + var x1442 uint32 + var x1443 uint32 + x1442, x1443 = bits.Add32(x1409, x1406, uint32(uint1(x1441))) + var x1444 uint32 + var x1445 uint32 + x1444, x1445 = bits.Add32(x1407, x1404, uint32(uint1(x1443))) + var x1446 uint32 + var x1447 uint32 + x1446, x1447 = bits.Add32(x1405, x1402, uint32(uint1(x1445))) + x1448 := (uint32(uint1(x1447)) + x1403) + var x1450 uint32 + _, x1450 = bits.Add32(x1374, x1424, uint32(0x0)) + var x1451 uint32 + var x1452 uint32 + x1451, x1452 = bits.Add32(x1376, x1426, uint32(uint1(x1450))) + var x1453 uint32 + var x1454 uint32 + x1453, x1454 = bits.Add32(x1378, x1428, uint32(uint1(x1452))) + var x1455 uint32 + var x1456 uint32 + x1455, x1456 = bits.Add32(x1380, x1430, uint32(uint1(x1454))) + var x1457 uint32 + var x1458 uint32 + x1457, x1458 = bits.Add32(x1382, x1432, uint32(uint1(x1456))) + var x1459 uint32 + var x1460 uint32 + x1459, x1460 = bits.Add32(x1384, x1434, uint32(uint1(x1458))) + var x1461 uint32 + var x1462 uint32 + x1461, x1462 = bits.Add32(x1386, x1436, uint32(uint1(x1460))) + var x1463 uint32 + var x1464 uint32 + x1463, x1464 = bits.Add32(x1388, x1438, uint32(uint1(x1462))) + var x1465 uint32 + var x1466 uint32 + x1465, x1466 = bits.Add32(x1390, x1440, uint32(uint1(x1464))) + var x1467 uint32 + var x1468 uint32 + x1467, x1468 = bits.Add32(x1392, x1442, uint32(uint1(x1466))) + var x1469 uint32 + var x1470 uint32 + x1469, x1470 = bits.Add32(x1394, x1444, uint32(uint1(x1468))) + var x1471 uint32 + var x1472 uint32 + x1471, x1472 = bits.Add32(x1396, x1446, uint32(uint1(x1470))) + var x1473 uint32 + var x1474 uint32 + x1473, x1474 = bits.Add32(x1398, x1448, uint32(uint1(x1472))) + x1475 := (uint32(uint1(x1474)) + uint32(uint1(x1399))) + var x1476 uint32 + var x1477 uint32 + x1477, x1476 = bits.Mul32(x10, arg1[11]) + var x1478 uint32 + var x1479 uint32 + x1479, x1478 = bits.Mul32(x10, arg1[10]) + var x1480 uint32 + var x1481 uint32 + x1481, x1480 = bits.Mul32(x10, arg1[9]) + var x1482 uint32 + var x1483 uint32 + x1483, x1482 = bits.Mul32(x10, arg1[8]) + var x1484 uint32 + var x1485 uint32 + x1485, x1484 = bits.Mul32(x10, arg1[7]) + var x1486 uint32 + var x1487 uint32 + x1487, x1486 = bits.Mul32(x10, arg1[6]) + var x1488 uint32 + var x1489 uint32 + x1489, x1488 = bits.Mul32(x10, arg1[5]) + var x1490 uint32 + var x1491 uint32 + x1491, x1490 = bits.Mul32(x10, arg1[4]) + var x1492 uint32 + var x1493 uint32 + x1493, x1492 = bits.Mul32(x10, arg1[3]) + var x1494 uint32 + var x1495 uint32 + x1495, x1494 = bits.Mul32(x10, arg1[2]) + var x1496 uint32 + var x1497 uint32 + x1497, x1496 = bits.Mul32(x10, arg1[1]) + var x1498 uint32 + var x1499 uint32 + x1499, x1498 = bits.Mul32(x10, arg1[0]) + var x1500 uint32 + var x1501 uint32 + x1500, x1501 = bits.Add32(x1499, x1496, uint32(0x0)) + var x1502 uint32 + var x1503 uint32 + x1502, x1503 = bits.Add32(x1497, x1494, uint32(uint1(x1501))) + var x1504 uint32 + var x1505 uint32 + x1504, x1505 = bits.Add32(x1495, x1492, uint32(uint1(x1503))) + var x1506 uint32 + var x1507 uint32 + x1506, x1507 = bits.Add32(x1493, x1490, uint32(uint1(x1505))) + var x1508 uint32 + var x1509 uint32 + x1508, x1509 = bits.Add32(x1491, x1488, uint32(uint1(x1507))) + var x1510 uint32 + var x1511 uint32 + x1510, x1511 = bits.Add32(x1489, x1486, uint32(uint1(x1509))) + var x1512 uint32 + var x1513 uint32 + x1512, x1513 = bits.Add32(x1487, x1484, uint32(uint1(x1511))) + var x1514 uint32 + var x1515 uint32 + x1514, x1515 = bits.Add32(x1485, x1482, uint32(uint1(x1513))) + var x1516 uint32 + var x1517 uint32 + x1516, x1517 = bits.Add32(x1483, x1480, uint32(uint1(x1515))) + var x1518 uint32 + var x1519 uint32 + x1518, x1519 = bits.Add32(x1481, x1478, uint32(uint1(x1517))) + var x1520 uint32 + var x1521 uint32 + x1520, x1521 = bits.Add32(x1479, x1476, uint32(uint1(x1519))) + x1522 := (uint32(uint1(x1521)) + x1477) + var x1523 uint32 + var x1524 uint32 + x1523, x1524 = bits.Add32(x1451, x1498, uint32(0x0)) + var x1525 uint32 + var x1526 uint32 + x1525, x1526 = bits.Add32(x1453, x1500, uint32(uint1(x1524))) + var x1527 uint32 + var x1528 uint32 + x1527, x1528 = bits.Add32(x1455, x1502, uint32(uint1(x1526))) + var x1529 uint32 + var x1530 uint32 + x1529, x1530 = bits.Add32(x1457, x1504, uint32(uint1(x1528))) + var x1531 uint32 + var x1532 uint32 + x1531, x1532 = bits.Add32(x1459, x1506, uint32(uint1(x1530))) + var x1533 uint32 + var x1534 uint32 + x1533, x1534 = bits.Add32(x1461, x1508, uint32(uint1(x1532))) + var x1535 uint32 + var x1536 uint32 + x1535, x1536 = bits.Add32(x1463, x1510, uint32(uint1(x1534))) + var x1537 uint32 + var x1538 uint32 + x1537, x1538 = bits.Add32(x1465, x1512, uint32(uint1(x1536))) + var x1539 uint32 + var x1540 uint32 + x1539, x1540 = bits.Add32(x1467, x1514, uint32(uint1(x1538))) + var x1541 uint32 + var x1542 uint32 + x1541, x1542 = bits.Add32(x1469, x1516, uint32(uint1(x1540))) + var x1543 uint32 + var x1544 uint32 + x1543, x1544 = bits.Add32(x1471, x1518, uint32(uint1(x1542))) + var x1545 uint32 + var x1546 uint32 + x1545, x1546 = bits.Add32(x1473, x1520, uint32(uint1(x1544))) + var x1547 uint32 + var x1548 uint32 + x1547, x1548 = bits.Add32(x1475, x1522, uint32(uint1(x1546))) + var x1549 uint32 + _, x1549 = bits.Mul32(x1523, 0xe88fdc45) + var x1551 uint32 + var x1552 uint32 + x1552, x1551 = bits.Mul32(x1549, 0xffffffff) + var x1553 uint32 + var x1554 uint32 + x1554, x1553 = bits.Mul32(x1549, 0xffffffff) + var x1555 uint32 + var x1556 uint32 + x1556, x1555 = bits.Mul32(x1549, 0xffffffff) + var x1557 uint32 + var x1558 uint32 + x1558, x1557 = bits.Mul32(x1549, 0xffffffff) + var x1559 uint32 + var x1560 uint32 + x1560, x1559 = bits.Mul32(x1549, 0xffffffff) + var x1561 uint32 + var x1562 uint32 + x1562, x1561 = bits.Mul32(x1549, 0xffffffff) + var x1563 uint32 + var x1564 uint32 + x1564, x1563 = bits.Mul32(x1549, 0xc7634d81) + var x1565 uint32 + var x1566 uint32 + x1566, x1565 = bits.Mul32(x1549, 0xf4372ddf) + var x1567 uint32 + var x1568 uint32 + x1568, x1567 = bits.Mul32(x1549, 0x581a0db2) + var x1569 uint32 + var x1570 uint32 + x1570, x1569 = bits.Mul32(x1549, 0x48b0a77a) + var x1571 uint32 + var x1572 uint32 + x1572, x1571 = bits.Mul32(x1549, 0xecec196a) + var x1573 uint32 + var x1574 uint32 + x1574, x1573 = bits.Mul32(x1549, 0xccc52973) + var x1575 uint32 + var x1576 uint32 + x1575, x1576 = bits.Add32(x1574, x1571, uint32(0x0)) + var x1577 uint32 + var x1578 uint32 + x1577, x1578 = bits.Add32(x1572, x1569, uint32(uint1(x1576))) + var x1579 uint32 + var x1580 uint32 + x1579, x1580 = bits.Add32(x1570, x1567, uint32(uint1(x1578))) + var x1581 uint32 + var x1582 uint32 + x1581, x1582 = bits.Add32(x1568, x1565, uint32(uint1(x1580))) + var x1583 uint32 + var x1584 uint32 + x1583, x1584 = bits.Add32(x1566, x1563, uint32(uint1(x1582))) + var x1585 uint32 + var x1586 uint32 + x1585, x1586 = bits.Add32(x1564, x1561, uint32(uint1(x1584))) + var x1587 uint32 + var x1588 uint32 + x1587, x1588 = bits.Add32(x1562, x1559, uint32(uint1(x1586))) + var x1589 uint32 + var x1590 uint32 + x1589, x1590 = bits.Add32(x1560, x1557, uint32(uint1(x1588))) + var x1591 uint32 + var x1592 uint32 + x1591, x1592 = bits.Add32(x1558, x1555, uint32(uint1(x1590))) + var x1593 uint32 + var x1594 uint32 + x1593, x1594 = bits.Add32(x1556, x1553, uint32(uint1(x1592))) + var x1595 uint32 + var x1596 uint32 + x1595, x1596 = bits.Add32(x1554, x1551, uint32(uint1(x1594))) + x1597 := (uint32(uint1(x1596)) + x1552) + var x1599 uint32 + _, x1599 = bits.Add32(x1523, x1573, uint32(0x0)) + var x1600 uint32 + var x1601 uint32 + x1600, x1601 = bits.Add32(x1525, x1575, uint32(uint1(x1599))) + var x1602 uint32 + var x1603 uint32 + x1602, x1603 = bits.Add32(x1527, x1577, uint32(uint1(x1601))) + var x1604 uint32 + var x1605 uint32 + x1604, x1605 = bits.Add32(x1529, x1579, uint32(uint1(x1603))) + var x1606 uint32 + var x1607 uint32 + x1606, x1607 = bits.Add32(x1531, x1581, uint32(uint1(x1605))) + var x1608 uint32 + var x1609 uint32 + x1608, x1609 = bits.Add32(x1533, x1583, uint32(uint1(x1607))) + var x1610 uint32 + var x1611 uint32 + x1610, x1611 = bits.Add32(x1535, x1585, uint32(uint1(x1609))) + var x1612 uint32 + var x1613 uint32 + x1612, x1613 = bits.Add32(x1537, x1587, uint32(uint1(x1611))) + var x1614 uint32 + var x1615 uint32 + x1614, x1615 = bits.Add32(x1539, x1589, uint32(uint1(x1613))) + var x1616 uint32 + var x1617 uint32 + x1616, x1617 = bits.Add32(x1541, x1591, uint32(uint1(x1615))) + var x1618 uint32 + var x1619 uint32 + x1618, x1619 = bits.Add32(x1543, x1593, uint32(uint1(x1617))) + var x1620 uint32 + var x1621 uint32 + x1620, x1621 = bits.Add32(x1545, x1595, uint32(uint1(x1619))) + var x1622 uint32 + var x1623 uint32 + x1622, x1623 = bits.Add32(x1547, x1597, uint32(uint1(x1621))) + x1624 := (uint32(uint1(x1623)) + uint32(uint1(x1548))) + var x1625 uint32 + var x1626 uint32 + x1626, x1625 = bits.Mul32(x11, arg1[11]) + var x1627 uint32 + var x1628 uint32 + x1628, x1627 = bits.Mul32(x11, arg1[10]) + var x1629 uint32 + var x1630 uint32 + x1630, x1629 = bits.Mul32(x11, arg1[9]) + var x1631 uint32 + var x1632 uint32 + x1632, x1631 = bits.Mul32(x11, arg1[8]) + var x1633 uint32 + var x1634 uint32 + x1634, x1633 = bits.Mul32(x11, arg1[7]) + var x1635 uint32 + var x1636 uint32 + x1636, x1635 = bits.Mul32(x11, arg1[6]) + var x1637 uint32 + var x1638 uint32 + x1638, x1637 = bits.Mul32(x11, arg1[5]) + var x1639 uint32 + var x1640 uint32 + x1640, x1639 = bits.Mul32(x11, arg1[4]) + var x1641 uint32 + var x1642 uint32 + x1642, x1641 = bits.Mul32(x11, arg1[3]) + var x1643 uint32 + var x1644 uint32 + x1644, x1643 = bits.Mul32(x11, arg1[2]) + var x1645 uint32 + var x1646 uint32 + x1646, x1645 = bits.Mul32(x11, arg1[1]) + var x1647 uint32 + var x1648 uint32 + x1648, x1647 = bits.Mul32(x11, arg1[0]) + var x1649 uint32 + var x1650 uint32 + x1649, x1650 = bits.Add32(x1648, x1645, uint32(0x0)) + var x1651 uint32 + var x1652 uint32 + x1651, x1652 = bits.Add32(x1646, x1643, uint32(uint1(x1650))) + var x1653 uint32 + var x1654 uint32 + x1653, x1654 = bits.Add32(x1644, x1641, uint32(uint1(x1652))) + var x1655 uint32 + var x1656 uint32 + x1655, x1656 = bits.Add32(x1642, x1639, uint32(uint1(x1654))) + var x1657 uint32 + var x1658 uint32 + x1657, x1658 = bits.Add32(x1640, x1637, uint32(uint1(x1656))) + var x1659 uint32 + var x1660 uint32 + x1659, x1660 = bits.Add32(x1638, x1635, uint32(uint1(x1658))) + var x1661 uint32 + var x1662 uint32 + x1661, x1662 = bits.Add32(x1636, x1633, uint32(uint1(x1660))) + var x1663 uint32 + var x1664 uint32 + x1663, x1664 = bits.Add32(x1634, x1631, uint32(uint1(x1662))) + var x1665 uint32 + var x1666 uint32 + x1665, x1666 = bits.Add32(x1632, x1629, uint32(uint1(x1664))) + var x1667 uint32 + var x1668 uint32 + x1667, x1668 = bits.Add32(x1630, x1627, uint32(uint1(x1666))) + var x1669 uint32 + var x1670 uint32 + x1669, x1670 = bits.Add32(x1628, x1625, uint32(uint1(x1668))) + x1671 := (uint32(uint1(x1670)) + x1626) + var x1672 uint32 + var x1673 uint32 + x1672, x1673 = bits.Add32(x1600, x1647, uint32(0x0)) + var x1674 uint32 + var x1675 uint32 + x1674, x1675 = bits.Add32(x1602, x1649, uint32(uint1(x1673))) + var x1676 uint32 + var x1677 uint32 + x1676, x1677 = bits.Add32(x1604, x1651, uint32(uint1(x1675))) + var x1678 uint32 + var x1679 uint32 + x1678, x1679 = bits.Add32(x1606, x1653, uint32(uint1(x1677))) + var x1680 uint32 + var x1681 uint32 + x1680, x1681 = bits.Add32(x1608, x1655, uint32(uint1(x1679))) + var x1682 uint32 + var x1683 uint32 + x1682, x1683 = bits.Add32(x1610, x1657, uint32(uint1(x1681))) + var x1684 uint32 + var x1685 uint32 + x1684, x1685 = bits.Add32(x1612, x1659, uint32(uint1(x1683))) + var x1686 uint32 + var x1687 uint32 + x1686, x1687 = bits.Add32(x1614, x1661, uint32(uint1(x1685))) + var x1688 uint32 + var x1689 uint32 + x1688, x1689 = bits.Add32(x1616, x1663, uint32(uint1(x1687))) + var x1690 uint32 + var x1691 uint32 + x1690, x1691 = bits.Add32(x1618, x1665, uint32(uint1(x1689))) + var x1692 uint32 + var x1693 uint32 + x1692, x1693 = bits.Add32(x1620, x1667, uint32(uint1(x1691))) + var x1694 uint32 + var x1695 uint32 + x1694, x1695 = bits.Add32(x1622, x1669, uint32(uint1(x1693))) + var x1696 uint32 + var x1697 uint32 + x1696, x1697 = bits.Add32(x1624, x1671, uint32(uint1(x1695))) + var x1698 uint32 + _, x1698 = bits.Mul32(x1672, 0xe88fdc45) + var x1700 uint32 + var x1701 uint32 + x1701, x1700 = bits.Mul32(x1698, 0xffffffff) + var x1702 uint32 + var x1703 uint32 + x1703, x1702 = bits.Mul32(x1698, 0xffffffff) + var x1704 uint32 + var x1705 uint32 + x1705, x1704 = bits.Mul32(x1698, 0xffffffff) + var x1706 uint32 + var x1707 uint32 + x1707, x1706 = bits.Mul32(x1698, 0xffffffff) + var x1708 uint32 + var x1709 uint32 + x1709, x1708 = bits.Mul32(x1698, 0xffffffff) + var x1710 uint32 + var x1711 uint32 + x1711, x1710 = bits.Mul32(x1698, 0xffffffff) + var x1712 uint32 + var x1713 uint32 + x1713, x1712 = bits.Mul32(x1698, 0xc7634d81) + var x1714 uint32 + var x1715 uint32 + x1715, x1714 = bits.Mul32(x1698, 0xf4372ddf) + var x1716 uint32 + var x1717 uint32 + x1717, x1716 = bits.Mul32(x1698, 0x581a0db2) + var x1718 uint32 + var x1719 uint32 + x1719, x1718 = bits.Mul32(x1698, 0x48b0a77a) + var x1720 uint32 + var x1721 uint32 + x1721, x1720 = bits.Mul32(x1698, 0xecec196a) + var x1722 uint32 + var x1723 uint32 + x1723, x1722 = bits.Mul32(x1698, 0xccc52973) + var x1724 uint32 + var x1725 uint32 + x1724, x1725 = bits.Add32(x1723, x1720, uint32(0x0)) + var x1726 uint32 + var x1727 uint32 + x1726, x1727 = bits.Add32(x1721, x1718, uint32(uint1(x1725))) + var x1728 uint32 + var x1729 uint32 + x1728, x1729 = bits.Add32(x1719, x1716, uint32(uint1(x1727))) + var x1730 uint32 + var x1731 uint32 + x1730, x1731 = bits.Add32(x1717, x1714, uint32(uint1(x1729))) + var x1732 uint32 + var x1733 uint32 + x1732, x1733 = bits.Add32(x1715, x1712, uint32(uint1(x1731))) + var x1734 uint32 + var x1735 uint32 + x1734, x1735 = bits.Add32(x1713, x1710, uint32(uint1(x1733))) + var x1736 uint32 + var x1737 uint32 + x1736, x1737 = bits.Add32(x1711, x1708, uint32(uint1(x1735))) + var x1738 uint32 + var x1739 uint32 + x1738, x1739 = bits.Add32(x1709, x1706, uint32(uint1(x1737))) + var x1740 uint32 + var x1741 uint32 + x1740, x1741 = bits.Add32(x1707, x1704, uint32(uint1(x1739))) + var x1742 uint32 + var x1743 uint32 + x1742, x1743 = bits.Add32(x1705, x1702, uint32(uint1(x1741))) + var x1744 uint32 + var x1745 uint32 + x1744, x1745 = bits.Add32(x1703, x1700, uint32(uint1(x1743))) + x1746 := (uint32(uint1(x1745)) + x1701) + var x1748 uint32 + _, x1748 = bits.Add32(x1672, x1722, uint32(0x0)) + var x1749 uint32 + var x1750 uint32 + x1749, x1750 = bits.Add32(x1674, x1724, uint32(uint1(x1748))) + var x1751 uint32 + var x1752 uint32 + x1751, x1752 = bits.Add32(x1676, x1726, uint32(uint1(x1750))) + var x1753 uint32 + var x1754 uint32 + x1753, x1754 = bits.Add32(x1678, x1728, uint32(uint1(x1752))) + var x1755 uint32 + var x1756 uint32 + x1755, x1756 = bits.Add32(x1680, x1730, uint32(uint1(x1754))) + var x1757 uint32 + var x1758 uint32 + x1757, x1758 = bits.Add32(x1682, x1732, uint32(uint1(x1756))) + var x1759 uint32 + var x1760 uint32 + x1759, x1760 = bits.Add32(x1684, x1734, uint32(uint1(x1758))) + var x1761 uint32 + var x1762 uint32 + x1761, x1762 = bits.Add32(x1686, x1736, uint32(uint1(x1760))) + var x1763 uint32 + var x1764 uint32 + x1763, x1764 = bits.Add32(x1688, x1738, uint32(uint1(x1762))) + var x1765 uint32 + var x1766 uint32 + x1765, x1766 = bits.Add32(x1690, x1740, uint32(uint1(x1764))) + var x1767 uint32 + var x1768 uint32 + x1767, x1768 = bits.Add32(x1692, x1742, uint32(uint1(x1766))) + var x1769 uint32 + var x1770 uint32 + x1769, x1770 = bits.Add32(x1694, x1744, uint32(uint1(x1768))) + var x1771 uint32 + var x1772 uint32 + x1771, x1772 = bits.Add32(x1696, x1746, uint32(uint1(x1770))) + x1773 := (uint32(uint1(x1772)) + uint32(uint1(x1697))) + var x1774 uint32 + var x1775 uint32 + x1774, x1775 = bits.Sub32(x1749, 0xccc52973, uint32(0x0)) + var x1776 uint32 + var x1777 uint32 + x1776, x1777 = bits.Sub32(x1751, 0xecec196a, uint32(uint1(x1775))) + var x1778 uint32 + var x1779 uint32 + x1778, x1779 = bits.Sub32(x1753, 0x48b0a77a, uint32(uint1(x1777))) + var x1780 uint32 + var x1781 uint32 + x1780, x1781 = bits.Sub32(x1755, 0x581a0db2, uint32(uint1(x1779))) + var x1782 uint32 + var x1783 uint32 + x1782, x1783 = bits.Sub32(x1757, 0xf4372ddf, uint32(uint1(x1781))) + var x1784 uint32 + var x1785 uint32 + x1784, x1785 = bits.Sub32(x1759, 0xc7634d81, uint32(uint1(x1783))) + var x1786 uint32 + var x1787 uint32 + x1786, x1787 = bits.Sub32(x1761, 0xffffffff, uint32(uint1(x1785))) + var x1788 uint32 + var x1789 uint32 + x1788, x1789 = bits.Sub32(x1763, 0xffffffff, uint32(uint1(x1787))) + var x1790 uint32 + var x1791 uint32 + x1790, x1791 = bits.Sub32(x1765, 0xffffffff, uint32(uint1(x1789))) + var x1792 uint32 + var x1793 uint32 + x1792, x1793 = bits.Sub32(x1767, 0xffffffff, uint32(uint1(x1791))) + var x1794 uint32 + var x1795 uint32 + x1794, x1795 = bits.Sub32(x1769, 0xffffffff, uint32(uint1(x1793))) + var x1796 uint32 + var x1797 uint32 + x1796, x1797 = bits.Sub32(x1771, 0xffffffff, uint32(uint1(x1795))) + var x1799 uint32 + _, x1799 = bits.Sub32(x1773, uint32(0x0), uint32(uint1(x1797))) + var x1800 uint32 + cmovznzU32(&x1800, uint1(x1799), x1774, x1749) + var x1801 uint32 + cmovznzU32(&x1801, uint1(x1799), x1776, x1751) + var x1802 uint32 + cmovznzU32(&x1802, uint1(x1799), x1778, x1753) + var x1803 uint32 + cmovznzU32(&x1803, uint1(x1799), x1780, x1755) + var x1804 uint32 + cmovznzU32(&x1804, uint1(x1799), x1782, x1757) + var x1805 uint32 + cmovznzU32(&x1805, uint1(x1799), x1784, x1759) + var x1806 uint32 + cmovznzU32(&x1806, uint1(x1799), x1786, x1761) + var x1807 uint32 + cmovznzU32(&x1807, uint1(x1799), x1788, x1763) + var x1808 uint32 + cmovznzU32(&x1808, uint1(x1799), x1790, x1765) + var x1809 uint32 + cmovznzU32(&x1809, uint1(x1799), x1792, x1767) + var x1810 uint32 + cmovznzU32(&x1810, uint1(x1799), x1794, x1769) + var x1811 uint32 + cmovznzU32(&x1811, uint1(x1799), x1796, x1771) + out1[0] = x1800 + out1[1] = x1801 + out1[2] = x1802 + out1[3] = x1803 + out1[4] = x1804 + out1[5] = x1805 + out1[6] = x1806 + out1[7] = x1807 + out1[8] = x1808 + out1[9] = x1809 + out1[10] = x1810 + out1[11] = x1811 +} + +// Add adds two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Add(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint32 + var x2 uint32 + x1, x2 = bits.Add32(arg1[0], arg2[0], uint32(0x0)) + var x3 uint32 + var x4 uint32 + x3, x4 = bits.Add32(arg1[1], arg2[1], uint32(uint1(x2))) + var x5 uint32 + var x6 uint32 + x5, x6 = bits.Add32(arg1[2], arg2[2], uint32(uint1(x4))) + var x7 uint32 + var x8 uint32 + x7, x8 = bits.Add32(arg1[3], arg2[3], uint32(uint1(x6))) + var x9 uint32 + var x10 uint32 + x9, x10 = bits.Add32(arg1[4], arg2[4], uint32(uint1(x8))) + var x11 uint32 + var x12 uint32 + x11, x12 = bits.Add32(arg1[5], arg2[5], uint32(uint1(x10))) + var x13 uint32 + var x14 uint32 + x13, x14 = bits.Add32(arg1[6], arg2[6], uint32(uint1(x12))) + var x15 uint32 + var x16 uint32 + x15, x16 = bits.Add32(arg1[7], arg2[7], uint32(uint1(x14))) + var x17 uint32 + var x18 uint32 + x17, x18 = bits.Add32(arg1[8], arg2[8], uint32(uint1(x16))) + var x19 uint32 + var x20 uint32 + x19, x20 = bits.Add32(arg1[9], arg2[9], uint32(uint1(x18))) + var x21 uint32 + var x22 uint32 + x21, x22 = bits.Add32(arg1[10], arg2[10], uint32(uint1(x20))) + var x23 uint32 + var x24 uint32 + x23, x24 = bits.Add32(arg1[11], arg2[11], uint32(uint1(x22))) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Sub32(x1, 0xccc52973, uint32(0x0)) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Sub32(x3, 0xecec196a, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Sub32(x5, 0x48b0a77a, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Sub32(x7, 0x581a0db2, uint32(uint1(x30))) + var x33 uint32 + var x34 uint32 + x33, x34 = bits.Sub32(x9, 0xf4372ddf, uint32(uint1(x32))) + var x35 uint32 + var x36 uint32 + x35, x36 = bits.Sub32(x11, 0xc7634d81, uint32(uint1(x34))) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Sub32(x13, 0xffffffff, uint32(uint1(x36))) + var x39 uint32 + var x40 uint32 + x39, x40 = bits.Sub32(x15, 0xffffffff, uint32(uint1(x38))) + var x41 uint32 + var x42 uint32 + x41, x42 = bits.Sub32(x17, 0xffffffff, uint32(uint1(x40))) + var x43 uint32 + var x44 uint32 + x43, x44 = bits.Sub32(x19, 0xffffffff, uint32(uint1(x42))) + var x45 uint32 + var x46 uint32 + x45, x46 = bits.Sub32(x21, 0xffffffff, uint32(uint1(x44))) + var x47 uint32 + var x48 uint32 + x47, x48 = bits.Sub32(x23, 0xffffffff, uint32(uint1(x46))) + var x50 uint32 + _, x50 = bits.Sub32(uint32(uint1(x24)), uint32(0x0), uint32(uint1(x48))) + var x51 uint32 + cmovznzU32(&x51, uint1(x50), x25, x1) + var x52 uint32 + cmovznzU32(&x52, uint1(x50), x27, x3) + var x53 uint32 + cmovznzU32(&x53, uint1(x50), x29, x5) + var x54 uint32 + cmovznzU32(&x54, uint1(x50), x31, x7) + var x55 uint32 + cmovznzU32(&x55, uint1(x50), x33, x9) + var x56 uint32 + cmovznzU32(&x56, uint1(x50), x35, x11) + var x57 uint32 + cmovznzU32(&x57, uint1(x50), x37, x13) + var x58 uint32 + cmovznzU32(&x58, uint1(x50), x39, x15) + var x59 uint32 + cmovznzU32(&x59, uint1(x50), x41, x17) + var x60 uint32 + cmovznzU32(&x60, uint1(x50), x43, x19) + var x61 uint32 + cmovznzU32(&x61, uint1(x50), x45, x21) + var x62 uint32 + cmovznzU32(&x62, uint1(x50), x47, x23) + out1[0] = x51 + out1[1] = x52 + out1[2] = x53 + out1[3] = x54 + out1[4] = x55 + out1[5] = x56 + out1[6] = x57 + out1[7] = x58 + out1[8] = x59 + out1[9] = x60 + out1[10] = x61 + out1[11] = x62 +} + +// Sub subtracts two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Sub(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint32 + var x2 uint32 + x1, x2 = bits.Sub32(arg1[0], arg2[0], uint32(0x0)) + var x3 uint32 + var x4 uint32 + x3, x4 = bits.Sub32(arg1[1], arg2[1], uint32(uint1(x2))) + var x5 uint32 + var x6 uint32 + x5, x6 = bits.Sub32(arg1[2], arg2[2], uint32(uint1(x4))) + var x7 uint32 + var x8 uint32 + x7, x8 = bits.Sub32(arg1[3], arg2[3], uint32(uint1(x6))) + var x9 uint32 + var x10 uint32 + x9, x10 = bits.Sub32(arg1[4], arg2[4], uint32(uint1(x8))) + var x11 uint32 + var x12 uint32 + x11, x12 = bits.Sub32(arg1[5], arg2[5], uint32(uint1(x10))) + var x13 uint32 + var x14 uint32 + x13, x14 = bits.Sub32(arg1[6], arg2[6], uint32(uint1(x12))) + var x15 uint32 + var x16 uint32 + x15, x16 = bits.Sub32(arg1[7], arg2[7], uint32(uint1(x14))) + var x17 uint32 + var x18 uint32 + x17, x18 = bits.Sub32(arg1[8], arg2[8], uint32(uint1(x16))) + var x19 uint32 + var x20 uint32 + x19, x20 = bits.Sub32(arg1[9], arg2[9], uint32(uint1(x18))) + var x21 uint32 + var x22 uint32 + x21, x22 = bits.Sub32(arg1[10], arg2[10], uint32(uint1(x20))) + var x23 uint32 + var x24 uint32 + x23, x24 = bits.Sub32(arg1[11], arg2[11], uint32(uint1(x22))) + var x25 uint32 + cmovznzU32(&x25, uint1(x24), uint32(0x0), 0xffffffff) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(x1, (x25 & 0xccc52973), uint32(0x0)) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(x3, (x25 & 0xecec196a), uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(x5, (x25 & 0x48b0a77a), uint32(uint1(x29))) + var x32 uint32 + var x33 uint32 + x32, x33 = bits.Add32(x7, (x25 & 0x581a0db2), uint32(uint1(x31))) + var x34 uint32 + var x35 uint32 + x34, x35 = bits.Add32(x9, (x25 & 0xf4372ddf), uint32(uint1(x33))) + var x36 uint32 + var x37 uint32 + x36, x37 = bits.Add32(x11, (x25 & 0xc7634d81), uint32(uint1(x35))) + var x38 uint32 + var x39 uint32 + x38, x39 = bits.Add32(x13, x25, uint32(uint1(x37))) + var x40 uint32 + var x41 uint32 + x40, x41 = bits.Add32(x15, x25, uint32(uint1(x39))) + var x42 uint32 + var x43 uint32 + x42, x43 = bits.Add32(x17, x25, uint32(uint1(x41))) + var x44 uint32 + var x45 uint32 + x44, x45 = bits.Add32(x19, x25, uint32(uint1(x43))) + var x46 uint32 + var x47 uint32 + x46, x47 = bits.Add32(x21, x25, uint32(uint1(x45))) + var x48 uint32 + x48, _ = bits.Add32(x23, x25, uint32(uint1(x47))) + out1[0] = x26 + out1[1] = x28 + out1[2] = x30 + out1[3] = x32 + out1[4] = x34 + out1[5] = x36 + out1[6] = x38 + out1[7] = x40 + out1[8] = x42 + out1[9] = x44 + out1[10] = x46 + out1[11] = x48 +} + +// Opp negates a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +// 0 ≤ eval out1 < m +// +func Opp(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + var x1 uint32 + var x2 uint32 + x1, x2 = bits.Sub32(uint32(0x0), arg1[0], uint32(0x0)) + var x3 uint32 + var x4 uint32 + x3, x4 = bits.Sub32(uint32(0x0), arg1[1], uint32(uint1(x2))) + var x5 uint32 + var x6 uint32 + x5, x6 = bits.Sub32(uint32(0x0), arg1[2], uint32(uint1(x4))) + var x7 uint32 + var x8 uint32 + x7, x8 = bits.Sub32(uint32(0x0), arg1[3], uint32(uint1(x6))) + var x9 uint32 + var x10 uint32 + x9, x10 = bits.Sub32(uint32(0x0), arg1[4], uint32(uint1(x8))) + var x11 uint32 + var x12 uint32 + x11, x12 = bits.Sub32(uint32(0x0), arg1[5], uint32(uint1(x10))) + var x13 uint32 + var x14 uint32 + x13, x14 = bits.Sub32(uint32(0x0), arg1[6], uint32(uint1(x12))) + var x15 uint32 + var x16 uint32 + x15, x16 = bits.Sub32(uint32(0x0), arg1[7], uint32(uint1(x14))) + var x17 uint32 + var x18 uint32 + x17, x18 = bits.Sub32(uint32(0x0), arg1[8], uint32(uint1(x16))) + var x19 uint32 + var x20 uint32 + x19, x20 = bits.Sub32(uint32(0x0), arg1[9], uint32(uint1(x18))) + var x21 uint32 + var x22 uint32 + x21, x22 = bits.Sub32(uint32(0x0), arg1[10], uint32(uint1(x20))) + var x23 uint32 + var x24 uint32 + x23, x24 = bits.Sub32(uint32(0x0), arg1[11], uint32(uint1(x22))) + var x25 uint32 + cmovznzU32(&x25, uint1(x24), uint32(0x0), 0xffffffff) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(x1, (x25 & 0xccc52973), uint32(0x0)) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(x3, (x25 & 0xecec196a), uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(x5, (x25 & 0x48b0a77a), uint32(uint1(x29))) + var x32 uint32 + var x33 uint32 + x32, x33 = bits.Add32(x7, (x25 & 0x581a0db2), uint32(uint1(x31))) + var x34 uint32 + var x35 uint32 + x34, x35 = bits.Add32(x9, (x25 & 0xf4372ddf), uint32(uint1(x33))) + var x36 uint32 + var x37 uint32 + x36, x37 = bits.Add32(x11, (x25 & 0xc7634d81), uint32(uint1(x35))) + var x38 uint32 + var x39 uint32 + x38, x39 = bits.Add32(x13, x25, uint32(uint1(x37))) + var x40 uint32 + var x41 uint32 + x40, x41 = bits.Add32(x15, x25, uint32(uint1(x39))) + var x42 uint32 + var x43 uint32 + x42, x43 = bits.Add32(x17, x25, uint32(uint1(x41))) + var x44 uint32 + var x45 uint32 + x44, x45 = bits.Add32(x19, x25, uint32(uint1(x43))) + var x46 uint32 + var x47 uint32 + x46, x47 = bits.Add32(x21, x25, uint32(uint1(x45))) + var x48 uint32 + x48, _ = bits.Add32(x23, x25, uint32(uint1(x47))) + out1[0] = x26 + out1[1] = x28 + out1[2] = x30 + out1[3] = x32 + out1[4] = x34 + out1[5] = x36 + out1[6] = x38 + out1[7] = x40 + out1[8] = x42 + out1[9] = x44 + out1[10] = x46 + out1[11] = x48 +} + +// FromMontgomery translates a field element out of the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^12) mod m +// 0 ≤ eval out1 < m +// +func FromMontgomery(out1 *NonMontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[0] + var x2 uint32 + _, x2 = bits.Mul32(x1, 0xe88fdc45) + var x4 uint32 + var x5 uint32 + x5, x4 = bits.Mul32(x2, 0xffffffff) + var x6 uint32 + var x7 uint32 + x7, x6 = bits.Mul32(x2, 0xffffffff) + var x8 uint32 + var x9 uint32 + x9, x8 = bits.Mul32(x2, 0xffffffff) + var x10 uint32 + var x11 uint32 + x11, x10 = bits.Mul32(x2, 0xffffffff) + var x12 uint32 + var x13 uint32 + x13, x12 = bits.Mul32(x2, 0xffffffff) + var x14 uint32 + var x15 uint32 + x15, x14 = bits.Mul32(x2, 0xffffffff) + var x16 uint32 + var x17 uint32 + x17, x16 = bits.Mul32(x2, 0xc7634d81) + var x18 uint32 + var x19 uint32 + x19, x18 = bits.Mul32(x2, 0xf4372ddf) + var x20 uint32 + var x21 uint32 + x21, x20 = bits.Mul32(x2, 0x581a0db2) + var x22 uint32 + var x23 uint32 + x23, x22 = bits.Mul32(x2, 0x48b0a77a) + var x24 uint32 + var x25 uint32 + x25, x24 = bits.Mul32(x2, 0xecec196a) + var x26 uint32 + var x27 uint32 + x27, x26 = bits.Mul32(x2, 0xccc52973) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(x27, x24, uint32(0x0)) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(x25, x22, uint32(uint1(x29))) + var x32 uint32 + var x33 uint32 + x32, x33 = bits.Add32(x23, x20, uint32(uint1(x31))) + var x34 uint32 + var x35 uint32 + x34, x35 = bits.Add32(x21, x18, uint32(uint1(x33))) + var x36 uint32 + var x37 uint32 + x36, x37 = bits.Add32(x19, x16, uint32(uint1(x35))) + var x38 uint32 + var x39 uint32 + x38, x39 = bits.Add32(x17, x14, uint32(uint1(x37))) + var x40 uint32 + var x41 uint32 + x40, x41 = bits.Add32(x15, x12, uint32(uint1(x39))) + var x42 uint32 + var x43 uint32 + x42, x43 = bits.Add32(x13, x10, uint32(uint1(x41))) + var x44 uint32 + var x45 uint32 + x44, x45 = bits.Add32(x11, x8, uint32(uint1(x43))) + var x46 uint32 + var x47 uint32 + x46, x47 = bits.Add32(x9, x6, uint32(uint1(x45))) + var x48 uint32 + var x49 uint32 + x48, x49 = bits.Add32(x7, x4, uint32(uint1(x47))) + var x51 uint32 + _, x51 = bits.Add32(x1, x26, uint32(0x0)) + var x52 uint32 + var x53 uint32 + x52, x53 = bits.Add32(uint32(0x0), x28, uint32(uint1(x51))) + var x54 uint32 + var x55 uint32 + x54, x55 = bits.Add32(uint32(0x0), x30, uint32(uint1(x53))) + var x56 uint32 + var x57 uint32 + x56, x57 = bits.Add32(uint32(0x0), x32, uint32(uint1(x55))) + var x58 uint32 + var x59 uint32 + x58, x59 = bits.Add32(uint32(0x0), x34, uint32(uint1(x57))) + var x60 uint32 + var x61 uint32 + x60, x61 = bits.Add32(uint32(0x0), x36, uint32(uint1(x59))) + var x62 uint32 + var x63 uint32 + x62, x63 = bits.Add32(uint32(0x0), x38, uint32(uint1(x61))) + var x64 uint32 + var x65 uint32 + x64, x65 = bits.Add32(uint32(0x0), x40, uint32(uint1(x63))) + var x66 uint32 + var x67 uint32 + x66, x67 = bits.Add32(uint32(0x0), x42, uint32(uint1(x65))) + var x68 uint32 + var x69 uint32 + x68, x69 = bits.Add32(uint32(0x0), x44, uint32(uint1(x67))) + var x70 uint32 + var x71 uint32 + x70, x71 = bits.Add32(uint32(0x0), x46, uint32(uint1(x69))) + var x72 uint32 + var x73 uint32 + x72, x73 = bits.Add32(uint32(0x0), x48, uint32(uint1(x71))) + var x74 uint32 + var x75 uint32 + x74, x75 = bits.Add32(uint32(0x0), (uint32(uint1(x49)) + x5), uint32(uint1(x73))) + var x76 uint32 + var x77 uint32 + x76, x77 = bits.Add32(x52, arg1[1], uint32(0x0)) + var x78 uint32 + var x79 uint32 + x78, x79 = bits.Add32(x54, uint32(0x0), uint32(uint1(x77))) + var x80 uint32 + var x81 uint32 + x80, x81 = bits.Add32(x56, uint32(0x0), uint32(uint1(x79))) + var x82 uint32 + var x83 uint32 + x82, x83 = bits.Add32(x58, uint32(0x0), uint32(uint1(x81))) + var x84 uint32 + var x85 uint32 + x84, x85 = bits.Add32(x60, uint32(0x0), uint32(uint1(x83))) + var x86 uint32 + var x87 uint32 + x86, x87 = bits.Add32(x62, uint32(0x0), uint32(uint1(x85))) + var x88 uint32 + var x89 uint32 + x88, x89 = bits.Add32(x64, uint32(0x0), uint32(uint1(x87))) + var x90 uint32 + var x91 uint32 + x90, x91 = bits.Add32(x66, uint32(0x0), uint32(uint1(x89))) + var x92 uint32 + var x93 uint32 + x92, x93 = bits.Add32(x68, uint32(0x0), uint32(uint1(x91))) + var x94 uint32 + var x95 uint32 + x94, x95 = bits.Add32(x70, uint32(0x0), uint32(uint1(x93))) + var x96 uint32 + var x97 uint32 + x96, x97 = bits.Add32(x72, uint32(0x0), uint32(uint1(x95))) + var x98 uint32 + var x99 uint32 + x98, x99 = bits.Add32(x74, uint32(0x0), uint32(uint1(x97))) + var x100 uint32 + _, x100 = bits.Mul32(x76, 0xe88fdc45) + var x102 uint32 + var x103 uint32 + x103, x102 = bits.Mul32(x100, 0xffffffff) + var x104 uint32 + var x105 uint32 + x105, x104 = bits.Mul32(x100, 0xffffffff) + var x106 uint32 + var x107 uint32 + x107, x106 = bits.Mul32(x100, 0xffffffff) + var x108 uint32 + var x109 uint32 + x109, x108 = bits.Mul32(x100, 0xffffffff) + var x110 uint32 + var x111 uint32 + x111, x110 = bits.Mul32(x100, 0xffffffff) + var x112 uint32 + var x113 uint32 + x113, x112 = bits.Mul32(x100, 0xffffffff) + var x114 uint32 + var x115 uint32 + x115, x114 = bits.Mul32(x100, 0xc7634d81) + var x116 uint32 + var x117 uint32 + x117, x116 = bits.Mul32(x100, 0xf4372ddf) + var x118 uint32 + var x119 uint32 + x119, x118 = bits.Mul32(x100, 0x581a0db2) + var x120 uint32 + var x121 uint32 + x121, x120 = bits.Mul32(x100, 0x48b0a77a) + var x122 uint32 + var x123 uint32 + x123, x122 = bits.Mul32(x100, 0xecec196a) + var x124 uint32 + var x125 uint32 + x125, x124 = bits.Mul32(x100, 0xccc52973) + var x126 uint32 + var x127 uint32 + x126, x127 = bits.Add32(x125, x122, uint32(0x0)) + var x128 uint32 + var x129 uint32 + x128, x129 = bits.Add32(x123, x120, uint32(uint1(x127))) + var x130 uint32 + var x131 uint32 + x130, x131 = bits.Add32(x121, x118, uint32(uint1(x129))) + var x132 uint32 + var x133 uint32 + x132, x133 = bits.Add32(x119, x116, uint32(uint1(x131))) + var x134 uint32 + var x135 uint32 + x134, x135 = bits.Add32(x117, x114, uint32(uint1(x133))) + var x136 uint32 + var x137 uint32 + x136, x137 = bits.Add32(x115, x112, uint32(uint1(x135))) + var x138 uint32 + var x139 uint32 + x138, x139 = bits.Add32(x113, x110, uint32(uint1(x137))) + var x140 uint32 + var x141 uint32 + x140, x141 = bits.Add32(x111, x108, uint32(uint1(x139))) + var x142 uint32 + var x143 uint32 + x142, x143 = bits.Add32(x109, x106, uint32(uint1(x141))) + var x144 uint32 + var x145 uint32 + x144, x145 = bits.Add32(x107, x104, uint32(uint1(x143))) + var x146 uint32 + var x147 uint32 + x146, x147 = bits.Add32(x105, x102, uint32(uint1(x145))) + var x149 uint32 + _, x149 = bits.Add32(x76, x124, uint32(0x0)) + var x150 uint32 + var x151 uint32 + x150, x151 = bits.Add32(x78, x126, uint32(uint1(x149))) + var x152 uint32 + var x153 uint32 + x152, x153 = bits.Add32(x80, x128, uint32(uint1(x151))) + var x154 uint32 + var x155 uint32 + x154, x155 = bits.Add32(x82, x130, uint32(uint1(x153))) + var x156 uint32 + var x157 uint32 + x156, x157 = bits.Add32(x84, x132, uint32(uint1(x155))) + var x158 uint32 + var x159 uint32 + x158, x159 = bits.Add32(x86, x134, uint32(uint1(x157))) + var x160 uint32 + var x161 uint32 + x160, x161 = bits.Add32(x88, x136, uint32(uint1(x159))) + var x162 uint32 + var x163 uint32 + x162, x163 = bits.Add32(x90, x138, uint32(uint1(x161))) + var x164 uint32 + var x165 uint32 + x164, x165 = bits.Add32(x92, x140, uint32(uint1(x163))) + var x166 uint32 + var x167 uint32 + x166, x167 = bits.Add32(x94, x142, uint32(uint1(x165))) + var x168 uint32 + var x169 uint32 + x168, x169 = bits.Add32(x96, x144, uint32(uint1(x167))) + var x170 uint32 + var x171 uint32 + x170, x171 = bits.Add32(x98, x146, uint32(uint1(x169))) + var x172 uint32 + var x173 uint32 + x172, x173 = bits.Add32((uint32(uint1(x99)) + uint32(uint1(x75))), (uint32(uint1(x147)) + x103), uint32(uint1(x171))) + var x174 uint32 + var x175 uint32 + x174, x175 = bits.Add32(x150, arg1[2], uint32(0x0)) + var x176 uint32 + var x177 uint32 + x176, x177 = bits.Add32(x152, uint32(0x0), uint32(uint1(x175))) + var x178 uint32 + var x179 uint32 + x178, x179 = bits.Add32(x154, uint32(0x0), uint32(uint1(x177))) + var x180 uint32 + var x181 uint32 + x180, x181 = bits.Add32(x156, uint32(0x0), uint32(uint1(x179))) + var x182 uint32 + var x183 uint32 + x182, x183 = bits.Add32(x158, uint32(0x0), uint32(uint1(x181))) + var x184 uint32 + var x185 uint32 + x184, x185 = bits.Add32(x160, uint32(0x0), uint32(uint1(x183))) + var x186 uint32 + var x187 uint32 + x186, x187 = bits.Add32(x162, uint32(0x0), uint32(uint1(x185))) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Add32(x164, uint32(0x0), uint32(uint1(x187))) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Add32(x166, uint32(0x0), uint32(uint1(x189))) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Add32(x168, uint32(0x0), uint32(uint1(x191))) + var x194 uint32 + var x195 uint32 + x194, x195 = bits.Add32(x170, uint32(0x0), uint32(uint1(x193))) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Add32(x172, uint32(0x0), uint32(uint1(x195))) + var x198 uint32 + _, x198 = bits.Mul32(x174, 0xe88fdc45) + var x200 uint32 + var x201 uint32 + x201, x200 = bits.Mul32(x198, 0xffffffff) + var x202 uint32 + var x203 uint32 + x203, x202 = bits.Mul32(x198, 0xffffffff) + var x204 uint32 + var x205 uint32 + x205, x204 = bits.Mul32(x198, 0xffffffff) + var x206 uint32 + var x207 uint32 + x207, x206 = bits.Mul32(x198, 0xffffffff) + var x208 uint32 + var x209 uint32 + x209, x208 = bits.Mul32(x198, 0xffffffff) + var x210 uint32 + var x211 uint32 + x211, x210 = bits.Mul32(x198, 0xffffffff) + var x212 uint32 + var x213 uint32 + x213, x212 = bits.Mul32(x198, 0xc7634d81) + var x214 uint32 + var x215 uint32 + x215, x214 = bits.Mul32(x198, 0xf4372ddf) + var x216 uint32 + var x217 uint32 + x217, x216 = bits.Mul32(x198, 0x581a0db2) + var x218 uint32 + var x219 uint32 + x219, x218 = bits.Mul32(x198, 0x48b0a77a) + var x220 uint32 + var x221 uint32 + x221, x220 = bits.Mul32(x198, 0xecec196a) + var x222 uint32 + var x223 uint32 + x223, x222 = bits.Mul32(x198, 0xccc52973) + var x224 uint32 + var x225 uint32 + x224, x225 = bits.Add32(x223, x220, uint32(0x0)) + var x226 uint32 + var x227 uint32 + x226, x227 = bits.Add32(x221, x218, uint32(uint1(x225))) + var x228 uint32 + var x229 uint32 + x228, x229 = bits.Add32(x219, x216, uint32(uint1(x227))) + var x230 uint32 + var x231 uint32 + x230, x231 = bits.Add32(x217, x214, uint32(uint1(x229))) + var x232 uint32 + var x233 uint32 + x232, x233 = bits.Add32(x215, x212, uint32(uint1(x231))) + var x234 uint32 + var x235 uint32 + x234, x235 = bits.Add32(x213, x210, uint32(uint1(x233))) + var x236 uint32 + var x237 uint32 + x236, x237 = bits.Add32(x211, x208, uint32(uint1(x235))) + var x238 uint32 + var x239 uint32 + x238, x239 = bits.Add32(x209, x206, uint32(uint1(x237))) + var x240 uint32 + var x241 uint32 + x240, x241 = bits.Add32(x207, x204, uint32(uint1(x239))) + var x242 uint32 + var x243 uint32 + x242, x243 = bits.Add32(x205, x202, uint32(uint1(x241))) + var x244 uint32 + var x245 uint32 + x244, x245 = bits.Add32(x203, x200, uint32(uint1(x243))) + var x247 uint32 + _, x247 = bits.Add32(x174, x222, uint32(0x0)) + var x248 uint32 + var x249 uint32 + x248, x249 = bits.Add32(x176, x224, uint32(uint1(x247))) + var x250 uint32 + var x251 uint32 + x250, x251 = bits.Add32(x178, x226, uint32(uint1(x249))) + var x252 uint32 + var x253 uint32 + x252, x253 = bits.Add32(x180, x228, uint32(uint1(x251))) + var x254 uint32 + var x255 uint32 + x254, x255 = bits.Add32(x182, x230, uint32(uint1(x253))) + var x256 uint32 + var x257 uint32 + x256, x257 = bits.Add32(x184, x232, uint32(uint1(x255))) + var x258 uint32 + var x259 uint32 + x258, x259 = bits.Add32(x186, x234, uint32(uint1(x257))) + var x260 uint32 + var x261 uint32 + x260, x261 = bits.Add32(x188, x236, uint32(uint1(x259))) + var x262 uint32 + var x263 uint32 + x262, x263 = bits.Add32(x190, x238, uint32(uint1(x261))) + var x264 uint32 + var x265 uint32 + x264, x265 = bits.Add32(x192, x240, uint32(uint1(x263))) + var x266 uint32 + var x267 uint32 + x266, x267 = bits.Add32(x194, x242, uint32(uint1(x265))) + var x268 uint32 + var x269 uint32 + x268, x269 = bits.Add32(x196, x244, uint32(uint1(x267))) + var x270 uint32 + var x271 uint32 + x270, x271 = bits.Add32((uint32(uint1(x197)) + uint32(uint1(x173))), (uint32(uint1(x245)) + x201), uint32(uint1(x269))) + var x272 uint32 + var x273 uint32 + x272, x273 = bits.Add32(x248, arg1[3], uint32(0x0)) + var x274 uint32 + var x275 uint32 + x274, x275 = bits.Add32(x250, uint32(0x0), uint32(uint1(x273))) + var x276 uint32 + var x277 uint32 + x276, x277 = bits.Add32(x252, uint32(0x0), uint32(uint1(x275))) + var x278 uint32 + var x279 uint32 + x278, x279 = bits.Add32(x254, uint32(0x0), uint32(uint1(x277))) + var x280 uint32 + var x281 uint32 + x280, x281 = bits.Add32(x256, uint32(0x0), uint32(uint1(x279))) + var x282 uint32 + var x283 uint32 + x282, x283 = bits.Add32(x258, uint32(0x0), uint32(uint1(x281))) + var x284 uint32 + var x285 uint32 + x284, x285 = bits.Add32(x260, uint32(0x0), uint32(uint1(x283))) + var x286 uint32 + var x287 uint32 + x286, x287 = bits.Add32(x262, uint32(0x0), uint32(uint1(x285))) + var x288 uint32 + var x289 uint32 + x288, x289 = bits.Add32(x264, uint32(0x0), uint32(uint1(x287))) + var x290 uint32 + var x291 uint32 + x290, x291 = bits.Add32(x266, uint32(0x0), uint32(uint1(x289))) + var x292 uint32 + var x293 uint32 + x292, x293 = bits.Add32(x268, uint32(0x0), uint32(uint1(x291))) + var x294 uint32 + var x295 uint32 + x294, x295 = bits.Add32(x270, uint32(0x0), uint32(uint1(x293))) + var x296 uint32 + _, x296 = bits.Mul32(x272, 0xe88fdc45) + var x298 uint32 + var x299 uint32 + x299, x298 = bits.Mul32(x296, 0xffffffff) + var x300 uint32 + var x301 uint32 + x301, x300 = bits.Mul32(x296, 0xffffffff) + var x302 uint32 + var x303 uint32 + x303, x302 = bits.Mul32(x296, 0xffffffff) + var x304 uint32 + var x305 uint32 + x305, x304 = bits.Mul32(x296, 0xffffffff) + var x306 uint32 + var x307 uint32 + x307, x306 = bits.Mul32(x296, 0xffffffff) + var x308 uint32 + var x309 uint32 + x309, x308 = bits.Mul32(x296, 0xffffffff) + var x310 uint32 + var x311 uint32 + x311, x310 = bits.Mul32(x296, 0xc7634d81) + var x312 uint32 + var x313 uint32 + x313, x312 = bits.Mul32(x296, 0xf4372ddf) + var x314 uint32 + var x315 uint32 + x315, x314 = bits.Mul32(x296, 0x581a0db2) + var x316 uint32 + var x317 uint32 + x317, x316 = bits.Mul32(x296, 0x48b0a77a) + var x318 uint32 + var x319 uint32 + x319, x318 = bits.Mul32(x296, 0xecec196a) + var x320 uint32 + var x321 uint32 + x321, x320 = bits.Mul32(x296, 0xccc52973) + var x322 uint32 + var x323 uint32 + x322, x323 = bits.Add32(x321, x318, uint32(0x0)) + var x324 uint32 + var x325 uint32 + x324, x325 = bits.Add32(x319, x316, uint32(uint1(x323))) + var x326 uint32 + var x327 uint32 + x326, x327 = bits.Add32(x317, x314, uint32(uint1(x325))) + var x328 uint32 + var x329 uint32 + x328, x329 = bits.Add32(x315, x312, uint32(uint1(x327))) + var x330 uint32 + var x331 uint32 + x330, x331 = bits.Add32(x313, x310, uint32(uint1(x329))) + var x332 uint32 + var x333 uint32 + x332, x333 = bits.Add32(x311, x308, uint32(uint1(x331))) + var x334 uint32 + var x335 uint32 + x334, x335 = bits.Add32(x309, x306, uint32(uint1(x333))) + var x336 uint32 + var x337 uint32 + x336, x337 = bits.Add32(x307, x304, uint32(uint1(x335))) + var x338 uint32 + var x339 uint32 + x338, x339 = bits.Add32(x305, x302, uint32(uint1(x337))) + var x340 uint32 + var x341 uint32 + x340, x341 = bits.Add32(x303, x300, uint32(uint1(x339))) + var x342 uint32 + var x343 uint32 + x342, x343 = bits.Add32(x301, x298, uint32(uint1(x341))) + var x345 uint32 + _, x345 = bits.Add32(x272, x320, uint32(0x0)) + var x346 uint32 + var x347 uint32 + x346, x347 = bits.Add32(x274, x322, uint32(uint1(x345))) + var x348 uint32 + var x349 uint32 + x348, x349 = bits.Add32(x276, x324, uint32(uint1(x347))) + var x350 uint32 + var x351 uint32 + x350, x351 = bits.Add32(x278, x326, uint32(uint1(x349))) + var x352 uint32 + var x353 uint32 + x352, x353 = bits.Add32(x280, x328, uint32(uint1(x351))) + var x354 uint32 + var x355 uint32 + x354, x355 = bits.Add32(x282, x330, uint32(uint1(x353))) + var x356 uint32 + var x357 uint32 + x356, x357 = bits.Add32(x284, x332, uint32(uint1(x355))) + var x358 uint32 + var x359 uint32 + x358, x359 = bits.Add32(x286, x334, uint32(uint1(x357))) + var x360 uint32 + var x361 uint32 + x360, x361 = bits.Add32(x288, x336, uint32(uint1(x359))) + var x362 uint32 + var x363 uint32 + x362, x363 = bits.Add32(x290, x338, uint32(uint1(x361))) + var x364 uint32 + var x365 uint32 + x364, x365 = bits.Add32(x292, x340, uint32(uint1(x363))) + var x366 uint32 + var x367 uint32 + x366, x367 = bits.Add32(x294, x342, uint32(uint1(x365))) + var x368 uint32 + var x369 uint32 + x368, x369 = bits.Add32((uint32(uint1(x295)) + uint32(uint1(x271))), (uint32(uint1(x343)) + x299), uint32(uint1(x367))) + var x370 uint32 + var x371 uint32 + x370, x371 = bits.Add32(x346, arg1[4], uint32(0x0)) + var x372 uint32 + var x373 uint32 + x372, x373 = bits.Add32(x348, uint32(0x0), uint32(uint1(x371))) + var x374 uint32 + var x375 uint32 + x374, x375 = bits.Add32(x350, uint32(0x0), uint32(uint1(x373))) + var x376 uint32 + var x377 uint32 + x376, x377 = bits.Add32(x352, uint32(0x0), uint32(uint1(x375))) + var x378 uint32 + var x379 uint32 + x378, x379 = bits.Add32(x354, uint32(0x0), uint32(uint1(x377))) + var x380 uint32 + var x381 uint32 + x380, x381 = bits.Add32(x356, uint32(0x0), uint32(uint1(x379))) + var x382 uint32 + var x383 uint32 + x382, x383 = bits.Add32(x358, uint32(0x0), uint32(uint1(x381))) + var x384 uint32 + var x385 uint32 + x384, x385 = bits.Add32(x360, uint32(0x0), uint32(uint1(x383))) + var x386 uint32 + var x387 uint32 + x386, x387 = bits.Add32(x362, uint32(0x0), uint32(uint1(x385))) + var x388 uint32 + var x389 uint32 + x388, x389 = bits.Add32(x364, uint32(0x0), uint32(uint1(x387))) + var x390 uint32 + var x391 uint32 + x390, x391 = bits.Add32(x366, uint32(0x0), uint32(uint1(x389))) + var x392 uint32 + var x393 uint32 + x392, x393 = bits.Add32(x368, uint32(0x0), uint32(uint1(x391))) + var x394 uint32 + _, x394 = bits.Mul32(x370, 0xe88fdc45) + var x396 uint32 + var x397 uint32 + x397, x396 = bits.Mul32(x394, 0xffffffff) + var x398 uint32 + var x399 uint32 + x399, x398 = bits.Mul32(x394, 0xffffffff) + var x400 uint32 + var x401 uint32 + x401, x400 = bits.Mul32(x394, 0xffffffff) + var x402 uint32 + var x403 uint32 + x403, x402 = bits.Mul32(x394, 0xffffffff) + var x404 uint32 + var x405 uint32 + x405, x404 = bits.Mul32(x394, 0xffffffff) + var x406 uint32 + var x407 uint32 + x407, x406 = bits.Mul32(x394, 0xffffffff) + var x408 uint32 + var x409 uint32 + x409, x408 = bits.Mul32(x394, 0xc7634d81) + var x410 uint32 + var x411 uint32 + x411, x410 = bits.Mul32(x394, 0xf4372ddf) + var x412 uint32 + var x413 uint32 + x413, x412 = bits.Mul32(x394, 0x581a0db2) + var x414 uint32 + var x415 uint32 + x415, x414 = bits.Mul32(x394, 0x48b0a77a) + var x416 uint32 + var x417 uint32 + x417, x416 = bits.Mul32(x394, 0xecec196a) + var x418 uint32 + var x419 uint32 + x419, x418 = bits.Mul32(x394, 0xccc52973) + var x420 uint32 + var x421 uint32 + x420, x421 = bits.Add32(x419, x416, uint32(0x0)) + var x422 uint32 + var x423 uint32 + x422, x423 = bits.Add32(x417, x414, uint32(uint1(x421))) + var x424 uint32 + var x425 uint32 + x424, x425 = bits.Add32(x415, x412, uint32(uint1(x423))) + var x426 uint32 + var x427 uint32 + x426, x427 = bits.Add32(x413, x410, uint32(uint1(x425))) + var x428 uint32 + var x429 uint32 + x428, x429 = bits.Add32(x411, x408, uint32(uint1(x427))) + var x430 uint32 + var x431 uint32 + x430, x431 = bits.Add32(x409, x406, uint32(uint1(x429))) + var x432 uint32 + var x433 uint32 + x432, x433 = bits.Add32(x407, x404, uint32(uint1(x431))) + var x434 uint32 + var x435 uint32 + x434, x435 = bits.Add32(x405, x402, uint32(uint1(x433))) + var x436 uint32 + var x437 uint32 + x436, x437 = bits.Add32(x403, x400, uint32(uint1(x435))) + var x438 uint32 + var x439 uint32 + x438, x439 = bits.Add32(x401, x398, uint32(uint1(x437))) + var x440 uint32 + var x441 uint32 + x440, x441 = bits.Add32(x399, x396, uint32(uint1(x439))) + var x443 uint32 + _, x443 = bits.Add32(x370, x418, uint32(0x0)) + var x444 uint32 + var x445 uint32 + x444, x445 = bits.Add32(x372, x420, uint32(uint1(x443))) + var x446 uint32 + var x447 uint32 + x446, x447 = bits.Add32(x374, x422, uint32(uint1(x445))) + var x448 uint32 + var x449 uint32 + x448, x449 = bits.Add32(x376, x424, uint32(uint1(x447))) + var x450 uint32 + var x451 uint32 + x450, x451 = bits.Add32(x378, x426, uint32(uint1(x449))) + var x452 uint32 + var x453 uint32 + x452, x453 = bits.Add32(x380, x428, uint32(uint1(x451))) + var x454 uint32 + var x455 uint32 + x454, x455 = bits.Add32(x382, x430, uint32(uint1(x453))) + var x456 uint32 + var x457 uint32 + x456, x457 = bits.Add32(x384, x432, uint32(uint1(x455))) + var x458 uint32 + var x459 uint32 + x458, x459 = bits.Add32(x386, x434, uint32(uint1(x457))) + var x460 uint32 + var x461 uint32 + x460, x461 = bits.Add32(x388, x436, uint32(uint1(x459))) + var x462 uint32 + var x463 uint32 + x462, x463 = bits.Add32(x390, x438, uint32(uint1(x461))) + var x464 uint32 + var x465 uint32 + x464, x465 = bits.Add32(x392, x440, uint32(uint1(x463))) + var x466 uint32 + var x467 uint32 + x466, x467 = bits.Add32((uint32(uint1(x393)) + uint32(uint1(x369))), (uint32(uint1(x441)) + x397), uint32(uint1(x465))) + var x468 uint32 + var x469 uint32 + x468, x469 = bits.Add32(x444, arg1[5], uint32(0x0)) + var x470 uint32 + var x471 uint32 + x470, x471 = bits.Add32(x446, uint32(0x0), uint32(uint1(x469))) + var x472 uint32 + var x473 uint32 + x472, x473 = bits.Add32(x448, uint32(0x0), uint32(uint1(x471))) + var x474 uint32 + var x475 uint32 + x474, x475 = bits.Add32(x450, uint32(0x0), uint32(uint1(x473))) + var x476 uint32 + var x477 uint32 + x476, x477 = bits.Add32(x452, uint32(0x0), uint32(uint1(x475))) + var x478 uint32 + var x479 uint32 + x478, x479 = bits.Add32(x454, uint32(0x0), uint32(uint1(x477))) + var x480 uint32 + var x481 uint32 + x480, x481 = bits.Add32(x456, uint32(0x0), uint32(uint1(x479))) + var x482 uint32 + var x483 uint32 + x482, x483 = bits.Add32(x458, uint32(0x0), uint32(uint1(x481))) + var x484 uint32 + var x485 uint32 + x484, x485 = bits.Add32(x460, uint32(0x0), uint32(uint1(x483))) + var x486 uint32 + var x487 uint32 + x486, x487 = bits.Add32(x462, uint32(0x0), uint32(uint1(x485))) + var x488 uint32 + var x489 uint32 + x488, x489 = bits.Add32(x464, uint32(0x0), uint32(uint1(x487))) + var x490 uint32 + var x491 uint32 + x490, x491 = bits.Add32(x466, uint32(0x0), uint32(uint1(x489))) + var x492 uint32 + _, x492 = bits.Mul32(x468, 0xe88fdc45) + var x494 uint32 + var x495 uint32 + x495, x494 = bits.Mul32(x492, 0xffffffff) + var x496 uint32 + var x497 uint32 + x497, x496 = bits.Mul32(x492, 0xffffffff) + var x498 uint32 + var x499 uint32 + x499, x498 = bits.Mul32(x492, 0xffffffff) + var x500 uint32 + var x501 uint32 + x501, x500 = bits.Mul32(x492, 0xffffffff) + var x502 uint32 + var x503 uint32 + x503, x502 = bits.Mul32(x492, 0xffffffff) + var x504 uint32 + var x505 uint32 + x505, x504 = bits.Mul32(x492, 0xffffffff) + var x506 uint32 + var x507 uint32 + x507, x506 = bits.Mul32(x492, 0xc7634d81) + var x508 uint32 + var x509 uint32 + x509, x508 = bits.Mul32(x492, 0xf4372ddf) + var x510 uint32 + var x511 uint32 + x511, x510 = bits.Mul32(x492, 0x581a0db2) + var x512 uint32 + var x513 uint32 + x513, x512 = bits.Mul32(x492, 0x48b0a77a) + var x514 uint32 + var x515 uint32 + x515, x514 = bits.Mul32(x492, 0xecec196a) + var x516 uint32 + var x517 uint32 + x517, x516 = bits.Mul32(x492, 0xccc52973) + var x518 uint32 + var x519 uint32 + x518, x519 = bits.Add32(x517, x514, uint32(0x0)) + var x520 uint32 + var x521 uint32 + x520, x521 = bits.Add32(x515, x512, uint32(uint1(x519))) + var x522 uint32 + var x523 uint32 + x522, x523 = bits.Add32(x513, x510, uint32(uint1(x521))) + var x524 uint32 + var x525 uint32 + x524, x525 = bits.Add32(x511, x508, uint32(uint1(x523))) + var x526 uint32 + var x527 uint32 + x526, x527 = bits.Add32(x509, x506, uint32(uint1(x525))) + var x528 uint32 + var x529 uint32 + x528, x529 = bits.Add32(x507, x504, uint32(uint1(x527))) + var x530 uint32 + var x531 uint32 + x530, x531 = bits.Add32(x505, x502, uint32(uint1(x529))) + var x532 uint32 + var x533 uint32 + x532, x533 = bits.Add32(x503, x500, uint32(uint1(x531))) + var x534 uint32 + var x535 uint32 + x534, x535 = bits.Add32(x501, x498, uint32(uint1(x533))) + var x536 uint32 + var x537 uint32 + x536, x537 = bits.Add32(x499, x496, uint32(uint1(x535))) + var x538 uint32 + var x539 uint32 + x538, x539 = bits.Add32(x497, x494, uint32(uint1(x537))) + var x541 uint32 + _, x541 = bits.Add32(x468, x516, uint32(0x0)) + var x542 uint32 + var x543 uint32 + x542, x543 = bits.Add32(x470, x518, uint32(uint1(x541))) + var x544 uint32 + var x545 uint32 + x544, x545 = bits.Add32(x472, x520, uint32(uint1(x543))) + var x546 uint32 + var x547 uint32 + x546, x547 = bits.Add32(x474, x522, uint32(uint1(x545))) + var x548 uint32 + var x549 uint32 + x548, x549 = bits.Add32(x476, x524, uint32(uint1(x547))) + var x550 uint32 + var x551 uint32 + x550, x551 = bits.Add32(x478, x526, uint32(uint1(x549))) + var x552 uint32 + var x553 uint32 + x552, x553 = bits.Add32(x480, x528, uint32(uint1(x551))) + var x554 uint32 + var x555 uint32 + x554, x555 = bits.Add32(x482, x530, uint32(uint1(x553))) + var x556 uint32 + var x557 uint32 + x556, x557 = bits.Add32(x484, x532, uint32(uint1(x555))) + var x558 uint32 + var x559 uint32 + x558, x559 = bits.Add32(x486, x534, uint32(uint1(x557))) + var x560 uint32 + var x561 uint32 + x560, x561 = bits.Add32(x488, x536, uint32(uint1(x559))) + var x562 uint32 + var x563 uint32 + x562, x563 = bits.Add32(x490, x538, uint32(uint1(x561))) + var x564 uint32 + var x565 uint32 + x564, x565 = bits.Add32((uint32(uint1(x491)) + uint32(uint1(x467))), (uint32(uint1(x539)) + x495), uint32(uint1(x563))) + var x566 uint32 + var x567 uint32 + x566, x567 = bits.Add32(x542, arg1[6], uint32(0x0)) + var x568 uint32 + var x569 uint32 + x568, x569 = bits.Add32(x544, uint32(0x0), uint32(uint1(x567))) + var x570 uint32 + var x571 uint32 + x570, x571 = bits.Add32(x546, uint32(0x0), uint32(uint1(x569))) + var x572 uint32 + var x573 uint32 + x572, x573 = bits.Add32(x548, uint32(0x0), uint32(uint1(x571))) + var x574 uint32 + var x575 uint32 + x574, x575 = bits.Add32(x550, uint32(0x0), uint32(uint1(x573))) + var x576 uint32 + var x577 uint32 + x576, x577 = bits.Add32(x552, uint32(0x0), uint32(uint1(x575))) + var x578 uint32 + var x579 uint32 + x578, x579 = bits.Add32(x554, uint32(0x0), uint32(uint1(x577))) + var x580 uint32 + var x581 uint32 + x580, x581 = bits.Add32(x556, uint32(0x0), uint32(uint1(x579))) + var x582 uint32 + var x583 uint32 + x582, x583 = bits.Add32(x558, uint32(0x0), uint32(uint1(x581))) + var x584 uint32 + var x585 uint32 + x584, x585 = bits.Add32(x560, uint32(0x0), uint32(uint1(x583))) + var x586 uint32 + var x587 uint32 + x586, x587 = bits.Add32(x562, uint32(0x0), uint32(uint1(x585))) + var x588 uint32 + var x589 uint32 + x588, x589 = bits.Add32(x564, uint32(0x0), uint32(uint1(x587))) + var x590 uint32 + _, x590 = bits.Mul32(x566, 0xe88fdc45) + var x592 uint32 + var x593 uint32 + x593, x592 = bits.Mul32(x590, 0xffffffff) + var x594 uint32 + var x595 uint32 + x595, x594 = bits.Mul32(x590, 0xffffffff) + var x596 uint32 + var x597 uint32 + x597, x596 = bits.Mul32(x590, 0xffffffff) + var x598 uint32 + var x599 uint32 + x599, x598 = bits.Mul32(x590, 0xffffffff) + var x600 uint32 + var x601 uint32 + x601, x600 = bits.Mul32(x590, 0xffffffff) + var x602 uint32 + var x603 uint32 + x603, x602 = bits.Mul32(x590, 0xffffffff) + var x604 uint32 + var x605 uint32 + x605, x604 = bits.Mul32(x590, 0xc7634d81) + var x606 uint32 + var x607 uint32 + x607, x606 = bits.Mul32(x590, 0xf4372ddf) + var x608 uint32 + var x609 uint32 + x609, x608 = bits.Mul32(x590, 0x581a0db2) + var x610 uint32 + var x611 uint32 + x611, x610 = bits.Mul32(x590, 0x48b0a77a) + var x612 uint32 + var x613 uint32 + x613, x612 = bits.Mul32(x590, 0xecec196a) + var x614 uint32 + var x615 uint32 + x615, x614 = bits.Mul32(x590, 0xccc52973) + var x616 uint32 + var x617 uint32 + x616, x617 = bits.Add32(x615, x612, uint32(0x0)) + var x618 uint32 + var x619 uint32 + x618, x619 = bits.Add32(x613, x610, uint32(uint1(x617))) + var x620 uint32 + var x621 uint32 + x620, x621 = bits.Add32(x611, x608, uint32(uint1(x619))) + var x622 uint32 + var x623 uint32 + x622, x623 = bits.Add32(x609, x606, uint32(uint1(x621))) + var x624 uint32 + var x625 uint32 + x624, x625 = bits.Add32(x607, x604, uint32(uint1(x623))) + var x626 uint32 + var x627 uint32 + x626, x627 = bits.Add32(x605, x602, uint32(uint1(x625))) + var x628 uint32 + var x629 uint32 + x628, x629 = bits.Add32(x603, x600, uint32(uint1(x627))) + var x630 uint32 + var x631 uint32 + x630, x631 = bits.Add32(x601, x598, uint32(uint1(x629))) + var x632 uint32 + var x633 uint32 + x632, x633 = bits.Add32(x599, x596, uint32(uint1(x631))) + var x634 uint32 + var x635 uint32 + x634, x635 = bits.Add32(x597, x594, uint32(uint1(x633))) + var x636 uint32 + var x637 uint32 + x636, x637 = bits.Add32(x595, x592, uint32(uint1(x635))) + var x639 uint32 + _, x639 = bits.Add32(x566, x614, uint32(0x0)) + var x640 uint32 + var x641 uint32 + x640, x641 = bits.Add32(x568, x616, uint32(uint1(x639))) + var x642 uint32 + var x643 uint32 + x642, x643 = bits.Add32(x570, x618, uint32(uint1(x641))) + var x644 uint32 + var x645 uint32 + x644, x645 = bits.Add32(x572, x620, uint32(uint1(x643))) + var x646 uint32 + var x647 uint32 + x646, x647 = bits.Add32(x574, x622, uint32(uint1(x645))) + var x648 uint32 + var x649 uint32 + x648, x649 = bits.Add32(x576, x624, uint32(uint1(x647))) + var x650 uint32 + var x651 uint32 + x650, x651 = bits.Add32(x578, x626, uint32(uint1(x649))) + var x652 uint32 + var x653 uint32 + x652, x653 = bits.Add32(x580, x628, uint32(uint1(x651))) + var x654 uint32 + var x655 uint32 + x654, x655 = bits.Add32(x582, x630, uint32(uint1(x653))) + var x656 uint32 + var x657 uint32 + x656, x657 = bits.Add32(x584, x632, uint32(uint1(x655))) + var x658 uint32 + var x659 uint32 + x658, x659 = bits.Add32(x586, x634, uint32(uint1(x657))) + var x660 uint32 + var x661 uint32 + x660, x661 = bits.Add32(x588, x636, uint32(uint1(x659))) + var x662 uint32 + var x663 uint32 + x662, x663 = bits.Add32((uint32(uint1(x589)) + uint32(uint1(x565))), (uint32(uint1(x637)) + x593), uint32(uint1(x661))) + var x664 uint32 + var x665 uint32 + x664, x665 = bits.Add32(x640, arg1[7], uint32(0x0)) + var x666 uint32 + var x667 uint32 + x666, x667 = bits.Add32(x642, uint32(0x0), uint32(uint1(x665))) + var x668 uint32 + var x669 uint32 + x668, x669 = bits.Add32(x644, uint32(0x0), uint32(uint1(x667))) + var x670 uint32 + var x671 uint32 + x670, x671 = bits.Add32(x646, uint32(0x0), uint32(uint1(x669))) + var x672 uint32 + var x673 uint32 + x672, x673 = bits.Add32(x648, uint32(0x0), uint32(uint1(x671))) + var x674 uint32 + var x675 uint32 + x674, x675 = bits.Add32(x650, uint32(0x0), uint32(uint1(x673))) + var x676 uint32 + var x677 uint32 + x676, x677 = bits.Add32(x652, uint32(0x0), uint32(uint1(x675))) + var x678 uint32 + var x679 uint32 + x678, x679 = bits.Add32(x654, uint32(0x0), uint32(uint1(x677))) + var x680 uint32 + var x681 uint32 + x680, x681 = bits.Add32(x656, uint32(0x0), uint32(uint1(x679))) + var x682 uint32 + var x683 uint32 + x682, x683 = bits.Add32(x658, uint32(0x0), uint32(uint1(x681))) + var x684 uint32 + var x685 uint32 + x684, x685 = bits.Add32(x660, uint32(0x0), uint32(uint1(x683))) + var x686 uint32 + var x687 uint32 + x686, x687 = bits.Add32(x662, uint32(0x0), uint32(uint1(x685))) + var x688 uint32 + _, x688 = bits.Mul32(x664, 0xe88fdc45) + var x690 uint32 + var x691 uint32 + x691, x690 = bits.Mul32(x688, 0xffffffff) + var x692 uint32 + var x693 uint32 + x693, x692 = bits.Mul32(x688, 0xffffffff) + var x694 uint32 + var x695 uint32 + x695, x694 = bits.Mul32(x688, 0xffffffff) + var x696 uint32 + var x697 uint32 + x697, x696 = bits.Mul32(x688, 0xffffffff) + var x698 uint32 + var x699 uint32 + x699, x698 = bits.Mul32(x688, 0xffffffff) + var x700 uint32 + var x701 uint32 + x701, x700 = bits.Mul32(x688, 0xffffffff) + var x702 uint32 + var x703 uint32 + x703, x702 = bits.Mul32(x688, 0xc7634d81) + var x704 uint32 + var x705 uint32 + x705, x704 = bits.Mul32(x688, 0xf4372ddf) + var x706 uint32 + var x707 uint32 + x707, x706 = bits.Mul32(x688, 0x581a0db2) + var x708 uint32 + var x709 uint32 + x709, x708 = bits.Mul32(x688, 0x48b0a77a) + var x710 uint32 + var x711 uint32 + x711, x710 = bits.Mul32(x688, 0xecec196a) + var x712 uint32 + var x713 uint32 + x713, x712 = bits.Mul32(x688, 0xccc52973) + var x714 uint32 + var x715 uint32 + x714, x715 = bits.Add32(x713, x710, uint32(0x0)) + var x716 uint32 + var x717 uint32 + x716, x717 = bits.Add32(x711, x708, uint32(uint1(x715))) + var x718 uint32 + var x719 uint32 + x718, x719 = bits.Add32(x709, x706, uint32(uint1(x717))) + var x720 uint32 + var x721 uint32 + x720, x721 = bits.Add32(x707, x704, uint32(uint1(x719))) + var x722 uint32 + var x723 uint32 + x722, x723 = bits.Add32(x705, x702, uint32(uint1(x721))) + var x724 uint32 + var x725 uint32 + x724, x725 = bits.Add32(x703, x700, uint32(uint1(x723))) + var x726 uint32 + var x727 uint32 + x726, x727 = bits.Add32(x701, x698, uint32(uint1(x725))) + var x728 uint32 + var x729 uint32 + x728, x729 = bits.Add32(x699, x696, uint32(uint1(x727))) + var x730 uint32 + var x731 uint32 + x730, x731 = bits.Add32(x697, x694, uint32(uint1(x729))) + var x732 uint32 + var x733 uint32 + x732, x733 = bits.Add32(x695, x692, uint32(uint1(x731))) + var x734 uint32 + var x735 uint32 + x734, x735 = bits.Add32(x693, x690, uint32(uint1(x733))) + var x737 uint32 + _, x737 = bits.Add32(x664, x712, uint32(0x0)) + var x738 uint32 + var x739 uint32 + x738, x739 = bits.Add32(x666, x714, uint32(uint1(x737))) + var x740 uint32 + var x741 uint32 + x740, x741 = bits.Add32(x668, x716, uint32(uint1(x739))) + var x742 uint32 + var x743 uint32 + x742, x743 = bits.Add32(x670, x718, uint32(uint1(x741))) + var x744 uint32 + var x745 uint32 + x744, x745 = bits.Add32(x672, x720, uint32(uint1(x743))) + var x746 uint32 + var x747 uint32 + x746, x747 = bits.Add32(x674, x722, uint32(uint1(x745))) + var x748 uint32 + var x749 uint32 + x748, x749 = bits.Add32(x676, x724, uint32(uint1(x747))) + var x750 uint32 + var x751 uint32 + x750, x751 = bits.Add32(x678, x726, uint32(uint1(x749))) + var x752 uint32 + var x753 uint32 + x752, x753 = bits.Add32(x680, x728, uint32(uint1(x751))) + var x754 uint32 + var x755 uint32 + x754, x755 = bits.Add32(x682, x730, uint32(uint1(x753))) + var x756 uint32 + var x757 uint32 + x756, x757 = bits.Add32(x684, x732, uint32(uint1(x755))) + var x758 uint32 + var x759 uint32 + x758, x759 = bits.Add32(x686, x734, uint32(uint1(x757))) + var x760 uint32 + var x761 uint32 + x760, x761 = bits.Add32((uint32(uint1(x687)) + uint32(uint1(x663))), (uint32(uint1(x735)) + x691), uint32(uint1(x759))) + var x762 uint32 + var x763 uint32 + x762, x763 = bits.Add32(x738, arg1[8], uint32(0x0)) + var x764 uint32 + var x765 uint32 + x764, x765 = bits.Add32(x740, uint32(0x0), uint32(uint1(x763))) + var x766 uint32 + var x767 uint32 + x766, x767 = bits.Add32(x742, uint32(0x0), uint32(uint1(x765))) + var x768 uint32 + var x769 uint32 + x768, x769 = bits.Add32(x744, uint32(0x0), uint32(uint1(x767))) + var x770 uint32 + var x771 uint32 + x770, x771 = bits.Add32(x746, uint32(0x0), uint32(uint1(x769))) + var x772 uint32 + var x773 uint32 + x772, x773 = bits.Add32(x748, uint32(0x0), uint32(uint1(x771))) + var x774 uint32 + var x775 uint32 + x774, x775 = bits.Add32(x750, uint32(0x0), uint32(uint1(x773))) + var x776 uint32 + var x777 uint32 + x776, x777 = bits.Add32(x752, uint32(0x0), uint32(uint1(x775))) + var x778 uint32 + var x779 uint32 + x778, x779 = bits.Add32(x754, uint32(0x0), uint32(uint1(x777))) + var x780 uint32 + var x781 uint32 + x780, x781 = bits.Add32(x756, uint32(0x0), uint32(uint1(x779))) + var x782 uint32 + var x783 uint32 + x782, x783 = bits.Add32(x758, uint32(0x0), uint32(uint1(x781))) + var x784 uint32 + var x785 uint32 + x784, x785 = bits.Add32(x760, uint32(0x0), uint32(uint1(x783))) + var x786 uint32 + _, x786 = bits.Mul32(x762, 0xe88fdc45) + var x788 uint32 + var x789 uint32 + x789, x788 = bits.Mul32(x786, 0xffffffff) + var x790 uint32 + var x791 uint32 + x791, x790 = bits.Mul32(x786, 0xffffffff) + var x792 uint32 + var x793 uint32 + x793, x792 = bits.Mul32(x786, 0xffffffff) + var x794 uint32 + var x795 uint32 + x795, x794 = bits.Mul32(x786, 0xffffffff) + var x796 uint32 + var x797 uint32 + x797, x796 = bits.Mul32(x786, 0xffffffff) + var x798 uint32 + var x799 uint32 + x799, x798 = bits.Mul32(x786, 0xffffffff) + var x800 uint32 + var x801 uint32 + x801, x800 = bits.Mul32(x786, 0xc7634d81) + var x802 uint32 + var x803 uint32 + x803, x802 = bits.Mul32(x786, 0xf4372ddf) + var x804 uint32 + var x805 uint32 + x805, x804 = bits.Mul32(x786, 0x581a0db2) + var x806 uint32 + var x807 uint32 + x807, x806 = bits.Mul32(x786, 0x48b0a77a) + var x808 uint32 + var x809 uint32 + x809, x808 = bits.Mul32(x786, 0xecec196a) + var x810 uint32 + var x811 uint32 + x811, x810 = bits.Mul32(x786, 0xccc52973) + var x812 uint32 + var x813 uint32 + x812, x813 = bits.Add32(x811, x808, uint32(0x0)) + var x814 uint32 + var x815 uint32 + x814, x815 = bits.Add32(x809, x806, uint32(uint1(x813))) + var x816 uint32 + var x817 uint32 + x816, x817 = bits.Add32(x807, x804, uint32(uint1(x815))) + var x818 uint32 + var x819 uint32 + x818, x819 = bits.Add32(x805, x802, uint32(uint1(x817))) + var x820 uint32 + var x821 uint32 + x820, x821 = bits.Add32(x803, x800, uint32(uint1(x819))) + var x822 uint32 + var x823 uint32 + x822, x823 = bits.Add32(x801, x798, uint32(uint1(x821))) + var x824 uint32 + var x825 uint32 + x824, x825 = bits.Add32(x799, x796, uint32(uint1(x823))) + var x826 uint32 + var x827 uint32 + x826, x827 = bits.Add32(x797, x794, uint32(uint1(x825))) + var x828 uint32 + var x829 uint32 + x828, x829 = bits.Add32(x795, x792, uint32(uint1(x827))) + var x830 uint32 + var x831 uint32 + x830, x831 = bits.Add32(x793, x790, uint32(uint1(x829))) + var x832 uint32 + var x833 uint32 + x832, x833 = bits.Add32(x791, x788, uint32(uint1(x831))) + var x835 uint32 + _, x835 = bits.Add32(x762, x810, uint32(0x0)) + var x836 uint32 + var x837 uint32 + x836, x837 = bits.Add32(x764, x812, uint32(uint1(x835))) + var x838 uint32 + var x839 uint32 + x838, x839 = bits.Add32(x766, x814, uint32(uint1(x837))) + var x840 uint32 + var x841 uint32 + x840, x841 = bits.Add32(x768, x816, uint32(uint1(x839))) + var x842 uint32 + var x843 uint32 + x842, x843 = bits.Add32(x770, x818, uint32(uint1(x841))) + var x844 uint32 + var x845 uint32 + x844, x845 = bits.Add32(x772, x820, uint32(uint1(x843))) + var x846 uint32 + var x847 uint32 + x846, x847 = bits.Add32(x774, x822, uint32(uint1(x845))) + var x848 uint32 + var x849 uint32 + x848, x849 = bits.Add32(x776, x824, uint32(uint1(x847))) + var x850 uint32 + var x851 uint32 + x850, x851 = bits.Add32(x778, x826, uint32(uint1(x849))) + var x852 uint32 + var x853 uint32 + x852, x853 = bits.Add32(x780, x828, uint32(uint1(x851))) + var x854 uint32 + var x855 uint32 + x854, x855 = bits.Add32(x782, x830, uint32(uint1(x853))) + var x856 uint32 + var x857 uint32 + x856, x857 = bits.Add32(x784, x832, uint32(uint1(x855))) + var x858 uint32 + var x859 uint32 + x858, x859 = bits.Add32((uint32(uint1(x785)) + uint32(uint1(x761))), (uint32(uint1(x833)) + x789), uint32(uint1(x857))) + var x860 uint32 + var x861 uint32 + x860, x861 = bits.Add32(x836, arg1[9], uint32(0x0)) + var x862 uint32 + var x863 uint32 + x862, x863 = bits.Add32(x838, uint32(0x0), uint32(uint1(x861))) + var x864 uint32 + var x865 uint32 + x864, x865 = bits.Add32(x840, uint32(0x0), uint32(uint1(x863))) + var x866 uint32 + var x867 uint32 + x866, x867 = bits.Add32(x842, uint32(0x0), uint32(uint1(x865))) + var x868 uint32 + var x869 uint32 + x868, x869 = bits.Add32(x844, uint32(0x0), uint32(uint1(x867))) + var x870 uint32 + var x871 uint32 + x870, x871 = bits.Add32(x846, uint32(0x0), uint32(uint1(x869))) + var x872 uint32 + var x873 uint32 + x872, x873 = bits.Add32(x848, uint32(0x0), uint32(uint1(x871))) + var x874 uint32 + var x875 uint32 + x874, x875 = bits.Add32(x850, uint32(0x0), uint32(uint1(x873))) + var x876 uint32 + var x877 uint32 + x876, x877 = bits.Add32(x852, uint32(0x0), uint32(uint1(x875))) + var x878 uint32 + var x879 uint32 + x878, x879 = bits.Add32(x854, uint32(0x0), uint32(uint1(x877))) + var x880 uint32 + var x881 uint32 + x880, x881 = bits.Add32(x856, uint32(0x0), uint32(uint1(x879))) + var x882 uint32 + var x883 uint32 + x882, x883 = bits.Add32(x858, uint32(0x0), uint32(uint1(x881))) + var x884 uint32 + _, x884 = bits.Mul32(x860, 0xe88fdc45) + var x886 uint32 + var x887 uint32 + x887, x886 = bits.Mul32(x884, 0xffffffff) + var x888 uint32 + var x889 uint32 + x889, x888 = bits.Mul32(x884, 0xffffffff) + var x890 uint32 + var x891 uint32 + x891, x890 = bits.Mul32(x884, 0xffffffff) + var x892 uint32 + var x893 uint32 + x893, x892 = bits.Mul32(x884, 0xffffffff) + var x894 uint32 + var x895 uint32 + x895, x894 = bits.Mul32(x884, 0xffffffff) + var x896 uint32 + var x897 uint32 + x897, x896 = bits.Mul32(x884, 0xffffffff) + var x898 uint32 + var x899 uint32 + x899, x898 = bits.Mul32(x884, 0xc7634d81) + var x900 uint32 + var x901 uint32 + x901, x900 = bits.Mul32(x884, 0xf4372ddf) + var x902 uint32 + var x903 uint32 + x903, x902 = bits.Mul32(x884, 0x581a0db2) + var x904 uint32 + var x905 uint32 + x905, x904 = bits.Mul32(x884, 0x48b0a77a) + var x906 uint32 + var x907 uint32 + x907, x906 = bits.Mul32(x884, 0xecec196a) + var x908 uint32 + var x909 uint32 + x909, x908 = bits.Mul32(x884, 0xccc52973) + var x910 uint32 + var x911 uint32 + x910, x911 = bits.Add32(x909, x906, uint32(0x0)) + var x912 uint32 + var x913 uint32 + x912, x913 = bits.Add32(x907, x904, uint32(uint1(x911))) + var x914 uint32 + var x915 uint32 + x914, x915 = bits.Add32(x905, x902, uint32(uint1(x913))) + var x916 uint32 + var x917 uint32 + x916, x917 = bits.Add32(x903, x900, uint32(uint1(x915))) + var x918 uint32 + var x919 uint32 + x918, x919 = bits.Add32(x901, x898, uint32(uint1(x917))) + var x920 uint32 + var x921 uint32 + x920, x921 = bits.Add32(x899, x896, uint32(uint1(x919))) + var x922 uint32 + var x923 uint32 + x922, x923 = bits.Add32(x897, x894, uint32(uint1(x921))) + var x924 uint32 + var x925 uint32 + x924, x925 = bits.Add32(x895, x892, uint32(uint1(x923))) + var x926 uint32 + var x927 uint32 + x926, x927 = bits.Add32(x893, x890, uint32(uint1(x925))) + var x928 uint32 + var x929 uint32 + x928, x929 = bits.Add32(x891, x888, uint32(uint1(x927))) + var x930 uint32 + var x931 uint32 + x930, x931 = bits.Add32(x889, x886, uint32(uint1(x929))) + var x933 uint32 + _, x933 = bits.Add32(x860, x908, uint32(0x0)) + var x934 uint32 + var x935 uint32 + x934, x935 = bits.Add32(x862, x910, uint32(uint1(x933))) + var x936 uint32 + var x937 uint32 + x936, x937 = bits.Add32(x864, x912, uint32(uint1(x935))) + var x938 uint32 + var x939 uint32 + x938, x939 = bits.Add32(x866, x914, uint32(uint1(x937))) + var x940 uint32 + var x941 uint32 + x940, x941 = bits.Add32(x868, x916, uint32(uint1(x939))) + var x942 uint32 + var x943 uint32 + x942, x943 = bits.Add32(x870, x918, uint32(uint1(x941))) + var x944 uint32 + var x945 uint32 + x944, x945 = bits.Add32(x872, x920, uint32(uint1(x943))) + var x946 uint32 + var x947 uint32 + x946, x947 = bits.Add32(x874, x922, uint32(uint1(x945))) + var x948 uint32 + var x949 uint32 + x948, x949 = bits.Add32(x876, x924, uint32(uint1(x947))) + var x950 uint32 + var x951 uint32 + x950, x951 = bits.Add32(x878, x926, uint32(uint1(x949))) + var x952 uint32 + var x953 uint32 + x952, x953 = bits.Add32(x880, x928, uint32(uint1(x951))) + var x954 uint32 + var x955 uint32 + x954, x955 = bits.Add32(x882, x930, uint32(uint1(x953))) + var x956 uint32 + var x957 uint32 + x956, x957 = bits.Add32((uint32(uint1(x883)) + uint32(uint1(x859))), (uint32(uint1(x931)) + x887), uint32(uint1(x955))) + var x958 uint32 + var x959 uint32 + x958, x959 = bits.Add32(x934, arg1[10], uint32(0x0)) + var x960 uint32 + var x961 uint32 + x960, x961 = bits.Add32(x936, uint32(0x0), uint32(uint1(x959))) + var x962 uint32 + var x963 uint32 + x962, x963 = bits.Add32(x938, uint32(0x0), uint32(uint1(x961))) + var x964 uint32 + var x965 uint32 + x964, x965 = bits.Add32(x940, uint32(0x0), uint32(uint1(x963))) + var x966 uint32 + var x967 uint32 + x966, x967 = bits.Add32(x942, uint32(0x0), uint32(uint1(x965))) + var x968 uint32 + var x969 uint32 + x968, x969 = bits.Add32(x944, uint32(0x0), uint32(uint1(x967))) + var x970 uint32 + var x971 uint32 + x970, x971 = bits.Add32(x946, uint32(0x0), uint32(uint1(x969))) + var x972 uint32 + var x973 uint32 + x972, x973 = bits.Add32(x948, uint32(0x0), uint32(uint1(x971))) + var x974 uint32 + var x975 uint32 + x974, x975 = bits.Add32(x950, uint32(0x0), uint32(uint1(x973))) + var x976 uint32 + var x977 uint32 + x976, x977 = bits.Add32(x952, uint32(0x0), uint32(uint1(x975))) + var x978 uint32 + var x979 uint32 + x978, x979 = bits.Add32(x954, uint32(0x0), uint32(uint1(x977))) + var x980 uint32 + var x981 uint32 + x980, x981 = bits.Add32(x956, uint32(0x0), uint32(uint1(x979))) + var x982 uint32 + _, x982 = bits.Mul32(x958, 0xe88fdc45) + var x984 uint32 + var x985 uint32 + x985, x984 = bits.Mul32(x982, 0xffffffff) + var x986 uint32 + var x987 uint32 + x987, x986 = bits.Mul32(x982, 0xffffffff) + var x988 uint32 + var x989 uint32 + x989, x988 = bits.Mul32(x982, 0xffffffff) + var x990 uint32 + var x991 uint32 + x991, x990 = bits.Mul32(x982, 0xffffffff) + var x992 uint32 + var x993 uint32 + x993, x992 = bits.Mul32(x982, 0xffffffff) + var x994 uint32 + var x995 uint32 + x995, x994 = bits.Mul32(x982, 0xffffffff) + var x996 uint32 + var x997 uint32 + x997, x996 = bits.Mul32(x982, 0xc7634d81) + var x998 uint32 + var x999 uint32 + x999, x998 = bits.Mul32(x982, 0xf4372ddf) + var x1000 uint32 + var x1001 uint32 + x1001, x1000 = bits.Mul32(x982, 0x581a0db2) + var x1002 uint32 + var x1003 uint32 + x1003, x1002 = bits.Mul32(x982, 0x48b0a77a) + var x1004 uint32 + var x1005 uint32 + x1005, x1004 = bits.Mul32(x982, 0xecec196a) + var x1006 uint32 + var x1007 uint32 + x1007, x1006 = bits.Mul32(x982, 0xccc52973) + var x1008 uint32 + var x1009 uint32 + x1008, x1009 = bits.Add32(x1007, x1004, uint32(0x0)) + var x1010 uint32 + var x1011 uint32 + x1010, x1011 = bits.Add32(x1005, x1002, uint32(uint1(x1009))) + var x1012 uint32 + var x1013 uint32 + x1012, x1013 = bits.Add32(x1003, x1000, uint32(uint1(x1011))) + var x1014 uint32 + var x1015 uint32 + x1014, x1015 = bits.Add32(x1001, x998, uint32(uint1(x1013))) + var x1016 uint32 + var x1017 uint32 + x1016, x1017 = bits.Add32(x999, x996, uint32(uint1(x1015))) + var x1018 uint32 + var x1019 uint32 + x1018, x1019 = bits.Add32(x997, x994, uint32(uint1(x1017))) + var x1020 uint32 + var x1021 uint32 + x1020, x1021 = bits.Add32(x995, x992, uint32(uint1(x1019))) + var x1022 uint32 + var x1023 uint32 + x1022, x1023 = bits.Add32(x993, x990, uint32(uint1(x1021))) + var x1024 uint32 + var x1025 uint32 + x1024, x1025 = bits.Add32(x991, x988, uint32(uint1(x1023))) + var x1026 uint32 + var x1027 uint32 + x1026, x1027 = bits.Add32(x989, x986, uint32(uint1(x1025))) + var x1028 uint32 + var x1029 uint32 + x1028, x1029 = bits.Add32(x987, x984, uint32(uint1(x1027))) + var x1031 uint32 + _, x1031 = bits.Add32(x958, x1006, uint32(0x0)) + var x1032 uint32 + var x1033 uint32 + x1032, x1033 = bits.Add32(x960, x1008, uint32(uint1(x1031))) + var x1034 uint32 + var x1035 uint32 + x1034, x1035 = bits.Add32(x962, x1010, uint32(uint1(x1033))) + var x1036 uint32 + var x1037 uint32 + x1036, x1037 = bits.Add32(x964, x1012, uint32(uint1(x1035))) + var x1038 uint32 + var x1039 uint32 + x1038, x1039 = bits.Add32(x966, x1014, uint32(uint1(x1037))) + var x1040 uint32 + var x1041 uint32 + x1040, x1041 = bits.Add32(x968, x1016, uint32(uint1(x1039))) + var x1042 uint32 + var x1043 uint32 + x1042, x1043 = bits.Add32(x970, x1018, uint32(uint1(x1041))) + var x1044 uint32 + var x1045 uint32 + x1044, x1045 = bits.Add32(x972, x1020, uint32(uint1(x1043))) + var x1046 uint32 + var x1047 uint32 + x1046, x1047 = bits.Add32(x974, x1022, uint32(uint1(x1045))) + var x1048 uint32 + var x1049 uint32 + x1048, x1049 = bits.Add32(x976, x1024, uint32(uint1(x1047))) + var x1050 uint32 + var x1051 uint32 + x1050, x1051 = bits.Add32(x978, x1026, uint32(uint1(x1049))) + var x1052 uint32 + var x1053 uint32 + x1052, x1053 = bits.Add32(x980, x1028, uint32(uint1(x1051))) + var x1054 uint32 + var x1055 uint32 + x1054, x1055 = bits.Add32((uint32(uint1(x981)) + uint32(uint1(x957))), (uint32(uint1(x1029)) + x985), uint32(uint1(x1053))) + var x1056 uint32 + var x1057 uint32 + x1056, x1057 = bits.Add32(x1032, arg1[11], uint32(0x0)) + var x1058 uint32 + var x1059 uint32 + x1058, x1059 = bits.Add32(x1034, uint32(0x0), uint32(uint1(x1057))) + var x1060 uint32 + var x1061 uint32 + x1060, x1061 = bits.Add32(x1036, uint32(0x0), uint32(uint1(x1059))) + var x1062 uint32 + var x1063 uint32 + x1062, x1063 = bits.Add32(x1038, uint32(0x0), uint32(uint1(x1061))) + var x1064 uint32 + var x1065 uint32 + x1064, x1065 = bits.Add32(x1040, uint32(0x0), uint32(uint1(x1063))) + var x1066 uint32 + var x1067 uint32 + x1066, x1067 = bits.Add32(x1042, uint32(0x0), uint32(uint1(x1065))) + var x1068 uint32 + var x1069 uint32 + x1068, x1069 = bits.Add32(x1044, uint32(0x0), uint32(uint1(x1067))) + var x1070 uint32 + var x1071 uint32 + x1070, x1071 = bits.Add32(x1046, uint32(0x0), uint32(uint1(x1069))) + var x1072 uint32 + var x1073 uint32 + x1072, x1073 = bits.Add32(x1048, uint32(0x0), uint32(uint1(x1071))) + var x1074 uint32 + var x1075 uint32 + x1074, x1075 = bits.Add32(x1050, uint32(0x0), uint32(uint1(x1073))) + var x1076 uint32 + var x1077 uint32 + x1076, x1077 = bits.Add32(x1052, uint32(0x0), uint32(uint1(x1075))) + var x1078 uint32 + var x1079 uint32 + x1078, x1079 = bits.Add32(x1054, uint32(0x0), uint32(uint1(x1077))) + var x1080 uint32 + _, x1080 = bits.Mul32(x1056, 0xe88fdc45) + var x1082 uint32 + var x1083 uint32 + x1083, x1082 = bits.Mul32(x1080, 0xffffffff) + var x1084 uint32 + var x1085 uint32 + x1085, x1084 = bits.Mul32(x1080, 0xffffffff) + var x1086 uint32 + var x1087 uint32 + x1087, x1086 = bits.Mul32(x1080, 0xffffffff) + var x1088 uint32 + var x1089 uint32 + x1089, x1088 = bits.Mul32(x1080, 0xffffffff) + var x1090 uint32 + var x1091 uint32 + x1091, x1090 = bits.Mul32(x1080, 0xffffffff) + var x1092 uint32 + var x1093 uint32 + x1093, x1092 = bits.Mul32(x1080, 0xffffffff) + var x1094 uint32 + var x1095 uint32 + x1095, x1094 = bits.Mul32(x1080, 0xc7634d81) + var x1096 uint32 + var x1097 uint32 + x1097, x1096 = bits.Mul32(x1080, 0xf4372ddf) + var x1098 uint32 + var x1099 uint32 + x1099, x1098 = bits.Mul32(x1080, 0x581a0db2) + var x1100 uint32 + var x1101 uint32 + x1101, x1100 = bits.Mul32(x1080, 0x48b0a77a) + var x1102 uint32 + var x1103 uint32 + x1103, x1102 = bits.Mul32(x1080, 0xecec196a) + var x1104 uint32 + var x1105 uint32 + x1105, x1104 = bits.Mul32(x1080, 0xccc52973) + var x1106 uint32 + var x1107 uint32 + x1106, x1107 = bits.Add32(x1105, x1102, uint32(0x0)) + var x1108 uint32 + var x1109 uint32 + x1108, x1109 = bits.Add32(x1103, x1100, uint32(uint1(x1107))) + var x1110 uint32 + var x1111 uint32 + x1110, x1111 = bits.Add32(x1101, x1098, uint32(uint1(x1109))) + var x1112 uint32 + var x1113 uint32 + x1112, x1113 = bits.Add32(x1099, x1096, uint32(uint1(x1111))) + var x1114 uint32 + var x1115 uint32 + x1114, x1115 = bits.Add32(x1097, x1094, uint32(uint1(x1113))) + var x1116 uint32 + var x1117 uint32 + x1116, x1117 = bits.Add32(x1095, x1092, uint32(uint1(x1115))) + var x1118 uint32 + var x1119 uint32 + x1118, x1119 = bits.Add32(x1093, x1090, uint32(uint1(x1117))) + var x1120 uint32 + var x1121 uint32 + x1120, x1121 = bits.Add32(x1091, x1088, uint32(uint1(x1119))) + var x1122 uint32 + var x1123 uint32 + x1122, x1123 = bits.Add32(x1089, x1086, uint32(uint1(x1121))) + var x1124 uint32 + var x1125 uint32 + x1124, x1125 = bits.Add32(x1087, x1084, uint32(uint1(x1123))) + var x1126 uint32 + var x1127 uint32 + x1126, x1127 = bits.Add32(x1085, x1082, uint32(uint1(x1125))) + var x1129 uint32 + _, x1129 = bits.Add32(x1056, x1104, uint32(0x0)) + var x1130 uint32 + var x1131 uint32 + x1130, x1131 = bits.Add32(x1058, x1106, uint32(uint1(x1129))) + var x1132 uint32 + var x1133 uint32 + x1132, x1133 = bits.Add32(x1060, x1108, uint32(uint1(x1131))) + var x1134 uint32 + var x1135 uint32 + x1134, x1135 = bits.Add32(x1062, x1110, uint32(uint1(x1133))) + var x1136 uint32 + var x1137 uint32 + x1136, x1137 = bits.Add32(x1064, x1112, uint32(uint1(x1135))) + var x1138 uint32 + var x1139 uint32 + x1138, x1139 = bits.Add32(x1066, x1114, uint32(uint1(x1137))) + var x1140 uint32 + var x1141 uint32 + x1140, x1141 = bits.Add32(x1068, x1116, uint32(uint1(x1139))) + var x1142 uint32 + var x1143 uint32 + x1142, x1143 = bits.Add32(x1070, x1118, uint32(uint1(x1141))) + var x1144 uint32 + var x1145 uint32 + x1144, x1145 = bits.Add32(x1072, x1120, uint32(uint1(x1143))) + var x1146 uint32 + var x1147 uint32 + x1146, x1147 = bits.Add32(x1074, x1122, uint32(uint1(x1145))) + var x1148 uint32 + var x1149 uint32 + x1148, x1149 = bits.Add32(x1076, x1124, uint32(uint1(x1147))) + var x1150 uint32 + var x1151 uint32 + x1150, x1151 = bits.Add32(x1078, x1126, uint32(uint1(x1149))) + var x1152 uint32 + var x1153 uint32 + x1152, x1153 = bits.Add32((uint32(uint1(x1079)) + uint32(uint1(x1055))), (uint32(uint1(x1127)) + x1083), uint32(uint1(x1151))) + var x1154 uint32 + var x1155 uint32 + x1154, x1155 = bits.Sub32(x1130, 0xccc52973, uint32(0x0)) + var x1156 uint32 + var x1157 uint32 + x1156, x1157 = bits.Sub32(x1132, 0xecec196a, uint32(uint1(x1155))) + var x1158 uint32 + var x1159 uint32 + x1158, x1159 = bits.Sub32(x1134, 0x48b0a77a, uint32(uint1(x1157))) + var x1160 uint32 + var x1161 uint32 + x1160, x1161 = bits.Sub32(x1136, 0x581a0db2, uint32(uint1(x1159))) + var x1162 uint32 + var x1163 uint32 + x1162, x1163 = bits.Sub32(x1138, 0xf4372ddf, uint32(uint1(x1161))) + var x1164 uint32 + var x1165 uint32 + x1164, x1165 = bits.Sub32(x1140, 0xc7634d81, uint32(uint1(x1163))) + var x1166 uint32 + var x1167 uint32 + x1166, x1167 = bits.Sub32(x1142, 0xffffffff, uint32(uint1(x1165))) + var x1168 uint32 + var x1169 uint32 + x1168, x1169 = bits.Sub32(x1144, 0xffffffff, uint32(uint1(x1167))) + var x1170 uint32 + var x1171 uint32 + x1170, x1171 = bits.Sub32(x1146, 0xffffffff, uint32(uint1(x1169))) + var x1172 uint32 + var x1173 uint32 + x1172, x1173 = bits.Sub32(x1148, 0xffffffff, uint32(uint1(x1171))) + var x1174 uint32 + var x1175 uint32 + x1174, x1175 = bits.Sub32(x1150, 0xffffffff, uint32(uint1(x1173))) + var x1176 uint32 + var x1177 uint32 + x1176, x1177 = bits.Sub32(x1152, 0xffffffff, uint32(uint1(x1175))) + var x1179 uint32 + _, x1179 = bits.Sub32(uint32(uint1(x1153)), uint32(0x0), uint32(uint1(x1177))) + var x1180 uint32 + cmovznzU32(&x1180, uint1(x1179), x1154, x1130) + var x1181 uint32 + cmovznzU32(&x1181, uint1(x1179), x1156, x1132) + var x1182 uint32 + cmovznzU32(&x1182, uint1(x1179), x1158, x1134) + var x1183 uint32 + cmovznzU32(&x1183, uint1(x1179), x1160, x1136) + var x1184 uint32 + cmovznzU32(&x1184, uint1(x1179), x1162, x1138) + var x1185 uint32 + cmovznzU32(&x1185, uint1(x1179), x1164, x1140) + var x1186 uint32 + cmovznzU32(&x1186, uint1(x1179), x1166, x1142) + var x1187 uint32 + cmovznzU32(&x1187, uint1(x1179), x1168, x1144) + var x1188 uint32 + cmovznzU32(&x1188, uint1(x1179), x1170, x1146) + var x1189 uint32 + cmovznzU32(&x1189, uint1(x1179), x1172, x1148) + var x1190 uint32 + cmovznzU32(&x1190, uint1(x1179), x1174, x1150) + var x1191 uint32 + cmovznzU32(&x1191, uint1(x1179), x1176, x1152) + out1[0] = x1180 + out1[1] = x1181 + out1[2] = x1182 + out1[3] = x1183 + out1[4] = x1184 + out1[5] = x1185 + out1[6] = x1186 + out1[7] = x1187 + out1[8] = x1188 + out1[9] = x1189 + out1[10] = x1190 + out1[11] = x1191 +} + +// ToMontgomery translates a field element into the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = eval arg1 mod m +// 0 ≤ eval out1 < m +// +func ToMontgomery(out1 *MontgomeryDomainFieldElement, arg1 *NonMontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[6] + x7 := arg1[7] + x8 := arg1[8] + x9 := arg1[9] + x10 := arg1[10] + x11 := arg1[11] + x12 := arg1[0] + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x12, 0xc84ee01) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x12, 0x2b39bf21) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x12, 0x3fb05b7a) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x12, 0x28266895) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x12, 0xd40d4917) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x12, 0x4aab1cc5) + var x25 uint32 + var x26 uint32 + x26, x25 = bits.Mul32(x12, 0xbc3e483a) + var x27 uint32 + var x28 uint32 + x28, x27 = bits.Mul32(x12, 0xfcb82947) + var x29 uint32 + var x30 uint32 + x30, x29 = bits.Mul32(x12, 0xff3d81e5) + var x31 uint32 + var x32 uint32 + x32, x31 = bits.Mul32(x12, 0xdf1aa419) + var x33 uint32 + var x34 uint32 + x34, x33 = bits.Mul32(x12, 0x2d319b24) + var x35 uint32 + var x36 uint32 + x36, x35 = bits.Mul32(x12, 0x19b409a9) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Add32(x36, x33, uint32(0x0)) + var x39 uint32 + var x40 uint32 + x39, x40 = bits.Add32(x34, x31, uint32(uint1(x38))) + var x41 uint32 + var x42 uint32 + x41, x42 = bits.Add32(x32, x29, uint32(uint1(x40))) + var x43 uint32 + var x44 uint32 + x43, x44 = bits.Add32(x30, x27, uint32(uint1(x42))) + var x45 uint32 + var x46 uint32 + x45, x46 = bits.Add32(x28, x25, uint32(uint1(x44))) + var x47 uint32 + var x48 uint32 + x47, x48 = bits.Add32(x26, x23, uint32(uint1(x46))) + var x49 uint32 + var x50 uint32 + x49, x50 = bits.Add32(x24, x21, uint32(uint1(x48))) + var x51 uint32 + var x52 uint32 + x51, x52 = bits.Add32(x22, x19, uint32(uint1(x50))) + var x53 uint32 + var x54 uint32 + x53, x54 = bits.Add32(x20, x17, uint32(uint1(x52))) + var x55 uint32 + var x56 uint32 + x55, x56 = bits.Add32(x18, x15, uint32(uint1(x54))) + var x57 uint32 + var x58 uint32 + x57, x58 = bits.Add32(x16, x13, uint32(uint1(x56))) + var x59 uint32 + _, x59 = bits.Mul32(x35, 0xe88fdc45) + var x61 uint32 + var x62 uint32 + x62, x61 = bits.Mul32(x59, 0xffffffff) + var x63 uint32 + var x64 uint32 + x64, x63 = bits.Mul32(x59, 0xffffffff) + var x65 uint32 + var x66 uint32 + x66, x65 = bits.Mul32(x59, 0xffffffff) + var x67 uint32 + var x68 uint32 + x68, x67 = bits.Mul32(x59, 0xffffffff) + var x69 uint32 + var x70 uint32 + x70, x69 = bits.Mul32(x59, 0xffffffff) + var x71 uint32 + var x72 uint32 + x72, x71 = bits.Mul32(x59, 0xffffffff) + var x73 uint32 + var x74 uint32 + x74, x73 = bits.Mul32(x59, 0xc7634d81) + var x75 uint32 + var x76 uint32 + x76, x75 = bits.Mul32(x59, 0xf4372ddf) + var x77 uint32 + var x78 uint32 + x78, x77 = bits.Mul32(x59, 0x581a0db2) + var x79 uint32 + var x80 uint32 + x80, x79 = bits.Mul32(x59, 0x48b0a77a) + var x81 uint32 + var x82 uint32 + x82, x81 = bits.Mul32(x59, 0xecec196a) + var x83 uint32 + var x84 uint32 + x84, x83 = bits.Mul32(x59, 0xccc52973) + var x85 uint32 + var x86 uint32 + x85, x86 = bits.Add32(x84, x81, uint32(0x0)) + var x87 uint32 + var x88 uint32 + x87, x88 = bits.Add32(x82, x79, uint32(uint1(x86))) + var x89 uint32 + var x90 uint32 + x89, x90 = bits.Add32(x80, x77, uint32(uint1(x88))) + var x91 uint32 + var x92 uint32 + x91, x92 = bits.Add32(x78, x75, uint32(uint1(x90))) + var x93 uint32 + var x94 uint32 + x93, x94 = bits.Add32(x76, x73, uint32(uint1(x92))) + var x95 uint32 + var x96 uint32 + x95, x96 = bits.Add32(x74, x71, uint32(uint1(x94))) + var x97 uint32 + var x98 uint32 + x97, x98 = bits.Add32(x72, x69, uint32(uint1(x96))) + var x99 uint32 + var x100 uint32 + x99, x100 = bits.Add32(x70, x67, uint32(uint1(x98))) + var x101 uint32 + var x102 uint32 + x101, x102 = bits.Add32(x68, x65, uint32(uint1(x100))) + var x103 uint32 + var x104 uint32 + x103, x104 = bits.Add32(x66, x63, uint32(uint1(x102))) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Add32(x64, x61, uint32(uint1(x104))) + var x108 uint32 + _, x108 = bits.Add32(x35, x83, uint32(0x0)) + var x109 uint32 + var x110 uint32 + x109, x110 = bits.Add32(x37, x85, uint32(uint1(x108))) + var x111 uint32 + var x112 uint32 + x111, x112 = bits.Add32(x39, x87, uint32(uint1(x110))) + var x113 uint32 + var x114 uint32 + x113, x114 = bits.Add32(x41, x89, uint32(uint1(x112))) + var x115 uint32 + var x116 uint32 + x115, x116 = bits.Add32(x43, x91, uint32(uint1(x114))) + var x117 uint32 + var x118 uint32 + x117, x118 = bits.Add32(x45, x93, uint32(uint1(x116))) + var x119 uint32 + var x120 uint32 + x119, x120 = bits.Add32(x47, x95, uint32(uint1(x118))) + var x121 uint32 + var x122 uint32 + x121, x122 = bits.Add32(x49, x97, uint32(uint1(x120))) + var x123 uint32 + var x124 uint32 + x123, x124 = bits.Add32(x51, x99, uint32(uint1(x122))) + var x125 uint32 + var x126 uint32 + x125, x126 = bits.Add32(x53, x101, uint32(uint1(x124))) + var x127 uint32 + var x128 uint32 + x127, x128 = bits.Add32(x55, x103, uint32(uint1(x126))) + var x129 uint32 + var x130 uint32 + x129, x130 = bits.Add32(x57, x105, uint32(uint1(x128))) + var x131 uint32 + var x132 uint32 + x131, x132 = bits.Add32((uint32(uint1(x58)) + x14), (uint32(uint1(x106)) + x62), uint32(uint1(x130))) + var x133 uint32 + var x134 uint32 + x134, x133 = bits.Mul32(x1, 0xc84ee01) + var x135 uint32 + var x136 uint32 + x136, x135 = bits.Mul32(x1, 0x2b39bf21) + var x137 uint32 + var x138 uint32 + x138, x137 = bits.Mul32(x1, 0x3fb05b7a) + var x139 uint32 + var x140 uint32 + x140, x139 = bits.Mul32(x1, 0x28266895) + var x141 uint32 + var x142 uint32 + x142, x141 = bits.Mul32(x1, 0xd40d4917) + var x143 uint32 + var x144 uint32 + x144, x143 = bits.Mul32(x1, 0x4aab1cc5) + var x145 uint32 + var x146 uint32 + x146, x145 = bits.Mul32(x1, 0xbc3e483a) + var x147 uint32 + var x148 uint32 + x148, x147 = bits.Mul32(x1, 0xfcb82947) + var x149 uint32 + var x150 uint32 + x150, x149 = bits.Mul32(x1, 0xff3d81e5) + var x151 uint32 + var x152 uint32 + x152, x151 = bits.Mul32(x1, 0xdf1aa419) + var x153 uint32 + var x154 uint32 + x154, x153 = bits.Mul32(x1, 0x2d319b24) + var x155 uint32 + var x156 uint32 + x156, x155 = bits.Mul32(x1, 0x19b409a9) + var x157 uint32 + var x158 uint32 + x157, x158 = bits.Add32(x156, x153, uint32(0x0)) + var x159 uint32 + var x160 uint32 + x159, x160 = bits.Add32(x154, x151, uint32(uint1(x158))) + var x161 uint32 + var x162 uint32 + x161, x162 = bits.Add32(x152, x149, uint32(uint1(x160))) + var x163 uint32 + var x164 uint32 + x163, x164 = bits.Add32(x150, x147, uint32(uint1(x162))) + var x165 uint32 + var x166 uint32 + x165, x166 = bits.Add32(x148, x145, uint32(uint1(x164))) + var x167 uint32 + var x168 uint32 + x167, x168 = bits.Add32(x146, x143, uint32(uint1(x166))) + var x169 uint32 + var x170 uint32 + x169, x170 = bits.Add32(x144, x141, uint32(uint1(x168))) + var x171 uint32 + var x172 uint32 + x171, x172 = bits.Add32(x142, x139, uint32(uint1(x170))) + var x173 uint32 + var x174 uint32 + x173, x174 = bits.Add32(x140, x137, uint32(uint1(x172))) + var x175 uint32 + var x176 uint32 + x175, x176 = bits.Add32(x138, x135, uint32(uint1(x174))) + var x177 uint32 + var x178 uint32 + x177, x178 = bits.Add32(x136, x133, uint32(uint1(x176))) + var x179 uint32 + var x180 uint32 + x179, x180 = bits.Add32(x109, x155, uint32(0x0)) + var x181 uint32 + var x182 uint32 + x181, x182 = bits.Add32(x111, x157, uint32(uint1(x180))) + var x183 uint32 + var x184 uint32 + x183, x184 = bits.Add32(x113, x159, uint32(uint1(x182))) + var x185 uint32 + var x186 uint32 + x185, x186 = bits.Add32(x115, x161, uint32(uint1(x184))) + var x187 uint32 + var x188 uint32 + x187, x188 = bits.Add32(x117, x163, uint32(uint1(x186))) + var x189 uint32 + var x190 uint32 + x189, x190 = bits.Add32(x119, x165, uint32(uint1(x188))) + var x191 uint32 + var x192 uint32 + x191, x192 = bits.Add32(x121, x167, uint32(uint1(x190))) + var x193 uint32 + var x194 uint32 + x193, x194 = bits.Add32(x123, x169, uint32(uint1(x192))) + var x195 uint32 + var x196 uint32 + x195, x196 = bits.Add32(x125, x171, uint32(uint1(x194))) + var x197 uint32 + var x198 uint32 + x197, x198 = bits.Add32(x127, x173, uint32(uint1(x196))) + var x199 uint32 + var x200 uint32 + x199, x200 = bits.Add32(x129, x175, uint32(uint1(x198))) + var x201 uint32 + var x202 uint32 + x201, x202 = bits.Add32(x131, x177, uint32(uint1(x200))) + var x203 uint32 + _, x203 = bits.Mul32(x179, 0xe88fdc45) + var x205 uint32 + var x206 uint32 + x206, x205 = bits.Mul32(x203, 0xffffffff) + var x207 uint32 + var x208 uint32 + x208, x207 = bits.Mul32(x203, 0xffffffff) + var x209 uint32 + var x210 uint32 + x210, x209 = bits.Mul32(x203, 0xffffffff) + var x211 uint32 + var x212 uint32 + x212, x211 = bits.Mul32(x203, 0xffffffff) + var x213 uint32 + var x214 uint32 + x214, x213 = bits.Mul32(x203, 0xffffffff) + var x215 uint32 + var x216 uint32 + x216, x215 = bits.Mul32(x203, 0xffffffff) + var x217 uint32 + var x218 uint32 + x218, x217 = bits.Mul32(x203, 0xc7634d81) + var x219 uint32 + var x220 uint32 + x220, x219 = bits.Mul32(x203, 0xf4372ddf) + var x221 uint32 + var x222 uint32 + x222, x221 = bits.Mul32(x203, 0x581a0db2) + var x223 uint32 + var x224 uint32 + x224, x223 = bits.Mul32(x203, 0x48b0a77a) + var x225 uint32 + var x226 uint32 + x226, x225 = bits.Mul32(x203, 0xecec196a) + var x227 uint32 + var x228 uint32 + x228, x227 = bits.Mul32(x203, 0xccc52973) + var x229 uint32 + var x230 uint32 + x229, x230 = bits.Add32(x228, x225, uint32(0x0)) + var x231 uint32 + var x232 uint32 + x231, x232 = bits.Add32(x226, x223, uint32(uint1(x230))) + var x233 uint32 + var x234 uint32 + x233, x234 = bits.Add32(x224, x221, uint32(uint1(x232))) + var x235 uint32 + var x236 uint32 + x235, x236 = bits.Add32(x222, x219, uint32(uint1(x234))) + var x237 uint32 + var x238 uint32 + x237, x238 = bits.Add32(x220, x217, uint32(uint1(x236))) + var x239 uint32 + var x240 uint32 + x239, x240 = bits.Add32(x218, x215, uint32(uint1(x238))) + var x241 uint32 + var x242 uint32 + x241, x242 = bits.Add32(x216, x213, uint32(uint1(x240))) + var x243 uint32 + var x244 uint32 + x243, x244 = bits.Add32(x214, x211, uint32(uint1(x242))) + var x245 uint32 + var x246 uint32 + x245, x246 = bits.Add32(x212, x209, uint32(uint1(x244))) + var x247 uint32 + var x248 uint32 + x247, x248 = bits.Add32(x210, x207, uint32(uint1(x246))) + var x249 uint32 + var x250 uint32 + x249, x250 = bits.Add32(x208, x205, uint32(uint1(x248))) + var x252 uint32 + _, x252 = bits.Add32(x179, x227, uint32(0x0)) + var x253 uint32 + var x254 uint32 + x253, x254 = bits.Add32(x181, x229, uint32(uint1(x252))) + var x255 uint32 + var x256 uint32 + x255, x256 = bits.Add32(x183, x231, uint32(uint1(x254))) + var x257 uint32 + var x258 uint32 + x257, x258 = bits.Add32(x185, x233, uint32(uint1(x256))) + var x259 uint32 + var x260 uint32 + x259, x260 = bits.Add32(x187, x235, uint32(uint1(x258))) + var x261 uint32 + var x262 uint32 + x261, x262 = bits.Add32(x189, x237, uint32(uint1(x260))) + var x263 uint32 + var x264 uint32 + x263, x264 = bits.Add32(x191, x239, uint32(uint1(x262))) + var x265 uint32 + var x266 uint32 + x265, x266 = bits.Add32(x193, x241, uint32(uint1(x264))) + var x267 uint32 + var x268 uint32 + x267, x268 = bits.Add32(x195, x243, uint32(uint1(x266))) + var x269 uint32 + var x270 uint32 + x269, x270 = bits.Add32(x197, x245, uint32(uint1(x268))) + var x271 uint32 + var x272 uint32 + x271, x272 = bits.Add32(x199, x247, uint32(uint1(x270))) + var x273 uint32 + var x274 uint32 + x273, x274 = bits.Add32(x201, x249, uint32(uint1(x272))) + var x275 uint32 + var x276 uint32 + x275, x276 = bits.Add32(((uint32(uint1(x202)) + uint32(uint1(x132))) + (uint32(uint1(x178)) + x134)), (uint32(uint1(x250)) + x206), uint32(uint1(x274))) + var x277 uint32 + var x278 uint32 + x278, x277 = bits.Mul32(x2, 0xc84ee01) + var x279 uint32 + var x280 uint32 + x280, x279 = bits.Mul32(x2, 0x2b39bf21) + var x281 uint32 + var x282 uint32 + x282, x281 = bits.Mul32(x2, 0x3fb05b7a) + var x283 uint32 + var x284 uint32 + x284, x283 = bits.Mul32(x2, 0x28266895) + var x285 uint32 + var x286 uint32 + x286, x285 = bits.Mul32(x2, 0xd40d4917) + var x287 uint32 + var x288 uint32 + x288, x287 = bits.Mul32(x2, 0x4aab1cc5) + var x289 uint32 + var x290 uint32 + x290, x289 = bits.Mul32(x2, 0xbc3e483a) + var x291 uint32 + var x292 uint32 + x292, x291 = bits.Mul32(x2, 0xfcb82947) + var x293 uint32 + var x294 uint32 + x294, x293 = bits.Mul32(x2, 0xff3d81e5) + var x295 uint32 + var x296 uint32 + x296, x295 = bits.Mul32(x2, 0xdf1aa419) + var x297 uint32 + var x298 uint32 + x298, x297 = bits.Mul32(x2, 0x2d319b24) + var x299 uint32 + var x300 uint32 + x300, x299 = bits.Mul32(x2, 0x19b409a9) + var x301 uint32 + var x302 uint32 + x301, x302 = bits.Add32(x300, x297, uint32(0x0)) + var x303 uint32 + var x304 uint32 + x303, x304 = bits.Add32(x298, x295, uint32(uint1(x302))) + var x305 uint32 + var x306 uint32 + x305, x306 = bits.Add32(x296, x293, uint32(uint1(x304))) + var x307 uint32 + var x308 uint32 + x307, x308 = bits.Add32(x294, x291, uint32(uint1(x306))) + var x309 uint32 + var x310 uint32 + x309, x310 = bits.Add32(x292, x289, uint32(uint1(x308))) + var x311 uint32 + var x312 uint32 + x311, x312 = bits.Add32(x290, x287, uint32(uint1(x310))) + var x313 uint32 + var x314 uint32 + x313, x314 = bits.Add32(x288, x285, uint32(uint1(x312))) + var x315 uint32 + var x316 uint32 + x315, x316 = bits.Add32(x286, x283, uint32(uint1(x314))) + var x317 uint32 + var x318 uint32 + x317, x318 = bits.Add32(x284, x281, uint32(uint1(x316))) + var x319 uint32 + var x320 uint32 + x319, x320 = bits.Add32(x282, x279, uint32(uint1(x318))) + var x321 uint32 + var x322 uint32 + x321, x322 = bits.Add32(x280, x277, uint32(uint1(x320))) + var x323 uint32 + var x324 uint32 + x323, x324 = bits.Add32(x253, x299, uint32(0x0)) + var x325 uint32 + var x326 uint32 + x325, x326 = bits.Add32(x255, x301, uint32(uint1(x324))) + var x327 uint32 + var x328 uint32 + x327, x328 = bits.Add32(x257, x303, uint32(uint1(x326))) + var x329 uint32 + var x330 uint32 + x329, x330 = bits.Add32(x259, x305, uint32(uint1(x328))) + var x331 uint32 + var x332 uint32 + x331, x332 = bits.Add32(x261, x307, uint32(uint1(x330))) + var x333 uint32 + var x334 uint32 + x333, x334 = bits.Add32(x263, x309, uint32(uint1(x332))) + var x335 uint32 + var x336 uint32 + x335, x336 = bits.Add32(x265, x311, uint32(uint1(x334))) + var x337 uint32 + var x338 uint32 + x337, x338 = bits.Add32(x267, x313, uint32(uint1(x336))) + var x339 uint32 + var x340 uint32 + x339, x340 = bits.Add32(x269, x315, uint32(uint1(x338))) + var x341 uint32 + var x342 uint32 + x341, x342 = bits.Add32(x271, x317, uint32(uint1(x340))) + var x343 uint32 + var x344 uint32 + x343, x344 = bits.Add32(x273, x319, uint32(uint1(x342))) + var x345 uint32 + var x346 uint32 + x345, x346 = bits.Add32(x275, x321, uint32(uint1(x344))) + var x347 uint32 + _, x347 = bits.Mul32(x323, 0xe88fdc45) + var x349 uint32 + var x350 uint32 + x350, x349 = bits.Mul32(x347, 0xffffffff) + var x351 uint32 + var x352 uint32 + x352, x351 = bits.Mul32(x347, 0xffffffff) + var x353 uint32 + var x354 uint32 + x354, x353 = bits.Mul32(x347, 0xffffffff) + var x355 uint32 + var x356 uint32 + x356, x355 = bits.Mul32(x347, 0xffffffff) + var x357 uint32 + var x358 uint32 + x358, x357 = bits.Mul32(x347, 0xffffffff) + var x359 uint32 + var x360 uint32 + x360, x359 = bits.Mul32(x347, 0xffffffff) + var x361 uint32 + var x362 uint32 + x362, x361 = bits.Mul32(x347, 0xc7634d81) + var x363 uint32 + var x364 uint32 + x364, x363 = bits.Mul32(x347, 0xf4372ddf) + var x365 uint32 + var x366 uint32 + x366, x365 = bits.Mul32(x347, 0x581a0db2) + var x367 uint32 + var x368 uint32 + x368, x367 = bits.Mul32(x347, 0x48b0a77a) + var x369 uint32 + var x370 uint32 + x370, x369 = bits.Mul32(x347, 0xecec196a) + var x371 uint32 + var x372 uint32 + x372, x371 = bits.Mul32(x347, 0xccc52973) + var x373 uint32 + var x374 uint32 + x373, x374 = bits.Add32(x372, x369, uint32(0x0)) + var x375 uint32 + var x376 uint32 + x375, x376 = bits.Add32(x370, x367, uint32(uint1(x374))) + var x377 uint32 + var x378 uint32 + x377, x378 = bits.Add32(x368, x365, uint32(uint1(x376))) + var x379 uint32 + var x380 uint32 + x379, x380 = bits.Add32(x366, x363, uint32(uint1(x378))) + var x381 uint32 + var x382 uint32 + x381, x382 = bits.Add32(x364, x361, uint32(uint1(x380))) + var x383 uint32 + var x384 uint32 + x383, x384 = bits.Add32(x362, x359, uint32(uint1(x382))) + var x385 uint32 + var x386 uint32 + x385, x386 = bits.Add32(x360, x357, uint32(uint1(x384))) + var x387 uint32 + var x388 uint32 + x387, x388 = bits.Add32(x358, x355, uint32(uint1(x386))) + var x389 uint32 + var x390 uint32 + x389, x390 = bits.Add32(x356, x353, uint32(uint1(x388))) + var x391 uint32 + var x392 uint32 + x391, x392 = bits.Add32(x354, x351, uint32(uint1(x390))) + var x393 uint32 + var x394 uint32 + x393, x394 = bits.Add32(x352, x349, uint32(uint1(x392))) + var x396 uint32 + _, x396 = bits.Add32(x323, x371, uint32(0x0)) + var x397 uint32 + var x398 uint32 + x397, x398 = bits.Add32(x325, x373, uint32(uint1(x396))) + var x399 uint32 + var x400 uint32 + x399, x400 = bits.Add32(x327, x375, uint32(uint1(x398))) + var x401 uint32 + var x402 uint32 + x401, x402 = bits.Add32(x329, x377, uint32(uint1(x400))) + var x403 uint32 + var x404 uint32 + x403, x404 = bits.Add32(x331, x379, uint32(uint1(x402))) + var x405 uint32 + var x406 uint32 + x405, x406 = bits.Add32(x333, x381, uint32(uint1(x404))) + var x407 uint32 + var x408 uint32 + x407, x408 = bits.Add32(x335, x383, uint32(uint1(x406))) + var x409 uint32 + var x410 uint32 + x409, x410 = bits.Add32(x337, x385, uint32(uint1(x408))) + var x411 uint32 + var x412 uint32 + x411, x412 = bits.Add32(x339, x387, uint32(uint1(x410))) + var x413 uint32 + var x414 uint32 + x413, x414 = bits.Add32(x341, x389, uint32(uint1(x412))) + var x415 uint32 + var x416 uint32 + x415, x416 = bits.Add32(x343, x391, uint32(uint1(x414))) + var x417 uint32 + var x418 uint32 + x417, x418 = bits.Add32(x345, x393, uint32(uint1(x416))) + var x419 uint32 + var x420 uint32 + x419, x420 = bits.Add32(((uint32(uint1(x346)) + uint32(uint1(x276))) + (uint32(uint1(x322)) + x278)), (uint32(uint1(x394)) + x350), uint32(uint1(x418))) + var x421 uint32 + var x422 uint32 + x422, x421 = bits.Mul32(x3, 0xc84ee01) + var x423 uint32 + var x424 uint32 + x424, x423 = bits.Mul32(x3, 0x2b39bf21) + var x425 uint32 + var x426 uint32 + x426, x425 = bits.Mul32(x3, 0x3fb05b7a) + var x427 uint32 + var x428 uint32 + x428, x427 = bits.Mul32(x3, 0x28266895) + var x429 uint32 + var x430 uint32 + x430, x429 = bits.Mul32(x3, 0xd40d4917) + var x431 uint32 + var x432 uint32 + x432, x431 = bits.Mul32(x3, 0x4aab1cc5) + var x433 uint32 + var x434 uint32 + x434, x433 = bits.Mul32(x3, 0xbc3e483a) + var x435 uint32 + var x436 uint32 + x436, x435 = bits.Mul32(x3, 0xfcb82947) + var x437 uint32 + var x438 uint32 + x438, x437 = bits.Mul32(x3, 0xff3d81e5) + var x439 uint32 + var x440 uint32 + x440, x439 = bits.Mul32(x3, 0xdf1aa419) + var x441 uint32 + var x442 uint32 + x442, x441 = bits.Mul32(x3, 0x2d319b24) + var x443 uint32 + var x444 uint32 + x444, x443 = bits.Mul32(x3, 0x19b409a9) + var x445 uint32 + var x446 uint32 + x445, x446 = bits.Add32(x444, x441, uint32(0x0)) + var x447 uint32 + var x448 uint32 + x447, x448 = bits.Add32(x442, x439, uint32(uint1(x446))) + var x449 uint32 + var x450 uint32 + x449, x450 = bits.Add32(x440, x437, uint32(uint1(x448))) + var x451 uint32 + var x452 uint32 + x451, x452 = bits.Add32(x438, x435, uint32(uint1(x450))) + var x453 uint32 + var x454 uint32 + x453, x454 = bits.Add32(x436, x433, uint32(uint1(x452))) + var x455 uint32 + var x456 uint32 + x455, x456 = bits.Add32(x434, x431, uint32(uint1(x454))) + var x457 uint32 + var x458 uint32 + x457, x458 = bits.Add32(x432, x429, uint32(uint1(x456))) + var x459 uint32 + var x460 uint32 + x459, x460 = bits.Add32(x430, x427, uint32(uint1(x458))) + var x461 uint32 + var x462 uint32 + x461, x462 = bits.Add32(x428, x425, uint32(uint1(x460))) + var x463 uint32 + var x464 uint32 + x463, x464 = bits.Add32(x426, x423, uint32(uint1(x462))) + var x465 uint32 + var x466 uint32 + x465, x466 = bits.Add32(x424, x421, uint32(uint1(x464))) + var x467 uint32 + var x468 uint32 + x467, x468 = bits.Add32(x397, x443, uint32(0x0)) + var x469 uint32 + var x470 uint32 + x469, x470 = bits.Add32(x399, x445, uint32(uint1(x468))) + var x471 uint32 + var x472 uint32 + x471, x472 = bits.Add32(x401, x447, uint32(uint1(x470))) + var x473 uint32 + var x474 uint32 + x473, x474 = bits.Add32(x403, x449, uint32(uint1(x472))) + var x475 uint32 + var x476 uint32 + x475, x476 = bits.Add32(x405, x451, uint32(uint1(x474))) + var x477 uint32 + var x478 uint32 + x477, x478 = bits.Add32(x407, x453, uint32(uint1(x476))) + var x479 uint32 + var x480 uint32 + x479, x480 = bits.Add32(x409, x455, uint32(uint1(x478))) + var x481 uint32 + var x482 uint32 + x481, x482 = bits.Add32(x411, x457, uint32(uint1(x480))) + var x483 uint32 + var x484 uint32 + x483, x484 = bits.Add32(x413, x459, uint32(uint1(x482))) + var x485 uint32 + var x486 uint32 + x485, x486 = bits.Add32(x415, x461, uint32(uint1(x484))) + var x487 uint32 + var x488 uint32 + x487, x488 = bits.Add32(x417, x463, uint32(uint1(x486))) + var x489 uint32 + var x490 uint32 + x489, x490 = bits.Add32(x419, x465, uint32(uint1(x488))) + var x491 uint32 + _, x491 = bits.Mul32(x467, 0xe88fdc45) + var x493 uint32 + var x494 uint32 + x494, x493 = bits.Mul32(x491, 0xffffffff) + var x495 uint32 + var x496 uint32 + x496, x495 = bits.Mul32(x491, 0xffffffff) + var x497 uint32 + var x498 uint32 + x498, x497 = bits.Mul32(x491, 0xffffffff) + var x499 uint32 + var x500 uint32 + x500, x499 = bits.Mul32(x491, 0xffffffff) + var x501 uint32 + var x502 uint32 + x502, x501 = bits.Mul32(x491, 0xffffffff) + var x503 uint32 + var x504 uint32 + x504, x503 = bits.Mul32(x491, 0xffffffff) + var x505 uint32 + var x506 uint32 + x506, x505 = bits.Mul32(x491, 0xc7634d81) + var x507 uint32 + var x508 uint32 + x508, x507 = bits.Mul32(x491, 0xf4372ddf) + var x509 uint32 + var x510 uint32 + x510, x509 = bits.Mul32(x491, 0x581a0db2) + var x511 uint32 + var x512 uint32 + x512, x511 = bits.Mul32(x491, 0x48b0a77a) + var x513 uint32 + var x514 uint32 + x514, x513 = bits.Mul32(x491, 0xecec196a) + var x515 uint32 + var x516 uint32 + x516, x515 = bits.Mul32(x491, 0xccc52973) + var x517 uint32 + var x518 uint32 + x517, x518 = bits.Add32(x516, x513, uint32(0x0)) + var x519 uint32 + var x520 uint32 + x519, x520 = bits.Add32(x514, x511, uint32(uint1(x518))) + var x521 uint32 + var x522 uint32 + x521, x522 = bits.Add32(x512, x509, uint32(uint1(x520))) + var x523 uint32 + var x524 uint32 + x523, x524 = bits.Add32(x510, x507, uint32(uint1(x522))) + var x525 uint32 + var x526 uint32 + x525, x526 = bits.Add32(x508, x505, uint32(uint1(x524))) + var x527 uint32 + var x528 uint32 + x527, x528 = bits.Add32(x506, x503, uint32(uint1(x526))) + var x529 uint32 + var x530 uint32 + x529, x530 = bits.Add32(x504, x501, uint32(uint1(x528))) + var x531 uint32 + var x532 uint32 + x531, x532 = bits.Add32(x502, x499, uint32(uint1(x530))) + var x533 uint32 + var x534 uint32 + x533, x534 = bits.Add32(x500, x497, uint32(uint1(x532))) + var x535 uint32 + var x536 uint32 + x535, x536 = bits.Add32(x498, x495, uint32(uint1(x534))) + var x537 uint32 + var x538 uint32 + x537, x538 = bits.Add32(x496, x493, uint32(uint1(x536))) + var x540 uint32 + _, x540 = bits.Add32(x467, x515, uint32(0x0)) + var x541 uint32 + var x542 uint32 + x541, x542 = bits.Add32(x469, x517, uint32(uint1(x540))) + var x543 uint32 + var x544 uint32 + x543, x544 = bits.Add32(x471, x519, uint32(uint1(x542))) + var x545 uint32 + var x546 uint32 + x545, x546 = bits.Add32(x473, x521, uint32(uint1(x544))) + var x547 uint32 + var x548 uint32 + x547, x548 = bits.Add32(x475, x523, uint32(uint1(x546))) + var x549 uint32 + var x550 uint32 + x549, x550 = bits.Add32(x477, x525, uint32(uint1(x548))) + var x551 uint32 + var x552 uint32 + x551, x552 = bits.Add32(x479, x527, uint32(uint1(x550))) + var x553 uint32 + var x554 uint32 + x553, x554 = bits.Add32(x481, x529, uint32(uint1(x552))) + var x555 uint32 + var x556 uint32 + x555, x556 = bits.Add32(x483, x531, uint32(uint1(x554))) + var x557 uint32 + var x558 uint32 + x557, x558 = bits.Add32(x485, x533, uint32(uint1(x556))) + var x559 uint32 + var x560 uint32 + x559, x560 = bits.Add32(x487, x535, uint32(uint1(x558))) + var x561 uint32 + var x562 uint32 + x561, x562 = bits.Add32(x489, x537, uint32(uint1(x560))) + var x563 uint32 + var x564 uint32 + x563, x564 = bits.Add32(((uint32(uint1(x490)) + uint32(uint1(x420))) + (uint32(uint1(x466)) + x422)), (uint32(uint1(x538)) + x494), uint32(uint1(x562))) + var x565 uint32 + var x566 uint32 + x566, x565 = bits.Mul32(x4, 0xc84ee01) + var x567 uint32 + var x568 uint32 + x568, x567 = bits.Mul32(x4, 0x2b39bf21) + var x569 uint32 + var x570 uint32 + x570, x569 = bits.Mul32(x4, 0x3fb05b7a) + var x571 uint32 + var x572 uint32 + x572, x571 = bits.Mul32(x4, 0x28266895) + var x573 uint32 + var x574 uint32 + x574, x573 = bits.Mul32(x4, 0xd40d4917) + var x575 uint32 + var x576 uint32 + x576, x575 = bits.Mul32(x4, 0x4aab1cc5) + var x577 uint32 + var x578 uint32 + x578, x577 = bits.Mul32(x4, 0xbc3e483a) + var x579 uint32 + var x580 uint32 + x580, x579 = bits.Mul32(x4, 0xfcb82947) + var x581 uint32 + var x582 uint32 + x582, x581 = bits.Mul32(x4, 0xff3d81e5) + var x583 uint32 + var x584 uint32 + x584, x583 = bits.Mul32(x4, 0xdf1aa419) + var x585 uint32 + var x586 uint32 + x586, x585 = bits.Mul32(x4, 0x2d319b24) + var x587 uint32 + var x588 uint32 + x588, x587 = bits.Mul32(x4, 0x19b409a9) + var x589 uint32 + var x590 uint32 + x589, x590 = bits.Add32(x588, x585, uint32(0x0)) + var x591 uint32 + var x592 uint32 + x591, x592 = bits.Add32(x586, x583, uint32(uint1(x590))) + var x593 uint32 + var x594 uint32 + x593, x594 = bits.Add32(x584, x581, uint32(uint1(x592))) + var x595 uint32 + var x596 uint32 + x595, x596 = bits.Add32(x582, x579, uint32(uint1(x594))) + var x597 uint32 + var x598 uint32 + x597, x598 = bits.Add32(x580, x577, uint32(uint1(x596))) + var x599 uint32 + var x600 uint32 + x599, x600 = bits.Add32(x578, x575, uint32(uint1(x598))) + var x601 uint32 + var x602 uint32 + x601, x602 = bits.Add32(x576, x573, uint32(uint1(x600))) + var x603 uint32 + var x604 uint32 + x603, x604 = bits.Add32(x574, x571, uint32(uint1(x602))) + var x605 uint32 + var x606 uint32 + x605, x606 = bits.Add32(x572, x569, uint32(uint1(x604))) + var x607 uint32 + var x608 uint32 + x607, x608 = bits.Add32(x570, x567, uint32(uint1(x606))) + var x609 uint32 + var x610 uint32 + x609, x610 = bits.Add32(x568, x565, uint32(uint1(x608))) + var x611 uint32 + var x612 uint32 + x611, x612 = bits.Add32(x541, x587, uint32(0x0)) + var x613 uint32 + var x614 uint32 + x613, x614 = bits.Add32(x543, x589, uint32(uint1(x612))) + var x615 uint32 + var x616 uint32 + x615, x616 = bits.Add32(x545, x591, uint32(uint1(x614))) + var x617 uint32 + var x618 uint32 + x617, x618 = bits.Add32(x547, x593, uint32(uint1(x616))) + var x619 uint32 + var x620 uint32 + x619, x620 = bits.Add32(x549, x595, uint32(uint1(x618))) + var x621 uint32 + var x622 uint32 + x621, x622 = bits.Add32(x551, x597, uint32(uint1(x620))) + var x623 uint32 + var x624 uint32 + x623, x624 = bits.Add32(x553, x599, uint32(uint1(x622))) + var x625 uint32 + var x626 uint32 + x625, x626 = bits.Add32(x555, x601, uint32(uint1(x624))) + var x627 uint32 + var x628 uint32 + x627, x628 = bits.Add32(x557, x603, uint32(uint1(x626))) + var x629 uint32 + var x630 uint32 + x629, x630 = bits.Add32(x559, x605, uint32(uint1(x628))) + var x631 uint32 + var x632 uint32 + x631, x632 = bits.Add32(x561, x607, uint32(uint1(x630))) + var x633 uint32 + var x634 uint32 + x633, x634 = bits.Add32(x563, x609, uint32(uint1(x632))) + var x635 uint32 + _, x635 = bits.Mul32(x611, 0xe88fdc45) + var x637 uint32 + var x638 uint32 + x638, x637 = bits.Mul32(x635, 0xffffffff) + var x639 uint32 + var x640 uint32 + x640, x639 = bits.Mul32(x635, 0xffffffff) + var x641 uint32 + var x642 uint32 + x642, x641 = bits.Mul32(x635, 0xffffffff) + var x643 uint32 + var x644 uint32 + x644, x643 = bits.Mul32(x635, 0xffffffff) + var x645 uint32 + var x646 uint32 + x646, x645 = bits.Mul32(x635, 0xffffffff) + var x647 uint32 + var x648 uint32 + x648, x647 = bits.Mul32(x635, 0xffffffff) + var x649 uint32 + var x650 uint32 + x650, x649 = bits.Mul32(x635, 0xc7634d81) + var x651 uint32 + var x652 uint32 + x652, x651 = bits.Mul32(x635, 0xf4372ddf) + var x653 uint32 + var x654 uint32 + x654, x653 = bits.Mul32(x635, 0x581a0db2) + var x655 uint32 + var x656 uint32 + x656, x655 = bits.Mul32(x635, 0x48b0a77a) + var x657 uint32 + var x658 uint32 + x658, x657 = bits.Mul32(x635, 0xecec196a) + var x659 uint32 + var x660 uint32 + x660, x659 = bits.Mul32(x635, 0xccc52973) + var x661 uint32 + var x662 uint32 + x661, x662 = bits.Add32(x660, x657, uint32(0x0)) + var x663 uint32 + var x664 uint32 + x663, x664 = bits.Add32(x658, x655, uint32(uint1(x662))) + var x665 uint32 + var x666 uint32 + x665, x666 = bits.Add32(x656, x653, uint32(uint1(x664))) + var x667 uint32 + var x668 uint32 + x667, x668 = bits.Add32(x654, x651, uint32(uint1(x666))) + var x669 uint32 + var x670 uint32 + x669, x670 = bits.Add32(x652, x649, uint32(uint1(x668))) + var x671 uint32 + var x672 uint32 + x671, x672 = bits.Add32(x650, x647, uint32(uint1(x670))) + var x673 uint32 + var x674 uint32 + x673, x674 = bits.Add32(x648, x645, uint32(uint1(x672))) + var x675 uint32 + var x676 uint32 + x675, x676 = bits.Add32(x646, x643, uint32(uint1(x674))) + var x677 uint32 + var x678 uint32 + x677, x678 = bits.Add32(x644, x641, uint32(uint1(x676))) + var x679 uint32 + var x680 uint32 + x679, x680 = bits.Add32(x642, x639, uint32(uint1(x678))) + var x681 uint32 + var x682 uint32 + x681, x682 = bits.Add32(x640, x637, uint32(uint1(x680))) + var x684 uint32 + _, x684 = bits.Add32(x611, x659, uint32(0x0)) + var x685 uint32 + var x686 uint32 + x685, x686 = bits.Add32(x613, x661, uint32(uint1(x684))) + var x687 uint32 + var x688 uint32 + x687, x688 = bits.Add32(x615, x663, uint32(uint1(x686))) + var x689 uint32 + var x690 uint32 + x689, x690 = bits.Add32(x617, x665, uint32(uint1(x688))) + var x691 uint32 + var x692 uint32 + x691, x692 = bits.Add32(x619, x667, uint32(uint1(x690))) + var x693 uint32 + var x694 uint32 + x693, x694 = bits.Add32(x621, x669, uint32(uint1(x692))) + var x695 uint32 + var x696 uint32 + x695, x696 = bits.Add32(x623, x671, uint32(uint1(x694))) + var x697 uint32 + var x698 uint32 + x697, x698 = bits.Add32(x625, x673, uint32(uint1(x696))) + var x699 uint32 + var x700 uint32 + x699, x700 = bits.Add32(x627, x675, uint32(uint1(x698))) + var x701 uint32 + var x702 uint32 + x701, x702 = bits.Add32(x629, x677, uint32(uint1(x700))) + var x703 uint32 + var x704 uint32 + x703, x704 = bits.Add32(x631, x679, uint32(uint1(x702))) + var x705 uint32 + var x706 uint32 + x705, x706 = bits.Add32(x633, x681, uint32(uint1(x704))) + var x707 uint32 + var x708 uint32 + x707, x708 = bits.Add32(((uint32(uint1(x634)) + uint32(uint1(x564))) + (uint32(uint1(x610)) + x566)), (uint32(uint1(x682)) + x638), uint32(uint1(x706))) + var x709 uint32 + var x710 uint32 + x710, x709 = bits.Mul32(x5, 0xc84ee01) + var x711 uint32 + var x712 uint32 + x712, x711 = bits.Mul32(x5, 0x2b39bf21) + var x713 uint32 + var x714 uint32 + x714, x713 = bits.Mul32(x5, 0x3fb05b7a) + var x715 uint32 + var x716 uint32 + x716, x715 = bits.Mul32(x5, 0x28266895) + var x717 uint32 + var x718 uint32 + x718, x717 = bits.Mul32(x5, 0xd40d4917) + var x719 uint32 + var x720 uint32 + x720, x719 = bits.Mul32(x5, 0x4aab1cc5) + var x721 uint32 + var x722 uint32 + x722, x721 = bits.Mul32(x5, 0xbc3e483a) + var x723 uint32 + var x724 uint32 + x724, x723 = bits.Mul32(x5, 0xfcb82947) + var x725 uint32 + var x726 uint32 + x726, x725 = bits.Mul32(x5, 0xff3d81e5) + var x727 uint32 + var x728 uint32 + x728, x727 = bits.Mul32(x5, 0xdf1aa419) + var x729 uint32 + var x730 uint32 + x730, x729 = bits.Mul32(x5, 0x2d319b24) + var x731 uint32 + var x732 uint32 + x732, x731 = bits.Mul32(x5, 0x19b409a9) + var x733 uint32 + var x734 uint32 + x733, x734 = bits.Add32(x732, x729, uint32(0x0)) + var x735 uint32 + var x736 uint32 + x735, x736 = bits.Add32(x730, x727, uint32(uint1(x734))) + var x737 uint32 + var x738 uint32 + x737, x738 = bits.Add32(x728, x725, uint32(uint1(x736))) + var x739 uint32 + var x740 uint32 + x739, x740 = bits.Add32(x726, x723, uint32(uint1(x738))) + var x741 uint32 + var x742 uint32 + x741, x742 = bits.Add32(x724, x721, uint32(uint1(x740))) + var x743 uint32 + var x744 uint32 + x743, x744 = bits.Add32(x722, x719, uint32(uint1(x742))) + var x745 uint32 + var x746 uint32 + x745, x746 = bits.Add32(x720, x717, uint32(uint1(x744))) + var x747 uint32 + var x748 uint32 + x747, x748 = bits.Add32(x718, x715, uint32(uint1(x746))) + var x749 uint32 + var x750 uint32 + x749, x750 = bits.Add32(x716, x713, uint32(uint1(x748))) + var x751 uint32 + var x752 uint32 + x751, x752 = bits.Add32(x714, x711, uint32(uint1(x750))) + var x753 uint32 + var x754 uint32 + x753, x754 = bits.Add32(x712, x709, uint32(uint1(x752))) + var x755 uint32 + var x756 uint32 + x755, x756 = bits.Add32(x685, x731, uint32(0x0)) + var x757 uint32 + var x758 uint32 + x757, x758 = bits.Add32(x687, x733, uint32(uint1(x756))) + var x759 uint32 + var x760 uint32 + x759, x760 = bits.Add32(x689, x735, uint32(uint1(x758))) + var x761 uint32 + var x762 uint32 + x761, x762 = bits.Add32(x691, x737, uint32(uint1(x760))) + var x763 uint32 + var x764 uint32 + x763, x764 = bits.Add32(x693, x739, uint32(uint1(x762))) + var x765 uint32 + var x766 uint32 + x765, x766 = bits.Add32(x695, x741, uint32(uint1(x764))) + var x767 uint32 + var x768 uint32 + x767, x768 = bits.Add32(x697, x743, uint32(uint1(x766))) + var x769 uint32 + var x770 uint32 + x769, x770 = bits.Add32(x699, x745, uint32(uint1(x768))) + var x771 uint32 + var x772 uint32 + x771, x772 = bits.Add32(x701, x747, uint32(uint1(x770))) + var x773 uint32 + var x774 uint32 + x773, x774 = bits.Add32(x703, x749, uint32(uint1(x772))) + var x775 uint32 + var x776 uint32 + x775, x776 = bits.Add32(x705, x751, uint32(uint1(x774))) + var x777 uint32 + var x778 uint32 + x777, x778 = bits.Add32(x707, x753, uint32(uint1(x776))) + var x779 uint32 + _, x779 = bits.Mul32(x755, 0xe88fdc45) + var x781 uint32 + var x782 uint32 + x782, x781 = bits.Mul32(x779, 0xffffffff) + var x783 uint32 + var x784 uint32 + x784, x783 = bits.Mul32(x779, 0xffffffff) + var x785 uint32 + var x786 uint32 + x786, x785 = bits.Mul32(x779, 0xffffffff) + var x787 uint32 + var x788 uint32 + x788, x787 = bits.Mul32(x779, 0xffffffff) + var x789 uint32 + var x790 uint32 + x790, x789 = bits.Mul32(x779, 0xffffffff) + var x791 uint32 + var x792 uint32 + x792, x791 = bits.Mul32(x779, 0xffffffff) + var x793 uint32 + var x794 uint32 + x794, x793 = bits.Mul32(x779, 0xc7634d81) + var x795 uint32 + var x796 uint32 + x796, x795 = bits.Mul32(x779, 0xf4372ddf) + var x797 uint32 + var x798 uint32 + x798, x797 = bits.Mul32(x779, 0x581a0db2) + var x799 uint32 + var x800 uint32 + x800, x799 = bits.Mul32(x779, 0x48b0a77a) + var x801 uint32 + var x802 uint32 + x802, x801 = bits.Mul32(x779, 0xecec196a) + var x803 uint32 + var x804 uint32 + x804, x803 = bits.Mul32(x779, 0xccc52973) + var x805 uint32 + var x806 uint32 + x805, x806 = bits.Add32(x804, x801, uint32(0x0)) + var x807 uint32 + var x808 uint32 + x807, x808 = bits.Add32(x802, x799, uint32(uint1(x806))) + var x809 uint32 + var x810 uint32 + x809, x810 = bits.Add32(x800, x797, uint32(uint1(x808))) + var x811 uint32 + var x812 uint32 + x811, x812 = bits.Add32(x798, x795, uint32(uint1(x810))) + var x813 uint32 + var x814 uint32 + x813, x814 = bits.Add32(x796, x793, uint32(uint1(x812))) + var x815 uint32 + var x816 uint32 + x815, x816 = bits.Add32(x794, x791, uint32(uint1(x814))) + var x817 uint32 + var x818 uint32 + x817, x818 = bits.Add32(x792, x789, uint32(uint1(x816))) + var x819 uint32 + var x820 uint32 + x819, x820 = bits.Add32(x790, x787, uint32(uint1(x818))) + var x821 uint32 + var x822 uint32 + x821, x822 = bits.Add32(x788, x785, uint32(uint1(x820))) + var x823 uint32 + var x824 uint32 + x823, x824 = bits.Add32(x786, x783, uint32(uint1(x822))) + var x825 uint32 + var x826 uint32 + x825, x826 = bits.Add32(x784, x781, uint32(uint1(x824))) + var x828 uint32 + _, x828 = bits.Add32(x755, x803, uint32(0x0)) + var x829 uint32 + var x830 uint32 + x829, x830 = bits.Add32(x757, x805, uint32(uint1(x828))) + var x831 uint32 + var x832 uint32 + x831, x832 = bits.Add32(x759, x807, uint32(uint1(x830))) + var x833 uint32 + var x834 uint32 + x833, x834 = bits.Add32(x761, x809, uint32(uint1(x832))) + var x835 uint32 + var x836 uint32 + x835, x836 = bits.Add32(x763, x811, uint32(uint1(x834))) + var x837 uint32 + var x838 uint32 + x837, x838 = bits.Add32(x765, x813, uint32(uint1(x836))) + var x839 uint32 + var x840 uint32 + x839, x840 = bits.Add32(x767, x815, uint32(uint1(x838))) + var x841 uint32 + var x842 uint32 + x841, x842 = bits.Add32(x769, x817, uint32(uint1(x840))) + var x843 uint32 + var x844 uint32 + x843, x844 = bits.Add32(x771, x819, uint32(uint1(x842))) + var x845 uint32 + var x846 uint32 + x845, x846 = bits.Add32(x773, x821, uint32(uint1(x844))) + var x847 uint32 + var x848 uint32 + x847, x848 = bits.Add32(x775, x823, uint32(uint1(x846))) + var x849 uint32 + var x850 uint32 + x849, x850 = bits.Add32(x777, x825, uint32(uint1(x848))) + var x851 uint32 + var x852 uint32 + x851, x852 = bits.Add32(((uint32(uint1(x778)) + uint32(uint1(x708))) + (uint32(uint1(x754)) + x710)), (uint32(uint1(x826)) + x782), uint32(uint1(x850))) + var x853 uint32 + var x854 uint32 + x854, x853 = bits.Mul32(x6, 0xc84ee01) + var x855 uint32 + var x856 uint32 + x856, x855 = bits.Mul32(x6, 0x2b39bf21) + var x857 uint32 + var x858 uint32 + x858, x857 = bits.Mul32(x6, 0x3fb05b7a) + var x859 uint32 + var x860 uint32 + x860, x859 = bits.Mul32(x6, 0x28266895) + var x861 uint32 + var x862 uint32 + x862, x861 = bits.Mul32(x6, 0xd40d4917) + var x863 uint32 + var x864 uint32 + x864, x863 = bits.Mul32(x6, 0x4aab1cc5) + var x865 uint32 + var x866 uint32 + x866, x865 = bits.Mul32(x6, 0xbc3e483a) + var x867 uint32 + var x868 uint32 + x868, x867 = bits.Mul32(x6, 0xfcb82947) + var x869 uint32 + var x870 uint32 + x870, x869 = bits.Mul32(x6, 0xff3d81e5) + var x871 uint32 + var x872 uint32 + x872, x871 = bits.Mul32(x6, 0xdf1aa419) + var x873 uint32 + var x874 uint32 + x874, x873 = bits.Mul32(x6, 0x2d319b24) + var x875 uint32 + var x876 uint32 + x876, x875 = bits.Mul32(x6, 0x19b409a9) + var x877 uint32 + var x878 uint32 + x877, x878 = bits.Add32(x876, x873, uint32(0x0)) + var x879 uint32 + var x880 uint32 + x879, x880 = bits.Add32(x874, x871, uint32(uint1(x878))) + var x881 uint32 + var x882 uint32 + x881, x882 = bits.Add32(x872, x869, uint32(uint1(x880))) + var x883 uint32 + var x884 uint32 + x883, x884 = bits.Add32(x870, x867, uint32(uint1(x882))) + var x885 uint32 + var x886 uint32 + x885, x886 = bits.Add32(x868, x865, uint32(uint1(x884))) + var x887 uint32 + var x888 uint32 + x887, x888 = bits.Add32(x866, x863, uint32(uint1(x886))) + var x889 uint32 + var x890 uint32 + x889, x890 = bits.Add32(x864, x861, uint32(uint1(x888))) + var x891 uint32 + var x892 uint32 + x891, x892 = bits.Add32(x862, x859, uint32(uint1(x890))) + var x893 uint32 + var x894 uint32 + x893, x894 = bits.Add32(x860, x857, uint32(uint1(x892))) + var x895 uint32 + var x896 uint32 + x895, x896 = bits.Add32(x858, x855, uint32(uint1(x894))) + var x897 uint32 + var x898 uint32 + x897, x898 = bits.Add32(x856, x853, uint32(uint1(x896))) + var x899 uint32 + var x900 uint32 + x899, x900 = bits.Add32(x829, x875, uint32(0x0)) + var x901 uint32 + var x902 uint32 + x901, x902 = bits.Add32(x831, x877, uint32(uint1(x900))) + var x903 uint32 + var x904 uint32 + x903, x904 = bits.Add32(x833, x879, uint32(uint1(x902))) + var x905 uint32 + var x906 uint32 + x905, x906 = bits.Add32(x835, x881, uint32(uint1(x904))) + var x907 uint32 + var x908 uint32 + x907, x908 = bits.Add32(x837, x883, uint32(uint1(x906))) + var x909 uint32 + var x910 uint32 + x909, x910 = bits.Add32(x839, x885, uint32(uint1(x908))) + var x911 uint32 + var x912 uint32 + x911, x912 = bits.Add32(x841, x887, uint32(uint1(x910))) + var x913 uint32 + var x914 uint32 + x913, x914 = bits.Add32(x843, x889, uint32(uint1(x912))) + var x915 uint32 + var x916 uint32 + x915, x916 = bits.Add32(x845, x891, uint32(uint1(x914))) + var x917 uint32 + var x918 uint32 + x917, x918 = bits.Add32(x847, x893, uint32(uint1(x916))) + var x919 uint32 + var x920 uint32 + x919, x920 = bits.Add32(x849, x895, uint32(uint1(x918))) + var x921 uint32 + var x922 uint32 + x921, x922 = bits.Add32(x851, x897, uint32(uint1(x920))) + var x923 uint32 + _, x923 = bits.Mul32(x899, 0xe88fdc45) + var x925 uint32 + var x926 uint32 + x926, x925 = bits.Mul32(x923, 0xffffffff) + var x927 uint32 + var x928 uint32 + x928, x927 = bits.Mul32(x923, 0xffffffff) + var x929 uint32 + var x930 uint32 + x930, x929 = bits.Mul32(x923, 0xffffffff) + var x931 uint32 + var x932 uint32 + x932, x931 = bits.Mul32(x923, 0xffffffff) + var x933 uint32 + var x934 uint32 + x934, x933 = bits.Mul32(x923, 0xffffffff) + var x935 uint32 + var x936 uint32 + x936, x935 = bits.Mul32(x923, 0xffffffff) + var x937 uint32 + var x938 uint32 + x938, x937 = bits.Mul32(x923, 0xc7634d81) + var x939 uint32 + var x940 uint32 + x940, x939 = bits.Mul32(x923, 0xf4372ddf) + var x941 uint32 + var x942 uint32 + x942, x941 = bits.Mul32(x923, 0x581a0db2) + var x943 uint32 + var x944 uint32 + x944, x943 = bits.Mul32(x923, 0x48b0a77a) + var x945 uint32 + var x946 uint32 + x946, x945 = bits.Mul32(x923, 0xecec196a) + var x947 uint32 + var x948 uint32 + x948, x947 = bits.Mul32(x923, 0xccc52973) + var x949 uint32 + var x950 uint32 + x949, x950 = bits.Add32(x948, x945, uint32(0x0)) + var x951 uint32 + var x952 uint32 + x951, x952 = bits.Add32(x946, x943, uint32(uint1(x950))) + var x953 uint32 + var x954 uint32 + x953, x954 = bits.Add32(x944, x941, uint32(uint1(x952))) + var x955 uint32 + var x956 uint32 + x955, x956 = bits.Add32(x942, x939, uint32(uint1(x954))) + var x957 uint32 + var x958 uint32 + x957, x958 = bits.Add32(x940, x937, uint32(uint1(x956))) + var x959 uint32 + var x960 uint32 + x959, x960 = bits.Add32(x938, x935, uint32(uint1(x958))) + var x961 uint32 + var x962 uint32 + x961, x962 = bits.Add32(x936, x933, uint32(uint1(x960))) + var x963 uint32 + var x964 uint32 + x963, x964 = bits.Add32(x934, x931, uint32(uint1(x962))) + var x965 uint32 + var x966 uint32 + x965, x966 = bits.Add32(x932, x929, uint32(uint1(x964))) + var x967 uint32 + var x968 uint32 + x967, x968 = bits.Add32(x930, x927, uint32(uint1(x966))) + var x969 uint32 + var x970 uint32 + x969, x970 = bits.Add32(x928, x925, uint32(uint1(x968))) + var x972 uint32 + _, x972 = bits.Add32(x899, x947, uint32(0x0)) + var x973 uint32 + var x974 uint32 + x973, x974 = bits.Add32(x901, x949, uint32(uint1(x972))) + var x975 uint32 + var x976 uint32 + x975, x976 = bits.Add32(x903, x951, uint32(uint1(x974))) + var x977 uint32 + var x978 uint32 + x977, x978 = bits.Add32(x905, x953, uint32(uint1(x976))) + var x979 uint32 + var x980 uint32 + x979, x980 = bits.Add32(x907, x955, uint32(uint1(x978))) + var x981 uint32 + var x982 uint32 + x981, x982 = bits.Add32(x909, x957, uint32(uint1(x980))) + var x983 uint32 + var x984 uint32 + x983, x984 = bits.Add32(x911, x959, uint32(uint1(x982))) + var x985 uint32 + var x986 uint32 + x985, x986 = bits.Add32(x913, x961, uint32(uint1(x984))) + var x987 uint32 + var x988 uint32 + x987, x988 = bits.Add32(x915, x963, uint32(uint1(x986))) + var x989 uint32 + var x990 uint32 + x989, x990 = bits.Add32(x917, x965, uint32(uint1(x988))) + var x991 uint32 + var x992 uint32 + x991, x992 = bits.Add32(x919, x967, uint32(uint1(x990))) + var x993 uint32 + var x994 uint32 + x993, x994 = bits.Add32(x921, x969, uint32(uint1(x992))) + var x995 uint32 + var x996 uint32 + x995, x996 = bits.Add32(((uint32(uint1(x922)) + uint32(uint1(x852))) + (uint32(uint1(x898)) + x854)), (uint32(uint1(x970)) + x926), uint32(uint1(x994))) + var x997 uint32 + var x998 uint32 + x998, x997 = bits.Mul32(x7, 0xc84ee01) + var x999 uint32 + var x1000 uint32 + x1000, x999 = bits.Mul32(x7, 0x2b39bf21) + var x1001 uint32 + var x1002 uint32 + x1002, x1001 = bits.Mul32(x7, 0x3fb05b7a) + var x1003 uint32 + var x1004 uint32 + x1004, x1003 = bits.Mul32(x7, 0x28266895) + var x1005 uint32 + var x1006 uint32 + x1006, x1005 = bits.Mul32(x7, 0xd40d4917) + var x1007 uint32 + var x1008 uint32 + x1008, x1007 = bits.Mul32(x7, 0x4aab1cc5) + var x1009 uint32 + var x1010 uint32 + x1010, x1009 = bits.Mul32(x7, 0xbc3e483a) + var x1011 uint32 + var x1012 uint32 + x1012, x1011 = bits.Mul32(x7, 0xfcb82947) + var x1013 uint32 + var x1014 uint32 + x1014, x1013 = bits.Mul32(x7, 0xff3d81e5) + var x1015 uint32 + var x1016 uint32 + x1016, x1015 = bits.Mul32(x7, 0xdf1aa419) + var x1017 uint32 + var x1018 uint32 + x1018, x1017 = bits.Mul32(x7, 0x2d319b24) + var x1019 uint32 + var x1020 uint32 + x1020, x1019 = bits.Mul32(x7, 0x19b409a9) + var x1021 uint32 + var x1022 uint32 + x1021, x1022 = bits.Add32(x1020, x1017, uint32(0x0)) + var x1023 uint32 + var x1024 uint32 + x1023, x1024 = bits.Add32(x1018, x1015, uint32(uint1(x1022))) + var x1025 uint32 + var x1026 uint32 + x1025, x1026 = bits.Add32(x1016, x1013, uint32(uint1(x1024))) + var x1027 uint32 + var x1028 uint32 + x1027, x1028 = bits.Add32(x1014, x1011, uint32(uint1(x1026))) + var x1029 uint32 + var x1030 uint32 + x1029, x1030 = bits.Add32(x1012, x1009, uint32(uint1(x1028))) + var x1031 uint32 + var x1032 uint32 + x1031, x1032 = bits.Add32(x1010, x1007, uint32(uint1(x1030))) + var x1033 uint32 + var x1034 uint32 + x1033, x1034 = bits.Add32(x1008, x1005, uint32(uint1(x1032))) + var x1035 uint32 + var x1036 uint32 + x1035, x1036 = bits.Add32(x1006, x1003, uint32(uint1(x1034))) + var x1037 uint32 + var x1038 uint32 + x1037, x1038 = bits.Add32(x1004, x1001, uint32(uint1(x1036))) + var x1039 uint32 + var x1040 uint32 + x1039, x1040 = bits.Add32(x1002, x999, uint32(uint1(x1038))) + var x1041 uint32 + var x1042 uint32 + x1041, x1042 = bits.Add32(x1000, x997, uint32(uint1(x1040))) + var x1043 uint32 + var x1044 uint32 + x1043, x1044 = bits.Add32(x973, x1019, uint32(0x0)) + var x1045 uint32 + var x1046 uint32 + x1045, x1046 = bits.Add32(x975, x1021, uint32(uint1(x1044))) + var x1047 uint32 + var x1048 uint32 + x1047, x1048 = bits.Add32(x977, x1023, uint32(uint1(x1046))) + var x1049 uint32 + var x1050 uint32 + x1049, x1050 = bits.Add32(x979, x1025, uint32(uint1(x1048))) + var x1051 uint32 + var x1052 uint32 + x1051, x1052 = bits.Add32(x981, x1027, uint32(uint1(x1050))) + var x1053 uint32 + var x1054 uint32 + x1053, x1054 = bits.Add32(x983, x1029, uint32(uint1(x1052))) + var x1055 uint32 + var x1056 uint32 + x1055, x1056 = bits.Add32(x985, x1031, uint32(uint1(x1054))) + var x1057 uint32 + var x1058 uint32 + x1057, x1058 = bits.Add32(x987, x1033, uint32(uint1(x1056))) + var x1059 uint32 + var x1060 uint32 + x1059, x1060 = bits.Add32(x989, x1035, uint32(uint1(x1058))) + var x1061 uint32 + var x1062 uint32 + x1061, x1062 = bits.Add32(x991, x1037, uint32(uint1(x1060))) + var x1063 uint32 + var x1064 uint32 + x1063, x1064 = bits.Add32(x993, x1039, uint32(uint1(x1062))) + var x1065 uint32 + var x1066 uint32 + x1065, x1066 = bits.Add32(x995, x1041, uint32(uint1(x1064))) + var x1067 uint32 + _, x1067 = bits.Mul32(x1043, 0xe88fdc45) + var x1069 uint32 + var x1070 uint32 + x1070, x1069 = bits.Mul32(x1067, 0xffffffff) + var x1071 uint32 + var x1072 uint32 + x1072, x1071 = bits.Mul32(x1067, 0xffffffff) + var x1073 uint32 + var x1074 uint32 + x1074, x1073 = bits.Mul32(x1067, 0xffffffff) + var x1075 uint32 + var x1076 uint32 + x1076, x1075 = bits.Mul32(x1067, 0xffffffff) + var x1077 uint32 + var x1078 uint32 + x1078, x1077 = bits.Mul32(x1067, 0xffffffff) + var x1079 uint32 + var x1080 uint32 + x1080, x1079 = bits.Mul32(x1067, 0xffffffff) + var x1081 uint32 + var x1082 uint32 + x1082, x1081 = bits.Mul32(x1067, 0xc7634d81) + var x1083 uint32 + var x1084 uint32 + x1084, x1083 = bits.Mul32(x1067, 0xf4372ddf) + var x1085 uint32 + var x1086 uint32 + x1086, x1085 = bits.Mul32(x1067, 0x581a0db2) + var x1087 uint32 + var x1088 uint32 + x1088, x1087 = bits.Mul32(x1067, 0x48b0a77a) + var x1089 uint32 + var x1090 uint32 + x1090, x1089 = bits.Mul32(x1067, 0xecec196a) + var x1091 uint32 + var x1092 uint32 + x1092, x1091 = bits.Mul32(x1067, 0xccc52973) + var x1093 uint32 + var x1094 uint32 + x1093, x1094 = bits.Add32(x1092, x1089, uint32(0x0)) + var x1095 uint32 + var x1096 uint32 + x1095, x1096 = bits.Add32(x1090, x1087, uint32(uint1(x1094))) + var x1097 uint32 + var x1098 uint32 + x1097, x1098 = bits.Add32(x1088, x1085, uint32(uint1(x1096))) + var x1099 uint32 + var x1100 uint32 + x1099, x1100 = bits.Add32(x1086, x1083, uint32(uint1(x1098))) + var x1101 uint32 + var x1102 uint32 + x1101, x1102 = bits.Add32(x1084, x1081, uint32(uint1(x1100))) + var x1103 uint32 + var x1104 uint32 + x1103, x1104 = bits.Add32(x1082, x1079, uint32(uint1(x1102))) + var x1105 uint32 + var x1106 uint32 + x1105, x1106 = bits.Add32(x1080, x1077, uint32(uint1(x1104))) + var x1107 uint32 + var x1108 uint32 + x1107, x1108 = bits.Add32(x1078, x1075, uint32(uint1(x1106))) + var x1109 uint32 + var x1110 uint32 + x1109, x1110 = bits.Add32(x1076, x1073, uint32(uint1(x1108))) + var x1111 uint32 + var x1112 uint32 + x1111, x1112 = bits.Add32(x1074, x1071, uint32(uint1(x1110))) + var x1113 uint32 + var x1114 uint32 + x1113, x1114 = bits.Add32(x1072, x1069, uint32(uint1(x1112))) + var x1116 uint32 + _, x1116 = bits.Add32(x1043, x1091, uint32(0x0)) + var x1117 uint32 + var x1118 uint32 + x1117, x1118 = bits.Add32(x1045, x1093, uint32(uint1(x1116))) + var x1119 uint32 + var x1120 uint32 + x1119, x1120 = bits.Add32(x1047, x1095, uint32(uint1(x1118))) + var x1121 uint32 + var x1122 uint32 + x1121, x1122 = bits.Add32(x1049, x1097, uint32(uint1(x1120))) + var x1123 uint32 + var x1124 uint32 + x1123, x1124 = bits.Add32(x1051, x1099, uint32(uint1(x1122))) + var x1125 uint32 + var x1126 uint32 + x1125, x1126 = bits.Add32(x1053, x1101, uint32(uint1(x1124))) + var x1127 uint32 + var x1128 uint32 + x1127, x1128 = bits.Add32(x1055, x1103, uint32(uint1(x1126))) + var x1129 uint32 + var x1130 uint32 + x1129, x1130 = bits.Add32(x1057, x1105, uint32(uint1(x1128))) + var x1131 uint32 + var x1132 uint32 + x1131, x1132 = bits.Add32(x1059, x1107, uint32(uint1(x1130))) + var x1133 uint32 + var x1134 uint32 + x1133, x1134 = bits.Add32(x1061, x1109, uint32(uint1(x1132))) + var x1135 uint32 + var x1136 uint32 + x1135, x1136 = bits.Add32(x1063, x1111, uint32(uint1(x1134))) + var x1137 uint32 + var x1138 uint32 + x1137, x1138 = bits.Add32(x1065, x1113, uint32(uint1(x1136))) + var x1139 uint32 + var x1140 uint32 + x1139, x1140 = bits.Add32(((uint32(uint1(x1066)) + uint32(uint1(x996))) + (uint32(uint1(x1042)) + x998)), (uint32(uint1(x1114)) + x1070), uint32(uint1(x1138))) + var x1141 uint32 + var x1142 uint32 + x1142, x1141 = bits.Mul32(x8, 0xc84ee01) + var x1143 uint32 + var x1144 uint32 + x1144, x1143 = bits.Mul32(x8, 0x2b39bf21) + var x1145 uint32 + var x1146 uint32 + x1146, x1145 = bits.Mul32(x8, 0x3fb05b7a) + var x1147 uint32 + var x1148 uint32 + x1148, x1147 = bits.Mul32(x8, 0x28266895) + var x1149 uint32 + var x1150 uint32 + x1150, x1149 = bits.Mul32(x8, 0xd40d4917) + var x1151 uint32 + var x1152 uint32 + x1152, x1151 = bits.Mul32(x8, 0x4aab1cc5) + var x1153 uint32 + var x1154 uint32 + x1154, x1153 = bits.Mul32(x8, 0xbc3e483a) + var x1155 uint32 + var x1156 uint32 + x1156, x1155 = bits.Mul32(x8, 0xfcb82947) + var x1157 uint32 + var x1158 uint32 + x1158, x1157 = bits.Mul32(x8, 0xff3d81e5) + var x1159 uint32 + var x1160 uint32 + x1160, x1159 = bits.Mul32(x8, 0xdf1aa419) + var x1161 uint32 + var x1162 uint32 + x1162, x1161 = bits.Mul32(x8, 0x2d319b24) + var x1163 uint32 + var x1164 uint32 + x1164, x1163 = bits.Mul32(x8, 0x19b409a9) + var x1165 uint32 + var x1166 uint32 + x1165, x1166 = bits.Add32(x1164, x1161, uint32(0x0)) + var x1167 uint32 + var x1168 uint32 + x1167, x1168 = bits.Add32(x1162, x1159, uint32(uint1(x1166))) + var x1169 uint32 + var x1170 uint32 + x1169, x1170 = bits.Add32(x1160, x1157, uint32(uint1(x1168))) + var x1171 uint32 + var x1172 uint32 + x1171, x1172 = bits.Add32(x1158, x1155, uint32(uint1(x1170))) + var x1173 uint32 + var x1174 uint32 + x1173, x1174 = bits.Add32(x1156, x1153, uint32(uint1(x1172))) + var x1175 uint32 + var x1176 uint32 + x1175, x1176 = bits.Add32(x1154, x1151, uint32(uint1(x1174))) + var x1177 uint32 + var x1178 uint32 + x1177, x1178 = bits.Add32(x1152, x1149, uint32(uint1(x1176))) + var x1179 uint32 + var x1180 uint32 + x1179, x1180 = bits.Add32(x1150, x1147, uint32(uint1(x1178))) + var x1181 uint32 + var x1182 uint32 + x1181, x1182 = bits.Add32(x1148, x1145, uint32(uint1(x1180))) + var x1183 uint32 + var x1184 uint32 + x1183, x1184 = bits.Add32(x1146, x1143, uint32(uint1(x1182))) + var x1185 uint32 + var x1186 uint32 + x1185, x1186 = bits.Add32(x1144, x1141, uint32(uint1(x1184))) + var x1187 uint32 + var x1188 uint32 + x1187, x1188 = bits.Add32(x1117, x1163, uint32(0x0)) + var x1189 uint32 + var x1190 uint32 + x1189, x1190 = bits.Add32(x1119, x1165, uint32(uint1(x1188))) + var x1191 uint32 + var x1192 uint32 + x1191, x1192 = bits.Add32(x1121, x1167, uint32(uint1(x1190))) + var x1193 uint32 + var x1194 uint32 + x1193, x1194 = bits.Add32(x1123, x1169, uint32(uint1(x1192))) + var x1195 uint32 + var x1196 uint32 + x1195, x1196 = bits.Add32(x1125, x1171, uint32(uint1(x1194))) + var x1197 uint32 + var x1198 uint32 + x1197, x1198 = bits.Add32(x1127, x1173, uint32(uint1(x1196))) + var x1199 uint32 + var x1200 uint32 + x1199, x1200 = bits.Add32(x1129, x1175, uint32(uint1(x1198))) + var x1201 uint32 + var x1202 uint32 + x1201, x1202 = bits.Add32(x1131, x1177, uint32(uint1(x1200))) + var x1203 uint32 + var x1204 uint32 + x1203, x1204 = bits.Add32(x1133, x1179, uint32(uint1(x1202))) + var x1205 uint32 + var x1206 uint32 + x1205, x1206 = bits.Add32(x1135, x1181, uint32(uint1(x1204))) + var x1207 uint32 + var x1208 uint32 + x1207, x1208 = bits.Add32(x1137, x1183, uint32(uint1(x1206))) + var x1209 uint32 + var x1210 uint32 + x1209, x1210 = bits.Add32(x1139, x1185, uint32(uint1(x1208))) + var x1211 uint32 + _, x1211 = bits.Mul32(x1187, 0xe88fdc45) + var x1213 uint32 + var x1214 uint32 + x1214, x1213 = bits.Mul32(x1211, 0xffffffff) + var x1215 uint32 + var x1216 uint32 + x1216, x1215 = bits.Mul32(x1211, 0xffffffff) + var x1217 uint32 + var x1218 uint32 + x1218, x1217 = bits.Mul32(x1211, 0xffffffff) + var x1219 uint32 + var x1220 uint32 + x1220, x1219 = bits.Mul32(x1211, 0xffffffff) + var x1221 uint32 + var x1222 uint32 + x1222, x1221 = bits.Mul32(x1211, 0xffffffff) + var x1223 uint32 + var x1224 uint32 + x1224, x1223 = bits.Mul32(x1211, 0xffffffff) + var x1225 uint32 + var x1226 uint32 + x1226, x1225 = bits.Mul32(x1211, 0xc7634d81) + var x1227 uint32 + var x1228 uint32 + x1228, x1227 = bits.Mul32(x1211, 0xf4372ddf) + var x1229 uint32 + var x1230 uint32 + x1230, x1229 = bits.Mul32(x1211, 0x581a0db2) + var x1231 uint32 + var x1232 uint32 + x1232, x1231 = bits.Mul32(x1211, 0x48b0a77a) + var x1233 uint32 + var x1234 uint32 + x1234, x1233 = bits.Mul32(x1211, 0xecec196a) + var x1235 uint32 + var x1236 uint32 + x1236, x1235 = bits.Mul32(x1211, 0xccc52973) + var x1237 uint32 + var x1238 uint32 + x1237, x1238 = bits.Add32(x1236, x1233, uint32(0x0)) + var x1239 uint32 + var x1240 uint32 + x1239, x1240 = bits.Add32(x1234, x1231, uint32(uint1(x1238))) + var x1241 uint32 + var x1242 uint32 + x1241, x1242 = bits.Add32(x1232, x1229, uint32(uint1(x1240))) + var x1243 uint32 + var x1244 uint32 + x1243, x1244 = bits.Add32(x1230, x1227, uint32(uint1(x1242))) + var x1245 uint32 + var x1246 uint32 + x1245, x1246 = bits.Add32(x1228, x1225, uint32(uint1(x1244))) + var x1247 uint32 + var x1248 uint32 + x1247, x1248 = bits.Add32(x1226, x1223, uint32(uint1(x1246))) + var x1249 uint32 + var x1250 uint32 + x1249, x1250 = bits.Add32(x1224, x1221, uint32(uint1(x1248))) + var x1251 uint32 + var x1252 uint32 + x1251, x1252 = bits.Add32(x1222, x1219, uint32(uint1(x1250))) + var x1253 uint32 + var x1254 uint32 + x1253, x1254 = bits.Add32(x1220, x1217, uint32(uint1(x1252))) + var x1255 uint32 + var x1256 uint32 + x1255, x1256 = bits.Add32(x1218, x1215, uint32(uint1(x1254))) + var x1257 uint32 + var x1258 uint32 + x1257, x1258 = bits.Add32(x1216, x1213, uint32(uint1(x1256))) + var x1260 uint32 + _, x1260 = bits.Add32(x1187, x1235, uint32(0x0)) + var x1261 uint32 + var x1262 uint32 + x1261, x1262 = bits.Add32(x1189, x1237, uint32(uint1(x1260))) + var x1263 uint32 + var x1264 uint32 + x1263, x1264 = bits.Add32(x1191, x1239, uint32(uint1(x1262))) + var x1265 uint32 + var x1266 uint32 + x1265, x1266 = bits.Add32(x1193, x1241, uint32(uint1(x1264))) + var x1267 uint32 + var x1268 uint32 + x1267, x1268 = bits.Add32(x1195, x1243, uint32(uint1(x1266))) + var x1269 uint32 + var x1270 uint32 + x1269, x1270 = bits.Add32(x1197, x1245, uint32(uint1(x1268))) + var x1271 uint32 + var x1272 uint32 + x1271, x1272 = bits.Add32(x1199, x1247, uint32(uint1(x1270))) + var x1273 uint32 + var x1274 uint32 + x1273, x1274 = bits.Add32(x1201, x1249, uint32(uint1(x1272))) + var x1275 uint32 + var x1276 uint32 + x1275, x1276 = bits.Add32(x1203, x1251, uint32(uint1(x1274))) + var x1277 uint32 + var x1278 uint32 + x1277, x1278 = bits.Add32(x1205, x1253, uint32(uint1(x1276))) + var x1279 uint32 + var x1280 uint32 + x1279, x1280 = bits.Add32(x1207, x1255, uint32(uint1(x1278))) + var x1281 uint32 + var x1282 uint32 + x1281, x1282 = bits.Add32(x1209, x1257, uint32(uint1(x1280))) + var x1283 uint32 + var x1284 uint32 + x1283, x1284 = bits.Add32(((uint32(uint1(x1210)) + uint32(uint1(x1140))) + (uint32(uint1(x1186)) + x1142)), (uint32(uint1(x1258)) + x1214), uint32(uint1(x1282))) + var x1285 uint32 + var x1286 uint32 + x1286, x1285 = bits.Mul32(x9, 0xc84ee01) + var x1287 uint32 + var x1288 uint32 + x1288, x1287 = bits.Mul32(x9, 0x2b39bf21) + var x1289 uint32 + var x1290 uint32 + x1290, x1289 = bits.Mul32(x9, 0x3fb05b7a) + var x1291 uint32 + var x1292 uint32 + x1292, x1291 = bits.Mul32(x9, 0x28266895) + var x1293 uint32 + var x1294 uint32 + x1294, x1293 = bits.Mul32(x9, 0xd40d4917) + var x1295 uint32 + var x1296 uint32 + x1296, x1295 = bits.Mul32(x9, 0x4aab1cc5) + var x1297 uint32 + var x1298 uint32 + x1298, x1297 = bits.Mul32(x9, 0xbc3e483a) + var x1299 uint32 + var x1300 uint32 + x1300, x1299 = bits.Mul32(x9, 0xfcb82947) + var x1301 uint32 + var x1302 uint32 + x1302, x1301 = bits.Mul32(x9, 0xff3d81e5) + var x1303 uint32 + var x1304 uint32 + x1304, x1303 = bits.Mul32(x9, 0xdf1aa419) + var x1305 uint32 + var x1306 uint32 + x1306, x1305 = bits.Mul32(x9, 0x2d319b24) + var x1307 uint32 + var x1308 uint32 + x1308, x1307 = bits.Mul32(x9, 0x19b409a9) + var x1309 uint32 + var x1310 uint32 + x1309, x1310 = bits.Add32(x1308, x1305, uint32(0x0)) + var x1311 uint32 + var x1312 uint32 + x1311, x1312 = bits.Add32(x1306, x1303, uint32(uint1(x1310))) + var x1313 uint32 + var x1314 uint32 + x1313, x1314 = bits.Add32(x1304, x1301, uint32(uint1(x1312))) + var x1315 uint32 + var x1316 uint32 + x1315, x1316 = bits.Add32(x1302, x1299, uint32(uint1(x1314))) + var x1317 uint32 + var x1318 uint32 + x1317, x1318 = bits.Add32(x1300, x1297, uint32(uint1(x1316))) + var x1319 uint32 + var x1320 uint32 + x1319, x1320 = bits.Add32(x1298, x1295, uint32(uint1(x1318))) + var x1321 uint32 + var x1322 uint32 + x1321, x1322 = bits.Add32(x1296, x1293, uint32(uint1(x1320))) + var x1323 uint32 + var x1324 uint32 + x1323, x1324 = bits.Add32(x1294, x1291, uint32(uint1(x1322))) + var x1325 uint32 + var x1326 uint32 + x1325, x1326 = bits.Add32(x1292, x1289, uint32(uint1(x1324))) + var x1327 uint32 + var x1328 uint32 + x1327, x1328 = bits.Add32(x1290, x1287, uint32(uint1(x1326))) + var x1329 uint32 + var x1330 uint32 + x1329, x1330 = bits.Add32(x1288, x1285, uint32(uint1(x1328))) + var x1331 uint32 + var x1332 uint32 + x1331, x1332 = bits.Add32(x1261, x1307, uint32(0x0)) + var x1333 uint32 + var x1334 uint32 + x1333, x1334 = bits.Add32(x1263, x1309, uint32(uint1(x1332))) + var x1335 uint32 + var x1336 uint32 + x1335, x1336 = bits.Add32(x1265, x1311, uint32(uint1(x1334))) + var x1337 uint32 + var x1338 uint32 + x1337, x1338 = bits.Add32(x1267, x1313, uint32(uint1(x1336))) + var x1339 uint32 + var x1340 uint32 + x1339, x1340 = bits.Add32(x1269, x1315, uint32(uint1(x1338))) + var x1341 uint32 + var x1342 uint32 + x1341, x1342 = bits.Add32(x1271, x1317, uint32(uint1(x1340))) + var x1343 uint32 + var x1344 uint32 + x1343, x1344 = bits.Add32(x1273, x1319, uint32(uint1(x1342))) + var x1345 uint32 + var x1346 uint32 + x1345, x1346 = bits.Add32(x1275, x1321, uint32(uint1(x1344))) + var x1347 uint32 + var x1348 uint32 + x1347, x1348 = bits.Add32(x1277, x1323, uint32(uint1(x1346))) + var x1349 uint32 + var x1350 uint32 + x1349, x1350 = bits.Add32(x1279, x1325, uint32(uint1(x1348))) + var x1351 uint32 + var x1352 uint32 + x1351, x1352 = bits.Add32(x1281, x1327, uint32(uint1(x1350))) + var x1353 uint32 + var x1354 uint32 + x1353, x1354 = bits.Add32(x1283, x1329, uint32(uint1(x1352))) + var x1355 uint32 + _, x1355 = bits.Mul32(x1331, 0xe88fdc45) + var x1357 uint32 + var x1358 uint32 + x1358, x1357 = bits.Mul32(x1355, 0xffffffff) + var x1359 uint32 + var x1360 uint32 + x1360, x1359 = bits.Mul32(x1355, 0xffffffff) + var x1361 uint32 + var x1362 uint32 + x1362, x1361 = bits.Mul32(x1355, 0xffffffff) + var x1363 uint32 + var x1364 uint32 + x1364, x1363 = bits.Mul32(x1355, 0xffffffff) + var x1365 uint32 + var x1366 uint32 + x1366, x1365 = bits.Mul32(x1355, 0xffffffff) + var x1367 uint32 + var x1368 uint32 + x1368, x1367 = bits.Mul32(x1355, 0xffffffff) + var x1369 uint32 + var x1370 uint32 + x1370, x1369 = bits.Mul32(x1355, 0xc7634d81) + var x1371 uint32 + var x1372 uint32 + x1372, x1371 = bits.Mul32(x1355, 0xf4372ddf) + var x1373 uint32 + var x1374 uint32 + x1374, x1373 = bits.Mul32(x1355, 0x581a0db2) + var x1375 uint32 + var x1376 uint32 + x1376, x1375 = bits.Mul32(x1355, 0x48b0a77a) + var x1377 uint32 + var x1378 uint32 + x1378, x1377 = bits.Mul32(x1355, 0xecec196a) + var x1379 uint32 + var x1380 uint32 + x1380, x1379 = bits.Mul32(x1355, 0xccc52973) + var x1381 uint32 + var x1382 uint32 + x1381, x1382 = bits.Add32(x1380, x1377, uint32(0x0)) + var x1383 uint32 + var x1384 uint32 + x1383, x1384 = bits.Add32(x1378, x1375, uint32(uint1(x1382))) + var x1385 uint32 + var x1386 uint32 + x1385, x1386 = bits.Add32(x1376, x1373, uint32(uint1(x1384))) + var x1387 uint32 + var x1388 uint32 + x1387, x1388 = bits.Add32(x1374, x1371, uint32(uint1(x1386))) + var x1389 uint32 + var x1390 uint32 + x1389, x1390 = bits.Add32(x1372, x1369, uint32(uint1(x1388))) + var x1391 uint32 + var x1392 uint32 + x1391, x1392 = bits.Add32(x1370, x1367, uint32(uint1(x1390))) + var x1393 uint32 + var x1394 uint32 + x1393, x1394 = bits.Add32(x1368, x1365, uint32(uint1(x1392))) + var x1395 uint32 + var x1396 uint32 + x1395, x1396 = bits.Add32(x1366, x1363, uint32(uint1(x1394))) + var x1397 uint32 + var x1398 uint32 + x1397, x1398 = bits.Add32(x1364, x1361, uint32(uint1(x1396))) + var x1399 uint32 + var x1400 uint32 + x1399, x1400 = bits.Add32(x1362, x1359, uint32(uint1(x1398))) + var x1401 uint32 + var x1402 uint32 + x1401, x1402 = bits.Add32(x1360, x1357, uint32(uint1(x1400))) + var x1404 uint32 + _, x1404 = bits.Add32(x1331, x1379, uint32(0x0)) + var x1405 uint32 + var x1406 uint32 + x1405, x1406 = bits.Add32(x1333, x1381, uint32(uint1(x1404))) + var x1407 uint32 + var x1408 uint32 + x1407, x1408 = bits.Add32(x1335, x1383, uint32(uint1(x1406))) + var x1409 uint32 + var x1410 uint32 + x1409, x1410 = bits.Add32(x1337, x1385, uint32(uint1(x1408))) + var x1411 uint32 + var x1412 uint32 + x1411, x1412 = bits.Add32(x1339, x1387, uint32(uint1(x1410))) + var x1413 uint32 + var x1414 uint32 + x1413, x1414 = bits.Add32(x1341, x1389, uint32(uint1(x1412))) + var x1415 uint32 + var x1416 uint32 + x1415, x1416 = bits.Add32(x1343, x1391, uint32(uint1(x1414))) + var x1417 uint32 + var x1418 uint32 + x1417, x1418 = bits.Add32(x1345, x1393, uint32(uint1(x1416))) + var x1419 uint32 + var x1420 uint32 + x1419, x1420 = bits.Add32(x1347, x1395, uint32(uint1(x1418))) + var x1421 uint32 + var x1422 uint32 + x1421, x1422 = bits.Add32(x1349, x1397, uint32(uint1(x1420))) + var x1423 uint32 + var x1424 uint32 + x1423, x1424 = bits.Add32(x1351, x1399, uint32(uint1(x1422))) + var x1425 uint32 + var x1426 uint32 + x1425, x1426 = bits.Add32(x1353, x1401, uint32(uint1(x1424))) + var x1427 uint32 + var x1428 uint32 + x1427, x1428 = bits.Add32(((uint32(uint1(x1354)) + uint32(uint1(x1284))) + (uint32(uint1(x1330)) + x1286)), (uint32(uint1(x1402)) + x1358), uint32(uint1(x1426))) + var x1429 uint32 + var x1430 uint32 + x1430, x1429 = bits.Mul32(x10, 0xc84ee01) + var x1431 uint32 + var x1432 uint32 + x1432, x1431 = bits.Mul32(x10, 0x2b39bf21) + var x1433 uint32 + var x1434 uint32 + x1434, x1433 = bits.Mul32(x10, 0x3fb05b7a) + var x1435 uint32 + var x1436 uint32 + x1436, x1435 = bits.Mul32(x10, 0x28266895) + var x1437 uint32 + var x1438 uint32 + x1438, x1437 = bits.Mul32(x10, 0xd40d4917) + var x1439 uint32 + var x1440 uint32 + x1440, x1439 = bits.Mul32(x10, 0x4aab1cc5) + var x1441 uint32 + var x1442 uint32 + x1442, x1441 = bits.Mul32(x10, 0xbc3e483a) + var x1443 uint32 + var x1444 uint32 + x1444, x1443 = bits.Mul32(x10, 0xfcb82947) + var x1445 uint32 + var x1446 uint32 + x1446, x1445 = bits.Mul32(x10, 0xff3d81e5) + var x1447 uint32 + var x1448 uint32 + x1448, x1447 = bits.Mul32(x10, 0xdf1aa419) + var x1449 uint32 + var x1450 uint32 + x1450, x1449 = bits.Mul32(x10, 0x2d319b24) + var x1451 uint32 + var x1452 uint32 + x1452, x1451 = bits.Mul32(x10, 0x19b409a9) + var x1453 uint32 + var x1454 uint32 + x1453, x1454 = bits.Add32(x1452, x1449, uint32(0x0)) + var x1455 uint32 + var x1456 uint32 + x1455, x1456 = bits.Add32(x1450, x1447, uint32(uint1(x1454))) + var x1457 uint32 + var x1458 uint32 + x1457, x1458 = bits.Add32(x1448, x1445, uint32(uint1(x1456))) + var x1459 uint32 + var x1460 uint32 + x1459, x1460 = bits.Add32(x1446, x1443, uint32(uint1(x1458))) + var x1461 uint32 + var x1462 uint32 + x1461, x1462 = bits.Add32(x1444, x1441, uint32(uint1(x1460))) + var x1463 uint32 + var x1464 uint32 + x1463, x1464 = bits.Add32(x1442, x1439, uint32(uint1(x1462))) + var x1465 uint32 + var x1466 uint32 + x1465, x1466 = bits.Add32(x1440, x1437, uint32(uint1(x1464))) + var x1467 uint32 + var x1468 uint32 + x1467, x1468 = bits.Add32(x1438, x1435, uint32(uint1(x1466))) + var x1469 uint32 + var x1470 uint32 + x1469, x1470 = bits.Add32(x1436, x1433, uint32(uint1(x1468))) + var x1471 uint32 + var x1472 uint32 + x1471, x1472 = bits.Add32(x1434, x1431, uint32(uint1(x1470))) + var x1473 uint32 + var x1474 uint32 + x1473, x1474 = bits.Add32(x1432, x1429, uint32(uint1(x1472))) + var x1475 uint32 + var x1476 uint32 + x1475, x1476 = bits.Add32(x1405, x1451, uint32(0x0)) + var x1477 uint32 + var x1478 uint32 + x1477, x1478 = bits.Add32(x1407, x1453, uint32(uint1(x1476))) + var x1479 uint32 + var x1480 uint32 + x1479, x1480 = bits.Add32(x1409, x1455, uint32(uint1(x1478))) + var x1481 uint32 + var x1482 uint32 + x1481, x1482 = bits.Add32(x1411, x1457, uint32(uint1(x1480))) + var x1483 uint32 + var x1484 uint32 + x1483, x1484 = bits.Add32(x1413, x1459, uint32(uint1(x1482))) + var x1485 uint32 + var x1486 uint32 + x1485, x1486 = bits.Add32(x1415, x1461, uint32(uint1(x1484))) + var x1487 uint32 + var x1488 uint32 + x1487, x1488 = bits.Add32(x1417, x1463, uint32(uint1(x1486))) + var x1489 uint32 + var x1490 uint32 + x1489, x1490 = bits.Add32(x1419, x1465, uint32(uint1(x1488))) + var x1491 uint32 + var x1492 uint32 + x1491, x1492 = bits.Add32(x1421, x1467, uint32(uint1(x1490))) + var x1493 uint32 + var x1494 uint32 + x1493, x1494 = bits.Add32(x1423, x1469, uint32(uint1(x1492))) + var x1495 uint32 + var x1496 uint32 + x1495, x1496 = bits.Add32(x1425, x1471, uint32(uint1(x1494))) + var x1497 uint32 + var x1498 uint32 + x1497, x1498 = bits.Add32(x1427, x1473, uint32(uint1(x1496))) + var x1499 uint32 + _, x1499 = bits.Mul32(x1475, 0xe88fdc45) + var x1501 uint32 + var x1502 uint32 + x1502, x1501 = bits.Mul32(x1499, 0xffffffff) + var x1503 uint32 + var x1504 uint32 + x1504, x1503 = bits.Mul32(x1499, 0xffffffff) + var x1505 uint32 + var x1506 uint32 + x1506, x1505 = bits.Mul32(x1499, 0xffffffff) + var x1507 uint32 + var x1508 uint32 + x1508, x1507 = bits.Mul32(x1499, 0xffffffff) + var x1509 uint32 + var x1510 uint32 + x1510, x1509 = bits.Mul32(x1499, 0xffffffff) + var x1511 uint32 + var x1512 uint32 + x1512, x1511 = bits.Mul32(x1499, 0xffffffff) + var x1513 uint32 + var x1514 uint32 + x1514, x1513 = bits.Mul32(x1499, 0xc7634d81) + var x1515 uint32 + var x1516 uint32 + x1516, x1515 = bits.Mul32(x1499, 0xf4372ddf) + var x1517 uint32 + var x1518 uint32 + x1518, x1517 = bits.Mul32(x1499, 0x581a0db2) + var x1519 uint32 + var x1520 uint32 + x1520, x1519 = bits.Mul32(x1499, 0x48b0a77a) + var x1521 uint32 + var x1522 uint32 + x1522, x1521 = bits.Mul32(x1499, 0xecec196a) + var x1523 uint32 + var x1524 uint32 + x1524, x1523 = bits.Mul32(x1499, 0xccc52973) + var x1525 uint32 + var x1526 uint32 + x1525, x1526 = bits.Add32(x1524, x1521, uint32(0x0)) + var x1527 uint32 + var x1528 uint32 + x1527, x1528 = bits.Add32(x1522, x1519, uint32(uint1(x1526))) + var x1529 uint32 + var x1530 uint32 + x1529, x1530 = bits.Add32(x1520, x1517, uint32(uint1(x1528))) + var x1531 uint32 + var x1532 uint32 + x1531, x1532 = bits.Add32(x1518, x1515, uint32(uint1(x1530))) + var x1533 uint32 + var x1534 uint32 + x1533, x1534 = bits.Add32(x1516, x1513, uint32(uint1(x1532))) + var x1535 uint32 + var x1536 uint32 + x1535, x1536 = bits.Add32(x1514, x1511, uint32(uint1(x1534))) + var x1537 uint32 + var x1538 uint32 + x1537, x1538 = bits.Add32(x1512, x1509, uint32(uint1(x1536))) + var x1539 uint32 + var x1540 uint32 + x1539, x1540 = bits.Add32(x1510, x1507, uint32(uint1(x1538))) + var x1541 uint32 + var x1542 uint32 + x1541, x1542 = bits.Add32(x1508, x1505, uint32(uint1(x1540))) + var x1543 uint32 + var x1544 uint32 + x1543, x1544 = bits.Add32(x1506, x1503, uint32(uint1(x1542))) + var x1545 uint32 + var x1546 uint32 + x1545, x1546 = bits.Add32(x1504, x1501, uint32(uint1(x1544))) + var x1548 uint32 + _, x1548 = bits.Add32(x1475, x1523, uint32(0x0)) + var x1549 uint32 + var x1550 uint32 + x1549, x1550 = bits.Add32(x1477, x1525, uint32(uint1(x1548))) + var x1551 uint32 + var x1552 uint32 + x1551, x1552 = bits.Add32(x1479, x1527, uint32(uint1(x1550))) + var x1553 uint32 + var x1554 uint32 + x1553, x1554 = bits.Add32(x1481, x1529, uint32(uint1(x1552))) + var x1555 uint32 + var x1556 uint32 + x1555, x1556 = bits.Add32(x1483, x1531, uint32(uint1(x1554))) + var x1557 uint32 + var x1558 uint32 + x1557, x1558 = bits.Add32(x1485, x1533, uint32(uint1(x1556))) + var x1559 uint32 + var x1560 uint32 + x1559, x1560 = bits.Add32(x1487, x1535, uint32(uint1(x1558))) + var x1561 uint32 + var x1562 uint32 + x1561, x1562 = bits.Add32(x1489, x1537, uint32(uint1(x1560))) + var x1563 uint32 + var x1564 uint32 + x1563, x1564 = bits.Add32(x1491, x1539, uint32(uint1(x1562))) + var x1565 uint32 + var x1566 uint32 + x1565, x1566 = bits.Add32(x1493, x1541, uint32(uint1(x1564))) + var x1567 uint32 + var x1568 uint32 + x1567, x1568 = bits.Add32(x1495, x1543, uint32(uint1(x1566))) + var x1569 uint32 + var x1570 uint32 + x1569, x1570 = bits.Add32(x1497, x1545, uint32(uint1(x1568))) + var x1571 uint32 + var x1572 uint32 + x1571, x1572 = bits.Add32(((uint32(uint1(x1498)) + uint32(uint1(x1428))) + (uint32(uint1(x1474)) + x1430)), (uint32(uint1(x1546)) + x1502), uint32(uint1(x1570))) + var x1573 uint32 + var x1574 uint32 + x1574, x1573 = bits.Mul32(x11, 0xc84ee01) + var x1575 uint32 + var x1576 uint32 + x1576, x1575 = bits.Mul32(x11, 0x2b39bf21) + var x1577 uint32 + var x1578 uint32 + x1578, x1577 = bits.Mul32(x11, 0x3fb05b7a) + var x1579 uint32 + var x1580 uint32 + x1580, x1579 = bits.Mul32(x11, 0x28266895) + var x1581 uint32 + var x1582 uint32 + x1582, x1581 = bits.Mul32(x11, 0xd40d4917) + var x1583 uint32 + var x1584 uint32 + x1584, x1583 = bits.Mul32(x11, 0x4aab1cc5) + var x1585 uint32 + var x1586 uint32 + x1586, x1585 = bits.Mul32(x11, 0xbc3e483a) + var x1587 uint32 + var x1588 uint32 + x1588, x1587 = bits.Mul32(x11, 0xfcb82947) + var x1589 uint32 + var x1590 uint32 + x1590, x1589 = bits.Mul32(x11, 0xff3d81e5) + var x1591 uint32 + var x1592 uint32 + x1592, x1591 = bits.Mul32(x11, 0xdf1aa419) + var x1593 uint32 + var x1594 uint32 + x1594, x1593 = bits.Mul32(x11, 0x2d319b24) + var x1595 uint32 + var x1596 uint32 + x1596, x1595 = bits.Mul32(x11, 0x19b409a9) + var x1597 uint32 + var x1598 uint32 + x1597, x1598 = bits.Add32(x1596, x1593, uint32(0x0)) + var x1599 uint32 + var x1600 uint32 + x1599, x1600 = bits.Add32(x1594, x1591, uint32(uint1(x1598))) + var x1601 uint32 + var x1602 uint32 + x1601, x1602 = bits.Add32(x1592, x1589, uint32(uint1(x1600))) + var x1603 uint32 + var x1604 uint32 + x1603, x1604 = bits.Add32(x1590, x1587, uint32(uint1(x1602))) + var x1605 uint32 + var x1606 uint32 + x1605, x1606 = bits.Add32(x1588, x1585, uint32(uint1(x1604))) + var x1607 uint32 + var x1608 uint32 + x1607, x1608 = bits.Add32(x1586, x1583, uint32(uint1(x1606))) + var x1609 uint32 + var x1610 uint32 + x1609, x1610 = bits.Add32(x1584, x1581, uint32(uint1(x1608))) + var x1611 uint32 + var x1612 uint32 + x1611, x1612 = bits.Add32(x1582, x1579, uint32(uint1(x1610))) + var x1613 uint32 + var x1614 uint32 + x1613, x1614 = bits.Add32(x1580, x1577, uint32(uint1(x1612))) + var x1615 uint32 + var x1616 uint32 + x1615, x1616 = bits.Add32(x1578, x1575, uint32(uint1(x1614))) + var x1617 uint32 + var x1618 uint32 + x1617, x1618 = bits.Add32(x1576, x1573, uint32(uint1(x1616))) + var x1619 uint32 + var x1620 uint32 + x1619, x1620 = bits.Add32(x1549, x1595, uint32(0x0)) + var x1621 uint32 + var x1622 uint32 + x1621, x1622 = bits.Add32(x1551, x1597, uint32(uint1(x1620))) + var x1623 uint32 + var x1624 uint32 + x1623, x1624 = bits.Add32(x1553, x1599, uint32(uint1(x1622))) + var x1625 uint32 + var x1626 uint32 + x1625, x1626 = bits.Add32(x1555, x1601, uint32(uint1(x1624))) + var x1627 uint32 + var x1628 uint32 + x1627, x1628 = bits.Add32(x1557, x1603, uint32(uint1(x1626))) + var x1629 uint32 + var x1630 uint32 + x1629, x1630 = bits.Add32(x1559, x1605, uint32(uint1(x1628))) + var x1631 uint32 + var x1632 uint32 + x1631, x1632 = bits.Add32(x1561, x1607, uint32(uint1(x1630))) + var x1633 uint32 + var x1634 uint32 + x1633, x1634 = bits.Add32(x1563, x1609, uint32(uint1(x1632))) + var x1635 uint32 + var x1636 uint32 + x1635, x1636 = bits.Add32(x1565, x1611, uint32(uint1(x1634))) + var x1637 uint32 + var x1638 uint32 + x1637, x1638 = bits.Add32(x1567, x1613, uint32(uint1(x1636))) + var x1639 uint32 + var x1640 uint32 + x1639, x1640 = bits.Add32(x1569, x1615, uint32(uint1(x1638))) + var x1641 uint32 + var x1642 uint32 + x1641, x1642 = bits.Add32(x1571, x1617, uint32(uint1(x1640))) + var x1643 uint32 + _, x1643 = bits.Mul32(x1619, 0xe88fdc45) + var x1645 uint32 + var x1646 uint32 + x1646, x1645 = bits.Mul32(x1643, 0xffffffff) + var x1647 uint32 + var x1648 uint32 + x1648, x1647 = bits.Mul32(x1643, 0xffffffff) + var x1649 uint32 + var x1650 uint32 + x1650, x1649 = bits.Mul32(x1643, 0xffffffff) + var x1651 uint32 + var x1652 uint32 + x1652, x1651 = bits.Mul32(x1643, 0xffffffff) + var x1653 uint32 + var x1654 uint32 + x1654, x1653 = bits.Mul32(x1643, 0xffffffff) + var x1655 uint32 + var x1656 uint32 + x1656, x1655 = bits.Mul32(x1643, 0xffffffff) + var x1657 uint32 + var x1658 uint32 + x1658, x1657 = bits.Mul32(x1643, 0xc7634d81) + var x1659 uint32 + var x1660 uint32 + x1660, x1659 = bits.Mul32(x1643, 0xf4372ddf) + var x1661 uint32 + var x1662 uint32 + x1662, x1661 = bits.Mul32(x1643, 0x581a0db2) + var x1663 uint32 + var x1664 uint32 + x1664, x1663 = bits.Mul32(x1643, 0x48b0a77a) + var x1665 uint32 + var x1666 uint32 + x1666, x1665 = bits.Mul32(x1643, 0xecec196a) + var x1667 uint32 + var x1668 uint32 + x1668, x1667 = bits.Mul32(x1643, 0xccc52973) + var x1669 uint32 + var x1670 uint32 + x1669, x1670 = bits.Add32(x1668, x1665, uint32(0x0)) + var x1671 uint32 + var x1672 uint32 + x1671, x1672 = bits.Add32(x1666, x1663, uint32(uint1(x1670))) + var x1673 uint32 + var x1674 uint32 + x1673, x1674 = bits.Add32(x1664, x1661, uint32(uint1(x1672))) + var x1675 uint32 + var x1676 uint32 + x1675, x1676 = bits.Add32(x1662, x1659, uint32(uint1(x1674))) + var x1677 uint32 + var x1678 uint32 + x1677, x1678 = bits.Add32(x1660, x1657, uint32(uint1(x1676))) + var x1679 uint32 + var x1680 uint32 + x1679, x1680 = bits.Add32(x1658, x1655, uint32(uint1(x1678))) + var x1681 uint32 + var x1682 uint32 + x1681, x1682 = bits.Add32(x1656, x1653, uint32(uint1(x1680))) + var x1683 uint32 + var x1684 uint32 + x1683, x1684 = bits.Add32(x1654, x1651, uint32(uint1(x1682))) + var x1685 uint32 + var x1686 uint32 + x1685, x1686 = bits.Add32(x1652, x1649, uint32(uint1(x1684))) + var x1687 uint32 + var x1688 uint32 + x1687, x1688 = bits.Add32(x1650, x1647, uint32(uint1(x1686))) + var x1689 uint32 + var x1690 uint32 + x1689, x1690 = bits.Add32(x1648, x1645, uint32(uint1(x1688))) + var x1692 uint32 + _, x1692 = bits.Add32(x1619, x1667, uint32(0x0)) + var x1693 uint32 + var x1694 uint32 + x1693, x1694 = bits.Add32(x1621, x1669, uint32(uint1(x1692))) + var x1695 uint32 + var x1696 uint32 + x1695, x1696 = bits.Add32(x1623, x1671, uint32(uint1(x1694))) + var x1697 uint32 + var x1698 uint32 + x1697, x1698 = bits.Add32(x1625, x1673, uint32(uint1(x1696))) + var x1699 uint32 + var x1700 uint32 + x1699, x1700 = bits.Add32(x1627, x1675, uint32(uint1(x1698))) + var x1701 uint32 + var x1702 uint32 + x1701, x1702 = bits.Add32(x1629, x1677, uint32(uint1(x1700))) + var x1703 uint32 + var x1704 uint32 + x1703, x1704 = bits.Add32(x1631, x1679, uint32(uint1(x1702))) + var x1705 uint32 + var x1706 uint32 + x1705, x1706 = bits.Add32(x1633, x1681, uint32(uint1(x1704))) + var x1707 uint32 + var x1708 uint32 + x1707, x1708 = bits.Add32(x1635, x1683, uint32(uint1(x1706))) + var x1709 uint32 + var x1710 uint32 + x1709, x1710 = bits.Add32(x1637, x1685, uint32(uint1(x1708))) + var x1711 uint32 + var x1712 uint32 + x1711, x1712 = bits.Add32(x1639, x1687, uint32(uint1(x1710))) + var x1713 uint32 + var x1714 uint32 + x1713, x1714 = bits.Add32(x1641, x1689, uint32(uint1(x1712))) + var x1715 uint32 + var x1716 uint32 + x1715, x1716 = bits.Add32(((uint32(uint1(x1642)) + uint32(uint1(x1572))) + (uint32(uint1(x1618)) + x1574)), (uint32(uint1(x1690)) + x1646), uint32(uint1(x1714))) + var x1717 uint32 + var x1718 uint32 + x1717, x1718 = bits.Sub32(x1693, 0xccc52973, uint32(0x0)) + var x1719 uint32 + var x1720 uint32 + x1719, x1720 = bits.Sub32(x1695, 0xecec196a, uint32(uint1(x1718))) + var x1721 uint32 + var x1722 uint32 + x1721, x1722 = bits.Sub32(x1697, 0x48b0a77a, uint32(uint1(x1720))) + var x1723 uint32 + var x1724 uint32 + x1723, x1724 = bits.Sub32(x1699, 0x581a0db2, uint32(uint1(x1722))) + var x1725 uint32 + var x1726 uint32 + x1725, x1726 = bits.Sub32(x1701, 0xf4372ddf, uint32(uint1(x1724))) + var x1727 uint32 + var x1728 uint32 + x1727, x1728 = bits.Sub32(x1703, 0xc7634d81, uint32(uint1(x1726))) + var x1729 uint32 + var x1730 uint32 + x1729, x1730 = bits.Sub32(x1705, 0xffffffff, uint32(uint1(x1728))) + var x1731 uint32 + var x1732 uint32 + x1731, x1732 = bits.Sub32(x1707, 0xffffffff, uint32(uint1(x1730))) + var x1733 uint32 + var x1734 uint32 + x1733, x1734 = bits.Sub32(x1709, 0xffffffff, uint32(uint1(x1732))) + var x1735 uint32 + var x1736 uint32 + x1735, x1736 = bits.Sub32(x1711, 0xffffffff, uint32(uint1(x1734))) + var x1737 uint32 + var x1738 uint32 + x1737, x1738 = bits.Sub32(x1713, 0xffffffff, uint32(uint1(x1736))) + var x1739 uint32 + var x1740 uint32 + x1739, x1740 = bits.Sub32(x1715, 0xffffffff, uint32(uint1(x1738))) + var x1742 uint32 + _, x1742 = bits.Sub32(uint32(uint1(x1716)), uint32(0x0), uint32(uint1(x1740))) + var x1743 uint32 + cmovznzU32(&x1743, uint1(x1742), x1717, x1693) + var x1744 uint32 + cmovznzU32(&x1744, uint1(x1742), x1719, x1695) + var x1745 uint32 + cmovznzU32(&x1745, uint1(x1742), x1721, x1697) + var x1746 uint32 + cmovznzU32(&x1746, uint1(x1742), x1723, x1699) + var x1747 uint32 + cmovznzU32(&x1747, uint1(x1742), x1725, x1701) + var x1748 uint32 + cmovznzU32(&x1748, uint1(x1742), x1727, x1703) + var x1749 uint32 + cmovznzU32(&x1749, uint1(x1742), x1729, x1705) + var x1750 uint32 + cmovznzU32(&x1750, uint1(x1742), x1731, x1707) + var x1751 uint32 + cmovznzU32(&x1751, uint1(x1742), x1733, x1709) + var x1752 uint32 + cmovznzU32(&x1752, uint1(x1742), x1735, x1711) + var x1753 uint32 + cmovznzU32(&x1753, uint1(x1742), x1737, x1713) + var x1754 uint32 + cmovznzU32(&x1754, uint1(x1742), x1739, x1715) + out1[0] = x1743 + out1[1] = x1744 + out1[2] = x1745 + out1[3] = x1746 + out1[4] = x1747 + out1[5] = x1748 + out1[6] = x1749 + out1[7] = x1750 + out1[8] = x1751 + out1[9] = x1752 + out1[10] = x1753 + out1[11] = x1754 +} + +// Nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffff] +func Nonzero(out1 *uint32, arg1 *[12]uint32) { + x1 := (arg1[0] | (arg1[1] | (arg1[2] | (arg1[3] | (arg1[4] | (arg1[5] | (arg1[6] | (arg1[7] | (arg1[8] | (arg1[9] | (arg1[10] | arg1[11]))))))))))) + *out1 = x1 +} + +// Selectznz is a multi-limb conditional select. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func Selectznz(out1 *[12]uint32, arg1 uint1, arg2 *[12]uint32, arg3 *[12]uint32) { + var x1 uint32 + cmovznzU32(&x1, arg1, arg2[0], arg3[0]) + var x2 uint32 + cmovznzU32(&x2, arg1, arg2[1], arg3[1]) + var x3 uint32 + cmovznzU32(&x3, arg1, arg2[2], arg3[2]) + var x4 uint32 + cmovznzU32(&x4, arg1, arg2[3], arg3[3]) + var x5 uint32 + cmovznzU32(&x5, arg1, arg2[4], arg3[4]) + var x6 uint32 + cmovznzU32(&x6, arg1, arg2[5], arg3[5]) + var x7 uint32 + cmovznzU32(&x7, arg1, arg2[6], arg3[6]) + var x8 uint32 + cmovznzU32(&x8, arg1, arg2[7], arg3[7]) + var x9 uint32 + cmovznzU32(&x9, arg1, arg2[8], arg3[8]) + var x10 uint32 + cmovznzU32(&x10, arg1, arg2[9], arg3[9]) + var x11 uint32 + cmovznzU32(&x11, arg1, arg2[10], arg3[10]) + var x12 uint32 + cmovznzU32(&x12, arg1, arg2[11], arg3[11]) + out1[0] = x1 + out1[1] = x2 + out1[2] = x3 + out1[3] = x4 + out1[4] = x5 + out1[5] = x6 + out1[6] = x7 + out1[7] = x8 + out1[8] = x9 + out1[9] = x10 + out1[10] = x11 + out1[11] = x12 +} + +// ToBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47] +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +func ToBytes(out1 *[48]uint8, arg1 *[12]uint32) { + x1 := arg1[11] + x2 := arg1[10] + x3 := arg1[9] + x4 := arg1[8] + x5 := arg1[7] + x6 := arg1[6] + x7 := arg1[5] + x8 := arg1[4] + x9 := arg1[3] + x10 := arg1[2] + x11 := arg1[1] + x12 := arg1[0] + x13 := (uint8(x12) & 0xff) + x14 := (x12 >> 8) + x15 := (uint8(x14) & 0xff) + x16 := (x14 >> 8) + x17 := (uint8(x16) & 0xff) + x18 := uint8((x16 >> 8)) + x19 := (uint8(x11) & 0xff) + x20 := (x11 >> 8) + x21 := (uint8(x20) & 0xff) + x22 := (x20 >> 8) + x23 := (uint8(x22) & 0xff) + x24 := uint8((x22 >> 8)) + x25 := (uint8(x10) & 0xff) + x26 := (x10 >> 8) + x27 := (uint8(x26) & 0xff) + x28 := (x26 >> 8) + x29 := (uint8(x28) & 0xff) + x30 := uint8((x28 >> 8)) + x31 := (uint8(x9) & 0xff) + x32 := (x9 >> 8) + x33 := (uint8(x32) & 0xff) + x34 := (x32 >> 8) + x35 := (uint8(x34) & 0xff) + x36 := uint8((x34 >> 8)) + x37 := (uint8(x8) & 0xff) + x38 := (x8 >> 8) + x39 := (uint8(x38) & 0xff) + x40 := (x38 >> 8) + x41 := (uint8(x40) & 0xff) + x42 := uint8((x40 >> 8)) + x43 := (uint8(x7) & 0xff) + x44 := (x7 >> 8) + x45 := (uint8(x44) & 0xff) + x46 := (x44 >> 8) + x47 := (uint8(x46) & 0xff) + x48 := uint8((x46 >> 8)) + x49 := (uint8(x6) & 0xff) + x50 := (x6 >> 8) + x51 := (uint8(x50) & 0xff) + x52 := (x50 >> 8) + x53 := (uint8(x52) & 0xff) + x54 := uint8((x52 >> 8)) + x55 := (uint8(x5) & 0xff) + x56 := (x5 >> 8) + x57 := (uint8(x56) & 0xff) + x58 := (x56 >> 8) + x59 := (uint8(x58) & 0xff) + x60 := uint8((x58 >> 8)) + x61 := (uint8(x4) & 0xff) + x62 := (x4 >> 8) + x63 := (uint8(x62) & 0xff) + x64 := (x62 >> 8) + x65 := (uint8(x64) & 0xff) + x66 := uint8((x64 >> 8)) + x67 := (uint8(x3) & 0xff) + x68 := (x3 >> 8) + x69 := (uint8(x68) & 0xff) + x70 := (x68 >> 8) + x71 := (uint8(x70) & 0xff) + x72 := uint8((x70 >> 8)) + x73 := (uint8(x2) & 0xff) + x74 := (x2 >> 8) + x75 := (uint8(x74) & 0xff) + x76 := (x74 >> 8) + x77 := (uint8(x76) & 0xff) + x78 := uint8((x76 >> 8)) + x79 := (uint8(x1) & 0xff) + x80 := (x1 >> 8) + x81 := (uint8(x80) & 0xff) + x82 := (x80 >> 8) + x83 := (uint8(x82) & 0xff) + x84 := uint8((x82 >> 8)) + out1[0] = x13 + out1[1] = x15 + out1[2] = x17 + out1[3] = x18 + out1[4] = x19 + out1[5] = x21 + out1[6] = x23 + out1[7] = x24 + out1[8] = x25 + out1[9] = x27 + out1[10] = x29 + out1[11] = x30 + out1[12] = x31 + out1[13] = x33 + out1[14] = x35 + out1[15] = x36 + out1[16] = x37 + out1[17] = x39 + out1[18] = x41 + out1[19] = x42 + out1[20] = x43 + out1[21] = x45 + out1[22] = x47 + out1[23] = x48 + out1[24] = x49 + out1[25] = x51 + out1[26] = x53 + out1[27] = x54 + out1[28] = x55 + out1[29] = x57 + out1[30] = x59 + out1[31] = x60 + out1[32] = x61 + out1[33] = x63 + out1[34] = x65 + out1[35] = x66 + out1[36] = x67 + out1[37] = x69 + out1[38] = x71 + out1[39] = x72 + out1[40] = x73 + out1[41] = x75 + out1[42] = x77 + out1[43] = x78 + out1[44] = x79 + out1[45] = x81 + out1[46] = x83 + out1[47] = x84 +} + +// FromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +// +// Preconditions: +// 0 ≤ bytes_eval arg1 < m +// Postconditions: +// eval out1 mod m = bytes_eval arg1 mod m +// 0 ≤ eval out1 < m +// +// Input Bounds: +// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func FromBytes(out1 *[12]uint32, arg1 *[48]uint8) { + x1 := (uint32(arg1[47]) << 24) + x2 := (uint32(arg1[46]) << 16) + x3 := (uint32(arg1[45]) << 8) + x4 := arg1[44] + x5 := (uint32(arg1[43]) << 24) + x6 := (uint32(arg1[42]) << 16) + x7 := (uint32(arg1[41]) << 8) + x8 := arg1[40] + x9 := (uint32(arg1[39]) << 24) + x10 := (uint32(arg1[38]) << 16) + x11 := (uint32(arg1[37]) << 8) + x12 := arg1[36] + x13 := (uint32(arg1[35]) << 24) + x14 := (uint32(arg1[34]) << 16) + x15 := (uint32(arg1[33]) << 8) + x16 := arg1[32] + x17 := (uint32(arg1[31]) << 24) + x18 := (uint32(arg1[30]) << 16) + x19 := (uint32(arg1[29]) << 8) + x20 := arg1[28] + x21 := (uint32(arg1[27]) << 24) + x22 := (uint32(arg1[26]) << 16) + x23 := (uint32(arg1[25]) << 8) + x24 := arg1[24] + x25 := (uint32(arg1[23]) << 24) + x26 := (uint32(arg1[22]) << 16) + x27 := (uint32(arg1[21]) << 8) + x28 := arg1[20] + x29 := (uint32(arg1[19]) << 24) + x30 := (uint32(arg1[18]) << 16) + x31 := (uint32(arg1[17]) << 8) + x32 := arg1[16] + x33 := (uint32(arg1[15]) << 24) + x34 := (uint32(arg1[14]) << 16) + x35 := (uint32(arg1[13]) << 8) + x36 := arg1[12] + x37 := (uint32(arg1[11]) << 24) + x38 := (uint32(arg1[10]) << 16) + x39 := (uint32(arg1[9]) << 8) + x40 := arg1[8] + x41 := (uint32(arg1[7]) << 24) + x42 := (uint32(arg1[6]) << 16) + x43 := (uint32(arg1[5]) << 8) + x44 := arg1[4] + x45 := (uint32(arg1[3]) << 24) + x46 := (uint32(arg1[2]) << 16) + x47 := (uint32(arg1[1]) << 8) + x48 := arg1[0] + x49 := (x47 + uint32(x48)) + x50 := (x46 + x49) + x51 := (x45 + x50) + x52 := (x43 + uint32(x44)) + x53 := (x42 + x52) + x54 := (x41 + x53) + x55 := (x39 + uint32(x40)) + x56 := (x38 + x55) + x57 := (x37 + x56) + x58 := (x35 + uint32(x36)) + x59 := (x34 + x58) + x60 := (x33 + x59) + x61 := (x31 + uint32(x32)) + x62 := (x30 + x61) + x63 := (x29 + x62) + x64 := (x27 + uint32(x28)) + x65 := (x26 + x64) + x66 := (x25 + x65) + x67 := (x23 + uint32(x24)) + x68 := (x22 + x67) + x69 := (x21 + x68) + x70 := (x19 + uint32(x20)) + x71 := (x18 + x70) + x72 := (x17 + x71) + x73 := (x15 + uint32(x16)) + x74 := (x14 + x73) + x75 := (x13 + x74) + x76 := (x11 + uint32(x12)) + x77 := (x10 + x76) + x78 := (x9 + x77) + x79 := (x7 + uint32(x8)) + x80 := (x6 + x79) + x81 := (x5 + x80) + x82 := (x3 + uint32(x4)) + x83 := (x2 + x82) + x84 := (x1 + x83) + out1[0] = x51 + out1[1] = x54 + out1[2] = x57 + out1[3] = x60 + out1[4] = x63 + out1[5] = x66 + out1[6] = x69 + out1[7] = x72 + out1[8] = x75 + out1[9] = x78 + out1[10] = x81 + out1[11] = x84 +} + +// SetOne returns the field element one in the Montgomery domain. +// +// Postconditions: +// eval (from_montgomery out1) mod m = 1 mod m +// 0 ≤ eval out1 < m +// +func SetOne(out1 *MontgomeryDomainFieldElement) { + out1[0] = 0x333ad68d + out1[1] = 0x1313e695 + out1[2] = 0xb74f5885 + out1[3] = 0xa7e5f24d + out1[4] = 0xbc8d220 + out1[5] = 0x389cb27e + out1[6] = uint32(0x0) + out1[7] = uint32(0x0) + out1[8] = uint32(0x0) + out1[9] = uint32(0x0) + out1[10] = uint32(0x0) + out1[11] = uint32(0x0) +} + +// Msat returns the saturated representation of the prime modulus. +// +// Postconditions: +// twos_complement_eval out1 = m +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func Msat(out1 *[13]uint32) { + out1[0] = 0xccc52973 + out1[1] = 0xecec196a + out1[2] = 0x48b0a77a + out1[3] = 0x581a0db2 + out1[4] = 0xf4372ddf + out1[5] = 0xc7634d81 + out1[6] = 0xffffffff + out1[7] = 0xffffffff + out1[8] = 0xffffffff + out1[9] = 0xffffffff + out1[10] = 0xffffffff + out1[11] = 0xffffffff + out1[12] = uint32(0x0) +} + +// Divstep computes a divstep. +// +// Preconditions: +// 0 ≤ eval arg4 < m +// 0 ≤ eval arg5 < m +// Postconditions: +// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +// 0 ≤ eval out5 < m +// 0 ≤ eval out5 < m +// 0 ≤ eval out2 < m +// 0 ≤ eval out3 < m +// +// Input Bounds: +// arg1: [0x0 ~> 0xffffffff] +// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffff] +// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func Divstep(out1 *uint32, out2 *[13]uint32, out3 *[13]uint32, out4 *[12]uint32, out5 *[12]uint32, arg1 uint32, arg2 *[13]uint32, arg3 *[13]uint32, arg4 *[12]uint32, arg5 *[12]uint32) { + var x1 uint32 + x1, _ = bits.Add32((^arg1), uint32(0x1), uint32(0x0)) + x3 := (uint1((x1 >> 31)) & (uint1(arg3[0]) & 0x1)) + var x4 uint32 + x4, _ = bits.Add32((^arg1), uint32(0x1), uint32(0x0)) + var x6 uint32 + cmovznzU32(&x6, x3, arg1, x4) + var x7 uint32 + cmovznzU32(&x7, x3, arg2[0], arg3[0]) + var x8 uint32 + cmovznzU32(&x8, x3, arg2[1], arg3[1]) + var x9 uint32 + cmovznzU32(&x9, x3, arg2[2], arg3[2]) + var x10 uint32 + cmovznzU32(&x10, x3, arg2[3], arg3[3]) + var x11 uint32 + cmovznzU32(&x11, x3, arg2[4], arg3[4]) + var x12 uint32 + cmovznzU32(&x12, x3, arg2[5], arg3[5]) + var x13 uint32 + cmovznzU32(&x13, x3, arg2[6], arg3[6]) + var x14 uint32 + cmovznzU32(&x14, x3, arg2[7], arg3[7]) + var x15 uint32 + cmovznzU32(&x15, x3, arg2[8], arg3[8]) + var x16 uint32 + cmovznzU32(&x16, x3, arg2[9], arg3[9]) + var x17 uint32 + cmovznzU32(&x17, x3, arg2[10], arg3[10]) + var x18 uint32 + cmovznzU32(&x18, x3, arg2[11], arg3[11]) + var x19 uint32 + cmovznzU32(&x19, x3, arg2[12], arg3[12]) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(uint32(0x1), (^arg2[0]), uint32(0x0)) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(uint32(0x0), (^arg2[1]), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(uint32(0x0), (^arg2[2]), uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(uint32(0x0), (^arg2[3]), uint32(uint1(x25))) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(uint32(0x0), (^arg2[4]), uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(uint32(0x0), (^arg2[5]), uint32(uint1(x29))) + var x32 uint32 + var x33 uint32 + x32, x33 = bits.Add32(uint32(0x0), (^arg2[6]), uint32(uint1(x31))) + var x34 uint32 + var x35 uint32 + x34, x35 = bits.Add32(uint32(0x0), (^arg2[7]), uint32(uint1(x33))) + var x36 uint32 + var x37 uint32 + x36, x37 = bits.Add32(uint32(0x0), (^arg2[8]), uint32(uint1(x35))) + var x38 uint32 + var x39 uint32 + x38, x39 = bits.Add32(uint32(0x0), (^arg2[9]), uint32(uint1(x37))) + var x40 uint32 + var x41 uint32 + x40, x41 = bits.Add32(uint32(0x0), (^arg2[10]), uint32(uint1(x39))) + var x42 uint32 + var x43 uint32 + x42, x43 = bits.Add32(uint32(0x0), (^arg2[11]), uint32(uint1(x41))) + var x44 uint32 + x44, _ = bits.Add32(uint32(0x0), (^arg2[12]), uint32(uint1(x43))) + var x46 uint32 + cmovznzU32(&x46, x3, arg3[0], x20) + var x47 uint32 + cmovznzU32(&x47, x3, arg3[1], x22) + var x48 uint32 + cmovznzU32(&x48, x3, arg3[2], x24) + var x49 uint32 + cmovznzU32(&x49, x3, arg3[3], x26) + var x50 uint32 + cmovznzU32(&x50, x3, arg3[4], x28) + var x51 uint32 + cmovznzU32(&x51, x3, arg3[5], x30) + var x52 uint32 + cmovznzU32(&x52, x3, arg3[6], x32) + var x53 uint32 + cmovznzU32(&x53, x3, arg3[7], x34) + var x54 uint32 + cmovznzU32(&x54, x3, arg3[8], x36) + var x55 uint32 + cmovznzU32(&x55, x3, arg3[9], x38) + var x56 uint32 + cmovznzU32(&x56, x3, arg3[10], x40) + var x57 uint32 + cmovznzU32(&x57, x3, arg3[11], x42) + var x58 uint32 + cmovznzU32(&x58, x3, arg3[12], x44) + var x59 uint32 + cmovznzU32(&x59, x3, arg4[0], arg5[0]) + var x60 uint32 + cmovznzU32(&x60, x3, arg4[1], arg5[1]) + var x61 uint32 + cmovznzU32(&x61, x3, arg4[2], arg5[2]) + var x62 uint32 + cmovznzU32(&x62, x3, arg4[3], arg5[3]) + var x63 uint32 + cmovznzU32(&x63, x3, arg4[4], arg5[4]) + var x64 uint32 + cmovznzU32(&x64, x3, arg4[5], arg5[5]) + var x65 uint32 + cmovznzU32(&x65, x3, arg4[6], arg5[6]) + var x66 uint32 + cmovznzU32(&x66, x3, arg4[7], arg5[7]) + var x67 uint32 + cmovznzU32(&x67, x3, arg4[8], arg5[8]) + var x68 uint32 + cmovznzU32(&x68, x3, arg4[9], arg5[9]) + var x69 uint32 + cmovznzU32(&x69, x3, arg4[10], arg5[10]) + var x70 uint32 + cmovznzU32(&x70, x3, arg4[11], arg5[11]) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Add32(x59, x59, uint32(0x0)) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Add32(x60, x60, uint32(uint1(x72))) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Add32(x61, x61, uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x77, x78 = bits.Add32(x62, x62, uint32(uint1(x76))) + var x79 uint32 + var x80 uint32 + x79, x80 = bits.Add32(x63, x63, uint32(uint1(x78))) + var x81 uint32 + var x82 uint32 + x81, x82 = bits.Add32(x64, x64, uint32(uint1(x80))) + var x83 uint32 + var x84 uint32 + x83, x84 = bits.Add32(x65, x65, uint32(uint1(x82))) + var x85 uint32 + var x86 uint32 + x85, x86 = bits.Add32(x66, x66, uint32(uint1(x84))) + var x87 uint32 + var x88 uint32 + x87, x88 = bits.Add32(x67, x67, uint32(uint1(x86))) + var x89 uint32 + var x90 uint32 + x89, x90 = bits.Add32(x68, x68, uint32(uint1(x88))) + var x91 uint32 + var x92 uint32 + x91, x92 = bits.Add32(x69, x69, uint32(uint1(x90))) + var x93 uint32 + var x94 uint32 + x93, x94 = bits.Add32(x70, x70, uint32(uint1(x92))) + var x95 uint32 + var x96 uint32 + x95, x96 = bits.Sub32(x71, 0xccc52973, uint32(0x0)) + var x97 uint32 + var x98 uint32 + x97, x98 = bits.Sub32(x73, 0xecec196a, uint32(uint1(x96))) + var x99 uint32 + var x100 uint32 + x99, x100 = bits.Sub32(x75, 0x48b0a77a, uint32(uint1(x98))) + var x101 uint32 + var x102 uint32 + x101, x102 = bits.Sub32(x77, 0x581a0db2, uint32(uint1(x100))) + var x103 uint32 + var x104 uint32 + x103, x104 = bits.Sub32(x79, 0xf4372ddf, uint32(uint1(x102))) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Sub32(x81, 0xc7634d81, uint32(uint1(x104))) + var x107 uint32 + var x108 uint32 + x107, x108 = bits.Sub32(x83, 0xffffffff, uint32(uint1(x106))) + var x109 uint32 + var x110 uint32 + x109, x110 = bits.Sub32(x85, 0xffffffff, uint32(uint1(x108))) + var x111 uint32 + var x112 uint32 + x111, x112 = bits.Sub32(x87, 0xffffffff, uint32(uint1(x110))) + var x113 uint32 + var x114 uint32 + x113, x114 = bits.Sub32(x89, 0xffffffff, uint32(uint1(x112))) + var x115 uint32 + var x116 uint32 + x115, x116 = bits.Sub32(x91, 0xffffffff, uint32(uint1(x114))) + var x117 uint32 + var x118 uint32 + x117, x118 = bits.Sub32(x93, 0xffffffff, uint32(uint1(x116))) + var x120 uint32 + _, x120 = bits.Sub32(uint32(uint1(x94)), uint32(0x0), uint32(uint1(x118))) + x121 := arg4[11] + x122 := arg4[10] + x123 := arg4[9] + x124 := arg4[8] + x125 := arg4[7] + x126 := arg4[6] + x127 := arg4[5] + x128 := arg4[4] + x129 := arg4[3] + x130 := arg4[2] + x131 := arg4[1] + x132 := arg4[0] + var x133 uint32 + var x134 uint32 + x133, x134 = bits.Sub32(uint32(0x0), x132, uint32(0x0)) + var x135 uint32 + var x136 uint32 + x135, x136 = bits.Sub32(uint32(0x0), x131, uint32(uint1(x134))) + var x137 uint32 + var x138 uint32 + x137, x138 = bits.Sub32(uint32(0x0), x130, uint32(uint1(x136))) + var x139 uint32 + var x140 uint32 + x139, x140 = bits.Sub32(uint32(0x0), x129, uint32(uint1(x138))) + var x141 uint32 + var x142 uint32 + x141, x142 = bits.Sub32(uint32(0x0), x128, uint32(uint1(x140))) + var x143 uint32 + var x144 uint32 + x143, x144 = bits.Sub32(uint32(0x0), x127, uint32(uint1(x142))) + var x145 uint32 + var x146 uint32 + x145, x146 = bits.Sub32(uint32(0x0), x126, uint32(uint1(x144))) + var x147 uint32 + var x148 uint32 + x147, x148 = bits.Sub32(uint32(0x0), x125, uint32(uint1(x146))) + var x149 uint32 + var x150 uint32 + x149, x150 = bits.Sub32(uint32(0x0), x124, uint32(uint1(x148))) + var x151 uint32 + var x152 uint32 + x151, x152 = bits.Sub32(uint32(0x0), x123, uint32(uint1(x150))) + var x153 uint32 + var x154 uint32 + x153, x154 = bits.Sub32(uint32(0x0), x122, uint32(uint1(x152))) + var x155 uint32 + var x156 uint32 + x155, x156 = bits.Sub32(uint32(0x0), x121, uint32(uint1(x154))) + var x157 uint32 + cmovznzU32(&x157, uint1(x156), uint32(0x0), 0xffffffff) + var x158 uint32 + var x159 uint32 + x158, x159 = bits.Add32(x133, (x157 & 0xccc52973), uint32(0x0)) + var x160 uint32 + var x161 uint32 + x160, x161 = bits.Add32(x135, (x157 & 0xecec196a), uint32(uint1(x159))) + var x162 uint32 + var x163 uint32 + x162, x163 = bits.Add32(x137, (x157 & 0x48b0a77a), uint32(uint1(x161))) + var x164 uint32 + var x165 uint32 + x164, x165 = bits.Add32(x139, (x157 & 0x581a0db2), uint32(uint1(x163))) + var x166 uint32 + var x167 uint32 + x166, x167 = bits.Add32(x141, (x157 & 0xf4372ddf), uint32(uint1(x165))) + var x168 uint32 + var x169 uint32 + x168, x169 = bits.Add32(x143, (x157 & 0xc7634d81), uint32(uint1(x167))) + var x170 uint32 + var x171 uint32 + x170, x171 = bits.Add32(x145, x157, uint32(uint1(x169))) + var x172 uint32 + var x173 uint32 + x172, x173 = bits.Add32(x147, x157, uint32(uint1(x171))) + var x174 uint32 + var x175 uint32 + x174, x175 = bits.Add32(x149, x157, uint32(uint1(x173))) + var x176 uint32 + var x177 uint32 + x176, x177 = bits.Add32(x151, x157, uint32(uint1(x175))) + var x178 uint32 + var x179 uint32 + x178, x179 = bits.Add32(x153, x157, uint32(uint1(x177))) + var x180 uint32 + x180, _ = bits.Add32(x155, x157, uint32(uint1(x179))) + var x182 uint32 + cmovznzU32(&x182, x3, arg5[0], x158) + var x183 uint32 + cmovznzU32(&x183, x3, arg5[1], x160) + var x184 uint32 + cmovznzU32(&x184, x3, arg5[2], x162) + var x185 uint32 + cmovznzU32(&x185, x3, arg5[3], x164) + var x186 uint32 + cmovznzU32(&x186, x3, arg5[4], x166) + var x187 uint32 + cmovznzU32(&x187, x3, arg5[5], x168) + var x188 uint32 + cmovznzU32(&x188, x3, arg5[6], x170) + var x189 uint32 + cmovznzU32(&x189, x3, arg5[7], x172) + var x190 uint32 + cmovznzU32(&x190, x3, arg5[8], x174) + var x191 uint32 + cmovznzU32(&x191, x3, arg5[9], x176) + var x192 uint32 + cmovznzU32(&x192, x3, arg5[10], x178) + var x193 uint32 + cmovznzU32(&x193, x3, arg5[11], x180) + x194 := (uint1(x46) & 0x1) + var x195 uint32 + cmovznzU32(&x195, x194, uint32(0x0), x7) + var x196 uint32 + cmovznzU32(&x196, x194, uint32(0x0), x8) + var x197 uint32 + cmovznzU32(&x197, x194, uint32(0x0), x9) + var x198 uint32 + cmovznzU32(&x198, x194, uint32(0x0), x10) + var x199 uint32 + cmovznzU32(&x199, x194, uint32(0x0), x11) + var x200 uint32 + cmovznzU32(&x200, x194, uint32(0x0), x12) + var x201 uint32 + cmovznzU32(&x201, x194, uint32(0x0), x13) + var x202 uint32 + cmovznzU32(&x202, x194, uint32(0x0), x14) + var x203 uint32 + cmovznzU32(&x203, x194, uint32(0x0), x15) + var x204 uint32 + cmovznzU32(&x204, x194, uint32(0x0), x16) + var x205 uint32 + cmovznzU32(&x205, x194, uint32(0x0), x17) + var x206 uint32 + cmovznzU32(&x206, x194, uint32(0x0), x18) + var x207 uint32 + cmovznzU32(&x207, x194, uint32(0x0), x19) + var x208 uint32 + var x209 uint32 + x208, x209 = bits.Add32(x46, x195, uint32(0x0)) + var x210 uint32 + var x211 uint32 + x210, x211 = bits.Add32(x47, x196, uint32(uint1(x209))) + var x212 uint32 + var x213 uint32 + x212, x213 = bits.Add32(x48, x197, uint32(uint1(x211))) + var x214 uint32 + var x215 uint32 + x214, x215 = bits.Add32(x49, x198, uint32(uint1(x213))) + var x216 uint32 + var x217 uint32 + x216, x217 = bits.Add32(x50, x199, uint32(uint1(x215))) + var x218 uint32 + var x219 uint32 + x218, x219 = bits.Add32(x51, x200, uint32(uint1(x217))) + var x220 uint32 + var x221 uint32 + x220, x221 = bits.Add32(x52, x201, uint32(uint1(x219))) + var x222 uint32 + var x223 uint32 + x222, x223 = bits.Add32(x53, x202, uint32(uint1(x221))) + var x224 uint32 + var x225 uint32 + x224, x225 = bits.Add32(x54, x203, uint32(uint1(x223))) + var x226 uint32 + var x227 uint32 + x226, x227 = bits.Add32(x55, x204, uint32(uint1(x225))) + var x228 uint32 + var x229 uint32 + x228, x229 = bits.Add32(x56, x205, uint32(uint1(x227))) + var x230 uint32 + var x231 uint32 + x230, x231 = bits.Add32(x57, x206, uint32(uint1(x229))) + var x232 uint32 + x232, _ = bits.Add32(x58, x207, uint32(uint1(x231))) + var x234 uint32 + cmovznzU32(&x234, x194, uint32(0x0), x59) + var x235 uint32 + cmovznzU32(&x235, x194, uint32(0x0), x60) + var x236 uint32 + cmovznzU32(&x236, x194, uint32(0x0), x61) + var x237 uint32 + cmovznzU32(&x237, x194, uint32(0x0), x62) + var x238 uint32 + cmovznzU32(&x238, x194, uint32(0x0), x63) + var x239 uint32 + cmovznzU32(&x239, x194, uint32(0x0), x64) + var x240 uint32 + cmovznzU32(&x240, x194, uint32(0x0), x65) + var x241 uint32 + cmovznzU32(&x241, x194, uint32(0x0), x66) + var x242 uint32 + cmovznzU32(&x242, x194, uint32(0x0), x67) + var x243 uint32 + cmovznzU32(&x243, x194, uint32(0x0), x68) + var x244 uint32 + cmovznzU32(&x244, x194, uint32(0x0), x69) + var x245 uint32 + cmovznzU32(&x245, x194, uint32(0x0), x70) + var x246 uint32 + var x247 uint32 + x246, x247 = bits.Add32(x182, x234, uint32(0x0)) + var x248 uint32 + var x249 uint32 + x248, x249 = bits.Add32(x183, x235, uint32(uint1(x247))) + var x250 uint32 + var x251 uint32 + x250, x251 = bits.Add32(x184, x236, uint32(uint1(x249))) + var x252 uint32 + var x253 uint32 + x252, x253 = bits.Add32(x185, x237, uint32(uint1(x251))) + var x254 uint32 + var x255 uint32 + x254, x255 = bits.Add32(x186, x238, uint32(uint1(x253))) + var x256 uint32 + var x257 uint32 + x256, x257 = bits.Add32(x187, x239, uint32(uint1(x255))) + var x258 uint32 + var x259 uint32 + x258, x259 = bits.Add32(x188, x240, uint32(uint1(x257))) + var x260 uint32 + var x261 uint32 + x260, x261 = bits.Add32(x189, x241, uint32(uint1(x259))) + var x262 uint32 + var x263 uint32 + x262, x263 = bits.Add32(x190, x242, uint32(uint1(x261))) + var x264 uint32 + var x265 uint32 + x264, x265 = bits.Add32(x191, x243, uint32(uint1(x263))) + var x266 uint32 + var x267 uint32 + x266, x267 = bits.Add32(x192, x244, uint32(uint1(x265))) + var x268 uint32 + var x269 uint32 + x268, x269 = bits.Add32(x193, x245, uint32(uint1(x267))) + var x270 uint32 + var x271 uint32 + x270, x271 = bits.Sub32(x246, 0xccc52973, uint32(0x0)) + var x272 uint32 + var x273 uint32 + x272, x273 = bits.Sub32(x248, 0xecec196a, uint32(uint1(x271))) + var x274 uint32 + var x275 uint32 + x274, x275 = bits.Sub32(x250, 0x48b0a77a, uint32(uint1(x273))) + var x276 uint32 + var x277 uint32 + x276, x277 = bits.Sub32(x252, 0x581a0db2, uint32(uint1(x275))) + var x278 uint32 + var x279 uint32 + x278, x279 = bits.Sub32(x254, 0xf4372ddf, uint32(uint1(x277))) + var x280 uint32 + var x281 uint32 + x280, x281 = bits.Sub32(x256, 0xc7634d81, uint32(uint1(x279))) + var x282 uint32 + var x283 uint32 + x282, x283 = bits.Sub32(x258, 0xffffffff, uint32(uint1(x281))) + var x284 uint32 + var x285 uint32 + x284, x285 = bits.Sub32(x260, 0xffffffff, uint32(uint1(x283))) + var x286 uint32 + var x287 uint32 + x286, x287 = bits.Sub32(x262, 0xffffffff, uint32(uint1(x285))) + var x288 uint32 + var x289 uint32 + x288, x289 = bits.Sub32(x264, 0xffffffff, uint32(uint1(x287))) + var x290 uint32 + var x291 uint32 + x290, x291 = bits.Sub32(x266, 0xffffffff, uint32(uint1(x289))) + var x292 uint32 + var x293 uint32 + x292, x293 = bits.Sub32(x268, 0xffffffff, uint32(uint1(x291))) + var x295 uint32 + _, x295 = bits.Sub32(uint32(uint1(x269)), uint32(0x0), uint32(uint1(x293))) + var x296 uint32 + x296, _ = bits.Add32(x6, uint32(0x1), uint32(0x0)) + x298 := ((x208 >> 1) | ((x210 << 31) & 0xffffffff)) + x299 := ((x210 >> 1) | ((x212 << 31) & 0xffffffff)) + x300 := ((x212 >> 1) | ((x214 << 31) & 0xffffffff)) + x301 := ((x214 >> 1) | ((x216 << 31) & 0xffffffff)) + x302 := ((x216 >> 1) | ((x218 << 31) & 0xffffffff)) + x303 := ((x218 >> 1) | ((x220 << 31) & 0xffffffff)) + x304 := ((x220 >> 1) | ((x222 << 31) & 0xffffffff)) + x305 := ((x222 >> 1) | ((x224 << 31) & 0xffffffff)) + x306 := ((x224 >> 1) | ((x226 << 31) & 0xffffffff)) + x307 := ((x226 >> 1) | ((x228 << 31) & 0xffffffff)) + x308 := ((x228 >> 1) | ((x230 << 31) & 0xffffffff)) + x309 := ((x230 >> 1) | ((x232 << 31) & 0xffffffff)) + x310 := ((x232 & 0x80000000) | (x232 >> 1)) + var x311 uint32 + cmovznzU32(&x311, uint1(x120), x95, x71) + var x312 uint32 + cmovznzU32(&x312, uint1(x120), x97, x73) + var x313 uint32 + cmovznzU32(&x313, uint1(x120), x99, x75) + var x314 uint32 + cmovznzU32(&x314, uint1(x120), x101, x77) + var x315 uint32 + cmovznzU32(&x315, uint1(x120), x103, x79) + var x316 uint32 + cmovznzU32(&x316, uint1(x120), x105, x81) + var x317 uint32 + cmovznzU32(&x317, uint1(x120), x107, x83) + var x318 uint32 + cmovznzU32(&x318, uint1(x120), x109, x85) + var x319 uint32 + cmovznzU32(&x319, uint1(x120), x111, x87) + var x320 uint32 + cmovznzU32(&x320, uint1(x120), x113, x89) + var x321 uint32 + cmovznzU32(&x321, uint1(x120), x115, x91) + var x322 uint32 + cmovznzU32(&x322, uint1(x120), x117, x93) + var x323 uint32 + cmovznzU32(&x323, uint1(x295), x270, x246) + var x324 uint32 + cmovznzU32(&x324, uint1(x295), x272, x248) + var x325 uint32 + cmovznzU32(&x325, uint1(x295), x274, x250) + var x326 uint32 + cmovznzU32(&x326, uint1(x295), x276, x252) + var x327 uint32 + cmovznzU32(&x327, uint1(x295), x278, x254) + var x328 uint32 + cmovznzU32(&x328, uint1(x295), x280, x256) + var x329 uint32 + cmovznzU32(&x329, uint1(x295), x282, x258) + var x330 uint32 + cmovznzU32(&x330, uint1(x295), x284, x260) + var x331 uint32 + cmovznzU32(&x331, uint1(x295), x286, x262) + var x332 uint32 + cmovznzU32(&x332, uint1(x295), x288, x264) + var x333 uint32 + cmovznzU32(&x333, uint1(x295), x290, x266) + var x334 uint32 + cmovznzU32(&x334, uint1(x295), x292, x268) + *out1 = x296 + out2[0] = x7 + out2[1] = x8 + out2[2] = x9 + out2[3] = x10 + out2[4] = x11 + out2[5] = x12 + out2[6] = x13 + out2[7] = x14 + out2[8] = x15 + out2[9] = x16 + out2[10] = x17 + out2[11] = x18 + out2[12] = x19 + out3[0] = x298 + out3[1] = x299 + out3[2] = x300 + out3[3] = x301 + out3[4] = x302 + out3[5] = x303 + out3[6] = x304 + out3[7] = x305 + out3[8] = x306 + out3[9] = x307 + out3[10] = x308 + out3[11] = x309 + out3[12] = x310 + out4[0] = x311 + out4[1] = x312 + out4[2] = x313 + out4[3] = x314 + out4[4] = x315 + out4[5] = x316 + out4[6] = x317 + out4[7] = x318 + out4[8] = x319 + out4[9] = x320 + out4[10] = x321 + out4[11] = x322 + out5[0] = x323 + out5[1] = x324 + out5[2] = x325 + out5[3] = x326 + out5[4] = x327 + out5[5] = x328 + out5[6] = x329 + out5[7] = x330 + out5[8] = x331 + out5[9] = x332 + out5[10] = x333 + out5[11] = x334 +} + +// DivstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +// +// Postconditions: +// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func DivstepPrecomp(out1 *[12]uint32) { + out1[0] = 0xe6045b6a + out1[1] = 0x49589ae0 + out1[2] = 0x870040ed + out1[3] = 0x3c9a5352 + out1[4] = 0x977dc242 + out1[5] = 0xdacb097e + out1[6] = 0xd1ecbe36 + out1[7] = 0xb5ab30a6 + out1[8] = 0x1f959973 + out1[9] = 0x97d7a108 + out1[10] = 0xd27192bc + out1[11] = 0x2ba012f8 +} diff --git a/fiat-go/32/secp256k1scalar/secp256k1scalar.go b/fiat-go/32/secp256k1scalar/secp256k1scalar.go new file mode 100644 index 0000000000..c226ae9e88 --- /dev/null +++ b/fiat-go/32/secp256k1scalar/secp256k1scalar.go @@ -0,0 +1,5462 @@ +// Code generated by Fiat Cryptography. DO NOT EDIT. +// +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Go --relax-primitive-carry-to-bitwidth 32,64 --cmovznz-by-mul --internal-static --package-case flatcase --public-function-case UpperCamelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case camelCase --no-prefix-fiat --doc-newline-in-typedef-bounds --doc-prepend-header 'Code generated by Fiat Cryptography. DO NOT EDIT.' --doc-text-before-function-name '' --doc-text-before-type-name '' --package-name secp256k1scalar '' 32 '2^256 - 432420386565659656852420866394968145599' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// +// curve description (via package name): secp256k1scalar +// +// machine_wordsize = 32 (from "32") +// +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// +// m = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141 (from "2^256 - 432420386565659656852420866394968145599") +// +// +// +// NOTE: In addition to the bounds specified above each function, all +// +// functions synthesized for this Montgomery arithmetic require the +// +// input to be strictly less than the prime modulus (m), and also +// +// require the input to be in the unique saturated representation. +// +// All functions also ensure that these two properties are true of +// +// return values. +// +// +// +// Computed values: +// +// eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) +// +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +// +// twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in +// +// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 +package secp256k1scalar + +import "math/bits" + +type uint1 uint64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 +type int1 int64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 + +// MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +type MontgomeryDomainFieldElement [8]uint32 + +// NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +type NonMontgomeryDomainFieldElement [8]uint32 + +// cmovznzU32 is a single-word conditional move. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [0x0 ~> 0xffffffff] +// arg3: [0x0 ~> 0xffffffff] +// Output Bounds: +// out1: [0x0 ~> 0xffffffff] +func cmovznzU32(out1 *uint32, arg1 uint1, arg2 uint32, arg3 uint32) { + x1 := (uint32(arg1) * 0xffffffff) + x2 := ((x1 & arg3) | ((^x1) & arg2)) + *out1 = x2 +} + +// Mul multiplies two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Mul(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[6] + x7 := arg1[7] + x8 := arg1[0] + var x9 uint32 + var x10 uint32 + x10, x9 = bits.Mul32(x8, arg2[7]) + var x11 uint32 + var x12 uint32 + x12, x11 = bits.Mul32(x8, arg2[6]) + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x8, arg2[5]) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x8, arg2[4]) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x8, arg2[3]) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x8, arg2[2]) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x8, arg2[1]) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x8, arg2[0]) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Add32(x24, x21, uint32(0x0)) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Add32(x22, x19, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Add32(x20, x17, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Add32(x18, x15, uint32(uint1(x30))) + var x33 uint32 + var x34 uint32 + x33, x34 = bits.Add32(x16, x13, uint32(uint1(x32))) + var x35 uint32 + var x36 uint32 + x35, x36 = bits.Add32(x14, x11, uint32(uint1(x34))) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Add32(x12, x9, uint32(uint1(x36))) + x39 := (uint32(uint1(x38)) + x10) + var x40 uint32 + _, x40 = bits.Mul32(x23, 0x5588b13f) + var x42 uint32 + var x43 uint32 + x43, x42 = bits.Mul32(x40, 0xffffffff) + var x44 uint32 + var x45 uint32 + x45, x44 = bits.Mul32(x40, 0xffffffff) + var x46 uint32 + var x47 uint32 + x47, x46 = bits.Mul32(x40, 0xffffffff) + var x48 uint32 + var x49 uint32 + x49, x48 = bits.Mul32(x40, 0xfffffffe) + var x50 uint32 + var x51 uint32 + x51, x50 = bits.Mul32(x40, 0xbaaedce6) + var x52 uint32 + var x53 uint32 + x53, x52 = bits.Mul32(x40, 0xaf48a03b) + var x54 uint32 + var x55 uint32 + x55, x54 = bits.Mul32(x40, 0xbfd25e8c) + var x56 uint32 + var x57 uint32 + x57, x56 = bits.Mul32(x40, 0xd0364141) + var x58 uint32 + var x59 uint32 + x58, x59 = bits.Add32(x57, x54, uint32(0x0)) + var x60 uint32 + var x61 uint32 + x60, x61 = bits.Add32(x55, x52, uint32(uint1(x59))) + var x62 uint32 + var x63 uint32 + x62, x63 = bits.Add32(x53, x50, uint32(uint1(x61))) + var x64 uint32 + var x65 uint32 + x64, x65 = bits.Add32(x51, x48, uint32(uint1(x63))) + var x66 uint32 + var x67 uint32 + x66, x67 = bits.Add32(x49, x46, uint32(uint1(x65))) + var x68 uint32 + var x69 uint32 + x68, x69 = bits.Add32(x47, x44, uint32(uint1(x67))) + var x70 uint32 + var x71 uint32 + x70, x71 = bits.Add32(x45, x42, uint32(uint1(x69))) + x72 := (uint32(uint1(x71)) + x43) + var x74 uint32 + _, x74 = bits.Add32(x23, x56, uint32(0x0)) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Add32(x25, x58, uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x77, x78 = bits.Add32(x27, x60, uint32(uint1(x76))) + var x79 uint32 + var x80 uint32 + x79, x80 = bits.Add32(x29, x62, uint32(uint1(x78))) + var x81 uint32 + var x82 uint32 + x81, x82 = bits.Add32(x31, x64, uint32(uint1(x80))) + var x83 uint32 + var x84 uint32 + x83, x84 = bits.Add32(x33, x66, uint32(uint1(x82))) + var x85 uint32 + var x86 uint32 + x85, x86 = bits.Add32(x35, x68, uint32(uint1(x84))) + var x87 uint32 + var x88 uint32 + x87, x88 = bits.Add32(x37, x70, uint32(uint1(x86))) + var x89 uint32 + var x90 uint32 + x89, x90 = bits.Add32(x39, x72, uint32(uint1(x88))) + var x91 uint32 + var x92 uint32 + x92, x91 = bits.Mul32(x1, arg2[7]) + var x93 uint32 + var x94 uint32 + x94, x93 = bits.Mul32(x1, arg2[6]) + var x95 uint32 + var x96 uint32 + x96, x95 = bits.Mul32(x1, arg2[5]) + var x97 uint32 + var x98 uint32 + x98, x97 = bits.Mul32(x1, arg2[4]) + var x99 uint32 + var x100 uint32 + x100, x99 = bits.Mul32(x1, arg2[3]) + var x101 uint32 + var x102 uint32 + x102, x101 = bits.Mul32(x1, arg2[2]) + var x103 uint32 + var x104 uint32 + x104, x103 = bits.Mul32(x1, arg2[1]) + var x105 uint32 + var x106 uint32 + x106, x105 = bits.Mul32(x1, arg2[0]) + var x107 uint32 + var x108 uint32 + x107, x108 = bits.Add32(x106, x103, uint32(0x0)) + var x109 uint32 + var x110 uint32 + x109, x110 = bits.Add32(x104, x101, uint32(uint1(x108))) + var x111 uint32 + var x112 uint32 + x111, x112 = bits.Add32(x102, x99, uint32(uint1(x110))) + var x113 uint32 + var x114 uint32 + x113, x114 = bits.Add32(x100, x97, uint32(uint1(x112))) + var x115 uint32 + var x116 uint32 + x115, x116 = bits.Add32(x98, x95, uint32(uint1(x114))) + var x117 uint32 + var x118 uint32 + x117, x118 = bits.Add32(x96, x93, uint32(uint1(x116))) + var x119 uint32 + var x120 uint32 + x119, x120 = bits.Add32(x94, x91, uint32(uint1(x118))) + x121 := (uint32(uint1(x120)) + x92) + var x122 uint32 + var x123 uint32 + x122, x123 = bits.Add32(x75, x105, uint32(0x0)) + var x124 uint32 + var x125 uint32 + x124, x125 = bits.Add32(x77, x107, uint32(uint1(x123))) + var x126 uint32 + var x127 uint32 + x126, x127 = bits.Add32(x79, x109, uint32(uint1(x125))) + var x128 uint32 + var x129 uint32 + x128, x129 = bits.Add32(x81, x111, uint32(uint1(x127))) + var x130 uint32 + var x131 uint32 + x130, x131 = bits.Add32(x83, x113, uint32(uint1(x129))) + var x132 uint32 + var x133 uint32 + x132, x133 = bits.Add32(x85, x115, uint32(uint1(x131))) + var x134 uint32 + var x135 uint32 + x134, x135 = bits.Add32(x87, x117, uint32(uint1(x133))) + var x136 uint32 + var x137 uint32 + x136, x137 = bits.Add32(x89, x119, uint32(uint1(x135))) + var x138 uint32 + var x139 uint32 + x138, x139 = bits.Add32(uint32(uint1(x90)), x121, uint32(uint1(x137))) + var x140 uint32 + _, x140 = bits.Mul32(x122, 0x5588b13f) + var x142 uint32 + var x143 uint32 + x143, x142 = bits.Mul32(x140, 0xffffffff) + var x144 uint32 + var x145 uint32 + x145, x144 = bits.Mul32(x140, 0xffffffff) + var x146 uint32 + var x147 uint32 + x147, x146 = bits.Mul32(x140, 0xffffffff) + var x148 uint32 + var x149 uint32 + x149, x148 = bits.Mul32(x140, 0xfffffffe) + var x150 uint32 + var x151 uint32 + x151, x150 = bits.Mul32(x140, 0xbaaedce6) + var x152 uint32 + var x153 uint32 + x153, x152 = bits.Mul32(x140, 0xaf48a03b) + var x154 uint32 + var x155 uint32 + x155, x154 = bits.Mul32(x140, 0xbfd25e8c) + var x156 uint32 + var x157 uint32 + x157, x156 = bits.Mul32(x140, 0xd0364141) + var x158 uint32 + var x159 uint32 + x158, x159 = bits.Add32(x157, x154, uint32(0x0)) + var x160 uint32 + var x161 uint32 + x160, x161 = bits.Add32(x155, x152, uint32(uint1(x159))) + var x162 uint32 + var x163 uint32 + x162, x163 = bits.Add32(x153, x150, uint32(uint1(x161))) + var x164 uint32 + var x165 uint32 + x164, x165 = bits.Add32(x151, x148, uint32(uint1(x163))) + var x166 uint32 + var x167 uint32 + x166, x167 = bits.Add32(x149, x146, uint32(uint1(x165))) + var x168 uint32 + var x169 uint32 + x168, x169 = bits.Add32(x147, x144, uint32(uint1(x167))) + var x170 uint32 + var x171 uint32 + x170, x171 = bits.Add32(x145, x142, uint32(uint1(x169))) + x172 := (uint32(uint1(x171)) + x143) + var x174 uint32 + _, x174 = bits.Add32(x122, x156, uint32(0x0)) + var x175 uint32 + var x176 uint32 + x175, x176 = bits.Add32(x124, x158, uint32(uint1(x174))) + var x177 uint32 + var x178 uint32 + x177, x178 = bits.Add32(x126, x160, uint32(uint1(x176))) + var x179 uint32 + var x180 uint32 + x179, x180 = bits.Add32(x128, x162, uint32(uint1(x178))) + var x181 uint32 + var x182 uint32 + x181, x182 = bits.Add32(x130, x164, uint32(uint1(x180))) + var x183 uint32 + var x184 uint32 + x183, x184 = bits.Add32(x132, x166, uint32(uint1(x182))) + var x185 uint32 + var x186 uint32 + x185, x186 = bits.Add32(x134, x168, uint32(uint1(x184))) + var x187 uint32 + var x188 uint32 + x187, x188 = bits.Add32(x136, x170, uint32(uint1(x186))) + var x189 uint32 + var x190 uint32 + x189, x190 = bits.Add32(x138, x172, uint32(uint1(x188))) + x191 := (uint32(uint1(x190)) + uint32(uint1(x139))) + var x192 uint32 + var x193 uint32 + x193, x192 = bits.Mul32(x2, arg2[7]) + var x194 uint32 + var x195 uint32 + x195, x194 = bits.Mul32(x2, arg2[6]) + var x196 uint32 + var x197 uint32 + x197, x196 = bits.Mul32(x2, arg2[5]) + var x198 uint32 + var x199 uint32 + x199, x198 = bits.Mul32(x2, arg2[4]) + var x200 uint32 + var x201 uint32 + x201, x200 = bits.Mul32(x2, arg2[3]) + var x202 uint32 + var x203 uint32 + x203, x202 = bits.Mul32(x2, arg2[2]) + var x204 uint32 + var x205 uint32 + x205, x204 = bits.Mul32(x2, arg2[1]) + var x206 uint32 + var x207 uint32 + x207, x206 = bits.Mul32(x2, arg2[0]) + var x208 uint32 + var x209 uint32 + x208, x209 = bits.Add32(x207, x204, uint32(0x0)) + var x210 uint32 + var x211 uint32 + x210, x211 = bits.Add32(x205, x202, uint32(uint1(x209))) + var x212 uint32 + var x213 uint32 + x212, x213 = bits.Add32(x203, x200, uint32(uint1(x211))) + var x214 uint32 + var x215 uint32 + x214, x215 = bits.Add32(x201, x198, uint32(uint1(x213))) + var x216 uint32 + var x217 uint32 + x216, x217 = bits.Add32(x199, x196, uint32(uint1(x215))) + var x218 uint32 + var x219 uint32 + x218, x219 = bits.Add32(x197, x194, uint32(uint1(x217))) + var x220 uint32 + var x221 uint32 + x220, x221 = bits.Add32(x195, x192, uint32(uint1(x219))) + x222 := (uint32(uint1(x221)) + x193) + var x223 uint32 + var x224 uint32 + x223, x224 = bits.Add32(x175, x206, uint32(0x0)) + var x225 uint32 + var x226 uint32 + x225, x226 = bits.Add32(x177, x208, uint32(uint1(x224))) + var x227 uint32 + var x228 uint32 + x227, x228 = bits.Add32(x179, x210, uint32(uint1(x226))) + var x229 uint32 + var x230 uint32 + x229, x230 = bits.Add32(x181, x212, uint32(uint1(x228))) + var x231 uint32 + var x232 uint32 + x231, x232 = bits.Add32(x183, x214, uint32(uint1(x230))) + var x233 uint32 + var x234 uint32 + x233, x234 = bits.Add32(x185, x216, uint32(uint1(x232))) + var x235 uint32 + var x236 uint32 + x235, x236 = bits.Add32(x187, x218, uint32(uint1(x234))) + var x237 uint32 + var x238 uint32 + x237, x238 = bits.Add32(x189, x220, uint32(uint1(x236))) + var x239 uint32 + var x240 uint32 + x239, x240 = bits.Add32(x191, x222, uint32(uint1(x238))) + var x241 uint32 + _, x241 = bits.Mul32(x223, 0x5588b13f) + var x243 uint32 + var x244 uint32 + x244, x243 = bits.Mul32(x241, 0xffffffff) + var x245 uint32 + var x246 uint32 + x246, x245 = bits.Mul32(x241, 0xffffffff) + var x247 uint32 + var x248 uint32 + x248, x247 = bits.Mul32(x241, 0xffffffff) + var x249 uint32 + var x250 uint32 + x250, x249 = bits.Mul32(x241, 0xfffffffe) + var x251 uint32 + var x252 uint32 + x252, x251 = bits.Mul32(x241, 0xbaaedce6) + var x253 uint32 + var x254 uint32 + x254, x253 = bits.Mul32(x241, 0xaf48a03b) + var x255 uint32 + var x256 uint32 + x256, x255 = bits.Mul32(x241, 0xbfd25e8c) + var x257 uint32 + var x258 uint32 + x258, x257 = bits.Mul32(x241, 0xd0364141) + var x259 uint32 + var x260 uint32 + x259, x260 = bits.Add32(x258, x255, uint32(0x0)) + var x261 uint32 + var x262 uint32 + x261, x262 = bits.Add32(x256, x253, uint32(uint1(x260))) + var x263 uint32 + var x264 uint32 + x263, x264 = bits.Add32(x254, x251, uint32(uint1(x262))) + var x265 uint32 + var x266 uint32 + x265, x266 = bits.Add32(x252, x249, uint32(uint1(x264))) + var x267 uint32 + var x268 uint32 + x267, x268 = bits.Add32(x250, x247, uint32(uint1(x266))) + var x269 uint32 + var x270 uint32 + x269, x270 = bits.Add32(x248, x245, uint32(uint1(x268))) + var x271 uint32 + var x272 uint32 + x271, x272 = bits.Add32(x246, x243, uint32(uint1(x270))) + x273 := (uint32(uint1(x272)) + x244) + var x275 uint32 + _, x275 = bits.Add32(x223, x257, uint32(0x0)) + var x276 uint32 + var x277 uint32 + x276, x277 = bits.Add32(x225, x259, uint32(uint1(x275))) + var x278 uint32 + var x279 uint32 + x278, x279 = bits.Add32(x227, x261, uint32(uint1(x277))) + var x280 uint32 + var x281 uint32 + x280, x281 = bits.Add32(x229, x263, uint32(uint1(x279))) + var x282 uint32 + var x283 uint32 + x282, x283 = bits.Add32(x231, x265, uint32(uint1(x281))) + var x284 uint32 + var x285 uint32 + x284, x285 = bits.Add32(x233, x267, uint32(uint1(x283))) + var x286 uint32 + var x287 uint32 + x286, x287 = bits.Add32(x235, x269, uint32(uint1(x285))) + var x288 uint32 + var x289 uint32 + x288, x289 = bits.Add32(x237, x271, uint32(uint1(x287))) + var x290 uint32 + var x291 uint32 + x290, x291 = bits.Add32(x239, x273, uint32(uint1(x289))) + x292 := (uint32(uint1(x291)) + uint32(uint1(x240))) + var x293 uint32 + var x294 uint32 + x294, x293 = bits.Mul32(x3, arg2[7]) + var x295 uint32 + var x296 uint32 + x296, x295 = bits.Mul32(x3, arg2[6]) + var x297 uint32 + var x298 uint32 + x298, x297 = bits.Mul32(x3, arg2[5]) + var x299 uint32 + var x300 uint32 + x300, x299 = bits.Mul32(x3, arg2[4]) + var x301 uint32 + var x302 uint32 + x302, x301 = bits.Mul32(x3, arg2[3]) + var x303 uint32 + var x304 uint32 + x304, x303 = bits.Mul32(x3, arg2[2]) + var x305 uint32 + var x306 uint32 + x306, x305 = bits.Mul32(x3, arg2[1]) + var x307 uint32 + var x308 uint32 + x308, x307 = bits.Mul32(x3, arg2[0]) + var x309 uint32 + var x310 uint32 + x309, x310 = bits.Add32(x308, x305, uint32(0x0)) + var x311 uint32 + var x312 uint32 + x311, x312 = bits.Add32(x306, x303, uint32(uint1(x310))) + var x313 uint32 + var x314 uint32 + x313, x314 = bits.Add32(x304, x301, uint32(uint1(x312))) + var x315 uint32 + var x316 uint32 + x315, x316 = bits.Add32(x302, x299, uint32(uint1(x314))) + var x317 uint32 + var x318 uint32 + x317, x318 = bits.Add32(x300, x297, uint32(uint1(x316))) + var x319 uint32 + var x320 uint32 + x319, x320 = bits.Add32(x298, x295, uint32(uint1(x318))) + var x321 uint32 + var x322 uint32 + x321, x322 = bits.Add32(x296, x293, uint32(uint1(x320))) + x323 := (uint32(uint1(x322)) + x294) + var x324 uint32 + var x325 uint32 + x324, x325 = bits.Add32(x276, x307, uint32(0x0)) + var x326 uint32 + var x327 uint32 + x326, x327 = bits.Add32(x278, x309, uint32(uint1(x325))) + var x328 uint32 + var x329 uint32 + x328, x329 = bits.Add32(x280, x311, uint32(uint1(x327))) + var x330 uint32 + var x331 uint32 + x330, x331 = bits.Add32(x282, x313, uint32(uint1(x329))) + var x332 uint32 + var x333 uint32 + x332, x333 = bits.Add32(x284, x315, uint32(uint1(x331))) + var x334 uint32 + var x335 uint32 + x334, x335 = bits.Add32(x286, x317, uint32(uint1(x333))) + var x336 uint32 + var x337 uint32 + x336, x337 = bits.Add32(x288, x319, uint32(uint1(x335))) + var x338 uint32 + var x339 uint32 + x338, x339 = bits.Add32(x290, x321, uint32(uint1(x337))) + var x340 uint32 + var x341 uint32 + x340, x341 = bits.Add32(x292, x323, uint32(uint1(x339))) + var x342 uint32 + _, x342 = bits.Mul32(x324, 0x5588b13f) + var x344 uint32 + var x345 uint32 + x345, x344 = bits.Mul32(x342, 0xffffffff) + var x346 uint32 + var x347 uint32 + x347, x346 = bits.Mul32(x342, 0xffffffff) + var x348 uint32 + var x349 uint32 + x349, x348 = bits.Mul32(x342, 0xffffffff) + var x350 uint32 + var x351 uint32 + x351, x350 = bits.Mul32(x342, 0xfffffffe) + var x352 uint32 + var x353 uint32 + x353, x352 = bits.Mul32(x342, 0xbaaedce6) + var x354 uint32 + var x355 uint32 + x355, x354 = bits.Mul32(x342, 0xaf48a03b) + var x356 uint32 + var x357 uint32 + x357, x356 = bits.Mul32(x342, 0xbfd25e8c) + var x358 uint32 + var x359 uint32 + x359, x358 = bits.Mul32(x342, 0xd0364141) + var x360 uint32 + var x361 uint32 + x360, x361 = bits.Add32(x359, x356, uint32(0x0)) + var x362 uint32 + var x363 uint32 + x362, x363 = bits.Add32(x357, x354, uint32(uint1(x361))) + var x364 uint32 + var x365 uint32 + x364, x365 = bits.Add32(x355, x352, uint32(uint1(x363))) + var x366 uint32 + var x367 uint32 + x366, x367 = bits.Add32(x353, x350, uint32(uint1(x365))) + var x368 uint32 + var x369 uint32 + x368, x369 = bits.Add32(x351, x348, uint32(uint1(x367))) + var x370 uint32 + var x371 uint32 + x370, x371 = bits.Add32(x349, x346, uint32(uint1(x369))) + var x372 uint32 + var x373 uint32 + x372, x373 = bits.Add32(x347, x344, uint32(uint1(x371))) + x374 := (uint32(uint1(x373)) + x345) + var x376 uint32 + _, x376 = bits.Add32(x324, x358, uint32(0x0)) + var x377 uint32 + var x378 uint32 + x377, x378 = bits.Add32(x326, x360, uint32(uint1(x376))) + var x379 uint32 + var x380 uint32 + x379, x380 = bits.Add32(x328, x362, uint32(uint1(x378))) + var x381 uint32 + var x382 uint32 + x381, x382 = bits.Add32(x330, x364, uint32(uint1(x380))) + var x383 uint32 + var x384 uint32 + x383, x384 = bits.Add32(x332, x366, uint32(uint1(x382))) + var x385 uint32 + var x386 uint32 + x385, x386 = bits.Add32(x334, x368, uint32(uint1(x384))) + var x387 uint32 + var x388 uint32 + x387, x388 = bits.Add32(x336, x370, uint32(uint1(x386))) + var x389 uint32 + var x390 uint32 + x389, x390 = bits.Add32(x338, x372, uint32(uint1(x388))) + var x391 uint32 + var x392 uint32 + x391, x392 = bits.Add32(x340, x374, uint32(uint1(x390))) + x393 := (uint32(uint1(x392)) + uint32(uint1(x341))) + var x394 uint32 + var x395 uint32 + x395, x394 = bits.Mul32(x4, arg2[7]) + var x396 uint32 + var x397 uint32 + x397, x396 = bits.Mul32(x4, arg2[6]) + var x398 uint32 + var x399 uint32 + x399, x398 = bits.Mul32(x4, arg2[5]) + var x400 uint32 + var x401 uint32 + x401, x400 = bits.Mul32(x4, arg2[4]) + var x402 uint32 + var x403 uint32 + x403, x402 = bits.Mul32(x4, arg2[3]) + var x404 uint32 + var x405 uint32 + x405, x404 = bits.Mul32(x4, arg2[2]) + var x406 uint32 + var x407 uint32 + x407, x406 = bits.Mul32(x4, arg2[1]) + var x408 uint32 + var x409 uint32 + x409, x408 = bits.Mul32(x4, arg2[0]) + var x410 uint32 + var x411 uint32 + x410, x411 = bits.Add32(x409, x406, uint32(0x0)) + var x412 uint32 + var x413 uint32 + x412, x413 = bits.Add32(x407, x404, uint32(uint1(x411))) + var x414 uint32 + var x415 uint32 + x414, x415 = bits.Add32(x405, x402, uint32(uint1(x413))) + var x416 uint32 + var x417 uint32 + x416, x417 = bits.Add32(x403, x400, uint32(uint1(x415))) + var x418 uint32 + var x419 uint32 + x418, x419 = bits.Add32(x401, x398, uint32(uint1(x417))) + var x420 uint32 + var x421 uint32 + x420, x421 = bits.Add32(x399, x396, uint32(uint1(x419))) + var x422 uint32 + var x423 uint32 + x422, x423 = bits.Add32(x397, x394, uint32(uint1(x421))) + x424 := (uint32(uint1(x423)) + x395) + var x425 uint32 + var x426 uint32 + x425, x426 = bits.Add32(x377, x408, uint32(0x0)) + var x427 uint32 + var x428 uint32 + x427, x428 = bits.Add32(x379, x410, uint32(uint1(x426))) + var x429 uint32 + var x430 uint32 + x429, x430 = bits.Add32(x381, x412, uint32(uint1(x428))) + var x431 uint32 + var x432 uint32 + x431, x432 = bits.Add32(x383, x414, uint32(uint1(x430))) + var x433 uint32 + var x434 uint32 + x433, x434 = bits.Add32(x385, x416, uint32(uint1(x432))) + var x435 uint32 + var x436 uint32 + x435, x436 = bits.Add32(x387, x418, uint32(uint1(x434))) + var x437 uint32 + var x438 uint32 + x437, x438 = bits.Add32(x389, x420, uint32(uint1(x436))) + var x439 uint32 + var x440 uint32 + x439, x440 = bits.Add32(x391, x422, uint32(uint1(x438))) + var x441 uint32 + var x442 uint32 + x441, x442 = bits.Add32(x393, x424, uint32(uint1(x440))) + var x443 uint32 + _, x443 = bits.Mul32(x425, 0x5588b13f) + var x445 uint32 + var x446 uint32 + x446, x445 = bits.Mul32(x443, 0xffffffff) + var x447 uint32 + var x448 uint32 + x448, x447 = bits.Mul32(x443, 0xffffffff) + var x449 uint32 + var x450 uint32 + x450, x449 = bits.Mul32(x443, 0xffffffff) + var x451 uint32 + var x452 uint32 + x452, x451 = bits.Mul32(x443, 0xfffffffe) + var x453 uint32 + var x454 uint32 + x454, x453 = bits.Mul32(x443, 0xbaaedce6) + var x455 uint32 + var x456 uint32 + x456, x455 = bits.Mul32(x443, 0xaf48a03b) + var x457 uint32 + var x458 uint32 + x458, x457 = bits.Mul32(x443, 0xbfd25e8c) + var x459 uint32 + var x460 uint32 + x460, x459 = bits.Mul32(x443, 0xd0364141) + var x461 uint32 + var x462 uint32 + x461, x462 = bits.Add32(x460, x457, uint32(0x0)) + var x463 uint32 + var x464 uint32 + x463, x464 = bits.Add32(x458, x455, uint32(uint1(x462))) + var x465 uint32 + var x466 uint32 + x465, x466 = bits.Add32(x456, x453, uint32(uint1(x464))) + var x467 uint32 + var x468 uint32 + x467, x468 = bits.Add32(x454, x451, uint32(uint1(x466))) + var x469 uint32 + var x470 uint32 + x469, x470 = bits.Add32(x452, x449, uint32(uint1(x468))) + var x471 uint32 + var x472 uint32 + x471, x472 = bits.Add32(x450, x447, uint32(uint1(x470))) + var x473 uint32 + var x474 uint32 + x473, x474 = bits.Add32(x448, x445, uint32(uint1(x472))) + x475 := (uint32(uint1(x474)) + x446) + var x477 uint32 + _, x477 = bits.Add32(x425, x459, uint32(0x0)) + var x478 uint32 + var x479 uint32 + x478, x479 = bits.Add32(x427, x461, uint32(uint1(x477))) + var x480 uint32 + var x481 uint32 + x480, x481 = bits.Add32(x429, x463, uint32(uint1(x479))) + var x482 uint32 + var x483 uint32 + x482, x483 = bits.Add32(x431, x465, uint32(uint1(x481))) + var x484 uint32 + var x485 uint32 + x484, x485 = bits.Add32(x433, x467, uint32(uint1(x483))) + var x486 uint32 + var x487 uint32 + x486, x487 = bits.Add32(x435, x469, uint32(uint1(x485))) + var x488 uint32 + var x489 uint32 + x488, x489 = bits.Add32(x437, x471, uint32(uint1(x487))) + var x490 uint32 + var x491 uint32 + x490, x491 = bits.Add32(x439, x473, uint32(uint1(x489))) + var x492 uint32 + var x493 uint32 + x492, x493 = bits.Add32(x441, x475, uint32(uint1(x491))) + x494 := (uint32(uint1(x493)) + uint32(uint1(x442))) + var x495 uint32 + var x496 uint32 + x496, x495 = bits.Mul32(x5, arg2[7]) + var x497 uint32 + var x498 uint32 + x498, x497 = bits.Mul32(x5, arg2[6]) + var x499 uint32 + var x500 uint32 + x500, x499 = bits.Mul32(x5, arg2[5]) + var x501 uint32 + var x502 uint32 + x502, x501 = bits.Mul32(x5, arg2[4]) + var x503 uint32 + var x504 uint32 + x504, x503 = bits.Mul32(x5, arg2[3]) + var x505 uint32 + var x506 uint32 + x506, x505 = bits.Mul32(x5, arg2[2]) + var x507 uint32 + var x508 uint32 + x508, x507 = bits.Mul32(x5, arg2[1]) + var x509 uint32 + var x510 uint32 + x510, x509 = bits.Mul32(x5, arg2[0]) + var x511 uint32 + var x512 uint32 + x511, x512 = bits.Add32(x510, x507, uint32(0x0)) + var x513 uint32 + var x514 uint32 + x513, x514 = bits.Add32(x508, x505, uint32(uint1(x512))) + var x515 uint32 + var x516 uint32 + x515, x516 = bits.Add32(x506, x503, uint32(uint1(x514))) + var x517 uint32 + var x518 uint32 + x517, x518 = bits.Add32(x504, x501, uint32(uint1(x516))) + var x519 uint32 + var x520 uint32 + x519, x520 = bits.Add32(x502, x499, uint32(uint1(x518))) + var x521 uint32 + var x522 uint32 + x521, x522 = bits.Add32(x500, x497, uint32(uint1(x520))) + var x523 uint32 + var x524 uint32 + x523, x524 = bits.Add32(x498, x495, uint32(uint1(x522))) + x525 := (uint32(uint1(x524)) + x496) + var x526 uint32 + var x527 uint32 + x526, x527 = bits.Add32(x478, x509, uint32(0x0)) + var x528 uint32 + var x529 uint32 + x528, x529 = bits.Add32(x480, x511, uint32(uint1(x527))) + var x530 uint32 + var x531 uint32 + x530, x531 = bits.Add32(x482, x513, uint32(uint1(x529))) + var x532 uint32 + var x533 uint32 + x532, x533 = bits.Add32(x484, x515, uint32(uint1(x531))) + var x534 uint32 + var x535 uint32 + x534, x535 = bits.Add32(x486, x517, uint32(uint1(x533))) + var x536 uint32 + var x537 uint32 + x536, x537 = bits.Add32(x488, x519, uint32(uint1(x535))) + var x538 uint32 + var x539 uint32 + x538, x539 = bits.Add32(x490, x521, uint32(uint1(x537))) + var x540 uint32 + var x541 uint32 + x540, x541 = bits.Add32(x492, x523, uint32(uint1(x539))) + var x542 uint32 + var x543 uint32 + x542, x543 = bits.Add32(x494, x525, uint32(uint1(x541))) + var x544 uint32 + _, x544 = bits.Mul32(x526, 0x5588b13f) + var x546 uint32 + var x547 uint32 + x547, x546 = bits.Mul32(x544, 0xffffffff) + var x548 uint32 + var x549 uint32 + x549, x548 = bits.Mul32(x544, 0xffffffff) + var x550 uint32 + var x551 uint32 + x551, x550 = bits.Mul32(x544, 0xffffffff) + var x552 uint32 + var x553 uint32 + x553, x552 = bits.Mul32(x544, 0xfffffffe) + var x554 uint32 + var x555 uint32 + x555, x554 = bits.Mul32(x544, 0xbaaedce6) + var x556 uint32 + var x557 uint32 + x557, x556 = bits.Mul32(x544, 0xaf48a03b) + var x558 uint32 + var x559 uint32 + x559, x558 = bits.Mul32(x544, 0xbfd25e8c) + var x560 uint32 + var x561 uint32 + x561, x560 = bits.Mul32(x544, 0xd0364141) + var x562 uint32 + var x563 uint32 + x562, x563 = bits.Add32(x561, x558, uint32(0x0)) + var x564 uint32 + var x565 uint32 + x564, x565 = bits.Add32(x559, x556, uint32(uint1(x563))) + var x566 uint32 + var x567 uint32 + x566, x567 = bits.Add32(x557, x554, uint32(uint1(x565))) + var x568 uint32 + var x569 uint32 + x568, x569 = bits.Add32(x555, x552, uint32(uint1(x567))) + var x570 uint32 + var x571 uint32 + x570, x571 = bits.Add32(x553, x550, uint32(uint1(x569))) + var x572 uint32 + var x573 uint32 + x572, x573 = bits.Add32(x551, x548, uint32(uint1(x571))) + var x574 uint32 + var x575 uint32 + x574, x575 = bits.Add32(x549, x546, uint32(uint1(x573))) + x576 := (uint32(uint1(x575)) + x547) + var x578 uint32 + _, x578 = bits.Add32(x526, x560, uint32(0x0)) + var x579 uint32 + var x580 uint32 + x579, x580 = bits.Add32(x528, x562, uint32(uint1(x578))) + var x581 uint32 + var x582 uint32 + x581, x582 = bits.Add32(x530, x564, uint32(uint1(x580))) + var x583 uint32 + var x584 uint32 + x583, x584 = bits.Add32(x532, x566, uint32(uint1(x582))) + var x585 uint32 + var x586 uint32 + x585, x586 = bits.Add32(x534, x568, uint32(uint1(x584))) + var x587 uint32 + var x588 uint32 + x587, x588 = bits.Add32(x536, x570, uint32(uint1(x586))) + var x589 uint32 + var x590 uint32 + x589, x590 = bits.Add32(x538, x572, uint32(uint1(x588))) + var x591 uint32 + var x592 uint32 + x591, x592 = bits.Add32(x540, x574, uint32(uint1(x590))) + var x593 uint32 + var x594 uint32 + x593, x594 = bits.Add32(x542, x576, uint32(uint1(x592))) + x595 := (uint32(uint1(x594)) + uint32(uint1(x543))) + var x596 uint32 + var x597 uint32 + x597, x596 = bits.Mul32(x6, arg2[7]) + var x598 uint32 + var x599 uint32 + x599, x598 = bits.Mul32(x6, arg2[6]) + var x600 uint32 + var x601 uint32 + x601, x600 = bits.Mul32(x6, arg2[5]) + var x602 uint32 + var x603 uint32 + x603, x602 = bits.Mul32(x6, arg2[4]) + var x604 uint32 + var x605 uint32 + x605, x604 = bits.Mul32(x6, arg2[3]) + var x606 uint32 + var x607 uint32 + x607, x606 = bits.Mul32(x6, arg2[2]) + var x608 uint32 + var x609 uint32 + x609, x608 = bits.Mul32(x6, arg2[1]) + var x610 uint32 + var x611 uint32 + x611, x610 = bits.Mul32(x6, arg2[0]) + var x612 uint32 + var x613 uint32 + x612, x613 = bits.Add32(x611, x608, uint32(0x0)) + var x614 uint32 + var x615 uint32 + x614, x615 = bits.Add32(x609, x606, uint32(uint1(x613))) + var x616 uint32 + var x617 uint32 + x616, x617 = bits.Add32(x607, x604, uint32(uint1(x615))) + var x618 uint32 + var x619 uint32 + x618, x619 = bits.Add32(x605, x602, uint32(uint1(x617))) + var x620 uint32 + var x621 uint32 + x620, x621 = bits.Add32(x603, x600, uint32(uint1(x619))) + var x622 uint32 + var x623 uint32 + x622, x623 = bits.Add32(x601, x598, uint32(uint1(x621))) + var x624 uint32 + var x625 uint32 + x624, x625 = bits.Add32(x599, x596, uint32(uint1(x623))) + x626 := (uint32(uint1(x625)) + x597) + var x627 uint32 + var x628 uint32 + x627, x628 = bits.Add32(x579, x610, uint32(0x0)) + var x629 uint32 + var x630 uint32 + x629, x630 = bits.Add32(x581, x612, uint32(uint1(x628))) + var x631 uint32 + var x632 uint32 + x631, x632 = bits.Add32(x583, x614, uint32(uint1(x630))) + var x633 uint32 + var x634 uint32 + x633, x634 = bits.Add32(x585, x616, uint32(uint1(x632))) + var x635 uint32 + var x636 uint32 + x635, x636 = bits.Add32(x587, x618, uint32(uint1(x634))) + var x637 uint32 + var x638 uint32 + x637, x638 = bits.Add32(x589, x620, uint32(uint1(x636))) + var x639 uint32 + var x640 uint32 + x639, x640 = bits.Add32(x591, x622, uint32(uint1(x638))) + var x641 uint32 + var x642 uint32 + x641, x642 = bits.Add32(x593, x624, uint32(uint1(x640))) + var x643 uint32 + var x644 uint32 + x643, x644 = bits.Add32(x595, x626, uint32(uint1(x642))) + var x645 uint32 + _, x645 = bits.Mul32(x627, 0x5588b13f) + var x647 uint32 + var x648 uint32 + x648, x647 = bits.Mul32(x645, 0xffffffff) + var x649 uint32 + var x650 uint32 + x650, x649 = bits.Mul32(x645, 0xffffffff) + var x651 uint32 + var x652 uint32 + x652, x651 = bits.Mul32(x645, 0xffffffff) + var x653 uint32 + var x654 uint32 + x654, x653 = bits.Mul32(x645, 0xfffffffe) + var x655 uint32 + var x656 uint32 + x656, x655 = bits.Mul32(x645, 0xbaaedce6) + var x657 uint32 + var x658 uint32 + x658, x657 = bits.Mul32(x645, 0xaf48a03b) + var x659 uint32 + var x660 uint32 + x660, x659 = bits.Mul32(x645, 0xbfd25e8c) + var x661 uint32 + var x662 uint32 + x662, x661 = bits.Mul32(x645, 0xd0364141) + var x663 uint32 + var x664 uint32 + x663, x664 = bits.Add32(x662, x659, uint32(0x0)) + var x665 uint32 + var x666 uint32 + x665, x666 = bits.Add32(x660, x657, uint32(uint1(x664))) + var x667 uint32 + var x668 uint32 + x667, x668 = bits.Add32(x658, x655, uint32(uint1(x666))) + var x669 uint32 + var x670 uint32 + x669, x670 = bits.Add32(x656, x653, uint32(uint1(x668))) + var x671 uint32 + var x672 uint32 + x671, x672 = bits.Add32(x654, x651, uint32(uint1(x670))) + var x673 uint32 + var x674 uint32 + x673, x674 = bits.Add32(x652, x649, uint32(uint1(x672))) + var x675 uint32 + var x676 uint32 + x675, x676 = bits.Add32(x650, x647, uint32(uint1(x674))) + x677 := (uint32(uint1(x676)) + x648) + var x679 uint32 + _, x679 = bits.Add32(x627, x661, uint32(0x0)) + var x680 uint32 + var x681 uint32 + x680, x681 = bits.Add32(x629, x663, uint32(uint1(x679))) + var x682 uint32 + var x683 uint32 + x682, x683 = bits.Add32(x631, x665, uint32(uint1(x681))) + var x684 uint32 + var x685 uint32 + x684, x685 = bits.Add32(x633, x667, uint32(uint1(x683))) + var x686 uint32 + var x687 uint32 + x686, x687 = bits.Add32(x635, x669, uint32(uint1(x685))) + var x688 uint32 + var x689 uint32 + x688, x689 = bits.Add32(x637, x671, uint32(uint1(x687))) + var x690 uint32 + var x691 uint32 + x690, x691 = bits.Add32(x639, x673, uint32(uint1(x689))) + var x692 uint32 + var x693 uint32 + x692, x693 = bits.Add32(x641, x675, uint32(uint1(x691))) + var x694 uint32 + var x695 uint32 + x694, x695 = bits.Add32(x643, x677, uint32(uint1(x693))) + x696 := (uint32(uint1(x695)) + uint32(uint1(x644))) + var x697 uint32 + var x698 uint32 + x698, x697 = bits.Mul32(x7, arg2[7]) + var x699 uint32 + var x700 uint32 + x700, x699 = bits.Mul32(x7, arg2[6]) + var x701 uint32 + var x702 uint32 + x702, x701 = bits.Mul32(x7, arg2[5]) + var x703 uint32 + var x704 uint32 + x704, x703 = bits.Mul32(x7, arg2[4]) + var x705 uint32 + var x706 uint32 + x706, x705 = bits.Mul32(x7, arg2[3]) + var x707 uint32 + var x708 uint32 + x708, x707 = bits.Mul32(x7, arg2[2]) + var x709 uint32 + var x710 uint32 + x710, x709 = bits.Mul32(x7, arg2[1]) + var x711 uint32 + var x712 uint32 + x712, x711 = bits.Mul32(x7, arg2[0]) + var x713 uint32 + var x714 uint32 + x713, x714 = bits.Add32(x712, x709, uint32(0x0)) + var x715 uint32 + var x716 uint32 + x715, x716 = bits.Add32(x710, x707, uint32(uint1(x714))) + var x717 uint32 + var x718 uint32 + x717, x718 = bits.Add32(x708, x705, uint32(uint1(x716))) + var x719 uint32 + var x720 uint32 + x719, x720 = bits.Add32(x706, x703, uint32(uint1(x718))) + var x721 uint32 + var x722 uint32 + x721, x722 = bits.Add32(x704, x701, uint32(uint1(x720))) + var x723 uint32 + var x724 uint32 + x723, x724 = bits.Add32(x702, x699, uint32(uint1(x722))) + var x725 uint32 + var x726 uint32 + x725, x726 = bits.Add32(x700, x697, uint32(uint1(x724))) + x727 := (uint32(uint1(x726)) + x698) + var x728 uint32 + var x729 uint32 + x728, x729 = bits.Add32(x680, x711, uint32(0x0)) + var x730 uint32 + var x731 uint32 + x730, x731 = bits.Add32(x682, x713, uint32(uint1(x729))) + var x732 uint32 + var x733 uint32 + x732, x733 = bits.Add32(x684, x715, uint32(uint1(x731))) + var x734 uint32 + var x735 uint32 + x734, x735 = bits.Add32(x686, x717, uint32(uint1(x733))) + var x736 uint32 + var x737 uint32 + x736, x737 = bits.Add32(x688, x719, uint32(uint1(x735))) + var x738 uint32 + var x739 uint32 + x738, x739 = bits.Add32(x690, x721, uint32(uint1(x737))) + var x740 uint32 + var x741 uint32 + x740, x741 = bits.Add32(x692, x723, uint32(uint1(x739))) + var x742 uint32 + var x743 uint32 + x742, x743 = bits.Add32(x694, x725, uint32(uint1(x741))) + var x744 uint32 + var x745 uint32 + x744, x745 = bits.Add32(x696, x727, uint32(uint1(x743))) + var x746 uint32 + _, x746 = bits.Mul32(x728, 0x5588b13f) + var x748 uint32 + var x749 uint32 + x749, x748 = bits.Mul32(x746, 0xffffffff) + var x750 uint32 + var x751 uint32 + x751, x750 = bits.Mul32(x746, 0xffffffff) + var x752 uint32 + var x753 uint32 + x753, x752 = bits.Mul32(x746, 0xffffffff) + var x754 uint32 + var x755 uint32 + x755, x754 = bits.Mul32(x746, 0xfffffffe) + var x756 uint32 + var x757 uint32 + x757, x756 = bits.Mul32(x746, 0xbaaedce6) + var x758 uint32 + var x759 uint32 + x759, x758 = bits.Mul32(x746, 0xaf48a03b) + var x760 uint32 + var x761 uint32 + x761, x760 = bits.Mul32(x746, 0xbfd25e8c) + var x762 uint32 + var x763 uint32 + x763, x762 = bits.Mul32(x746, 0xd0364141) + var x764 uint32 + var x765 uint32 + x764, x765 = bits.Add32(x763, x760, uint32(0x0)) + var x766 uint32 + var x767 uint32 + x766, x767 = bits.Add32(x761, x758, uint32(uint1(x765))) + var x768 uint32 + var x769 uint32 + x768, x769 = bits.Add32(x759, x756, uint32(uint1(x767))) + var x770 uint32 + var x771 uint32 + x770, x771 = bits.Add32(x757, x754, uint32(uint1(x769))) + var x772 uint32 + var x773 uint32 + x772, x773 = bits.Add32(x755, x752, uint32(uint1(x771))) + var x774 uint32 + var x775 uint32 + x774, x775 = bits.Add32(x753, x750, uint32(uint1(x773))) + var x776 uint32 + var x777 uint32 + x776, x777 = bits.Add32(x751, x748, uint32(uint1(x775))) + x778 := (uint32(uint1(x777)) + x749) + var x780 uint32 + _, x780 = bits.Add32(x728, x762, uint32(0x0)) + var x781 uint32 + var x782 uint32 + x781, x782 = bits.Add32(x730, x764, uint32(uint1(x780))) + var x783 uint32 + var x784 uint32 + x783, x784 = bits.Add32(x732, x766, uint32(uint1(x782))) + var x785 uint32 + var x786 uint32 + x785, x786 = bits.Add32(x734, x768, uint32(uint1(x784))) + var x787 uint32 + var x788 uint32 + x787, x788 = bits.Add32(x736, x770, uint32(uint1(x786))) + var x789 uint32 + var x790 uint32 + x789, x790 = bits.Add32(x738, x772, uint32(uint1(x788))) + var x791 uint32 + var x792 uint32 + x791, x792 = bits.Add32(x740, x774, uint32(uint1(x790))) + var x793 uint32 + var x794 uint32 + x793, x794 = bits.Add32(x742, x776, uint32(uint1(x792))) + var x795 uint32 + var x796 uint32 + x795, x796 = bits.Add32(x744, x778, uint32(uint1(x794))) + x797 := (uint32(uint1(x796)) + uint32(uint1(x745))) + var x798 uint32 + var x799 uint32 + x798, x799 = bits.Sub32(x781, 0xd0364141, uint32(0x0)) + var x800 uint32 + var x801 uint32 + x800, x801 = bits.Sub32(x783, 0xbfd25e8c, uint32(uint1(x799))) + var x802 uint32 + var x803 uint32 + x802, x803 = bits.Sub32(x785, 0xaf48a03b, uint32(uint1(x801))) + var x804 uint32 + var x805 uint32 + x804, x805 = bits.Sub32(x787, 0xbaaedce6, uint32(uint1(x803))) + var x806 uint32 + var x807 uint32 + x806, x807 = bits.Sub32(x789, 0xfffffffe, uint32(uint1(x805))) + var x808 uint32 + var x809 uint32 + x808, x809 = bits.Sub32(x791, 0xffffffff, uint32(uint1(x807))) + var x810 uint32 + var x811 uint32 + x810, x811 = bits.Sub32(x793, 0xffffffff, uint32(uint1(x809))) + var x812 uint32 + var x813 uint32 + x812, x813 = bits.Sub32(x795, 0xffffffff, uint32(uint1(x811))) + var x815 uint32 + _, x815 = bits.Sub32(x797, uint32(0x0), uint32(uint1(x813))) + var x816 uint32 + cmovznzU32(&x816, uint1(x815), x798, x781) + var x817 uint32 + cmovznzU32(&x817, uint1(x815), x800, x783) + var x818 uint32 + cmovznzU32(&x818, uint1(x815), x802, x785) + var x819 uint32 + cmovznzU32(&x819, uint1(x815), x804, x787) + var x820 uint32 + cmovznzU32(&x820, uint1(x815), x806, x789) + var x821 uint32 + cmovznzU32(&x821, uint1(x815), x808, x791) + var x822 uint32 + cmovznzU32(&x822, uint1(x815), x810, x793) + var x823 uint32 + cmovznzU32(&x823, uint1(x815), x812, x795) + out1[0] = x816 + out1[1] = x817 + out1[2] = x818 + out1[3] = x819 + out1[4] = x820 + out1[5] = x821 + out1[6] = x822 + out1[7] = x823 +} + +// Square squares a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +// 0 ≤ eval out1 < m +// +func Square(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[6] + x7 := arg1[7] + x8 := arg1[0] + var x9 uint32 + var x10 uint32 + x10, x9 = bits.Mul32(x8, arg1[7]) + var x11 uint32 + var x12 uint32 + x12, x11 = bits.Mul32(x8, arg1[6]) + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x8, arg1[5]) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x8, arg1[4]) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x8, arg1[3]) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x8, arg1[2]) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x8, arg1[1]) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x8, arg1[0]) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Add32(x24, x21, uint32(0x0)) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Add32(x22, x19, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Add32(x20, x17, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Add32(x18, x15, uint32(uint1(x30))) + var x33 uint32 + var x34 uint32 + x33, x34 = bits.Add32(x16, x13, uint32(uint1(x32))) + var x35 uint32 + var x36 uint32 + x35, x36 = bits.Add32(x14, x11, uint32(uint1(x34))) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Add32(x12, x9, uint32(uint1(x36))) + x39 := (uint32(uint1(x38)) + x10) + var x40 uint32 + _, x40 = bits.Mul32(x23, 0x5588b13f) + var x42 uint32 + var x43 uint32 + x43, x42 = bits.Mul32(x40, 0xffffffff) + var x44 uint32 + var x45 uint32 + x45, x44 = bits.Mul32(x40, 0xffffffff) + var x46 uint32 + var x47 uint32 + x47, x46 = bits.Mul32(x40, 0xffffffff) + var x48 uint32 + var x49 uint32 + x49, x48 = bits.Mul32(x40, 0xfffffffe) + var x50 uint32 + var x51 uint32 + x51, x50 = bits.Mul32(x40, 0xbaaedce6) + var x52 uint32 + var x53 uint32 + x53, x52 = bits.Mul32(x40, 0xaf48a03b) + var x54 uint32 + var x55 uint32 + x55, x54 = bits.Mul32(x40, 0xbfd25e8c) + var x56 uint32 + var x57 uint32 + x57, x56 = bits.Mul32(x40, 0xd0364141) + var x58 uint32 + var x59 uint32 + x58, x59 = bits.Add32(x57, x54, uint32(0x0)) + var x60 uint32 + var x61 uint32 + x60, x61 = bits.Add32(x55, x52, uint32(uint1(x59))) + var x62 uint32 + var x63 uint32 + x62, x63 = bits.Add32(x53, x50, uint32(uint1(x61))) + var x64 uint32 + var x65 uint32 + x64, x65 = bits.Add32(x51, x48, uint32(uint1(x63))) + var x66 uint32 + var x67 uint32 + x66, x67 = bits.Add32(x49, x46, uint32(uint1(x65))) + var x68 uint32 + var x69 uint32 + x68, x69 = bits.Add32(x47, x44, uint32(uint1(x67))) + var x70 uint32 + var x71 uint32 + x70, x71 = bits.Add32(x45, x42, uint32(uint1(x69))) + x72 := (uint32(uint1(x71)) + x43) + var x74 uint32 + _, x74 = bits.Add32(x23, x56, uint32(0x0)) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Add32(x25, x58, uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x77, x78 = bits.Add32(x27, x60, uint32(uint1(x76))) + var x79 uint32 + var x80 uint32 + x79, x80 = bits.Add32(x29, x62, uint32(uint1(x78))) + var x81 uint32 + var x82 uint32 + x81, x82 = bits.Add32(x31, x64, uint32(uint1(x80))) + var x83 uint32 + var x84 uint32 + x83, x84 = bits.Add32(x33, x66, uint32(uint1(x82))) + var x85 uint32 + var x86 uint32 + x85, x86 = bits.Add32(x35, x68, uint32(uint1(x84))) + var x87 uint32 + var x88 uint32 + x87, x88 = bits.Add32(x37, x70, uint32(uint1(x86))) + var x89 uint32 + var x90 uint32 + x89, x90 = bits.Add32(x39, x72, uint32(uint1(x88))) + var x91 uint32 + var x92 uint32 + x92, x91 = bits.Mul32(x1, arg1[7]) + var x93 uint32 + var x94 uint32 + x94, x93 = bits.Mul32(x1, arg1[6]) + var x95 uint32 + var x96 uint32 + x96, x95 = bits.Mul32(x1, arg1[5]) + var x97 uint32 + var x98 uint32 + x98, x97 = bits.Mul32(x1, arg1[4]) + var x99 uint32 + var x100 uint32 + x100, x99 = bits.Mul32(x1, arg1[3]) + var x101 uint32 + var x102 uint32 + x102, x101 = bits.Mul32(x1, arg1[2]) + var x103 uint32 + var x104 uint32 + x104, x103 = bits.Mul32(x1, arg1[1]) + var x105 uint32 + var x106 uint32 + x106, x105 = bits.Mul32(x1, arg1[0]) + var x107 uint32 + var x108 uint32 + x107, x108 = bits.Add32(x106, x103, uint32(0x0)) + var x109 uint32 + var x110 uint32 + x109, x110 = bits.Add32(x104, x101, uint32(uint1(x108))) + var x111 uint32 + var x112 uint32 + x111, x112 = bits.Add32(x102, x99, uint32(uint1(x110))) + var x113 uint32 + var x114 uint32 + x113, x114 = bits.Add32(x100, x97, uint32(uint1(x112))) + var x115 uint32 + var x116 uint32 + x115, x116 = bits.Add32(x98, x95, uint32(uint1(x114))) + var x117 uint32 + var x118 uint32 + x117, x118 = bits.Add32(x96, x93, uint32(uint1(x116))) + var x119 uint32 + var x120 uint32 + x119, x120 = bits.Add32(x94, x91, uint32(uint1(x118))) + x121 := (uint32(uint1(x120)) + x92) + var x122 uint32 + var x123 uint32 + x122, x123 = bits.Add32(x75, x105, uint32(0x0)) + var x124 uint32 + var x125 uint32 + x124, x125 = bits.Add32(x77, x107, uint32(uint1(x123))) + var x126 uint32 + var x127 uint32 + x126, x127 = bits.Add32(x79, x109, uint32(uint1(x125))) + var x128 uint32 + var x129 uint32 + x128, x129 = bits.Add32(x81, x111, uint32(uint1(x127))) + var x130 uint32 + var x131 uint32 + x130, x131 = bits.Add32(x83, x113, uint32(uint1(x129))) + var x132 uint32 + var x133 uint32 + x132, x133 = bits.Add32(x85, x115, uint32(uint1(x131))) + var x134 uint32 + var x135 uint32 + x134, x135 = bits.Add32(x87, x117, uint32(uint1(x133))) + var x136 uint32 + var x137 uint32 + x136, x137 = bits.Add32(x89, x119, uint32(uint1(x135))) + var x138 uint32 + var x139 uint32 + x138, x139 = bits.Add32(uint32(uint1(x90)), x121, uint32(uint1(x137))) + var x140 uint32 + _, x140 = bits.Mul32(x122, 0x5588b13f) + var x142 uint32 + var x143 uint32 + x143, x142 = bits.Mul32(x140, 0xffffffff) + var x144 uint32 + var x145 uint32 + x145, x144 = bits.Mul32(x140, 0xffffffff) + var x146 uint32 + var x147 uint32 + x147, x146 = bits.Mul32(x140, 0xffffffff) + var x148 uint32 + var x149 uint32 + x149, x148 = bits.Mul32(x140, 0xfffffffe) + var x150 uint32 + var x151 uint32 + x151, x150 = bits.Mul32(x140, 0xbaaedce6) + var x152 uint32 + var x153 uint32 + x153, x152 = bits.Mul32(x140, 0xaf48a03b) + var x154 uint32 + var x155 uint32 + x155, x154 = bits.Mul32(x140, 0xbfd25e8c) + var x156 uint32 + var x157 uint32 + x157, x156 = bits.Mul32(x140, 0xd0364141) + var x158 uint32 + var x159 uint32 + x158, x159 = bits.Add32(x157, x154, uint32(0x0)) + var x160 uint32 + var x161 uint32 + x160, x161 = bits.Add32(x155, x152, uint32(uint1(x159))) + var x162 uint32 + var x163 uint32 + x162, x163 = bits.Add32(x153, x150, uint32(uint1(x161))) + var x164 uint32 + var x165 uint32 + x164, x165 = bits.Add32(x151, x148, uint32(uint1(x163))) + var x166 uint32 + var x167 uint32 + x166, x167 = bits.Add32(x149, x146, uint32(uint1(x165))) + var x168 uint32 + var x169 uint32 + x168, x169 = bits.Add32(x147, x144, uint32(uint1(x167))) + var x170 uint32 + var x171 uint32 + x170, x171 = bits.Add32(x145, x142, uint32(uint1(x169))) + x172 := (uint32(uint1(x171)) + x143) + var x174 uint32 + _, x174 = bits.Add32(x122, x156, uint32(0x0)) + var x175 uint32 + var x176 uint32 + x175, x176 = bits.Add32(x124, x158, uint32(uint1(x174))) + var x177 uint32 + var x178 uint32 + x177, x178 = bits.Add32(x126, x160, uint32(uint1(x176))) + var x179 uint32 + var x180 uint32 + x179, x180 = bits.Add32(x128, x162, uint32(uint1(x178))) + var x181 uint32 + var x182 uint32 + x181, x182 = bits.Add32(x130, x164, uint32(uint1(x180))) + var x183 uint32 + var x184 uint32 + x183, x184 = bits.Add32(x132, x166, uint32(uint1(x182))) + var x185 uint32 + var x186 uint32 + x185, x186 = bits.Add32(x134, x168, uint32(uint1(x184))) + var x187 uint32 + var x188 uint32 + x187, x188 = bits.Add32(x136, x170, uint32(uint1(x186))) + var x189 uint32 + var x190 uint32 + x189, x190 = bits.Add32(x138, x172, uint32(uint1(x188))) + x191 := (uint32(uint1(x190)) + uint32(uint1(x139))) + var x192 uint32 + var x193 uint32 + x193, x192 = bits.Mul32(x2, arg1[7]) + var x194 uint32 + var x195 uint32 + x195, x194 = bits.Mul32(x2, arg1[6]) + var x196 uint32 + var x197 uint32 + x197, x196 = bits.Mul32(x2, arg1[5]) + var x198 uint32 + var x199 uint32 + x199, x198 = bits.Mul32(x2, arg1[4]) + var x200 uint32 + var x201 uint32 + x201, x200 = bits.Mul32(x2, arg1[3]) + var x202 uint32 + var x203 uint32 + x203, x202 = bits.Mul32(x2, arg1[2]) + var x204 uint32 + var x205 uint32 + x205, x204 = bits.Mul32(x2, arg1[1]) + var x206 uint32 + var x207 uint32 + x207, x206 = bits.Mul32(x2, arg1[0]) + var x208 uint32 + var x209 uint32 + x208, x209 = bits.Add32(x207, x204, uint32(0x0)) + var x210 uint32 + var x211 uint32 + x210, x211 = bits.Add32(x205, x202, uint32(uint1(x209))) + var x212 uint32 + var x213 uint32 + x212, x213 = bits.Add32(x203, x200, uint32(uint1(x211))) + var x214 uint32 + var x215 uint32 + x214, x215 = bits.Add32(x201, x198, uint32(uint1(x213))) + var x216 uint32 + var x217 uint32 + x216, x217 = bits.Add32(x199, x196, uint32(uint1(x215))) + var x218 uint32 + var x219 uint32 + x218, x219 = bits.Add32(x197, x194, uint32(uint1(x217))) + var x220 uint32 + var x221 uint32 + x220, x221 = bits.Add32(x195, x192, uint32(uint1(x219))) + x222 := (uint32(uint1(x221)) + x193) + var x223 uint32 + var x224 uint32 + x223, x224 = bits.Add32(x175, x206, uint32(0x0)) + var x225 uint32 + var x226 uint32 + x225, x226 = bits.Add32(x177, x208, uint32(uint1(x224))) + var x227 uint32 + var x228 uint32 + x227, x228 = bits.Add32(x179, x210, uint32(uint1(x226))) + var x229 uint32 + var x230 uint32 + x229, x230 = bits.Add32(x181, x212, uint32(uint1(x228))) + var x231 uint32 + var x232 uint32 + x231, x232 = bits.Add32(x183, x214, uint32(uint1(x230))) + var x233 uint32 + var x234 uint32 + x233, x234 = bits.Add32(x185, x216, uint32(uint1(x232))) + var x235 uint32 + var x236 uint32 + x235, x236 = bits.Add32(x187, x218, uint32(uint1(x234))) + var x237 uint32 + var x238 uint32 + x237, x238 = bits.Add32(x189, x220, uint32(uint1(x236))) + var x239 uint32 + var x240 uint32 + x239, x240 = bits.Add32(x191, x222, uint32(uint1(x238))) + var x241 uint32 + _, x241 = bits.Mul32(x223, 0x5588b13f) + var x243 uint32 + var x244 uint32 + x244, x243 = bits.Mul32(x241, 0xffffffff) + var x245 uint32 + var x246 uint32 + x246, x245 = bits.Mul32(x241, 0xffffffff) + var x247 uint32 + var x248 uint32 + x248, x247 = bits.Mul32(x241, 0xffffffff) + var x249 uint32 + var x250 uint32 + x250, x249 = bits.Mul32(x241, 0xfffffffe) + var x251 uint32 + var x252 uint32 + x252, x251 = bits.Mul32(x241, 0xbaaedce6) + var x253 uint32 + var x254 uint32 + x254, x253 = bits.Mul32(x241, 0xaf48a03b) + var x255 uint32 + var x256 uint32 + x256, x255 = bits.Mul32(x241, 0xbfd25e8c) + var x257 uint32 + var x258 uint32 + x258, x257 = bits.Mul32(x241, 0xd0364141) + var x259 uint32 + var x260 uint32 + x259, x260 = bits.Add32(x258, x255, uint32(0x0)) + var x261 uint32 + var x262 uint32 + x261, x262 = bits.Add32(x256, x253, uint32(uint1(x260))) + var x263 uint32 + var x264 uint32 + x263, x264 = bits.Add32(x254, x251, uint32(uint1(x262))) + var x265 uint32 + var x266 uint32 + x265, x266 = bits.Add32(x252, x249, uint32(uint1(x264))) + var x267 uint32 + var x268 uint32 + x267, x268 = bits.Add32(x250, x247, uint32(uint1(x266))) + var x269 uint32 + var x270 uint32 + x269, x270 = bits.Add32(x248, x245, uint32(uint1(x268))) + var x271 uint32 + var x272 uint32 + x271, x272 = bits.Add32(x246, x243, uint32(uint1(x270))) + x273 := (uint32(uint1(x272)) + x244) + var x275 uint32 + _, x275 = bits.Add32(x223, x257, uint32(0x0)) + var x276 uint32 + var x277 uint32 + x276, x277 = bits.Add32(x225, x259, uint32(uint1(x275))) + var x278 uint32 + var x279 uint32 + x278, x279 = bits.Add32(x227, x261, uint32(uint1(x277))) + var x280 uint32 + var x281 uint32 + x280, x281 = bits.Add32(x229, x263, uint32(uint1(x279))) + var x282 uint32 + var x283 uint32 + x282, x283 = bits.Add32(x231, x265, uint32(uint1(x281))) + var x284 uint32 + var x285 uint32 + x284, x285 = bits.Add32(x233, x267, uint32(uint1(x283))) + var x286 uint32 + var x287 uint32 + x286, x287 = bits.Add32(x235, x269, uint32(uint1(x285))) + var x288 uint32 + var x289 uint32 + x288, x289 = bits.Add32(x237, x271, uint32(uint1(x287))) + var x290 uint32 + var x291 uint32 + x290, x291 = bits.Add32(x239, x273, uint32(uint1(x289))) + x292 := (uint32(uint1(x291)) + uint32(uint1(x240))) + var x293 uint32 + var x294 uint32 + x294, x293 = bits.Mul32(x3, arg1[7]) + var x295 uint32 + var x296 uint32 + x296, x295 = bits.Mul32(x3, arg1[6]) + var x297 uint32 + var x298 uint32 + x298, x297 = bits.Mul32(x3, arg1[5]) + var x299 uint32 + var x300 uint32 + x300, x299 = bits.Mul32(x3, arg1[4]) + var x301 uint32 + var x302 uint32 + x302, x301 = bits.Mul32(x3, arg1[3]) + var x303 uint32 + var x304 uint32 + x304, x303 = bits.Mul32(x3, arg1[2]) + var x305 uint32 + var x306 uint32 + x306, x305 = bits.Mul32(x3, arg1[1]) + var x307 uint32 + var x308 uint32 + x308, x307 = bits.Mul32(x3, arg1[0]) + var x309 uint32 + var x310 uint32 + x309, x310 = bits.Add32(x308, x305, uint32(0x0)) + var x311 uint32 + var x312 uint32 + x311, x312 = bits.Add32(x306, x303, uint32(uint1(x310))) + var x313 uint32 + var x314 uint32 + x313, x314 = bits.Add32(x304, x301, uint32(uint1(x312))) + var x315 uint32 + var x316 uint32 + x315, x316 = bits.Add32(x302, x299, uint32(uint1(x314))) + var x317 uint32 + var x318 uint32 + x317, x318 = bits.Add32(x300, x297, uint32(uint1(x316))) + var x319 uint32 + var x320 uint32 + x319, x320 = bits.Add32(x298, x295, uint32(uint1(x318))) + var x321 uint32 + var x322 uint32 + x321, x322 = bits.Add32(x296, x293, uint32(uint1(x320))) + x323 := (uint32(uint1(x322)) + x294) + var x324 uint32 + var x325 uint32 + x324, x325 = bits.Add32(x276, x307, uint32(0x0)) + var x326 uint32 + var x327 uint32 + x326, x327 = bits.Add32(x278, x309, uint32(uint1(x325))) + var x328 uint32 + var x329 uint32 + x328, x329 = bits.Add32(x280, x311, uint32(uint1(x327))) + var x330 uint32 + var x331 uint32 + x330, x331 = bits.Add32(x282, x313, uint32(uint1(x329))) + var x332 uint32 + var x333 uint32 + x332, x333 = bits.Add32(x284, x315, uint32(uint1(x331))) + var x334 uint32 + var x335 uint32 + x334, x335 = bits.Add32(x286, x317, uint32(uint1(x333))) + var x336 uint32 + var x337 uint32 + x336, x337 = bits.Add32(x288, x319, uint32(uint1(x335))) + var x338 uint32 + var x339 uint32 + x338, x339 = bits.Add32(x290, x321, uint32(uint1(x337))) + var x340 uint32 + var x341 uint32 + x340, x341 = bits.Add32(x292, x323, uint32(uint1(x339))) + var x342 uint32 + _, x342 = bits.Mul32(x324, 0x5588b13f) + var x344 uint32 + var x345 uint32 + x345, x344 = bits.Mul32(x342, 0xffffffff) + var x346 uint32 + var x347 uint32 + x347, x346 = bits.Mul32(x342, 0xffffffff) + var x348 uint32 + var x349 uint32 + x349, x348 = bits.Mul32(x342, 0xffffffff) + var x350 uint32 + var x351 uint32 + x351, x350 = bits.Mul32(x342, 0xfffffffe) + var x352 uint32 + var x353 uint32 + x353, x352 = bits.Mul32(x342, 0xbaaedce6) + var x354 uint32 + var x355 uint32 + x355, x354 = bits.Mul32(x342, 0xaf48a03b) + var x356 uint32 + var x357 uint32 + x357, x356 = bits.Mul32(x342, 0xbfd25e8c) + var x358 uint32 + var x359 uint32 + x359, x358 = bits.Mul32(x342, 0xd0364141) + var x360 uint32 + var x361 uint32 + x360, x361 = bits.Add32(x359, x356, uint32(0x0)) + var x362 uint32 + var x363 uint32 + x362, x363 = bits.Add32(x357, x354, uint32(uint1(x361))) + var x364 uint32 + var x365 uint32 + x364, x365 = bits.Add32(x355, x352, uint32(uint1(x363))) + var x366 uint32 + var x367 uint32 + x366, x367 = bits.Add32(x353, x350, uint32(uint1(x365))) + var x368 uint32 + var x369 uint32 + x368, x369 = bits.Add32(x351, x348, uint32(uint1(x367))) + var x370 uint32 + var x371 uint32 + x370, x371 = bits.Add32(x349, x346, uint32(uint1(x369))) + var x372 uint32 + var x373 uint32 + x372, x373 = bits.Add32(x347, x344, uint32(uint1(x371))) + x374 := (uint32(uint1(x373)) + x345) + var x376 uint32 + _, x376 = bits.Add32(x324, x358, uint32(0x0)) + var x377 uint32 + var x378 uint32 + x377, x378 = bits.Add32(x326, x360, uint32(uint1(x376))) + var x379 uint32 + var x380 uint32 + x379, x380 = bits.Add32(x328, x362, uint32(uint1(x378))) + var x381 uint32 + var x382 uint32 + x381, x382 = bits.Add32(x330, x364, uint32(uint1(x380))) + var x383 uint32 + var x384 uint32 + x383, x384 = bits.Add32(x332, x366, uint32(uint1(x382))) + var x385 uint32 + var x386 uint32 + x385, x386 = bits.Add32(x334, x368, uint32(uint1(x384))) + var x387 uint32 + var x388 uint32 + x387, x388 = bits.Add32(x336, x370, uint32(uint1(x386))) + var x389 uint32 + var x390 uint32 + x389, x390 = bits.Add32(x338, x372, uint32(uint1(x388))) + var x391 uint32 + var x392 uint32 + x391, x392 = bits.Add32(x340, x374, uint32(uint1(x390))) + x393 := (uint32(uint1(x392)) + uint32(uint1(x341))) + var x394 uint32 + var x395 uint32 + x395, x394 = bits.Mul32(x4, arg1[7]) + var x396 uint32 + var x397 uint32 + x397, x396 = bits.Mul32(x4, arg1[6]) + var x398 uint32 + var x399 uint32 + x399, x398 = bits.Mul32(x4, arg1[5]) + var x400 uint32 + var x401 uint32 + x401, x400 = bits.Mul32(x4, arg1[4]) + var x402 uint32 + var x403 uint32 + x403, x402 = bits.Mul32(x4, arg1[3]) + var x404 uint32 + var x405 uint32 + x405, x404 = bits.Mul32(x4, arg1[2]) + var x406 uint32 + var x407 uint32 + x407, x406 = bits.Mul32(x4, arg1[1]) + var x408 uint32 + var x409 uint32 + x409, x408 = bits.Mul32(x4, arg1[0]) + var x410 uint32 + var x411 uint32 + x410, x411 = bits.Add32(x409, x406, uint32(0x0)) + var x412 uint32 + var x413 uint32 + x412, x413 = bits.Add32(x407, x404, uint32(uint1(x411))) + var x414 uint32 + var x415 uint32 + x414, x415 = bits.Add32(x405, x402, uint32(uint1(x413))) + var x416 uint32 + var x417 uint32 + x416, x417 = bits.Add32(x403, x400, uint32(uint1(x415))) + var x418 uint32 + var x419 uint32 + x418, x419 = bits.Add32(x401, x398, uint32(uint1(x417))) + var x420 uint32 + var x421 uint32 + x420, x421 = bits.Add32(x399, x396, uint32(uint1(x419))) + var x422 uint32 + var x423 uint32 + x422, x423 = bits.Add32(x397, x394, uint32(uint1(x421))) + x424 := (uint32(uint1(x423)) + x395) + var x425 uint32 + var x426 uint32 + x425, x426 = bits.Add32(x377, x408, uint32(0x0)) + var x427 uint32 + var x428 uint32 + x427, x428 = bits.Add32(x379, x410, uint32(uint1(x426))) + var x429 uint32 + var x430 uint32 + x429, x430 = bits.Add32(x381, x412, uint32(uint1(x428))) + var x431 uint32 + var x432 uint32 + x431, x432 = bits.Add32(x383, x414, uint32(uint1(x430))) + var x433 uint32 + var x434 uint32 + x433, x434 = bits.Add32(x385, x416, uint32(uint1(x432))) + var x435 uint32 + var x436 uint32 + x435, x436 = bits.Add32(x387, x418, uint32(uint1(x434))) + var x437 uint32 + var x438 uint32 + x437, x438 = bits.Add32(x389, x420, uint32(uint1(x436))) + var x439 uint32 + var x440 uint32 + x439, x440 = bits.Add32(x391, x422, uint32(uint1(x438))) + var x441 uint32 + var x442 uint32 + x441, x442 = bits.Add32(x393, x424, uint32(uint1(x440))) + var x443 uint32 + _, x443 = bits.Mul32(x425, 0x5588b13f) + var x445 uint32 + var x446 uint32 + x446, x445 = bits.Mul32(x443, 0xffffffff) + var x447 uint32 + var x448 uint32 + x448, x447 = bits.Mul32(x443, 0xffffffff) + var x449 uint32 + var x450 uint32 + x450, x449 = bits.Mul32(x443, 0xffffffff) + var x451 uint32 + var x452 uint32 + x452, x451 = bits.Mul32(x443, 0xfffffffe) + var x453 uint32 + var x454 uint32 + x454, x453 = bits.Mul32(x443, 0xbaaedce6) + var x455 uint32 + var x456 uint32 + x456, x455 = bits.Mul32(x443, 0xaf48a03b) + var x457 uint32 + var x458 uint32 + x458, x457 = bits.Mul32(x443, 0xbfd25e8c) + var x459 uint32 + var x460 uint32 + x460, x459 = bits.Mul32(x443, 0xd0364141) + var x461 uint32 + var x462 uint32 + x461, x462 = bits.Add32(x460, x457, uint32(0x0)) + var x463 uint32 + var x464 uint32 + x463, x464 = bits.Add32(x458, x455, uint32(uint1(x462))) + var x465 uint32 + var x466 uint32 + x465, x466 = bits.Add32(x456, x453, uint32(uint1(x464))) + var x467 uint32 + var x468 uint32 + x467, x468 = bits.Add32(x454, x451, uint32(uint1(x466))) + var x469 uint32 + var x470 uint32 + x469, x470 = bits.Add32(x452, x449, uint32(uint1(x468))) + var x471 uint32 + var x472 uint32 + x471, x472 = bits.Add32(x450, x447, uint32(uint1(x470))) + var x473 uint32 + var x474 uint32 + x473, x474 = bits.Add32(x448, x445, uint32(uint1(x472))) + x475 := (uint32(uint1(x474)) + x446) + var x477 uint32 + _, x477 = bits.Add32(x425, x459, uint32(0x0)) + var x478 uint32 + var x479 uint32 + x478, x479 = bits.Add32(x427, x461, uint32(uint1(x477))) + var x480 uint32 + var x481 uint32 + x480, x481 = bits.Add32(x429, x463, uint32(uint1(x479))) + var x482 uint32 + var x483 uint32 + x482, x483 = bits.Add32(x431, x465, uint32(uint1(x481))) + var x484 uint32 + var x485 uint32 + x484, x485 = bits.Add32(x433, x467, uint32(uint1(x483))) + var x486 uint32 + var x487 uint32 + x486, x487 = bits.Add32(x435, x469, uint32(uint1(x485))) + var x488 uint32 + var x489 uint32 + x488, x489 = bits.Add32(x437, x471, uint32(uint1(x487))) + var x490 uint32 + var x491 uint32 + x490, x491 = bits.Add32(x439, x473, uint32(uint1(x489))) + var x492 uint32 + var x493 uint32 + x492, x493 = bits.Add32(x441, x475, uint32(uint1(x491))) + x494 := (uint32(uint1(x493)) + uint32(uint1(x442))) + var x495 uint32 + var x496 uint32 + x496, x495 = bits.Mul32(x5, arg1[7]) + var x497 uint32 + var x498 uint32 + x498, x497 = bits.Mul32(x5, arg1[6]) + var x499 uint32 + var x500 uint32 + x500, x499 = bits.Mul32(x5, arg1[5]) + var x501 uint32 + var x502 uint32 + x502, x501 = bits.Mul32(x5, arg1[4]) + var x503 uint32 + var x504 uint32 + x504, x503 = bits.Mul32(x5, arg1[3]) + var x505 uint32 + var x506 uint32 + x506, x505 = bits.Mul32(x5, arg1[2]) + var x507 uint32 + var x508 uint32 + x508, x507 = bits.Mul32(x5, arg1[1]) + var x509 uint32 + var x510 uint32 + x510, x509 = bits.Mul32(x5, arg1[0]) + var x511 uint32 + var x512 uint32 + x511, x512 = bits.Add32(x510, x507, uint32(0x0)) + var x513 uint32 + var x514 uint32 + x513, x514 = bits.Add32(x508, x505, uint32(uint1(x512))) + var x515 uint32 + var x516 uint32 + x515, x516 = bits.Add32(x506, x503, uint32(uint1(x514))) + var x517 uint32 + var x518 uint32 + x517, x518 = bits.Add32(x504, x501, uint32(uint1(x516))) + var x519 uint32 + var x520 uint32 + x519, x520 = bits.Add32(x502, x499, uint32(uint1(x518))) + var x521 uint32 + var x522 uint32 + x521, x522 = bits.Add32(x500, x497, uint32(uint1(x520))) + var x523 uint32 + var x524 uint32 + x523, x524 = bits.Add32(x498, x495, uint32(uint1(x522))) + x525 := (uint32(uint1(x524)) + x496) + var x526 uint32 + var x527 uint32 + x526, x527 = bits.Add32(x478, x509, uint32(0x0)) + var x528 uint32 + var x529 uint32 + x528, x529 = bits.Add32(x480, x511, uint32(uint1(x527))) + var x530 uint32 + var x531 uint32 + x530, x531 = bits.Add32(x482, x513, uint32(uint1(x529))) + var x532 uint32 + var x533 uint32 + x532, x533 = bits.Add32(x484, x515, uint32(uint1(x531))) + var x534 uint32 + var x535 uint32 + x534, x535 = bits.Add32(x486, x517, uint32(uint1(x533))) + var x536 uint32 + var x537 uint32 + x536, x537 = bits.Add32(x488, x519, uint32(uint1(x535))) + var x538 uint32 + var x539 uint32 + x538, x539 = bits.Add32(x490, x521, uint32(uint1(x537))) + var x540 uint32 + var x541 uint32 + x540, x541 = bits.Add32(x492, x523, uint32(uint1(x539))) + var x542 uint32 + var x543 uint32 + x542, x543 = bits.Add32(x494, x525, uint32(uint1(x541))) + var x544 uint32 + _, x544 = bits.Mul32(x526, 0x5588b13f) + var x546 uint32 + var x547 uint32 + x547, x546 = bits.Mul32(x544, 0xffffffff) + var x548 uint32 + var x549 uint32 + x549, x548 = bits.Mul32(x544, 0xffffffff) + var x550 uint32 + var x551 uint32 + x551, x550 = bits.Mul32(x544, 0xffffffff) + var x552 uint32 + var x553 uint32 + x553, x552 = bits.Mul32(x544, 0xfffffffe) + var x554 uint32 + var x555 uint32 + x555, x554 = bits.Mul32(x544, 0xbaaedce6) + var x556 uint32 + var x557 uint32 + x557, x556 = bits.Mul32(x544, 0xaf48a03b) + var x558 uint32 + var x559 uint32 + x559, x558 = bits.Mul32(x544, 0xbfd25e8c) + var x560 uint32 + var x561 uint32 + x561, x560 = bits.Mul32(x544, 0xd0364141) + var x562 uint32 + var x563 uint32 + x562, x563 = bits.Add32(x561, x558, uint32(0x0)) + var x564 uint32 + var x565 uint32 + x564, x565 = bits.Add32(x559, x556, uint32(uint1(x563))) + var x566 uint32 + var x567 uint32 + x566, x567 = bits.Add32(x557, x554, uint32(uint1(x565))) + var x568 uint32 + var x569 uint32 + x568, x569 = bits.Add32(x555, x552, uint32(uint1(x567))) + var x570 uint32 + var x571 uint32 + x570, x571 = bits.Add32(x553, x550, uint32(uint1(x569))) + var x572 uint32 + var x573 uint32 + x572, x573 = bits.Add32(x551, x548, uint32(uint1(x571))) + var x574 uint32 + var x575 uint32 + x574, x575 = bits.Add32(x549, x546, uint32(uint1(x573))) + x576 := (uint32(uint1(x575)) + x547) + var x578 uint32 + _, x578 = bits.Add32(x526, x560, uint32(0x0)) + var x579 uint32 + var x580 uint32 + x579, x580 = bits.Add32(x528, x562, uint32(uint1(x578))) + var x581 uint32 + var x582 uint32 + x581, x582 = bits.Add32(x530, x564, uint32(uint1(x580))) + var x583 uint32 + var x584 uint32 + x583, x584 = bits.Add32(x532, x566, uint32(uint1(x582))) + var x585 uint32 + var x586 uint32 + x585, x586 = bits.Add32(x534, x568, uint32(uint1(x584))) + var x587 uint32 + var x588 uint32 + x587, x588 = bits.Add32(x536, x570, uint32(uint1(x586))) + var x589 uint32 + var x590 uint32 + x589, x590 = bits.Add32(x538, x572, uint32(uint1(x588))) + var x591 uint32 + var x592 uint32 + x591, x592 = bits.Add32(x540, x574, uint32(uint1(x590))) + var x593 uint32 + var x594 uint32 + x593, x594 = bits.Add32(x542, x576, uint32(uint1(x592))) + x595 := (uint32(uint1(x594)) + uint32(uint1(x543))) + var x596 uint32 + var x597 uint32 + x597, x596 = bits.Mul32(x6, arg1[7]) + var x598 uint32 + var x599 uint32 + x599, x598 = bits.Mul32(x6, arg1[6]) + var x600 uint32 + var x601 uint32 + x601, x600 = bits.Mul32(x6, arg1[5]) + var x602 uint32 + var x603 uint32 + x603, x602 = bits.Mul32(x6, arg1[4]) + var x604 uint32 + var x605 uint32 + x605, x604 = bits.Mul32(x6, arg1[3]) + var x606 uint32 + var x607 uint32 + x607, x606 = bits.Mul32(x6, arg1[2]) + var x608 uint32 + var x609 uint32 + x609, x608 = bits.Mul32(x6, arg1[1]) + var x610 uint32 + var x611 uint32 + x611, x610 = bits.Mul32(x6, arg1[0]) + var x612 uint32 + var x613 uint32 + x612, x613 = bits.Add32(x611, x608, uint32(0x0)) + var x614 uint32 + var x615 uint32 + x614, x615 = bits.Add32(x609, x606, uint32(uint1(x613))) + var x616 uint32 + var x617 uint32 + x616, x617 = bits.Add32(x607, x604, uint32(uint1(x615))) + var x618 uint32 + var x619 uint32 + x618, x619 = bits.Add32(x605, x602, uint32(uint1(x617))) + var x620 uint32 + var x621 uint32 + x620, x621 = bits.Add32(x603, x600, uint32(uint1(x619))) + var x622 uint32 + var x623 uint32 + x622, x623 = bits.Add32(x601, x598, uint32(uint1(x621))) + var x624 uint32 + var x625 uint32 + x624, x625 = bits.Add32(x599, x596, uint32(uint1(x623))) + x626 := (uint32(uint1(x625)) + x597) + var x627 uint32 + var x628 uint32 + x627, x628 = bits.Add32(x579, x610, uint32(0x0)) + var x629 uint32 + var x630 uint32 + x629, x630 = bits.Add32(x581, x612, uint32(uint1(x628))) + var x631 uint32 + var x632 uint32 + x631, x632 = bits.Add32(x583, x614, uint32(uint1(x630))) + var x633 uint32 + var x634 uint32 + x633, x634 = bits.Add32(x585, x616, uint32(uint1(x632))) + var x635 uint32 + var x636 uint32 + x635, x636 = bits.Add32(x587, x618, uint32(uint1(x634))) + var x637 uint32 + var x638 uint32 + x637, x638 = bits.Add32(x589, x620, uint32(uint1(x636))) + var x639 uint32 + var x640 uint32 + x639, x640 = bits.Add32(x591, x622, uint32(uint1(x638))) + var x641 uint32 + var x642 uint32 + x641, x642 = bits.Add32(x593, x624, uint32(uint1(x640))) + var x643 uint32 + var x644 uint32 + x643, x644 = bits.Add32(x595, x626, uint32(uint1(x642))) + var x645 uint32 + _, x645 = bits.Mul32(x627, 0x5588b13f) + var x647 uint32 + var x648 uint32 + x648, x647 = bits.Mul32(x645, 0xffffffff) + var x649 uint32 + var x650 uint32 + x650, x649 = bits.Mul32(x645, 0xffffffff) + var x651 uint32 + var x652 uint32 + x652, x651 = bits.Mul32(x645, 0xffffffff) + var x653 uint32 + var x654 uint32 + x654, x653 = bits.Mul32(x645, 0xfffffffe) + var x655 uint32 + var x656 uint32 + x656, x655 = bits.Mul32(x645, 0xbaaedce6) + var x657 uint32 + var x658 uint32 + x658, x657 = bits.Mul32(x645, 0xaf48a03b) + var x659 uint32 + var x660 uint32 + x660, x659 = bits.Mul32(x645, 0xbfd25e8c) + var x661 uint32 + var x662 uint32 + x662, x661 = bits.Mul32(x645, 0xd0364141) + var x663 uint32 + var x664 uint32 + x663, x664 = bits.Add32(x662, x659, uint32(0x0)) + var x665 uint32 + var x666 uint32 + x665, x666 = bits.Add32(x660, x657, uint32(uint1(x664))) + var x667 uint32 + var x668 uint32 + x667, x668 = bits.Add32(x658, x655, uint32(uint1(x666))) + var x669 uint32 + var x670 uint32 + x669, x670 = bits.Add32(x656, x653, uint32(uint1(x668))) + var x671 uint32 + var x672 uint32 + x671, x672 = bits.Add32(x654, x651, uint32(uint1(x670))) + var x673 uint32 + var x674 uint32 + x673, x674 = bits.Add32(x652, x649, uint32(uint1(x672))) + var x675 uint32 + var x676 uint32 + x675, x676 = bits.Add32(x650, x647, uint32(uint1(x674))) + x677 := (uint32(uint1(x676)) + x648) + var x679 uint32 + _, x679 = bits.Add32(x627, x661, uint32(0x0)) + var x680 uint32 + var x681 uint32 + x680, x681 = bits.Add32(x629, x663, uint32(uint1(x679))) + var x682 uint32 + var x683 uint32 + x682, x683 = bits.Add32(x631, x665, uint32(uint1(x681))) + var x684 uint32 + var x685 uint32 + x684, x685 = bits.Add32(x633, x667, uint32(uint1(x683))) + var x686 uint32 + var x687 uint32 + x686, x687 = bits.Add32(x635, x669, uint32(uint1(x685))) + var x688 uint32 + var x689 uint32 + x688, x689 = bits.Add32(x637, x671, uint32(uint1(x687))) + var x690 uint32 + var x691 uint32 + x690, x691 = bits.Add32(x639, x673, uint32(uint1(x689))) + var x692 uint32 + var x693 uint32 + x692, x693 = bits.Add32(x641, x675, uint32(uint1(x691))) + var x694 uint32 + var x695 uint32 + x694, x695 = bits.Add32(x643, x677, uint32(uint1(x693))) + x696 := (uint32(uint1(x695)) + uint32(uint1(x644))) + var x697 uint32 + var x698 uint32 + x698, x697 = bits.Mul32(x7, arg1[7]) + var x699 uint32 + var x700 uint32 + x700, x699 = bits.Mul32(x7, arg1[6]) + var x701 uint32 + var x702 uint32 + x702, x701 = bits.Mul32(x7, arg1[5]) + var x703 uint32 + var x704 uint32 + x704, x703 = bits.Mul32(x7, arg1[4]) + var x705 uint32 + var x706 uint32 + x706, x705 = bits.Mul32(x7, arg1[3]) + var x707 uint32 + var x708 uint32 + x708, x707 = bits.Mul32(x7, arg1[2]) + var x709 uint32 + var x710 uint32 + x710, x709 = bits.Mul32(x7, arg1[1]) + var x711 uint32 + var x712 uint32 + x712, x711 = bits.Mul32(x7, arg1[0]) + var x713 uint32 + var x714 uint32 + x713, x714 = bits.Add32(x712, x709, uint32(0x0)) + var x715 uint32 + var x716 uint32 + x715, x716 = bits.Add32(x710, x707, uint32(uint1(x714))) + var x717 uint32 + var x718 uint32 + x717, x718 = bits.Add32(x708, x705, uint32(uint1(x716))) + var x719 uint32 + var x720 uint32 + x719, x720 = bits.Add32(x706, x703, uint32(uint1(x718))) + var x721 uint32 + var x722 uint32 + x721, x722 = bits.Add32(x704, x701, uint32(uint1(x720))) + var x723 uint32 + var x724 uint32 + x723, x724 = bits.Add32(x702, x699, uint32(uint1(x722))) + var x725 uint32 + var x726 uint32 + x725, x726 = bits.Add32(x700, x697, uint32(uint1(x724))) + x727 := (uint32(uint1(x726)) + x698) + var x728 uint32 + var x729 uint32 + x728, x729 = bits.Add32(x680, x711, uint32(0x0)) + var x730 uint32 + var x731 uint32 + x730, x731 = bits.Add32(x682, x713, uint32(uint1(x729))) + var x732 uint32 + var x733 uint32 + x732, x733 = bits.Add32(x684, x715, uint32(uint1(x731))) + var x734 uint32 + var x735 uint32 + x734, x735 = bits.Add32(x686, x717, uint32(uint1(x733))) + var x736 uint32 + var x737 uint32 + x736, x737 = bits.Add32(x688, x719, uint32(uint1(x735))) + var x738 uint32 + var x739 uint32 + x738, x739 = bits.Add32(x690, x721, uint32(uint1(x737))) + var x740 uint32 + var x741 uint32 + x740, x741 = bits.Add32(x692, x723, uint32(uint1(x739))) + var x742 uint32 + var x743 uint32 + x742, x743 = bits.Add32(x694, x725, uint32(uint1(x741))) + var x744 uint32 + var x745 uint32 + x744, x745 = bits.Add32(x696, x727, uint32(uint1(x743))) + var x746 uint32 + _, x746 = bits.Mul32(x728, 0x5588b13f) + var x748 uint32 + var x749 uint32 + x749, x748 = bits.Mul32(x746, 0xffffffff) + var x750 uint32 + var x751 uint32 + x751, x750 = bits.Mul32(x746, 0xffffffff) + var x752 uint32 + var x753 uint32 + x753, x752 = bits.Mul32(x746, 0xffffffff) + var x754 uint32 + var x755 uint32 + x755, x754 = bits.Mul32(x746, 0xfffffffe) + var x756 uint32 + var x757 uint32 + x757, x756 = bits.Mul32(x746, 0xbaaedce6) + var x758 uint32 + var x759 uint32 + x759, x758 = bits.Mul32(x746, 0xaf48a03b) + var x760 uint32 + var x761 uint32 + x761, x760 = bits.Mul32(x746, 0xbfd25e8c) + var x762 uint32 + var x763 uint32 + x763, x762 = bits.Mul32(x746, 0xd0364141) + var x764 uint32 + var x765 uint32 + x764, x765 = bits.Add32(x763, x760, uint32(0x0)) + var x766 uint32 + var x767 uint32 + x766, x767 = bits.Add32(x761, x758, uint32(uint1(x765))) + var x768 uint32 + var x769 uint32 + x768, x769 = bits.Add32(x759, x756, uint32(uint1(x767))) + var x770 uint32 + var x771 uint32 + x770, x771 = bits.Add32(x757, x754, uint32(uint1(x769))) + var x772 uint32 + var x773 uint32 + x772, x773 = bits.Add32(x755, x752, uint32(uint1(x771))) + var x774 uint32 + var x775 uint32 + x774, x775 = bits.Add32(x753, x750, uint32(uint1(x773))) + var x776 uint32 + var x777 uint32 + x776, x777 = bits.Add32(x751, x748, uint32(uint1(x775))) + x778 := (uint32(uint1(x777)) + x749) + var x780 uint32 + _, x780 = bits.Add32(x728, x762, uint32(0x0)) + var x781 uint32 + var x782 uint32 + x781, x782 = bits.Add32(x730, x764, uint32(uint1(x780))) + var x783 uint32 + var x784 uint32 + x783, x784 = bits.Add32(x732, x766, uint32(uint1(x782))) + var x785 uint32 + var x786 uint32 + x785, x786 = bits.Add32(x734, x768, uint32(uint1(x784))) + var x787 uint32 + var x788 uint32 + x787, x788 = bits.Add32(x736, x770, uint32(uint1(x786))) + var x789 uint32 + var x790 uint32 + x789, x790 = bits.Add32(x738, x772, uint32(uint1(x788))) + var x791 uint32 + var x792 uint32 + x791, x792 = bits.Add32(x740, x774, uint32(uint1(x790))) + var x793 uint32 + var x794 uint32 + x793, x794 = bits.Add32(x742, x776, uint32(uint1(x792))) + var x795 uint32 + var x796 uint32 + x795, x796 = bits.Add32(x744, x778, uint32(uint1(x794))) + x797 := (uint32(uint1(x796)) + uint32(uint1(x745))) + var x798 uint32 + var x799 uint32 + x798, x799 = bits.Sub32(x781, 0xd0364141, uint32(0x0)) + var x800 uint32 + var x801 uint32 + x800, x801 = bits.Sub32(x783, 0xbfd25e8c, uint32(uint1(x799))) + var x802 uint32 + var x803 uint32 + x802, x803 = bits.Sub32(x785, 0xaf48a03b, uint32(uint1(x801))) + var x804 uint32 + var x805 uint32 + x804, x805 = bits.Sub32(x787, 0xbaaedce6, uint32(uint1(x803))) + var x806 uint32 + var x807 uint32 + x806, x807 = bits.Sub32(x789, 0xfffffffe, uint32(uint1(x805))) + var x808 uint32 + var x809 uint32 + x808, x809 = bits.Sub32(x791, 0xffffffff, uint32(uint1(x807))) + var x810 uint32 + var x811 uint32 + x810, x811 = bits.Sub32(x793, 0xffffffff, uint32(uint1(x809))) + var x812 uint32 + var x813 uint32 + x812, x813 = bits.Sub32(x795, 0xffffffff, uint32(uint1(x811))) + var x815 uint32 + _, x815 = bits.Sub32(x797, uint32(0x0), uint32(uint1(x813))) + var x816 uint32 + cmovznzU32(&x816, uint1(x815), x798, x781) + var x817 uint32 + cmovznzU32(&x817, uint1(x815), x800, x783) + var x818 uint32 + cmovznzU32(&x818, uint1(x815), x802, x785) + var x819 uint32 + cmovznzU32(&x819, uint1(x815), x804, x787) + var x820 uint32 + cmovznzU32(&x820, uint1(x815), x806, x789) + var x821 uint32 + cmovznzU32(&x821, uint1(x815), x808, x791) + var x822 uint32 + cmovznzU32(&x822, uint1(x815), x810, x793) + var x823 uint32 + cmovznzU32(&x823, uint1(x815), x812, x795) + out1[0] = x816 + out1[1] = x817 + out1[2] = x818 + out1[3] = x819 + out1[4] = x820 + out1[5] = x821 + out1[6] = x822 + out1[7] = x823 +} + +// Add adds two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Add(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint32 + var x2 uint32 + x1, x2 = bits.Add32(arg1[0], arg2[0], uint32(0x0)) + var x3 uint32 + var x4 uint32 + x3, x4 = bits.Add32(arg1[1], arg2[1], uint32(uint1(x2))) + var x5 uint32 + var x6 uint32 + x5, x6 = bits.Add32(arg1[2], arg2[2], uint32(uint1(x4))) + var x7 uint32 + var x8 uint32 + x7, x8 = bits.Add32(arg1[3], arg2[3], uint32(uint1(x6))) + var x9 uint32 + var x10 uint32 + x9, x10 = bits.Add32(arg1[4], arg2[4], uint32(uint1(x8))) + var x11 uint32 + var x12 uint32 + x11, x12 = bits.Add32(arg1[5], arg2[5], uint32(uint1(x10))) + var x13 uint32 + var x14 uint32 + x13, x14 = bits.Add32(arg1[6], arg2[6], uint32(uint1(x12))) + var x15 uint32 + var x16 uint32 + x15, x16 = bits.Add32(arg1[7], arg2[7], uint32(uint1(x14))) + var x17 uint32 + var x18 uint32 + x17, x18 = bits.Sub32(x1, 0xd0364141, uint32(0x0)) + var x19 uint32 + var x20 uint32 + x19, x20 = bits.Sub32(x3, 0xbfd25e8c, uint32(uint1(x18))) + var x21 uint32 + var x22 uint32 + x21, x22 = bits.Sub32(x5, 0xaf48a03b, uint32(uint1(x20))) + var x23 uint32 + var x24 uint32 + x23, x24 = bits.Sub32(x7, 0xbaaedce6, uint32(uint1(x22))) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Sub32(x9, 0xfffffffe, uint32(uint1(x24))) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Sub32(x11, 0xffffffff, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Sub32(x13, 0xffffffff, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Sub32(x15, 0xffffffff, uint32(uint1(x30))) + var x34 uint32 + _, x34 = bits.Sub32(uint32(uint1(x16)), uint32(0x0), uint32(uint1(x32))) + var x35 uint32 + cmovznzU32(&x35, uint1(x34), x17, x1) + var x36 uint32 + cmovznzU32(&x36, uint1(x34), x19, x3) + var x37 uint32 + cmovznzU32(&x37, uint1(x34), x21, x5) + var x38 uint32 + cmovznzU32(&x38, uint1(x34), x23, x7) + var x39 uint32 + cmovznzU32(&x39, uint1(x34), x25, x9) + var x40 uint32 + cmovznzU32(&x40, uint1(x34), x27, x11) + var x41 uint32 + cmovznzU32(&x41, uint1(x34), x29, x13) + var x42 uint32 + cmovznzU32(&x42, uint1(x34), x31, x15) + out1[0] = x35 + out1[1] = x36 + out1[2] = x37 + out1[3] = x38 + out1[4] = x39 + out1[5] = x40 + out1[6] = x41 + out1[7] = x42 +} + +// Sub subtracts two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Sub(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint32 + var x2 uint32 + x1, x2 = bits.Sub32(arg1[0], arg2[0], uint32(0x0)) + var x3 uint32 + var x4 uint32 + x3, x4 = bits.Sub32(arg1[1], arg2[1], uint32(uint1(x2))) + var x5 uint32 + var x6 uint32 + x5, x6 = bits.Sub32(arg1[2], arg2[2], uint32(uint1(x4))) + var x7 uint32 + var x8 uint32 + x7, x8 = bits.Sub32(arg1[3], arg2[3], uint32(uint1(x6))) + var x9 uint32 + var x10 uint32 + x9, x10 = bits.Sub32(arg1[4], arg2[4], uint32(uint1(x8))) + var x11 uint32 + var x12 uint32 + x11, x12 = bits.Sub32(arg1[5], arg2[5], uint32(uint1(x10))) + var x13 uint32 + var x14 uint32 + x13, x14 = bits.Sub32(arg1[6], arg2[6], uint32(uint1(x12))) + var x15 uint32 + var x16 uint32 + x15, x16 = bits.Sub32(arg1[7], arg2[7], uint32(uint1(x14))) + var x17 uint32 + cmovznzU32(&x17, uint1(x16), uint32(0x0), 0xffffffff) + var x18 uint32 + var x19 uint32 + x18, x19 = bits.Add32(x1, (x17 & 0xd0364141), uint32(0x0)) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x3, (x17 & 0xbfd25e8c), uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x5, (x17 & 0xaf48a03b), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x7, (x17 & 0xbaaedce6), uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(x9, (x17 & 0xfffffffe), uint32(uint1(x25))) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(x11, x17, uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(x13, x17, uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(x15, x17, uint32(uint1(x31))) + out1[0] = x18 + out1[1] = x20 + out1[2] = x22 + out1[3] = x24 + out1[4] = x26 + out1[5] = x28 + out1[6] = x30 + out1[7] = x32 +} + +// Opp negates a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +// 0 ≤ eval out1 < m +// +func Opp(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + var x1 uint32 + var x2 uint32 + x1, x2 = bits.Sub32(uint32(0x0), arg1[0], uint32(0x0)) + var x3 uint32 + var x4 uint32 + x3, x4 = bits.Sub32(uint32(0x0), arg1[1], uint32(uint1(x2))) + var x5 uint32 + var x6 uint32 + x5, x6 = bits.Sub32(uint32(0x0), arg1[2], uint32(uint1(x4))) + var x7 uint32 + var x8 uint32 + x7, x8 = bits.Sub32(uint32(0x0), arg1[3], uint32(uint1(x6))) + var x9 uint32 + var x10 uint32 + x9, x10 = bits.Sub32(uint32(0x0), arg1[4], uint32(uint1(x8))) + var x11 uint32 + var x12 uint32 + x11, x12 = bits.Sub32(uint32(0x0), arg1[5], uint32(uint1(x10))) + var x13 uint32 + var x14 uint32 + x13, x14 = bits.Sub32(uint32(0x0), arg1[6], uint32(uint1(x12))) + var x15 uint32 + var x16 uint32 + x15, x16 = bits.Sub32(uint32(0x0), arg1[7], uint32(uint1(x14))) + var x17 uint32 + cmovznzU32(&x17, uint1(x16), uint32(0x0), 0xffffffff) + var x18 uint32 + var x19 uint32 + x18, x19 = bits.Add32(x1, (x17 & 0xd0364141), uint32(0x0)) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x3, (x17 & 0xbfd25e8c), uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x5, (x17 & 0xaf48a03b), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x7, (x17 & 0xbaaedce6), uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(x9, (x17 & 0xfffffffe), uint32(uint1(x25))) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(x11, x17, uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(x13, x17, uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(x15, x17, uint32(uint1(x31))) + out1[0] = x18 + out1[1] = x20 + out1[2] = x22 + out1[3] = x24 + out1[4] = x26 + out1[5] = x28 + out1[6] = x30 + out1[7] = x32 +} + +// FromMontgomery translates a field element out of the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m +// 0 ≤ eval out1 < m +// +func FromMontgomery(out1 *NonMontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[0] + var x2 uint32 + _, x2 = bits.Mul32(x1, 0x5588b13f) + var x4 uint32 + var x5 uint32 + x5, x4 = bits.Mul32(x2, 0xffffffff) + var x6 uint32 + var x7 uint32 + x7, x6 = bits.Mul32(x2, 0xffffffff) + var x8 uint32 + var x9 uint32 + x9, x8 = bits.Mul32(x2, 0xffffffff) + var x10 uint32 + var x11 uint32 + x11, x10 = bits.Mul32(x2, 0xfffffffe) + var x12 uint32 + var x13 uint32 + x13, x12 = bits.Mul32(x2, 0xbaaedce6) + var x14 uint32 + var x15 uint32 + x15, x14 = bits.Mul32(x2, 0xaf48a03b) + var x16 uint32 + var x17 uint32 + x17, x16 = bits.Mul32(x2, 0xbfd25e8c) + var x18 uint32 + var x19 uint32 + x19, x18 = bits.Mul32(x2, 0xd0364141) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x19, x16, uint32(0x0)) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x17, x14, uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x15, x12, uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(x13, x10, uint32(uint1(x25))) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(x11, x8, uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(x9, x6, uint32(uint1(x29))) + var x32 uint32 + var x33 uint32 + x32, x33 = bits.Add32(x7, x4, uint32(uint1(x31))) + var x35 uint32 + _, x35 = bits.Add32(x1, x18, uint32(0x0)) + var x36 uint32 + var x37 uint32 + x36, x37 = bits.Add32(uint32(0x0), x20, uint32(uint1(x35))) + var x38 uint32 + var x39 uint32 + x38, x39 = bits.Add32(uint32(0x0), x22, uint32(uint1(x37))) + var x40 uint32 + var x41 uint32 + x40, x41 = bits.Add32(uint32(0x0), x24, uint32(uint1(x39))) + var x42 uint32 + var x43 uint32 + x42, x43 = bits.Add32(uint32(0x0), x26, uint32(uint1(x41))) + var x44 uint32 + var x45 uint32 + x44, x45 = bits.Add32(uint32(0x0), x28, uint32(uint1(x43))) + var x46 uint32 + var x47 uint32 + x46, x47 = bits.Add32(uint32(0x0), x30, uint32(uint1(x45))) + var x48 uint32 + var x49 uint32 + x48, x49 = bits.Add32(uint32(0x0), x32, uint32(uint1(x47))) + var x50 uint32 + var x51 uint32 + x50, x51 = bits.Add32(uint32(0x0), (uint32(uint1(x33)) + x5), uint32(uint1(x49))) + var x52 uint32 + var x53 uint32 + x52, x53 = bits.Add32(x36, arg1[1], uint32(0x0)) + var x54 uint32 + var x55 uint32 + x54, x55 = bits.Add32(x38, uint32(0x0), uint32(uint1(x53))) + var x56 uint32 + var x57 uint32 + x56, x57 = bits.Add32(x40, uint32(0x0), uint32(uint1(x55))) + var x58 uint32 + var x59 uint32 + x58, x59 = bits.Add32(x42, uint32(0x0), uint32(uint1(x57))) + var x60 uint32 + var x61 uint32 + x60, x61 = bits.Add32(x44, uint32(0x0), uint32(uint1(x59))) + var x62 uint32 + var x63 uint32 + x62, x63 = bits.Add32(x46, uint32(0x0), uint32(uint1(x61))) + var x64 uint32 + var x65 uint32 + x64, x65 = bits.Add32(x48, uint32(0x0), uint32(uint1(x63))) + var x66 uint32 + var x67 uint32 + x66, x67 = bits.Add32(x50, uint32(0x0), uint32(uint1(x65))) + var x68 uint32 + _, x68 = bits.Mul32(x52, 0x5588b13f) + var x70 uint32 + var x71 uint32 + x71, x70 = bits.Mul32(x68, 0xffffffff) + var x72 uint32 + var x73 uint32 + x73, x72 = bits.Mul32(x68, 0xffffffff) + var x74 uint32 + var x75 uint32 + x75, x74 = bits.Mul32(x68, 0xffffffff) + var x76 uint32 + var x77 uint32 + x77, x76 = bits.Mul32(x68, 0xfffffffe) + var x78 uint32 + var x79 uint32 + x79, x78 = bits.Mul32(x68, 0xbaaedce6) + var x80 uint32 + var x81 uint32 + x81, x80 = bits.Mul32(x68, 0xaf48a03b) + var x82 uint32 + var x83 uint32 + x83, x82 = bits.Mul32(x68, 0xbfd25e8c) + var x84 uint32 + var x85 uint32 + x85, x84 = bits.Mul32(x68, 0xd0364141) + var x86 uint32 + var x87 uint32 + x86, x87 = bits.Add32(x85, x82, uint32(0x0)) + var x88 uint32 + var x89 uint32 + x88, x89 = bits.Add32(x83, x80, uint32(uint1(x87))) + var x90 uint32 + var x91 uint32 + x90, x91 = bits.Add32(x81, x78, uint32(uint1(x89))) + var x92 uint32 + var x93 uint32 + x92, x93 = bits.Add32(x79, x76, uint32(uint1(x91))) + var x94 uint32 + var x95 uint32 + x94, x95 = bits.Add32(x77, x74, uint32(uint1(x93))) + var x96 uint32 + var x97 uint32 + x96, x97 = bits.Add32(x75, x72, uint32(uint1(x95))) + var x98 uint32 + var x99 uint32 + x98, x99 = bits.Add32(x73, x70, uint32(uint1(x97))) + var x101 uint32 + _, x101 = bits.Add32(x52, x84, uint32(0x0)) + var x102 uint32 + var x103 uint32 + x102, x103 = bits.Add32(x54, x86, uint32(uint1(x101))) + var x104 uint32 + var x105 uint32 + x104, x105 = bits.Add32(x56, x88, uint32(uint1(x103))) + var x106 uint32 + var x107 uint32 + x106, x107 = bits.Add32(x58, x90, uint32(uint1(x105))) + var x108 uint32 + var x109 uint32 + x108, x109 = bits.Add32(x60, x92, uint32(uint1(x107))) + var x110 uint32 + var x111 uint32 + x110, x111 = bits.Add32(x62, x94, uint32(uint1(x109))) + var x112 uint32 + var x113 uint32 + x112, x113 = bits.Add32(x64, x96, uint32(uint1(x111))) + var x114 uint32 + var x115 uint32 + x114, x115 = bits.Add32(x66, x98, uint32(uint1(x113))) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32((uint32(uint1(x67)) + uint32(uint1(x51))), (uint32(uint1(x99)) + x71), uint32(uint1(x115))) + var x118 uint32 + var x119 uint32 + x118, x119 = bits.Add32(x102, arg1[2], uint32(0x0)) + var x120 uint32 + var x121 uint32 + x120, x121 = bits.Add32(x104, uint32(0x0), uint32(uint1(x119))) + var x122 uint32 + var x123 uint32 + x122, x123 = bits.Add32(x106, uint32(0x0), uint32(uint1(x121))) + var x124 uint32 + var x125 uint32 + x124, x125 = bits.Add32(x108, uint32(0x0), uint32(uint1(x123))) + var x126 uint32 + var x127 uint32 + x126, x127 = bits.Add32(x110, uint32(0x0), uint32(uint1(x125))) + var x128 uint32 + var x129 uint32 + x128, x129 = bits.Add32(x112, uint32(0x0), uint32(uint1(x127))) + var x130 uint32 + var x131 uint32 + x130, x131 = bits.Add32(x114, uint32(0x0), uint32(uint1(x129))) + var x132 uint32 + var x133 uint32 + x132, x133 = bits.Add32(x116, uint32(0x0), uint32(uint1(x131))) + var x134 uint32 + _, x134 = bits.Mul32(x118, 0x5588b13f) + var x136 uint32 + var x137 uint32 + x137, x136 = bits.Mul32(x134, 0xffffffff) + var x138 uint32 + var x139 uint32 + x139, x138 = bits.Mul32(x134, 0xffffffff) + var x140 uint32 + var x141 uint32 + x141, x140 = bits.Mul32(x134, 0xffffffff) + var x142 uint32 + var x143 uint32 + x143, x142 = bits.Mul32(x134, 0xfffffffe) + var x144 uint32 + var x145 uint32 + x145, x144 = bits.Mul32(x134, 0xbaaedce6) + var x146 uint32 + var x147 uint32 + x147, x146 = bits.Mul32(x134, 0xaf48a03b) + var x148 uint32 + var x149 uint32 + x149, x148 = bits.Mul32(x134, 0xbfd25e8c) + var x150 uint32 + var x151 uint32 + x151, x150 = bits.Mul32(x134, 0xd0364141) + var x152 uint32 + var x153 uint32 + x152, x153 = bits.Add32(x151, x148, uint32(0x0)) + var x154 uint32 + var x155 uint32 + x154, x155 = bits.Add32(x149, x146, uint32(uint1(x153))) + var x156 uint32 + var x157 uint32 + x156, x157 = bits.Add32(x147, x144, uint32(uint1(x155))) + var x158 uint32 + var x159 uint32 + x158, x159 = bits.Add32(x145, x142, uint32(uint1(x157))) + var x160 uint32 + var x161 uint32 + x160, x161 = bits.Add32(x143, x140, uint32(uint1(x159))) + var x162 uint32 + var x163 uint32 + x162, x163 = bits.Add32(x141, x138, uint32(uint1(x161))) + var x164 uint32 + var x165 uint32 + x164, x165 = bits.Add32(x139, x136, uint32(uint1(x163))) + var x167 uint32 + _, x167 = bits.Add32(x118, x150, uint32(0x0)) + var x168 uint32 + var x169 uint32 + x168, x169 = bits.Add32(x120, x152, uint32(uint1(x167))) + var x170 uint32 + var x171 uint32 + x170, x171 = bits.Add32(x122, x154, uint32(uint1(x169))) + var x172 uint32 + var x173 uint32 + x172, x173 = bits.Add32(x124, x156, uint32(uint1(x171))) + var x174 uint32 + var x175 uint32 + x174, x175 = bits.Add32(x126, x158, uint32(uint1(x173))) + var x176 uint32 + var x177 uint32 + x176, x177 = bits.Add32(x128, x160, uint32(uint1(x175))) + var x178 uint32 + var x179 uint32 + x178, x179 = bits.Add32(x130, x162, uint32(uint1(x177))) + var x180 uint32 + var x181 uint32 + x180, x181 = bits.Add32(x132, x164, uint32(uint1(x179))) + var x182 uint32 + var x183 uint32 + x182, x183 = bits.Add32((uint32(uint1(x133)) + uint32(uint1(x117))), (uint32(uint1(x165)) + x137), uint32(uint1(x181))) + var x184 uint32 + var x185 uint32 + x184, x185 = bits.Add32(x168, arg1[3], uint32(0x0)) + var x186 uint32 + var x187 uint32 + x186, x187 = bits.Add32(x170, uint32(0x0), uint32(uint1(x185))) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Add32(x172, uint32(0x0), uint32(uint1(x187))) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Add32(x174, uint32(0x0), uint32(uint1(x189))) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Add32(x176, uint32(0x0), uint32(uint1(x191))) + var x194 uint32 + var x195 uint32 + x194, x195 = bits.Add32(x178, uint32(0x0), uint32(uint1(x193))) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Add32(x180, uint32(0x0), uint32(uint1(x195))) + var x198 uint32 + var x199 uint32 + x198, x199 = bits.Add32(x182, uint32(0x0), uint32(uint1(x197))) + var x200 uint32 + _, x200 = bits.Mul32(x184, 0x5588b13f) + var x202 uint32 + var x203 uint32 + x203, x202 = bits.Mul32(x200, 0xffffffff) + var x204 uint32 + var x205 uint32 + x205, x204 = bits.Mul32(x200, 0xffffffff) + var x206 uint32 + var x207 uint32 + x207, x206 = bits.Mul32(x200, 0xffffffff) + var x208 uint32 + var x209 uint32 + x209, x208 = bits.Mul32(x200, 0xfffffffe) + var x210 uint32 + var x211 uint32 + x211, x210 = bits.Mul32(x200, 0xbaaedce6) + var x212 uint32 + var x213 uint32 + x213, x212 = bits.Mul32(x200, 0xaf48a03b) + var x214 uint32 + var x215 uint32 + x215, x214 = bits.Mul32(x200, 0xbfd25e8c) + var x216 uint32 + var x217 uint32 + x217, x216 = bits.Mul32(x200, 0xd0364141) + var x218 uint32 + var x219 uint32 + x218, x219 = bits.Add32(x217, x214, uint32(0x0)) + var x220 uint32 + var x221 uint32 + x220, x221 = bits.Add32(x215, x212, uint32(uint1(x219))) + var x222 uint32 + var x223 uint32 + x222, x223 = bits.Add32(x213, x210, uint32(uint1(x221))) + var x224 uint32 + var x225 uint32 + x224, x225 = bits.Add32(x211, x208, uint32(uint1(x223))) + var x226 uint32 + var x227 uint32 + x226, x227 = bits.Add32(x209, x206, uint32(uint1(x225))) + var x228 uint32 + var x229 uint32 + x228, x229 = bits.Add32(x207, x204, uint32(uint1(x227))) + var x230 uint32 + var x231 uint32 + x230, x231 = bits.Add32(x205, x202, uint32(uint1(x229))) + var x233 uint32 + _, x233 = bits.Add32(x184, x216, uint32(0x0)) + var x234 uint32 + var x235 uint32 + x234, x235 = bits.Add32(x186, x218, uint32(uint1(x233))) + var x236 uint32 + var x237 uint32 + x236, x237 = bits.Add32(x188, x220, uint32(uint1(x235))) + var x238 uint32 + var x239 uint32 + x238, x239 = bits.Add32(x190, x222, uint32(uint1(x237))) + var x240 uint32 + var x241 uint32 + x240, x241 = bits.Add32(x192, x224, uint32(uint1(x239))) + var x242 uint32 + var x243 uint32 + x242, x243 = bits.Add32(x194, x226, uint32(uint1(x241))) + var x244 uint32 + var x245 uint32 + x244, x245 = bits.Add32(x196, x228, uint32(uint1(x243))) + var x246 uint32 + var x247 uint32 + x246, x247 = bits.Add32(x198, x230, uint32(uint1(x245))) + var x248 uint32 + var x249 uint32 + x248, x249 = bits.Add32((uint32(uint1(x199)) + uint32(uint1(x183))), (uint32(uint1(x231)) + x203), uint32(uint1(x247))) + var x250 uint32 + var x251 uint32 + x250, x251 = bits.Add32(x234, arg1[4], uint32(0x0)) + var x252 uint32 + var x253 uint32 + x252, x253 = bits.Add32(x236, uint32(0x0), uint32(uint1(x251))) + var x254 uint32 + var x255 uint32 + x254, x255 = bits.Add32(x238, uint32(0x0), uint32(uint1(x253))) + var x256 uint32 + var x257 uint32 + x256, x257 = bits.Add32(x240, uint32(0x0), uint32(uint1(x255))) + var x258 uint32 + var x259 uint32 + x258, x259 = bits.Add32(x242, uint32(0x0), uint32(uint1(x257))) + var x260 uint32 + var x261 uint32 + x260, x261 = bits.Add32(x244, uint32(0x0), uint32(uint1(x259))) + var x262 uint32 + var x263 uint32 + x262, x263 = bits.Add32(x246, uint32(0x0), uint32(uint1(x261))) + var x264 uint32 + var x265 uint32 + x264, x265 = bits.Add32(x248, uint32(0x0), uint32(uint1(x263))) + var x266 uint32 + _, x266 = bits.Mul32(x250, 0x5588b13f) + var x268 uint32 + var x269 uint32 + x269, x268 = bits.Mul32(x266, 0xffffffff) + var x270 uint32 + var x271 uint32 + x271, x270 = bits.Mul32(x266, 0xffffffff) + var x272 uint32 + var x273 uint32 + x273, x272 = bits.Mul32(x266, 0xffffffff) + var x274 uint32 + var x275 uint32 + x275, x274 = bits.Mul32(x266, 0xfffffffe) + var x276 uint32 + var x277 uint32 + x277, x276 = bits.Mul32(x266, 0xbaaedce6) + var x278 uint32 + var x279 uint32 + x279, x278 = bits.Mul32(x266, 0xaf48a03b) + var x280 uint32 + var x281 uint32 + x281, x280 = bits.Mul32(x266, 0xbfd25e8c) + var x282 uint32 + var x283 uint32 + x283, x282 = bits.Mul32(x266, 0xd0364141) + var x284 uint32 + var x285 uint32 + x284, x285 = bits.Add32(x283, x280, uint32(0x0)) + var x286 uint32 + var x287 uint32 + x286, x287 = bits.Add32(x281, x278, uint32(uint1(x285))) + var x288 uint32 + var x289 uint32 + x288, x289 = bits.Add32(x279, x276, uint32(uint1(x287))) + var x290 uint32 + var x291 uint32 + x290, x291 = bits.Add32(x277, x274, uint32(uint1(x289))) + var x292 uint32 + var x293 uint32 + x292, x293 = bits.Add32(x275, x272, uint32(uint1(x291))) + var x294 uint32 + var x295 uint32 + x294, x295 = bits.Add32(x273, x270, uint32(uint1(x293))) + var x296 uint32 + var x297 uint32 + x296, x297 = bits.Add32(x271, x268, uint32(uint1(x295))) + var x299 uint32 + _, x299 = bits.Add32(x250, x282, uint32(0x0)) + var x300 uint32 + var x301 uint32 + x300, x301 = bits.Add32(x252, x284, uint32(uint1(x299))) + var x302 uint32 + var x303 uint32 + x302, x303 = bits.Add32(x254, x286, uint32(uint1(x301))) + var x304 uint32 + var x305 uint32 + x304, x305 = bits.Add32(x256, x288, uint32(uint1(x303))) + var x306 uint32 + var x307 uint32 + x306, x307 = bits.Add32(x258, x290, uint32(uint1(x305))) + var x308 uint32 + var x309 uint32 + x308, x309 = bits.Add32(x260, x292, uint32(uint1(x307))) + var x310 uint32 + var x311 uint32 + x310, x311 = bits.Add32(x262, x294, uint32(uint1(x309))) + var x312 uint32 + var x313 uint32 + x312, x313 = bits.Add32(x264, x296, uint32(uint1(x311))) + var x314 uint32 + var x315 uint32 + x314, x315 = bits.Add32((uint32(uint1(x265)) + uint32(uint1(x249))), (uint32(uint1(x297)) + x269), uint32(uint1(x313))) + var x316 uint32 + var x317 uint32 + x316, x317 = bits.Add32(x300, arg1[5], uint32(0x0)) + var x318 uint32 + var x319 uint32 + x318, x319 = bits.Add32(x302, uint32(0x0), uint32(uint1(x317))) + var x320 uint32 + var x321 uint32 + x320, x321 = bits.Add32(x304, uint32(0x0), uint32(uint1(x319))) + var x322 uint32 + var x323 uint32 + x322, x323 = bits.Add32(x306, uint32(0x0), uint32(uint1(x321))) + var x324 uint32 + var x325 uint32 + x324, x325 = bits.Add32(x308, uint32(0x0), uint32(uint1(x323))) + var x326 uint32 + var x327 uint32 + x326, x327 = bits.Add32(x310, uint32(0x0), uint32(uint1(x325))) + var x328 uint32 + var x329 uint32 + x328, x329 = bits.Add32(x312, uint32(0x0), uint32(uint1(x327))) + var x330 uint32 + var x331 uint32 + x330, x331 = bits.Add32(x314, uint32(0x0), uint32(uint1(x329))) + var x332 uint32 + _, x332 = bits.Mul32(x316, 0x5588b13f) + var x334 uint32 + var x335 uint32 + x335, x334 = bits.Mul32(x332, 0xffffffff) + var x336 uint32 + var x337 uint32 + x337, x336 = bits.Mul32(x332, 0xffffffff) + var x338 uint32 + var x339 uint32 + x339, x338 = bits.Mul32(x332, 0xffffffff) + var x340 uint32 + var x341 uint32 + x341, x340 = bits.Mul32(x332, 0xfffffffe) + var x342 uint32 + var x343 uint32 + x343, x342 = bits.Mul32(x332, 0xbaaedce6) + var x344 uint32 + var x345 uint32 + x345, x344 = bits.Mul32(x332, 0xaf48a03b) + var x346 uint32 + var x347 uint32 + x347, x346 = bits.Mul32(x332, 0xbfd25e8c) + var x348 uint32 + var x349 uint32 + x349, x348 = bits.Mul32(x332, 0xd0364141) + var x350 uint32 + var x351 uint32 + x350, x351 = bits.Add32(x349, x346, uint32(0x0)) + var x352 uint32 + var x353 uint32 + x352, x353 = bits.Add32(x347, x344, uint32(uint1(x351))) + var x354 uint32 + var x355 uint32 + x354, x355 = bits.Add32(x345, x342, uint32(uint1(x353))) + var x356 uint32 + var x357 uint32 + x356, x357 = bits.Add32(x343, x340, uint32(uint1(x355))) + var x358 uint32 + var x359 uint32 + x358, x359 = bits.Add32(x341, x338, uint32(uint1(x357))) + var x360 uint32 + var x361 uint32 + x360, x361 = bits.Add32(x339, x336, uint32(uint1(x359))) + var x362 uint32 + var x363 uint32 + x362, x363 = bits.Add32(x337, x334, uint32(uint1(x361))) + var x365 uint32 + _, x365 = bits.Add32(x316, x348, uint32(0x0)) + var x366 uint32 + var x367 uint32 + x366, x367 = bits.Add32(x318, x350, uint32(uint1(x365))) + var x368 uint32 + var x369 uint32 + x368, x369 = bits.Add32(x320, x352, uint32(uint1(x367))) + var x370 uint32 + var x371 uint32 + x370, x371 = bits.Add32(x322, x354, uint32(uint1(x369))) + var x372 uint32 + var x373 uint32 + x372, x373 = bits.Add32(x324, x356, uint32(uint1(x371))) + var x374 uint32 + var x375 uint32 + x374, x375 = bits.Add32(x326, x358, uint32(uint1(x373))) + var x376 uint32 + var x377 uint32 + x376, x377 = bits.Add32(x328, x360, uint32(uint1(x375))) + var x378 uint32 + var x379 uint32 + x378, x379 = bits.Add32(x330, x362, uint32(uint1(x377))) + var x380 uint32 + var x381 uint32 + x380, x381 = bits.Add32((uint32(uint1(x331)) + uint32(uint1(x315))), (uint32(uint1(x363)) + x335), uint32(uint1(x379))) + var x382 uint32 + var x383 uint32 + x382, x383 = bits.Add32(x366, arg1[6], uint32(0x0)) + var x384 uint32 + var x385 uint32 + x384, x385 = bits.Add32(x368, uint32(0x0), uint32(uint1(x383))) + var x386 uint32 + var x387 uint32 + x386, x387 = bits.Add32(x370, uint32(0x0), uint32(uint1(x385))) + var x388 uint32 + var x389 uint32 + x388, x389 = bits.Add32(x372, uint32(0x0), uint32(uint1(x387))) + var x390 uint32 + var x391 uint32 + x390, x391 = bits.Add32(x374, uint32(0x0), uint32(uint1(x389))) + var x392 uint32 + var x393 uint32 + x392, x393 = bits.Add32(x376, uint32(0x0), uint32(uint1(x391))) + var x394 uint32 + var x395 uint32 + x394, x395 = bits.Add32(x378, uint32(0x0), uint32(uint1(x393))) + var x396 uint32 + var x397 uint32 + x396, x397 = bits.Add32(x380, uint32(0x0), uint32(uint1(x395))) + var x398 uint32 + _, x398 = bits.Mul32(x382, 0x5588b13f) + var x400 uint32 + var x401 uint32 + x401, x400 = bits.Mul32(x398, 0xffffffff) + var x402 uint32 + var x403 uint32 + x403, x402 = bits.Mul32(x398, 0xffffffff) + var x404 uint32 + var x405 uint32 + x405, x404 = bits.Mul32(x398, 0xffffffff) + var x406 uint32 + var x407 uint32 + x407, x406 = bits.Mul32(x398, 0xfffffffe) + var x408 uint32 + var x409 uint32 + x409, x408 = bits.Mul32(x398, 0xbaaedce6) + var x410 uint32 + var x411 uint32 + x411, x410 = bits.Mul32(x398, 0xaf48a03b) + var x412 uint32 + var x413 uint32 + x413, x412 = bits.Mul32(x398, 0xbfd25e8c) + var x414 uint32 + var x415 uint32 + x415, x414 = bits.Mul32(x398, 0xd0364141) + var x416 uint32 + var x417 uint32 + x416, x417 = bits.Add32(x415, x412, uint32(0x0)) + var x418 uint32 + var x419 uint32 + x418, x419 = bits.Add32(x413, x410, uint32(uint1(x417))) + var x420 uint32 + var x421 uint32 + x420, x421 = bits.Add32(x411, x408, uint32(uint1(x419))) + var x422 uint32 + var x423 uint32 + x422, x423 = bits.Add32(x409, x406, uint32(uint1(x421))) + var x424 uint32 + var x425 uint32 + x424, x425 = bits.Add32(x407, x404, uint32(uint1(x423))) + var x426 uint32 + var x427 uint32 + x426, x427 = bits.Add32(x405, x402, uint32(uint1(x425))) + var x428 uint32 + var x429 uint32 + x428, x429 = bits.Add32(x403, x400, uint32(uint1(x427))) + var x431 uint32 + _, x431 = bits.Add32(x382, x414, uint32(0x0)) + var x432 uint32 + var x433 uint32 + x432, x433 = bits.Add32(x384, x416, uint32(uint1(x431))) + var x434 uint32 + var x435 uint32 + x434, x435 = bits.Add32(x386, x418, uint32(uint1(x433))) + var x436 uint32 + var x437 uint32 + x436, x437 = bits.Add32(x388, x420, uint32(uint1(x435))) + var x438 uint32 + var x439 uint32 + x438, x439 = bits.Add32(x390, x422, uint32(uint1(x437))) + var x440 uint32 + var x441 uint32 + x440, x441 = bits.Add32(x392, x424, uint32(uint1(x439))) + var x442 uint32 + var x443 uint32 + x442, x443 = bits.Add32(x394, x426, uint32(uint1(x441))) + var x444 uint32 + var x445 uint32 + x444, x445 = bits.Add32(x396, x428, uint32(uint1(x443))) + var x446 uint32 + var x447 uint32 + x446, x447 = bits.Add32((uint32(uint1(x397)) + uint32(uint1(x381))), (uint32(uint1(x429)) + x401), uint32(uint1(x445))) + var x448 uint32 + var x449 uint32 + x448, x449 = bits.Add32(x432, arg1[7], uint32(0x0)) + var x450 uint32 + var x451 uint32 + x450, x451 = bits.Add32(x434, uint32(0x0), uint32(uint1(x449))) + var x452 uint32 + var x453 uint32 + x452, x453 = bits.Add32(x436, uint32(0x0), uint32(uint1(x451))) + var x454 uint32 + var x455 uint32 + x454, x455 = bits.Add32(x438, uint32(0x0), uint32(uint1(x453))) + var x456 uint32 + var x457 uint32 + x456, x457 = bits.Add32(x440, uint32(0x0), uint32(uint1(x455))) + var x458 uint32 + var x459 uint32 + x458, x459 = bits.Add32(x442, uint32(0x0), uint32(uint1(x457))) + var x460 uint32 + var x461 uint32 + x460, x461 = bits.Add32(x444, uint32(0x0), uint32(uint1(x459))) + var x462 uint32 + var x463 uint32 + x462, x463 = bits.Add32(x446, uint32(0x0), uint32(uint1(x461))) + var x464 uint32 + _, x464 = bits.Mul32(x448, 0x5588b13f) + var x466 uint32 + var x467 uint32 + x467, x466 = bits.Mul32(x464, 0xffffffff) + var x468 uint32 + var x469 uint32 + x469, x468 = bits.Mul32(x464, 0xffffffff) + var x470 uint32 + var x471 uint32 + x471, x470 = bits.Mul32(x464, 0xffffffff) + var x472 uint32 + var x473 uint32 + x473, x472 = bits.Mul32(x464, 0xfffffffe) + var x474 uint32 + var x475 uint32 + x475, x474 = bits.Mul32(x464, 0xbaaedce6) + var x476 uint32 + var x477 uint32 + x477, x476 = bits.Mul32(x464, 0xaf48a03b) + var x478 uint32 + var x479 uint32 + x479, x478 = bits.Mul32(x464, 0xbfd25e8c) + var x480 uint32 + var x481 uint32 + x481, x480 = bits.Mul32(x464, 0xd0364141) + var x482 uint32 + var x483 uint32 + x482, x483 = bits.Add32(x481, x478, uint32(0x0)) + var x484 uint32 + var x485 uint32 + x484, x485 = bits.Add32(x479, x476, uint32(uint1(x483))) + var x486 uint32 + var x487 uint32 + x486, x487 = bits.Add32(x477, x474, uint32(uint1(x485))) + var x488 uint32 + var x489 uint32 + x488, x489 = bits.Add32(x475, x472, uint32(uint1(x487))) + var x490 uint32 + var x491 uint32 + x490, x491 = bits.Add32(x473, x470, uint32(uint1(x489))) + var x492 uint32 + var x493 uint32 + x492, x493 = bits.Add32(x471, x468, uint32(uint1(x491))) + var x494 uint32 + var x495 uint32 + x494, x495 = bits.Add32(x469, x466, uint32(uint1(x493))) + var x497 uint32 + _, x497 = bits.Add32(x448, x480, uint32(0x0)) + var x498 uint32 + var x499 uint32 + x498, x499 = bits.Add32(x450, x482, uint32(uint1(x497))) + var x500 uint32 + var x501 uint32 + x500, x501 = bits.Add32(x452, x484, uint32(uint1(x499))) + var x502 uint32 + var x503 uint32 + x502, x503 = bits.Add32(x454, x486, uint32(uint1(x501))) + var x504 uint32 + var x505 uint32 + x504, x505 = bits.Add32(x456, x488, uint32(uint1(x503))) + var x506 uint32 + var x507 uint32 + x506, x507 = bits.Add32(x458, x490, uint32(uint1(x505))) + var x508 uint32 + var x509 uint32 + x508, x509 = bits.Add32(x460, x492, uint32(uint1(x507))) + var x510 uint32 + var x511 uint32 + x510, x511 = bits.Add32(x462, x494, uint32(uint1(x509))) + var x512 uint32 + var x513 uint32 + x512, x513 = bits.Add32((uint32(uint1(x463)) + uint32(uint1(x447))), (uint32(uint1(x495)) + x467), uint32(uint1(x511))) + var x514 uint32 + var x515 uint32 + x514, x515 = bits.Sub32(x498, 0xd0364141, uint32(0x0)) + var x516 uint32 + var x517 uint32 + x516, x517 = bits.Sub32(x500, 0xbfd25e8c, uint32(uint1(x515))) + var x518 uint32 + var x519 uint32 + x518, x519 = bits.Sub32(x502, 0xaf48a03b, uint32(uint1(x517))) + var x520 uint32 + var x521 uint32 + x520, x521 = bits.Sub32(x504, 0xbaaedce6, uint32(uint1(x519))) + var x522 uint32 + var x523 uint32 + x522, x523 = bits.Sub32(x506, 0xfffffffe, uint32(uint1(x521))) + var x524 uint32 + var x525 uint32 + x524, x525 = bits.Sub32(x508, 0xffffffff, uint32(uint1(x523))) + var x526 uint32 + var x527 uint32 + x526, x527 = bits.Sub32(x510, 0xffffffff, uint32(uint1(x525))) + var x528 uint32 + var x529 uint32 + x528, x529 = bits.Sub32(x512, 0xffffffff, uint32(uint1(x527))) + var x531 uint32 + _, x531 = bits.Sub32(uint32(uint1(x513)), uint32(0x0), uint32(uint1(x529))) + var x532 uint32 + cmovznzU32(&x532, uint1(x531), x514, x498) + var x533 uint32 + cmovznzU32(&x533, uint1(x531), x516, x500) + var x534 uint32 + cmovznzU32(&x534, uint1(x531), x518, x502) + var x535 uint32 + cmovznzU32(&x535, uint1(x531), x520, x504) + var x536 uint32 + cmovznzU32(&x536, uint1(x531), x522, x506) + var x537 uint32 + cmovznzU32(&x537, uint1(x531), x524, x508) + var x538 uint32 + cmovznzU32(&x538, uint1(x531), x526, x510) + var x539 uint32 + cmovznzU32(&x539, uint1(x531), x528, x512) + out1[0] = x532 + out1[1] = x533 + out1[2] = x534 + out1[3] = x535 + out1[4] = x536 + out1[5] = x537 + out1[6] = x538 + out1[7] = x539 +} + +// ToMontgomery translates a field element into the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = eval arg1 mod m +// 0 ≤ eval out1 < m +// +func ToMontgomery(out1 *MontgomeryDomainFieldElement, arg1 *NonMontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[6] + x7 := arg1[7] + x8 := arg1[0] + var x9 uint32 + var x10 uint32 + x10, x9 = bits.Mul32(x8, 0x9d671cd5) + var x11 uint32 + var x12 uint32 + x12, x11 = bits.Mul32(x8, 0x81c69bc5) + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x8, 0xe697f5e4) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x8, 0x5bcd07c6) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x8, 0x741496c2) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x8, 0xe7cf878) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x8, 0x896cf214) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x8, 0x67d7d140) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Add32(x24, x21, uint32(0x0)) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Add32(x22, x19, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Add32(x20, x17, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Add32(x18, x15, uint32(uint1(x30))) + var x33 uint32 + var x34 uint32 + x33, x34 = bits.Add32(x16, x13, uint32(uint1(x32))) + var x35 uint32 + var x36 uint32 + x35, x36 = bits.Add32(x14, x11, uint32(uint1(x34))) + var x37 uint32 + var x38 uint32 + x37, x38 = bits.Add32(x12, x9, uint32(uint1(x36))) + var x39 uint32 + _, x39 = bits.Mul32(x23, 0x5588b13f) + var x41 uint32 + var x42 uint32 + x42, x41 = bits.Mul32(x39, 0xffffffff) + var x43 uint32 + var x44 uint32 + x44, x43 = bits.Mul32(x39, 0xffffffff) + var x45 uint32 + var x46 uint32 + x46, x45 = bits.Mul32(x39, 0xffffffff) + var x47 uint32 + var x48 uint32 + x48, x47 = bits.Mul32(x39, 0xfffffffe) + var x49 uint32 + var x50 uint32 + x50, x49 = bits.Mul32(x39, 0xbaaedce6) + var x51 uint32 + var x52 uint32 + x52, x51 = bits.Mul32(x39, 0xaf48a03b) + var x53 uint32 + var x54 uint32 + x54, x53 = bits.Mul32(x39, 0xbfd25e8c) + var x55 uint32 + var x56 uint32 + x56, x55 = bits.Mul32(x39, 0xd0364141) + var x57 uint32 + var x58 uint32 + x57, x58 = bits.Add32(x56, x53, uint32(0x0)) + var x59 uint32 + var x60 uint32 + x59, x60 = bits.Add32(x54, x51, uint32(uint1(x58))) + var x61 uint32 + var x62 uint32 + x61, x62 = bits.Add32(x52, x49, uint32(uint1(x60))) + var x63 uint32 + var x64 uint32 + x63, x64 = bits.Add32(x50, x47, uint32(uint1(x62))) + var x65 uint32 + var x66 uint32 + x65, x66 = bits.Add32(x48, x45, uint32(uint1(x64))) + var x67 uint32 + var x68 uint32 + x67, x68 = bits.Add32(x46, x43, uint32(uint1(x66))) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Add32(x44, x41, uint32(uint1(x68))) + var x72 uint32 + _, x72 = bits.Add32(x23, x55, uint32(0x0)) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Add32(x25, x57, uint32(uint1(x72))) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Add32(x27, x59, uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x77, x78 = bits.Add32(x29, x61, uint32(uint1(x76))) + var x79 uint32 + var x80 uint32 + x79, x80 = bits.Add32(x31, x63, uint32(uint1(x78))) + var x81 uint32 + var x82 uint32 + x81, x82 = bits.Add32(x33, x65, uint32(uint1(x80))) + var x83 uint32 + var x84 uint32 + x83, x84 = bits.Add32(x35, x67, uint32(uint1(x82))) + var x85 uint32 + var x86 uint32 + x85, x86 = bits.Add32(x37, x69, uint32(uint1(x84))) + var x87 uint32 + var x88 uint32 + x87, x88 = bits.Add32((uint32(uint1(x38)) + x10), (uint32(uint1(x70)) + x42), uint32(uint1(x86))) + var x89 uint32 + var x90 uint32 + x90, x89 = bits.Mul32(x1, 0x9d671cd5) + var x91 uint32 + var x92 uint32 + x92, x91 = bits.Mul32(x1, 0x81c69bc5) + var x93 uint32 + var x94 uint32 + x94, x93 = bits.Mul32(x1, 0xe697f5e4) + var x95 uint32 + var x96 uint32 + x96, x95 = bits.Mul32(x1, 0x5bcd07c6) + var x97 uint32 + var x98 uint32 + x98, x97 = bits.Mul32(x1, 0x741496c2) + var x99 uint32 + var x100 uint32 + x100, x99 = bits.Mul32(x1, 0xe7cf878) + var x101 uint32 + var x102 uint32 + x102, x101 = bits.Mul32(x1, 0x896cf214) + var x103 uint32 + var x104 uint32 + x104, x103 = bits.Mul32(x1, 0x67d7d140) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Add32(x104, x101, uint32(0x0)) + var x107 uint32 + var x108 uint32 + x107, x108 = bits.Add32(x102, x99, uint32(uint1(x106))) + var x109 uint32 + var x110 uint32 + x109, x110 = bits.Add32(x100, x97, uint32(uint1(x108))) + var x111 uint32 + var x112 uint32 + x111, x112 = bits.Add32(x98, x95, uint32(uint1(x110))) + var x113 uint32 + var x114 uint32 + x113, x114 = bits.Add32(x96, x93, uint32(uint1(x112))) + var x115 uint32 + var x116 uint32 + x115, x116 = bits.Add32(x94, x91, uint32(uint1(x114))) + var x117 uint32 + var x118 uint32 + x117, x118 = bits.Add32(x92, x89, uint32(uint1(x116))) + var x119 uint32 + var x120 uint32 + x119, x120 = bits.Add32(x73, x103, uint32(0x0)) + var x121 uint32 + var x122 uint32 + x121, x122 = bits.Add32(x75, x105, uint32(uint1(x120))) + var x123 uint32 + var x124 uint32 + x123, x124 = bits.Add32(x77, x107, uint32(uint1(x122))) + var x125 uint32 + var x126 uint32 + x125, x126 = bits.Add32(x79, x109, uint32(uint1(x124))) + var x127 uint32 + var x128 uint32 + x127, x128 = bits.Add32(x81, x111, uint32(uint1(x126))) + var x129 uint32 + var x130 uint32 + x129, x130 = bits.Add32(x83, x113, uint32(uint1(x128))) + var x131 uint32 + var x132 uint32 + x131, x132 = bits.Add32(x85, x115, uint32(uint1(x130))) + var x133 uint32 + var x134 uint32 + x133, x134 = bits.Add32(x87, x117, uint32(uint1(x132))) + var x135 uint32 + _, x135 = bits.Mul32(x119, 0x5588b13f) + var x137 uint32 + var x138 uint32 + x138, x137 = bits.Mul32(x135, 0xffffffff) + var x139 uint32 + var x140 uint32 + x140, x139 = bits.Mul32(x135, 0xffffffff) + var x141 uint32 + var x142 uint32 + x142, x141 = bits.Mul32(x135, 0xffffffff) + var x143 uint32 + var x144 uint32 + x144, x143 = bits.Mul32(x135, 0xfffffffe) + var x145 uint32 + var x146 uint32 + x146, x145 = bits.Mul32(x135, 0xbaaedce6) + var x147 uint32 + var x148 uint32 + x148, x147 = bits.Mul32(x135, 0xaf48a03b) + var x149 uint32 + var x150 uint32 + x150, x149 = bits.Mul32(x135, 0xbfd25e8c) + var x151 uint32 + var x152 uint32 + x152, x151 = bits.Mul32(x135, 0xd0364141) + var x153 uint32 + var x154 uint32 + x153, x154 = bits.Add32(x152, x149, uint32(0x0)) + var x155 uint32 + var x156 uint32 + x155, x156 = bits.Add32(x150, x147, uint32(uint1(x154))) + var x157 uint32 + var x158 uint32 + x157, x158 = bits.Add32(x148, x145, uint32(uint1(x156))) + var x159 uint32 + var x160 uint32 + x159, x160 = bits.Add32(x146, x143, uint32(uint1(x158))) + var x161 uint32 + var x162 uint32 + x161, x162 = bits.Add32(x144, x141, uint32(uint1(x160))) + var x163 uint32 + var x164 uint32 + x163, x164 = bits.Add32(x142, x139, uint32(uint1(x162))) + var x165 uint32 + var x166 uint32 + x165, x166 = bits.Add32(x140, x137, uint32(uint1(x164))) + var x168 uint32 + _, x168 = bits.Add32(x119, x151, uint32(0x0)) + var x169 uint32 + var x170 uint32 + x169, x170 = bits.Add32(x121, x153, uint32(uint1(x168))) + var x171 uint32 + var x172 uint32 + x171, x172 = bits.Add32(x123, x155, uint32(uint1(x170))) + var x173 uint32 + var x174 uint32 + x173, x174 = bits.Add32(x125, x157, uint32(uint1(x172))) + var x175 uint32 + var x176 uint32 + x175, x176 = bits.Add32(x127, x159, uint32(uint1(x174))) + var x177 uint32 + var x178 uint32 + x177, x178 = bits.Add32(x129, x161, uint32(uint1(x176))) + var x179 uint32 + var x180 uint32 + x179, x180 = bits.Add32(x131, x163, uint32(uint1(x178))) + var x181 uint32 + var x182 uint32 + x181, x182 = bits.Add32(x133, x165, uint32(uint1(x180))) + var x183 uint32 + var x184 uint32 + x183, x184 = bits.Add32(((uint32(uint1(x134)) + uint32(uint1(x88))) + (uint32(uint1(x118)) + x90)), (uint32(uint1(x166)) + x138), uint32(uint1(x182))) + var x185 uint32 + var x186 uint32 + x186, x185 = bits.Mul32(x2, 0x9d671cd5) + var x187 uint32 + var x188 uint32 + x188, x187 = bits.Mul32(x2, 0x81c69bc5) + var x189 uint32 + var x190 uint32 + x190, x189 = bits.Mul32(x2, 0xe697f5e4) + var x191 uint32 + var x192 uint32 + x192, x191 = bits.Mul32(x2, 0x5bcd07c6) + var x193 uint32 + var x194 uint32 + x194, x193 = bits.Mul32(x2, 0x741496c2) + var x195 uint32 + var x196 uint32 + x196, x195 = bits.Mul32(x2, 0xe7cf878) + var x197 uint32 + var x198 uint32 + x198, x197 = bits.Mul32(x2, 0x896cf214) + var x199 uint32 + var x200 uint32 + x200, x199 = bits.Mul32(x2, 0x67d7d140) + var x201 uint32 + var x202 uint32 + x201, x202 = bits.Add32(x200, x197, uint32(0x0)) + var x203 uint32 + var x204 uint32 + x203, x204 = bits.Add32(x198, x195, uint32(uint1(x202))) + var x205 uint32 + var x206 uint32 + x205, x206 = bits.Add32(x196, x193, uint32(uint1(x204))) + var x207 uint32 + var x208 uint32 + x207, x208 = bits.Add32(x194, x191, uint32(uint1(x206))) + var x209 uint32 + var x210 uint32 + x209, x210 = bits.Add32(x192, x189, uint32(uint1(x208))) + var x211 uint32 + var x212 uint32 + x211, x212 = bits.Add32(x190, x187, uint32(uint1(x210))) + var x213 uint32 + var x214 uint32 + x213, x214 = bits.Add32(x188, x185, uint32(uint1(x212))) + var x215 uint32 + var x216 uint32 + x215, x216 = bits.Add32(x169, x199, uint32(0x0)) + var x217 uint32 + var x218 uint32 + x217, x218 = bits.Add32(x171, x201, uint32(uint1(x216))) + var x219 uint32 + var x220 uint32 + x219, x220 = bits.Add32(x173, x203, uint32(uint1(x218))) + var x221 uint32 + var x222 uint32 + x221, x222 = bits.Add32(x175, x205, uint32(uint1(x220))) + var x223 uint32 + var x224 uint32 + x223, x224 = bits.Add32(x177, x207, uint32(uint1(x222))) + var x225 uint32 + var x226 uint32 + x225, x226 = bits.Add32(x179, x209, uint32(uint1(x224))) + var x227 uint32 + var x228 uint32 + x227, x228 = bits.Add32(x181, x211, uint32(uint1(x226))) + var x229 uint32 + var x230 uint32 + x229, x230 = bits.Add32(x183, x213, uint32(uint1(x228))) + var x231 uint32 + _, x231 = bits.Mul32(x215, 0x5588b13f) + var x233 uint32 + var x234 uint32 + x234, x233 = bits.Mul32(x231, 0xffffffff) + var x235 uint32 + var x236 uint32 + x236, x235 = bits.Mul32(x231, 0xffffffff) + var x237 uint32 + var x238 uint32 + x238, x237 = bits.Mul32(x231, 0xffffffff) + var x239 uint32 + var x240 uint32 + x240, x239 = bits.Mul32(x231, 0xfffffffe) + var x241 uint32 + var x242 uint32 + x242, x241 = bits.Mul32(x231, 0xbaaedce6) + var x243 uint32 + var x244 uint32 + x244, x243 = bits.Mul32(x231, 0xaf48a03b) + var x245 uint32 + var x246 uint32 + x246, x245 = bits.Mul32(x231, 0xbfd25e8c) + var x247 uint32 + var x248 uint32 + x248, x247 = bits.Mul32(x231, 0xd0364141) + var x249 uint32 + var x250 uint32 + x249, x250 = bits.Add32(x248, x245, uint32(0x0)) + var x251 uint32 + var x252 uint32 + x251, x252 = bits.Add32(x246, x243, uint32(uint1(x250))) + var x253 uint32 + var x254 uint32 + x253, x254 = bits.Add32(x244, x241, uint32(uint1(x252))) + var x255 uint32 + var x256 uint32 + x255, x256 = bits.Add32(x242, x239, uint32(uint1(x254))) + var x257 uint32 + var x258 uint32 + x257, x258 = bits.Add32(x240, x237, uint32(uint1(x256))) + var x259 uint32 + var x260 uint32 + x259, x260 = bits.Add32(x238, x235, uint32(uint1(x258))) + var x261 uint32 + var x262 uint32 + x261, x262 = bits.Add32(x236, x233, uint32(uint1(x260))) + var x264 uint32 + _, x264 = bits.Add32(x215, x247, uint32(0x0)) + var x265 uint32 + var x266 uint32 + x265, x266 = bits.Add32(x217, x249, uint32(uint1(x264))) + var x267 uint32 + var x268 uint32 + x267, x268 = bits.Add32(x219, x251, uint32(uint1(x266))) + var x269 uint32 + var x270 uint32 + x269, x270 = bits.Add32(x221, x253, uint32(uint1(x268))) + var x271 uint32 + var x272 uint32 + x271, x272 = bits.Add32(x223, x255, uint32(uint1(x270))) + var x273 uint32 + var x274 uint32 + x273, x274 = bits.Add32(x225, x257, uint32(uint1(x272))) + var x275 uint32 + var x276 uint32 + x275, x276 = bits.Add32(x227, x259, uint32(uint1(x274))) + var x277 uint32 + var x278 uint32 + x277, x278 = bits.Add32(x229, x261, uint32(uint1(x276))) + var x279 uint32 + var x280 uint32 + x279, x280 = bits.Add32(((uint32(uint1(x230)) + uint32(uint1(x184))) + (uint32(uint1(x214)) + x186)), (uint32(uint1(x262)) + x234), uint32(uint1(x278))) + var x281 uint32 + var x282 uint32 + x282, x281 = bits.Mul32(x3, 0x9d671cd5) + var x283 uint32 + var x284 uint32 + x284, x283 = bits.Mul32(x3, 0x81c69bc5) + var x285 uint32 + var x286 uint32 + x286, x285 = bits.Mul32(x3, 0xe697f5e4) + var x287 uint32 + var x288 uint32 + x288, x287 = bits.Mul32(x3, 0x5bcd07c6) + var x289 uint32 + var x290 uint32 + x290, x289 = bits.Mul32(x3, 0x741496c2) + var x291 uint32 + var x292 uint32 + x292, x291 = bits.Mul32(x3, 0xe7cf878) + var x293 uint32 + var x294 uint32 + x294, x293 = bits.Mul32(x3, 0x896cf214) + var x295 uint32 + var x296 uint32 + x296, x295 = bits.Mul32(x3, 0x67d7d140) + var x297 uint32 + var x298 uint32 + x297, x298 = bits.Add32(x296, x293, uint32(0x0)) + var x299 uint32 + var x300 uint32 + x299, x300 = bits.Add32(x294, x291, uint32(uint1(x298))) + var x301 uint32 + var x302 uint32 + x301, x302 = bits.Add32(x292, x289, uint32(uint1(x300))) + var x303 uint32 + var x304 uint32 + x303, x304 = bits.Add32(x290, x287, uint32(uint1(x302))) + var x305 uint32 + var x306 uint32 + x305, x306 = bits.Add32(x288, x285, uint32(uint1(x304))) + var x307 uint32 + var x308 uint32 + x307, x308 = bits.Add32(x286, x283, uint32(uint1(x306))) + var x309 uint32 + var x310 uint32 + x309, x310 = bits.Add32(x284, x281, uint32(uint1(x308))) + var x311 uint32 + var x312 uint32 + x311, x312 = bits.Add32(x265, x295, uint32(0x0)) + var x313 uint32 + var x314 uint32 + x313, x314 = bits.Add32(x267, x297, uint32(uint1(x312))) + var x315 uint32 + var x316 uint32 + x315, x316 = bits.Add32(x269, x299, uint32(uint1(x314))) + var x317 uint32 + var x318 uint32 + x317, x318 = bits.Add32(x271, x301, uint32(uint1(x316))) + var x319 uint32 + var x320 uint32 + x319, x320 = bits.Add32(x273, x303, uint32(uint1(x318))) + var x321 uint32 + var x322 uint32 + x321, x322 = bits.Add32(x275, x305, uint32(uint1(x320))) + var x323 uint32 + var x324 uint32 + x323, x324 = bits.Add32(x277, x307, uint32(uint1(x322))) + var x325 uint32 + var x326 uint32 + x325, x326 = bits.Add32(x279, x309, uint32(uint1(x324))) + var x327 uint32 + _, x327 = bits.Mul32(x311, 0x5588b13f) + var x329 uint32 + var x330 uint32 + x330, x329 = bits.Mul32(x327, 0xffffffff) + var x331 uint32 + var x332 uint32 + x332, x331 = bits.Mul32(x327, 0xffffffff) + var x333 uint32 + var x334 uint32 + x334, x333 = bits.Mul32(x327, 0xffffffff) + var x335 uint32 + var x336 uint32 + x336, x335 = bits.Mul32(x327, 0xfffffffe) + var x337 uint32 + var x338 uint32 + x338, x337 = bits.Mul32(x327, 0xbaaedce6) + var x339 uint32 + var x340 uint32 + x340, x339 = bits.Mul32(x327, 0xaf48a03b) + var x341 uint32 + var x342 uint32 + x342, x341 = bits.Mul32(x327, 0xbfd25e8c) + var x343 uint32 + var x344 uint32 + x344, x343 = bits.Mul32(x327, 0xd0364141) + var x345 uint32 + var x346 uint32 + x345, x346 = bits.Add32(x344, x341, uint32(0x0)) + var x347 uint32 + var x348 uint32 + x347, x348 = bits.Add32(x342, x339, uint32(uint1(x346))) + var x349 uint32 + var x350 uint32 + x349, x350 = bits.Add32(x340, x337, uint32(uint1(x348))) + var x351 uint32 + var x352 uint32 + x351, x352 = bits.Add32(x338, x335, uint32(uint1(x350))) + var x353 uint32 + var x354 uint32 + x353, x354 = bits.Add32(x336, x333, uint32(uint1(x352))) + var x355 uint32 + var x356 uint32 + x355, x356 = bits.Add32(x334, x331, uint32(uint1(x354))) + var x357 uint32 + var x358 uint32 + x357, x358 = bits.Add32(x332, x329, uint32(uint1(x356))) + var x360 uint32 + _, x360 = bits.Add32(x311, x343, uint32(0x0)) + var x361 uint32 + var x362 uint32 + x361, x362 = bits.Add32(x313, x345, uint32(uint1(x360))) + var x363 uint32 + var x364 uint32 + x363, x364 = bits.Add32(x315, x347, uint32(uint1(x362))) + var x365 uint32 + var x366 uint32 + x365, x366 = bits.Add32(x317, x349, uint32(uint1(x364))) + var x367 uint32 + var x368 uint32 + x367, x368 = bits.Add32(x319, x351, uint32(uint1(x366))) + var x369 uint32 + var x370 uint32 + x369, x370 = bits.Add32(x321, x353, uint32(uint1(x368))) + var x371 uint32 + var x372 uint32 + x371, x372 = bits.Add32(x323, x355, uint32(uint1(x370))) + var x373 uint32 + var x374 uint32 + x373, x374 = bits.Add32(x325, x357, uint32(uint1(x372))) + var x375 uint32 + var x376 uint32 + x375, x376 = bits.Add32(((uint32(uint1(x326)) + uint32(uint1(x280))) + (uint32(uint1(x310)) + x282)), (uint32(uint1(x358)) + x330), uint32(uint1(x374))) + var x377 uint32 + var x378 uint32 + x378, x377 = bits.Mul32(x4, 0x9d671cd5) + var x379 uint32 + var x380 uint32 + x380, x379 = bits.Mul32(x4, 0x81c69bc5) + var x381 uint32 + var x382 uint32 + x382, x381 = bits.Mul32(x4, 0xe697f5e4) + var x383 uint32 + var x384 uint32 + x384, x383 = bits.Mul32(x4, 0x5bcd07c6) + var x385 uint32 + var x386 uint32 + x386, x385 = bits.Mul32(x4, 0x741496c2) + var x387 uint32 + var x388 uint32 + x388, x387 = bits.Mul32(x4, 0xe7cf878) + var x389 uint32 + var x390 uint32 + x390, x389 = bits.Mul32(x4, 0x896cf214) + var x391 uint32 + var x392 uint32 + x392, x391 = bits.Mul32(x4, 0x67d7d140) + var x393 uint32 + var x394 uint32 + x393, x394 = bits.Add32(x392, x389, uint32(0x0)) + var x395 uint32 + var x396 uint32 + x395, x396 = bits.Add32(x390, x387, uint32(uint1(x394))) + var x397 uint32 + var x398 uint32 + x397, x398 = bits.Add32(x388, x385, uint32(uint1(x396))) + var x399 uint32 + var x400 uint32 + x399, x400 = bits.Add32(x386, x383, uint32(uint1(x398))) + var x401 uint32 + var x402 uint32 + x401, x402 = bits.Add32(x384, x381, uint32(uint1(x400))) + var x403 uint32 + var x404 uint32 + x403, x404 = bits.Add32(x382, x379, uint32(uint1(x402))) + var x405 uint32 + var x406 uint32 + x405, x406 = bits.Add32(x380, x377, uint32(uint1(x404))) + var x407 uint32 + var x408 uint32 + x407, x408 = bits.Add32(x361, x391, uint32(0x0)) + var x409 uint32 + var x410 uint32 + x409, x410 = bits.Add32(x363, x393, uint32(uint1(x408))) + var x411 uint32 + var x412 uint32 + x411, x412 = bits.Add32(x365, x395, uint32(uint1(x410))) + var x413 uint32 + var x414 uint32 + x413, x414 = bits.Add32(x367, x397, uint32(uint1(x412))) + var x415 uint32 + var x416 uint32 + x415, x416 = bits.Add32(x369, x399, uint32(uint1(x414))) + var x417 uint32 + var x418 uint32 + x417, x418 = bits.Add32(x371, x401, uint32(uint1(x416))) + var x419 uint32 + var x420 uint32 + x419, x420 = bits.Add32(x373, x403, uint32(uint1(x418))) + var x421 uint32 + var x422 uint32 + x421, x422 = bits.Add32(x375, x405, uint32(uint1(x420))) + var x423 uint32 + _, x423 = bits.Mul32(x407, 0x5588b13f) + var x425 uint32 + var x426 uint32 + x426, x425 = bits.Mul32(x423, 0xffffffff) + var x427 uint32 + var x428 uint32 + x428, x427 = bits.Mul32(x423, 0xffffffff) + var x429 uint32 + var x430 uint32 + x430, x429 = bits.Mul32(x423, 0xffffffff) + var x431 uint32 + var x432 uint32 + x432, x431 = bits.Mul32(x423, 0xfffffffe) + var x433 uint32 + var x434 uint32 + x434, x433 = bits.Mul32(x423, 0xbaaedce6) + var x435 uint32 + var x436 uint32 + x436, x435 = bits.Mul32(x423, 0xaf48a03b) + var x437 uint32 + var x438 uint32 + x438, x437 = bits.Mul32(x423, 0xbfd25e8c) + var x439 uint32 + var x440 uint32 + x440, x439 = bits.Mul32(x423, 0xd0364141) + var x441 uint32 + var x442 uint32 + x441, x442 = bits.Add32(x440, x437, uint32(0x0)) + var x443 uint32 + var x444 uint32 + x443, x444 = bits.Add32(x438, x435, uint32(uint1(x442))) + var x445 uint32 + var x446 uint32 + x445, x446 = bits.Add32(x436, x433, uint32(uint1(x444))) + var x447 uint32 + var x448 uint32 + x447, x448 = bits.Add32(x434, x431, uint32(uint1(x446))) + var x449 uint32 + var x450 uint32 + x449, x450 = bits.Add32(x432, x429, uint32(uint1(x448))) + var x451 uint32 + var x452 uint32 + x451, x452 = bits.Add32(x430, x427, uint32(uint1(x450))) + var x453 uint32 + var x454 uint32 + x453, x454 = bits.Add32(x428, x425, uint32(uint1(x452))) + var x456 uint32 + _, x456 = bits.Add32(x407, x439, uint32(0x0)) + var x457 uint32 + var x458 uint32 + x457, x458 = bits.Add32(x409, x441, uint32(uint1(x456))) + var x459 uint32 + var x460 uint32 + x459, x460 = bits.Add32(x411, x443, uint32(uint1(x458))) + var x461 uint32 + var x462 uint32 + x461, x462 = bits.Add32(x413, x445, uint32(uint1(x460))) + var x463 uint32 + var x464 uint32 + x463, x464 = bits.Add32(x415, x447, uint32(uint1(x462))) + var x465 uint32 + var x466 uint32 + x465, x466 = bits.Add32(x417, x449, uint32(uint1(x464))) + var x467 uint32 + var x468 uint32 + x467, x468 = bits.Add32(x419, x451, uint32(uint1(x466))) + var x469 uint32 + var x470 uint32 + x469, x470 = bits.Add32(x421, x453, uint32(uint1(x468))) + var x471 uint32 + var x472 uint32 + x471, x472 = bits.Add32(((uint32(uint1(x422)) + uint32(uint1(x376))) + (uint32(uint1(x406)) + x378)), (uint32(uint1(x454)) + x426), uint32(uint1(x470))) + var x473 uint32 + var x474 uint32 + x474, x473 = bits.Mul32(x5, 0x9d671cd5) + var x475 uint32 + var x476 uint32 + x476, x475 = bits.Mul32(x5, 0x81c69bc5) + var x477 uint32 + var x478 uint32 + x478, x477 = bits.Mul32(x5, 0xe697f5e4) + var x479 uint32 + var x480 uint32 + x480, x479 = bits.Mul32(x5, 0x5bcd07c6) + var x481 uint32 + var x482 uint32 + x482, x481 = bits.Mul32(x5, 0x741496c2) + var x483 uint32 + var x484 uint32 + x484, x483 = bits.Mul32(x5, 0xe7cf878) + var x485 uint32 + var x486 uint32 + x486, x485 = bits.Mul32(x5, 0x896cf214) + var x487 uint32 + var x488 uint32 + x488, x487 = bits.Mul32(x5, 0x67d7d140) + var x489 uint32 + var x490 uint32 + x489, x490 = bits.Add32(x488, x485, uint32(0x0)) + var x491 uint32 + var x492 uint32 + x491, x492 = bits.Add32(x486, x483, uint32(uint1(x490))) + var x493 uint32 + var x494 uint32 + x493, x494 = bits.Add32(x484, x481, uint32(uint1(x492))) + var x495 uint32 + var x496 uint32 + x495, x496 = bits.Add32(x482, x479, uint32(uint1(x494))) + var x497 uint32 + var x498 uint32 + x497, x498 = bits.Add32(x480, x477, uint32(uint1(x496))) + var x499 uint32 + var x500 uint32 + x499, x500 = bits.Add32(x478, x475, uint32(uint1(x498))) + var x501 uint32 + var x502 uint32 + x501, x502 = bits.Add32(x476, x473, uint32(uint1(x500))) + var x503 uint32 + var x504 uint32 + x503, x504 = bits.Add32(x457, x487, uint32(0x0)) + var x505 uint32 + var x506 uint32 + x505, x506 = bits.Add32(x459, x489, uint32(uint1(x504))) + var x507 uint32 + var x508 uint32 + x507, x508 = bits.Add32(x461, x491, uint32(uint1(x506))) + var x509 uint32 + var x510 uint32 + x509, x510 = bits.Add32(x463, x493, uint32(uint1(x508))) + var x511 uint32 + var x512 uint32 + x511, x512 = bits.Add32(x465, x495, uint32(uint1(x510))) + var x513 uint32 + var x514 uint32 + x513, x514 = bits.Add32(x467, x497, uint32(uint1(x512))) + var x515 uint32 + var x516 uint32 + x515, x516 = bits.Add32(x469, x499, uint32(uint1(x514))) + var x517 uint32 + var x518 uint32 + x517, x518 = bits.Add32(x471, x501, uint32(uint1(x516))) + var x519 uint32 + _, x519 = bits.Mul32(x503, 0x5588b13f) + var x521 uint32 + var x522 uint32 + x522, x521 = bits.Mul32(x519, 0xffffffff) + var x523 uint32 + var x524 uint32 + x524, x523 = bits.Mul32(x519, 0xffffffff) + var x525 uint32 + var x526 uint32 + x526, x525 = bits.Mul32(x519, 0xffffffff) + var x527 uint32 + var x528 uint32 + x528, x527 = bits.Mul32(x519, 0xfffffffe) + var x529 uint32 + var x530 uint32 + x530, x529 = bits.Mul32(x519, 0xbaaedce6) + var x531 uint32 + var x532 uint32 + x532, x531 = bits.Mul32(x519, 0xaf48a03b) + var x533 uint32 + var x534 uint32 + x534, x533 = bits.Mul32(x519, 0xbfd25e8c) + var x535 uint32 + var x536 uint32 + x536, x535 = bits.Mul32(x519, 0xd0364141) + var x537 uint32 + var x538 uint32 + x537, x538 = bits.Add32(x536, x533, uint32(0x0)) + var x539 uint32 + var x540 uint32 + x539, x540 = bits.Add32(x534, x531, uint32(uint1(x538))) + var x541 uint32 + var x542 uint32 + x541, x542 = bits.Add32(x532, x529, uint32(uint1(x540))) + var x543 uint32 + var x544 uint32 + x543, x544 = bits.Add32(x530, x527, uint32(uint1(x542))) + var x545 uint32 + var x546 uint32 + x545, x546 = bits.Add32(x528, x525, uint32(uint1(x544))) + var x547 uint32 + var x548 uint32 + x547, x548 = bits.Add32(x526, x523, uint32(uint1(x546))) + var x549 uint32 + var x550 uint32 + x549, x550 = bits.Add32(x524, x521, uint32(uint1(x548))) + var x552 uint32 + _, x552 = bits.Add32(x503, x535, uint32(0x0)) + var x553 uint32 + var x554 uint32 + x553, x554 = bits.Add32(x505, x537, uint32(uint1(x552))) + var x555 uint32 + var x556 uint32 + x555, x556 = bits.Add32(x507, x539, uint32(uint1(x554))) + var x557 uint32 + var x558 uint32 + x557, x558 = bits.Add32(x509, x541, uint32(uint1(x556))) + var x559 uint32 + var x560 uint32 + x559, x560 = bits.Add32(x511, x543, uint32(uint1(x558))) + var x561 uint32 + var x562 uint32 + x561, x562 = bits.Add32(x513, x545, uint32(uint1(x560))) + var x563 uint32 + var x564 uint32 + x563, x564 = bits.Add32(x515, x547, uint32(uint1(x562))) + var x565 uint32 + var x566 uint32 + x565, x566 = bits.Add32(x517, x549, uint32(uint1(x564))) + var x567 uint32 + var x568 uint32 + x567, x568 = bits.Add32(((uint32(uint1(x518)) + uint32(uint1(x472))) + (uint32(uint1(x502)) + x474)), (uint32(uint1(x550)) + x522), uint32(uint1(x566))) + var x569 uint32 + var x570 uint32 + x570, x569 = bits.Mul32(x6, 0x9d671cd5) + var x571 uint32 + var x572 uint32 + x572, x571 = bits.Mul32(x6, 0x81c69bc5) + var x573 uint32 + var x574 uint32 + x574, x573 = bits.Mul32(x6, 0xe697f5e4) + var x575 uint32 + var x576 uint32 + x576, x575 = bits.Mul32(x6, 0x5bcd07c6) + var x577 uint32 + var x578 uint32 + x578, x577 = bits.Mul32(x6, 0x741496c2) + var x579 uint32 + var x580 uint32 + x580, x579 = bits.Mul32(x6, 0xe7cf878) + var x581 uint32 + var x582 uint32 + x582, x581 = bits.Mul32(x6, 0x896cf214) + var x583 uint32 + var x584 uint32 + x584, x583 = bits.Mul32(x6, 0x67d7d140) + var x585 uint32 + var x586 uint32 + x585, x586 = bits.Add32(x584, x581, uint32(0x0)) + var x587 uint32 + var x588 uint32 + x587, x588 = bits.Add32(x582, x579, uint32(uint1(x586))) + var x589 uint32 + var x590 uint32 + x589, x590 = bits.Add32(x580, x577, uint32(uint1(x588))) + var x591 uint32 + var x592 uint32 + x591, x592 = bits.Add32(x578, x575, uint32(uint1(x590))) + var x593 uint32 + var x594 uint32 + x593, x594 = bits.Add32(x576, x573, uint32(uint1(x592))) + var x595 uint32 + var x596 uint32 + x595, x596 = bits.Add32(x574, x571, uint32(uint1(x594))) + var x597 uint32 + var x598 uint32 + x597, x598 = bits.Add32(x572, x569, uint32(uint1(x596))) + var x599 uint32 + var x600 uint32 + x599, x600 = bits.Add32(x553, x583, uint32(0x0)) + var x601 uint32 + var x602 uint32 + x601, x602 = bits.Add32(x555, x585, uint32(uint1(x600))) + var x603 uint32 + var x604 uint32 + x603, x604 = bits.Add32(x557, x587, uint32(uint1(x602))) + var x605 uint32 + var x606 uint32 + x605, x606 = bits.Add32(x559, x589, uint32(uint1(x604))) + var x607 uint32 + var x608 uint32 + x607, x608 = bits.Add32(x561, x591, uint32(uint1(x606))) + var x609 uint32 + var x610 uint32 + x609, x610 = bits.Add32(x563, x593, uint32(uint1(x608))) + var x611 uint32 + var x612 uint32 + x611, x612 = bits.Add32(x565, x595, uint32(uint1(x610))) + var x613 uint32 + var x614 uint32 + x613, x614 = bits.Add32(x567, x597, uint32(uint1(x612))) + var x615 uint32 + _, x615 = bits.Mul32(x599, 0x5588b13f) + var x617 uint32 + var x618 uint32 + x618, x617 = bits.Mul32(x615, 0xffffffff) + var x619 uint32 + var x620 uint32 + x620, x619 = bits.Mul32(x615, 0xffffffff) + var x621 uint32 + var x622 uint32 + x622, x621 = bits.Mul32(x615, 0xffffffff) + var x623 uint32 + var x624 uint32 + x624, x623 = bits.Mul32(x615, 0xfffffffe) + var x625 uint32 + var x626 uint32 + x626, x625 = bits.Mul32(x615, 0xbaaedce6) + var x627 uint32 + var x628 uint32 + x628, x627 = bits.Mul32(x615, 0xaf48a03b) + var x629 uint32 + var x630 uint32 + x630, x629 = bits.Mul32(x615, 0xbfd25e8c) + var x631 uint32 + var x632 uint32 + x632, x631 = bits.Mul32(x615, 0xd0364141) + var x633 uint32 + var x634 uint32 + x633, x634 = bits.Add32(x632, x629, uint32(0x0)) + var x635 uint32 + var x636 uint32 + x635, x636 = bits.Add32(x630, x627, uint32(uint1(x634))) + var x637 uint32 + var x638 uint32 + x637, x638 = bits.Add32(x628, x625, uint32(uint1(x636))) + var x639 uint32 + var x640 uint32 + x639, x640 = bits.Add32(x626, x623, uint32(uint1(x638))) + var x641 uint32 + var x642 uint32 + x641, x642 = bits.Add32(x624, x621, uint32(uint1(x640))) + var x643 uint32 + var x644 uint32 + x643, x644 = bits.Add32(x622, x619, uint32(uint1(x642))) + var x645 uint32 + var x646 uint32 + x645, x646 = bits.Add32(x620, x617, uint32(uint1(x644))) + var x648 uint32 + _, x648 = bits.Add32(x599, x631, uint32(0x0)) + var x649 uint32 + var x650 uint32 + x649, x650 = bits.Add32(x601, x633, uint32(uint1(x648))) + var x651 uint32 + var x652 uint32 + x651, x652 = bits.Add32(x603, x635, uint32(uint1(x650))) + var x653 uint32 + var x654 uint32 + x653, x654 = bits.Add32(x605, x637, uint32(uint1(x652))) + var x655 uint32 + var x656 uint32 + x655, x656 = bits.Add32(x607, x639, uint32(uint1(x654))) + var x657 uint32 + var x658 uint32 + x657, x658 = bits.Add32(x609, x641, uint32(uint1(x656))) + var x659 uint32 + var x660 uint32 + x659, x660 = bits.Add32(x611, x643, uint32(uint1(x658))) + var x661 uint32 + var x662 uint32 + x661, x662 = bits.Add32(x613, x645, uint32(uint1(x660))) + var x663 uint32 + var x664 uint32 + x663, x664 = bits.Add32(((uint32(uint1(x614)) + uint32(uint1(x568))) + (uint32(uint1(x598)) + x570)), (uint32(uint1(x646)) + x618), uint32(uint1(x662))) + var x665 uint32 + var x666 uint32 + x666, x665 = bits.Mul32(x7, 0x9d671cd5) + var x667 uint32 + var x668 uint32 + x668, x667 = bits.Mul32(x7, 0x81c69bc5) + var x669 uint32 + var x670 uint32 + x670, x669 = bits.Mul32(x7, 0xe697f5e4) + var x671 uint32 + var x672 uint32 + x672, x671 = bits.Mul32(x7, 0x5bcd07c6) + var x673 uint32 + var x674 uint32 + x674, x673 = bits.Mul32(x7, 0x741496c2) + var x675 uint32 + var x676 uint32 + x676, x675 = bits.Mul32(x7, 0xe7cf878) + var x677 uint32 + var x678 uint32 + x678, x677 = bits.Mul32(x7, 0x896cf214) + var x679 uint32 + var x680 uint32 + x680, x679 = bits.Mul32(x7, 0x67d7d140) + var x681 uint32 + var x682 uint32 + x681, x682 = bits.Add32(x680, x677, uint32(0x0)) + var x683 uint32 + var x684 uint32 + x683, x684 = bits.Add32(x678, x675, uint32(uint1(x682))) + var x685 uint32 + var x686 uint32 + x685, x686 = bits.Add32(x676, x673, uint32(uint1(x684))) + var x687 uint32 + var x688 uint32 + x687, x688 = bits.Add32(x674, x671, uint32(uint1(x686))) + var x689 uint32 + var x690 uint32 + x689, x690 = bits.Add32(x672, x669, uint32(uint1(x688))) + var x691 uint32 + var x692 uint32 + x691, x692 = bits.Add32(x670, x667, uint32(uint1(x690))) + var x693 uint32 + var x694 uint32 + x693, x694 = bits.Add32(x668, x665, uint32(uint1(x692))) + var x695 uint32 + var x696 uint32 + x695, x696 = bits.Add32(x649, x679, uint32(0x0)) + var x697 uint32 + var x698 uint32 + x697, x698 = bits.Add32(x651, x681, uint32(uint1(x696))) + var x699 uint32 + var x700 uint32 + x699, x700 = bits.Add32(x653, x683, uint32(uint1(x698))) + var x701 uint32 + var x702 uint32 + x701, x702 = bits.Add32(x655, x685, uint32(uint1(x700))) + var x703 uint32 + var x704 uint32 + x703, x704 = bits.Add32(x657, x687, uint32(uint1(x702))) + var x705 uint32 + var x706 uint32 + x705, x706 = bits.Add32(x659, x689, uint32(uint1(x704))) + var x707 uint32 + var x708 uint32 + x707, x708 = bits.Add32(x661, x691, uint32(uint1(x706))) + var x709 uint32 + var x710 uint32 + x709, x710 = bits.Add32(x663, x693, uint32(uint1(x708))) + var x711 uint32 + _, x711 = bits.Mul32(x695, 0x5588b13f) + var x713 uint32 + var x714 uint32 + x714, x713 = bits.Mul32(x711, 0xffffffff) + var x715 uint32 + var x716 uint32 + x716, x715 = bits.Mul32(x711, 0xffffffff) + var x717 uint32 + var x718 uint32 + x718, x717 = bits.Mul32(x711, 0xffffffff) + var x719 uint32 + var x720 uint32 + x720, x719 = bits.Mul32(x711, 0xfffffffe) + var x721 uint32 + var x722 uint32 + x722, x721 = bits.Mul32(x711, 0xbaaedce6) + var x723 uint32 + var x724 uint32 + x724, x723 = bits.Mul32(x711, 0xaf48a03b) + var x725 uint32 + var x726 uint32 + x726, x725 = bits.Mul32(x711, 0xbfd25e8c) + var x727 uint32 + var x728 uint32 + x728, x727 = bits.Mul32(x711, 0xd0364141) + var x729 uint32 + var x730 uint32 + x729, x730 = bits.Add32(x728, x725, uint32(0x0)) + var x731 uint32 + var x732 uint32 + x731, x732 = bits.Add32(x726, x723, uint32(uint1(x730))) + var x733 uint32 + var x734 uint32 + x733, x734 = bits.Add32(x724, x721, uint32(uint1(x732))) + var x735 uint32 + var x736 uint32 + x735, x736 = bits.Add32(x722, x719, uint32(uint1(x734))) + var x737 uint32 + var x738 uint32 + x737, x738 = bits.Add32(x720, x717, uint32(uint1(x736))) + var x739 uint32 + var x740 uint32 + x739, x740 = bits.Add32(x718, x715, uint32(uint1(x738))) + var x741 uint32 + var x742 uint32 + x741, x742 = bits.Add32(x716, x713, uint32(uint1(x740))) + var x744 uint32 + _, x744 = bits.Add32(x695, x727, uint32(0x0)) + var x745 uint32 + var x746 uint32 + x745, x746 = bits.Add32(x697, x729, uint32(uint1(x744))) + var x747 uint32 + var x748 uint32 + x747, x748 = bits.Add32(x699, x731, uint32(uint1(x746))) + var x749 uint32 + var x750 uint32 + x749, x750 = bits.Add32(x701, x733, uint32(uint1(x748))) + var x751 uint32 + var x752 uint32 + x751, x752 = bits.Add32(x703, x735, uint32(uint1(x750))) + var x753 uint32 + var x754 uint32 + x753, x754 = bits.Add32(x705, x737, uint32(uint1(x752))) + var x755 uint32 + var x756 uint32 + x755, x756 = bits.Add32(x707, x739, uint32(uint1(x754))) + var x757 uint32 + var x758 uint32 + x757, x758 = bits.Add32(x709, x741, uint32(uint1(x756))) + var x759 uint32 + var x760 uint32 + x759, x760 = bits.Add32(((uint32(uint1(x710)) + uint32(uint1(x664))) + (uint32(uint1(x694)) + x666)), (uint32(uint1(x742)) + x714), uint32(uint1(x758))) + var x761 uint32 + var x762 uint32 + x761, x762 = bits.Sub32(x745, 0xd0364141, uint32(0x0)) + var x763 uint32 + var x764 uint32 + x763, x764 = bits.Sub32(x747, 0xbfd25e8c, uint32(uint1(x762))) + var x765 uint32 + var x766 uint32 + x765, x766 = bits.Sub32(x749, 0xaf48a03b, uint32(uint1(x764))) + var x767 uint32 + var x768 uint32 + x767, x768 = bits.Sub32(x751, 0xbaaedce6, uint32(uint1(x766))) + var x769 uint32 + var x770 uint32 + x769, x770 = bits.Sub32(x753, 0xfffffffe, uint32(uint1(x768))) + var x771 uint32 + var x772 uint32 + x771, x772 = bits.Sub32(x755, 0xffffffff, uint32(uint1(x770))) + var x773 uint32 + var x774 uint32 + x773, x774 = bits.Sub32(x757, 0xffffffff, uint32(uint1(x772))) + var x775 uint32 + var x776 uint32 + x775, x776 = bits.Sub32(x759, 0xffffffff, uint32(uint1(x774))) + var x778 uint32 + _, x778 = bits.Sub32(uint32(uint1(x760)), uint32(0x0), uint32(uint1(x776))) + var x779 uint32 + cmovznzU32(&x779, uint1(x778), x761, x745) + var x780 uint32 + cmovznzU32(&x780, uint1(x778), x763, x747) + var x781 uint32 + cmovznzU32(&x781, uint1(x778), x765, x749) + var x782 uint32 + cmovznzU32(&x782, uint1(x778), x767, x751) + var x783 uint32 + cmovznzU32(&x783, uint1(x778), x769, x753) + var x784 uint32 + cmovznzU32(&x784, uint1(x778), x771, x755) + var x785 uint32 + cmovznzU32(&x785, uint1(x778), x773, x757) + var x786 uint32 + cmovznzU32(&x786, uint1(x778), x775, x759) + out1[0] = x779 + out1[1] = x780 + out1[2] = x781 + out1[3] = x782 + out1[4] = x783 + out1[5] = x784 + out1[6] = x785 + out1[7] = x786 +} + +// Nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffff] +func Nonzero(out1 *uint32, arg1 *[8]uint32) { + x1 := (arg1[0] | (arg1[1] | (arg1[2] | (arg1[3] | (arg1[4] | (arg1[5] | (arg1[6] | arg1[7]))))))) + *out1 = x1 +} + +// Selectznz is a multi-limb conditional select. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func Selectznz(out1 *[8]uint32, arg1 uint1, arg2 *[8]uint32, arg3 *[8]uint32) { + var x1 uint32 + cmovznzU32(&x1, arg1, arg2[0], arg3[0]) + var x2 uint32 + cmovznzU32(&x2, arg1, arg2[1], arg3[1]) + var x3 uint32 + cmovznzU32(&x3, arg1, arg2[2], arg3[2]) + var x4 uint32 + cmovznzU32(&x4, arg1, arg2[3], arg3[3]) + var x5 uint32 + cmovznzU32(&x5, arg1, arg2[4], arg3[4]) + var x6 uint32 + cmovznzU32(&x6, arg1, arg2[5], arg3[5]) + var x7 uint32 + cmovznzU32(&x7, arg1, arg2[6], arg3[6]) + var x8 uint32 + cmovznzU32(&x8, arg1, arg2[7], arg3[7]) + out1[0] = x1 + out1[1] = x2 + out1[2] = x3 + out1[3] = x4 + out1[4] = x5 + out1[5] = x6 + out1[6] = x7 + out1[7] = x8 +} + +// ToBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +func ToBytes(out1 *[32]uint8, arg1 *[8]uint32) { + x1 := arg1[7] + x2 := arg1[6] + x3 := arg1[5] + x4 := arg1[4] + x5 := arg1[3] + x6 := arg1[2] + x7 := arg1[1] + x8 := arg1[0] + x9 := (uint8(x8) & 0xff) + x10 := (x8 >> 8) + x11 := (uint8(x10) & 0xff) + x12 := (x10 >> 8) + x13 := (uint8(x12) & 0xff) + x14 := uint8((x12 >> 8)) + x15 := (uint8(x7) & 0xff) + x16 := (x7 >> 8) + x17 := (uint8(x16) & 0xff) + x18 := (x16 >> 8) + x19 := (uint8(x18) & 0xff) + x20 := uint8((x18 >> 8)) + x21 := (uint8(x6) & 0xff) + x22 := (x6 >> 8) + x23 := (uint8(x22) & 0xff) + x24 := (x22 >> 8) + x25 := (uint8(x24) & 0xff) + x26 := uint8((x24 >> 8)) + x27 := (uint8(x5) & 0xff) + x28 := (x5 >> 8) + x29 := (uint8(x28) & 0xff) + x30 := (x28 >> 8) + x31 := (uint8(x30) & 0xff) + x32 := uint8((x30 >> 8)) + x33 := (uint8(x4) & 0xff) + x34 := (x4 >> 8) + x35 := (uint8(x34) & 0xff) + x36 := (x34 >> 8) + x37 := (uint8(x36) & 0xff) + x38 := uint8((x36 >> 8)) + x39 := (uint8(x3) & 0xff) + x40 := (x3 >> 8) + x41 := (uint8(x40) & 0xff) + x42 := (x40 >> 8) + x43 := (uint8(x42) & 0xff) + x44 := uint8((x42 >> 8)) + x45 := (uint8(x2) & 0xff) + x46 := (x2 >> 8) + x47 := (uint8(x46) & 0xff) + x48 := (x46 >> 8) + x49 := (uint8(x48) & 0xff) + x50 := uint8((x48 >> 8)) + x51 := (uint8(x1) & 0xff) + x52 := (x1 >> 8) + x53 := (uint8(x52) & 0xff) + x54 := (x52 >> 8) + x55 := (uint8(x54) & 0xff) + x56 := uint8((x54 >> 8)) + out1[0] = x9 + out1[1] = x11 + out1[2] = x13 + out1[3] = x14 + out1[4] = x15 + out1[5] = x17 + out1[6] = x19 + out1[7] = x20 + out1[8] = x21 + out1[9] = x23 + out1[10] = x25 + out1[11] = x26 + out1[12] = x27 + out1[13] = x29 + out1[14] = x31 + out1[15] = x32 + out1[16] = x33 + out1[17] = x35 + out1[18] = x37 + out1[19] = x38 + out1[20] = x39 + out1[21] = x41 + out1[22] = x43 + out1[23] = x44 + out1[24] = x45 + out1[25] = x47 + out1[26] = x49 + out1[27] = x50 + out1[28] = x51 + out1[29] = x53 + out1[30] = x55 + out1[31] = x56 +} + +// FromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +// +// Preconditions: +// 0 ≤ bytes_eval arg1 < m +// Postconditions: +// eval out1 mod m = bytes_eval arg1 mod m +// 0 ≤ eval out1 < m +// +// Input Bounds: +// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func FromBytes(out1 *[8]uint32, arg1 *[32]uint8) { + x1 := (uint32(arg1[31]) << 24) + x2 := (uint32(arg1[30]) << 16) + x3 := (uint32(arg1[29]) << 8) + x4 := arg1[28] + x5 := (uint32(arg1[27]) << 24) + x6 := (uint32(arg1[26]) << 16) + x7 := (uint32(arg1[25]) << 8) + x8 := arg1[24] + x9 := (uint32(arg1[23]) << 24) + x10 := (uint32(arg1[22]) << 16) + x11 := (uint32(arg1[21]) << 8) + x12 := arg1[20] + x13 := (uint32(arg1[19]) << 24) + x14 := (uint32(arg1[18]) << 16) + x15 := (uint32(arg1[17]) << 8) + x16 := arg1[16] + x17 := (uint32(arg1[15]) << 24) + x18 := (uint32(arg1[14]) << 16) + x19 := (uint32(arg1[13]) << 8) + x20 := arg1[12] + x21 := (uint32(arg1[11]) << 24) + x22 := (uint32(arg1[10]) << 16) + x23 := (uint32(arg1[9]) << 8) + x24 := arg1[8] + x25 := (uint32(arg1[7]) << 24) + x26 := (uint32(arg1[6]) << 16) + x27 := (uint32(arg1[5]) << 8) + x28 := arg1[4] + x29 := (uint32(arg1[3]) << 24) + x30 := (uint32(arg1[2]) << 16) + x31 := (uint32(arg1[1]) << 8) + x32 := arg1[0] + x33 := (x31 + uint32(x32)) + x34 := (x30 + x33) + x35 := (x29 + x34) + x36 := (x27 + uint32(x28)) + x37 := (x26 + x36) + x38 := (x25 + x37) + x39 := (x23 + uint32(x24)) + x40 := (x22 + x39) + x41 := (x21 + x40) + x42 := (x19 + uint32(x20)) + x43 := (x18 + x42) + x44 := (x17 + x43) + x45 := (x15 + uint32(x16)) + x46 := (x14 + x45) + x47 := (x13 + x46) + x48 := (x11 + uint32(x12)) + x49 := (x10 + x48) + x50 := (x9 + x49) + x51 := (x7 + uint32(x8)) + x52 := (x6 + x51) + x53 := (x5 + x52) + x54 := (x3 + uint32(x4)) + x55 := (x2 + x54) + x56 := (x1 + x55) + out1[0] = x35 + out1[1] = x38 + out1[2] = x41 + out1[3] = x44 + out1[4] = x47 + out1[5] = x50 + out1[6] = x53 + out1[7] = x56 +} + +// SetOne returns the field element one in the Montgomery domain. +// +// Postconditions: +// eval (from_montgomery out1) mod m = 1 mod m +// 0 ≤ eval out1 < m +// +func SetOne(out1 *MontgomeryDomainFieldElement) { + out1[0] = 0x2fc9bebf + out1[1] = 0x402da173 + out1[2] = 0x50b75fc4 + out1[3] = 0x45512319 + out1[4] = uint32(0x1) + out1[5] = uint32(0x0) + out1[6] = uint32(0x0) + out1[7] = uint32(0x0) +} + +// Msat returns the saturated representation of the prime modulus. +// +// Postconditions: +// twos_complement_eval out1 = m +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func Msat(out1 *[9]uint32) { + out1[0] = 0xd0364141 + out1[1] = 0xbfd25e8c + out1[2] = 0xaf48a03b + out1[3] = 0xbaaedce6 + out1[4] = 0xfffffffe + out1[5] = 0xffffffff + out1[6] = 0xffffffff + out1[7] = 0xffffffff + out1[8] = uint32(0x0) +} + +// Divstep computes a divstep. +// +// Preconditions: +// 0 ≤ eval arg4 < m +// 0 ≤ eval arg5 < m +// Postconditions: +// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +// 0 ≤ eval out5 < m +// 0 ≤ eval out5 < m +// 0 ≤ eval out2 < m +// 0 ≤ eval out3 < m +// +// Input Bounds: +// arg1: [0x0 ~> 0xffffffff] +// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffff] +// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func Divstep(out1 *uint32, out2 *[9]uint32, out3 *[9]uint32, out4 *[8]uint32, out5 *[8]uint32, arg1 uint32, arg2 *[9]uint32, arg3 *[9]uint32, arg4 *[8]uint32, arg5 *[8]uint32) { + var x1 uint32 + x1, _ = bits.Add32((^arg1), uint32(0x1), uint32(0x0)) + x3 := (uint1((x1 >> 31)) & (uint1(arg3[0]) & 0x1)) + var x4 uint32 + x4, _ = bits.Add32((^arg1), uint32(0x1), uint32(0x0)) + var x6 uint32 + cmovznzU32(&x6, x3, arg1, x4) + var x7 uint32 + cmovznzU32(&x7, x3, arg2[0], arg3[0]) + var x8 uint32 + cmovznzU32(&x8, x3, arg2[1], arg3[1]) + var x9 uint32 + cmovznzU32(&x9, x3, arg2[2], arg3[2]) + var x10 uint32 + cmovznzU32(&x10, x3, arg2[3], arg3[3]) + var x11 uint32 + cmovznzU32(&x11, x3, arg2[4], arg3[4]) + var x12 uint32 + cmovznzU32(&x12, x3, arg2[5], arg3[5]) + var x13 uint32 + cmovznzU32(&x13, x3, arg2[6], arg3[6]) + var x14 uint32 + cmovznzU32(&x14, x3, arg2[7], arg3[7]) + var x15 uint32 + cmovznzU32(&x15, x3, arg2[8], arg3[8]) + var x16 uint32 + var x17 uint32 + x16, x17 = bits.Add32(uint32(0x1), (^arg2[0]), uint32(0x0)) + var x18 uint32 + var x19 uint32 + x18, x19 = bits.Add32(uint32(0x0), (^arg2[1]), uint32(uint1(x17))) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(uint32(0x0), (^arg2[2]), uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(uint32(0x0), (^arg2[3]), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(uint32(0x0), (^arg2[4]), uint32(uint1(x23))) + var x26 uint32 + var x27 uint32 + x26, x27 = bits.Add32(uint32(0x0), (^arg2[5]), uint32(uint1(x25))) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(uint32(0x0), (^arg2[6]), uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(uint32(0x0), (^arg2[7]), uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(uint32(0x0), (^arg2[8]), uint32(uint1(x31))) + var x34 uint32 + cmovznzU32(&x34, x3, arg3[0], x16) + var x35 uint32 + cmovznzU32(&x35, x3, arg3[1], x18) + var x36 uint32 + cmovznzU32(&x36, x3, arg3[2], x20) + var x37 uint32 + cmovznzU32(&x37, x3, arg3[3], x22) + var x38 uint32 + cmovznzU32(&x38, x3, arg3[4], x24) + var x39 uint32 + cmovznzU32(&x39, x3, arg3[5], x26) + var x40 uint32 + cmovznzU32(&x40, x3, arg3[6], x28) + var x41 uint32 + cmovznzU32(&x41, x3, arg3[7], x30) + var x42 uint32 + cmovznzU32(&x42, x3, arg3[8], x32) + var x43 uint32 + cmovznzU32(&x43, x3, arg4[0], arg5[0]) + var x44 uint32 + cmovznzU32(&x44, x3, arg4[1], arg5[1]) + var x45 uint32 + cmovznzU32(&x45, x3, arg4[2], arg5[2]) + var x46 uint32 + cmovznzU32(&x46, x3, arg4[3], arg5[3]) + var x47 uint32 + cmovznzU32(&x47, x3, arg4[4], arg5[4]) + var x48 uint32 + cmovznzU32(&x48, x3, arg4[5], arg5[5]) + var x49 uint32 + cmovznzU32(&x49, x3, arg4[6], arg5[6]) + var x50 uint32 + cmovznzU32(&x50, x3, arg4[7], arg5[7]) + var x51 uint32 + var x52 uint32 + x51, x52 = bits.Add32(x43, x43, uint32(0x0)) + var x53 uint32 + var x54 uint32 + x53, x54 = bits.Add32(x44, x44, uint32(uint1(x52))) + var x55 uint32 + var x56 uint32 + x55, x56 = bits.Add32(x45, x45, uint32(uint1(x54))) + var x57 uint32 + var x58 uint32 + x57, x58 = bits.Add32(x46, x46, uint32(uint1(x56))) + var x59 uint32 + var x60 uint32 + x59, x60 = bits.Add32(x47, x47, uint32(uint1(x58))) + var x61 uint32 + var x62 uint32 + x61, x62 = bits.Add32(x48, x48, uint32(uint1(x60))) + var x63 uint32 + var x64 uint32 + x63, x64 = bits.Add32(x49, x49, uint32(uint1(x62))) + var x65 uint32 + var x66 uint32 + x65, x66 = bits.Add32(x50, x50, uint32(uint1(x64))) + var x67 uint32 + var x68 uint32 + x67, x68 = bits.Sub32(x51, 0xd0364141, uint32(0x0)) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Sub32(x53, 0xbfd25e8c, uint32(uint1(x68))) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Sub32(x55, 0xaf48a03b, uint32(uint1(x70))) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Sub32(x57, 0xbaaedce6, uint32(uint1(x72))) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Sub32(x59, 0xfffffffe, uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x77, x78 = bits.Sub32(x61, 0xffffffff, uint32(uint1(x76))) + var x79 uint32 + var x80 uint32 + x79, x80 = bits.Sub32(x63, 0xffffffff, uint32(uint1(x78))) + var x81 uint32 + var x82 uint32 + x81, x82 = bits.Sub32(x65, 0xffffffff, uint32(uint1(x80))) + var x84 uint32 + _, x84 = bits.Sub32(uint32(uint1(x66)), uint32(0x0), uint32(uint1(x82))) + x85 := arg4[7] + x86 := arg4[6] + x87 := arg4[5] + x88 := arg4[4] + x89 := arg4[3] + x90 := arg4[2] + x91 := arg4[1] + x92 := arg4[0] + var x93 uint32 + var x94 uint32 + x93, x94 = bits.Sub32(uint32(0x0), x92, uint32(0x0)) + var x95 uint32 + var x96 uint32 + x95, x96 = bits.Sub32(uint32(0x0), x91, uint32(uint1(x94))) + var x97 uint32 + var x98 uint32 + x97, x98 = bits.Sub32(uint32(0x0), x90, uint32(uint1(x96))) + var x99 uint32 + var x100 uint32 + x99, x100 = bits.Sub32(uint32(0x0), x89, uint32(uint1(x98))) + var x101 uint32 + var x102 uint32 + x101, x102 = bits.Sub32(uint32(0x0), x88, uint32(uint1(x100))) + var x103 uint32 + var x104 uint32 + x103, x104 = bits.Sub32(uint32(0x0), x87, uint32(uint1(x102))) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Sub32(uint32(0x0), x86, uint32(uint1(x104))) + var x107 uint32 + var x108 uint32 + x107, x108 = bits.Sub32(uint32(0x0), x85, uint32(uint1(x106))) + var x109 uint32 + cmovznzU32(&x109, uint1(x108), uint32(0x0), 0xffffffff) + var x110 uint32 + var x111 uint32 + x110, x111 = bits.Add32(x93, (x109 & 0xd0364141), uint32(0x0)) + var x112 uint32 + var x113 uint32 + x112, x113 = bits.Add32(x95, (x109 & 0xbfd25e8c), uint32(uint1(x111))) + var x114 uint32 + var x115 uint32 + x114, x115 = bits.Add32(x97, (x109 & 0xaf48a03b), uint32(uint1(x113))) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32(x99, (x109 & 0xbaaedce6), uint32(uint1(x115))) + var x118 uint32 + var x119 uint32 + x118, x119 = bits.Add32(x101, (x109 & 0xfffffffe), uint32(uint1(x117))) + var x120 uint32 + var x121 uint32 + x120, x121 = bits.Add32(x103, x109, uint32(uint1(x119))) + var x122 uint32 + var x123 uint32 + x122, x123 = bits.Add32(x105, x109, uint32(uint1(x121))) + var x124 uint32 + x124, _ = bits.Add32(x107, x109, uint32(uint1(x123))) + var x126 uint32 + cmovznzU32(&x126, x3, arg5[0], x110) + var x127 uint32 + cmovznzU32(&x127, x3, arg5[1], x112) + var x128 uint32 + cmovznzU32(&x128, x3, arg5[2], x114) + var x129 uint32 + cmovznzU32(&x129, x3, arg5[3], x116) + var x130 uint32 + cmovznzU32(&x130, x3, arg5[4], x118) + var x131 uint32 + cmovznzU32(&x131, x3, arg5[5], x120) + var x132 uint32 + cmovznzU32(&x132, x3, arg5[6], x122) + var x133 uint32 + cmovznzU32(&x133, x3, arg5[7], x124) + x134 := (uint1(x34) & 0x1) + var x135 uint32 + cmovznzU32(&x135, x134, uint32(0x0), x7) + var x136 uint32 + cmovznzU32(&x136, x134, uint32(0x0), x8) + var x137 uint32 + cmovznzU32(&x137, x134, uint32(0x0), x9) + var x138 uint32 + cmovznzU32(&x138, x134, uint32(0x0), x10) + var x139 uint32 + cmovznzU32(&x139, x134, uint32(0x0), x11) + var x140 uint32 + cmovznzU32(&x140, x134, uint32(0x0), x12) + var x141 uint32 + cmovznzU32(&x141, x134, uint32(0x0), x13) + var x142 uint32 + cmovznzU32(&x142, x134, uint32(0x0), x14) + var x143 uint32 + cmovznzU32(&x143, x134, uint32(0x0), x15) + var x144 uint32 + var x145 uint32 + x144, x145 = bits.Add32(x34, x135, uint32(0x0)) + var x146 uint32 + var x147 uint32 + x146, x147 = bits.Add32(x35, x136, uint32(uint1(x145))) + var x148 uint32 + var x149 uint32 + x148, x149 = bits.Add32(x36, x137, uint32(uint1(x147))) + var x150 uint32 + var x151 uint32 + x150, x151 = bits.Add32(x37, x138, uint32(uint1(x149))) + var x152 uint32 + var x153 uint32 + x152, x153 = bits.Add32(x38, x139, uint32(uint1(x151))) + var x154 uint32 + var x155 uint32 + x154, x155 = bits.Add32(x39, x140, uint32(uint1(x153))) + var x156 uint32 + var x157 uint32 + x156, x157 = bits.Add32(x40, x141, uint32(uint1(x155))) + var x158 uint32 + var x159 uint32 + x158, x159 = bits.Add32(x41, x142, uint32(uint1(x157))) + var x160 uint32 + x160, _ = bits.Add32(x42, x143, uint32(uint1(x159))) + var x162 uint32 + cmovznzU32(&x162, x134, uint32(0x0), x43) + var x163 uint32 + cmovznzU32(&x163, x134, uint32(0x0), x44) + var x164 uint32 + cmovznzU32(&x164, x134, uint32(0x0), x45) + var x165 uint32 + cmovznzU32(&x165, x134, uint32(0x0), x46) + var x166 uint32 + cmovznzU32(&x166, x134, uint32(0x0), x47) + var x167 uint32 + cmovznzU32(&x167, x134, uint32(0x0), x48) + var x168 uint32 + cmovznzU32(&x168, x134, uint32(0x0), x49) + var x169 uint32 + cmovznzU32(&x169, x134, uint32(0x0), x50) + var x170 uint32 + var x171 uint32 + x170, x171 = bits.Add32(x126, x162, uint32(0x0)) + var x172 uint32 + var x173 uint32 + x172, x173 = bits.Add32(x127, x163, uint32(uint1(x171))) + var x174 uint32 + var x175 uint32 + x174, x175 = bits.Add32(x128, x164, uint32(uint1(x173))) + var x176 uint32 + var x177 uint32 + x176, x177 = bits.Add32(x129, x165, uint32(uint1(x175))) + var x178 uint32 + var x179 uint32 + x178, x179 = bits.Add32(x130, x166, uint32(uint1(x177))) + var x180 uint32 + var x181 uint32 + x180, x181 = bits.Add32(x131, x167, uint32(uint1(x179))) + var x182 uint32 + var x183 uint32 + x182, x183 = bits.Add32(x132, x168, uint32(uint1(x181))) + var x184 uint32 + var x185 uint32 + x184, x185 = bits.Add32(x133, x169, uint32(uint1(x183))) + var x186 uint32 + var x187 uint32 + x186, x187 = bits.Sub32(x170, 0xd0364141, uint32(0x0)) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Sub32(x172, 0xbfd25e8c, uint32(uint1(x187))) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Sub32(x174, 0xaf48a03b, uint32(uint1(x189))) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Sub32(x176, 0xbaaedce6, uint32(uint1(x191))) + var x194 uint32 + var x195 uint32 + x194, x195 = bits.Sub32(x178, 0xfffffffe, uint32(uint1(x193))) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Sub32(x180, 0xffffffff, uint32(uint1(x195))) + var x198 uint32 + var x199 uint32 + x198, x199 = bits.Sub32(x182, 0xffffffff, uint32(uint1(x197))) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Sub32(x184, 0xffffffff, uint32(uint1(x199))) + var x203 uint32 + _, x203 = bits.Sub32(uint32(uint1(x185)), uint32(0x0), uint32(uint1(x201))) + var x204 uint32 + x204, _ = bits.Add32(x6, uint32(0x1), uint32(0x0)) + x206 := ((x144 >> 1) | ((x146 << 31) & 0xffffffff)) + x207 := ((x146 >> 1) | ((x148 << 31) & 0xffffffff)) + x208 := ((x148 >> 1) | ((x150 << 31) & 0xffffffff)) + x209 := ((x150 >> 1) | ((x152 << 31) & 0xffffffff)) + x210 := ((x152 >> 1) | ((x154 << 31) & 0xffffffff)) + x211 := ((x154 >> 1) | ((x156 << 31) & 0xffffffff)) + x212 := ((x156 >> 1) | ((x158 << 31) & 0xffffffff)) + x213 := ((x158 >> 1) | ((x160 << 31) & 0xffffffff)) + x214 := ((x160 & 0x80000000) | (x160 >> 1)) + var x215 uint32 + cmovznzU32(&x215, uint1(x84), x67, x51) + var x216 uint32 + cmovznzU32(&x216, uint1(x84), x69, x53) + var x217 uint32 + cmovznzU32(&x217, uint1(x84), x71, x55) + var x218 uint32 + cmovznzU32(&x218, uint1(x84), x73, x57) + var x219 uint32 + cmovznzU32(&x219, uint1(x84), x75, x59) + var x220 uint32 + cmovznzU32(&x220, uint1(x84), x77, x61) + var x221 uint32 + cmovznzU32(&x221, uint1(x84), x79, x63) + var x222 uint32 + cmovznzU32(&x222, uint1(x84), x81, x65) + var x223 uint32 + cmovznzU32(&x223, uint1(x203), x186, x170) + var x224 uint32 + cmovznzU32(&x224, uint1(x203), x188, x172) + var x225 uint32 + cmovznzU32(&x225, uint1(x203), x190, x174) + var x226 uint32 + cmovznzU32(&x226, uint1(x203), x192, x176) + var x227 uint32 + cmovznzU32(&x227, uint1(x203), x194, x178) + var x228 uint32 + cmovznzU32(&x228, uint1(x203), x196, x180) + var x229 uint32 + cmovznzU32(&x229, uint1(x203), x198, x182) + var x230 uint32 + cmovznzU32(&x230, uint1(x203), x200, x184) + *out1 = x204 + out2[0] = x7 + out2[1] = x8 + out2[2] = x9 + out2[3] = x10 + out2[4] = x11 + out2[5] = x12 + out2[6] = x13 + out2[7] = x14 + out2[8] = x15 + out3[0] = x206 + out3[1] = x207 + out3[2] = x208 + out3[3] = x209 + out3[4] = x210 + out3[5] = x211 + out3[6] = x212 + out3[7] = x213 + out3[8] = x214 + out4[0] = x215 + out4[1] = x216 + out4[2] = x217 + out4[3] = x218 + out4[4] = x219 + out4[5] = x220 + out4[6] = x221 + out4[7] = x222 + out5[0] = x223 + out5[1] = x224 + out5[2] = x225 + out5[3] = x226 + out5[4] = x227 + out5[5] = x228 + out5[6] = x229 + out5[7] = x230 +} + +// DivstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +// +// Postconditions: +// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +func DivstepPrecomp(out1 *[8]uint32) { + out1[0] = 0x2b9cb4e9 + out1[1] = 0xd7431a4d + out1[2] = 0x32d9c503 + out1[3] = 0xab67d35a + out1[4] = 0x859ce35f + out1[5] = 0xadf6c7e5 + out1[6] = 0x1df6c379 + out1[7] = 0x61544145 +} diff --git a/fiat-go/64/curve25519scalar/curve25519scalar.go b/fiat-go/64/curve25519scalar/curve25519scalar.go new file mode 100644 index 0000000000..1526a7f149 --- /dev/null +++ b/fiat-go/64/curve25519scalar/curve25519scalar.go @@ -0,0 +1,1723 @@ +// Code generated by Fiat Cryptography. DO NOT EDIT. +// +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Go --no-wide-int --relax-primitive-carry-to-bitwidth 32,64 --cmovznz-by-mul --internal-static --package-case flatcase --public-function-case UpperCamelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case camelCase --no-prefix-fiat --doc-newline-in-typedef-bounds --doc-prepend-header 'Code generated by Fiat Cryptography. DO NOT EDIT.' --doc-text-before-function-name '' --doc-text-before-type-name '' --package-name curve25519scalar '' 64 '2^252 + 27742317777372353535851937790883648493' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// +// curve description (via package name): curve25519scalar +// +// machine_wordsize = 64 (from "64") +// +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// +// m = 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed (from "2^252 + 27742317777372353535851937790883648493") +// +// +// +// NOTE: In addition to the bounds specified above each function, all +// +// functions synthesized for this Montgomery arithmetic require the +// +// input to be strictly less than the prime modulus (m), and also +// +// require the input to be in the unique saturated representation. +// +// All functions also ensure that these two properties are true of +// +// return values. +// +// +// +// Computed values: +// +// eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) +// +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +// +// twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in +// +// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 +package curve25519scalar + +import "math/bits" + +type uint1 uint64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 +type int1 int64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 + +// MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +type MontgomeryDomainFieldElement [4]uint64 + +// NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +type NonMontgomeryDomainFieldElement [4]uint64 + +// cmovznzU64 is a single-word conditional move. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [0x0 ~> 0xffffffffffffffff] +// arg3: [0x0 ~> 0xffffffffffffffff] +// Output Bounds: +// out1: [0x0 ~> 0xffffffffffffffff] +func cmovznzU64(out1 *uint64, arg1 uint1, arg2 uint64, arg3 uint64) { + x1 := (uint64(arg1) * 0xffffffffffffffff) + x2 := ((x1 & arg3) | ((^x1) & arg2)) + *out1 = x2 +} + +// Mul multiplies two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Mul(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[0] + var x5 uint64 + var x6 uint64 + x6, x5 = bits.Mul64(x4, arg2[3]) + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x4, arg2[2]) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x4, arg2[1]) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x4, arg2[0]) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Add64(x12, x9, uint64(0x0)) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Add64(x10, x7, uint64(uint1(x14))) + var x17 uint64 + var x18 uint64 + x17, x18 = bits.Add64(x8, x5, uint64(uint1(x16))) + x19 := (uint64(uint1(x18)) + x6) + var x20 uint64 + _, x20 = bits.Mul64(x11, 0xd2b51da312547e1b) + var x22 uint64 + var x23 uint64 + x23, x22 = bits.Mul64(x20, 0x1000000000000000) + var x24 uint64 + var x25 uint64 + x25, x24 = bits.Mul64(x20, 0x14def9dea2f79cd6) + var x26 uint64 + var x27 uint64 + x27, x26 = bits.Mul64(x20, 0x5812631a5cf5d3ed) + var x28 uint64 + var x29 uint64 + x28, x29 = bits.Add64(x27, x24, uint64(0x0)) + x30 := (uint64(uint1(x29)) + x25) + var x32 uint64 + _, x32 = bits.Add64(x11, x26, uint64(0x0)) + var x33 uint64 + var x34 uint64 + x33, x34 = bits.Add64(x13, x28, uint64(uint1(x32))) + var x35 uint64 + var x36 uint64 + x35, x36 = bits.Add64(x15, x30, uint64(uint1(x34))) + var x37 uint64 + var x38 uint64 + x37, x38 = bits.Add64(x17, x22, uint64(uint1(x36))) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Add64(x19, x23, uint64(uint1(x38))) + var x41 uint64 + var x42 uint64 + x42, x41 = bits.Mul64(x1, arg2[3]) + var x43 uint64 + var x44 uint64 + x44, x43 = bits.Mul64(x1, arg2[2]) + var x45 uint64 + var x46 uint64 + x46, x45 = bits.Mul64(x1, arg2[1]) + var x47 uint64 + var x48 uint64 + x48, x47 = bits.Mul64(x1, arg2[0]) + var x49 uint64 + var x50 uint64 + x49, x50 = bits.Add64(x48, x45, uint64(0x0)) + var x51 uint64 + var x52 uint64 + x51, x52 = bits.Add64(x46, x43, uint64(uint1(x50))) + var x53 uint64 + var x54 uint64 + x53, x54 = bits.Add64(x44, x41, uint64(uint1(x52))) + x55 := (uint64(uint1(x54)) + x42) + var x56 uint64 + var x57 uint64 + x56, x57 = bits.Add64(x33, x47, uint64(0x0)) + var x58 uint64 + var x59 uint64 + x58, x59 = bits.Add64(x35, x49, uint64(uint1(x57))) + var x60 uint64 + var x61 uint64 + x60, x61 = bits.Add64(x37, x51, uint64(uint1(x59))) + var x62 uint64 + var x63 uint64 + x62, x63 = bits.Add64(x39, x53, uint64(uint1(x61))) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(uint64(uint1(x40)), x55, uint64(uint1(x63))) + var x66 uint64 + _, x66 = bits.Mul64(x56, 0xd2b51da312547e1b) + var x68 uint64 + var x69 uint64 + x69, x68 = bits.Mul64(x66, 0x1000000000000000) + var x70 uint64 + var x71 uint64 + x71, x70 = bits.Mul64(x66, 0x14def9dea2f79cd6) + var x72 uint64 + var x73 uint64 + x73, x72 = bits.Mul64(x66, 0x5812631a5cf5d3ed) + var x74 uint64 + var x75 uint64 + x74, x75 = bits.Add64(x73, x70, uint64(0x0)) + x76 := (uint64(uint1(x75)) + x71) + var x78 uint64 + _, x78 = bits.Add64(x56, x72, uint64(0x0)) + var x79 uint64 + var x80 uint64 + x79, x80 = bits.Add64(x58, x74, uint64(uint1(x78))) + var x81 uint64 + var x82 uint64 + x81, x82 = bits.Add64(x60, x76, uint64(uint1(x80))) + var x83 uint64 + var x84 uint64 + x83, x84 = bits.Add64(x62, x68, uint64(uint1(x82))) + var x85 uint64 + var x86 uint64 + x85, x86 = bits.Add64(x64, x69, uint64(uint1(x84))) + x87 := (uint64(uint1(x86)) + uint64(uint1(x65))) + var x88 uint64 + var x89 uint64 + x89, x88 = bits.Mul64(x2, arg2[3]) + var x90 uint64 + var x91 uint64 + x91, x90 = bits.Mul64(x2, arg2[2]) + var x92 uint64 + var x93 uint64 + x93, x92 = bits.Mul64(x2, arg2[1]) + var x94 uint64 + var x95 uint64 + x95, x94 = bits.Mul64(x2, arg2[0]) + var x96 uint64 + var x97 uint64 + x96, x97 = bits.Add64(x95, x92, uint64(0x0)) + var x98 uint64 + var x99 uint64 + x98, x99 = bits.Add64(x93, x90, uint64(uint1(x97))) + var x100 uint64 + var x101 uint64 + x100, x101 = bits.Add64(x91, x88, uint64(uint1(x99))) + x102 := (uint64(uint1(x101)) + x89) + var x103 uint64 + var x104 uint64 + x103, x104 = bits.Add64(x79, x94, uint64(0x0)) + var x105 uint64 + var x106 uint64 + x105, x106 = bits.Add64(x81, x96, uint64(uint1(x104))) + var x107 uint64 + var x108 uint64 + x107, x108 = bits.Add64(x83, x98, uint64(uint1(x106))) + var x109 uint64 + var x110 uint64 + x109, x110 = bits.Add64(x85, x100, uint64(uint1(x108))) + var x111 uint64 + var x112 uint64 + x111, x112 = bits.Add64(x87, x102, uint64(uint1(x110))) + var x113 uint64 + _, x113 = bits.Mul64(x103, 0xd2b51da312547e1b) + var x115 uint64 + var x116 uint64 + x116, x115 = bits.Mul64(x113, 0x1000000000000000) + var x117 uint64 + var x118 uint64 + x118, x117 = bits.Mul64(x113, 0x14def9dea2f79cd6) + var x119 uint64 + var x120 uint64 + x120, x119 = bits.Mul64(x113, 0x5812631a5cf5d3ed) + var x121 uint64 + var x122 uint64 + x121, x122 = bits.Add64(x120, x117, uint64(0x0)) + x123 := (uint64(uint1(x122)) + x118) + var x125 uint64 + _, x125 = bits.Add64(x103, x119, uint64(0x0)) + var x126 uint64 + var x127 uint64 + x126, x127 = bits.Add64(x105, x121, uint64(uint1(x125))) + var x128 uint64 + var x129 uint64 + x128, x129 = bits.Add64(x107, x123, uint64(uint1(x127))) + var x130 uint64 + var x131 uint64 + x130, x131 = bits.Add64(x109, x115, uint64(uint1(x129))) + var x132 uint64 + var x133 uint64 + x132, x133 = bits.Add64(x111, x116, uint64(uint1(x131))) + x134 := (uint64(uint1(x133)) + uint64(uint1(x112))) + var x135 uint64 + var x136 uint64 + x136, x135 = bits.Mul64(x3, arg2[3]) + var x137 uint64 + var x138 uint64 + x138, x137 = bits.Mul64(x3, arg2[2]) + var x139 uint64 + var x140 uint64 + x140, x139 = bits.Mul64(x3, arg2[1]) + var x141 uint64 + var x142 uint64 + x142, x141 = bits.Mul64(x3, arg2[0]) + var x143 uint64 + var x144 uint64 + x143, x144 = bits.Add64(x142, x139, uint64(0x0)) + var x145 uint64 + var x146 uint64 + x145, x146 = bits.Add64(x140, x137, uint64(uint1(x144))) + var x147 uint64 + var x148 uint64 + x147, x148 = bits.Add64(x138, x135, uint64(uint1(x146))) + x149 := (uint64(uint1(x148)) + x136) + var x150 uint64 + var x151 uint64 + x150, x151 = bits.Add64(x126, x141, uint64(0x0)) + var x152 uint64 + var x153 uint64 + x152, x153 = bits.Add64(x128, x143, uint64(uint1(x151))) + var x154 uint64 + var x155 uint64 + x154, x155 = bits.Add64(x130, x145, uint64(uint1(x153))) + var x156 uint64 + var x157 uint64 + x156, x157 = bits.Add64(x132, x147, uint64(uint1(x155))) + var x158 uint64 + var x159 uint64 + x158, x159 = bits.Add64(x134, x149, uint64(uint1(x157))) + var x160 uint64 + _, x160 = bits.Mul64(x150, 0xd2b51da312547e1b) + var x162 uint64 + var x163 uint64 + x163, x162 = bits.Mul64(x160, 0x1000000000000000) + var x164 uint64 + var x165 uint64 + x165, x164 = bits.Mul64(x160, 0x14def9dea2f79cd6) + var x166 uint64 + var x167 uint64 + x167, x166 = bits.Mul64(x160, 0x5812631a5cf5d3ed) + var x168 uint64 + var x169 uint64 + x168, x169 = bits.Add64(x167, x164, uint64(0x0)) + x170 := (uint64(uint1(x169)) + x165) + var x172 uint64 + _, x172 = bits.Add64(x150, x166, uint64(0x0)) + var x173 uint64 + var x174 uint64 + x173, x174 = bits.Add64(x152, x168, uint64(uint1(x172))) + var x175 uint64 + var x176 uint64 + x175, x176 = bits.Add64(x154, x170, uint64(uint1(x174))) + var x177 uint64 + var x178 uint64 + x177, x178 = bits.Add64(x156, x162, uint64(uint1(x176))) + var x179 uint64 + var x180 uint64 + x179, x180 = bits.Add64(x158, x163, uint64(uint1(x178))) + x181 := (uint64(uint1(x180)) + uint64(uint1(x159))) + var x182 uint64 + var x183 uint64 + x182, x183 = bits.Sub64(x173, 0x5812631a5cf5d3ed, uint64(0x0)) + var x184 uint64 + var x185 uint64 + x184, x185 = bits.Sub64(x175, 0x14def9dea2f79cd6, uint64(uint1(x183))) + var x186 uint64 + var x187 uint64 + x186, x187 = bits.Sub64(x177, uint64(0x0), uint64(uint1(x185))) + var x188 uint64 + var x189 uint64 + x188, x189 = bits.Sub64(x179, 0x1000000000000000, uint64(uint1(x187))) + var x191 uint64 + _, x191 = bits.Sub64(x181, uint64(0x0), uint64(uint1(x189))) + var x192 uint64 + cmovznzU64(&x192, uint1(x191), x182, x173) + var x193 uint64 + cmovznzU64(&x193, uint1(x191), x184, x175) + var x194 uint64 + cmovznzU64(&x194, uint1(x191), x186, x177) + var x195 uint64 + cmovznzU64(&x195, uint1(x191), x188, x179) + out1[0] = x192 + out1[1] = x193 + out1[2] = x194 + out1[3] = x195 +} + +// Square squares a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +// 0 ≤ eval out1 < m +// +func Square(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[0] + var x5 uint64 + var x6 uint64 + x6, x5 = bits.Mul64(x4, arg1[3]) + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x4, arg1[2]) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x4, arg1[1]) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x4, arg1[0]) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Add64(x12, x9, uint64(0x0)) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Add64(x10, x7, uint64(uint1(x14))) + var x17 uint64 + var x18 uint64 + x17, x18 = bits.Add64(x8, x5, uint64(uint1(x16))) + x19 := (uint64(uint1(x18)) + x6) + var x20 uint64 + _, x20 = bits.Mul64(x11, 0xd2b51da312547e1b) + var x22 uint64 + var x23 uint64 + x23, x22 = bits.Mul64(x20, 0x1000000000000000) + var x24 uint64 + var x25 uint64 + x25, x24 = bits.Mul64(x20, 0x14def9dea2f79cd6) + var x26 uint64 + var x27 uint64 + x27, x26 = bits.Mul64(x20, 0x5812631a5cf5d3ed) + var x28 uint64 + var x29 uint64 + x28, x29 = bits.Add64(x27, x24, uint64(0x0)) + x30 := (uint64(uint1(x29)) + x25) + var x32 uint64 + _, x32 = bits.Add64(x11, x26, uint64(0x0)) + var x33 uint64 + var x34 uint64 + x33, x34 = bits.Add64(x13, x28, uint64(uint1(x32))) + var x35 uint64 + var x36 uint64 + x35, x36 = bits.Add64(x15, x30, uint64(uint1(x34))) + var x37 uint64 + var x38 uint64 + x37, x38 = bits.Add64(x17, x22, uint64(uint1(x36))) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Add64(x19, x23, uint64(uint1(x38))) + var x41 uint64 + var x42 uint64 + x42, x41 = bits.Mul64(x1, arg1[3]) + var x43 uint64 + var x44 uint64 + x44, x43 = bits.Mul64(x1, arg1[2]) + var x45 uint64 + var x46 uint64 + x46, x45 = bits.Mul64(x1, arg1[1]) + var x47 uint64 + var x48 uint64 + x48, x47 = bits.Mul64(x1, arg1[0]) + var x49 uint64 + var x50 uint64 + x49, x50 = bits.Add64(x48, x45, uint64(0x0)) + var x51 uint64 + var x52 uint64 + x51, x52 = bits.Add64(x46, x43, uint64(uint1(x50))) + var x53 uint64 + var x54 uint64 + x53, x54 = bits.Add64(x44, x41, uint64(uint1(x52))) + x55 := (uint64(uint1(x54)) + x42) + var x56 uint64 + var x57 uint64 + x56, x57 = bits.Add64(x33, x47, uint64(0x0)) + var x58 uint64 + var x59 uint64 + x58, x59 = bits.Add64(x35, x49, uint64(uint1(x57))) + var x60 uint64 + var x61 uint64 + x60, x61 = bits.Add64(x37, x51, uint64(uint1(x59))) + var x62 uint64 + var x63 uint64 + x62, x63 = bits.Add64(x39, x53, uint64(uint1(x61))) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(uint64(uint1(x40)), x55, uint64(uint1(x63))) + var x66 uint64 + _, x66 = bits.Mul64(x56, 0xd2b51da312547e1b) + var x68 uint64 + var x69 uint64 + x69, x68 = bits.Mul64(x66, 0x1000000000000000) + var x70 uint64 + var x71 uint64 + x71, x70 = bits.Mul64(x66, 0x14def9dea2f79cd6) + var x72 uint64 + var x73 uint64 + x73, x72 = bits.Mul64(x66, 0x5812631a5cf5d3ed) + var x74 uint64 + var x75 uint64 + x74, x75 = bits.Add64(x73, x70, uint64(0x0)) + x76 := (uint64(uint1(x75)) + x71) + var x78 uint64 + _, x78 = bits.Add64(x56, x72, uint64(0x0)) + var x79 uint64 + var x80 uint64 + x79, x80 = bits.Add64(x58, x74, uint64(uint1(x78))) + var x81 uint64 + var x82 uint64 + x81, x82 = bits.Add64(x60, x76, uint64(uint1(x80))) + var x83 uint64 + var x84 uint64 + x83, x84 = bits.Add64(x62, x68, uint64(uint1(x82))) + var x85 uint64 + var x86 uint64 + x85, x86 = bits.Add64(x64, x69, uint64(uint1(x84))) + x87 := (uint64(uint1(x86)) + uint64(uint1(x65))) + var x88 uint64 + var x89 uint64 + x89, x88 = bits.Mul64(x2, arg1[3]) + var x90 uint64 + var x91 uint64 + x91, x90 = bits.Mul64(x2, arg1[2]) + var x92 uint64 + var x93 uint64 + x93, x92 = bits.Mul64(x2, arg1[1]) + var x94 uint64 + var x95 uint64 + x95, x94 = bits.Mul64(x2, arg1[0]) + var x96 uint64 + var x97 uint64 + x96, x97 = bits.Add64(x95, x92, uint64(0x0)) + var x98 uint64 + var x99 uint64 + x98, x99 = bits.Add64(x93, x90, uint64(uint1(x97))) + var x100 uint64 + var x101 uint64 + x100, x101 = bits.Add64(x91, x88, uint64(uint1(x99))) + x102 := (uint64(uint1(x101)) + x89) + var x103 uint64 + var x104 uint64 + x103, x104 = bits.Add64(x79, x94, uint64(0x0)) + var x105 uint64 + var x106 uint64 + x105, x106 = bits.Add64(x81, x96, uint64(uint1(x104))) + var x107 uint64 + var x108 uint64 + x107, x108 = bits.Add64(x83, x98, uint64(uint1(x106))) + var x109 uint64 + var x110 uint64 + x109, x110 = bits.Add64(x85, x100, uint64(uint1(x108))) + var x111 uint64 + var x112 uint64 + x111, x112 = bits.Add64(x87, x102, uint64(uint1(x110))) + var x113 uint64 + _, x113 = bits.Mul64(x103, 0xd2b51da312547e1b) + var x115 uint64 + var x116 uint64 + x116, x115 = bits.Mul64(x113, 0x1000000000000000) + var x117 uint64 + var x118 uint64 + x118, x117 = bits.Mul64(x113, 0x14def9dea2f79cd6) + var x119 uint64 + var x120 uint64 + x120, x119 = bits.Mul64(x113, 0x5812631a5cf5d3ed) + var x121 uint64 + var x122 uint64 + x121, x122 = bits.Add64(x120, x117, uint64(0x0)) + x123 := (uint64(uint1(x122)) + x118) + var x125 uint64 + _, x125 = bits.Add64(x103, x119, uint64(0x0)) + var x126 uint64 + var x127 uint64 + x126, x127 = bits.Add64(x105, x121, uint64(uint1(x125))) + var x128 uint64 + var x129 uint64 + x128, x129 = bits.Add64(x107, x123, uint64(uint1(x127))) + var x130 uint64 + var x131 uint64 + x130, x131 = bits.Add64(x109, x115, uint64(uint1(x129))) + var x132 uint64 + var x133 uint64 + x132, x133 = bits.Add64(x111, x116, uint64(uint1(x131))) + x134 := (uint64(uint1(x133)) + uint64(uint1(x112))) + var x135 uint64 + var x136 uint64 + x136, x135 = bits.Mul64(x3, arg1[3]) + var x137 uint64 + var x138 uint64 + x138, x137 = bits.Mul64(x3, arg1[2]) + var x139 uint64 + var x140 uint64 + x140, x139 = bits.Mul64(x3, arg1[1]) + var x141 uint64 + var x142 uint64 + x142, x141 = bits.Mul64(x3, arg1[0]) + var x143 uint64 + var x144 uint64 + x143, x144 = bits.Add64(x142, x139, uint64(0x0)) + var x145 uint64 + var x146 uint64 + x145, x146 = bits.Add64(x140, x137, uint64(uint1(x144))) + var x147 uint64 + var x148 uint64 + x147, x148 = bits.Add64(x138, x135, uint64(uint1(x146))) + x149 := (uint64(uint1(x148)) + x136) + var x150 uint64 + var x151 uint64 + x150, x151 = bits.Add64(x126, x141, uint64(0x0)) + var x152 uint64 + var x153 uint64 + x152, x153 = bits.Add64(x128, x143, uint64(uint1(x151))) + var x154 uint64 + var x155 uint64 + x154, x155 = bits.Add64(x130, x145, uint64(uint1(x153))) + var x156 uint64 + var x157 uint64 + x156, x157 = bits.Add64(x132, x147, uint64(uint1(x155))) + var x158 uint64 + var x159 uint64 + x158, x159 = bits.Add64(x134, x149, uint64(uint1(x157))) + var x160 uint64 + _, x160 = bits.Mul64(x150, 0xd2b51da312547e1b) + var x162 uint64 + var x163 uint64 + x163, x162 = bits.Mul64(x160, 0x1000000000000000) + var x164 uint64 + var x165 uint64 + x165, x164 = bits.Mul64(x160, 0x14def9dea2f79cd6) + var x166 uint64 + var x167 uint64 + x167, x166 = bits.Mul64(x160, 0x5812631a5cf5d3ed) + var x168 uint64 + var x169 uint64 + x168, x169 = bits.Add64(x167, x164, uint64(0x0)) + x170 := (uint64(uint1(x169)) + x165) + var x172 uint64 + _, x172 = bits.Add64(x150, x166, uint64(0x0)) + var x173 uint64 + var x174 uint64 + x173, x174 = bits.Add64(x152, x168, uint64(uint1(x172))) + var x175 uint64 + var x176 uint64 + x175, x176 = bits.Add64(x154, x170, uint64(uint1(x174))) + var x177 uint64 + var x178 uint64 + x177, x178 = bits.Add64(x156, x162, uint64(uint1(x176))) + var x179 uint64 + var x180 uint64 + x179, x180 = bits.Add64(x158, x163, uint64(uint1(x178))) + x181 := (uint64(uint1(x180)) + uint64(uint1(x159))) + var x182 uint64 + var x183 uint64 + x182, x183 = bits.Sub64(x173, 0x5812631a5cf5d3ed, uint64(0x0)) + var x184 uint64 + var x185 uint64 + x184, x185 = bits.Sub64(x175, 0x14def9dea2f79cd6, uint64(uint1(x183))) + var x186 uint64 + var x187 uint64 + x186, x187 = bits.Sub64(x177, uint64(0x0), uint64(uint1(x185))) + var x188 uint64 + var x189 uint64 + x188, x189 = bits.Sub64(x179, 0x1000000000000000, uint64(uint1(x187))) + var x191 uint64 + _, x191 = bits.Sub64(x181, uint64(0x0), uint64(uint1(x189))) + var x192 uint64 + cmovznzU64(&x192, uint1(x191), x182, x173) + var x193 uint64 + cmovznzU64(&x193, uint1(x191), x184, x175) + var x194 uint64 + cmovznzU64(&x194, uint1(x191), x186, x177) + var x195 uint64 + cmovznzU64(&x195, uint1(x191), x188, x179) + out1[0] = x192 + out1[1] = x193 + out1[2] = x194 + out1[3] = x195 +} + +// Add adds two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Add(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint64 + var x2 uint64 + x1, x2 = bits.Add64(arg1[0], arg2[0], uint64(0x0)) + var x3 uint64 + var x4 uint64 + x3, x4 = bits.Add64(arg1[1], arg2[1], uint64(uint1(x2))) + var x5 uint64 + var x6 uint64 + x5, x6 = bits.Add64(arg1[2], arg2[2], uint64(uint1(x4))) + var x7 uint64 + var x8 uint64 + x7, x8 = bits.Add64(arg1[3], arg2[3], uint64(uint1(x6))) + var x9 uint64 + var x10 uint64 + x9, x10 = bits.Sub64(x1, 0x5812631a5cf5d3ed, uint64(0x0)) + var x11 uint64 + var x12 uint64 + x11, x12 = bits.Sub64(x3, 0x14def9dea2f79cd6, uint64(uint1(x10))) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Sub64(x5, uint64(0x0), uint64(uint1(x12))) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Sub64(x7, 0x1000000000000000, uint64(uint1(x14))) + var x18 uint64 + _, x18 = bits.Sub64(uint64(uint1(x8)), uint64(0x0), uint64(uint1(x16))) + var x19 uint64 + cmovznzU64(&x19, uint1(x18), x9, x1) + var x20 uint64 + cmovznzU64(&x20, uint1(x18), x11, x3) + var x21 uint64 + cmovznzU64(&x21, uint1(x18), x13, x5) + var x22 uint64 + cmovznzU64(&x22, uint1(x18), x15, x7) + out1[0] = x19 + out1[1] = x20 + out1[2] = x21 + out1[3] = x22 +} + +// Sub subtracts two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Sub(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint64 + var x2 uint64 + x1, x2 = bits.Sub64(arg1[0], arg2[0], uint64(0x0)) + var x3 uint64 + var x4 uint64 + x3, x4 = bits.Sub64(arg1[1], arg2[1], uint64(uint1(x2))) + var x5 uint64 + var x6 uint64 + x5, x6 = bits.Sub64(arg1[2], arg2[2], uint64(uint1(x4))) + var x7 uint64 + var x8 uint64 + x7, x8 = bits.Sub64(arg1[3], arg2[3], uint64(uint1(x6))) + var x9 uint64 + cmovznzU64(&x9, uint1(x8), uint64(0x0), 0xffffffffffffffff) + var x10 uint64 + var x11 uint64 + x10, x11 = bits.Add64(x1, (x9 & 0x5812631a5cf5d3ed), uint64(0x0)) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x3, (x9 & 0x14def9dea2f79cd6), uint64(uint1(x11))) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(x5, uint64(0x0), uint64(uint1(x13))) + var x16 uint64 + x16, _ = bits.Add64(x7, (x9 & 0x1000000000000000), uint64(uint1(x15))) + out1[0] = x10 + out1[1] = x12 + out1[2] = x14 + out1[3] = x16 +} + +// Opp negates a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +// 0 ≤ eval out1 < m +// +func Opp(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + var x1 uint64 + var x2 uint64 + x1, x2 = bits.Sub64(uint64(0x0), arg1[0], uint64(0x0)) + var x3 uint64 + var x4 uint64 + x3, x4 = bits.Sub64(uint64(0x0), arg1[1], uint64(uint1(x2))) + var x5 uint64 + var x6 uint64 + x5, x6 = bits.Sub64(uint64(0x0), arg1[2], uint64(uint1(x4))) + var x7 uint64 + var x8 uint64 + x7, x8 = bits.Sub64(uint64(0x0), arg1[3], uint64(uint1(x6))) + var x9 uint64 + cmovznzU64(&x9, uint1(x8), uint64(0x0), 0xffffffffffffffff) + var x10 uint64 + var x11 uint64 + x10, x11 = bits.Add64(x1, (x9 & 0x5812631a5cf5d3ed), uint64(0x0)) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x3, (x9 & 0x14def9dea2f79cd6), uint64(uint1(x11))) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(x5, uint64(0x0), uint64(uint1(x13))) + var x16 uint64 + x16, _ = bits.Add64(x7, (x9 & 0x1000000000000000), uint64(uint1(x15))) + out1[0] = x10 + out1[1] = x12 + out1[2] = x14 + out1[3] = x16 +} + +// FromMontgomery translates a field element out of the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m +// 0 ≤ eval out1 < m +// +func FromMontgomery(out1 *NonMontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[0] + var x2 uint64 + _, x2 = bits.Mul64(x1, 0xd2b51da312547e1b) + var x4 uint64 + var x5 uint64 + x5, x4 = bits.Mul64(x2, 0x1000000000000000) + var x6 uint64 + var x7 uint64 + x7, x6 = bits.Mul64(x2, 0x14def9dea2f79cd6) + var x8 uint64 + var x9 uint64 + x9, x8 = bits.Mul64(x2, 0x5812631a5cf5d3ed) + var x10 uint64 + var x11 uint64 + x10, x11 = bits.Add64(x9, x6, uint64(0x0)) + var x13 uint64 + _, x13 = bits.Add64(x1, x8, uint64(0x0)) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(uint64(0x0), x10, uint64(uint1(x13))) + var x16 uint64 + var x17 uint64 + x16, x17 = bits.Add64(x14, arg1[1], uint64(0x0)) + var x18 uint64 + _, x18 = bits.Mul64(x16, 0xd2b51da312547e1b) + var x20 uint64 + var x21 uint64 + x21, x20 = bits.Mul64(x18, 0x1000000000000000) + var x22 uint64 + var x23 uint64 + x23, x22 = bits.Mul64(x18, 0x14def9dea2f79cd6) + var x24 uint64 + var x25 uint64 + x25, x24 = bits.Mul64(x18, 0x5812631a5cf5d3ed) + var x26 uint64 + var x27 uint64 + x26, x27 = bits.Add64(x25, x22, uint64(0x0)) + var x29 uint64 + _, x29 = bits.Add64(x16, x24, uint64(0x0)) + var x30 uint64 + var x31 uint64 + x30, x31 = bits.Add64((uint64(uint1(x17)) + (uint64(uint1(x15)) + (uint64(uint1(x11)) + x7))), x26, uint64(uint1(x29))) + var x32 uint64 + var x33 uint64 + x32, x33 = bits.Add64(x4, (uint64(uint1(x27)) + x23), uint64(uint1(x31))) + var x34 uint64 + var x35 uint64 + x34, x35 = bits.Add64(x5, x20, uint64(uint1(x33))) + var x36 uint64 + var x37 uint64 + x36, x37 = bits.Add64(x30, arg1[2], uint64(0x0)) + var x38 uint64 + var x39 uint64 + x38, x39 = bits.Add64(x32, uint64(0x0), uint64(uint1(x37))) + var x40 uint64 + var x41 uint64 + x40, x41 = bits.Add64(x34, uint64(0x0), uint64(uint1(x39))) + var x42 uint64 + _, x42 = bits.Mul64(x36, 0xd2b51da312547e1b) + var x44 uint64 + var x45 uint64 + x45, x44 = bits.Mul64(x42, 0x1000000000000000) + var x46 uint64 + var x47 uint64 + x47, x46 = bits.Mul64(x42, 0x14def9dea2f79cd6) + var x48 uint64 + var x49 uint64 + x49, x48 = bits.Mul64(x42, 0x5812631a5cf5d3ed) + var x50 uint64 + var x51 uint64 + x50, x51 = bits.Add64(x49, x46, uint64(0x0)) + var x53 uint64 + _, x53 = bits.Add64(x36, x48, uint64(0x0)) + var x54 uint64 + var x55 uint64 + x54, x55 = bits.Add64(x38, x50, uint64(uint1(x53))) + var x56 uint64 + var x57 uint64 + x56, x57 = bits.Add64(x40, (uint64(uint1(x51)) + x47), uint64(uint1(x55))) + var x58 uint64 + var x59 uint64 + x58, x59 = bits.Add64((uint64(uint1(x41)) + (uint64(uint1(x35)) + x21)), x44, uint64(uint1(x57))) + var x60 uint64 + var x61 uint64 + x60, x61 = bits.Add64(x54, arg1[3], uint64(0x0)) + var x62 uint64 + var x63 uint64 + x62, x63 = bits.Add64(x56, uint64(0x0), uint64(uint1(x61))) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(x58, uint64(0x0), uint64(uint1(x63))) + var x66 uint64 + _, x66 = bits.Mul64(x60, 0xd2b51da312547e1b) + var x68 uint64 + var x69 uint64 + x69, x68 = bits.Mul64(x66, 0x1000000000000000) + var x70 uint64 + var x71 uint64 + x71, x70 = bits.Mul64(x66, 0x14def9dea2f79cd6) + var x72 uint64 + var x73 uint64 + x73, x72 = bits.Mul64(x66, 0x5812631a5cf5d3ed) + var x74 uint64 + var x75 uint64 + x74, x75 = bits.Add64(x73, x70, uint64(0x0)) + var x77 uint64 + _, x77 = bits.Add64(x60, x72, uint64(0x0)) + var x78 uint64 + var x79 uint64 + x78, x79 = bits.Add64(x62, x74, uint64(uint1(x77))) + var x80 uint64 + var x81 uint64 + x80, x81 = bits.Add64(x64, (uint64(uint1(x75)) + x71), uint64(uint1(x79))) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64((uint64(uint1(x65)) + (uint64(uint1(x59)) + x45)), x68, uint64(uint1(x81))) + x84 := (uint64(uint1(x83)) + x69) + var x85 uint64 + var x86 uint64 + x85, x86 = bits.Sub64(x78, 0x5812631a5cf5d3ed, uint64(0x0)) + var x87 uint64 + var x88 uint64 + x87, x88 = bits.Sub64(x80, 0x14def9dea2f79cd6, uint64(uint1(x86))) + var x89 uint64 + var x90 uint64 + x89, x90 = bits.Sub64(x82, uint64(0x0), uint64(uint1(x88))) + var x91 uint64 + var x92 uint64 + x91, x92 = bits.Sub64(x84, 0x1000000000000000, uint64(uint1(x90))) + var x94 uint64 + _, x94 = bits.Sub64(uint64(0x0), uint64(0x0), uint64(uint1(x92))) + var x95 uint64 + cmovznzU64(&x95, uint1(x94), x85, x78) + var x96 uint64 + cmovznzU64(&x96, uint1(x94), x87, x80) + var x97 uint64 + cmovznzU64(&x97, uint1(x94), x89, x82) + var x98 uint64 + cmovznzU64(&x98, uint1(x94), x91, x84) + out1[0] = x95 + out1[1] = x96 + out1[2] = x97 + out1[3] = x98 +} + +// ToMontgomery translates a field element into the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = eval arg1 mod m +// 0 ≤ eval out1 < m +// +func ToMontgomery(out1 *MontgomeryDomainFieldElement, arg1 *NonMontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[0] + var x5 uint64 + var x6 uint64 + x6, x5 = bits.Mul64(x4, 0x399411b7c309a3d) + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x4, 0xceec73d217f5be65) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x4, 0xd00e1ba768859347) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x4, 0xa40611e3449c0f01) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Add64(x12, x9, uint64(0x0)) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Add64(x10, x7, uint64(uint1(x14))) + var x17 uint64 + var x18 uint64 + x17, x18 = bits.Add64(x8, x5, uint64(uint1(x16))) + var x19 uint64 + _, x19 = bits.Mul64(x11, 0xd2b51da312547e1b) + var x21 uint64 + var x22 uint64 + x22, x21 = bits.Mul64(x19, 0x1000000000000000) + var x23 uint64 + var x24 uint64 + x24, x23 = bits.Mul64(x19, 0x14def9dea2f79cd6) + var x25 uint64 + var x26 uint64 + x26, x25 = bits.Mul64(x19, 0x5812631a5cf5d3ed) + var x27 uint64 + var x28 uint64 + x27, x28 = bits.Add64(x26, x23, uint64(0x0)) + var x30 uint64 + _, x30 = bits.Add64(x11, x25, uint64(0x0)) + var x31 uint64 + var x32 uint64 + x31, x32 = bits.Add64(x13, x27, uint64(uint1(x30))) + var x33 uint64 + var x34 uint64 + x33, x34 = bits.Add64(x15, (uint64(uint1(x28)) + x24), uint64(uint1(x32))) + var x35 uint64 + var x36 uint64 + x35, x36 = bits.Add64(x17, x21, uint64(uint1(x34))) + var x37 uint64 + var x38 uint64 + x38, x37 = bits.Mul64(x1, 0x399411b7c309a3d) + var x39 uint64 + var x40 uint64 + x40, x39 = bits.Mul64(x1, 0xceec73d217f5be65) + var x41 uint64 + var x42 uint64 + x42, x41 = bits.Mul64(x1, 0xd00e1ba768859347) + var x43 uint64 + var x44 uint64 + x44, x43 = bits.Mul64(x1, 0xa40611e3449c0f01) + var x45 uint64 + var x46 uint64 + x45, x46 = bits.Add64(x44, x41, uint64(0x0)) + var x47 uint64 + var x48 uint64 + x47, x48 = bits.Add64(x42, x39, uint64(uint1(x46))) + var x49 uint64 + var x50 uint64 + x49, x50 = bits.Add64(x40, x37, uint64(uint1(x48))) + var x51 uint64 + var x52 uint64 + x51, x52 = bits.Add64(x31, x43, uint64(0x0)) + var x53 uint64 + var x54 uint64 + x53, x54 = bits.Add64(x33, x45, uint64(uint1(x52))) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Add64(x35, x47, uint64(uint1(x54))) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Add64(((uint64(uint1(x36)) + (uint64(uint1(x18)) + x6)) + x22), x49, uint64(uint1(x56))) + var x59 uint64 + _, x59 = bits.Mul64(x51, 0xd2b51da312547e1b) + var x61 uint64 + var x62 uint64 + x62, x61 = bits.Mul64(x59, 0x1000000000000000) + var x63 uint64 + var x64 uint64 + x64, x63 = bits.Mul64(x59, 0x14def9dea2f79cd6) + var x65 uint64 + var x66 uint64 + x66, x65 = bits.Mul64(x59, 0x5812631a5cf5d3ed) + var x67 uint64 + var x68 uint64 + x67, x68 = bits.Add64(x66, x63, uint64(0x0)) + var x70 uint64 + _, x70 = bits.Add64(x51, x65, uint64(0x0)) + var x71 uint64 + var x72 uint64 + x71, x72 = bits.Add64(x53, x67, uint64(uint1(x70))) + var x73 uint64 + var x74 uint64 + x73, x74 = bits.Add64(x55, (uint64(uint1(x68)) + x64), uint64(uint1(x72))) + var x75 uint64 + var x76 uint64 + x75, x76 = bits.Add64(x57, x61, uint64(uint1(x74))) + var x77 uint64 + var x78 uint64 + x78, x77 = bits.Mul64(x2, 0x399411b7c309a3d) + var x79 uint64 + var x80 uint64 + x80, x79 = bits.Mul64(x2, 0xceec73d217f5be65) + var x81 uint64 + var x82 uint64 + x82, x81 = bits.Mul64(x2, 0xd00e1ba768859347) + var x83 uint64 + var x84 uint64 + x84, x83 = bits.Mul64(x2, 0xa40611e3449c0f01) + var x85 uint64 + var x86 uint64 + x85, x86 = bits.Add64(x84, x81, uint64(0x0)) + var x87 uint64 + var x88 uint64 + x87, x88 = bits.Add64(x82, x79, uint64(uint1(x86))) + var x89 uint64 + var x90 uint64 + x89, x90 = bits.Add64(x80, x77, uint64(uint1(x88))) + var x91 uint64 + var x92 uint64 + x91, x92 = bits.Add64(x71, x83, uint64(0x0)) + var x93 uint64 + var x94 uint64 + x93, x94 = bits.Add64(x73, x85, uint64(uint1(x92))) + var x95 uint64 + var x96 uint64 + x95, x96 = bits.Add64(x75, x87, uint64(uint1(x94))) + var x97 uint64 + var x98 uint64 + x97, x98 = bits.Add64(((uint64(uint1(x76)) + (uint64(uint1(x58)) + (uint64(uint1(x50)) + x38))) + x62), x89, uint64(uint1(x96))) + var x99 uint64 + _, x99 = bits.Mul64(x91, 0xd2b51da312547e1b) + var x101 uint64 + var x102 uint64 + x102, x101 = bits.Mul64(x99, 0x1000000000000000) + var x103 uint64 + var x104 uint64 + x104, x103 = bits.Mul64(x99, 0x14def9dea2f79cd6) + var x105 uint64 + var x106 uint64 + x106, x105 = bits.Mul64(x99, 0x5812631a5cf5d3ed) + var x107 uint64 + var x108 uint64 + x107, x108 = bits.Add64(x106, x103, uint64(0x0)) + var x110 uint64 + _, x110 = bits.Add64(x91, x105, uint64(0x0)) + var x111 uint64 + var x112 uint64 + x111, x112 = bits.Add64(x93, x107, uint64(uint1(x110))) + var x113 uint64 + var x114 uint64 + x113, x114 = bits.Add64(x95, (uint64(uint1(x108)) + x104), uint64(uint1(x112))) + var x115 uint64 + var x116 uint64 + x115, x116 = bits.Add64(x97, x101, uint64(uint1(x114))) + var x117 uint64 + var x118 uint64 + x118, x117 = bits.Mul64(x3, 0x399411b7c309a3d) + var x119 uint64 + var x120 uint64 + x120, x119 = bits.Mul64(x3, 0xceec73d217f5be65) + var x121 uint64 + var x122 uint64 + x122, x121 = bits.Mul64(x3, 0xd00e1ba768859347) + var x123 uint64 + var x124 uint64 + x124, x123 = bits.Mul64(x3, 0xa40611e3449c0f01) + var x125 uint64 + var x126 uint64 + x125, x126 = bits.Add64(x124, x121, uint64(0x0)) + var x127 uint64 + var x128 uint64 + x127, x128 = bits.Add64(x122, x119, uint64(uint1(x126))) + var x129 uint64 + var x130 uint64 + x129, x130 = bits.Add64(x120, x117, uint64(uint1(x128))) + var x131 uint64 + var x132 uint64 + x131, x132 = bits.Add64(x111, x123, uint64(0x0)) + var x133 uint64 + var x134 uint64 + x133, x134 = bits.Add64(x113, x125, uint64(uint1(x132))) + var x135 uint64 + var x136 uint64 + x135, x136 = bits.Add64(x115, x127, uint64(uint1(x134))) + var x137 uint64 + var x138 uint64 + x137, x138 = bits.Add64(((uint64(uint1(x116)) + (uint64(uint1(x98)) + (uint64(uint1(x90)) + x78))) + x102), x129, uint64(uint1(x136))) + var x139 uint64 + _, x139 = bits.Mul64(x131, 0xd2b51da312547e1b) + var x141 uint64 + var x142 uint64 + x142, x141 = bits.Mul64(x139, 0x1000000000000000) + var x143 uint64 + var x144 uint64 + x144, x143 = bits.Mul64(x139, 0x14def9dea2f79cd6) + var x145 uint64 + var x146 uint64 + x146, x145 = bits.Mul64(x139, 0x5812631a5cf5d3ed) + var x147 uint64 + var x148 uint64 + x147, x148 = bits.Add64(x146, x143, uint64(0x0)) + var x150 uint64 + _, x150 = bits.Add64(x131, x145, uint64(0x0)) + var x151 uint64 + var x152 uint64 + x151, x152 = bits.Add64(x133, x147, uint64(uint1(x150))) + var x153 uint64 + var x154 uint64 + x153, x154 = bits.Add64(x135, (uint64(uint1(x148)) + x144), uint64(uint1(x152))) + var x155 uint64 + var x156 uint64 + x155, x156 = bits.Add64(x137, x141, uint64(uint1(x154))) + x157 := ((uint64(uint1(x156)) + (uint64(uint1(x138)) + (uint64(uint1(x130)) + x118))) + x142) + var x158 uint64 + var x159 uint64 + x158, x159 = bits.Sub64(x151, 0x5812631a5cf5d3ed, uint64(0x0)) + var x160 uint64 + var x161 uint64 + x160, x161 = bits.Sub64(x153, 0x14def9dea2f79cd6, uint64(uint1(x159))) + var x162 uint64 + var x163 uint64 + x162, x163 = bits.Sub64(x155, uint64(0x0), uint64(uint1(x161))) + var x164 uint64 + var x165 uint64 + x164, x165 = bits.Sub64(x157, 0x1000000000000000, uint64(uint1(x163))) + var x167 uint64 + _, x167 = bits.Sub64(uint64(0x0), uint64(0x0), uint64(uint1(x165))) + var x168 uint64 + cmovznzU64(&x168, uint1(x167), x158, x151) + var x169 uint64 + cmovznzU64(&x169, uint1(x167), x160, x153) + var x170 uint64 + cmovznzU64(&x170, uint1(x167), x162, x155) + var x171 uint64 + cmovznzU64(&x171, uint1(x167), x164, x157) + out1[0] = x168 + out1[1] = x169 + out1[2] = x170 + out1[3] = x171 +} + +// Nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffffffffffff] +func Nonzero(out1 *uint64, arg1 *[4]uint64) { + x1 := (arg1[0] | (arg1[1] | (arg1[2] | arg1[3]))) + *out1 = x1 +} + +// Selectznz is a multi-limb conditional select. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func Selectznz(out1 *[4]uint64, arg1 uint1, arg2 *[4]uint64, arg3 *[4]uint64) { + var x1 uint64 + cmovznzU64(&x1, arg1, arg2[0], arg3[0]) + var x2 uint64 + cmovznzU64(&x2, arg1, arg2[1], arg3[1]) + var x3 uint64 + cmovznzU64(&x3, arg1, arg2[2], arg3[2]) + var x4 uint64 + cmovznzU64(&x4, arg1, arg2[3], arg3[3]) + out1[0] = x1 + out1[1] = x2 + out1[2] = x3 + out1[3] = x4 +} + +// ToBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1fffffffffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] +func ToBytes(out1 *[32]uint8, arg1 *[4]uint64) { + x1 := arg1[3] + x2 := arg1[2] + x3 := arg1[1] + x4 := arg1[0] + x5 := (uint8(x4) & 0xff) + x6 := (x4 >> 8) + x7 := (uint8(x6) & 0xff) + x8 := (x6 >> 8) + x9 := (uint8(x8) & 0xff) + x10 := (x8 >> 8) + x11 := (uint8(x10) & 0xff) + x12 := (x10 >> 8) + x13 := (uint8(x12) & 0xff) + x14 := (x12 >> 8) + x15 := (uint8(x14) & 0xff) + x16 := (x14 >> 8) + x17 := (uint8(x16) & 0xff) + x18 := uint8((x16 >> 8)) + x19 := (uint8(x3) & 0xff) + x20 := (x3 >> 8) + x21 := (uint8(x20) & 0xff) + x22 := (x20 >> 8) + x23 := (uint8(x22) & 0xff) + x24 := (x22 >> 8) + x25 := (uint8(x24) & 0xff) + x26 := (x24 >> 8) + x27 := (uint8(x26) & 0xff) + x28 := (x26 >> 8) + x29 := (uint8(x28) & 0xff) + x30 := (x28 >> 8) + x31 := (uint8(x30) & 0xff) + x32 := uint8((x30 >> 8)) + x33 := (uint8(x2) & 0xff) + x34 := (x2 >> 8) + x35 := (uint8(x34) & 0xff) + x36 := (x34 >> 8) + x37 := (uint8(x36) & 0xff) + x38 := (x36 >> 8) + x39 := (uint8(x38) & 0xff) + x40 := (x38 >> 8) + x41 := (uint8(x40) & 0xff) + x42 := (x40 >> 8) + x43 := (uint8(x42) & 0xff) + x44 := (x42 >> 8) + x45 := (uint8(x44) & 0xff) + x46 := uint8((x44 >> 8)) + x47 := (uint8(x1) & 0xff) + x48 := (x1 >> 8) + x49 := (uint8(x48) & 0xff) + x50 := (x48 >> 8) + x51 := (uint8(x50) & 0xff) + x52 := (x50 >> 8) + x53 := (uint8(x52) & 0xff) + x54 := (x52 >> 8) + x55 := (uint8(x54) & 0xff) + x56 := (x54 >> 8) + x57 := (uint8(x56) & 0xff) + x58 := (x56 >> 8) + x59 := (uint8(x58) & 0xff) + x60 := uint8((x58 >> 8)) + out1[0] = x5 + out1[1] = x7 + out1[2] = x9 + out1[3] = x11 + out1[4] = x13 + out1[5] = x15 + out1[6] = x17 + out1[7] = x18 + out1[8] = x19 + out1[9] = x21 + out1[10] = x23 + out1[11] = x25 + out1[12] = x27 + out1[13] = x29 + out1[14] = x31 + out1[15] = x32 + out1[16] = x33 + out1[17] = x35 + out1[18] = x37 + out1[19] = x39 + out1[20] = x41 + out1[21] = x43 + out1[22] = x45 + out1[23] = x46 + out1[24] = x47 + out1[25] = x49 + out1[26] = x51 + out1[27] = x53 + out1[28] = x55 + out1[29] = x57 + out1[30] = x59 + out1[31] = x60 +} + +// FromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +// +// Preconditions: +// 0 ≤ bytes_eval arg1 < m +// Postconditions: +// eval out1 mod m = bytes_eval arg1 mod m +// 0 ≤ eval out1 < m +// +// Input Bounds: +// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1fffffffffffffff]] +func FromBytes(out1 *[4]uint64, arg1 *[32]uint8) { + x1 := (uint64(arg1[31]) << 56) + x2 := (uint64(arg1[30]) << 48) + x3 := (uint64(arg1[29]) << 40) + x4 := (uint64(arg1[28]) << 32) + x5 := (uint64(arg1[27]) << 24) + x6 := (uint64(arg1[26]) << 16) + x7 := (uint64(arg1[25]) << 8) + x8 := arg1[24] + x9 := (uint64(arg1[23]) << 56) + x10 := (uint64(arg1[22]) << 48) + x11 := (uint64(arg1[21]) << 40) + x12 := (uint64(arg1[20]) << 32) + x13 := (uint64(arg1[19]) << 24) + x14 := (uint64(arg1[18]) << 16) + x15 := (uint64(arg1[17]) << 8) + x16 := arg1[16] + x17 := (uint64(arg1[15]) << 56) + x18 := (uint64(arg1[14]) << 48) + x19 := (uint64(arg1[13]) << 40) + x20 := (uint64(arg1[12]) << 32) + x21 := (uint64(arg1[11]) << 24) + x22 := (uint64(arg1[10]) << 16) + x23 := (uint64(arg1[9]) << 8) + x24 := arg1[8] + x25 := (uint64(arg1[7]) << 56) + x26 := (uint64(arg1[6]) << 48) + x27 := (uint64(arg1[5]) << 40) + x28 := (uint64(arg1[4]) << 32) + x29 := (uint64(arg1[3]) << 24) + x30 := (uint64(arg1[2]) << 16) + x31 := (uint64(arg1[1]) << 8) + x32 := arg1[0] + x33 := (x31 + uint64(x32)) + x34 := (x30 + x33) + x35 := (x29 + x34) + x36 := (x28 + x35) + x37 := (x27 + x36) + x38 := (x26 + x37) + x39 := (x25 + x38) + x40 := (x23 + uint64(x24)) + x41 := (x22 + x40) + x42 := (x21 + x41) + x43 := (x20 + x42) + x44 := (x19 + x43) + x45 := (x18 + x44) + x46 := (x17 + x45) + x47 := (x15 + uint64(x16)) + x48 := (x14 + x47) + x49 := (x13 + x48) + x50 := (x12 + x49) + x51 := (x11 + x50) + x52 := (x10 + x51) + x53 := (x9 + x52) + x54 := (x7 + uint64(x8)) + x55 := (x6 + x54) + x56 := (x5 + x55) + x57 := (x4 + x56) + x58 := (x3 + x57) + x59 := (x2 + x58) + x60 := (x1 + x59) + out1[0] = x39 + out1[1] = x46 + out1[2] = x53 + out1[3] = x60 +} + +// SetOne returns the field element one in the Montgomery domain. +// +// Postconditions: +// eval (from_montgomery out1) mod m = 1 mod m +// 0 ≤ eval out1 < m +// +func SetOne(out1 *MontgomeryDomainFieldElement) { + out1[0] = 0xd6ec31748d98951d + out1[1] = 0xc6ef5bf4737dcf70 + out1[2] = 0xfffffffffffffffe + out1[3] = 0xfffffffffffffff +} + +// Msat returns the saturated representation of the prime modulus. +// +// Postconditions: +// twos_complement_eval out1 = m +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func Msat(out1 *[5]uint64) { + out1[0] = 0x5812631a5cf5d3ed + out1[1] = 0x14def9dea2f79cd6 + out1[2] = uint64(0x0) + out1[3] = 0x1000000000000000 + out1[4] = uint64(0x0) +} + +// Divstep computes a divstep. +// +// Preconditions: +// 0 ≤ eval arg4 < m +// 0 ≤ eval arg5 < m +// Postconditions: +// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +// 0 ≤ eval out5 < m +// 0 ≤ eval out5 < m +// 0 ≤ eval out2 < m +// 0 ≤ eval out3 < m +// +// Input Bounds: +// arg1: [0x0 ~> 0xffffffffffffffff] +// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffffffffffff] +// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func Divstep(out1 *uint64, out2 *[5]uint64, out3 *[5]uint64, out4 *[4]uint64, out5 *[4]uint64, arg1 uint64, arg2 *[5]uint64, arg3 *[5]uint64, arg4 *[4]uint64, arg5 *[4]uint64) { + var x1 uint64 + x1, _ = bits.Add64((^arg1), uint64(0x1), uint64(0x0)) + x3 := (uint1((x1 >> 63)) & (uint1(arg3[0]) & 0x1)) + var x4 uint64 + x4, _ = bits.Add64((^arg1), uint64(0x1), uint64(0x0)) + var x6 uint64 + cmovznzU64(&x6, x3, arg1, x4) + var x7 uint64 + cmovznzU64(&x7, x3, arg2[0], arg3[0]) + var x8 uint64 + cmovznzU64(&x8, x3, arg2[1], arg3[1]) + var x9 uint64 + cmovznzU64(&x9, x3, arg2[2], arg3[2]) + var x10 uint64 + cmovznzU64(&x10, x3, arg2[3], arg3[3]) + var x11 uint64 + cmovznzU64(&x11, x3, arg2[4], arg3[4]) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(uint64(0x1), (^arg2[0]), uint64(0x0)) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(uint64(0x0), (^arg2[1]), uint64(uint1(x13))) + var x16 uint64 + var x17 uint64 + x16, x17 = bits.Add64(uint64(0x0), (^arg2[2]), uint64(uint1(x15))) + var x18 uint64 + var x19 uint64 + x18, x19 = bits.Add64(uint64(0x0), (^arg2[3]), uint64(uint1(x17))) + var x20 uint64 + x20, _ = bits.Add64(uint64(0x0), (^arg2[4]), uint64(uint1(x19))) + var x22 uint64 + cmovznzU64(&x22, x3, arg3[0], x12) + var x23 uint64 + cmovznzU64(&x23, x3, arg3[1], x14) + var x24 uint64 + cmovznzU64(&x24, x3, arg3[2], x16) + var x25 uint64 + cmovznzU64(&x25, x3, arg3[3], x18) + var x26 uint64 + cmovznzU64(&x26, x3, arg3[4], x20) + var x27 uint64 + cmovznzU64(&x27, x3, arg4[0], arg5[0]) + var x28 uint64 + cmovznzU64(&x28, x3, arg4[1], arg5[1]) + var x29 uint64 + cmovznzU64(&x29, x3, arg4[2], arg5[2]) + var x30 uint64 + cmovznzU64(&x30, x3, arg4[3], arg5[3]) + var x31 uint64 + var x32 uint64 + x31, x32 = bits.Add64(x27, x27, uint64(0x0)) + var x33 uint64 + var x34 uint64 + x33, x34 = bits.Add64(x28, x28, uint64(uint1(x32))) + var x35 uint64 + var x36 uint64 + x35, x36 = bits.Add64(x29, x29, uint64(uint1(x34))) + var x37 uint64 + var x38 uint64 + x37, x38 = bits.Add64(x30, x30, uint64(uint1(x36))) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Sub64(x31, 0x5812631a5cf5d3ed, uint64(0x0)) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Sub64(x33, 0x14def9dea2f79cd6, uint64(uint1(x40))) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Sub64(x35, uint64(0x0), uint64(uint1(x42))) + var x45 uint64 + var x46 uint64 + x45, x46 = bits.Sub64(x37, 0x1000000000000000, uint64(uint1(x44))) + var x48 uint64 + _, x48 = bits.Sub64(uint64(uint1(x38)), uint64(0x0), uint64(uint1(x46))) + x49 := arg4[3] + x50 := arg4[2] + x51 := arg4[1] + x52 := arg4[0] + var x53 uint64 + var x54 uint64 + x53, x54 = bits.Sub64(uint64(0x0), x52, uint64(0x0)) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Sub64(uint64(0x0), x51, uint64(uint1(x54))) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Sub64(uint64(0x0), x50, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Sub64(uint64(0x0), x49, uint64(uint1(x58))) + var x61 uint64 + cmovznzU64(&x61, uint1(x60), uint64(0x0), 0xffffffffffffffff) + var x62 uint64 + var x63 uint64 + x62, x63 = bits.Add64(x53, (x61 & 0x5812631a5cf5d3ed), uint64(0x0)) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(x55, (x61 & 0x14def9dea2f79cd6), uint64(uint1(x63))) + var x66 uint64 + var x67 uint64 + x66, x67 = bits.Add64(x57, uint64(0x0), uint64(uint1(x65))) + var x68 uint64 + x68, _ = bits.Add64(x59, (x61 & 0x1000000000000000), uint64(uint1(x67))) + var x70 uint64 + cmovznzU64(&x70, x3, arg5[0], x62) + var x71 uint64 + cmovznzU64(&x71, x3, arg5[1], x64) + var x72 uint64 + cmovznzU64(&x72, x3, arg5[2], x66) + var x73 uint64 + cmovznzU64(&x73, x3, arg5[3], x68) + x74 := (uint1(x22) & 0x1) + var x75 uint64 + cmovznzU64(&x75, x74, uint64(0x0), x7) + var x76 uint64 + cmovznzU64(&x76, x74, uint64(0x0), x8) + var x77 uint64 + cmovznzU64(&x77, x74, uint64(0x0), x9) + var x78 uint64 + cmovznzU64(&x78, x74, uint64(0x0), x10) + var x79 uint64 + cmovznzU64(&x79, x74, uint64(0x0), x11) + var x80 uint64 + var x81 uint64 + x80, x81 = bits.Add64(x22, x75, uint64(0x0)) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x23, x76, uint64(uint1(x81))) + var x84 uint64 + var x85 uint64 + x84, x85 = bits.Add64(x24, x77, uint64(uint1(x83))) + var x86 uint64 + var x87 uint64 + x86, x87 = bits.Add64(x25, x78, uint64(uint1(x85))) + var x88 uint64 + x88, _ = bits.Add64(x26, x79, uint64(uint1(x87))) + var x90 uint64 + cmovznzU64(&x90, x74, uint64(0x0), x27) + var x91 uint64 + cmovznzU64(&x91, x74, uint64(0x0), x28) + var x92 uint64 + cmovznzU64(&x92, x74, uint64(0x0), x29) + var x93 uint64 + cmovznzU64(&x93, x74, uint64(0x0), x30) + var x94 uint64 + var x95 uint64 + x94, x95 = bits.Add64(x70, x90, uint64(0x0)) + var x96 uint64 + var x97 uint64 + x96, x97 = bits.Add64(x71, x91, uint64(uint1(x95))) + var x98 uint64 + var x99 uint64 + x98, x99 = bits.Add64(x72, x92, uint64(uint1(x97))) + var x100 uint64 + var x101 uint64 + x100, x101 = bits.Add64(x73, x93, uint64(uint1(x99))) + var x102 uint64 + var x103 uint64 + x102, x103 = bits.Sub64(x94, 0x5812631a5cf5d3ed, uint64(0x0)) + var x104 uint64 + var x105 uint64 + x104, x105 = bits.Sub64(x96, 0x14def9dea2f79cd6, uint64(uint1(x103))) + var x106 uint64 + var x107 uint64 + x106, x107 = bits.Sub64(x98, uint64(0x0), uint64(uint1(x105))) + var x108 uint64 + var x109 uint64 + x108, x109 = bits.Sub64(x100, 0x1000000000000000, uint64(uint1(x107))) + var x111 uint64 + _, x111 = bits.Sub64(uint64(uint1(x101)), uint64(0x0), uint64(uint1(x109))) + var x112 uint64 + x112, _ = bits.Add64(x6, uint64(0x1), uint64(0x0)) + x114 := ((x80 >> 1) | ((x82 << 63) & 0xffffffffffffffff)) + x115 := ((x82 >> 1) | ((x84 << 63) & 0xffffffffffffffff)) + x116 := ((x84 >> 1) | ((x86 << 63) & 0xffffffffffffffff)) + x117 := ((x86 >> 1) | ((x88 << 63) & 0xffffffffffffffff)) + x118 := ((x88 & 0x8000000000000000) | (x88 >> 1)) + var x119 uint64 + cmovznzU64(&x119, uint1(x48), x39, x31) + var x120 uint64 + cmovznzU64(&x120, uint1(x48), x41, x33) + var x121 uint64 + cmovznzU64(&x121, uint1(x48), x43, x35) + var x122 uint64 + cmovznzU64(&x122, uint1(x48), x45, x37) + var x123 uint64 + cmovznzU64(&x123, uint1(x111), x102, x94) + var x124 uint64 + cmovznzU64(&x124, uint1(x111), x104, x96) + var x125 uint64 + cmovznzU64(&x125, uint1(x111), x106, x98) + var x126 uint64 + cmovznzU64(&x126, uint1(x111), x108, x100) + *out1 = x112 + out2[0] = x7 + out2[1] = x8 + out2[2] = x9 + out2[3] = x10 + out2[4] = x11 + out3[0] = x114 + out3[1] = x115 + out3[2] = x116 + out3[3] = x117 + out3[4] = x118 + out4[0] = x119 + out4[1] = x120 + out4[2] = x121 + out4[3] = x122 + out5[0] = x123 + out5[1] = x124 + out5[2] = x125 + out5[3] = x126 +} + +// DivstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +// +// Postconditions: +// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func DivstepPrecomp(out1 *[4]uint64) { + out1[0] = 0xd70af84436a7cb92 + out1[1] = 0x5f71c978b0b8b159 + out1[2] = 0xe76d816974947f1a + out1[3] = 0x19a2d36f193e4ff +} diff --git a/fiat-go/64/p256scalar/p256scalar.go b/fiat-go/64/p256scalar/p256scalar.go new file mode 100644 index 0000000000..fd94528e7e --- /dev/null +++ b/fiat-go/64/p256scalar/p256scalar.go @@ -0,0 +1,1890 @@ +// Code generated by Fiat Cryptography. DO NOT EDIT. +// +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Go --no-wide-int --relax-primitive-carry-to-bitwidth 32,64 --cmovznz-by-mul --internal-static --package-case flatcase --public-function-case UpperCamelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case camelCase --no-prefix-fiat --doc-newline-in-typedef-bounds --doc-prepend-header 'Code generated by Fiat Cryptography. DO NOT EDIT.' --doc-text-before-function-name '' --doc-text-before-type-name '' --package-name p256scalar '' 64 '2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// +// curve description (via package name): p256scalar +// +// machine_wordsize = 64 (from "64") +// +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// +// m = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 (from "2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247") +// +// +// +// NOTE: In addition to the bounds specified above each function, all +// +// functions synthesized for this Montgomery arithmetic require the +// +// input to be strictly less than the prime modulus (m), and also +// +// require the input to be in the unique saturated representation. +// +// All functions also ensure that these two properties are true of +// +// return values. +// +// +// +// Computed values: +// +// eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) +// +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +// +// twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in +// +// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 +package p256scalar + +import "math/bits" + +type uint1 uint64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 +type int1 int64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 + +// MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +type MontgomeryDomainFieldElement [4]uint64 + +// NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +type NonMontgomeryDomainFieldElement [4]uint64 + +// cmovznzU64 is a single-word conditional move. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [0x0 ~> 0xffffffffffffffff] +// arg3: [0x0 ~> 0xffffffffffffffff] +// Output Bounds: +// out1: [0x0 ~> 0xffffffffffffffff] +func cmovznzU64(out1 *uint64, arg1 uint1, arg2 uint64, arg3 uint64) { + x1 := (uint64(arg1) * 0xffffffffffffffff) + x2 := ((x1 & arg3) | ((^x1) & arg2)) + *out1 = x2 +} + +// Mul multiplies two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Mul(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[0] + var x5 uint64 + var x6 uint64 + x6, x5 = bits.Mul64(x4, arg2[3]) + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x4, arg2[2]) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x4, arg2[1]) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x4, arg2[0]) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Add64(x12, x9, uint64(0x0)) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Add64(x10, x7, uint64(uint1(x14))) + var x17 uint64 + var x18 uint64 + x17, x18 = bits.Add64(x8, x5, uint64(uint1(x16))) + x19 := (uint64(uint1(x18)) + x6) + var x20 uint64 + _, x20 = bits.Mul64(x11, 0xccd1c8aaee00bc4f) + var x22 uint64 + var x23 uint64 + x23, x22 = bits.Mul64(x20, 0xffffffff00000000) + var x24 uint64 + var x25 uint64 + x25, x24 = bits.Mul64(x20, 0xffffffffffffffff) + var x26 uint64 + var x27 uint64 + x27, x26 = bits.Mul64(x20, 0xbce6faada7179e84) + var x28 uint64 + var x29 uint64 + x29, x28 = bits.Mul64(x20, 0xf3b9cac2fc632551) + var x30 uint64 + var x31 uint64 + x30, x31 = bits.Add64(x29, x26, uint64(0x0)) + var x32 uint64 + var x33 uint64 + x32, x33 = bits.Add64(x27, x24, uint64(uint1(x31))) + var x34 uint64 + var x35 uint64 + x34, x35 = bits.Add64(x25, x22, uint64(uint1(x33))) + x36 := (uint64(uint1(x35)) + x23) + var x38 uint64 + _, x38 = bits.Add64(x11, x28, uint64(0x0)) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Add64(x13, x30, uint64(uint1(x38))) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Add64(x15, x32, uint64(uint1(x40))) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Add64(x17, x34, uint64(uint1(x42))) + var x45 uint64 + var x46 uint64 + x45, x46 = bits.Add64(x19, x36, uint64(uint1(x44))) + var x47 uint64 + var x48 uint64 + x48, x47 = bits.Mul64(x1, arg2[3]) + var x49 uint64 + var x50 uint64 + x50, x49 = bits.Mul64(x1, arg2[2]) + var x51 uint64 + var x52 uint64 + x52, x51 = bits.Mul64(x1, arg2[1]) + var x53 uint64 + var x54 uint64 + x54, x53 = bits.Mul64(x1, arg2[0]) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Add64(x54, x51, uint64(0x0)) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Add64(x52, x49, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Add64(x50, x47, uint64(uint1(x58))) + x61 := (uint64(uint1(x60)) + x48) + var x62 uint64 + var x63 uint64 + x62, x63 = bits.Add64(x39, x53, uint64(0x0)) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(x41, x55, uint64(uint1(x63))) + var x66 uint64 + var x67 uint64 + x66, x67 = bits.Add64(x43, x57, uint64(uint1(x65))) + var x68 uint64 + var x69 uint64 + x68, x69 = bits.Add64(x45, x59, uint64(uint1(x67))) + var x70 uint64 + var x71 uint64 + x70, x71 = bits.Add64(uint64(uint1(x46)), x61, uint64(uint1(x69))) + var x72 uint64 + _, x72 = bits.Mul64(x62, 0xccd1c8aaee00bc4f) + var x74 uint64 + var x75 uint64 + x75, x74 = bits.Mul64(x72, 0xffffffff00000000) + var x76 uint64 + var x77 uint64 + x77, x76 = bits.Mul64(x72, 0xffffffffffffffff) + var x78 uint64 + var x79 uint64 + x79, x78 = bits.Mul64(x72, 0xbce6faada7179e84) + var x80 uint64 + var x81 uint64 + x81, x80 = bits.Mul64(x72, 0xf3b9cac2fc632551) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x81, x78, uint64(0x0)) + var x84 uint64 + var x85 uint64 + x84, x85 = bits.Add64(x79, x76, uint64(uint1(x83))) + var x86 uint64 + var x87 uint64 + x86, x87 = bits.Add64(x77, x74, uint64(uint1(x85))) + x88 := (uint64(uint1(x87)) + x75) + var x90 uint64 + _, x90 = bits.Add64(x62, x80, uint64(0x0)) + var x91 uint64 + var x92 uint64 + x91, x92 = bits.Add64(x64, x82, uint64(uint1(x90))) + var x93 uint64 + var x94 uint64 + x93, x94 = bits.Add64(x66, x84, uint64(uint1(x92))) + var x95 uint64 + var x96 uint64 + x95, x96 = bits.Add64(x68, x86, uint64(uint1(x94))) + var x97 uint64 + var x98 uint64 + x97, x98 = bits.Add64(x70, x88, uint64(uint1(x96))) + x99 := (uint64(uint1(x98)) + uint64(uint1(x71))) + var x100 uint64 + var x101 uint64 + x101, x100 = bits.Mul64(x2, arg2[3]) + var x102 uint64 + var x103 uint64 + x103, x102 = bits.Mul64(x2, arg2[2]) + var x104 uint64 + var x105 uint64 + x105, x104 = bits.Mul64(x2, arg2[1]) + var x106 uint64 + var x107 uint64 + x107, x106 = bits.Mul64(x2, arg2[0]) + var x108 uint64 + var x109 uint64 + x108, x109 = bits.Add64(x107, x104, uint64(0x0)) + var x110 uint64 + var x111 uint64 + x110, x111 = bits.Add64(x105, x102, uint64(uint1(x109))) + var x112 uint64 + var x113 uint64 + x112, x113 = bits.Add64(x103, x100, uint64(uint1(x111))) + x114 := (uint64(uint1(x113)) + x101) + var x115 uint64 + var x116 uint64 + x115, x116 = bits.Add64(x91, x106, uint64(0x0)) + var x117 uint64 + var x118 uint64 + x117, x118 = bits.Add64(x93, x108, uint64(uint1(x116))) + var x119 uint64 + var x120 uint64 + x119, x120 = bits.Add64(x95, x110, uint64(uint1(x118))) + var x121 uint64 + var x122 uint64 + x121, x122 = bits.Add64(x97, x112, uint64(uint1(x120))) + var x123 uint64 + var x124 uint64 + x123, x124 = bits.Add64(x99, x114, uint64(uint1(x122))) + var x125 uint64 + _, x125 = bits.Mul64(x115, 0xccd1c8aaee00bc4f) + var x127 uint64 + var x128 uint64 + x128, x127 = bits.Mul64(x125, 0xffffffff00000000) + var x129 uint64 + var x130 uint64 + x130, x129 = bits.Mul64(x125, 0xffffffffffffffff) + var x131 uint64 + var x132 uint64 + x132, x131 = bits.Mul64(x125, 0xbce6faada7179e84) + var x133 uint64 + var x134 uint64 + x134, x133 = bits.Mul64(x125, 0xf3b9cac2fc632551) + var x135 uint64 + var x136 uint64 + x135, x136 = bits.Add64(x134, x131, uint64(0x0)) + var x137 uint64 + var x138 uint64 + x137, x138 = bits.Add64(x132, x129, uint64(uint1(x136))) + var x139 uint64 + var x140 uint64 + x139, x140 = bits.Add64(x130, x127, uint64(uint1(x138))) + x141 := (uint64(uint1(x140)) + x128) + var x143 uint64 + _, x143 = bits.Add64(x115, x133, uint64(0x0)) + var x144 uint64 + var x145 uint64 + x144, x145 = bits.Add64(x117, x135, uint64(uint1(x143))) + var x146 uint64 + var x147 uint64 + x146, x147 = bits.Add64(x119, x137, uint64(uint1(x145))) + var x148 uint64 + var x149 uint64 + x148, x149 = bits.Add64(x121, x139, uint64(uint1(x147))) + var x150 uint64 + var x151 uint64 + x150, x151 = bits.Add64(x123, x141, uint64(uint1(x149))) + x152 := (uint64(uint1(x151)) + uint64(uint1(x124))) + var x153 uint64 + var x154 uint64 + x154, x153 = bits.Mul64(x3, arg2[3]) + var x155 uint64 + var x156 uint64 + x156, x155 = bits.Mul64(x3, arg2[2]) + var x157 uint64 + var x158 uint64 + x158, x157 = bits.Mul64(x3, arg2[1]) + var x159 uint64 + var x160 uint64 + x160, x159 = bits.Mul64(x3, arg2[0]) + var x161 uint64 + var x162 uint64 + x161, x162 = bits.Add64(x160, x157, uint64(0x0)) + var x163 uint64 + var x164 uint64 + x163, x164 = bits.Add64(x158, x155, uint64(uint1(x162))) + var x165 uint64 + var x166 uint64 + x165, x166 = bits.Add64(x156, x153, uint64(uint1(x164))) + x167 := (uint64(uint1(x166)) + x154) + var x168 uint64 + var x169 uint64 + x168, x169 = bits.Add64(x144, x159, uint64(0x0)) + var x170 uint64 + var x171 uint64 + x170, x171 = bits.Add64(x146, x161, uint64(uint1(x169))) + var x172 uint64 + var x173 uint64 + x172, x173 = bits.Add64(x148, x163, uint64(uint1(x171))) + var x174 uint64 + var x175 uint64 + x174, x175 = bits.Add64(x150, x165, uint64(uint1(x173))) + var x176 uint64 + var x177 uint64 + x176, x177 = bits.Add64(x152, x167, uint64(uint1(x175))) + var x178 uint64 + _, x178 = bits.Mul64(x168, 0xccd1c8aaee00bc4f) + var x180 uint64 + var x181 uint64 + x181, x180 = bits.Mul64(x178, 0xffffffff00000000) + var x182 uint64 + var x183 uint64 + x183, x182 = bits.Mul64(x178, 0xffffffffffffffff) + var x184 uint64 + var x185 uint64 + x185, x184 = bits.Mul64(x178, 0xbce6faada7179e84) + var x186 uint64 + var x187 uint64 + x187, x186 = bits.Mul64(x178, 0xf3b9cac2fc632551) + var x188 uint64 + var x189 uint64 + x188, x189 = bits.Add64(x187, x184, uint64(0x0)) + var x190 uint64 + var x191 uint64 + x190, x191 = bits.Add64(x185, x182, uint64(uint1(x189))) + var x192 uint64 + var x193 uint64 + x192, x193 = bits.Add64(x183, x180, uint64(uint1(x191))) + x194 := (uint64(uint1(x193)) + x181) + var x196 uint64 + _, x196 = bits.Add64(x168, x186, uint64(0x0)) + var x197 uint64 + var x198 uint64 + x197, x198 = bits.Add64(x170, x188, uint64(uint1(x196))) + var x199 uint64 + var x200 uint64 + x199, x200 = bits.Add64(x172, x190, uint64(uint1(x198))) + var x201 uint64 + var x202 uint64 + x201, x202 = bits.Add64(x174, x192, uint64(uint1(x200))) + var x203 uint64 + var x204 uint64 + x203, x204 = bits.Add64(x176, x194, uint64(uint1(x202))) + x205 := (uint64(uint1(x204)) + uint64(uint1(x177))) + var x206 uint64 + var x207 uint64 + x206, x207 = bits.Sub64(x197, 0xf3b9cac2fc632551, uint64(0x0)) + var x208 uint64 + var x209 uint64 + x208, x209 = bits.Sub64(x199, 0xbce6faada7179e84, uint64(uint1(x207))) + var x210 uint64 + var x211 uint64 + x210, x211 = bits.Sub64(x201, 0xffffffffffffffff, uint64(uint1(x209))) + var x212 uint64 + var x213 uint64 + x212, x213 = bits.Sub64(x203, 0xffffffff00000000, uint64(uint1(x211))) + var x215 uint64 + _, x215 = bits.Sub64(x205, uint64(0x0), uint64(uint1(x213))) + var x216 uint64 + cmovznzU64(&x216, uint1(x215), x206, x197) + var x217 uint64 + cmovznzU64(&x217, uint1(x215), x208, x199) + var x218 uint64 + cmovznzU64(&x218, uint1(x215), x210, x201) + var x219 uint64 + cmovznzU64(&x219, uint1(x215), x212, x203) + out1[0] = x216 + out1[1] = x217 + out1[2] = x218 + out1[3] = x219 +} + +// Square squares a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +// 0 ≤ eval out1 < m +// +func Square(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[0] + var x5 uint64 + var x6 uint64 + x6, x5 = bits.Mul64(x4, arg1[3]) + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x4, arg1[2]) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x4, arg1[1]) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x4, arg1[0]) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Add64(x12, x9, uint64(0x0)) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Add64(x10, x7, uint64(uint1(x14))) + var x17 uint64 + var x18 uint64 + x17, x18 = bits.Add64(x8, x5, uint64(uint1(x16))) + x19 := (uint64(uint1(x18)) + x6) + var x20 uint64 + _, x20 = bits.Mul64(x11, 0xccd1c8aaee00bc4f) + var x22 uint64 + var x23 uint64 + x23, x22 = bits.Mul64(x20, 0xffffffff00000000) + var x24 uint64 + var x25 uint64 + x25, x24 = bits.Mul64(x20, 0xffffffffffffffff) + var x26 uint64 + var x27 uint64 + x27, x26 = bits.Mul64(x20, 0xbce6faada7179e84) + var x28 uint64 + var x29 uint64 + x29, x28 = bits.Mul64(x20, 0xf3b9cac2fc632551) + var x30 uint64 + var x31 uint64 + x30, x31 = bits.Add64(x29, x26, uint64(0x0)) + var x32 uint64 + var x33 uint64 + x32, x33 = bits.Add64(x27, x24, uint64(uint1(x31))) + var x34 uint64 + var x35 uint64 + x34, x35 = bits.Add64(x25, x22, uint64(uint1(x33))) + x36 := (uint64(uint1(x35)) + x23) + var x38 uint64 + _, x38 = bits.Add64(x11, x28, uint64(0x0)) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Add64(x13, x30, uint64(uint1(x38))) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Add64(x15, x32, uint64(uint1(x40))) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Add64(x17, x34, uint64(uint1(x42))) + var x45 uint64 + var x46 uint64 + x45, x46 = bits.Add64(x19, x36, uint64(uint1(x44))) + var x47 uint64 + var x48 uint64 + x48, x47 = bits.Mul64(x1, arg1[3]) + var x49 uint64 + var x50 uint64 + x50, x49 = bits.Mul64(x1, arg1[2]) + var x51 uint64 + var x52 uint64 + x52, x51 = bits.Mul64(x1, arg1[1]) + var x53 uint64 + var x54 uint64 + x54, x53 = bits.Mul64(x1, arg1[0]) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Add64(x54, x51, uint64(0x0)) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Add64(x52, x49, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Add64(x50, x47, uint64(uint1(x58))) + x61 := (uint64(uint1(x60)) + x48) + var x62 uint64 + var x63 uint64 + x62, x63 = bits.Add64(x39, x53, uint64(0x0)) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(x41, x55, uint64(uint1(x63))) + var x66 uint64 + var x67 uint64 + x66, x67 = bits.Add64(x43, x57, uint64(uint1(x65))) + var x68 uint64 + var x69 uint64 + x68, x69 = bits.Add64(x45, x59, uint64(uint1(x67))) + var x70 uint64 + var x71 uint64 + x70, x71 = bits.Add64(uint64(uint1(x46)), x61, uint64(uint1(x69))) + var x72 uint64 + _, x72 = bits.Mul64(x62, 0xccd1c8aaee00bc4f) + var x74 uint64 + var x75 uint64 + x75, x74 = bits.Mul64(x72, 0xffffffff00000000) + var x76 uint64 + var x77 uint64 + x77, x76 = bits.Mul64(x72, 0xffffffffffffffff) + var x78 uint64 + var x79 uint64 + x79, x78 = bits.Mul64(x72, 0xbce6faada7179e84) + var x80 uint64 + var x81 uint64 + x81, x80 = bits.Mul64(x72, 0xf3b9cac2fc632551) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x81, x78, uint64(0x0)) + var x84 uint64 + var x85 uint64 + x84, x85 = bits.Add64(x79, x76, uint64(uint1(x83))) + var x86 uint64 + var x87 uint64 + x86, x87 = bits.Add64(x77, x74, uint64(uint1(x85))) + x88 := (uint64(uint1(x87)) + x75) + var x90 uint64 + _, x90 = bits.Add64(x62, x80, uint64(0x0)) + var x91 uint64 + var x92 uint64 + x91, x92 = bits.Add64(x64, x82, uint64(uint1(x90))) + var x93 uint64 + var x94 uint64 + x93, x94 = bits.Add64(x66, x84, uint64(uint1(x92))) + var x95 uint64 + var x96 uint64 + x95, x96 = bits.Add64(x68, x86, uint64(uint1(x94))) + var x97 uint64 + var x98 uint64 + x97, x98 = bits.Add64(x70, x88, uint64(uint1(x96))) + x99 := (uint64(uint1(x98)) + uint64(uint1(x71))) + var x100 uint64 + var x101 uint64 + x101, x100 = bits.Mul64(x2, arg1[3]) + var x102 uint64 + var x103 uint64 + x103, x102 = bits.Mul64(x2, arg1[2]) + var x104 uint64 + var x105 uint64 + x105, x104 = bits.Mul64(x2, arg1[1]) + var x106 uint64 + var x107 uint64 + x107, x106 = bits.Mul64(x2, arg1[0]) + var x108 uint64 + var x109 uint64 + x108, x109 = bits.Add64(x107, x104, uint64(0x0)) + var x110 uint64 + var x111 uint64 + x110, x111 = bits.Add64(x105, x102, uint64(uint1(x109))) + var x112 uint64 + var x113 uint64 + x112, x113 = bits.Add64(x103, x100, uint64(uint1(x111))) + x114 := (uint64(uint1(x113)) + x101) + var x115 uint64 + var x116 uint64 + x115, x116 = bits.Add64(x91, x106, uint64(0x0)) + var x117 uint64 + var x118 uint64 + x117, x118 = bits.Add64(x93, x108, uint64(uint1(x116))) + var x119 uint64 + var x120 uint64 + x119, x120 = bits.Add64(x95, x110, uint64(uint1(x118))) + var x121 uint64 + var x122 uint64 + x121, x122 = bits.Add64(x97, x112, uint64(uint1(x120))) + var x123 uint64 + var x124 uint64 + x123, x124 = bits.Add64(x99, x114, uint64(uint1(x122))) + var x125 uint64 + _, x125 = bits.Mul64(x115, 0xccd1c8aaee00bc4f) + var x127 uint64 + var x128 uint64 + x128, x127 = bits.Mul64(x125, 0xffffffff00000000) + var x129 uint64 + var x130 uint64 + x130, x129 = bits.Mul64(x125, 0xffffffffffffffff) + var x131 uint64 + var x132 uint64 + x132, x131 = bits.Mul64(x125, 0xbce6faada7179e84) + var x133 uint64 + var x134 uint64 + x134, x133 = bits.Mul64(x125, 0xf3b9cac2fc632551) + var x135 uint64 + var x136 uint64 + x135, x136 = bits.Add64(x134, x131, uint64(0x0)) + var x137 uint64 + var x138 uint64 + x137, x138 = bits.Add64(x132, x129, uint64(uint1(x136))) + var x139 uint64 + var x140 uint64 + x139, x140 = bits.Add64(x130, x127, uint64(uint1(x138))) + x141 := (uint64(uint1(x140)) + x128) + var x143 uint64 + _, x143 = bits.Add64(x115, x133, uint64(0x0)) + var x144 uint64 + var x145 uint64 + x144, x145 = bits.Add64(x117, x135, uint64(uint1(x143))) + var x146 uint64 + var x147 uint64 + x146, x147 = bits.Add64(x119, x137, uint64(uint1(x145))) + var x148 uint64 + var x149 uint64 + x148, x149 = bits.Add64(x121, x139, uint64(uint1(x147))) + var x150 uint64 + var x151 uint64 + x150, x151 = bits.Add64(x123, x141, uint64(uint1(x149))) + x152 := (uint64(uint1(x151)) + uint64(uint1(x124))) + var x153 uint64 + var x154 uint64 + x154, x153 = bits.Mul64(x3, arg1[3]) + var x155 uint64 + var x156 uint64 + x156, x155 = bits.Mul64(x3, arg1[2]) + var x157 uint64 + var x158 uint64 + x158, x157 = bits.Mul64(x3, arg1[1]) + var x159 uint64 + var x160 uint64 + x160, x159 = bits.Mul64(x3, arg1[0]) + var x161 uint64 + var x162 uint64 + x161, x162 = bits.Add64(x160, x157, uint64(0x0)) + var x163 uint64 + var x164 uint64 + x163, x164 = bits.Add64(x158, x155, uint64(uint1(x162))) + var x165 uint64 + var x166 uint64 + x165, x166 = bits.Add64(x156, x153, uint64(uint1(x164))) + x167 := (uint64(uint1(x166)) + x154) + var x168 uint64 + var x169 uint64 + x168, x169 = bits.Add64(x144, x159, uint64(0x0)) + var x170 uint64 + var x171 uint64 + x170, x171 = bits.Add64(x146, x161, uint64(uint1(x169))) + var x172 uint64 + var x173 uint64 + x172, x173 = bits.Add64(x148, x163, uint64(uint1(x171))) + var x174 uint64 + var x175 uint64 + x174, x175 = bits.Add64(x150, x165, uint64(uint1(x173))) + var x176 uint64 + var x177 uint64 + x176, x177 = bits.Add64(x152, x167, uint64(uint1(x175))) + var x178 uint64 + _, x178 = bits.Mul64(x168, 0xccd1c8aaee00bc4f) + var x180 uint64 + var x181 uint64 + x181, x180 = bits.Mul64(x178, 0xffffffff00000000) + var x182 uint64 + var x183 uint64 + x183, x182 = bits.Mul64(x178, 0xffffffffffffffff) + var x184 uint64 + var x185 uint64 + x185, x184 = bits.Mul64(x178, 0xbce6faada7179e84) + var x186 uint64 + var x187 uint64 + x187, x186 = bits.Mul64(x178, 0xf3b9cac2fc632551) + var x188 uint64 + var x189 uint64 + x188, x189 = bits.Add64(x187, x184, uint64(0x0)) + var x190 uint64 + var x191 uint64 + x190, x191 = bits.Add64(x185, x182, uint64(uint1(x189))) + var x192 uint64 + var x193 uint64 + x192, x193 = bits.Add64(x183, x180, uint64(uint1(x191))) + x194 := (uint64(uint1(x193)) + x181) + var x196 uint64 + _, x196 = bits.Add64(x168, x186, uint64(0x0)) + var x197 uint64 + var x198 uint64 + x197, x198 = bits.Add64(x170, x188, uint64(uint1(x196))) + var x199 uint64 + var x200 uint64 + x199, x200 = bits.Add64(x172, x190, uint64(uint1(x198))) + var x201 uint64 + var x202 uint64 + x201, x202 = bits.Add64(x174, x192, uint64(uint1(x200))) + var x203 uint64 + var x204 uint64 + x203, x204 = bits.Add64(x176, x194, uint64(uint1(x202))) + x205 := (uint64(uint1(x204)) + uint64(uint1(x177))) + var x206 uint64 + var x207 uint64 + x206, x207 = bits.Sub64(x197, 0xf3b9cac2fc632551, uint64(0x0)) + var x208 uint64 + var x209 uint64 + x208, x209 = bits.Sub64(x199, 0xbce6faada7179e84, uint64(uint1(x207))) + var x210 uint64 + var x211 uint64 + x210, x211 = bits.Sub64(x201, 0xffffffffffffffff, uint64(uint1(x209))) + var x212 uint64 + var x213 uint64 + x212, x213 = bits.Sub64(x203, 0xffffffff00000000, uint64(uint1(x211))) + var x215 uint64 + _, x215 = bits.Sub64(x205, uint64(0x0), uint64(uint1(x213))) + var x216 uint64 + cmovznzU64(&x216, uint1(x215), x206, x197) + var x217 uint64 + cmovznzU64(&x217, uint1(x215), x208, x199) + var x218 uint64 + cmovznzU64(&x218, uint1(x215), x210, x201) + var x219 uint64 + cmovznzU64(&x219, uint1(x215), x212, x203) + out1[0] = x216 + out1[1] = x217 + out1[2] = x218 + out1[3] = x219 +} + +// Add adds two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Add(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint64 + var x2 uint64 + x1, x2 = bits.Add64(arg1[0], arg2[0], uint64(0x0)) + var x3 uint64 + var x4 uint64 + x3, x4 = bits.Add64(arg1[1], arg2[1], uint64(uint1(x2))) + var x5 uint64 + var x6 uint64 + x5, x6 = bits.Add64(arg1[2], arg2[2], uint64(uint1(x4))) + var x7 uint64 + var x8 uint64 + x7, x8 = bits.Add64(arg1[3], arg2[3], uint64(uint1(x6))) + var x9 uint64 + var x10 uint64 + x9, x10 = bits.Sub64(x1, 0xf3b9cac2fc632551, uint64(0x0)) + var x11 uint64 + var x12 uint64 + x11, x12 = bits.Sub64(x3, 0xbce6faada7179e84, uint64(uint1(x10))) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Sub64(x5, 0xffffffffffffffff, uint64(uint1(x12))) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Sub64(x7, 0xffffffff00000000, uint64(uint1(x14))) + var x18 uint64 + _, x18 = bits.Sub64(uint64(uint1(x8)), uint64(0x0), uint64(uint1(x16))) + var x19 uint64 + cmovznzU64(&x19, uint1(x18), x9, x1) + var x20 uint64 + cmovznzU64(&x20, uint1(x18), x11, x3) + var x21 uint64 + cmovznzU64(&x21, uint1(x18), x13, x5) + var x22 uint64 + cmovznzU64(&x22, uint1(x18), x15, x7) + out1[0] = x19 + out1[1] = x20 + out1[2] = x21 + out1[3] = x22 +} + +// Sub subtracts two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Sub(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint64 + var x2 uint64 + x1, x2 = bits.Sub64(arg1[0], arg2[0], uint64(0x0)) + var x3 uint64 + var x4 uint64 + x3, x4 = bits.Sub64(arg1[1], arg2[1], uint64(uint1(x2))) + var x5 uint64 + var x6 uint64 + x5, x6 = bits.Sub64(arg1[2], arg2[2], uint64(uint1(x4))) + var x7 uint64 + var x8 uint64 + x7, x8 = bits.Sub64(arg1[3], arg2[3], uint64(uint1(x6))) + var x9 uint64 + cmovznzU64(&x9, uint1(x8), uint64(0x0), 0xffffffffffffffff) + var x10 uint64 + var x11 uint64 + x10, x11 = bits.Add64(x1, (x9 & 0xf3b9cac2fc632551), uint64(0x0)) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x3, (x9 & 0xbce6faada7179e84), uint64(uint1(x11))) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(x5, x9, uint64(uint1(x13))) + var x16 uint64 + x16, _ = bits.Add64(x7, (x9 & 0xffffffff00000000), uint64(uint1(x15))) + out1[0] = x10 + out1[1] = x12 + out1[2] = x14 + out1[3] = x16 +} + +// Opp negates a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +// 0 ≤ eval out1 < m +// +func Opp(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + var x1 uint64 + var x2 uint64 + x1, x2 = bits.Sub64(uint64(0x0), arg1[0], uint64(0x0)) + var x3 uint64 + var x4 uint64 + x3, x4 = bits.Sub64(uint64(0x0), arg1[1], uint64(uint1(x2))) + var x5 uint64 + var x6 uint64 + x5, x6 = bits.Sub64(uint64(0x0), arg1[2], uint64(uint1(x4))) + var x7 uint64 + var x8 uint64 + x7, x8 = bits.Sub64(uint64(0x0), arg1[3], uint64(uint1(x6))) + var x9 uint64 + cmovznzU64(&x9, uint1(x8), uint64(0x0), 0xffffffffffffffff) + var x10 uint64 + var x11 uint64 + x10, x11 = bits.Add64(x1, (x9 & 0xf3b9cac2fc632551), uint64(0x0)) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x3, (x9 & 0xbce6faada7179e84), uint64(uint1(x11))) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(x5, x9, uint64(uint1(x13))) + var x16 uint64 + x16, _ = bits.Add64(x7, (x9 & 0xffffffff00000000), uint64(uint1(x15))) + out1[0] = x10 + out1[1] = x12 + out1[2] = x14 + out1[3] = x16 +} + +// FromMontgomery translates a field element out of the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m +// 0 ≤ eval out1 < m +// +func FromMontgomery(out1 *NonMontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[0] + var x2 uint64 + _, x2 = bits.Mul64(x1, 0xccd1c8aaee00bc4f) + var x4 uint64 + var x5 uint64 + x5, x4 = bits.Mul64(x2, 0xffffffff00000000) + var x6 uint64 + var x7 uint64 + x7, x6 = bits.Mul64(x2, 0xffffffffffffffff) + var x8 uint64 + var x9 uint64 + x9, x8 = bits.Mul64(x2, 0xbce6faada7179e84) + var x10 uint64 + var x11 uint64 + x11, x10 = bits.Mul64(x2, 0xf3b9cac2fc632551) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x11, x8, uint64(0x0)) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(x9, x6, uint64(uint1(x13))) + var x16 uint64 + var x17 uint64 + x16, x17 = bits.Add64(x7, x4, uint64(uint1(x15))) + var x19 uint64 + _, x19 = bits.Add64(x1, x10, uint64(0x0)) + var x20 uint64 + var x21 uint64 + x20, x21 = bits.Add64(uint64(0x0), x12, uint64(uint1(x19))) + var x22 uint64 + var x23 uint64 + x22, x23 = bits.Add64(uint64(0x0), x14, uint64(uint1(x21))) + var x24 uint64 + var x25 uint64 + x24, x25 = bits.Add64(uint64(0x0), x16, uint64(uint1(x23))) + var x26 uint64 + var x27 uint64 + x26, x27 = bits.Add64(x20, arg1[1], uint64(0x0)) + var x28 uint64 + var x29 uint64 + x28, x29 = bits.Add64(x22, uint64(0x0), uint64(uint1(x27))) + var x30 uint64 + var x31 uint64 + x30, x31 = bits.Add64(x24, uint64(0x0), uint64(uint1(x29))) + var x32 uint64 + _, x32 = bits.Mul64(x26, 0xccd1c8aaee00bc4f) + var x34 uint64 + var x35 uint64 + x35, x34 = bits.Mul64(x32, 0xffffffff00000000) + var x36 uint64 + var x37 uint64 + x37, x36 = bits.Mul64(x32, 0xffffffffffffffff) + var x38 uint64 + var x39 uint64 + x39, x38 = bits.Mul64(x32, 0xbce6faada7179e84) + var x40 uint64 + var x41 uint64 + x41, x40 = bits.Mul64(x32, 0xf3b9cac2fc632551) + var x42 uint64 + var x43 uint64 + x42, x43 = bits.Add64(x41, x38, uint64(0x0)) + var x44 uint64 + var x45 uint64 + x44, x45 = bits.Add64(x39, x36, uint64(uint1(x43))) + var x46 uint64 + var x47 uint64 + x46, x47 = bits.Add64(x37, x34, uint64(uint1(x45))) + var x49 uint64 + _, x49 = bits.Add64(x26, x40, uint64(0x0)) + var x50 uint64 + var x51 uint64 + x50, x51 = bits.Add64(x28, x42, uint64(uint1(x49))) + var x52 uint64 + var x53 uint64 + x52, x53 = bits.Add64(x30, x44, uint64(uint1(x51))) + var x54 uint64 + var x55 uint64 + x54, x55 = bits.Add64((uint64(uint1(x31)) + (uint64(uint1(x25)) + (uint64(uint1(x17)) + x5))), x46, uint64(uint1(x53))) + var x56 uint64 + var x57 uint64 + x56, x57 = bits.Add64(x50, arg1[2], uint64(0x0)) + var x58 uint64 + var x59 uint64 + x58, x59 = bits.Add64(x52, uint64(0x0), uint64(uint1(x57))) + var x60 uint64 + var x61 uint64 + x60, x61 = bits.Add64(x54, uint64(0x0), uint64(uint1(x59))) + var x62 uint64 + _, x62 = bits.Mul64(x56, 0xccd1c8aaee00bc4f) + var x64 uint64 + var x65 uint64 + x65, x64 = bits.Mul64(x62, 0xffffffff00000000) + var x66 uint64 + var x67 uint64 + x67, x66 = bits.Mul64(x62, 0xffffffffffffffff) + var x68 uint64 + var x69 uint64 + x69, x68 = bits.Mul64(x62, 0xbce6faada7179e84) + var x70 uint64 + var x71 uint64 + x71, x70 = bits.Mul64(x62, 0xf3b9cac2fc632551) + var x72 uint64 + var x73 uint64 + x72, x73 = bits.Add64(x71, x68, uint64(0x0)) + var x74 uint64 + var x75 uint64 + x74, x75 = bits.Add64(x69, x66, uint64(uint1(x73))) + var x76 uint64 + var x77 uint64 + x76, x77 = bits.Add64(x67, x64, uint64(uint1(x75))) + var x79 uint64 + _, x79 = bits.Add64(x56, x70, uint64(0x0)) + var x80 uint64 + var x81 uint64 + x80, x81 = bits.Add64(x58, x72, uint64(uint1(x79))) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x60, x74, uint64(uint1(x81))) + var x84 uint64 + var x85 uint64 + x84, x85 = bits.Add64((uint64(uint1(x61)) + (uint64(uint1(x55)) + (uint64(uint1(x47)) + x35))), x76, uint64(uint1(x83))) + var x86 uint64 + var x87 uint64 + x86, x87 = bits.Add64(x80, arg1[3], uint64(0x0)) + var x88 uint64 + var x89 uint64 + x88, x89 = bits.Add64(x82, uint64(0x0), uint64(uint1(x87))) + var x90 uint64 + var x91 uint64 + x90, x91 = bits.Add64(x84, uint64(0x0), uint64(uint1(x89))) + var x92 uint64 + _, x92 = bits.Mul64(x86, 0xccd1c8aaee00bc4f) + var x94 uint64 + var x95 uint64 + x95, x94 = bits.Mul64(x92, 0xffffffff00000000) + var x96 uint64 + var x97 uint64 + x97, x96 = bits.Mul64(x92, 0xffffffffffffffff) + var x98 uint64 + var x99 uint64 + x99, x98 = bits.Mul64(x92, 0xbce6faada7179e84) + var x100 uint64 + var x101 uint64 + x101, x100 = bits.Mul64(x92, 0xf3b9cac2fc632551) + var x102 uint64 + var x103 uint64 + x102, x103 = bits.Add64(x101, x98, uint64(0x0)) + var x104 uint64 + var x105 uint64 + x104, x105 = bits.Add64(x99, x96, uint64(uint1(x103))) + var x106 uint64 + var x107 uint64 + x106, x107 = bits.Add64(x97, x94, uint64(uint1(x105))) + var x109 uint64 + _, x109 = bits.Add64(x86, x100, uint64(0x0)) + var x110 uint64 + var x111 uint64 + x110, x111 = bits.Add64(x88, x102, uint64(uint1(x109))) + var x112 uint64 + var x113 uint64 + x112, x113 = bits.Add64(x90, x104, uint64(uint1(x111))) + var x114 uint64 + var x115 uint64 + x114, x115 = bits.Add64((uint64(uint1(x91)) + (uint64(uint1(x85)) + (uint64(uint1(x77)) + x65))), x106, uint64(uint1(x113))) + x116 := (uint64(uint1(x115)) + (uint64(uint1(x107)) + x95)) + var x117 uint64 + var x118 uint64 + x117, x118 = bits.Sub64(x110, 0xf3b9cac2fc632551, uint64(0x0)) + var x119 uint64 + var x120 uint64 + x119, x120 = bits.Sub64(x112, 0xbce6faada7179e84, uint64(uint1(x118))) + var x121 uint64 + var x122 uint64 + x121, x122 = bits.Sub64(x114, 0xffffffffffffffff, uint64(uint1(x120))) + var x123 uint64 + var x124 uint64 + x123, x124 = bits.Sub64(x116, 0xffffffff00000000, uint64(uint1(x122))) + var x126 uint64 + _, x126 = bits.Sub64(uint64(0x0), uint64(0x0), uint64(uint1(x124))) + var x127 uint64 + cmovznzU64(&x127, uint1(x126), x117, x110) + var x128 uint64 + cmovznzU64(&x128, uint1(x126), x119, x112) + var x129 uint64 + cmovznzU64(&x129, uint1(x126), x121, x114) + var x130 uint64 + cmovznzU64(&x130, uint1(x126), x123, x116) + out1[0] = x127 + out1[1] = x128 + out1[2] = x129 + out1[3] = x130 +} + +// ToMontgomery translates a field element into the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = eval arg1 mod m +// 0 ≤ eval out1 < m +// +func ToMontgomery(out1 *MontgomeryDomainFieldElement, arg1 *NonMontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[0] + var x5 uint64 + var x6 uint64 + x6, x5 = bits.Mul64(x4, 0x66e12d94f3d95620) + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x4, 0x2845b2392b6bec59) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x4, 0x4699799c49bd6fa6) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x4, 0x83244c95be79eea2) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Add64(x12, x9, uint64(0x0)) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Add64(x10, x7, uint64(uint1(x14))) + var x17 uint64 + var x18 uint64 + x17, x18 = bits.Add64(x8, x5, uint64(uint1(x16))) + var x19 uint64 + _, x19 = bits.Mul64(x11, 0xccd1c8aaee00bc4f) + var x21 uint64 + var x22 uint64 + x22, x21 = bits.Mul64(x19, 0xffffffff00000000) + var x23 uint64 + var x24 uint64 + x24, x23 = bits.Mul64(x19, 0xffffffffffffffff) + var x25 uint64 + var x26 uint64 + x26, x25 = bits.Mul64(x19, 0xbce6faada7179e84) + var x27 uint64 + var x28 uint64 + x28, x27 = bits.Mul64(x19, 0xf3b9cac2fc632551) + var x29 uint64 + var x30 uint64 + x29, x30 = bits.Add64(x28, x25, uint64(0x0)) + var x31 uint64 + var x32 uint64 + x31, x32 = bits.Add64(x26, x23, uint64(uint1(x30))) + var x33 uint64 + var x34 uint64 + x33, x34 = bits.Add64(x24, x21, uint64(uint1(x32))) + var x36 uint64 + _, x36 = bits.Add64(x11, x27, uint64(0x0)) + var x37 uint64 + var x38 uint64 + x37, x38 = bits.Add64(x13, x29, uint64(uint1(x36))) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Add64(x15, x31, uint64(uint1(x38))) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Add64(x17, x33, uint64(uint1(x40))) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Add64((uint64(uint1(x18)) + x6), (uint64(uint1(x34)) + x22), uint64(uint1(x42))) + var x45 uint64 + var x46 uint64 + x46, x45 = bits.Mul64(x1, 0x66e12d94f3d95620) + var x47 uint64 + var x48 uint64 + x48, x47 = bits.Mul64(x1, 0x2845b2392b6bec59) + var x49 uint64 + var x50 uint64 + x50, x49 = bits.Mul64(x1, 0x4699799c49bd6fa6) + var x51 uint64 + var x52 uint64 + x52, x51 = bits.Mul64(x1, 0x83244c95be79eea2) + var x53 uint64 + var x54 uint64 + x53, x54 = bits.Add64(x52, x49, uint64(0x0)) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Add64(x50, x47, uint64(uint1(x54))) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Add64(x48, x45, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Add64(x37, x51, uint64(0x0)) + var x61 uint64 + var x62 uint64 + x61, x62 = bits.Add64(x39, x53, uint64(uint1(x60))) + var x63 uint64 + var x64 uint64 + x63, x64 = bits.Add64(x41, x55, uint64(uint1(x62))) + var x65 uint64 + var x66 uint64 + x65, x66 = bits.Add64(x43, x57, uint64(uint1(x64))) + var x67 uint64 + _, x67 = bits.Mul64(x59, 0xccd1c8aaee00bc4f) + var x69 uint64 + var x70 uint64 + x70, x69 = bits.Mul64(x67, 0xffffffff00000000) + var x71 uint64 + var x72 uint64 + x72, x71 = bits.Mul64(x67, 0xffffffffffffffff) + var x73 uint64 + var x74 uint64 + x74, x73 = bits.Mul64(x67, 0xbce6faada7179e84) + var x75 uint64 + var x76 uint64 + x76, x75 = bits.Mul64(x67, 0xf3b9cac2fc632551) + var x77 uint64 + var x78 uint64 + x77, x78 = bits.Add64(x76, x73, uint64(0x0)) + var x79 uint64 + var x80 uint64 + x79, x80 = bits.Add64(x74, x71, uint64(uint1(x78))) + var x81 uint64 + var x82 uint64 + x81, x82 = bits.Add64(x72, x69, uint64(uint1(x80))) + var x84 uint64 + _, x84 = bits.Add64(x59, x75, uint64(0x0)) + var x85 uint64 + var x86 uint64 + x85, x86 = bits.Add64(x61, x77, uint64(uint1(x84))) + var x87 uint64 + var x88 uint64 + x87, x88 = bits.Add64(x63, x79, uint64(uint1(x86))) + var x89 uint64 + var x90 uint64 + x89, x90 = bits.Add64(x65, x81, uint64(uint1(x88))) + var x91 uint64 + var x92 uint64 + x91, x92 = bits.Add64(((uint64(uint1(x66)) + uint64(uint1(x44))) + (uint64(uint1(x58)) + x46)), (uint64(uint1(x82)) + x70), uint64(uint1(x90))) + var x93 uint64 + var x94 uint64 + x94, x93 = bits.Mul64(x2, 0x66e12d94f3d95620) + var x95 uint64 + var x96 uint64 + x96, x95 = bits.Mul64(x2, 0x2845b2392b6bec59) + var x97 uint64 + var x98 uint64 + x98, x97 = bits.Mul64(x2, 0x4699799c49bd6fa6) + var x99 uint64 + var x100 uint64 + x100, x99 = bits.Mul64(x2, 0x83244c95be79eea2) + var x101 uint64 + var x102 uint64 + x101, x102 = bits.Add64(x100, x97, uint64(0x0)) + var x103 uint64 + var x104 uint64 + x103, x104 = bits.Add64(x98, x95, uint64(uint1(x102))) + var x105 uint64 + var x106 uint64 + x105, x106 = bits.Add64(x96, x93, uint64(uint1(x104))) + var x107 uint64 + var x108 uint64 + x107, x108 = bits.Add64(x85, x99, uint64(0x0)) + var x109 uint64 + var x110 uint64 + x109, x110 = bits.Add64(x87, x101, uint64(uint1(x108))) + var x111 uint64 + var x112 uint64 + x111, x112 = bits.Add64(x89, x103, uint64(uint1(x110))) + var x113 uint64 + var x114 uint64 + x113, x114 = bits.Add64(x91, x105, uint64(uint1(x112))) + var x115 uint64 + _, x115 = bits.Mul64(x107, 0xccd1c8aaee00bc4f) + var x117 uint64 + var x118 uint64 + x118, x117 = bits.Mul64(x115, 0xffffffff00000000) + var x119 uint64 + var x120 uint64 + x120, x119 = bits.Mul64(x115, 0xffffffffffffffff) + var x121 uint64 + var x122 uint64 + x122, x121 = bits.Mul64(x115, 0xbce6faada7179e84) + var x123 uint64 + var x124 uint64 + x124, x123 = bits.Mul64(x115, 0xf3b9cac2fc632551) + var x125 uint64 + var x126 uint64 + x125, x126 = bits.Add64(x124, x121, uint64(0x0)) + var x127 uint64 + var x128 uint64 + x127, x128 = bits.Add64(x122, x119, uint64(uint1(x126))) + var x129 uint64 + var x130 uint64 + x129, x130 = bits.Add64(x120, x117, uint64(uint1(x128))) + var x132 uint64 + _, x132 = bits.Add64(x107, x123, uint64(0x0)) + var x133 uint64 + var x134 uint64 + x133, x134 = bits.Add64(x109, x125, uint64(uint1(x132))) + var x135 uint64 + var x136 uint64 + x135, x136 = bits.Add64(x111, x127, uint64(uint1(x134))) + var x137 uint64 + var x138 uint64 + x137, x138 = bits.Add64(x113, x129, uint64(uint1(x136))) + var x139 uint64 + var x140 uint64 + x139, x140 = bits.Add64(((uint64(uint1(x114)) + uint64(uint1(x92))) + (uint64(uint1(x106)) + x94)), (uint64(uint1(x130)) + x118), uint64(uint1(x138))) + var x141 uint64 + var x142 uint64 + x142, x141 = bits.Mul64(x3, 0x66e12d94f3d95620) + var x143 uint64 + var x144 uint64 + x144, x143 = bits.Mul64(x3, 0x2845b2392b6bec59) + var x145 uint64 + var x146 uint64 + x146, x145 = bits.Mul64(x3, 0x4699799c49bd6fa6) + var x147 uint64 + var x148 uint64 + x148, x147 = bits.Mul64(x3, 0x83244c95be79eea2) + var x149 uint64 + var x150 uint64 + x149, x150 = bits.Add64(x148, x145, uint64(0x0)) + var x151 uint64 + var x152 uint64 + x151, x152 = bits.Add64(x146, x143, uint64(uint1(x150))) + var x153 uint64 + var x154 uint64 + x153, x154 = bits.Add64(x144, x141, uint64(uint1(x152))) + var x155 uint64 + var x156 uint64 + x155, x156 = bits.Add64(x133, x147, uint64(0x0)) + var x157 uint64 + var x158 uint64 + x157, x158 = bits.Add64(x135, x149, uint64(uint1(x156))) + var x159 uint64 + var x160 uint64 + x159, x160 = bits.Add64(x137, x151, uint64(uint1(x158))) + var x161 uint64 + var x162 uint64 + x161, x162 = bits.Add64(x139, x153, uint64(uint1(x160))) + var x163 uint64 + _, x163 = bits.Mul64(x155, 0xccd1c8aaee00bc4f) + var x165 uint64 + var x166 uint64 + x166, x165 = bits.Mul64(x163, 0xffffffff00000000) + var x167 uint64 + var x168 uint64 + x168, x167 = bits.Mul64(x163, 0xffffffffffffffff) + var x169 uint64 + var x170 uint64 + x170, x169 = bits.Mul64(x163, 0xbce6faada7179e84) + var x171 uint64 + var x172 uint64 + x172, x171 = bits.Mul64(x163, 0xf3b9cac2fc632551) + var x173 uint64 + var x174 uint64 + x173, x174 = bits.Add64(x172, x169, uint64(0x0)) + var x175 uint64 + var x176 uint64 + x175, x176 = bits.Add64(x170, x167, uint64(uint1(x174))) + var x177 uint64 + var x178 uint64 + x177, x178 = bits.Add64(x168, x165, uint64(uint1(x176))) + var x180 uint64 + _, x180 = bits.Add64(x155, x171, uint64(0x0)) + var x181 uint64 + var x182 uint64 + x181, x182 = bits.Add64(x157, x173, uint64(uint1(x180))) + var x183 uint64 + var x184 uint64 + x183, x184 = bits.Add64(x159, x175, uint64(uint1(x182))) + var x185 uint64 + var x186 uint64 + x185, x186 = bits.Add64(x161, x177, uint64(uint1(x184))) + var x187 uint64 + var x188 uint64 + x187, x188 = bits.Add64(((uint64(uint1(x162)) + uint64(uint1(x140))) + (uint64(uint1(x154)) + x142)), (uint64(uint1(x178)) + x166), uint64(uint1(x186))) + var x189 uint64 + var x190 uint64 + x189, x190 = bits.Sub64(x181, 0xf3b9cac2fc632551, uint64(0x0)) + var x191 uint64 + var x192 uint64 + x191, x192 = bits.Sub64(x183, 0xbce6faada7179e84, uint64(uint1(x190))) + var x193 uint64 + var x194 uint64 + x193, x194 = bits.Sub64(x185, 0xffffffffffffffff, uint64(uint1(x192))) + var x195 uint64 + var x196 uint64 + x195, x196 = bits.Sub64(x187, 0xffffffff00000000, uint64(uint1(x194))) + var x198 uint64 + _, x198 = bits.Sub64(uint64(uint1(x188)), uint64(0x0), uint64(uint1(x196))) + var x199 uint64 + cmovznzU64(&x199, uint1(x198), x189, x181) + var x200 uint64 + cmovznzU64(&x200, uint1(x198), x191, x183) + var x201 uint64 + cmovznzU64(&x201, uint1(x198), x193, x185) + var x202 uint64 + cmovznzU64(&x202, uint1(x198), x195, x187) + out1[0] = x199 + out1[1] = x200 + out1[2] = x201 + out1[3] = x202 +} + +// Nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffffffffffff] +func Nonzero(out1 *uint64, arg1 *[4]uint64) { + x1 := (arg1[0] | (arg1[1] | (arg1[2] | arg1[3]))) + *out1 = x1 +} + +// Selectznz is a multi-limb conditional select. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func Selectznz(out1 *[4]uint64, arg1 uint1, arg2 *[4]uint64, arg3 *[4]uint64) { + var x1 uint64 + cmovznzU64(&x1, arg1, arg2[0], arg3[0]) + var x2 uint64 + cmovznzU64(&x2, arg1, arg2[1], arg3[1]) + var x3 uint64 + cmovznzU64(&x3, arg1, arg2[2], arg3[2]) + var x4 uint64 + cmovznzU64(&x4, arg1, arg2[3], arg3[3]) + out1[0] = x1 + out1[1] = x2 + out1[2] = x3 + out1[3] = x4 +} + +// ToBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +func ToBytes(out1 *[32]uint8, arg1 *[4]uint64) { + x1 := arg1[3] + x2 := arg1[2] + x3 := arg1[1] + x4 := arg1[0] + x5 := (uint8(x4) & 0xff) + x6 := (x4 >> 8) + x7 := (uint8(x6) & 0xff) + x8 := (x6 >> 8) + x9 := (uint8(x8) & 0xff) + x10 := (x8 >> 8) + x11 := (uint8(x10) & 0xff) + x12 := (x10 >> 8) + x13 := (uint8(x12) & 0xff) + x14 := (x12 >> 8) + x15 := (uint8(x14) & 0xff) + x16 := (x14 >> 8) + x17 := (uint8(x16) & 0xff) + x18 := uint8((x16 >> 8)) + x19 := (uint8(x3) & 0xff) + x20 := (x3 >> 8) + x21 := (uint8(x20) & 0xff) + x22 := (x20 >> 8) + x23 := (uint8(x22) & 0xff) + x24 := (x22 >> 8) + x25 := (uint8(x24) & 0xff) + x26 := (x24 >> 8) + x27 := (uint8(x26) & 0xff) + x28 := (x26 >> 8) + x29 := (uint8(x28) & 0xff) + x30 := (x28 >> 8) + x31 := (uint8(x30) & 0xff) + x32 := uint8((x30 >> 8)) + x33 := (uint8(x2) & 0xff) + x34 := (x2 >> 8) + x35 := (uint8(x34) & 0xff) + x36 := (x34 >> 8) + x37 := (uint8(x36) & 0xff) + x38 := (x36 >> 8) + x39 := (uint8(x38) & 0xff) + x40 := (x38 >> 8) + x41 := (uint8(x40) & 0xff) + x42 := (x40 >> 8) + x43 := (uint8(x42) & 0xff) + x44 := (x42 >> 8) + x45 := (uint8(x44) & 0xff) + x46 := uint8((x44 >> 8)) + x47 := (uint8(x1) & 0xff) + x48 := (x1 >> 8) + x49 := (uint8(x48) & 0xff) + x50 := (x48 >> 8) + x51 := (uint8(x50) & 0xff) + x52 := (x50 >> 8) + x53 := (uint8(x52) & 0xff) + x54 := (x52 >> 8) + x55 := (uint8(x54) & 0xff) + x56 := (x54 >> 8) + x57 := (uint8(x56) & 0xff) + x58 := (x56 >> 8) + x59 := (uint8(x58) & 0xff) + x60 := uint8((x58 >> 8)) + out1[0] = x5 + out1[1] = x7 + out1[2] = x9 + out1[3] = x11 + out1[4] = x13 + out1[5] = x15 + out1[6] = x17 + out1[7] = x18 + out1[8] = x19 + out1[9] = x21 + out1[10] = x23 + out1[11] = x25 + out1[12] = x27 + out1[13] = x29 + out1[14] = x31 + out1[15] = x32 + out1[16] = x33 + out1[17] = x35 + out1[18] = x37 + out1[19] = x39 + out1[20] = x41 + out1[21] = x43 + out1[22] = x45 + out1[23] = x46 + out1[24] = x47 + out1[25] = x49 + out1[26] = x51 + out1[27] = x53 + out1[28] = x55 + out1[29] = x57 + out1[30] = x59 + out1[31] = x60 +} + +// FromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +// +// Preconditions: +// 0 ≤ bytes_eval arg1 < m +// Postconditions: +// eval out1 mod m = bytes_eval arg1 mod m +// 0 ≤ eval out1 < m +// +// Input Bounds: +// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func FromBytes(out1 *[4]uint64, arg1 *[32]uint8) { + x1 := (uint64(arg1[31]) << 56) + x2 := (uint64(arg1[30]) << 48) + x3 := (uint64(arg1[29]) << 40) + x4 := (uint64(arg1[28]) << 32) + x5 := (uint64(arg1[27]) << 24) + x6 := (uint64(arg1[26]) << 16) + x7 := (uint64(arg1[25]) << 8) + x8 := arg1[24] + x9 := (uint64(arg1[23]) << 56) + x10 := (uint64(arg1[22]) << 48) + x11 := (uint64(arg1[21]) << 40) + x12 := (uint64(arg1[20]) << 32) + x13 := (uint64(arg1[19]) << 24) + x14 := (uint64(arg1[18]) << 16) + x15 := (uint64(arg1[17]) << 8) + x16 := arg1[16] + x17 := (uint64(arg1[15]) << 56) + x18 := (uint64(arg1[14]) << 48) + x19 := (uint64(arg1[13]) << 40) + x20 := (uint64(arg1[12]) << 32) + x21 := (uint64(arg1[11]) << 24) + x22 := (uint64(arg1[10]) << 16) + x23 := (uint64(arg1[9]) << 8) + x24 := arg1[8] + x25 := (uint64(arg1[7]) << 56) + x26 := (uint64(arg1[6]) << 48) + x27 := (uint64(arg1[5]) << 40) + x28 := (uint64(arg1[4]) << 32) + x29 := (uint64(arg1[3]) << 24) + x30 := (uint64(arg1[2]) << 16) + x31 := (uint64(arg1[1]) << 8) + x32 := arg1[0] + x33 := (x31 + uint64(x32)) + x34 := (x30 + x33) + x35 := (x29 + x34) + x36 := (x28 + x35) + x37 := (x27 + x36) + x38 := (x26 + x37) + x39 := (x25 + x38) + x40 := (x23 + uint64(x24)) + x41 := (x22 + x40) + x42 := (x21 + x41) + x43 := (x20 + x42) + x44 := (x19 + x43) + x45 := (x18 + x44) + x46 := (x17 + x45) + x47 := (x15 + uint64(x16)) + x48 := (x14 + x47) + x49 := (x13 + x48) + x50 := (x12 + x49) + x51 := (x11 + x50) + x52 := (x10 + x51) + x53 := (x9 + x52) + x54 := (x7 + uint64(x8)) + x55 := (x6 + x54) + x56 := (x5 + x55) + x57 := (x4 + x56) + x58 := (x3 + x57) + x59 := (x2 + x58) + x60 := (x1 + x59) + out1[0] = x39 + out1[1] = x46 + out1[2] = x53 + out1[3] = x60 +} + +// SetOne returns the field element one in the Montgomery domain. +// +// Postconditions: +// eval (from_montgomery out1) mod m = 1 mod m +// 0 ≤ eval out1 < m +// +func SetOne(out1 *MontgomeryDomainFieldElement) { + out1[0] = 0xc46353d039cdaaf + out1[1] = 0x4319055258e8617b + out1[2] = uint64(0x0) + out1[3] = 0xffffffff +} + +// Msat returns the saturated representation of the prime modulus. +// +// Postconditions: +// twos_complement_eval out1 = m +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func Msat(out1 *[5]uint64) { + out1[0] = 0xf3b9cac2fc632551 + out1[1] = 0xbce6faada7179e84 + out1[2] = 0xffffffffffffffff + out1[3] = 0xffffffff00000000 + out1[4] = uint64(0x0) +} + +// Divstep computes a divstep. +// +// Preconditions: +// 0 ≤ eval arg4 < m +// 0 ≤ eval arg5 < m +// Postconditions: +// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +// 0 ≤ eval out5 < m +// 0 ≤ eval out5 < m +// 0 ≤ eval out2 < m +// 0 ≤ eval out3 < m +// +// Input Bounds: +// arg1: [0x0 ~> 0xffffffffffffffff] +// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffffffffffff] +// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func Divstep(out1 *uint64, out2 *[5]uint64, out3 *[5]uint64, out4 *[4]uint64, out5 *[4]uint64, arg1 uint64, arg2 *[5]uint64, arg3 *[5]uint64, arg4 *[4]uint64, arg5 *[4]uint64) { + var x1 uint64 + x1, _ = bits.Add64((^arg1), uint64(0x1), uint64(0x0)) + x3 := (uint1((x1 >> 63)) & (uint1(arg3[0]) & 0x1)) + var x4 uint64 + x4, _ = bits.Add64((^arg1), uint64(0x1), uint64(0x0)) + var x6 uint64 + cmovznzU64(&x6, x3, arg1, x4) + var x7 uint64 + cmovznzU64(&x7, x3, arg2[0], arg3[0]) + var x8 uint64 + cmovznzU64(&x8, x3, arg2[1], arg3[1]) + var x9 uint64 + cmovznzU64(&x9, x3, arg2[2], arg3[2]) + var x10 uint64 + cmovznzU64(&x10, x3, arg2[3], arg3[3]) + var x11 uint64 + cmovznzU64(&x11, x3, arg2[4], arg3[4]) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(uint64(0x1), (^arg2[0]), uint64(0x0)) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(uint64(0x0), (^arg2[1]), uint64(uint1(x13))) + var x16 uint64 + var x17 uint64 + x16, x17 = bits.Add64(uint64(0x0), (^arg2[2]), uint64(uint1(x15))) + var x18 uint64 + var x19 uint64 + x18, x19 = bits.Add64(uint64(0x0), (^arg2[3]), uint64(uint1(x17))) + var x20 uint64 + x20, _ = bits.Add64(uint64(0x0), (^arg2[4]), uint64(uint1(x19))) + var x22 uint64 + cmovznzU64(&x22, x3, arg3[0], x12) + var x23 uint64 + cmovznzU64(&x23, x3, arg3[1], x14) + var x24 uint64 + cmovznzU64(&x24, x3, arg3[2], x16) + var x25 uint64 + cmovznzU64(&x25, x3, arg3[3], x18) + var x26 uint64 + cmovznzU64(&x26, x3, arg3[4], x20) + var x27 uint64 + cmovznzU64(&x27, x3, arg4[0], arg5[0]) + var x28 uint64 + cmovznzU64(&x28, x3, arg4[1], arg5[1]) + var x29 uint64 + cmovznzU64(&x29, x3, arg4[2], arg5[2]) + var x30 uint64 + cmovznzU64(&x30, x3, arg4[3], arg5[3]) + var x31 uint64 + var x32 uint64 + x31, x32 = bits.Add64(x27, x27, uint64(0x0)) + var x33 uint64 + var x34 uint64 + x33, x34 = bits.Add64(x28, x28, uint64(uint1(x32))) + var x35 uint64 + var x36 uint64 + x35, x36 = bits.Add64(x29, x29, uint64(uint1(x34))) + var x37 uint64 + var x38 uint64 + x37, x38 = bits.Add64(x30, x30, uint64(uint1(x36))) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Sub64(x31, 0xf3b9cac2fc632551, uint64(0x0)) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Sub64(x33, 0xbce6faada7179e84, uint64(uint1(x40))) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Sub64(x35, 0xffffffffffffffff, uint64(uint1(x42))) + var x45 uint64 + var x46 uint64 + x45, x46 = bits.Sub64(x37, 0xffffffff00000000, uint64(uint1(x44))) + var x48 uint64 + _, x48 = bits.Sub64(uint64(uint1(x38)), uint64(0x0), uint64(uint1(x46))) + x49 := arg4[3] + x50 := arg4[2] + x51 := arg4[1] + x52 := arg4[0] + var x53 uint64 + var x54 uint64 + x53, x54 = bits.Sub64(uint64(0x0), x52, uint64(0x0)) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Sub64(uint64(0x0), x51, uint64(uint1(x54))) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Sub64(uint64(0x0), x50, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Sub64(uint64(0x0), x49, uint64(uint1(x58))) + var x61 uint64 + cmovznzU64(&x61, uint1(x60), uint64(0x0), 0xffffffffffffffff) + var x62 uint64 + var x63 uint64 + x62, x63 = bits.Add64(x53, (x61 & 0xf3b9cac2fc632551), uint64(0x0)) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(x55, (x61 & 0xbce6faada7179e84), uint64(uint1(x63))) + var x66 uint64 + var x67 uint64 + x66, x67 = bits.Add64(x57, x61, uint64(uint1(x65))) + var x68 uint64 + x68, _ = bits.Add64(x59, (x61 & 0xffffffff00000000), uint64(uint1(x67))) + var x70 uint64 + cmovznzU64(&x70, x3, arg5[0], x62) + var x71 uint64 + cmovznzU64(&x71, x3, arg5[1], x64) + var x72 uint64 + cmovznzU64(&x72, x3, arg5[2], x66) + var x73 uint64 + cmovznzU64(&x73, x3, arg5[3], x68) + x74 := (uint1(x22) & 0x1) + var x75 uint64 + cmovznzU64(&x75, x74, uint64(0x0), x7) + var x76 uint64 + cmovznzU64(&x76, x74, uint64(0x0), x8) + var x77 uint64 + cmovznzU64(&x77, x74, uint64(0x0), x9) + var x78 uint64 + cmovznzU64(&x78, x74, uint64(0x0), x10) + var x79 uint64 + cmovznzU64(&x79, x74, uint64(0x0), x11) + var x80 uint64 + var x81 uint64 + x80, x81 = bits.Add64(x22, x75, uint64(0x0)) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x23, x76, uint64(uint1(x81))) + var x84 uint64 + var x85 uint64 + x84, x85 = bits.Add64(x24, x77, uint64(uint1(x83))) + var x86 uint64 + var x87 uint64 + x86, x87 = bits.Add64(x25, x78, uint64(uint1(x85))) + var x88 uint64 + x88, _ = bits.Add64(x26, x79, uint64(uint1(x87))) + var x90 uint64 + cmovznzU64(&x90, x74, uint64(0x0), x27) + var x91 uint64 + cmovznzU64(&x91, x74, uint64(0x0), x28) + var x92 uint64 + cmovznzU64(&x92, x74, uint64(0x0), x29) + var x93 uint64 + cmovznzU64(&x93, x74, uint64(0x0), x30) + var x94 uint64 + var x95 uint64 + x94, x95 = bits.Add64(x70, x90, uint64(0x0)) + var x96 uint64 + var x97 uint64 + x96, x97 = bits.Add64(x71, x91, uint64(uint1(x95))) + var x98 uint64 + var x99 uint64 + x98, x99 = bits.Add64(x72, x92, uint64(uint1(x97))) + var x100 uint64 + var x101 uint64 + x100, x101 = bits.Add64(x73, x93, uint64(uint1(x99))) + var x102 uint64 + var x103 uint64 + x102, x103 = bits.Sub64(x94, 0xf3b9cac2fc632551, uint64(0x0)) + var x104 uint64 + var x105 uint64 + x104, x105 = bits.Sub64(x96, 0xbce6faada7179e84, uint64(uint1(x103))) + var x106 uint64 + var x107 uint64 + x106, x107 = bits.Sub64(x98, 0xffffffffffffffff, uint64(uint1(x105))) + var x108 uint64 + var x109 uint64 + x108, x109 = bits.Sub64(x100, 0xffffffff00000000, uint64(uint1(x107))) + var x111 uint64 + _, x111 = bits.Sub64(uint64(uint1(x101)), uint64(0x0), uint64(uint1(x109))) + var x112 uint64 + x112, _ = bits.Add64(x6, uint64(0x1), uint64(0x0)) + x114 := ((x80 >> 1) | ((x82 << 63) & 0xffffffffffffffff)) + x115 := ((x82 >> 1) | ((x84 << 63) & 0xffffffffffffffff)) + x116 := ((x84 >> 1) | ((x86 << 63) & 0xffffffffffffffff)) + x117 := ((x86 >> 1) | ((x88 << 63) & 0xffffffffffffffff)) + x118 := ((x88 & 0x8000000000000000) | (x88 >> 1)) + var x119 uint64 + cmovznzU64(&x119, uint1(x48), x39, x31) + var x120 uint64 + cmovznzU64(&x120, uint1(x48), x41, x33) + var x121 uint64 + cmovznzU64(&x121, uint1(x48), x43, x35) + var x122 uint64 + cmovznzU64(&x122, uint1(x48), x45, x37) + var x123 uint64 + cmovznzU64(&x123, uint1(x111), x102, x94) + var x124 uint64 + cmovznzU64(&x124, uint1(x111), x104, x96) + var x125 uint64 + cmovznzU64(&x125, uint1(x111), x106, x98) + var x126 uint64 + cmovznzU64(&x126, uint1(x111), x108, x100) + *out1 = x112 + out2[0] = x7 + out2[1] = x8 + out2[2] = x9 + out2[3] = x10 + out2[4] = x11 + out3[0] = x114 + out3[1] = x115 + out3[2] = x116 + out3[3] = x117 + out3[4] = x118 + out4[0] = x119 + out4[1] = x120 + out4[2] = x121 + out4[3] = x122 + out5[0] = x123 + out5[1] = x124 + out5[2] = x125 + out5[3] = x126 +} + +// DivstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +// +// Postconditions: +// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func DivstepPrecomp(out1 *[4]uint64) { + out1[0] = 0xd739262fb7fcfbb5 + out1[1] = 0x8ac6f75d20074414 + out1[2] = 0xc67428bfb5e3c256 + out1[3] = 0x444962f2eda7aedf +} diff --git a/fiat-go/64/p384scalar/p384scalar.go b/fiat-go/64/p384scalar/p384scalar.go new file mode 100644 index 0000000000..2c3b673fdb --- /dev/null +++ b/fiat-go/64/p384scalar/p384scalar.go @@ -0,0 +1,3502 @@ +// Code generated by Fiat Cryptography. DO NOT EDIT. +// +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Go --no-wide-int --relax-primitive-carry-to-bitwidth 32,64 --cmovznz-by-mul --internal-static --package-case flatcase --public-function-case UpperCamelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case camelCase --no-prefix-fiat --doc-newline-in-typedef-bounds --doc-prepend-header 'Code generated by Fiat Cryptography. DO NOT EDIT.' --doc-text-before-function-name '' --doc-text-before-type-name '' --package-name p384scalar '' 64 '2^384 - 1388124618062372383947042015309946732620727252194336364173' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// +// curve description (via package name): p384scalar +// +// machine_wordsize = 64 (from "64") +// +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// +// m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from "2^384 - 1388124618062372383947042015309946732620727252194336364173") +// +// +// +// NOTE: In addition to the bounds specified above each function, all +// +// functions synthesized for this Montgomery arithmetic require the +// +// input to be strictly less than the prime modulus (m), and also +// +// require the input to be in the unique saturated representation. +// +// All functions also ensure that these two properties are true of +// +// return values. +// +// +// +// Computed values: +// +// eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) +// +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) +// +// twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) in +// +// if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384 +package p384scalar + +import "math/bits" + +type uint1 uint64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 +type int1 int64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 + +// MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +type MontgomeryDomainFieldElement [6]uint64 + +// NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +type NonMontgomeryDomainFieldElement [6]uint64 + +// cmovznzU64 is a single-word conditional move. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [0x0 ~> 0xffffffffffffffff] +// arg3: [0x0 ~> 0xffffffffffffffff] +// Output Bounds: +// out1: [0x0 ~> 0xffffffffffffffff] +func cmovznzU64(out1 *uint64, arg1 uint1, arg2 uint64, arg3 uint64) { + x1 := (uint64(arg1) * 0xffffffffffffffff) + x2 := ((x1 & arg3) | ((^x1) & arg2)) + *out1 = x2 +} + +// Mul multiplies two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Mul(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[0] + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x6, arg2[5]) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x6, arg2[4]) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x6, arg2[3]) + var x13 uint64 + var x14 uint64 + x14, x13 = bits.Mul64(x6, arg2[2]) + var x15 uint64 + var x16 uint64 + x16, x15 = bits.Mul64(x6, arg2[1]) + var x17 uint64 + var x18 uint64 + x18, x17 = bits.Mul64(x6, arg2[0]) + var x19 uint64 + var x20 uint64 + x19, x20 = bits.Add64(x18, x15, uint64(0x0)) + var x21 uint64 + var x22 uint64 + x21, x22 = bits.Add64(x16, x13, uint64(uint1(x20))) + var x23 uint64 + var x24 uint64 + x23, x24 = bits.Add64(x14, x11, uint64(uint1(x22))) + var x25 uint64 + var x26 uint64 + x25, x26 = bits.Add64(x12, x9, uint64(uint1(x24))) + var x27 uint64 + var x28 uint64 + x27, x28 = bits.Add64(x10, x7, uint64(uint1(x26))) + x29 := (uint64(uint1(x28)) + x8) + var x30 uint64 + _, x30 = bits.Mul64(x17, 0x6ed46089e88fdc45) + var x32 uint64 + var x33 uint64 + x33, x32 = bits.Mul64(x30, 0xffffffffffffffff) + var x34 uint64 + var x35 uint64 + x35, x34 = bits.Mul64(x30, 0xffffffffffffffff) + var x36 uint64 + var x37 uint64 + x37, x36 = bits.Mul64(x30, 0xffffffffffffffff) + var x38 uint64 + var x39 uint64 + x39, x38 = bits.Mul64(x30, 0xc7634d81f4372ddf) + var x40 uint64 + var x41 uint64 + x41, x40 = bits.Mul64(x30, 0x581a0db248b0a77a) + var x42 uint64 + var x43 uint64 + x43, x42 = bits.Mul64(x30, 0xecec196accc52973) + var x44 uint64 + var x45 uint64 + x44, x45 = bits.Add64(x43, x40, uint64(0x0)) + var x46 uint64 + var x47 uint64 + x46, x47 = bits.Add64(x41, x38, uint64(uint1(x45))) + var x48 uint64 + var x49 uint64 + x48, x49 = bits.Add64(x39, x36, uint64(uint1(x47))) + var x50 uint64 + var x51 uint64 + x50, x51 = bits.Add64(x37, x34, uint64(uint1(x49))) + var x52 uint64 + var x53 uint64 + x52, x53 = bits.Add64(x35, x32, uint64(uint1(x51))) + x54 := (uint64(uint1(x53)) + x33) + var x56 uint64 + _, x56 = bits.Add64(x17, x42, uint64(0x0)) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Add64(x19, x44, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Add64(x21, x46, uint64(uint1(x58))) + var x61 uint64 + var x62 uint64 + x61, x62 = bits.Add64(x23, x48, uint64(uint1(x60))) + var x63 uint64 + var x64 uint64 + x63, x64 = bits.Add64(x25, x50, uint64(uint1(x62))) + var x65 uint64 + var x66 uint64 + x65, x66 = bits.Add64(x27, x52, uint64(uint1(x64))) + var x67 uint64 + var x68 uint64 + x67, x68 = bits.Add64(x29, x54, uint64(uint1(x66))) + var x69 uint64 + var x70 uint64 + x70, x69 = bits.Mul64(x1, arg2[5]) + var x71 uint64 + var x72 uint64 + x72, x71 = bits.Mul64(x1, arg2[4]) + var x73 uint64 + var x74 uint64 + x74, x73 = bits.Mul64(x1, arg2[3]) + var x75 uint64 + var x76 uint64 + x76, x75 = bits.Mul64(x1, arg2[2]) + var x77 uint64 + var x78 uint64 + x78, x77 = bits.Mul64(x1, arg2[1]) + var x79 uint64 + var x80 uint64 + x80, x79 = bits.Mul64(x1, arg2[0]) + var x81 uint64 + var x82 uint64 + x81, x82 = bits.Add64(x80, x77, uint64(0x0)) + var x83 uint64 + var x84 uint64 + x83, x84 = bits.Add64(x78, x75, uint64(uint1(x82))) + var x85 uint64 + var x86 uint64 + x85, x86 = bits.Add64(x76, x73, uint64(uint1(x84))) + var x87 uint64 + var x88 uint64 + x87, x88 = bits.Add64(x74, x71, uint64(uint1(x86))) + var x89 uint64 + var x90 uint64 + x89, x90 = bits.Add64(x72, x69, uint64(uint1(x88))) + x91 := (uint64(uint1(x90)) + x70) + var x92 uint64 + var x93 uint64 + x92, x93 = bits.Add64(x57, x79, uint64(0x0)) + var x94 uint64 + var x95 uint64 + x94, x95 = bits.Add64(x59, x81, uint64(uint1(x93))) + var x96 uint64 + var x97 uint64 + x96, x97 = bits.Add64(x61, x83, uint64(uint1(x95))) + var x98 uint64 + var x99 uint64 + x98, x99 = bits.Add64(x63, x85, uint64(uint1(x97))) + var x100 uint64 + var x101 uint64 + x100, x101 = bits.Add64(x65, x87, uint64(uint1(x99))) + var x102 uint64 + var x103 uint64 + x102, x103 = bits.Add64(x67, x89, uint64(uint1(x101))) + var x104 uint64 + var x105 uint64 + x104, x105 = bits.Add64(uint64(uint1(x68)), x91, uint64(uint1(x103))) + var x106 uint64 + _, x106 = bits.Mul64(x92, 0x6ed46089e88fdc45) + var x108 uint64 + var x109 uint64 + x109, x108 = bits.Mul64(x106, 0xffffffffffffffff) + var x110 uint64 + var x111 uint64 + x111, x110 = bits.Mul64(x106, 0xffffffffffffffff) + var x112 uint64 + var x113 uint64 + x113, x112 = bits.Mul64(x106, 0xffffffffffffffff) + var x114 uint64 + var x115 uint64 + x115, x114 = bits.Mul64(x106, 0xc7634d81f4372ddf) + var x116 uint64 + var x117 uint64 + x117, x116 = bits.Mul64(x106, 0x581a0db248b0a77a) + var x118 uint64 + var x119 uint64 + x119, x118 = bits.Mul64(x106, 0xecec196accc52973) + var x120 uint64 + var x121 uint64 + x120, x121 = bits.Add64(x119, x116, uint64(0x0)) + var x122 uint64 + var x123 uint64 + x122, x123 = bits.Add64(x117, x114, uint64(uint1(x121))) + var x124 uint64 + var x125 uint64 + x124, x125 = bits.Add64(x115, x112, uint64(uint1(x123))) + var x126 uint64 + var x127 uint64 + x126, x127 = bits.Add64(x113, x110, uint64(uint1(x125))) + var x128 uint64 + var x129 uint64 + x128, x129 = bits.Add64(x111, x108, uint64(uint1(x127))) + x130 := (uint64(uint1(x129)) + x109) + var x132 uint64 + _, x132 = bits.Add64(x92, x118, uint64(0x0)) + var x133 uint64 + var x134 uint64 + x133, x134 = bits.Add64(x94, x120, uint64(uint1(x132))) + var x135 uint64 + var x136 uint64 + x135, x136 = bits.Add64(x96, x122, uint64(uint1(x134))) + var x137 uint64 + var x138 uint64 + x137, x138 = bits.Add64(x98, x124, uint64(uint1(x136))) + var x139 uint64 + var x140 uint64 + x139, x140 = bits.Add64(x100, x126, uint64(uint1(x138))) + var x141 uint64 + var x142 uint64 + x141, x142 = bits.Add64(x102, x128, uint64(uint1(x140))) + var x143 uint64 + var x144 uint64 + x143, x144 = bits.Add64(x104, x130, uint64(uint1(x142))) + x145 := (uint64(uint1(x144)) + uint64(uint1(x105))) + var x146 uint64 + var x147 uint64 + x147, x146 = bits.Mul64(x2, arg2[5]) + var x148 uint64 + var x149 uint64 + x149, x148 = bits.Mul64(x2, arg2[4]) + var x150 uint64 + var x151 uint64 + x151, x150 = bits.Mul64(x2, arg2[3]) + var x152 uint64 + var x153 uint64 + x153, x152 = bits.Mul64(x2, arg2[2]) + var x154 uint64 + var x155 uint64 + x155, x154 = bits.Mul64(x2, arg2[1]) + var x156 uint64 + var x157 uint64 + x157, x156 = bits.Mul64(x2, arg2[0]) + var x158 uint64 + var x159 uint64 + x158, x159 = bits.Add64(x157, x154, uint64(0x0)) + var x160 uint64 + var x161 uint64 + x160, x161 = bits.Add64(x155, x152, uint64(uint1(x159))) + var x162 uint64 + var x163 uint64 + x162, x163 = bits.Add64(x153, x150, uint64(uint1(x161))) + var x164 uint64 + var x165 uint64 + x164, x165 = bits.Add64(x151, x148, uint64(uint1(x163))) + var x166 uint64 + var x167 uint64 + x166, x167 = bits.Add64(x149, x146, uint64(uint1(x165))) + x168 := (uint64(uint1(x167)) + x147) + var x169 uint64 + var x170 uint64 + x169, x170 = bits.Add64(x133, x156, uint64(0x0)) + var x171 uint64 + var x172 uint64 + x171, x172 = bits.Add64(x135, x158, uint64(uint1(x170))) + var x173 uint64 + var x174 uint64 + x173, x174 = bits.Add64(x137, x160, uint64(uint1(x172))) + var x175 uint64 + var x176 uint64 + x175, x176 = bits.Add64(x139, x162, uint64(uint1(x174))) + var x177 uint64 + var x178 uint64 + x177, x178 = bits.Add64(x141, x164, uint64(uint1(x176))) + var x179 uint64 + var x180 uint64 + x179, x180 = bits.Add64(x143, x166, uint64(uint1(x178))) + var x181 uint64 + var x182 uint64 + x181, x182 = bits.Add64(x145, x168, uint64(uint1(x180))) + var x183 uint64 + _, x183 = bits.Mul64(x169, 0x6ed46089e88fdc45) + var x185 uint64 + var x186 uint64 + x186, x185 = bits.Mul64(x183, 0xffffffffffffffff) + var x187 uint64 + var x188 uint64 + x188, x187 = bits.Mul64(x183, 0xffffffffffffffff) + var x189 uint64 + var x190 uint64 + x190, x189 = bits.Mul64(x183, 0xffffffffffffffff) + var x191 uint64 + var x192 uint64 + x192, x191 = bits.Mul64(x183, 0xc7634d81f4372ddf) + var x193 uint64 + var x194 uint64 + x194, x193 = bits.Mul64(x183, 0x581a0db248b0a77a) + var x195 uint64 + var x196 uint64 + x196, x195 = bits.Mul64(x183, 0xecec196accc52973) + var x197 uint64 + var x198 uint64 + x197, x198 = bits.Add64(x196, x193, uint64(0x0)) + var x199 uint64 + var x200 uint64 + x199, x200 = bits.Add64(x194, x191, uint64(uint1(x198))) + var x201 uint64 + var x202 uint64 + x201, x202 = bits.Add64(x192, x189, uint64(uint1(x200))) + var x203 uint64 + var x204 uint64 + x203, x204 = bits.Add64(x190, x187, uint64(uint1(x202))) + var x205 uint64 + var x206 uint64 + x205, x206 = bits.Add64(x188, x185, uint64(uint1(x204))) + x207 := (uint64(uint1(x206)) + x186) + var x209 uint64 + _, x209 = bits.Add64(x169, x195, uint64(0x0)) + var x210 uint64 + var x211 uint64 + x210, x211 = bits.Add64(x171, x197, uint64(uint1(x209))) + var x212 uint64 + var x213 uint64 + x212, x213 = bits.Add64(x173, x199, uint64(uint1(x211))) + var x214 uint64 + var x215 uint64 + x214, x215 = bits.Add64(x175, x201, uint64(uint1(x213))) + var x216 uint64 + var x217 uint64 + x216, x217 = bits.Add64(x177, x203, uint64(uint1(x215))) + var x218 uint64 + var x219 uint64 + x218, x219 = bits.Add64(x179, x205, uint64(uint1(x217))) + var x220 uint64 + var x221 uint64 + x220, x221 = bits.Add64(x181, x207, uint64(uint1(x219))) + x222 := (uint64(uint1(x221)) + uint64(uint1(x182))) + var x223 uint64 + var x224 uint64 + x224, x223 = bits.Mul64(x3, arg2[5]) + var x225 uint64 + var x226 uint64 + x226, x225 = bits.Mul64(x3, arg2[4]) + var x227 uint64 + var x228 uint64 + x228, x227 = bits.Mul64(x3, arg2[3]) + var x229 uint64 + var x230 uint64 + x230, x229 = bits.Mul64(x3, arg2[2]) + var x231 uint64 + var x232 uint64 + x232, x231 = bits.Mul64(x3, arg2[1]) + var x233 uint64 + var x234 uint64 + x234, x233 = bits.Mul64(x3, arg2[0]) + var x235 uint64 + var x236 uint64 + x235, x236 = bits.Add64(x234, x231, uint64(0x0)) + var x237 uint64 + var x238 uint64 + x237, x238 = bits.Add64(x232, x229, uint64(uint1(x236))) + var x239 uint64 + var x240 uint64 + x239, x240 = bits.Add64(x230, x227, uint64(uint1(x238))) + var x241 uint64 + var x242 uint64 + x241, x242 = bits.Add64(x228, x225, uint64(uint1(x240))) + var x243 uint64 + var x244 uint64 + x243, x244 = bits.Add64(x226, x223, uint64(uint1(x242))) + x245 := (uint64(uint1(x244)) + x224) + var x246 uint64 + var x247 uint64 + x246, x247 = bits.Add64(x210, x233, uint64(0x0)) + var x248 uint64 + var x249 uint64 + x248, x249 = bits.Add64(x212, x235, uint64(uint1(x247))) + var x250 uint64 + var x251 uint64 + x250, x251 = bits.Add64(x214, x237, uint64(uint1(x249))) + var x252 uint64 + var x253 uint64 + x252, x253 = bits.Add64(x216, x239, uint64(uint1(x251))) + var x254 uint64 + var x255 uint64 + x254, x255 = bits.Add64(x218, x241, uint64(uint1(x253))) + var x256 uint64 + var x257 uint64 + x256, x257 = bits.Add64(x220, x243, uint64(uint1(x255))) + var x258 uint64 + var x259 uint64 + x258, x259 = bits.Add64(x222, x245, uint64(uint1(x257))) + var x260 uint64 + _, x260 = bits.Mul64(x246, 0x6ed46089e88fdc45) + var x262 uint64 + var x263 uint64 + x263, x262 = bits.Mul64(x260, 0xffffffffffffffff) + var x264 uint64 + var x265 uint64 + x265, x264 = bits.Mul64(x260, 0xffffffffffffffff) + var x266 uint64 + var x267 uint64 + x267, x266 = bits.Mul64(x260, 0xffffffffffffffff) + var x268 uint64 + var x269 uint64 + x269, x268 = bits.Mul64(x260, 0xc7634d81f4372ddf) + var x270 uint64 + var x271 uint64 + x271, x270 = bits.Mul64(x260, 0x581a0db248b0a77a) + var x272 uint64 + var x273 uint64 + x273, x272 = bits.Mul64(x260, 0xecec196accc52973) + var x274 uint64 + var x275 uint64 + x274, x275 = bits.Add64(x273, x270, uint64(0x0)) + var x276 uint64 + var x277 uint64 + x276, x277 = bits.Add64(x271, x268, uint64(uint1(x275))) + var x278 uint64 + var x279 uint64 + x278, x279 = bits.Add64(x269, x266, uint64(uint1(x277))) + var x280 uint64 + var x281 uint64 + x280, x281 = bits.Add64(x267, x264, uint64(uint1(x279))) + var x282 uint64 + var x283 uint64 + x282, x283 = bits.Add64(x265, x262, uint64(uint1(x281))) + x284 := (uint64(uint1(x283)) + x263) + var x286 uint64 + _, x286 = bits.Add64(x246, x272, uint64(0x0)) + var x287 uint64 + var x288 uint64 + x287, x288 = bits.Add64(x248, x274, uint64(uint1(x286))) + var x289 uint64 + var x290 uint64 + x289, x290 = bits.Add64(x250, x276, uint64(uint1(x288))) + var x291 uint64 + var x292 uint64 + x291, x292 = bits.Add64(x252, x278, uint64(uint1(x290))) + var x293 uint64 + var x294 uint64 + x293, x294 = bits.Add64(x254, x280, uint64(uint1(x292))) + var x295 uint64 + var x296 uint64 + x295, x296 = bits.Add64(x256, x282, uint64(uint1(x294))) + var x297 uint64 + var x298 uint64 + x297, x298 = bits.Add64(x258, x284, uint64(uint1(x296))) + x299 := (uint64(uint1(x298)) + uint64(uint1(x259))) + var x300 uint64 + var x301 uint64 + x301, x300 = bits.Mul64(x4, arg2[5]) + var x302 uint64 + var x303 uint64 + x303, x302 = bits.Mul64(x4, arg2[4]) + var x304 uint64 + var x305 uint64 + x305, x304 = bits.Mul64(x4, arg2[3]) + var x306 uint64 + var x307 uint64 + x307, x306 = bits.Mul64(x4, arg2[2]) + var x308 uint64 + var x309 uint64 + x309, x308 = bits.Mul64(x4, arg2[1]) + var x310 uint64 + var x311 uint64 + x311, x310 = bits.Mul64(x4, arg2[0]) + var x312 uint64 + var x313 uint64 + x312, x313 = bits.Add64(x311, x308, uint64(0x0)) + var x314 uint64 + var x315 uint64 + x314, x315 = bits.Add64(x309, x306, uint64(uint1(x313))) + var x316 uint64 + var x317 uint64 + x316, x317 = bits.Add64(x307, x304, uint64(uint1(x315))) + var x318 uint64 + var x319 uint64 + x318, x319 = bits.Add64(x305, x302, uint64(uint1(x317))) + var x320 uint64 + var x321 uint64 + x320, x321 = bits.Add64(x303, x300, uint64(uint1(x319))) + x322 := (uint64(uint1(x321)) + x301) + var x323 uint64 + var x324 uint64 + x323, x324 = bits.Add64(x287, x310, uint64(0x0)) + var x325 uint64 + var x326 uint64 + x325, x326 = bits.Add64(x289, x312, uint64(uint1(x324))) + var x327 uint64 + var x328 uint64 + x327, x328 = bits.Add64(x291, x314, uint64(uint1(x326))) + var x329 uint64 + var x330 uint64 + x329, x330 = bits.Add64(x293, x316, uint64(uint1(x328))) + var x331 uint64 + var x332 uint64 + x331, x332 = bits.Add64(x295, x318, uint64(uint1(x330))) + var x333 uint64 + var x334 uint64 + x333, x334 = bits.Add64(x297, x320, uint64(uint1(x332))) + var x335 uint64 + var x336 uint64 + x335, x336 = bits.Add64(x299, x322, uint64(uint1(x334))) + var x337 uint64 + _, x337 = bits.Mul64(x323, 0x6ed46089e88fdc45) + var x339 uint64 + var x340 uint64 + x340, x339 = bits.Mul64(x337, 0xffffffffffffffff) + var x341 uint64 + var x342 uint64 + x342, x341 = bits.Mul64(x337, 0xffffffffffffffff) + var x343 uint64 + var x344 uint64 + x344, x343 = bits.Mul64(x337, 0xffffffffffffffff) + var x345 uint64 + var x346 uint64 + x346, x345 = bits.Mul64(x337, 0xc7634d81f4372ddf) + var x347 uint64 + var x348 uint64 + x348, x347 = bits.Mul64(x337, 0x581a0db248b0a77a) + var x349 uint64 + var x350 uint64 + x350, x349 = bits.Mul64(x337, 0xecec196accc52973) + var x351 uint64 + var x352 uint64 + x351, x352 = bits.Add64(x350, x347, uint64(0x0)) + var x353 uint64 + var x354 uint64 + x353, x354 = bits.Add64(x348, x345, uint64(uint1(x352))) + var x355 uint64 + var x356 uint64 + x355, x356 = bits.Add64(x346, x343, uint64(uint1(x354))) + var x357 uint64 + var x358 uint64 + x357, x358 = bits.Add64(x344, x341, uint64(uint1(x356))) + var x359 uint64 + var x360 uint64 + x359, x360 = bits.Add64(x342, x339, uint64(uint1(x358))) + x361 := (uint64(uint1(x360)) + x340) + var x363 uint64 + _, x363 = bits.Add64(x323, x349, uint64(0x0)) + var x364 uint64 + var x365 uint64 + x364, x365 = bits.Add64(x325, x351, uint64(uint1(x363))) + var x366 uint64 + var x367 uint64 + x366, x367 = bits.Add64(x327, x353, uint64(uint1(x365))) + var x368 uint64 + var x369 uint64 + x368, x369 = bits.Add64(x329, x355, uint64(uint1(x367))) + var x370 uint64 + var x371 uint64 + x370, x371 = bits.Add64(x331, x357, uint64(uint1(x369))) + var x372 uint64 + var x373 uint64 + x372, x373 = bits.Add64(x333, x359, uint64(uint1(x371))) + var x374 uint64 + var x375 uint64 + x374, x375 = bits.Add64(x335, x361, uint64(uint1(x373))) + x376 := (uint64(uint1(x375)) + uint64(uint1(x336))) + var x377 uint64 + var x378 uint64 + x378, x377 = bits.Mul64(x5, arg2[5]) + var x379 uint64 + var x380 uint64 + x380, x379 = bits.Mul64(x5, arg2[4]) + var x381 uint64 + var x382 uint64 + x382, x381 = bits.Mul64(x5, arg2[3]) + var x383 uint64 + var x384 uint64 + x384, x383 = bits.Mul64(x5, arg2[2]) + var x385 uint64 + var x386 uint64 + x386, x385 = bits.Mul64(x5, arg2[1]) + var x387 uint64 + var x388 uint64 + x388, x387 = bits.Mul64(x5, arg2[0]) + var x389 uint64 + var x390 uint64 + x389, x390 = bits.Add64(x388, x385, uint64(0x0)) + var x391 uint64 + var x392 uint64 + x391, x392 = bits.Add64(x386, x383, uint64(uint1(x390))) + var x393 uint64 + var x394 uint64 + x393, x394 = bits.Add64(x384, x381, uint64(uint1(x392))) + var x395 uint64 + var x396 uint64 + x395, x396 = bits.Add64(x382, x379, uint64(uint1(x394))) + var x397 uint64 + var x398 uint64 + x397, x398 = bits.Add64(x380, x377, uint64(uint1(x396))) + x399 := (uint64(uint1(x398)) + x378) + var x400 uint64 + var x401 uint64 + x400, x401 = bits.Add64(x364, x387, uint64(0x0)) + var x402 uint64 + var x403 uint64 + x402, x403 = bits.Add64(x366, x389, uint64(uint1(x401))) + var x404 uint64 + var x405 uint64 + x404, x405 = bits.Add64(x368, x391, uint64(uint1(x403))) + var x406 uint64 + var x407 uint64 + x406, x407 = bits.Add64(x370, x393, uint64(uint1(x405))) + var x408 uint64 + var x409 uint64 + x408, x409 = bits.Add64(x372, x395, uint64(uint1(x407))) + var x410 uint64 + var x411 uint64 + x410, x411 = bits.Add64(x374, x397, uint64(uint1(x409))) + var x412 uint64 + var x413 uint64 + x412, x413 = bits.Add64(x376, x399, uint64(uint1(x411))) + var x414 uint64 + _, x414 = bits.Mul64(x400, 0x6ed46089e88fdc45) + var x416 uint64 + var x417 uint64 + x417, x416 = bits.Mul64(x414, 0xffffffffffffffff) + var x418 uint64 + var x419 uint64 + x419, x418 = bits.Mul64(x414, 0xffffffffffffffff) + var x420 uint64 + var x421 uint64 + x421, x420 = bits.Mul64(x414, 0xffffffffffffffff) + var x422 uint64 + var x423 uint64 + x423, x422 = bits.Mul64(x414, 0xc7634d81f4372ddf) + var x424 uint64 + var x425 uint64 + x425, x424 = bits.Mul64(x414, 0x581a0db248b0a77a) + var x426 uint64 + var x427 uint64 + x427, x426 = bits.Mul64(x414, 0xecec196accc52973) + var x428 uint64 + var x429 uint64 + x428, x429 = bits.Add64(x427, x424, uint64(0x0)) + var x430 uint64 + var x431 uint64 + x430, x431 = bits.Add64(x425, x422, uint64(uint1(x429))) + var x432 uint64 + var x433 uint64 + x432, x433 = bits.Add64(x423, x420, uint64(uint1(x431))) + var x434 uint64 + var x435 uint64 + x434, x435 = bits.Add64(x421, x418, uint64(uint1(x433))) + var x436 uint64 + var x437 uint64 + x436, x437 = bits.Add64(x419, x416, uint64(uint1(x435))) + x438 := (uint64(uint1(x437)) + x417) + var x440 uint64 + _, x440 = bits.Add64(x400, x426, uint64(0x0)) + var x441 uint64 + var x442 uint64 + x441, x442 = bits.Add64(x402, x428, uint64(uint1(x440))) + var x443 uint64 + var x444 uint64 + x443, x444 = bits.Add64(x404, x430, uint64(uint1(x442))) + var x445 uint64 + var x446 uint64 + x445, x446 = bits.Add64(x406, x432, uint64(uint1(x444))) + var x447 uint64 + var x448 uint64 + x447, x448 = bits.Add64(x408, x434, uint64(uint1(x446))) + var x449 uint64 + var x450 uint64 + x449, x450 = bits.Add64(x410, x436, uint64(uint1(x448))) + var x451 uint64 + var x452 uint64 + x451, x452 = bits.Add64(x412, x438, uint64(uint1(x450))) + x453 := (uint64(uint1(x452)) + uint64(uint1(x413))) + var x454 uint64 + var x455 uint64 + x454, x455 = bits.Sub64(x441, 0xecec196accc52973, uint64(0x0)) + var x456 uint64 + var x457 uint64 + x456, x457 = bits.Sub64(x443, 0x581a0db248b0a77a, uint64(uint1(x455))) + var x458 uint64 + var x459 uint64 + x458, x459 = bits.Sub64(x445, 0xc7634d81f4372ddf, uint64(uint1(x457))) + var x460 uint64 + var x461 uint64 + x460, x461 = bits.Sub64(x447, 0xffffffffffffffff, uint64(uint1(x459))) + var x462 uint64 + var x463 uint64 + x462, x463 = bits.Sub64(x449, 0xffffffffffffffff, uint64(uint1(x461))) + var x464 uint64 + var x465 uint64 + x464, x465 = bits.Sub64(x451, 0xffffffffffffffff, uint64(uint1(x463))) + var x467 uint64 + _, x467 = bits.Sub64(x453, uint64(0x0), uint64(uint1(x465))) + var x468 uint64 + cmovznzU64(&x468, uint1(x467), x454, x441) + var x469 uint64 + cmovznzU64(&x469, uint1(x467), x456, x443) + var x470 uint64 + cmovznzU64(&x470, uint1(x467), x458, x445) + var x471 uint64 + cmovznzU64(&x471, uint1(x467), x460, x447) + var x472 uint64 + cmovznzU64(&x472, uint1(x467), x462, x449) + var x473 uint64 + cmovznzU64(&x473, uint1(x467), x464, x451) + out1[0] = x468 + out1[1] = x469 + out1[2] = x470 + out1[3] = x471 + out1[4] = x472 + out1[5] = x473 +} + +// Square squares a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +// 0 ≤ eval out1 < m +// +func Square(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[0] + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x6, arg1[5]) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x6, arg1[4]) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x6, arg1[3]) + var x13 uint64 + var x14 uint64 + x14, x13 = bits.Mul64(x6, arg1[2]) + var x15 uint64 + var x16 uint64 + x16, x15 = bits.Mul64(x6, arg1[1]) + var x17 uint64 + var x18 uint64 + x18, x17 = bits.Mul64(x6, arg1[0]) + var x19 uint64 + var x20 uint64 + x19, x20 = bits.Add64(x18, x15, uint64(0x0)) + var x21 uint64 + var x22 uint64 + x21, x22 = bits.Add64(x16, x13, uint64(uint1(x20))) + var x23 uint64 + var x24 uint64 + x23, x24 = bits.Add64(x14, x11, uint64(uint1(x22))) + var x25 uint64 + var x26 uint64 + x25, x26 = bits.Add64(x12, x9, uint64(uint1(x24))) + var x27 uint64 + var x28 uint64 + x27, x28 = bits.Add64(x10, x7, uint64(uint1(x26))) + x29 := (uint64(uint1(x28)) + x8) + var x30 uint64 + _, x30 = bits.Mul64(x17, 0x6ed46089e88fdc45) + var x32 uint64 + var x33 uint64 + x33, x32 = bits.Mul64(x30, 0xffffffffffffffff) + var x34 uint64 + var x35 uint64 + x35, x34 = bits.Mul64(x30, 0xffffffffffffffff) + var x36 uint64 + var x37 uint64 + x37, x36 = bits.Mul64(x30, 0xffffffffffffffff) + var x38 uint64 + var x39 uint64 + x39, x38 = bits.Mul64(x30, 0xc7634d81f4372ddf) + var x40 uint64 + var x41 uint64 + x41, x40 = bits.Mul64(x30, 0x581a0db248b0a77a) + var x42 uint64 + var x43 uint64 + x43, x42 = bits.Mul64(x30, 0xecec196accc52973) + var x44 uint64 + var x45 uint64 + x44, x45 = bits.Add64(x43, x40, uint64(0x0)) + var x46 uint64 + var x47 uint64 + x46, x47 = bits.Add64(x41, x38, uint64(uint1(x45))) + var x48 uint64 + var x49 uint64 + x48, x49 = bits.Add64(x39, x36, uint64(uint1(x47))) + var x50 uint64 + var x51 uint64 + x50, x51 = bits.Add64(x37, x34, uint64(uint1(x49))) + var x52 uint64 + var x53 uint64 + x52, x53 = bits.Add64(x35, x32, uint64(uint1(x51))) + x54 := (uint64(uint1(x53)) + x33) + var x56 uint64 + _, x56 = bits.Add64(x17, x42, uint64(0x0)) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Add64(x19, x44, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Add64(x21, x46, uint64(uint1(x58))) + var x61 uint64 + var x62 uint64 + x61, x62 = bits.Add64(x23, x48, uint64(uint1(x60))) + var x63 uint64 + var x64 uint64 + x63, x64 = bits.Add64(x25, x50, uint64(uint1(x62))) + var x65 uint64 + var x66 uint64 + x65, x66 = bits.Add64(x27, x52, uint64(uint1(x64))) + var x67 uint64 + var x68 uint64 + x67, x68 = bits.Add64(x29, x54, uint64(uint1(x66))) + var x69 uint64 + var x70 uint64 + x70, x69 = bits.Mul64(x1, arg1[5]) + var x71 uint64 + var x72 uint64 + x72, x71 = bits.Mul64(x1, arg1[4]) + var x73 uint64 + var x74 uint64 + x74, x73 = bits.Mul64(x1, arg1[3]) + var x75 uint64 + var x76 uint64 + x76, x75 = bits.Mul64(x1, arg1[2]) + var x77 uint64 + var x78 uint64 + x78, x77 = bits.Mul64(x1, arg1[1]) + var x79 uint64 + var x80 uint64 + x80, x79 = bits.Mul64(x1, arg1[0]) + var x81 uint64 + var x82 uint64 + x81, x82 = bits.Add64(x80, x77, uint64(0x0)) + var x83 uint64 + var x84 uint64 + x83, x84 = bits.Add64(x78, x75, uint64(uint1(x82))) + var x85 uint64 + var x86 uint64 + x85, x86 = bits.Add64(x76, x73, uint64(uint1(x84))) + var x87 uint64 + var x88 uint64 + x87, x88 = bits.Add64(x74, x71, uint64(uint1(x86))) + var x89 uint64 + var x90 uint64 + x89, x90 = bits.Add64(x72, x69, uint64(uint1(x88))) + x91 := (uint64(uint1(x90)) + x70) + var x92 uint64 + var x93 uint64 + x92, x93 = bits.Add64(x57, x79, uint64(0x0)) + var x94 uint64 + var x95 uint64 + x94, x95 = bits.Add64(x59, x81, uint64(uint1(x93))) + var x96 uint64 + var x97 uint64 + x96, x97 = bits.Add64(x61, x83, uint64(uint1(x95))) + var x98 uint64 + var x99 uint64 + x98, x99 = bits.Add64(x63, x85, uint64(uint1(x97))) + var x100 uint64 + var x101 uint64 + x100, x101 = bits.Add64(x65, x87, uint64(uint1(x99))) + var x102 uint64 + var x103 uint64 + x102, x103 = bits.Add64(x67, x89, uint64(uint1(x101))) + var x104 uint64 + var x105 uint64 + x104, x105 = bits.Add64(uint64(uint1(x68)), x91, uint64(uint1(x103))) + var x106 uint64 + _, x106 = bits.Mul64(x92, 0x6ed46089e88fdc45) + var x108 uint64 + var x109 uint64 + x109, x108 = bits.Mul64(x106, 0xffffffffffffffff) + var x110 uint64 + var x111 uint64 + x111, x110 = bits.Mul64(x106, 0xffffffffffffffff) + var x112 uint64 + var x113 uint64 + x113, x112 = bits.Mul64(x106, 0xffffffffffffffff) + var x114 uint64 + var x115 uint64 + x115, x114 = bits.Mul64(x106, 0xc7634d81f4372ddf) + var x116 uint64 + var x117 uint64 + x117, x116 = bits.Mul64(x106, 0x581a0db248b0a77a) + var x118 uint64 + var x119 uint64 + x119, x118 = bits.Mul64(x106, 0xecec196accc52973) + var x120 uint64 + var x121 uint64 + x120, x121 = bits.Add64(x119, x116, uint64(0x0)) + var x122 uint64 + var x123 uint64 + x122, x123 = bits.Add64(x117, x114, uint64(uint1(x121))) + var x124 uint64 + var x125 uint64 + x124, x125 = bits.Add64(x115, x112, uint64(uint1(x123))) + var x126 uint64 + var x127 uint64 + x126, x127 = bits.Add64(x113, x110, uint64(uint1(x125))) + var x128 uint64 + var x129 uint64 + x128, x129 = bits.Add64(x111, x108, uint64(uint1(x127))) + x130 := (uint64(uint1(x129)) + x109) + var x132 uint64 + _, x132 = bits.Add64(x92, x118, uint64(0x0)) + var x133 uint64 + var x134 uint64 + x133, x134 = bits.Add64(x94, x120, uint64(uint1(x132))) + var x135 uint64 + var x136 uint64 + x135, x136 = bits.Add64(x96, x122, uint64(uint1(x134))) + var x137 uint64 + var x138 uint64 + x137, x138 = bits.Add64(x98, x124, uint64(uint1(x136))) + var x139 uint64 + var x140 uint64 + x139, x140 = bits.Add64(x100, x126, uint64(uint1(x138))) + var x141 uint64 + var x142 uint64 + x141, x142 = bits.Add64(x102, x128, uint64(uint1(x140))) + var x143 uint64 + var x144 uint64 + x143, x144 = bits.Add64(x104, x130, uint64(uint1(x142))) + x145 := (uint64(uint1(x144)) + uint64(uint1(x105))) + var x146 uint64 + var x147 uint64 + x147, x146 = bits.Mul64(x2, arg1[5]) + var x148 uint64 + var x149 uint64 + x149, x148 = bits.Mul64(x2, arg1[4]) + var x150 uint64 + var x151 uint64 + x151, x150 = bits.Mul64(x2, arg1[3]) + var x152 uint64 + var x153 uint64 + x153, x152 = bits.Mul64(x2, arg1[2]) + var x154 uint64 + var x155 uint64 + x155, x154 = bits.Mul64(x2, arg1[1]) + var x156 uint64 + var x157 uint64 + x157, x156 = bits.Mul64(x2, arg1[0]) + var x158 uint64 + var x159 uint64 + x158, x159 = bits.Add64(x157, x154, uint64(0x0)) + var x160 uint64 + var x161 uint64 + x160, x161 = bits.Add64(x155, x152, uint64(uint1(x159))) + var x162 uint64 + var x163 uint64 + x162, x163 = bits.Add64(x153, x150, uint64(uint1(x161))) + var x164 uint64 + var x165 uint64 + x164, x165 = bits.Add64(x151, x148, uint64(uint1(x163))) + var x166 uint64 + var x167 uint64 + x166, x167 = bits.Add64(x149, x146, uint64(uint1(x165))) + x168 := (uint64(uint1(x167)) + x147) + var x169 uint64 + var x170 uint64 + x169, x170 = bits.Add64(x133, x156, uint64(0x0)) + var x171 uint64 + var x172 uint64 + x171, x172 = bits.Add64(x135, x158, uint64(uint1(x170))) + var x173 uint64 + var x174 uint64 + x173, x174 = bits.Add64(x137, x160, uint64(uint1(x172))) + var x175 uint64 + var x176 uint64 + x175, x176 = bits.Add64(x139, x162, uint64(uint1(x174))) + var x177 uint64 + var x178 uint64 + x177, x178 = bits.Add64(x141, x164, uint64(uint1(x176))) + var x179 uint64 + var x180 uint64 + x179, x180 = bits.Add64(x143, x166, uint64(uint1(x178))) + var x181 uint64 + var x182 uint64 + x181, x182 = bits.Add64(x145, x168, uint64(uint1(x180))) + var x183 uint64 + _, x183 = bits.Mul64(x169, 0x6ed46089e88fdc45) + var x185 uint64 + var x186 uint64 + x186, x185 = bits.Mul64(x183, 0xffffffffffffffff) + var x187 uint64 + var x188 uint64 + x188, x187 = bits.Mul64(x183, 0xffffffffffffffff) + var x189 uint64 + var x190 uint64 + x190, x189 = bits.Mul64(x183, 0xffffffffffffffff) + var x191 uint64 + var x192 uint64 + x192, x191 = bits.Mul64(x183, 0xc7634d81f4372ddf) + var x193 uint64 + var x194 uint64 + x194, x193 = bits.Mul64(x183, 0x581a0db248b0a77a) + var x195 uint64 + var x196 uint64 + x196, x195 = bits.Mul64(x183, 0xecec196accc52973) + var x197 uint64 + var x198 uint64 + x197, x198 = bits.Add64(x196, x193, uint64(0x0)) + var x199 uint64 + var x200 uint64 + x199, x200 = bits.Add64(x194, x191, uint64(uint1(x198))) + var x201 uint64 + var x202 uint64 + x201, x202 = bits.Add64(x192, x189, uint64(uint1(x200))) + var x203 uint64 + var x204 uint64 + x203, x204 = bits.Add64(x190, x187, uint64(uint1(x202))) + var x205 uint64 + var x206 uint64 + x205, x206 = bits.Add64(x188, x185, uint64(uint1(x204))) + x207 := (uint64(uint1(x206)) + x186) + var x209 uint64 + _, x209 = bits.Add64(x169, x195, uint64(0x0)) + var x210 uint64 + var x211 uint64 + x210, x211 = bits.Add64(x171, x197, uint64(uint1(x209))) + var x212 uint64 + var x213 uint64 + x212, x213 = bits.Add64(x173, x199, uint64(uint1(x211))) + var x214 uint64 + var x215 uint64 + x214, x215 = bits.Add64(x175, x201, uint64(uint1(x213))) + var x216 uint64 + var x217 uint64 + x216, x217 = bits.Add64(x177, x203, uint64(uint1(x215))) + var x218 uint64 + var x219 uint64 + x218, x219 = bits.Add64(x179, x205, uint64(uint1(x217))) + var x220 uint64 + var x221 uint64 + x220, x221 = bits.Add64(x181, x207, uint64(uint1(x219))) + x222 := (uint64(uint1(x221)) + uint64(uint1(x182))) + var x223 uint64 + var x224 uint64 + x224, x223 = bits.Mul64(x3, arg1[5]) + var x225 uint64 + var x226 uint64 + x226, x225 = bits.Mul64(x3, arg1[4]) + var x227 uint64 + var x228 uint64 + x228, x227 = bits.Mul64(x3, arg1[3]) + var x229 uint64 + var x230 uint64 + x230, x229 = bits.Mul64(x3, arg1[2]) + var x231 uint64 + var x232 uint64 + x232, x231 = bits.Mul64(x3, arg1[1]) + var x233 uint64 + var x234 uint64 + x234, x233 = bits.Mul64(x3, arg1[0]) + var x235 uint64 + var x236 uint64 + x235, x236 = bits.Add64(x234, x231, uint64(0x0)) + var x237 uint64 + var x238 uint64 + x237, x238 = bits.Add64(x232, x229, uint64(uint1(x236))) + var x239 uint64 + var x240 uint64 + x239, x240 = bits.Add64(x230, x227, uint64(uint1(x238))) + var x241 uint64 + var x242 uint64 + x241, x242 = bits.Add64(x228, x225, uint64(uint1(x240))) + var x243 uint64 + var x244 uint64 + x243, x244 = bits.Add64(x226, x223, uint64(uint1(x242))) + x245 := (uint64(uint1(x244)) + x224) + var x246 uint64 + var x247 uint64 + x246, x247 = bits.Add64(x210, x233, uint64(0x0)) + var x248 uint64 + var x249 uint64 + x248, x249 = bits.Add64(x212, x235, uint64(uint1(x247))) + var x250 uint64 + var x251 uint64 + x250, x251 = bits.Add64(x214, x237, uint64(uint1(x249))) + var x252 uint64 + var x253 uint64 + x252, x253 = bits.Add64(x216, x239, uint64(uint1(x251))) + var x254 uint64 + var x255 uint64 + x254, x255 = bits.Add64(x218, x241, uint64(uint1(x253))) + var x256 uint64 + var x257 uint64 + x256, x257 = bits.Add64(x220, x243, uint64(uint1(x255))) + var x258 uint64 + var x259 uint64 + x258, x259 = bits.Add64(x222, x245, uint64(uint1(x257))) + var x260 uint64 + _, x260 = bits.Mul64(x246, 0x6ed46089e88fdc45) + var x262 uint64 + var x263 uint64 + x263, x262 = bits.Mul64(x260, 0xffffffffffffffff) + var x264 uint64 + var x265 uint64 + x265, x264 = bits.Mul64(x260, 0xffffffffffffffff) + var x266 uint64 + var x267 uint64 + x267, x266 = bits.Mul64(x260, 0xffffffffffffffff) + var x268 uint64 + var x269 uint64 + x269, x268 = bits.Mul64(x260, 0xc7634d81f4372ddf) + var x270 uint64 + var x271 uint64 + x271, x270 = bits.Mul64(x260, 0x581a0db248b0a77a) + var x272 uint64 + var x273 uint64 + x273, x272 = bits.Mul64(x260, 0xecec196accc52973) + var x274 uint64 + var x275 uint64 + x274, x275 = bits.Add64(x273, x270, uint64(0x0)) + var x276 uint64 + var x277 uint64 + x276, x277 = bits.Add64(x271, x268, uint64(uint1(x275))) + var x278 uint64 + var x279 uint64 + x278, x279 = bits.Add64(x269, x266, uint64(uint1(x277))) + var x280 uint64 + var x281 uint64 + x280, x281 = bits.Add64(x267, x264, uint64(uint1(x279))) + var x282 uint64 + var x283 uint64 + x282, x283 = bits.Add64(x265, x262, uint64(uint1(x281))) + x284 := (uint64(uint1(x283)) + x263) + var x286 uint64 + _, x286 = bits.Add64(x246, x272, uint64(0x0)) + var x287 uint64 + var x288 uint64 + x287, x288 = bits.Add64(x248, x274, uint64(uint1(x286))) + var x289 uint64 + var x290 uint64 + x289, x290 = bits.Add64(x250, x276, uint64(uint1(x288))) + var x291 uint64 + var x292 uint64 + x291, x292 = bits.Add64(x252, x278, uint64(uint1(x290))) + var x293 uint64 + var x294 uint64 + x293, x294 = bits.Add64(x254, x280, uint64(uint1(x292))) + var x295 uint64 + var x296 uint64 + x295, x296 = bits.Add64(x256, x282, uint64(uint1(x294))) + var x297 uint64 + var x298 uint64 + x297, x298 = bits.Add64(x258, x284, uint64(uint1(x296))) + x299 := (uint64(uint1(x298)) + uint64(uint1(x259))) + var x300 uint64 + var x301 uint64 + x301, x300 = bits.Mul64(x4, arg1[5]) + var x302 uint64 + var x303 uint64 + x303, x302 = bits.Mul64(x4, arg1[4]) + var x304 uint64 + var x305 uint64 + x305, x304 = bits.Mul64(x4, arg1[3]) + var x306 uint64 + var x307 uint64 + x307, x306 = bits.Mul64(x4, arg1[2]) + var x308 uint64 + var x309 uint64 + x309, x308 = bits.Mul64(x4, arg1[1]) + var x310 uint64 + var x311 uint64 + x311, x310 = bits.Mul64(x4, arg1[0]) + var x312 uint64 + var x313 uint64 + x312, x313 = bits.Add64(x311, x308, uint64(0x0)) + var x314 uint64 + var x315 uint64 + x314, x315 = bits.Add64(x309, x306, uint64(uint1(x313))) + var x316 uint64 + var x317 uint64 + x316, x317 = bits.Add64(x307, x304, uint64(uint1(x315))) + var x318 uint64 + var x319 uint64 + x318, x319 = bits.Add64(x305, x302, uint64(uint1(x317))) + var x320 uint64 + var x321 uint64 + x320, x321 = bits.Add64(x303, x300, uint64(uint1(x319))) + x322 := (uint64(uint1(x321)) + x301) + var x323 uint64 + var x324 uint64 + x323, x324 = bits.Add64(x287, x310, uint64(0x0)) + var x325 uint64 + var x326 uint64 + x325, x326 = bits.Add64(x289, x312, uint64(uint1(x324))) + var x327 uint64 + var x328 uint64 + x327, x328 = bits.Add64(x291, x314, uint64(uint1(x326))) + var x329 uint64 + var x330 uint64 + x329, x330 = bits.Add64(x293, x316, uint64(uint1(x328))) + var x331 uint64 + var x332 uint64 + x331, x332 = bits.Add64(x295, x318, uint64(uint1(x330))) + var x333 uint64 + var x334 uint64 + x333, x334 = bits.Add64(x297, x320, uint64(uint1(x332))) + var x335 uint64 + var x336 uint64 + x335, x336 = bits.Add64(x299, x322, uint64(uint1(x334))) + var x337 uint64 + _, x337 = bits.Mul64(x323, 0x6ed46089e88fdc45) + var x339 uint64 + var x340 uint64 + x340, x339 = bits.Mul64(x337, 0xffffffffffffffff) + var x341 uint64 + var x342 uint64 + x342, x341 = bits.Mul64(x337, 0xffffffffffffffff) + var x343 uint64 + var x344 uint64 + x344, x343 = bits.Mul64(x337, 0xffffffffffffffff) + var x345 uint64 + var x346 uint64 + x346, x345 = bits.Mul64(x337, 0xc7634d81f4372ddf) + var x347 uint64 + var x348 uint64 + x348, x347 = bits.Mul64(x337, 0x581a0db248b0a77a) + var x349 uint64 + var x350 uint64 + x350, x349 = bits.Mul64(x337, 0xecec196accc52973) + var x351 uint64 + var x352 uint64 + x351, x352 = bits.Add64(x350, x347, uint64(0x0)) + var x353 uint64 + var x354 uint64 + x353, x354 = bits.Add64(x348, x345, uint64(uint1(x352))) + var x355 uint64 + var x356 uint64 + x355, x356 = bits.Add64(x346, x343, uint64(uint1(x354))) + var x357 uint64 + var x358 uint64 + x357, x358 = bits.Add64(x344, x341, uint64(uint1(x356))) + var x359 uint64 + var x360 uint64 + x359, x360 = bits.Add64(x342, x339, uint64(uint1(x358))) + x361 := (uint64(uint1(x360)) + x340) + var x363 uint64 + _, x363 = bits.Add64(x323, x349, uint64(0x0)) + var x364 uint64 + var x365 uint64 + x364, x365 = bits.Add64(x325, x351, uint64(uint1(x363))) + var x366 uint64 + var x367 uint64 + x366, x367 = bits.Add64(x327, x353, uint64(uint1(x365))) + var x368 uint64 + var x369 uint64 + x368, x369 = bits.Add64(x329, x355, uint64(uint1(x367))) + var x370 uint64 + var x371 uint64 + x370, x371 = bits.Add64(x331, x357, uint64(uint1(x369))) + var x372 uint64 + var x373 uint64 + x372, x373 = bits.Add64(x333, x359, uint64(uint1(x371))) + var x374 uint64 + var x375 uint64 + x374, x375 = bits.Add64(x335, x361, uint64(uint1(x373))) + x376 := (uint64(uint1(x375)) + uint64(uint1(x336))) + var x377 uint64 + var x378 uint64 + x378, x377 = bits.Mul64(x5, arg1[5]) + var x379 uint64 + var x380 uint64 + x380, x379 = bits.Mul64(x5, arg1[4]) + var x381 uint64 + var x382 uint64 + x382, x381 = bits.Mul64(x5, arg1[3]) + var x383 uint64 + var x384 uint64 + x384, x383 = bits.Mul64(x5, arg1[2]) + var x385 uint64 + var x386 uint64 + x386, x385 = bits.Mul64(x5, arg1[1]) + var x387 uint64 + var x388 uint64 + x388, x387 = bits.Mul64(x5, arg1[0]) + var x389 uint64 + var x390 uint64 + x389, x390 = bits.Add64(x388, x385, uint64(0x0)) + var x391 uint64 + var x392 uint64 + x391, x392 = bits.Add64(x386, x383, uint64(uint1(x390))) + var x393 uint64 + var x394 uint64 + x393, x394 = bits.Add64(x384, x381, uint64(uint1(x392))) + var x395 uint64 + var x396 uint64 + x395, x396 = bits.Add64(x382, x379, uint64(uint1(x394))) + var x397 uint64 + var x398 uint64 + x397, x398 = bits.Add64(x380, x377, uint64(uint1(x396))) + x399 := (uint64(uint1(x398)) + x378) + var x400 uint64 + var x401 uint64 + x400, x401 = bits.Add64(x364, x387, uint64(0x0)) + var x402 uint64 + var x403 uint64 + x402, x403 = bits.Add64(x366, x389, uint64(uint1(x401))) + var x404 uint64 + var x405 uint64 + x404, x405 = bits.Add64(x368, x391, uint64(uint1(x403))) + var x406 uint64 + var x407 uint64 + x406, x407 = bits.Add64(x370, x393, uint64(uint1(x405))) + var x408 uint64 + var x409 uint64 + x408, x409 = bits.Add64(x372, x395, uint64(uint1(x407))) + var x410 uint64 + var x411 uint64 + x410, x411 = bits.Add64(x374, x397, uint64(uint1(x409))) + var x412 uint64 + var x413 uint64 + x412, x413 = bits.Add64(x376, x399, uint64(uint1(x411))) + var x414 uint64 + _, x414 = bits.Mul64(x400, 0x6ed46089e88fdc45) + var x416 uint64 + var x417 uint64 + x417, x416 = bits.Mul64(x414, 0xffffffffffffffff) + var x418 uint64 + var x419 uint64 + x419, x418 = bits.Mul64(x414, 0xffffffffffffffff) + var x420 uint64 + var x421 uint64 + x421, x420 = bits.Mul64(x414, 0xffffffffffffffff) + var x422 uint64 + var x423 uint64 + x423, x422 = bits.Mul64(x414, 0xc7634d81f4372ddf) + var x424 uint64 + var x425 uint64 + x425, x424 = bits.Mul64(x414, 0x581a0db248b0a77a) + var x426 uint64 + var x427 uint64 + x427, x426 = bits.Mul64(x414, 0xecec196accc52973) + var x428 uint64 + var x429 uint64 + x428, x429 = bits.Add64(x427, x424, uint64(0x0)) + var x430 uint64 + var x431 uint64 + x430, x431 = bits.Add64(x425, x422, uint64(uint1(x429))) + var x432 uint64 + var x433 uint64 + x432, x433 = bits.Add64(x423, x420, uint64(uint1(x431))) + var x434 uint64 + var x435 uint64 + x434, x435 = bits.Add64(x421, x418, uint64(uint1(x433))) + var x436 uint64 + var x437 uint64 + x436, x437 = bits.Add64(x419, x416, uint64(uint1(x435))) + x438 := (uint64(uint1(x437)) + x417) + var x440 uint64 + _, x440 = bits.Add64(x400, x426, uint64(0x0)) + var x441 uint64 + var x442 uint64 + x441, x442 = bits.Add64(x402, x428, uint64(uint1(x440))) + var x443 uint64 + var x444 uint64 + x443, x444 = bits.Add64(x404, x430, uint64(uint1(x442))) + var x445 uint64 + var x446 uint64 + x445, x446 = bits.Add64(x406, x432, uint64(uint1(x444))) + var x447 uint64 + var x448 uint64 + x447, x448 = bits.Add64(x408, x434, uint64(uint1(x446))) + var x449 uint64 + var x450 uint64 + x449, x450 = bits.Add64(x410, x436, uint64(uint1(x448))) + var x451 uint64 + var x452 uint64 + x451, x452 = bits.Add64(x412, x438, uint64(uint1(x450))) + x453 := (uint64(uint1(x452)) + uint64(uint1(x413))) + var x454 uint64 + var x455 uint64 + x454, x455 = bits.Sub64(x441, 0xecec196accc52973, uint64(0x0)) + var x456 uint64 + var x457 uint64 + x456, x457 = bits.Sub64(x443, 0x581a0db248b0a77a, uint64(uint1(x455))) + var x458 uint64 + var x459 uint64 + x458, x459 = bits.Sub64(x445, 0xc7634d81f4372ddf, uint64(uint1(x457))) + var x460 uint64 + var x461 uint64 + x460, x461 = bits.Sub64(x447, 0xffffffffffffffff, uint64(uint1(x459))) + var x462 uint64 + var x463 uint64 + x462, x463 = bits.Sub64(x449, 0xffffffffffffffff, uint64(uint1(x461))) + var x464 uint64 + var x465 uint64 + x464, x465 = bits.Sub64(x451, 0xffffffffffffffff, uint64(uint1(x463))) + var x467 uint64 + _, x467 = bits.Sub64(x453, uint64(0x0), uint64(uint1(x465))) + var x468 uint64 + cmovznzU64(&x468, uint1(x467), x454, x441) + var x469 uint64 + cmovznzU64(&x469, uint1(x467), x456, x443) + var x470 uint64 + cmovznzU64(&x470, uint1(x467), x458, x445) + var x471 uint64 + cmovznzU64(&x471, uint1(x467), x460, x447) + var x472 uint64 + cmovznzU64(&x472, uint1(x467), x462, x449) + var x473 uint64 + cmovznzU64(&x473, uint1(x467), x464, x451) + out1[0] = x468 + out1[1] = x469 + out1[2] = x470 + out1[3] = x471 + out1[4] = x472 + out1[5] = x473 +} + +// Add adds two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Add(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint64 + var x2 uint64 + x1, x2 = bits.Add64(arg1[0], arg2[0], uint64(0x0)) + var x3 uint64 + var x4 uint64 + x3, x4 = bits.Add64(arg1[1], arg2[1], uint64(uint1(x2))) + var x5 uint64 + var x6 uint64 + x5, x6 = bits.Add64(arg1[2], arg2[2], uint64(uint1(x4))) + var x7 uint64 + var x8 uint64 + x7, x8 = bits.Add64(arg1[3], arg2[3], uint64(uint1(x6))) + var x9 uint64 + var x10 uint64 + x9, x10 = bits.Add64(arg1[4], arg2[4], uint64(uint1(x8))) + var x11 uint64 + var x12 uint64 + x11, x12 = bits.Add64(arg1[5], arg2[5], uint64(uint1(x10))) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Sub64(x1, 0xecec196accc52973, uint64(0x0)) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Sub64(x3, 0x581a0db248b0a77a, uint64(uint1(x14))) + var x17 uint64 + var x18 uint64 + x17, x18 = bits.Sub64(x5, 0xc7634d81f4372ddf, uint64(uint1(x16))) + var x19 uint64 + var x20 uint64 + x19, x20 = bits.Sub64(x7, 0xffffffffffffffff, uint64(uint1(x18))) + var x21 uint64 + var x22 uint64 + x21, x22 = bits.Sub64(x9, 0xffffffffffffffff, uint64(uint1(x20))) + var x23 uint64 + var x24 uint64 + x23, x24 = bits.Sub64(x11, 0xffffffffffffffff, uint64(uint1(x22))) + var x26 uint64 + _, x26 = bits.Sub64(uint64(uint1(x12)), uint64(0x0), uint64(uint1(x24))) + var x27 uint64 + cmovznzU64(&x27, uint1(x26), x13, x1) + var x28 uint64 + cmovznzU64(&x28, uint1(x26), x15, x3) + var x29 uint64 + cmovznzU64(&x29, uint1(x26), x17, x5) + var x30 uint64 + cmovznzU64(&x30, uint1(x26), x19, x7) + var x31 uint64 + cmovznzU64(&x31, uint1(x26), x21, x9) + var x32 uint64 + cmovznzU64(&x32, uint1(x26), x23, x11) + out1[0] = x27 + out1[1] = x28 + out1[2] = x29 + out1[3] = x30 + out1[4] = x31 + out1[5] = x32 +} + +// Sub subtracts two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Sub(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint64 + var x2 uint64 + x1, x2 = bits.Sub64(arg1[0], arg2[0], uint64(0x0)) + var x3 uint64 + var x4 uint64 + x3, x4 = bits.Sub64(arg1[1], arg2[1], uint64(uint1(x2))) + var x5 uint64 + var x6 uint64 + x5, x6 = bits.Sub64(arg1[2], arg2[2], uint64(uint1(x4))) + var x7 uint64 + var x8 uint64 + x7, x8 = bits.Sub64(arg1[3], arg2[3], uint64(uint1(x6))) + var x9 uint64 + var x10 uint64 + x9, x10 = bits.Sub64(arg1[4], arg2[4], uint64(uint1(x8))) + var x11 uint64 + var x12 uint64 + x11, x12 = bits.Sub64(arg1[5], arg2[5], uint64(uint1(x10))) + var x13 uint64 + cmovznzU64(&x13, uint1(x12), uint64(0x0), 0xffffffffffffffff) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(x1, (x13 & 0xecec196accc52973), uint64(0x0)) + var x16 uint64 + var x17 uint64 + x16, x17 = bits.Add64(x3, (x13 & 0x581a0db248b0a77a), uint64(uint1(x15))) + var x18 uint64 + var x19 uint64 + x18, x19 = bits.Add64(x5, (x13 & 0xc7634d81f4372ddf), uint64(uint1(x17))) + var x20 uint64 + var x21 uint64 + x20, x21 = bits.Add64(x7, x13, uint64(uint1(x19))) + var x22 uint64 + var x23 uint64 + x22, x23 = bits.Add64(x9, x13, uint64(uint1(x21))) + var x24 uint64 + x24, _ = bits.Add64(x11, x13, uint64(uint1(x23))) + out1[0] = x14 + out1[1] = x16 + out1[2] = x18 + out1[3] = x20 + out1[4] = x22 + out1[5] = x24 +} + +// Opp negates a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +// 0 ≤ eval out1 < m +// +func Opp(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + var x1 uint64 + var x2 uint64 + x1, x2 = bits.Sub64(uint64(0x0), arg1[0], uint64(0x0)) + var x3 uint64 + var x4 uint64 + x3, x4 = bits.Sub64(uint64(0x0), arg1[1], uint64(uint1(x2))) + var x5 uint64 + var x6 uint64 + x5, x6 = bits.Sub64(uint64(0x0), arg1[2], uint64(uint1(x4))) + var x7 uint64 + var x8 uint64 + x7, x8 = bits.Sub64(uint64(0x0), arg1[3], uint64(uint1(x6))) + var x9 uint64 + var x10 uint64 + x9, x10 = bits.Sub64(uint64(0x0), arg1[4], uint64(uint1(x8))) + var x11 uint64 + var x12 uint64 + x11, x12 = bits.Sub64(uint64(0x0), arg1[5], uint64(uint1(x10))) + var x13 uint64 + cmovznzU64(&x13, uint1(x12), uint64(0x0), 0xffffffffffffffff) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(x1, (x13 & 0xecec196accc52973), uint64(0x0)) + var x16 uint64 + var x17 uint64 + x16, x17 = bits.Add64(x3, (x13 & 0x581a0db248b0a77a), uint64(uint1(x15))) + var x18 uint64 + var x19 uint64 + x18, x19 = bits.Add64(x5, (x13 & 0xc7634d81f4372ddf), uint64(uint1(x17))) + var x20 uint64 + var x21 uint64 + x20, x21 = bits.Add64(x7, x13, uint64(uint1(x19))) + var x22 uint64 + var x23 uint64 + x22, x23 = bits.Add64(x9, x13, uint64(uint1(x21))) + var x24 uint64 + x24, _ = bits.Add64(x11, x13, uint64(uint1(x23))) + out1[0] = x14 + out1[1] = x16 + out1[2] = x18 + out1[3] = x20 + out1[4] = x22 + out1[5] = x24 +} + +// FromMontgomery translates a field element out of the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^6) mod m +// 0 ≤ eval out1 < m +// +func FromMontgomery(out1 *NonMontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[0] + var x2 uint64 + _, x2 = bits.Mul64(x1, 0x6ed46089e88fdc45) + var x4 uint64 + var x5 uint64 + x5, x4 = bits.Mul64(x2, 0xffffffffffffffff) + var x6 uint64 + var x7 uint64 + x7, x6 = bits.Mul64(x2, 0xffffffffffffffff) + var x8 uint64 + var x9 uint64 + x9, x8 = bits.Mul64(x2, 0xffffffffffffffff) + var x10 uint64 + var x11 uint64 + x11, x10 = bits.Mul64(x2, 0xc7634d81f4372ddf) + var x12 uint64 + var x13 uint64 + x13, x12 = bits.Mul64(x2, 0x581a0db248b0a77a) + var x14 uint64 + var x15 uint64 + x15, x14 = bits.Mul64(x2, 0xecec196accc52973) + var x16 uint64 + var x17 uint64 + x16, x17 = bits.Add64(x15, x12, uint64(0x0)) + var x18 uint64 + var x19 uint64 + x18, x19 = bits.Add64(x13, x10, uint64(uint1(x17))) + var x20 uint64 + var x21 uint64 + x20, x21 = bits.Add64(x11, x8, uint64(uint1(x19))) + var x22 uint64 + var x23 uint64 + x22, x23 = bits.Add64(x9, x6, uint64(uint1(x21))) + var x24 uint64 + var x25 uint64 + x24, x25 = bits.Add64(x7, x4, uint64(uint1(x23))) + var x27 uint64 + _, x27 = bits.Add64(x1, x14, uint64(0x0)) + var x28 uint64 + var x29 uint64 + x28, x29 = bits.Add64(uint64(0x0), x16, uint64(uint1(x27))) + var x30 uint64 + var x31 uint64 + x30, x31 = bits.Add64(uint64(0x0), x18, uint64(uint1(x29))) + var x32 uint64 + var x33 uint64 + x32, x33 = bits.Add64(uint64(0x0), x20, uint64(uint1(x31))) + var x34 uint64 + var x35 uint64 + x34, x35 = bits.Add64(uint64(0x0), x22, uint64(uint1(x33))) + var x36 uint64 + var x37 uint64 + x36, x37 = bits.Add64(uint64(0x0), x24, uint64(uint1(x35))) + var x38 uint64 + var x39 uint64 + x38, x39 = bits.Add64(uint64(0x0), (uint64(uint1(x25)) + x5), uint64(uint1(x37))) + var x40 uint64 + var x41 uint64 + x40, x41 = bits.Add64(x28, arg1[1], uint64(0x0)) + var x42 uint64 + var x43 uint64 + x42, x43 = bits.Add64(x30, uint64(0x0), uint64(uint1(x41))) + var x44 uint64 + var x45 uint64 + x44, x45 = bits.Add64(x32, uint64(0x0), uint64(uint1(x43))) + var x46 uint64 + var x47 uint64 + x46, x47 = bits.Add64(x34, uint64(0x0), uint64(uint1(x45))) + var x48 uint64 + var x49 uint64 + x48, x49 = bits.Add64(x36, uint64(0x0), uint64(uint1(x47))) + var x50 uint64 + var x51 uint64 + x50, x51 = bits.Add64(x38, uint64(0x0), uint64(uint1(x49))) + var x52 uint64 + _, x52 = bits.Mul64(x40, 0x6ed46089e88fdc45) + var x54 uint64 + var x55 uint64 + x55, x54 = bits.Mul64(x52, 0xffffffffffffffff) + var x56 uint64 + var x57 uint64 + x57, x56 = bits.Mul64(x52, 0xffffffffffffffff) + var x58 uint64 + var x59 uint64 + x59, x58 = bits.Mul64(x52, 0xffffffffffffffff) + var x60 uint64 + var x61 uint64 + x61, x60 = bits.Mul64(x52, 0xc7634d81f4372ddf) + var x62 uint64 + var x63 uint64 + x63, x62 = bits.Mul64(x52, 0x581a0db248b0a77a) + var x64 uint64 + var x65 uint64 + x65, x64 = bits.Mul64(x52, 0xecec196accc52973) + var x66 uint64 + var x67 uint64 + x66, x67 = bits.Add64(x65, x62, uint64(0x0)) + var x68 uint64 + var x69 uint64 + x68, x69 = bits.Add64(x63, x60, uint64(uint1(x67))) + var x70 uint64 + var x71 uint64 + x70, x71 = bits.Add64(x61, x58, uint64(uint1(x69))) + var x72 uint64 + var x73 uint64 + x72, x73 = bits.Add64(x59, x56, uint64(uint1(x71))) + var x74 uint64 + var x75 uint64 + x74, x75 = bits.Add64(x57, x54, uint64(uint1(x73))) + var x77 uint64 + _, x77 = bits.Add64(x40, x64, uint64(0x0)) + var x78 uint64 + var x79 uint64 + x78, x79 = bits.Add64(x42, x66, uint64(uint1(x77))) + var x80 uint64 + var x81 uint64 + x80, x81 = bits.Add64(x44, x68, uint64(uint1(x79))) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x46, x70, uint64(uint1(x81))) + var x84 uint64 + var x85 uint64 + x84, x85 = bits.Add64(x48, x72, uint64(uint1(x83))) + var x86 uint64 + var x87 uint64 + x86, x87 = bits.Add64(x50, x74, uint64(uint1(x85))) + var x88 uint64 + var x89 uint64 + x88, x89 = bits.Add64((uint64(uint1(x51)) + uint64(uint1(x39))), (uint64(uint1(x75)) + x55), uint64(uint1(x87))) + var x90 uint64 + var x91 uint64 + x90, x91 = bits.Add64(x78, arg1[2], uint64(0x0)) + var x92 uint64 + var x93 uint64 + x92, x93 = bits.Add64(x80, uint64(0x0), uint64(uint1(x91))) + var x94 uint64 + var x95 uint64 + x94, x95 = bits.Add64(x82, uint64(0x0), uint64(uint1(x93))) + var x96 uint64 + var x97 uint64 + x96, x97 = bits.Add64(x84, uint64(0x0), uint64(uint1(x95))) + var x98 uint64 + var x99 uint64 + x98, x99 = bits.Add64(x86, uint64(0x0), uint64(uint1(x97))) + var x100 uint64 + var x101 uint64 + x100, x101 = bits.Add64(x88, uint64(0x0), uint64(uint1(x99))) + var x102 uint64 + _, x102 = bits.Mul64(x90, 0x6ed46089e88fdc45) + var x104 uint64 + var x105 uint64 + x105, x104 = bits.Mul64(x102, 0xffffffffffffffff) + var x106 uint64 + var x107 uint64 + x107, x106 = bits.Mul64(x102, 0xffffffffffffffff) + var x108 uint64 + var x109 uint64 + x109, x108 = bits.Mul64(x102, 0xffffffffffffffff) + var x110 uint64 + var x111 uint64 + x111, x110 = bits.Mul64(x102, 0xc7634d81f4372ddf) + var x112 uint64 + var x113 uint64 + x113, x112 = bits.Mul64(x102, 0x581a0db248b0a77a) + var x114 uint64 + var x115 uint64 + x115, x114 = bits.Mul64(x102, 0xecec196accc52973) + var x116 uint64 + var x117 uint64 + x116, x117 = bits.Add64(x115, x112, uint64(0x0)) + var x118 uint64 + var x119 uint64 + x118, x119 = bits.Add64(x113, x110, uint64(uint1(x117))) + var x120 uint64 + var x121 uint64 + x120, x121 = bits.Add64(x111, x108, uint64(uint1(x119))) + var x122 uint64 + var x123 uint64 + x122, x123 = bits.Add64(x109, x106, uint64(uint1(x121))) + var x124 uint64 + var x125 uint64 + x124, x125 = bits.Add64(x107, x104, uint64(uint1(x123))) + var x127 uint64 + _, x127 = bits.Add64(x90, x114, uint64(0x0)) + var x128 uint64 + var x129 uint64 + x128, x129 = bits.Add64(x92, x116, uint64(uint1(x127))) + var x130 uint64 + var x131 uint64 + x130, x131 = bits.Add64(x94, x118, uint64(uint1(x129))) + var x132 uint64 + var x133 uint64 + x132, x133 = bits.Add64(x96, x120, uint64(uint1(x131))) + var x134 uint64 + var x135 uint64 + x134, x135 = bits.Add64(x98, x122, uint64(uint1(x133))) + var x136 uint64 + var x137 uint64 + x136, x137 = bits.Add64(x100, x124, uint64(uint1(x135))) + var x138 uint64 + var x139 uint64 + x138, x139 = bits.Add64((uint64(uint1(x101)) + uint64(uint1(x89))), (uint64(uint1(x125)) + x105), uint64(uint1(x137))) + var x140 uint64 + var x141 uint64 + x140, x141 = bits.Add64(x128, arg1[3], uint64(0x0)) + var x142 uint64 + var x143 uint64 + x142, x143 = bits.Add64(x130, uint64(0x0), uint64(uint1(x141))) + var x144 uint64 + var x145 uint64 + x144, x145 = bits.Add64(x132, uint64(0x0), uint64(uint1(x143))) + var x146 uint64 + var x147 uint64 + x146, x147 = bits.Add64(x134, uint64(0x0), uint64(uint1(x145))) + var x148 uint64 + var x149 uint64 + x148, x149 = bits.Add64(x136, uint64(0x0), uint64(uint1(x147))) + var x150 uint64 + var x151 uint64 + x150, x151 = bits.Add64(x138, uint64(0x0), uint64(uint1(x149))) + var x152 uint64 + _, x152 = bits.Mul64(x140, 0x6ed46089e88fdc45) + var x154 uint64 + var x155 uint64 + x155, x154 = bits.Mul64(x152, 0xffffffffffffffff) + var x156 uint64 + var x157 uint64 + x157, x156 = bits.Mul64(x152, 0xffffffffffffffff) + var x158 uint64 + var x159 uint64 + x159, x158 = bits.Mul64(x152, 0xffffffffffffffff) + var x160 uint64 + var x161 uint64 + x161, x160 = bits.Mul64(x152, 0xc7634d81f4372ddf) + var x162 uint64 + var x163 uint64 + x163, x162 = bits.Mul64(x152, 0x581a0db248b0a77a) + var x164 uint64 + var x165 uint64 + x165, x164 = bits.Mul64(x152, 0xecec196accc52973) + var x166 uint64 + var x167 uint64 + x166, x167 = bits.Add64(x165, x162, uint64(0x0)) + var x168 uint64 + var x169 uint64 + x168, x169 = bits.Add64(x163, x160, uint64(uint1(x167))) + var x170 uint64 + var x171 uint64 + x170, x171 = bits.Add64(x161, x158, uint64(uint1(x169))) + var x172 uint64 + var x173 uint64 + x172, x173 = bits.Add64(x159, x156, uint64(uint1(x171))) + var x174 uint64 + var x175 uint64 + x174, x175 = bits.Add64(x157, x154, uint64(uint1(x173))) + var x177 uint64 + _, x177 = bits.Add64(x140, x164, uint64(0x0)) + var x178 uint64 + var x179 uint64 + x178, x179 = bits.Add64(x142, x166, uint64(uint1(x177))) + var x180 uint64 + var x181 uint64 + x180, x181 = bits.Add64(x144, x168, uint64(uint1(x179))) + var x182 uint64 + var x183 uint64 + x182, x183 = bits.Add64(x146, x170, uint64(uint1(x181))) + var x184 uint64 + var x185 uint64 + x184, x185 = bits.Add64(x148, x172, uint64(uint1(x183))) + var x186 uint64 + var x187 uint64 + x186, x187 = bits.Add64(x150, x174, uint64(uint1(x185))) + var x188 uint64 + var x189 uint64 + x188, x189 = bits.Add64((uint64(uint1(x151)) + uint64(uint1(x139))), (uint64(uint1(x175)) + x155), uint64(uint1(x187))) + var x190 uint64 + var x191 uint64 + x190, x191 = bits.Add64(x178, arg1[4], uint64(0x0)) + var x192 uint64 + var x193 uint64 + x192, x193 = bits.Add64(x180, uint64(0x0), uint64(uint1(x191))) + var x194 uint64 + var x195 uint64 + x194, x195 = bits.Add64(x182, uint64(0x0), uint64(uint1(x193))) + var x196 uint64 + var x197 uint64 + x196, x197 = bits.Add64(x184, uint64(0x0), uint64(uint1(x195))) + var x198 uint64 + var x199 uint64 + x198, x199 = bits.Add64(x186, uint64(0x0), uint64(uint1(x197))) + var x200 uint64 + var x201 uint64 + x200, x201 = bits.Add64(x188, uint64(0x0), uint64(uint1(x199))) + var x202 uint64 + _, x202 = bits.Mul64(x190, 0x6ed46089e88fdc45) + var x204 uint64 + var x205 uint64 + x205, x204 = bits.Mul64(x202, 0xffffffffffffffff) + var x206 uint64 + var x207 uint64 + x207, x206 = bits.Mul64(x202, 0xffffffffffffffff) + var x208 uint64 + var x209 uint64 + x209, x208 = bits.Mul64(x202, 0xffffffffffffffff) + var x210 uint64 + var x211 uint64 + x211, x210 = bits.Mul64(x202, 0xc7634d81f4372ddf) + var x212 uint64 + var x213 uint64 + x213, x212 = bits.Mul64(x202, 0x581a0db248b0a77a) + var x214 uint64 + var x215 uint64 + x215, x214 = bits.Mul64(x202, 0xecec196accc52973) + var x216 uint64 + var x217 uint64 + x216, x217 = bits.Add64(x215, x212, uint64(0x0)) + var x218 uint64 + var x219 uint64 + x218, x219 = bits.Add64(x213, x210, uint64(uint1(x217))) + var x220 uint64 + var x221 uint64 + x220, x221 = bits.Add64(x211, x208, uint64(uint1(x219))) + var x222 uint64 + var x223 uint64 + x222, x223 = bits.Add64(x209, x206, uint64(uint1(x221))) + var x224 uint64 + var x225 uint64 + x224, x225 = bits.Add64(x207, x204, uint64(uint1(x223))) + var x227 uint64 + _, x227 = bits.Add64(x190, x214, uint64(0x0)) + var x228 uint64 + var x229 uint64 + x228, x229 = bits.Add64(x192, x216, uint64(uint1(x227))) + var x230 uint64 + var x231 uint64 + x230, x231 = bits.Add64(x194, x218, uint64(uint1(x229))) + var x232 uint64 + var x233 uint64 + x232, x233 = bits.Add64(x196, x220, uint64(uint1(x231))) + var x234 uint64 + var x235 uint64 + x234, x235 = bits.Add64(x198, x222, uint64(uint1(x233))) + var x236 uint64 + var x237 uint64 + x236, x237 = bits.Add64(x200, x224, uint64(uint1(x235))) + var x238 uint64 + var x239 uint64 + x238, x239 = bits.Add64((uint64(uint1(x201)) + uint64(uint1(x189))), (uint64(uint1(x225)) + x205), uint64(uint1(x237))) + var x240 uint64 + var x241 uint64 + x240, x241 = bits.Add64(x228, arg1[5], uint64(0x0)) + var x242 uint64 + var x243 uint64 + x242, x243 = bits.Add64(x230, uint64(0x0), uint64(uint1(x241))) + var x244 uint64 + var x245 uint64 + x244, x245 = bits.Add64(x232, uint64(0x0), uint64(uint1(x243))) + var x246 uint64 + var x247 uint64 + x246, x247 = bits.Add64(x234, uint64(0x0), uint64(uint1(x245))) + var x248 uint64 + var x249 uint64 + x248, x249 = bits.Add64(x236, uint64(0x0), uint64(uint1(x247))) + var x250 uint64 + var x251 uint64 + x250, x251 = bits.Add64(x238, uint64(0x0), uint64(uint1(x249))) + var x252 uint64 + _, x252 = bits.Mul64(x240, 0x6ed46089e88fdc45) + var x254 uint64 + var x255 uint64 + x255, x254 = bits.Mul64(x252, 0xffffffffffffffff) + var x256 uint64 + var x257 uint64 + x257, x256 = bits.Mul64(x252, 0xffffffffffffffff) + var x258 uint64 + var x259 uint64 + x259, x258 = bits.Mul64(x252, 0xffffffffffffffff) + var x260 uint64 + var x261 uint64 + x261, x260 = bits.Mul64(x252, 0xc7634d81f4372ddf) + var x262 uint64 + var x263 uint64 + x263, x262 = bits.Mul64(x252, 0x581a0db248b0a77a) + var x264 uint64 + var x265 uint64 + x265, x264 = bits.Mul64(x252, 0xecec196accc52973) + var x266 uint64 + var x267 uint64 + x266, x267 = bits.Add64(x265, x262, uint64(0x0)) + var x268 uint64 + var x269 uint64 + x268, x269 = bits.Add64(x263, x260, uint64(uint1(x267))) + var x270 uint64 + var x271 uint64 + x270, x271 = bits.Add64(x261, x258, uint64(uint1(x269))) + var x272 uint64 + var x273 uint64 + x272, x273 = bits.Add64(x259, x256, uint64(uint1(x271))) + var x274 uint64 + var x275 uint64 + x274, x275 = bits.Add64(x257, x254, uint64(uint1(x273))) + var x277 uint64 + _, x277 = bits.Add64(x240, x264, uint64(0x0)) + var x278 uint64 + var x279 uint64 + x278, x279 = bits.Add64(x242, x266, uint64(uint1(x277))) + var x280 uint64 + var x281 uint64 + x280, x281 = bits.Add64(x244, x268, uint64(uint1(x279))) + var x282 uint64 + var x283 uint64 + x282, x283 = bits.Add64(x246, x270, uint64(uint1(x281))) + var x284 uint64 + var x285 uint64 + x284, x285 = bits.Add64(x248, x272, uint64(uint1(x283))) + var x286 uint64 + var x287 uint64 + x286, x287 = bits.Add64(x250, x274, uint64(uint1(x285))) + var x288 uint64 + var x289 uint64 + x288, x289 = bits.Add64((uint64(uint1(x251)) + uint64(uint1(x239))), (uint64(uint1(x275)) + x255), uint64(uint1(x287))) + var x290 uint64 + var x291 uint64 + x290, x291 = bits.Sub64(x278, 0xecec196accc52973, uint64(0x0)) + var x292 uint64 + var x293 uint64 + x292, x293 = bits.Sub64(x280, 0x581a0db248b0a77a, uint64(uint1(x291))) + var x294 uint64 + var x295 uint64 + x294, x295 = bits.Sub64(x282, 0xc7634d81f4372ddf, uint64(uint1(x293))) + var x296 uint64 + var x297 uint64 + x296, x297 = bits.Sub64(x284, 0xffffffffffffffff, uint64(uint1(x295))) + var x298 uint64 + var x299 uint64 + x298, x299 = bits.Sub64(x286, 0xffffffffffffffff, uint64(uint1(x297))) + var x300 uint64 + var x301 uint64 + x300, x301 = bits.Sub64(x288, 0xffffffffffffffff, uint64(uint1(x299))) + var x303 uint64 + _, x303 = bits.Sub64(uint64(uint1(x289)), uint64(0x0), uint64(uint1(x301))) + var x304 uint64 + cmovznzU64(&x304, uint1(x303), x290, x278) + var x305 uint64 + cmovznzU64(&x305, uint1(x303), x292, x280) + var x306 uint64 + cmovznzU64(&x306, uint1(x303), x294, x282) + var x307 uint64 + cmovznzU64(&x307, uint1(x303), x296, x284) + var x308 uint64 + cmovznzU64(&x308, uint1(x303), x298, x286) + var x309 uint64 + cmovznzU64(&x309, uint1(x303), x300, x288) + out1[0] = x304 + out1[1] = x305 + out1[2] = x306 + out1[3] = x307 + out1[4] = x308 + out1[5] = x309 +} + +// ToMontgomery translates a field element into the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = eval arg1 mod m +// 0 ≤ eval out1 < m +// +func ToMontgomery(out1 *MontgomeryDomainFieldElement, arg1 *NonMontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[4] + x5 := arg1[5] + x6 := arg1[0] + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x6, 0xc84ee012b39bf21) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x6, 0x3fb05b7a28266895) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x6, 0xd40d49174aab1cc5) + var x13 uint64 + var x14 uint64 + x14, x13 = bits.Mul64(x6, 0xbc3e483afcb82947) + var x15 uint64 + var x16 uint64 + x16, x15 = bits.Mul64(x6, 0xff3d81e5df1aa419) + var x17 uint64 + var x18 uint64 + x18, x17 = bits.Mul64(x6, 0x2d319b2419b409a9) + var x19 uint64 + var x20 uint64 + x19, x20 = bits.Add64(x18, x15, uint64(0x0)) + var x21 uint64 + var x22 uint64 + x21, x22 = bits.Add64(x16, x13, uint64(uint1(x20))) + var x23 uint64 + var x24 uint64 + x23, x24 = bits.Add64(x14, x11, uint64(uint1(x22))) + var x25 uint64 + var x26 uint64 + x25, x26 = bits.Add64(x12, x9, uint64(uint1(x24))) + var x27 uint64 + var x28 uint64 + x27, x28 = bits.Add64(x10, x7, uint64(uint1(x26))) + var x29 uint64 + _, x29 = bits.Mul64(x17, 0x6ed46089e88fdc45) + var x31 uint64 + var x32 uint64 + x32, x31 = bits.Mul64(x29, 0xffffffffffffffff) + var x33 uint64 + var x34 uint64 + x34, x33 = bits.Mul64(x29, 0xffffffffffffffff) + var x35 uint64 + var x36 uint64 + x36, x35 = bits.Mul64(x29, 0xffffffffffffffff) + var x37 uint64 + var x38 uint64 + x38, x37 = bits.Mul64(x29, 0xc7634d81f4372ddf) + var x39 uint64 + var x40 uint64 + x40, x39 = bits.Mul64(x29, 0x581a0db248b0a77a) + var x41 uint64 + var x42 uint64 + x42, x41 = bits.Mul64(x29, 0xecec196accc52973) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Add64(x42, x39, uint64(0x0)) + var x45 uint64 + var x46 uint64 + x45, x46 = bits.Add64(x40, x37, uint64(uint1(x44))) + var x47 uint64 + var x48 uint64 + x47, x48 = bits.Add64(x38, x35, uint64(uint1(x46))) + var x49 uint64 + var x50 uint64 + x49, x50 = bits.Add64(x36, x33, uint64(uint1(x48))) + var x51 uint64 + var x52 uint64 + x51, x52 = bits.Add64(x34, x31, uint64(uint1(x50))) + var x54 uint64 + _, x54 = bits.Add64(x17, x41, uint64(0x0)) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Add64(x19, x43, uint64(uint1(x54))) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Add64(x21, x45, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Add64(x23, x47, uint64(uint1(x58))) + var x61 uint64 + var x62 uint64 + x61, x62 = bits.Add64(x25, x49, uint64(uint1(x60))) + var x63 uint64 + var x64 uint64 + x63, x64 = bits.Add64(x27, x51, uint64(uint1(x62))) + var x65 uint64 + var x66 uint64 + x65, x66 = bits.Add64((uint64(uint1(x28)) + x8), (uint64(uint1(x52)) + x32), uint64(uint1(x64))) + var x67 uint64 + var x68 uint64 + x68, x67 = bits.Mul64(x1, 0xc84ee012b39bf21) + var x69 uint64 + var x70 uint64 + x70, x69 = bits.Mul64(x1, 0x3fb05b7a28266895) + var x71 uint64 + var x72 uint64 + x72, x71 = bits.Mul64(x1, 0xd40d49174aab1cc5) + var x73 uint64 + var x74 uint64 + x74, x73 = bits.Mul64(x1, 0xbc3e483afcb82947) + var x75 uint64 + var x76 uint64 + x76, x75 = bits.Mul64(x1, 0xff3d81e5df1aa419) + var x77 uint64 + var x78 uint64 + x78, x77 = bits.Mul64(x1, 0x2d319b2419b409a9) + var x79 uint64 + var x80 uint64 + x79, x80 = bits.Add64(x78, x75, uint64(0x0)) + var x81 uint64 + var x82 uint64 + x81, x82 = bits.Add64(x76, x73, uint64(uint1(x80))) + var x83 uint64 + var x84 uint64 + x83, x84 = bits.Add64(x74, x71, uint64(uint1(x82))) + var x85 uint64 + var x86 uint64 + x85, x86 = bits.Add64(x72, x69, uint64(uint1(x84))) + var x87 uint64 + var x88 uint64 + x87, x88 = bits.Add64(x70, x67, uint64(uint1(x86))) + var x89 uint64 + var x90 uint64 + x89, x90 = bits.Add64(x55, x77, uint64(0x0)) + var x91 uint64 + var x92 uint64 + x91, x92 = bits.Add64(x57, x79, uint64(uint1(x90))) + var x93 uint64 + var x94 uint64 + x93, x94 = bits.Add64(x59, x81, uint64(uint1(x92))) + var x95 uint64 + var x96 uint64 + x95, x96 = bits.Add64(x61, x83, uint64(uint1(x94))) + var x97 uint64 + var x98 uint64 + x97, x98 = bits.Add64(x63, x85, uint64(uint1(x96))) + var x99 uint64 + var x100 uint64 + x99, x100 = bits.Add64(x65, x87, uint64(uint1(x98))) + var x101 uint64 + _, x101 = bits.Mul64(x89, 0x6ed46089e88fdc45) + var x103 uint64 + var x104 uint64 + x104, x103 = bits.Mul64(x101, 0xffffffffffffffff) + var x105 uint64 + var x106 uint64 + x106, x105 = bits.Mul64(x101, 0xffffffffffffffff) + var x107 uint64 + var x108 uint64 + x108, x107 = bits.Mul64(x101, 0xffffffffffffffff) + var x109 uint64 + var x110 uint64 + x110, x109 = bits.Mul64(x101, 0xc7634d81f4372ddf) + var x111 uint64 + var x112 uint64 + x112, x111 = bits.Mul64(x101, 0x581a0db248b0a77a) + var x113 uint64 + var x114 uint64 + x114, x113 = bits.Mul64(x101, 0xecec196accc52973) + var x115 uint64 + var x116 uint64 + x115, x116 = bits.Add64(x114, x111, uint64(0x0)) + var x117 uint64 + var x118 uint64 + x117, x118 = bits.Add64(x112, x109, uint64(uint1(x116))) + var x119 uint64 + var x120 uint64 + x119, x120 = bits.Add64(x110, x107, uint64(uint1(x118))) + var x121 uint64 + var x122 uint64 + x121, x122 = bits.Add64(x108, x105, uint64(uint1(x120))) + var x123 uint64 + var x124 uint64 + x123, x124 = bits.Add64(x106, x103, uint64(uint1(x122))) + var x126 uint64 + _, x126 = bits.Add64(x89, x113, uint64(0x0)) + var x127 uint64 + var x128 uint64 + x127, x128 = bits.Add64(x91, x115, uint64(uint1(x126))) + var x129 uint64 + var x130 uint64 + x129, x130 = bits.Add64(x93, x117, uint64(uint1(x128))) + var x131 uint64 + var x132 uint64 + x131, x132 = bits.Add64(x95, x119, uint64(uint1(x130))) + var x133 uint64 + var x134 uint64 + x133, x134 = bits.Add64(x97, x121, uint64(uint1(x132))) + var x135 uint64 + var x136 uint64 + x135, x136 = bits.Add64(x99, x123, uint64(uint1(x134))) + var x137 uint64 + var x138 uint64 + x137, x138 = bits.Add64(((uint64(uint1(x100)) + uint64(uint1(x66))) + (uint64(uint1(x88)) + x68)), (uint64(uint1(x124)) + x104), uint64(uint1(x136))) + var x139 uint64 + var x140 uint64 + x140, x139 = bits.Mul64(x2, 0xc84ee012b39bf21) + var x141 uint64 + var x142 uint64 + x142, x141 = bits.Mul64(x2, 0x3fb05b7a28266895) + var x143 uint64 + var x144 uint64 + x144, x143 = bits.Mul64(x2, 0xd40d49174aab1cc5) + var x145 uint64 + var x146 uint64 + x146, x145 = bits.Mul64(x2, 0xbc3e483afcb82947) + var x147 uint64 + var x148 uint64 + x148, x147 = bits.Mul64(x2, 0xff3d81e5df1aa419) + var x149 uint64 + var x150 uint64 + x150, x149 = bits.Mul64(x2, 0x2d319b2419b409a9) + var x151 uint64 + var x152 uint64 + x151, x152 = bits.Add64(x150, x147, uint64(0x0)) + var x153 uint64 + var x154 uint64 + x153, x154 = bits.Add64(x148, x145, uint64(uint1(x152))) + var x155 uint64 + var x156 uint64 + x155, x156 = bits.Add64(x146, x143, uint64(uint1(x154))) + var x157 uint64 + var x158 uint64 + x157, x158 = bits.Add64(x144, x141, uint64(uint1(x156))) + var x159 uint64 + var x160 uint64 + x159, x160 = bits.Add64(x142, x139, uint64(uint1(x158))) + var x161 uint64 + var x162 uint64 + x161, x162 = bits.Add64(x127, x149, uint64(0x0)) + var x163 uint64 + var x164 uint64 + x163, x164 = bits.Add64(x129, x151, uint64(uint1(x162))) + var x165 uint64 + var x166 uint64 + x165, x166 = bits.Add64(x131, x153, uint64(uint1(x164))) + var x167 uint64 + var x168 uint64 + x167, x168 = bits.Add64(x133, x155, uint64(uint1(x166))) + var x169 uint64 + var x170 uint64 + x169, x170 = bits.Add64(x135, x157, uint64(uint1(x168))) + var x171 uint64 + var x172 uint64 + x171, x172 = bits.Add64(x137, x159, uint64(uint1(x170))) + var x173 uint64 + _, x173 = bits.Mul64(x161, 0x6ed46089e88fdc45) + var x175 uint64 + var x176 uint64 + x176, x175 = bits.Mul64(x173, 0xffffffffffffffff) + var x177 uint64 + var x178 uint64 + x178, x177 = bits.Mul64(x173, 0xffffffffffffffff) + var x179 uint64 + var x180 uint64 + x180, x179 = bits.Mul64(x173, 0xffffffffffffffff) + var x181 uint64 + var x182 uint64 + x182, x181 = bits.Mul64(x173, 0xc7634d81f4372ddf) + var x183 uint64 + var x184 uint64 + x184, x183 = bits.Mul64(x173, 0x581a0db248b0a77a) + var x185 uint64 + var x186 uint64 + x186, x185 = bits.Mul64(x173, 0xecec196accc52973) + var x187 uint64 + var x188 uint64 + x187, x188 = bits.Add64(x186, x183, uint64(0x0)) + var x189 uint64 + var x190 uint64 + x189, x190 = bits.Add64(x184, x181, uint64(uint1(x188))) + var x191 uint64 + var x192 uint64 + x191, x192 = bits.Add64(x182, x179, uint64(uint1(x190))) + var x193 uint64 + var x194 uint64 + x193, x194 = bits.Add64(x180, x177, uint64(uint1(x192))) + var x195 uint64 + var x196 uint64 + x195, x196 = bits.Add64(x178, x175, uint64(uint1(x194))) + var x198 uint64 + _, x198 = bits.Add64(x161, x185, uint64(0x0)) + var x199 uint64 + var x200 uint64 + x199, x200 = bits.Add64(x163, x187, uint64(uint1(x198))) + var x201 uint64 + var x202 uint64 + x201, x202 = bits.Add64(x165, x189, uint64(uint1(x200))) + var x203 uint64 + var x204 uint64 + x203, x204 = bits.Add64(x167, x191, uint64(uint1(x202))) + var x205 uint64 + var x206 uint64 + x205, x206 = bits.Add64(x169, x193, uint64(uint1(x204))) + var x207 uint64 + var x208 uint64 + x207, x208 = bits.Add64(x171, x195, uint64(uint1(x206))) + var x209 uint64 + var x210 uint64 + x209, x210 = bits.Add64(((uint64(uint1(x172)) + uint64(uint1(x138))) + (uint64(uint1(x160)) + x140)), (uint64(uint1(x196)) + x176), uint64(uint1(x208))) + var x211 uint64 + var x212 uint64 + x212, x211 = bits.Mul64(x3, 0xc84ee012b39bf21) + var x213 uint64 + var x214 uint64 + x214, x213 = bits.Mul64(x3, 0x3fb05b7a28266895) + var x215 uint64 + var x216 uint64 + x216, x215 = bits.Mul64(x3, 0xd40d49174aab1cc5) + var x217 uint64 + var x218 uint64 + x218, x217 = bits.Mul64(x3, 0xbc3e483afcb82947) + var x219 uint64 + var x220 uint64 + x220, x219 = bits.Mul64(x3, 0xff3d81e5df1aa419) + var x221 uint64 + var x222 uint64 + x222, x221 = bits.Mul64(x3, 0x2d319b2419b409a9) + var x223 uint64 + var x224 uint64 + x223, x224 = bits.Add64(x222, x219, uint64(0x0)) + var x225 uint64 + var x226 uint64 + x225, x226 = bits.Add64(x220, x217, uint64(uint1(x224))) + var x227 uint64 + var x228 uint64 + x227, x228 = bits.Add64(x218, x215, uint64(uint1(x226))) + var x229 uint64 + var x230 uint64 + x229, x230 = bits.Add64(x216, x213, uint64(uint1(x228))) + var x231 uint64 + var x232 uint64 + x231, x232 = bits.Add64(x214, x211, uint64(uint1(x230))) + var x233 uint64 + var x234 uint64 + x233, x234 = bits.Add64(x199, x221, uint64(0x0)) + var x235 uint64 + var x236 uint64 + x235, x236 = bits.Add64(x201, x223, uint64(uint1(x234))) + var x237 uint64 + var x238 uint64 + x237, x238 = bits.Add64(x203, x225, uint64(uint1(x236))) + var x239 uint64 + var x240 uint64 + x239, x240 = bits.Add64(x205, x227, uint64(uint1(x238))) + var x241 uint64 + var x242 uint64 + x241, x242 = bits.Add64(x207, x229, uint64(uint1(x240))) + var x243 uint64 + var x244 uint64 + x243, x244 = bits.Add64(x209, x231, uint64(uint1(x242))) + var x245 uint64 + _, x245 = bits.Mul64(x233, 0x6ed46089e88fdc45) + var x247 uint64 + var x248 uint64 + x248, x247 = bits.Mul64(x245, 0xffffffffffffffff) + var x249 uint64 + var x250 uint64 + x250, x249 = bits.Mul64(x245, 0xffffffffffffffff) + var x251 uint64 + var x252 uint64 + x252, x251 = bits.Mul64(x245, 0xffffffffffffffff) + var x253 uint64 + var x254 uint64 + x254, x253 = bits.Mul64(x245, 0xc7634d81f4372ddf) + var x255 uint64 + var x256 uint64 + x256, x255 = bits.Mul64(x245, 0x581a0db248b0a77a) + var x257 uint64 + var x258 uint64 + x258, x257 = bits.Mul64(x245, 0xecec196accc52973) + var x259 uint64 + var x260 uint64 + x259, x260 = bits.Add64(x258, x255, uint64(0x0)) + var x261 uint64 + var x262 uint64 + x261, x262 = bits.Add64(x256, x253, uint64(uint1(x260))) + var x263 uint64 + var x264 uint64 + x263, x264 = bits.Add64(x254, x251, uint64(uint1(x262))) + var x265 uint64 + var x266 uint64 + x265, x266 = bits.Add64(x252, x249, uint64(uint1(x264))) + var x267 uint64 + var x268 uint64 + x267, x268 = bits.Add64(x250, x247, uint64(uint1(x266))) + var x270 uint64 + _, x270 = bits.Add64(x233, x257, uint64(0x0)) + var x271 uint64 + var x272 uint64 + x271, x272 = bits.Add64(x235, x259, uint64(uint1(x270))) + var x273 uint64 + var x274 uint64 + x273, x274 = bits.Add64(x237, x261, uint64(uint1(x272))) + var x275 uint64 + var x276 uint64 + x275, x276 = bits.Add64(x239, x263, uint64(uint1(x274))) + var x277 uint64 + var x278 uint64 + x277, x278 = bits.Add64(x241, x265, uint64(uint1(x276))) + var x279 uint64 + var x280 uint64 + x279, x280 = bits.Add64(x243, x267, uint64(uint1(x278))) + var x281 uint64 + var x282 uint64 + x281, x282 = bits.Add64(((uint64(uint1(x244)) + uint64(uint1(x210))) + (uint64(uint1(x232)) + x212)), (uint64(uint1(x268)) + x248), uint64(uint1(x280))) + var x283 uint64 + var x284 uint64 + x284, x283 = bits.Mul64(x4, 0xc84ee012b39bf21) + var x285 uint64 + var x286 uint64 + x286, x285 = bits.Mul64(x4, 0x3fb05b7a28266895) + var x287 uint64 + var x288 uint64 + x288, x287 = bits.Mul64(x4, 0xd40d49174aab1cc5) + var x289 uint64 + var x290 uint64 + x290, x289 = bits.Mul64(x4, 0xbc3e483afcb82947) + var x291 uint64 + var x292 uint64 + x292, x291 = bits.Mul64(x4, 0xff3d81e5df1aa419) + var x293 uint64 + var x294 uint64 + x294, x293 = bits.Mul64(x4, 0x2d319b2419b409a9) + var x295 uint64 + var x296 uint64 + x295, x296 = bits.Add64(x294, x291, uint64(0x0)) + var x297 uint64 + var x298 uint64 + x297, x298 = bits.Add64(x292, x289, uint64(uint1(x296))) + var x299 uint64 + var x300 uint64 + x299, x300 = bits.Add64(x290, x287, uint64(uint1(x298))) + var x301 uint64 + var x302 uint64 + x301, x302 = bits.Add64(x288, x285, uint64(uint1(x300))) + var x303 uint64 + var x304 uint64 + x303, x304 = bits.Add64(x286, x283, uint64(uint1(x302))) + var x305 uint64 + var x306 uint64 + x305, x306 = bits.Add64(x271, x293, uint64(0x0)) + var x307 uint64 + var x308 uint64 + x307, x308 = bits.Add64(x273, x295, uint64(uint1(x306))) + var x309 uint64 + var x310 uint64 + x309, x310 = bits.Add64(x275, x297, uint64(uint1(x308))) + var x311 uint64 + var x312 uint64 + x311, x312 = bits.Add64(x277, x299, uint64(uint1(x310))) + var x313 uint64 + var x314 uint64 + x313, x314 = bits.Add64(x279, x301, uint64(uint1(x312))) + var x315 uint64 + var x316 uint64 + x315, x316 = bits.Add64(x281, x303, uint64(uint1(x314))) + var x317 uint64 + _, x317 = bits.Mul64(x305, 0x6ed46089e88fdc45) + var x319 uint64 + var x320 uint64 + x320, x319 = bits.Mul64(x317, 0xffffffffffffffff) + var x321 uint64 + var x322 uint64 + x322, x321 = bits.Mul64(x317, 0xffffffffffffffff) + var x323 uint64 + var x324 uint64 + x324, x323 = bits.Mul64(x317, 0xffffffffffffffff) + var x325 uint64 + var x326 uint64 + x326, x325 = bits.Mul64(x317, 0xc7634d81f4372ddf) + var x327 uint64 + var x328 uint64 + x328, x327 = bits.Mul64(x317, 0x581a0db248b0a77a) + var x329 uint64 + var x330 uint64 + x330, x329 = bits.Mul64(x317, 0xecec196accc52973) + var x331 uint64 + var x332 uint64 + x331, x332 = bits.Add64(x330, x327, uint64(0x0)) + var x333 uint64 + var x334 uint64 + x333, x334 = bits.Add64(x328, x325, uint64(uint1(x332))) + var x335 uint64 + var x336 uint64 + x335, x336 = bits.Add64(x326, x323, uint64(uint1(x334))) + var x337 uint64 + var x338 uint64 + x337, x338 = bits.Add64(x324, x321, uint64(uint1(x336))) + var x339 uint64 + var x340 uint64 + x339, x340 = bits.Add64(x322, x319, uint64(uint1(x338))) + var x342 uint64 + _, x342 = bits.Add64(x305, x329, uint64(0x0)) + var x343 uint64 + var x344 uint64 + x343, x344 = bits.Add64(x307, x331, uint64(uint1(x342))) + var x345 uint64 + var x346 uint64 + x345, x346 = bits.Add64(x309, x333, uint64(uint1(x344))) + var x347 uint64 + var x348 uint64 + x347, x348 = bits.Add64(x311, x335, uint64(uint1(x346))) + var x349 uint64 + var x350 uint64 + x349, x350 = bits.Add64(x313, x337, uint64(uint1(x348))) + var x351 uint64 + var x352 uint64 + x351, x352 = bits.Add64(x315, x339, uint64(uint1(x350))) + var x353 uint64 + var x354 uint64 + x353, x354 = bits.Add64(((uint64(uint1(x316)) + uint64(uint1(x282))) + (uint64(uint1(x304)) + x284)), (uint64(uint1(x340)) + x320), uint64(uint1(x352))) + var x355 uint64 + var x356 uint64 + x356, x355 = bits.Mul64(x5, 0xc84ee012b39bf21) + var x357 uint64 + var x358 uint64 + x358, x357 = bits.Mul64(x5, 0x3fb05b7a28266895) + var x359 uint64 + var x360 uint64 + x360, x359 = bits.Mul64(x5, 0xd40d49174aab1cc5) + var x361 uint64 + var x362 uint64 + x362, x361 = bits.Mul64(x5, 0xbc3e483afcb82947) + var x363 uint64 + var x364 uint64 + x364, x363 = bits.Mul64(x5, 0xff3d81e5df1aa419) + var x365 uint64 + var x366 uint64 + x366, x365 = bits.Mul64(x5, 0x2d319b2419b409a9) + var x367 uint64 + var x368 uint64 + x367, x368 = bits.Add64(x366, x363, uint64(0x0)) + var x369 uint64 + var x370 uint64 + x369, x370 = bits.Add64(x364, x361, uint64(uint1(x368))) + var x371 uint64 + var x372 uint64 + x371, x372 = bits.Add64(x362, x359, uint64(uint1(x370))) + var x373 uint64 + var x374 uint64 + x373, x374 = bits.Add64(x360, x357, uint64(uint1(x372))) + var x375 uint64 + var x376 uint64 + x375, x376 = bits.Add64(x358, x355, uint64(uint1(x374))) + var x377 uint64 + var x378 uint64 + x377, x378 = bits.Add64(x343, x365, uint64(0x0)) + var x379 uint64 + var x380 uint64 + x379, x380 = bits.Add64(x345, x367, uint64(uint1(x378))) + var x381 uint64 + var x382 uint64 + x381, x382 = bits.Add64(x347, x369, uint64(uint1(x380))) + var x383 uint64 + var x384 uint64 + x383, x384 = bits.Add64(x349, x371, uint64(uint1(x382))) + var x385 uint64 + var x386 uint64 + x385, x386 = bits.Add64(x351, x373, uint64(uint1(x384))) + var x387 uint64 + var x388 uint64 + x387, x388 = bits.Add64(x353, x375, uint64(uint1(x386))) + var x389 uint64 + _, x389 = bits.Mul64(x377, 0x6ed46089e88fdc45) + var x391 uint64 + var x392 uint64 + x392, x391 = bits.Mul64(x389, 0xffffffffffffffff) + var x393 uint64 + var x394 uint64 + x394, x393 = bits.Mul64(x389, 0xffffffffffffffff) + var x395 uint64 + var x396 uint64 + x396, x395 = bits.Mul64(x389, 0xffffffffffffffff) + var x397 uint64 + var x398 uint64 + x398, x397 = bits.Mul64(x389, 0xc7634d81f4372ddf) + var x399 uint64 + var x400 uint64 + x400, x399 = bits.Mul64(x389, 0x581a0db248b0a77a) + var x401 uint64 + var x402 uint64 + x402, x401 = bits.Mul64(x389, 0xecec196accc52973) + var x403 uint64 + var x404 uint64 + x403, x404 = bits.Add64(x402, x399, uint64(0x0)) + var x405 uint64 + var x406 uint64 + x405, x406 = bits.Add64(x400, x397, uint64(uint1(x404))) + var x407 uint64 + var x408 uint64 + x407, x408 = bits.Add64(x398, x395, uint64(uint1(x406))) + var x409 uint64 + var x410 uint64 + x409, x410 = bits.Add64(x396, x393, uint64(uint1(x408))) + var x411 uint64 + var x412 uint64 + x411, x412 = bits.Add64(x394, x391, uint64(uint1(x410))) + var x414 uint64 + _, x414 = bits.Add64(x377, x401, uint64(0x0)) + var x415 uint64 + var x416 uint64 + x415, x416 = bits.Add64(x379, x403, uint64(uint1(x414))) + var x417 uint64 + var x418 uint64 + x417, x418 = bits.Add64(x381, x405, uint64(uint1(x416))) + var x419 uint64 + var x420 uint64 + x419, x420 = bits.Add64(x383, x407, uint64(uint1(x418))) + var x421 uint64 + var x422 uint64 + x421, x422 = bits.Add64(x385, x409, uint64(uint1(x420))) + var x423 uint64 + var x424 uint64 + x423, x424 = bits.Add64(x387, x411, uint64(uint1(x422))) + var x425 uint64 + var x426 uint64 + x425, x426 = bits.Add64(((uint64(uint1(x388)) + uint64(uint1(x354))) + (uint64(uint1(x376)) + x356)), (uint64(uint1(x412)) + x392), uint64(uint1(x424))) + var x427 uint64 + var x428 uint64 + x427, x428 = bits.Sub64(x415, 0xecec196accc52973, uint64(0x0)) + var x429 uint64 + var x430 uint64 + x429, x430 = bits.Sub64(x417, 0x581a0db248b0a77a, uint64(uint1(x428))) + var x431 uint64 + var x432 uint64 + x431, x432 = bits.Sub64(x419, 0xc7634d81f4372ddf, uint64(uint1(x430))) + var x433 uint64 + var x434 uint64 + x433, x434 = bits.Sub64(x421, 0xffffffffffffffff, uint64(uint1(x432))) + var x435 uint64 + var x436 uint64 + x435, x436 = bits.Sub64(x423, 0xffffffffffffffff, uint64(uint1(x434))) + var x437 uint64 + var x438 uint64 + x437, x438 = bits.Sub64(x425, 0xffffffffffffffff, uint64(uint1(x436))) + var x440 uint64 + _, x440 = bits.Sub64(uint64(uint1(x426)), uint64(0x0), uint64(uint1(x438))) + var x441 uint64 + cmovznzU64(&x441, uint1(x440), x427, x415) + var x442 uint64 + cmovznzU64(&x442, uint1(x440), x429, x417) + var x443 uint64 + cmovznzU64(&x443, uint1(x440), x431, x419) + var x444 uint64 + cmovznzU64(&x444, uint1(x440), x433, x421) + var x445 uint64 + cmovznzU64(&x445, uint1(x440), x435, x423) + var x446 uint64 + cmovznzU64(&x446, uint1(x440), x437, x425) + out1[0] = x441 + out1[1] = x442 + out1[2] = x443 + out1[3] = x444 + out1[4] = x445 + out1[5] = x446 +} + +// Nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffffffffffff] +func Nonzero(out1 *uint64, arg1 *[6]uint64) { + x1 := (arg1[0] | (arg1[1] | (arg1[2] | (arg1[3] | (arg1[4] | arg1[5]))))) + *out1 = x1 +} + +// Selectznz is a multi-limb conditional select. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func Selectznz(out1 *[6]uint64, arg1 uint1, arg2 *[6]uint64, arg3 *[6]uint64) { + var x1 uint64 + cmovznzU64(&x1, arg1, arg2[0], arg3[0]) + var x2 uint64 + cmovznzU64(&x2, arg1, arg2[1], arg3[1]) + var x3 uint64 + cmovznzU64(&x3, arg1, arg2[2], arg3[2]) + var x4 uint64 + cmovznzU64(&x4, arg1, arg2[3], arg3[3]) + var x5 uint64 + cmovznzU64(&x5, arg1, arg2[4], arg3[4]) + var x6 uint64 + cmovznzU64(&x6, arg1, arg2[5], arg3[5]) + out1[0] = x1 + out1[1] = x2 + out1[2] = x3 + out1[3] = x4 + out1[4] = x5 + out1[5] = x6 +} + +// ToBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47] +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +func ToBytes(out1 *[48]uint8, arg1 *[6]uint64) { + x1 := arg1[5] + x2 := arg1[4] + x3 := arg1[3] + x4 := arg1[2] + x5 := arg1[1] + x6 := arg1[0] + x7 := (uint8(x6) & 0xff) + x8 := (x6 >> 8) + x9 := (uint8(x8) & 0xff) + x10 := (x8 >> 8) + x11 := (uint8(x10) & 0xff) + x12 := (x10 >> 8) + x13 := (uint8(x12) & 0xff) + x14 := (x12 >> 8) + x15 := (uint8(x14) & 0xff) + x16 := (x14 >> 8) + x17 := (uint8(x16) & 0xff) + x18 := (x16 >> 8) + x19 := (uint8(x18) & 0xff) + x20 := uint8((x18 >> 8)) + x21 := (uint8(x5) & 0xff) + x22 := (x5 >> 8) + x23 := (uint8(x22) & 0xff) + x24 := (x22 >> 8) + x25 := (uint8(x24) & 0xff) + x26 := (x24 >> 8) + x27 := (uint8(x26) & 0xff) + x28 := (x26 >> 8) + x29 := (uint8(x28) & 0xff) + x30 := (x28 >> 8) + x31 := (uint8(x30) & 0xff) + x32 := (x30 >> 8) + x33 := (uint8(x32) & 0xff) + x34 := uint8((x32 >> 8)) + x35 := (uint8(x4) & 0xff) + x36 := (x4 >> 8) + x37 := (uint8(x36) & 0xff) + x38 := (x36 >> 8) + x39 := (uint8(x38) & 0xff) + x40 := (x38 >> 8) + x41 := (uint8(x40) & 0xff) + x42 := (x40 >> 8) + x43 := (uint8(x42) & 0xff) + x44 := (x42 >> 8) + x45 := (uint8(x44) & 0xff) + x46 := (x44 >> 8) + x47 := (uint8(x46) & 0xff) + x48 := uint8((x46 >> 8)) + x49 := (uint8(x3) & 0xff) + x50 := (x3 >> 8) + x51 := (uint8(x50) & 0xff) + x52 := (x50 >> 8) + x53 := (uint8(x52) & 0xff) + x54 := (x52 >> 8) + x55 := (uint8(x54) & 0xff) + x56 := (x54 >> 8) + x57 := (uint8(x56) & 0xff) + x58 := (x56 >> 8) + x59 := (uint8(x58) & 0xff) + x60 := (x58 >> 8) + x61 := (uint8(x60) & 0xff) + x62 := uint8((x60 >> 8)) + x63 := (uint8(x2) & 0xff) + x64 := (x2 >> 8) + x65 := (uint8(x64) & 0xff) + x66 := (x64 >> 8) + x67 := (uint8(x66) & 0xff) + x68 := (x66 >> 8) + x69 := (uint8(x68) & 0xff) + x70 := (x68 >> 8) + x71 := (uint8(x70) & 0xff) + x72 := (x70 >> 8) + x73 := (uint8(x72) & 0xff) + x74 := (x72 >> 8) + x75 := (uint8(x74) & 0xff) + x76 := uint8((x74 >> 8)) + x77 := (uint8(x1) & 0xff) + x78 := (x1 >> 8) + x79 := (uint8(x78) & 0xff) + x80 := (x78 >> 8) + x81 := (uint8(x80) & 0xff) + x82 := (x80 >> 8) + x83 := (uint8(x82) & 0xff) + x84 := (x82 >> 8) + x85 := (uint8(x84) & 0xff) + x86 := (x84 >> 8) + x87 := (uint8(x86) & 0xff) + x88 := (x86 >> 8) + x89 := (uint8(x88) & 0xff) + x90 := uint8((x88 >> 8)) + out1[0] = x7 + out1[1] = x9 + out1[2] = x11 + out1[3] = x13 + out1[4] = x15 + out1[5] = x17 + out1[6] = x19 + out1[7] = x20 + out1[8] = x21 + out1[9] = x23 + out1[10] = x25 + out1[11] = x27 + out1[12] = x29 + out1[13] = x31 + out1[14] = x33 + out1[15] = x34 + out1[16] = x35 + out1[17] = x37 + out1[18] = x39 + out1[19] = x41 + out1[20] = x43 + out1[21] = x45 + out1[22] = x47 + out1[23] = x48 + out1[24] = x49 + out1[25] = x51 + out1[26] = x53 + out1[27] = x55 + out1[28] = x57 + out1[29] = x59 + out1[30] = x61 + out1[31] = x62 + out1[32] = x63 + out1[33] = x65 + out1[34] = x67 + out1[35] = x69 + out1[36] = x71 + out1[37] = x73 + out1[38] = x75 + out1[39] = x76 + out1[40] = x77 + out1[41] = x79 + out1[42] = x81 + out1[43] = x83 + out1[44] = x85 + out1[45] = x87 + out1[46] = x89 + out1[47] = x90 +} + +// FromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +// +// Preconditions: +// 0 ≤ bytes_eval arg1 < m +// Postconditions: +// eval out1 mod m = bytes_eval arg1 mod m +// 0 ≤ eval out1 < m +// +// Input Bounds: +// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func FromBytes(out1 *[6]uint64, arg1 *[48]uint8) { + x1 := (uint64(arg1[47]) << 56) + x2 := (uint64(arg1[46]) << 48) + x3 := (uint64(arg1[45]) << 40) + x4 := (uint64(arg1[44]) << 32) + x5 := (uint64(arg1[43]) << 24) + x6 := (uint64(arg1[42]) << 16) + x7 := (uint64(arg1[41]) << 8) + x8 := arg1[40] + x9 := (uint64(arg1[39]) << 56) + x10 := (uint64(arg1[38]) << 48) + x11 := (uint64(arg1[37]) << 40) + x12 := (uint64(arg1[36]) << 32) + x13 := (uint64(arg1[35]) << 24) + x14 := (uint64(arg1[34]) << 16) + x15 := (uint64(arg1[33]) << 8) + x16 := arg1[32] + x17 := (uint64(arg1[31]) << 56) + x18 := (uint64(arg1[30]) << 48) + x19 := (uint64(arg1[29]) << 40) + x20 := (uint64(arg1[28]) << 32) + x21 := (uint64(arg1[27]) << 24) + x22 := (uint64(arg1[26]) << 16) + x23 := (uint64(arg1[25]) << 8) + x24 := arg1[24] + x25 := (uint64(arg1[23]) << 56) + x26 := (uint64(arg1[22]) << 48) + x27 := (uint64(arg1[21]) << 40) + x28 := (uint64(arg1[20]) << 32) + x29 := (uint64(arg1[19]) << 24) + x30 := (uint64(arg1[18]) << 16) + x31 := (uint64(arg1[17]) << 8) + x32 := arg1[16] + x33 := (uint64(arg1[15]) << 56) + x34 := (uint64(arg1[14]) << 48) + x35 := (uint64(arg1[13]) << 40) + x36 := (uint64(arg1[12]) << 32) + x37 := (uint64(arg1[11]) << 24) + x38 := (uint64(arg1[10]) << 16) + x39 := (uint64(arg1[9]) << 8) + x40 := arg1[8] + x41 := (uint64(arg1[7]) << 56) + x42 := (uint64(arg1[6]) << 48) + x43 := (uint64(arg1[5]) << 40) + x44 := (uint64(arg1[4]) << 32) + x45 := (uint64(arg1[3]) << 24) + x46 := (uint64(arg1[2]) << 16) + x47 := (uint64(arg1[1]) << 8) + x48 := arg1[0] + x49 := (x47 + uint64(x48)) + x50 := (x46 + x49) + x51 := (x45 + x50) + x52 := (x44 + x51) + x53 := (x43 + x52) + x54 := (x42 + x53) + x55 := (x41 + x54) + x56 := (x39 + uint64(x40)) + x57 := (x38 + x56) + x58 := (x37 + x57) + x59 := (x36 + x58) + x60 := (x35 + x59) + x61 := (x34 + x60) + x62 := (x33 + x61) + x63 := (x31 + uint64(x32)) + x64 := (x30 + x63) + x65 := (x29 + x64) + x66 := (x28 + x65) + x67 := (x27 + x66) + x68 := (x26 + x67) + x69 := (x25 + x68) + x70 := (x23 + uint64(x24)) + x71 := (x22 + x70) + x72 := (x21 + x71) + x73 := (x20 + x72) + x74 := (x19 + x73) + x75 := (x18 + x74) + x76 := (x17 + x75) + x77 := (x15 + uint64(x16)) + x78 := (x14 + x77) + x79 := (x13 + x78) + x80 := (x12 + x79) + x81 := (x11 + x80) + x82 := (x10 + x81) + x83 := (x9 + x82) + x84 := (x7 + uint64(x8)) + x85 := (x6 + x84) + x86 := (x5 + x85) + x87 := (x4 + x86) + x88 := (x3 + x87) + x89 := (x2 + x88) + x90 := (x1 + x89) + out1[0] = x55 + out1[1] = x62 + out1[2] = x69 + out1[3] = x76 + out1[4] = x83 + out1[5] = x90 +} + +// SetOne returns the field element one in the Montgomery domain. +// +// Postconditions: +// eval (from_montgomery out1) mod m = 1 mod m +// 0 ≤ eval out1 < m +// +func SetOne(out1 *MontgomeryDomainFieldElement) { + out1[0] = 0x1313e695333ad68d + out1[1] = 0xa7e5f24db74f5885 + out1[2] = 0x389cb27e0bc8d220 + out1[3] = uint64(0x0) + out1[4] = uint64(0x0) + out1[5] = uint64(0x0) +} + +// Msat returns the saturated representation of the prime modulus. +// +// Postconditions: +// twos_complement_eval out1 = m +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func Msat(out1 *[7]uint64) { + out1[0] = 0xecec196accc52973 + out1[1] = 0x581a0db248b0a77a + out1[2] = 0xc7634d81f4372ddf + out1[3] = 0xffffffffffffffff + out1[4] = 0xffffffffffffffff + out1[5] = 0xffffffffffffffff + out1[6] = uint64(0x0) +} + +// Divstep computes a divstep. +// +// Preconditions: +// 0 ≤ eval arg4 < m +// 0 ≤ eval arg5 < m +// Postconditions: +// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +// 0 ≤ eval out5 < m +// 0 ≤ eval out5 < m +// 0 ≤ eval out2 < m +// 0 ≤ eval out3 < m +// +// Input Bounds: +// arg1: [0x0 ~> 0xffffffffffffffff] +// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffffffffffff] +// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func Divstep(out1 *uint64, out2 *[7]uint64, out3 *[7]uint64, out4 *[6]uint64, out5 *[6]uint64, arg1 uint64, arg2 *[7]uint64, arg3 *[7]uint64, arg4 *[6]uint64, arg5 *[6]uint64) { + var x1 uint64 + x1, _ = bits.Add64((^arg1), uint64(0x1), uint64(0x0)) + x3 := (uint1((x1 >> 63)) & (uint1(arg3[0]) & 0x1)) + var x4 uint64 + x4, _ = bits.Add64((^arg1), uint64(0x1), uint64(0x0)) + var x6 uint64 + cmovznzU64(&x6, x3, arg1, x4) + var x7 uint64 + cmovznzU64(&x7, x3, arg2[0], arg3[0]) + var x8 uint64 + cmovznzU64(&x8, x3, arg2[1], arg3[1]) + var x9 uint64 + cmovznzU64(&x9, x3, arg2[2], arg3[2]) + var x10 uint64 + cmovznzU64(&x10, x3, arg2[3], arg3[3]) + var x11 uint64 + cmovznzU64(&x11, x3, arg2[4], arg3[4]) + var x12 uint64 + cmovznzU64(&x12, x3, arg2[5], arg3[5]) + var x13 uint64 + cmovznzU64(&x13, x3, arg2[6], arg3[6]) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(uint64(0x1), (^arg2[0]), uint64(0x0)) + var x16 uint64 + var x17 uint64 + x16, x17 = bits.Add64(uint64(0x0), (^arg2[1]), uint64(uint1(x15))) + var x18 uint64 + var x19 uint64 + x18, x19 = bits.Add64(uint64(0x0), (^arg2[2]), uint64(uint1(x17))) + var x20 uint64 + var x21 uint64 + x20, x21 = bits.Add64(uint64(0x0), (^arg2[3]), uint64(uint1(x19))) + var x22 uint64 + var x23 uint64 + x22, x23 = bits.Add64(uint64(0x0), (^arg2[4]), uint64(uint1(x21))) + var x24 uint64 + var x25 uint64 + x24, x25 = bits.Add64(uint64(0x0), (^arg2[5]), uint64(uint1(x23))) + var x26 uint64 + x26, _ = bits.Add64(uint64(0x0), (^arg2[6]), uint64(uint1(x25))) + var x28 uint64 + cmovznzU64(&x28, x3, arg3[0], x14) + var x29 uint64 + cmovznzU64(&x29, x3, arg3[1], x16) + var x30 uint64 + cmovznzU64(&x30, x3, arg3[2], x18) + var x31 uint64 + cmovznzU64(&x31, x3, arg3[3], x20) + var x32 uint64 + cmovznzU64(&x32, x3, arg3[4], x22) + var x33 uint64 + cmovznzU64(&x33, x3, arg3[5], x24) + var x34 uint64 + cmovznzU64(&x34, x3, arg3[6], x26) + var x35 uint64 + cmovznzU64(&x35, x3, arg4[0], arg5[0]) + var x36 uint64 + cmovznzU64(&x36, x3, arg4[1], arg5[1]) + var x37 uint64 + cmovznzU64(&x37, x3, arg4[2], arg5[2]) + var x38 uint64 + cmovznzU64(&x38, x3, arg4[3], arg5[3]) + var x39 uint64 + cmovznzU64(&x39, x3, arg4[4], arg5[4]) + var x40 uint64 + cmovznzU64(&x40, x3, arg4[5], arg5[5]) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Add64(x35, x35, uint64(0x0)) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Add64(x36, x36, uint64(uint1(x42))) + var x45 uint64 + var x46 uint64 + x45, x46 = bits.Add64(x37, x37, uint64(uint1(x44))) + var x47 uint64 + var x48 uint64 + x47, x48 = bits.Add64(x38, x38, uint64(uint1(x46))) + var x49 uint64 + var x50 uint64 + x49, x50 = bits.Add64(x39, x39, uint64(uint1(x48))) + var x51 uint64 + var x52 uint64 + x51, x52 = bits.Add64(x40, x40, uint64(uint1(x50))) + var x53 uint64 + var x54 uint64 + x53, x54 = bits.Sub64(x41, 0xecec196accc52973, uint64(0x0)) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Sub64(x43, 0x581a0db248b0a77a, uint64(uint1(x54))) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Sub64(x45, 0xc7634d81f4372ddf, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Sub64(x47, 0xffffffffffffffff, uint64(uint1(x58))) + var x61 uint64 + var x62 uint64 + x61, x62 = bits.Sub64(x49, 0xffffffffffffffff, uint64(uint1(x60))) + var x63 uint64 + var x64 uint64 + x63, x64 = bits.Sub64(x51, 0xffffffffffffffff, uint64(uint1(x62))) + var x66 uint64 + _, x66 = bits.Sub64(uint64(uint1(x52)), uint64(0x0), uint64(uint1(x64))) + x67 := arg4[5] + x68 := arg4[4] + x69 := arg4[3] + x70 := arg4[2] + x71 := arg4[1] + x72 := arg4[0] + var x73 uint64 + var x74 uint64 + x73, x74 = bits.Sub64(uint64(0x0), x72, uint64(0x0)) + var x75 uint64 + var x76 uint64 + x75, x76 = bits.Sub64(uint64(0x0), x71, uint64(uint1(x74))) + var x77 uint64 + var x78 uint64 + x77, x78 = bits.Sub64(uint64(0x0), x70, uint64(uint1(x76))) + var x79 uint64 + var x80 uint64 + x79, x80 = bits.Sub64(uint64(0x0), x69, uint64(uint1(x78))) + var x81 uint64 + var x82 uint64 + x81, x82 = bits.Sub64(uint64(0x0), x68, uint64(uint1(x80))) + var x83 uint64 + var x84 uint64 + x83, x84 = bits.Sub64(uint64(0x0), x67, uint64(uint1(x82))) + var x85 uint64 + cmovznzU64(&x85, uint1(x84), uint64(0x0), 0xffffffffffffffff) + var x86 uint64 + var x87 uint64 + x86, x87 = bits.Add64(x73, (x85 & 0xecec196accc52973), uint64(0x0)) + var x88 uint64 + var x89 uint64 + x88, x89 = bits.Add64(x75, (x85 & 0x581a0db248b0a77a), uint64(uint1(x87))) + var x90 uint64 + var x91 uint64 + x90, x91 = bits.Add64(x77, (x85 & 0xc7634d81f4372ddf), uint64(uint1(x89))) + var x92 uint64 + var x93 uint64 + x92, x93 = bits.Add64(x79, x85, uint64(uint1(x91))) + var x94 uint64 + var x95 uint64 + x94, x95 = bits.Add64(x81, x85, uint64(uint1(x93))) + var x96 uint64 + x96, _ = bits.Add64(x83, x85, uint64(uint1(x95))) + var x98 uint64 + cmovznzU64(&x98, x3, arg5[0], x86) + var x99 uint64 + cmovznzU64(&x99, x3, arg5[1], x88) + var x100 uint64 + cmovznzU64(&x100, x3, arg5[2], x90) + var x101 uint64 + cmovznzU64(&x101, x3, arg5[3], x92) + var x102 uint64 + cmovznzU64(&x102, x3, arg5[4], x94) + var x103 uint64 + cmovznzU64(&x103, x3, arg5[5], x96) + x104 := (uint1(x28) & 0x1) + var x105 uint64 + cmovznzU64(&x105, x104, uint64(0x0), x7) + var x106 uint64 + cmovznzU64(&x106, x104, uint64(0x0), x8) + var x107 uint64 + cmovznzU64(&x107, x104, uint64(0x0), x9) + var x108 uint64 + cmovznzU64(&x108, x104, uint64(0x0), x10) + var x109 uint64 + cmovznzU64(&x109, x104, uint64(0x0), x11) + var x110 uint64 + cmovznzU64(&x110, x104, uint64(0x0), x12) + var x111 uint64 + cmovznzU64(&x111, x104, uint64(0x0), x13) + var x112 uint64 + var x113 uint64 + x112, x113 = bits.Add64(x28, x105, uint64(0x0)) + var x114 uint64 + var x115 uint64 + x114, x115 = bits.Add64(x29, x106, uint64(uint1(x113))) + var x116 uint64 + var x117 uint64 + x116, x117 = bits.Add64(x30, x107, uint64(uint1(x115))) + var x118 uint64 + var x119 uint64 + x118, x119 = bits.Add64(x31, x108, uint64(uint1(x117))) + var x120 uint64 + var x121 uint64 + x120, x121 = bits.Add64(x32, x109, uint64(uint1(x119))) + var x122 uint64 + var x123 uint64 + x122, x123 = bits.Add64(x33, x110, uint64(uint1(x121))) + var x124 uint64 + x124, _ = bits.Add64(x34, x111, uint64(uint1(x123))) + var x126 uint64 + cmovznzU64(&x126, x104, uint64(0x0), x35) + var x127 uint64 + cmovznzU64(&x127, x104, uint64(0x0), x36) + var x128 uint64 + cmovznzU64(&x128, x104, uint64(0x0), x37) + var x129 uint64 + cmovznzU64(&x129, x104, uint64(0x0), x38) + var x130 uint64 + cmovznzU64(&x130, x104, uint64(0x0), x39) + var x131 uint64 + cmovznzU64(&x131, x104, uint64(0x0), x40) + var x132 uint64 + var x133 uint64 + x132, x133 = bits.Add64(x98, x126, uint64(0x0)) + var x134 uint64 + var x135 uint64 + x134, x135 = bits.Add64(x99, x127, uint64(uint1(x133))) + var x136 uint64 + var x137 uint64 + x136, x137 = bits.Add64(x100, x128, uint64(uint1(x135))) + var x138 uint64 + var x139 uint64 + x138, x139 = bits.Add64(x101, x129, uint64(uint1(x137))) + var x140 uint64 + var x141 uint64 + x140, x141 = bits.Add64(x102, x130, uint64(uint1(x139))) + var x142 uint64 + var x143 uint64 + x142, x143 = bits.Add64(x103, x131, uint64(uint1(x141))) + var x144 uint64 + var x145 uint64 + x144, x145 = bits.Sub64(x132, 0xecec196accc52973, uint64(0x0)) + var x146 uint64 + var x147 uint64 + x146, x147 = bits.Sub64(x134, 0x581a0db248b0a77a, uint64(uint1(x145))) + var x148 uint64 + var x149 uint64 + x148, x149 = bits.Sub64(x136, 0xc7634d81f4372ddf, uint64(uint1(x147))) + var x150 uint64 + var x151 uint64 + x150, x151 = bits.Sub64(x138, 0xffffffffffffffff, uint64(uint1(x149))) + var x152 uint64 + var x153 uint64 + x152, x153 = bits.Sub64(x140, 0xffffffffffffffff, uint64(uint1(x151))) + var x154 uint64 + var x155 uint64 + x154, x155 = bits.Sub64(x142, 0xffffffffffffffff, uint64(uint1(x153))) + var x157 uint64 + _, x157 = bits.Sub64(uint64(uint1(x143)), uint64(0x0), uint64(uint1(x155))) + var x158 uint64 + x158, _ = bits.Add64(x6, uint64(0x1), uint64(0x0)) + x160 := ((x112 >> 1) | ((x114 << 63) & 0xffffffffffffffff)) + x161 := ((x114 >> 1) | ((x116 << 63) & 0xffffffffffffffff)) + x162 := ((x116 >> 1) | ((x118 << 63) & 0xffffffffffffffff)) + x163 := ((x118 >> 1) | ((x120 << 63) & 0xffffffffffffffff)) + x164 := ((x120 >> 1) | ((x122 << 63) & 0xffffffffffffffff)) + x165 := ((x122 >> 1) | ((x124 << 63) & 0xffffffffffffffff)) + x166 := ((x124 & 0x8000000000000000) | (x124 >> 1)) + var x167 uint64 + cmovznzU64(&x167, uint1(x66), x53, x41) + var x168 uint64 + cmovznzU64(&x168, uint1(x66), x55, x43) + var x169 uint64 + cmovznzU64(&x169, uint1(x66), x57, x45) + var x170 uint64 + cmovznzU64(&x170, uint1(x66), x59, x47) + var x171 uint64 + cmovznzU64(&x171, uint1(x66), x61, x49) + var x172 uint64 + cmovznzU64(&x172, uint1(x66), x63, x51) + var x173 uint64 + cmovznzU64(&x173, uint1(x157), x144, x132) + var x174 uint64 + cmovznzU64(&x174, uint1(x157), x146, x134) + var x175 uint64 + cmovznzU64(&x175, uint1(x157), x148, x136) + var x176 uint64 + cmovznzU64(&x176, uint1(x157), x150, x138) + var x177 uint64 + cmovznzU64(&x177, uint1(x157), x152, x140) + var x178 uint64 + cmovznzU64(&x178, uint1(x157), x154, x142) + *out1 = x158 + out2[0] = x7 + out2[1] = x8 + out2[2] = x9 + out2[3] = x10 + out2[4] = x11 + out2[5] = x12 + out2[6] = x13 + out3[0] = x160 + out3[1] = x161 + out3[2] = x162 + out3[3] = x163 + out3[4] = x164 + out3[5] = x165 + out3[6] = x166 + out4[0] = x167 + out4[1] = x168 + out4[2] = x169 + out4[3] = x170 + out4[4] = x171 + out4[5] = x172 + out5[0] = x173 + out5[1] = x174 + out5[2] = x175 + out5[3] = x176 + out5[4] = x177 + out5[5] = x178 +} + +// DivstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +// +// Postconditions: +// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func DivstepPrecomp(out1 *[6]uint64) { + out1[0] = 0x49589ae0e6045b6a + out1[1] = 0x3c9a5352870040ed + out1[2] = 0xdacb097e977dc242 + out1[3] = 0xb5ab30a6d1ecbe36 + out1[4] = 0x97d7a1081f959973 + out1[5] = 0x2ba012f8d27192bc +} diff --git a/fiat-go/64/secp256k1scalar/secp256k1scalar.go b/fiat-go/64/secp256k1scalar/secp256k1scalar.go new file mode 100644 index 0000000000..8df668c376 --- /dev/null +++ b/fiat-go/64/secp256k1scalar/secp256k1scalar.go @@ -0,0 +1,1910 @@ +// Code generated by Fiat Cryptography. DO NOT EDIT. +// +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Go --no-wide-int --relax-primitive-carry-to-bitwidth 32,64 --cmovznz-by-mul --internal-static --package-case flatcase --public-function-case UpperCamelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case camelCase --no-prefix-fiat --doc-newline-in-typedef-bounds --doc-prepend-header 'Code generated by Fiat Cryptography. DO NOT EDIT.' --doc-text-before-function-name '' --doc-text-before-type-name '' --package-name secp256k1scalar '' 64 '2^256 - 432420386565659656852420866394968145599' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// +// curve description (via package name): secp256k1scalar +// +// machine_wordsize = 64 (from "64") +// +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// +// m = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141 (from "2^256 - 432420386565659656852420866394968145599") +// +// +// +// NOTE: In addition to the bounds specified above each function, all +// +// functions synthesized for this Montgomery arithmetic require the +// +// input to be strictly less than the prime modulus (m), and also +// +// require the input to be in the unique saturated representation. +// +// All functions also ensure that these two properties are true of +// +// return values. +// +// +// +// Computed values: +// +// eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) +// +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +// +// twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in +// +// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 +package secp256k1scalar + +import "math/bits" + +type uint1 uint64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 +type int1 int64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927 + +// MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +type MontgomeryDomainFieldElement [4]uint64 + +// NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// +// Bounds: +// +// [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +type NonMontgomeryDomainFieldElement [4]uint64 + +// cmovznzU64 is a single-word conditional move. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [0x0 ~> 0xffffffffffffffff] +// arg3: [0x0 ~> 0xffffffffffffffff] +// Output Bounds: +// out1: [0x0 ~> 0xffffffffffffffff] +func cmovznzU64(out1 *uint64, arg1 uint1, arg2 uint64, arg3 uint64) { + x1 := (uint64(arg1) * 0xffffffffffffffff) + x2 := ((x1 & arg3) | ((^x1) & arg2)) + *out1 = x2 +} + +// Mul multiplies two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Mul(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[0] + var x5 uint64 + var x6 uint64 + x6, x5 = bits.Mul64(x4, arg2[3]) + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x4, arg2[2]) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x4, arg2[1]) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x4, arg2[0]) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Add64(x12, x9, uint64(0x0)) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Add64(x10, x7, uint64(uint1(x14))) + var x17 uint64 + var x18 uint64 + x17, x18 = bits.Add64(x8, x5, uint64(uint1(x16))) + x19 := (uint64(uint1(x18)) + x6) + var x20 uint64 + _, x20 = bits.Mul64(x11, 0x4b0dff665588b13f) + var x22 uint64 + var x23 uint64 + x23, x22 = bits.Mul64(x20, 0xffffffffffffffff) + var x24 uint64 + var x25 uint64 + x25, x24 = bits.Mul64(x20, 0xfffffffffffffffe) + var x26 uint64 + var x27 uint64 + x27, x26 = bits.Mul64(x20, 0xbaaedce6af48a03b) + var x28 uint64 + var x29 uint64 + x29, x28 = bits.Mul64(x20, 0xbfd25e8cd0364141) + var x30 uint64 + var x31 uint64 + x30, x31 = bits.Add64(x29, x26, uint64(0x0)) + var x32 uint64 + var x33 uint64 + x32, x33 = bits.Add64(x27, x24, uint64(uint1(x31))) + var x34 uint64 + var x35 uint64 + x34, x35 = bits.Add64(x25, x22, uint64(uint1(x33))) + x36 := (uint64(uint1(x35)) + x23) + var x38 uint64 + _, x38 = bits.Add64(x11, x28, uint64(0x0)) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Add64(x13, x30, uint64(uint1(x38))) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Add64(x15, x32, uint64(uint1(x40))) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Add64(x17, x34, uint64(uint1(x42))) + var x45 uint64 + var x46 uint64 + x45, x46 = bits.Add64(x19, x36, uint64(uint1(x44))) + var x47 uint64 + var x48 uint64 + x48, x47 = bits.Mul64(x1, arg2[3]) + var x49 uint64 + var x50 uint64 + x50, x49 = bits.Mul64(x1, arg2[2]) + var x51 uint64 + var x52 uint64 + x52, x51 = bits.Mul64(x1, arg2[1]) + var x53 uint64 + var x54 uint64 + x54, x53 = bits.Mul64(x1, arg2[0]) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Add64(x54, x51, uint64(0x0)) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Add64(x52, x49, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Add64(x50, x47, uint64(uint1(x58))) + x61 := (uint64(uint1(x60)) + x48) + var x62 uint64 + var x63 uint64 + x62, x63 = bits.Add64(x39, x53, uint64(0x0)) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(x41, x55, uint64(uint1(x63))) + var x66 uint64 + var x67 uint64 + x66, x67 = bits.Add64(x43, x57, uint64(uint1(x65))) + var x68 uint64 + var x69 uint64 + x68, x69 = bits.Add64(x45, x59, uint64(uint1(x67))) + var x70 uint64 + var x71 uint64 + x70, x71 = bits.Add64(uint64(uint1(x46)), x61, uint64(uint1(x69))) + var x72 uint64 + _, x72 = bits.Mul64(x62, 0x4b0dff665588b13f) + var x74 uint64 + var x75 uint64 + x75, x74 = bits.Mul64(x72, 0xffffffffffffffff) + var x76 uint64 + var x77 uint64 + x77, x76 = bits.Mul64(x72, 0xfffffffffffffffe) + var x78 uint64 + var x79 uint64 + x79, x78 = bits.Mul64(x72, 0xbaaedce6af48a03b) + var x80 uint64 + var x81 uint64 + x81, x80 = bits.Mul64(x72, 0xbfd25e8cd0364141) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x81, x78, uint64(0x0)) + var x84 uint64 + var x85 uint64 + x84, x85 = bits.Add64(x79, x76, uint64(uint1(x83))) + var x86 uint64 + var x87 uint64 + x86, x87 = bits.Add64(x77, x74, uint64(uint1(x85))) + x88 := (uint64(uint1(x87)) + x75) + var x90 uint64 + _, x90 = bits.Add64(x62, x80, uint64(0x0)) + var x91 uint64 + var x92 uint64 + x91, x92 = bits.Add64(x64, x82, uint64(uint1(x90))) + var x93 uint64 + var x94 uint64 + x93, x94 = bits.Add64(x66, x84, uint64(uint1(x92))) + var x95 uint64 + var x96 uint64 + x95, x96 = bits.Add64(x68, x86, uint64(uint1(x94))) + var x97 uint64 + var x98 uint64 + x97, x98 = bits.Add64(x70, x88, uint64(uint1(x96))) + x99 := (uint64(uint1(x98)) + uint64(uint1(x71))) + var x100 uint64 + var x101 uint64 + x101, x100 = bits.Mul64(x2, arg2[3]) + var x102 uint64 + var x103 uint64 + x103, x102 = bits.Mul64(x2, arg2[2]) + var x104 uint64 + var x105 uint64 + x105, x104 = bits.Mul64(x2, arg2[1]) + var x106 uint64 + var x107 uint64 + x107, x106 = bits.Mul64(x2, arg2[0]) + var x108 uint64 + var x109 uint64 + x108, x109 = bits.Add64(x107, x104, uint64(0x0)) + var x110 uint64 + var x111 uint64 + x110, x111 = bits.Add64(x105, x102, uint64(uint1(x109))) + var x112 uint64 + var x113 uint64 + x112, x113 = bits.Add64(x103, x100, uint64(uint1(x111))) + x114 := (uint64(uint1(x113)) + x101) + var x115 uint64 + var x116 uint64 + x115, x116 = bits.Add64(x91, x106, uint64(0x0)) + var x117 uint64 + var x118 uint64 + x117, x118 = bits.Add64(x93, x108, uint64(uint1(x116))) + var x119 uint64 + var x120 uint64 + x119, x120 = bits.Add64(x95, x110, uint64(uint1(x118))) + var x121 uint64 + var x122 uint64 + x121, x122 = bits.Add64(x97, x112, uint64(uint1(x120))) + var x123 uint64 + var x124 uint64 + x123, x124 = bits.Add64(x99, x114, uint64(uint1(x122))) + var x125 uint64 + _, x125 = bits.Mul64(x115, 0x4b0dff665588b13f) + var x127 uint64 + var x128 uint64 + x128, x127 = bits.Mul64(x125, 0xffffffffffffffff) + var x129 uint64 + var x130 uint64 + x130, x129 = bits.Mul64(x125, 0xfffffffffffffffe) + var x131 uint64 + var x132 uint64 + x132, x131 = bits.Mul64(x125, 0xbaaedce6af48a03b) + var x133 uint64 + var x134 uint64 + x134, x133 = bits.Mul64(x125, 0xbfd25e8cd0364141) + var x135 uint64 + var x136 uint64 + x135, x136 = bits.Add64(x134, x131, uint64(0x0)) + var x137 uint64 + var x138 uint64 + x137, x138 = bits.Add64(x132, x129, uint64(uint1(x136))) + var x139 uint64 + var x140 uint64 + x139, x140 = bits.Add64(x130, x127, uint64(uint1(x138))) + x141 := (uint64(uint1(x140)) + x128) + var x143 uint64 + _, x143 = bits.Add64(x115, x133, uint64(0x0)) + var x144 uint64 + var x145 uint64 + x144, x145 = bits.Add64(x117, x135, uint64(uint1(x143))) + var x146 uint64 + var x147 uint64 + x146, x147 = bits.Add64(x119, x137, uint64(uint1(x145))) + var x148 uint64 + var x149 uint64 + x148, x149 = bits.Add64(x121, x139, uint64(uint1(x147))) + var x150 uint64 + var x151 uint64 + x150, x151 = bits.Add64(x123, x141, uint64(uint1(x149))) + x152 := (uint64(uint1(x151)) + uint64(uint1(x124))) + var x153 uint64 + var x154 uint64 + x154, x153 = bits.Mul64(x3, arg2[3]) + var x155 uint64 + var x156 uint64 + x156, x155 = bits.Mul64(x3, arg2[2]) + var x157 uint64 + var x158 uint64 + x158, x157 = bits.Mul64(x3, arg2[1]) + var x159 uint64 + var x160 uint64 + x160, x159 = bits.Mul64(x3, arg2[0]) + var x161 uint64 + var x162 uint64 + x161, x162 = bits.Add64(x160, x157, uint64(0x0)) + var x163 uint64 + var x164 uint64 + x163, x164 = bits.Add64(x158, x155, uint64(uint1(x162))) + var x165 uint64 + var x166 uint64 + x165, x166 = bits.Add64(x156, x153, uint64(uint1(x164))) + x167 := (uint64(uint1(x166)) + x154) + var x168 uint64 + var x169 uint64 + x168, x169 = bits.Add64(x144, x159, uint64(0x0)) + var x170 uint64 + var x171 uint64 + x170, x171 = bits.Add64(x146, x161, uint64(uint1(x169))) + var x172 uint64 + var x173 uint64 + x172, x173 = bits.Add64(x148, x163, uint64(uint1(x171))) + var x174 uint64 + var x175 uint64 + x174, x175 = bits.Add64(x150, x165, uint64(uint1(x173))) + var x176 uint64 + var x177 uint64 + x176, x177 = bits.Add64(x152, x167, uint64(uint1(x175))) + var x178 uint64 + _, x178 = bits.Mul64(x168, 0x4b0dff665588b13f) + var x180 uint64 + var x181 uint64 + x181, x180 = bits.Mul64(x178, 0xffffffffffffffff) + var x182 uint64 + var x183 uint64 + x183, x182 = bits.Mul64(x178, 0xfffffffffffffffe) + var x184 uint64 + var x185 uint64 + x185, x184 = bits.Mul64(x178, 0xbaaedce6af48a03b) + var x186 uint64 + var x187 uint64 + x187, x186 = bits.Mul64(x178, 0xbfd25e8cd0364141) + var x188 uint64 + var x189 uint64 + x188, x189 = bits.Add64(x187, x184, uint64(0x0)) + var x190 uint64 + var x191 uint64 + x190, x191 = bits.Add64(x185, x182, uint64(uint1(x189))) + var x192 uint64 + var x193 uint64 + x192, x193 = bits.Add64(x183, x180, uint64(uint1(x191))) + x194 := (uint64(uint1(x193)) + x181) + var x196 uint64 + _, x196 = bits.Add64(x168, x186, uint64(0x0)) + var x197 uint64 + var x198 uint64 + x197, x198 = bits.Add64(x170, x188, uint64(uint1(x196))) + var x199 uint64 + var x200 uint64 + x199, x200 = bits.Add64(x172, x190, uint64(uint1(x198))) + var x201 uint64 + var x202 uint64 + x201, x202 = bits.Add64(x174, x192, uint64(uint1(x200))) + var x203 uint64 + var x204 uint64 + x203, x204 = bits.Add64(x176, x194, uint64(uint1(x202))) + x205 := (uint64(uint1(x204)) + uint64(uint1(x177))) + var x206 uint64 + var x207 uint64 + x206, x207 = bits.Sub64(x197, 0xbfd25e8cd0364141, uint64(0x0)) + var x208 uint64 + var x209 uint64 + x208, x209 = bits.Sub64(x199, 0xbaaedce6af48a03b, uint64(uint1(x207))) + var x210 uint64 + var x211 uint64 + x210, x211 = bits.Sub64(x201, 0xfffffffffffffffe, uint64(uint1(x209))) + var x212 uint64 + var x213 uint64 + x212, x213 = bits.Sub64(x203, 0xffffffffffffffff, uint64(uint1(x211))) + var x215 uint64 + _, x215 = bits.Sub64(x205, uint64(0x0), uint64(uint1(x213))) + var x216 uint64 + cmovznzU64(&x216, uint1(x215), x206, x197) + var x217 uint64 + cmovznzU64(&x217, uint1(x215), x208, x199) + var x218 uint64 + cmovznzU64(&x218, uint1(x215), x210, x201) + var x219 uint64 + cmovznzU64(&x219, uint1(x215), x212, x203) + out1[0] = x216 + out1[1] = x217 + out1[2] = x218 + out1[3] = x219 +} + +// Square squares a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +// 0 ≤ eval out1 < m +// +func Square(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[0] + var x5 uint64 + var x6 uint64 + x6, x5 = bits.Mul64(x4, arg1[3]) + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x4, arg1[2]) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x4, arg1[1]) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x4, arg1[0]) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Add64(x12, x9, uint64(0x0)) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Add64(x10, x7, uint64(uint1(x14))) + var x17 uint64 + var x18 uint64 + x17, x18 = bits.Add64(x8, x5, uint64(uint1(x16))) + x19 := (uint64(uint1(x18)) + x6) + var x20 uint64 + _, x20 = bits.Mul64(x11, 0x4b0dff665588b13f) + var x22 uint64 + var x23 uint64 + x23, x22 = bits.Mul64(x20, 0xffffffffffffffff) + var x24 uint64 + var x25 uint64 + x25, x24 = bits.Mul64(x20, 0xfffffffffffffffe) + var x26 uint64 + var x27 uint64 + x27, x26 = bits.Mul64(x20, 0xbaaedce6af48a03b) + var x28 uint64 + var x29 uint64 + x29, x28 = bits.Mul64(x20, 0xbfd25e8cd0364141) + var x30 uint64 + var x31 uint64 + x30, x31 = bits.Add64(x29, x26, uint64(0x0)) + var x32 uint64 + var x33 uint64 + x32, x33 = bits.Add64(x27, x24, uint64(uint1(x31))) + var x34 uint64 + var x35 uint64 + x34, x35 = bits.Add64(x25, x22, uint64(uint1(x33))) + x36 := (uint64(uint1(x35)) + x23) + var x38 uint64 + _, x38 = bits.Add64(x11, x28, uint64(0x0)) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Add64(x13, x30, uint64(uint1(x38))) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Add64(x15, x32, uint64(uint1(x40))) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Add64(x17, x34, uint64(uint1(x42))) + var x45 uint64 + var x46 uint64 + x45, x46 = bits.Add64(x19, x36, uint64(uint1(x44))) + var x47 uint64 + var x48 uint64 + x48, x47 = bits.Mul64(x1, arg1[3]) + var x49 uint64 + var x50 uint64 + x50, x49 = bits.Mul64(x1, arg1[2]) + var x51 uint64 + var x52 uint64 + x52, x51 = bits.Mul64(x1, arg1[1]) + var x53 uint64 + var x54 uint64 + x54, x53 = bits.Mul64(x1, arg1[0]) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Add64(x54, x51, uint64(0x0)) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Add64(x52, x49, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Add64(x50, x47, uint64(uint1(x58))) + x61 := (uint64(uint1(x60)) + x48) + var x62 uint64 + var x63 uint64 + x62, x63 = bits.Add64(x39, x53, uint64(0x0)) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(x41, x55, uint64(uint1(x63))) + var x66 uint64 + var x67 uint64 + x66, x67 = bits.Add64(x43, x57, uint64(uint1(x65))) + var x68 uint64 + var x69 uint64 + x68, x69 = bits.Add64(x45, x59, uint64(uint1(x67))) + var x70 uint64 + var x71 uint64 + x70, x71 = bits.Add64(uint64(uint1(x46)), x61, uint64(uint1(x69))) + var x72 uint64 + _, x72 = bits.Mul64(x62, 0x4b0dff665588b13f) + var x74 uint64 + var x75 uint64 + x75, x74 = bits.Mul64(x72, 0xffffffffffffffff) + var x76 uint64 + var x77 uint64 + x77, x76 = bits.Mul64(x72, 0xfffffffffffffffe) + var x78 uint64 + var x79 uint64 + x79, x78 = bits.Mul64(x72, 0xbaaedce6af48a03b) + var x80 uint64 + var x81 uint64 + x81, x80 = bits.Mul64(x72, 0xbfd25e8cd0364141) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x81, x78, uint64(0x0)) + var x84 uint64 + var x85 uint64 + x84, x85 = bits.Add64(x79, x76, uint64(uint1(x83))) + var x86 uint64 + var x87 uint64 + x86, x87 = bits.Add64(x77, x74, uint64(uint1(x85))) + x88 := (uint64(uint1(x87)) + x75) + var x90 uint64 + _, x90 = bits.Add64(x62, x80, uint64(0x0)) + var x91 uint64 + var x92 uint64 + x91, x92 = bits.Add64(x64, x82, uint64(uint1(x90))) + var x93 uint64 + var x94 uint64 + x93, x94 = bits.Add64(x66, x84, uint64(uint1(x92))) + var x95 uint64 + var x96 uint64 + x95, x96 = bits.Add64(x68, x86, uint64(uint1(x94))) + var x97 uint64 + var x98 uint64 + x97, x98 = bits.Add64(x70, x88, uint64(uint1(x96))) + x99 := (uint64(uint1(x98)) + uint64(uint1(x71))) + var x100 uint64 + var x101 uint64 + x101, x100 = bits.Mul64(x2, arg1[3]) + var x102 uint64 + var x103 uint64 + x103, x102 = bits.Mul64(x2, arg1[2]) + var x104 uint64 + var x105 uint64 + x105, x104 = bits.Mul64(x2, arg1[1]) + var x106 uint64 + var x107 uint64 + x107, x106 = bits.Mul64(x2, arg1[0]) + var x108 uint64 + var x109 uint64 + x108, x109 = bits.Add64(x107, x104, uint64(0x0)) + var x110 uint64 + var x111 uint64 + x110, x111 = bits.Add64(x105, x102, uint64(uint1(x109))) + var x112 uint64 + var x113 uint64 + x112, x113 = bits.Add64(x103, x100, uint64(uint1(x111))) + x114 := (uint64(uint1(x113)) + x101) + var x115 uint64 + var x116 uint64 + x115, x116 = bits.Add64(x91, x106, uint64(0x0)) + var x117 uint64 + var x118 uint64 + x117, x118 = bits.Add64(x93, x108, uint64(uint1(x116))) + var x119 uint64 + var x120 uint64 + x119, x120 = bits.Add64(x95, x110, uint64(uint1(x118))) + var x121 uint64 + var x122 uint64 + x121, x122 = bits.Add64(x97, x112, uint64(uint1(x120))) + var x123 uint64 + var x124 uint64 + x123, x124 = bits.Add64(x99, x114, uint64(uint1(x122))) + var x125 uint64 + _, x125 = bits.Mul64(x115, 0x4b0dff665588b13f) + var x127 uint64 + var x128 uint64 + x128, x127 = bits.Mul64(x125, 0xffffffffffffffff) + var x129 uint64 + var x130 uint64 + x130, x129 = bits.Mul64(x125, 0xfffffffffffffffe) + var x131 uint64 + var x132 uint64 + x132, x131 = bits.Mul64(x125, 0xbaaedce6af48a03b) + var x133 uint64 + var x134 uint64 + x134, x133 = bits.Mul64(x125, 0xbfd25e8cd0364141) + var x135 uint64 + var x136 uint64 + x135, x136 = bits.Add64(x134, x131, uint64(0x0)) + var x137 uint64 + var x138 uint64 + x137, x138 = bits.Add64(x132, x129, uint64(uint1(x136))) + var x139 uint64 + var x140 uint64 + x139, x140 = bits.Add64(x130, x127, uint64(uint1(x138))) + x141 := (uint64(uint1(x140)) + x128) + var x143 uint64 + _, x143 = bits.Add64(x115, x133, uint64(0x0)) + var x144 uint64 + var x145 uint64 + x144, x145 = bits.Add64(x117, x135, uint64(uint1(x143))) + var x146 uint64 + var x147 uint64 + x146, x147 = bits.Add64(x119, x137, uint64(uint1(x145))) + var x148 uint64 + var x149 uint64 + x148, x149 = bits.Add64(x121, x139, uint64(uint1(x147))) + var x150 uint64 + var x151 uint64 + x150, x151 = bits.Add64(x123, x141, uint64(uint1(x149))) + x152 := (uint64(uint1(x151)) + uint64(uint1(x124))) + var x153 uint64 + var x154 uint64 + x154, x153 = bits.Mul64(x3, arg1[3]) + var x155 uint64 + var x156 uint64 + x156, x155 = bits.Mul64(x3, arg1[2]) + var x157 uint64 + var x158 uint64 + x158, x157 = bits.Mul64(x3, arg1[1]) + var x159 uint64 + var x160 uint64 + x160, x159 = bits.Mul64(x3, arg1[0]) + var x161 uint64 + var x162 uint64 + x161, x162 = bits.Add64(x160, x157, uint64(0x0)) + var x163 uint64 + var x164 uint64 + x163, x164 = bits.Add64(x158, x155, uint64(uint1(x162))) + var x165 uint64 + var x166 uint64 + x165, x166 = bits.Add64(x156, x153, uint64(uint1(x164))) + x167 := (uint64(uint1(x166)) + x154) + var x168 uint64 + var x169 uint64 + x168, x169 = bits.Add64(x144, x159, uint64(0x0)) + var x170 uint64 + var x171 uint64 + x170, x171 = bits.Add64(x146, x161, uint64(uint1(x169))) + var x172 uint64 + var x173 uint64 + x172, x173 = bits.Add64(x148, x163, uint64(uint1(x171))) + var x174 uint64 + var x175 uint64 + x174, x175 = bits.Add64(x150, x165, uint64(uint1(x173))) + var x176 uint64 + var x177 uint64 + x176, x177 = bits.Add64(x152, x167, uint64(uint1(x175))) + var x178 uint64 + _, x178 = bits.Mul64(x168, 0x4b0dff665588b13f) + var x180 uint64 + var x181 uint64 + x181, x180 = bits.Mul64(x178, 0xffffffffffffffff) + var x182 uint64 + var x183 uint64 + x183, x182 = bits.Mul64(x178, 0xfffffffffffffffe) + var x184 uint64 + var x185 uint64 + x185, x184 = bits.Mul64(x178, 0xbaaedce6af48a03b) + var x186 uint64 + var x187 uint64 + x187, x186 = bits.Mul64(x178, 0xbfd25e8cd0364141) + var x188 uint64 + var x189 uint64 + x188, x189 = bits.Add64(x187, x184, uint64(0x0)) + var x190 uint64 + var x191 uint64 + x190, x191 = bits.Add64(x185, x182, uint64(uint1(x189))) + var x192 uint64 + var x193 uint64 + x192, x193 = bits.Add64(x183, x180, uint64(uint1(x191))) + x194 := (uint64(uint1(x193)) + x181) + var x196 uint64 + _, x196 = bits.Add64(x168, x186, uint64(0x0)) + var x197 uint64 + var x198 uint64 + x197, x198 = bits.Add64(x170, x188, uint64(uint1(x196))) + var x199 uint64 + var x200 uint64 + x199, x200 = bits.Add64(x172, x190, uint64(uint1(x198))) + var x201 uint64 + var x202 uint64 + x201, x202 = bits.Add64(x174, x192, uint64(uint1(x200))) + var x203 uint64 + var x204 uint64 + x203, x204 = bits.Add64(x176, x194, uint64(uint1(x202))) + x205 := (uint64(uint1(x204)) + uint64(uint1(x177))) + var x206 uint64 + var x207 uint64 + x206, x207 = bits.Sub64(x197, 0xbfd25e8cd0364141, uint64(0x0)) + var x208 uint64 + var x209 uint64 + x208, x209 = bits.Sub64(x199, 0xbaaedce6af48a03b, uint64(uint1(x207))) + var x210 uint64 + var x211 uint64 + x210, x211 = bits.Sub64(x201, 0xfffffffffffffffe, uint64(uint1(x209))) + var x212 uint64 + var x213 uint64 + x212, x213 = bits.Sub64(x203, 0xffffffffffffffff, uint64(uint1(x211))) + var x215 uint64 + _, x215 = bits.Sub64(x205, uint64(0x0), uint64(uint1(x213))) + var x216 uint64 + cmovznzU64(&x216, uint1(x215), x206, x197) + var x217 uint64 + cmovznzU64(&x217, uint1(x215), x208, x199) + var x218 uint64 + cmovznzU64(&x218, uint1(x215), x210, x201) + var x219 uint64 + cmovznzU64(&x219, uint1(x215), x212, x203) + out1[0] = x216 + out1[1] = x217 + out1[2] = x218 + out1[3] = x219 +} + +// Add adds two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Add(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint64 + var x2 uint64 + x1, x2 = bits.Add64(arg1[0], arg2[0], uint64(0x0)) + var x3 uint64 + var x4 uint64 + x3, x4 = bits.Add64(arg1[1], arg2[1], uint64(uint1(x2))) + var x5 uint64 + var x6 uint64 + x5, x6 = bits.Add64(arg1[2], arg2[2], uint64(uint1(x4))) + var x7 uint64 + var x8 uint64 + x7, x8 = bits.Add64(arg1[3], arg2[3], uint64(uint1(x6))) + var x9 uint64 + var x10 uint64 + x9, x10 = bits.Sub64(x1, 0xbfd25e8cd0364141, uint64(0x0)) + var x11 uint64 + var x12 uint64 + x11, x12 = bits.Sub64(x3, 0xbaaedce6af48a03b, uint64(uint1(x10))) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Sub64(x5, 0xfffffffffffffffe, uint64(uint1(x12))) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Sub64(x7, 0xffffffffffffffff, uint64(uint1(x14))) + var x18 uint64 + _, x18 = bits.Sub64(uint64(uint1(x8)), uint64(0x0), uint64(uint1(x16))) + var x19 uint64 + cmovznzU64(&x19, uint1(x18), x9, x1) + var x20 uint64 + cmovznzU64(&x20, uint1(x18), x11, x3) + var x21 uint64 + cmovznzU64(&x21, uint1(x18), x13, x5) + var x22 uint64 + cmovznzU64(&x22, uint1(x18), x15, x7) + out1[0] = x19 + out1[1] = x20 + out1[2] = x21 + out1[3] = x22 +} + +// Sub subtracts two field elements in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// 0 ≤ eval arg2 < m +// Postconditions: +// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +// 0 ≤ eval out1 < m +// +func Sub(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement, arg2 *MontgomeryDomainFieldElement) { + var x1 uint64 + var x2 uint64 + x1, x2 = bits.Sub64(arg1[0], arg2[0], uint64(0x0)) + var x3 uint64 + var x4 uint64 + x3, x4 = bits.Sub64(arg1[1], arg2[1], uint64(uint1(x2))) + var x5 uint64 + var x6 uint64 + x5, x6 = bits.Sub64(arg1[2], arg2[2], uint64(uint1(x4))) + var x7 uint64 + var x8 uint64 + x7, x8 = bits.Sub64(arg1[3], arg2[3], uint64(uint1(x6))) + var x9 uint64 + cmovznzU64(&x9, uint1(x8), uint64(0x0), 0xffffffffffffffff) + var x10 uint64 + var x11 uint64 + x10, x11 = bits.Add64(x1, (x9 & 0xbfd25e8cd0364141), uint64(0x0)) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x3, (x9 & 0xbaaedce6af48a03b), uint64(uint1(x11))) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(x5, (x9 & 0xfffffffffffffffe), uint64(uint1(x13))) + var x16 uint64 + x16, _ = bits.Add64(x7, x9, uint64(uint1(x15))) + out1[0] = x10 + out1[1] = x12 + out1[2] = x14 + out1[3] = x16 +} + +// Opp negates a field element in the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +// 0 ≤ eval out1 < m +// +func Opp(out1 *MontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + var x1 uint64 + var x2 uint64 + x1, x2 = bits.Sub64(uint64(0x0), arg1[0], uint64(0x0)) + var x3 uint64 + var x4 uint64 + x3, x4 = bits.Sub64(uint64(0x0), arg1[1], uint64(uint1(x2))) + var x5 uint64 + var x6 uint64 + x5, x6 = bits.Sub64(uint64(0x0), arg1[2], uint64(uint1(x4))) + var x7 uint64 + var x8 uint64 + x7, x8 = bits.Sub64(uint64(0x0), arg1[3], uint64(uint1(x6))) + var x9 uint64 + cmovznzU64(&x9, uint1(x8), uint64(0x0), 0xffffffffffffffff) + var x10 uint64 + var x11 uint64 + x10, x11 = bits.Add64(x1, (x9 & 0xbfd25e8cd0364141), uint64(0x0)) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x3, (x9 & 0xbaaedce6af48a03b), uint64(uint1(x11))) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(x5, (x9 & 0xfffffffffffffffe), uint64(uint1(x13))) + var x16 uint64 + x16, _ = bits.Add64(x7, x9, uint64(uint1(x15))) + out1[0] = x10 + out1[1] = x12 + out1[2] = x14 + out1[3] = x16 +} + +// FromMontgomery translates a field element out of the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m +// 0 ≤ eval out1 < m +// +func FromMontgomery(out1 *NonMontgomeryDomainFieldElement, arg1 *MontgomeryDomainFieldElement) { + x1 := arg1[0] + var x2 uint64 + _, x2 = bits.Mul64(x1, 0x4b0dff665588b13f) + var x4 uint64 + var x5 uint64 + x5, x4 = bits.Mul64(x2, 0xffffffffffffffff) + var x6 uint64 + var x7 uint64 + x7, x6 = bits.Mul64(x2, 0xfffffffffffffffe) + var x8 uint64 + var x9 uint64 + x9, x8 = bits.Mul64(x2, 0xbaaedce6af48a03b) + var x10 uint64 + var x11 uint64 + x11, x10 = bits.Mul64(x2, 0xbfd25e8cd0364141) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x11, x8, uint64(0x0)) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(x9, x6, uint64(uint1(x13))) + var x16 uint64 + var x17 uint64 + x16, x17 = bits.Add64(x7, x4, uint64(uint1(x15))) + var x19 uint64 + _, x19 = bits.Add64(x1, x10, uint64(0x0)) + var x20 uint64 + var x21 uint64 + x20, x21 = bits.Add64(uint64(0x0), x12, uint64(uint1(x19))) + var x22 uint64 + var x23 uint64 + x22, x23 = bits.Add64(uint64(0x0), x14, uint64(uint1(x21))) + var x24 uint64 + var x25 uint64 + x24, x25 = bits.Add64(uint64(0x0), x16, uint64(uint1(x23))) + var x26 uint64 + var x27 uint64 + x26, x27 = bits.Add64(uint64(0x0), (uint64(uint1(x17)) + x5), uint64(uint1(x25))) + var x28 uint64 + var x29 uint64 + x28, x29 = bits.Add64(x20, arg1[1], uint64(0x0)) + var x30 uint64 + var x31 uint64 + x30, x31 = bits.Add64(x22, uint64(0x0), uint64(uint1(x29))) + var x32 uint64 + var x33 uint64 + x32, x33 = bits.Add64(x24, uint64(0x0), uint64(uint1(x31))) + var x34 uint64 + var x35 uint64 + x34, x35 = bits.Add64(x26, uint64(0x0), uint64(uint1(x33))) + var x36 uint64 + _, x36 = bits.Mul64(x28, 0x4b0dff665588b13f) + var x38 uint64 + var x39 uint64 + x39, x38 = bits.Mul64(x36, 0xffffffffffffffff) + var x40 uint64 + var x41 uint64 + x41, x40 = bits.Mul64(x36, 0xfffffffffffffffe) + var x42 uint64 + var x43 uint64 + x43, x42 = bits.Mul64(x36, 0xbaaedce6af48a03b) + var x44 uint64 + var x45 uint64 + x45, x44 = bits.Mul64(x36, 0xbfd25e8cd0364141) + var x46 uint64 + var x47 uint64 + x46, x47 = bits.Add64(x45, x42, uint64(0x0)) + var x48 uint64 + var x49 uint64 + x48, x49 = bits.Add64(x43, x40, uint64(uint1(x47))) + var x50 uint64 + var x51 uint64 + x50, x51 = bits.Add64(x41, x38, uint64(uint1(x49))) + var x53 uint64 + _, x53 = bits.Add64(x28, x44, uint64(0x0)) + var x54 uint64 + var x55 uint64 + x54, x55 = bits.Add64(x30, x46, uint64(uint1(x53))) + var x56 uint64 + var x57 uint64 + x56, x57 = bits.Add64(x32, x48, uint64(uint1(x55))) + var x58 uint64 + var x59 uint64 + x58, x59 = bits.Add64(x34, x50, uint64(uint1(x57))) + var x60 uint64 + var x61 uint64 + x60, x61 = bits.Add64((uint64(uint1(x35)) + uint64(uint1(x27))), (uint64(uint1(x51)) + x39), uint64(uint1(x59))) + var x62 uint64 + var x63 uint64 + x62, x63 = bits.Add64(x54, arg1[2], uint64(0x0)) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(x56, uint64(0x0), uint64(uint1(x63))) + var x66 uint64 + var x67 uint64 + x66, x67 = bits.Add64(x58, uint64(0x0), uint64(uint1(x65))) + var x68 uint64 + var x69 uint64 + x68, x69 = bits.Add64(x60, uint64(0x0), uint64(uint1(x67))) + var x70 uint64 + _, x70 = bits.Mul64(x62, 0x4b0dff665588b13f) + var x72 uint64 + var x73 uint64 + x73, x72 = bits.Mul64(x70, 0xffffffffffffffff) + var x74 uint64 + var x75 uint64 + x75, x74 = bits.Mul64(x70, 0xfffffffffffffffe) + var x76 uint64 + var x77 uint64 + x77, x76 = bits.Mul64(x70, 0xbaaedce6af48a03b) + var x78 uint64 + var x79 uint64 + x79, x78 = bits.Mul64(x70, 0xbfd25e8cd0364141) + var x80 uint64 + var x81 uint64 + x80, x81 = bits.Add64(x79, x76, uint64(0x0)) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x77, x74, uint64(uint1(x81))) + var x84 uint64 + var x85 uint64 + x84, x85 = bits.Add64(x75, x72, uint64(uint1(x83))) + var x87 uint64 + _, x87 = bits.Add64(x62, x78, uint64(0x0)) + var x88 uint64 + var x89 uint64 + x88, x89 = bits.Add64(x64, x80, uint64(uint1(x87))) + var x90 uint64 + var x91 uint64 + x90, x91 = bits.Add64(x66, x82, uint64(uint1(x89))) + var x92 uint64 + var x93 uint64 + x92, x93 = bits.Add64(x68, x84, uint64(uint1(x91))) + var x94 uint64 + var x95 uint64 + x94, x95 = bits.Add64((uint64(uint1(x69)) + uint64(uint1(x61))), (uint64(uint1(x85)) + x73), uint64(uint1(x93))) + var x96 uint64 + var x97 uint64 + x96, x97 = bits.Add64(x88, arg1[3], uint64(0x0)) + var x98 uint64 + var x99 uint64 + x98, x99 = bits.Add64(x90, uint64(0x0), uint64(uint1(x97))) + var x100 uint64 + var x101 uint64 + x100, x101 = bits.Add64(x92, uint64(0x0), uint64(uint1(x99))) + var x102 uint64 + var x103 uint64 + x102, x103 = bits.Add64(x94, uint64(0x0), uint64(uint1(x101))) + var x104 uint64 + _, x104 = bits.Mul64(x96, 0x4b0dff665588b13f) + var x106 uint64 + var x107 uint64 + x107, x106 = bits.Mul64(x104, 0xffffffffffffffff) + var x108 uint64 + var x109 uint64 + x109, x108 = bits.Mul64(x104, 0xfffffffffffffffe) + var x110 uint64 + var x111 uint64 + x111, x110 = bits.Mul64(x104, 0xbaaedce6af48a03b) + var x112 uint64 + var x113 uint64 + x113, x112 = bits.Mul64(x104, 0xbfd25e8cd0364141) + var x114 uint64 + var x115 uint64 + x114, x115 = bits.Add64(x113, x110, uint64(0x0)) + var x116 uint64 + var x117 uint64 + x116, x117 = bits.Add64(x111, x108, uint64(uint1(x115))) + var x118 uint64 + var x119 uint64 + x118, x119 = bits.Add64(x109, x106, uint64(uint1(x117))) + var x121 uint64 + _, x121 = bits.Add64(x96, x112, uint64(0x0)) + var x122 uint64 + var x123 uint64 + x122, x123 = bits.Add64(x98, x114, uint64(uint1(x121))) + var x124 uint64 + var x125 uint64 + x124, x125 = bits.Add64(x100, x116, uint64(uint1(x123))) + var x126 uint64 + var x127 uint64 + x126, x127 = bits.Add64(x102, x118, uint64(uint1(x125))) + var x128 uint64 + var x129 uint64 + x128, x129 = bits.Add64((uint64(uint1(x103)) + uint64(uint1(x95))), (uint64(uint1(x119)) + x107), uint64(uint1(x127))) + var x130 uint64 + var x131 uint64 + x130, x131 = bits.Sub64(x122, 0xbfd25e8cd0364141, uint64(0x0)) + var x132 uint64 + var x133 uint64 + x132, x133 = bits.Sub64(x124, 0xbaaedce6af48a03b, uint64(uint1(x131))) + var x134 uint64 + var x135 uint64 + x134, x135 = bits.Sub64(x126, 0xfffffffffffffffe, uint64(uint1(x133))) + var x136 uint64 + var x137 uint64 + x136, x137 = bits.Sub64(x128, 0xffffffffffffffff, uint64(uint1(x135))) + var x139 uint64 + _, x139 = bits.Sub64(uint64(uint1(x129)), uint64(0x0), uint64(uint1(x137))) + var x140 uint64 + cmovznzU64(&x140, uint1(x139), x130, x122) + var x141 uint64 + cmovznzU64(&x141, uint1(x139), x132, x124) + var x142 uint64 + cmovznzU64(&x142, uint1(x139), x134, x126) + var x143 uint64 + cmovznzU64(&x143, uint1(x139), x136, x128) + out1[0] = x140 + out1[1] = x141 + out1[2] = x142 + out1[3] = x143 +} + +// ToMontgomery translates a field element into the Montgomery domain. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// eval (from_montgomery out1) mod m = eval arg1 mod m +// 0 ≤ eval out1 < m +// +func ToMontgomery(out1 *MontgomeryDomainFieldElement, arg1 *NonMontgomeryDomainFieldElement) { + x1 := arg1[1] + x2 := arg1[2] + x3 := arg1[3] + x4 := arg1[0] + var x5 uint64 + var x6 uint64 + x6, x5 = bits.Mul64(x4, 0x9d671cd581c69bc5) + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x4, 0xe697f5e45bcd07c6) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x4, 0x741496c20e7cf878) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x4, 0x896cf21467d7d140) + var x13 uint64 + var x14 uint64 + x13, x14 = bits.Add64(x12, x9, uint64(0x0)) + var x15 uint64 + var x16 uint64 + x15, x16 = bits.Add64(x10, x7, uint64(uint1(x14))) + var x17 uint64 + var x18 uint64 + x17, x18 = bits.Add64(x8, x5, uint64(uint1(x16))) + var x19 uint64 + _, x19 = bits.Mul64(x11, 0x4b0dff665588b13f) + var x21 uint64 + var x22 uint64 + x22, x21 = bits.Mul64(x19, 0xffffffffffffffff) + var x23 uint64 + var x24 uint64 + x24, x23 = bits.Mul64(x19, 0xfffffffffffffffe) + var x25 uint64 + var x26 uint64 + x26, x25 = bits.Mul64(x19, 0xbaaedce6af48a03b) + var x27 uint64 + var x28 uint64 + x28, x27 = bits.Mul64(x19, 0xbfd25e8cd0364141) + var x29 uint64 + var x30 uint64 + x29, x30 = bits.Add64(x28, x25, uint64(0x0)) + var x31 uint64 + var x32 uint64 + x31, x32 = bits.Add64(x26, x23, uint64(uint1(x30))) + var x33 uint64 + var x34 uint64 + x33, x34 = bits.Add64(x24, x21, uint64(uint1(x32))) + var x36 uint64 + _, x36 = bits.Add64(x11, x27, uint64(0x0)) + var x37 uint64 + var x38 uint64 + x37, x38 = bits.Add64(x13, x29, uint64(uint1(x36))) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Add64(x15, x31, uint64(uint1(x38))) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Add64(x17, x33, uint64(uint1(x40))) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Add64((uint64(uint1(x18)) + x6), (uint64(uint1(x34)) + x22), uint64(uint1(x42))) + var x45 uint64 + var x46 uint64 + x46, x45 = bits.Mul64(x1, 0x9d671cd581c69bc5) + var x47 uint64 + var x48 uint64 + x48, x47 = bits.Mul64(x1, 0xe697f5e45bcd07c6) + var x49 uint64 + var x50 uint64 + x50, x49 = bits.Mul64(x1, 0x741496c20e7cf878) + var x51 uint64 + var x52 uint64 + x52, x51 = bits.Mul64(x1, 0x896cf21467d7d140) + var x53 uint64 + var x54 uint64 + x53, x54 = bits.Add64(x52, x49, uint64(0x0)) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Add64(x50, x47, uint64(uint1(x54))) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Add64(x48, x45, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Add64(x37, x51, uint64(0x0)) + var x61 uint64 + var x62 uint64 + x61, x62 = bits.Add64(x39, x53, uint64(uint1(x60))) + var x63 uint64 + var x64 uint64 + x63, x64 = bits.Add64(x41, x55, uint64(uint1(x62))) + var x65 uint64 + var x66 uint64 + x65, x66 = bits.Add64(x43, x57, uint64(uint1(x64))) + var x67 uint64 + _, x67 = bits.Mul64(x59, 0x4b0dff665588b13f) + var x69 uint64 + var x70 uint64 + x70, x69 = bits.Mul64(x67, 0xffffffffffffffff) + var x71 uint64 + var x72 uint64 + x72, x71 = bits.Mul64(x67, 0xfffffffffffffffe) + var x73 uint64 + var x74 uint64 + x74, x73 = bits.Mul64(x67, 0xbaaedce6af48a03b) + var x75 uint64 + var x76 uint64 + x76, x75 = bits.Mul64(x67, 0xbfd25e8cd0364141) + var x77 uint64 + var x78 uint64 + x77, x78 = bits.Add64(x76, x73, uint64(0x0)) + var x79 uint64 + var x80 uint64 + x79, x80 = bits.Add64(x74, x71, uint64(uint1(x78))) + var x81 uint64 + var x82 uint64 + x81, x82 = bits.Add64(x72, x69, uint64(uint1(x80))) + var x84 uint64 + _, x84 = bits.Add64(x59, x75, uint64(0x0)) + var x85 uint64 + var x86 uint64 + x85, x86 = bits.Add64(x61, x77, uint64(uint1(x84))) + var x87 uint64 + var x88 uint64 + x87, x88 = bits.Add64(x63, x79, uint64(uint1(x86))) + var x89 uint64 + var x90 uint64 + x89, x90 = bits.Add64(x65, x81, uint64(uint1(x88))) + var x91 uint64 + var x92 uint64 + x91, x92 = bits.Add64(((uint64(uint1(x66)) + uint64(uint1(x44))) + (uint64(uint1(x58)) + x46)), (uint64(uint1(x82)) + x70), uint64(uint1(x90))) + var x93 uint64 + var x94 uint64 + x94, x93 = bits.Mul64(x2, 0x9d671cd581c69bc5) + var x95 uint64 + var x96 uint64 + x96, x95 = bits.Mul64(x2, 0xe697f5e45bcd07c6) + var x97 uint64 + var x98 uint64 + x98, x97 = bits.Mul64(x2, 0x741496c20e7cf878) + var x99 uint64 + var x100 uint64 + x100, x99 = bits.Mul64(x2, 0x896cf21467d7d140) + var x101 uint64 + var x102 uint64 + x101, x102 = bits.Add64(x100, x97, uint64(0x0)) + var x103 uint64 + var x104 uint64 + x103, x104 = bits.Add64(x98, x95, uint64(uint1(x102))) + var x105 uint64 + var x106 uint64 + x105, x106 = bits.Add64(x96, x93, uint64(uint1(x104))) + var x107 uint64 + var x108 uint64 + x107, x108 = bits.Add64(x85, x99, uint64(0x0)) + var x109 uint64 + var x110 uint64 + x109, x110 = bits.Add64(x87, x101, uint64(uint1(x108))) + var x111 uint64 + var x112 uint64 + x111, x112 = bits.Add64(x89, x103, uint64(uint1(x110))) + var x113 uint64 + var x114 uint64 + x113, x114 = bits.Add64(x91, x105, uint64(uint1(x112))) + var x115 uint64 + _, x115 = bits.Mul64(x107, 0x4b0dff665588b13f) + var x117 uint64 + var x118 uint64 + x118, x117 = bits.Mul64(x115, 0xffffffffffffffff) + var x119 uint64 + var x120 uint64 + x120, x119 = bits.Mul64(x115, 0xfffffffffffffffe) + var x121 uint64 + var x122 uint64 + x122, x121 = bits.Mul64(x115, 0xbaaedce6af48a03b) + var x123 uint64 + var x124 uint64 + x124, x123 = bits.Mul64(x115, 0xbfd25e8cd0364141) + var x125 uint64 + var x126 uint64 + x125, x126 = bits.Add64(x124, x121, uint64(0x0)) + var x127 uint64 + var x128 uint64 + x127, x128 = bits.Add64(x122, x119, uint64(uint1(x126))) + var x129 uint64 + var x130 uint64 + x129, x130 = bits.Add64(x120, x117, uint64(uint1(x128))) + var x132 uint64 + _, x132 = bits.Add64(x107, x123, uint64(0x0)) + var x133 uint64 + var x134 uint64 + x133, x134 = bits.Add64(x109, x125, uint64(uint1(x132))) + var x135 uint64 + var x136 uint64 + x135, x136 = bits.Add64(x111, x127, uint64(uint1(x134))) + var x137 uint64 + var x138 uint64 + x137, x138 = bits.Add64(x113, x129, uint64(uint1(x136))) + var x139 uint64 + var x140 uint64 + x139, x140 = bits.Add64(((uint64(uint1(x114)) + uint64(uint1(x92))) + (uint64(uint1(x106)) + x94)), (uint64(uint1(x130)) + x118), uint64(uint1(x138))) + var x141 uint64 + var x142 uint64 + x142, x141 = bits.Mul64(x3, 0x9d671cd581c69bc5) + var x143 uint64 + var x144 uint64 + x144, x143 = bits.Mul64(x3, 0xe697f5e45bcd07c6) + var x145 uint64 + var x146 uint64 + x146, x145 = bits.Mul64(x3, 0x741496c20e7cf878) + var x147 uint64 + var x148 uint64 + x148, x147 = bits.Mul64(x3, 0x896cf21467d7d140) + var x149 uint64 + var x150 uint64 + x149, x150 = bits.Add64(x148, x145, uint64(0x0)) + var x151 uint64 + var x152 uint64 + x151, x152 = bits.Add64(x146, x143, uint64(uint1(x150))) + var x153 uint64 + var x154 uint64 + x153, x154 = bits.Add64(x144, x141, uint64(uint1(x152))) + var x155 uint64 + var x156 uint64 + x155, x156 = bits.Add64(x133, x147, uint64(0x0)) + var x157 uint64 + var x158 uint64 + x157, x158 = bits.Add64(x135, x149, uint64(uint1(x156))) + var x159 uint64 + var x160 uint64 + x159, x160 = bits.Add64(x137, x151, uint64(uint1(x158))) + var x161 uint64 + var x162 uint64 + x161, x162 = bits.Add64(x139, x153, uint64(uint1(x160))) + var x163 uint64 + _, x163 = bits.Mul64(x155, 0x4b0dff665588b13f) + var x165 uint64 + var x166 uint64 + x166, x165 = bits.Mul64(x163, 0xffffffffffffffff) + var x167 uint64 + var x168 uint64 + x168, x167 = bits.Mul64(x163, 0xfffffffffffffffe) + var x169 uint64 + var x170 uint64 + x170, x169 = bits.Mul64(x163, 0xbaaedce6af48a03b) + var x171 uint64 + var x172 uint64 + x172, x171 = bits.Mul64(x163, 0xbfd25e8cd0364141) + var x173 uint64 + var x174 uint64 + x173, x174 = bits.Add64(x172, x169, uint64(0x0)) + var x175 uint64 + var x176 uint64 + x175, x176 = bits.Add64(x170, x167, uint64(uint1(x174))) + var x177 uint64 + var x178 uint64 + x177, x178 = bits.Add64(x168, x165, uint64(uint1(x176))) + var x180 uint64 + _, x180 = bits.Add64(x155, x171, uint64(0x0)) + var x181 uint64 + var x182 uint64 + x181, x182 = bits.Add64(x157, x173, uint64(uint1(x180))) + var x183 uint64 + var x184 uint64 + x183, x184 = bits.Add64(x159, x175, uint64(uint1(x182))) + var x185 uint64 + var x186 uint64 + x185, x186 = bits.Add64(x161, x177, uint64(uint1(x184))) + var x187 uint64 + var x188 uint64 + x187, x188 = bits.Add64(((uint64(uint1(x162)) + uint64(uint1(x140))) + (uint64(uint1(x154)) + x142)), (uint64(uint1(x178)) + x166), uint64(uint1(x186))) + var x189 uint64 + var x190 uint64 + x189, x190 = bits.Sub64(x181, 0xbfd25e8cd0364141, uint64(0x0)) + var x191 uint64 + var x192 uint64 + x191, x192 = bits.Sub64(x183, 0xbaaedce6af48a03b, uint64(uint1(x190))) + var x193 uint64 + var x194 uint64 + x193, x194 = bits.Sub64(x185, 0xfffffffffffffffe, uint64(uint1(x192))) + var x195 uint64 + var x196 uint64 + x195, x196 = bits.Sub64(x187, 0xffffffffffffffff, uint64(uint1(x194))) + var x198 uint64 + _, x198 = bits.Sub64(uint64(uint1(x188)), uint64(0x0), uint64(uint1(x196))) + var x199 uint64 + cmovznzU64(&x199, uint1(x198), x189, x181) + var x200 uint64 + cmovznzU64(&x200, uint1(x198), x191, x183) + var x201 uint64 + cmovznzU64(&x201, uint1(x198), x193, x185) + var x202 uint64 + cmovznzU64(&x202, uint1(x198), x195, x187) + out1[0] = x199 + out1[1] = x200 + out1[2] = x201 + out1[3] = x202 +} + +// Nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffffffffffff] +func Nonzero(out1 *uint64, arg1 *[4]uint64) { + x1 := (arg1[0] | (arg1[1] | (arg1[2] | arg1[3]))) + *out1 = x1 +} + +// Selectznz is a multi-limb conditional select. +// +// Postconditions: +// out1 = (if arg1 = 0 then arg2 else arg3) +// +// Input Bounds: +// arg1: [0x0 ~> 0x1] +// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func Selectznz(out1 *[4]uint64, arg1 uint1, arg2 *[4]uint64, arg3 *[4]uint64) { + var x1 uint64 + cmovznzU64(&x1, arg1, arg2[0], arg3[0]) + var x2 uint64 + cmovznzU64(&x2, arg1, arg2[1], arg3[1]) + var x3 uint64 + cmovznzU64(&x3, arg1, arg2[2], arg3[2]) + var x4 uint64 + cmovznzU64(&x4, arg1, arg2[3], arg3[3]) + out1[0] = x1 + out1[1] = x2 + out1[2] = x3 + out1[3] = x4 +} + +// ToBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +// +// Preconditions: +// 0 ≤ eval arg1 < m +// Postconditions: +// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +// +// Input Bounds: +// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +func ToBytes(out1 *[32]uint8, arg1 *[4]uint64) { + x1 := arg1[3] + x2 := arg1[2] + x3 := arg1[1] + x4 := arg1[0] + x5 := (uint8(x4) & 0xff) + x6 := (x4 >> 8) + x7 := (uint8(x6) & 0xff) + x8 := (x6 >> 8) + x9 := (uint8(x8) & 0xff) + x10 := (x8 >> 8) + x11 := (uint8(x10) & 0xff) + x12 := (x10 >> 8) + x13 := (uint8(x12) & 0xff) + x14 := (x12 >> 8) + x15 := (uint8(x14) & 0xff) + x16 := (x14 >> 8) + x17 := (uint8(x16) & 0xff) + x18 := uint8((x16 >> 8)) + x19 := (uint8(x3) & 0xff) + x20 := (x3 >> 8) + x21 := (uint8(x20) & 0xff) + x22 := (x20 >> 8) + x23 := (uint8(x22) & 0xff) + x24 := (x22 >> 8) + x25 := (uint8(x24) & 0xff) + x26 := (x24 >> 8) + x27 := (uint8(x26) & 0xff) + x28 := (x26 >> 8) + x29 := (uint8(x28) & 0xff) + x30 := (x28 >> 8) + x31 := (uint8(x30) & 0xff) + x32 := uint8((x30 >> 8)) + x33 := (uint8(x2) & 0xff) + x34 := (x2 >> 8) + x35 := (uint8(x34) & 0xff) + x36 := (x34 >> 8) + x37 := (uint8(x36) & 0xff) + x38 := (x36 >> 8) + x39 := (uint8(x38) & 0xff) + x40 := (x38 >> 8) + x41 := (uint8(x40) & 0xff) + x42 := (x40 >> 8) + x43 := (uint8(x42) & 0xff) + x44 := (x42 >> 8) + x45 := (uint8(x44) & 0xff) + x46 := uint8((x44 >> 8)) + x47 := (uint8(x1) & 0xff) + x48 := (x1 >> 8) + x49 := (uint8(x48) & 0xff) + x50 := (x48 >> 8) + x51 := (uint8(x50) & 0xff) + x52 := (x50 >> 8) + x53 := (uint8(x52) & 0xff) + x54 := (x52 >> 8) + x55 := (uint8(x54) & 0xff) + x56 := (x54 >> 8) + x57 := (uint8(x56) & 0xff) + x58 := (x56 >> 8) + x59 := (uint8(x58) & 0xff) + x60 := uint8((x58 >> 8)) + out1[0] = x5 + out1[1] = x7 + out1[2] = x9 + out1[3] = x11 + out1[4] = x13 + out1[5] = x15 + out1[6] = x17 + out1[7] = x18 + out1[8] = x19 + out1[9] = x21 + out1[10] = x23 + out1[11] = x25 + out1[12] = x27 + out1[13] = x29 + out1[14] = x31 + out1[15] = x32 + out1[16] = x33 + out1[17] = x35 + out1[18] = x37 + out1[19] = x39 + out1[20] = x41 + out1[21] = x43 + out1[22] = x45 + out1[23] = x46 + out1[24] = x47 + out1[25] = x49 + out1[26] = x51 + out1[27] = x53 + out1[28] = x55 + out1[29] = x57 + out1[30] = x59 + out1[31] = x60 +} + +// FromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +// +// Preconditions: +// 0 ≤ bytes_eval arg1 < m +// Postconditions: +// eval out1 mod m = bytes_eval arg1 mod m +// 0 ≤ eval out1 < m +// +// Input Bounds: +// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func FromBytes(out1 *[4]uint64, arg1 *[32]uint8) { + x1 := (uint64(arg1[31]) << 56) + x2 := (uint64(arg1[30]) << 48) + x3 := (uint64(arg1[29]) << 40) + x4 := (uint64(arg1[28]) << 32) + x5 := (uint64(arg1[27]) << 24) + x6 := (uint64(arg1[26]) << 16) + x7 := (uint64(arg1[25]) << 8) + x8 := arg1[24] + x9 := (uint64(arg1[23]) << 56) + x10 := (uint64(arg1[22]) << 48) + x11 := (uint64(arg1[21]) << 40) + x12 := (uint64(arg1[20]) << 32) + x13 := (uint64(arg1[19]) << 24) + x14 := (uint64(arg1[18]) << 16) + x15 := (uint64(arg1[17]) << 8) + x16 := arg1[16] + x17 := (uint64(arg1[15]) << 56) + x18 := (uint64(arg1[14]) << 48) + x19 := (uint64(arg1[13]) << 40) + x20 := (uint64(arg1[12]) << 32) + x21 := (uint64(arg1[11]) << 24) + x22 := (uint64(arg1[10]) << 16) + x23 := (uint64(arg1[9]) << 8) + x24 := arg1[8] + x25 := (uint64(arg1[7]) << 56) + x26 := (uint64(arg1[6]) << 48) + x27 := (uint64(arg1[5]) << 40) + x28 := (uint64(arg1[4]) << 32) + x29 := (uint64(arg1[3]) << 24) + x30 := (uint64(arg1[2]) << 16) + x31 := (uint64(arg1[1]) << 8) + x32 := arg1[0] + x33 := (x31 + uint64(x32)) + x34 := (x30 + x33) + x35 := (x29 + x34) + x36 := (x28 + x35) + x37 := (x27 + x36) + x38 := (x26 + x37) + x39 := (x25 + x38) + x40 := (x23 + uint64(x24)) + x41 := (x22 + x40) + x42 := (x21 + x41) + x43 := (x20 + x42) + x44 := (x19 + x43) + x45 := (x18 + x44) + x46 := (x17 + x45) + x47 := (x15 + uint64(x16)) + x48 := (x14 + x47) + x49 := (x13 + x48) + x50 := (x12 + x49) + x51 := (x11 + x50) + x52 := (x10 + x51) + x53 := (x9 + x52) + x54 := (x7 + uint64(x8)) + x55 := (x6 + x54) + x56 := (x5 + x55) + x57 := (x4 + x56) + x58 := (x3 + x57) + x59 := (x2 + x58) + x60 := (x1 + x59) + out1[0] = x39 + out1[1] = x46 + out1[2] = x53 + out1[3] = x60 +} + +// SetOne returns the field element one in the Montgomery domain. +// +// Postconditions: +// eval (from_montgomery out1) mod m = 1 mod m +// 0 ≤ eval out1 < m +// +func SetOne(out1 *MontgomeryDomainFieldElement) { + out1[0] = 0x402da1732fc9bebf + out1[1] = 0x4551231950b75fc4 + out1[2] = uint64(0x1) + out1[3] = uint64(0x0) +} + +// Msat returns the saturated representation of the prime modulus. +// +// Postconditions: +// twos_complement_eval out1 = m +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func Msat(out1 *[5]uint64) { + out1[0] = 0xbfd25e8cd0364141 + out1[1] = 0xbaaedce6af48a03b + out1[2] = 0xfffffffffffffffe + out1[3] = 0xffffffffffffffff + out1[4] = uint64(0x0) +} + +// Divstep computes a divstep. +// +// Preconditions: +// 0 ≤ eval arg4 < m +// 0 ≤ eval arg5 < m +// Postconditions: +// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +// 0 ≤ eval out5 < m +// 0 ≤ eval out5 < m +// 0 ≤ eval out2 < m +// 0 ≤ eval out3 < m +// +// Input Bounds: +// arg1: [0x0 ~> 0xffffffffffffffff] +// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// Output Bounds: +// out1: [0x0 ~> 0xffffffffffffffff] +// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func Divstep(out1 *uint64, out2 *[5]uint64, out3 *[5]uint64, out4 *[4]uint64, out5 *[4]uint64, arg1 uint64, arg2 *[5]uint64, arg3 *[5]uint64, arg4 *[4]uint64, arg5 *[4]uint64) { + var x1 uint64 + x1, _ = bits.Add64((^arg1), uint64(0x1), uint64(0x0)) + x3 := (uint1((x1 >> 63)) & (uint1(arg3[0]) & 0x1)) + var x4 uint64 + x4, _ = bits.Add64((^arg1), uint64(0x1), uint64(0x0)) + var x6 uint64 + cmovznzU64(&x6, x3, arg1, x4) + var x7 uint64 + cmovznzU64(&x7, x3, arg2[0], arg3[0]) + var x8 uint64 + cmovznzU64(&x8, x3, arg2[1], arg3[1]) + var x9 uint64 + cmovznzU64(&x9, x3, arg2[2], arg3[2]) + var x10 uint64 + cmovznzU64(&x10, x3, arg2[3], arg3[3]) + var x11 uint64 + cmovznzU64(&x11, x3, arg2[4], arg3[4]) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(uint64(0x1), (^arg2[0]), uint64(0x0)) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(uint64(0x0), (^arg2[1]), uint64(uint1(x13))) + var x16 uint64 + var x17 uint64 + x16, x17 = bits.Add64(uint64(0x0), (^arg2[2]), uint64(uint1(x15))) + var x18 uint64 + var x19 uint64 + x18, x19 = bits.Add64(uint64(0x0), (^arg2[3]), uint64(uint1(x17))) + var x20 uint64 + x20, _ = bits.Add64(uint64(0x0), (^arg2[4]), uint64(uint1(x19))) + var x22 uint64 + cmovznzU64(&x22, x3, arg3[0], x12) + var x23 uint64 + cmovznzU64(&x23, x3, arg3[1], x14) + var x24 uint64 + cmovznzU64(&x24, x3, arg3[2], x16) + var x25 uint64 + cmovznzU64(&x25, x3, arg3[3], x18) + var x26 uint64 + cmovznzU64(&x26, x3, arg3[4], x20) + var x27 uint64 + cmovznzU64(&x27, x3, arg4[0], arg5[0]) + var x28 uint64 + cmovznzU64(&x28, x3, arg4[1], arg5[1]) + var x29 uint64 + cmovznzU64(&x29, x3, arg4[2], arg5[2]) + var x30 uint64 + cmovznzU64(&x30, x3, arg4[3], arg5[3]) + var x31 uint64 + var x32 uint64 + x31, x32 = bits.Add64(x27, x27, uint64(0x0)) + var x33 uint64 + var x34 uint64 + x33, x34 = bits.Add64(x28, x28, uint64(uint1(x32))) + var x35 uint64 + var x36 uint64 + x35, x36 = bits.Add64(x29, x29, uint64(uint1(x34))) + var x37 uint64 + var x38 uint64 + x37, x38 = bits.Add64(x30, x30, uint64(uint1(x36))) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Sub64(x31, 0xbfd25e8cd0364141, uint64(0x0)) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Sub64(x33, 0xbaaedce6af48a03b, uint64(uint1(x40))) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Sub64(x35, 0xfffffffffffffffe, uint64(uint1(x42))) + var x45 uint64 + var x46 uint64 + x45, x46 = bits.Sub64(x37, 0xffffffffffffffff, uint64(uint1(x44))) + var x48 uint64 + _, x48 = bits.Sub64(uint64(uint1(x38)), uint64(0x0), uint64(uint1(x46))) + x49 := arg4[3] + x50 := arg4[2] + x51 := arg4[1] + x52 := arg4[0] + var x53 uint64 + var x54 uint64 + x53, x54 = bits.Sub64(uint64(0x0), x52, uint64(0x0)) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Sub64(uint64(0x0), x51, uint64(uint1(x54))) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Sub64(uint64(0x0), x50, uint64(uint1(x56))) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Sub64(uint64(0x0), x49, uint64(uint1(x58))) + var x61 uint64 + cmovznzU64(&x61, uint1(x60), uint64(0x0), 0xffffffffffffffff) + var x62 uint64 + var x63 uint64 + x62, x63 = bits.Add64(x53, (x61 & 0xbfd25e8cd0364141), uint64(0x0)) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(x55, (x61 & 0xbaaedce6af48a03b), uint64(uint1(x63))) + var x66 uint64 + var x67 uint64 + x66, x67 = bits.Add64(x57, (x61 & 0xfffffffffffffffe), uint64(uint1(x65))) + var x68 uint64 + x68, _ = bits.Add64(x59, x61, uint64(uint1(x67))) + var x70 uint64 + cmovznzU64(&x70, x3, arg5[0], x62) + var x71 uint64 + cmovznzU64(&x71, x3, arg5[1], x64) + var x72 uint64 + cmovznzU64(&x72, x3, arg5[2], x66) + var x73 uint64 + cmovznzU64(&x73, x3, arg5[3], x68) + x74 := (uint1(x22) & 0x1) + var x75 uint64 + cmovznzU64(&x75, x74, uint64(0x0), x7) + var x76 uint64 + cmovznzU64(&x76, x74, uint64(0x0), x8) + var x77 uint64 + cmovznzU64(&x77, x74, uint64(0x0), x9) + var x78 uint64 + cmovznzU64(&x78, x74, uint64(0x0), x10) + var x79 uint64 + cmovznzU64(&x79, x74, uint64(0x0), x11) + var x80 uint64 + var x81 uint64 + x80, x81 = bits.Add64(x22, x75, uint64(0x0)) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x23, x76, uint64(uint1(x81))) + var x84 uint64 + var x85 uint64 + x84, x85 = bits.Add64(x24, x77, uint64(uint1(x83))) + var x86 uint64 + var x87 uint64 + x86, x87 = bits.Add64(x25, x78, uint64(uint1(x85))) + var x88 uint64 + x88, _ = bits.Add64(x26, x79, uint64(uint1(x87))) + var x90 uint64 + cmovznzU64(&x90, x74, uint64(0x0), x27) + var x91 uint64 + cmovznzU64(&x91, x74, uint64(0x0), x28) + var x92 uint64 + cmovznzU64(&x92, x74, uint64(0x0), x29) + var x93 uint64 + cmovznzU64(&x93, x74, uint64(0x0), x30) + var x94 uint64 + var x95 uint64 + x94, x95 = bits.Add64(x70, x90, uint64(0x0)) + var x96 uint64 + var x97 uint64 + x96, x97 = bits.Add64(x71, x91, uint64(uint1(x95))) + var x98 uint64 + var x99 uint64 + x98, x99 = bits.Add64(x72, x92, uint64(uint1(x97))) + var x100 uint64 + var x101 uint64 + x100, x101 = bits.Add64(x73, x93, uint64(uint1(x99))) + var x102 uint64 + var x103 uint64 + x102, x103 = bits.Sub64(x94, 0xbfd25e8cd0364141, uint64(0x0)) + var x104 uint64 + var x105 uint64 + x104, x105 = bits.Sub64(x96, 0xbaaedce6af48a03b, uint64(uint1(x103))) + var x106 uint64 + var x107 uint64 + x106, x107 = bits.Sub64(x98, 0xfffffffffffffffe, uint64(uint1(x105))) + var x108 uint64 + var x109 uint64 + x108, x109 = bits.Sub64(x100, 0xffffffffffffffff, uint64(uint1(x107))) + var x111 uint64 + _, x111 = bits.Sub64(uint64(uint1(x101)), uint64(0x0), uint64(uint1(x109))) + var x112 uint64 + x112, _ = bits.Add64(x6, uint64(0x1), uint64(0x0)) + x114 := ((x80 >> 1) | ((x82 << 63) & 0xffffffffffffffff)) + x115 := ((x82 >> 1) | ((x84 << 63) & 0xffffffffffffffff)) + x116 := ((x84 >> 1) | ((x86 << 63) & 0xffffffffffffffff)) + x117 := ((x86 >> 1) | ((x88 << 63) & 0xffffffffffffffff)) + x118 := ((x88 & 0x8000000000000000) | (x88 >> 1)) + var x119 uint64 + cmovznzU64(&x119, uint1(x48), x39, x31) + var x120 uint64 + cmovznzU64(&x120, uint1(x48), x41, x33) + var x121 uint64 + cmovznzU64(&x121, uint1(x48), x43, x35) + var x122 uint64 + cmovznzU64(&x122, uint1(x48), x45, x37) + var x123 uint64 + cmovznzU64(&x123, uint1(x111), x102, x94) + var x124 uint64 + cmovznzU64(&x124, uint1(x111), x104, x96) + var x125 uint64 + cmovznzU64(&x125, uint1(x111), x106, x98) + var x126 uint64 + cmovznzU64(&x126, uint1(x111), x108, x100) + *out1 = x112 + out2[0] = x7 + out2[1] = x8 + out2[2] = x9 + out2[3] = x10 + out2[4] = x11 + out3[0] = x114 + out3[1] = x115 + out3[2] = x116 + out3[3] = x117 + out3[4] = x118 + out4[0] = x119 + out4[1] = x120 + out4[2] = x121 + out4[3] = x122 + out5[0] = x123 + out5[1] = x124 + out5[2] = x125 + out5[3] = x126 +} + +// DivstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +// +// Postconditions: +// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +// 0 ≤ eval out1 < m +// +// Output Bounds: +// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +func DivstepPrecomp(out1 *[4]uint64) { + out1[0] = 0xd7431a4d2b9cb4e9 + out1[1] = 0xab67d35a32d9c503 + out1[2] = 0xadf6c7e5859ce35f + out1[3] = 0x615441451df6c379 +} diff --git a/fiat-java/src/FiatCurve25519Scalar.java b/fiat-java/src/FiatCurve25519Scalar.java new file mode 100644 index 0000000000..cce1812b31 --- /dev/null +++ b/fiat-java/src/FiatCurve25519Scalar.java @@ -0,0 +1,4845 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Java --cmovznz-by-mul --widen-carry --widen-bytes --internal-static --package-name fiat_crypto --class-case UpperCamelCase --no-field-element-typedefs Curve25519Scalar 32 '2^252 + 27742317777372353535851937790883648493' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: Curve25519Scalar */ +/* machine_wordsize = 32 (from "32") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed (from "2^252 + 27742317777372353535851937790883648493") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +package fiat_crypto; + +public final class FiatCurve25519Scalar { + +static class Box { + private T value; + public Box(T value) { this.value = value; } + public void set(T value) { this.value = value; } + public T get() { return this.value; } +} + + + +/** + * The function fiat_Curve25519Scalar_addcarryx_u32 is an addition with carry.

+ *

+ * Postconditions:

+ * out1 = (arg1 + arg2 + arg3) mod 2^32

+ * out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [0x0 ~> 0xffffffff]

+ * arg3: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [0x0 ~> 0x1]

+ */ +static void fiat_Curve25519Scalar_addcarryx_u32(Box out1, Box out2, int arg1, int arg2, int arg3) { + long x1 = (((long) Integer.toUnsignedLong(((Number) (arg1)).intValue()) + (long) Integer.toUnsignedLong(((Number) (arg2)).intValue())) + (long) Integer.toUnsignedLong(((Number) (arg3)).intValue())); + int x2 = ((int) Integer.toUnsignedLong(((Number) (x1)).intValue()) & 0xffffffff); + int x3 = (int) Integer.toUnsignedLong(((Number) ((x1 >>> 32))).intValue()); + out1.set(x2); + out2.set(x3); +} + +/** + * The function fiat_Curve25519Scalar_subborrowx_u32 is a subtraction with borrow.

+ *

+ * Postconditions:

+ * out1 = (-arg1 + arg2 + -arg3) mod 2^32

+ * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [0x0 ~> 0xffffffff]

+ * arg3: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [0x0 ~> 0x1]

+ */ +static void fiat_Curve25519Scalar_subborrowx_u32(Box out1, Box out2, int arg1, int arg2, int arg3) { + long x1 = (((long) Integer.toUnsignedLong(((Number) (arg2)).intValue()) - (long) Integer.toUnsignedLong(((Number) (arg1)).intValue())) - (long) Integer.toUnsignedLong(((Number) (arg3)).intValue())); + int x2 = (int) Integer.toUnsignedLong(((Number) ((x1 >>> 32))).intValue()); + int x3 = ((int) Integer.toUnsignedLong(((Number) (x1)).intValue()) & 0xffffffff); + out1.set(x3); + out2.set(((int) Integer.toUnsignedLong(((Number) (0x0)).intValue()) - (int) Integer.toUnsignedLong(((Number) (x2)).intValue()))); +} + +/** + * The function fiat_Curve25519Scalar_mulx_u32 is a multiplication, returning the full double-width result.

+ *

+ * Postconditions:

+ * out1 = (arg1 * arg2) mod 2^32

+ * out2 = ⌊arg1 * arg2 / 2^32⌋

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0xffffffff]

+ * arg2: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [0x0 ~> 0xffffffff]

+ */ +static void fiat_Curve25519Scalar_mulx_u32(Box out1, Box out2, int arg1, int arg2) { + long x1 = ((long) Integer.toUnsignedLong(((Number) (arg1)).intValue()) * (long) Integer.toUnsignedLong(((Number) (arg2)).intValue())); + int x2 = ((int) Integer.toUnsignedLong(((Number) (x1)).intValue()) & 0xffffffff); + int x3 = (int) Integer.toUnsignedLong(((Number) ((x1 >>> 32))).intValue()); + out1.set(x2); + out2.set(x3); +} + +/** + * The function fiat_Curve25519Scalar_cmovznz_u32 is a single-word conditional move.

+ *

+ * Postconditions:

+ * out1 = (if arg1 = 0 then arg2 else arg3)

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [0x0 ~> 0xffffffff]

+ * arg3: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ */ +static void fiat_Curve25519Scalar_cmovznz_u32(Box out1, int arg1, int arg2, int arg3) { + int x1 = (arg1 * 0xffffffff); + int x2 = ((x1 & arg3) | ((~x1) & arg2)); + out1.set(x2); +} + +/** + * The function fiat_Curve25519Scalar_mul multiplies two field elements in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * 0 ≤ eval arg2 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Curve25519Scalar_mul(int[] out1, final int[] arg1, final int[] arg2) { + int x1 = (arg1[1]); + int x2 = (arg1[2]); + int x3 = (arg1[3]); + int x4 = (arg1[4]); + int x5 = (arg1[5]); + int x6 = (arg1[6]); + int x7 = (arg1[7]); + int x8 = (arg1[0]); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x9, x10, x8, (arg2[7])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x11, x12, x8, (arg2[6])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x13, x14, x8, (arg2[5])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x15, x16, x8, (arg2[4])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x17, x18, x8, (arg2[3])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x19, x20, x8, (arg2[2])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x21, x22, x8, (arg2[1])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x23, x24, x8, (arg2[0])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x37, x38, (x36).get(), (x12).get(), (x9).get()); + int x39 = ((x38).get() + (x10).get()); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x40, x41, (x23).get(), 0x12547e1b); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x42, x43, (x40).get(), 0x10000000); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x44, x45, (x40).get(), 0x14def9de); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x46, x47, (x40).get(), 0xa2f79cd6); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x48, x49, (x40).get(), 0x5812631a); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x50, x51, (x40).get(), 0x5cf5d3ed); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x52, x53, 0x0, (x51).get(), (x48).get()); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x54, x55, (x53).get(), (x49).get(), (x46).get()); + Box x56 = new Box((int)0); + Box x57 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x56, x57, (x55).get(), (x47).get(), (x44).get()); + int x58 = ((x57).get() + (x45).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x59, x60, 0x0, (x23).get(), (x50).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x61, x62, (x60).get(), (x25).get(), (x52).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x63, x64, (x62).get(), (x27).get(), (x54).get()); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x65, x66, (x64).get(), (x29).get(), (x56).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x67, x68, (x66).get(), (x31).get(), x58); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x69, x70, (x68).get(), (x33).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x71, x72, (x70).get(), (x35).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x73, x74, (x72).get(), (x37).get(), (x42).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x75, x76, (x74).get(), x39, (x43).get()); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x77, x78, x1, (arg2[7])); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x79, x80, x1, (arg2[6])); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x81, x82, x1, (arg2[5])); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x83, x84, x1, (arg2[4])); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x85, x86, x1, (arg2[3])); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x87, x88, x1, (arg2[2])); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x89, x90, x1, (arg2[1])); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x91, x92, x1, (arg2[0])); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x93, x94, 0x0, (x92).get(), (x89).get()); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x95, x96, (x94).get(), (x90).get(), (x87).get()); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x97, x98, (x96).get(), (x88).get(), (x85).get()); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x99, x100, (x98).get(), (x86).get(), (x83).get()); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x101, x102, (x100).get(), (x84).get(), (x81).get()); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x103, x104, (x102).get(), (x82).get(), (x79).get()); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x105, x106, (x104).get(), (x80).get(), (x77).get()); + int x107 = ((x106).get() + (x78).get()); + Box x108 = new Box((int)0); + Box x109 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x108, x109, 0x0, (x61).get(), (x91).get()); + Box x110 = new Box((int)0); + Box x111 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x110, x111, (x109).get(), (x63).get(), (x93).get()); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x112, x113, (x111).get(), (x65).get(), (x95).get()); + Box x114 = new Box((int)0); + Box x115 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x114, x115, (x113).get(), (x67).get(), (x97).get()); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x116, x117, (x115).get(), (x69).get(), (x99).get()); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x118, x119, (x117).get(), (x71).get(), (x101).get()); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x120, x121, (x119).get(), (x73).get(), (x103).get()); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x122, x123, (x121).get(), (x75).get(), (x105).get()); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x124, x125, (x123).get(), (x76).get(), x107); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x126, x127, (x108).get(), 0x12547e1b); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x128, x129, (x126).get(), 0x10000000); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x130, x131, (x126).get(), 0x14def9de); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x132, x133, (x126).get(), 0xa2f79cd6); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x134, x135, (x126).get(), 0x5812631a); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x136, x137, (x126).get(), 0x5cf5d3ed); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x138, x139, 0x0, (x137).get(), (x134).get()); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x140, x141, (x139).get(), (x135).get(), (x132).get()); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x142, x143, (x141).get(), (x133).get(), (x130).get()); + int x144 = ((x143).get() + (x131).get()); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x145, x146, 0x0, (x108).get(), (x136).get()); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x147, x148, (x146).get(), (x110).get(), (x138).get()); + Box x149 = new Box((int)0); + Box x150 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x149, x150, (x148).get(), (x112).get(), (x140).get()); + Box x151 = new Box((int)0); + Box x152 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x151, x152, (x150).get(), (x114).get(), (x142).get()); + Box x153 = new Box((int)0); + Box x154 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x153, x154, (x152).get(), (x116).get(), x144); + Box x155 = new Box((int)0); + Box x156 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x155, x156, (x154).get(), (x118).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x157 = new Box((int)0); + Box x158 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x157, x158, (x156).get(), (x120).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x159 = new Box((int)0); + Box x160 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x159, x160, (x158).get(), (x122).get(), (x128).get()); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x161, x162, (x160).get(), (x124).get(), (x129).get()); + int x163 = ((x162).get() + (x125).get()); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x164, x165, x2, (arg2[7])); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x166, x167, x2, (arg2[6])); + Box x168 = new Box((int)0); + Box x169 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x168, x169, x2, (arg2[5])); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x170, x171, x2, (arg2[4])); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x172, x173, x2, (arg2[3])); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x174, x175, x2, (arg2[2])); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x176, x177, x2, (arg2[1])); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x178, x179, x2, (arg2[0])); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x180, x181, 0x0, (x179).get(), (x176).get()); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x182, x183, (x181).get(), (x177).get(), (x174).get()); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x184, x185, (x183).get(), (x175).get(), (x172).get()); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x186, x187, (x185).get(), (x173).get(), (x170).get()); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x188, x189, (x187).get(), (x171).get(), (x168).get()); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x190, x191, (x189).get(), (x169).get(), (x166).get()); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x192, x193, (x191).get(), (x167).get(), (x164).get()); + int x194 = ((x193).get() + (x165).get()); + Box x195 = new Box((int)0); + Box x196 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x195, x196, 0x0, (x147).get(), (x178).get()); + Box x197 = new Box((int)0); + Box x198 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x197, x198, (x196).get(), (x149).get(), (x180).get()); + Box x199 = new Box((int)0); + Box x200 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x199, x200, (x198).get(), (x151).get(), (x182).get()); + Box x201 = new Box((int)0); + Box x202 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x201, x202, (x200).get(), (x153).get(), (x184).get()); + Box x203 = new Box((int)0); + Box x204 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x203, x204, (x202).get(), (x155).get(), (x186).get()); + Box x205 = new Box((int)0); + Box x206 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x205, x206, (x204).get(), (x157).get(), (x188).get()); + Box x207 = new Box((int)0); + Box x208 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x207, x208, (x206).get(), (x159).get(), (x190).get()); + Box x209 = new Box((int)0); + Box x210 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x209, x210, (x208).get(), (x161).get(), (x192).get()); + Box x211 = new Box((int)0); + Box x212 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x211, x212, (x210).get(), x163, x194); + Box x213 = new Box((int)0); + Box x214 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x213, x214, (x195).get(), 0x12547e1b); + Box x215 = new Box((int)0); + Box x216 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x215, x216, (x213).get(), 0x10000000); + Box x217 = new Box((int)0); + Box x218 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x217, x218, (x213).get(), 0x14def9de); + Box x219 = new Box((int)0); + Box x220 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x219, x220, (x213).get(), 0xa2f79cd6); + Box x221 = new Box((int)0); + Box x222 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x221, x222, (x213).get(), 0x5812631a); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x223, x224, (x213).get(), 0x5cf5d3ed); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x225, x226, 0x0, (x224).get(), (x221).get()); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x227, x228, (x226).get(), (x222).get(), (x219).get()); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x229, x230, (x228).get(), (x220).get(), (x217).get()); + int x231 = ((x230).get() + (x218).get()); + Box x232 = new Box((int)0); + Box x233 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x232, x233, 0x0, (x195).get(), (x223).get()); + Box x234 = new Box((int)0); + Box x235 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x234, x235, (x233).get(), (x197).get(), (x225).get()); + Box x236 = new Box((int)0); + Box x237 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x236, x237, (x235).get(), (x199).get(), (x227).get()); + Box x238 = new Box((int)0); + Box x239 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x238, x239, (x237).get(), (x201).get(), (x229).get()); + Box x240 = new Box((int)0); + Box x241 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x240, x241, (x239).get(), (x203).get(), x231); + Box x242 = new Box((int)0); + Box x243 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x242, x243, (x241).get(), (x205).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x244 = new Box((int)0); + Box x245 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x244, x245, (x243).get(), (x207).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x246, x247, (x245).get(), (x209).get(), (x215).get()); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x248, x249, (x247).get(), (x211).get(), (x216).get()); + int x250 = ((x249).get() + (x212).get()); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x251, x252, x3, (arg2[7])); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x253, x254, x3, (arg2[6])); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x255, x256, x3, (arg2[5])); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x257, x258, x3, (arg2[4])); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x259, x260, x3, (arg2[3])); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x261, x262, x3, (arg2[2])); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x263, x264, x3, (arg2[1])); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x265, x266, x3, (arg2[0])); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x267, x268, 0x0, (x266).get(), (x263).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x269, x270, (x268).get(), (x264).get(), (x261).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x271, x272, (x270).get(), (x262).get(), (x259).get()); + Box x273 = new Box((int)0); + Box x274 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x273, x274, (x272).get(), (x260).get(), (x257).get()); + Box x275 = new Box((int)0); + Box x276 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x275, x276, (x274).get(), (x258).get(), (x255).get()); + Box x277 = new Box((int)0); + Box x278 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x277, x278, (x276).get(), (x256).get(), (x253).get()); + Box x279 = new Box((int)0); + Box x280 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x279, x280, (x278).get(), (x254).get(), (x251).get()); + int x281 = ((x280).get() + (x252).get()); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x282, x283, 0x0, (x234).get(), (x265).get()); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x284, x285, (x283).get(), (x236).get(), (x267).get()); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x286, x287, (x285).get(), (x238).get(), (x269).get()); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x288, x289, (x287).get(), (x240).get(), (x271).get()); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x290, x291, (x289).get(), (x242).get(), (x273).get()); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x292, x293, (x291).get(), (x244).get(), (x275).get()); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x294, x295, (x293).get(), (x246).get(), (x277).get()); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x296, x297, (x295).get(), (x248).get(), (x279).get()); + Box x298 = new Box((int)0); + Box x299 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x298, x299, (x297).get(), x250, x281); + Box x300 = new Box((int)0); + Box x301 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x300, x301, (x282).get(), 0x12547e1b); + Box x302 = new Box((int)0); + Box x303 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x302, x303, (x300).get(), 0x10000000); + Box x304 = new Box((int)0); + Box x305 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x304, x305, (x300).get(), 0x14def9de); + Box x306 = new Box((int)0); + Box x307 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x306, x307, (x300).get(), 0xa2f79cd6); + Box x308 = new Box((int)0); + Box x309 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x308, x309, (x300).get(), 0x5812631a); + Box x310 = new Box((int)0); + Box x311 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x310, x311, (x300).get(), 0x5cf5d3ed); + Box x312 = new Box((int)0); + Box x313 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x312, x313, 0x0, (x311).get(), (x308).get()); + Box x314 = new Box((int)0); + Box x315 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x314, x315, (x313).get(), (x309).get(), (x306).get()); + Box x316 = new Box((int)0); + Box x317 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x316, x317, (x315).get(), (x307).get(), (x304).get()); + int x318 = ((x317).get() + (x305).get()); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x319, x320, 0x0, (x282).get(), (x310).get()); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x321, x322, (x320).get(), (x284).get(), (x312).get()); + Box x323 = new Box((int)0); + Box x324 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x323, x324, (x322).get(), (x286).get(), (x314).get()); + Box x325 = new Box((int)0); + Box x326 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x325, x326, (x324).get(), (x288).get(), (x316).get()); + Box x327 = new Box((int)0); + Box x328 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x327, x328, (x326).get(), (x290).get(), x318); + Box x329 = new Box((int)0); + Box x330 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x329, x330, (x328).get(), (x292).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x331, x332, (x330).get(), (x294).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x333, x334, (x332).get(), (x296).get(), (x302).get()); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x335, x336, (x334).get(), (x298).get(), (x303).get()); + int x337 = ((x336).get() + (x299).get()); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x338, x339, x4, (arg2[7])); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x340, x341, x4, (arg2[6])); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x342, x343, x4, (arg2[5])); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x344, x345, x4, (arg2[4])); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x346, x347, x4, (arg2[3])); + Box x348 = new Box((int)0); + Box x349 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x348, x349, x4, (arg2[2])); + Box x350 = new Box((int)0); + Box x351 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x350, x351, x4, (arg2[1])); + Box x352 = new Box((int)0); + Box x353 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x352, x353, x4, (arg2[0])); + Box x354 = new Box((int)0); + Box x355 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x354, x355, 0x0, (x353).get(), (x350).get()); + Box x356 = new Box((int)0); + Box x357 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x356, x357, (x355).get(), (x351).get(), (x348).get()); + Box x358 = new Box((int)0); + Box x359 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x358, x359, (x357).get(), (x349).get(), (x346).get()); + Box x360 = new Box((int)0); + Box x361 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x360, x361, (x359).get(), (x347).get(), (x344).get()); + Box x362 = new Box((int)0); + Box x363 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x362, x363, (x361).get(), (x345).get(), (x342).get()); + Box x364 = new Box((int)0); + Box x365 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x364, x365, (x363).get(), (x343).get(), (x340).get()); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x366, x367, (x365).get(), (x341).get(), (x338).get()); + int x368 = ((x367).get() + (x339).get()); + Box x369 = new Box((int)0); + Box x370 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x369, x370, 0x0, (x321).get(), (x352).get()); + Box x371 = new Box((int)0); + Box x372 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x371, x372, (x370).get(), (x323).get(), (x354).get()); + Box x373 = new Box((int)0); + Box x374 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x373, x374, (x372).get(), (x325).get(), (x356).get()); + Box x375 = new Box((int)0); + Box x376 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x375, x376, (x374).get(), (x327).get(), (x358).get()); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x377, x378, (x376).get(), (x329).get(), (x360).get()); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x379, x380, (x378).get(), (x331).get(), (x362).get()); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x381, x382, (x380).get(), (x333).get(), (x364).get()); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x383, x384, (x382).get(), (x335).get(), (x366).get()); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x385, x386, (x384).get(), x337, x368); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x387, x388, (x369).get(), 0x12547e1b); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x389, x390, (x387).get(), 0x10000000); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x391, x392, (x387).get(), 0x14def9de); + Box x393 = new Box((int)0); + Box x394 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x393, x394, (x387).get(), 0xa2f79cd6); + Box x395 = new Box((int)0); + Box x396 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x395, x396, (x387).get(), 0x5812631a); + Box x397 = new Box((int)0); + Box x398 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x397, x398, (x387).get(), 0x5cf5d3ed); + Box x399 = new Box((int)0); + Box x400 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x399, x400, 0x0, (x398).get(), (x395).get()); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x401, x402, (x400).get(), (x396).get(), (x393).get()); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x403, x404, (x402).get(), (x394).get(), (x391).get()); + int x405 = ((x404).get() + (x392).get()); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x406, x407, 0x0, (x369).get(), (x397).get()); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x408, x409, (x407).get(), (x371).get(), (x399).get()); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x410, x411, (x409).get(), (x373).get(), (x401).get()); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x412, x413, (x411).get(), (x375).get(), (x403).get()); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x414, x415, (x413).get(), (x377).get(), x405); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x416, x417, (x415).get(), (x379).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x418, x419, (x417).get(), (x381).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x420, x421, (x419).get(), (x383).get(), (x389).get()); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x422, x423, (x421).get(), (x385).get(), (x390).get()); + int x424 = ((x423).get() + (x386).get()); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x425, x426, x5, (arg2[7])); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x427, x428, x5, (arg2[6])); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x429, x430, x5, (arg2[5])); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x431, x432, x5, (arg2[4])); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x433, x434, x5, (arg2[3])); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x435, x436, x5, (arg2[2])); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x437, x438, x5, (arg2[1])); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x439, x440, x5, (arg2[0])); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x441, x442, 0x0, (x440).get(), (x437).get()); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x443, x444, (x442).get(), (x438).get(), (x435).get()); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x445, x446, (x444).get(), (x436).get(), (x433).get()); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x447, x448, (x446).get(), (x434).get(), (x431).get()); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x449, x450, (x448).get(), (x432).get(), (x429).get()); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x451, x452, (x450).get(), (x430).get(), (x427).get()); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x453, x454, (x452).get(), (x428).get(), (x425).get()); + int x455 = ((x454).get() + (x426).get()); + Box x456 = new Box((int)0); + Box x457 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x456, x457, 0x0, (x408).get(), (x439).get()); + Box x458 = new Box((int)0); + Box x459 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x458, x459, (x457).get(), (x410).get(), (x441).get()); + Box x460 = new Box((int)0); + Box x461 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x460, x461, (x459).get(), (x412).get(), (x443).get()); + Box x462 = new Box((int)0); + Box x463 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x462, x463, (x461).get(), (x414).get(), (x445).get()); + Box x464 = new Box((int)0); + Box x465 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x464, x465, (x463).get(), (x416).get(), (x447).get()); + Box x466 = new Box((int)0); + Box x467 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x466, x467, (x465).get(), (x418).get(), (x449).get()); + Box x468 = new Box((int)0); + Box x469 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x468, x469, (x467).get(), (x420).get(), (x451).get()); + Box x470 = new Box((int)0); + Box x471 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x470, x471, (x469).get(), (x422).get(), (x453).get()); + Box x472 = new Box((int)0); + Box x473 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x472, x473, (x471).get(), x424, x455); + Box x474 = new Box((int)0); + Box x475 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x474, x475, (x456).get(), 0x12547e1b); + Box x476 = new Box((int)0); + Box x477 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x476, x477, (x474).get(), 0x10000000); + Box x478 = new Box((int)0); + Box x479 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x478, x479, (x474).get(), 0x14def9de); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x480, x481, (x474).get(), 0xa2f79cd6); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x482, x483, (x474).get(), 0x5812631a); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x484, x485, (x474).get(), 0x5cf5d3ed); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x486, x487, 0x0, (x485).get(), (x482).get()); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x488, x489, (x487).get(), (x483).get(), (x480).get()); + Box x490 = new Box((int)0); + Box x491 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x490, x491, (x489).get(), (x481).get(), (x478).get()); + int x492 = ((x491).get() + (x479).get()); + Box x493 = new Box((int)0); + Box x494 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x493, x494, 0x0, (x456).get(), (x484).get()); + Box x495 = new Box((int)0); + Box x496 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x495, x496, (x494).get(), (x458).get(), (x486).get()); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x497, x498, (x496).get(), (x460).get(), (x488).get()); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x499, x500, (x498).get(), (x462).get(), (x490).get()); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x501, x502, (x500).get(), (x464).get(), x492); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x503, x504, (x502).get(), (x466).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x505, x506, (x504).get(), (x468).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x507, x508, (x506).get(), (x470).get(), (x476).get()); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x509, x510, (x508).get(), (x472).get(), (x477).get()); + int x511 = ((x510).get() + (x473).get()); + Box x512 = new Box((int)0); + Box x513 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x512, x513, x6, (arg2[7])); + Box x514 = new Box((int)0); + Box x515 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x514, x515, x6, (arg2[6])); + Box x516 = new Box((int)0); + Box x517 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x516, x517, x6, (arg2[5])); + Box x518 = new Box((int)0); + Box x519 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x518, x519, x6, (arg2[4])); + Box x520 = new Box((int)0); + Box x521 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x520, x521, x6, (arg2[3])); + Box x522 = new Box((int)0); + Box x523 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x522, x523, x6, (arg2[2])); + Box x524 = new Box((int)0); + Box x525 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x524, x525, x6, (arg2[1])); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x526, x527, x6, (arg2[0])); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x528, x529, 0x0, (x527).get(), (x524).get()); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x530, x531, (x529).get(), (x525).get(), (x522).get()); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x532, x533, (x531).get(), (x523).get(), (x520).get()); + Box x534 = new Box((int)0); + Box x535 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x534, x535, (x533).get(), (x521).get(), (x518).get()); + Box x536 = new Box((int)0); + Box x537 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x536, x537, (x535).get(), (x519).get(), (x516).get()); + Box x538 = new Box((int)0); + Box x539 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x538, x539, (x537).get(), (x517).get(), (x514).get()); + Box x540 = new Box((int)0); + Box x541 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x540, x541, (x539).get(), (x515).get(), (x512).get()); + int x542 = ((x541).get() + (x513).get()); + Box x543 = new Box((int)0); + Box x544 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x543, x544, 0x0, (x495).get(), (x526).get()); + Box x545 = new Box((int)0); + Box x546 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x545, x546, (x544).get(), (x497).get(), (x528).get()); + Box x547 = new Box((int)0); + Box x548 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x547, x548, (x546).get(), (x499).get(), (x530).get()); + Box x549 = new Box((int)0); + Box x550 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x549, x550, (x548).get(), (x501).get(), (x532).get()); + Box x551 = new Box((int)0); + Box x552 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x551, x552, (x550).get(), (x503).get(), (x534).get()); + Box x553 = new Box((int)0); + Box x554 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x553, x554, (x552).get(), (x505).get(), (x536).get()); + Box x555 = new Box((int)0); + Box x556 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x555, x556, (x554).get(), (x507).get(), (x538).get()); + Box x557 = new Box((int)0); + Box x558 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x557, x558, (x556).get(), (x509).get(), (x540).get()); + Box x559 = new Box((int)0); + Box x560 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x559, x560, (x558).get(), x511, x542); + Box x561 = new Box((int)0); + Box x562 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x561, x562, (x543).get(), 0x12547e1b); + Box x563 = new Box((int)0); + Box x564 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x563, x564, (x561).get(), 0x10000000); + Box x565 = new Box((int)0); + Box x566 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x565, x566, (x561).get(), 0x14def9de); + Box x567 = new Box((int)0); + Box x568 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x567, x568, (x561).get(), 0xa2f79cd6); + Box x569 = new Box((int)0); + Box x570 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x569, x570, (x561).get(), 0x5812631a); + Box x571 = new Box((int)0); + Box x572 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x571, x572, (x561).get(), 0x5cf5d3ed); + Box x573 = new Box((int)0); + Box x574 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x573, x574, 0x0, (x572).get(), (x569).get()); + Box x575 = new Box((int)0); + Box x576 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x575, x576, (x574).get(), (x570).get(), (x567).get()); + Box x577 = new Box((int)0); + Box x578 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x577, x578, (x576).get(), (x568).get(), (x565).get()); + int x579 = ((x578).get() + (x566).get()); + Box x580 = new Box((int)0); + Box x581 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x580, x581, 0x0, (x543).get(), (x571).get()); + Box x582 = new Box((int)0); + Box x583 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x582, x583, (x581).get(), (x545).get(), (x573).get()); + Box x584 = new Box((int)0); + Box x585 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x584, x585, (x583).get(), (x547).get(), (x575).get()); + Box x586 = new Box((int)0); + Box x587 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x586, x587, (x585).get(), (x549).get(), (x577).get()); + Box x588 = new Box((int)0); + Box x589 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x588, x589, (x587).get(), (x551).get(), x579); + Box x590 = new Box((int)0); + Box x591 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x590, x591, (x589).get(), (x553).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x592 = new Box((int)0); + Box x593 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x592, x593, (x591).get(), (x555).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x594 = new Box((int)0); + Box x595 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x594, x595, (x593).get(), (x557).get(), (x563).get()); + Box x596 = new Box((int)0); + Box x597 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x596, x597, (x595).get(), (x559).get(), (x564).get()); + int x598 = ((x597).get() + (x560).get()); + Box x599 = new Box((int)0); + Box x600 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x599, x600, x7, (arg2[7])); + Box x601 = new Box((int)0); + Box x602 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x601, x602, x7, (arg2[6])); + Box x603 = new Box((int)0); + Box x604 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x603, x604, x7, (arg2[5])); + Box x605 = new Box((int)0); + Box x606 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x605, x606, x7, (arg2[4])); + Box x607 = new Box((int)0); + Box x608 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x607, x608, x7, (arg2[3])); + Box x609 = new Box((int)0); + Box x610 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x609, x610, x7, (arg2[2])); + Box x611 = new Box((int)0); + Box x612 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x611, x612, x7, (arg2[1])); + Box x613 = new Box((int)0); + Box x614 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x613, x614, x7, (arg2[0])); + Box x615 = new Box((int)0); + Box x616 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x615, x616, 0x0, (x614).get(), (x611).get()); + Box x617 = new Box((int)0); + Box x618 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x617, x618, (x616).get(), (x612).get(), (x609).get()); + Box x619 = new Box((int)0); + Box x620 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x619, x620, (x618).get(), (x610).get(), (x607).get()); + Box x621 = new Box((int)0); + Box x622 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x621, x622, (x620).get(), (x608).get(), (x605).get()); + Box x623 = new Box((int)0); + Box x624 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x623, x624, (x622).get(), (x606).get(), (x603).get()); + Box x625 = new Box((int)0); + Box x626 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x625, x626, (x624).get(), (x604).get(), (x601).get()); + Box x627 = new Box((int)0); + Box x628 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x627, x628, (x626).get(), (x602).get(), (x599).get()); + int x629 = ((x628).get() + (x600).get()); + Box x630 = new Box((int)0); + Box x631 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x630, x631, 0x0, (x582).get(), (x613).get()); + Box x632 = new Box((int)0); + Box x633 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x632, x633, (x631).get(), (x584).get(), (x615).get()); + Box x634 = new Box((int)0); + Box x635 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x634, x635, (x633).get(), (x586).get(), (x617).get()); + Box x636 = new Box((int)0); + Box x637 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x636, x637, (x635).get(), (x588).get(), (x619).get()); + Box x638 = new Box((int)0); + Box x639 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x638, x639, (x637).get(), (x590).get(), (x621).get()); + Box x640 = new Box((int)0); + Box x641 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x640, x641, (x639).get(), (x592).get(), (x623).get()); + Box x642 = new Box((int)0); + Box x643 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x642, x643, (x641).get(), (x594).get(), (x625).get()); + Box x644 = new Box((int)0); + Box x645 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x644, x645, (x643).get(), (x596).get(), (x627).get()); + Box x646 = new Box((int)0); + Box x647 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x646, x647, (x645).get(), x598, x629); + Box x648 = new Box((int)0); + Box x649 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x648, x649, (x630).get(), 0x12547e1b); + Box x650 = new Box((int)0); + Box x651 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x650, x651, (x648).get(), 0x10000000); + Box x652 = new Box((int)0); + Box x653 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x652, x653, (x648).get(), 0x14def9de); + Box x654 = new Box((int)0); + Box x655 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x654, x655, (x648).get(), 0xa2f79cd6); + Box x656 = new Box((int)0); + Box x657 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x656, x657, (x648).get(), 0x5812631a); + Box x658 = new Box((int)0); + Box x659 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x658, x659, (x648).get(), 0x5cf5d3ed); + Box x660 = new Box((int)0); + Box x661 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x660, x661, 0x0, (x659).get(), (x656).get()); + Box x662 = new Box((int)0); + Box x663 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x662, x663, (x661).get(), (x657).get(), (x654).get()); + Box x664 = new Box((int)0); + Box x665 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x664, x665, (x663).get(), (x655).get(), (x652).get()); + int x666 = ((x665).get() + (x653).get()); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x667, x668, 0x0, (x630).get(), (x658).get()); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x669, x670, (x668).get(), (x632).get(), (x660).get()); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x671, x672, (x670).get(), (x634).get(), (x662).get()); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x673, x674, (x672).get(), (x636).get(), (x664).get()); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x675, x676, (x674).get(), (x638).get(), x666); + Box x677 = new Box((int)0); + Box x678 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x677, x678, (x676).get(), (x640).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x679, x680, (x678).get(), (x642).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x681, x682, (x680).get(), (x644).get(), (x650).get()); + Box x683 = new Box((int)0); + Box x684 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x683, x684, (x682).get(), (x646).get(), (x651).get()); + int x685 = ((x684).get() + (x647).get()); + Box x686 = new Box((int)0); + Box x687 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x686, x687, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x669).get(), 0x5cf5d3ed); + Box x688 = new Box((int)0); + Box x689 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x688, x689, (x687).get(), (x671).get(), 0x5812631a); + Box x690 = new Box((int)0); + Box x691 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x690, x691, (x689).get(), (x673).get(), 0xa2f79cd6); + Box x692 = new Box((int)0); + Box x693 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x692, x693, (x691).get(), (x675).get(), 0x14def9de); + Box x694 = new Box((int)0); + Box x695 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x694, x695, (x693).get(), (x677).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x696 = new Box((int)0); + Box x697 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x696, x697, (x695).get(), (x679).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x698 = new Box((int)0); + Box x699 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x698, x699, (x697).get(), (x681).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x700 = new Box((int)0); + Box x701 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x700, x701, (x699).get(), (x683).get(), 0x10000000); + Box x702 = new Box((int)0); + Box x703 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x702, x703, (x701).get(), x685, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x704 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x704, (x703).get(), (x686).get(), (x669).get()); + Box x705 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x705, (x703).get(), (x688).get(), (x671).get()); + Box x706 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x706, (x703).get(), (x690).get(), (x673).get()); + Box x707 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x707, (x703).get(), (x692).get(), (x675).get()); + Box x708 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x708, (x703).get(), (x694).get(), (x677).get()); + Box x709 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x709, (x703).get(), (x696).get(), (x679).get()); + Box x710 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x710, (x703).get(), (x698).get(), (x681).get()); + Box x711 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x711, (x703).get(), (x700).get(), (x683).get()); + out1[0] = (x704).get(); + out1[1] = (x705).get(); + out1[2] = (x706).get(); + out1[3] = (x707).get(); + out1[4] = (x708).get(); + out1[5] = (x709).get(); + out1[6] = (x710).get(); + out1[7] = (x711).get(); +} + +/** + * The function fiat_Curve25519Scalar_square squares a field element in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Curve25519Scalar_square(int[] out1, final int[] arg1) { + int x1 = (arg1[1]); + int x2 = (arg1[2]); + int x3 = (arg1[3]); + int x4 = (arg1[4]); + int x5 = (arg1[5]); + int x6 = (arg1[6]); + int x7 = (arg1[7]); + int x8 = (arg1[0]); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x9, x10, x8, (arg1[7])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x11, x12, x8, (arg1[6])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x13, x14, x8, (arg1[5])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x15, x16, x8, (arg1[4])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x17, x18, x8, (arg1[3])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x19, x20, x8, (arg1[2])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x21, x22, x8, (arg1[1])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x23, x24, x8, (arg1[0])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x37, x38, (x36).get(), (x12).get(), (x9).get()); + int x39 = ((x38).get() + (x10).get()); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x40, x41, (x23).get(), 0x12547e1b); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x42, x43, (x40).get(), 0x10000000); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x44, x45, (x40).get(), 0x14def9de); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x46, x47, (x40).get(), 0xa2f79cd6); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x48, x49, (x40).get(), 0x5812631a); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x50, x51, (x40).get(), 0x5cf5d3ed); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x52, x53, 0x0, (x51).get(), (x48).get()); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x54, x55, (x53).get(), (x49).get(), (x46).get()); + Box x56 = new Box((int)0); + Box x57 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x56, x57, (x55).get(), (x47).get(), (x44).get()); + int x58 = ((x57).get() + (x45).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x59, x60, 0x0, (x23).get(), (x50).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x61, x62, (x60).get(), (x25).get(), (x52).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x63, x64, (x62).get(), (x27).get(), (x54).get()); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x65, x66, (x64).get(), (x29).get(), (x56).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x67, x68, (x66).get(), (x31).get(), x58); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x69, x70, (x68).get(), (x33).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x71, x72, (x70).get(), (x35).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x73, x74, (x72).get(), (x37).get(), (x42).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x75, x76, (x74).get(), x39, (x43).get()); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x77, x78, x1, (arg1[7])); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x79, x80, x1, (arg1[6])); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x81, x82, x1, (arg1[5])); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x83, x84, x1, (arg1[4])); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x85, x86, x1, (arg1[3])); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x87, x88, x1, (arg1[2])); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x89, x90, x1, (arg1[1])); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x91, x92, x1, (arg1[0])); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x93, x94, 0x0, (x92).get(), (x89).get()); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x95, x96, (x94).get(), (x90).get(), (x87).get()); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x97, x98, (x96).get(), (x88).get(), (x85).get()); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x99, x100, (x98).get(), (x86).get(), (x83).get()); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x101, x102, (x100).get(), (x84).get(), (x81).get()); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x103, x104, (x102).get(), (x82).get(), (x79).get()); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x105, x106, (x104).get(), (x80).get(), (x77).get()); + int x107 = ((x106).get() + (x78).get()); + Box x108 = new Box((int)0); + Box x109 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x108, x109, 0x0, (x61).get(), (x91).get()); + Box x110 = new Box((int)0); + Box x111 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x110, x111, (x109).get(), (x63).get(), (x93).get()); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x112, x113, (x111).get(), (x65).get(), (x95).get()); + Box x114 = new Box((int)0); + Box x115 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x114, x115, (x113).get(), (x67).get(), (x97).get()); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x116, x117, (x115).get(), (x69).get(), (x99).get()); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x118, x119, (x117).get(), (x71).get(), (x101).get()); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x120, x121, (x119).get(), (x73).get(), (x103).get()); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x122, x123, (x121).get(), (x75).get(), (x105).get()); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x124, x125, (x123).get(), (x76).get(), x107); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x126, x127, (x108).get(), 0x12547e1b); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x128, x129, (x126).get(), 0x10000000); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x130, x131, (x126).get(), 0x14def9de); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x132, x133, (x126).get(), 0xa2f79cd6); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x134, x135, (x126).get(), 0x5812631a); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x136, x137, (x126).get(), 0x5cf5d3ed); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x138, x139, 0x0, (x137).get(), (x134).get()); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x140, x141, (x139).get(), (x135).get(), (x132).get()); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x142, x143, (x141).get(), (x133).get(), (x130).get()); + int x144 = ((x143).get() + (x131).get()); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x145, x146, 0x0, (x108).get(), (x136).get()); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x147, x148, (x146).get(), (x110).get(), (x138).get()); + Box x149 = new Box((int)0); + Box x150 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x149, x150, (x148).get(), (x112).get(), (x140).get()); + Box x151 = new Box((int)0); + Box x152 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x151, x152, (x150).get(), (x114).get(), (x142).get()); + Box x153 = new Box((int)0); + Box x154 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x153, x154, (x152).get(), (x116).get(), x144); + Box x155 = new Box((int)0); + Box x156 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x155, x156, (x154).get(), (x118).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x157 = new Box((int)0); + Box x158 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x157, x158, (x156).get(), (x120).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x159 = new Box((int)0); + Box x160 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x159, x160, (x158).get(), (x122).get(), (x128).get()); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x161, x162, (x160).get(), (x124).get(), (x129).get()); + int x163 = ((x162).get() + (x125).get()); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x164, x165, x2, (arg1[7])); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x166, x167, x2, (arg1[6])); + Box x168 = new Box((int)0); + Box x169 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x168, x169, x2, (arg1[5])); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x170, x171, x2, (arg1[4])); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x172, x173, x2, (arg1[3])); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x174, x175, x2, (arg1[2])); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x176, x177, x2, (arg1[1])); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x178, x179, x2, (arg1[0])); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x180, x181, 0x0, (x179).get(), (x176).get()); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x182, x183, (x181).get(), (x177).get(), (x174).get()); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x184, x185, (x183).get(), (x175).get(), (x172).get()); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x186, x187, (x185).get(), (x173).get(), (x170).get()); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x188, x189, (x187).get(), (x171).get(), (x168).get()); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x190, x191, (x189).get(), (x169).get(), (x166).get()); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x192, x193, (x191).get(), (x167).get(), (x164).get()); + int x194 = ((x193).get() + (x165).get()); + Box x195 = new Box((int)0); + Box x196 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x195, x196, 0x0, (x147).get(), (x178).get()); + Box x197 = new Box((int)0); + Box x198 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x197, x198, (x196).get(), (x149).get(), (x180).get()); + Box x199 = new Box((int)0); + Box x200 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x199, x200, (x198).get(), (x151).get(), (x182).get()); + Box x201 = new Box((int)0); + Box x202 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x201, x202, (x200).get(), (x153).get(), (x184).get()); + Box x203 = new Box((int)0); + Box x204 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x203, x204, (x202).get(), (x155).get(), (x186).get()); + Box x205 = new Box((int)0); + Box x206 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x205, x206, (x204).get(), (x157).get(), (x188).get()); + Box x207 = new Box((int)0); + Box x208 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x207, x208, (x206).get(), (x159).get(), (x190).get()); + Box x209 = new Box((int)0); + Box x210 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x209, x210, (x208).get(), (x161).get(), (x192).get()); + Box x211 = new Box((int)0); + Box x212 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x211, x212, (x210).get(), x163, x194); + Box x213 = new Box((int)0); + Box x214 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x213, x214, (x195).get(), 0x12547e1b); + Box x215 = new Box((int)0); + Box x216 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x215, x216, (x213).get(), 0x10000000); + Box x217 = new Box((int)0); + Box x218 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x217, x218, (x213).get(), 0x14def9de); + Box x219 = new Box((int)0); + Box x220 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x219, x220, (x213).get(), 0xa2f79cd6); + Box x221 = new Box((int)0); + Box x222 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x221, x222, (x213).get(), 0x5812631a); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x223, x224, (x213).get(), 0x5cf5d3ed); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x225, x226, 0x0, (x224).get(), (x221).get()); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x227, x228, (x226).get(), (x222).get(), (x219).get()); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x229, x230, (x228).get(), (x220).get(), (x217).get()); + int x231 = ((x230).get() + (x218).get()); + Box x232 = new Box((int)0); + Box x233 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x232, x233, 0x0, (x195).get(), (x223).get()); + Box x234 = new Box((int)0); + Box x235 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x234, x235, (x233).get(), (x197).get(), (x225).get()); + Box x236 = new Box((int)0); + Box x237 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x236, x237, (x235).get(), (x199).get(), (x227).get()); + Box x238 = new Box((int)0); + Box x239 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x238, x239, (x237).get(), (x201).get(), (x229).get()); + Box x240 = new Box((int)0); + Box x241 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x240, x241, (x239).get(), (x203).get(), x231); + Box x242 = new Box((int)0); + Box x243 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x242, x243, (x241).get(), (x205).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x244 = new Box((int)0); + Box x245 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x244, x245, (x243).get(), (x207).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x246, x247, (x245).get(), (x209).get(), (x215).get()); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x248, x249, (x247).get(), (x211).get(), (x216).get()); + int x250 = ((x249).get() + (x212).get()); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x251, x252, x3, (arg1[7])); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x253, x254, x3, (arg1[6])); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x255, x256, x3, (arg1[5])); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x257, x258, x3, (arg1[4])); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x259, x260, x3, (arg1[3])); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x261, x262, x3, (arg1[2])); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x263, x264, x3, (arg1[1])); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x265, x266, x3, (arg1[0])); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x267, x268, 0x0, (x266).get(), (x263).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x269, x270, (x268).get(), (x264).get(), (x261).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x271, x272, (x270).get(), (x262).get(), (x259).get()); + Box x273 = new Box((int)0); + Box x274 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x273, x274, (x272).get(), (x260).get(), (x257).get()); + Box x275 = new Box((int)0); + Box x276 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x275, x276, (x274).get(), (x258).get(), (x255).get()); + Box x277 = new Box((int)0); + Box x278 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x277, x278, (x276).get(), (x256).get(), (x253).get()); + Box x279 = new Box((int)0); + Box x280 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x279, x280, (x278).get(), (x254).get(), (x251).get()); + int x281 = ((x280).get() + (x252).get()); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x282, x283, 0x0, (x234).get(), (x265).get()); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x284, x285, (x283).get(), (x236).get(), (x267).get()); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x286, x287, (x285).get(), (x238).get(), (x269).get()); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x288, x289, (x287).get(), (x240).get(), (x271).get()); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x290, x291, (x289).get(), (x242).get(), (x273).get()); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x292, x293, (x291).get(), (x244).get(), (x275).get()); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x294, x295, (x293).get(), (x246).get(), (x277).get()); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x296, x297, (x295).get(), (x248).get(), (x279).get()); + Box x298 = new Box((int)0); + Box x299 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x298, x299, (x297).get(), x250, x281); + Box x300 = new Box((int)0); + Box x301 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x300, x301, (x282).get(), 0x12547e1b); + Box x302 = new Box((int)0); + Box x303 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x302, x303, (x300).get(), 0x10000000); + Box x304 = new Box((int)0); + Box x305 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x304, x305, (x300).get(), 0x14def9de); + Box x306 = new Box((int)0); + Box x307 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x306, x307, (x300).get(), 0xa2f79cd6); + Box x308 = new Box((int)0); + Box x309 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x308, x309, (x300).get(), 0x5812631a); + Box x310 = new Box((int)0); + Box x311 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x310, x311, (x300).get(), 0x5cf5d3ed); + Box x312 = new Box((int)0); + Box x313 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x312, x313, 0x0, (x311).get(), (x308).get()); + Box x314 = new Box((int)0); + Box x315 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x314, x315, (x313).get(), (x309).get(), (x306).get()); + Box x316 = new Box((int)0); + Box x317 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x316, x317, (x315).get(), (x307).get(), (x304).get()); + int x318 = ((x317).get() + (x305).get()); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x319, x320, 0x0, (x282).get(), (x310).get()); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x321, x322, (x320).get(), (x284).get(), (x312).get()); + Box x323 = new Box((int)0); + Box x324 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x323, x324, (x322).get(), (x286).get(), (x314).get()); + Box x325 = new Box((int)0); + Box x326 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x325, x326, (x324).get(), (x288).get(), (x316).get()); + Box x327 = new Box((int)0); + Box x328 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x327, x328, (x326).get(), (x290).get(), x318); + Box x329 = new Box((int)0); + Box x330 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x329, x330, (x328).get(), (x292).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x331, x332, (x330).get(), (x294).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x333, x334, (x332).get(), (x296).get(), (x302).get()); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x335, x336, (x334).get(), (x298).get(), (x303).get()); + int x337 = ((x336).get() + (x299).get()); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x338, x339, x4, (arg1[7])); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x340, x341, x4, (arg1[6])); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x342, x343, x4, (arg1[5])); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x344, x345, x4, (arg1[4])); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x346, x347, x4, (arg1[3])); + Box x348 = new Box((int)0); + Box x349 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x348, x349, x4, (arg1[2])); + Box x350 = new Box((int)0); + Box x351 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x350, x351, x4, (arg1[1])); + Box x352 = new Box((int)0); + Box x353 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x352, x353, x4, (arg1[0])); + Box x354 = new Box((int)0); + Box x355 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x354, x355, 0x0, (x353).get(), (x350).get()); + Box x356 = new Box((int)0); + Box x357 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x356, x357, (x355).get(), (x351).get(), (x348).get()); + Box x358 = new Box((int)0); + Box x359 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x358, x359, (x357).get(), (x349).get(), (x346).get()); + Box x360 = new Box((int)0); + Box x361 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x360, x361, (x359).get(), (x347).get(), (x344).get()); + Box x362 = new Box((int)0); + Box x363 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x362, x363, (x361).get(), (x345).get(), (x342).get()); + Box x364 = new Box((int)0); + Box x365 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x364, x365, (x363).get(), (x343).get(), (x340).get()); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x366, x367, (x365).get(), (x341).get(), (x338).get()); + int x368 = ((x367).get() + (x339).get()); + Box x369 = new Box((int)0); + Box x370 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x369, x370, 0x0, (x321).get(), (x352).get()); + Box x371 = new Box((int)0); + Box x372 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x371, x372, (x370).get(), (x323).get(), (x354).get()); + Box x373 = new Box((int)0); + Box x374 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x373, x374, (x372).get(), (x325).get(), (x356).get()); + Box x375 = new Box((int)0); + Box x376 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x375, x376, (x374).get(), (x327).get(), (x358).get()); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x377, x378, (x376).get(), (x329).get(), (x360).get()); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x379, x380, (x378).get(), (x331).get(), (x362).get()); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x381, x382, (x380).get(), (x333).get(), (x364).get()); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x383, x384, (x382).get(), (x335).get(), (x366).get()); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x385, x386, (x384).get(), x337, x368); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x387, x388, (x369).get(), 0x12547e1b); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x389, x390, (x387).get(), 0x10000000); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x391, x392, (x387).get(), 0x14def9de); + Box x393 = new Box((int)0); + Box x394 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x393, x394, (x387).get(), 0xa2f79cd6); + Box x395 = new Box((int)0); + Box x396 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x395, x396, (x387).get(), 0x5812631a); + Box x397 = new Box((int)0); + Box x398 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x397, x398, (x387).get(), 0x5cf5d3ed); + Box x399 = new Box((int)0); + Box x400 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x399, x400, 0x0, (x398).get(), (x395).get()); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x401, x402, (x400).get(), (x396).get(), (x393).get()); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x403, x404, (x402).get(), (x394).get(), (x391).get()); + int x405 = ((x404).get() + (x392).get()); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x406, x407, 0x0, (x369).get(), (x397).get()); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x408, x409, (x407).get(), (x371).get(), (x399).get()); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x410, x411, (x409).get(), (x373).get(), (x401).get()); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x412, x413, (x411).get(), (x375).get(), (x403).get()); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x414, x415, (x413).get(), (x377).get(), x405); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x416, x417, (x415).get(), (x379).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x418, x419, (x417).get(), (x381).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x420, x421, (x419).get(), (x383).get(), (x389).get()); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x422, x423, (x421).get(), (x385).get(), (x390).get()); + int x424 = ((x423).get() + (x386).get()); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x425, x426, x5, (arg1[7])); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x427, x428, x5, (arg1[6])); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x429, x430, x5, (arg1[5])); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x431, x432, x5, (arg1[4])); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x433, x434, x5, (arg1[3])); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x435, x436, x5, (arg1[2])); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x437, x438, x5, (arg1[1])); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x439, x440, x5, (arg1[0])); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x441, x442, 0x0, (x440).get(), (x437).get()); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x443, x444, (x442).get(), (x438).get(), (x435).get()); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x445, x446, (x444).get(), (x436).get(), (x433).get()); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x447, x448, (x446).get(), (x434).get(), (x431).get()); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x449, x450, (x448).get(), (x432).get(), (x429).get()); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x451, x452, (x450).get(), (x430).get(), (x427).get()); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x453, x454, (x452).get(), (x428).get(), (x425).get()); + int x455 = ((x454).get() + (x426).get()); + Box x456 = new Box((int)0); + Box x457 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x456, x457, 0x0, (x408).get(), (x439).get()); + Box x458 = new Box((int)0); + Box x459 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x458, x459, (x457).get(), (x410).get(), (x441).get()); + Box x460 = new Box((int)0); + Box x461 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x460, x461, (x459).get(), (x412).get(), (x443).get()); + Box x462 = new Box((int)0); + Box x463 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x462, x463, (x461).get(), (x414).get(), (x445).get()); + Box x464 = new Box((int)0); + Box x465 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x464, x465, (x463).get(), (x416).get(), (x447).get()); + Box x466 = new Box((int)0); + Box x467 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x466, x467, (x465).get(), (x418).get(), (x449).get()); + Box x468 = new Box((int)0); + Box x469 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x468, x469, (x467).get(), (x420).get(), (x451).get()); + Box x470 = new Box((int)0); + Box x471 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x470, x471, (x469).get(), (x422).get(), (x453).get()); + Box x472 = new Box((int)0); + Box x473 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x472, x473, (x471).get(), x424, x455); + Box x474 = new Box((int)0); + Box x475 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x474, x475, (x456).get(), 0x12547e1b); + Box x476 = new Box((int)0); + Box x477 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x476, x477, (x474).get(), 0x10000000); + Box x478 = new Box((int)0); + Box x479 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x478, x479, (x474).get(), 0x14def9de); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x480, x481, (x474).get(), 0xa2f79cd6); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x482, x483, (x474).get(), 0x5812631a); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x484, x485, (x474).get(), 0x5cf5d3ed); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x486, x487, 0x0, (x485).get(), (x482).get()); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x488, x489, (x487).get(), (x483).get(), (x480).get()); + Box x490 = new Box((int)0); + Box x491 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x490, x491, (x489).get(), (x481).get(), (x478).get()); + int x492 = ((x491).get() + (x479).get()); + Box x493 = new Box((int)0); + Box x494 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x493, x494, 0x0, (x456).get(), (x484).get()); + Box x495 = new Box((int)0); + Box x496 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x495, x496, (x494).get(), (x458).get(), (x486).get()); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x497, x498, (x496).get(), (x460).get(), (x488).get()); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x499, x500, (x498).get(), (x462).get(), (x490).get()); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x501, x502, (x500).get(), (x464).get(), x492); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x503, x504, (x502).get(), (x466).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x505, x506, (x504).get(), (x468).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x507, x508, (x506).get(), (x470).get(), (x476).get()); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x509, x510, (x508).get(), (x472).get(), (x477).get()); + int x511 = ((x510).get() + (x473).get()); + Box x512 = new Box((int)0); + Box x513 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x512, x513, x6, (arg1[7])); + Box x514 = new Box((int)0); + Box x515 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x514, x515, x6, (arg1[6])); + Box x516 = new Box((int)0); + Box x517 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x516, x517, x6, (arg1[5])); + Box x518 = new Box((int)0); + Box x519 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x518, x519, x6, (arg1[4])); + Box x520 = new Box((int)0); + Box x521 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x520, x521, x6, (arg1[3])); + Box x522 = new Box((int)0); + Box x523 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x522, x523, x6, (arg1[2])); + Box x524 = new Box((int)0); + Box x525 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x524, x525, x6, (arg1[1])); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x526, x527, x6, (arg1[0])); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x528, x529, 0x0, (x527).get(), (x524).get()); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x530, x531, (x529).get(), (x525).get(), (x522).get()); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x532, x533, (x531).get(), (x523).get(), (x520).get()); + Box x534 = new Box((int)0); + Box x535 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x534, x535, (x533).get(), (x521).get(), (x518).get()); + Box x536 = new Box((int)0); + Box x537 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x536, x537, (x535).get(), (x519).get(), (x516).get()); + Box x538 = new Box((int)0); + Box x539 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x538, x539, (x537).get(), (x517).get(), (x514).get()); + Box x540 = new Box((int)0); + Box x541 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x540, x541, (x539).get(), (x515).get(), (x512).get()); + int x542 = ((x541).get() + (x513).get()); + Box x543 = new Box((int)0); + Box x544 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x543, x544, 0x0, (x495).get(), (x526).get()); + Box x545 = new Box((int)0); + Box x546 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x545, x546, (x544).get(), (x497).get(), (x528).get()); + Box x547 = new Box((int)0); + Box x548 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x547, x548, (x546).get(), (x499).get(), (x530).get()); + Box x549 = new Box((int)0); + Box x550 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x549, x550, (x548).get(), (x501).get(), (x532).get()); + Box x551 = new Box((int)0); + Box x552 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x551, x552, (x550).get(), (x503).get(), (x534).get()); + Box x553 = new Box((int)0); + Box x554 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x553, x554, (x552).get(), (x505).get(), (x536).get()); + Box x555 = new Box((int)0); + Box x556 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x555, x556, (x554).get(), (x507).get(), (x538).get()); + Box x557 = new Box((int)0); + Box x558 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x557, x558, (x556).get(), (x509).get(), (x540).get()); + Box x559 = new Box((int)0); + Box x560 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x559, x560, (x558).get(), x511, x542); + Box x561 = new Box((int)0); + Box x562 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x561, x562, (x543).get(), 0x12547e1b); + Box x563 = new Box((int)0); + Box x564 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x563, x564, (x561).get(), 0x10000000); + Box x565 = new Box((int)0); + Box x566 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x565, x566, (x561).get(), 0x14def9de); + Box x567 = new Box((int)0); + Box x568 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x567, x568, (x561).get(), 0xa2f79cd6); + Box x569 = new Box((int)0); + Box x570 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x569, x570, (x561).get(), 0x5812631a); + Box x571 = new Box((int)0); + Box x572 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x571, x572, (x561).get(), 0x5cf5d3ed); + Box x573 = new Box((int)0); + Box x574 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x573, x574, 0x0, (x572).get(), (x569).get()); + Box x575 = new Box((int)0); + Box x576 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x575, x576, (x574).get(), (x570).get(), (x567).get()); + Box x577 = new Box((int)0); + Box x578 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x577, x578, (x576).get(), (x568).get(), (x565).get()); + int x579 = ((x578).get() + (x566).get()); + Box x580 = new Box((int)0); + Box x581 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x580, x581, 0x0, (x543).get(), (x571).get()); + Box x582 = new Box((int)0); + Box x583 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x582, x583, (x581).get(), (x545).get(), (x573).get()); + Box x584 = new Box((int)0); + Box x585 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x584, x585, (x583).get(), (x547).get(), (x575).get()); + Box x586 = new Box((int)0); + Box x587 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x586, x587, (x585).get(), (x549).get(), (x577).get()); + Box x588 = new Box((int)0); + Box x589 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x588, x589, (x587).get(), (x551).get(), x579); + Box x590 = new Box((int)0); + Box x591 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x590, x591, (x589).get(), (x553).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x592 = new Box((int)0); + Box x593 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x592, x593, (x591).get(), (x555).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x594 = new Box((int)0); + Box x595 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x594, x595, (x593).get(), (x557).get(), (x563).get()); + Box x596 = new Box((int)0); + Box x597 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x596, x597, (x595).get(), (x559).get(), (x564).get()); + int x598 = ((x597).get() + (x560).get()); + Box x599 = new Box((int)0); + Box x600 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x599, x600, x7, (arg1[7])); + Box x601 = new Box((int)0); + Box x602 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x601, x602, x7, (arg1[6])); + Box x603 = new Box((int)0); + Box x604 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x603, x604, x7, (arg1[5])); + Box x605 = new Box((int)0); + Box x606 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x605, x606, x7, (arg1[4])); + Box x607 = new Box((int)0); + Box x608 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x607, x608, x7, (arg1[3])); + Box x609 = new Box((int)0); + Box x610 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x609, x610, x7, (arg1[2])); + Box x611 = new Box((int)0); + Box x612 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x611, x612, x7, (arg1[1])); + Box x613 = new Box((int)0); + Box x614 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x613, x614, x7, (arg1[0])); + Box x615 = new Box((int)0); + Box x616 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x615, x616, 0x0, (x614).get(), (x611).get()); + Box x617 = new Box((int)0); + Box x618 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x617, x618, (x616).get(), (x612).get(), (x609).get()); + Box x619 = new Box((int)0); + Box x620 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x619, x620, (x618).get(), (x610).get(), (x607).get()); + Box x621 = new Box((int)0); + Box x622 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x621, x622, (x620).get(), (x608).get(), (x605).get()); + Box x623 = new Box((int)0); + Box x624 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x623, x624, (x622).get(), (x606).get(), (x603).get()); + Box x625 = new Box((int)0); + Box x626 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x625, x626, (x624).get(), (x604).get(), (x601).get()); + Box x627 = new Box((int)0); + Box x628 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x627, x628, (x626).get(), (x602).get(), (x599).get()); + int x629 = ((x628).get() + (x600).get()); + Box x630 = new Box((int)0); + Box x631 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x630, x631, 0x0, (x582).get(), (x613).get()); + Box x632 = new Box((int)0); + Box x633 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x632, x633, (x631).get(), (x584).get(), (x615).get()); + Box x634 = new Box((int)0); + Box x635 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x634, x635, (x633).get(), (x586).get(), (x617).get()); + Box x636 = new Box((int)0); + Box x637 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x636, x637, (x635).get(), (x588).get(), (x619).get()); + Box x638 = new Box((int)0); + Box x639 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x638, x639, (x637).get(), (x590).get(), (x621).get()); + Box x640 = new Box((int)0); + Box x641 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x640, x641, (x639).get(), (x592).get(), (x623).get()); + Box x642 = new Box((int)0); + Box x643 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x642, x643, (x641).get(), (x594).get(), (x625).get()); + Box x644 = new Box((int)0); + Box x645 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x644, x645, (x643).get(), (x596).get(), (x627).get()); + Box x646 = new Box((int)0); + Box x647 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x646, x647, (x645).get(), x598, x629); + Box x648 = new Box((int)0); + Box x649 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x648, x649, (x630).get(), 0x12547e1b); + Box x650 = new Box((int)0); + Box x651 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x650, x651, (x648).get(), 0x10000000); + Box x652 = new Box((int)0); + Box x653 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x652, x653, (x648).get(), 0x14def9de); + Box x654 = new Box((int)0); + Box x655 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x654, x655, (x648).get(), 0xa2f79cd6); + Box x656 = new Box((int)0); + Box x657 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x656, x657, (x648).get(), 0x5812631a); + Box x658 = new Box((int)0); + Box x659 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x658, x659, (x648).get(), 0x5cf5d3ed); + Box x660 = new Box((int)0); + Box x661 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x660, x661, 0x0, (x659).get(), (x656).get()); + Box x662 = new Box((int)0); + Box x663 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x662, x663, (x661).get(), (x657).get(), (x654).get()); + Box x664 = new Box((int)0); + Box x665 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x664, x665, (x663).get(), (x655).get(), (x652).get()); + int x666 = ((x665).get() + (x653).get()); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x667, x668, 0x0, (x630).get(), (x658).get()); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x669, x670, (x668).get(), (x632).get(), (x660).get()); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x671, x672, (x670).get(), (x634).get(), (x662).get()); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x673, x674, (x672).get(), (x636).get(), (x664).get()); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x675, x676, (x674).get(), (x638).get(), x666); + Box x677 = new Box((int)0); + Box x678 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x677, x678, (x676).get(), (x640).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x679, x680, (x678).get(), (x642).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x681, x682, (x680).get(), (x644).get(), (x650).get()); + Box x683 = new Box((int)0); + Box x684 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x683, x684, (x682).get(), (x646).get(), (x651).get()); + int x685 = ((x684).get() + (x647).get()); + Box x686 = new Box((int)0); + Box x687 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x686, x687, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x669).get(), 0x5cf5d3ed); + Box x688 = new Box((int)0); + Box x689 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x688, x689, (x687).get(), (x671).get(), 0x5812631a); + Box x690 = new Box((int)0); + Box x691 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x690, x691, (x689).get(), (x673).get(), 0xa2f79cd6); + Box x692 = new Box((int)0); + Box x693 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x692, x693, (x691).get(), (x675).get(), 0x14def9de); + Box x694 = new Box((int)0); + Box x695 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x694, x695, (x693).get(), (x677).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x696 = new Box((int)0); + Box x697 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x696, x697, (x695).get(), (x679).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x698 = new Box((int)0); + Box x699 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x698, x699, (x697).get(), (x681).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x700 = new Box((int)0); + Box x701 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x700, x701, (x699).get(), (x683).get(), 0x10000000); + Box x702 = new Box((int)0); + Box x703 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x702, x703, (x701).get(), x685, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x704 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x704, (x703).get(), (x686).get(), (x669).get()); + Box x705 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x705, (x703).get(), (x688).get(), (x671).get()); + Box x706 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x706, (x703).get(), (x690).get(), (x673).get()); + Box x707 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x707, (x703).get(), (x692).get(), (x675).get()); + Box x708 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x708, (x703).get(), (x694).get(), (x677).get()); + Box x709 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x709, (x703).get(), (x696).get(), (x679).get()); + Box x710 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x710, (x703).get(), (x698).get(), (x681).get()); + Box x711 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x711, (x703).get(), (x700).get(), (x683).get()); + out1[0] = (x704).get(); + out1[1] = (x705).get(); + out1[2] = (x706).get(); + out1[3] = (x707).get(); + out1[4] = (x708).get(); + out1[5] = (x709).get(); + out1[6] = (x710).get(); + out1[7] = (x711).get(); +} + +/** + * The function fiat_Curve25519Scalar_add adds two field elements in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * 0 ≤ eval arg2 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Curve25519Scalar_add(int[] out1, final int[] arg1, final int[] arg2) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x1, x2, 0x0, (arg1[0]), (arg2[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x3, x4, (x2).get(), (arg1[1]), (arg2[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x5, x6, (x4).get(), (arg1[2]), (arg2[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x7, x8, (x6).get(), (arg1[3]), (arg2[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x9, x10, (x8).get(), (arg1[4]), (arg2[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x11, x12, (x10).get(), (arg1[5]), (arg2[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x13, x14, (x12).get(), (arg1[6]), (arg2[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x15, x16, (x14).get(), (arg1[7]), (arg2[7])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x17, x18, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x1).get(), 0x5cf5d3ed); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x19, x20, (x18).get(), (x3).get(), 0x5812631a); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x21, x22, (x20).get(), (x5).get(), 0xa2f79cd6); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x23, x24, (x22).get(), (x7).get(), 0x14def9de); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x25, x26, (x24).get(), (x9).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x27, x28, (x26).get(), (x11).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x29, x30, (x28).get(), (x13).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x31, x32, (x30).get(), (x15).get(), 0x10000000); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x33, x34, (x32).get(), (x16).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x35 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x35, (x34).get(), (x17).get(), (x1).get()); + Box x36 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x36, (x34).get(), (x19).get(), (x3).get()); + Box x37 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x37, (x34).get(), (x21).get(), (x5).get()); + Box x38 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x38, (x34).get(), (x23).get(), (x7).get()); + Box x39 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x39, (x34).get(), (x25).get(), (x9).get()); + Box x40 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x40, (x34).get(), (x27).get(), (x11).get()); + Box x41 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x41, (x34).get(), (x29).get(), (x13).get()); + Box x42 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x42, (x34).get(), (x31).get(), (x15).get()); + out1[0] = (x35).get(); + out1[1] = (x36).get(); + out1[2] = (x37).get(); + out1[3] = (x38).get(); + out1[4] = (x39).get(); + out1[5] = (x40).get(); + out1[6] = (x41).get(); + out1[7] = (x42).get(); +} + +/** + * The function fiat_Curve25519Scalar_sub subtracts two field elements in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * 0 ≤ eval arg2 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Curve25519Scalar_sub(int[] out1, final int[] arg1, final int[] arg2) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x1, x2, 0x0, (arg1[0]), (arg2[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x3, x4, (x2).get(), (arg1[1]), (arg2[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x5, x6, (x4).get(), (arg1[2]), (arg2[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x7, x8, (x6).get(), (arg1[3]), (arg2[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x9, x10, (x8).get(), (arg1[4]), (arg2[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x11, x12, (x10).get(), (arg1[5]), (arg2[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x13, x14, (x12).get(), (arg1[6]), (arg2[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x15, x16, (x14).get(), (arg1[7]), (arg2[7])); + Box x17 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x17, (x16).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), 0xffffffff); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x18, x19, 0x0, (x1).get(), ((x17).get() & 0x5cf5d3ed)); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x20, x21, (x19).get(), (x3).get(), ((x17).get() & 0x5812631a)); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x22, x23, (x21).get(), (x5).get(), ((x17).get() & 0xa2f79cd6)); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x24, x25, (x23).get(), (x7).get(), ((x17).get() & 0x14def9de)); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x26, x27, (x25).get(), (x9).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x28, x29, (x27).get(), (x11).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x30, x31, (x29).get(), (x13).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x32, x33, (x31).get(), (x15).get(), ((x17).get() & 0x10000000)); + out1[0] = (x18).get(); + out1[1] = (x20).get(); + out1[2] = (x22).get(); + out1[3] = (x24).get(); + out1[4] = (x26).get(); + out1[5] = (x28).get(); + out1[6] = (x30).get(); + out1[7] = (x32).get(); +} + +/** + * The function fiat_Curve25519Scalar_opp negates a field element in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Curve25519Scalar_opp(int[] out1, final int[] arg1) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x1, x2, 0x0, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x3, x4, (x2).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x5, x6, (x4).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x7, x8, (x6).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x9, x10, (x8).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x11, x12, (x10).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x13, x14, (x12).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x15, x16, (x14).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[7])); + Box x17 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x17, (x16).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), 0xffffffff); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x18, x19, 0x0, (x1).get(), ((x17).get() & 0x5cf5d3ed)); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x20, x21, (x19).get(), (x3).get(), ((x17).get() & 0x5812631a)); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x22, x23, (x21).get(), (x5).get(), ((x17).get() & 0xa2f79cd6)); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x24, x25, (x23).get(), (x7).get(), ((x17).get() & 0x14def9de)); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x26, x27, (x25).get(), (x9).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x28, x29, (x27).get(), (x11).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x30, x31, (x29).get(), (x13).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x32, x33, (x31).get(), (x15).get(), ((x17).get() & 0x10000000)); + out1[0] = (x18).get(); + out1[1] = (x20).get(); + out1[2] = (x22).get(); + out1[3] = (x24).get(); + out1[4] = (x26).get(); + out1[5] = (x28).get(); + out1[6] = (x30).get(); + out1[7] = (x32).get(); +} + +/** + * The function fiat_Curve25519Scalar_from_montgomery translates a field element out of the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Curve25519Scalar_from_montgomery(int[] out1, final int[] arg1) { + int x1 = (arg1[0]); + Box x2 = new Box((int)0); + Box x3 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x2, x3, x1, 0x12547e1b); + Box x4 = new Box((int)0); + Box x5 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x4, x5, (x2).get(), 0x10000000); + Box x6 = new Box((int)0); + Box x7 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x6, x7, (x2).get(), 0x14def9de); + Box x8 = new Box((int)0); + Box x9 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x8, x9, (x2).get(), 0xa2f79cd6); + Box x10 = new Box((int)0); + Box x11 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x10, x11, (x2).get(), 0x5812631a); + Box x12 = new Box((int)0); + Box x13 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x12, x13, (x2).get(), 0x5cf5d3ed); + Box x14 = new Box((int)0); + Box x15 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x14, x15, 0x0, (x13).get(), (x10).get()); + Box x16 = new Box((int)0); + Box x17 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x16, x17, (x15).get(), (x11).get(), (x8).get()); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x18, x19, (x17).get(), (x9).get(), (x6).get()); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x20, x21, 0x0, x1, (x12).get()); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x22, x23, (x21).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x14).get()); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x24, x25, (x23).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x16).get()); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x26, x27, (x25).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x18).get()); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x28, x29, 0x0, (x22).get(), (arg1[1])); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x30, x31, (x29).get(), (x24).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x32, x33, (x31).get(), (x26).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x34 = new Box((int)0); + Box x35 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x34, x35, (x28).get(), 0x12547e1b); + Box x36 = new Box((int)0); + Box x37 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x36, x37, (x34).get(), 0x10000000); + Box x38 = new Box((int)0); + Box x39 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x38, x39, (x34).get(), 0x14def9de); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x40, x41, (x34).get(), 0xa2f79cd6); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x42, x43, (x34).get(), 0x5812631a); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x44, x45, (x34).get(), 0x5cf5d3ed); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x46, x47, 0x0, (x45).get(), (x42).get()); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x48, x49, (x47).get(), (x43).get(), (x40).get()); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x50, x51, (x49).get(), (x41).get(), (x38).get()); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x52, x53, 0x0, (x28).get(), (x44).get()); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x54, x55, (x53).get(), (x30).get(), (x46).get()); + Box x56 = new Box((int)0); + Box x57 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x56, x57, (x55).get(), (x32).get(), (x48).get()); + Box x58 = new Box((int)0); + Box x59 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x58, x59, (x57).get(), ((x33).get() + ((x27).get() + ((x19).get() + (x7).get()))), (x50).get()); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x60, x61, 0x0, (x5).get(), (x36).get()); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x62, x63, 0x0, (x54).get(), (arg1[2])); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x64, x65, (x63).get(), (x56).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x66, x67, (x65).get(), (x58).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x68, x69, (x62).get(), 0x12547e1b); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x70, x71, (x68).get(), 0x10000000); + Box x72 = new Box((int)0); + Box x73 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x72, x73, (x68).get(), 0x14def9de); + Box x74 = new Box((int)0); + Box x75 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x74, x75, (x68).get(), 0xa2f79cd6); + Box x76 = new Box((int)0); + Box x77 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x76, x77, (x68).get(), 0x5812631a); + Box x78 = new Box((int)0); + Box x79 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x78, x79, (x68).get(), 0x5cf5d3ed); + Box x80 = new Box((int)0); + Box x81 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x80, x81, 0x0, (x79).get(), (x76).get()); + Box x82 = new Box((int)0); + Box x83 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x82, x83, (x81).get(), (x77).get(), (x74).get()); + Box x84 = new Box((int)0); + Box x85 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x84, x85, (x83).get(), (x75).get(), (x72).get()); + Box x86 = new Box((int)0); + Box x87 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x86, x87, 0x0, (x62).get(), (x78).get()); + Box x88 = new Box((int)0); + Box x89 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x88, x89, (x87).get(), (x64).get(), (x80).get()); + Box x90 = new Box((int)0); + Box x91 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x90, x91, (x89).get(), (x66).get(), (x82).get()); + Box x92 = new Box((int)0); + Box x93 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x92, x93, (x91).get(), ((x67).get() + ((x59).get() + ((x51).get() + (x39).get()))), (x84).get()); + Box x94 = new Box((int)0); + Box x95 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x94, x95, 0x0, ((x61).get() + (x37).get()), (x70).get()); + Box x96 = new Box((int)0); + Box x97 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x96, x97, 0x0, (x88).get(), (arg1[3])); + Box x98 = new Box((int)0); + Box x99 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x98, x99, (x97).get(), (x90).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x100 = new Box((int)0); + Box x101 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x100, x101, (x99).get(), (x92).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x102 = new Box((int)0); + Box x103 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x102, x103, (x96).get(), 0x12547e1b); + Box x104 = new Box((int)0); + Box x105 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x104, x105, (x102).get(), 0x10000000); + Box x106 = new Box((int)0); + Box x107 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x106, x107, (x102).get(), 0x14def9de); + Box x108 = new Box((int)0); + Box x109 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x108, x109, (x102).get(), 0xa2f79cd6); + Box x110 = new Box((int)0); + Box x111 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x110, x111, (x102).get(), 0x5812631a); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x112, x113, (x102).get(), 0x5cf5d3ed); + Box x114 = new Box((int)0); + Box x115 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x114, x115, 0x0, (x113).get(), (x110).get()); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x116, x117, (x115).get(), (x111).get(), (x108).get()); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x118, x119, (x117).get(), (x109).get(), (x106).get()); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x120, x121, 0x0, (x96).get(), (x112).get()); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x122, x123, (x121).get(), (x98).get(), (x114).get()); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x124, x125, (x123).get(), (x100).get(), (x116).get()); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x126, x127, (x125).get(), ((x101).get() + ((x93).get() + ((x85).get() + (x73).get()))), (x118).get()); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x128, x129, (x127).get(), (x4).get(), ((x119).get() + (x107).get())); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x130, x131, (x129).get(), (x60).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x132, x133, (x131).get(), (x94).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x134, x135, (x133).get(), ((x95).get() + (x71).get()), (x104).get()); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x136, x137, 0x0, (x122).get(), (arg1[4])); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x138, x139, (x137).get(), (x124).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x140, x141, (x139).get(), (x126).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x142, x143, (x141).get(), (x128).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x144, x145, (x143).get(), (x130).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x146, x147, (x145).get(), (x132).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x148, x149, (x147).get(), (x134).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x150, x151, (x136).get(), 0x12547e1b); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x152, x153, (x150).get(), 0x10000000); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x154, x155, (x150).get(), 0x14def9de); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x156, x157, (x150).get(), 0xa2f79cd6); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x158, x159, (x150).get(), 0x5812631a); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x160, x161, (x150).get(), 0x5cf5d3ed); + Box x162 = new Box((int)0); + Box x163 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x162, x163, 0x0, (x161).get(), (x158).get()); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x164, x165, (x163).get(), (x159).get(), (x156).get()); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x166, x167, (x165).get(), (x157).get(), (x154).get()); + Box x168 = new Box((int)0); + Box x169 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x168, x169, 0x0, (x136).get(), (x160).get()); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x170, x171, (x169).get(), (x138).get(), (x162).get()); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x172, x173, (x171).get(), (x140).get(), (x164).get()); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x174, x175, (x173).get(), (x142).get(), (x166).get()); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x176, x177, (x175).get(), (x144).get(), ((x167).get() + (x155).get())); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x178, x179, (x177).get(), (x146).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x180, x181, (x179).get(), (x148).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x182, x183, (x181).get(), ((x149).get() + ((x135).get() + (x105).get())), (x152).get()); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x184, x185, 0x0, (x170).get(), (arg1[5])); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x186, x187, (x185).get(), (x172).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x188, x189, (x187).get(), (x174).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x190, x191, (x189).get(), (x176).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x192, x193, (x191).get(), (x178).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x194, x195, (x193).get(), (x180).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x196, x197, (x195).get(), (x182).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x198, x199, (x184).get(), 0x12547e1b); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x200, x201, (x198).get(), 0x10000000); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x202, x203, (x198).get(), 0x14def9de); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x204, x205, (x198).get(), 0xa2f79cd6); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x206, x207, (x198).get(), 0x5812631a); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x208, x209, (x198).get(), 0x5cf5d3ed); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x210, x211, 0x0, (x209).get(), (x206).get()); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x212, x213, (x211).get(), (x207).get(), (x204).get()); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x214, x215, (x213).get(), (x205).get(), (x202).get()); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x216, x217, 0x0, (x184).get(), (x208).get()); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x218, x219, (x217).get(), (x186).get(), (x210).get()); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x220, x221, (x219).get(), (x188).get(), (x212).get()); + Box x222 = new Box((int)0); + Box x223 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x222, x223, (x221).get(), (x190).get(), (x214).get()); + Box x224 = new Box((int)0); + Box x225 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x224, x225, (x223).get(), (x192).get(), ((x215).get() + (x203).get())); + Box x226 = new Box((int)0); + Box x227 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x226, x227, (x225).get(), (x194).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x228 = new Box((int)0); + Box x229 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x228, x229, (x227).get(), (x196).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x230 = new Box((int)0); + Box x231 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x230, x231, (x229).get(), ((x197).get() + ((x183).get() + (x153).get())), (x200).get()); + Box x232 = new Box((int)0); + Box x233 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x232, x233, 0x0, (x218).get(), (arg1[6])); + Box x234 = new Box((int)0); + Box x235 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x234, x235, (x233).get(), (x220).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x236 = new Box((int)0); + Box x237 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x236, x237, (x235).get(), (x222).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x238 = new Box((int)0); + Box x239 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x238, x239, (x237).get(), (x224).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x240 = new Box((int)0); + Box x241 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x240, x241, (x239).get(), (x226).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x242 = new Box((int)0); + Box x243 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x242, x243, (x241).get(), (x228).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x244 = new Box((int)0); + Box x245 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x244, x245, (x243).get(), (x230).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x246, x247, (x232).get(), 0x12547e1b); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x248, x249, (x246).get(), 0x10000000); + Box x250 = new Box((int)0); + Box x251 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x250, x251, (x246).get(), 0x14def9de); + Box x252 = new Box((int)0); + Box x253 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x252, x253, (x246).get(), 0xa2f79cd6); + Box x254 = new Box((int)0); + Box x255 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x254, x255, (x246).get(), 0x5812631a); + Box x256 = new Box((int)0); + Box x257 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x256, x257, (x246).get(), 0x5cf5d3ed); + Box x258 = new Box((int)0); + Box x259 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x258, x259, 0x0, (x257).get(), (x254).get()); + Box x260 = new Box((int)0); + Box x261 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x260, x261, (x259).get(), (x255).get(), (x252).get()); + Box x262 = new Box((int)0); + Box x263 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x262, x263, (x261).get(), (x253).get(), (x250).get()); + Box x264 = new Box((int)0); + Box x265 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x264, x265, 0x0, (x232).get(), (x256).get()); + Box x266 = new Box((int)0); + Box x267 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x266, x267, (x265).get(), (x234).get(), (x258).get()); + Box x268 = new Box((int)0); + Box x269 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x268, x269, (x267).get(), (x236).get(), (x260).get()); + Box x270 = new Box((int)0); + Box x271 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x270, x271, (x269).get(), (x238).get(), (x262).get()); + Box x272 = new Box((int)0); + Box x273 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x272, x273, (x271).get(), (x240).get(), ((x263).get() + (x251).get())); + Box x274 = new Box((int)0); + Box x275 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x274, x275, (x273).get(), (x242).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x276, x277, (x275).get(), (x244).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x278, x279, (x277).get(), ((x245).get() + ((x231).get() + (x201).get())), (x248).get()); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x280, x281, 0x0, (x266).get(), (arg1[7])); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x282, x283, (x281).get(), (x268).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x284, x285, (x283).get(), (x270).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x286, x287, (x285).get(), (x272).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x288, x289, (x287).get(), (x274).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x290, x291, (x289).get(), (x276).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x292, x293, (x291).get(), (x278).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x294, x295, (x280).get(), 0x12547e1b); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x296, x297, (x294).get(), 0x10000000); + Box x298 = new Box((int)0); + Box x299 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x298, x299, (x294).get(), 0x14def9de); + Box x300 = new Box((int)0); + Box x301 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x300, x301, (x294).get(), 0xa2f79cd6); + Box x302 = new Box((int)0); + Box x303 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x302, x303, (x294).get(), 0x5812631a); + Box x304 = new Box((int)0); + Box x305 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x304, x305, (x294).get(), 0x5cf5d3ed); + Box x306 = new Box((int)0); + Box x307 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x306, x307, 0x0, (x305).get(), (x302).get()); + Box x308 = new Box((int)0); + Box x309 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x308, x309, (x307).get(), (x303).get(), (x300).get()); + Box x310 = new Box((int)0); + Box x311 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x310, x311, (x309).get(), (x301).get(), (x298).get()); + Box x312 = new Box((int)0); + Box x313 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x312, x313, 0x0, (x280).get(), (x304).get()); + Box x314 = new Box((int)0); + Box x315 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x314, x315, (x313).get(), (x282).get(), (x306).get()); + Box x316 = new Box((int)0); + Box x317 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x316, x317, (x315).get(), (x284).get(), (x308).get()); + Box x318 = new Box((int)0); + Box x319 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x318, x319, (x317).get(), (x286).get(), (x310).get()); + Box x320 = new Box((int)0); + Box x321 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x320, x321, (x319).get(), (x288).get(), ((x311).get() + (x299).get())); + Box x322 = new Box((int)0); + Box x323 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x322, x323, (x321).get(), (x290).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x324 = new Box((int)0); + Box x325 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x324, x325, (x323).get(), (x292).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x326, x327, (x325).get(), ((x293).get() + ((x279).get() + (x249).get())), (x296).get()); + int x328 = ((x327).get() + (x297).get()); + Box x329 = new Box((int)0); + Box x330 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x329, x330, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x314).get(), 0x5cf5d3ed); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x331, x332, (x330).get(), (x316).get(), 0x5812631a); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x333, x334, (x332).get(), (x318).get(), 0xa2f79cd6); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x335, x336, (x334).get(), (x320).get(), 0x14def9de); + Box x337 = new Box((int)0); + Box x338 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x337, x338, (x336).get(), (x322).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x339 = new Box((int)0); + Box x340 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x339, x340, (x338).get(), (x324).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x341 = new Box((int)0); + Box x342 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x341, x342, (x340).get(), (x326).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x343 = new Box((int)0); + Box x344 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x343, x344, (x342).get(), x328, 0x10000000); + Box x345 = new Box((int)0); + Box x346 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x345, x346, (x344).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x347 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x347, (x346).get(), (x329).get(), (x314).get()); + Box x348 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x348, (x346).get(), (x331).get(), (x316).get()); + Box x349 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x349, (x346).get(), (x333).get(), (x318).get()); + Box x350 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x350, (x346).get(), (x335).get(), (x320).get()); + Box x351 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x351, (x346).get(), (x337).get(), (x322).get()); + Box x352 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x352, (x346).get(), (x339).get(), (x324).get()); + Box x353 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x353, (x346).get(), (x341).get(), (x326).get()); + Box x354 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x354, (x346).get(), (x343).get(), x328); + out1[0] = (x347).get(); + out1[1] = (x348).get(); + out1[2] = (x349).get(); + out1[3] = (x350).get(); + out1[4] = (x351).get(); + out1[5] = (x352).get(); + out1[6] = (x353).get(); + out1[7] = (x354).get(); +} + +/** + * The function fiat_Curve25519Scalar_to_montgomery translates a field element into the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = eval arg1 mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Curve25519Scalar_to_montgomery(int[] out1, final int[] arg1) { + int x1 = (arg1[1]); + int x2 = (arg1[2]); + int x3 = (arg1[3]); + int x4 = (arg1[4]); + int x5 = (arg1[5]); + int x6 = (arg1[6]); + int x7 = (arg1[7]); + int x8 = (arg1[0]); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x9, x10, x8, 0x399411b); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x11, x12, x8, 0x7c309a3d); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x13, x14, x8, 0xceec73d2); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x15, x16, x8, 0x17f5be65); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x17, x18, x8, 0xd00e1ba7); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x19, x20, x8, 0x68859347); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x21, x22, x8, 0xa40611e3); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x23, x24, x8, 0x449c0f01); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x37, x38, (x36).get(), (x12).get(), (x9).get()); + Box x39 = new Box((int)0); + Box x40 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x39, x40, (x23).get(), 0x12547e1b); + Box x41 = new Box((int)0); + Box x42 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x41, x42, (x39).get(), 0x10000000); + Box x43 = new Box((int)0); + Box x44 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x43, x44, (x39).get(), 0x14def9de); + Box x45 = new Box((int)0); + Box x46 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x45, x46, (x39).get(), 0xa2f79cd6); + Box x47 = new Box((int)0); + Box x48 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x47, x48, (x39).get(), 0x5812631a); + Box x49 = new Box((int)0); + Box x50 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x49, x50, (x39).get(), 0x5cf5d3ed); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x51, x52, 0x0, (x50).get(), (x47).get()); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x53, x54, (x52).get(), (x48).get(), (x45).get()); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x55, x56, (x54).get(), (x46).get(), (x43).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x57, x58, 0x0, (x23).get(), (x49).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x59, x60, (x58).get(), (x25).get(), (x51).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x61, x62, (x60).get(), (x27).get(), (x53).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x63, x64, (x62).get(), (x29).get(), (x55).get()); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x65, x66, (x64).get(), (x31).get(), ((x56).get() + (x44).get())); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x67, x68, (x66).get(), (x33).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x69, x70, (x68).get(), (x35).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x71, x72, (x70).get(), (x37).get(), (x41).get()); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x73, x74, x1, 0x399411b); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x75, x76, x1, 0x7c309a3d); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x77, x78, x1, 0xceec73d2); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x79, x80, x1, 0x17f5be65); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x81, x82, x1, 0xd00e1ba7); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x83, x84, x1, 0x68859347); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x85, x86, x1, 0xa40611e3); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x87, x88, x1, 0x449c0f01); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x89, x90, 0x0, (x88).get(), (x85).get()); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x91, x92, (x90).get(), (x86).get(), (x83).get()); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x93, x94, (x92).get(), (x84).get(), (x81).get()); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x95, x96, (x94).get(), (x82).get(), (x79).get()); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x97, x98, (x96).get(), (x80).get(), (x77).get()); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x99, x100, (x98).get(), (x78).get(), (x75).get()); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x101, x102, (x100).get(), (x76).get(), (x73).get()); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x103, x104, 0x0, (x59).get(), (x87).get()); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x105, x106, (x104).get(), (x61).get(), (x89).get()); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x107, x108, (x106).get(), (x63).get(), (x91).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x109, x110, (x108).get(), (x65).get(), (x93).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x111, x112, (x110).get(), (x67).get(), (x95).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x113, x114, (x112).get(), (x69).get(), (x97).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x115, x116, (x114).get(), (x71).get(), (x99).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x117, x118, (x116).get(), (((x72).get() + ((x38).get() + (x10).get())) + (x42).get()), (x101).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x119, x120, (x103).get(), 0x12547e1b); + Box x121 = new Box((int)0); + Box x122 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x121, x122, (x119).get(), 0x10000000); + Box x123 = new Box((int)0); + Box x124 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x123, x124, (x119).get(), 0x14def9de); + Box x125 = new Box((int)0); + Box x126 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x125, x126, (x119).get(), 0xa2f79cd6); + Box x127 = new Box((int)0); + Box x128 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x127, x128, (x119).get(), 0x5812631a); + Box x129 = new Box((int)0); + Box x130 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x129, x130, (x119).get(), 0x5cf5d3ed); + Box x131 = new Box((int)0); + Box x132 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x131, x132, 0x0, (x130).get(), (x127).get()); + Box x133 = new Box((int)0); + Box x134 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x133, x134, (x132).get(), (x128).get(), (x125).get()); + Box x135 = new Box((int)0); + Box x136 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x135, x136, (x134).get(), (x126).get(), (x123).get()); + Box x137 = new Box((int)0); + Box x138 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x137, x138, 0x0, (x103).get(), (x129).get()); + Box x139 = new Box((int)0); + Box x140 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x139, x140, (x138).get(), (x105).get(), (x131).get()); + Box x141 = new Box((int)0); + Box x142 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x141, x142, (x140).get(), (x107).get(), (x133).get()); + Box x143 = new Box((int)0); + Box x144 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x143, x144, (x142).get(), (x109).get(), (x135).get()); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x145, x146, (x144).get(), (x111).get(), ((x136).get() + (x124).get())); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x147, x148, (x146).get(), (x113).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x149 = new Box((int)0); + Box x150 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x149, x150, (x148).get(), (x115).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x151 = new Box((int)0); + Box x152 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x151, x152, (x150).get(), (x117).get(), (x121).get()); + Box x153 = new Box((int)0); + Box x154 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x153, x154, x2, 0x399411b); + Box x155 = new Box((int)0); + Box x156 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x155, x156, x2, 0x7c309a3d); + Box x157 = new Box((int)0); + Box x158 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x157, x158, x2, 0xceec73d2); + Box x159 = new Box((int)0); + Box x160 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x159, x160, x2, 0x17f5be65); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x161, x162, x2, 0xd00e1ba7); + Box x163 = new Box((int)0); + Box x164 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x163, x164, x2, 0x68859347); + Box x165 = new Box((int)0); + Box x166 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x165, x166, x2, 0xa40611e3); + Box x167 = new Box((int)0); + Box x168 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x167, x168, x2, 0x449c0f01); + Box x169 = new Box((int)0); + Box x170 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x169, x170, 0x0, (x168).get(), (x165).get()); + Box x171 = new Box((int)0); + Box x172 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x171, x172, (x170).get(), (x166).get(), (x163).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x173, x174, (x172).get(), (x164).get(), (x161).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x175, x176, (x174).get(), (x162).get(), (x159).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x177, x178, (x176).get(), (x160).get(), (x157).get()); + Box x179 = new Box((int)0); + Box x180 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x179, x180, (x178).get(), (x158).get(), (x155).get()); + Box x181 = new Box((int)0); + Box x182 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x181, x182, (x180).get(), (x156).get(), (x153).get()); + Box x183 = new Box((int)0); + Box x184 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x183, x184, 0x0, (x139).get(), (x167).get()); + Box x185 = new Box((int)0); + Box x186 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x185, x186, (x184).get(), (x141).get(), (x169).get()); + Box x187 = new Box((int)0); + Box x188 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x187, x188, (x186).get(), (x143).get(), (x171).get()); + Box x189 = new Box((int)0); + Box x190 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x189, x190, (x188).get(), (x145).get(), (x173).get()); + Box x191 = new Box((int)0); + Box x192 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x191, x192, (x190).get(), (x147).get(), (x175).get()); + Box x193 = new Box((int)0); + Box x194 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x193, x194, (x192).get(), (x149).get(), (x177).get()); + Box x195 = new Box((int)0); + Box x196 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x195, x196, (x194).get(), (x151).get(), (x179).get()); + Box x197 = new Box((int)0); + Box x198 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x197, x198, (x196).get(), (((x152).get() + ((x118).get() + ((x102).get() + (x74).get()))) + (x122).get()), (x181).get()); + Box x199 = new Box((int)0); + Box x200 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x199, x200, (x183).get(), 0x12547e1b); + Box x201 = new Box((int)0); + Box x202 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x201, x202, (x199).get(), 0x10000000); + Box x203 = new Box((int)0); + Box x204 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x203, x204, (x199).get(), 0x14def9de); + Box x205 = new Box((int)0); + Box x206 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x205, x206, (x199).get(), 0xa2f79cd6); + Box x207 = new Box((int)0); + Box x208 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x207, x208, (x199).get(), 0x5812631a); + Box x209 = new Box((int)0); + Box x210 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x209, x210, (x199).get(), 0x5cf5d3ed); + Box x211 = new Box((int)0); + Box x212 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x211, x212, 0x0, (x210).get(), (x207).get()); + Box x213 = new Box((int)0); + Box x214 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x213, x214, (x212).get(), (x208).get(), (x205).get()); + Box x215 = new Box((int)0); + Box x216 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x215, x216, (x214).get(), (x206).get(), (x203).get()); + Box x217 = new Box((int)0); + Box x218 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x217, x218, 0x0, (x183).get(), (x209).get()); + Box x219 = new Box((int)0); + Box x220 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x219, x220, (x218).get(), (x185).get(), (x211).get()); + Box x221 = new Box((int)0); + Box x222 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x221, x222, (x220).get(), (x187).get(), (x213).get()); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x223, x224, (x222).get(), (x189).get(), (x215).get()); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x225, x226, (x224).get(), (x191).get(), ((x216).get() + (x204).get())); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x227, x228, (x226).get(), (x193).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x229, x230, (x228).get(), (x195).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x231, x232, (x230).get(), (x197).get(), (x201).get()); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x233, x234, x3, 0x399411b); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x235, x236, x3, 0x7c309a3d); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x237, x238, x3, 0xceec73d2); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x239, x240, x3, 0x17f5be65); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x241, x242, x3, 0xd00e1ba7); + Box x243 = new Box((int)0); + Box x244 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x243, x244, x3, 0x68859347); + Box x245 = new Box((int)0); + Box x246 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x245, x246, x3, 0xa40611e3); + Box x247 = new Box((int)0); + Box x248 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x247, x248, x3, 0x449c0f01); + Box x249 = new Box((int)0); + Box x250 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x249, x250, 0x0, (x248).get(), (x245).get()); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x251, x252, (x250).get(), (x246).get(), (x243).get()); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x253, x254, (x252).get(), (x244).get(), (x241).get()); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x255, x256, (x254).get(), (x242).get(), (x239).get()); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x257, x258, (x256).get(), (x240).get(), (x237).get()); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x259, x260, (x258).get(), (x238).get(), (x235).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x261, x262, (x260).get(), (x236).get(), (x233).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x263, x264, 0x0, (x219).get(), (x247).get()); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x265, x266, (x264).get(), (x221).get(), (x249).get()); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x267, x268, (x266).get(), (x223).get(), (x251).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x269, x270, (x268).get(), (x225).get(), (x253).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x271, x272, (x270).get(), (x227).get(), (x255).get()); + Box x273 = new Box((int)0); + Box x274 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x273, x274, (x272).get(), (x229).get(), (x257).get()); + Box x275 = new Box((int)0); + Box x276 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x275, x276, (x274).get(), (x231).get(), (x259).get()); + Box x277 = new Box((int)0); + Box x278 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x277, x278, (x276).get(), (((x232).get() + ((x198).get() + ((x182).get() + (x154).get()))) + (x202).get()), (x261).get()); + Box x279 = new Box((int)0); + Box x280 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x279, x280, (x263).get(), 0x12547e1b); + Box x281 = new Box((int)0); + Box x282 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x281, x282, (x279).get(), 0x10000000); + Box x283 = new Box((int)0); + Box x284 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x283, x284, (x279).get(), 0x14def9de); + Box x285 = new Box((int)0); + Box x286 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x285, x286, (x279).get(), 0xa2f79cd6); + Box x287 = new Box((int)0); + Box x288 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x287, x288, (x279).get(), 0x5812631a); + Box x289 = new Box((int)0); + Box x290 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x289, x290, (x279).get(), 0x5cf5d3ed); + Box x291 = new Box((int)0); + Box x292 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x291, x292, 0x0, (x290).get(), (x287).get()); + Box x293 = new Box((int)0); + Box x294 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x293, x294, (x292).get(), (x288).get(), (x285).get()); + Box x295 = new Box((int)0); + Box x296 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x295, x296, (x294).get(), (x286).get(), (x283).get()); + Box x297 = new Box((int)0); + Box x298 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x297, x298, 0x0, (x263).get(), (x289).get()); + Box x299 = new Box((int)0); + Box x300 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x299, x300, (x298).get(), (x265).get(), (x291).get()); + Box x301 = new Box((int)0); + Box x302 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x301, x302, (x300).get(), (x267).get(), (x293).get()); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x303, x304, (x302).get(), (x269).get(), (x295).get()); + Box x305 = new Box((int)0); + Box x306 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x305, x306, (x304).get(), (x271).get(), ((x296).get() + (x284).get())); + Box x307 = new Box((int)0); + Box x308 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x307, x308, (x306).get(), (x273).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x309 = new Box((int)0); + Box x310 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x309, x310, (x308).get(), (x275).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x311 = new Box((int)0); + Box x312 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x311, x312, (x310).get(), (x277).get(), (x281).get()); + Box x313 = new Box((int)0); + Box x314 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x313, x314, x4, 0x399411b); + Box x315 = new Box((int)0); + Box x316 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x315, x316, x4, 0x7c309a3d); + Box x317 = new Box((int)0); + Box x318 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x317, x318, x4, 0xceec73d2); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x319, x320, x4, 0x17f5be65); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x321, x322, x4, 0xd00e1ba7); + Box x323 = new Box((int)0); + Box x324 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x323, x324, x4, 0x68859347); + Box x325 = new Box((int)0); + Box x326 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x325, x326, x4, 0xa40611e3); + Box x327 = new Box((int)0); + Box x328 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x327, x328, x4, 0x449c0f01); + Box x329 = new Box((int)0); + Box x330 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x329, x330, 0x0, (x328).get(), (x325).get()); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x331, x332, (x330).get(), (x326).get(), (x323).get()); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x333, x334, (x332).get(), (x324).get(), (x321).get()); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x335, x336, (x334).get(), (x322).get(), (x319).get()); + Box x337 = new Box((int)0); + Box x338 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x337, x338, (x336).get(), (x320).get(), (x317).get()); + Box x339 = new Box((int)0); + Box x340 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x339, x340, (x338).get(), (x318).get(), (x315).get()); + Box x341 = new Box((int)0); + Box x342 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x341, x342, (x340).get(), (x316).get(), (x313).get()); + Box x343 = new Box((int)0); + Box x344 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x343, x344, 0x0, (x299).get(), (x327).get()); + Box x345 = new Box((int)0); + Box x346 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x345, x346, (x344).get(), (x301).get(), (x329).get()); + Box x347 = new Box((int)0); + Box x348 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x347, x348, (x346).get(), (x303).get(), (x331).get()); + Box x349 = new Box((int)0); + Box x350 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x349, x350, (x348).get(), (x305).get(), (x333).get()); + Box x351 = new Box((int)0); + Box x352 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x351, x352, (x350).get(), (x307).get(), (x335).get()); + Box x353 = new Box((int)0); + Box x354 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x353, x354, (x352).get(), (x309).get(), (x337).get()); + Box x355 = new Box((int)0); + Box x356 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x355, x356, (x354).get(), (x311).get(), (x339).get()); + Box x357 = new Box((int)0); + Box x358 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x357, x358, (x356).get(), (((x312).get() + ((x278).get() + ((x262).get() + (x234).get()))) + (x282).get()), (x341).get()); + Box x359 = new Box((int)0); + Box x360 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x359, x360, (x343).get(), 0x12547e1b); + Box x361 = new Box((int)0); + Box x362 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x361, x362, (x359).get(), 0x10000000); + Box x363 = new Box((int)0); + Box x364 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x363, x364, (x359).get(), 0x14def9de); + Box x365 = new Box((int)0); + Box x366 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x365, x366, (x359).get(), 0xa2f79cd6); + Box x367 = new Box((int)0); + Box x368 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x367, x368, (x359).get(), 0x5812631a); + Box x369 = new Box((int)0); + Box x370 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x369, x370, (x359).get(), 0x5cf5d3ed); + Box x371 = new Box((int)0); + Box x372 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x371, x372, 0x0, (x370).get(), (x367).get()); + Box x373 = new Box((int)0); + Box x374 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x373, x374, (x372).get(), (x368).get(), (x365).get()); + Box x375 = new Box((int)0); + Box x376 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x375, x376, (x374).get(), (x366).get(), (x363).get()); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x377, x378, 0x0, (x343).get(), (x369).get()); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x379, x380, (x378).get(), (x345).get(), (x371).get()); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x381, x382, (x380).get(), (x347).get(), (x373).get()); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x383, x384, (x382).get(), (x349).get(), (x375).get()); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x385, x386, (x384).get(), (x351).get(), ((x376).get() + (x364).get())); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x387, x388, (x386).get(), (x353).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x389, x390, (x388).get(), (x355).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x391, x392, (x390).get(), (x357).get(), (x361).get()); + Box x393 = new Box((int)0); + Box x394 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x393, x394, x5, 0x399411b); + Box x395 = new Box((int)0); + Box x396 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x395, x396, x5, 0x7c309a3d); + Box x397 = new Box((int)0); + Box x398 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x397, x398, x5, 0xceec73d2); + Box x399 = new Box((int)0); + Box x400 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x399, x400, x5, 0x17f5be65); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x401, x402, x5, 0xd00e1ba7); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x403, x404, x5, 0x68859347); + Box x405 = new Box((int)0); + Box x406 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x405, x406, x5, 0xa40611e3); + Box x407 = new Box((int)0); + Box x408 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x407, x408, x5, 0x449c0f01); + Box x409 = new Box((int)0); + Box x410 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x409, x410, 0x0, (x408).get(), (x405).get()); + Box x411 = new Box((int)0); + Box x412 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x411, x412, (x410).get(), (x406).get(), (x403).get()); + Box x413 = new Box((int)0); + Box x414 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x413, x414, (x412).get(), (x404).get(), (x401).get()); + Box x415 = new Box((int)0); + Box x416 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x415, x416, (x414).get(), (x402).get(), (x399).get()); + Box x417 = new Box((int)0); + Box x418 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x417, x418, (x416).get(), (x400).get(), (x397).get()); + Box x419 = new Box((int)0); + Box x420 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x419, x420, (x418).get(), (x398).get(), (x395).get()); + Box x421 = new Box((int)0); + Box x422 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x421, x422, (x420).get(), (x396).get(), (x393).get()); + Box x423 = new Box((int)0); + Box x424 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x423, x424, 0x0, (x379).get(), (x407).get()); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x425, x426, (x424).get(), (x381).get(), (x409).get()); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x427, x428, (x426).get(), (x383).get(), (x411).get()); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x429, x430, (x428).get(), (x385).get(), (x413).get()); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x431, x432, (x430).get(), (x387).get(), (x415).get()); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x433, x434, (x432).get(), (x389).get(), (x417).get()); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x435, x436, (x434).get(), (x391).get(), (x419).get()); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x437, x438, (x436).get(), (((x392).get() + ((x358).get() + ((x342).get() + (x314).get()))) + (x362).get()), (x421).get()); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x439, x440, (x423).get(), 0x12547e1b); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x441, x442, (x439).get(), 0x10000000); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x443, x444, (x439).get(), 0x14def9de); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x445, x446, (x439).get(), 0xa2f79cd6); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x447, x448, (x439).get(), 0x5812631a); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x449, x450, (x439).get(), 0x5cf5d3ed); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x451, x452, 0x0, (x450).get(), (x447).get()); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x453, x454, (x452).get(), (x448).get(), (x445).get()); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x455, x456, (x454).get(), (x446).get(), (x443).get()); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x457, x458, 0x0, (x423).get(), (x449).get()); + Box x459 = new Box((int)0); + Box x460 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x459, x460, (x458).get(), (x425).get(), (x451).get()); + Box x461 = new Box((int)0); + Box x462 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x461, x462, (x460).get(), (x427).get(), (x453).get()); + Box x463 = new Box((int)0); + Box x464 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x463, x464, (x462).get(), (x429).get(), (x455).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x465, x466, (x464).get(), (x431).get(), ((x456).get() + (x444).get())); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x467, x468, (x466).get(), (x433).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x469, x470, (x468).get(), (x435).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x471, x472, (x470).get(), (x437).get(), (x441).get()); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x473, x474, x6, 0x399411b); + Box x475 = new Box((int)0); + Box x476 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x475, x476, x6, 0x7c309a3d); + Box x477 = new Box((int)0); + Box x478 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x477, x478, x6, 0xceec73d2); + Box x479 = new Box((int)0); + Box x480 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x479, x480, x6, 0x17f5be65); + Box x481 = new Box((int)0); + Box x482 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x481, x482, x6, 0xd00e1ba7); + Box x483 = new Box((int)0); + Box x484 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x483, x484, x6, 0x68859347); + Box x485 = new Box((int)0); + Box x486 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x485, x486, x6, 0xa40611e3); + Box x487 = new Box((int)0); + Box x488 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x487, x488, x6, 0x449c0f01); + Box x489 = new Box((int)0); + Box x490 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x489, x490, 0x0, (x488).get(), (x485).get()); + Box x491 = new Box((int)0); + Box x492 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x491, x492, (x490).get(), (x486).get(), (x483).get()); + Box x493 = new Box((int)0); + Box x494 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x493, x494, (x492).get(), (x484).get(), (x481).get()); + Box x495 = new Box((int)0); + Box x496 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x495, x496, (x494).get(), (x482).get(), (x479).get()); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x497, x498, (x496).get(), (x480).get(), (x477).get()); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x499, x500, (x498).get(), (x478).get(), (x475).get()); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x501, x502, (x500).get(), (x476).get(), (x473).get()); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x503, x504, 0x0, (x459).get(), (x487).get()); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x505, x506, (x504).get(), (x461).get(), (x489).get()); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x507, x508, (x506).get(), (x463).get(), (x491).get()); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x509, x510, (x508).get(), (x465).get(), (x493).get()); + Box x511 = new Box((int)0); + Box x512 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x511, x512, (x510).get(), (x467).get(), (x495).get()); + Box x513 = new Box((int)0); + Box x514 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x513, x514, (x512).get(), (x469).get(), (x497).get()); + Box x515 = new Box((int)0); + Box x516 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x515, x516, (x514).get(), (x471).get(), (x499).get()); + Box x517 = new Box((int)0); + Box x518 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x517, x518, (x516).get(), (((x472).get() + ((x438).get() + ((x422).get() + (x394).get()))) + (x442).get()), (x501).get()); + Box x519 = new Box((int)0); + Box x520 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x519, x520, (x503).get(), 0x12547e1b); + Box x521 = new Box((int)0); + Box x522 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x521, x522, (x519).get(), 0x10000000); + Box x523 = new Box((int)0); + Box x524 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x523, x524, (x519).get(), 0x14def9de); + Box x525 = new Box((int)0); + Box x526 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x525, x526, (x519).get(), 0xa2f79cd6); + Box x527 = new Box((int)0); + Box x528 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x527, x528, (x519).get(), 0x5812631a); + Box x529 = new Box((int)0); + Box x530 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x529, x530, (x519).get(), 0x5cf5d3ed); + Box x531 = new Box((int)0); + Box x532 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x531, x532, 0x0, (x530).get(), (x527).get()); + Box x533 = new Box((int)0); + Box x534 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x533, x534, (x532).get(), (x528).get(), (x525).get()); + Box x535 = new Box((int)0); + Box x536 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x535, x536, (x534).get(), (x526).get(), (x523).get()); + Box x537 = new Box((int)0); + Box x538 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x537, x538, 0x0, (x503).get(), (x529).get()); + Box x539 = new Box((int)0); + Box x540 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x539, x540, (x538).get(), (x505).get(), (x531).get()); + Box x541 = new Box((int)0); + Box x542 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x541, x542, (x540).get(), (x507).get(), (x533).get()); + Box x543 = new Box((int)0); + Box x544 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x543, x544, (x542).get(), (x509).get(), (x535).get()); + Box x545 = new Box((int)0); + Box x546 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x545, x546, (x544).get(), (x511).get(), ((x536).get() + (x524).get())); + Box x547 = new Box((int)0); + Box x548 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x547, x548, (x546).get(), (x513).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x549 = new Box((int)0); + Box x550 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x549, x550, (x548).get(), (x515).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x551 = new Box((int)0); + Box x552 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x551, x552, (x550).get(), (x517).get(), (x521).get()); + Box x553 = new Box((int)0); + Box x554 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x553, x554, x7, 0x399411b); + Box x555 = new Box((int)0); + Box x556 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x555, x556, x7, 0x7c309a3d); + Box x557 = new Box((int)0); + Box x558 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x557, x558, x7, 0xceec73d2); + Box x559 = new Box((int)0); + Box x560 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x559, x560, x7, 0x17f5be65); + Box x561 = new Box((int)0); + Box x562 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x561, x562, x7, 0xd00e1ba7); + Box x563 = new Box((int)0); + Box x564 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x563, x564, x7, 0x68859347); + Box x565 = new Box((int)0); + Box x566 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x565, x566, x7, 0xa40611e3); + Box x567 = new Box((int)0); + Box x568 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x567, x568, x7, 0x449c0f01); + Box x569 = new Box((int)0); + Box x570 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x569, x570, 0x0, (x568).get(), (x565).get()); + Box x571 = new Box((int)0); + Box x572 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x571, x572, (x570).get(), (x566).get(), (x563).get()); + Box x573 = new Box((int)0); + Box x574 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x573, x574, (x572).get(), (x564).get(), (x561).get()); + Box x575 = new Box((int)0); + Box x576 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x575, x576, (x574).get(), (x562).get(), (x559).get()); + Box x577 = new Box((int)0); + Box x578 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x577, x578, (x576).get(), (x560).get(), (x557).get()); + Box x579 = new Box((int)0); + Box x580 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x579, x580, (x578).get(), (x558).get(), (x555).get()); + Box x581 = new Box((int)0); + Box x582 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x581, x582, (x580).get(), (x556).get(), (x553).get()); + Box x583 = new Box((int)0); + Box x584 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x583, x584, 0x0, (x539).get(), (x567).get()); + Box x585 = new Box((int)0); + Box x586 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x585, x586, (x584).get(), (x541).get(), (x569).get()); + Box x587 = new Box((int)0); + Box x588 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x587, x588, (x586).get(), (x543).get(), (x571).get()); + Box x589 = new Box((int)0); + Box x590 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x589, x590, (x588).get(), (x545).get(), (x573).get()); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x591, x592, (x590).get(), (x547).get(), (x575).get()); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x593, x594, (x592).get(), (x549).get(), (x577).get()); + Box x595 = new Box((int)0); + Box x596 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x595, x596, (x594).get(), (x551).get(), (x579).get()); + Box x597 = new Box((int)0); + Box x598 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x597, x598, (x596).get(), (((x552).get() + ((x518).get() + ((x502).get() + (x474).get()))) + (x522).get()), (x581).get()); + Box x599 = new Box((int)0); + Box x600 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x599, x600, (x583).get(), 0x12547e1b); + Box x601 = new Box((int)0); + Box x602 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x601, x602, (x599).get(), 0x10000000); + Box x603 = new Box((int)0); + Box x604 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x603, x604, (x599).get(), 0x14def9de); + Box x605 = new Box((int)0); + Box x606 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x605, x606, (x599).get(), 0xa2f79cd6); + Box x607 = new Box((int)0); + Box x608 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x607, x608, (x599).get(), 0x5812631a); + Box x609 = new Box((int)0); + Box x610 = new Box((int)0); + fiat_Curve25519Scalar_mulx_u32(x609, x610, (x599).get(), 0x5cf5d3ed); + Box x611 = new Box((int)0); + Box x612 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x611, x612, 0x0, (x610).get(), (x607).get()); + Box x613 = new Box((int)0); + Box x614 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x613, x614, (x612).get(), (x608).get(), (x605).get()); + Box x615 = new Box((int)0); + Box x616 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x615, x616, (x614).get(), (x606).get(), (x603).get()); + Box x617 = new Box((int)0); + Box x618 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x617, x618, 0x0, (x583).get(), (x609).get()); + Box x619 = new Box((int)0); + Box x620 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x619, x620, (x618).get(), (x585).get(), (x611).get()); + Box x621 = new Box((int)0); + Box x622 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x621, x622, (x620).get(), (x587).get(), (x613).get()); + Box x623 = new Box((int)0); + Box x624 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x623, x624, (x622).get(), (x589).get(), (x615).get()); + Box x625 = new Box((int)0); + Box x626 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x625, x626, (x624).get(), (x591).get(), ((x616).get() + (x604).get())); + Box x627 = new Box((int)0); + Box x628 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x627, x628, (x626).get(), (x593).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x629, x630, (x628).get(), (x595).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x631, x632, (x630).get(), (x597).get(), (x601).get()); + int x633 = (((x632).get() + ((x598).get() + ((x582).get() + (x554).get()))) + (x602).get()); + Box x634 = new Box((int)0); + Box x635 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x634, x635, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x619).get(), 0x5cf5d3ed); + Box x636 = new Box((int)0); + Box x637 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x636, x637, (x635).get(), (x621).get(), 0x5812631a); + Box x638 = new Box((int)0); + Box x639 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x638, x639, (x637).get(), (x623).get(), 0xa2f79cd6); + Box x640 = new Box((int)0); + Box x641 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x640, x641, (x639).get(), (x625).get(), 0x14def9de); + Box x642 = new Box((int)0); + Box x643 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x642, x643, (x641).get(), (x627).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x644 = new Box((int)0); + Box x645 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x644, x645, (x643).get(), (x629).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x646 = new Box((int)0); + Box x647 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x646, x647, (x645).get(), (x631).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x648 = new Box((int)0); + Box x649 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x648, x649, (x647).get(), x633, 0x10000000); + Box x650 = new Box((int)0); + Box x651 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x650, x651, (x649).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x652 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x652, (x651).get(), (x634).get(), (x619).get()); + Box x653 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x653, (x651).get(), (x636).get(), (x621).get()); + Box x654 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x654, (x651).get(), (x638).get(), (x623).get()); + Box x655 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x655, (x651).get(), (x640).get(), (x625).get()); + Box x656 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x656, (x651).get(), (x642).get(), (x627).get()); + Box x657 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x657, (x651).get(), (x644).get(), (x629).get()); + Box x658 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x658, (x651).get(), (x646).get(), (x631).get()); + Box x659 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x659, (x651).get(), (x648).get(), x633); + out1[0] = (x652).get(); + out1[1] = (x653).get(); + out1[2] = (x654).get(); + out1[3] = (x655).get(); + out1[4] = (x656).get(); + out1[5] = (x657).get(); + out1[6] = (x658).get(); + out1[7] = (x659).get(); +} + +/** + * The function fiat_Curve25519Scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ */ +public static void fiat_Curve25519Scalar_nonzero(Box out1, final int[] arg1) { + int x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | (arg1[7])))))))); + out1.set(x1); +} + +/** + * The function fiat_Curve25519Scalar_selectznz is a multi-limb conditional select.

+ *

+ * Postconditions:

+ * out1 = (if arg1 = 0 then arg2 else arg3)

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Curve25519Scalar_selectznz(int[] out1, int arg1, final int[] arg2, final int[] arg3) { + Box x1 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x1, arg1, (arg2[0]), (arg3[0])); + Box x2 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x2, arg1, (arg2[1]), (arg3[1])); + Box x3 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x3, arg1, (arg2[2]), (arg3[2])); + Box x4 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x4, arg1, (arg2[3]), (arg3[3])); + Box x5 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x5, arg1, (arg2[4]), (arg3[4])); + Box x6 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x6, arg1, (arg2[5]), (arg3[5])); + Box x7 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x7, arg1, (arg2[6]), (arg3[6])); + Box x8 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x8, arg1, (arg2[7]), (arg3[7])); + out1[0] = (x1).get(); + out1[1] = (x2).get(); + out1[2] = (x3).get(); + out1[3] = (x4).get(); + out1[4] = (x5).get(); + out1[5] = (x6).get(); + out1[6] = (x7).get(); + out1[7] = (x8).get(); +} + +/** + * The function fiat_Curve25519Scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31]

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0x1fffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]]

+ */ +public static void fiat_Curve25519Scalar_to_bytes(int[] out1, final int[] arg1) { + int x1 = (arg1[7]); + int x2 = (arg1[6]); + int x3 = (arg1[5]); + int x4 = (arg1[4]); + int x5 = (arg1[3]); + int x6 = (arg1[2]); + int x7 = (arg1[1]); + int x8 = (arg1[0]); + int x9 = (x8 & 0xff); + int x10 = (x8 >>> 8); + int x11 = (x10 & 0xff); + int x12 = (x10 >>> 8); + int x13 = (x12 & 0xff); + int x14 = (x12 >>> 8); + int x15 = (x7 & 0xff); + int x16 = (x7 >>> 8); + int x17 = (x16 & 0xff); + int x18 = (x16 >>> 8); + int x19 = (x18 & 0xff); + int x20 = (x18 >>> 8); + int x21 = (x6 & 0xff); + int x22 = (x6 >>> 8); + int x23 = (x22 & 0xff); + int x24 = (x22 >>> 8); + int x25 = (x24 & 0xff); + int x26 = (x24 >>> 8); + int x27 = (x5 & 0xff); + int x28 = (x5 >>> 8); + int x29 = (x28 & 0xff); + int x30 = (x28 >>> 8); + int x31 = (x30 & 0xff); + int x32 = (x30 >>> 8); + int x33 = (x4 & 0xff); + int x34 = (x4 >>> 8); + int x35 = (x34 & 0xff); + int x36 = (x34 >>> 8); + int x37 = (x36 & 0xff); + int x38 = (x36 >>> 8); + int x39 = (x3 & 0xff); + int x40 = (x3 >>> 8); + int x41 = (x40 & 0xff); + int x42 = (x40 >>> 8); + int x43 = (x42 & 0xff); + int x44 = (x42 >>> 8); + int x45 = (x2 & 0xff); + int x46 = (x2 >>> 8); + int x47 = (x46 & 0xff); + int x48 = (x46 >>> 8); + int x49 = (x48 & 0xff); + int x50 = (x48 >>> 8); + int x51 = (x1 & 0xff); + int x52 = (x1 >>> 8); + int x53 = (x52 & 0xff); + int x54 = (x52 >>> 8); + int x55 = (x54 & 0xff); + int x56 = (x54 >>> 8); + out1[0] = x9; + out1[1] = x11; + out1[2] = x13; + out1[3] = x14; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x26; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x38; + out1[20] = x39; + out1[21] = x41; + out1[22] = x43; + out1[23] = x44; + out1[24] = x45; + out1[25] = x47; + out1[26] = x49; + out1[27] = x50; + out1[28] = x51; + out1[29] = x53; + out1[30] = x55; + out1[31] = x56; +} + +/** + * The function fiat_Curve25519Scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order.

+ *

+ * Preconditions:

+ * 0 ≤ bytes_eval arg1 < m

+ * Postconditions:

+ * eval out1 mod m = bytes_eval arg1 mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0x1fffffff]]

+ */ +public static void fiat_Curve25519Scalar_from_bytes(int[] out1, final int[] arg1) { + int x1 = ((arg1[31]) << 24); + int x2 = ((arg1[30]) << 16); + int x3 = ((arg1[29]) << 8); + int x4 = (arg1[28]); + int x5 = ((arg1[27]) << 24); + int x6 = ((arg1[26]) << 16); + int x7 = ((arg1[25]) << 8); + int x8 = (arg1[24]); + int x9 = ((arg1[23]) << 24); + int x10 = ((arg1[22]) << 16); + int x11 = ((arg1[21]) << 8); + int x12 = (arg1[20]); + int x13 = ((arg1[19]) << 24); + int x14 = ((arg1[18]) << 16); + int x15 = ((arg1[17]) << 8); + int x16 = (arg1[16]); + int x17 = ((arg1[15]) << 24); + int x18 = ((arg1[14]) << 16); + int x19 = ((arg1[13]) << 8); + int x20 = (arg1[12]); + int x21 = ((arg1[11]) << 24); + int x22 = ((arg1[10]) << 16); + int x23 = ((arg1[9]) << 8); + int x24 = (arg1[8]); + int x25 = ((arg1[7]) << 24); + int x26 = ((arg1[6]) << 16); + int x27 = ((arg1[5]) << 8); + int x28 = (arg1[4]); + int x29 = ((arg1[3]) << 24); + int x30 = ((arg1[2]) << 16); + int x31 = ((arg1[1]) << 8); + int x32 = (arg1[0]); + int x33 = (x31 + x32); + int x34 = (x30 + x33); + int x35 = (x29 + x34); + int x36 = (x27 + x28); + int x37 = (x26 + x36); + int x38 = (x25 + x37); + int x39 = (x23 + x24); + int x40 = (x22 + x39); + int x41 = (x21 + x40); + int x42 = (x19 + x20); + int x43 = (x18 + x42); + int x44 = (x17 + x43); + int x45 = (x15 + x16); + int x46 = (x14 + x45); + int x47 = (x13 + x46); + int x48 = (x11 + x12); + int x49 = (x10 + x48); + int x50 = (x9 + x49); + int x51 = (x7 + x8); + int x52 = (x6 + x51); + int x53 = (x5 + x52); + int x54 = (x3 + x4); + int x55 = (x2 + x54); + int x56 = (x1 + x55); + out1[0] = x35; + out1[1] = x38; + out1[2] = x41; + out1[3] = x44; + out1[4] = x47; + out1[5] = x50; + out1[6] = x53; + out1[7] = x56; +} + +/** + * The function fiat_Curve25519Scalar_set_one returns the field element one in the Montgomery domain.

+ *

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = 1 mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Curve25519Scalar_set_one(int[] out1) { + out1[0] = 0x8d98951d; + out1[1] = 0xd6ec3174; + out1[2] = 0x737dcf70; + out1[3] = 0xc6ef5bf4; + out1[4] = 0xfffffffe; + out1[5] = 0xffffffff; + out1[6] = 0xffffffff; + out1[7] = 0xfffffff; +} + +/** + * The function fiat_Curve25519Scalar_msat returns the saturated representation of the prime modulus.

+ *

+ * Postconditions:

+ * twos_complement_eval out1 = m

+ * 0 ≤ eval out1 < m

+ *

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Curve25519Scalar_msat(int[] out1) { + out1[0] = 0x5cf5d3ed; + out1[1] = 0x5812631a; + out1[2] = 0xa2f79cd6; + out1[3] = 0x14def9de; + out1[4] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[5] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[6] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[7] = 0x10000000; + out1[8] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); +} + +/** + * The function fiat_Curve25519Scalar_divstep computes a divstep.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg4 < m

+ * 0 ≤ eval arg5 < m

+ * Postconditions:

+ * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1)

+ * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2)

+ * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋)

+ * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m)

+ * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m)

+ * 0 ≤ eval out5 < m

+ * 0 ≤ eval out5 < m

+ * 0 ≤ eval out2 < m

+ * 0 ≤ eval out3 < m

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0xffffffff]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Curve25519Scalar_divstep(Box out1, int[] out2, int[] out3, int[] out4, int[] out5, int arg1, final int[] arg2, final int[] arg3, final int[] arg4, final int[] arg5) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x1, x2, 0x0, (~arg1), 0x1); + int x3 = (((x1).get() >>> 31) & ((arg3[0]) & 0x1)); + Box x4 = new Box((int)0); + Box x5 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x4, x5, 0x0, (~arg1), 0x1); + Box x6 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x6, x3, arg1, (x4).get()); + Box x7 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x7, x3, (arg2[0]), (arg3[0])); + Box x8 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x8, x3, (arg2[1]), (arg3[1])); + Box x9 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x9, x3, (arg2[2]), (arg3[2])); + Box x10 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x10, x3, (arg2[3]), (arg3[3])); + Box x11 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x11, x3, (arg2[4]), (arg3[4])); + Box x12 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x12, x3, (arg2[5]), (arg3[5])); + Box x13 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x13, x3, (arg2[6]), (arg3[6])); + Box x14 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x14, x3, (arg2[7]), (arg3[7])); + Box x15 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x15, x3, (arg2[8]), (arg3[8])); + Box x16 = new Box((int)0); + Box x17 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x16, x17, 0x0, 0x1, (~(arg2[0]))); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x18, x19, (x17).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[1]))); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x20, x21, (x19).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[2]))); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x22, x23, (x21).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[3]))); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x24, x25, (x23).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[4]))); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x26, x27, (x25).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[5]))); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x28, x29, (x27).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[6]))); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x30, x31, (x29).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[7]))); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x32, x33, (x31).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[8]))); + Box x34 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x34, x3, (arg3[0]), (x16).get()); + Box x35 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x35, x3, (arg3[1]), (x18).get()); + Box x36 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x36, x3, (arg3[2]), (x20).get()); + Box x37 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x37, x3, (arg3[3]), (x22).get()); + Box x38 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x38, x3, (arg3[4]), (x24).get()); + Box x39 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x39, x3, (arg3[5]), (x26).get()); + Box x40 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x40, x3, (arg3[6]), (x28).get()); + Box x41 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x41, x3, (arg3[7]), (x30).get()); + Box x42 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x42, x3, (arg3[8]), (x32).get()); + Box x43 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x43, x3, (arg4[0]), (arg5[0])); + Box x44 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x44, x3, (arg4[1]), (arg5[1])); + Box x45 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x45, x3, (arg4[2]), (arg5[2])); + Box x46 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x46, x3, (arg4[3]), (arg5[3])); + Box x47 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x47, x3, (arg4[4]), (arg5[4])); + Box x48 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x48, x3, (arg4[5]), (arg5[5])); + Box x49 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x49, x3, (arg4[6]), (arg5[6])); + Box x50 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x50, x3, (arg4[7]), (arg5[7])); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x51, x52, 0x0, (x43).get(), (x43).get()); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x53, x54, (x52).get(), (x44).get(), (x44).get()); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x55, x56, (x54).get(), (x45).get(), (x45).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x57, x58, (x56).get(), (x46).get(), (x46).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x59, x60, (x58).get(), (x47).get(), (x47).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x61, x62, (x60).get(), (x48).get(), (x48).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x63, x64, (x62).get(), (x49).get(), (x49).get()); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x65, x66, (x64).get(), (x50).get(), (x50).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x67, x68, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x51).get(), 0x5cf5d3ed); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x69, x70, (x68).get(), (x53).get(), 0x5812631a); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x71, x72, (x70).get(), (x55).get(), 0xa2f79cd6); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x73, x74, (x72).get(), (x57).get(), 0x14def9de); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x75, x76, (x74).get(), (x59).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x77, x78, (x76).get(), (x61).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x79, x80, (x78).get(), (x63).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x81, x82, (x80).get(), (x65).get(), 0x10000000); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x83, x84, (x82).get(), (x66).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + int x85 = (arg4[7]); + int x86 = (arg4[6]); + int x87 = (arg4[5]); + int x88 = (arg4[4]); + int x89 = (arg4[3]); + int x90 = (arg4[2]); + int x91 = (arg4[1]); + int x92 = (arg4[0]); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x93, x94, 0x0, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x92); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x95, x96, (x94).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x91); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x97, x98, (x96).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x90); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x99, x100, (x98).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x89); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x101, x102, (x100).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x88); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x103, x104, (x102).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x87); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x105, x106, (x104).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x86); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x107, x108, (x106).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x85); + Box x109 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x109, (x108).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), 0xffffffff); + Box x110 = new Box((int)0); + Box x111 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x110, x111, 0x0, (x93).get(), ((x109).get() & 0x5cf5d3ed)); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x112, x113, (x111).get(), (x95).get(), ((x109).get() & 0x5812631a)); + Box x114 = new Box((int)0); + Box x115 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x114, x115, (x113).get(), (x97).get(), ((x109).get() & 0xa2f79cd6)); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x116, x117, (x115).get(), (x99).get(), ((x109).get() & 0x14def9de)); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x118, x119, (x117).get(), (x101).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x120, x121, (x119).get(), (x103).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x122, x123, (x121).get(), (x105).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x124, x125, (x123).get(), (x107).get(), ((x109).get() & 0x10000000)); + Box x126 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x126, x3, (arg5[0]), (x110).get()); + Box x127 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x127, x3, (arg5[1]), (x112).get()); + Box x128 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x128, x3, (arg5[2]), (x114).get()); + Box x129 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x129, x3, (arg5[3]), (x116).get()); + Box x130 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x130, x3, (arg5[4]), (x118).get()); + Box x131 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x131, x3, (arg5[5]), (x120).get()); + Box x132 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x132, x3, (arg5[6]), (x122).get()); + Box x133 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x133, x3, (arg5[7]), (x124).get()); + int x134 = ((x34).get() & 0x1); + Box x135 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x135, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x7).get()); + Box x136 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x136, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x8).get()); + Box x137 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x137, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x9).get()); + Box x138 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x138, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x10).get()); + Box x139 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x139, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x11).get()); + Box x140 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x140, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x12).get()); + Box x141 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x141, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x13).get()); + Box x142 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x142, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x14).get()); + Box x143 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x143, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x15).get()); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x144, x145, 0x0, (x34).get(), (x135).get()); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x146, x147, (x145).get(), (x35).get(), (x136).get()); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x148, x149, (x147).get(), (x36).get(), (x137).get()); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x150, x151, (x149).get(), (x37).get(), (x138).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x152, x153, (x151).get(), (x38).get(), (x139).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x154, x155, (x153).get(), (x39).get(), (x140).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x156, x157, (x155).get(), (x40).get(), (x141).get()); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x158, x159, (x157).get(), (x41).get(), (x142).get()); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x160, x161, (x159).get(), (x42).get(), (x143).get()); + Box x162 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x162, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x43).get()); + Box x163 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x163, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x44).get()); + Box x164 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x164, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x45).get()); + Box x165 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x165, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x46).get()); + Box x166 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x166, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x47).get()); + Box x167 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x167, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x48).get()); + Box x168 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x168, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x49).get()); + Box x169 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x169, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x50).get()); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x170, x171, 0x0, (x126).get(), (x162).get()); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x172, x173, (x171).get(), (x127).get(), (x163).get()); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x174, x175, (x173).get(), (x128).get(), (x164).get()); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x176, x177, (x175).get(), (x129).get(), (x165).get()); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x178, x179, (x177).get(), (x130).get(), (x166).get()); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x180, x181, (x179).get(), (x131).get(), (x167).get()); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x182, x183, (x181).get(), (x132).get(), (x168).get()); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x184, x185, (x183).get(), (x133).get(), (x169).get()); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x186, x187, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x170).get(), 0x5cf5d3ed); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x188, x189, (x187).get(), (x172).get(), 0x5812631a); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x190, x191, (x189).get(), (x174).get(), 0xa2f79cd6); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x192, x193, (x191).get(), (x176).get(), 0x14def9de); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x194, x195, (x193).get(), (x178).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x196, x197, (x195).get(), (x180).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x198, x199, (x197).get(), (x182).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x200, x201, (x199).get(), (x184).get(), 0x10000000); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Curve25519Scalar_subborrowx_u32(x202, x203, (x201).get(), (x185).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_Curve25519Scalar_addcarryx_u32(x204, x205, 0x0, (x6).get(), 0x1); + int x206 = (((x144).get() >>> 1) | (((x146).get() << 31) & 0xffffffff)); + int x207 = (((x146).get() >>> 1) | (((x148).get() << 31) & 0xffffffff)); + int x208 = (((x148).get() >>> 1) | (((x150).get() << 31) & 0xffffffff)); + int x209 = (((x150).get() >>> 1) | (((x152).get() << 31) & 0xffffffff)); + int x210 = (((x152).get() >>> 1) | (((x154).get() << 31) & 0xffffffff)); + int x211 = (((x154).get() >>> 1) | (((x156).get() << 31) & 0xffffffff)); + int x212 = (((x156).get() >>> 1) | (((x158).get() << 31) & 0xffffffff)); + int x213 = (((x158).get() >>> 1) | (((x160).get() << 31) & 0xffffffff)); + int x214 = (((x160).get() & 0x80000000) | ((x160).get() >>> 1)); + Box x215 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x215, (x84).get(), (x67).get(), (x51).get()); + Box x216 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x216, (x84).get(), (x69).get(), (x53).get()); + Box x217 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x217, (x84).get(), (x71).get(), (x55).get()); + Box x218 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x218, (x84).get(), (x73).get(), (x57).get()); + Box x219 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x219, (x84).get(), (x75).get(), (x59).get()); + Box x220 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x220, (x84).get(), (x77).get(), (x61).get()); + Box x221 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x221, (x84).get(), (x79).get(), (x63).get()); + Box x222 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x222, (x84).get(), (x81).get(), (x65).get()); + Box x223 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x223, (x203).get(), (x186).get(), (x170).get()); + Box x224 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x224, (x203).get(), (x188).get(), (x172).get()); + Box x225 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x225, (x203).get(), (x190).get(), (x174).get()); + Box x226 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x226, (x203).get(), (x192).get(), (x176).get()); + Box x227 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x227, (x203).get(), (x194).get(), (x178).get()); + Box x228 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x228, (x203).get(), (x196).get(), (x180).get()); + Box x229 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x229, (x203).get(), (x198).get(), (x182).get()); + Box x230 = new Box((int)0); + fiat_Curve25519Scalar_cmovznz_u32(x230, (x203).get(), (x200).get(), (x184).get()); + out1.set((x204).get()); + out2[0] = (x7).get(); + out2[1] = (x8).get(); + out2[2] = (x9).get(); + out2[3] = (x10).get(); + out2[4] = (x11).get(); + out2[5] = (x12).get(); + out2[6] = (x13).get(); + out2[7] = (x14).get(); + out2[8] = (x15).get(); + out3[0] = x206; + out3[1] = x207; + out3[2] = x208; + out3[3] = x209; + out3[4] = x210; + out3[5] = x211; + out3[6] = x212; + out3[7] = x213; + out3[8] = x214; + out4[0] = (x215).get(); + out4[1] = (x216).get(); + out4[2] = (x217).get(); + out4[3] = (x218).get(); + out4[4] = (x219).get(); + out4[5] = (x220).get(); + out4[6] = (x221).get(); + out4[7] = (x222).get(); + out5[0] = (x223).get(); + out5[1] = (x224).get(); + out5[2] = (x225).get(); + out5[3] = (x226).get(); + out5[4] = (x227).get(); + out5[5] = (x228).get(); + out5[6] = (x229).get(); + out5[7] = (x230).get(); +} + +/** + * The function fiat_Curve25519Scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form).

+ *

+ * Postconditions:

+ * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋)

+ * 0 ≤ eval out1 < m

+ *

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Curve25519Scalar_divstep_precomp(int[] out1) { + out1[0] = 0x36a7cb92; + out1[1] = 0xd70af844; + out1[2] = 0xb0b8b159; + out1[3] = 0x5f71c978; + out1[4] = 0x74947f1a; + out1[5] = 0xe76d8169; + out1[6] = 0xf193e4ff; + out1[7] = 0x19a2d36; +} + +} diff --git a/fiat-java/src/FiatP256Scalar.java b/fiat-java/src/FiatP256Scalar.java new file mode 100644 index 0000000000..961c5066f9 --- /dev/null +++ b/fiat-java/src/FiatP256Scalar.java @@ -0,0 +1,5359 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Java --cmovznz-by-mul --widen-carry --widen-bytes --internal-static --package-name fiat_crypto --class-case UpperCamelCase --no-field-element-typedefs P256Scalar 32 '2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: P256Scalar */ +/* machine_wordsize = 32 (from "32") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 (from "2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +package fiat_crypto; + +public final class FiatP256Scalar { + +static class Box { + private T value; + public Box(T value) { this.value = value; } + public void set(T value) { this.value = value; } + public T get() { return this.value; } +} + + + +/** + * The function fiat_P256Scalar_addcarryx_u32 is an addition with carry.

+ *

+ * Postconditions:

+ * out1 = (arg1 + arg2 + arg3) mod 2^32

+ * out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [0x0 ~> 0xffffffff]

+ * arg3: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [0x0 ~> 0x1]

+ */ +static void fiat_P256Scalar_addcarryx_u32(Box out1, Box out2, int arg1, int arg2, int arg3) { + long x1 = (((long) Integer.toUnsignedLong(((Number) (arg1)).intValue()) + (long) Integer.toUnsignedLong(((Number) (arg2)).intValue())) + (long) Integer.toUnsignedLong(((Number) (arg3)).intValue())); + int x2 = ((int) Integer.toUnsignedLong(((Number) (x1)).intValue()) & 0xffffffff); + int x3 = (int) Integer.toUnsignedLong(((Number) ((x1 >>> 32))).intValue()); + out1.set(x2); + out2.set(x3); +} + +/** + * The function fiat_P256Scalar_subborrowx_u32 is a subtraction with borrow.

+ *

+ * Postconditions:

+ * out1 = (-arg1 + arg2 + -arg3) mod 2^32

+ * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [0x0 ~> 0xffffffff]

+ * arg3: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [0x0 ~> 0x1]

+ */ +static void fiat_P256Scalar_subborrowx_u32(Box out1, Box out2, int arg1, int arg2, int arg3) { + long x1 = (((long) Integer.toUnsignedLong(((Number) (arg2)).intValue()) - (long) Integer.toUnsignedLong(((Number) (arg1)).intValue())) - (long) Integer.toUnsignedLong(((Number) (arg3)).intValue())); + int x2 = (int) Integer.toUnsignedLong(((Number) ((x1 >>> 32))).intValue()); + int x3 = ((int) Integer.toUnsignedLong(((Number) (x1)).intValue()) & 0xffffffff); + out1.set(x3); + out2.set(((int) Integer.toUnsignedLong(((Number) (0x0)).intValue()) - (int) Integer.toUnsignedLong(((Number) (x2)).intValue()))); +} + +/** + * The function fiat_P256Scalar_mulx_u32 is a multiplication, returning the full double-width result.

+ *

+ * Postconditions:

+ * out1 = (arg1 * arg2) mod 2^32

+ * out2 = ⌊arg1 * arg2 / 2^32⌋

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0xffffffff]

+ * arg2: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [0x0 ~> 0xffffffff]

+ */ +static void fiat_P256Scalar_mulx_u32(Box out1, Box out2, int arg1, int arg2) { + long x1 = ((long) Integer.toUnsignedLong(((Number) (arg1)).intValue()) * (long) Integer.toUnsignedLong(((Number) (arg2)).intValue())); + int x2 = ((int) Integer.toUnsignedLong(((Number) (x1)).intValue()) & 0xffffffff); + int x3 = (int) Integer.toUnsignedLong(((Number) ((x1 >>> 32))).intValue()); + out1.set(x2); + out2.set(x3); +} + +/** + * The function fiat_P256Scalar_cmovznz_u32 is a single-word conditional move.

+ *

+ * Postconditions:

+ * out1 = (if arg1 = 0 then arg2 else arg3)

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [0x0 ~> 0xffffffff]

+ * arg3: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ */ +static void fiat_P256Scalar_cmovznz_u32(Box out1, int arg1, int arg2, int arg3) { + int x1 = (arg1 * 0xffffffff); + int x2 = ((x1 & arg3) | ((~x1) & arg2)); + out1.set(x2); +} + +/** + * The function fiat_P256Scalar_mul multiplies two field elements in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * 0 ≤ eval arg2 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_mul(int[] out1, final int[] arg1, final int[] arg2) { + int x1 = (arg1[1]); + int x2 = (arg1[2]); + int x3 = (arg1[3]); + int x4 = (arg1[4]); + int x5 = (arg1[5]); + int x6 = (arg1[6]); + int x7 = (arg1[7]); + int x8 = (arg1[0]); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x9, x10, x8, (arg2[7])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x11, x12, x8, (arg2[6])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x13, x14, x8, (arg2[5])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x15, x16, x8, (arg2[4])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x17, x18, x8, (arg2[3])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x19, x20, x8, (arg2[2])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x21, x22, x8, (arg2[1])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x23, x24, x8, (arg2[0])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x37, x38, (x36).get(), (x12).get(), (x9).get()); + int x39 = ((x38).get() + (x10).get()); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x40, x41, (x23).get(), 0xee00bc4f); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x42, x43, (x40).get(), 0xffffffff); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x44, x45, (x40).get(), 0xffffffff); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x46, x47, (x40).get(), 0xffffffff); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x48, x49, (x40).get(), 0xbce6faad); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x50, x51, (x40).get(), 0xa7179e84); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x52, x53, (x40).get(), 0xf3b9cac2); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x54, x55, (x40).get(), 0xfc632551); + Box x56 = new Box((int)0); + Box x57 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x56, x57, 0x0, (x55).get(), (x52).get()); + Box x58 = new Box((int)0); + Box x59 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x58, x59, (x57).get(), (x53).get(), (x50).get()); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x60, x61, (x59).get(), (x51).get(), (x48).get()); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x62, x63, (x61).get(), (x49).get(), (x46).get()); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x64, x65, (x63).get(), (x47).get(), (x44).get()); + int x66 = ((x65).get() + (x45).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x67, x68, 0x0, (x23).get(), (x54).get()); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x69, x70, (x68).get(), (x25).get(), (x56).get()); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x71, x72, (x70).get(), (x27).get(), (x58).get()); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x73, x74, (x72).get(), (x29).get(), (x60).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x75, x76, (x74).get(), (x31).get(), (x62).get()); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x77, x78, (x76).get(), (x33).get(), (x64).get()); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x79, x80, (x78).get(), (x35).get(), x66); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x81, x82, (x80).get(), (x37).get(), (x42).get()); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x83, x84, (x82).get(), x39, (x43).get()); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x85, x86, x1, (arg2[7])); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x87, x88, x1, (arg2[6])); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x89, x90, x1, (arg2[5])); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x91, x92, x1, (arg2[4])); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x93, x94, x1, (arg2[3])); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x95, x96, x1, (arg2[2])); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x97, x98, x1, (arg2[1])); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x99, x100, x1, (arg2[0])); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x101, x102, 0x0, (x100).get(), (x97).get()); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x103, x104, (x102).get(), (x98).get(), (x95).get()); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x105, x106, (x104).get(), (x96).get(), (x93).get()); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x107, x108, (x106).get(), (x94).get(), (x91).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x109, x110, (x108).get(), (x92).get(), (x89).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x111, x112, (x110).get(), (x90).get(), (x87).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x113, x114, (x112).get(), (x88).get(), (x85).get()); + int x115 = ((x114).get() + (x86).get()); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x116, x117, 0x0, (x69).get(), (x99).get()); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x118, x119, (x117).get(), (x71).get(), (x101).get()); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x120, x121, (x119).get(), (x73).get(), (x103).get()); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x122, x123, (x121).get(), (x75).get(), (x105).get()); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x124, x125, (x123).get(), (x77).get(), (x107).get()); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x126, x127, (x125).get(), (x79).get(), (x109).get()); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x128, x129, (x127).get(), (x81).get(), (x111).get()); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x130, x131, (x129).get(), (x83).get(), (x113).get()); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x132, x133, (x131).get(), (x84).get(), x115); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x134, x135, (x116).get(), 0xee00bc4f); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x136, x137, (x134).get(), 0xffffffff); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x138, x139, (x134).get(), 0xffffffff); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x140, x141, (x134).get(), 0xffffffff); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x142, x143, (x134).get(), 0xbce6faad); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x144, x145, (x134).get(), 0xa7179e84); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x146, x147, (x134).get(), 0xf3b9cac2); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x148, x149, (x134).get(), 0xfc632551); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x150, x151, 0x0, (x149).get(), (x146).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x152, x153, (x151).get(), (x147).get(), (x144).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x154, x155, (x153).get(), (x145).get(), (x142).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x156, x157, (x155).get(), (x143).get(), (x140).get()); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x158, x159, (x157).get(), (x141).get(), (x138).get()); + int x160 = ((x159).get() + (x139).get()); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x161, x162, 0x0, (x116).get(), (x148).get()); + Box x163 = new Box((int)0); + Box x164 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x163, x164, (x162).get(), (x118).get(), (x150).get()); + Box x165 = new Box((int)0); + Box x166 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x165, x166, (x164).get(), (x120).get(), (x152).get()); + Box x167 = new Box((int)0); + Box x168 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x167, x168, (x166).get(), (x122).get(), (x154).get()); + Box x169 = new Box((int)0); + Box x170 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x169, x170, (x168).get(), (x124).get(), (x156).get()); + Box x171 = new Box((int)0); + Box x172 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x171, x172, (x170).get(), (x126).get(), (x158).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x173, x174, (x172).get(), (x128).get(), x160); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x175, x176, (x174).get(), (x130).get(), (x136).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x177, x178, (x176).get(), (x132).get(), (x137).get()); + int x179 = ((x178).get() + (x133).get()); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x180, x181, x2, (arg2[7])); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x182, x183, x2, (arg2[6])); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x184, x185, x2, (arg2[5])); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x186, x187, x2, (arg2[4])); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x188, x189, x2, (arg2[3])); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x190, x191, x2, (arg2[2])); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x192, x193, x2, (arg2[1])); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x194, x195, x2, (arg2[0])); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x196, x197, 0x0, (x195).get(), (x192).get()); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x198, x199, (x197).get(), (x193).get(), (x190).get()); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x200, x201, (x199).get(), (x191).get(), (x188).get()); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x202, x203, (x201).get(), (x189).get(), (x186).get()); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x204, x205, (x203).get(), (x187).get(), (x184).get()); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x206, x207, (x205).get(), (x185).get(), (x182).get()); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x208, x209, (x207).get(), (x183).get(), (x180).get()); + int x210 = ((x209).get() + (x181).get()); + Box x211 = new Box((int)0); + Box x212 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x211, x212, 0x0, (x163).get(), (x194).get()); + Box x213 = new Box((int)0); + Box x214 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x213, x214, (x212).get(), (x165).get(), (x196).get()); + Box x215 = new Box((int)0); + Box x216 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x215, x216, (x214).get(), (x167).get(), (x198).get()); + Box x217 = new Box((int)0); + Box x218 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x217, x218, (x216).get(), (x169).get(), (x200).get()); + Box x219 = new Box((int)0); + Box x220 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x219, x220, (x218).get(), (x171).get(), (x202).get()); + Box x221 = new Box((int)0); + Box x222 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x221, x222, (x220).get(), (x173).get(), (x204).get()); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x223, x224, (x222).get(), (x175).get(), (x206).get()); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x225, x226, (x224).get(), (x177).get(), (x208).get()); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x227, x228, (x226).get(), x179, x210); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x229, x230, (x211).get(), 0xee00bc4f); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x231, x232, (x229).get(), 0xffffffff); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x233, x234, (x229).get(), 0xffffffff); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x235, x236, (x229).get(), 0xffffffff); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x237, x238, (x229).get(), 0xbce6faad); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x239, x240, (x229).get(), 0xa7179e84); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x241, x242, (x229).get(), 0xf3b9cac2); + Box x243 = new Box((int)0); + Box x244 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x243, x244, (x229).get(), 0xfc632551); + Box x245 = new Box((int)0); + Box x246 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x245, x246, 0x0, (x244).get(), (x241).get()); + Box x247 = new Box((int)0); + Box x248 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x247, x248, (x246).get(), (x242).get(), (x239).get()); + Box x249 = new Box((int)0); + Box x250 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x249, x250, (x248).get(), (x240).get(), (x237).get()); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x251, x252, (x250).get(), (x238).get(), (x235).get()); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x253, x254, (x252).get(), (x236).get(), (x233).get()); + int x255 = ((x254).get() + (x234).get()); + Box x256 = new Box((int)0); + Box x257 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x256, x257, 0x0, (x211).get(), (x243).get()); + Box x258 = new Box((int)0); + Box x259 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x258, x259, (x257).get(), (x213).get(), (x245).get()); + Box x260 = new Box((int)0); + Box x261 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x260, x261, (x259).get(), (x215).get(), (x247).get()); + Box x262 = new Box((int)0); + Box x263 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x262, x263, (x261).get(), (x217).get(), (x249).get()); + Box x264 = new Box((int)0); + Box x265 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x264, x265, (x263).get(), (x219).get(), (x251).get()); + Box x266 = new Box((int)0); + Box x267 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x266, x267, (x265).get(), (x221).get(), (x253).get()); + Box x268 = new Box((int)0); + Box x269 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x268, x269, (x267).get(), (x223).get(), x255); + Box x270 = new Box((int)0); + Box x271 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x270, x271, (x269).get(), (x225).get(), (x231).get()); + Box x272 = new Box((int)0); + Box x273 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x272, x273, (x271).get(), (x227).get(), (x232).get()); + int x274 = ((x273).get() + (x228).get()); + Box x275 = new Box((int)0); + Box x276 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x275, x276, x3, (arg2[7])); + Box x277 = new Box((int)0); + Box x278 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x277, x278, x3, (arg2[6])); + Box x279 = new Box((int)0); + Box x280 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x279, x280, x3, (arg2[5])); + Box x281 = new Box((int)0); + Box x282 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x281, x282, x3, (arg2[4])); + Box x283 = new Box((int)0); + Box x284 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x283, x284, x3, (arg2[3])); + Box x285 = new Box((int)0); + Box x286 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x285, x286, x3, (arg2[2])); + Box x287 = new Box((int)0); + Box x288 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x287, x288, x3, (arg2[1])); + Box x289 = new Box((int)0); + Box x290 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x289, x290, x3, (arg2[0])); + Box x291 = new Box((int)0); + Box x292 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x291, x292, 0x0, (x290).get(), (x287).get()); + Box x293 = new Box((int)0); + Box x294 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x293, x294, (x292).get(), (x288).get(), (x285).get()); + Box x295 = new Box((int)0); + Box x296 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x295, x296, (x294).get(), (x286).get(), (x283).get()); + Box x297 = new Box((int)0); + Box x298 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x297, x298, (x296).get(), (x284).get(), (x281).get()); + Box x299 = new Box((int)0); + Box x300 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x299, x300, (x298).get(), (x282).get(), (x279).get()); + Box x301 = new Box((int)0); + Box x302 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x301, x302, (x300).get(), (x280).get(), (x277).get()); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x303, x304, (x302).get(), (x278).get(), (x275).get()); + int x305 = ((x304).get() + (x276).get()); + Box x306 = new Box((int)0); + Box x307 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x306, x307, 0x0, (x258).get(), (x289).get()); + Box x308 = new Box((int)0); + Box x309 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x308, x309, (x307).get(), (x260).get(), (x291).get()); + Box x310 = new Box((int)0); + Box x311 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x310, x311, (x309).get(), (x262).get(), (x293).get()); + Box x312 = new Box((int)0); + Box x313 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x312, x313, (x311).get(), (x264).get(), (x295).get()); + Box x314 = new Box((int)0); + Box x315 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x314, x315, (x313).get(), (x266).get(), (x297).get()); + Box x316 = new Box((int)0); + Box x317 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x316, x317, (x315).get(), (x268).get(), (x299).get()); + Box x318 = new Box((int)0); + Box x319 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x318, x319, (x317).get(), (x270).get(), (x301).get()); + Box x320 = new Box((int)0); + Box x321 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x320, x321, (x319).get(), (x272).get(), (x303).get()); + Box x322 = new Box((int)0); + Box x323 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x322, x323, (x321).get(), x274, x305); + Box x324 = new Box((int)0); + Box x325 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x324, x325, (x306).get(), 0xee00bc4f); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x326, x327, (x324).get(), 0xffffffff); + Box x328 = new Box((int)0); + Box x329 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x328, x329, (x324).get(), 0xffffffff); + Box x330 = new Box((int)0); + Box x331 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x330, x331, (x324).get(), 0xffffffff); + Box x332 = new Box((int)0); + Box x333 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x332, x333, (x324).get(), 0xbce6faad); + Box x334 = new Box((int)0); + Box x335 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x334, x335, (x324).get(), 0xa7179e84); + Box x336 = new Box((int)0); + Box x337 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x336, x337, (x324).get(), 0xf3b9cac2); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x338, x339, (x324).get(), 0xfc632551); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x340, x341, 0x0, (x339).get(), (x336).get()); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x342, x343, (x341).get(), (x337).get(), (x334).get()); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x344, x345, (x343).get(), (x335).get(), (x332).get()); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x346, x347, (x345).get(), (x333).get(), (x330).get()); + Box x348 = new Box((int)0); + Box x349 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x348, x349, (x347).get(), (x331).get(), (x328).get()); + int x350 = ((x349).get() + (x329).get()); + Box x351 = new Box((int)0); + Box x352 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x351, x352, 0x0, (x306).get(), (x338).get()); + Box x353 = new Box((int)0); + Box x354 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x353, x354, (x352).get(), (x308).get(), (x340).get()); + Box x355 = new Box((int)0); + Box x356 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x355, x356, (x354).get(), (x310).get(), (x342).get()); + Box x357 = new Box((int)0); + Box x358 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x357, x358, (x356).get(), (x312).get(), (x344).get()); + Box x359 = new Box((int)0); + Box x360 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x359, x360, (x358).get(), (x314).get(), (x346).get()); + Box x361 = new Box((int)0); + Box x362 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x361, x362, (x360).get(), (x316).get(), (x348).get()); + Box x363 = new Box((int)0); + Box x364 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x363, x364, (x362).get(), (x318).get(), x350); + Box x365 = new Box((int)0); + Box x366 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x365, x366, (x364).get(), (x320).get(), (x326).get()); + Box x367 = new Box((int)0); + Box x368 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x367, x368, (x366).get(), (x322).get(), (x327).get()); + int x369 = ((x368).get() + (x323).get()); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x370, x371, x4, (arg2[7])); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x372, x373, x4, (arg2[6])); + Box x374 = new Box((int)0); + Box x375 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x374, x375, x4, (arg2[5])); + Box x376 = new Box((int)0); + Box x377 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x376, x377, x4, (arg2[4])); + Box x378 = new Box((int)0); + Box x379 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x378, x379, x4, (arg2[3])); + Box x380 = new Box((int)0); + Box x381 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x380, x381, x4, (arg2[2])); + Box x382 = new Box((int)0); + Box x383 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x382, x383, x4, (arg2[1])); + Box x384 = new Box((int)0); + Box x385 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x384, x385, x4, (arg2[0])); + Box x386 = new Box((int)0); + Box x387 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x386, x387, 0x0, (x385).get(), (x382).get()); + Box x388 = new Box((int)0); + Box x389 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x388, x389, (x387).get(), (x383).get(), (x380).get()); + Box x390 = new Box((int)0); + Box x391 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x390, x391, (x389).get(), (x381).get(), (x378).get()); + Box x392 = new Box((int)0); + Box x393 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x392, x393, (x391).get(), (x379).get(), (x376).get()); + Box x394 = new Box((int)0); + Box x395 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x394, x395, (x393).get(), (x377).get(), (x374).get()); + Box x396 = new Box((int)0); + Box x397 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x396, x397, (x395).get(), (x375).get(), (x372).get()); + Box x398 = new Box((int)0); + Box x399 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x398, x399, (x397).get(), (x373).get(), (x370).get()); + int x400 = ((x399).get() + (x371).get()); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x401, x402, 0x0, (x353).get(), (x384).get()); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x403, x404, (x402).get(), (x355).get(), (x386).get()); + Box x405 = new Box((int)0); + Box x406 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x405, x406, (x404).get(), (x357).get(), (x388).get()); + Box x407 = new Box((int)0); + Box x408 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x407, x408, (x406).get(), (x359).get(), (x390).get()); + Box x409 = new Box((int)0); + Box x410 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x409, x410, (x408).get(), (x361).get(), (x392).get()); + Box x411 = new Box((int)0); + Box x412 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x411, x412, (x410).get(), (x363).get(), (x394).get()); + Box x413 = new Box((int)0); + Box x414 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x413, x414, (x412).get(), (x365).get(), (x396).get()); + Box x415 = new Box((int)0); + Box x416 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x415, x416, (x414).get(), (x367).get(), (x398).get()); + Box x417 = new Box((int)0); + Box x418 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x417, x418, (x416).get(), x369, x400); + Box x419 = new Box((int)0); + Box x420 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x419, x420, (x401).get(), 0xee00bc4f); + Box x421 = new Box((int)0); + Box x422 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x421, x422, (x419).get(), 0xffffffff); + Box x423 = new Box((int)0); + Box x424 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x423, x424, (x419).get(), 0xffffffff); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x425, x426, (x419).get(), 0xffffffff); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x427, x428, (x419).get(), 0xbce6faad); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x429, x430, (x419).get(), 0xa7179e84); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x431, x432, (x419).get(), 0xf3b9cac2); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x433, x434, (x419).get(), 0xfc632551); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x435, x436, 0x0, (x434).get(), (x431).get()); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x437, x438, (x436).get(), (x432).get(), (x429).get()); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x439, x440, (x438).get(), (x430).get(), (x427).get()); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x441, x442, (x440).get(), (x428).get(), (x425).get()); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x443, x444, (x442).get(), (x426).get(), (x423).get()); + int x445 = ((x444).get() + (x424).get()); + Box x446 = new Box((int)0); + Box x447 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x446, x447, 0x0, (x401).get(), (x433).get()); + Box x448 = new Box((int)0); + Box x449 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x448, x449, (x447).get(), (x403).get(), (x435).get()); + Box x450 = new Box((int)0); + Box x451 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x450, x451, (x449).get(), (x405).get(), (x437).get()); + Box x452 = new Box((int)0); + Box x453 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x452, x453, (x451).get(), (x407).get(), (x439).get()); + Box x454 = new Box((int)0); + Box x455 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x454, x455, (x453).get(), (x409).get(), (x441).get()); + Box x456 = new Box((int)0); + Box x457 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x456, x457, (x455).get(), (x411).get(), (x443).get()); + Box x458 = new Box((int)0); + Box x459 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x458, x459, (x457).get(), (x413).get(), x445); + Box x460 = new Box((int)0); + Box x461 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x460, x461, (x459).get(), (x415).get(), (x421).get()); + Box x462 = new Box((int)0); + Box x463 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x462, x463, (x461).get(), (x417).get(), (x422).get()); + int x464 = ((x463).get() + (x418).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x465, x466, x5, (arg2[7])); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x467, x468, x5, (arg2[6])); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x469, x470, x5, (arg2[5])); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x471, x472, x5, (arg2[4])); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x473, x474, x5, (arg2[3])); + Box x475 = new Box((int)0); + Box x476 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x475, x476, x5, (arg2[2])); + Box x477 = new Box((int)0); + Box x478 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x477, x478, x5, (arg2[1])); + Box x479 = new Box((int)0); + Box x480 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x479, x480, x5, (arg2[0])); + Box x481 = new Box((int)0); + Box x482 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x481, x482, 0x0, (x480).get(), (x477).get()); + Box x483 = new Box((int)0); + Box x484 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x483, x484, (x482).get(), (x478).get(), (x475).get()); + Box x485 = new Box((int)0); + Box x486 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x485, x486, (x484).get(), (x476).get(), (x473).get()); + Box x487 = new Box((int)0); + Box x488 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x487, x488, (x486).get(), (x474).get(), (x471).get()); + Box x489 = new Box((int)0); + Box x490 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x489, x490, (x488).get(), (x472).get(), (x469).get()); + Box x491 = new Box((int)0); + Box x492 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x491, x492, (x490).get(), (x470).get(), (x467).get()); + Box x493 = new Box((int)0); + Box x494 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x493, x494, (x492).get(), (x468).get(), (x465).get()); + int x495 = ((x494).get() + (x466).get()); + Box x496 = new Box((int)0); + Box x497 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x496, x497, 0x0, (x448).get(), (x479).get()); + Box x498 = new Box((int)0); + Box x499 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x498, x499, (x497).get(), (x450).get(), (x481).get()); + Box x500 = new Box((int)0); + Box x501 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x500, x501, (x499).get(), (x452).get(), (x483).get()); + Box x502 = new Box((int)0); + Box x503 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x502, x503, (x501).get(), (x454).get(), (x485).get()); + Box x504 = new Box((int)0); + Box x505 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x504, x505, (x503).get(), (x456).get(), (x487).get()); + Box x506 = new Box((int)0); + Box x507 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x506, x507, (x505).get(), (x458).get(), (x489).get()); + Box x508 = new Box((int)0); + Box x509 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x508, x509, (x507).get(), (x460).get(), (x491).get()); + Box x510 = new Box((int)0); + Box x511 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x510, x511, (x509).get(), (x462).get(), (x493).get()); + Box x512 = new Box((int)0); + Box x513 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x512, x513, (x511).get(), x464, x495); + Box x514 = new Box((int)0); + Box x515 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x514, x515, (x496).get(), 0xee00bc4f); + Box x516 = new Box((int)0); + Box x517 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x516, x517, (x514).get(), 0xffffffff); + Box x518 = new Box((int)0); + Box x519 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x518, x519, (x514).get(), 0xffffffff); + Box x520 = new Box((int)0); + Box x521 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x520, x521, (x514).get(), 0xffffffff); + Box x522 = new Box((int)0); + Box x523 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x522, x523, (x514).get(), 0xbce6faad); + Box x524 = new Box((int)0); + Box x525 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x524, x525, (x514).get(), 0xa7179e84); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x526, x527, (x514).get(), 0xf3b9cac2); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x528, x529, (x514).get(), 0xfc632551); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x530, x531, 0x0, (x529).get(), (x526).get()); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x532, x533, (x531).get(), (x527).get(), (x524).get()); + Box x534 = new Box((int)0); + Box x535 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x534, x535, (x533).get(), (x525).get(), (x522).get()); + Box x536 = new Box((int)0); + Box x537 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x536, x537, (x535).get(), (x523).get(), (x520).get()); + Box x538 = new Box((int)0); + Box x539 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x538, x539, (x537).get(), (x521).get(), (x518).get()); + int x540 = ((x539).get() + (x519).get()); + Box x541 = new Box((int)0); + Box x542 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x541, x542, 0x0, (x496).get(), (x528).get()); + Box x543 = new Box((int)0); + Box x544 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x543, x544, (x542).get(), (x498).get(), (x530).get()); + Box x545 = new Box((int)0); + Box x546 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x545, x546, (x544).get(), (x500).get(), (x532).get()); + Box x547 = new Box((int)0); + Box x548 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x547, x548, (x546).get(), (x502).get(), (x534).get()); + Box x549 = new Box((int)0); + Box x550 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x549, x550, (x548).get(), (x504).get(), (x536).get()); + Box x551 = new Box((int)0); + Box x552 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x551, x552, (x550).get(), (x506).get(), (x538).get()); + Box x553 = new Box((int)0); + Box x554 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x553, x554, (x552).get(), (x508).get(), x540); + Box x555 = new Box((int)0); + Box x556 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x555, x556, (x554).get(), (x510).get(), (x516).get()); + Box x557 = new Box((int)0); + Box x558 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x557, x558, (x556).get(), (x512).get(), (x517).get()); + int x559 = ((x558).get() + (x513).get()); + Box x560 = new Box((int)0); + Box x561 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x560, x561, x6, (arg2[7])); + Box x562 = new Box((int)0); + Box x563 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x562, x563, x6, (arg2[6])); + Box x564 = new Box((int)0); + Box x565 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x564, x565, x6, (arg2[5])); + Box x566 = new Box((int)0); + Box x567 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x566, x567, x6, (arg2[4])); + Box x568 = new Box((int)0); + Box x569 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x568, x569, x6, (arg2[3])); + Box x570 = new Box((int)0); + Box x571 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x570, x571, x6, (arg2[2])); + Box x572 = new Box((int)0); + Box x573 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x572, x573, x6, (arg2[1])); + Box x574 = new Box((int)0); + Box x575 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x574, x575, x6, (arg2[0])); + Box x576 = new Box((int)0); + Box x577 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x576, x577, 0x0, (x575).get(), (x572).get()); + Box x578 = new Box((int)0); + Box x579 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x578, x579, (x577).get(), (x573).get(), (x570).get()); + Box x580 = new Box((int)0); + Box x581 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x580, x581, (x579).get(), (x571).get(), (x568).get()); + Box x582 = new Box((int)0); + Box x583 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x582, x583, (x581).get(), (x569).get(), (x566).get()); + Box x584 = new Box((int)0); + Box x585 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x584, x585, (x583).get(), (x567).get(), (x564).get()); + Box x586 = new Box((int)0); + Box x587 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x586, x587, (x585).get(), (x565).get(), (x562).get()); + Box x588 = new Box((int)0); + Box x589 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x588, x589, (x587).get(), (x563).get(), (x560).get()); + int x590 = ((x589).get() + (x561).get()); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x591, x592, 0x0, (x543).get(), (x574).get()); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x593, x594, (x592).get(), (x545).get(), (x576).get()); + Box x595 = new Box((int)0); + Box x596 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x595, x596, (x594).get(), (x547).get(), (x578).get()); + Box x597 = new Box((int)0); + Box x598 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x597, x598, (x596).get(), (x549).get(), (x580).get()); + Box x599 = new Box((int)0); + Box x600 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x599, x600, (x598).get(), (x551).get(), (x582).get()); + Box x601 = new Box((int)0); + Box x602 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x601, x602, (x600).get(), (x553).get(), (x584).get()); + Box x603 = new Box((int)0); + Box x604 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x603, x604, (x602).get(), (x555).get(), (x586).get()); + Box x605 = new Box((int)0); + Box x606 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x605, x606, (x604).get(), (x557).get(), (x588).get()); + Box x607 = new Box((int)0); + Box x608 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x607, x608, (x606).get(), x559, x590); + Box x609 = new Box((int)0); + Box x610 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x609, x610, (x591).get(), 0xee00bc4f); + Box x611 = new Box((int)0); + Box x612 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x611, x612, (x609).get(), 0xffffffff); + Box x613 = new Box((int)0); + Box x614 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x613, x614, (x609).get(), 0xffffffff); + Box x615 = new Box((int)0); + Box x616 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x615, x616, (x609).get(), 0xffffffff); + Box x617 = new Box((int)0); + Box x618 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x617, x618, (x609).get(), 0xbce6faad); + Box x619 = new Box((int)0); + Box x620 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x619, x620, (x609).get(), 0xa7179e84); + Box x621 = new Box((int)0); + Box x622 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x621, x622, (x609).get(), 0xf3b9cac2); + Box x623 = new Box((int)0); + Box x624 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x623, x624, (x609).get(), 0xfc632551); + Box x625 = new Box((int)0); + Box x626 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x625, x626, 0x0, (x624).get(), (x621).get()); + Box x627 = new Box((int)0); + Box x628 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x627, x628, (x626).get(), (x622).get(), (x619).get()); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x629, x630, (x628).get(), (x620).get(), (x617).get()); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x631, x632, (x630).get(), (x618).get(), (x615).get()); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x633, x634, (x632).get(), (x616).get(), (x613).get()); + int x635 = ((x634).get() + (x614).get()); + Box x636 = new Box((int)0); + Box x637 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x636, x637, 0x0, (x591).get(), (x623).get()); + Box x638 = new Box((int)0); + Box x639 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x638, x639, (x637).get(), (x593).get(), (x625).get()); + Box x640 = new Box((int)0); + Box x641 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x640, x641, (x639).get(), (x595).get(), (x627).get()); + Box x642 = new Box((int)0); + Box x643 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x642, x643, (x641).get(), (x597).get(), (x629).get()); + Box x644 = new Box((int)0); + Box x645 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x644, x645, (x643).get(), (x599).get(), (x631).get()); + Box x646 = new Box((int)0); + Box x647 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x646, x647, (x645).get(), (x601).get(), (x633).get()); + Box x648 = new Box((int)0); + Box x649 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x648, x649, (x647).get(), (x603).get(), x635); + Box x650 = new Box((int)0); + Box x651 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x650, x651, (x649).get(), (x605).get(), (x611).get()); + Box x652 = new Box((int)0); + Box x653 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x652, x653, (x651).get(), (x607).get(), (x612).get()); + int x654 = ((x653).get() + (x608).get()); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x655, x656, x7, (arg2[7])); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x657, x658, x7, (arg2[6])); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x659, x660, x7, (arg2[5])); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x661, x662, x7, (arg2[4])); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x663, x664, x7, (arg2[3])); + Box x665 = new Box((int)0); + Box x666 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x665, x666, x7, (arg2[2])); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x667, x668, x7, (arg2[1])); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x669, x670, x7, (arg2[0])); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x671, x672, 0x0, (x670).get(), (x667).get()); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x673, x674, (x672).get(), (x668).get(), (x665).get()); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x675, x676, (x674).get(), (x666).get(), (x663).get()); + Box x677 = new Box((int)0); + Box x678 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x677, x678, (x676).get(), (x664).get(), (x661).get()); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x679, x680, (x678).get(), (x662).get(), (x659).get()); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x681, x682, (x680).get(), (x660).get(), (x657).get()); + Box x683 = new Box((int)0); + Box x684 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x683, x684, (x682).get(), (x658).get(), (x655).get()); + int x685 = ((x684).get() + (x656).get()); + Box x686 = new Box((int)0); + Box x687 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x686, x687, 0x0, (x638).get(), (x669).get()); + Box x688 = new Box((int)0); + Box x689 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x688, x689, (x687).get(), (x640).get(), (x671).get()); + Box x690 = new Box((int)0); + Box x691 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x690, x691, (x689).get(), (x642).get(), (x673).get()); + Box x692 = new Box((int)0); + Box x693 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x692, x693, (x691).get(), (x644).get(), (x675).get()); + Box x694 = new Box((int)0); + Box x695 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x694, x695, (x693).get(), (x646).get(), (x677).get()); + Box x696 = new Box((int)0); + Box x697 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x696, x697, (x695).get(), (x648).get(), (x679).get()); + Box x698 = new Box((int)0); + Box x699 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x698, x699, (x697).get(), (x650).get(), (x681).get()); + Box x700 = new Box((int)0); + Box x701 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x700, x701, (x699).get(), (x652).get(), (x683).get()); + Box x702 = new Box((int)0); + Box x703 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x702, x703, (x701).get(), x654, x685); + Box x704 = new Box((int)0); + Box x705 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x704, x705, (x686).get(), 0xee00bc4f); + Box x706 = new Box((int)0); + Box x707 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x706, x707, (x704).get(), 0xffffffff); + Box x708 = new Box((int)0); + Box x709 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x708, x709, (x704).get(), 0xffffffff); + Box x710 = new Box((int)0); + Box x711 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x710, x711, (x704).get(), 0xffffffff); + Box x712 = new Box((int)0); + Box x713 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x712, x713, (x704).get(), 0xbce6faad); + Box x714 = new Box((int)0); + Box x715 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x714, x715, (x704).get(), 0xa7179e84); + Box x716 = new Box((int)0); + Box x717 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x716, x717, (x704).get(), 0xf3b9cac2); + Box x718 = new Box((int)0); + Box x719 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x718, x719, (x704).get(), 0xfc632551); + Box x720 = new Box((int)0); + Box x721 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x720, x721, 0x0, (x719).get(), (x716).get()); + Box x722 = new Box((int)0); + Box x723 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x722, x723, (x721).get(), (x717).get(), (x714).get()); + Box x724 = new Box((int)0); + Box x725 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x724, x725, (x723).get(), (x715).get(), (x712).get()); + Box x726 = new Box((int)0); + Box x727 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x726, x727, (x725).get(), (x713).get(), (x710).get()); + Box x728 = new Box((int)0); + Box x729 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x728, x729, (x727).get(), (x711).get(), (x708).get()); + int x730 = ((x729).get() + (x709).get()); + Box x731 = new Box((int)0); + Box x732 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x731, x732, 0x0, (x686).get(), (x718).get()); + Box x733 = new Box((int)0); + Box x734 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x733, x734, (x732).get(), (x688).get(), (x720).get()); + Box x735 = new Box((int)0); + Box x736 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x735, x736, (x734).get(), (x690).get(), (x722).get()); + Box x737 = new Box((int)0); + Box x738 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x737, x738, (x736).get(), (x692).get(), (x724).get()); + Box x739 = new Box((int)0); + Box x740 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x739, x740, (x738).get(), (x694).get(), (x726).get()); + Box x741 = new Box((int)0); + Box x742 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x741, x742, (x740).get(), (x696).get(), (x728).get()); + Box x743 = new Box((int)0); + Box x744 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x743, x744, (x742).get(), (x698).get(), x730); + Box x745 = new Box((int)0); + Box x746 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x745, x746, (x744).get(), (x700).get(), (x706).get()); + Box x747 = new Box((int)0); + Box x748 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x747, x748, (x746).get(), (x702).get(), (x707).get()); + int x749 = ((x748).get() + (x703).get()); + Box x750 = new Box((int)0); + Box x751 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x750, x751, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x733).get(), 0xfc632551); + Box x752 = new Box((int)0); + Box x753 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x752, x753, (x751).get(), (x735).get(), 0xf3b9cac2); + Box x754 = new Box((int)0); + Box x755 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x754, x755, (x753).get(), (x737).get(), 0xa7179e84); + Box x756 = new Box((int)0); + Box x757 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x756, x757, (x755).get(), (x739).get(), 0xbce6faad); + Box x758 = new Box((int)0); + Box x759 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x758, x759, (x757).get(), (x741).get(), 0xffffffff); + Box x760 = new Box((int)0); + Box x761 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x760, x761, (x759).get(), (x743).get(), 0xffffffff); + Box x762 = new Box((int)0); + Box x763 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x762, x763, (x761).get(), (x745).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x764 = new Box((int)0); + Box x765 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x764, x765, (x763).get(), (x747).get(), 0xffffffff); + Box x766 = new Box((int)0); + Box x767 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x766, x767, (x765).get(), x749, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x768 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x768, (x767).get(), (x750).get(), (x733).get()); + Box x769 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x769, (x767).get(), (x752).get(), (x735).get()); + Box x770 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x770, (x767).get(), (x754).get(), (x737).get()); + Box x771 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x771, (x767).get(), (x756).get(), (x739).get()); + Box x772 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x772, (x767).get(), (x758).get(), (x741).get()); + Box x773 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x773, (x767).get(), (x760).get(), (x743).get()); + Box x774 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x774, (x767).get(), (x762).get(), (x745).get()); + Box x775 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x775, (x767).get(), (x764).get(), (x747).get()); + out1[0] = (x768).get(); + out1[1] = (x769).get(); + out1[2] = (x770).get(); + out1[3] = (x771).get(); + out1[4] = (x772).get(); + out1[5] = (x773).get(); + out1[6] = (x774).get(); + out1[7] = (x775).get(); +} + +/** + * The function fiat_P256Scalar_square squares a field element in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_square(int[] out1, final int[] arg1) { + int x1 = (arg1[1]); + int x2 = (arg1[2]); + int x3 = (arg1[3]); + int x4 = (arg1[4]); + int x5 = (arg1[5]); + int x6 = (arg1[6]); + int x7 = (arg1[7]); + int x8 = (arg1[0]); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x9, x10, x8, (arg1[7])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x11, x12, x8, (arg1[6])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x13, x14, x8, (arg1[5])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x15, x16, x8, (arg1[4])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x17, x18, x8, (arg1[3])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x19, x20, x8, (arg1[2])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x21, x22, x8, (arg1[1])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x23, x24, x8, (arg1[0])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x37, x38, (x36).get(), (x12).get(), (x9).get()); + int x39 = ((x38).get() + (x10).get()); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x40, x41, (x23).get(), 0xee00bc4f); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x42, x43, (x40).get(), 0xffffffff); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x44, x45, (x40).get(), 0xffffffff); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x46, x47, (x40).get(), 0xffffffff); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x48, x49, (x40).get(), 0xbce6faad); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x50, x51, (x40).get(), 0xa7179e84); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x52, x53, (x40).get(), 0xf3b9cac2); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x54, x55, (x40).get(), 0xfc632551); + Box x56 = new Box((int)0); + Box x57 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x56, x57, 0x0, (x55).get(), (x52).get()); + Box x58 = new Box((int)0); + Box x59 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x58, x59, (x57).get(), (x53).get(), (x50).get()); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x60, x61, (x59).get(), (x51).get(), (x48).get()); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x62, x63, (x61).get(), (x49).get(), (x46).get()); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x64, x65, (x63).get(), (x47).get(), (x44).get()); + int x66 = ((x65).get() + (x45).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x67, x68, 0x0, (x23).get(), (x54).get()); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x69, x70, (x68).get(), (x25).get(), (x56).get()); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x71, x72, (x70).get(), (x27).get(), (x58).get()); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x73, x74, (x72).get(), (x29).get(), (x60).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x75, x76, (x74).get(), (x31).get(), (x62).get()); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x77, x78, (x76).get(), (x33).get(), (x64).get()); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x79, x80, (x78).get(), (x35).get(), x66); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x81, x82, (x80).get(), (x37).get(), (x42).get()); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x83, x84, (x82).get(), x39, (x43).get()); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x85, x86, x1, (arg1[7])); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x87, x88, x1, (arg1[6])); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x89, x90, x1, (arg1[5])); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x91, x92, x1, (arg1[4])); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x93, x94, x1, (arg1[3])); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x95, x96, x1, (arg1[2])); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x97, x98, x1, (arg1[1])); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x99, x100, x1, (arg1[0])); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x101, x102, 0x0, (x100).get(), (x97).get()); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x103, x104, (x102).get(), (x98).get(), (x95).get()); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x105, x106, (x104).get(), (x96).get(), (x93).get()); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x107, x108, (x106).get(), (x94).get(), (x91).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x109, x110, (x108).get(), (x92).get(), (x89).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x111, x112, (x110).get(), (x90).get(), (x87).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x113, x114, (x112).get(), (x88).get(), (x85).get()); + int x115 = ((x114).get() + (x86).get()); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x116, x117, 0x0, (x69).get(), (x99).get()); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x118, x119, (x117).get(), (x71).get(), (x101).get()); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x120, x121, (x119).get(), (x73).get(), (x103).get()); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x122, x123, (x121).get(), (x75).get(), (x105).get()); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x124, x125, (x123).get(), (x77).get(), (x107).get()); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x126, x127, (x125).get(), (x79).get(), (x109).get()); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x128, x129, (x127).get(), (x81).get(), (x111).get()); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x130, x131, (x129).get(), (x83).get(), (x113).get()); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x132, x133, (x131).get(), (x84).get(), x115); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x134, x135, (x116).get(), 0xee00bc4f); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x136, x137, (x134).get(), 0xffffffff); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x138, x139, (x134).get(), 0xffffffff); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x140, x141, (x134).get(), 0xffffffff); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x142, x143, (x134).get(), 0xbce6faad); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x144, x145, (x134).get(), 0xa7179e84); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x146, x147, (x134).get(), 0xf3b9cac2); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x148, x149, (x134).get(), 0xfc632551); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x150, x151, 0x0, (x149).get(), (x146).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x152, x153, (x151).get(), (x147).get(), (x144).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x154, x155, (x153).get(), (x145).get(), (x142).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x156, x157, (x155).get(), (x143).get(), (x140).get()); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x158, x159, (x157).get(), (x141).get(), (x138).get()); + int x160 = ((x159).get() + (x139).get()); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x161, x162, 0x0, (x116).get(), (x148).get()); + Box x163 = new Box((int)0); + Box x164 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x163, x164, (x162).get(), (x118).get(), (x150).get()); + Box x165 = new Box((int)0); + Box x166 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x165, x166, (x164).get(), (x120).get(), (x152).get()); + Box x167 = new Box((int)0); + Box x168 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x167, x168, (x166).get(), (x122).get(), (x154).get()); + Box x169 = new Box((int)0); + Box x170 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x169, x170, (x168).get(), (x124).get(), (x156).get()); + Box x171 = new Box((int)0); + Box x172 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x171, x172, (x170).get(), (x126).get(), (x158).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x173, x174, (x172).get(), (x128).get(), x160); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x175, x176, (x174).get(), (x130).get(), (x136).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x177, x178, (x176).get(), (x132).get(), (x137).get()); + int x179 = ((x178).get() + (x133).get()); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x180, x181, x2, (arg1[7])); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x182, x183, x2, (arg1[6])); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x184, x185, x2, (arg1[5])); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x186, x187, x2, (arg1[4])); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x188, x189, x2, (arg1[3])); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x190, x191, x2, (arg1[2])); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x192, x193, x2, (arg1[1])); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x194, x195, x2, (arg1[0])); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x196, x197, 0x0, (x195).get(), (x192).get()); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x198, x199, (x197).get(), (x193).get(), (x190).get()); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x200, x201, (x199).get(), (x191).get(), (x188).get()); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x202, x203, (x201).get(), (x189).get(), (x186).get()); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x204, x205, (x203).get(), (x187).get(), (x184).get()); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x206, x207, (x205).get(), (x185).get(), (x182).get()); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x208, x209, (x207).get(), (x183).get(), (x180).get()); + int x210 = ((x209).get() + (x181).get()); + Box x211 = new Box((int)0); + Box x212 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x211, x212, 0x0, (x163).get(), (x194).get()); + Box x213 = new Box((int)0); + Box x214 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x213, x214, (x212).get(), (x165).get(), (x196).get()); + Box x215 = new Box((int)0); + Box x216 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x215, x216, (x214).get(), (x167).get(), (x198).get()); + Box x217 = new Box((int)0); + Box x218 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x217, x218, (x216).get(), (x169).get(), (x200).get()); + Box x219 = new Box((int)0); + Box x220 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x219, x220, (x218).get(), (x171).get(), (x202).get()); + Box x221 = new Box((int)0); + Box x222 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x221, x222, (x220).get(), (x173).get(), (x204).get()); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x223, x224, (x222).get(), (x175).get(), (x206).get()); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x225, x226, (x224).get(), (x177).get(), (x208).get()); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x227, x228, (x226).get(), x179, x210); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x229, x230, (x211).get(), 0xee00bc4f); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x231, x232, (x229).get(), 0xffffffff); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x233, x234, (x229).get(), 0xffffffff); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x235, x236, (x229).get(), 0xffffffff); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x237, x238, (x229).get(), 0xbce6faad); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x239, x240, (x229).get(), 0xa7179e84); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x241, x242, (x229).get(), 0xf3b9cac2); + Box x243 = new Box((int)0); + Box x244 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x243, x244, (x229).get(), 0xfc632551); + Box x245 = new Box((int)0); + Box x246 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x245, x246, 0x0, (x244).get(), (x241).get()); + Box x247 = new Box((int)0); + Box x248 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x247, x248, (x246).get(), (x242).get(), (x239).get()); + Box x249 = new Box((int)0); + Box x250 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x249, x250, (x248).get(), (x240).get(), (x237).get()); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x251, x252, (x250).get(), (x238).get(), (x235).get()); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x253, x254, (x252).get(), (x236).get(), (x233).get()); + int x255 = ((x254).get() + (x234).get()); + Box x256 = new Box((int)0); + Box x257 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x256, x257, 0x0, (x211).get(), (x243).get()); + Box x258 = new Box((int)0); + Box x259 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x258, x259, (x257).get(), (x213).get(), (x245).get()); + Box x260 = new Box((int)0); + Box x261 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x260, x261, (x259).get(), (x215).get(), (x247).get()); + Box x262 = new Box((int)0); + Box x263 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x262, x263, (x261).get(), (x217).get(), (x249).get()); + Box x264 = new Box((int)0); + Box x265 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x264, x265, (x263).get(), (x219).get(), (x251).get()); + Box x266 = new Box((int)0); + Box x267 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x266, x267, (x265).get(), (x221).get(), (x253).get()); + Box x268 = new Box((int)0); + Box x269 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x268, x269, (x267).get(), (x223).get(), x255); + Box x270 = new Box((int)0); + Box x271 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x270, x271, (x269).get(), (x225).get(), (x231).get()); + Box x272 = new Box((int)0); + Box x273 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x272, x273, (x271).get(), (x227).get(), (x232).get()); + int x274 = ((x273).get() + (x228).get()); + Box x275 = new Box((int)0); + Box x276 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x275, x276, x3, (arg1[7])); + Box x277 = new Box((int)0); + Box x278 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x277, x278, x3, (arg1[6])); + Box x279 = new Box((int)0); + Box x280 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x279, x280, x3, (arg1[5])); + Box x281 = new Box((int)0); + Box x282 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x281, x282, x3, (arg1[4])); + Box x283 = new Box((int)0); + Box x284 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x283, x284, x3, (arg1[3])); + Box x285 = new Box((int)0); + Box x286 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x285, x286, x3, (arg1[2])); + Box x287 = new Box((int)0); + Box x288 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x287, x288, x3, (arg1[1])); + Box x289 = new Box((int)0); + Box x290 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x289, x290, x3, (arg1[0])); + Box x291 = new Box((int)0); + Box x292 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x291, x292, 0x0, (x290).get(), (x287).get()); + Box x293 = new Box((int)0); + Box x294 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x293, x294, (x292).get(), (x288).get(), (x285).get()); + Box x295 = new Box((int)0); + Box x296 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x295, x296, (x294).get(), (x286).get(), (x283).get()); + Box x297 = new Box((int)0); + Box x298 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x297, x298, (x296).get(), (x284).get(), (x281).get()); + Box x299 = new Box((int)0); + Box x300 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x299, x300, (x298).get(), (x282).get(), (x279).get()); + Box x301 = new Box((int)0); + Box x302 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x301, x302, (x300).get(), (x280).get(), (x277).get()); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x303, x304, (x302).get(), (x278).get(), (x275).get()); + int x305 = ((x304).get() + (x276).get()); + Box x306 = new Box((int)0); + Box x307 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x306, x307, 0x0, (x258).get(), (x289).get()); + Box x308 = new Box((int)0); + Box x309 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x308, x309, (x307).get(), (x260).get(), (x291).get()); + Box x310 = new Box((int)0); + Box x311 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x310, x311, (x309).get(), (x262).get(), (x293).get()); + Box x312 = new Box((int)0); + Box x313 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x312, x313, (x311).get(), (x264).get(), (x295).get()); + Box x314 = new Box((int)0); + Box x315 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x314, x315, (x313).get(), (x266).get(), (x297).get()); + Box x316 = new Box((int)0); + Box x317 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x316, x317, (x315).get(), (x268).get(), (x299).get()); + Box x318 = new Box((int)0); + Box x319 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x318, x319, (x317).get(), (x270).get(), (x301).get()); + Box x320 = new Box((int)0); + Box x321 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x320, x321, (x319).get(), (x272).get(), (x303).get()); + Box x322 = new Box((int)0); + Box x323 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x322, x323, (x321).get(), x274, x305); + Box x324 = new Box((int)0); + Box x325 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x324, x325, (x306).get(), 0xee00bc4f); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x326, x327, (x324).get(), 0xffffffff); + Box x328 = new Box((int)0); + Box x329 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x328, x329, (x324).get(), 0xffffffff); + Box x330 = new Box((int)0); + Box x331 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x330, x331, (x324).get(), 0xffffffff); + Box x332 = new Box((int)0); + Box x333 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x332, x333, (x324).get(), 0xbce6faad); + Box x334 = new Box((int)0); + Box x335 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x334, x335, (x324).get(), 0xa7179e84); + Box x336 = new Box((int)0); + Box x337 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x336, x337, (x324).get(), 0xf3b9cac2); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x338, x339, (x324).get(), 0xfc632551); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x340, x341, 0x0, (x339).get(), (x336).get()); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x342, x343, (x341).get(), (x337).get(), (x334).get()); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x344, x345, (x343).get(), (x335).get(), (x332).get()); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x346, x347, (x345).get(), (x333).get(), (x330).get()); + Box x348 = new Box((int)0); + Box x349 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x348, x349, (x347).get(), (x331).get(), (x328).get()); + int x350 = ((x349).get() + (x329).get()); + Box x351 = new Box((int)0); + Box x352 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x351, x352, 0x0, (x306).get(), (x338).get()); + Box x353 = new Box((int)0); + Box x354 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x353, x354, (x352).get(), (x308).get(), (x340).get()); + Box x355 = new Box((int)0); + Box x356 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x355, x356, (x354).get(), (x310).get(), (x342).get()); + Box x357 = new Box((int)0); + Box x358 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x357, x358, (x356).get(), (x312).get(), (x344).get()); + Box x359 = new Box((int)0); + Box x360 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x359, x360, (x358).get(), (x314).get(), (x346).get()); + Box x361 = new Box((int)0); + Box x362 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x361, x362, (x360).get(), (x316).get(), (x348).get()); + Box x363 = new Box((int)0); + Box x364 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x363, x364, (x362).get(), (x318).get(), x350); + Box x365 = new Box((int)0); + Box x366 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x365, x366, (x364).get(), (x320).get(), (x326).get()); + Box x367 = new Box((int)0); + Box x368 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x367, x368, (x366).get(), (x322).get(), (x327).get()); + int x369 = ((x368).get() + (x323).get()); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x370, x371, x4, (arg1[7])); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x372, x373, x4, (arg1[6])); + Box x374 = new Box((int)0); + Box x375 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x374, x375, x4, (arg1[5])); + Box x376 = new Box((int)0); + Box x377 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x376, x377, x4, (arg1[4])); + Box x378 = new Box((int)0); + Box x379 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x378, x379, x4, (arg1[3])); + Box x380 = new Box((int)0); + Box x381 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x380, x381, x4, (arg1[2])); + Box x382 = new Box((int)0); + Box x383 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x382, x383, x4, (arg1[1])); + Box x384 = new Box((int)0); + Box x385 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x384, x385, x4, (arg1[0])); + Box x386 = new Box((int)0); + Box x387 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x386, x387, 0x0, (x385).get(), (x382).get()); + Box x388 = new Box((int)0); + Box x389 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x388, x389, (x387).get(), (x383).get(), (x380).get()); + Box x390 = new Box((int)0); + Box x391 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x390, x391, (x389).get(), (x381).get(), (x378).get()); + Box x392 = new Box((int)0); + Box x393 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x392, x393, (x391).get(), (x379).get(), (x376).get()); + Box x394 = new Box((int)0); + Box x395 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x394, x395, (x393).get(), (x377).get(), (x374).get()); + Box x396 = new Box((int)0); + Box x397 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x396, x397, (x395).get(), (x375).get(), (x372).get()); + Box x398 = new Box((int)0); + Box x399 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x398, x399, (x397).get(), (x373).get(), (x370).get()); + int x400 = ((x399).get() + (x371).get()); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x401, x402, 0x0, (x353).get(), (x384).get()); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x403, x404, (x402).get(), (x355).get(), (x386).get()); + Box x405 = new Box((int)0); + Box x406 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x405, x406, (x404).get(), (x357).get(), (x388).get()); + Box x407 = new Box((int)0); + Box x408 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x407, x408, (x406).get(), (x359).get(), (x390).get()); + Box x409 = new Box((int)0); + Box x410 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x409, x410, (x408).get(), (x361).get(), (x392).get()); + Box x411 = new Box((int)0); + Box x412 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x411, x412, (x410).get(), (x363).get(), (x394).get()); + Box x413 = new Box((int)0); + Box x414 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x413, x414, (x412).get(), (x365).get(), (x396).get()); + Box x415 = new Box((int)0); + Box x416 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x415, x416, (x414).get(), (x367).get(), (x398).get()); + Box x417 = new Box((int)0); + Box x418 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x417, x418, (x416).get(), x369, x400); + Box x419 = new Box((int)0); + Box x420 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x419, x420, (x401).get(), 0xee00bc4f); + Box x421 = new Box((int)0); + Box x422 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x421, x422, (x419).get(), 0xffffffff); + Box x423 = new Box((int)0); + Box x424 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x423, x424, (x419).get(), 0xffffffff); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x425, x426, (x419).get(), 0xffffffff); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x427, x428, (x419).get(), 0xbce6faad); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x429, x430, (x419).get(), 0xa7179e84); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x431, x432, (x419).get(), 0xf3b9cac2); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x433, x434, (x419).get(), 0xfc632551); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x435, x436, 0x0, (x434).get(), (x431).get()); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x437, x438, (x436).get(), (x432).get(), (x429).get()); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x439, x440, (x438).get(), (x430).get(), (x427).get()); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x441, x442, (x440).get(), (x428).get(), (x425).get()); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x443, x444, (x442).get(), (x426).get(), (x423).get()); + int x445 = ((x444).get() + (x424).get()); + Box x446 = new Box((int)0); + Box x447 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x446, x447, 0x0, (x401).get(), (x433).get()); + Box x448 = new Box((int)0); + Box x449 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x448, x449, (x447).get(), (x403).get(), (x435).get()); + Box x450 = new Box((int)0); + Box x451 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x450, x451, (x449).get(), (x405).get(), (x437).get()); + Box x452 = new Box((int)0); + Box x453 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x452, x453, (x451).get(), (x407).get(), (x439).get()); + Box x454 = new Box((int)0); + Box x455 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x454, x455, (x453).get(), (x409).get(), (x441).get()); + Box x456 = new Box((int)0); + Box x457 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x456, x457, (x455).get(), (x411).get(), (x443).get()); + Box x458 = new Box((int)0); + Box x459 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x458, x459, (x457).get(), (x413).get(), x445); + Box x460 = new Box((int)0); + Box x461 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x460, x461, (x459).get(), (x415).get(), (x421).get()); + Box x462 = new Box((int)0); + Box x463 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x462, x463, (x461).get(), (x417).get(), (x422).get()); + int x464 = ((x463).get() + (x418).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x465, x466, x5, (arg1[7])); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x467, x468, x5, (arg1[6])); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x469, x470, x5, (arg1[5])); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x471, x472, x5, (arg1[4])); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x473, x474, x5, (arg1[3])); + Box x475 = new Box((int)0); + Box x476 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x475, x476, x5, (arg1[2])); + Box x477 = new Box((int)0); + Box x478 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x477, x478, x5, (arg1[1])); + Box x479 = new Box((int)0); + Box x480 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x479, x480, x5, (arg1[0])); + Box x481 = new Box((int)0); + Box x482 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x481, x482, 0x0, (x480).get(), (x477).get()); + Box x483 = new Box((int)0); + Box x484 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x483, x484, (x482).get(), (x478).get(), (x475).get()); + Box x485 = new Box((int)0); + Box x486 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x485, x486, (x484).get(), (x476).get(), (x473).get()); + Box x487 = new Box((int)0); + Box x488 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x487, x488, (x486).get(), (x474).get(), (x471).get()); + Box x489 = new Box((int)0); + Box x490 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x489, x490, (x488).get(), (x472).get(), (x469).get()); + Box x491 = new Box((int)0); + Box x492 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x491, x492, (x490).get(), (x470).get(), (x467).get()); + Box x493 = new Box((int)0); + Box x494 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x493, x494, (x492).get(), (x468).get(), (x465).get()); + int x495 = ((x494).get() + (x466).get()); + Box x496 = new Box((int)0); + Box x497 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x496, x497, 0x0, (x448).get(), (x479).get()); + Box x498 = new Box((int)0); + Box x499 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x498, x499, (x497).get(), (x450).get(), (x481).get()); + Box x500 = new Box((int)0); + Box x501 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x500, x501, (x499).get(), (x452).get(), (x483).get()); + Box x502 = new Box((int)0); + Box x503 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x502, x503, (x501).get(), (x454).get(), (x485).get()); + Box x504 = new Box((int)0); + Box x505 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x504, x505, (x503).get(), (x456).get(), (x487).get()); + Box x506 = new Box((int)0); + Box x507 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x506, x507, (x505).get(), (x458).get(), (x489).get()); + Box x508 = new Box((int)0); + Box x509 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x508, x509, (x507).get(), (x460).get(), (x491).get()); + Box x510 = new Box((int)0); + Box x511 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x510, x511, (x509).get(), (x462).get(), (x493).get()); + Box x512 = new Box((int)0); + Box x513 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x512, x513, (x511).get(), x464, x495); + Box x514 = new Box((int)0); + Box x515 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x514, x515, (x496).get(), 0xee00bc4f); + Box x516 = new Box((int)0); + Box x517 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x516, x517, (x514).get(), 0xffffffff); + Box x518 = new Box((int)0); + Box x519 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x518, x519, (x514).get(), 0xffffffff); + Box x520 = new Box((int)0); + Box x521 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x520, x521, (x514).get(), 0xffffffff); + Box x522 = new Box((int)0); + Box x523 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x522, x523, (x514).get(), 0xbce6faad); + Box x524 = new Box((int)0); + Box x525 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x524, x525, (x514).get(), 0xa7179e84); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x526, x527, (x514).get(), 0xf3b9cac2); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x528, x529, (x514).get(), 0xfc632551); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x530, x531, 0x0, (x529).get(), (x526).get()); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x532, x533, (x531).get(), (x527).get(), (x524).get()); + Box x534 = new Box((int)0); + Box x535 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x534, x535, (x533).get(), (x525).get(), (x522).get()); + Box x536 = new Box((int)0); + Box x537 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x536, x537, (x535).get(), (x523).get(), (x520).get()); + Box x538 = new Box((int)0); + Box x539 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x538, x539, (x537).get(), (x521).get(), (x518).get()); + int x540 = ((x539).get() + (x519).get()); + Box x541 = new Box((int)0); + Box x542 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x541, x542, 0x0, (x496).get(), (x528).get()); + Box x543 = new Box((int)0); + Box x544 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x543, x544, (x542).get(), (x498).get(), (x530).get()); + Box x545 = new Box((int)0); + Box x546 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x545, x546, (x544).get(), (x500).get(), (x532).get()); + Box x547 = new Box((int)0); + Box x548 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x547, x548, (x546).get(), (x502).get(), (x534).get()); + Box x549 = new Box((int)0); + Box x550 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x549, x550, (x548).get(), (x504).get(), (x536).get()); + Box x551 = new Box((int)0); + Box x552 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x551, x552, (x550).get(), (x506).get(), (x538).get()); + Box x553 = new Box((int)0); + Box x554 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x553, x554, (x552).get(), (x508).get(), x540); + Box x555 = new Box((int)0); + Box x556 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x555, x556, (x554).get(), (x510).get(), (x516).get()); + Box x557 = new Box((int)0); + Box x558 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x557, x558, (x556).get(), (x512).get(), (x517).get()); + int x559 = ((x558).get() + (x513).get()); + Box x560 = new Box((int)0); + Box x561 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x560, x561, x6, (arg1[7])); + Box x562 = new Box((int)0); + Box x563 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x562, x563, x6, (arg1[6])); + Box x564 = new Box((int)0); + Box x565 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x564, x565, x6, (arg1[5])); + Box x566 = new Box((int)0); + Box x567 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x566, x567, x6, (arg1[4])); + Box x568 = new Box((int)0); + Box x569 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x568, x569, x6, (arg1[3])); + Box x570 = new Box((int)0); + Box x571 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x570, x571, x6, (arg1[2])); + Box x572 = new Box((int)0); + Box x573 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x572, x573, x6, (arg1[1])); + Box x574 = new Box((int)0); + Box x575 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x574, x575, x6, (arg1[0])); + Box x576 = new Box((int)0); + Box x577 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x576, x577, 0x0, (x575).get(), (x572).get()); + Box x578 = new Box((int)0); + Box x579 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x578, x579, (x577).get(), (x573).get(), (x570).get()); + Box x580 = new Box((int)0); + Box x581 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x580, x581, (x579).get(), (x571).get(), (x568).get()); + Box x582 = new Box((int)0); + Box x583 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x582, x583, (x581).get(), (x569).get(), (x566).get()); + Box x584 = new Box((int)0); + Box x585 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x584, x585, (x583).get(), (x567).get(), (x564).get()); + Box x586 = new Box((int)0); + Box x587 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x586, x587, (x585).get(), (x565).get(), (x562).get()); + Box x588 = new Box((int)0); + Box x589 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x588, x589, (x587).get(), (x563).get(), (x560).get()); + int x590 = ((x589).get() + (x561).get()); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x591, x592, 0x0, (x543).get(), (x574).get()); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x593, x594, (x592).get(), (x545).get(), (x576).get()); + Box x595 = new Box((int)0); + Box x596 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x595, x596, (x594).get(), (x547).get(), (x578).get()); + Box x597 = new Box((int)0); + Box x598 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x597, x598, (x596).get(), (x549).get(), (x580).get()); + Box x599 = new Box((int)0); + Box x600 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x599, x600, (x598).get(), (x551).get(), (x582).get()); + Box x601 = new Box((int)0); + Box x602 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x601, x602, (x600).get(), (x553).get(), (x584).get()); + Box x603 = new Box((int)0); + Box x604 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x603, x604, (x602).get(), (x555).get(), (x586).get()); + Box x605 = new Box((int)0); + Box x606 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x605, x606, (x604).get(), (x557).get(), (x588).get()); + Box x607 = new Box((int)0); + Box x608 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x607, x608, (x606).get(), x559, x590); + Box x609 = new Box((int)0); + Box x610 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x609, x610, (x591).get(), 0xee00bc4f); + Box x611 = new Box((int)0); + Box x612 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x611, x612, (x609).get(), 0xffffffff); + Box x613 = new Box((int)0); + Box x614 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x613, x614, (x609).get(), 0xffffffff); + Box x615 = new Box((int)0); + Box x616 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x615, x616, (x609).get(), 0xffffffff); + Box x617 = new Box((int)0); + Box x618 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x617, x618, (x609).get(), 0xbce6faad); + Box x619 = new Box((int)0); + Box x620 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x619, x620, (x609).get(), 0xa7179e84); + Box x621 = new Box((int)0); + Box x622 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x621, x622, (x609).get(), 0xf3b9cac2); + Box x623 = new Box((int)0); + Box x624 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x623, x624, (x609).get(), 0xfc632551); + Box x625 = new Box((int)0); + Box x626 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x625, x626, 0x0, (x624).get(), (x621).get()); + Box x627 = new Box((int)0); + Box x628 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x627, x628, (x626).get(), (x622).get(), (x619).get()); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x629, x630, (x628).get(), (x620).get(), (x617).get()); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x631, x632, (x630).get(), (x618).get(), (x615).get()); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x633, x634, (x632).get(), (x616).get(), (x613).get()); + int x635 = ((x634).get() + (x614).get()); + Box x636 = new Box((int)0); + Box x637 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x636, x637, 0x0, (x591).get(), (x623).get()); + Box x638 = new Box((int)0); + Box x639 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x638, x639, (x637).get(), (x593).get(), (x625).get()); + Box x640 = new Box((int)0); + Box x641 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x640, x641, (x639).get(), (x595).get(), (x627).get()); + Box x642 = new Box((int)0); + Box x643 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x642, x643, (x641).get(), (x597).get(), (x629).get()); + Box x644 = new Box((int)0); + Box x645 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x644, x645, (x643).get(), (x599).get(), (x631).get()); + Box x646 = new Box((int)0); + Box x647 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x646, x647, (x645).get(), (x601).get(), (x633).get()); + Box x648 = new Box((int)0); + Box x649 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x648, x649, (x647).get(), (x603).get(), x635); + Box x650 = new Box((int)0); + Box x651 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x650, x651, (x649).get(), (x605).get(), (x611).get()); + Box x652 = new Box((int)0); + Box x653 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x652, x653, (x651).get(), (x607).get(), (x612).get()); + int x654 = ((x653).get() + (x608).get()); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x655, x656, x7, (arg1[7])); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x657, x658, x7, (arg1[6])); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x659, x660, x7, (arg1[5])); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x661, x662, x7, (arg1[4])); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x663, x664, x7, (arg1[3])); + Box x665 = new Box((int)0); + Box x666 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x665, x666, x7, (arg1[2])); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x667, x668, x7, (arg1[1])); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x669, x670, x7, (arg1[0])); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x671, x672, 0x0, (x670).get(), (x667).get()); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x673, x674, (x672).get(), (x668).get(), (x665).get()); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x675, x676, (x674).get(), (x666).get(), (x663).get()); + Box x677 = new Box((int)0); + Box x678 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x677, x678, (x676).get(), (x664).get(), (x661).get()); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x679, x680, (x678).get(), (x662).get(), (x659).get()); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x681, x682, (x680).get(), (x660).get(), (x657).get()); + Box x683 = new Box((int)0); + Box x684 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x683, x684, (x682).get(), (x658).get(), (x655).get()); + int x685 = ((x684).get() + (x656).get()); + Box x686 = new Box((int)0); + Box x687 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x686, x687, 0x0, (x638).get(), (x669).get()); + Box x688 = new Box((int)0); + Box x689 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x688, x689, (x687).get(), (x640).get(), (x671).get()); + Box x690 = new Box((int)0); + Box x691 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x690, x691, (x689).get(), (x642).get(), (x673).get()); + Box x692 = new Box((int)0); + Box x693 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x692, x693, (x691).get(), (x644).get(), (x675).get()); + Box x694 = new Box((int)0); + Box x695 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x694, x695, (x693).get(), (x646).get(), (x677).get()); + Box x696 = new Box((int)0); + Box x697 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x696, x697, (x695).get(), (x648).get(), (x679).get()); + Box x698 = new Box((int)0); + Box x699 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x698, x699, (x697).get(), (x650).get(), (x681).get()); + Box x700 = new Box((int)0); + Box x701 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x700, x701, (x699).get(), (x652).get(), (x683).get()); + Box x702 = new Box((int)0); + Box x703 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x702, x703, (x701).get(), x654, x685); + Box x704 = new Box((int)0); + Box x705 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x704, x705, (x686).get(), 0xee00bc4f); + Box x706 = new Box((int)0); + Box x707 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x706, x707, (x704).get(), 0xffffffff); + Box x708 = new Box((int)0); + Box x709 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x708, x709, (x704).get(), 0xffffffff); + Box x710 = new Box((int)0); + Box x711 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x710, x711, (x704).get(), 0xffffffff); + Box x712 = new Box((int)0); + Box x713 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x712, x713, (x704).get(), 0xbce6faad); + Box x714 = new Box((int)0); + Box x715 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x714, x715, (x704).get(), 0xa7179e84); + Box x716 = new Box((int)0); + Box x717 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x716, x717, (x704).get(), 0xf3b9cac2); + Box x718 = new Box((int)0); + Box x719 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x718, x719, (x704).get(), 0xfc632551); + Box x720 = new Box((int)0); + Box x721 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x720, x721, 0x0, (x719).get(), (x716).get()); + Box x722 = new Box((int)0); + Box x723 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x722, x723, (x721).get(), (x717).get(), (x714).get()); + Box x724 = new Box((int)0); + Box x725 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x724, x725, (x723).get(), (x715).get(), (x712).get()); + Box x726 = new Box((int)0); + Box x727 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x726, x727, (x725).get(), (x713).get(), (x710).get()); + Box x728 = new Box((int)0); + Box x729 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x728, x729, (x727).get(), (x711).get(), (x708).get()); + int x730 = ((x729).get() + (x709).get()); + Box x731 = new Box((int)0); + Box x732 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x731, x732, 0x0, (x686).get(), (x718).get()); + Box x733 = new Box((int)0); + Box x734 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x733, x734, (x732).get(), (x688).get(), (x720).get()); + Box x735 = new Box((int)0); + Box x736 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x735, x736, (x734).get(), (x690).get(), (x722).get()); + Box x737 = new Box((int)0); + Box x738 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x737, x738, (x736).get(), (x692).get(), (x724).get()); + Box x739 = new Box((int)0); + Box x740 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x739, x740, (x738).get(), (x694).get(), (x726).get()); + Box x741 = new Box((int)0); + Box x742 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x741, x742, (x740).get(), (x696).get(), (x728).get()); + Box x743 = new Box((int)0); + Box x744 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x743, x744, (x742).get(), (x698).get(), x730); + Box x745 = new Box((int)0); + Box x746 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x745, x746, (x744).get(), (x700).get(), (x706).get()); + Box x747 = new Box((int)0); + Box x748 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x747, x748, (x746).get(), (x702).get(), (x707).get()); + int x749 = ((x748).get() + (x703).get()); + Box x750 = new Box((int)0); + Box x751 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x750, x751, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x733).get(), 0xfc632551); + Box x752 = new Box((int)0); + Box x753 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x752, x753, (x751).get(), (x735).get(), 0xf3b9cac2); + Box x754 = new Box((int)0); + Box x755 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x754, x755, (x753).get(), (x737).get(), 0xa7179e84); + Box x756 = new Box((int)0); + Box x757 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x756, x757, (x755).get(), (x739).get(), 0xbce6faad); + Box x758 = new Box((int)0); + Box x759 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x758, x759, (x757).get(), (x741).get(), 0xffffffff); + Box x760 = new Box((int)0); + Box x761 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x760, x761, (x759).get(), (x743).get(), 0xffffffff); + Box x762 = new Box((int)0); + Box x763 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x762, x763, (x761).get(), (x745).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x764 = new Box((int)0); + Box x765 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x764, x765, (x763).get(), (x747).get(), 0xffffffff); + Box x766 = new Box((int)0); + Box x767 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x766, x767, (x765).get(), x749, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x768 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x768, (x767).get(), (x750).get(), (x733).get()); + Box x769 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x769, (x767).get(), (x752).get(), (x735).get()); + Box x770 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x770, (x767).get(), (x754).get(), (x737).get()); + Box x771 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x771, (x767).get(), (x756).get(), (x739).get()); + Box x772 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x772, (x767).get(), (x758).get(), (x741).get()); + Box x773 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x773, (x767).get(), (x760).get(), (x743).get()); + Box x774 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x774, (x767).get(), (x762).get(), (x745).get()); + Box x775 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x775, (x767).get(), (x764).get(), (x747).get()); + out1[0] = (x768).get(); + out1[1] = (x769).get(); + out1[2] = (x770).get(); + out1[3] = (x771).get(); + out1[4] = (x772).get(); + out1[5] = (x773).get(); + out1[6] = (x774).get(); + out1[7] = (x775).get(); +} + +/** + * The function fiat_P256Scalar_add adds two field elements in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * 0 ≤ eval arg2 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_add(int[] out1, final int[] arg1, final int[] arg2) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x1, x2, 0x0, (arg1[0]), (arg2[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x3, x4, (x2).get(), (arg1[1]), (arg2[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x5, x6, (x4).get(), (arg1[2]), (arg2[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x7, x8, (x6).get(), (arg1[3]), (arg2[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x9, x10, (x8).get(), (arg1[4]), (arg2[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x11, x12, (x10).get(), (arg1[5]), (arg2[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x13, x14, (x12).get(), (arg1[6]), (arg2[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x15, x16, (x14).get(), (arg1[7]), (arg2[7])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x17, x18, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x1).get(), 0xfc632551); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x19, x20, (x18).get(), (x3).get(), 0xf3b9cac2); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x21, x22, (x20).get(), (x5).get(), 0xa7179e84); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x23, x24, (x22).get(), (x7).get(), 0xbce6faad); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x25, x26, (x24).get(), (x9).get(), 0xffffffff); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x27, x28, (x26).get(), (x11).get(), 0xffffffff); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x29, x30, (x28).get(), (x13).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x31, x32, (x30).get(), (x15).get(), 0xffffffff); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x33, x34, (x32).get(), (x16).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x35 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x35, (x34).get(), (x17).get(), (x1).get()); + Box x36 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x36, (x34).get(), (x19).get(), (x3).get()); + Box x37 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x37, (x34).get(), (x21).get(), (x5).get()); + Box x38 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x38, (x34).get(), (x23).get(), (x7).get()); + Box x39 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x39, (x34).get(), (x25).get(), (x9).get()); + Box x40 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x40, (x34).get(), (x27).get(), (x11).get()); + Box x41 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x41, (x34).get(), (x29).get(), (x13).get()); + Box x42 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x42, (x34).get(), (x31).get(), (x15).get()); + out1[0] = (x35).get(); + out1[1] = (x36).get(); + out1[2] = (x37).get(); + out1[3] = (x38).get(); + out1[4] = (x39).get(); + out1[5] = (x40).get(); + out1[6] = (x41).get(); + out1[7] = (x42).get(); +} + +/** + * The function fiat_P256Scalar_sub subtracts two field elements in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * 0 ≤ eval arg2 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_sub(int[] out1, final int[] arg1, final int[] arg2) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x1, x2, 0x0, (arg1[0]), (arg2[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x3, x4, (x2).get(), (arg1[1]), (arg2[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x5, x6, (x4).get(), (arg1[2]), (arg2[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x7, x8, (x6).get(), (arg1[3]), (arg2[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x9, x10, (x8).get(), (arg1[4]), (arg2[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x11, x12, (x10).get(), (arg1[5]), (arg2[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x13, x14, (x12).get(), (arg1[6]), (arg2[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x15, x16, (x14).get(), (arg1[7]), (arg2[7])); + Box x17 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x17, (x16).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), 0xffffffff); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x18, x19, 0x0, (x1).get(), ((x17).get() & 0xfc632551)); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x20, x21, (x19).get(), (x3).get(), ((x17).get() & 0xf3b9cac2)); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x22, x23, (x21).get(), (x5).get(), ((x17).get() & 0xa7179e84)); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x24, x25, (x23).get(), (x7).get(), ((x17).get() & 0xbce6faad)); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x26, x27, (x25).get(), (x9).get(), (x17).get()); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x28, x29, (x27).get(), (x11).get(), (x17).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x30, x31, (x29).get(), (x13).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x32, x33, (x31).get(), (x15).get(), (x17).get()); + out1[0] = (x18).get(); + out1[1] = (x20).get(); + out1[2] = (x22).get(); + out1[3] = (x24).get(); + out1[4] = (x26).get(); + out1[5] = (x28).get(); + out1[6] = (x30).get(); + out1[7] = (x32).get(); +} + +/** + * The function fiat_P256Scalar_opp negates a field element in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_opp(int[] out1, final int[] arg1) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x1, x2, 0x0, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x3, x4, (x2).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x5, x6, (x4).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x7, x8, (x6).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x9, x10, (x8).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x11, x12, (x10).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x13, x14, (x12).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x15, x16, (x14).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[7])); + Box x17 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x17, (x16).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), 0xffffffff); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x18, x19, 0x0, (x1).get(), ((x17).get() & 0xfc632551)); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x20, x21, (x19).get(), (x3).get(), ((x17).get() & 0xf3b9cac2)); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x22, x23, (x21).get(), (x5).get(), ((x17).get() & 0xa7179e84)); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x24, x25, (x23).get(), (x7).get(), ((x17).get() & 0xbce6faad)); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x26, x27, (x25).get(), (x9).get(), (x17).get()); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x28, x29, (x27).get(), (x11).get(), (x17).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x30, x31, (x29).get(), (x13).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x32, x33, (x31).get(), (x15).get(), (x17).get()); + out1[0] = (x18).get(); + out1[1] = (x20).get(); + out1[2] = (x22).get(); + out1[3] = (x24).get(); + out1[4] = (x26).get(); + out1[5] = (x28).get(); + out1[6] = (x30).get(); + out1[7] = (x32).get(); +} + +/** + * The function fiat_P256Scalar_from_montgomery translates a field element out of the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_from_montgomery(int[] out1, final int[] arg1) { + int x1 = (arg1[0]); + Box x2 = new Box((int)0); + Box x3 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x2, x3, x1, 0xee00bc4f); + Box x4 = new Box((int)0); + Box x5 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x4, x5, (x2).get(), 0xffffffff); + Box x6 = new Box((int)0); + Box x7 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x6, x7, (x2).get(), 0xffffffff); + Box x8 = new Box((int)0); + Box x9 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x8, x9, (x2).get(), 0xffffffff); + Box x10 = new Box((int)0); + Box x11 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x10, x11, (x2).get(), 0xbce6faad); + Box x12 = new Box((int)0); + Box x13 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x12, x13, (x2).get(), 0xa7179e84); + Box x14 = new Box((int)0); + Box x15 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x14, x15, (x2).get(), 0xf3b9cac2); + Box x16 = new Box((int)0); + Box x17 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x16, x17, (x2).get(), 0xfc632551); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x18, x19, 0x0, (x17).get(), (x14).get()); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x20, x21, (x19).get(), (x15).get(), (x12).get()); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x22, x23, (x21).get(), (x13).get(), (x10).get()); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x24, x25, (x23).get(), (x11).get(), (x8).get()); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x26, x27, (x25).get(), (x9).get(), (x6).get()); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x28, x29, 0x0, x1, (x16).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x30, x31, (x29).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x18).get()); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x32, x33, (x31).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x20).get()); + Box x34 = new Box((int)0); + Box x35 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x34, x35, (x33).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x22).get()); + Box x36 = new Box((int)0); + Box x37 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x36, x37, (x35).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x24).get()); + Box x38 = new Box((int)0); + Box x39 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x38, x39, (x37).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x26).get()); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x40, x41, (x39).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), ((x27).get() + (x7).get())); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x42, x43, (x41).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x4).get()); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x44, x45, 0x0, (x30).get(), (arg1[1])); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x46, x47, (x45).get(), (x32).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x48, x49, (x47).get(), (x34).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x50, x51, (x49).get(), (x36).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x52, x53, (x51).get(), (x38).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x54, x55, (x53).get(), (x40).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x56 = new Box((int)0); + Box x57 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x56, x57, (x55).get(), (x42).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x58 = new Box((int)0); + Box x59 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x58, x59, (x57).get(), ((x43).get() + (x5).get()), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x60, x61, (x44).get(), 0xee00bc4f); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x62, x63, (x60).get(), 0xffffffff); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x64, x65, (x60).get(), 0xffffffff); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x66, x67, (x60).get(), 0xffffffff); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x68, x69, (x60).get(), 0xbce6faad); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x70, x71, (x60).get(), 0xa7179e84); + Box x72 = new Box((int)0); + Box x73 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x72, x73, (x60).get(), 0xf3b9cac2); + Box x74 = new Box((int)0); + Box x75 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x74, x75, (x60).get(), 0xfc632551); + Box x76 = new Box((int)0); + Box x77 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x76, x77, 0x0, (x75).get(), (x72).get()); + Box x78 = new Box((int)0); + Box x79 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x78, x79, (x77).get(), (x73).get(), (x70).get()); + Box x80 = new Box((int)0); + Box x81 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x80, x81, (x79).get(), (x71).get(), (x68).get()); + Box x82 = new Box((int)0); + Box x83 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x82, x83, (x81).get(), (x69).get(), (x66).get()); + Box x84 = new Box((int)0); + Box x85 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x84, x85, (x83).get(), (x67).get(), (x64).get()); + Box x86 = new Box((int)0); + Box x87 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x86, x87, 0x0, (x44).get(), (x74).get()); + Box x88 = new Box((int)0); + Box x89 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x88, x89, (x87).get(), (x46).get(), (x76).get()); + Box x90 = new Box((int)0); + Box x91 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x90, x91, (x89).get(), (x48).get(), (x78).get()); + Box x92 = new Box((int)0); + Box x93 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x92, x93, (x91).get(), (x50).get(), (x80).get()); + Box x94 = new Box((int)0); + Box x95 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x94, x95, (x93).get(), (x52).get(), (x82).get()); + Box x96 = new Box((int)0); + Box x97 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x96, x97, (x95).get(), (x54).get(), (x84).get()); + Box x98 = new Box((int)0); + Box x99 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x98, x99, (x97).get(), (x56).get(), ((x85).get() + (x65).get())); + Box x100 = new Box((int)0); + Box x101 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x100, x101, (x99).get(), (x58).get(), (x62).get()); + Box x102 = new Box((int)0); + Box x103 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x102, x103, (x101).get(), (x59).get(), (x63).get()); + Box x104 = new Box((int)0); + Box x105 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x104, x105, 0x0, (x88).get(), (arg1[2])); + Box x106 = new Box((int)0); + Box x107 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x106, x107, (x105).get(), (x90).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x108 = new Box((int)0); + Box x109 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x108, x109, (x107).get(), (x92).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x110 = new Box((int)0); + Box x111 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x110, x111, (x109).get(), (x94).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x112, x113, (x111).get(), (x96).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x114 = new Box((int)0); + Box x115 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x114, x115, (x113).get(), (x98).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x116, x117, (x115).get(), (x100).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x118, x119, (x117).get(), (x102).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x120, x121, (x104).get(), 0xee00bc4f); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x122, x123, (x120).get(), 0xffffffff); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x124, x125, (x120).get(), 0xffffffff); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x126, x127, (x120).get(), 0xffffffff); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x128, x129, (x120).get(), 0xbce6faad); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x130, x131, (x120).get(), 0xa7179e84); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x132, x133, (x120).get(), 0xf3b9cac2); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x134, x135, (x120).get(), 0xfc632551); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x136, x137, 0x0, (x135).get(), (x132).get()); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x138, x139, (x137).get(), (x133).get(), (x130).get()); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x140, x141, (x139).get(), (x131).get(), (x128).get()); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x142, x143, (x141).get(), (x129).get(), (x126).get()); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x144, x145, (x143).get(), (x127).get(), (x124).get()); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x146, x147, 0x0, (x104).get(), (x134).get()); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x148, x149, (x147).get(), (x106).get(), (x136).get()); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x150, x151, (x149).get(), (x108).get(), (x138).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x152, x153, (x151).get(), (x110).get(), (x140).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x154, x155, (x153).get(), (x112).get(), (x142).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x156, x157, (x155).get(), (x114).get(), (x144).get()); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x158, x159, (x157).get(), (x116).get(), ((x145).get() + (x125).get())); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x160, x161, (x159).get(), (x118).get(), (x122).get()); + Box x162 = new Box((int)0); + Box x163 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x162, x163, (x161).get(), ((x119).get() + (x103).get()), (x123).get()); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x164, x165, 0x0, (x148).get(), (arg1[3])); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x166, x167, (x165).get(), (x150).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x168 = new Box((int)0); + Box x169 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x168, x169, (x167).get(), (x152).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x170, x171, (x169).get(), (x154).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x172, x173, (x171).get(), (x156).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x174, x175, (x173).get(), (x158).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x176, x177, (x175).get(), (x160).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x178, x179, (x177).get(), (x162).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x180, x181, (x164).get(), 0xee00bc4f); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x182, x183, (x180).get(), 0xffffffff); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x184, x185, (x180).get(), 0xffffffff); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x186, x187, (x180).get(), 0xffffffff); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x188, x189, (x180).get(), 0xbce6faad); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x190, x191, (x180).get(), 0xa7179e84); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x192, x193, (x180).get(), 0xf3b9cac2); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x194, x195, (x180).get(), 0xfc632551); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x196, x197, 0x0, (x195).get(), (x192).get()); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x198, x199, (x197).get(), (x193).get(), (x190).get()); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x200, x201, (x199).get(), (x191).get(), (x188).get()); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x202, x203, (x201).get(), (x189).get(), (x186).get()); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x204, x205, (x203).get(), (x187).get(), (x184).get()); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x206, x207, 0x0, (x164).get(), (x194).get()); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x208, x209, (x207).get(), (x166).get(), (x196).get()); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x210, x211, (x209).get(), (x168).get(), (x198).get()); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x212, x213, (x211).get(), (x170).get(), (x200).get()); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x214, x215, (x213).get(), (x172).get(), (x202).get()); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x216, x217, (x215).get(), (x174).get(), (x204).get()); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x218, x219, (x217).get(), (x176).get(), ((x205).get() + (x185).get())); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x220, x221, (x219).get(), (x178).get(), (x182).get()); + Box x222 = new Box((int)0); + Box x223 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x222, x223, (x221).get(), ((x179).get() + (x163).get()), (x183).get()); + Box x224 = new Box((int)0); + Box x225 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x224, x225, 0x0, (x208).get(), (arg1[4])); + Box x226 = new Box((int)0); + Box x227 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x226, x227, (x225).get(), (x210).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x228 = new Box((int)0); + Box x229 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x228, x229, (x227).get(), (x212).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x230 = new Box((int)0); + Box x231 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x230, x231, (x229).get(), (x214).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x232 = new Box((int)0); + Box x233 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x232, x233, (x231).get(), (x216).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x234 = new Box((int)0); + Box x235 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x234, x235, (x233).get(), (x218).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x236 = new Box((int)0); + Box x237 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x236, x237, (x235).get(), (x220).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x238 = new Box((int)0); + Box x239 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x238, x239, (x237).get(), (x222).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x240 = new Box((int)0); + Box x241 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x240, x241, (x224).get(), 0xee00bc4f); + Box x242 = new Box((int)0); + Box x243 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x242, x243, (x240).get(), 0xffffffff); + Box x244 = new Box((int)0); + Box x245 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x244, x245, (x240).get(), 0xffffffff); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x246, x247, (x240).get(), 0xffffffff); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x248, x249, (x240).get(), 0xbce6faad); + Box x250 = new Box((int)0); + Box x251 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x250, x251, (x240).get(), 0xa7179e84); + Box x252 = new Box((int)0); + Box x253 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x252, x253, (x240).get(), 0xf3b9cac2); + Box x254 = new Box((int)0); + Box x255 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x254, x255, (x240).get(), 0xfc632551); + Box x256 = new Box((int)0); + Box x257 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x256, x257, 0x0, (x255).get(), (x252).get()); + Box x258 = new Box((int)0); + Box x259 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x258, x259, (x257).get(), (x253).get(), (x250).get()); + Box x260 = new Box((int)0); + Box x261 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x260, x261, (x259).get(), (x251).get(), (x248).get()); + Box x262 = new Box((int)0); + Box x263 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x262, x263, (x261).get(), (x249).get(), (x246).get()); + Box x264 = new Box((int)0); + Box x265 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x264, x265, (x263).get(), (x247).get(), (x244).get()); + Box x266 = new Box((int)0); + Box x267 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x266, x267, 0x0, (x224).get(), (x254).get()); + Box x268 = new Box((int)0); + Box x269 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x268, x269, (x267).get(), (x226).get(), (x256).get()); + Box x270 = new Box((int)0); + Box x271 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x270, x271, (x269).get(), (x228).get(), (x258).get()); + Box x272 = new Box((int)0); + Box x273 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x272, x273, (x271).get(), (x230).get(), (x260).get()); + Box x274 = new Box((int)0); + Box x275 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x274, x275, (x273).get(), (x232).get(), (x262).get()); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x276, x277, (x275).get(), (x234).get(), (x264).get()); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x278, x279, (x277).get(), (x236).get(), ((x265).get() + (x245).get())); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x280, x281, (x279).get(), (x238).get(), (x242).get()); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x282, x283, (x281).get(), ((x239).get() + (x223).get()), (x243).get()); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x284, x285, 0x0, (x268).get(), (arg1[5])); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x286, x287, (x285).get(), (x270).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x288, x289, (x287).get(), (x272).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x290, x291, (x289).get(), (x274).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x292, x293, (x291).get(), (x276).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x294, x295, (x293).get(), (x278).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x296, x297, (x295).get(), (x280).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x298 = new Box((int)0); + Box x299 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x298, x299, (x297).get(), (x282).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x300 = new Box((int)0); + Box x301 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x300, x301, (x284).get(), 0xee00bc4f); + Box x302 = new Box((int)0); + Box x303 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x302, x303, (x300).get(), 0xffffffff); + Box x304 = new Box((int)0); + Box x305 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x304, x305, (x300).get(), 0xffffffff); + Box x306 = new Box((int)0); + Box x307 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x306, x307, (x300).get(), 0xffffffff); + Box x308 = new Box((int)0); + Box x309 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x308, x309, (x300).get(), 0xbce6faad); + Box x310 = new Box((int)0); + Box x311 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x310, x311, (x300).get(), 0xa7179e84); + Box x312 = new Box((int)0); + Box x313 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x312, x313, (x300).get(), 0xf3b9cac2); + Box x314 = new Box((int)0); + Box x315 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x314, x315, (x300).get(), 0xfc632551); + Box x316 = new Box((int)0); + Box x317 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x316, x317, 0x0, (x315).get(), (x312).get()); + Box x318 = new Box((int)0); + Box x319 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x318, x319, (x317).get(), (x313).get(), (x310).get()); + Box x320 = new Box((int)0); + Box x321 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x320, x321, (x319).get(), (x311).get(), (x308).get()); + Box x322 = new Box((int)0); + Box x323 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x322, x323, (x321).get(), (x309).get(), (x306).get()); + Box x324 = new Box((int)0); + Box x325 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x324, x325, (x323).get(), (x307).get(), (x304).get()); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x326, x327, 0x0, (x284).get(), (x314).get()); + Box x328 = new Box((int)0); + Box x329 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x328, x329, (x327).get(), (x286).get(), (x316).get()); + Box x330 = new Box((int)0); + Box x331 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x330, x331, (x329).get(), (x288).get(), (x318).get()); + Box x332 = new Box((int)0); + Box x333 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x332, x333, (x331).get(), (x290).get(), (x320).get()); + Box x334 = new Box((int)0); + Box x335 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x334, x335, (x333).get(), (x292).get(), (x322).get()); + Box x336 = new Box((int)0); + Box x337 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x336, x337, (x335).get(), (x294).get(), (x324).get()); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x338, x339, (x337).get(), (x296).get(), ((x325).get() + (x305).get())); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x340, x341, (x339).get(), (x298).get(), (x302).get()); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x342, x343, (x341).get(), ((x299).get() + (x283).get()), (x303).get()); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x344, x345, 0x0, (x328).get(), (arg1[6])); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x346, x347, (x345).get(), (x330).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x348 = new Box((int)0); + Box x349 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x348, x349, (x347).get(), (x332).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x350 = new Box((int)0); + Box x351 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x350, x351, (x349).get(), (x334).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x352 = new Box((int)0); + Box x353 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x352, x353, (x351).get(), (x336).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x354 = new Box((int)0); + Box x355 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x354, x355, (x353).get(), (x338).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x356 = new Box((int)0); + Box x357 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x356, x357, (x355).get(), (x340).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x358 = new Box((int)0); + Box x359 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x358, x359, (x357).get(), (x342).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x360 = new Box((int)0); + Box x361 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x360, x361, (x344).get(), 0xee00bc4f); + Box x362 = new Box((int)0); + Box x363 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x362, x363, (x360).get(), 0xffffffff); + Box x364 = new Box((int)0); + Box x365 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x364, x365, (x360).get(), 0xffffffff); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x366, x367, (x360).get(), 0xffffffff); + Box x368 = new Box((int)0); + Box x369 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x368, x369, (x360).get(), 0xbce6faad); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x370, x371, (x360).get(), 0xa7179e84); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x372, x373, (x360).get(), 0xf3b9cac2); + Box x374 = new Box((int)0); + Box x375 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x374, x375, (x360).get(), 0xfc632551); + Box x376 = new Box((int)0); + Box x377 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x376, x377, 0x0, (x375).get(), (x372).get()); + Box x378 = new Box((int)0); + Box x379 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x378, x379, (x377).get(), (x373).get(), (x370).get()); + Box x380 = new Box((int)0); + Box x381 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x380, x381, (x379).get(), (x371).get(), (x368).get()); + Box x382 = new Box((int)0); + Box x383 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x382, x383, (x381).get(), (x369).get(), (x366).get()); + Box x384 = new Box((int)0); + Box x385 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x384, x385, (x383).get(), (x367).get(), (x364).get()); + Box x386 = new Box((int)0); + Box x387 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x386, x387, 0x0, (x344).get(), (x374).get()); + Box x388 = new Box((int)0); + Box x389 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x388, x389, (x387).get(), (x346).get(), (x376).get()); + Box x390 = new Box((int)0); + Box x391 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x390, x391, (x389).get(), (x348).get(), (x378).get()); + Box x392 = new Box((int)0); + Box x393 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x392, x393, (x391).get(), (x350).get(), (x380).get()); + Box x394 = new Box((int)0); + Box x395 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x394, x395, (x393).get(), (x352).get(), (x382).get()); + Box x396 = new Box((int)0); + Box x397 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x396, x397, (x395).get(), (x354).get(), (x384).get()); + Box x398 = new Box((int)0); + Box x399 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x398, x399, (x397).get(), (x356).get(), ((x385).get() + (x365).get())); + Box x400 = new Box((int)0); + Box x401 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x400, x401, (x399).get(), (x358).get(), (x362).get()); + Box x402 = new Box((int)0); + Box x403 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x402, x403, (x401).get(), ((x359).get() + (x343).get()), (x363).get()); + Box x404 = new Box((int)0); + Box x405 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x404, x405, 0x0, (x388).get(), (arg1[7])); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x406, x407, (x405).get(), (x390).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x408, x409, (x407).get(), (x392).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x410, x411, (x409).get(), (x394).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x412, x413, (x411).get(), (x396).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x414, x415, (x413).get(), (x398).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x416, x417, (x415).get(), (x400).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x418, x419, (x417).get(), (x402).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x420, x421, (x404).get(), 0xee00bc4f); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x422, x423, (x420).get(), 0xffffffff); + Box x424 = new Box((int)0); + Box x425 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x424, x425, (x420).get(), 0xffffffff); + Box x426 = new Box((int)0); + Box x427 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x426, x427, (x420).get(), 0xffffffff); + Box x428 = new Box((int)0); + Box x429 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x428, x429, (x420).get(), 0xbce6faad); + Box x430 = new Box((int)0); + Box x431 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x430, x431, (x420).get(), 0xa7179e84); + Box x432 = new Box((int)0); + Box x433 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x432, x433, (x420).get(), 0xf3b9cac2); + Box x434 = new Box((int)0); + Box x435 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x434, x435, (x420).get(), 0xfc632551); + Box x436 = new Box((int)0); + Box x437 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x436, x437, 0x0, (x435).get(), (x432).get()); + Box x438 = new Box((int)0); + Box x439 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x438, x439, (x437).get(), (x433).get(), (x430).get()); + Box x440 = new Box((int)0); + Box x441 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x440, x441, (x439).get(), (x431).get(), (x428).get()); + Box x442 = new Box((int)0); + Box x443 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x442, x443, (x441).get(), (x429).get(), (x426).get()); + Box x444 = new Box((int)0); + Box x445 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x444, x445, (x443).get(), (x427).get(), (x424).get()); + Box x446 = new Box((int)0); + Box x447 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x446, x447, 0x0, (x404).get(), (x434).get()); + Box x448 = new Box((int)0); + Box x449 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x448, x449, (x447).get(), (x406).get(), (x436).get()); + Box x450 = new Box((int)0); + Box x451 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x450, x451, (x449).get(), (x408).get(), (x438).get()); + Box x452 = new Box((int)0); + Box x453 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x452, x453, (x451).get(), (x410).get(), (x440).get()); + Box x454 = new Box((int)0); + Box x455 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x454, x455, (x453).get(), (x412).get(), (x442).get()); + Box x456 = new Box((int)0); + Box x457 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x456, x457, (x455).get(), (x414).get(), (x444).get()); + Box x458 = new Box((int)0); + Box x459 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x458, x459, (x457).get(), (x416).get(), ((x445).get() + (x425).get())); + Box x460 = new Box((int)0); + Box x461 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x460, x461, (x459).get(), (x418).get(), (x422).get()); + Box x462 = new Box((int)0); + Box x463 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x462, x463, (x461).get(), ((x419).get() + (x403).get()), (x423).get()); + Box x464 = new Box((int)0); + Box x465 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x464, x465, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x448).get(), 0xfc632551); + Box x466 = new Box((int)0); + Box x467 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x466, x467, (x465).get(), (x450).get(), 0xf3b9cac2); + Box x468 = new Box((int)0); + Box x469 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x468, x469, (x467).get(), (x452).get(), 0xa7179e84); + Box x470 = new Box((int)0); + Box x471 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x470, x471, (x469).get(), (x454).get(), 0xbce6faad); + Box x472 = new Box((int)0); + Box x473 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x472, x473, (x471).get(), (x456).get(), 0xffffffff); + Box x474 = new Box((int)0); + Box x475 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x474, x475, (x473).get(), (x458).get(), 0xffffffff); + Box x476 = new Box((int)0); + Box x477 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x476, x477, (x475).get(), (x460).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x478 = new Box((int)0); + Box x479 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x478, x479, (x477).get(), (x462).get(), 0xffffffff); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x480, x481, (x479).get(), (x463).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x482 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x482, (x481).get(), (x464).get(), (x448).get()); + Box x483 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x483, (x481).get(), (x466).get(), (x450).get()); + Box x484 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x484, (x481).get(), (x468).get(), (x452).get()); + Box x485 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x485, (x481).get(), (x470).get(), (x454).get()); + Box x486 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x486, (x481).get(), (x472).get(), (x456).get()); + Box x487 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x487, (x481).get(), (x474).get(), (x458).get()); + Box x488 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x488, (x481).get(), (x476).get(), (x460).get()); + Box x489 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x489, (x481).get(), (x478).get(), (x462).get()); + out1[0] = (x482).get(); + out1[1] = (x483).get(); + out1[2] = (x484).get(); + out1[3] = (x485).get(); + out1[4] = (x486).get(); + out1[5] = (x487).get(); + out1[6] = (x488).get(); + out1[7] = (x489).get(); +} + +/** + * The function fiat_P256Scalar_to_montgomery translates a field element into the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = eval arg1 mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_to_montgomery(int[] out1, final int[] arg1) { + int x1 = (arg1[1]); + int x2 = (arg1[2]); + int x3 = (arg1[3]); + int x4 = (arg1[4]); + int x5 = (arg1[5]); + int x6 = (arg1[6]); + int x7 = (arg1[7]); + int x8 = (arg1[0]); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x9, x10, x8, 0x66e12d94); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x11, x12, x8, 0xf3d95620); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x13, x14, x8, 0x2845b239); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x15, x16, x8, 0x2b6bec59); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x17, x18, x8, 0x4699799c); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x19, x20, x8, 0x49bd6fa6); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x21, x22, x8, 0x83244c95); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x23, x24, x8, 0xbe79eea2); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x37, x38, (x36).get(), (x12).get(), (x9).get()); + Box x39 = new Box((int)0); + Box x40 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x39, x40, (x23).get(), 0xee00bc4f); + Box x41 = new Box((int)0); + Box x42 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x41, x42, (x39).get(), 0xffffffff); + Box x43 = new Box((int)0); + Box x44 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x43, x44, (x39).get(), 0xffffffff); + Box x45 = new Box((int)0); + Box x46 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x45, x46, (x39).get(), 0xffffffff); + Box x47 = new Box((int)0); + Box x48 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x47, x48, (x39).get(), 0xbce6faad); + Box x49 = new Box((int)0); + Box x50 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x49, x50, (x39).get(), 0xa7179e84); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x51, x52, (x39).get(), 0xf3b9cac2); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x53, x54, (x39).get(), 0xfc632551); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x55, x56, 0x0, (x54).get(), (x51).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x57, x58, (x56).get(), (x52).get(), (x49).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x59, x60, (x58).get(), (x50).get(), (x47).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x61, x62, (x60).get(), (x48).get(), (x45).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x63, x64, (x62).get(), (x46).get(), (x43).get()); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x65, x66, 0x0, (x23).get(), (x53).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x67, x68, (x66).get(), (x25).get(), (x55).get()); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x69, x70, (x68).get(), (x27).get(), (x57).get()); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x71, x72, (x70).get(), (x29).get(), (x59).get()); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x73, x74, (x72).get(), (x31).get(), (x61).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x75, x76, (x74).get(), (x33).get(), (x63).get()); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x77, x78, (x76).get(), (x35).get(), ((x64).get() + (x44).get())); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x79, x80, (x78).get(), (x37).get(), (x41).get()); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x81, x82, (x80).get(), ((x38).get() + (x10).get()), (x42).get()); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x83, x84, x1, 0x66e12d94); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x85, x86, x1, 0xf3d95620); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x87, x88, x1, 0x2845b239); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x89, x90, x1, 0x2b6bec59); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x91, x92, x1, 0x4699799c); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x93, x94, x1, 0x49bd6fa6); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x95, x96, x1, 0x83244c95); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x97, x98, x1, 0xbe79eea2); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x99, x100, 0x0, (x98).get(), (x95).get()); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x101, x102, (x100).get(), (x96).get(), (x93).get()); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x103, x104, (x102).get(), (x94).get(), (x91).get()); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x105, x106, (x104).get(), (x92).get(), (x89).get()); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x107, x108, (x106).get(), (x90).get(), (x87).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x109, x110, (x108).get(), (x88).get(), (x85).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x111, x112, (x110).get(), (x86).get(), (x83).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x113, x114, 0x0, (x67).get(), (x97).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x115, x116, (x114).get(), (x69).get(), (x99).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x117, x118, (x116).get(), (x71).get(), (x101).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x119, x120, (x118).get(), (x73).get(), (x103).get()); + Box x121 = new Box((int)0); + Box x122 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x121, x122, (x120).get(), (x75).get(), (x105).get()); + Box x123 = new Box((int)0); + Box x124 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x123, x124, (x122).get(), (x77).get(), (x107).get()); + Box x125 = new Box((int)0); + Box x126 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x125, x126, (x124).get(), (x79).get(), (x109).get()); + Box x127 = new Box((int)0); + Box x128 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x127, x128, (x126).get(), (x81).get(), (x111).get()); + Box x129 = new Box((int)0); + Box x130 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x129, x130, (x113).get(), 0xee00bc4f); + Box x131 = new Box((int)0); + Box x132 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x131, x132, (x129).get(), 0xffffffff); + Box x133 = new Box((int)0); + Box x134 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x133, x134, (x129).get(), 0xffffffff); + Box x135 = new Box((int)0); + Box x136 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x135, x136, (x129).get(), 0xffffffff); + Box x137 = new Box((int)0); + Box x138 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x137, x138, (x129).get(), 0xbce6faad); + Box x139 = new Box((int)0); + Box x140 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x139, x140, (x129).get(), 0xa7179e84); + Box x141 = new Box((int)0); + Box x142 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x141, x142, (x129).get(), 0xf3b9cac2); + Box x143 = new Box((int)0); + Box x144 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x143, x144, (x129).get(), 0xfc632551); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x145, x146, 0x0, (x144).get(), (x141).get()); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x147, x148, (x146).get(), (x142).get(), (x139).get()); + Box x149 = new Box((int)0); + Box x150 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x149, x150, (x148).get(), (x140).get(), (x137).get()); + Box x151 = new Box((int)0); + Box x152 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x151, x152, (x150).get(), (x138).get(), (x135).get()); + Box x153 = new Box((int)0); + Box x154 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x153, x154, (x152).get(), (x136).get(), (x133).get()); + Box x155 = new Box((int)0); + Box x156 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x155, x156, 0x0, (x113).get(), (x143).get()); + Box x157 = new Box((int)0); + Box x158 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x157, x158, (x156).get(), (x115).get(), (x145).get()); + Box x159 = new Box((int)0); + Box x160 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x159, x160, (x158).get(), (x117).get(), (x147).get()); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x161, x162, (x160).get(), (x119).get(), (x149).get()); + Box x163 = new Box((int)0); + Box x164 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x163, x164, (x162).get(), (x121).get(), (x151).get()); + Box x165 = new Box((int)0); + Box x166 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x165, x166, (x164).get(), (x123).get(), (x153).get()); + Box x167 = new Box((int)0); + Box x168 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x167, x168, (x166).get(), (x125).get(), ((x154).get() + (x134).get())); + Box x169 = new Box((int)0); + Box x170 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x169, x170, (x168).get(), (x127).get(), (x131).get()); + Box x171 = new Box((int)0); + Box x172 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x171, x172, (x170).get(), (((x128).get() + (x82).get()) + ((x112).get() + (x84).get())), (x132).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x173, x174, x2, 0x66e12d94); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x175, x176, x2, 0xf3d95620); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x177, x178, x2, 0x2845b239); + Box x179 = new Box((int)0); + Box x180 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x179, x180, x2, 0x2b6bec59); + Box x181 = new Box((int)0); + Box x182 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x181, x182, x2, 0x4699799c); + Box x183 = new Box((int)0); + Box x184 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x183, x184, x2, 0x49bd6fa6); + Box x185 = new Box((int)0); + Box x186 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x185, x186, x2, 0x83244c95); + Box x187 = new Box((int)0); + Box x188 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x187, x188, x2, 0xbe79eea2); + Box x189 = new Box((int)0); + Box x190 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x189, x190, 0x0, (x188).get(), (x185).get()); + Box x191 = new Box((int)0); + Box x192 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x191, x192, (x190).get(), (x186).get(), (x183).get()); + Box x193 = new Box((int)0); + Box x194 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x193, x194, (x192).get(), (x184).get(), (x181).get()); + Box x195 = new Box((int)0); + Box x196 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x195, x196, (x194).get(), (x182).get(), (x179).get()); + Box x197 = new Box((int)0); + Box x198 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x197, x198, (x196).get(), (x180).get(), (x177).get()); + Box x199 = new Box((int)0); + Box x200 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x199, x200, (x198).get(), (x178).get(), (x175).get()); + Box x201 = new Box((int)0); + Box x202 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x201, x202, (x200).get(), (x176).get(), (x173).get()); + Box x203 = new Box((int)0); + Box x204 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x203, x204, 0x0, (x157).get(), (x187).get()); + Box x205 = new Box((int)0); + Box x206 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x205, x206, (x204).get(), (x159).get(), (x189).get()); + Box x207 = new Box((int)0); + Box x208 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x207, x208, (x206).get(), (x161).get(), (x191).get()); + Box x209 = new Box((int)0); + Box x210 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x209, x210, (x208).get(), (x163).get(), (x193).get()); + Box x211 = new Box((int)0); + Box x212 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x211, x212, (x210).get(), (x165).get(), (x195).get()); + Box x213 = new Box((int)0); + Box x214 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x213, x214, (x212).get(), (x167).get(), (x197).get()); + Box x215 = new Box((int)0); + Box x216 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x215, x216, (x214).get(), (x169).get(), (x199).get()); + Box x217 = new Box((int)0); + Box x218 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x217, x218, (x216).get(), (x171).get(), (x201).get()); + Box x219 = new Box((int)0); + Box x220 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x219, x220, (x203).get(), 0xee00bc4f); + Box x221 = new Box((int)0); + Box x222 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x221, x222, (x219).get(), 0xffffffff); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x223, x224, (x219).get(), 0xffffffff); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x225, x226, (x219).get(), 0xffffffff); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x227, x228, (x219).get(), 0xbce6faad); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x229, x230, (x219).get(), 0xa7179e84); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x231, x232, (x219).get(), 0xf3b9cac2); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x233, x234, (x219).get(), 0xfc632551); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x235, x236, 0x0, (x234).get(), (x231).get()); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x237, x238, (x236).get(), (x232).get(), (x229).get()); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x239, x240, (x238).get(), (x230).get(), (x227).get()); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x241, x242, (x240).get(), (x228).get(), (x225).get()); + Box x243 = new Box((int)0); + Box x244 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x243, x244, (x242).get(), (x226).get(), (x223).get()); + Box x245 = new Box((int)0); + Box x246 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x245, x246, 0x0, (x203).get(), (x233).get()); + Box x247 = new Box((int)0); + Box x248 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x247, x248, (x246).get(), (x205).get(), (x235).get()); + Box x249 = new Box((int)0); + Box x250 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x249, x250, (x248).get(), (x207).get(), (x237).get()); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x251, x252, (x250).get(), (x209).get(), (x239).get()); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x253, x254, (x252).get(), (x211).get(), (x241).get()); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x255, x256, (x254).get(), (x213).get(), (x243).get()); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x257, x258, (x256).get(), (x215).get(), ((x244).get() + (x224).get())); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x259, x260, (x258).get(), (x217).get(), (x221).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x261, x262, (x260).get(), (((x218).get() + (x172).get()) + ((x202).get() + (x174).get())), (x222).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x263, x264, x3, 0x66e12d94); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x265, x266, x3, 0xf3d95620); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x267, x268, x3, 0x2845b239); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x269, x270, x3, 0x2b6bec59); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x271, x272, x3, 0x4699799c); + Box x273 = new Box((int)0); + Box x274 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x273, x274, x3, 0x49bd6fa6); + Box x275 = new Box((int)0); + Box x276 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x275, x276, x3, 0x83244c95); + Box x277 = new Box((int)0); + Box x278 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x277, x278, x3, 0xbe79eea2); + Box x279 = new Box((int)0); + Box x280 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x279, x280, 0x0, (x278).get(), (x275).get()); + Box x281 = new Box((int)0); + Box x282 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x281, x282, (x280).get(), (x276).get(), (x273).get()); + Box x283 = new Box((int)0); + Box x284 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x283, x284, (x282).get(), (x274).get(), (x271).get()); + Box x285 = new Box((int)0); + Box x286 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x285, x286, (x284).get(), (x272).get(), (x269).get()); + Box x287 = new Box((int)0); + Box x288 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x287, x288, (x286).get(), (x270).get(), (x267).get()); + Box x289 = new Box((int)0); + Box x290 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x289, x290, (x288).get(), (x268).get(), (x265).get()); + Box x291 = new Box((int)0); + Box x292 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x291, x292, (x290).get(), (x266).get(), (x263).get()); + Box x293 = new Box((int)0); + Box x294 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x293, x294, 0x0, (x247).get(), (x277).get()); + Box x295 = new Box((int)0); + Box x296 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x295, x296, (x294).get(), (x249).get(), (x279).get()); + Box x297 = new Box((int)0); + Box x298 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x297, x298, (x296).get(), (x251).get(), (x281).get()); + Box x299 = new Box((int)0); + Box x300 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x299, x300, (x298).get(), (x253).get(), (x283).get()); + Box x301 = new Box((int)0); + Box x302 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x301, x302, (x300).get(), (x255).get(), (x285).get()); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x303, x304, (x302).get(), (x257).get(), (x287).get()); + Box x305 = new Box((int)0); + Box x306 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x305, x306, (x304).get(), (x259).get(), (x289).get()); + Box x307 = new Box((int)0); + Box x308 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x307, x308, (x306).get(), (x261).get(), (x291).get()); + Box x309 = new Box((int)0); + Box x310 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x309, x310, (x293).get(), 0xee00bc4f); + Box x311 = new Box((int)0); + Box x312 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x311, x312, (x309).get(), 0xffffffff); + Box x313 = new Box((int)0); + Box x314 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x313, x314, (x309).get(), 0xffffffff); + Box x315 = new Box((int)0); + Box x316 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x315, x316, (x309).get(), 0xffffffff); + Box x317 = new Box((int)0); + Box x318 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x317, x318, (x309).get(), 0xbce6faad); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x319, x320, (x309).get(), 0xa7179e84); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x321, x322, (x309).get(), 0xf3b9cac2); + Box x323 = new Box((int)0); + Box x324 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x323, x324, (x309).get(), 0xfc632551); + Box x325 = new Box((int)0); + Box x326 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x325, x326, 0x0, (x324).get(), (x321).get()); + Box x327 = new Box((int)0); + Box x328 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x327, x328, (x326).get(), (x322).get(), (x319).get()); + Box x329 = new Box((int)0); + Box x330 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x329, x330, (x328).get(), (x320).get(), (x317).get()); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x331, x332, (x330).get(), (x318).get(), (x315).get()); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x333, x334, (x332).get(), (x316).get(), (x313).get()); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x335, x336, 0x0, (x293).get(), (x323).get()); + Box x337 = new Box((int)0); + Box x338 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x337, x338, (x336).get(), (x295).get(), (x325).get()); + Box x339 = new Box((int)0); + Box x340 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x339, x340, (x338).get(), (x297).get(), (x327).get()); + Box x341 = new Box((int)0); + Box x342 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x341, x342, (x340).get(), (x299).get(), (x329).get()); + Box x343 = new Box((int)0); + Box x344 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x343, x344, (x342).get(), (x301).get(), (x331).get()); + Box x345 = new Box((int)0); + Box x346 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x345, x346, (x344).get(), (x303).get(), (x333).get()); + Box x347 = new Box((int)0); + Box x348 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x347, x348, (x346).get(), (x305).get(), ((x334).get() + (x314).get())); + Box x349 = new Box((int)0); + Box x350 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x349, x350, (x348).get(), (x307).get(), (x311).get()); + Box x351 = new Box((int)0); + Box x352 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x351, x352, (x350).get(), (((x308).get() + (x262).get()) + ((x292).get() + (x264).get())), (x312).get()); + Box x353 = new Box((int)0); + Box x354 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x353, x354, x4, 0x66e12d94); + Box x355 = new Box((int)0); + Box x356 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x355, x356, x4, 0xf3d95620); + Box x357 = new Box((int)0); + Box x358 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x357, x358, x4, 0x2845b239); + Box x359 = new Box((int)0); + Box x360 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x359, x360, x4, 0x2b6bec59); + Box x361 = new Box((int)0); + Box x362 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x361, x362, x4, 0x4699799c); + Box x363 = new Box((int)0); + Box x364 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x363, x364, x4, 0x49bd6fa6); + Box x365 = new Box((int)0); + Box x366 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x365, x366, x4, 0x83244c95); + Box x367 = new Box((int)0); + Box x368 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x367, x368, x4, 0xbe79eea2); + Box x369 = new Box((int)0); + Box x370 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x369, x370, 0x0, (x368).get(), (x365).get()); + Box x371 = new Box((int)0); + Box x372 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x371, x372, (x370).get(), (x366).get(), (x363).get()); + Box x373 = new Box((int)0); + Box x374 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x373, x374, (x372).get(), (x364).get(), (x361).get()); + Box x375 = new Box((int)0); + Box x376 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x375, x376, (x374).get(), (x362).get(), (x359).get()); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x377, x378, (x376).get(), (x360).get(), (x357).get()); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x379, x380, (x378).get(), (x358).get(), (x355).get()); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x381, x382, (x380).get(), (x356).get(), (x353).get()); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x383, x384, 0x0, (x337).get(), (x367).get()); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x385, x386, (x384).get(), (x339).get(), (x369).get()); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x387, x388, (x386).get(), (x341).get(), (x371).get()); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x389, x390, (x388).get(), (x343).get(), (x373).get()); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x391, x392, (x390).get(), (x345).get(), (x375).get()); + Box x393 = new Box((int)0); + Box x394 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x393, x394, (x392).get(), (x347).get(), (x377).get()); + Box x395 = new Box((int)0); + Box x396 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x395, x396, (x394).get(), (x349).get(), (x379).get()); + Box x397 = new Box((int)0); + Box x398 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x397, x398, (x396).get(), (x351).get(), (x381).get()); + Box x399 = new Box((int)0); + Box x400 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x399, x400, (x383).get(), 0xee00bc4f); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x401, x402, (x399).get(), 0xffffffff); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x403, x404, (x399).get(), 0xffffffff); + Box x405 = new Box((int)0); + Box x406 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x405, x406, (x399).get(), 0xffffffff); + Box x407 = new Box((int)0); + Box x408 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x407, x408, (x399).get(), 0xbce6faad); + Box x409 = new Box((int)0); + Box x410 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x409, x410, (x399).get(), 0xa7179e84); + Box x411 = new Box((int)0); + Box x412 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x411, x412, (x399).get(), 0xf3b9cac2); + Box x413 = new Box((int)0); + Box x414 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x413, x414, (x399).get(), 0xfc632551); + Box x415 = new Box((int)0); + Box x416 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x415, x416, 0x0, (x414).get(), (x411).get()); + Box x417 = new Box((int)0); + Box x418 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x417, x418, (x416).get(), (x412).get(), (x409).get()); + Box x419 = new Box((int)0); + Box x420 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x419, x420, (x418).get(), (x410).get(), (x407).get()); + Box x421 = new Box((int)0); + Box x422 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x421, x422, (x420).get(), (x408).get(), (x405).get()); + Box x423 = new Box((int)0); + Box x424 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x423, x424, (x422).get(), (x406).get(), (x403).get()); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x425, x426, 0x0, (x383).get(), (x413).get()); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x427, x428, (x426).get(), (x385).get(), (x415).get()); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x429, x430, (x428).get(), (x387).get(), (x417).get()); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x431, x432, (x430).get(), (x389).get(), (x419).get()); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x433, x434, (x432).get(), (x391).get(), (x421).get()); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x435, x436, (x434).get(), (x393).get(), (x423).get()); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x437, x438, (x436).get(), (x395).get(), ((x424).get() + (x404).get())); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x439, x440, (x438).get(), (x397).get(), (x401).get()); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x441, x442, (x440).get(), (((x398).get() + (x352).get()) + ((x382).get() + (x354).get())), (x402).get()); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x443, x444, x5, 0x66e12d94); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x445, x446, x5, 0xf3d95620); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x447, x448, x5, 0x2845b239); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x449, x450, x5, 0x2b6bec59); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x451, x452, x5, 0x4699799c); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x453, x454, x5, 0x49bd6fa6); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x455, x456, x5, 0x83244c95); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x457, x458, x5, 0xbe79eea2); + Box x459 = new Box((int)0); + Box x460 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x459, x460, 0x0, (x458).get(), (x455).get()); + Box x461 = new Box((int)0); + Box x462 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x461, x462, (x460).get(), (x456).get(), (x453).get()); + Box x463 = new Box((int)0); + Box x464 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x463, x464, (x462).get(), (x454).get(), (x451).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x465, x466, (x464).get(), (x452).get(), (x449).get()); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x467, x468, (x466).get(), (x450).get(), (x447).get()); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x469, x470, (x468).get(), (x448).get(), (x445).get()); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x471, x472, (x470).get(), (x446).get(), (x443).get()); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x473, x474, 0x0, (x427).get(), (x457).get()); + Box x475 = new Box((int)0); + Box x476 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x475, x476, (x474).get(), (x429).get(), (x459).get()); + Box x477 = new Box((int)0); + Box x478 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x477, x478, (x476).get(), (x431).get(), (x461).get()); + Box x479 = new Box((int)0); + Box x480 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x479, x480, (x478).get(), (x433).get(), (x463).get()); + Box x481 = new Box((int)0); + Box x482 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x481, x482, (x480).get(), (x435).get(), (x465).get()); + Box x483 = new Box((int)0); + Box x484 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x483, x484, (x482).get(), (x437).get(), (x467).get()); + Box x485 = new Box((int)0); + Box x486 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x485, x486, (x484).get(), (x439).get(), (x469).get()); + Box x487 = new Box((int)0); + Box x488 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x487, x488, (x486).get(), (x441).get(), (x471).get()); + Box x489 = new Box((int)0); + Box x490 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x489, x490, (x473).get(), 0xee00bc4f); + Box x491 = new Box((int)0); + Box x492 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x491, x492, (x489).get(), 0xffffffff); + Box x493 = new Box((int)0); + Box x494 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x493, x494, (x489).get(), 0xffffffff); + Box x495 = new Box((int)0); + Box x496 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x495, x496, (x489).get(), 0xffffffff); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x497, x498, (x489).get(), 0xbce6faad); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x499, x500, (x489).get(), 0xa7179e84); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x501, x502, (x489).get(), 0xf3b9cac2); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x503, x504, (x489).get(), 0xfc632551); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x505, x506, 0x0, (x504).get(), (x501).get()); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x507, x508, (x506).get(), (x502).get(), (x499).get()); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x509, x510, (x508).get(), (x500).get(), (x497).get()); + Box x511 = new Box((int)0); + Box x512 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x511, x512, (x510).get(), (x498).get(), (x495).get()); + Box x513 = new Box((int)0); + Box x514 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x513, x514, (x512).get(), (x496).get(), (x493).get()); + Box x515 = new Box((int)0); + Box x516 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x515, x516, 0x0, (x473).get(), (x503).get()); + Box x517 = new Box((int)0); + Box x518 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x517, x518, (x516).get(), (x475).get(), (x505).get()); + Box x519 = new Box((int)0); + Box x520 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x519, x520, (x518).get(), (x477).get(), (x507).get()); + Box x521 = new Box((int)0); + Box x522 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x521, x522, (x520).get(), (x479).get(), (x509).get()); + Box x523 = new Box((int)0); + Box x524 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x523, x524, (x522).get(), (x481).get(), (x511).get()); + Box x525 = new Box((int)0); + Box x526 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x525, x526, (x524).get(), (x483).get(), (x513).get()); + Box x527 = new Box((int)0); + Box x528 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x527, x528, (x526).get(), (x485).get(), ((x514).get() + (x494).get())); + Box x529 = new Box((int)0); + Box x530 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x529, x530, (x528).get(), (x487).get(), (x491).get()); + Box x531 = new Box((int)0); + Box x532 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x531, x532, (x530).get(), (((x488).get() + (x442).get()) + ((x472).get() + (x444).get())), (x492).get()); + Box x533 = new Box((int)0); + Box x534 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x533, x534, x6, 0x66e12d94); + Box x535 = new Box((int)0); + Box x536 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x535, x536, x6, 0xf3d95620); + Box x537 = new Box((int)0); + Box x538 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x537, x538, x6, 0x2845b239); + Box x539 = new Box((int)0); + Box x540 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x539, x540, x6, 0x2b6bec59); + Box x541 = new Box((int)0); + Box x542 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x541, x542, x6, 0x4699799c); + Box x543 = new Box((int)0); + Box x544 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x543, x544, x6, 0x49bd6fa6); + Box x545 = new Box((int)0); + Box x546 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x545, x546, x6, 0x83244c95); + Box x547 = new Box((int)0); + Box x548 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x547, x548, x6, 0xbe79eea2); + Box x549 = new Box((int)0); + Box x550 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x549, x550, 0x0, (x548).get(), (x545).get()); + Box x551 = new Box((int)0); + Box x552 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x551, x552, (x550).get(), (x546).get(), (x543).get()); + Box x553 = new Box((int)0); + Box x554 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x553, x554, (x552).get(), (x544).get(), (x541).get()); + Box x555 = new Box((int)0); + Box x556 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x555, x556, (x554).get(), (x542).get(), (x539).get()); + Box x557 = new Box((int)0); + Box x558 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x557, x558, (x556).get(), (x540).get(), (x537).get()); + Box x559 = new Box((int)0); + Box x560 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x559, x560, (x558).get(), (x538).get(), (x535).get()); + Box x561 = new Box((int)0); + Box x562 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x561, x562, (x560).get(), (x536).get(), (x533).get()); + Box x563 = new Box((int)0); + Box x564 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x563, x564, 0x0, (x517).get(), (x547).get()); + Box x565 = new Box((int)0); + Box x566 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x565, x566, (x564).get(), (x519).get(), (x549).get()); + Box x567 = new Box((int)0); + Box x568 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x567, x568, (x566).get(), (x521).get(), (x551).get()); + Box x569 = new Box((int)0); + Box x570 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x569, x570, (x568).get(), (x523).get(), (x553).get()); + Box x571 = new Box((int)0); + Box x572 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x571, x572, (x570).get(), (x525).get(), (x555).get()); + Box x573 = new Box((int)0); + Box x574 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x573, x574, (x572).get(), (x527).get(), (x557).get()); + Box x575 = new Box((int)0); + Box x576 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x575, x576, (x574).get(), (x529).get(), (x559).get()); + Box x577 = new Box((int)0); + Box x578 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x577, x578, (x576).get(), (x531).get(), (x561).get()); + Box x579 = new Box((int)0); + Box x580 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x579, x580, (x563).get(), 0xee00bc4f); + Box x581 = new Box((int)0); + Box x582 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x581, x582, (x579).get(), 0xffffffff); + Box x583 = new Box((int)0); + Box x584 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x583, x584, (x579).get(), 0xffffffff); + Box x585 = new Box((int)0); + Box x586 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x585, x586, (x579).get(), 0xffffffff); + Box x587 = new Box((int)0); + Box x588 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x587, x588, (x579).get(), 0xbce6faad); + Box x589 = new Box((int)0); + Box x590 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x589, x590, (x579).get(), 0xa7179e84); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x591, x592, (x579).get(), 0xf3b9cac2); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x593, x594, (x579).get(), 0xfc632551); + Box x595 = new Box((int)0); + Box x596 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x595, x596, 0x0, (x594).get(), (x591).get()); + Box x597 = new Box((int)0); + Box x598 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x597, x598, (x596).get(), (x592).get(), (x589).get()); + Box x599 = new Box((int)0); + Box x600 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x599, x600, (x598).get(), (x590).get(), (x587).get()); + Box x601 = new Box((int)0); + Box x602 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x601, x602, (x600).get(), (x588).get(), (x585).get()); + Box x603 = new Box((int)0); + Box x604 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x603, x604, (x602).get(), (x586).get(), (x583).get()); + Box x605 = new Box((int)0); + Box x606 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x605, x606, 0x0, (x563).get(), (x593).get()); + Box x607 = new Box((int)0); + Box x608 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x607, x608, (x606).get(), (x565).get(), (x595).get()); + Box x609 = new Box((int)0); + Box x610 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x609, x610, (x608).get(), (x567).get(), (x597).get()); + Box x611 = new Box((int)0); + Box x612 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x611, x612, (x610).get(), (x569).get(), (x599).get()); + Box x613 = new Box((int)0); + Box x614 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x613, x614, (x612).get(), (x571).get(), (x601).get()); + Box x615 = new Box((int)0); + Box x616 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x615, x616, (x614).get(), (x573).get(), (x603).get()); + Box x617 = new Box((int)0); + Box x618 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x617, x618, (x616).get(), (x575).get(), ((x604).get() + (x584).get())); + Box x619 = new Box((int)0); + Box x620 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x619, x620, (x618).get(), (x577).get(), (x581).get()); + Box x621 = new Box((int)0); + Box x622 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x621, x622, (x620).get(), (((x578).get() + (x532).get()) + ((x562).get() + (x534).get())), (x582).get()); + Box x623 = new Box((int)0); + Box x624 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x623, x624, x7, 0x66e12d94); + Box x625 = new Box((int)0); + Box x626 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x625, x626, x7, 0xf3d95620); + Box x627 = new Box((int)0); + Box x628 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x627, x628, x7, 0x2845b239); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x629, x630, x7, 0x2b6bec59); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x631, x632, x7, 0x4699799c); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x633, x634, x7, 0x49bd6fa6); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x635, x636, x7, 0x83244c95); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x637, x638, x7, 0xbe79eea2); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x639, x640, 0x0, (x638).get(), (x635).get()); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x641, x642, (x640).get(), (x636).get(), (x633).get()); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x643, x644, (x642).get(), (x634).get(), (x631).get()); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x645, x646, (x644).get(), (x632).get(), (x629).get()); + Box x647 = new Box((int)0); + Box x648 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x647, x648, (x646).get(), (x630).get(), (x627).get()); + Box x649 = new Box((int)0); + Box x650 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x649, x650, (x648).get(), (x628).get(), (x625).get()); + Box x651 = new Box((int)0); + Box x652 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x651, x652, (x650).get(), (x626).get(), (x623).get()); + Box x653 = new Box((int)0); + Box x654 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x653, x654, 0x0, (x607).get(), (x637).get()); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x655, x656, (x654).get(), (x609).get(), (x639).get()); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x657, x658, (x656).get(), (x611).get(), (x641).get()); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x659, x660, (x658).get(), (x613).get(), (x643).get()); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x661, x662, (x660).get(), (x615).get(), (x645).get()); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x663, x664, (x662).get(), (x617).get(), (x647).get()); + Box x665 = new Box((int)0); + Box x666 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x665, x666, (x664).get(), (x619).get(), (x649).get()); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x667, x668, (x666).get(), (x621).get(), (x651).get()); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x669, x670, (x653).get(), 0xee00bc4f); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x671, x672, (x669).get(), 0xffffffff); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x673, x674, (x669).get(), 0xffffffff); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x675, x676, (x669).get(), 0xffffffff); + Box x677 = new Box((int)0); + Box x678 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x677, x678, (x669).get(), 0xbce6faad); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x679, x680, (x669).get(), 0xa7179e84); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x681, x682, (x669).get(), 0xf3b9cac2); + Box x683 = new Box((int)0); + Box x684 = new Box((int)0); + fiat_P256Scalar_mulx_u32(x683, x684, (x669).get(), 0xfc632551); + Box x685 = new Box((int)0); + Box x686 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x685, x686, 0x0, (x684).get(), (x681).get()); + Box x687 = new Box((int)0); + Box x688 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x687, x688, (x686).get(), (x682).get(), (x679).get()); + Box x689 = new Box((int)0); + Box x690 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x689, x690, (x688).get(), (x680).get(), (x677).get()); + Box x691 = new Box((int)0); + Box x692 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x691, x692, (x690).get(), (x678).get(), (x675).get()); + Box x693 = new Box((int)0); + Box x694 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x693, x694, (x692).get(), (x676).get(), (x673).get()); + Box x695 = new Box((int)0); + Box x696 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x695, x696, 0x0, (x653).get(), (x683).get()); + Box x697 = new Box((int)0); + Box x698 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x697, x698, (x696).get(), (x655).get(), (x685).get()); + Box x699 = new Box((int)0); + Box x700 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x699, x700, (x698).get(), (x657).get(), (x687).get()); + Box x701 = new Box((int)0); + Box x702 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x701, x702, (x700).get(), (x659).get(), (x689).get()); + Box x703 = new Box((int)0); + Box x704 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x703, x704, (x702).get(), (x661).get(), (x691).get()); + Box x705 = new Box((int)0); + Box x706 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x705, x706, (x704).get(), (x663).get(), (x693).get()); + Box x707 = new Box((int)0); + Box x708 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x707, x708, (x706).get(), (x665).get(), ((x694).get() + (x674).get())); + Box x709 = new Box((int)0); + Box x710 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x709, x710, (x708).get(), (x667).get(), (x671).get()); + Box x711 = new Box((int)0); + Box x712 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x711, x712, (x710).get(), (((x668).get() + (x622).get()) + ((x652).get() + (x624).get())), (x672).get()); + Box x713 = new Box((int)0); + Box x714 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x713, x714, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x697).get(), 0xfc632551); + Box x715 = new Box((int)0); + Box x716 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x715, x716, (x714).get(), (x699).get(), 0xf3b9cac2); + Box x717 = new Box((int)0); + Box x718 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x717, x718, (x716).get(), (x701).get(), 0xa7179e84); + Box x719 = new Box((int)0); + Box x720 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x719, x720, (x718).get(), (x703).get(), 0xbce6faad); + Box x721 = new Box((int)0); + Box x722 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x721, x722, (x720).get(), (x705).get(), 0xffffffff); + Box x723 = new Box((int)0); + Box x724 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x723, x724, (x722).get(), (x707).get(), 0xffffffff); + Box x725 = new Box((int)0); + Box x726 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x725, x726, (x724).get(), (x709).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x727 = new Box((int)0); + Box x728 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x727, x728, (x726).get(), (x711).get(), 0xffffffff); + Box x729 = new Box((int)0); + Box x730 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x729, x730, (x728).get(), (x712).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x731 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x731, (x730).get(), (x713).get(), (x697).get()); + Box x732 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x732, (x730).get(), (x715).get(), (x699).get()); + Box x733 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x733, (x730).get(), (x717).get(), (x701).get()); + Box x734 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x734, (x730).get(), (x719).get(), (x703).get()); + Box x735 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x735, (x730).get(), (x721).get(), (x705).get()); + Box x736 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x736, (x730).get(), (x723).get(), (x707).get()); + Box x737 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x737, (x730).get(), (x725).get(), (x709).get()); + Box x738 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x738, (x730).get(), (x727).get(), (x711).get()); + out1[0] = (x731).get(); + out1[1] = (x732).get(); + out1[2] = (x733).get(); + out1[3] = (x734).get(); + out1[4] = (x735).get(); + out1[5] = (x736).get(); + out1[6] = (x737).get(); + out1[7] = (x738).get(); +} + +/** + * The function fiat_P256Scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ */ +public static void fiat_P256Scalar_nonzero(Box out1, final int[] arg1) { + int x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | (arg1[7])))))))); + out1.set(x1); +} + +/** + * The function fiat_P256Scalar_selectznz is a multi-limb conditional select.

+ *

+ * Postconditions:

+ * out1 = (if arg1 = 0 then arg2 else arg3)

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_selectznz(int[] out1, int arg1, final int[] arg2, final int[] arg3) { + Box x1 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x1, arg1, (arg2[0]), (arg3[0])); + Box x2 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x2, arg1, (arg2[1]), (arg3[1])); + Box x3 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x3, arg1, (arg2[2]), (arg3[2])); + Box x4 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x4, arg1, (arg2[3]), (arg3[3])); + Box x5 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x5, arg1, (arg2[4]), (arg3[4])); + Box x6 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x6, arg1, (arg2[5]), (arg3[5])); + Box x7 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x7, arg1, (arg2[6]), (arg3[6])); + Box x8 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x8, arg1, (arg2[7]), (arg3[7])); + out1[0] = (x1).get(); + out1[1] = (x2).get(); + out1[2] = (x3).get(); + out1[3] = (x4).get(); + out1[4] = (x5).get(); + out1[5] = (x6).get(); + out1[6] = (x7).get(); + out1[7] = (x8).get(); +} + +/** + * The function fiat_P256Scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31]

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]

+ */ +public static void fiat_P256Scalar_to_bytes(int[] out1, final int[] arg1) { + int x1 = (arg1[7]); + int x2 = (arg1[6]); + int x3 = (arg1[5]); + int x4 = (arg1[4]); + int x5 = (arg1[3]); + int x6 = (arg1[2]); + int x7 = (arg1[1]); + int x8 = (arg1[0]); + int x9 = (x8 & 0xff); + int x10 = (x8 >>> 8); + int x11 = (x10 & 0xff); + int x12 = (x10 >>> 8); + int x13 = (x12 & 0xff); + int x14 = (x12 >>> 8); + int x15 = (x7 & 0xff); + int x16 = (x7 >>> 8); + int x17 = (x16 & 0xff); + int x18 = (x16 >>> 8); + int x19 = (x18 & 0xff); + int x20 = (x18 >>> 8); + int x21 = (x6 & 0xff); + int x22 = (x6 >>> 8); + int x23 = (x22 & 0xff); + int x24 = (x22 >>> 8); + int x25 = (x24 & 0xff); + int x26 = (x24 >>> 8); + int x27 = (x5 & 0xff); + int x28 = (x5 >>> 8); + int x29 = (x28 & 0xff); + int x30 = (x28 >>> 8); + int x31 = (x30 & 0xff); + int x32 = (x30 >>> 8); + int x33 = (x4 & 0xff); + int x34 = (x4 >>> 8); + int x35 = (x34 & 0xff); + int x36 = (x34 >>> 8); + int x37 = (x36 & 0xff); + int x38 = (x36 >>> 8); + int x39 = (x3 & 0xff); + int x40 = (x3 >>> 8); + int x41 = (x40 & 0xff); + int x42 = (x40 >>> 8); + int x43 = (x42 & 0xff); + int x44 = (x42 >>> 8); + int x45 = (x2 & 0xff); + int x46 = (x2 >>> 8); + int x47 = (x46 & 0xff); + int x48 = (x46 >>> 8); + int x49 = (x48 & 0xff); + int x50 = (x48 >>> 8); + int x51 = (x1 & 0xff); + int x52 = (x1 >>> 8); + int x53 = (x52 & 0xff); + int x54 = (x52 >>> 8); + int x55 = (x54 & 0xff); + int x56 = (x54 >>> 8); + out1[0] = x9; + out1[1] = x11; + out1[2] = x13; + out1[3] = x14; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x26; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x38; + out1[20] = x39; + out1[21] = x41; + out1[22] = x43; + out1[23] = x44; + out1[24] = x45; + out1[25] = x47; + out1[26] = x49; + out1[27] = x50; + out1[28] = x51; + out1[29] = x53; + out1[30] = x55; + out1[31] = x56; +} + +/** + * The function fiat_P256Scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order.

+ *

+ * Preconditions:

+ * 0 ≤ bytes_eval arg1 < m

+ * Postconditions:

+ * eval out1 mod m = bytes_eval arg1 mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_from_bytes(int[] out1, final int[] arg1) { + int x1 = ((arg1[31]) << 24); + int x2 = ((arg1[30]) << 16); + int x3 = ((arg1[29]) << 8); + int x4 = (arg1[28]); + int x5 = ((arg1[27]) << 24); + int x6 = ((arg1[26]) << 16); + int x7 = ((arg1[25]) << 8); + int x8 = (arg1[24]); + int x9 = ((arg1[23]) << 24); + int x10 = ((arg1[22]) << 16); + int x11 = ((arg1[21]) << 8); + int x12 = (arg1[20]); + int x13 = ((arg1[19]) << 24); + int x14 = ((arg1[18]) << 16); + int x15 = ((arg1[17]) << 8); + int x16 = (arg1[16]); + int x17 = ((arg1[15]) << 24); + int x18 = ((arg1[14]) << 16); + int x19 = ((arg1[13]) << 8); + int x20 = (arg1[12]); + int x21 = ((arg1[11]) << 24); + int x22 = ((arg1[10]) << 16); + int x23 = ((arg1[9]) << 8); + int x24 = (arg1[8]); + int x25 = ((arg1[7]) << 24); + int x26 = ((arg1[6]) << 16); + int x27 = ((arg1[5]) << 8); + int x28 = (arg1[4]); + int x29 = ((arg1[3]) << 24); + int x30 = ((arg1[2]) << 16); + int x31 = ((arg1[1]) << 8); + int x32 = (arg1[0]); + int x33 = (x31 + x32); + int x34 = (x30 + x33); + int x35 = (x29 + x34); + int x36 = (x27 + x28); + int x37 = (x26 + x36); + int x38 = (x25 + x37); + int x39 = (x23 + x24); + int x40 = (x22 + x39); + int x41 = (x21 + x40); + int x42 = (x19 + x20); + int x43 = (x18 + x42); + int x44 = (x17 + x43); + int x45 = (x15 + x16); + int x46 = (x14 + x45); + int x47 = (x13 + x46); + int x48 = (x11 + x12); + int x49 = (x10 + x48); + int x50 = (x9 + x49); + int x51 = (x7 + x8); + int x52 = (x6 + x51); + int x53 = (x5 + x52); + int x54 = (x3 + x4); + int x55 = (x2 + x54); + int x56 = (x1 + x55); + out1[0] = x35; + out1[1] = x38; + out1[2] = x41; + out1[3] = x44; + out1[4] = x47; + out1[5] = x50; + out1[6] = x53; + out1[7] = x56; +} + +/** + * The function fiat_P256Scalar_set_one returns the field element one in the Montgomery domain.

+ *

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = 1 mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_set_one(int[] out1) { + out1[0] = 0x39cdaaf; + out1[1] = 0xc46353d; + out1[2] = 0x58e8617b; + out1[3] = 0x43190552; + out1[4] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[5] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[6] = 0xffffffff; + out1[7] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); +} + +/** + * The function fiat_P256Scalar_msat returns the saturated representation of the prime modulus.

+ *

+ * Postconditions:

+ * twos_complement_eval out1 = m

+ * 0 ≤ eval out1 < m

+ *

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_msat(int[] out1) { + out1[0] = 0xfc632551; + out1[1] = 0xf3b9cac2; + out1[2] = 0xa7179e84; + out1[3] = 0xbce6faad; + out1[4] = 0xffffffff; + out1[5] = 0xffffffff; + out1[6] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[7] = 0xffffffff; + out1[8] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); +} + +/** + * The function fiat_P256Scalar_divstep computes a divstep.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg4 < m

+ * 0 ≤ eval arg5 < m

+ * Postconditions:

+ * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1)

+ * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2)

+ * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋)

+ * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m)

+ * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m)

+ * 0 ≤ eval out5 < m

+ * 0 ≤ eval out5 < m

+ * 0 ≤ eval out2 < m

+ * 0 ≤ eval out3 < m

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0xffffffff]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_divstep(Box out1, int[] out2, int[] out3, int[] out4, int[] out5, int arg1, final int[] arg2, final int[] arg3, final int[] arg4, final int[] arg5) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x1, x2, 0x0, (~arg1), 0x1); + int x3 = (((x1).get() >>> 31) & ((arg3[0]) & 0x1)); + Box x4 = new Box((int)0); + Box x5 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x4, x5, 0x0, (~arg1), 0x1); + Box x6 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x6, x3, arg1, (x4).get()); + Box x7 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x7, x3, (arg2[0]), (arg3[0])); + Box x8 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x8, x3, (arg2[1]), (arg3[1])); + Box x9 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x9, x3, (arg2[2]), (arg3[2])); + Box x10 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x10, x3, (arg2[3]), (arg3[3])); + Box x11 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x11, x3, (arg2[4]), (arg3[4])); + Box x12 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x12, x3, (arg2[5]), (arg3[5])); + Box x13 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x13, x3, (arg2[6]), (arg3[6])); + Box x14 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x14, x3, (arg2[7]), (arg3[7])); + Box x15 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x15, x3, (arg2[8]), (arg3[8])); + Box x16 = new Box((int)0); + Box x17 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x16, x17, 0x0, 0x1, (~(arg2[0]))); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x18, x19, (x17).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[1]))); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x20, x21, (x19).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[2]))); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x22, x23, (x21).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[3]))); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x24, x25, (x23).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[4]))); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x26, x27, (x25).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[5]))); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x28, x29, (x27).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[6]))); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x30, x31, (x29).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[7]))); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x32, x33, (x31).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[8]))); + Box x34 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x34, x3, (arg3[0]), (x16).get()); + Box x35 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x35, x3, (arg3[1]), (x18).get()); + Box x36 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x36, x3, (arg3[2]), (x20).get()); + Box x37 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x37, x3, (arg3[3]), (x22).get()); + Box x38 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x38, x3, (arg3[4]), (x24).get()); + Box x39 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x39, x3, (arg3[5]), (x26).get()); + Box x40 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x40, x3, (arg3[6]), (x28).get()); + Box x41 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x41, x3, (arg3[7]), (x30).get()); + Box x42 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x42, x3, (arg3[8]), (x32).get()); + Box x43 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x43, x3, (arg4[0]), (arg5[0])); + Box x44 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x44, x3, (arg4[1]), (arg5[1])); + Box x45 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x45, x3, (arg4[2]), (arg5[2])); + Box x46 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x46, x3, (arg4[3]), (arg5[3])); + Box x47 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x47, x3, (arg4[4]), (arg5[4])); + Box x48 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x48, x3, (arg4[5]), (arg5[5])); + Box x49 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x49, x3, (arg4[6]), (arg5[6])); + Box x50 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x50, x3, (arg4[7]), (arg5[7])); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x51, x52, 0x0, (x43).get(), (x43).get()); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x53, x54, (x52).get(), (x44).get(), (x44).get()); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x55, x56, (x54).get(), (x45).get(), (x45).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x57, x58, (x56).get(), (x46).get(), (x46).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x59, x60, (x58).get(), (x47).get(), (x47).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x61, x62, (x60).get(), (x48).get(), (x48).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x63, x64, (x62).get(), (x49).get(), (x49).get()); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x65, x66, (x64).get(), (x50).get(), (x50).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x67, x68, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x51).get(), 0xfc632551); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x69, x70, (x68).get(), (x53).get(), 0xf3b9cac2); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x71, x72, (x70).get(), (x55).get(), 0xa7179e84); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x73, x74, (x72).get(), (x57).get(), 0xbce6faad); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x75, x76, (x74).get(), (x59).get(), 0xffffffff); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x77, x78, (x76).get(), (x61).get(), 0xffffffff); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x79, x80, (x78).get(), (x63).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x81, x82, (x80).get(), (x65).get(), 0xffffffff); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x83, x84, (x82).get(), (x66).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + int x85 = (arg4[7]); + int x86 = (arg4[6]); + int x87 = (arg4[5]); + int x88 = (arg4[4]); + int x89 = (arg4[3]); + int x90 = (arg4[2]); + int x91 = (arg4[1]); + int x92 = (arg4[0]); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x93, x94, 0x0, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x92); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x95, x96, (x94).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x91); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x97, x98, (x96).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x90); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x99, x100, (x98).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x89); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x101, x102, (x100).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x88); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x103, x104, (x102).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x87); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x105, x106, (x104).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x86); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x107, x108, (x106).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x85); + Box x109 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x109, (x108).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), 0xffffffff); + Box x110 = new Box((int)0); + Box x111 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x110, x111, 0x0, (x93).get(), ((x109).get() & 0xfc632551)); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x112, x113, (x111).get(), (x95).get(), ((x109).get() & 0xf3b9cac2)); + Box x114 = new Box((int)0); + Box x115 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x114, x115, (x113).get(), (x97).get(), ((x109).get() & 0xa7179e84)); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x116, x117, (x115).get(), (x99).get(), ((x109).get() & 0xbce6faad)); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x118, x119, (x117).get(), (x101).get(), (x109).get()); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x120, x121, (x119).get(), (x103).get(), (x109).get()); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x122, x123, (x121).get(), (x105).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x124, x125, (x123).get(), (x107).get(), (x109).get()); + Box x126 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x126, x3, (arg5[0]), (x110).get()); + Box x127 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x127, x3, (arg5[1]), (x112).get()); + Box x128 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x128, x3, (arg5[2]), (x114).get()); + Box x129 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x129, x3, (arg5[3]), (x116).get()); + Box x130 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x130, x3, (arg5[4]), (x118).get()); + Box x131 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x131, x3, (arg5[5]), (x120).get()); + Box x132 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x132, x3, (arg5[6]), (x122).get()); + Box x133 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x133, x3, (arg5[7]), (x124).get()); + int x134 = ((x34).get() & 0x1); + Box x135 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x135, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x7).get()); + Box x136 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x136, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x8).get()); + Box x137 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x137, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x9).get()); + Box x138 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x138, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x10).get()); + Box x139 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x139, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x11).get()); + Box x140 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x140, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x12).get()); + Box x141 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x141, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x13).get()); + Box x142 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x142, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x14).get()); + Box x143 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x143, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x15).get()); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x144, x145, 0x0, (x34).get(), (x135).get()); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x146, x147, (x145).get(), (x35).get(), (x136).get()); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x148, x149, (x147).get(), (x36).get(), (x137).get()); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x150, x151, (x149).get(), (x37).get(), (x138).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x152, x153, (x151).get(), (x38).get(), (x139).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x154, x155, (x153).get(), (x39).get(), (x140).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x156, x157, (x155).get(), (x40).get(), (x141).get()); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x158, x159, (x157).get(), (x41).get(), (x142).get()); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x160, x161, (x159).get(), (x42).get(), (x143).get()); + Box x162 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x162, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x43).get()); + Box x163 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x163, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x44).get()); + Box x164 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x164, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x45).get()); + Box x165 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x165, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x46).get()); + Box x166 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x166, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x47).get()); + Box x167 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x167, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x48).get()); + Box x168 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x168, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x49).get()); + Box x169 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x169, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x50).get()); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x170, x171, 0x0, (x126).get(), (x162).get()); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x172, x173, (x171).get(), (x127).get(), (x163).get()); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x174, x175, (x173).get(), (x128).get(), (x164).get()); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x176, x177, (x175).get(), (x129).get(), (x165).get()); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x178, x179, (x177).get(), (x130).get(), (x166).get()); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x180, x181, (x179).get(), (x131).get(), (x167).get()); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x182, x183, (x181).get(), (x132).get(), (x168).get()); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x184, x185, (x183).get(), (x133).get(), (x169).get()); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x186, x187, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x170).get(), 0xfc632551); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x188, x189, (x187).get(), (x172).get(), 0xf3b9cac2); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x190, x191, (x189).get(), (x174).get(), 0xa7179e84); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x192, x193, (x191).get(), (x176).get(), 0xbce6faad); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x194, x195, (x193).get(), (x178).get(), 0xffffffff); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x196, x197, (x195).get(), (x180).get(), 0xffffffff); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x198, x199, (x197).get(), (x182).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x200, x201, (x199).get(), (x184).get(), 0xffffffff); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_P256Scalar_subborrowx_u32(x202, x203, (x201).get(), (x185).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_P256Scalar_addcarryx_u32(x204, x205, 0x0, (x6).get(), 0x1); + int x206 = (((x144).get() >>> 1) | (((x146).get() << 31) & 0xffffffff)); + int x207 = (((x146).get() >>> 1) | (((x148).get() << 31) & 0xffffffff)); + int x208 = (((x148).get() >>> 1) | (((x150).get() << 31) & 0xffffffff)); + int x209 = (((x150).get() >>> 1) | (((x152).get() << 31) & 0xffffffff)); + int x210 = (((x152).get() >>> 1) | (((x154).get() << 31) & 0xffffffff)); + int x211 = (((x154).get() >>> 1) | (((x156).get() << 31) & 0xffffffff)); + int x212 = (((x156).get() >>> 1) | (((x158).get() << 31) & 0xffffffff)); + int x213 = (((x158).get() >>> 1) | (((x160).get() << 31) & 0xffffffff)); + int x214 = (((x160).get() & 0x80000000) | ((x160).get() >>> 1)); + Box x215 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x215, (x84).get(), (x67).get(), (x51).get()); + Box x216 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x216, (x84).get(), (x69).get(), (x53).get()); + Box x217 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x217, (x84).get(), (x71).get(), (x55).get()); + Box x218 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x218, (x84).get(), (x73).get(), (x57).get()); + Box x219 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x219, (x84).get(), (x75).get(), (x59).get()); + Box x220 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x220, (x84).get(), (x77).get(), (x61).get()); + Box x221 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x221, (x84).get(), (x79).get(), (x63).get()); + Box x222 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x222, (x84).get(), (x81).get(), (x65).get()); + Box x223 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x223, (x203).get(), (x186).get(), (x170).get()); + Box x224 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x224, (x203).get(), (x188).get(), (x172).get()); + Box x225 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x225, (x203).get(), (x190).get(), (x174).get()); + Box x226 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x226, (x203).get(), (x192).get(), (x176).get()); + Box x227 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x227, (x203).get(), (x194).get(), (x178).get()); + Box x228 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x228, (x203).get(), (x196).get(), (x180).get()); + Box x229 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x229, (x203).get(), (x198).get(), (x182).get()); + Box x230 = new Box((int)0); + fiat_P256Scalar_cmovznz_u32(x230, (x203).get(), (x200).get(), (x184).get()); + out1.set((x204).get()); + out2[0] = (x7).get(); + out2[1] = (x8).get(); + out2[2] = (x9).get(); + out2[3] = (x10).get(); + out2[4] = (x11).get(); + out2[5] = (x12).get(); + out2[6] = (x13).get(); + out2[7] = (x14).get(); + out2[8] = (x15).get(); + out3[0] = x206; + out3[1] = x207; + out3[2] = x208; + out3[3] = x209; + out3[4] = x210; + out3[5] = x211; + out3[6] = x212; + out3[7] = x213; + out3[8] = x214; + out4[0] = (x215).get(); + out4[1] = (x216).get(); + out4[2] = (x217).get(); + out4[3] = (x218).get(); + out4[4] = (x219).get(); + out4[5] = (x220).get(); + out4[6] = (x221).get(); + out4[7] = (x222).get(); + out5[0] = (x223).get(); + out5[1] = (x224).get(); + out5[2] = (x225).get(); + out5[3] = (x226).get(); + out5[4] = (x227).get(); + out5[5] = (x228).get(); + out5[6] = (x229).get(); + out5[7] = (x230).get(); +} + +/** + * The function fiat_P256Scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form).

+ *

+ * Postconditions:

+ * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋)

+ * 0 ≤ eval out1 < m

+ *

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P256Scalar_divstep_precomp(int[] out1) { + out1[0] = 0xb7fcfbb5; + out1[1] = 0xd739262f; + out1[2] = 0x20074414; + out1[3] = 0x8ac6f75d; + out1[4] = 0xb5e3c256; + out1[5] = 0xc67428bf; + out1[6] = 0xeda7aedf; + out1[7] = 0x444962f2; +} + +} diff --git a/fiat-java/src/FiatP384Scalar.java b/fiat-java/src/FiatP384Scalar.java new file mode 100644 index 0000000000..20a8836814 --- /dev/null +++ b/fiat-java/src/FiatP384Scalar.java @@ -0,0 +1,11426 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Java --cmovznz-by-mul --widen-carry --widen-bytes --internal-static --package-name fiat_crypto --class-case UpperCamelCase --no-field-element-typedefs P384Scalar 32 '2^384 - 1388124618062372383947042015309946732620727252194336364173' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: P384Scalar */ +/* machine_wordsize = 32 (from "32") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from "2^384 - 1388124618062372383947042015309946732620727252194336364173") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) in */ +/* if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384 */ + +package fiat_crypto; + +public final class FiatP384Scalar { + +static class Box { + private T value; + public Box(T value) { this.value = value; } + public void set(T value) { this.value = value; } + public T get() { return this.value; } +} + + + +/** + * The function fiat_P384Scalar_addcarryx_u32 is an addition with carry.

+ *

+ * Postconditions:

+ * out1 = (arg1 + arg2 + arg3) mod 2^32

+ * out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [0x0 ~> 0xffffffff]

+ * arg3: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [0x0 ~> 0x1]

+ */ +static void fiat_P384Scalar_addcarryx_u32(Box out1, Box out2, int arg1, int arg2, int arg3) { + long x1 = (((long) Integer.toUnsignedLong(((Number) (arg1)).intValue()) + (long) Integer.toUnsignedLong(((Number) (arg2)).intValue())) + (long) Integer.toUnsignedLong(((Number) (arg3)).intValue())); + int x2 = ((int) Integer.toUnsignedLong(((Number) (x1)).intValue()) & 0xffffffff); + int x3 = (int) Integer.toUnsignedLong(((Number) ((x1 >>> 32))).intValue()); + out1.set(x2); + out2.set(x3); +} + +/** + * The function fiat_P384Scalar_subborrowx_u32 is a subtraction with borrow.

+ *

+ * Postconditions:

+ * out1 = (-arg1 + arg2 + -arg3) mod 2^32

+ * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [0x0 ~> 0xffffffff]

+ * arg3: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [0x0 ~> 0x1]

+ */ +static void fiat_P384Scalar_subborrowx_u32(Box out1, Box out2, int arg1, int arg2, int arg3) { + long x1 = (((long) Integer.toUnsignedLong(((Number) (arg2)).intValue()) - (long) Integer.toUnsignedLong(((Number) (arg1)).intValue())) - (long) Integer.toUnsignedLong(((Number) (arg3)).intValue())); + int x2 = (int) Integer.toUnsignedLong(((Number) ((x1 >>> 32))).intValue()); + int x3 = ((int) Integer.toUnsignedLong(((Number) (x1)).intValue()) & 0xffffffff); + out1.set(x3); + out2.set(((int) Integer.toUnsignedLong(((Number) (0x0)).intValue()) - (int) Integer.toUnsignedLong(((Number) (x2)).intValue()))); +} + +/** + * The function fiat_P384Scalar_mulx_u32 is a multiplication, returning the full double-width result.

+ *

+ * Postconditions:

+ * out1 = (arg1 * arg2) mod 2^32

+ * out2 = ⌊arg1 * arg2 / 2^32⌋

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0xffffffff]

+ * arg2: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [0x0 ~> 0xffffffff]

+ */ +static void fiat_P384Scalar_mulx_u32(Box out1, Box out2, int arg1, int arg2) { + long x1 = ((long) Integer.toUnsignedLong(((Number) (arg1)).intValue()) * (long) Integer.toUnsignedLong(((Number) (arg2)).intValue())); + int x2 = ((int) Integer.toUnsignedLong(((Number) (x1)).intValue()) & 0xffffffff); + int x3 = (int) Integer.toUnsignedLong(((Number) ((x1 >>> 32))).intValue()); + out1.set(x2); + out2.set(x3); +} + +/** + * The function fiat_P384Scalar_cmovznz_u32 is a single-word conditional move.

+ *

+ * Postconditions:

+ * out1 = (if arg1 = 0 then arg2 else arg3)

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [0x0 ~> 0xffffffff]

+ * arg3: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ */ +static void fiat_P384Scalar_cmovznz_u32(Box out1, int arg1, int arg2, int arg3) { + int x1 = (arg1 * 0xffffffff); + int x2 = ((x1 & arg3) | ((~x1) & arg2)); + out1.set(x2); +} + +/** + * The function fiat_P384Scalar_mul multiplies two field elements in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * 0 ≤ eval arg2 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_mul(int[] out1, final int[] arg1, final int[] arg2) { + int x1 = (arg1[1]); + int x2 = (arg1[2]); + int x3 = (arg1[3]); + int x4 = (arg1[4]); + int x5 = (arg1[5]); + int x6 = (arg1[6]); + int x7 = (arg1[7]); + int x8 = (arg1[8]); + int x9 = (arg1[9]); + int x10 = (arg1[10]); + int x11 = (arg1[11]); + int x12 = (arg1[0]); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x13, x14, x12, (arg2[11])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x15, x16, x12, (arg2[10])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x17, x18, x12, (arg2[9])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x19, x20, x12, (arg2[8])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x21, x22, x12, (arg2[7])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x23, x24, x12, (arg2[6])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x25, x26, x12, (arg2[5])); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x27, x28, x12, (arg2[4])); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x29, x30, x12, (arg2[3])); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x31, x32, x12, (arg2[2])); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x33, x34, x12, (arg2[1])); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x35, x36, x12, (arg2[0])); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x37, x38, 0x0, (x36).get(), (x33).get()); + Box x39 = new Box((int)0); + Box x40 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x39, x40, (x38).get(), (x34).get(), (x31).get()); + Box x41 = new Box((int)0); + Box x42 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x41, x42, (x40).get(), (x32).get(), (x29).get()); + Box x43 = new Box((int)0); + Box x44 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x43, x44, (x42).get(), (x30).get(), (x27).get()); + Box x45 = new Box((int)0); + Box x46 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x45, x46, (x44).get(), (x28).get(), (x25).get()); + Box x47 = new Box((int)0); + Box x48 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x47, x48, (x46).get(), (x26).get(), (x23).get()); + Box x49 = new Box((int)0); + Box x50 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x49, x50, (x48).get(), (x24).get(), (x21).get()); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x51, x52, (x50).get(), (x22).get(), (x19).get()); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x53, x54, (x52).get(), (x20).get(), (x17).get()); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x55, x56, (x54).get(), (x18).get(), (x15).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x57, x58, (x56).get(), (x16).get(), (x13).get()); + int x59 = ((x58).get() + (x14).get()); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x60, x61, (x35).get(), 0xe88fdc45); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x62, x63, (x60).get(), 0xffffffff); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x64, x65, (x60).get(), 0xffffffff); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x66, x67, (x60).get(), 0xffffffff); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x68, x69, (x60).get(), 0xffffffff); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x70, x71, (x60).get(), 0xffffffff); + Box x72 = new Box((int)0); + Box x73 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x72, x73, (x60).get(), 0xffffffff); + Box x74 = new Box((int)0); + Box x75 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x74, x75, (x60).get(), 0xc7634d81); + Box x76 = new Box((int)0); + Box x77 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x76, x77, (x60).get(), 0xf4372ddf); + Box x78 = new Box((int)0); + Box x79 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x78, x79, (x60).get(), 0x581a0db2); + Box x80 = new Box((int)0); + Box x81 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x80, x81, (x60).get(), 0x48b0a77a); + Box x82 = new Box((int)0); + Box x83 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x82, x83, (x60).get(), 0xecec196a); + Box x84 = new Box((int)0); + Box x85 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x84, x85, (x60).get(), 0xccc52973); + Box x86 = new Box((int)0); + Box x87 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x86, x87, 0x0, (x85).get(), (x82).get()); + Box x88 = new Box((int)0); + Box x89 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x88, x89, (x87).get(), (x83).get(), (x80).get()); + Box x90 = new Box((int)0); + Box x91 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x90, x91, (x89).get(), (x81).get(), (x78).get()); + Box x92 = new Box((int)0); + Box x93 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x92, x93, (x91).get(), (x79).get(), (x76).get()); + Box x94 = new Box((int)0); + Box x95 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x94, x95, (x93).get(), (x77).get(), (x74).get()); + Box x96 = new Box((int)0); + Box x97 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x96, x97, (x95).get(), (x75).get(), (x72).get()); + Box x98 = new Box((int)0); + Box x99 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x98, x99, (x97).get(), (x73).get(), (x70).get()); + Box x100 = new Box((int)0); + Box x101 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x100, x101, (x99).get(), (x71).get(), (x68).get()); + Box x102 = new Box((int)0); + Box x103 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x102, x103, (x101).get(), (x69).get(), (x66).get()); + Box x104 = new Box((int)0); + Box x105 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x104, x105, (x103).get(), (x67).get(), (x64).get()); + Box x106 = new Box((int)0); + Box x107 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x106, x107, (x105).get(), (x65).get(), (x62).get()); + int x108 = ((x107).get() + (x63).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x109, x110, 0x0, (x35).get(), (x84).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x111, x112, (x110).get(), (x37).get(), (x86).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x113, x114, (x112).get(), (x39).get(), (x88).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x115, x116, (x114).get(), (x41).get(), (x90).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x117, x118, (x116).get(), (x43).get(), (x92).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x119, x120, (x118).get(), (x45).get(), (x94).get()); + Box x121 = new Box((int)0); + Box x122 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x121, x122, (x120).get(), (x47).get(), (x96).get()); + Box x123 = new Box((int)0); + Box x124 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x123, x124, (x122).get(), (x49).get(), (x98).get()); + Box x125 = new Box((int)0); + Box x126 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x125, x126, (x124).get(), (x51).get(), (x100).get()); + Box x127 = new Box((int)0); + Box x128 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x127, x128, (x126).get(), (x53).get(), (x102).get()); + Box x129 = new Box((int)0); + Box x130 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x129, x130, (x128).get(), (x55).get(), (x104).get()); + Box x131 = new Box((int)0); + Box x132 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x131, x132, (x130).get(), (x57).get(), (x106).get()); + Box x133 = new Box((int)0); + Box x134 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x133, x134, (x132).get(), x59, x108); + Box x135 = new Box((int)0); + Box x136 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x135, x136, x1, (arg2[11])); + Box x137 = new Box((int)0); + Box x138 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x137, x138, x1, (arg2[10])); + Box x139 = new Box((int)0); + Box x140 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x139, x140, x1, (arg2[9])); + Box x141 = new Box((int)0); + Box x142 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x141, x142, x1, (arg2[8])); + Box x143 = new Box((int)0); + Box x144 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x143, x144, x1, (arg2[7])); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x145, x146, x1, (arg2[6])); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x147, x148, x1, (arg2[5])); + Box x149 = new Box((int)0); + Box x150 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x149, x150, x1, (arg2[4])); + Box x151 = new Box((int)0); + Box x152 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x151, x152, x1, (arg2[3])); + Box x153 = new Box((int)0); + Box x154 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x153, x154, x1, (arg2[2])); + Box x155 = new Box((int)0); + Box x156 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x155, x156, x1, (arg2[1])); + Box x157 = new Box((int)0); + Box x158 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x157, x158, x1, (arg2[0])); + Box x159 = new Box((int)0); + Box x160 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x159, x160, 0x0, (x158).get(), (x155).get()); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x161, x162, (x160).get(), (x156).get(), (x153).get()); + Box x163 = new Box((int)0); + Box x164 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x163, x164, (x162).get(), (x154).get(), (x151).get()); + Box x165 = new Box((int)0); + Box x166 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x165, x166, (x164).get(), (x152).get(), (x149).get()); + Box x167 = new Box((int)0); + Box x168 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x167, x168, (x166).get(), (x150).get(), (x147).get()); + Box x169 = new Box((int)0); + Box x170 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x169, x170, (x168).get(), (x148).get(), (x145).get()); + Box x171 = new Box((int)0); + Box x172 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x171, x172, (x170).get(), (x146).get(), (x143).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x173, x174, (x172).get(), (x144).get(), (x141).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x175, x176, (x174).get(), (x142).get(), (x139).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x177, x178, (x176).get(), (x140).get(), (x137).get()); + Box x179 = new Box((int)0); + Box x180 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x179, x180, (x178).get(), (x138).get(), (x135).get()); + int x181 = ((x180).get() + (x136).get()); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x182, x183, 0x0, (x111).get(), (x157).get()); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x184, x185, (x183).get(), (x113).get(), (x159).get()); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x186, x187, (x185).get(), (x115).get(), (x161).get()); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x188, x189, (x187).get(), (x117).get(), (x163).get()); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x190, x191, (x189).get(), (x119).get(), (x165).get()); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x192, x193, (x191).get(), (x121).get(), (x167).get()); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x194, x195, (x193).get(), (x123).get(), (x169).get()); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x196, x197, (x195).get(), (x125).get(), (x171).get()); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x198, x199, (x197).get(), (x127).get(), (x173).get()); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x200, x201, (x199).get(), (x129).get(), (x175).get()); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x202, x203, (x201).get(), (x131).get(), (x177).get()); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x204, x205, (x203).get(), (x133).get(), (x179).get()); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x206, x207, (x205).get(), (x134).get(), x181); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x208, x209, (x182).get(), 0xe88fdc45); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x210, x211, (x208).get(), 0xffffffff); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x212, x213, (x208).get(), 0xffffffff); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x214, x215, (x208).get(), 0xffffffff); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x216, x217, (x208).get(), 0xffffffff); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x218, x219, (x208).get(), 0xffffffff); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x220, x221, (x208).get(), 0xffffffff); + Box x222 = new Box((int)0); + Box x223 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x222, x223, (x208).get(), 0xc7634d81); + Box x224 = new Box((int)0); + Box x225 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x224, x225, (x208).get(), 0xf4372ddf); + Box x226 = new Box((int)0); + Box x227 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x226, x227, (x208).get(), 0x581a0db2); + Box x228 = new Box((int)0); + Box x229 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x228, x229, (x208).get(), 0x48b0a77a); + Box x230 = new Box((int)0); + Box x231 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x230, x231, (x208).get(), 0xecec196a); + Box x232 = new Box((int)0); + Box x233 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x232, x233, (x208).get(), 0xccc52973); + Box x234 = new Box((int)0); + Box x235 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x234, x235, 0x0, (x233).get(), (x230).get()); + Box x236 = new Box((int)0); + Box x237 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x236, x237, (x235).get(), (x231).get(), (x228).get()); + Box x238 = new Box((int)0); + Box x239 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x238, x239, (x237).get(), (x229).get(), (x226).get()); + Box x240 = new Box((int)0); + Box x241 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x240, x241, (x239).get(), (x227).get(), (x224).get()); + Box x242 = new Box((int)0); + Box x243 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x242, x243, (x241).get(), (x225).get(), (x222).get()); + Box x244 = new Box((int)0); + Box x245 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x244, x245, (x243).get(), (x223).get(), (x220).get()); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x246, x247, (x245).get(), (x221).get(), (x218).get()); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x248, x249, (x247).get(), (x219).get(), (x216).get()); + Box x250 = new Box((int)0); + Box x251 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x250, x251, (x249).get(), (x217).get(), (x214).get()); + Box x252 = new Box((int)0); + Box x253 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x252, x253, (x251).get(), (x215).get(), (x212).get()); + Box x254 = new Box((int)0); + Box x255 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x254, x255, (x253).get(), (x213).get(), (x210).get()); + int x256 = ((x255).get() + (x211).get()); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x257, x258, 0x0, (x182).get(), (x232).get()); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x259, x260, (x258).get(), (x184).get(), (x234).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x261, x262, (x260).get(), (x186).get(), (x236).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x263, x264, (x262).get(), (x188).get(), (x238).get()); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x265, x266, (x264).get(), (x190).get(), (x240).get()); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x267, x268, (x266).get(), (x192).get(), (x242).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x269, x270, (x268).get(), (x194).get(), (x244).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x271, x272, (x270).get(), (x196).get(), (x246).get()); + Box x273 = new Box((int)0); + Box x274 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x273, x274, (x272).get(), (x198).get(), (x248).get()); + Box x275 = new Box((int)0); + Box x276 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x275, x276, (x274).get(), (x200).get(), (x250).get()); + Box x277 = new Box((int)0); + Box x278 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x277, x278, (x276).get(), (x202).get(), (x252).get()); + Box x279 = new Box((int)0); + Box x280 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x279, x280, (x278).get(), (x204).get(), (x254).get()); + Box x281 = new Box((int)0); + Box x282 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x281, x282, (x280).get(), (x206).get(), x256); + int x283 = ((x282).get() + (x207).get()); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x284, x285, x2, (arg2[11])); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x286, x287, x2, (arg2[10])); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x288, x289, x2, (arg2[9])); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x290, x291, x2, (arg2[8])); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x292, x293, x2, (arg2[7])); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x294, x295, x2, (arg2[6])); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x296, x297, x2, (arg2[5])); + Box x298 = new Box((int)0); + Box x299 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x298, x299, x2, (arg2[4])); + Box x300 = new Box((int)0); + Box x301 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x300, x301, x2, (arg2[3])); + Box x302 = new Box((int)0); + Box x303 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x302, x303, x2, (arg2[2])); + Box x304 = new Box((int)0); + Box x305 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x304, x305, x2, (arg2[1])); + Box x306 = new Box((int)0); + Box x307 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x306, x307, x2, (arg2[0])); + Box x308 = new Box((int)0); + Box x309 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x308, x309, 0x0, (x307).get(), (x304).get()); + Box x310 = new Box((int)0); + Box x311 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x310, x311, (x309).get(), (x305).get(), (x302).get()); + Box x312 = new Box((int)0); + Box x313 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x312, x313, (x311).get(), (x303).get(), (x300).get()); + Box x314 = new Box((int)0); + Box x315 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x314, x315, (x313).get(), (x301).get(), (x298).get()); + Box x316 = new Box((int)0); + Box x317 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x316, x317, (x315).get(), (x299).get(), (x296).get()); + Box x318 = new Box((int)0); + Box x319 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x318, x319, (x317).get(), (x297).get(), (x294).get()); + Box x320 = new Box((int)0); + Box x321 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x320, x321, (x319).get(), (x295).get(), (x292).get()); + Box x322 = new Box((int)0); + Box x323 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x322, x323, (x321).get(), (x293).get(), (x290).get()); + Box x324 = new Box((int)0); + Box x325 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x324, x325, (x323).get(), (x291).get(), (x288).get()); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x326, x327, (x325).get(), (x289).get(), (x286).get()); + Box x328 = new Box((int)0); + Box x329 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x328, x329, (x327).get(), (x287).get(), (x284).get()); + int x330 = ((x329).get() + (x285).get()); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x331, x332, 0x0, (x259).get(), (x306).get()); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x333, x334, (x332).get(), (x261).get(), (x308).get()); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x335, x336, (x334).get(), (x263).get(), (x310).get()); + Box x337 = new Box((int)0); + Box x338 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x337, x338, (x336).get(), (x265).get(), (x312).get()); + Box x339 = new Box((int)0); + Box x340 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x339, x340, (x338).get(), (x267).get(), (x314).get()); + Box x341 = new Box((int)0); + Box x342 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x341, x342, (x340).get(), (x269).get(), (x316).get()); + Box x343 = new Box((int)0); + Box x344 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x343, x344, (x342).get(), (x271).get(), (x318).get()); + Box x345 = new Box((int)0); + Box x346 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x345, x346, (x344).get(), (x273).get(), (x320).get()); + Box x347 = new Box((int)0); + Box x348 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x347, x348, (x346).get(), (x275).get(), (x322).get()); + Box x349 = new Box((int)0); + Box x350 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x349, x350, (x348).get(), (x277).get(), (x324).get()); + Box x351 = new Box((int)0); + Box x352 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x351, x352, (x350).get(), (x279).get(), (x326).get()); + Box x353 = new Box((int)0); + Box x354 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x353, x354, (x352).get(), (x281).get(), (x328).get()); + Box x355 = new Box((int)0); + Box x356 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x355, x356, (x354).get(), x283, x330); + Box x357 = new Box((int)0); + Box x358 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x357, x358, (x331).get(), 0xe88fdc45); + Box x359 = new Box((int)0); + Box x360 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x359, x360, (x357).get(), 0xffffffff); + Box x361 = new Box((int)0); + Box x362 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x361, x362, (x357).get(), 0xffffffff); + Box x363 = new Box((int)0); + Box x364 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x363, x364, (x357).get(), 0xffffffff); + Box x365 = new Box((int)0); + Box x366 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x365, x366, (x357).get(), 0xffffffff); + Box x367 = new Box((int)0); + Box x368 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x367, x368, (x357).get(), 0xffffffff); + Box x369 = new Box((int)0); + Box x370 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x369, x370, (x357).get(), 0xffffffff); + Box x371 = new Box((int)0); + Box x372 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x371, x372, (x357).get(), 0xc7634d81); + Box x373 = new Box((int)0); + Box x374 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x373, x374, (x357).get(), 0xf4372ddf); + Box x375 = new Box((int)0); + Box x376 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x375, x376, (x357).get(), 0x581a0db2); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x377, x378, (x357).get(), 0x48b0a77a); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x379, x380, (x357).get(), 0xecec196a); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x381, x382, (x357).get(), 0xccc52973); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x383, x384, 0x0, (x382).get(), (x379).get()); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x385, x386, (x384).get(), (x380).get(), (x377).get()); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x387, x388, (x386).get(), (x378).get(), (x375).get()); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x389, x390, (x388).get(), (x376).get(), (x373).get()); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x391, x392, (x390).get(), (x374).get(), (x371).get()); + Box x393 = new Box((int)0); + Box x394 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x393, x394, (x392).get(), (x372).get(), (x369).get()); + Box x395 = new Box((int)0); + Box x396 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x395, x396, (x394).get(), (x370).get(), (x367).get()); + Box x397 = new Box((int)0); + Box x398 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x397, x398, (x396).get(), (x368).get(), (x365).get()); + Box x399 = new Box((int)0); + Box x400 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x399, x400, (x398).get(), (x366).get(), (x363).get()); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x401, x402, (x400).get(), (x364).get(), (x361).get()); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x403, x404, (x402).get(), (x362).get(), (x359).get()); + int x405 = ((x404).get() + (x360).get()); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x406, x407, 0x0, (x331).get(), (x381).get()); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x408, x409, (x407).get(), (x333).get(), (x383).get()); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x410, x411, (x409).get(), (x335).get(), (x385).get()); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x412, x413, (x411).get(), (x337).get(), (x387).get()); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x414, x415, (x413).get(), (x339).get(), (x389).get()); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x416, x417, (x415).get(), (x341).get(), (x391).get()); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x418, x419, (x417).get(), (x343).get(), (x393).get()); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x420, x421, (x419).get(), (x345).get(), (x395).get()); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x422, x423, (x421).get(), (x347).get(), (x397).get()); + Box x424 = new Box((int)0); + Box x425 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x424, x425, (x423).get(), (x349).get(), (x399).get()); + Box x426 = new Box((int)0); + Box x427 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x426, x427, (x425).get(), (x351).get(), (x401).get()); + Box x428 = new Box((int)0); + Box x429 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x428, x429, (x427).get(), (x353).get(), (x403).get()); + Box x430 = new Box((int)0); + Box x431 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x430, x431, (x429).get(), (x355).get(), x405); + int x432 = ((x431).get() + (x356).get()); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x433, x434, x3, (arg2[11])); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x435, x436, x3, (arg2[10])); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x437, x438, x3, (arg2[9])); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x439, x440, x3, (arg2[8])); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x441, x442, x3, (arg2[7])); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x443, x444, x3, (arg2[6])); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x445, x446, x3, (arg2[5])); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x447, x448, x3, (arg2[4])); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x449, x450, x3, (arg2[3])); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x451, x452, x3, (arg2[2])); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x453, x454, x3, (arg2[1])); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x455, x456, x3, (arg2[0])); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x457, x458, 0x0, (x456).get(), (x453).get()); + Box x459 = new Box((int)0); + Box x460 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x459, x460, (x458).get(), (x454).get(), (x451).get()); + Box x461 = new Box((int)0); + Box x462 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x461, x462, (x460).get(), (x452).get(), (x449).get()); + Box x463 = new Box((int)0); + Box x464 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x463, x464, (x462).get(), (x450).get(), (x447).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x465, x466, (x464).get(), (x448).get(), (x445).get()); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x467, x468, (x466).get(), (x446).get(), (x443).get()); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x469, x470, (x468).get(), (x444).get(), (x441).get()); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x471, x472, (x470).get(), (x442).get(), (x439).get()); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x473, x474, (x472).get(), (x440).get(), (x437).get()); + Box x475 = new Box((int)0); + Box x476 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x475, x476, (x474).get(), (x438).get(), (x435).get()); + Box x477 = new Box((int)0); + Box x478 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x477, x478, (x476).get(), (x436).get(), (x433).get()); + int x479 = ((x478).get() + (x434).get()); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x480, x481, 0x0, (x408).get(), (x455).get()); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x482, x483, (x481).get(), (x410).get(), (x457).get()); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x484, x485, (x483).get(), (x412).get(), (x459).get()); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x486, x487, (x485).get(), (x414).get(), (x461).get()); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x488, x489, (x487).get(), (x416).get(), (x463).get()); + Box x490 = new Box((int)0); + Box x491 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x490, x491, (x489).get(), (x418).get(), (x465).get()); + Box x492 = new Box((int)0); + Box x493 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x492, x493, (x491).get(), (x420).get(), (x467).get()); + Box x494 = new Box((int)0); + Box x495 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x494, x495, (x493).get(), (x422).get(), (x469).get()); + Box x496 = new Box((int)0); + Box x497 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x496, x497, (x495).get(), (x424).get(), (x471).get()); + Box x498 = new Box((int)0); + Box x499 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x498, x499, (x497).get(), (x426).get(), (x473).get()); + Box x500 = new Box((int)0); + Box x501 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x500, x501, (x499).get(), (x428).get(), (x475).get()); + Box x502 = new Box((int)0); + Box x503 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x502, x503, (x501).get(), (x430).get(), (x477).get()); + Box x504 = new Box((int)0); + Box x505 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x504, x505, (x503).get(), x432, x479); + Box x506 = new Box((int)0); + Box x507 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x506, x507, (x480).get(), 0xe88fdc45); + Box x508 = new Box((int)0); + Box x509 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x508, x509, (x506).get(), 0xffffffff); + Box x510 = new Box((int)0); + Box x511 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x510, x511, (x506).get(), 0xffffffff); + Box x512 = new Box((int)0); + Box x513 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x512, x513, (x506).get(), 0xffffffff); + Box x514 = new Box((int)0); + Box x515 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x514, x515, (x506).get(), 0xffffffff); + Box x516 = new Box((int)0); + Box x517 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x516, x517, (x506).get(), 0xffffffff); + Box x518 = new Box((int)0); + Box x519 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x518, x519, (x506).get(), 0xffffffff); + Box x520 = new Box((int)0); + Box x521 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x520, x521, (x506).get(), 0xc7634d81); + Box x522 = new Box((int)0); + Box x523 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x522, x523, (x506).get(), 0xf4372ddf); + Box x524 = new Box((int)0); + Box x525 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x524, x525, (x506).get(), 0x581a0db2); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x526, x527, (x506).get(), 0x48b0a77a); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x528, x529, (x506).get(), 0xecec196a); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x530, x531, (x506).get(), 0xccc52973); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x532, x533, 0x0, (x531).get(), (x528).get()); + Box x534 = new Box((int)0); + Box x535 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x534, x535, (x533).get(), (x529).get(), (x526).get()); + Box x536 = new Box((int)0); + Box x537 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x536, x537, (x535).get(), (x527).get(), (x524).get()); + Box x538 = new Box((int)0); + Box x539 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x538, x539, (x537).get(), (x525).get(), (x522).get()); + Box x540 = new Box((int)0); + Box x541 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x540, x541, (x539).get(), (x523).get(), (x520).get()); + Box x542 = new Box((int)0); + Box x543 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x542, x543, (x541).get(), (x521).get(), (x518).get()); + Box x544 = new Box((int)0); + Box x545 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x544, x545, (x543).get(), (x519).get(), (x516).get()); + Box x546 = new Box((int)0); + Box x547 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x546, x547, (x545).get(), (x517).get(), (x514).get()); + Box x548 = new Box((int)0); + Box x549 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x548, x549, (x547).get(), (x515).get(), (x512).get()); + Box x550 = new Box((int)0); + Box x551 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x550, x551, (x549).get(), (x513).get(), (x510).get()); + Box x552 = new Box((int)0); + Box x553 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x552, x553, (x551).get(), (x511).get(), (x508).get()); + int x554 = ((x553).get() + (x509).get()); + Box x555 = new Box((int)0); + Box x556 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x555, x556, 0x0, (x480).get(), (x530).get()); + Box x557 = new Box((int)0); + Box x558 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x557, x558, (x556).get(), (x482).get(), (x532).get()); + Box x559 = new Box((int)0); + Box x560 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x559, x560, (x558).get(), (x484).get(), (x534).get()); + Box x561 = new Box((int)0); + Box x562 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x561, x562, (x560).get(), (x486).get(), (x536).get()); + Box x563 = new Box((int)0); + Box x564 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x563, x564, (x562).get(), (x488).get(), (x538).get()); + Box x565 = new Box((int)0); + Box x566 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x565, x566, (x564).get(), (x490).get(), (x540).get()); + Box x567 = new Box((int)0); + Box x568 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x567, x568, (x566).get(), (x492).get(), (x542).get()); + Box x569 = new Box((int)0); + Box x570 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x569, x570, (x568).get(), (x494).get(), (x544).get()); + Box x571 = new Box((int)0); + Box x572 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x571, x572, (x570).get(), (x496).get(), (x546).get()); + Box x573 = new Box((int)0); + Box x574 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x573, x574, (x572).get(), (x498).get(), (x548).get()); + Box x575 = new Box((int)0); + Box x576 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x575, x576, (x574).get(), (x500).get(), (x550).get()); + Box x577 = new Box((int)0); + Box x578 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x577, x578, (x576).get(), (x502).get(), (x552).get()); + Box x579 = new Box((int)0); + Box x580 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x579, x580, (x578).get(), (x504).get(), x554); + int x581 = ((x580).get() + (x505).get()); + Box x582 = new Box((int)0); + Box x583 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x582, x583, x4, (arg2[11])); + Box x584 = new Box((int)0); + Box x585 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x584, x585, x4, (arg2[10])); + Box x586 = new Box((int)0); + Box x587 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x586, x587, x4, (arg2[9])); + Box x588 = new Box((int)0); + Box x589 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x588, x589, x4, (arg2[8])); + Box x590 = new Box((int)0); + Box x591 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x590, x591, x4, (arg2[7])); + Box x592 = new Box((int)0); + Box x593 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x592, x593, x4, (arg2[6])); + Box x594 = new Box((int)0); + Box x595 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x594, x595, x4, (arg2[5])); + Box x596 = new Box((int)0); + Box x597 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x596, x597, x4, (arg2[4])); + Box x598 = new Box((int)0); + Box x599 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x598, x599, x4, (arg2[3])); + Box x600 = new Box((int)0); + Box x601 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x600, x601, x4, (arg2[2])); + Box x602 = new Box((int)0); + Box x603 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x602, x603, x4, (arg2[1])); + Box x604 = new Box((int)0); + Box x605 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x604, x605, x4, (arg2[0])); + Box x606 = new Box((int)0); + Box x607 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x606, x607, 0x0, (x605).get(), (x602).get()); + Box x608 = new Box((int)0); + Box x609 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x608, x609, (x607).get(), (x603).get(), (x600).get()); + Box x610 = new Box((int)0); + Box x611 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x610, x611, (x609).get(), (x601).get(), (x598).get()); + Box x612 = new Box((int)0); + Box x613 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x612, x613, (x611).get(), (x599).get(), (x596).get()); + Box x614 = new Box((int)0); + Box x615 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x614, x615, (x613).get(), (x597).get(), (x594).get()); + Box x616 = new Box((int)0); + Box x617 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x616, x617, (x615).get(), (x595).get(), (x592).get()); + Box x618 = new Box((int)0); + Box x619 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x618, x619, (x617).get(), (x593).get(), (x590).get()); + Box x620 = new Box((int)0); + Box x621 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x620, x621, (x619).get(), (x591).get(), (x588).get()); + Box x622 = new Box((int)0); + Box x623 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x622, x623, (x621).get(), (x589).get(), (x586).get()); + Box x624 = new Box((int)0); + Box x625 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x624, x625, (x623).get(), (x587).get(), (x584).get()); + Box x626 = new Box((int)0); + Box x627 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x626, x627, (x625).get(), (x585).get(), (x582).get()); + int x628 = ((x627).get() + (x583).get()); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x629, x630, 0x0, (x557).get(), (x604).get()); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x631, x632, (x630).get(), (x559).get(), (x606).get()); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x633, x634, (x632).get(), (x561).get(), (x608).get()); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x635, x636, (x634).get(), (x563).get(), (x610).get()); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x637, x638, (x636).get(), (x565).get(), (x612).get()); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x639, x640, (x638).get(), (x567).get(), (x614).get()); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x641, x642, (x640).get(), (x569).get(), (x616).get()); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x643, x644, (x642).get(), (x571).get(), (x618).get()); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x645, x646, (x644).get(), (x573).get(), (x620).get()); + Box x647 = new Box((int)0); + Box x648 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x647, x648, (x646).get(), (x575).get(), (x622).get()); + Box x649 = new Box((int)0); + Box x650 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x649, x650, (x648).get(), (x577).get(), (x624).get()); + Box x651 = new Box((int)0); + Box x652 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x651, x652, (x650).get(), (x579).get(), (x626).get()); + Box x653 = new Box((int)0); + Box x654 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x653, x654, (x652).get(), x581, x628); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x655, x656, (x629).get(), 0xe88fdc45); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x657, x658, (x655).get(), 0xffffffff); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x659, x660, (x655).get(), 0xffffffff); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x661, x662, (x655).get(), 0xffffffff); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x663, x664, (x655).get(), 0xffffffff); + Box x665 = new Box((int)0); + Box x666 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x665, x666, (x655).get(), 0xffffffff); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x667, x668, (x655).get(), 0xffffffff); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x669, x670, (x655).get(), 0xc7634d81); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x671, x672, (x655).get(), 0xf4372ddf); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x673, x674, (x655).get(), 0x581a0db2); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x675, x676, (x655).get(), 0x48b0a77a); + Box x677 = new Box((int)0); + Box x678 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x677, x678, (x655).get(), 0xecec196a); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x679, x680, (x655).get(), 0xccc52973); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x681, x682, 0x0, (x680).get(), (x677).get()); + Box x683 = new Box((int)0); + Box x684 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x683, x684, (x682).get(), (x678).get(), (x675).get()); + Box x685 = new Box((int)0); + Box x686 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x685, x686, (x684).get(), (x676).get(), (x673).get()); + Box x687 = new Box((int)0); + Box x688 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x687, x688, (x686).get(), (x674).get(), (x671).get()); + Box x689 = new Box((int)0); + Box x690 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x689, x690, (x688).get(), (x672).get(), (x669).get()); + Box x691 = new Box((int)0); + Box x692 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x691, x692, (x690).get(), (x670).get(), (x667).get()); + Box x693 = new Box((int)0); + Box x694 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x693, x694, (x692).get(), (x668).get(), (x665).get()); + Box x695 = new Box((int)0); + Box x696 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x695, x696, (x694).get(), (x666).get(), (x663).get()); + Box x697 = new Box((int)0); + Box x698 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x697, x698, (x696).get(), (x664).get(), (x661).get()); + Box x699 = new Box((int)0); + Box x700 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x699, x700, (x698).get(), (x662).get(), (x659).get()); + Box x701 = new Box((int)0); + Box x702 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x701, x702, (x700).get(), (x660).get(), (x657).get()); + int x703 = ((x702).get() + (x658).get()); + Box x704 = new Box((int)0); + Box x705 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x704, x705, 0x0, (x629).get(), (x679).get()); + Box x706 = new Box((int)0); + Box x707 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x706, x707, (x705).get(), (x631).get(), (x681).get()); + Box x708 = new Box((int)0); + Box x709 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x708, x709, (x707).get(), (x633).get(), (x683).get()); + Box x710 = new Box((int)0); + Box x711 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x710, x711, (x709).get(), (x635).get(), (x685).get()); + Box x712 = new Box((int)0); + Box x713 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x712, x713, (x711).get(), (x637).get(), (x687).get()); + Box x714 = new Box((int)0); + Box x715 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x714, x715, (x713).get(), (x639).get(), (x689).get()); + Box x716 = new Box((int)0); + Box x717 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x716, x717, (x715).get(), (x641).get(), (x691).get()); + Box x718 = new Box((int)0); + Box x719 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x718, x719, (x717).get(), (x643).get(), (x693).get()); + Box x720 = new Box((int)0); + Box x721 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x720, x721, (x719).get(), (x645).get(), (x695).get()); + Box x722 = new Box((int)0); + Box x723 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x722, x723, (x721).get(), (x647).get(), (x697).get()); + Box x724 = new Box((int)0); + Box x725 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x724, x725, (x723).get(), (x649).get(), (x699).get()); + Box x726 = new Box((int)0); + Box x727 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x726, x727, (x725).get(), (x651).get(), (x701).get()); + Box x728 = new Box((int)0); + Box x729 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x728, x729, (x727).get(), (x653).get(), x703); + int x730 = ((x729).get() + (x654).get()); + Box x731 = new Box((int)0); + Box x732 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x731, x732, x5, (arg2[11])); + Box x733 = new Box((int)0); + Box x734 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x733, x734, x5, (arg2[10])); + Box x735 = new Box((int)0); + Box x736 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x735, x736, x5, (arg2[9])); + Box x737 = new Box((int)0); + Box x738 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x737, x738, x5, (arg2[8])); + Box x739 = new Box((int)0); + Box x740 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x739, x740, x5, (arg2[7])); + Box x741 = new Box((int)0); + Box x742 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x741, x742, x5, (arg2[6])); + Box x743 = new Box((int)0); + Box x744 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x743, x744, x5, (arg2[5])); + Box x745 = new Box((int)0); + Box x746 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x745, x746, x5, (arg2[4])); + Box x747 = new Box((int)0); + Box x748 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x747, x748, x5, (arg2[3])); + Box x749 = new Box((int)0); + Box x750 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x749, x750, x5, (arg2[2])); + Box x751 = new Box((int)0); + Box x752 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x751, x752, x5, (arg2[1])); + Box x753 = new Box((int)0); + Box x754 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x753, x754, x5, (arg2[0])); + Box x755 = new Box((int)0); + Box x756 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x755, x756, 0x0, (x754).get(), (x751).get()); + Box x757 = new Box((int)0); + Box x758 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x757, x758, (x756).get(), (x752).get(), (x749).get()); + Box x759 = new Box((int)0); + Box x760 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x759, x760, (x758).get(), (x750).get(), (x747).get()); + Box x761 = new Box((int)0); + Box x762 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x761, x762, (x760).get(), (x748).get(), (x745).get()); + Box x763 = new Box((int)0); + Box x764 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x763, x764, (x762).get(), (x746).get(), (x743).get()); + Box x765 = new Box((int)0); + Box x766 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x765, x766, (x764).get(), (x744).get(), (x741).get()); + Box x767 = new Box((int)0); + Box x768 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x767, x768, (x766).get(), (x742).get(), (x739).get()); + Box x769 = new Box((int)0); + Box x770 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x769, x770, (x768).get(), (x740).get(), (x737).get()); + Box x771 = new Box((int)0); + Box x772 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x771, x772, (x770).get(), (x738).get(), (x735).get()); + Box x773 = new Box((int)0); + Box x774 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x773, x774, (x772).get(), (x736).get(), (x733).get()); + Box x775 = new Box((int)0); + Box x776 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x775, x776, (x774).get(), (x734).get(), (x731).get()); + int x777 = ((x776).get() + (x732).get()); + Box x778 = new Box((int)0); + Box x779 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x778, x779, 0x0, (x706).get(), (x753).get()); + Box x780 = new Box((int)0); + Box x781 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x780, x781, (x779).get(), (x708).get(), (x755).get()); + Box x782 = new Box((int)0); + Box x783 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x782, x783, (x781).get(), (x710).get(), (x757).get()); + Box x784 = new Box((int)0); + Box x785 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x784, x785, (x783).get(), (x712).get(), (x759).get()); + Box x786 = new Box((int)0); + Box x787 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x786, x787, (x785).get(), (x714).get(), (x761).get()); + Box x788 = new Box((int)0); + Box x789 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x788, x789, (x787).get(), (x716).get(), (x763).get()); + Box x790 = new Box((int)0); + Box x791 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x790, x791, (x789).get(), (x718).get(), (x765).get()); + Box x792 = new Box((int)0); + Box x793 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x792, x793, (x791).get(), (x720).get(), (x767).get()); + Box x794 = new Box((int)0); + Box x795 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x794, x795, (x793).get(), (x722).get(), (x769).get()); + Box x796 = new Box((int)0); + Box x797 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x796, x797, (x795).get(), (x724).get(), (x771).get()); + Box x798 = new Box((int)0); + Box x799 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x798, x799, (x797).get(), (x726).get(), (x773).get()); + Box x800 = new Box((int)0); + Box x801 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x800, x801, (x799).get(), (x728).get(), (x775).get()); + Box x802 = new Box((int)0); + Box x803 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x802, x803, (x801).get(), x730, x777); + Box x804 = new Box((int)0); + Box x805 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x804, x805, (x778).get(), 0xe88fdc45); + Box x806 = new Box((int)0); + Box x807 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x806, x807, (x804).get(), 0xffffffff); + Box x808 = new Box((int)0); + Box x809 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x808, x809, (x804).get(), 0xffffffff); + Box x810 = new Box((int)0); + Box x811 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x810, x811, (x804).get(), 0xffffffff); + Box x812 = new Box((int)0); + Box x813 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x812, x813, (x804).get(), 0xffffffff); + Box x814 = new Box((int)0); + Box x815 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x814, x815, (x804).get(), 0xffffffff); + Box x816 = new Box((int)0); + Box x817 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x816, x817, (x804).get(), 0xffffffff); + Box x818 = new Box((int)0); + Box x819 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x818, x819, (x804).get(), 0xc7634d81); + Box x820 = new Box((int)0); + Box x821 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x820, x821, (x804).get(), 0xf4372ddf); + Box x822 = new Box((int)0); + Box x823 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x822, x823, (x804).get(), 0x581a0db2); + Box x824 = new Box((int)0); + Box x825 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x824, x825, (x804).get(), 0x48b0a77a); + Box x826 = new Box((int)0); + Box x827 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x826, x827, (x804).get(), 0xecec196a); + Box x828 = new Box((int)0); + Box x829 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x828, x829, (x804).get(), 0xccc52973); + Box x830 = new Box((int)0); + Box x831 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x830, x831, 0x0, (x829).get(), (x826).get()); + Box x832 = new Box((int)0); + Box x833 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x832, x833, (x831).get(), (x827).get(), (x824).get()); + Box x834 = new Box((int)0); + Box x835 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x834, x835, (x833).get(), (x825).get(), (x822).get()); + Box x836 = new Box((int)0); + Box x837 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x836, x837, (x835).get(), (x823).get(), (x820).get()); + Box x838 = new Box((int)0); + Box x839 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x838, x839, (x837).get(), (x821).get(), (x818).get()); + Box x840 = new Box((int)0); + Box x841 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x840, x841, (x839).get(), (x819).get(), (x816).get()); + Box x842 = new Box((int)0); + Box x843 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x842, x843, (x841).get(), (x817).get(), (x814).get()); + Box x844 = new Box((int)0); + Box x845 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x844, x845, (x843).get(), (x815).get(), (x812).get()); + Box x846 = new Box((int)0); + Box x847 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x846, x847, (x845).get(), (x813).get(), (x810).get()); + Box x848 = new Box((int)0); + Box x849 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x848, x849, (x847).get(), (x811).get(), (x808).get()); + Box x850 = new Box((int)0); + Box x851 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x850, x851, (x849).get(), (x809).get(), (x806).get()); + int x852 = ((x851).get() + (x807).get()); + Box x853 = new Box((int)0); + Box x854 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x853, x854, 0x0, (x778).get(), (x828).get()); + Box x855 = new Box((int)0); + Box x856 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x855, x856, (x854).get(), (x780).get(), (x830).get()); + Box x857 = new Box((int)0); + Box x858 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x857, x858, (x856).get(), (x782).get(), (x832).get()); + Box x859 = new Box((int)0); + Box x860 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x859, x860, (x858).get(), (x784).get(), (x834).get()); + Box x861 = new Box((int)0); + Box x862 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x861, x862, (x860).get(), (x786).get(), (x836).get()); + Box x863 = new Box((int)0); + Box x864 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x863, x864, (x862).get(), (x788).get(), (x838).get()); + Box x865 = new Box((int)0); + Box x866 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x865, x866, (x864).get(), (x790).get(), (x840).get()); + Box x867 = new Box((int)0); + Box x868 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x867, x868, (x866).get(), (x792).get(), (x842).get()); + Box x869 = new Box((int)0); + Box x870 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x869, x870, (x868).get(), (x794).get(), (x844).get()); + Box x871 = new Box((int)0); + Box x872 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x871, x872, (x870).get(), (x796).get(), (x846).get()); + Box x873 = new Box((int)0); + Box x874 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x873, x874, (x872).get(), (x798).get(), (x848).get()); + Box x875 = new Box((int)0); + Box x876 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x875, x876, (x874).get(), (x800).get(), (x850).get()); + Box x877 = new Box((int)0); + Box x878 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x877, x878, (x876).get(), (x802).get(), x852); + int x879 = ((x878).get() + (x803).get()); + Box x880 = new Box((int)0); + Box x881 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x880, x881, x6, (arg2[11])); + Box x882 = new Box((int)0); + Box x883 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x882, x883, x6, (arg2[10])); + Box x884 = new Box((int)0); + Box x885 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x884, x885, x6, (arg2[9])); + Box x886 = new Box((int)0); + Box x887 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x886, x887, x6, (arg2[8])); + Box x888 = new Box((int)0); + Box x889 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x888, x889, x6, (arg2[7])); + Box x890 = new Box((int)0); + Box x891 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x890, x891, x6, (arg2[6])); + Box x892 = new Box((int)0); + Box x893 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x892, x893, x6, (arg2[5])); + Box x894 = new Box((int)0); + Box x895 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x894, x895, x6, (arg2[4])); + Box x896 = new Box((int)0); + Box x897 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x896, x897, x6, (arg2[3])); + Box x898 = new Box((int)0); + Box x899 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x898, x899, x6, (arg2[2])); + Box x900 = new Box((int)0); + Box x901 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x900, x901, x6, (arg2[1])); + Box x902 = new Box((int)0); + Box x903 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x902, x903, x6, (arg2[0])); + Box x904 = new Box((int)0); + Box x905 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x904, x905, 0x0, (x903).get(), (x900).get()); + Box x906 = new Box((int)0); + Box x907 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x906, x907, (x905).get(), (x901).get(), (x898).get()); + Box x908 = new Box((int)0); + Box x909 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x908, x909, (x907).get(), (x899).get(), (x896).get()); + Box x910 = new Box((int)0); + Box x911 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x910, x911, (x909).get(), (x897).get(), (x894).get()); + Box x912 = new Box((int)0); + Box x913 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x912, x913, (x911).get(), (x895).get(), (x892).get()); + Box x914 = new Box((int)0); + Box x915 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x914, x915, (x913).get(), (x893).get(), (x890).get()); + Box x916 = new Box((int)0); + Box x917 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x916, x917, (x915).get(), (x891).get(), (x888).get()); + Box x918 = new Box((int)0); + Box x919 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x918, x919, (x917).get(), (x889).get(), (x886).get()); + Box x920 = new Box((int)0); + Box x921 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x920, x921, (x919).get(), (x887).get(), (x884).get()); + Box x922 = new Box((int)0); + Box x923 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x922, x923, (x921).get(), (x885).get(), (x882).get()); + Box x924 = new Box((int)0); + Box x925 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x924, x925, (x923).get(), (x883).get(), (x880).get()); + int x926 = ((x925).get() + (x881).get()); + Box x927 = new Box((int)0); + Box x928 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x927, x928, 0x0, (x855).get(), (x902).get()); + Box x929 = new Box((int)0); + Box x930 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x929, x930, (x928).get(), (x857).get(), (x904).get()); + Box x931 = new Box((int)0); + Box x932 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x931, x932, (x930).get(), (x859).get(), (x906).get()); + Box x933 = new Box((int)0); + Box x934 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x933, x934, (x932).get(), (x861).get(), (x908).get()); + Box x935 = new Box((int)0); + Box x936 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x935, x936, (x934).get(), (x863).get(), (x910).get()); + Box x937 = new Box((int)0); + Box x938 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x937, x938, (x936).get(), (x865).get(), (x912).get()); + Box x939 = new Box((int)0); + Box x940 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x939, x940, (x938).get(), (x867).get(), (x914).get()); + Box x941 = new Box((int)0); + Box x942 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x941, x942, (x940).get(), (x869).get(), (x916).get()); + Box x943 = new Box((int)0); + Box x944 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x943, x944, (x942).get(), (x871).get(), (x918).get()); + Box x945 = new Box((int)0); + Box x946 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x945, x946, (x944).get(), (x873).get(), (x920).get()); + Box x947 = new Box((int)0); + Box x948 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x947, x948, (x946).get(), (x875).get(), (x922).get()); + Box x949 = new Box((int)0); + Box x950 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x949, x950, (x948).get(), (x877).get(), (x924).get()); + Box x951 = new Box((int)0); + Box x952 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x951, x952, (x950).get(), x879, x926); + Box x953 = new Box((int)0); + Box x954 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x953, x954, (x927).get(), 0xe88fdc45); + Box x955 = new Box((int)0); + Box x956 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x955, x956, (x953).get(), 0xffffffff); + Box x957 = new Box((int)0); + Box x958 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x957, x958, (x953).get(), 0xffffffff); + Box x959 = new Box((int)0); + Box x960 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x959, x960, (x953).get(), 0xffffffff); + Box x961 = new Box((int)0); + Box x962 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x961, x962, (x953).get(), 0xffffffff); + Box x963 = new Box((int)0); + Box x964 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x963, x964, (x953).get(), 0xffffffff); + Box x965 = new Box((int)0); + Box x966 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x965, x966, (x953).get(), 0xffffffff); + Box x967 = new Box((int)0); + Box x968 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x967, x968, (x953).get(), 0xc7634d81); + Box x969 = new Box((int)0); + Box x970 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x969, x970, (x953).get(), 0xf4372ddf); + Box x971 = new Box((int)0); + Box x972 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x971, x972, (x953).get(), 0x581a0db2); + Box x973 = new Box((int)0); + Box x974 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x973, x974, (x953).get(), 0x48b0a77a); + Box x975 = new Box((int)0); + Box x976 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x975, x976, (x953).get(), 0xecec196a); + Box x977 = new Box((int)0); + Box x978 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x977, x978, (x953).get(), 0xccc52973); + Box x979 = new Box((int)0); + Box x980 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x979, x980, 0x0, (x978).get(), (x975).get()); + Box x981 = new Box((int)0); + Box x982 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x981, x982, (x980).get(), (x976).get(), (x973).get()); + Box x983 = new Box((int)0); + Box x984 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x983, x984, (x982).get(), (x974).get(), (x971).get()); + Box x985 = new Box((int)0); + Box x986 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x985, x986, (x984).get(), (x972).get(), (x969).get()); + Box x987 = new Box((int)0); + Box x988 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x987, x988, (x986).get(), (x970).get(), (x967).get()); + Box x989 = new Box((int)0); + Box x990 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x989, x990, (x988).get(), (x968).get(), (x965).get()); + Box x991 = new Box((int)0); + Box x992 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x991, x992, (x990).get(), (x966).get(), (x963).get()); + Box x993 = new Box((int)0); + Box x994 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x993, x994, (x992).get(), (x964).get(), (x961).get()); + Box x995 = new Box((int)0); + Box x996 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x995, x996, (x994).get(), (x962).get(), (x959).get()); + Box x997 = new Box((int)0); + Box x998 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x997, x998, (x996).get(), (x960).get(), (x957).get()); + Box x999 = new Box((int)0); + Box x1000 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x999, x1000, (x998).get(), (x958).get(), (x955).get()); + int x1001 = ((x1000).get() + (x956).get()); + Box x1002 = new Box((int)0); + Box x1003 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1002, x1003, 0x0, (x927).get(), (x977).get()); + Box x1004 = new Box((int)0); + Box x1005 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1004, x1005, (x1003).get(), (x929).get(), (x979).get()); + Box x1006 = new Box((int)0); + Box x1007 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1006, x1007, (x1005).get(), (x931).get(), (x981).get()); + Box x1008 = new Box((int)0); + Box x1009 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1008, x1009, (x1007).get(), (x933).get(), (x983).get()); + Box x1010 = new Box((int)0); + Box x1011 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1010, x1011, (x1009).get(), (x935).get(), (x985).get()); + Box x1012 = new Box((int)0); + Box x1013 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1012, x1013, (x1011).get(), (x937).get(), (x987).get()); + Box x1014 = new Box((int)0); + Box x1015 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1014, x1015, (x1013).get(), (x939).get(), (x989).get()); + Box x1016 = new Box((int)0); + Box x1017 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1016, x1017, (x1015).get(), (x941).get(), (x991).get()); + Box x1018 = new Box((int)0); + Box x1019 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1018, x1019, (x1017).get(), (x943).get(), (x993).get()); + Box x1020 = new Box((int)0); + Box x1021 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1020, x1021, (x1019).get(), (x945).get(), (x995).get()); + Box x1022 = new Box((int)0); + Box x1023 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1022, x1023, (x1021).get(), (x947).get(), (x997).get()); + Box x1024 = new Box((int)0); + Box x1025 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1024, x1025, (x1023).get(), (x949).get(), (x999).get()); + Box x1026 = new Box((int)0); + Box x1027 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1026, x1027, (x1025).get(), (x951).get(), x1001); + int x1028 = ((x1027).get() + (x952).get()); + Box x1029 = new Box((int)0); + Box x1030 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1029, x1030, x7, (arg2[11])); + Box x1031 = new Box((int)0); + Box x1032 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1031, x1032, x7, (arg2[10])); + Box x1033 = new Box((int)0); + Box x1034 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1033, x1034, x7, (arg2[9])); + Box x1035 = new Box((int)0); + Box x1036 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1035, x1036, x7, (arg2[8])); + Box x1037 = new Box((int)0); + Box x1038 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1037, x1038, x7, (arg2[7])); + Box x1039 = new Box((int)0); + Box x1040 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1039, x1040, x7, (arg2[6])); + Box x1041 = new Box((int)0); + Box x1042 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1041, x1042, x7, (arg2[5])); + Box x1043 = new Box((int)0); + Box x1044 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1043, x1044, x7, (arg2[4])); + Box x1045 = new Box((int)0); + Box x1046 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1045, x1046, x7, (arg2[3])); + Box x1047 = new Box((int)0); + Box x1048 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1047, x1048, x7, (arg2[2])); + Box x1049 = new Box((int)0); + Box x1050 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1049, x1050, x7, (arg2[1])); + Box x1051 = new Box((int)0); + Box x1052 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1051, x1052, x7, (arg2[0])); + Box x1053 = new Box((int)0); + Box x1054 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1053, x1054, 0x0, (x1052).get(), (x1049).get()); + Box x1055 = new Box((int)0); + Box x1056 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1055, x1056, (x1054).get(), (x1050).get(), (x1047).get()); + Box x1057 = new Box((int)0); + Box x1058 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1057, x1058, (x1056).get(), (x1048).get(), (x1045).get()); + Box x1059 = new Box((int)0); + Box x1060 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1059, x1060, (x1058).get(), (x1046).get(), (x1043).get()); + Box x1061 = new Box((int)0); + Box x1062 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1061, x1062, (x1060).get(), (x1044).get(), (x1041).get()); + Box x1063 = new Box((int)0); + Box x1064 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1063, x1064, (x1062).get(), (x1042).get(), (x1039).get()); + Box x1065 = new Box((int)0); + Box x1066 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1065, x1066, (x1064).get(), (x1040).get(), (x1037).get()); + Box x1067 = new Box((int)0); + Box x1068 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1067, x1068, (x1066).get(), (x1038).get(), (x1035).get()); + Box x1069 = new Box((int)0); + Box x1070 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1069, x1070, (x1068).get(), (x1036).get(), (x1033).get()); + Box x1071 = new Box((int)0); + Box x1072 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1071, x1072, (x1070).get(), (x1034).get(), (x1031).get()); + Box x1073 = new Box((int)0); + Box x1074 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1073, x1074, (x1072).get(), (x1032).get(), (x1029).get()); + int x1075 = ((x1074).get() + (x1030).get()); + Box x1076 = new Box((int)0); + Box x1077 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1076, x1077, 0x0, (x1004).get(), (x1051).get()); + Box x1078 = new Box((int)0); + Box x1079 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1078, x1079, (x1077).get(), (x1006).get(), (x1053).get()); + Box x1080 = new Box((int)0); + Box x1081 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1080, x1081, (x1079).get(), (x1008).get(), (x1055).get()); + Box x1082 = new Box((int)0); + Box x1083 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1082, x1083, (x1081).get(), (x1010).get(), (x1057).get()); + Box x1084 = new Box((int)0); + Box x1085 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1084, x1085, (x1083).get(), (x1012).get(), (x1059).get()); + Box x1086 = new Box((int)0); + Box x1087 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1086, x1087, (x1085).get(), (x1014).get(), (x1061).get()); + Box x1088 = new Box((int)0); + Box x1089 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1088, x1089, (x1087).get(), (x1016).get(), (x1063).get()); + Box x1090 = new Box((int)0); + Box x1091 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1090, x1091, (x1089).get(), (x1018).get(), (x1065).get()); + Box x1092 = new Box((int)0); + Box x1093 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1092, x1093, (x1091).get(), (x1020).get(), (x1067).get()); + Box x1094 = new Box((int)0); + Box x1095 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1094, x1095, (x1093).get(), (x1022).get(), (x1069).get()); + Box x1096 = new Box((int)0); + Box x1097 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1096, x1097, (x1095).get(), (x1024).get(), (x1071).get()); + Box x1098 = new Box((int)0); + Box x1099 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1098, x1099, (x1097).get(), (x1026).get(), (x1073).get()); + Box x1100 = new Box((int)0); + Box x1101 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1100, x1101, (x1099).get(), x1028, x1075); + Box x1102 = new Box((int)0); + Box x1103 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1102, x1103, (x1076).get(), 0xe88fdc45); + Box x1104 = new Box((int)0); + Box x1105 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1104, x1105, (x1102).get(), 0xffffffff); + Box x1106 = new Box((int)0); + Box x1107 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1106, x1107, (x1102).get(), 0xffffffff); + Box x1108 = new Box((int)0); + Box x1109 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1108, x1109, (x1102).get(), 0xffffffff); + Box x1110 = new Box((int)0); + Box x1111 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1110, x1111, (x1102).get(), 0xffffffff); + Box x1112 = new Box((int)0); + Box x1113 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1112, x1113, (x1102).get(), 0xffffffff); + Box x1114 = new Box((int)0); + Box x1115 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1114, x1115, (x1102).get(), 0xffffffff); + Box x1116 = new Box((int)0); + Box x1117 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1116, x1117, (x1102).get(), 0xc7634d81); + Box x1118 = new Box((int)0); + Box x1119 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1118, x1119, (x1102).get(), 0xf4372ddf); + Box x1120 = new Box((int)0); + Box x1121 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1120, x1121, (x1102).get(), 0x581a0db2); + Box x1122 = new Box((int)0); + Box x1123 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1122, x1123, (x1102).get(), 0x48b0a77a); + Box x1124 = new Box((int)0); + Box x1125 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1124, x1125, (x1102).get(), 0xecec196a); + Box x1126 = new Box((int)0); + Box x1127 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1126, x1127, (x1102).get(), 0xccc52973); + Box x1128 = new Box((int)0); + Box x1129 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1128, x1129, 0x0, (x1127).get(), (x1124).get()); + Box x1130 = new Box((int)0); + Box x1131 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1130, x1131, (x1129).get(), (x1125).get(), (x1122).get()); + Box x1132 = new Box((int)0); + Box x1133 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1132, x1133, (x1131).get(), (x1123).get(), (x1120).get()); + Box x1134 = new Box((int)0); + Box x1135 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1134, x1135, (x1133).get(), (x1121).get(), (x1118).get()); + Box x1136 = new Box((int)0); + Box x1137 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1136, x1137, (x1135).get(), (x1119).get(), (x1116).get()); + Box x1138 = new Box((int)0); + Box x1139 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1138, x1139, (x1137).get(), (x1117).get(), (x1114).get()); + Box x1140 = new Box((int)0); + Box x1141 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1140, x1141, (x1139).get(), (x1115).get(), (x1112).get()); + Box x1142 = new Box((int)0); + Box x1143 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1142, x1143, (x1141).get(), (x1113).get(), (x1110).get()); + Box x1144 = new Box((int)0); + Box x1145 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1144, x1145, (x1143).get(), (x1111).get(), (x1108).get()); + Box x1146 = new Box((int)0); + Box x1147 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1146, x1147, (x1145).get(), (x1109).get(), (x1106).get()); + Box x1148 = new Box((int)0); + Box x1149 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1148, x1149, (x1147).get(), (x1107).get(), (x1104).get()); + int x1150 = ((x1149).get() + (x1105).get()); + Box x1151 = new Box((int)0); + Box x1152 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1151, x1152, 0x0, (x1076).get(), (x1126).get()); + Box x1153 = new Box((int)0); + Box x1154 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1153, x1154, (x1152).get(), (x1078).get(), (x1128).get()); + Box x1155 = new Box((int)0); + Box x1156 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1155, x1156, (x1154).get(), (x1080).get(), (x1130).get()); + Box x1157 = new Box((int)0); + Box x1158 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1157, x1158, (x1156).get(), (x1082).get(), (x1132).get()); + Box x1159 = new Box((int)0); + Box x1160 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1159, x1160, (x1158).get(), (x1084).get(), (x1134).get()); + Box x1161 = new Box((int)0); + Box x1162 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1161, x1162, (x1160).get(), (x1086).get(), (x1136).get()); + Box x1163 = new Box((int)0); + Box x1164 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1163, x1164, (x1162).get(), (x1088).get(), (x1138).get()); + Box x1165 = new Box((int)0); + Box x1166 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1165, x1166, (x1164).get(), (x1090).get(), (x1140).get()); + Box x1167 = new Box((int)0); + Box x1168 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1167, x1168, (x1166).get(), (x1092).get(), (x1142).get()); + Box x1169 = new Box((int)0); + Box x1170 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1169, x1170, (x1168).get(), (x1094).get(), (x1144).get()); + Box x1171 = new Box((int)0); + Box x1172 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1171, x1172, (x1170).get(), (x1096).get(), (x1146).get()); + Box x1173 = new Box((int)0); + Box x1174 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1173, x1174, (x1172).get(), (x1098).get(), (x1148).get()); + Box x1175 = new Box((int)0); + Box x1176 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1175, x1176, (x1174).get(), (x1100).get(), x1150); + int x1177 = ((x1176).get() + (x1101).get()); + Box x1178 = new Box((int)0); + Box x1179 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1178, x1179, x8, (arg2[11])); + Box x1180 = new Box((int)0); + Box x1181 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1180, x1181, x8, (arg2[10])); + Box x1182 = new Box((int)0); + Box x1183 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1182, x1183, x8, (arg2[9])); + Box x1184 = new Box((int)0); + Box x1185 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1184, x1185, x8, (arg2[8])); + Box x1186 = new Box((int)0); + Box x1187 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1186, x1187, x8, (arg2[7])); + Box x1188 = new Box((int)0); + Box x1189 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1188, x1189, x8, (arg2[6])); + Box x1190 = new Box((int)0); + Box x1191 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1190, x1191, x8, (arg2[5])); + Box x1192 = new Box((int)0); + Box x1193 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1192, x1193, x8, (arg2[4])); + Box x1194 = new Box((int)0); + Box x1195 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1194, x1195, x8, (arg2[3])); + Box x1196 = new Box((int)0); + Box x1197 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1196, x1197, x8, (arg2[2])); + Box x1198 = new Box((int)0); + Box x1199 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1198, x1199, x8, (arg2[1])); + Box x1200 = new Box((int)0); + Box x1201 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1200, x1201, x8, (arg2[0])); + Box x1202 = new Box((int)0); + Box x1203 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1202, x1203, 0x0, (x1201).get(), (x1198).get()); + Box x1204 = new Box((int)0); + Box x1205 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1204, x1205, (x1203).get(), (x1199).get(), (x1196).get()); + Box x1206 = new Box((int)0); + Box x1207 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1206, x1207, (x1205).get(), (x1197).get(), (x1194).get()); + Box x1208 = new Box((int)0); + Box x1209 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1208, x1209, (x1207).get(), (x1195).get(), (x1192).get()); + Box x1210 = new Box((int)0); + Box x1211 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1210, x1211, (x1209).get(), (x1193).get(), (x1190).get()); + Box x1212 = new Box((int)0); + Box x1213 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1212, x1213, (x1211).get(), (x1191).get(), (x1188).get()); + Box x1214 = new Box((int)0); + Box x1215 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1214, x1215, (x1213).get(), (x1189).get(), (x1186).get()); + Box x1216 = new Box((int)0); + Box x1217 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1216, x1217, (x1215).get(), (x1187).get(), (x1184).get()); + Box x1218 = new Box((int)0); + Box x1219 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1218, x1219, (x1217).get(), (x1185).get(), (x1182).get()); + Box x1220 = new Box((int)0); + Box x1221 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1220, x1221, (x1219).get(), (x1183).get(), (x1180).get()); + Box x1222 = new Box((int)0); + Box x1223 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1222, x1223, (x1221).get(), (x1181).get(), (x1178).get()); + int x1224 = ((x1223).get() + (x1179).get()); + Box x1225 = new Box((int)0); + Box x1226 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1225, x1226, 0x0, (x1153).get(), (x1200).get()); + Box x1227 = new Box((int)0); + Box x1228 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1227, x1228, (x1226).get(), (x1155).get(), (x1202).get()); + Box x1229 = new Box((int)0); + Box x1230 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1229, x1230, (x1228).get(), (x1157).get(), (x1204).get()); + Box x1231 = new Box((int)0); + Box x1232 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1231, x1232, (x1230).get(), (x1159).get(), (x1206).get()); + Box x1233 = new Box((int)0); + Box x1234 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1233, x1234, (x1232).get(), (x1161).get(), (x1208).get()); + Box x1235 = new Box((int)0); + Box x1236 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1235, x1236, (x1234).get(), (x1163).get(), (x1210).get()); + Box x1237 = new Box((int)0); + Box x1238 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1237, x1238, (x1236).get(), (x1165).get(), (x1212).get()); + Box x1239 = new Box((int)0); + Box x1240 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1239, x1240, (x1238).get(), (x1167).get(), (x1214).get()); + Box x1241 = new Box((int)0); + Box x1242 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1241, x1242, (x1240).get(), (x1169).get(), (x1216).get()); + Box x1243 = new Box((int)0); + Box x1244 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1243, x1244, (x1242).get(), (x1171).get(), (x1218).get()); + Box x1245 = new Box((int)0); + Box x1246 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1245, x1246, (x1244).get(), (x1173).get(), (x1220).get()); + Box x1247 = new Box((int)0); + Box x1248 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1247, x1248, (x1246).get(), (x1175).get(), (x1222).get()); + Box x1249 = new Box((int)0); + Box x1250 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1249, x1250, (x1248).get(), x1177, x1224); + Box x1251 = new Box((int)0); + Box x1252 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1251, x1252, (x1225).get(), 0xe88fdc45); + Box x1253 = new Box((int)0); + Box x1254 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1253, x1254, (x1251).get(), 0xffffffff); + Box x1255 = new Box((int)0); + Box x1256 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1255, x1256, (x1251).get(), 0xffffffff); + Box x1257 = new Box((int)0); + Box x1258 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1257, x1258, (x1251).get(), 0xffffffff); + Box x1259 = new Box((int)0); + Box x1260 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1259, x1260, (x1251).get(), 0xffffffff); + Box x1261 = new Box((int)0); + Box x1262 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1261, x1262, (x1251).get(), 0xffffffff); + Box x1263 = new Box((int)0); + Box x1264 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1263, x1264, (x1251).get(), 0xffffffff); + Box x1265 = new Box((int)0); + Box x1266 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1265, x1266, (x1251).get(), 0xc7634d81); + Box x1267 = new Box((int)0); + Box x1268 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1267, x1268, (x1251).get(), 0xf4372ddf); + Box x1269 = new Box((int)0); + Box x1270 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1269, x1270, (x1251).get(), 0x581a0db2); + Box x1271 = new Box((int)0); + Box x1272 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1271, x1272, (x1251).get(), 0x48b0a77a); + Box x1273 = new Box((int)0); + Box x1274 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1273, x1274, (x1251).get(), 0xecec196a); + Box x1275 = new Box((int)0); + Box x1276 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1275, x1276, (x1251).get(), 0xccc52973); + Box x1277 = new Box((int)0); + Box x1278 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1277, x1278, 0x0, (x1276).get(), (x1273).get()); + Box x1279 = new Box((int)0); + Box x1280 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1279, x1280, (x1278).get(), (x1274).get(), (x1271).get()); + Box x1281 = new Box((int)0); + Box x1282 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1281, x1282, (x1280).get(), (x1272).get(), (x1269).get()); + Box x1283 = new Box((int)0); + Box x1284 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1283, x1284, (x1282).get(), (x1270).get(), (x1267).get()); + Box x1285 = new Box((int)0); + Box x1286 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1285, x1286, (x1284).get(), (x1268).get(), (x1265).get()); + Box x1287 = new Box((int)0); + Box x1288 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1287, x1288, (x1286).get(), (x1266).get(), (x1263).get()); + Box x1289 = new Box((int)0); + Box x1290 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1289, x1290, (x1288).get(), (x1264).get(), (x1261).get()); + Box x1291 = new Box((int)0); + Box x1292 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1291, x1292, (x1290).get(), (x1262).get(), (x1259).get()); + Box x1293 = new Box((int)0); + Box x1294 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1293, x1294, (x1292).get(), (x1260).get(), (x1257).get()); + Box x1295 = new Box((int)0); + Box x1296 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1295, x1296, (x1294).get(), (x1258).get(), (x1255).get()); + Box x1297 = new Box((int)0); + Box x1298 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1297, x1298, (x1296).get(), (x1256).get(), (x1253).get()); + int x1299 = ((x1298).get() + (x1254).get()); + Box x1300 = new Box((int)0); + Box x1301 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1300, x1301, 0x0, (x1225).get(), (x1275).get()); + Box x1302 = new Box((int)0); + Box x1303 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1302, x1303, (x1301).get(), (x1227).get(), (x1277).get()); + Box x1304 = new Box((int)0); + Box x1305 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1304, x1305, (x1303).get(), (x1229).get(), (x1279).get()); + Box x1306 = new Box((int)0); + Box x1307 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1306, x1307, (x1305).get(), (x1231).get(), (x1281).get()); + Box x1308 = new Box((int)0); + Box x1309 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1308, x1309, (x1307).get(), (x1233).get(), (x1283).get()); + Box x1310 = new Box((int)0); + Box x1311 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1310, x1311, (x1309).get(), (x1235).get(), (x1285).get()); + Box x1312 = new Box((int)0); + Box x1313 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1312, x1313, (x1311).get(), (x1237).get(), (x1287).get()); + Box x1314 = new Box((int)0); + Box x1315 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1314, x1315, (x1313).get(), (x1239).get(), (x1289).get()); + Box x1316 = new Box((int)0); + Box x1317 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1316, x1317, (x1315).get(), (x1241).get(), (x1291).get()); + Box x1318 = new Box((int)0); + Box x1319 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1318, x1319, (x1317).get(), (x1243).get(), (x1293).get()); + Box x1320 = new Box((int)0); + Box x1321 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1320, x1321, (x1319).get(), (x1245).get(), (x1295).get()); + Box x1322 = new Box((int)0); + Box x1323 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1322, x1323, (x1321).get(), (x1247).get(), (x1297).get()); + Box x1324 = new Box((int)0); + Box x1325 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1324, x1325, (x1323).get(), (x1249).get(), x1299); + int x1326 = ((x1325).get() + (x1250).get()); + Box x1327 = new Box((int)0); + Box x1328 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1327, x1328, x9, (arg2[11])); + Box x1329 = new Box((int)0); + Box x1330 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1329, x1330, x9, (arg2[10])); + Box x1331 = new Box((int)0); + Box x1332 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1331, x1332, x9, (arg2[9])); + Box x1333 = new Box((int)0); + Box x1334 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1333, x1334, x9, (arg2[8])); + Box x1335 = new Box((int)0); + Box x1336 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1335, x1336, x9, (arg2[7])); + Box x1337 = new Box((int)0); + Box x1338 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1337, x1338, x9, (arg2[6])); + Box x1339 = new Box((int)0); + Box x1340 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1339, x1340, x9, (arg2[5])); + Box x1341 = new Box((int)0); + Box x1342 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1341, x1342, x9, (arg2[4])); + Box x1343 = new Box((int)0); + Box x1344 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1343, x1344, x9, (arg2[3])); + Box x1345 = new Box((int)0); + Box x1346 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1345, x1346, x9, (arg2[2])); + Box x1347 = new Box((int)0); + Box x1348 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1347, x1348, x9, (arg2[1])); + Box x1349 = new Box((int)0); + Box x1350 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1349, x1350, x9, (arg2[0])); + Box x1351 = new Box((int)0); + Box x1352 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1351, x1352, 0x0, (x1350).get(), (x1347).get()); + Box x1353 = new Box((int)0); + Box x1354 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1353, x1354, (x1352).get(), (x1348).get(), (x1345).get()); + Box x1355 = new Box((int)0); + Box x1356 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1355, x1356, (x1354).get(), (x1346).get(), (x1343).get()); + Box x1357 = new Box((int)0); + Box x1358 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1357, x1358, (x1356).get(), (x1344).get(), (x1341).get()); + Box x1359 = new Box((int)0); + Box x1360 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1359, x1360, (x1358).get(), (x1342).get(), (x1339).get()); + Box x1361 = new Box((int)0); + Box x1362 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1361, x1362, (x1360).get(), (x1340).get(), (x1337).get()); + Box x1363 = new Box((int)0); + Box x1364 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1363, x1364, (x1362).get(), (x1338).get(), (x1335).get()); + Box x1365 = new Box((int)0); + Box x1366 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1365, x1366, (x1364).get(), (x1336).get(), (x1333).get()); + Box x1367 = new Box((int)0); + Box x1368 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1367, x1368, (x1366).get(), (x1334).get(), (x1331).get()); + Box x1369 = new Box((int)0); + Box x1370 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1369, x1370, (x1368).get(), (x1332).get(), (x1329).get()); + Box x1371 = new Box((int)0); + Box x1372 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1371, x1372, (x1370).get(), (x1330).get(), (x1327).get()); + int x1373 = ((x1372).get() + (x1328).get()); + Box x1374 = new Box((int)0); + Box x1375 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1374, x1375, 0x0, (x1302).get(), (x1349).get()); + Box x1376 = new Box((int)0); + Box x1377 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1376, x1377, (x1375).get(), (x1304).get(), (x1351).get()); + Box x1378 = new Box((int)0); + Box x1379 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1378, x1379, (x1377).get(), (x1306).get(), (x1353).get()); + Box x1380 = new Box((int)0); + Box x1381 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1380, x1381, (x1379).get(), (x1308).get(), (x1355).get()); + Box x1382 = new Box((int)0); + Box x1383 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1382, x1383, (x1381).get(), (x1310).get(), (x1357).get()); + Box x1384 = new Box((int)0); + Box x1385 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1384, x1385, (x1383).get(), (x1312).get(), (x1359).get()); + Box x1386 = new Box((int)0); + Box x1387 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1386, x1387, (x1385).get(), (x1314).get(), (x1361).get()); + Box x1388 = new Box((int)0); + Box x1389 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1388, x1389, (x1387).get(), (x1316).get(), (x1363).get()); + Box x1390 = new Box((int)0); + Box x1391 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1390, x1391, (x1389).get(), (x1318).get(), (x1365).get()); + Box x1392 = new Box((int)0); + Box x1393 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1392, x1393, (x1391).get(), (x1320).get(), (x1367).get()); + Box x1394 = new Box((int)0); + Box x1395 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1394, x1395, (x1393).get(), (x1322).get(), (x1369).get()); + Box x1396 = new Box((int)0); + Box x1397 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1396, x1397, (x1395).get(), (x1324).get(), (x1371).get()); + Box x1398 = new Box((int)0); + Box x1399 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1398, x1399, (x1397).get(), x1326, x1373); + Box x1400 = new Box((int)0); + Box x1401 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1400, x1401, (x1374).get(), 0xe88fdc45); + Box x1402 = new Box((int)0); + Box x1403 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1402, x1403, (x1400).get(), 0xffffffff); + Box x1404 = new Box((int)0); + Box x1405 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1404, x1405, (x1400).get(), 0xffffffff); + Box x1406 = new Box((int)0); + Box x1407 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1406, x1407, (x1400).get(), 0xffffffff); + Box x1408 = new Box((int)0); + Box x1409 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1408, x1409, (x1400).get(), 0xffffffff); + Box x1410 = new Box((int)0); + Box x1411 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1410, x1411, (x1400).get(), 0xffffffff); + Box x1412 = new Box((int)0); + Box x1413 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1412, x1413, (x1400).get(), 0xffffffff); + Box x1414 = new Box((int)0); + Box x1415 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1414, x1415, (x1400).get(), 0xc7634d81); + Box x1416 = new Box((int)0); + Box x1417 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1416, x1417, (x1400).get(), 0xf4372ddf); + Box x1418 = new Box((int)0); + Box x1419 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1418, x1419, (x1400).get(), 0x581a0db2); + Box x1420 = new Box((int)0); + Box x1421 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1420, x1421, (x1400).get(), 0x48b0a77a); + Box x1422 = new Box((int)0); + Box x1423 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1422, x1423, (x1400).get(), 0xecec196a); + Box x1424 = new Box((int)0); + Box x1425 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1424, x1425, (x1400).get(), 0xccc52973); + Box x1426 = new Box((int)0); + Box x1427 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1426, x1427, 0x0, (x1425).get(), (x1422).get()); + Box x1428 = new Box((int)0); + Box x1429 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1428, x1429, (x1427).get(), (x1423).get(), (x1420).get()); + Box x1430 = new Box((int)0); + Box x1431 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1430, x1431, (x1429).get(), (x1421).get(), (x1418).get()); + Box x1432 = new Box((int)0); + Box x1433 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1432, x1433, (x1431).get(), (x1419).get(), (x1416).get()); + Box x1434 = new Box((int)0); + Box x1435 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1434, x1435, (x1433).get(), (x1417).get(), (x1414).get()); + Box x1436 = new Box((int)0); + Box x1437 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1436, x1437, (x1435).get(), (x1415).get(), (x1412).get()); + Box x1438 = new Box((int)0); + Box x1439 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1438, x1439, (x1437).get(), (x1413).get(), (x1410).get()); + Box x1440 = new Box((int)0); + Box x1441 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1440, x1441, (x1439).get(), (x1411).get(), (x1408).get()); + Box x1442 = new Box((int)0); + Box x1443 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1442, x1443, (x1441).get(), (x1409).get(), (x1406).get()); + Box x1444 = new Box((int)0); + Box x1445 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1444, x1445, (x1443).get(), (x1407).get(), (x1404).get()); + Box x1446 = new Box((int)0); + Box x1447 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1446, x1447, (x1445).get(), (x1405).get(), (x1402).get()); + int x1448 = ((x1447).get() + (x1403).get()); + Box x1449 = new Box((int)0); + Box x1450 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1449, x1450, 0x0, (x1374).get(), (x1424).get()); + Box x1451 = new Box((int)0); + Box x1452 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1451, x1452, (x1450).get(), (x1376).get(), (x1426).get()); + Box x1453 = new Box((int)0); + Box x1454 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1453, x1454, (x1452).get(), (x1378).get(), (x1428).get()); + Box x1455 = new Box((int)0); + Box x1456 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1455, x1456, (x1454).get(), (x1380).get(), (x1430).get()); + Box x1457 = new Box((int)0); + Box x1458 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1457, x1458, (x1456).get(), (x1382).get(), (x1432).get()); + Box x1459 = new Box((int)0); + Box x1460 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1459, x1460, (x1458).get(), (x1384).get(), (x1434).get()); + Box x1461 = new Box((int)0); + Box x1462 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1461, x1462, (x1460).get(), (x1386).get(), (x1436).get()); + Box x1463 = new Box((int)0); + Box x1464 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1463, x1464, (x1462).get(), (x1388).get(), (x1438).get()); + Box x1465 = new Box((int)0); + Box x1466 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1465, x1466, (x1464).get(), (x1390).get(), (x1440).get()); + Box x1467 = new Box((int)0); + Box x1468 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1467, x1468, (x1466).get(), (x1392).get(), (x1442).get()); + Box x1469 = new Box((int)0); + Box x1470 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1469, x1470, (x1468).get(), (x1394).get(), (x1444).get()); + Box x1471 = new Box((int)0); + Box x1472 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1471, x1472, (x1470).get(), (x1396).get(), (x1446).get()); + Box x1473 = new Box((int)0); + Box x1474 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1473, x1474, (x1472).get(), (x1398).get(), x1448); + int x1475 = ((x1474).get() + (x1399).get()); + Box x1476 = new Box((int)0); + Box x1477 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1476, x1477, x10, (arg2[11])); + Box x1478 = new Box((int)0); + Box x1479 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1478, x1479, x10, (arg2[10])); + Box x1480 = new Box((int)0); + Box x1481 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1480, x1481, x10, (arg2[9])); + Box x1482 = new Box((int)0); + Box x1483 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1482, x1483, x10, (arg2[8])); + Box x1484 = new Box((int)0); + Box x1485 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1484, x1485, x10, (arg2[7])); + Box x1486 = new Box((int)0); + Box x1487 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1486, x1487, x10, (arg2[6])); + Box x1488 = new Box((int)0); + Box x1489 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1488, x1489, x10, (arg2[5])); + Box x1490 = new Box((int)0); + Box x1491 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1490, x1491, x10, (arg2[4])); + Box x1492 = new Box((int)0); + Box x1493 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1492, x1493, x10, (arg2[3])); + Box x1494 = new Box((int)0); + Box x1495 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1494, x1495, x10, (arg2[2])); + Box x1496 = new Box((int)0); + Box x1497 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1496, x1497, x10, (arg2[1])); + Box x1498 = new Box((int)0); + Box x1499 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1498, x1499, x10, (arg2[0])); + Box x1500 = new Box((int)0); + Box x1501 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1500, x1501, 0x0, (x1499).get(), (x1496).get()); + Box x1502 = new Box((int)0); + Box x1503 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1502, x1503, (x1501).get(), (x1497).get(), (x1494).get()); + Box x1504 = new Box((int)0); + Box x1505 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1504, x1505, (x1503).get(), (x1495).get(), (x1492).get()); + Box x1506 = new Box((int)0); + Box x1507 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1506, x1507, (x1505).get(), (x1493).get(), (x1490).get()); + Box x1508 = new Box((int)0); + Box x1509 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1508, x1509, (x1507).get(), (x1491).get(), (x1488).get()); + Box x1510 = new Box((int)0); + Box x1511 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1510, x1511, (x1509).get(), (x1489).get(), (x1486).get()); + Box x1512 = new Box((int)0); + Box x1513 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1512, x1513, (x1511).get(), (x1487).get(), (x1484).get()); + Box x1514 = new Box((int)0); + Box x1515 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1514, x1515, (x1513).get(), (x1485).get(), (x1482).get()); + Box x1516 = new Box((int)0); + Box x1517 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1516, x1517, (x1515).get(), (x1483).get(), (x1480).get()); + Box x1518 = new Box((int)0); + Box x1519 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1518, x1519, (x1517).get(), (x1481).get(), (x1478).get()); + Box x1520 = new Box((int)0); + Box x1521 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1520, x1521, (x1519).get(), (x1479).get(), (x1476).get()); + int x1522 = ((x1521).get() + (x1477).get()); + Box x1523 = new Box((int)0); + Box x1524 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1523, x1524, 0x0, (x1451).get(), (x1498).get()); + Box x1525 = new Box((int)0); + Box x1526 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1525, x1526, (x1524).get(), (x1453).get(), (x1500).get()); + Box x1527 = new Box((int)0); + Box x1528 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1527, x1528, (x1526).get(), (x1455).get(), (x1502).get()); + Box x1529 = new Box((int)0); + Box x1530 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1529, x1530, (x1528).get(), (x1457).get(), (x1504).get()); + Box x1531 = new Box((int)0); + Box x1532 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1531, x1532, (x1530).get(), (x1459).get(), (x1506).get()); + Box x1533 = new Box((int)0); + Box x1534 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1533, x1534, (x1532).get(), (x1461).get(), (x1508).get()); + Box x1535 = new Box((int)0); + Box x1536 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1535, x1536, (x1534).get(), (x1463).get(), (x1510).get()); + Box x1537 = new Box((int)0); + Box x1538 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1537, x1538, (x1536).get(), (x1465).get(), (x1512).get()); + Box x1539 = new Box((int)0); + Box x1540 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1539, x1540, (x1538).get(), (x1467).get(), (x1514).get()); + Box x1541 = new Box((int)0); + Box x1542 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1541, x1542, (x1540).get(), (x1469).get(), (x1516).get()); + Box x1543 = new Box((int)0); + Box x1544 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1543, x1544, (x1542).get(), (x1471).get(), (x1518).get()); + Box x1545 = new Box((int)0); + Box x1546 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1545, x1546, (x1544).get(), (x1473).get(), (x1520).get()); + Box x1547 = new Box((int)0); + Box x1548 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1547, x1548, (x1546).get(), x1475, x1522); + Box x1549 = new Box((int)0); + Box x1550 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1549, x1550, (x1523).get(), 0xe88fdc45); + Box x1551 = new Box((int)0); + Box x1552 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1551, x1552, (x1549).get(), 0xffffffff); + Box x1553 = new Box((int)0); + Box x1554 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1553, x1554, (x1549).get(), 0xffffffff); + Box x1555 = new Box((int)0); + Box x1556 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1555, x1556, (x1549).get(), 0xffffffff); + Box x1557 = new Box((int)0); + Box x1558 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1557, x1558, (x1549).get(), 0xffffffff); + Box x1559 = new Box((int)0); + Box x1560 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1559, x1560, (x1549).get(), 0xffffffff); + Box x1561 = new Box((int)0); + Box x1562 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1561, x1562, (x1549).get(), 0xffffffff); + Box x1563 = new Box((int)0); + Box x1564 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1563, x1564, (x1549).get(), 0xc7634d81); + Box x1565 = new Box((int)0); + Box x1566 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1565, x1566, (x1549).get(), 0xf4372ddf); + Box x1567 = new Box((int)0); + Box x1568 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1567, x1568, (x1549).get(), 0x581a0db2); + Box x1569 = new Box((int)0); + Box x1570 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1569, x1570, (x1549).get(), 0x48b0a77a); + Box x1571 = new Box((int)0); + Box x1572 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1571, x1572, (x1549).get(), 0xecec196a); + Box x1573 = new Box((int)0); + Box x1574 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1573, x1574, (x1549).get(), 0xccc52973); + Box x1575 = new Box((int)0); + Box x1576 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1575, x1576, 0x0, (x1574).get(), (x1571).get()); + Box x1577 = new Box((int)0); + Box x1578 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1577, x1578, (x1576).get(), (x1572).get(), (x1569).get()); + Box x1579 = new Box((int)0); + Box x1580 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1579, x1580, (x1578).get(), (x1570).get(), (x1567).get()); + Box x1581 = new Box((int)0); + Box x1582 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1581, x1582, (x1580).get(), (x1568).get(), (x1565).get()); + Box x1583 = new Box((int)0); + Box x1584 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1583, x1584, (x1582).get(), (x1566).get(), (x1563).get()); + Box x1585 = new Box((int)0); + Box x1586 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1585, x1586, (x1584).get(), (x1564).get(), (x1561).get()); + Box x1587 = new Box((int)0); + Box x1588 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1587, x1588, (x1586).get(), (x1562).get(), (x1559).get()); + Box x1589 = new Box((int)0); + Box x1590 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1589, x1590, (x1588).get(), (x1560).get(), (x1557).get()); + Box x1591 = new Box((int)0); + Box x1592 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1591, x1592, (x1590).get(), (x1558).get(), (x1555).get()); + Box x1593 = new Box((int)0); + Box x1594 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1593, x1594, (x1592).get(), (x1556).get(), (x1553).get()); + Box x1595 = new Box((int)0); + Box x1596 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1595, x1596, (x1594).get(), (x1554).get(), (x1551).get()); + int x1597 = ((x1596).get() + (x1552).get()); + Box x1598 = new Box((int)0); + Box x1599 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1598, x1599, 0x0, (x1523).get(), (x1573).get()); + Box x1600 = new Box((int)0); + Box x1601 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1600, x1601, (x1599).get(), (x1525).get(), (x1575).get()); + Box x1602 = new Box((int)0); + Box x1603 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1602, x1603, (x1601).get(), (x1527).get(), (x1577).get()); + Box x1604 = new Box((int)0); + Box x1605 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1604, x1605, (x1603).get(), (x1529).get(), (x1579).get()); + Box x1606 = new Box((int)0); + Box x1607 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1606, x1607, (x1605).get(), (x1531).get(), (x1581).get()); + Box x1608 = new Box((int)0); + Box x1609 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1608, x1609, (x1607).get(), (x1533).get(), (x1583).get()); + Box x1610 = new Box((int)0); + Box x1611 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1610, x1611, (x1609).get(), (x1535).get(), (x1585).get()); + Box x1612 = new Box((int)0); + Box x1613 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1612, x1613, (x1611).get(), (x1537).get(), (x1587).get()); + Box x1614 = new Box((int)0); + Box x1615 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1614, x1615, (x1613).get(), (x1539).get(), (x1589).get()); + Box x1616 = new Box((int)0); + Box x1617 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1616, x1617, (x1615).get(), (x1541).get(), (x1591).get()); + Box x1618 = new Box((int)0); + Box x1619 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1618, x1619, (x1617).get(), (x1543).get(), (x1593).get()); + Box x1620 = new Box((int)0); + Box x1621 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1620, x1621, (x1619).get(), (x1545).get(), (x1595).get()); + Box x1622 = new Box((int)0); + Box x1623 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1622, x1623, (x1621).get(), (x1547).get(), x1597); + int x1624 = ((x1623).get() + (x1548).get()); + Box x1625 = new Box((int)0); + Box x1626 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1625, x1626, x11, (arg2[11])); + Box x1627 = new Box((int)0); + Box x1628 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1627, x1628, x11, (arg2[10])); + Box x1629 = new Box((int)0); + Box x1630 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1629, x1630, x11, (arg2[9])); + Box x1631 = new Box((int)0); + Box x1632 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1631, x1632, x11, (arg2[8])); + Box x1633 = new Box((int)0); + Box x1634 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1633, x1634, x11, (arg2[7])); + Box x1635 = new Box((int)0); + Box x1636 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1635, x1636, x11, (arg2[6])); + Box x1637 = new Box((int)0); + Box x1638 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1637, x1638, x11, (arg2[5])); + Box x1639 = new Box((int)0); + Box x1640 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1639, x1640, x11, (arg2[4])); + Box x1641 = new Box((int)0); + Box x1642 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1641, x1642, x11, (arg2[3])); + Box x1643 = new Box((int)0); + Box x1644 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1643, x1644, x11, (arg2[2])); + Box x1645 = new Box((int)0); + Box x1646 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1645, x1646, x11, (arg2[1])); + Box x1647 = new Box((int)0); + Box x1648 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1647, x1648, x11, (arg2[0])); + Box x1649 = new Box((int)0); + Box x1650 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1649, x1650, 0x0, (x1648).get(), (x1645).get()); + Box x1651 = new Box((int)0); + Box x1652 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1651, x1652, (x1650).get(), (x1646).get(), (x1643).get()); + Box x1653 = new Box((int)0); + Box x1654 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1653, x1654, (x1652).get(), (x1644).get(), (x1641).get()); + Box x1655 = new Box((int)0); + Box x1656 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1655, x1656, (x1654).get(), (x1642).get(), (x1639).get()); + Box x1657 = new Box((int)0); + Box x1658 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1657, x1658, (x1656).get(), (x1640).get(), (x1637).get()); + Box x1659 = new Box((int)0); + Box x1660 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1659, x1660, (x1658).get(), (x1638).get(), (x1635).get()); + Box x1661 = new Box((int)0); + Box x1662 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1661, x1662, (x1660).get(), (x1636).get(), (x1633).get()); + Box x1663 = new Box((int)0); + Box x1664 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1663, x1664, (x1662).get(), (x1634).get(), (x1631).get()); + Box x1665 = new Box((int)0); + Box x1666 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1665, x1666, (x1664).get(), (x1632).get(), (x1629).get()); + Box x1667 = new Box((int)0); + Box x1668 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1667, x1668, (x1666).get(), (x1630).get(), (x1627).get()); + Box x1669 = new Box((int)0); + Box x1670 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1669, x1670, (x1668).get(), (x1628).get(), (x1625).get()); + int x1671 = ((x1670).get() + (x1626).get()); + Box x1672 = new Box((int)0); + Box x1673 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1672, x1673, 0x0, (x1600).get(), (x1647).get()); + Box x1674 = new Box((int)0); + Box x1675 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1674, x1675, (x1673).get(), (x1602).get(), (x1649).get()); + Box x1676 = new Box((int)0); + Box x1677 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1676, x1677, (x1675).get(), (x1604).get(), (x1651).get()); + Box x1678 = new Box((int)0); + Box x1679 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1678, x1679, (x1677).get(), (x1606).get(), (x1653).get()); + Box x1680 = new Box((int)0); + Box x1681 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1680, x1681, (x1679).get(), (x1608).get(), (x1655).get()); + Box x1682 = new Box((int)0); + Box x1683 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1682, x1683, (x1681).get(), (x1610).get(), (x1657).get()); + Box x1684 = new Box((int)0); + Box x1685 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1684, x1685, (x1683).get(), (x1612).get(), (x1659).get()); + Box x1686 = new Box((int)0); + Box x1687 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1686, x1687, (x1685).get(), (x1614).get(), (x1661).get()); + Box x1688 = new Box((int)0); + Box x1689 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1688, x1689, (x1687).get(), (x1616).get(), (x1663).get()); + Box x1690 = new Box((int)0); + Box x1691 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1690, x1691, (x1689).get(), (x1618).get(), (x1665).get()); + Box x1692 = new Box((int)0); + Box x1693 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1692, x1693, (x1691).get(), (x1620).get(), (x1667).get()); + Box x1694 = new Box((int)0); + Box x1695 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1694, x1695, (x1693).get(), (x1622).get(), (x1669).get()); + Box x1696 = new Box((int)0); + Box x1697 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1696, x1697, (x1695).get(), x1624, x1671); + Box x1698 = new Box((int)0); + Box x1699 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1698, x1699, (x1672).get(), 0xe88fdc45); + Box x1700 = new Box((int)0); + Box x1701 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1700, x1701, (x1698).get(), 0xffffffff); + Box x1702 = new Box((int)0); + Box x1703 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1702, x1703, (x1698).get(), 0xffffffff); + Box x1704 = new Box((int)0); + Box x1705 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1704, x1705, (x1698).get(), 0xffffffff); + Box x1706 = new Box((int)0); + Box x1707 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1706, x1707, (x1698).get(), 0xffffffff); + Box x1708 = new Box((int)0); + Box x1709 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1708, x1709, (x1698).get(), 0xffffffff); + Box x1710 = new Box((int)0); + Box x1711 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1710, x1711, (x1698).get(), 0xffffffff); + Box x1712 = new Box((int)0); + Box x1713 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1712, x1713, (x1698).get(), 0xc7634d81); + Box x1714 = new Box((int)0); + Box x1715 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1714, x1715, (x1698).get(), 0xf4372ddf); + Box x1716 = new Box((int)0); + Box x1717 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1716, x1717, (x1698).get(), 0x581a0db2); + Box x1718 = new Box((int)0); + Box x1719 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1718, x1719, (x1698).get(), 0x48b0a77a); + Box x1720 = new Box((int)0); + Box x1721 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1720, x1721, (x1698).get(), 0xecec196a); + Box x1722 = new Box((int)0); + Box x1723 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1722, x1723, (x1698).get(), 0xccc52973); + Box x1724 = new Box((int)0); + Box x1725 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1724, x1725, 0x0, (x1723).get(), (x1720).get()); + Box x1726 = new Box((int)0); + Box x1727 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1726, x1727, (x1725).get(), (x1721).get(), (x1718).get()); + Box x1728 = new Box((int)0); + Box x1729 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1728, x1729, (x1727).get(), (x1719).get(), (x1716).get()); + Box x1730 = new Box((int)0); + Box x1731 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1730, x1731, (x1729).get(), (x1717).get(), (x1714).get()); + Box x1732 = new Box((int)0); + Box x1733 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1732, x1733, (x1731).get(), (x1715).get(), (x1712).get()); + Box x1734 = new Box((int)0); + Box x1735 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1734, x1735, (x1733).get(), (x1713).get(), (x1710).get()); + Box x1736 = new Box((int)0); + Box x1737 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1736, x1737, (x1735).get(), (x1711).get(), (x1708).get()); + Box x1738 = new Box((int)0); + Box x1739 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1738, x1739, (x1737).get(), (x1709).get(), (x1706).get()); + Box x1740 = new Box((int)0); + Box x1741 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1740, x1741, (x1739).get(), (x1707).get(), (x1704).get()); + Box x1742 = new Box((int)0); + Box x1743 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1742, x1743, (x1741).get(), (x1705).get(), (x1702).get()); + Box x1744 = new Box((int)0); + Box x1745 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1744, x1745, (x1743).get(), (x1703).get(), (x1700).get()); + int x1746 = ((x1745).get() + (x1701).get()); + Box x1747 = new Box((int)0); + Box x1748 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1747, x1748, 0x0, (x1672).get(), (x1722).get()); + Box x1749 = new Box((int)0); + Box x1750 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1749, x1750, (x1748).get(), (x1674).get(), (x1724).get()); + Box x1751 = new Box((int)0); + Box x1752 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1751, x1752, (x1750).get(), (x1676).get(), (x1726).get()); + Box x1753 = new Box((int)0); + Box x1754 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1753, x1754, (x1752).get(), (x1678).get(), (x1728).get()); + Box x1755 = new Box((int)0); + Box x1756 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1755, x1756, (x1754).get(), (x1680).get(), (x1730).get()); + Box x1757 = new Box((int)0); + Box x1758 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1757, x1758, (x1756).get(), (x1682).get(), (x1732).get()); + Box x1759 = new Box((int)0); + Box x1760 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1759, x1760, (x1758).get(), (x1684).get(), (x1734).get()); + Box x1761 = new Box((int)0); + Box x1762 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1761, x1762, (x1760).get(), (x1686).get(), (x1736).get()); + Box x1763 = new Box((int)0); + Box x1764 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1763, x1764, (x1762).get(), (x1688).get(), (x1738).get()); + Box x1765 = new Box((int)0); + Box x1766 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1765, x1766, (x1764).get(), (x1690).get(), (x1740).get()); + Box x1767 = new Box((int)0); + Box x1768 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1767, x1768, (x1766).get(), (x1692).get(), (x1742).get()); + Box x1769 = new Box((int)0); + Box x1770 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1769, x1770, (x1768).get(), (x1694).get(), (x1744).get()); + Box x1771 = new Box((int)0); + Box x1772 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1771, x1772, (x1770).get(), (x1696).get(), x1746); + int x1773 = ((x1772).get() + (x1697).get()); + Box x1774 = new Box((int)0); + Box x1775 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1774, x1775, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x1749).get(), 0xccc52973); + Box x1776 = new Box((int)0); + Box x1777 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1776, x1777, (x1775).get(), (x1751).get(), 0xecec196a); + Box x1778 = new Box((int)0); + Box x1779 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1778, x1779, (x1777).get(), (x1753).get(), 0x48b0a77a); + Box x1780 = new Box((int)0); + Box x1781 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1780, x1781, (x1779).get(), (x1755).get(), 0x581a0db2); + Box x1782 = new Box((int)0); + Box x1783 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1782, x1783, (x1781).get(), (x1757).get(), 0xf4372ddf); + Box x1784 = new Box((int)0); + Box x1785 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1784, x1785, (x1783).get(), (x1759).get(), 0xc7634d81); + Box x1786 = new Box((int)0); + Box x1787 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1786, x1787, (x1785).get(), (x1761).get(), 0xffffffff); + Box x1788 = new Box((int)0); + Box x1789 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1788, x1789, (x1787).get(), (x1763).get(), 0xffffffff); + Box x1790 = new Box((int)0); + Box x1791 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1790, x1791, (x1789).get(), (x1765).get(), 0xffffffff); + Box x1792 = new Box((int)0); + Box x1793 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1792, x1793, (x1791).get(), (x1767).get(), 0xffffffff); + Box x1794 = new Box((int)0); + Box x1795 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1794, x1795, (x1793).get(), (x1769).get(), 0xffffffff); + Box x1796 = new Box((int)0); + Box x1797 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1796, x1797, (x1795).get(), (x1771).get(), 0xffffffff); + Box x1798 = new Box((int)0); + Box x1799 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1798, x1799, (x1797).get(), x1773, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1800 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1800, (x1799).get(), (x1774).get(), (x1749).get()); + Box x1801 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1801, (x1799).get(), (x1776).get(), (x1751).get()); + Box x1802 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1802, (x1799).get(), (x1778).get(), (x1753).get()); + Box x1803 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1803, (x1799).get(), (x1780).get(), (x1755).get()); + Box x1804 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1804, (x1799).get(), (x1782).get(), (x1757).get()); + Box x1805 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1805, (x1799).get(), (x1784).get(), (x1759).get()); + Box x1806 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1806, (x1799).get(), (x1786).get(), (x1761).get()); + Box x1807 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1807, (x1799).get(), (x1788).get(), (x1763).get()); + Box x1808 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1808, (x1799).get(), (x1790).get(), (x1765).get()); + Box x1809 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1809, (x1799).get(), (x1792).get(), (x1767).get()); + Box x1810 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1810, (x1799).get(), (x1794).get(), (x1769).get()); + Box x1811 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1811, (x1799).get(), (x1796).get(), (x1771).get()); + out1[0] = (x1800).get(); + out1[1] = (x1801).get(); + out1[2] = (x1802).get(); + out1[3] = (x1803).get(); + out1[4] = (x1804).get(); + out1[5] = (x1805).get(); + out1[6] = (x1806).get(); + out1[7] = (x1807).get(); + out1[8] = (x1808).get(); + out1[9] = (x1809).get(); + out1[10] = (x1810).get(); + out1[11] = (x1811).get(); +} + +/** + * The function fiat_P384Scalar_square squares a field element in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_square(int[] out1, final int[] arg1) { + int x1 = (arg1[1]); + int x2 = (arg1[2]); + int x3 = (arg1[3]); + int x4 = (arg1[4]); + int x5 = (arg1[5]); + int x6 = (arg1[6]); + int x7 = (arg1[7]); + int x8 = (arg1[8]); + int x9 = (arg1[9]); + int x10 = (arg1[10]); + int x11 = (arg1[11]); + int x12 = (arg1[0]); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x13, x14, x12, (arg1[11])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x15, x16, x12, (arg1[10])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x17, x18, x12, (arg1[9])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x19, x20, x12, (arg1[8])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x21, x22, x12, (arg1[7])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x23, x24, x12, (arg1[6])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x25, x26, x12, (arg1[5])); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x27, x28, x12, (arg1[4])); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x29, x30, x12, (arg1[3])); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x31, x32, x12, (arg1[2])); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x33, x34, x12, (arg1[1])); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x35, x36, x12, (arg1[0])); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x37, x38, 0x0, (x36).get(), (x33).get()); + Box x39 = new Box((int)0); + Box x40 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x39, x40, (x38).get(), (x34).get(), (x31).get()); + Box x41 = new Box((int)0); + Box x42 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x41, x42, (x40).get(), (x32).get(), (x29).get()); + Box x43 = new Box((int)0); + Box x44 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x43, x44, (x42).get(), (x30).get(), (x27).get()); + Box x45 = new Box((int)0); + Box x46 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x45, x46, (x44).get(), (x28).get(), (x25).get()); + Box x47 = new Box((int)0); + Box x48 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x47, x48, (x46).get(), (x26).get(), (x23).get()); + Box x49 = new Box((int)0); + Box x50 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x49, x50, (x48).get(), (x24).get(), (x21).get()); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x51, x52, (x50).get(), (x22).get(), (x19).get()); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x53, x54, (x52).get(), (x20).get(), (x17).get()); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x55, x56, (x54).get(), (x18).get(), (x15).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x57, x58, (x56).get(), (x16).get(), (x13).get()); + int x59 = ((x58).get() + (x14).get()); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x60, x61, (x35).get(), 0xe88fdc45); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x62, x63, (x60).get(), 0xffffffff); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x64, x65, (x60).get(), 0xffffffff); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x66, x67, (x60).get(), 0xffffffff); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x68, x69, (x60).get(), 0xffffffff); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x70, x71, (x60).get(), 0xffffffff); + Box x72 = new Box((int)0); + Box x73 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x72, x73, (x60).get(), 0xffffffff); + Box x74 = new Box((int)0); + Box x75 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x74, x75, (x60).get(), 0xc7634d81); + Box x76 = new Box((int)0); + Box x77 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x76, x77, (x60).get(), 0xf4372ddf); + Box x78 = new Box((int)0); + Box x79 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x78, x79, (x60).get(), 0x581a0db2); + Box x80 = new Box((int)0); + Box x81 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x80, x81, (x60).get(), 0x48b0a77a); + Box x82 = new Box((int)0); + Box x83 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x82, x83, (x60).get(), 0xecec196a); + Box x84 = new Box((int)0); + Box x85 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x84, x85, (x60).get(), 0xccc52973); + Box x86 = new Box((int)0); + Box x87 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x86, x87, 0x0, (x85).get(), (x82).get()); + Box x88 = new Box((int)0); + Box x89 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x88, x89, (x87).get(), (x83).get(), (x80).get()); + Box x90 = new Box((int)0); + Box x91 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x90, x91, (x89).get(), (x81).get(), (x78).get()); + Box x92 = new Box((int)0); + Box x93 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x92, x93, (x91).get(), (x79).get(), (x76).get()); + Box x94 = new Box((int)0); + Box x95 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x94, x95, (x93).get(), (x77).get(), (x74).get()); + Box x96 = new Box((int)0); + Box x97 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x96, x97, (x95).get(), (x75).get(), (x72).get()); + Box x98 = new Box((int)0); + Box x99 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x98, x99, (x97).get(), (x73).get(), (x70).get()); + Box x100 = new Box((int)0); + Box x101 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x100, x101, (x99).get(), (x71).get(), (x68).get()); + Box x102 = new Box((int)0); + Box x103 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x102, x103, (x101).get(), (x69).get(), (x66).get()); + Box x104 = new Box((int)0); + Box x105 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x104, x105, (x103).get(), (x67).get(), (x64).get()); + Box x106 = new Box((int)0); + Box x107 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x106, x107, (x105).get(), (x65).get(), (x62).get()); + int x108 = ((x107).get() + (x63).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x109, x110, 0x0, (x35).get(), (x84).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x111, x112, (x110).get(), (x37).get(), (x86).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x113, x114, (x112).get(), (x39).get(), (x88).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x115, x116, (x114).get(), (x41).get(), (x90).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x117, x118, (x116).get(), (x43).get(), (x92).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x119, x120, (x118).get(), (x45).get(), (x94).get()); + Box x121 = new Box((int)0); + Box x122 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x121, x122, (x120).get(), (x47).get(), (x96).get()); + Box x123 = new Box((int)0); + Box x124 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x123, x124, (x122).get(), (x49).get(), (x98).get()); + Box x125 = new Box((int)0); + Box x126 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x125, x126, (x124).get(), (x51).get(), (x100).get()); + Box x127 = new Box((int)0); + Box x128 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x127, x128, (x126).get(), (x53).get(), (x102).get()); + Box x129 = new Box((int)0); + Box x130 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x129, x130, (x128).get(), (x55).get(), (x104).get()); + Box x131 = new Box((int)0); + Box x132 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x131, x132, (x130).get(), (x57).get(), (x106).get()); + Box x133 = new Box((int)0); + Box x134 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x133, x134, (x132).get(), x59, x108); + Box x135 = new Box((int)0); + Box x136 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x135, x136, x1, (arg1[11])); + Box x137 = new Box((int)0); + Box x138 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x137, x138, x1, (arg1[10])); + Box x139 = new Box((int)0); + Box x140 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x139, x140, x1, (arg1[9])); + Box x141 = new Box((int)0); + Box x142 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x141, x142, x1, (arg1[8])); + Box x143 = new Box((int)0); + Box x144 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x143, x144, x1, (arg1[7])); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x145, x146, x1, (arg1[6])); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x147, x148, x1, (arg1[5])); + Box x149 = new Box((int)0); + Box x150 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x149, x150, x1, (arg1[4])); + Box x151 = new Box((int)0); + Box x152 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x151, x152, x1, (arg1[3])); + Box x153 = new Box((int)0); + Box x154 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x153, x154, x1, (arg1[2])); + Box x155 = new Box((int)0); + Box x156 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x155, x156, x1, (arg1[1])); + Box x157 = new Box((int)0); + Box x158 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x157, x158, x1, (arg1[0])); + Box x159 = new Box((int)0); + Box x160 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x159, x160, 0x0, (x158).get(), (x155).get()); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x161, x162, (x160).get(), (x156).get(), (x153).get()); + Box x163 = new Box((int)0); + Box x164 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x163, x164, (x162).get(), (x154).get(), (x151).get()); + Box x165 = new Box((int)0); + Box x166 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x165, x166, (x164).get(), (x152).get(), (x149).get()); + Box x167 = new Box((int)0); + Box x168 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x167, x168, (x166).get(), (x150).get(), (x147).get()); + Box x169 = new Box((int)0); + Box x170 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x169, x170, (x168).get(), (x148).get(), (x145).get()); + Box x171 = new Box((int)0); + Box x172 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x171, x172, (x170).get(), (x146).get(), (x143).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x173, x174, (x172).get(), (x144).get(), (x141).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x175, x176, (x174).get(), (x142).get(), (x139).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x177, x178, (x176).get(), (x140).get(), (x137).get()); + Box x179 = new Box((int)0); + Box x180 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x179, x180, (x178).get(), (x138).get(), (x135).get()); + int x181 = ((x180).get() + (x136).get()); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x182, x183, 0x0, (x111).get(), (x157).get()); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x184, x185, (x183).get(), (x113).get(), (x159).get()); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x186, x187, (x185).get(), (x115).get(), (x161).get()); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x188, x189, (x187).get(), (x117).get(), (x163).get()); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x190, x191, (x189).get(), (x119).get(), (x165).get()); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x192, x193, (x191).get(), (x121).get(), (x167).get()); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x194, x195, (x193).get(), (x123).get(), (x169).get()); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x196, x197, (x195).get(), (x125).get(), (x171).get()); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x198, x199, (x197).get(), (x127).get(), (x173).get()); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x200, x201, (x199).get(), (x129).get(), (x175).get()); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x202, x203, (x201).get(), (x131).get(), (x177).get()); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x204, x205, (x203).get(), (x133).get(), (x179).get()); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x206, x207, (x205).get(), (x134).get(), x181); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x208, x209, (x182).get(), 0xe88fdc45); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x210, x211, (x208).get(), 0xffffffff); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x212, x213, (x208).get(), 0xffffffff); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x214, x215, (x208).get(), 0xffffffff); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x216, x217, (x208).get(), 0xffffffff); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x218, x219, (x208).get(), 0xffffffff); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x220, x221, (x208).get(), 0xffffffff); + Box x222 = new Box((int)0); + Box x223 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x222, x223, (x208).get(), 0xc7634d81); + Box x224 = new Box((int)0); + Box x225 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x224, x225, (x208).get(), 0xf4372ddf); + Box x226 = new Box((int)0); + Box x227 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x226, x227, (x208).get(), 0x581a0db2); + Box x228 = new Box((int)0); + Box x229 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x228, x229, (x208).get(), 0x48b0a77a); + Box x230 = new Box((int)0); + Box x231 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x230, x231, (x208).get(), 0xecec196a); + Box x232 = new Box((int)0); + Box x233 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x232, x233, (x208).get(), 0xccc52973); + Box x234 = new Box((int)0); + Box x235 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x234, x235, 0x0, (x233).get(), (x230).get()); + Box x236 = new Box((int)0); + Box x237 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x236, x237, (x235).get(), (x231).get(), (x228).get()); + Box x238 = new Box((int)0); + Box x239 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x238, x239, (x237).get(), (x229).get(), (x226).get()); + Box x240 = new Box((int)0); + Box x241 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x240, x241, (x239).get(), (x227).get(), (x224).get()); + Box x242 = new Box((int)0); + Box x243 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x242, x243, (x241).get(), (x225).get(), (x222).get()); + Box x244 = new Box((int)0); + Box x245 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x244, x245, (x243).get(), (x223).get(), (x220).get()); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x246, x247, (x245).get(), (x221).get(), (x218).get()); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x248, x249, (x247).get(), (x219).get(), (x216).get()); + Box x250 = new Box((int)0); + Box x251 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x250, x251, (x249).get(), (x217).get(), (x214).get()); + Box x252 = new Box((int)0); + Box x253 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x252, x253, (x251).get(), (x215).get(), (x212).get()); + Box x254 = new Box((int)0); + Box x255 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x254, x255, (x253).get(), (x213).get(), (x210).get()); + int x256 = ((x255).get() + (x211).get()); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x257, x258, 0x0, (x182).get(), (x232).get()); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x259, x260, (x258).get(), (x184).get(), (x234).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x261, x262, (x260).get(), (x186).get(), (x236).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x263, x264, (x262).get(), (x188).get(), (x238).get()); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x265, x266, (x264).get(), (x190).get(), (x240).get()); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x267, x268, (x266).get(), (x192).get(), (x242).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x269, x270, (x268).get(), (x194).get(), (x244).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x271, x272, (x270).get(), (x196).get(), (x246).get()); + Box x273 = new Box((int)0); + Box x274 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x273, x274, (x272).get(), (x198).get(), (x248).get()); + Box x275 = new Box((int)0); + Box x276 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x275, x276, (x274).get(), (x200).get(), (x250).get()); + Box x277 = new Box((int)0); + Box x278 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x277, x278, (x276).get(), (x202).get(), (x252).get()); + Box x279 = new Box((int)0); + Box x280 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x279, x280, (x278).get(), (x204).get(), (x254).get()); + Box x281 = new Box((int)0); + Box x282 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x281, x282, (x280).get(), (x206).get(), x256); + int x283 = ((x282).get() + (x207).get()); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x284, x285, x2, (arg1[11])); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x286, x287, x2, (arg1[10])); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x288, x289, x2, (arg1[9])); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x290, x291, x2, (arg1[8])); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x292, x293, x2, (arg1[7])); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x294, x295, x2, (arg1[6])); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x296, x297, x2, (arg1[5])); + Box x298 = new Box((int)0); + Box x299 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x298, x299, x2, (arg1[4])); + Box x300 = new Box((int)0); + Box x301 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x300, x301, x2, (arg1[3])); + Box x302 = new Box((int)0); + Box x303 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x302, x303, x2, (arg1[2])); + Box x304 = new Box((int)0); + Box x305 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x304, x305, x2, (arg1[1])); + Box x306 = new Box((int)0); + Box x307 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x306, x307, x2, (arg1[0])); + Box x308 = new Box((int)0); + Box x309 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x308, x309, 0x0, (x307).get(), (x304).get()); + Box x310 = new Box((int)0); + Box x311 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x310, x311, (x309).get(), (x305).get(), (x302).get()); + Box x312 = new Box((int)0); + Box x313 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x312, x313, (x311).get(), (x303).get(), (x300).get()); + Box x314 = new Box((int)0); + Box x315 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x314, x315, (x313).get(), (x301).get(), (x298).get()); + Box x316 = new Box((int)0); + Box x317 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x316, x317, (x315).get(), (x299).get(), (x296).get()); + Box x318 = new Box((int)0); + Box x319 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x318, x319, (x317).get(), (x297).get(), (x294).get()); + Box x320 = new Box((int)0); + Box x321 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x320, x321, (x319).get(), (x295).get(), (x292).get()); + Box x322 = new Box((int)0); + Box x323 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x322, x323, (x321).get(), (x293).get(), (x290).get()); + Box x324 = new Box((int)0); + Box x325 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x324, x325, (x323).get(), (x291).get(), (x288).get()); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x326, x327, (x325).get(), (x289).get(), (x286).get()); + Box x328 = new Box((int)0); + Box x329 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x328, x329, (x327).get(), (x287).get(), (x284).get()); + int x330 = ((x329).get() + (x285).get()); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x331, x332, 0x0, (x259).get(), (x306).get()); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x333, x334, (x332).get(), (x261).get(), (x308).get()); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x335, x336, (x334).get(), (x263).get(), (x310).get()); + Box x337 = new Box((int)0); + Box x338 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x337, x338, (x336).get(), (x265).get(), (x312).get()); + Box x339 = new Box((int)0); + Box x340 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x339, x340, (x338).get(), (x267).get(), (x314).get()); + Box x341 = new Box((int)0); + Box x342 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x341, x342, (x340).get(), (x269).get(), (x316).get()); + Box x343 = new Box((int)0); + Box x344 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x343, x344, (x342).get(), (x271).get(), (x318).get()); + Box x345 = new Box((int)0); + Box x346 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x345, x346, (x344).get(), (x273).get(), (x320).get()); + Box x347 = new Box((int)0); + Box x348 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x347, x348, (x346).get(), (x275).get(), (x322).get()); + Box x349 = new Box((int)0); + Box x350 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x349, x350, (x348).get(), (x277).get(), (x324).get()); + Box x351 = new Box((int)0); + Box x352 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x351, x352, (x350).get(), (x279).get(), (x326).get()); + Box x353 = new Box((int)0); + Box x354 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x353, x354, (x352).get(), (x281).get(), (x328).get()); + Box x355 = new Box((int)0); + Box x356 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x355, x356, (x354).get(), x283, x330); + Box x357 = new Box((int)0); + Box x358 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x357, x358, (x331).get(), 0xe88fdc45); + Box x359 = new Box((int)0); + Box x360 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x359, x360, (x357).get(), 0xffffffff); + Box x361 = new Box((int)0); + Box x362 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x361, x362, (x357).get(), 0xffffffff); + Box x363 = new Box((int)0); + Box x364 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x363, x364, (x357).get(), 0xffffffff); + Box x365 = new Box((int)0); + Box x366 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x365, x366, (x357).get(), 0xffffffff); + Box x367 = new Box((int)0); + Box x368 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x367, x368, (x357).get(), 0xffffffff); + Box x369 = new Box((int)0); + Box x370 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x369, x370, (x357).get(), 0xffffffff); + Box x371 = new Box((int)0); + Box x372 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x371, x372, (x357).get(), 0xc7634d81); + Box x373 = new Box((int)0); + Box x374 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x373, x374, (x357).get(), 0xf4372ddf); + Box x375 = new Box((int)0); + Box x376 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x375, x376, (x357).get(), 0x581a0db2); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x377, x378, (x357).get(), 0x48b0a77a); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x379, x380, (x357).get(), 0xecec196a); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x381, x382, (x357).get(), 0xccc52973); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x383, x384, 0x0, (x382).get(), (x379).get()); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x385, x386, (x384).get(), (x380).get(), (x377).get()); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x387, x388, (x386).get(), (x378).get(), (x375).get()); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x389, x390, (x388).get(), (x376).get(), (x373).get()); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x391, x392, (x390).get(), (x374).get(), (x371).get()); + Box x393 = new Box((int)0); + Box x394 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x393, x394, (x392).get(), (x372).get(), (x369).get()); + Box x395 = new Box((int)0); + Box x396 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x395, x396, (x394).get(), (x370).get(), (x367).get()); + Box x397 = new Box((int)0); + Box x398 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x397, x398, (x396).get(), (x368).get(), (x365).get()); + Box x399 = new Box((int)0); + Box x400 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x399, x400, (x398).get(), (x366).get(), (x363).get()); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x401, x402, (x400).get(), (x364).get(), (x361).get()); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x403, x404, (x402).get(), (x362).get(), (x359).get()); + int x405 = ((x404).get() + (x360).get()); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x406, x407, 0x0, (x331).get(), (x381).get()); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x408, x409, (x407).get(), (x333).get(), (x383).get()); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x410, x411, (x409).get(), (x335).get(), (x385).get()); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x412, x413, (x411).get(), (x337).get(), (x387).get()); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x414, x415, (x413).get(), (x339).get(), (x389).get()); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x416, x417, (x415).get(), (x341).get(), (x391).get()); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x418, x419, (x417).get(), (x343).get(), (x393).get()); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x420, x421, (x419).get(), (x345).get(), (x395).get()); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x422, x423, (x421).get(), (x347).get(), (x397).get()); + Box x424 = new Box((int)0); + Box x425 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x424, x425, (x423).get(), (x349).get(), (x399).get()); + Box x426 = new Box((int)0); + Box x427 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x426, x427, (x425).get(), (x351).get(), (x401).get()); + Box x428 = new Box((int)0); + Box x429 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x428, x429, (x427).get(), (x353).get(), (x403).get()); + Box x430 = new Box((int)0); + Box x431 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x430, x431, (x429).get(), (x355).get(), x405); + int x432 = ((x431).get() + (x356).get()); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x433, x434, x3, (arg1[11])); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x435, x436, x3, (arg1[10])); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x437, x438, x3, (arg1[9])); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x439, x440, x3, (arg1[8])); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x441, x442, x3, (arg1[7])); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x443, x444, x3, (arg1[6])); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x445, x446, x3, (arg1[5])); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x447, x448, x3, (arg1[4])); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x449, x450, x3, (arg1[3])); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x451, x452, x3, (arg1[2])); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x453, x454, x3, (arg1[1])); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x455, x456, x3, (arg1[0])); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x457, x458, 0x0, (x456).get(), (x453).get()); + Box x459 = new Box((int)0); + Box x460 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x459, x460, (x458).get(), (x454).get(), (x451).get()); + Box x461 = new Box((int)0); + Box x462 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x461, x462, (x460).get(), (x452).get(), (x449).get()); + Box x463 = new Box((int)0); + Box x464 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x463, x464, (x462).get(), (x450).get(), (x447).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x465, x466, (x464).get(), (x448).get(), (x445).get()); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x467, x468, (x466).get(), (x446).get(), (x443).get()); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x469, x470, (x468).get(), (x444).get(), (x441).get()); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x471, x472, (x470).get(), (x442).get(), (x439).get()); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x473, x474, (x472).get(), (x440).get(), (x437).get()); + Box x475 = new Box((int)0); + Box x476 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x475, x476, (x474).get(), (x438).get(), (x435).get()); + Box x477 = new Box((int)0); + Box x478 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x477, x478, (x476).get(), (x436).get(), (x433).get()); + int x479 = ((x478).get() + (x434).get()); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x480, x481, 0x0, (x408).get(), (x455).get()); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x482, x483, (x481).get(), (x410).get(), (x457).get()); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x484, x485, (x483).get(), (x412).get(), (x459).get()); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x486, x487, (x485).get(), (x414).get(), (x461).get()); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x488, x489, (x487).get(), (x416).get(), (x463).get()); + Box x490 = new Box((int)0); + Box x491 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x490, x491, (x489).get(), (x418).get(), (x465).get()); + Box x492 = new Box((int)0); + Box x493 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x492, x493, (x491).get(), (x420).get(), (x467).get()); + Box x494 = new Box((int)0); + Box x495 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x494, x495, (x493).get(), (x422).get(), (x469).get()); + Box x496 = new Box((int)0); + Box x497 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x496, x497, (x495).get(), (x424).get(), (x471).get()); + Box x498 = new Box((int)0); + Box x499 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x498, x499, (x497).get(), (x426).get(), (x473).get()); + Box x500 = new Box((int)0); + Box x501 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x500, x501, (x499).get(), (x428).get(), (x475).get()); + Box x502 = new Box((int)0); + Box x503 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x502, x503, (x501).get(), (x430).get(), (x477).get()); + Box x504 = new Box((int)0); + Box x505 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x504, x505, (x503).get(), x432, x479); + Box x506 = new Box((int)0); + Box x507 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x506, x507, (x480).get(), 0xe88fdc45); + Box x508 = new Box((int)0); + Box x509 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x508, x509, (x506).get(), 0xffffffff); + Box x510 = new Box((int)0); + Box x511 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x510, x511, (x506).get(), 0xffffffff); + Box x512 = new Box((int)0); + Box x513 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x512, x513, (x506).get(), 0xffffffff); + Box x514 = new Box((int)0); + Box x515 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x514, x515, (x506).get(), 0xffffffff); + Box x516 = new Box((int)0); + Box x517 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x516, x517, (x506).get(), 0xffffffff); + Box x518 = new Box((int)0); + Box x519 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x518, x519, (x506).get(), 0xffffffff); + Box x520 = new Box((int)0); + Box x521 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x520, x521, (x506).get(), 0xc7634d81); + Box x522 = new Box((int)0); + Box x523 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x522, x523, (x506).get(), 0xf4372ddf); + Box x524 = new Box((int)0); + Box x525 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x524, x525, (x506).get(), 0x581a0db2); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x526, x527, (x506).get(), 0x48b0a77a); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x528, x529, (x506).get(), 0xecec196a); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x530, x531, (x506).get(), 0xccc52973); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x532, x533, 0x0, (x531).get(), (x528).get()); + Box x534 = new Box((int)0); + Box x535 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x534, x535, (x533).get(), (x529).get(), (x526).get()); + Box x536 = new Box((int)0); + Box x537 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x536, x537, (x535).get(), (x527).get(), (x524).get()); + Box x538 = new Box((int)0); + Box x539 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x538, x539, (x537).get(), (x525).get(), (x522).get()); + Box x540 = new Box((int)0); + Box x541 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x540, x541, (x539).get(), (x523).get(), (x520).get()); + Box x542 = new Box((int)0); + Box x543 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x542, x543, (x541).get(), (x521).get(), (x518).get()); + Box x544 = new Box((int)0); + Box x545 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x544, x545, (x543).get(), (x519).get(), (x516).get()); + Box x546 = new Box((int)0); + Box x547 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x546, x547, (x545).get(), (x517).get(), (x514).get()); + Box x548 = new Box((int)0); + Box x549 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x548, x549, (x547).get(), (x515).get(), (x512).get()); + Box x550 = new Box((int)0); + Box x551 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x550, x551, (x549).get(), (x513).get(), (x510).get()); + Box x552 = new Box((int)0); + Box x553 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x552, x553, (x551).get(), (x511).get(), (x508).get()); + int x554 = ((x553).get() + (x509).get()); + Box x555 = new Box((int)0); + Box x556 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x555, x556, 0x0, (x480).get(), (x530).get()); + Box x557 = new Box((int)0); + Box x558 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x557, x558, (x556).get(), (x482).get(), (x532).get()); + Box x559 = new Box((int)0); + Box x560 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x559, x560, (x558).get(), (x484).get(), (x534).get()); + Box x561 = new Box((int)0); + Box x562 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x561, x562, (x560).get(), (x486).get(), (x536).get()); + Box x563 = new Box((int)0); + Box x564 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x563, x564, (x562).get(), (x488).get(), (x538).get()); + Box x565 = new Box((int)0); + Box x566 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x565, x566, (x564).get(), (x490).get(), (x540).get()); + Box x567 = new Box((int)0); + Box x568 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x567, x568, (x566).get(), (x492).get(), (x542).get()); + Box x569 = new Box((int)0); + Box x570 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x569, x570, (x568).get(), (x494).get(), (x544).get()); + Box x571 = new Box((int)0); + Box x572 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x571, x572, (x570).get(), (x496).get(), (x546).get()); + Box x573 = new Box((int)0); + Box x574 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x573, x574, (x572).get(), (x498).get(), (x548).get()); + Box x575 = new Box((int)0); + Box x576 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x575, x576, (x574).get(), (x500).get(), (x550).get()); + Box x577 = new Box((int)0); + Box x578 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x577, x578, (x576).get(), (x502).get(), (x552).get()); + Box x579 = new Box((int)0); + Box x580 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x579, x580, (x578).get(), (x504).get(), x554); + int x581 = ((x580).get() + (x505).get()); + Box x582 = new Box((int)0); + Box x583 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x582, x583, x4, (arg1[11])); + Box x584 = new Box((int)0); + Box x585 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x584, x585, x4, (arg1[10])); + Box x586 = new Box((int)0); + Box x587 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x586, x587, x4, (arg1[9])); + Box x588 = new Box((int)0); + Box x589 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x588, x589, x4, (arg1[8])); + Box x590 = new Box((int)0); + Box x591 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x590, x591, x4, (arg1[7])); + Box x592 = new Box((int)0); + Box x593 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x592, x593, x4, (arg1[6])); + Box x594 = new Box((int)0); + Box x595 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x594, x595, x4, (arg1[5])); + Box x596 = new Box((int)0); + Box x597 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x596, x597, x4, (arg1[4])); + Box x598 = new Box((int)0); + Box x599 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x598, x599, x4, (arg1[3])); + Box x600 = new Box((int)0); + Box x601 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x600, x601, x4, (arg1[2])); + Box x602 = new Box((int)0); + Box x603 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x602, x603, x4, (arg1[1])); + Box x604 = new Box((int)0); + Box x605 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x604, x605, x4, (arg1[0])); + Box x606 = new Box((int)0); + Box x607 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x606, x607, 0x0, (x605).get(), (x602).get()); + Box x608 = new Box((int)0); + Box x609 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x608, x609, (x607).get(), (x603).get(), (x600).get()); + Box x610 = new Box((int)0); + Box x611 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x610, x611, (x609).get(), (x601).get(), (x598).get()); + Box x612 = new Box((int)0); + Box x613 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x612, x613, (x611).get(), (x599).get(), (x596).get()); + Box x614 = new Box((int)0); + Box x615 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x614, x615, (x613).get(), (x597).get(), (x594).get()); + Box x616 = new Box((int)0); + Box x617 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x616, x617, (x615).get(), (x595).get(), (x592).get()); + Box x618 = new Box((int)0); + Box x619 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x618, x619, (x617).get(), (x593).get(), (x590).get()); + Box x620 = new Box((int)0); + Box x621 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x620, x621, (x619).get(), (x591).get(), (x588).get()); + Box x622 = new Box((int)0); + Box x623 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x622, x623, (x621).get(), (x589).get(), (x586).get()); + Box x624 = new Box((int)0); + Box x625 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x624, x625, (x623).get(), (x587).get(), (x584).get()); + Box x626 = new Box((int)0); + Box x627 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x626, x627, (x625).get(), (x585).get(), (x582).get()); + int x628 = ((x627).get() + (x583).get()); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x629, x630, 0x0, (x557).get(), (x604).get()); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x631, x632, (x630).get(), (x559).get(), (x606).get()); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x633, x634, (x632).get(), (x561).get(), (x608).get()); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x635, x636, (x634).get(), (x563).get(), (x610).get()); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x637, x638, (x636).get(), (x565).get(), (x612).get()); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x639, x640, (x638).get(), (x567).get(), (x614).get()); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x641, x642, (x640).get(), (x569).get(), (x616).get()); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x643, x644, (x642).get(), (x571).get(), (x618).get()); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x645, x646, (x644).get(), (x573).get(), (x620).get()); + Box x647 = new Box((int)0); + Box x648 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x647, x648, (x646).get(), (x575).get(), (x622).get()); + Box x649 = new Box((int)0); + Box x650 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x649, x650, (x648).get(), (x577).get(), (x624).get()); + Box x651 = new Box((int)0); + Box x652 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x651, x652, (x650).get(), (x579).get(), (x626).get()); + Box x653 = new Box((int)0); + Box x654 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x653, x654, (x652).get(), x581, x628); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x655, x656, (x629).get(), 0xe88fdc45); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x657, x658, (x655).get(), 0xffffffff); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x659, x660, (x655).get(), 0xffffffff); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x661, x662, (x655).get(), 0xffffffff); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x663, x664, (x655).get(), 0xffffffff); + Box x665 = new Box((int)0); + Box x666 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x665, x666, (x655).get(), 0xffffffff); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x667, x668, (x655).get(), 0xffffffff); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x669, x670, (x655).get(), 0xc7634d81); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x671, x672, (x655).get(), 0xf4372ddf); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x673, x674, (x655).get(), 0x581a0db2); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x675, x676, (x655).get(), 0x48b0a77a); + Box x677 = new Box((int)0); + Box x678 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x677, x678, (x655).get(), 0xecec196a); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x679, x680, (x655).get(), 0xccc52973); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x681, x682, 0x0, (x680).get(), (x677).get()); + Box x683 = new Box((int)0); + Box x684 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x683, x684, (x682).get(), (x678).get(), (x675).get()); + Box x685 = new Box((int)0); + Box x686 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x685, x686, (x684).get(), (x676).get(), (x673).get()); + Box x687 = new Box((int)0); + Box x688 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x687, x688, (x686).get(), (x674).get(), (x671).get()); + Box x689 = new Box((int)0); + Box x690 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x689, x690, (x688).get(), (x672).get(), (x669).get()); + Box x691 = new Box((int)0); + Box x692 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x691, x692, (x690).get(), (x670).get(), (x667).get()); + Box x693 = new Box((int)0); + Box x694 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x693, x694, (x692).get(), (x668).get(), (x665).get()); + Box x695 = new Box((int)0); + Box x696 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x695, x696, (x694).get(), (x666).get(), (x663).get()); + Box x697 = new Box((int)0); + Box x698 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x697, x698, (x696).get(), (x664).get(), (x661).get()); + Box x699 = new Box((int)0); + Box x700 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x699, x700, (x698).get(), (x662).get(), (x659).get()); + Box x701 = new Box((int)0); + Box x702 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x701, x702, (x700).get(), (x660).get(), (x657).get()); + int x703 = ((x702).get() + (x658).get()); + Box x704 = new Box((int)0); + Box x705 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x704, x705, 0x0, (x629).get(), (x679).get()); + Box x706 = new Box((int)0); + Box x707 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x706, x707, (x705).get(), (x631).get(), (x681).get()); + Box x708 = new Box((int)0); + Box x709 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x708, x709, (x707).get(), (x633).get(), (x683).get()); + Box x710 = new Box((int)0); + Box x711 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x710, x711, (x709).get(), (x635).get(), (x685).get()); + Box x712 = new Box((int)0); + Box x713 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x712, x713, (x711).get(), (x637).get(), (x687).get()); + Box x714 = new Box((int)0); + Box x715 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x714, x715, (x713).get(), (x639).get(), (x689).get()); + Box x716 = new Box((int)0); + Box x717 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x716, x717, (x715).get(), (x641).get(), (x691).get()); + Box x718 = new Box((int)0); + Box x719 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x718, x719, (x717).get(), (x643).get(), (x693).get()); + Box x720 = new Box((int)0); + Box x721 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x720, x721, (x719).get(), (x645).get(), (x695).get()); + Box x722 = new Box((int)0); + Box x723 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x722, x723, (x721).get(), (x647).get(), (x697).get()); + Box x724 = new Box((int)0); + Box x725 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x724, x725, (x723).get(), (x649).get(), (x699).get()); + Box x726 = new Box((int)0); + Box x727 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x726, x727, (x725).get(), (x651).get(), (x701).get()); + Box x728 = new Box((int)0); + Box x729 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x728, x729, (x727).get(), (x653).get(), x703); + int x730 = ((x729).get() + (x654).get()); + Box x731 = new Box((int)0); + Box x732 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x731, x732, x5, (arg1[11])); + Box x733 = new Box((int)0); + Box x734 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x733, x734, x5, (arg1[10])); + Box x735 = new Box((int)0); + Box x736 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x735, x736, x5, (arg1[9])); + Box x737 = new Box((int)0); + Box x738 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x737, x738, x5, (arg1[8])); + Box x739 = new Box((int)0); + Box x740 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x739, x740, x5, (arg1[7])); + Box x741 = new Box((int)0); + Box x742 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x741, x742, x5, (arg1[6])); + Box x743 = new Box((int)0); + Box x744 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x743, x744, x5, (arg1[5])); + Box x745 = new Box((int)0); + Box x746 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x745, x746, x5, (arg1[4])); + Box x747 = new Box((int)0); + Box x748 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x747, x748, x5, (arg1[3])); + Box x749 = new Box((int)0); + Box x750 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x749, x750, x5, (arg1[2])); + Box x751 = new Box((int)0); + Box x752 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x751, x752, x5, (arg1[1])); + Box x753 = new Box((int)0); + Box x754 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x753, x754, x5, (arg1[0])); + Box x755 = new Box((int)0); + Box x756 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x755, x756, 0x0, (x754).get(), (x751).get()); + Box x757 = new Box((int)0); + Box x758 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x757, x758, (x756).get(), (x752).get(), (x749).get()); + Box x759 = new Box((int)0); + Box x760 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x759, x760, (x758).get(), (x750).get(), (x747).get()); + Box x761 = new Box((int)0); + Box x762 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x761, x762, (x760).get(), (x748).get(), (x745).get()); + Box x763 = new Box((int)0); + Box x764 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x763, x764, (x762).get(), (x746).get(), (x743).get()); + Box x765 = new Box((int)0); + Box x766 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x765, x766, (x764).get(), (x744).get(), (x741).get()); + Box x767 = new Box((int)0); + Box x768 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x767, x768, (x766).get(), (x742).get(), (x739).get()); + Box x769 = new Box((int)0); + Box x770 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x769, x770, (x768).get(), (x740).get(), (x737).get()); + Box x771 = new Box((int)0); + Box x772 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x771, x772, (x770).get(), (x738).get(), (x735).get()); + Box x773 = new Box((int)0); + Box x774 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x773, x774, (x772).get(), (x736).get(), (x733).get()); + Box x775 = new Box((int)0); + Box x776 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x775, x776, (x774).get(), (x734).get(), (x731).get()); + int x777 = ((x776).get() + (x732).get()); + Box x778 = new Box((int)0); + Box x779 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x778, x779, 0x0, (x706).get(), (x753).get()); + Box x780 = new Box((int)0); + Box x781 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x780, x781, (x779).get(), (x708).get(), (x755).get()); + Box x782 = new Box((int)0); + Box x783 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x782, x783, (x781).get(), (x710).get(), (x757).get()); + Box x784 = new Box((int)0); + Box x785 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x784, x785, (x783).get(), (x712).get(), (x759).get()); + Box x786 = new Box((int)0); + Box x787 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x786, x787, (x785).get(), (x714).get(), (x761).get()); + Box x788 = new Box((int)0); + Box x789 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x788, x789, (x787).get(), (x716).get(), (x763).get()); + Box x790 = new Box((int)0); + Box x791 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x790, x791, (x789).get(), (x718).get(), (x765).get()); + Box x792 = new Box((int)0); + Box x793 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x792, x793, (x791).get(), (x720).get(), (x767).get()); + Box x794 = new Box((int)0); + Box x795 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x794, x795, (x793).get(), (x722).get(), (x769).get()); + Box x796 = new Box((int)0); + Box x797 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x796, x797, (x795).get(), (x724).get(), (x771).get()); + Box x798 = new Box((int)0); + Box x799 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x798, x799, (x797).get(), (x726).get(), (x773).get()); + Box x800 = new Box((int)0); + Box x801 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x800, x801, (x799).get(), (x728).get(), (x775).get()); + Box x802 = new Box((int)0); + Box x803 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x802, x803, (x801).get(), x730, x777); + Box x804 = new Box((int)0); + Box x805 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x804, x805, (x778).get(), 0xe88fdc45); + Box x806 = new Box((int)0); + Box x807 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x806, x807, (x804).get(), 0xffffffff); + Box x808 = new Box((int)0); + Box x809 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x808, x809, (x804).get(), 0xffffffff); + Box x810 = new Box((int)0); + Box x811 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x810, x811, (x804).get(), 0xffffffff); + Box x812 = new Box((int)0); + Box x813 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x812, x813, (x804).get(), 0xffffffff); + Box x814 = new Box((int)0); + Box x815 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x814, x815, (x804).get(), 0xffffffff); + Box x816 = new Box((int)0); + Box x817 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x816, x817, (x804).get(), 0xffffffff); + Box x818 = new Box((int)0); + Box x819 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x818, x819, (x804).get(), 0xc7634d81); + Box x820 = new Box((int)0); + Box x821 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x820, x821, (x804).get(), 0xf4372ddf); + Box x822 = new Box((int)0); + Box x823 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x822, x823, (x804).get(), 0x581a0db2); + Box x824 = new Box((int)0); + Box x825 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x824, x825, (x804).get(), 0x48b0a77a); + Box x826 = new Box((int)0); + Box x827 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x826, x827, (x804).get(), 0xecec196a); + Box x828 = new Box((int)0); + Box x829 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x828, x829, (x804).get(), 0xccc52973); + Box x830 = new Box((int)0); + Box x831 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x830, x831, 0x0, (x829).get(), (x826).get()); + Box x832 = new Box((int)0); + Box x833 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x832, x833, (x831).get(), (x827).get(), (x824).get()); + Box x834 = new Box((int)0); + Box x835 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x834, x835, (x833).get(), (x825).get(), (x822).get()); + Box x836 = new Box((int)0); + Box x837 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x836, x837, (x835).get(), (x823).get(), (x820).get()); + Box x838 = new Box((int)0); + Box x839 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x838, x839, (x837).get(), (x821).get(), (x818).get()); + Box x840 = new Box((int)0); + Box x841 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x840, x841, (x839).get(), (x819).get(), (x816).get()); + Box x842 = new Box((int)0); + Box x843 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x842, x843, (x841).get(), (x817).get(), (x814).get()); + Box x844 = new Box((int)0); + Box x845 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x844, x845, (x843).get(), (x815).get(), (x812).get()); + Box x846 = new Box((int)0); + Box x847 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x846, x847, (x845).get(), (x813).get(), (x810).get()); + Box x848 = new Box((int)0); + Box x849 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x848, x849, (x847).get(), (x811).get(), (x808).get()); + Box x850 = new Box((int)0); + Box x851 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x850, x851, (x849).get(), (x809).get(), (x806).get()); + int x852 = ((x851).get() + (x807).get()); + Box x853 = new Box((int)0); + Box x854 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x853, x854, 0x0, (x778).get(), (x828).get()); + Box x855 = new Box((int)0); + Box x856 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x855, x856, (x854).get(), (x780).get(), (x830).get()); + Box x857 = new Box((int)0); + Box x858 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x857, x858, (x856).get(), (x782).get(), (x832).get()); + Box x859 = new Box((int)0); + Box x860 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x859, x860, (x858).get(), (x784).get(), (x834).get()); + Box x861 = new Box((int)0); + Box x862 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x861, x862, (x860).get(), (x786).get(), (x836).get()); + Box x863 = new Box((int)0); + Box x864 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x863, x864, (x862).get(), (x788).get(), (x838).get()); + Box x865 = new Box((int)0); + Box x866 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x865, x866, (x864).get(), (x790).get(), (x840).get()); + Box x867 = new Box((int)0); + Box x868 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x867, x868, (x866).get(), (x792).get(), (x842).get()); + Box x869 = new Box((int)0); + Box x870 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x869, x870, (x868).get(), (x794).get(), (x844).get()); + Box x871 = new Box((int)0); + Box x872 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x871, x872, (x870).get(), (x796).get(), (x846).get()); + Box x873 = new Box((int)0); + Box x874 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x873, x874, (x872).get(), (x798).get(), (x848).get()); + Box x875 = new Box((int)0); + Box x876 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x875, x876, (x874).get(), (x800).get(), (x850).get()); + Box x877 = new Box((int)0); + Box x878 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x877, x878, (x876).get(), (x802).get(), x852); + int x879 = ((x878).get() + (x803).get()); + Box x880 = new Box((int)0); + Box x881 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x880, x881, x6, (arg1[11])); + Box x882 = new Box((int)0); + Box x883 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x882, x883, x6, (arg1[10])); + Box x884 = new Box((int)0); + Box x885 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x884, x885, x6, (arg1[9])); + Box x886 = new Box((int)0); + Box x887 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x886, x887, x6, (arg1[8])); + Box x888 = new Box((int)0); + Box x889 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x888, x889, x6, (arg1[7])); + Box x890 = new Box((int)0); + Box x891 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x890, x891, x6, (arg1[6])); + Box x892 = new Box((int)0); + Box x893 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x892, x893, x6, (arg1[5])); + Box x894 = new Box((int)0); + Box x895 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x894, x895, x6, (arg1[4])); + Box x896 = new Box((int)0); + Box x897 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x896, x897, x6, (arg1[3])); + Box x898 = new Box((int)0); + Box x899 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x898, x899, x6, (arg1[2])); + Box x900 = new Box((int)0); + Box x901 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x900, x901, x6, (arg1[1])); + Box x902 = new Box((int)0); + Box x903 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x902, x903, x6, (arg1[0])); + Box x904 = new Box((int)0); + Box x905 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x904, x905, 0x0, (x903).get(), (x900).get()); + Box x906 = new Box((int)0); + Box x907 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x906, x907, (x905).get(), (x901).get(), (x898).get()); + Box x908 = new Box((int)0); + Box x909 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x908, x909, (x907).get(), (x899).get(), (x896).get()); + Box x910 = new Box((int)0); + Box x911 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x910, x911, (x909).get(), (x897).get(), (x894).get()); + Box x912 = new Box((int)0); + Box x913 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x912, x913, (x911).get(), (x895).get(), (x892).get()); + Box x914 = new Box((int)0); + Box x915 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x914, x915, (x913).get(), (x893).get(), (x890).get()); + Box x916 = new Box((int)0); + Box x917 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x916, x917, (x915).get(), (x891).get(), (x888).get()); + Box x918 = new Box((int)0); + Box x919 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x918, x919, (x917).get(), (x889).get(), (x886).get()); + Box x920 = new Box((int)0); + Box x921 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x920, x921, (x919).get(), (x887).get(), (x884).get()); + Box x922 = new Box((int)0); + Box x923 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x922, x923, (x921).get(), (x885).get(), (x882).get()); + Box x924 = new Box((int)0); + Box x925 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x924, x925, (x923).get(), (x883).get(), (x880).get()); + int x926 = ((x925).get() + (x881).get()); + Box x927 = new Box((int)0); + Box x928 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x927, x928, 0x0, (x855).get(), (x902).get()); + Box x929 = new Box((int)0); + Box x930 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x929, x930, (x928).get(), (x857).get(), (x904).get()); + Box x931 = new Box((int)0); + Box x932 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x931, x932, (x930).get(), (x859).get(), (x906).get()); + Box x933 = new Box((int)0); + Box x934 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x933, x934, (x932).get(), (x861).get(), (x908).get()); + Box x935 = new Box((int)0); + Box x936 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x935, x936, (x934).get(), (x863).get(), (x910).get()); + Box x937 = new Box((int)0); + Box x938 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x937, x938, (x936).get(), (x865).get(), (x912).get()); + Box x939 = new Box((int)0); + Box x940 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x939, x940, (x938).get(), (x867).get(), (x914).get()); + Box x941 = new Box((int)0); + Box x942 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x941, x942, (x940).get(), (x869).get(), (x916).get()); + Box x943 = new Box((int)0); + Box x944 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x943, x944, (x942).get(), (x871).get(), (x918).get()); + Box x945 = new Box((int)0); + Box x946 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x945, x946, (x944).get(), (x873).get(), (x920).get()); + Box x947 = new Box((int)0); + Box x948 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x947, x948, (x946).get(), (x875).get(), (x922).get()); + Box x949 = new Box((int)0); + Box x950 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x949, x950, (x948).get(), (x877).get(), (x924).get()); + Box x951 = new Box((int)0); + Box x952 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x951, x952, (x950).get(), x879, x926); + Box x953 = new Box((int)0); + Box x954 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x953, x954, (x927).get(), 0xe88fdc45); + Box x955 = new Box((int)0); + Box x956 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x955, x956, (x953).get(), 0xffffffff); + Box x957 = new Box((int)0); + Box x958 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x957, x958, (x953).get(), 0xffffffff); + Box x959 = new Box((int)0); + Box x960 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x959, x960, (x953).get(), 0xffffffff); + Box x961 = new Box((int)0); + Box x962 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x961, x962, (x953).get(), 0xffffffff); + Box x963 = new Box((int)0); + Box x964 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x963, x964, (x953).get(), 0xffffffff); + Box x965 = new Box((int)0); + Box x966 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x965, x966, (x953).get(), 0xffffffff); + Box x967 = new Box((int)0); + Box x968 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x967, x968, (x953).get(), 0xc7634d81); + Box x969 = new Box((int)0); + Box x970 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x969, x970, (x953).get(), 0xf4372ddf); + Box x971 = new Box((int)0); + Box x972 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x971, x972, (x953).get(), 0x581a0db2); + Box x973 = new Box((int)0); + Box x974 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x973, x974, (x953).get(), 0x48b0a77a); + Box x975 = new Box((int)0); + Box x976 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x975, x976, (x953).get(), 0xecec196a); + Box x977 = new Box((int)0); + Box x978 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x977, x978, (x953).get(), 0xccc52973); + Box x979 = new Box((int)0); + Box x980 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x979, x980, 0x0, (x978).get(), (x975).get()); + Box x981 = new Box((int)0); + Box x982 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x981, x982, (x980).get(), (x976).get(), (x973).get()); + Box x983 = new Box((int)0); + Box x984 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x983, x984, (x982).get(), (x974).get(), (x971).get()); + Box x985 = new Box((int)0); + Box x986 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x985, x986, (x984).get(), (x972).get(), (x969).get()); + Box x987 = new Box((int)0); + Box x988 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x987, x988, (x986).get(), (x970).get(), (x967).get()); + Box x989 = new Box((int)0); + Box x990 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x989, x990, (x988).get(), (x968).get(), (x965).get()); + Box x991 = new Box((int)0); + Box x992 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x991, x992, (x990).get(), (x966).get(), (x963).get()); + Box x993 = new Box((int)0); + Box x994 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x993, x994, (x992).get(), (x964).get(), (x961).get()); + Box x995 = new Box((int)0); + Box x996 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x995, x996, (x994).get(), (x962).get(), (x959).get()); + Box x997 = new Box((int)0); + Box x998 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x997, x998, (x996).get(), (x960).get(), (x957).get()); + Box x999 = new Box((int)0); + Box x1000 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x999, x1000, (x998).get(), (x958).get(), (x955).get()); + int x1001 = ((x1000).get() + (x956).get()); + Box x1002 = new Box((int)0); + Box x1003 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1002, x1003, 0x0, (x927).get(), (x977).get()); + Box x1004 = new Box((int)0); + Box x1005 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1004, x1005, (x1003).get(), (x929).get(), (x979).get()); + Box x1006 = new Box((int)0); + Box x1007 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1006, x1007, (x1005).get(), (x931).get(), (x981).get()); + Box x1008 = new Box((int)0); + Box x1009 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1008, x1009, (x1007).get(), (x933).get(), (x983).get()); + Box x1010 = new Box((int)0); + Box x1011 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1010, x1011, (x1009).get(), (x935).get(), (x985).get()); + Box x1012 = new Box((int)0); + Box x1013 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1012, x1013, (x1011).get(), (x937).get(), (x987).get()); + Box x1014 = new Box((int)0); + Box x1015 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1014, x1015, (x1013).get(), (x939).get(), (x989).get()); + Box x1016 = new Box((int)0); + Box x1017 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1016, x1017, (x1015).get(), (x941).get(), (x991).get()); + Box x1018 = new Box((int)0); + Box x1019 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1018, x1019, (x1017).get(), (x943).get(), (x993).get()); + Box x1020 = new Box((int)0); + Box x1021 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1020, x1021, (x1019).get(), (x945).get(), (x995).get()); + Box x1022 = new Box((int)0); + Box x1023 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1022, x1023, (x1021).get(), (x947).get(), (x997).get()); + Box x1024 = new Box((int)0); + Box x1025 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1024, x1025, (x1023).get(), (x949).get(), (x999).get()); + Box x1026 = new Box((int)0); + Box x1027 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1026, x1027, (x1025).get(), (x951).get(), x1001); + int x1028 = ((x1027).get() + (x952).get()); + Box x1029 = new Box((int)0); + Box x1030 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1029, x1030, x7, (arg1[11])); + Box x1031 = new Box((int)0); + Box x1032 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1031, x1032, x7, (arg1[10])); + Box x1033 = new Box((int)0); + Box x1034 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1033, x1034, x7, (arg1[9])); + Box x1035 = new Box((int)0); + Box x1036 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1035, x1036, x7, (arg1[8])); + Box x1037 = new Box((int)0); + Box x1038 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1037, x1038, x7, (arg1[7])); + Box x1039 = new Box((int)0); + Box x1040 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1039, x1040, x7, (arg1[6])); + Box x1041 = new Box((int)0); + Box x1042 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1041, x1042, x7, (arg1[5])); + Box x1043 = new Box((int)0); + Box x1044 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1043, x1044, x7, (arg1[4])); + Box x1045 = new Box((int)0); + Box x1046 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1045, x1046, x7, (arg1[3])); + Box x1047 = new Box((int)0); + Box x1048 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1047, x1048, x7, (arg1[2])); + Box x1049 = new Box((int)0); + Box x1050 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1049, x1050, x7, (arg1[1])); + Box x1051 = new Box((int)0); + Box x1052 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1051, x1052, x7, (arg1[0])); + Box x1053 = new Box((int)0); + Box x1054 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1053, x1054, 0x0, (x1052).get(), (x1049).get()); + Box x1055 = new Box((int)0); + Box x1056 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1055, x1056, (x1054).get(), (x1050).get(), (x1047).get()); + Box x1057 = new Box((int)0); + Box x1058 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1057, x1058, (x1056).get(), (x1048).get(), (x1045).get()); + Box x1059 = new Box((int)0); + Box x1060 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1059, x1060, (x1058).get(), (x1046).get(), (x1043).get()); + Box x1061 = new Box((int)0); + Box x1062 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1061, x1062, (x1060).get(), (x1044).get(), (x1041).get()); + Box x1063 = new Box((int)0); + Box x1064 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1063, x1064, (x1062).get(), (x1042).get(), (x1039).get()); + Box x1065 = new Box((int)0); + Box x1066 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1065, x1066, (x1064).get(), (x1040).get(), (x1037).get()); + Box x1067 = new Box((int)0); + Box x1068 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1067, x1068, (x1066).get(), (x1038).get(), (x1035).get()); + Box x1069 = new Box((int)0); + Box x1070 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1069, x1070, (x1068).get(), (x1036).get(), (x1033).get()); + Box x1071 = new Box((int)0); + Box x1072 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1071, x1072, (x1070).get(), (x1034).get(), (x1031).get()); + Box x1073 = new Box((int)0); + Box x1074 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1073, x1074, (x1072).get(), (x1032).get(), (x1029).get()); + int x1075 = ((x1074).get() + (x1030).get()); + Box x1076 = new Box((int)0); + Box x1077 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1076, x1077, 0x0, (x1004).get(), (x1051).get()); + Box x1078 = new Box((int)0); + Box x1079 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1078, x1079, (x1077).get(), (x1006).get(), (x1053).get()); + Box x1080 = new Box((int)0); + Box x1081 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1080, x1081, (x1079).get(), (x1008).get(), (x1055).get()); + Box x1082 = new Box((int)0); + Box x1083 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1082, x1083, (x1081).get(), (x1010).get(), (x1057).get()); + Box x1084 = new Box((int)0); + Box x1085 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1084, x1085, (x1083).get(), (x1012).get(), (x1059).get()); + Box x1086 = new Box((int)0); + Box x1087 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1086, x1087, (x1085).get(), (x1014).get(), (x1061).get()); + Box x1088 = new Box((int)0); + Box x1089 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1088, x1089, (x1087).get(), (x1016).get(), (x1063).get()); + Box x1090 = new Box((int)0); + Box x1091 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1090, x1091, (x1089).get(), (x1018).get(), (x1065).get()); + Box x1092 = new Box((int)0); + Box x1093 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1092, x1093, (x1091).get(), (x1020).get(), (x1067).get()); + Box x1094 = new Box((int)0); + Box x1095 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1094, x1095, (x1093).get(), (x1022).get(), (x1069).get()); + Box x1096 = new Box((int)0); + Box x1097 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1096, x1097, (x1095).get(), (x1024).get(), (x1071).get()); + Box x1098 = new Box((int)0); + Box x1099 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1098, x1099, (x1097).get(), (x1026).get(), (x1073).get()); + Box x1100 = new Box((int)0); + Box x1101 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1100, x1101, (x1099).get(), x1028, x1075); + Box x1102 = new Box((int)0); + Box x1103 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1102, x1103, (x1076).get(), 0xe88fdc45); + Box x1104 = new Box((int)0); + Box x1105 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1104, x1105, (x1102).get(), 0xffffffff); + Box x1106 = new Box((int)0); + Box x1107 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1106, x1107, (x1102).get(), 0xffffffff); + Box x1108 = new Box((int)0); + Box x1109 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1108, x1109, (x1102).get(), 0xffffffff); + Box x1110 = new Box((int)0); + Box x1111 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1110, x1111, (x1102).get(), 0xffffffff); + Box x1112 = new Box((int)0); + Box x1113 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1112, x1113, (x1102).get(), 0xffffffff); + Box x1114 = new Box((int)0); + Box x1115 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1114, x1115, (x1102).get(), 0xffffffff); + Box x1116 = new Box((int)0); + Box x1117 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1116, x1117, (x1102).get(), 0xc7634d81); + Box x1118 = new Box((int)0); + Box x1119 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1118, x1119, (x1102).get(), 0xf4372ddf); + Box x1120 = new Box((int)0); + Box x1121 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1120, x1121, (x1102).get(), 0x581a0db2); + Box x1122 = new Box((int)0); + Box x1123 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1122, x1123, (x1102).get(), 0x48b0a77a); + Box x1124 = new Box((int)0); + Box x1125 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1124, x1125, (x1102).get(), 0xecec196a); + Box x1126 = new Box((int)0); + Box x1127 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1126, x1127, (x1102).get(), 0xccc52973); + Box x1128 = new Box((int)0); + Box x1129 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1128, x1129, 0x0, (x1127).get(), (x1124).get()); + Box x1130 = new Box((int)0); + Box x1131 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1130, x1131, (x1129).get(), (x1125).get(), (x1122).get()); + Box x1132 = new Box((int)0); + Box x1133 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1132, x1133, (x1131).get(), (x1123).get(), (x1120).get()); + Box x1134 = new Box((int)0); + Box x1135 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1134, x1135, (x1133).get(), (x1121).get(), (x1118).get()); + Box x1136 = new Box((int)0); + Box x1137 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1136, x1137, (x1135).get(), (x1119).get(), (x1116).get()); + Box x1138 = new Box((int)0); + Box x1139 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1138, x1139, (x1137).get(), (x1117).get(), (x1114).get()); + Box x1140 = new Box((int)0); + Box x1141 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1140, x1141, (x1139).get(), (x1115).get(), (x1112).get()); + Box x1142 = new Box((int)0); + Box x1143 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1142, x1143, (x1141).get(), (x1113).get(), (x1110).get()); + Box x1144 = new Box((int)0); + Box x1145 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1144, x1145, (x1143).get(), (x1111).get(), (x1108).get()); + Box x1146 = new Box((int)0); + Box x1147 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1146, x1147, (x1145).get(), (x1109).get(), (x1106).get()); + Box x1148 = new Box((int)0); + Box x1149 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1148, x1149, (x1147).get(), (x1107).get(), (x1104).get()); + int x1150 = ((x1149).get() + (x1105).get()); + Box x1151 = new Box((int)0); + Box x1152 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1151, x1152, 0x0, (x1076).get(), (x1126).get()); + Box x1153 = new Box((int)0); + Box x1154 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1153, x1154, (x1152).get(), (x1078).get(), (x1128).get()); + Box x1155 = new Box((int)0); + Box x1156 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1155, x1156, (x1154).get(), (x1080).get(), (x1130).get()); + Box x1157 = new Box((int)0); + Box x1158 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1157, x1158, (x1156).get(), (x1082).get(), (x1132).get()); + Box x1159 = new Box((int)0); + Box x1160 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1159, x1160, (x1158).get(), (x1084).get(), (x1134).get()); + Box x1161 = new Box((int)0); + Box x1162 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1161, x1162, (x1160).get(), (x1086).get(), (x1136).get()); + Box x1163 = new Box((int)0); + Box x1164 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1163, x1164, (x1162).get(), (x1088).get(), (x1138).get()); + Box x1165 = new Box((int)0); + Box x1166 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1165, x1166, (x1164).get(), (x1090).get(), (x1140).get()); + Box x1167 = new Box((int)0); + Box x1168 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1167, x1168, (x1166).get(), (x1092).get(), (x1142).get()); + Box x1169 = new Box((int)0); + Box x1170 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1169, x1170, (x1168).get(), (x1094).get(), (x1144).get()); + Box x1171 = new Box((int)0); + Box x1172 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1171, x1172, (x1170).get(), (x1096).get(), (x1146).get()); + Box x1173 = new Box((int)0); + Box x1174 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1173, x1174, (x1172).get(), (x1098).get(), (x1148).get()); + Box x1175 = new Box((int)0); + Box x1176 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1175, x1176, (x1174).get(), (x1100).get(), x1150); + int x1177 = ((x1176).get() + (x1101).get()); + Box x1178 = new Box((int)0); + Box x1179 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1178, x1179, x8, (arg1[11])); + Box x1180 = new Box((int)0); + Box x1181 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1180, x1181, x8, (arg1[10])); + Box x1182 = new Box((int)0); + Box x1183 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1182, x1183, x8, (arg1[9])); + Box x1184 = new Box((int)0); + Box x1185 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1184, x1185, x8, (arg1[8])); + Box x1186 = new Box((int)0); + Box x1187 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1186, x1187, x8, (arg1[7])); + Box x1188 = new Box((int)0); + Box x1189 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1188, x1189, x8, (arg1[6])); + Box x1190 = new Box((int)0); + Box x1191 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1190, x1191, x8, (arg1[5])); + Box x1192 = new Box((int)0); + Box x1193 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1192, x1193, x8, (arg1[4])); + Box x1194 = new Box((int)0); + Box x1195 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1194, x1195, x8, (arg1[3])); + Box x1196 = new Box((int)0); + Box x1197 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1196, x1197, x8, (arg1[2])); + Box x1198 = new Box((int)0); + Box x1199 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1198, x1199, x8, (arg1[1])); + Box x1200 = new Box((int)0); + Box x1201 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1200, x1201, x8, (arg1[0])); + Box x1202 = new Box((int)0); + Box x1203 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1202, x1203, 0x0, (x1201).get(), (x1198).get()); + Box x1204 = new Box((int)0); + Box x1205 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1204, x1205, (x1203).get(), (x1199).get(), (x1196).get()); + Box x1206 = new Box((int)0); + Box x1207 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1206, x1207, (x1205).get(), (x1197).get(), (x1194).get()); + Box x1208 = new Box((int)0); + Box x1209 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1208, x1209, (x1207).get(), (x1195).get(), (x1192).get()); + Box x1210 = new Box((int)0); + Box x1211 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1210, x1211, (x1209).get(), (x1193).get(), (x1190).get()); + Box x1212 = new Box((int)0); + Box x1213 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1212, x1213, (x1211).get(), (x1191).get(), (x1188).get()); + Box x1214 = new Box((int)0); + Box x1215 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1214, x1215, (x1213).get(), (x1189).get(), (x1186).get()); + Box x1216 = new Box((int)0); + Box x1217 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1216, x1217, (x1215).get(), (x1187).get(), (x1184).get()); + Box x1218 = new Box((int)0); + Box x1219 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1218, x1219, (x1217).get(), (x1185).get(), (x1182).get()); + Box x1220 = new Box((int)0); + Box x1221 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1220, x1221, (x1219).get(), (x1183).get(), (x1180).get()); + Box x1222 = new Box((int)0); + Box x1223 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1222, x1223, (x1221).get(), (x1181).get(), (x1178).get()); + int x1224 = ((x1223).get() + (x1179).get()); + Box x1225 = new Box((int)0); + Box x1226 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1225, x1226, 0x0, (x1153).get(), (x1200).get()); + Box x1227 = new Box((int)0); + Box x1228 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1227, x1228, (x1226).get(), (x1155).get(), (x1202).get()); + Box x1229 = new Box((int)0); + Box x1230 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1229, x1230, (x1228).get(), (x1157).get(), (x1204).get()); + Box x1231 = new Box((int)0); + Box x1232 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1231, x1232, (x1230).get(), (x1159).get(), (x1206).get()); + Box x1233 = new Box((int)0); + Box x1234 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1233, x1234, (x1232).get(), (x1161).get(), (x1208).get()); + Box x1235 = new Box((int)0); + Box x1236 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1235, x1236, (x1234).get(), (x1163).get(), (x1210).get()); + Box x1237 = new Box((int)0); + Box x1238 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1237, x1238, (x1236).get(), (x1165).get(), (x1212).get()); + Box x1239 = new Box((int)0); + Box x1240 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1239, x1240, (x1238).get(), (x1167).get(), (x1214).get()); + Box x1241 = new Box((int)0); + Box x1242 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1241, x1242, (x1240).get(), (x1169).get(), (x1216).get()); + Box x1243 = new Box((int)0); + Box x1244 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1243, x1244, (x1242).get(), (x1171).get(), (x1218).get()); + Box x1245 = new Box((int)0); + Box x1246 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1245, x1246, (x1244).get(), (x1173).get(), (x1220).get()); + Box x1247 = new Box((int)0); + Box x1248 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1247, x1248, (x1246).get(), (x1175).get(), (x1222).get()); + Box x1249 = new Box((int)0); + Box x1250 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1249, x1250, (x1248).get(), x1177, x1224); + Box x1251 = new Box((int)0); + Box x1252 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1251, x1252, (x1225).get(), 0xe88fdc45); + Box x1253 = new Box((int)0); + Box x1254 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1253, x1254, (x1251).get(), 0xffffffff); + Box x1255 = new Box((int)0); + Box x1256 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1255, x1256, (x1251).get(), 0xffffffff); + Box x1257 = new Box((int)0); + Box x1258 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1257, x1258, (x1251).get(), 0xffffffff); + Box x1259 = new Box((int)0); + Box x1260 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1259, x1260, (x1251).get(), 0xffffffff); + Box x1261 = new Box((int)0); + Box x1262 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1261, x1262, (x1251).get(), 0xffffffff); + Box x1263 = new Box((int)0); + Box x1264 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1263, x1264, (x1251).get(), 0xffffffff); + Box x1265 = new Box((int)0); + Box x1266 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1265, x1266, (x1251).get(), 0xc7634d81); + Box x1267 = new Box((int)0); + Box x1268 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1267, x1268, (x1251).get(), 0xf4372ddf); + Box x1269 = new Box((int)0); + Box x1270 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1269, x1270, (x1251).get(), 0x581a0db2); + Box x1271 = new Box((int)0); + Box x1272 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1271, x1272, (x1251).get(), 0x48b0a77a); + Box x1273 = new Box((int)0); + Box x1274 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1273, x1274, (x1251).get(), 0xecec196a); + Box x1275 = new Box((int)0); + Box x1276 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1275, x1276, (x1251).get(), 0xccc52973); + Box x1277 = new Box((int)0); + Box x1278 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1277, x1278, 0x0, (x1276).get(), (x1273).get()); + Box x1279 = new Box((int)0); + Box x1280 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1279, x1280, (x1278).get(), (x1274).get(), (x1271).get()); + Box x1281 = new Box((int)0); + Box x1282 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1281, x1282, (x1280).get(), (x1272).get(), (x1269).get()); + Box x1283 = new Box((int)0); + Box x1284 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1283, x1284, (x1282).get(), (x1270).get(), (x1267).get()); + Box x1285 = new Box((int)0); + Box x1286 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1285, x1286, (x1284).get(), (x1268).get(), (x1265).get()); + Box x1287 = new Box((int)0); + Box x1288 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1287, x1288, (x1286).get(), (x1266).get(), (x1263).get()); + Box x1289 = new Box((int)0); + Box x1290 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1289, x1290, (x1288).get(), (x1264).get(), (x1261).get()); + Box x1291 = new Box((int)0); + Box x1292 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1291, x1292, (x1290).get(), (x1262).get(), (x1259).get()); + Box x1293 = new Box((int)0); + Box x1294 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1293, x1294, (x1292).get(), (x1260).get(), (x1257).get()); + Box x1295 = new Box((int)0); + Box x1296 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1295, x1296, (x1294).get(), (x1258).get(), (x1255).get()); + Box x1297 = new Box((int)0); + Box x1298 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1297, x1298, (x1296).get(), (x1256).get(), (x1253).get()); + int x1299 = ((x1298).get() + (x1254).get()); + Box x1300 = new Box((int)0); + Box x1301 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1300, x1301, 0x0, (x1225).get(), (x1275).get()); + Box x1302 = new Box((int)0); + Box x1303 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1302, x1303, (x1301).get(), (x1227).get(), (x1277).get()); + Box x1304 = new Box((int)0); + Box x1305 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1304, x1305, (x1303).get(), (x1229).get(), (x1279).get()); + Box x1306 = new Box((int)0); + Box x1307 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1306, x1307, (x1305).get(), (x1231).get(), (x1281).get()); + Box x1308 = new Box((int)0); + Box x1309 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1308, x1309, (x1307).get(), (x1233).get(), (x1283).get()); + Box x1310 = new Box((int)0); + Box x1311 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1310, x1311, (x1309).get(), (x1235).get(), (x1285).get()); + Box x1312 = new Box((int)0); + Box x1313 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1312, x1313, (x1311).get(), (x1237).get(), (x1287).get()); + Box x1314 = new Box((int)0); + Box x1315 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1314, x1315, (x1313).get(), (x1239).get(), (x1289).get()); + Box x1316 = new Box((int)0); + Box x1317 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1316, x1317, (x1315).get(), (x1241).get(), (x1291).get()); + Box x1318 = new Box((int)0); + Box x1319 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1318, x1319, (x1317).get(), (x1243).get(), (x1293).get()); + Box x1320 = new Box((int)0); + Box x1321 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1320, x1321, (x1319).get(), (x1245).get(), (x1295).get()); + Box x1322 = new Box((int)0); + Box x1323 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1322, x1323, (x1321).get(), (x1247).get(), (x1297).get()); + Box x1324 = new Box((int)0); + Box x1325 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1324, x1325, (x1323).get(), (x1249).get(), x1299); + int x1326 = ((x1325).get() + (x1250).get()); + Box x1327 = new Box((int)0); + Box x1328 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1327, x1328, x9, (arg1[11])); + Box x1329 = new Box((int)0); + Box x1330 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1329, x1330, x9, (arg1[10])); + Box x1331 = new Box((int)0); + Box x1332 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1331, x1332, x9, (arg1[9])); + Box x1333 = new Box((int)0); + Box x1334 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1333, x1334, x9, (arg1[8])); + Box x1335 = new Box((int)0); + Box x1336 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1335, x1336, x9, (arg1[7])); + Box x1337 = new Box((int)0); + Box x1338 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1337, x1338, x9, (arg1[6])); + Box x1339 = new Box((int)0); + Box x1340 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1339, x1340, x9, (arg1[5])); + Box x1341 = new Box((int)0); + Box x1342 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1341, x1342, x9, (arg1[4])); + Box x1343 = new Box((int)0); + Box x1344 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1343, x1344, x9, (arg1[3])); + Box x1345 = new Box((int)0); + Box x1346 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1345, x1346, x9, (arg1[2])); + Box x1347 = new Box((int)0); + Box x1348 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1347, x1348, x9, (arg1[1])); + Box x1349 = new Box((int)0); + Box x1350 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1349, x1350, x9, (arg1[0])); + Box x1351 = new Box((int)0); + Box x1352 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1351, x1352, 0x0, (x1350).get(), (x1347).get()); + Box x1353 = new Box((int)0); + Box x1354 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1353, x1354, (x1352).get(), (x1348).get(), (x1345).get()); + Box x1355 = new Box((int)0); + Box x1356 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1355, x1356, (x1354).get(), (x1346).get(), (x1343).get()); + Box x1357 = new Box((int)0); + Box x1358 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1357, x1358, (x1356).get(), (x1344).get(), (x1341).get()); + Box x1359 = new Box((int)0); + Box x1360 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1359, x1360, (x1358).get(), (x1342).get(), (x1339).get()); + Box x1361 = new Box((int)0); + Box x1362 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1361, x1362, (x1360).get(), (x1340).get(), (x1337).get()); + Box x1363 = new Box((int)0); + Box x1364 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1363, x1364, (x1362).get(), (x1338).get(), (x1335).get()); + Box x1365 = new Box((int)0); + Box x1366 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1365, x1366, (x1364).get(), (x1336).get(), (x1333).get()); + Box x1367 = new Box((int)0); + Box x1368 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1367, x1368, (x1366).get(), (x1334).get(), (x1331).get()); + Box x1369 = new Box((int)0); + Box x1370 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1369, x1370, (x1368).get(), (x1332).get(), (x1329).get()); + Box x1371 = new Box((int)0); + Box x1372 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1371, x1372, (x1370).get(), (x1330).get(), (x1327).get()); + int x1373 = ((x1372).get() + (x1328).get()); + Box x1374 = new Box((int)0); + Box x1375 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1374, x1375, 0x0, (x1302).get(), (x1349).get()); + Box x1376 = new Box((int)0); + Box x1377 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1376, x1377, (x1375).get(), (x1304).get(), (x1351).get()); + Box x1378 = new Box((int)0); + Box x1379 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1378, x1379, (x1377).get(), (x1306).get(), (x1353).get()); + Box x1380 = new Box((int)0); + Box x1381 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1380, x1381, (x1379).get(), (x1308).get(), (x1355).get()); + Box x1382 = new Box((int)0); + Box x1383 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1382, x1383, (x1381).get(), (x1310).get(), (x1357).get()); + Box x1384 = new Box((int)0); + Box x1385 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1384, x1385, (x1383).get(), (x1312).get(), (x1359).get()); + Box x1386 = new Box((int)0); + Box x1387 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1386, x1387, (x1385).get(), (x1314).get(), (x1361).get()); + Box x1388 = new Box((int)0); + Box x1389 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1388, x1389, (x1387).get(), (x1316).get(), (x1363).get()); + Box x1390 = new Box((int)0); + Box x1391 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1390, x1391, (x1389).get(), (x1318).get(), (x1365).get()); + Box x1392 = new Box((int)0); + Box x1393 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1392, x1393, (x1391).get(), (x1320).get(), (x1367).get()); + Box x1394 = new Box((int)0); + Box x1395 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1394, x1395, (x1393).get(), (x1322).get(), (x1369).get()); + Box x1396 = new Box((int)0); + Box x1397 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1396, x1397, (x1395).get(), (x1324).get(), (x1371).get()); + Box x1398 = new Box((int)0); + Box x1399 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1398, x1399, (x1397).get(), x1326, x1373); + Box x1400 = new Box((int)0); + Box x1401 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1400, x1401, (x1374).get(), 0xe88fdc45); + Box x1402 = new Box((int)0); + Box x1403 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1402, x1403, (x1400).get(), 0xffffffff); + Box x1404 = new Box((int)0); + Box x1405 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1404, x1405, (x1400).get(), 0xffffffff); + Box x1406 = new Box((int)0); + Box x1407 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1406, x1407, (x1400).get(), 0xffffffff); + Box x1408 = new Box((int)0); + Box x1409 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1408, x1409, (x1400).get(), 0xffffffff); + Box x1410 = new Box((int)0); + Box x1411 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1410, x1411, (x1400).get(), 0xffffffff); + Box x1412 = new Box((int)0); + Box x1413 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1412, x1413, (x1400).get(), 0xffffffff); + Box x1414 = new Box((int)0); + Box x1415 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1414, x1415, (x1400).get(), 0xc7634d81); + Box x1416 = new Box((int)0); + Box x1417 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1416, x1417, (x1400).get(), 0xf4372ddf); + Box x1418 = new Box((int)0); + Box x1419 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1418, x1419, (x1400).get(), 0x581a0db2); + Box x1420 = new Box((int)0); + Box x1421 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1420, x1421, (x1400).get(), 0x48b0a77a); + Box x1422 = new Box((int)0); + Box x1423 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1422, x1423, (x1400).get(), 0xecec196a); + Box x1424 = new Box((int)0); + Box x1425 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1424, x1425, (x1400).get(), 0xccc52973); + Box x1426 = new Box((int)0); + Box x1427 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1426, x1427, 0x0, (x1425).get(), (x1422).get()); + Box x1428 = new Box((int)0); + Box x1429 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1428, x1429, (x1427).get(), (x1423).get(), (x1420).get()); + Box x1430 = new Box((int)0); + Box x1431 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1430, x1431, (x1429).get(), (x1421).get(), (x1418).get()); + Box x1432 = new Box((int)0); + Box x1433 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1432, x1433, (x1431).get(), (x1419).get(), (x1416).get()); + Box x1434 = new Box((int)0); + Box x1435 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1434, x1435, (x1433).get(), (x1417).get(), (x1414).get()); + Box x1436 = new Box((int)0); + Box x1437 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1436, x1437, (x1435).get(), (x1415).get(), (x1412).get()); + Box x1438 = new Box((int)0); + Box x1439 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1438, x1439, (x1437).get(), (x1413).get(), (x1410).get()); + Box x1440 = new Box((int)0); + Box x1441 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1440, x1441, (x1439).get(), (x1411).get(), (x1408).get()); + Box x1442 = new Box((int)0); + Box x1443 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1442, x1443, (x1441).get(), (x1409).get(), (x1406).get()); + Box x1444 = new Box((int)0); + Box x1445 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1444, x1445, (x1443).get(), (x1407).get(), (x1404).get()); + Box x1446 = new Box((int)0); + Box x1447 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1446, x1447, (x1445).get(), (x1405).get(), (x1402).get()); + int x1448 = ((x1447).get() + (x1403).get()); + Box x1449 = new Box((int)0); + Box x1450 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1449, x1450, 0x0, (x1374).get(), (x1424).get()); + Box x1451 = new Box((int)0); + Box x1452 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1451, x1452, (x1450).get(), (x1376).get(), (x1426).get()); + Box x1453 = new Box((int)0); + Box x1454 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1453, x1454, (x1452).get(), (x1378).get(), (x1428).get()); + Box x1455 = new Box((int)0); + Box x1456 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1455, x1456, (x1454).get(), (x1380).get(), (x1430).get()); + Box x1457 = new Box((int)0); + Box x1458 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1457, x1458, (x1456).get(), (x1382).get(), (x1432).get()); + Box x1459 = new Box((int)0); + Box x1460 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1459, x1460, (x1458).get(), (x1384).get(), (x1434).get()); + Box x1461 = new Box((int)0); + Box x1462 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1461, x1462, (x1460).get(), (x1386).get(), (x1436).get()); + Box x1463 = new Box((int)0); + Box x1464 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1463, x1464, (x1462).get(), (x1388).get(), (x1438).get()); + Box x1465 = new Box((int)0); + Box x1466 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1465, x1466, (x1464).get(), (x1390).get(), (x1440).get()); + Box x1467 = new Box((int)0); + Box x1468 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1467, x1468, (x1466).get(), (x1392).get(), (x1442).get()); + Box x1469 = new Box((int)0); + Box x1470 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1469, x1470, (x1468).get(), (x1394).get(), (x1444).get()); + Box x1471 = new Box((int)0); + Box x1472 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1471, x1472, (x1470).get(), (x1396).get(), (x1446).get()); + Box x1473 = new Box((int)0); + Box x1474 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1473, x1474, (x1472).get(), (x1398).get(), x1448); + int x1475 = ((x1474).get() + (x1399).get()); + Box x1476 = new Box((int)0); + Box x1477 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1476, x1477, x10, (arg1[11])); + Box x1478 = new Box((int)0); + Box x1479 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1478, x1479, x10, (arg1[10])); + Box x1480 = new Box((int)0); + Box x1481 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1480, x1481, x10, (arg1[9])); + Box x1482 = new Box((int)0); + Box x1483 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1482, x1483, x10, (arg1[8])); + Box x1484 = new Box((int)0); + Box x1485 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1484, x1485, x10, (arg1[7])); + Box x1486 = new Box((int)0); + Box x1487 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1486, x1487, x10, (arg1[6])); + Box x1488 = new Box((int)0); + Box x1489 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1488, x1489, x10, (arg1[5])); + Box x1490 = new Box((int)0); + Box x1491 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1490, x1491, x10, (arg1[4])); + Box x1492 = new Box((int)0); + Box x1493 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1492, x1493, x10, (arg1[3])); + Box x1494 = new Box((int)0); + Box x1495 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1494, x1495, x10, (arg1[2])); + Box x1496 = new Box((int)0); + Box x1497 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1496, x1497, x10, (arg1[1])); + Box x1498 = new Box((int)0); + Box x1499 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1498, x1499, x10, (arg1[0])); + Box x1500 = new Box((int)0); + Box x1501 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1500, x1501, 0x0, (x1499).get(), (x1496).get()); + Box x1502 = new Box((int)0); + Box x1503 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1502, x1503, (x1501).get(), (x1497).get(), (x1494).get()); + Box x1504 = new Box((int)0); + Box x1505 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1504, x1505, (x1503).get(), (x1495).get(), (x1492).get()); + Box x1506 = new Box((int)0); + Box x1507 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1506, x1507, (x1505).get(), (x1493).get(), (x1490).get()); + Box x1508 = new Box((int)0); + Box x1509 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1508, x1509, (x1507).get(), (x1491).get(), (x1488).get()); + Box x1510 = new Box((int)0); + Box x1511 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1510, x1511, (x1509).get(), (x1489).get(), (x1486).get()); + Box x1512 = new Box((int)0); + Box x1513 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1512, x1513, (x1511).get(), (x1487).get(), (x1484).get()); + Box x1514 = new Box((int)0); + Box x1515 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1514, x1515, (x1513).get(), (x1485).get(), (x1482).get()); + Box x1516 = new Box((int)0); + Box x1517 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1516, x1517, (x1515).get(), (x1483).get(), (x1480).get()); + Box x1518 = new Box((int)0); + Box x1519 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1518, x1519, (x1517).get(), (x1481).get(), (x1478).get()); + Box x1520 = new Box((int)0); + Box x1521 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1520, x1521, (x1519).get(), (x1479).get(), (x1476).get()); + int x1522 = ((x1521).get() + (x1477).get()); + Box x1523 = new Box((int)0); + Box x1524 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1523, x1524, 0x0, (x1451).get(), (x1498).get()); + Box x1525 = new Box((int)0); + Box x1526 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1525, x1526, (x1524).get(), (x1453).get(), (x1500).get()); + Box x1527 = new Box((int)0); + Box x1528 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1527, x1528, (x1526).get(), (x1455).get(), (x1502).get()); + Box x1529 = new Box((int)0); + Box x1530 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1529, x1530, (x1528).get(), (x1457).get(), (x1504).get()); + Box x1531 = new Box((int)0); + Box x1532 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1531, x1532, (x1530).get(), (x1459).get(), (x1506).get()); + Box x1533 = new Box((int)0); + Box x1534 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1533, x1534, (x1532).get(), (x1461).get(), (x1508).get()); + Box x1535 = new Box((int)0); + Box x1536 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1535, x1536, (x1534).get(), (x1463).get(), (x1510).get()); + Box x1537 = new Box((int)0); + Box x1538 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1537, x1538, (x1536).get(), (x1465).get(), (x1512).get()); + Box x1539 = new Box((int)0); + Box x1540 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1539, x1540, (x1538).get(), (x1467).get(), (x1514).get()); + Box x1541 = new Box((int)0); + Box x1542 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1541, x1542, (x1540).get(), (x1469).get(), (x1516).get()); + Box x1543 = new Box((int)0); + Box x1544 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1543, x1544, (x1542).get(), (x1471).get(), (x1518).get()); + Box x1545 = new Box((int)0); + Box x1546 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1545, x1546, (x1544).get(), (x1473).get(), (x1520).get()); + Box x1547 = new Box((int)0); + Box x1548 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1547, x1548, (x1546).get(), x1475, x1522); + Box x1549 = new Box((int)0); + Box x1550 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1549, x1550, (x1523).get(), 0xe88fdc45); + Box x1551 = new Box((int)0); + Box x1552 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1551, x1552, (x1549).get(), 0xffffffff); + Box x1553 = new Box((int)0); + Box x1554 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1553, x1554, (x1549).get(), 0xffffffff); + Box x1555 = new Box((int)0); + Box x1556 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1555, x1556, (x1549).get(), 0xffffffff); + Box x1557 = new Box((int)0); + Box x1558 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1557, x1558, (x1549).get(), 0xffffffff); + Box x1559 = new Box((int)0); + Box x1560 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1559, x1560, (x1549).get(), 0xffffffff); + Box x1561 = new Box((int)0); + Box x1562 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1561, x1562, (x1549).get(), 0xffffffff); + Box x1563 = new Box((int)0); + Box x1564 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1563, x1564, (x1549).get(), 0xc7634d81); + Box x1565 = new Box((int)0); + Box x1566 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1565, x1566, (x1549).get(), 0xf4372ddf); + Box x1567 = new Box((int)0); + Box x1568 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1567, x1568, (x1549).get(), 0x581a0db2); + Box x1569 = new Box((int)0); + Box x1570 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1569, x1570, (x1549).get(), 0x48b0a77a); + Box x1571 = new Box((int)0); + Box x1572 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1571, x1572, (x1549).get(), 0xecec196a); + Box x1573 = new Box((int)0); + Box x1574 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1573, x1574, (x1549).get(), 0xccc52973); + Box x1575 = new Box((int)0); + Box x1576 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1575, x1576, 0x0, (x1574).get(), (x1571).get()); + Box x1577 = new Box((int)0); + Box x1578 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1577, x1578, (x1576).get(), (x1572).get(), (x1569).get()); + Box x1579 = new Box((int)0); + Box x1580 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1579, x1580, (x1578).get(), (x1570).get(), (x1567).get()); + Box x1581 = new Box((int)0); + Box x1582 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1581, x1582, (x1580).get(), (x1568).get(), (x1565).get()); + Box x1583 = new Box((int)0); + Box x1584 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1583, x1584, (x1582).get(), (x1566).get(), (x1563).get()); + Box x1585 = new Box((int)0); + Box x1586 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1585, x1586, (x1584).get(), (x1564).get(), (x1561).get()); + Box x1587 = new Box((int)0); + Box x1588 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1587, x1588, (x1586).get(), (x1562).get(), (x1559).get()); + Box x1589 = new Box((int)0); + Box x1590 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1589, x1590, (x1588).get(), (x1560).get(), (x1557).get()); + Box x1591 = new Box((int)0); + Box x1592 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1591, x1592, (x1590).get(), (x1558).get(), (x1555).get()); + Box x1593 = new Box((int)0); + Box x1594 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1593, x1594, (x1592).get(), (x1556).get(), (x1553).get()); + Box x1595 = new Box((int)0); + Box x1596 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1595, x1596, (x1594).get(), (x1554).get(), (x1551).get()); + int x1597 = ((x1596).get() + (x1552).get()); + Box x1598 = new Box((int)0); + Box x1599 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1598, x1599, 0x0, (x1523).get(), (x1573).get()); + Box x1600 = new Box((int)0); + Box x1601 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1600, x1601, (x1599).get(), (x1525).get(), (x1575).get()); + Box x1602 = new Box((int)0); + Box x1603 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1602, x1603, (x1601).get(), (x1527).get(), (x1577).get()); + Box x1604 = new Box((int)0); + Box x1605 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1604, x1605, (x1603).get(), (x1529).get(), (x1579).get()); + Box x1606 = new Box((int)0); + Box x1607 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1606, x1607, (x1605).get(), (x1531).get(), (x1581).get()); + Box x1608 = new Box((int)0); + Box x1609 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1608, x1609, (x1607).get(), (x1533).get(), (x1583).get()); + Box x1610 = new Box((int)0); + Box x1611 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1610, x1611, (x1609).get(), (x1535).get(), (x1585).get()); + Box x1612 = new Box((int)0); + Box x1613 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1612, x1613, (x1611).get(), (x1537).get(), (x1587).get()); + Box x1614 = new Box((int)0); + Box x1615 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1614, x1615, (x1613).get(), (x1539).get(), (x1589).get()); + Box x1616 = new Box((int)0); + Box x1617 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1616, x1617, (x1615).get(), (x1541).get(), (x1591).get()); + Box x1618 = new Box((int)0); + Box x1619 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1618, x1619, (x1617).get(), (x1543).get(), (x1593).get()); + Box x1620 = new Box((int)0); + Box x1621 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1620, x1621, (x1619).get(), (x1545).get(), (x1595).get()); + Box x1622 = new Box((int)0); + Box x1623 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1622, x1623, (x1621).get(), (x1547).get(), x1597); + int x1624 = ((x1623).get() + (x1548).get()); + Box x1625 = new Box((int)0); + Box x1626 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1625, x1626, x11, (arg1[11])); + Box x1627 = new Box((int)0); + Box x1628 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1627, x1628, x11, (arg1[10])); + Box x1629 = new Box((int)0); + Box x1630 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1629, x1630, x11, (arg1[9])); + Box x1631 = new Box((int)0); + Box x1632 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1631, x1632, x11, (arg1[8])); + Box x1633 = new Box((int)0); + Box x1634 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1633, x1634, x11, (arg1[7])); + Box x1635 = new Box((int)0); + Box x1636 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1635, x1636, x11, (arg1[6])); + Box x1637 = new Box((int)0); + Box x1638 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1637, x1638, x11, (arg1[5])); + Box x1639 = new Box((int)0); + Box x1640 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1639, x1640, x11, (arg1[4])); + Box x1641 = new Box((int)0); + Box x1642 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1641, x1642, x11, (arg1[3])); + Box x1643 = new Box((int)0); + Box x1644 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1643, x1644, x11, (arg1[2])); + Box x1645 = new Box((int)0); + Box x1646 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1645, x1646, x11, (arg1[1])); + Box x1647 = new Box((int)0); + Box x1648 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1647, x1648, x11, (arg1[0])); + Box x1649 = new Box((int)0); + Box x1650 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1649, x1650, 0x0, (x1648).get(), (x1645).get()); + Box x1651 = new Box((int)0); + Box x1652 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1651, x1652, (x1650).get(), (x1646).get(), (x1643).get()); + Box x1653 = new Box((int)0); + Box x1654 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1653, x1654, (x1652).get(), (x1644).get(), (x1641).get()); + Box x1655 = new Box((int)0); + Box x1656 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1655, x1656, (x1654).get(), (x1642).get(), (x1639).get()); + Box x1657 = new Box((int)0); + Box x1658 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1657, x1658, (x1656).get(), (x1640).get(), (x1637).get()); + Box x1659 = new Box((int)0); + Box x1660 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1659, x1660, (x1658).get(), (x1638).get(), (x1635).get()); + Box x1661 = new Box((int)0); + Box x1662 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1661, x1662, (x1660).get(), (x1636).get(), (x1633).get()); + Box x1663 = new Box((int)0); + Box x1664 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1663, x1664, (x1662).get(), (x1634).get(), (x1631).get()); + Box x1665 = new Box((int)0); + Box x1666 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1665, x1666, (x1664).get(), (x1632).get(), (x1629).get()); + Box x1667 = new Box((int)0); + Box x1668 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1667, x1668, (x1666).get(), (x1630).get(), (x1627).get()); + Box x1669 = new Box((int)0); + Box x1670 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1669, x1670, (x1668).get(), (x1628).get(), (x1625).get()); + int x1671 = ((x1670).get() + (x1626).get()); + Box x1672 = new Box((int)0); + Box x1673 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1672, x1673, 0x0, (x1600).get(), (x1647).get()); + Box x1674 = new Box((int)0); + Box x1675 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1674, x1675, (x1673).get(), (x1602).get(), (x1649).get()); + Box x1676 = new Box((int)0); + Box x1677 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1676, x1677, (x1675).get(), (x1604).get(), (x1651).get()); + Box x1678 = new Box((int)0); + Box x1679 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1678, x1679, (x1677).get(), (x1606).get(), (x1653).get()); + Box x1680 = new Box((int)0); + Box x1681 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1680, x1681, (x1679).get(), (x1608).get(), (x1655).get()); + Box x1682 = new Box((int)0); + Box x1683 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1682, x1683, (x1681).get(), (x1610).get(), (x1657).get()); + Box x1684 = new Box((int)0); + Box x1685 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1684, x1685, (x1683).get(), (x1612).get(), (x1659).get()); + Box x1686 = new Box((int)0); + Box x1687 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1686, x1687, (x1685).get(), (x1614).get(), (x1661).get()); + Box x1688 = new Box((int)0); + Box x1689 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1688, x1689, (x1687).get(), (x1616).get(), (x1663).get()); + Box x1690 = new Box((int)0); + Box x1691 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1690, x1691, (x1689).get(), (x1618).get(), (x1665).get()); + Box x1692 = new Box((int)0); + Box x1693 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1692, x1693, (x1691).get(), (x1620).get(), (x1667).get()); + Box x1694 = new Box((int)0); + Box x1695 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1694, x1695, (x1693).get(), (x1622).get(), (x1669).get()); + Box x1696 = new Box((int)0); + Box x1697 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1696, x1697, (x1695).get(), x1624, x1671); + Box x1698 = new Box((int)0); + Box x1699 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1698, x1699, (x1672).get(), 0xe88fdc45); + Box x1700 = new Box((int)0); + Box x1701 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1700, x1701, (x1698).get(), 0xffffffff); + Box x1702 = new Box((int)0); + Box x1703 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1702, x1703, (x1698).get(), 0xffffffff); + Box x1704 = new Box((int)0); + Box x1705 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1704, x1705, (x1698).get(), 0xffffffff); + Box x1706 = new Box((int)0); + Box x1707 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1706, x1707, (x1698).get(), 0xffffffff); + Box x1708 = new Box((int)0); + Box x1709 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1708, x1709, (x1698).get(), 0xffffffff); + Box x1710 = new Box((int)0); + Box x1711 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1710, x1711, (x1698).get(), 0xffffffff); + Box x1712 = new Box((int)0); + Box x1713 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1712, x1713, (x1698).get(), 0xc7634d81); + Box x1714 = new Box((int)0); + Box x1715 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1714, x1715, (x1698).get(), 0xf4372ddf); + Box x1716 = new Box((int)0); + Box x1717 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1716, x1717, (x1698).get(), 0x581a0db2); + Box x1718 = new Box((int)0); + Box x1719 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1718, x1719, (x1698).get(), 0x48b0a77a); + Box x1720 = new Box((int)0); + Box x1721 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1720, x1721, (x1698).get(), 0xecec196a); + Box x1722 = new Box((int)0); + Box x1723 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1722, x1723, (x1698).get(), 0xccc52973); + Box x1724 = new Box((int)0); + Box x1725 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1724, x1725, 0x0, (x1723).get(), (x1720).get()); + Box x1726 = new Box((int)0); + Box x1727 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1726, x1727, (x1725).get(), (x1721).get(), (x1718).get()); + Box x1728 = new Box((int)0); + Box x1729 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1728, x1729, (x1727).get(), (x1719).get(), (x1716).get()); + Box x1730 = new Box((int)0); + Box x1731 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1730, x1731, (x1729).get(), (x1717).get(), (x1714).get()); + Box x1732 = new Box((int)0); + Box x1733 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1732, x1733, (x1731).get(), (x1715).get(), (x1712).get()); + Box x1734 = new Box((int)0); + Box x1735 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1734, x1735, (x1733).get(), (x1713).get(), (x1710).get()); + Box x1736 = new Box((int)0); + Box x1737 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1736, x1737, (x1735).get(), (x1711).get(), (x1708).get()); + Box x1738 = new Box((int)0); + Box x1739 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1738, x1739, (x1737).get(), (x1709).get(), (x1706).get()); + Box x1740 = new Box((int)0); + Box x1741 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1740, x1741, (x1739).get(), (x1707).get(), (x1704).get()); + Box x1742 = new Box((int)0); + Box x1743 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1742, x1743, (x1741).get(), (x1705).get(), (x1702).get()); + Box x1744 = new Box((int)0); + Box x1745 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1744, x1745, (x1743).get(), (x1703).get(), (x1700).get()); + int x1746 = ((x1745).get() + (x1701).get()); + Box x1747 = new Box((int)0); + Box x1748 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1747, x1748, 0x0, (x1672).get(), (x1722).get()); + Box x1749 = new Box((int)0); + Box x1750 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1749, x1750, (x1748).get(), (x1674).get(), (x1724).get()); + Box x1751 = new Box((int)0); + Box x1752 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1751, x1752, (x1750).get(), (x1676).get(), (x1726).get()); + Box x1753 = new Box((int)0); + Box x1754 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1753, x1754, (x1752).get(), (x1678).get(), (x1728).get()); + Box x1755 = new Box((int)0); + Box x1756 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1755, x1756, (x1754).get(), (x1680).get(), (x1730).get()); + Box x1757 = new Box((int)0); + Box x1758 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1757, x1758, (x1756).get(), (x1682).get(), (x1732).get()); + Box x1759 = new Box((int)0); + Box x1760 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1759, x1760, (x1758).get(), (x1684).get(), (x1734).get()); + Box x1761 = new Box((int)0); + Box x1762 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1761, x1762, (x1760).get(), (x1686).get(), (x1736).get()); + Box x1763 = new Box((int)0); + Box x1764 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1763, x1764, (x1762).get(), (x1688).get(), (x1738).get()); + Box x1765 = new Box((int)0); + Box x1766 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1765, x1766, (x1764).get(), (x1690).get(), (x1740).get()); + Box x1767 = new Box((int)0); + Box x1768 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1767, x1768, (x1766).get(), (x1692).get(), (x1742).get()); + Box x1769 = new Box((int)0); + Box x1770 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1769, x1770, (x1768).get(), (x1694).get(), (x1744).get()); + Box x1771 = new Box((int)0); + Box x1772 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1771, x1772, (x1770).get(), (x1696).get(), x1746); + int x1773 = ((x1772).get() + (x1697).get()); + Box x1774 = new Box((int)0); + Box x1775 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1774, x1775, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x1749).get(), 0xccc52973); + Box x1776 = new Box((int)0); + Box x1777 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1776, x1777, (x1775).get(), (x1751).get(), 0xecec196a); + Box x1778 = new Box((int)0); + Box x1779 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1778, x1779, (x1777).get(), (x1753).get(), 0x48b0a77a); + Box x1780 = new Box((int)0); + Box x1781 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1780, x1781, (x1779).get(), (x1755).get(), 0x581a0db2); + Box x1782 = new Box((int)0); + Box x1783 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1782, x1783, (x1781).get(), (x1757).get(), 0xf4372ddf); + Box x1784 = new Box((int)0); + Box x1785 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1784, x1785, (x1783).get(), (x1759).get(), 0xc7634d81); + Box x1786 = new Box((int)0); + Box x1787 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1786, x1787, (x1785).get(), (x1761).get(), 0xffffffff); + Box x1788 = new Box((int)0); + Box x1789 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1788, x1789, (x1787).get(), (x1763).get(), 0xffffffff); + Box x1790 = new Box((int)0); + Box x1791 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1790, x1791, (x1789).get(), (x1765).get(), 0xffffffff); + Box x1792 = new Box((int)0); + Box x1793 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1792, x1793, (x1791).get(), (x1767).get(), 0xffffffff); + Box x1794 = new Box((int)0); + Box x1795 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1794, x1795, (x1793).get(), (x1769).get(), 0xffffffff); + Box x1796 = new Box((int)0); + Box x1797 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1796, x1797, (x1795).get(), (x1771).get(), 0xffffffff); + Box x1798 = new Box((int)0); + Box x1799 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1798, x1799, (x1797).get(), x1773, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1800 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1800, (x1799).get(), (x1774).get(), (x1749).get()); + Box x1801 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1801, (x1799).get(), (x1776).get(), (x1751).get()); + Box x1802 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1802, (x1799).get(), (x1778).get(), (x1753).get()); + Box x1803 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1803, (x1799).get(), (x1780).get(), (x1755).get()); + Box x1804 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1804, (x1799).get(), (x1782).get(), (x1757).get()); + Box x1805 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1805, (x1799).get(), (x1784).get(), (x1759).get()); + Box x1806 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1806, (x1799).get(), (x1786).get(), (x1761).get()); + Box x1807 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1807, (x1799).get(), (x1788).get(), (x1763).get()); + Box x1808 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1808, (x1799).get(), (x1790).get(), (x1765).get()); + Box x1809 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1809, (x1799).get(), (x1792).get(), (x1767).get()); + Box x1810 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1810, (x1799).get(), (x1794).get(), (x1769).get()); + Box x1811 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1811, (x1799).get(), (x1796).get(), (x1771).get()); + out1[0] = (x1800).get(); + out1[1] = (x1801).get(); + out1[2] = (x1802).get(); + out1[3] = (x1803).get(); + out1[4] = (x1804).get(); + out1[5] = (x1805).get(); + out1[6] = (x1806).get(); + out1[7] = (x1807).get(); + out1[8] = (x1808).get(); + out1[9] = (x1809).get(); + out1[10] = (x1810).get(); + out1[11] = (x1811).get(); +} + +/** + * The function fiat_P384Scalar_add adds two field elements in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * 0 ≤ eval arg2 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_add(int[] out1, final int[] arg1, final int[] arg2) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1, x2, 0x0, (arg1[0]), (arg2[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x3, x4, (x2).get(), (arg1[1]), (arg2[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x5, x6, (x4).get(), (arg1[2]), (arg2[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x7, x8, (x6).get(), (arg1[3]), (arg2[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x9, x10, (x8).get(), (arg1[4]), (arg2[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x11, x12, (x10).get(), (arg1[5]), (arg2[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x13, x14, (x12).get(), (arg1[6]), (arg2[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x15, x16, (x14).get(), (arg1[7]), (arg2[7])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x17, x18, (x16).get(), (arg1[8]), (arg2[8])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x19, x20, (x18).get(), (arg1[9]), (arg2[9])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x21, x22, (x20).get(), (arg1[10]), (arg2[10])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x23, x24, (x22).get(), (arg1[11]), (arg2[11])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x25, x26, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x1).get(), 0xccc52973); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x27, x28, (x26).get(), (x3).get(), 0xecec196a); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x29, x30, (x28).get(), (x5).get(), 0x48b0a77a); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x31, x32, (x30).get(), (x7).get(), 0x581a0db2); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x33, x34, (x32).get(), (x9).get(), 0xf4372ddf); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x35, x36, (x34).get(), (x11).get(), 0xc7634d81); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x37, x38, (x36).get(), (x13).get(), 0xffffffff); + Box x39 = new Box((int)0); + Box x40 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x39, x40, (x38).get(), (x15).get(), 0xffffffff); + Box x41 = new Box((int)0); + Box x42 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x41, x42, (x40).get(), (x17).get(), 0xffffffff); + Box x43 = new Box((int)0); + Box x44 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x43, x44, (x42).get(), (x19).get(), 0xffffffff); + Box x45 = new Box((int)0); + Box x46 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x45, x46, (x44).get(), (x21).get(), 0xffffffff); + Box x47 = new Box((int)0); + Box x48 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x47, x48, (x46).get(), (x23).get(), 0xffffffff); + Box x49 = new Box((int)0); + Box x50 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x49, x50, (x48).get(), (x24).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x51 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x51, (x50).get(), (x25).get(), (x1).get()); + Box x52 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x52, (x50).get(), (x27).get(), (x3).get()); + Box x53 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x53, (x50).get(), (x29).get(), (x5).get()); + Box x54 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x54, (x50).get(), (x31).get(), (x7).get()); + Box x55 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x55, (x50).get(), (x33).get(), (x9).get()); + Box x56 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x56, (x50).get(), (x35).get(), (x11).get()); + Box x57 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x57, (x50).get(), (x37).get(), (x13).get()); + Box x58 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x58, (x50).get(), (x39).get(), (x15).get()); + Box x59 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x59, (x50).get(), (x41).get(), (x17).get()); + Box x60 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x60, (x50).get(), (x43).get(), (x19).get()); + Box x61 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x61, (x50).get(), (x45).get(), (x21).get()); + Box x62 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x62, (x50).get(), (x47).get(), (x23).get()); + out1[0] = (x51).get(); + out1[1] = (x52).get(); + out1[2] = (x53).get(); + out1[3] = (x54).get(); + out1[4] = (x55).get(); + out1[5] = (x56).get(); + out1[6] = (x57).get(); + out1[7] = (x58).get(); + out1[8] = (x59).get(); + out1[9] = (x60).get(); + out1[10] = (x61).get(); + out1[11] = (x62).get(); +} + +/** + * The function fiat_P384Scalar_sub subtracts two field elements in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * 0 ≤ eval arg2 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_sub(int[] out1, final int[] arg1, final int[] arg2) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1, x2, 0x0, (arg1[0]), (arg2[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x3, x4, (x2).get(), (arg1[1]), (arg2[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x5, x6, (x4).get(), (arg1[2]), (arg2[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x7, x8, (x6).get(), (arg1[3]), (arg2[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x9, x10, (x8).get(), (arg1[4]), (arg2[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x11, x12, (x10).get(), (arg1[5]), (arg2[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x13, x14, (x12).get(), (arg1[6]), (arg2[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x15, x16, (x14).get(), (arg1[7]), (arg2[7])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x17, x18, (x16).get(), (arg1[8]), (arg2[8])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x19, x20, (x18).get(), (arg1[9]), (arg2[9])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x21, x22, (x20).get(), (arg1[10]), (arg2[10])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x23, x24, (x22).get(), (arg1[11]), (arg2[11])); + Box x25 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x25, (x24).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), 0xffffffff); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x26, x27, 0x0, (x1).get(), ((x25).get() & 0xccc52973)); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x28, x29, (x27).get(), (x3).get(), ((x25).get() & 0xecec196a)); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x30, x31, (x29).get(), (x5).get(), ((x25).get() & 0x48b0a77a)); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x32, x33, (x31).get(), (x7).get(), ((x25).get() & 0x581a0db2)); + Box x34 = new Box((int)0); + Box x35 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x34, x35, (x33).get(), (x9).get(), ((x25).get() & 0xf4372ddf)); + Box x36 = new Box((int)0); + Box x37 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x36, x37, (x35).get(), (x11).get(), ((x25).get() & 0xc7634d81)); + Box x38 = new Box((int)0); + Box x39 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x38, x39, (x37).get(), (x13).get(), (x25).get()); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x40, x41, (x39).get(), (x15).get(), (x25).get()); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x42, x43, (x41).get(), (x17).get(), (x25).get()); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x44, x45, (x43).get(), (x19).get(), (x25).get()); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x46, x47, (x45).get(), (x21).get(), (x25).get()); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x48, x49, (x47).get(), (x23).get(), (x25).get()); + out1[0] = (x26).get(); + out1[1] = (x28).get(); + out1[2] = (x30).get(); + out1[3] = (x32).get(); + out1[4] = (x34).get(); + out1[5] = (x36).get(); + out1[6] = (x38).get(); + out1[7] = (x40).get(); + out1[8] = (x42).get(); + out1[9] = (x44).get(); + out1[10] = (x46).get(); + out1[11] = (x48).get(); +} + +/** + * The function fiat_P384Scalar_opp negates a field element in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_opp(int[] out1, final int[] arg1) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1, x2, 0x0, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x3, x4, (x2).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x5, x6, (x4).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x7, x8, (x6).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x9, x10, (x8).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x11, x12, (x10).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x13, x14, (x12).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x15, x16, (x14).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[7])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x17, x18, (x16).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[8])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x19, x20, (x18).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[9])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x21, x22, (x20).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[10])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x23, x24, (x22).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[11])); + Box x25 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x25, (x24).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), 0xffffffff); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x26, x27, 0x0, (x1).get(), ((x25).get() & 0xccc52973)); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x28, x29, (x27).get(), (x3).get(), ((x25).get() & 0xecec196a)); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x30, x31, (x29).get(), (x5).get(), ((x25).get() & 0x48b0a77a)); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x32, x33, (x31).get(), (x7).get(), ((x25).get() & 0x581a0db2)); + Box x34 = new Box((int)0); + Box x35 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x34, x35, (x33).get(), (x9).get(), ((x25).get() & 0xf4372ddf)); + Box x36 = new Box((int)0); + Box x37 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x36, x37, (x35).get(), (x11).get(), ((x25).get() & 0xc7634d81)); + Box x38 = new Box((int)0); + Box x39 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x38, x39, (x37).get(), (x13).get(), (x25).get()); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x40, x41, (x39).get(), (x15).get(), (x25).get()); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x42, x43, (x41).get(), (x17).get(), (x25).get()); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x44, x45, (x43).get(), (x19).get(), (x25).get()); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x46, x47, (x45).get(), (x21).get(), (x25).get()); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x48, x49, (x47).get(), (x23).get(), (x25).get()); + out1[0] = (x26).get(); + out1[1] = (x28).get(); + out1[2] = (x30).get(); + out1[3] = (x32).get(); + out1[4] = (x34).get(); + out1[5] = (x36).get(); + out1[6] = (x38).get(); + out1[7] = (x40).get(); + out1[8] = (x42).get(); + out1[9] = (x44).get(); + out1[10] = (x46).get(); + out1[11] = (x48).get(); +} + +/** + * The function fiat_P384Scalar_from_montgomery translates a field element out of the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^12) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_from_montgomery(int[] out1, final int[] arg1) { + int x1 = (arg1[0]); + Box x2 = new Box((int)0); + Box x3 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x2, x3, x1, 0xe88fdc45); + Box x4 = new Box((int)0); + Box x5 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x4, x5, (x2).get(), 0xffffffff); + Box x6 = new Box((int)0); + Box x7 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x6, x7, (x2).get(), 0xffffffff); + Box x8 = new Box((int)0); + Box x9 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x8, x9, (x2).get(), 0xffffffff); + Box x10 = new Box((int)0); + Box x11 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x10, x11, (x2).get(), 0xffffffff); + Box x12 = new Box((int)0); + Box x13 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x12, x13, (x2).get(), 0xffffffff); + Box x14 = new Box((int)0); + Box x15 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x14, x15, (x2).get(), 0xffffffff); + Box x16 = new Box((int)0); + Box x17 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x16, x17, (x2).get(), 0xc7634d81); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x18, x19, (x2).get(), 0xf4372ddf); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x20, x21, (x2).get(), 0x581a0db2); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x22, x23, (x2).get(), 0x48b0a77a); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x24, x25, (x2).get(), 0xecec196a); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x26, x27, (x2).get(), 0xccc52973); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x28, x29, 0x0, (x27).get(), (x24).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x30, x31, (x29).get(), (x25).get(), (x22).get()); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x32, x33, (x31).get(), (x23).get(), (x20).get()); + Box x34 = new Box((int)0); + Box x35 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x34, x35, (x33).get(), (x21).get(), (x18).get()); + Box x36 = new Box((int)0); + Box x37 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x36, x37, (x35).get(), (x19).get(), (x16).get()); + Box x38 = new Box((int)0); + Box x39 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x38, x39, (x37).get(), (x17).get(), (x14).get()); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x40, x41, (x39).get(), (x15).get(), (x12).get()); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x42, x43, (x41).get(), (x13).get(), (x10).get()); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x44, x45, (x43).get(), (x11).get(), (x8).get()); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x46, x47, (x45).get(), (x9).get(), (x6).get()); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x48, x49, (x47).get(), (x7).get(), (x4).get()); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x50, x51, 0x0, x1, (x26).get()); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x52, x53, (x51).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x28).get()); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x54, x55, (x53).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x30).get()); + Box x56 = new Box((int)0); + Box x57 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x56, x57, (x55).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x32).get()); + Box x58 = new Box((int)0); + Box x59 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x58, x59, (x57).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x34).get()); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x60, x61, (x59).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x36).get()); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x62, x63, (x61).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x38).get()); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x64, x65, (x63).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x40).get()); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x66, x67, (x65).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x42).get()); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x68, x69, (x67).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x44).get()); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x70, x71, (x69).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x46).get()); + Box x72 = new Box((int)0); + Box x73 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x72, x73, (x71).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x48).get()); + Box x74 = new Box((int)0); + Box x75 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x74, x75, (x73).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), ((x49).get() + (x5).get())); + Box x76 = new Box((int)0); + Box x77 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x76, x77, 0x0, (x52).get(), (arg1[1])); + Box x78 = new Box((int)0); + Box x79 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x78, x79, (x77).get(), (x54).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x80 = new Box((int)0); + Box x81 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x80, x81, (x79).get(), (x56).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x82 = new Box((int)0); + Box x83 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x82, x83, (x81).get(), (x58).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x84 = new Box((int)0); + Box x85 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x84, x85, (x83).get(), (x60).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x86 = new Box((int)0); + Box x87 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x86, x87, (x85).get(), (x62).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x88 = new Box((int)0); + Box x89 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x88, x89, (x87).get(), (x64).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x90 = new Box((int)0); + Box x91 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x90, x91, (x89).get(), (x66).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x92 = new Box((int)0); + Box x93 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x92, x93, (x91).get(), (x68).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x94 = new Box((int)0); + Box x95 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x94, x95, (x93).get(), (x70).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x96 = new Box((int)0); + Box x97 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x96, x97, (x95).get(), (x72).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x98 = new Box((int)0); + Box x99 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x98, x99, (x97).get(), (x74).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x100 = new Box((int)0); + Box x101 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x100, x101, (x76).get(), 0xe88fdc45); + Box x102 = new Box((int)0); + Box x103 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x102, x103, (x100).get(), 0xffffffff); + Box x104 = new Box((int)0); + Box x105 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x104, x105, (x100).get(), 0xffffffff); + Box x106 = new Box((int)0); + Box x107 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x106, x107, (x100).get(), 0xffffffff); + Box x108 = new Box((int)0); + Box x109 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x108, x109, (x100).get(), 0xffffffff); + Box x110 = new Box((int)0); + Box x111 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x110, x111, (x100).get(), 0xffffffff); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x112, x113, (x100).get(), 0xffffffff); + Box x114 = new Box((int)0); + Box x115 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x114, x115, (x100).get(), 0xc7634d81); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x116, x117, (x100).get(), 0xf4372ddf); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x118, x119, (x100).get(), 0x581a0db2); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x120, x121, (x100).get(), 0x48b0a77a); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x122, x123, (x100).get(), 0xecec196a); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x124, x125, (x100).get(), 0xccc52973); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x126, x127, 0x0, (x125).get(), (x122).get()); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x128, x129, (x127).get(), (x123).get(), (x120).get()); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x130, x131, (x129).get(), (x121).get(), (x118).get()); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x132, x133, (x131).get(), (x119).get(), (x116).get()); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x134, x135, (x133).get(), (x117).get(), (x114).get()); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x136, x137, (x135).get(), (x115).get(), (x112).get()); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x138, x139, (x137).get(), (x113).get(), (x110).get()); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x140, x141, (x139).get(), (x111).get(), (x108).get()); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x142, x143, (x141).get(), (x109).get(), (x106).get()); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x144, x145, (x143).get(), (x107).get(), (x104).get()); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x146, x147, (x145).get(), (x105).get(), (x102).get()); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x148, x149, 0x0, (x76).get(), (x124).get()); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x150, x151, (x149).get(), (x78).get(), (x126).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x152, x153, (x151).get(), (x80).get(), (x128).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x154, x155, (x153).get(), (x82).get(), (x130).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x156, x157, (x155).get(), (x84).get(), (x132).get()); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x158, x159, (x157).get(), (x86).get(), (x134).get()); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x160, x161, (x159).get(), (x88).get(), (x136).get()); + Box x162 = new Box((int)0); + Box x163 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x162, x163, (x161).get(), (x90).get(), (x138).get()); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x164, x165, (x163).get(), (x92).get(), (x140).get()); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x166, x167, (x165).get(), (x94).get(), (x142).get()); + Box x168 = new Box((int)0); + Box x169 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x168, x169, (x167).get(), (x96).get(), (x144).get()); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x170, x171, (x169).get(), (x98).get(), (x146).get()); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x172, x173, (x171).get(), ((x99).get() + (x75).get()), ((x147).get() + (x103).get())); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x174, x175, 0x0, (x150).get(), (arg1[2])); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x176, x177, (x175).get(), (x152).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x178, x179, (x177).get(), (x154).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x180, x181, (x179).get(), (x156).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x182, x183, (x181).get(), (x158).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x184, x185, (x183).get(), (x160).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x186, x187, (x185).get(), (x162).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x188, x189, (x187).get(), (x164).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x190, x191, (x189).get(), (x166).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x192, x193, (x191).get(), (x168).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x194, x195, (x193).get(), (x170).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x196, x197, (x195).get(), (x172).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x198, x199, (x174).get(), 0xe88fdc45); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x200, x201, (x198).get(), 0xffffffff); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x202, x203, (x198).get(), 0xffffffff); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x204, x205, (x198).get(), 0xffffffff); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x206, x207, (x198).get(), 0xffffffff); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x208, x209, (x198).get(), 0xffffffff); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x210, x211, (x198).get(), 0xffffffff); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x212, x213, (x198).get(), 0xc7634d81); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x214, x215, (x198).get(), 0xf4372ddf); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x216, x217, (x198).get(), 0x581a0db2); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x218, x219, (x198).get(), 0x48b0a77a); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x220, x221, (x198).get(), 0xecec196a); + Box x222 = new Box((int)0); + Box x223 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x222, x223, (x198).get(), 0xccc52973); + Box x224 = new Box((int)0); + Box x225 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x224, x225, 0x0, (x223).get(), (x220).get()); + Box x226 = new Box((int)0); + Box x227 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x226, x227, (x225).get(), (x221).get(), (x218).get()); + Box x228 = new Box((int)0); + Box x229 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x228, x229, (x227).get(), (x219).get(), (x216).get()); + Box x230 = new Box((int)0); + Box x231 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x230, x231, (x229).get(), (x217).get(), (x214).get()); + Box x232 = new Box((int)0); + Box x233 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x232, x233, (x231).get(), (x215).get(), (x212).get()); + Box x234 = new Box((int)0); + Box x235 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x234, x235, (x233).get(), (x213).get(), (x210).get()); + Box x236 = new Box((int)0); + Box x237 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x236, x237, (x235).get(), (x211).get(), (x208).get()); + Box x238 = new Box((int)0); + Box x239 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x238, x239, (x237).get(), (x209).get(), (x206).get()); + Box x240 = new Box((int)0); + Box x241 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x240, x241, (x239).get(), (x207).get(), (x204).get()); + Box x242 = new Box((int)0); + Box x243 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x242, x243, (x241).get(), (x205).get(), (x202).get()); + Box x244 = new Box((int)0); + Box x245 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x244, x245, (x243).get(), (x203).get(), (x200).get()); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x246, x247, 0x0, (x174).get(), (x222).get()); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x248, x249, (x247).get(), (x176).get(), (x224).get()); + Box x250 = new Box((int)0); + Box x251 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x250, x251, (x249).get(), (x178).get(), (x226).get()); + Box x252 = new Box((int)0); + Box x253 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x252, x253, (x251).get(), (x180).get(), (x228).get()); + Box x254 = new Box((int)0); + Box x255 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x254, x255, (x253).get(), (x182).get(), (x230).get()); + Box x256 = new Box((int)0); + Box x257 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x256, x257, (x255).get(), (x184).get(), (x232).get()); + Box x258 = new Box((int)0); + Box x259 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x258, x259, (x257).get(), (x186).get(), (x234).get()); + Box x260 = new Box((int)0); + Box x261 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x260, x261, (x259).get(), (x188).get(), (x236).get()); + Box x262 = new Box((int)0); + Box x263 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x262, x263, (x261).get(), (x190).get(), (x238).get()); + Box x264 = new Box((int)0); + Box x265 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x264, x265, (x263).get(), (x192).get(), (x240).get()); + Box x266 = new Box((int)0); + Box x267 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x266, x267, (x265).get(), (x194).get(), (x242).get()); + Box x268 = new Box((int)0); + Box x269 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x268, x269, (x267).get(), (x196).get(), (x244).get()); + Box x270 = new Box((int)0); + Box x271 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x270, x271, (x269).get(), ((x197).get() + (x173).get()), ((x245).get() + (x201).get())); + Box x272 = new Box((int)0); + Box x273 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x272, x273, 0x0, (x248).get(), (arg1[3])); + Box x274 = new Box((int)0); + Box x275 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x274, x275, (x273).get(), (x250).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x276, x277, (x275).get(), (x252).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x278, x279, (x277).get(), (x254).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x280, x281, (x279).get(), (x256).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x282, x283, (x281).get(), (x258).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x284, x285, (x283).get(), (x260).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x286, x287, (x285).get(), (x262).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x288, x289, (x287).get(), (x264).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x290, x291, (x289).get(), (x266).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x292, x293, (x291).get(), (x268).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x294, x295, (x293).get(), (x270).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x296, x297, (x272).get(), 0xe88fdc45); + Box x298 = new Box((int)0); + Box x299 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x298, x299, (x296).get(), 0xffffffff); + Box x300 = new Box((int)0); + Box x301 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x300, x301, (x296).get(), 0xffffffff); + Box x302 = new Box((int)0); + Box x303 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x302, x303, (x296).get(), 0xffffffff); + Box x304 = new Box((int)0); + Box x305 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x304, x305, (x296).get(), 0xffffffff); + Box x306 = new Box((int)0); + Box x307 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x306, x307, (x296).get(), 0xffffffff); + Box x308 = new Box((int)0); + Box x309 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x308, x309, (x296).get(), 0xffffffff); + Box x310 = new Box((int)0); + Box x311 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x310, x311, (x296).get(), 0xc7634d81); + Box x312 = new Box((int)0); + Box x313 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x312, x313, (x296).get(), 0xf4372ddf); + Box x314 = new Box((int)0); + Box x315 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x314, x315, (x296).get(), 0x581a0db2); + Box x316 = new Box((int)0); + Box x317 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x316, x317, (x296).get(), 0x48b0a77a); + Box x318 = new Box((int)0); + Box x319 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x318, x319, (x296).get(), 0xecec196a); + Box x320 = new Box((int)0); + Box x321 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x320, x321, (x296).get(), 0xccc52973); + Box x322 = new Box((int)0); + Box x323 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x322, x323, 0x0, (x321).get(), (x318).get()); + Box x324 = new Box((int)0); + Box x325 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x324, x325, (x323).get(), (x319).get(), (x316).get()); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x326, x327, (x325).get(), (x317).get(), (x314).get()); + Box x328 = new Box((int)0); + Box x329 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x328, x329, (x327).get(), (x315).get(), (x312).get()); + Box x330 = new Box((int)0); + Box x331 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x330, x331, (x329).get(), (x313).get(), (x310).get()); + Box x332 = new Box((int)0); + Box x333 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x332, x333, (x331).get(), (x311).get(), (x308).get()); + Box x334 = new Box((int)0); + Box x335 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x334, x335, (x333).get(), (x309).get(), (x306).get()); + Box x336 = new Box((int)0); + Box x337 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x336, x337, (x335).get(), (x307).get(), (x304).get()); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x338, x339, (x337).get(), (x305).get(), (x302).get()); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x340, x341, (x339).get(), (x303).get(), (x300).get()); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x342, x343, (x341).get(), (x301).get(), (x298).get()); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x344, x345, 0x0, (x272).get(), (x320).get()); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x346, x347, (x345).get(), (x274).get(), (x322).get()); + Box x348 = new Box((int)0); + Box x349 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x348, x349, (x347).get(), (x276).get(), (x324).get()); + Box x350 = new Box((int)0); + Box x351 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x350, x351, (x349).get(), (x278).get(), (x326).get()); + Box x352 = new Box((int)0); + Box x353 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x352, x353, (x351).get(), (x280).get(), (x328).get()); + Box x354 = new Box((int)0); + Box x355 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x354, x355, (x353).get(), (x282).get(), (x330).get()); + Box x356 = new Box((int)0); + Box x357 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x356, x357, (x355).get(), (x284).get(), (x332).get()); + Box x358 = new Box((int)0); + Box x359 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x358, x359, (x357).get(), (x286).get(), (x334).get()); + Box x360 = new Box((int)0); + Box x361 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x360, x361, (x359).get(), (x288).get(), (x336).get()); + Box x362 = new Box((int)0); + Box x363 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x362, x363, (x361).get(), (x290).get(), (x338).get()); + Box x364 = new Box((int)0); + Box x365 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x364, x365, (x363).get(), (x292).get(), (x340).get()); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x366, x367, (x365).get(), (x294).get(), (x342).get()); + Box x368 = new Box((int)0); + Box x369 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x368, x369, (x367).get(), ((x295).get() + (x271).get()), ((x343).get() + (x299).get())); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x370, x371, 0x0, (x346).get(), (arg1[4])); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x372, x373, (x371).get(), (x348).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x374 = new Box((int)0); + Box x375 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x374, x375, (x373).get(), (x350).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x376 = new Box((int)0); + Box x377 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x376, x377, (x375).get(), (x352).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x378 = new Box((int)0); + Box x379 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x378, x379, (x377).get(), (x354).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x380 = new Box((int)0); + Box x381 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x380, x381, (x379).get(), (x356).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x382 = new Box((int)0); + Box x383 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x382, x383, (x381).get(), (x358).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x384 = new Box((int)0); + Box x385 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x384, x385, (x383).get(), (x360).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x386 = new Box((int)0); + Box x387 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x386, x387, (x385).get(), (x362).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x388 = new Box((int)0); + Box x389 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x388, x389, (x387).get(), (x364).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x390 = new Box((int)0); + Box x391 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x390, x391, (x389).get(), (x366).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x392 = new Box((int)0); + Box x393 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x392, x393, (x391).get(), (x368).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x394 = new Box((int)0); + Box x395 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x394, x395, (x370).get(), 0xe88fdc45); + Box x396 = new Box((int)0); + Box x397 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x396, x397, (x394).get(), 0xffffffff); + Box x398 = new Box((int)0); + Box x399 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x398, x399, (x394).get(), 0xffffffff); + Box x400 = new Box((int)0); + Box x401 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x400, x401, (x394).get(), 0xffffffff); + Box x402 = new Box((int)0); + Box x403 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x402, x403, (x394).get(), 0xffffffff); + Box x404 = new Box((int)0); + Box x405 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x404, x405, (x394).get(), 0xffffffff); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x406, x407, (x394).get(), 0xffffffff); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x408, x409, (x394).get(), 0xc7634d81); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x410, x411, (x394).get(), 0xf4372ddf); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x412, x413, (x394).get(), 0x581a0db2); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x414, x415, (x394).get(), 0x48b0a77a); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x416, x417, (x394).get(), 0xecec196a); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x418, x419, (x394).get(), 0xccc52973); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x420, x421, 0x0, (x419).get(), (x416).get()); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x422, x423, (x421).get(), (x417).get(), (x414).get()); + Box x424 = new Box((int)0); + Box x425 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x424, x425, (x423).get(), (x415).get(), (x412).get()); + Box x426 = new Box((int)0); + Box x427 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x426, x427, (x425).get(), (x413).get(), (x410).get()); + Box x428 = new Box((int)0); + Box x429 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x428, x429, (x427).get(), (x411).get(), (x408).get()); + Box x430 = new Box((int)0); + Box x431 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x430, x431, (x429).get(), (x409).get(), (x406).get()); + Box x432 = new Box((int)0); + Box x433 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x432, x433, (x431).get(), (x407).get(), (x404).get()); + Box x434 = new Box((int)0); + Box x435 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x434, x435, (x433).get(), (x405).get(), (x402).get()); + Box x436 = new Box((int)0); + Box x437 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x436, x437, (x435).get(), (x403).get(), (x400).get()); + Box x438 = new Box((int)0); + Box x439 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x438, x439, (x437).get(), (x401).get(), (x398).get()); + Box x440 = new Box((int)0); + Box x441 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x440, x441, (x439).get(), (x399).get(), (x396).get()); + Box x442 = new Box((int)0); + Box x443 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x442, x443, 0x0, (x370).get(), (x418).get()); + Box x444 = new Box((int)0); + Box x445 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x444, x445, (x443).get(), (x372).get(), (x420).get()); + Box x446 = new Box((int)0); + Box x447 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x446, x447, (x445).get(), (x374).get(), (x422).get()); + Box x448 = new Box((int)0); + Box x449 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x448, x449, (x447).get(), (x376).get(), (x424).get()); + Box x450 = new Box((int)0); + Box x451 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x450, x451, (x449).get(), (x378).get(), (x426).get()); + Box x452 = new Box((int)0); + Box x453 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x452, x453, (x451).get(), (x380).get(), (x428).get()); + Box x454 = new Box((int)0); + Box x455 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x454, x455, (x453).get(), (x382).get(), (x430).get()); + Box x456 = new Box((int)0); + Box x457 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x456, x457, (x455).get(), (x384).get(), (x432).get()); + Box x458 = new Box((int)0); + Box x459 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x458, x459, (x457).get(), (x386).get(), (x434).get()); + Box x460 = new Box((int)0); + Box x461 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x460, x461, (x459).get(), (x388).get(), (x436).get()); + Box x462 = new Box((int)0); + Box x463 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x462, x463, (x461).get(), (x390).get(), (x438).get()); + Box x464 = new Box((int)0); + Box x465 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x464, x465, (x463).get(), (x392).get(), (x440).get()); + Box x466 = new Box((int)0); + Box x467 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x466, x467, (x465).get(), ((x393).get() + (x369).get()), ((x441).get() + (x397).get())); + Box x468 = new Box((int)0); + Box x469 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x468, x469, 0x0, (x444).get(), (arg1[5])); + Box x470 = new Box((int)0); + Box x471 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x470, x471, (x469).get(), (x446).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x472 = new Box((int)0); + Box x473 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x472, x473, (x471).get(), (x448).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x474 = new Box((int)0); + Box x475 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x474, x475, (x473).get(), (x450).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x476 = new Box((int)0); + Box x477 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x476, x477, (x475).get(), (x452).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x478 = new Box((int)0); + Box x479 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x478, x479, (x477).get(), (x454).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x480, x481, (x479).get(), (x456).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x482, x483, (x481).get(), (x458).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x484, x485, (x483).get(), (x460).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x486, x487, (x485).get(), (x462).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x488, x489, (x487).get(), (x464).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x490 = new Box((int)0); + Box x491 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x490, x491, (x489).get(), (x466).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x492 = new Box((int)0); + Box x493 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x492, x493, (x468).get(), 0xe88fdc45); + Box x494 = new Box((int)0); + Box x495 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x494, x495, (x492).get(), 0xffffffff); + Box x496 = new Box((int)0); + Box x497 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x496, x497, (x492).get(), 0xffffffff); + Box x498 = new Box((int)0); + Box x499 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x498, x499, (x492).get(), 0xffffffff); + Box x500 = new Box((int)0); + Box x501 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x500, x501, (x492).get(), 0xffffffff); + Box x502 = new Box((int)0); + Box x503 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x502, x503, (x492).get(), 0xffffffff); + Box x504 = new Box((int)0); + Box x505 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x504, x505, (x492).get(), 0xffffffff); + Box x506 = new Box((int)0); + Box x507 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x506, x507, (x492).get(), 0xc7634d81); + Box x508 = new Box((int)0); + Box x509 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x508, x509, (x492).get(), 0xf4372ddf); + Box x510 = new Box((int)0); + Box x511 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x510, x511, (x492).get(), 0x581a0db2); + Box x512 = new Box((int)0); + Box x513 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x512, x513, (x492).get(), 0x48b0a77a); + Box x514 = new Box((int)0); + Box x515 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x514, x515, (x492).get(), 0xecec196a); + Box x516 = new Box((int)0); + Box x517 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x516, x517, (x492).get(), 0xccc52973); + Box x518 = new Box((int)0); + Box x519 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x518, x519, 0x0, (x517).get(), (x514).get()); + Box x520 = new Box((int)0); + Box x521 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x520, x521, (x519).get(), (x515).get(), (x512).get()); + Box x522 = new Box((int)0); + Box x523 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x522, x523, (x521).get(), (x513).get(), (x510).get()); + Box x524 = new Box((int)0); + Box x525 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x524, x525, (x523).get(), (x511).get(), (x508).get()); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x526, x527, (x525).get(), (x509).get(), (x506).get()); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x528, x529, (x527).get(), (x507).get(), (x504).get()); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x530, x531, (x529).get(), (x505).get(), (x502).get()); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x532, x533, (x531).get(), (x503).get(), (x500).get()); + Box x534 = new Box((int)0); + Box x535 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x534, x535, (x533).get(), (x501).get(), (x498).get()); + Box x536 = new Box((int)0); + Box x537 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x536, x537, (x535).get(), (x499).get(), (x496).get()); + Box x538 = new Box((int)0); + Box x539 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x538, x539, (x537).get(), (x497).get(), (x494).get()); + Box x540 = new Box((int)0); + Box x541 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x540, x541, 0x0, (x468).get(), (x516).get()); + Box x542 = new Box((int)0); + Box x543 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x542, x543, (x541).get(), (x470).get(), (x518).get()); + Box x544 = new Box((int)0); + Box x545 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x544, x545, (x543).get(), (x472).get(), (x520).get()); + Box x546 = new Box((int)0); + Box x547 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x546, x547, (x545).get(), (x474).get(), (x522).get()); + Box x548 = new Box((int)0); + Box x549 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x548, x549, (x547).get(), (x476).get(), (x524).get()); + Box x550 = new Box((int)0); + Box x551 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x550, x551, (x549).get(), (x478).get(), (x526).get()); + Box x552 = new Box((int)0); + Box x553 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x552, x553, (x551).get(), (x480).get(), (x528).get()); + Box x554 = new Box((int)0); + Box x555 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x554, x555, (x553).get(), (x482).get(), (x530).get()); + Box x556 = new Box((int)0); + Box x557 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x556, x557, (x555).get(), (x484).get(), (x532).get()); + Box x558 = new Box((int)0); + Box x559 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x558, x559, (x557).get(), (x486).get(), (x534).get()); + Box x560 = new Box((int)0); + Box x561 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x560, x561, (x559).get(), (x488).get(), (x536).get()); + Box x562 = new Box((int)0); + Box x563 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x562, x563, (x561).get(), (x490).get(), (x538).get()); + Box x564 = new Box((int)0); + Box x565 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x564, x565, (x563).get(), ((x491).get() + (x467).get()), ((x539).get() + (x495).get())); + Box x566 = new Box((int)0); + Box x567 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x566, x567, 0x0, (x542).get(), (arg1[6])); + Box x568 = new Box((int)0); + Box x569 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x568, x569, (x567).get(), (x544).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x570 = new Box((int)0); + Box x571 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x570, x571, (x569).get(), (x546).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x572 = new Box((int)0); + Box x573 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x572, x573, (x571).get(), (x548).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x574 = new Box((int)0); + Box x575 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x574, x575, (x573).get(), (x550).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x576 = new Box((int)0); + Box x577 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x576, x577, (x575).get(), (x552).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x578 = new Box((int)0); + Box x579 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x578, x579, (x577).get(), (x554).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x580 = new Box((int)0); + Box x581 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x580, x581, (x579).get(), (x556).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x582 = new Box((int)0); + Box x583 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x582, x583, (x581).get(), (x558).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x584 = new Box((int)0); + Box x585 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x584, x585, (x583).get(), (x560).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x586 = new Box((int)0); + Box x587 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x586, x587, (x585).get(), (x562).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x588 = new Box((int)0); + Box x589 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x588, x589, (x587).get(), (x564).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x590 = new Box((int)0); + Box x591 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x590, x591, (x566).get(), 0xe88fdc45); + Box x592 = new Box((int)0); + Box x593 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x592, x593, (x590).get(), 0xffffffff); + Box x594 = new Box((int)0); + Box x595 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x594, x595, (x590).get(), 0xffffffff); + Box x596 = new Box((int)0); + Box x597 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x596, x597, (x590).get(), 0xffffffff); + Box x598 = new Box((int)0); + Box x599 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x598, x599, (x590).get(), 0xffffffff); + Box x600 = new Box((int)0); + Box x601 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x600, x601, (x590).get(), 0xffffffff); + Box x602 = new Box((int)0); + Box x603 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x602, x603, (x590).get(), 0xffffffff); + Box x604 = new Box((int)0); + Box x605 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x604, x605, (x590).get(), 0xc7634d81); + Box x606 = new Box((int)0); + Box x607 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x606, x607, (x590).get(), 0xf4372ddf); + Box x608 = new Box((int)0); + Box x609 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x608, x609, (x590).get(), 0x581a0db2); + Box x610 = new Box((int)0); + Box x611 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x610, x611, (x590).get(), 0x48b0a77a); + Box x612 = new Box((int)0); + Box x613 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x612, x613, (x590).get(), 0xecec196a); + Box x614 = new Box((int)0); + Box x615 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x614, x615, (x590).get(), 0xccc52973); + Box x616 = new Box((int)0); + Box x617 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x616, x617, 0x0, (x615).get(), (x612).get()); + Box x618 = new Box((int)0); + Box x619 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x618, x619, (x617).get(), (x613).get(), (x610).get()); + Box x620 = new Box((int)0); + Box x621 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x620, x621, (x619).get(), (x611).get(), (x608).get()); + Box x622 = new Box((int)0); + Box x623 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x622, x623, (x621).get(), (x609).get(), (x606).get()); + Box x624 = new Box((int)0); + Box x625 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x624, x625, (x623).get(), (x607).get(), (x604).get()); + Box x626 = new Box((int)0); + Box x627 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x626, x627, (x625).get(), (x605).get(), (x602).get()); + Box x628 = new Box((int)0); + Box x629 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x628, x629, (x627).get(), (x603).get(), (x600).get()); + Box x630 = new Box((int)0); + Box x631 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x630, x631, (x629).get(), (x601).get(), (x598).get()); + Box x632 = new Box((int)0); + Box x633 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x632, x633, (x631).get(), (x599).get(), (x596).get()); + Box x634 = new Box((int)0); + Box x635 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x634, x635, (x633).get(), (x597).get(), (x594).get()); + Box x636 = new Box((int)0); + Box x637 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x636, x637, (x635).get(), (x595).get(), (x592).get()); + Box x638 = new Box((int)0); + Box x639 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x638, x639, 0x0, (x566).get(), (x614).get()); + Box x640 = new Box((int)0); + Box x641 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x640, x641, (x639).get(), (x568).get(), (x616).get()); + Box x642 = new Box((int)0); + Box x643 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x642, x643, (x641).get(), (x570).get(), (x618).get()); + Box x644 = new Box((int)0); + Box x645 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x644, x645, (x643).get(), (x572).get(), (x620).get()); + Box x646 = new Box((int)0); + Box x647 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x646, x647, (x645).get(), (x574).get(), (x622).get()); + Box x648 = new Box((int)0); + Box x649 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x648, x649, (x647).get(), (x576).get(), (x624).get()); + Box x650 = new Box((int)0); + Box x651 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x650, x651, (x649).get(), (x578).get(), (x626).get()); + Box x652 = new Box((int)0); + Box x653 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x652, x653, (x651).get(), (x580).get(), (x628).get()); + Box x654 = new Box((int)0); + Box x655 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x654, x655, (x653).get(), (x582).get(), (x630).get()); + Box x656 = new Box((int)0); + Box x657 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x656, x657, (x655).get(), (x584).get(), (x632).get()); + Box x658 = new Box((int)0); + Box x659 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x658, x659, (x657).get(), (x586).get(), (x634).get()); + Box x660 = new Box((int)0); + Box x661 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x660, x661, (x659).get(), (x588).get(), (x636).get()); + Box x662 = new Box((int)0); + Box x663 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x662, x663, (x661).get(), ((x589).get() + (x565).get()), ((x637).get() + (x593).get())); + Box x664 = new Box((int)0); + Box x665 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x664, x665, 0x0, (x640).get(), (arg1[7])); + Box x666 = new Box((int)0); + Box x667 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x666, x667, (x665).get(), (x642).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x668 = new Box((int)0); + Box x669 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x668, x669, (x667).get(), (x644).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x670 = new Box((int)0); + Box x671 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x670, x671, (x669).get(), (x646).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x672 = new Box((int)0); + Box x673 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x672, x673, (x671).get(), (x648).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x674 = new Box((int)0); + Box x675 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x674, x675, (x673).get(), (x650).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x676 = new Box((int)0); + Box x677 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x676, x677, (x675).get(), (x652).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x678 = new Box((int)0); + Box x679 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x678, x679, (x677).get(), (x654).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x680 = new Box((int)0); + Box x681 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x680, x681, (x679).get(), (x656).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x682 = new Box((int)0); + Box x683 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x682, x683, (x681).get(), (x658).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x684 = new Box((int)0); + Box x685 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x684, x685, (x683).get(), (x660).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x686 = new Box((int)0); + Box x687 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x686, x687, (x685).get(), (x662).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x688 = new Box((int)0); + Box x689 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x688, x689, (x664).get(), 0xe88fdc45); + Box x690 = new Box((int)0); + Box x691 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x690, x691, (x688).get(), 0xffffffff); + Box x692 = new Box((int)0); + Box x693 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x692, x693, (x688).get(), 0xffffffff); + Box x694 = new Box((int)0); + Box x695 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x694, x695, (x688).get(), 0xffffffff); + Box x696 = new Box((int)0); + Box x697 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x696, x697, (x688).get(), 0xffffffff); + Box x698 = new Box((int)0); + Box x699 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x698, x699, (x688).get(), 0xffffffff); + Box x700 = new Box((int)0); + Box x701 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x700, x701, (x688).get(), 0xffffffff); + Box x702 = new Box((int)0); + Box x703 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x702, x703, (x688).get(), 0xc7634d81); + Box x704 = new Box((int)0); + Box x705 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x704, x705, (x688).get(), 0xf4372ddf); + Box x706 = new Box((int)0); + Box x707 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x706, x707, (x688).get(), 0x581a0db2); + Box x708 = new Box((int)0); + Box x709 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x708, x709, (x688).get(), 0x48b0a77a); + Box x710 = new Box((int)0); + Box x711 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x710, x711, (x688).get(), 0xecec196a); + Box x712 = new Box((int)0); + Box x713 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x712, x713, (x688).get(), 0xccc52973); + Box x714 = new Box((int)0); + Box x715 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x714, x715, 0x0, (x713).get(), (x710).get()); + Box x716 = new Box((int)0); + Box x717 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x716, x717, (x715).get(), (x711).get(), (x708).get()); + Box x718 = new Box((int)0); + Box x719 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x718, x719, (x717).get(), (x709).get(), (x706).get()); + Box x720 = new Box((int)0); + Box x721 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x720, x721, (x719).get(), (x707).get(), (x704).get()); + Box x722 = new Box((int)0); + Box x723 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x722, x723, (x721).get(), (x705).get(), (x702).get()); + Box x724 = new Box((int)0); + Box x725 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x724, x725, (x723).get(), (x703).get(), (x700).get()); + Box x726 = new Box((int)0); + Box x727 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x726, x727, (x725).get(), (x701).get(), (x698).get()); + Box x728 = new Box((int)0); + Box x729 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x728, x729, (x727).get(), (x699).get(), (x696).get()); + Box x730 = new Box((int)0); + Box x731 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x730, x731, (x729).get(), (x697).get(), (x694).get()); + Box x732 = new Box((int)0); + Box x733 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x732, x733, (x731).get(), (x695).get(), (x692).get()); + Box x734 = new Box((int)0); + Box x735 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x734, x735, (x733).get(), (x693).get(), (x690).get()); + Box x736 = new Box((int)0); + Box x737 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x736, x737, 0x0, (x664).get(), (x712).get()); + Box x738 = new Box((int)0); + Box x739 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x738, x739, (x737).get(), (x666).get(), (x714).get()); + Box x740 = new Box((int)0); + Box x741 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x740, x741, (x739).get(), (x668).get(), (x716).get()); + Box x742 = new Box((int)0); + Box x743 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x742, x743, (x741).get(), (x670).get(), (x718).get()); + Box x744 = new Box((int)0); + Box x745 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x744, x745, (x743).get(), (x672).get(), (x720).get()); + Box x746 = new Box((int)0); + Box x747 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x746, x747, (x745).get(), (x674).get(), (x722).get()); + Box x748 = new Box((int)0); + Box x749 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x748, x749, (x747).get(), (x676).get(), (x724).get()); + Box x750 = new Box((int)0); + Box x751 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x750, x751, (x749).get(), (x678).get(), (x726).get()); + Box x752 = new Box((int)0); + Box x753 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x752, x753, (x751).get(), (x680).get(), (x728).get()); + Box x754 = new Box((int)0); + Box x755 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x754, x755, (x753).get(), (x682).get(), (x730).get()); + Box x756 = new Box((int)0); + Box x757 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x756, x757, (x755).get(), (x684).get(), (x732).get()); + Box x758 = new Box((int)0); + Box x759 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x758, x759, (x757).get(), (x686).get(), (x734).get()); + Box x760 = new Box((int)0); + Box x761 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x760, x761, (x759).get(), ((x687).get() + (x663).get()), ((x735).get() + (x691).get())); + Box x762 = new Box((int)0); + Box x763 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x762, x763, 0x0, (x738).get(), (arg1[8])); + Box x764 = new Box((int)0); + Box x765 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x764, x765, (x763).get(), (x740).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x766 = new Box((int)0); + Box x767 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x766, x767, (x765).get(), (x742).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x768 = new Box((int)0); + Box x769 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x768, x769, (x767).get(), (x744).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x770 = new Box((int)0); + Box x771 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x770, x771, (x769).get(), (x746).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x772 = new Box((int)0); + Box x773 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x772, x773, (x771).get(), (x748).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x774 = new Box((int)0); + Box x775 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x774, x775, (x773).get(), (x750).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x776 = new Box((int)0); + Box x777 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x776, x777, (x775).get(), (x752).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x778 = new Box((int)0); + Box x779 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x778, x779, (x777).get(), (x754).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x780 = new Box((int)0); + Box x781 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x780, x781, (x779).get(), (x756).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x782 = new Box((int)0); + Box x783 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x782, x783, (x781).get(), (x758).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x784 = new Box((int)0); + Box x785 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x784, x785, (x783).get(), (x760).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x786 = new Box((int)0); + Box x787 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x786, x787, (x762).get(), 0xe88fdc45); + Box x788 = new Box((int)0); + Box x789 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x788, x789, (x786).get(), 0xffffffff); + Box x790 = new Box((int)0); + Box x791 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x790, x791, (x786).get(), 0xffffffff); + Box x792 = new Box((int)0); + Box x793 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x792, x793, (x786).get(), 0xffffffff); + Box x794 = new Box((int)0); + Box x795 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x794, x795, (x786).get(), 0xffffffff); + Box x796 = new Box((int)0); + Box x797 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x796, x797, (x786).get(), 0xffffffff); + Box x798 = new Box((int)0); + Box x799 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x798, x799, (x786).get(), 0xffffffff); + Box x800 = new Box((int)0); + Box x801 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x800, x801, (x786).get(), 0xc7634d81); + Box x802 = new Box((int)0); + Box x803 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x802, x803, (x786).get(), 0xf4372ddf); + Box x804 = new Box((int)0); + Box x805 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x804, x805, (x786).get(), 0x581a0db2); + Box x806 = new Box((int)0); + Box x807 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x806, x807, (x786).get(), 0x48b0a77a); + Box x808 = new Box((int)0); + Box x809 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x808, x809, (x786).get(), 0xecec196a); + Box x810 = new Box((int)0); + Box x811 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x810, x811, (x786).get(), 0xccc52973); + Box x812 = new Box((int)0); + Box x813 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x812, x813, 0x0, (x811).get(), (x808).get()); + Box x814 = new Box((int)0); + Box x815 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x814, x815, (x813).get(), (x809).get(), (x806).get()); + Box x816 = new Box((int)0); + Box x817 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x816, x817, (x815).get(), (x807).get(), (x804).get()); + Box x818 = new Box((int)0); + Box x819 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x818, x819, (x817).get(), (x805).get(), (x802).get()); + Box x820 = new Box((int)0); + Box x821 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x820, x821, (x819).get(), (x803).get(), (x800).get()); + Box x822 = new Box((int)0); + Box x823 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x822, x823, (x821).get(), (x801).get(), (x798).get()); + Box x824 = new Box((int)0); + Box x825 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x824, x825, (x823).get(), (x799).get(), (x796).get()); + Box x826 = new Box((int)0); + Box x827 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x826, x827, (x825).get(), (x797).get(), (x794).get()); + Box x828 = new Box((int)0); + Box x829 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x828, x829, (x827).get(), (x795).get(), (x792).get()); + Box x830 = new Box((int)0); + Box x831 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x830, x831, (x829).get(), (x793).get(), (x790).get()); + Box x832 = new Box((int)0); + Box x833 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x832, x833, (x831).get(), (x791).get(), (x788).get()); + Box x834 = new Box((int)0); + Box x835 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x834, x835, 0x0, (x762).get(), (x810).get()); + Box x836 = new Box((int)0); + Box x837 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x836, x837, (x835).get(), (x764).get(), (x812).get()); + Box x838 = new Box((int)0); + Box x839 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x838, x839, (x837).get(), (x766).get(), (x814).get()); + Box x840 = new Box((int)0); + Box x841 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x840, x841, (x839).get(), (x768).get(), (x816).get()); + Box x842 = new Box((int)0); + Box x843 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x842, x843, (x841).get(), (x770).get(), (x818).get()); + Box x844 = new Box((int)0); + Box x845 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x844, x845, (x843).get(), (x772).get(), (x820).get()); + Box x846 = new Box((int)0); + Box x847 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x846, x847, (x845).get(), (x774).get(), (x822).get()); + Box x848 = new Box((int)0); + Box x849 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x848, x849, (x847).get(), (x776).get(), (x824).get()); + Box x850 = new Box((int)0); + Box x851 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x850, x851, (x849).get(), (x778).get(), (x826).get()); + Box x852 = new Box((int)0); + Box x853 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x852, x853, (x851).get(), (x780).get(), (x828).get()); + Box x854 = new Box((int)0); + Box x855 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x854, x855, (x853).get(), (x782).get(), (x830).get()); + Box x856 = new Box((int)0); + Box x857 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x856, x857, (x855).get(), (x784).get(), (x832).get()); + Box x858 = new Box((int)0); + Box x859 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x858, x859, (x857).get(), ((x785).get() + (x761).get()), ((x833).get() + (x789).get())); + Box x860 = new Box((int)0); + Box x861 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x860, x861, 0x0, (x836).get(), (arg1[9])); + Box x862 = new Box((int)0); + Box x863 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x862, x863, (x861).get(), (x838).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x864 = new Box((int)0); + Box x865 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x864, x865, (x863).get(), (x840).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x866 = new Box((int)0); + Box x867 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x866, x867, (x865).get(), (x842).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x868 = new Box((int)0); + Box x869 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x868, x869, (x867).get(), (x844).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x870 = new Box((int)0); + Box x871 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x870, x871, (x869).get(), (x846).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x872 = new Box((int)0); + Box x873 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x872, x873, (x871).get(), (x848).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x874 = new Box((int)0); + Box x875 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x874, x875, (x873).get(), (x850).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x876 = new Box((int)0); + Box x877 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x876, x877, (x875).get(), (x852).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x878 = new Box((int)0); + Box x879 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x878, x879, (x877).get(), (x854).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x880 = new Box((int)0); + Box x881 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x880, x881, (x879).get(), (x856).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x882 = new Box((int)0); + Box x883 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x882, x883, (x881).get(), (x858).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x884 = new Box((int)0); + Box x885 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x884, x885, (x860).get(), 0xe88fdc45); + Box x886 = new Box((int)0); + Box x887 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x886, x887, (x884).get(), 0xffffffff); + Box x888 = new Box((int)0); + Box x889 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x888, x889, (x884).get(), 0xffffffff); + Box x890 = new Box((int)0); + Box x891 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x890, x891, (x884).get(), 0xffffffff); + Box x892 = new Box((int)0); + Box x893 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x892, x893, (x884).get(), 0xffffffff); + Box x894 = new Box((int)0); + Box x895 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x894, x895, (x884).get(), 0xffffffff); + Box x896 = new Box((int)0); + Box x897 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x896, x897, (x884).get(), 0xffffffff); + Box x898 = new Box((int)0); + Box x899 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x898, x899, (x884).get(), 0xc7634d81); + Box x900 = new Box((int)0); + Box x901 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x900, x901, (x884).get(), 0xf4372ddf); + Box x902 = new Box((int)0); + Box x903 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x902, x903, (x884).get(), 0x581a0db2); + Box x904 = new Box((int)0); + Box x905 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x904, x905, (x884).get(), 0x48b0a77a); + Box x906 = new Box((int)0); + Box x907 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x906, x907, (x884).get(), 0xecec196a); + Box x908 = new Box((int)0); + Box x909 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x908, x909, (x884).get(), 0xccc52973); + Box x910 = new Box((int)0); + Box x911 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x910, x911, 0x0, (x909).get(), (x906).get()); + Box x912 = new Box((int)0); + Box x913 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x912, x913, (x911).get(), (x907).get(), (x904).get()); + Box x914 = new Box((int)0); + Box x915 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x914, x915, (x913).get(), (x905).get(), (x902).get()); + Box x916 = new Box((int)0); + Box x917 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x916, x917, (x915).get(), (x903).get(), (x900).get()); + Box x918 = new Box((int)0); + Box x919 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x918, x919, (x917).get(), (x901).get(), (x898).get()); + Box x920 = new Box((int)0); + Box x921 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x920, x921, (x919).get(), (x899).get(), (x896).get()); + Box x922 = new Box((int)0); + Box x923 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x922, x923, (x921).get(), (x897).get(), (x894).get()); + Box x924 = new Box((int)0); + Box x925 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x924, x925, (x923).get(), (x895).get(), (x892).get()); + Box x926 = new Box((int)0); + Box x927 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x926, x927, (x925).get(), (x893).get(), (x890).get()); + Box x928 = new Box((int)0); + Box x929 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x928, x929, (x927).get(), (x891).get(), (x888).get()); + Box x930 = new Box((int)0); + Box x931 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x930, x931, (x929).get(), (x889).get(), (x886).get()); + Box x932 = new Box((int)0); + Box x933 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x932, x933, 0x0, (x860).get(), (x908).get()); + Box x934 = new Box((int)0); + Box x935 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x934, x935, (x933).get(), (x862).get(), (x910).get()); + Box x936 = new Box((int)0); + Box x937 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x936, x937, (x935).get(), (x864).get(), (x912).get()); + Box x938 = new Box((int)0); + Box x939 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x938, x939, (x937).get(), (x866).get(), (x914).get()); + Box x940 = new Box((int)0); + Box x941 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x940, x941, (x939).get(), (x868).get(), (x916).get()); + Box x942 = new Box((int)0); + Box x943 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x942, x943, (x941).get(), (x870).get(), (x918).get()); + Box x944 = new Box((int)0); + Box x945 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x944, x945, (x943).get(), (x872).get(), (x920).get()); + Box x946 = new Box((int)0); + Box x947 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x946, x947, (x945).get(), (x874).get(), (x922).get()); + Box x948 = new Box((int)0); + Box x949 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x948, x949, (x947).get(), (x876).get(), (x924).get()); + Box x950 = new Box((int)0); + Box x951 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x950, x951, (x949).get(), (x878).get(), (x926).get()); + Box x952 = new Box((int)0); + Box x953 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x952, x953, (x951).get(), (x880).get(), (x928).get()); + Box x954 = new Box((int)0); + Box x955 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x954, x955, (x953).get(), (x882).get(), (x930).get()); + Box x956 = new Box((int)0); + Box x957 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x956, x957, (x955).get(), ((x883).get() + (x859).get()), ((x931).get() + (x887).get())); + Box x958 = new Box((int)0); + Box x959 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x958, x959, 0x0, (x934).get(), (arg1[10])); + Box x960 = new Box((int)0); + Box x961 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x960, x961, (x959).get(), (x936).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x962 = new Box((int)0); + Box x963 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x962, x963, (x961).get(), (x938).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x964 = new Box((int)0); + Box x965 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x964, x965, (x963).get(), (x940).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x966 = new Box((int)0); + Box x967 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x966, x967, (x965).get(), (x942).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x968 = new Box((int)0); + Box x969 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x968, x969, (x967).get(), (x944).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x970 = new Box((int)0); + Box x971 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x970, x971, (x969).get(), (x946).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x972 = new Box((int)0); + Box x973 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x972, x973, (x971).get(), (x948).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x974 = new Box((int)0); + Box x975 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x974, x975, (x973).get(), (x950).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x976 = new Box((int)0); + Box x977 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x976, x977, (x975).get(), (x952).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x978 = new Box((int)0); + Box x979 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x978, x979, (x977).get(), (x954).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x980 = new Box((int)0); + Box x981 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x980, x981, (x979).get(), (x956).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x982 = new Box((int)0); + Box x983 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x982, x983, (x958).get(), 0xe88fdc45); + Box x984 = new Box((int)0); + Box x985 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x984, x985, (x982).get(), 0xffffffff); + Box x986 = new Box((int)0); + Box x987 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x986, x987, (x982).get(), 0xffffffff); + Box x988 = new Box((int)0); + Box x989 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x988, x989, (x982).get(), 0xffffffff); + Box x990 = new Box((int)0); + Box x991 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x990, x991, (x982).get(), 0xffffffff); + Box x992 = new Box((int)0); + Box x993 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x992, x993, (x982).get(), 0xffffffff); + Box x994 = new Box((int)0); + Box x995 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x994, x995, (x982).get(), 0xffffffff); + Box x996 = new Box((int)0); + Box x997 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x996, x997, (x982).get(), 0xc7634d81); + Box x998 = new Box((int)0); + Box x999 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x998, x999, (x982).get(), 0xf4372ddf); + Box x1000 = new Box((int)0); + Box x1001 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1000, x1001, (x982).get(), 0x581a0db2); + Box x1002 = new Box((int)0); + Box x1003 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1002, x1003, (x982).get(), 0x48b0a77a); + Box x1004 = new Box((int)0); + Box x1005 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1004, x1005, (x982).get(), 0xecec196a); + Box x1006 = new Box((int)0); + Box x1007 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1006, x1007, (x982).get(), 0xccc52973); + Box x1008 = new Box((int)0); + Box x1009 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1008, x1009, 0x0, (x1007).get(), (x1004).get()); + Box x1010 = new Box((int)0); + Box x1011 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1010, x1011, (x1009).get(), (x1005).get(), (x1002).get()); + Box x1012 = new Box((int)0); + Box x1013 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1012, x1013, (x1011).get(), (x1003).get(), (x1000).get()); + Box x1014 = new Box((int)0); + Box x1015 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1014, x1015, (x1013).get(), (x1001).get(), (x998).get()); + Box x1016 = new Box((int)0); + Box x1017 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1016, x1017, (x1015).get(), (x999).get(), (x996).get()); + Box x1018 = new Box((int)0); + Box x1019 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1018, x1019, (x1017).get(), (x997).get(), (x994).get()); + Box x1020 = new Box((int)0); + Box x1021 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1020, x1021, (x1019).get(), (x995).get(), (x992).get()); + Box x1022 = new Box((int)0); + Box x1023 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1022, x1023, (x1021).get(), (x993).get(), (x990).get()); + Box x1024 = new Box((int)0); + Box x1025 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1024, x1025, (x1023).get(), (x991).get(), (x988).get()); + Box x1026 = new Box((int)0); + Box x1027 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1026, x1027, (x1025).get(), (x989).get(), (x986).get()); + Box x1028 = new Box((int)0); + Box x1029 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1028, x1029, (x1027).get(), (x987).get(), (x984).get()); + Box x1030 = new Box((int)0); + Box x1031 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1030, x1031, 0x0, (x958).get(), (x1006).get()); + Box x1032 = new Box((int)0); + Box x1033 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1032, x1033, (x1031).get(), (x960).get(), (x1008).get()); + Box x1034 = new Box((int)0); + Box x1035 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1034, x1035, (x1033).get(), (x962).get(), (x1010).get()); + Box x1036 = new Box((int)0); + Box x1037 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1036, x1037, (x1035).get(), (x964).get(), (x1012).get()); + Box x1038 = new Box((int)0); + Box x1039 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1038, x1039, (x1037).get(), (x966).get(), (x1014).get()); + Box x1040 = new Box((int)0); + Box x1041 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1040, x1041, (x1039).get(), (x968).get(), (x1016).get()); + Box x1042 = new Box((int)0); + Box x1043 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1042, x1043, (x1041).get(), (x970).get(), (x1018).get()); + Box x1044 = new Box((int)0); + Box x1045 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1044, x1045, (x1043).get(), (x972).get(), (x1020).get()); + Box x1046 = new Box((int)0); + Box x1047 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1046, x1047, (x1045).get(), (x974).get(), (x1022).get()); + Box x1048 = new Box((int)0); + Box x1049 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1048, x1049, (x1047).get(), (x976).get(), (x1024).get()); + Box x1050 = new Box((int)0); + Box x1051 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1050, x1051, (x1049).get(), (x978).get(), (x1026).get()); + Box x1052 = new Box((int)0); + Box x1053 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1052, x1053, (x1051).get(), (x980).get(), (x1028).get()); + Box x1054 = new Box((int)0); + Box x1055 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1054, x1055, (x1053).get(), ((x981).get() + (x957).get()), ((x1029).get() + (x985).get())); + Box x1056 = new Box((int)0); + Box x1057 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1056, x1057, 0x0, (x1032).get(), (arg1[11])); + Box x1058 = new Box((int)0); + Box x1059 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1058, x1059, (x1057).get(), (x1034).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1060 = new Box((int)0); + Box x1061 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1060, x1061, (x1059).get(), (x1036).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1062 = new Box((int)0); + Box x1063 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1062, x1063, (x1061).get(), (x1038).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1064 = new Box((int)0); + Box x1065 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1064, x1065, (x1063).get(), (x1040).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1066 = new Box((int)0); + Box x1067 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1066, x1067, (x1065).get(), (x1042).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1068 = new Box((int)0); + Box x1069 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1068, x1069, (x1067).get(), (x1044).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1070 = new Box((int)0); + Box x1071 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1070, x1071, (x1069).get(), (x1046).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1072 = new Box((int)0); + Box x1073 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1072, x1073, (x1071).get(), (x1048).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1074 = new Box((int)0); + Box x1075 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1074, x1075, (x1073).get(), (x1050).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1076 = new Box((int)0); + Box x1077 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1076, x1077, (x1075).get(), (x1052).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1078 = new Box((int)0); + Box x1079 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1078, x1079, (x1077).get(), (x1054).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1080 = new Box((int)0); + Box x1081 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1080, x1081, (x1056).get(), 0xe88fdc45); + Box x1082 = new Box((int)0); + Box x1083 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1082, x1083, (x1080).get(), 0xffffffff); + Box x1084 = new Box((int)0); + Box x1085 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1084, x1085, (x1080).get(), 0xffffffff); + Box x1086 = new Box((int)0); + Box x1087 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1086, x1087, (x1080).get(), 0xffffffff); + Box x1088 = new Box((int)0); + Box x1089 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1088, x1089, (x1080).get(), 0xffffffff); + Box x1090 = new Box((int)0); + Box x1091 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1090, x1091, (x1080).get(), 0xffffffff); + Box x1092 = new Box((int)0); + Box x1093 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1092, x1093, (x1080).get(), 0xffffffff); + Box x1094 = new Box((int)0); + Box x1095 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1094, x1095, (x1080).get(), 0xc7634d81); + Box x1096 = new Box((int)0); + Box x1097 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1096, x1097, (x1080).get(), 0xf4372ddf); + Box x1098 = new Box((int)0); + Box x1099 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1098, x1099, (x1080).get(), 0x581a0db2); + Box x1100 = new Box((int)0); + Box x1101 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1100, x1101, (x1080).get(), 0x48b0a77a); + Box x1102 = new Box((int)0); + Box x1103 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1102, x1103, (x1080).get(), 0xecec196a); + Box x1104 = new Box((int)0); + Box x1105 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1104, x1105, (x1080).get(), 0xccc52973); + Box x1106 = new Box((int)0); + Box x1107 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1106, x1107, 0x0, (x1105).get(), (x1102).get()); + Box x1108 = new Box((int)0); + Box x1109 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1108, x1109, (x1107).get(), (x1103).get(), (x1100).get()); + Box x1110 = new Box((int)0); + Box x1111 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1110, x1111, (x1109).get(), (x1101).get(), (x1098).get()); + Box x1112 = new Box((int)0); + Box x1113 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1112, x1113, (x1111).get(), (x1099).get(), (x1096).get()); + Box x1114 = new Box((int)0); + Box x1115 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1114, x1115, (x1113).get(), (x1097).get(), (x1094).get()); + Box x1116 = new Box((int)0); + Box x1117 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1116, x1117, (x1115).get(), (x1095).get(), (x1092).get()); + Box x1118 = new Box((int)0); + Box x1119 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1118, x1119, (x1117).get(), (x1093).get(), (x1090).get()); + Box x1120 = new Box((int)0); + Box x1121 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1120, x1121, (x1119).get(), (x1091).get(), (x1088).get()); + Box x1122 = new Box((int)0); + Box x1123 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1122, x1123, (x1121).get(), (x1089).get(), (x1086).get()); + Box x1124 = new Box((int)0); + Box x1125 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1124, x1125, (x1123).get(), (x1087).get(), (x1084).get()); + Box x1126 = new Box((int)0); + Box x1127 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1126, x1127, (x1125).get(), (x1085).get(), (x1082).get()); + Box x1128 = new Box((int)0); + Box x1129 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1128, x1129, 0x0, (x1056).get(), (x1104).get()); + Box x1130 = new Box((int)0); + Box x1131 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1130, x1131, (x1129).get(), (x1058).get(), (x1106).get()); + Box x1132 = new Box((int)0); + Box x1133 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1132, x1133, (x1131).get(), (x1060).get(), (x1108).get()); + Box x1134 = new Box((int)0); + Box x1135 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1134, x1135, (x1133).get(), (x1062).get(), (x1110).get()); + Box x1136 = new Box((int)0); + Box x1137 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1136, x1137, (x1135).get(), (x1064).get(), (x1112).get()); + Box x1138 = new Box((int)0); + Box x1139 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1138, x1139, (x1137).get(), (x1066).get(), (x1114).get()); + Box x1140 = new Box((int)0); + Box x1141 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1140, x1141, (x1139).get(), (x1068).get(), (x1116).get()); + Box x1142 = new Box((int)0); + Box x1143 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1142, x1143, (x1141).get(), (x1070).get(), (x1118).get()); + Box x1144 = new Box((int)0); + Box x1145 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1144, x1145, (x1143).get(), (x1072).get(), (x1120).get()); + Box x1146 = new Box((int)0); + Box x1147 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1146, x1147, (x1145).get(), (x1074).get(), (x1122).get()); + Box x1148 = new Box((int)0); + Box x1149 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1148, x1149, (x1147).get(), (x1076).get(), (x1124).get()); + Box x1150 = new Box((int)0); + Box x1151 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1150, x1151, (x1149).get(), (x1078).get(), (x1126).get()); + Box x1152 = new Box((int)0); + Box x1153 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1152, x1153, (x1151).get(), ((x1079).get() + (x1055).get()), ((x1127).get() + (x1083).get())); + Box x1154 = new Box((int)0); + Box x1155 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1154, x1155, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x1130).get(), 0xccc52973); + Box x1156 = new Box((int)0); + Box x1157 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1156, x1157, (x1155).get(), (x1132).get(), 0xecec196a); + Box x1158 = new Box((int)0); + Box x1159 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1158, x1159, (x1157).get(), (x1134).get(), 0x48b0a77a); + Box x1160 = new Box((int)0); + Box x1161 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1160, x1161, (x1159).get(), (x1136).get(), 0x581a0db2); + Box x1162 = new Box((int)0); + Box x1163 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1162, x1163, (x1161).get(), (x1138).get(), 0xf4372ddf); + Box x1164 = new Box((int)0); + Box x1165 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1164, x1165, (x1163).get(), (x1140).get(), 0xc7634d81); + Box x1166 = new Box((int)0); + Box x1167 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1166, x1167, (x1165).get(), (x1142).get(), 0xffffffff); + Box x1168 = new Box((int)0); + Box x1169 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1168, x1169, (x1167).get(), (x1144).get(), 0xffffffff); + Box x1170 = new Box((int)0); + Box x1171 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1170, x1171, (x1169).get(), (x1146).get(), 0xffffffff); + Box x1172 = new Box((int)0); + Box x1173 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1172, x1173, (x1171).get(), (x1148).get(), 0xffffffff); + Box x1174 = new Box((int)0); + Box x1175 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1174, x1175, (x1173).get(), (x1150).get(), 0xffffffff); + Box x1176 = new Box((int)0); + Box x1177 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1176, x1177, (x1175).get(), (x1152).get(), 0xffffffff); + Box x1178 = new Box((int)0); + Box x1179 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1178, x1179, (x1177).get(), (x1153).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1180 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1180, (x1179).get(), (x1154).get(), (x1130).get()); + Box x1181 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1181, (x1179).get(), (x1156).get(), (x1132).get()); + Box x1182 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1182, (x1179).get(), (x1158).get(), (x1134).get()); + Box x1183 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1183, (x1179).get(), (x1160).get(), (x1136).get()); + Box x1184 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1184, (x1179).get(), (x1162).get(), (x1138).get()); + Box x1185 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1185, (x1179).get(), (x1164).get(), (x1140).get()); + Box x1186 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1186, (x1179).get(), (x1166).get(), (x1142).get()); + Box x1187 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1187, (x1179).get(), (x1168).get(), (x1144).get()); + Box x1188 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1188, (x1179).get(), (x1170).get(), (x1146).get()); + Box x1189 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1189, (x1179).get(), (x1172).get(), (x1148).get()); + Box x1190 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1190, (x1179).get(), (x1174).get(), (x1150).get()); + Box x1191 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1191, (x1179).get(), (x1176).get(), (x1152).get()); + out1[0] = (x1180).get(); + out1[1] = (x1181).get(); + out1[2] = (x1182).get(); + out1[3] = (x1183).get(); + out1[4] = (x1184).get(); + out1[5] = (x1185).get(); + out1[6] = (x1186).get(); + out1[7] = (x1187).get(); + out1[8] = (x1188).get(); + out1[9] = (x1189).get(); + out1[10] = (x1190).get(); + out1[11] = (x1191).get(); +} + +/** + * The function fiat_P384Scalar_to_montgomery translates a field element into the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = eval arg1 mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_to_montgomery(int[] out1, final int[] arg1) { + int x1 = (arg1[1]); + int x2 = (arg1[2]); + int x3 = (arg1[3]); + int x4 = (arg1[4]); + int x5 = (arg1[5]); + int x6 = (arg1[6]); + int x7 = (arg1[7]); + int x8 = (arg1[8]); + int x9 = (arg1[9]); + int x10 = (arg1[10]); + int x11 = (arg1[11]); + int x12 = (arg1[0]); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x13, x14, x12, 0xc84ee01); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x15, x16, x12, 0x2b39bf21); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x17, x18, x12, 0x3fb05b7a); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x19, x20, x12, 0x28266895); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x21, x22, x12, 0xd40d4917); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x23, x24, x12, 0x4aab1cc5); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x25, x26, x12, 0xbc3e483a); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x27, x28, x12, 0xfcb82947); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x29, x30, x12, 0xff3d81e5); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x31, x32, x12, 0xdf1aa419); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x33, x34, x12, 0x2d319b24); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x35, x36, x12, 0x19b409a9); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x37, x38, 0x0, (x36).get(), (x33).get()); + Box x39 = new Box((int)0); + Box x40 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x39, x40, (x38).get(), (x34).get(), (x31).get()); + Box x41 = new Box((int)0); + Box x42 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x41, x42, (x40).get(), (x32).get(), (x29).get()); + Box x43 = new Box((int)0); + Box x44 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x43, x44, (x42).get(), (x30).get(), (x27).get()); + Box x45 = new Box((int)0); + Box x46 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x45, x46, (x44).get(), (x28).get(), (x25).get()); + Box x47 = new Box((int)0); + Box x48 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x47, x48, (x46).get(), (x26).get(), (x23).get()); + Box x49 = new Box((int)0); + Box x50 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x49, x50, (x48).get(), (x24).get(), (x21).get()); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x51, x52, (x50).get(), (x22).get(), (x19).get()); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x53, x54, (x52).get(), (x20).get(), (x17).get()); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x55, x56, (x54).get(), (x18).get(), (x15).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x57, x58, (x56).get(), (x16).get(), (x13).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x59, x60, (x35).get(), 0xe88fdc45); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x61, x62, (x59).get(), 0xffffffff); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x63, x64, (x59).get(), 0xffffffff); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x65, x66, (x59).get(), 0xffffffff); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x67, x68, (x59).get(), 0xffffffff); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x69, x70, (x59).get(), 0xffffffff); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x71, x72, (x59).get(), 0xffffffff); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x73, x74, (x59).get(), 0xc7634d81); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x75, x76, (x59).get(), 0xf4372ddf); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x77, x78, (x59).get(), 0x581a0db2); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x79, x80, (x59).get(), 0x48b0a77a); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x81, x82, (x59).get(), 0xecec196a); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x83, x84, (x59).get(), 0xccc52973); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x85, x86, 0x0, (x84).get(), (x81).get()); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x87, x88, (x86).get(), (x82).get(), (x79).get()); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x89, x90, (x88).get(), (x80).get(), (x77).get()); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x91, x92, (x90).get(), (x78).get(), (x75).get()); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x93, x94, (x92).get(), (x76).get(), (x73).get()); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x95, x96, (x94).get(), (x74).get(), (x71).get()); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x97, x98, (x96).get(), (x72).get(), (x69).get()); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x99, x100, (x98).get(), (x70).get(), (x67).get()); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x101, x102, (x100).get(), (x68).get(), (x65).get()); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x103, x104, (x102).get(), (x66).get(), (x63).get()); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x105, x106, (x104).get(), (x64).get(), (x61).get()); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x107, x108, 0x0, (x35).get(), (x83).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x109, x110, (x108).get(), (x37).get(), (x85).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x111, x112, (x110).get(), (x39).get(), (x87).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x113, x114, (x112).get(), (x41).get(), (x89).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x115, x116, (x114).get(), (x43).get(), (x91).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x117, x118, (x116).get(), (x45).get(), (x93).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x119, x120, (x118).get(), (x47).get(), (x95).get()); + Box x121 = new Box((int)0); + Box x122 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x121, x122, (x120).get(), (x49).get(), (x97).get()); + Box x123 = new Box((int)0); + Box x124 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x123, x124, (x122).get(), (x51).get(), (x99).get()); + Box x125 = new Box((int)0); + Box x126 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x125, x126, (x124).get(), (x53).get(), (x101).get()); + Box x127 = new Box((int)0); + Box x128 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x127, x128, (x126).get(), (x55).get(), (x103).get()); + Box x129 = new Box((int)0); + Box x130 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x129, x130, (x128).get(), (x57).get(), (x105).get()); + Box x131 = new Box((int)0); + Box x132 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x131, x132, (x130).get(), ((x58).get() + (x14).get()), ((x106).get() + (x62).get())); + Box x133 = new Box((int)0); + Box x134 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x133, x134, x1, 0xc84ee01); + Box x135 = new Box((int)0); + Box x136 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x135, x136, x1, 0x2b39bf21); + Box x137 = new Box((int)0); + Box x138 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x137, x138, x1, 0x3fb05b7a); + Box x139 = new Box((int)0); + Box x140 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x139, x140, x1, 0x28266895); + Box x141 = new Box((int)0); + Box x142 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x141, x142, x1, 0xd40d4917); + Box x143 = new Box((int)0); + Box x144 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x143, x144, x1, 0x4aab1cc5); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x145, x146, x1, 0xbc3e483a); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x147, x148, x1, 0xfcb82947); + Box x149 = new Box((int)0); + Box x150 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x149, x150, x1, 0xff3d81e5); + Box x151 = new Box((int)0); + Box x152 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x151, x152, x1, 0xdf1aa419); + Box x153 = new Box((int)0); + Box x154 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x153, x154, x1, 0x2d319b24); + Box x155 = new Box((int)0); + Box x156 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x155, x156, x1, 0x19b409a9); + Box x157 = new Box((int)0); + Box x158 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x157, x158, 0x0, (x156).get(), (x153).get()); + Box x159 = new Box((int)0); + Box x160 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x159, x160, (x158).get(), (x154).get(), (x151).get()); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x161, x162, (x160).get(), (x152).get(), (x149).get()); + Box x163 = new Box((int)0); + Box x164 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x163, x164, (x162).get(), (x150).get(), (x147).get()); + Box x165 = new Box((int)0); + Box x166 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x165, x166, (x164).get(), (x148).get(), (x145).get()); + Box x167 = new Box((int)0); + Box x168 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x167, x168, (x166).get(), (x146).get(), (x143).get()); + Box x169 = new Box((int)0); + Box x170 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x169, x170, (x168).get(), (x144).get(), (x141).get()); + Box x171 = new Box((int)0); + Box x172 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x171, x172, (x170).get(), (x142).get(), (x139).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x173, x174, (x172).get(), (x140).get(), (x137).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x175, x176, (x174).get(), (x138).get(), (x135).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x177, x178, (x176).get(), (x136).get(), (x133).get()); + Box x179 = new Box((int)0); + Box x180 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x179, x180, 0x0, (x109).get(), (x155).get()); + Box x181 = new Box((int)0); + Box x182 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x181, x182, (x180).get(), (x111).get(), (x157).get()); + Box x183 = new Box((int)0); + Box x184 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x183, x184, (x182).get(), (x113).get(), (x159).get()); + Box x185 = new Box((int)0); + Box x186 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x185, x186, (x184).get(), (x115).get(), (x161).get()); + Box x187 = new Box((int)0); + Box x188 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x187, x188, (x186).get(), (x117).get(), (x163).get()); + Box x189 = new Box((int)0); + Box x190 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x189, x190, (x188).get(), (x119).get(), (x165).get()); + Box x191 = new Box((int)0); + Box x192 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x191, x192, (x190).get(), (x121).get(), (x167).get()); + Box x193 = new Box((int)0); + Box x194 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x193, x194, (x192).get(), (x123).get(), (x169).get()); + Box x195 = new Box((int)0); + Box x196 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x195, x196, (x194).get(), (x125).get(), (x171).get()); + Box x197 = new Box((int)0); + Box x198 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x197, x198, (x196).get(), (x127).get(), (x173).get()); + Box x199 = new Box((int)0); + Box x200 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x199, x200, (x198).get(), (x129).get(), (x175).get()); + Box x201 = new Box((int)0); + Box x202 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x201, x202, (x200).get(), (x131).get(), (x177).get()); + Box x203 = new Box((int)0); + Box x204 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x203, x204, (x179).get(), 0xe88fdc45); + Box x205 = new Box((int)0); + Box x206 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x205, x206, (x203).get(), 0xffffffff); + Box x207 = new Box((int)0); + Box x208 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x207, x208, (x203).get(), 0xffffffff); + Box x209 = new Box((int)0); + Box x210 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x209, x210, (x203).get(), 0xffffffff); + Box x211 = new Box((int)0); + Box x212 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x211, x212, (x203).get(), 0xffffffff); + Box x213 = new Box((int)0); + Box x214 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x213, x214, (x203).get(), 0xffffffff); + Box x215 = new Box((int)0); + Box x216 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x215, x216, (x203).get(), 0xffffffff); + Box x217 = new Box((int)0); + Box x218 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x217, x218, (x203).get(), 0xc7634d81); + Box x219 = new Box((int)0); + Box x220 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x219, x220, (x203).get(), 0xf4372ddf); + Box x221 = new Box((int)0); + Box x222 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x221, x222, (x203).get(), 0x581a0db2); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x223, x224, (x203).get(), 0x48b0a77a); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x225, x226, (x203).get(), 0xecec196a); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x227, x228, (x203).get(), 0xccc52973); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x229, x230, 0x0, (x228).get(), (x225).get()); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x231, x232, (x230).get(), (x226).get(), (x223).get()); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x233, x234, (x232).get(), (x224).get(), (x221).get()); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x235, x236, (x234).get(), (x222).get(), (x219).get()); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x237, x238, (x236).get(), (x220).get(), (x217).get()); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x239, x240, (x238).get(), (x218).get(), (x215).get()); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x241, x242, (x240).get(), (x216).get(), (x213).get()); + Box x243 = new Box((int)0); + Box x244 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x243, x244, (x242).get(), (x214).get(), (x211).get()); + Box x245 = new Box((int)0); + Box x246 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x245, x246, (x244).get(), (x212).get(), (x209).get()); + Box x247 = new Box((int)0); + Box x248 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x247, x248, (x246).get(), (x210).get(), (x207).get()); + Box x249 = new Box((int)0); + Box x250 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x249, x250, (x248).get(), (x208).get(), (x205).get()); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x251, x252, 0x0, (x179).get(), (x227).get()); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x253, x254, (x252).get(), (x181).get(), (x229).get()); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x255, x256, (x254).get(), (x183).get(), (x231).get()); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x257, x258, (x256).get(), (x185).get(), (x233).get()); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x259, x260, (x258).get(), (x187).get(), (x235).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x261, x262, (x260).get(), (x189).get(), (x237).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x263, x264, (x262).get(), (x191).get(), (x239).get()); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x265, x266, (x264).get(), (x193).get(), (x241).get()); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x267, x268, (x266).get(), (x195).get(), (x243).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x269, x270, (x268).get(), (x197).get(), (x245).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x271, x272, (x270).get(), (x199).get(), (x247).get()); + Box x273 = new Box((int)0); + Box x274 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x273, x274, (x272).get(), (x201).get(), (x249).get()); + Box x275 = new Box((int)0); + Box x276 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x275, x276, (x274).get(), (((x202).get() + (x132).get()) + ((x178).get() + (x134).get())), ((x250).get() + (x206).get())); + Box x277 = new Box((int)0); + Box x278 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x277, x278, x2, 0xc84ee01); + Box x279 = new Box((int)0); + Box x280 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x279, x280, x2, 0x2b39bf21); + Box x281 = new Box((int)0); + Box x282 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x281, x282, x2, 0x3fb05b7a); + Box x283 = new Box((int)0); + Box x284 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x283, x284, x2, 0x28266895); + Box x285 = new Box((int)0); + Box x286 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x285, x286, x2, 0xd40d4917); + Box x287 = new Box((int)0); + Box x288 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x287, x288, x2, 0x4aab1cc5); + Box x289 = new Box((int)0); + Box x290 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x289, x290, x2, 0xbc3e483a); + Box x291 = new Box((int)0); + Box x292 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x291, x292, x2, 0xfcb82947); + Box x293 = new Box((int)0); + Box x294 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x293, x294, x2, 0xff3d81e5); + Box x295 = new Box((int)0); + Box x296 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x295, x296, x2, 0xdf1aa419); + Box x297 = new Box((int)0); + Box x298 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x297, x298, x2, 0x2d319b24); + Box x299 = new Box((int)0); + Box x300 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x299, x300, x2, 0x19b409a9); + Box x301 = new Box((int)0); + Box x302 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x301, x302, 0x0, (x300).get(), (x297).get()); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x303, x304, (x302).get(), (x298).get(), (x295).get()); + Box x305 = new Box((int)0); + Box x306 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x305, x306, (x304).get(), (x296).get(), (x293).get()); + Box x307 = new Box((int)0); + Box x308 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x307, x308, (x306).get(), (x294).get(), (x291).get()); + Box x309 = new Box((int)0); + Box x310 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x309, x310, (x308).get(), (x292).get(), (x289).get()); + Box x311 = new Box((int)0); + Box x312 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x311, x312, (x310).get(), (x290).get(), (x287).get()); + Box x313 = new Box((int)0); + Box x314 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x313, x314, (x312).get(), (x288).get(), (x285).get()); + Box x315 = new Box((int)0); + Box x316 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x315, x316, (x314).get(), (x286).get(), (x283).get()); + Box x317 = new Box((int)0); + Box x318 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x317, x318, (x316).get(), (x284).get(), (x281).get()); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x319, x320, (x318).get(), (x282).get(), (x279).get()); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x321, x322, (x320).get(), (x280).get(), (x277).get()); + Box x323 = new Box((int)0); + Box x324 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x323, x324, 0x0, (x253).get(), (x299).get()); + Box x325 = new Box((int)0); + Box x326 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x325, x326, (x324).get(), (x255).get(), (x301).get()); + Box x327 = new Box((int)0); + Box x328 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x327, x328, (x326).get(), (x257).get(), (x303).get()); + Box x329 = new Box((int)0); + Box x330 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x329, x330, (x328).get(), (x259).get(), (x305).get()); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x331, x332, (x330).get(), (x261).get(), (x307).get()); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x333, x334, (x332).get(), (x263).get(), (x309).get()); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x335, x336, (x334).get(), (x265).get(), (x311).get()); + Box x337 = new Box((int)0); + Box x338 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x337, x338, (x336).get(), (x267).get(), (x313).get()); + Box x339 = new Box((int)0); + Box x340 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x339, x340, (x338).get(), (x269).get(), (x315).get()); + Box x341 = new Box((int)0); + Box x342 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x341, x342, (x340).get(), (x271).get(), (x317).get()); + Box x343 = new Box((int)0); + Box x344 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x343, x344, (x342).get(), (x273).get(), (x319).get()); + Box x345 = new Box((int)0); + Box x346 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x345, x346, (x344).get(), (x275).get(), (x321).get()); + Box x347 = new Box((int)0); + Box x348 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x347, x348, (x323).get(), 0xe88fdc45); + Box x349 = new Box((int)0); + Box x350 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x349, x350, (x347).get(), 0xffffffff); + Box x351 = new Box((int)0); + Box x352 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x351, x352, (x347).get(), 0xffffffff); + Box x353 = new Box((int)0); + Box x354 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x353, x354, (x347).get(), 0xffffffff); + Box x355 = new Box((int)0); + Box x356 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x355, x356, (x347).get(), 0xffffffff); + Box x357 = new Box((int)0); + Box x358 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x357, x358, (x347).get(), 0xffffffff); + Box x359 = new Box((int)0); + Box x360 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x359, x360, (x347).get(), 0xffffffff); + Box x361 = new Box((int)0); + Box x362 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x361, x362, (x347).get(), 0xc7634d81); + Box x363 = new Box((int)0); + Box x364 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x363, x364, (x347).get(), 0xf4372ddf); + Box x365 = new Box((int)0); + Box x366 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x365, x366, (x347).get(), 0x581a0db2); + Box x367 = new Box((int)0); + Box x368 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x367, x368, (x347).get(), 0x48b0a77a); + Box x369 = new Box((int)0); + Box x370 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x369, x370, (x347).get(), 0xecec196a); + Box x371 = new Box((int)0); + Box x372 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x371, x372, (x347).get(), 0xccc52973); + Box x373 = new Box((int)0); + Box x374 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x373, x374, 0x0, (x372).get(), (x369).get()); + Box x375 = new Box((int)0); + Box x376 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x375, x376, (x374).get(), (x370).get(), (x367).get()); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x377, x378, (x376).get(), (x368).get(), (x365).get()); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x379, x380, (x378).get(), (x366).get(), (x363).get()); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x381, x382, (x380).get(), (x364).get(), (x361).get()); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x383, x384, (x382).get(), (x362).get(), (x359).get()); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x385, x386, (x384).get(), (x360).get(), (x357).get()); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x387, x388, (x386).get(), (x358).get(), (x355).get()); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x389, x390, (x388).get(), (x356).get(), (x353).get()); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x391, x392, (x390).get(), (x354).get(), (x351).get()); + Box x393 = new Box((int)0); + Box x394 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x393, x394, (x392).get(), (x352).get(), (x349).get()); + Box x395 = new Box((int)0); + Box x396 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x395, x396, 0x0, (x323).get(), (x371).get()); + Box x397 = new Box((int)0); + Box x398 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x397, x398, (x396).get(), (x325).get(), (x373).get()); + Box x399 = new Box((int)0); + Box x400 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x399, x400, (x398).get(), (x327).get(), (x375).get()); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x401, x402, (x400).get(), (x329).get(), (x377).get()); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x403, x404, (x402).get(), (x331).get(), (x379).get()); + Box x405 = new Box((int)0); + Box x406 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x405, x406, (x404).get(), (x333).get(), (x381).get()); + Box x407 = new Box((int)0); + Box x408 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x407, x408, (x406).get(), (x335).get(), (x383).get()); + Box x409 = new Box((int)0); + Box x410 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x409, x410, (x408).get(), (x337).get(), (x385).get()); + Box x411 = new Box((int)0); + Box x412 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x411, x412, (x410).get(), (x339).get(), (x387).get()); + Box x413 = new Box((int)0); + Box x414 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x413, x414, (x412).get(), (x341).get(), (x389).get()); + Box x415 = new Box((int)0); + Box x416 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x415, x416, (x414).get(), (x343).get(), (x391).get()); + Box x417 = new Box((int)0); + Box x418 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x417, x418, (x416).get(), (x345).get(), (x393).get()); + Box x419 = new Box((int)0); + Box x420 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x419, x420, (x418).get(), (((x346).get() + (x276).get()) + ((x322).get() + (x278).get())), ((x394).get() + (x350).get())); + Box x421 = new Box((int)0); + Box x422 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x421, x422, x3, 0xc84ee01); + Box x423 = new Box((int)0); + Box x424 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x423, x424, x3, 0x2b39bf21); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x425, x426, x3, 0x3fb05b7a); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x427, x428, x3, 0x28266895); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x429, x430, x3, 0xd40d4917); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x431, x432, x3, 0x4aab1cc5); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x433, x434, x3, 0xbc3e483a); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x435, x436, x3, 0xfcb82947); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x437, x438, x3, 0xff3d81e5); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x439, x440, x3, 0xdf1aa419); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x441, x442, x3, 0x2d319b24); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x443, x444, x3, 0x19b409a9); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x445, x446, 0x0, (x444).get(), (x441).get()); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x447, x448, (x446).get(), (x442).get(), (x439).get()); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x449, x450, (x448).get(), (x440).get(), (x437).get()); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x451, x452, (x450).get(), (x438).get(), (x435).get()); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x453, x454, (x452).get(), (x436).get(), (x433).get()); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x455, x456, (x454).get(), (x434).get(), (x431).get()); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x457, x458, (x456).get(), (x432).get(), (x429).get()); + Box x459 = new Box((int)0); + Box x460 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x459, x460, (x458).get(), (x430).get(), (x427).get()); + Box x461 = new Box((int)0); + Box x462 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x461, x462, (x460).get(), (x428).get(), (x425).get()); + Box x463 = new Box((int)0); + Box x464 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x463, x464, (x462).get(), (x426).get(), (x423).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x465, x466, (x464).get(), (x424).get(), (x421).get()); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x467, x468, 0x0, (x397).get(), (x443).get()); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x469, x470, (x468).get(), (x399).get(), (x445).get()); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x471, x472, (x470).get(), (x401).get(), (x447).get()); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x473, x474, (x472).get(), (x403).get(), (x449).get()); + Box x475 = new Box((int)0); + Box x476 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x475, x476, (x474).get(), (x405).get(), (x451).get()); + Box x477 = new Box((int)0); + Box x478 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x477, x478, (x476).get(), (x407).get(), (x453).get()); + Box x479 = new Box((int)0); + Box x480 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x479, x480, (x478).get(), (x409).get(), (x455).get()); + Box x481 = new Box((int)0); + Box x482 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x481, x482, (x480).get(), (x411).get(), (x457).get()); + Box x483 = new Box((int)0); + Box x484 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x483, x484, (x482).get(), (x413).get(), (x459).get()); + Box x485 = new Box((int)0); + Box x486 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x485, x486, (x484).get(), (x415).get(), (x461).get()); + Box x487 = new Box((int)0); + Box x488 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x487, x488, (x486).get(), (x417).get(), (x463).get()); + Box x489 = new Box((int)0); + Box x490 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x489, x490, (x488).get(), (x419).get(), (x465).get()); + Box x491 = new Box((int)0); + Box x492 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x491, x492, (x467).get(), 0xe88fdc45); + Box x493 = new Box((int)0); + Box x494 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x493, x494, (x491).get(), 0xffffffff); + Box x495 = new Box((int)0); + Box x496 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x495, x496, (x491).get(), 0xffffffff); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x497, x498, (x491).get(), 0xffffffff); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x499, x500, (x491).get(), 0xffffffff); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x501, x502, (x491).get(), 0xffffffff); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x503, x504, (x491).get(), 0xffffffff); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x505, x506, (x491).get(), 0xc7634d81); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x507, x508, (x491).get(), 0xf4372ddf); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x509, x510, (x491).get(), 0x581a0db2); + Box x511 = new Box((int)0); + Box x512 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x511, x512, (x491).get(), 0x48b0a77a); + Box x513 = new Box((int)0); + Box x514 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x513, x514, (x491).get(), 0xecec196a); + Box x515 = new Box((int)0); + Box x516 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x515, x516, (x491).get(), 0xccc52973); + Box x517 = new Box((int)0); + Box x518 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x517, x518, 0x0, (x516).get(), (x513).get()); + Box x519 = new Box((int)0); + Box x520 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x519, x520, (x518).get(), (x514).get(), (x511).get()); + Box x521 = new Box((int)0); + Box x522 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x521, x522, (x520).get(), (x512).get(), (x509).get()); + Box x523 = new Box((int)0); + Box x524 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x523, x524, (x522).get(), (x510).get(), (x507).get()); + Box x525 = new Box((int)0); + Box x526 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x525, x526, (x524).get(), (x508).get(), (x505).get()); + Box x527 = new Box((int)0); + Box x528 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x527, x528, (x526).get(), (x506).get(), (x503).get()); + Box x529 = new Box((int)0); + Box x530 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x529, x530, (x528).get(), (x504).get(), (x501).get()); + Box x531 = new Box((int)0); + Box x532 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x531, x532, (x530).get(), (x502).get(), (x499).get()); + Box x533 = new Box((int)0); + Box x534 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x533, x534, (x532).get(), (x500).get(), (x497).get()); + Box x535 = new Box((int)0); + Box x536 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x535, x536, (x534).get(), (x498).get(), (x495).get()); + Box x537 = new Box((int)0); + Box x538 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x537, x538, (x536).get(), (x496).get(), (x493).get()); + Box x539 = new Box((int)0); + Box x540 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x539, x540, 0x0, (x467).get(), (x515).get()); + Box x541 = new Box((int)0); + Box x542 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x541, x542, (x540).get(), (x469).get(), (x517).get()); + Box x543 = new Box((int)0); + Box x544 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x543, x544, (x542).get(), (x471).get(), (x519).get()); + Box x545 = new Box((int)0); + Box x546 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x545, x546, (x544).get(), (x473).get(), (x521).get()); + Box x547 = new Box((int)0); + Box x548 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x547, x548, (x546).get(), (x475).get(), (x523).get()); + Box x549 = new Box((int)0); + Box x550 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x549, x550, (x548).get(), (x477).get(), (x525).get()); + Box x551 = new Box((int)0); + Box x552 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x551, x552, (x550).get(), (x479).get(), (x527).get()); + Box x553 = new Box((int)0); + Box x554 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x553, x554, (x552).get(), (x481).get(), (x529).get()); + Box x555 = new Box((int)0); + Box x556 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x555, x556, (x554).get(), (x483).get(), (x531).get()); + Box x557 = new Box((int)0); + Box x558 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x557, x558, (x556).get(), (x485).get(), (x533).get()); + Box x559 = new Box((int)0); + Box x560 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x559, x560, (x558).get(), (x487).get(), (x535).get()); + Box x561 = new Box((int)0); + Box x562 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x561, x562, (x560).get(), (x489).get(), (x537).get()); + Box x563 = new Box((int)0); + Box x564 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x563, x564, (x562).get(), (((x490).get() + (x420).get()) + ((x466).get() + (x422).get())), ((x538).get() + (x494).get())); + Box x565 = new Box((int)0); + Box x566 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x565, x566, x4, 0xc84ee01); + Box x567 = new Box((int)0); + Box x568 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x567, x568, x4, 0x2b39bf21); + Box x569 = new Box((int)0); + Box x570 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x569, x570, x4, 0x3fb05b7a); + Box x571 = new Box((int)0); + Box x572 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x571, x572, x4, 0x28266895); + Box x573 = new Box((int)0); + Box x574 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x573, x574, x4, 0xd40d4917); + Box x575 = new Box((int)0); + Box x576 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x575, x576, x4, 0x4aab1cc5); + Box x577 = new Box((int)0); + Box x578 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x577, x578, x4, 0xbc3e483a); + Box x579 = new Box((int)0); + Box x580 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x579, x580, x4, 0xfcb82947); + Box x581 = new Box((int)0); + Box x582 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x581, x582, x4, 0xff3d81e5); + Box x583 = new Box((int)0); + Box x584 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x583, x584, x4, 0xdf1aa419); + Box x585 = new Box((int)0); + Box x586 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x585, x586, x4, 0x2d319b24); + Box x587 = new Box((int)0); + Box x588 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x587, x588, x4, 0x19b409a9); + Box x589 = new Box((int)0); + Box x590 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x589, x590, 0x0, (x588).get(), (x585).get()); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x591, x592, (x590).get(), (x586).get(), (x583).get()); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x593, x594, (x592).get(), (x584).get(), (x581).get()); + Box x595 = new Box((int)0); + Box x596 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x595, x596, (x594).get(), (x582).get(), (x579).get()); + Box x597 = new Box((int)0); + Box x598 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x597, x598, (x596).get(), (x580).get(), (x577).get()); + Box x599 = new Box((int)0); + Box x600 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x599, x600, (x598).get(), (x578).get(), (x575).get()); + Box x601 = new Box((int)0); + Box x602 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x601, x602, (x600).get(), (x576).get(), (x573).get()); + Box x603 = new Box((int)0); + Box x604 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x603, x604, (x602).get(), (x574).get(), (x571).get()); + Box x605 = new Box((int)0); + Box x606 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x605, x606, (x604).get(), (x572).get(), (x569).get()); + Box x607 = new Box((int)0); + Box x608 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x607, x608, (x606).get(), (x570).get(), (x567).get()); + Box x609 = new Box((int)0); + Box x610 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x609, x610, (x608).get(), (x568).get(), (x565).get()); + Box x611 = new Box((int)0); + Box x612 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x611, x612, 0x0, (x541).get(), (x587).get()); + Box x613 = new Box((int)0); + Box x614 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x613, x614, (x612).get(), (x543).get(), (x589).get()); + Box x615 = new Box((int)0); + Box x616 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x615, x616, (x614).get(), (x545).get(), (x591).get()); + Box x617 = new Box((int)0); + Box x618 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x617, x618, (x616).get(), (x547).get(), (x593).get()); + Box x619 = new Box((int)0); + Box x620 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x619, x620, (x618).get(), (x549).get(), (x595).get()); + Box x621 = new Box((int)0); + Box x622 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x621, x622, (x620).get(), (x551).get(), (x597).get()); + Box x623 = new Box((int)0); + Box x624 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x623, x624, (x622).get(), (x553).get(), (x599).get()); + Box x625 = new Box((int)0); + Box x626 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x625, x626, (x624).get(), (x555).get(), (x601).get()); + Box x627 = new Box((int)0); + Box x628 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x627, x628, (x626).get(), (x557).get(), (x603).get()); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x629, x630, (x628).get(), (x559).get(), (x605).get()); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x631, x632, (x630).get(), (x561).get(), (x607).get()); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x633, x634, (x632).get(), (x563).get(), (x609).get()); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x635, x636, (x611).get(), 0xe88fdc45); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x637, x638, (x635).get(), 0xffffffff); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x639, x640, (x635).get(), 0xffffffff); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x641, x642, (x635).get(), 0xffffffff); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x643, x644, (x635).get(), 0xffffffff); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x645, x646, (x635).get(), 0xffffffff); + Box x647 = new Box((int)0); + Box x648 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x647, x648, (x635).get(), 0xffffffff); + Box x649 = new Box((int)0); + Box x650 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x649, x650, (x635).get(), 0xc7634d81); + Box x651 = new Box((int)0); + Box x652 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x651, x652, (x635).get(), 0xf4372ddf); + Box x653 = new Box((int)0); + Box x654 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x653, x654, (x635).get(), 0x581a0db2); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x655, x656, (x635).get(), 0x48b0a77a); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x657, x658, (x635).get(), 0xecec196a); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x659, x660, (x635).get(), 0xccc52973); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x661, x662, 0x0, (x660).get(), (x657).get()); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x663, x664, (x662).get(), (x658).get(), (x655).get()); + Box x665 = new Box((int)0); + Box x666 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x665, x666, (x664).get(), (x656).get(), (x653).get()); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x667, x668, (x666).get(), (x654).get(), (x651).get()); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x669, x670, (x668).get(), (x652).get(), (x649).get()); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x671, x672, (x670).get(), (x650).get(), (x647).get()); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x673, x674, (x672).get(), (x648).get(), (x645).get()); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x675, x676, (x674).get(), (x646).get(), (x643).get()); + Box x677 = new Box((int)0); + Box x678 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x677, x678, (x676).get(), (x644).get(), (x641).get()); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x679, x680, (x678).get(), (x642).get(), (x639).get()); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x681, x682, (x680).get(), (x640).get(), (x637).get()); + Box x683 = new Box((int)0); + Box x684 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x683, x684, 0x0, (x611).get(), (x659).get()); + Box x685 = new Box((int)0); + Box x686 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x685, x686, (x684).get(), (x613).get(), (x661).get()); + Box x687 = new Box((int)0); + Box x688 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x687, x688, (x686).get(), (x615).get(), (x663).get()); + Box x689 = new Box((int)0); + Box x690 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x689, x690, (x688).get(), (x617).get(), (x665).get()); + Box x691 = new Box((int)0); + Box x692 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x691, x692, (x690).get(), (x619).get(), (x667).get()); + Box x693 = new Box((int)0); + Box x694 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x693, x694, (x692).get(), (x621).get(), (x669).get()); + Box x695 = new Box((int)0); + Box x696 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x695, x696, (x694).get(), (x623).get(), (x671).get()); + Box x697 = new Box((int)0); + Box x698 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x697, x698, (x696).get(), (x625).get(), (x673).get()); + Box x699 = new Box((int)0); + Box x700 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x699, x700, (x698).get(), (x627).get(), (x675).get()); + Box x701 = new Box((int)0); + Box x702 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x701, x702, (x700).get(), (x629).get(), (x677).get()); + Box x703 = new Box((int)0); + Box x704 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x703, x704, (x702).get(), (x631).get(), (x679).get()); + Box x705 = new Box((int)0); + Box x706 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x705, x706, (x704).get(), (x633).get(), (x681).get()); + Box x707 = new Box((int)0); + Box x708 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x707, x708, (x706).get(), (((x634).get() + (x564).get()) + ((x610).get() + (x566).get())), ((x682).get() + (x638).get())); + Box x709 = new Box((int)0); + Box x710 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x709, x710, x5, 0xc84ee01); + Box x711 = new Box((int)0); + Box x712 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x711, x712, x5, 0x2b39bf21); + Box x713 = new Box((int)0); + Box x714 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x713, x714, x5, 0x3fb05b7a); + Box x715 = new Box((int)0); + Box x716 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x715, x716, x5, 0x28266895); + Box x717 = new Box((int)0); + Box x718 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x717, x718, x5, 0xd40d4917); + Box x719 = new Box((int)0); + Box x720 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x719, x720, x5, 0x4aab1cc5); + Box x721 = new Box((int)0); + Box x722 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x721, x722, x5, 0xbc3e483a); + Box x723 = new Box((int)0); + Box x724 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x723, x724, x5, 0xfcb82947); + Box x725 = new Box((int)0); + Box x726 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x725, x726, x5, 0xff3d81e5); + Box x727 = new Box((int)0); + Box x728 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x727, x728, x5, 0xdf1aa419); + Box x729 = new Box((int)0); + Box x730 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x729, x730, x5, 0x2d319b24); + Box x731 = new Box((int)0); + Box x732 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x731, x732, x5, 0x19b409a9); + Box x733 = new Box((int)0); + Box x734 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x733, x734, 0x0, (x732).get(), (x729).get()); + Box x735 = new Box((int)0); + Box x736 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x735, x736, (x734).get(), (x730).get(), (x727).get()); + Box x737 = new Box((int)0); + Box x738 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x737, x738, (x736).get(), (x728).get(), (x725).get()); + Box x739 = new Box((int)0); + Box x740 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x739, x740, (x738).get(), (x726).get(), (x723).get()); + Box x741 = new Box((int)0); + Box x742 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x741, x742, (x740).get(), (x724).get(), (x721).get()); + Box x743 = new Box((int)0); + Box x744 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x743, x744, (x742).get(), (x722).get(), (x719).get()); + Box x745 = new Box((int)0); + Box x746 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x745, x746, (x744).get(), (x720).get(), (x717).get()); + Box x747 = new Box((int)0); + Box x748 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x747, x748, (x746).get(), (x718).get(), (x715).get()); + Box x749 = new Box((int)0); + Box x750 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x749, x750, (x748).get(), (x716).get(), (x713).get()); + Box x751 = new Box((int)0); + Box x752 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x751, x752, (x750).get(), (x714).get(), (x711).get()); + Box x753 = new Box((int)0); + Box x754 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x753, x754, (x752).get(), (x712).get(), (x709).get()); + Box x755 = new Box((int)0); + Box x756 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x755, x756, 0x0, (x685).get(), (x731).get()); + Box x757 = new Box((int)0); + Box x758 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x757, x758, (x756).get(), (x687).get(), (x733).get()); + Box x759 = new Box((int)0); + Box x760 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x759, x760, (x758).get(), (x689).get(), (x735).get()); + Box x761 = new Box((int)0); + Box x762 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x761, x762, (x760).get(), (x691).get(), (x737).get()); + Box x763 = new Box((int)0); + Box x764 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x763, x764, (x762).get(), (x693).get(), (x739).get()); + Box x765 = new Box((int)0); + Box x766 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x765, x766, (x764).get(), (x695).get(), (x741).get()); + Box x767 = new Box((int)0); + Box x768 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x767, x768, (x766).get(), (x697).get(), (x743).get()); + Box x769 = new Box((int)0); + Box x770 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x769, x770, (x768).get(), (x699).get(), (x745).get()); + Box x771 = new Box((int)0); + Box x772 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x771, x772, (x770).get(), (x701).get(), (x747).get()); + Box x773 = new Box((int)0); + Box x774 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x773, x774, (x772).get(), (x703).get(), (x749).get()); + Box x775 = new Box((int)0); + Box x776 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x775, x776, (x774).get(), (x705).get(), (x751).get()); + Box x777 = new Box((int)0); + Box x778 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x777, x778, (x776).get(), (x707).get(), (x753).get()); + Box x779 = new Box((int)0); + Box x780 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x779, x780, (x755).get(), 0xe88fdc45); + Box x781 = new Box((int)0); + Box x782 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x781, x782, (x779).get(), 0xffffffff); + Box x783 = new Box((int)0); + Box x784 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x783, x784, (x779).get(), 0xffffffff); + Box x785 = new Box((int)0); + Box x786 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x785, x786, (x779).get(), 0xffffffff); + Box x787 = new Box((int)0); + Box x788 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x787, x788, (x779).get(), 0xffffffff); + Box x789 = new Box((int)0); + Box x790 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x789, x790, (x779).get(), 0xffffffff); + Box x791 = new Box((int)0); + Box x792 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x791, x792, (x779).get(), 0xffffffff); + Box x793 = new Box((int)0); + Box x794 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x793, x794, (x779).get(), 0xc7634d81); + Box x795 = new Box((int)0); + Box x796 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x795, x796, (x779).get(), 0xf4372ddf); + Box x797 = new Box((int)0); + Box x798 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x797, x798, (x779).get(), 0x581a0db2); + Box x799 = new Box((int)0); + Box x800 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x799, x800, (x779).get(), 0x48b0a77a); + Box x801 = new Box((int)0); + Box x802 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x801, x802, (x779).get(), 0xecec196a); + Box x803 = new Box((int)0); + Box x804 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x803, x804, (x779).get(), 0xccc52973); + Box x805 = new Box((int)0); + Box x806 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x805, x806, 0x0, (x804).get(), (x801).get()); + Box x807 = new Box((int)0); + Box x808 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x807, x808, (x806).get(), (x802).get(), (x799).get()); + Box x809 = new Box((int)0); + Box x810 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x809, x810, (x808).get(), (x800).get(), (x797).get()); + Box x811 = new Box((int)0); + Box x812 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x811, x812, (x810).get(), (x798).get(), (x795).get()); + Box x813 = new Box((int)0); + Box x814 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x813, x814, (x812).get(), (x796).get(), (x793).get()); + Box x815 = new Box((int)0); + Box x816 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x815, x816, (x814).get(), (x794).get(), (x791).get()); + Box x817 = new Box((int)0); + Box x818 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x817, x818, (x816).get(), (x792).get(), (x789).get()); + Box x819 = new Box((int)0); + Box x820 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x819, x820, (x818).get(), (x790).get(), (x787).get()); + Box x821 = new Box((int)0); + Box x822 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x821, x822, (x820).get(), (x788).get(), (x785).get()); + Box x823 = new Box((int)0); + Box x824 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x823, x824, (x822).get(), (x786).get(), (x783).get()); + Box x825 = new Box((int)0); + Box x826 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x825, x826, (x824).get(), (x784).get(), (x781).get()); + Box x827 = new Box((int)0); + Box x828 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x827, x828, 0x0, (x755).get(), (x803).get()); + Box x829 = new Box((int)0); + Box x830 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x829, x830, (x828).get(), (x757).get(), (x805).get()); + Box x831 = new Box((int)0); + Box x832 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x831, x832, (x830).get(), (x759).get(), (x807).get()); + Box x833 = new Box((int)0); + Box x834 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x833, x834, (x832).get(), (x761).get(), (x809).get()); + Box x835 = new Box((int)0); + Box x836 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x835, x836, (x834).get(), (x763).get(), (x811).get()); + Box x837 = new Box((int)0); + Box x838 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x837, x838, (x836).get(), (x765).get(), (x813).get()); + Box x839 = new Box((int)0); + Box x840 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x839, x840, (x838).get(), (x767).get(), (x815).get()); + Box x841 = new Box((int)0); + Box x842 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x841, x842, (x840).get(), (x769).get(), (x817).get()); + Box x843 = new Box((int)0); + Box x844 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x843, x844, (x842).get(), (x771).get(), (x819).get()); + Box x845 = new Box((int)0); + Box x846 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x845, x846, (x844).get(), (x773).get(), (x821).get()); + Box x847 = new Box((int)0); + Box x848 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x847, x848, (x846).get(), (x775).get(), (x823).get()); + Box x849 = new Box((int)0); + Box x850 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x849, x850, (x848).get(), (x777).get(), (x825).get()); + Box x851 = new Box((int)0); + Box x852 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x851, x852, (x850).get(), (((x778).get() + (x708).get()) + ((x754).get() + (x710).get())), ((x826).get() + (x782).get())); + Box x853 = new Box((int)0); + Box x854 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x853, x854, x6, 0xc84ee01); + Box x855 = new Box((int)0); + Box x856 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x855, x856, x6, 0x2b39bf21); + Box x857 = new Box((int)0); + Box x858 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x857, x858, x6, 0x3fb05b7a); + Box x859 = new Box((int)0); + Box x860 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x859, x860, x6, 0x28266895); + Box x861 = new Box((int)0); + Box x862 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x861, x862, x6, 0xd40d4917); + Box x863 = new Box((int)0); + Box x864 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x863, x864, x6, 0x4aab1cc5); + Box x865 = new Box((int)0); + Box x866 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x865, x866, x6, 0xbc3e483a); + Box x867 = new Box((int)0); + Box x868 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x867, x868, x6, 0xfcb82947); + Box x869 = new Box((int)0); + Box x870 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x869, x870, x6, 0xff3d81e5); + Box x871 = new Box((int)0); + Box x872 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x871, x872, x6, 0xdf1aa419); + Box x873 = new Box((int)0); + Box x874 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x873, x874, x6, 0x2d319b24); + Box x875 = new Box((int)0); + Box x876 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x875, x876, x6, 0x19b409a9); + Box x877 = new Box((int)0); + Box x878 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x877, x878, 0x0, (x876).get(), (x873).get()); + Box x879 = new Box((int)0); + Box x880 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x879, x880, (x878).get(), (x874).get(), (x871).get()); + Box x881 = new Box((int)0); + Box x882 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x881, x882, (x880).get(), (x872).get(), (x869).get()); + Box x883 = new Box((int)0); + Box x884 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x883, x884, (x882).get(), (x870).get(), (x867).get()); + Box x885 = new Box((int)0); + Box x886 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x885, x886, (x884).get(), (x868).get(), (x865).get()); + Box x887 = new Box((int)0); + Box x888 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x887, x888, (x886).get(), (x866).get(), (x863).get()); + Box x889 = new Box((int)0); + Box x890 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x889, x890, (x888).get(), (x864).get(), (x861).get()); + Box x891 = new Box((int)0); + Box x892 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x891, x892, (x890).get(), (x862).get(), (x859).get()); + Box x893 = new Box((int)0); + Box x894 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x893, x894, (x892).get(), (x860).get(), (x857).get()); + Box x895 = new Box((int)0); + Box x896 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x895, x896, (x894).get(), (x858).get(), (x855).get()); + Box x897 = new Box((int)0); + Box x898 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x897, x898, (x896).get(), (x856).get(), (x853).get()); + Box x899 = new Box((int)0); + Box x900 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x899, x900, 0x0, (x829).get(), (x875).get()); + Box x901 = new Box((int)0); + Box x902 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x901, x902, (x900).get(), (x831).get(), (x877).get()); + Box x903 = new Box((int)0); + Box x904 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x903, x904, (x902).get(), (x833).get(), (x879).get()); + Box x905 = new Box((int)0); + Box x906 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x905, x906, (x904).get(), (x835).get(), (x881).get()); + Box x907 = new Box((int)0); + Box x908 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x907, x908, (x906).get(), (x837).get(), (x883).get()); + Box x909 = new Box((int)0); + Box x910 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x909, x910, (x908).get(), (x839).get(), (x885).get()); + Box x911 = new Box((int)0); + Box x912 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x911, x912, (x910).get(), (x841).get(), (x887).get()); + Box x913 = new Box((int)0); + Box x914 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x913, x914, (x912).get(), (x843).get(), (x889).get()); + Box x915 = new Box((int)0); + Box x916 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x915, x916, (x914).get(), (x845).get(), (x891).get()); + Box x917 = new Box((int)0); + Box x918 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x917, x918, (x916).get(), (x847).get(), (x893).get()); + Box x919 = new Box((int)0); + Box x920 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x919, x920, (x918).get(), (x849).get(), (x895).get()); + Box x921 = new Box((int)0); + Box x922 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x921, x922, (x920).get(), (x851).get(), (x897).get()); + Box x923 = new Box((int)0); + Box x924 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x923, x924, (x899).get(), 0xe88fdc45); + Box x925 = new Box((int)0); + Box x926 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x925, x926, (x923).get(), 0xffffffff); + Box x927 = new Box((int)0); + Box x928 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x927, x928, (x923).get(), 0xffffffff); + Box x929 = new Box((int)0); + Box x930 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x929, x930, (x923).get(), 0xffffffff); + Box x931 = new Box((int)0); + Box x932 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x931, x932, (x923).get(), 0xffffffff); + Box x933 = new Box((int)0); + Box x934 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x933, x934, (x923).get(), 0xffffffff); + Box x935 = new Box((int)0); + Box x936 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x935, x936, (x923).get(), 0xffffffff); + Box x937 = new Box((int)0); + Box x938 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x937, x938, (x923).get(), 0xc7634d81); + Box x939 = new Box((int)0); + Box x940 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x939, x940, (x923).get(), 0xf4372ddf); + Box x941 = new Box((int)0); + Box x942 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x941, x942, (x923).get(), 0x581a0db2); + Box x943 = new Box((int)0); + Box x944 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x943, x944, (x923).get(), 0x48b0a77a); + Box x945 = new Box((int)0); + Box x946 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x945, x946, (x923).get(), 0xecec196a); + Box x947 = new Box((int)0); + Box x948 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x947, x948, (x923).get(), 0xccc52973); + Box x949 = new Box((int)0); + Box x950 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x949, x950, 0x0, (x948).get(), (x945).get()); + Box x951 = new Box((int)0); + Box x952 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x951, x952, (x950).get(), (x946).get(), (x943).get()); + Box x953 = new Box((int)0); + Box x954 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x953, x954, (x952).get(), (x944).get(), (x941).get()); + Box x955 = new Box((int)0); + Box x956 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x955, x956, (x954).get(), (x942).get(), (x939).get()); + Box x957 = new Box((int)0); + Box x958 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x957, x958, (x956).get(), (x940).get(), (x937).get()); + Box x959 = new Box((int)0); + Box x960 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x959, x960, (x958).get(), (x938).get(), (x935).get()); + Box x961 = new Box((int)0); + Box x962 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x961, x962, (x960).get(), (x936).get(), (x933).get()); + Box x963 = new Box((int)0); + Box x964 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x963, x964, (x962).get(), (x934).get(), (x931).get()); + Box x965 = new Box((int)0); + Box x966 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x965, x966, (x964).get(), (x932).get(), (x929).get()); + Box x967 = new Box((int)0); + Box x968 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x967, x968, (x966).get(), (x930).get(), (x927).get()); + Box x969 = new Box((int)0); + Box x970 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x969, x970, (x968).get(), (x928).get(), (x925).get()); + Box x971 = new Box((int)0); + Box x972 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x971, x972, 0x0, (x899).get(), (x947).get()); + Box x973 = new Box((int)0); + Box x974 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x973, x974, (x972).get(), (x901).get(), (x949).get()); + Box x975 = new Box((int)0); + Box x976 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x975, x976, (x974).get(), (x903).get(), (x951).get()); + Box x977 = new Box((int)0); + Box x978 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x977, x978, (x976).get(), (x905).get(), (x953).get()); + Box x979 = new Box((int)0); + Box x980 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x979, x980, (x978).get(), (x907).get(), (x955).get()); + Box x981 = new Box((int)0); + Box x982 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x981, x982, (x980).get(), (x909).get(), (x957).get()); + Box x983 = new Box((int)0); + Box x984 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x983, x984, (x982).get(), (x911).get(), (x959).get()); + Box x985 = new Box((int)0); + Box x986 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x985, x986, (x984).get(), (x913).get(), (x961).get()); + Box x987 = new Box((int)0); + Box x988 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x987, x988, (x986).get(), (x915).get(), (x963).get()); + Box x989 = new Box((int)0); + Box x990 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x989, x990, (x988).get(), (x917).get(), (x965).get()); + Box x991 = new Box((int)0); + Box x992 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x991, x992, (x990).get(), (x919).get(), (x967).get()); + Box x993 = new Box((int)0); + Box x994 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x993, x994, (x992).get(), (x921).get(), (x969).get()); + Box x995 = new Box((int)0); + Box x996 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x995, x996, (x994).get(), (((x922).get() + (x852).get()) + ((x898).get() + (x854).get())), ((x970).get() + (x926).get())); + Box x997 = new Box((int)0); + Box x998 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x997, x998, x7, 0xc84ee01); + Box x999 = new Box((int)0); + Box x1000 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x999, x1000, x7, 0x2b39bf21); + Box x1001 = new Box((int)0); + Box x1002 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1001, x1002, x7, 0x3fb05b7a); + Box x1003 = new Box((int)0); + Box x1004 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1003, x1004, x7, 0x28266895); + Box x1005 = new Box((int)0); + Box x1006 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1005, x1006, x7, 0xd40d4917); + Box x1007 = new Box((int)0); + Box x1008 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1007, x1008, x7, 0x4aab1cc5); + Box x1009 = new Box((int)0); + Box x1010 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1009, x1010, x7, 0xbc3e483a); + Box x1011 = new Box((int)0); + Box x1012 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1011, x1012, x7, 0xfcb82947); + Box x1013 = new Box((int)0); + Box x1014 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1013, x1014, x7, 0xff3d81e5); + Box x1015 = new Box((int)0); + Box x1016 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1015, x1016, x7, 0xdf1aa419); + Box x1017 = new Box((int)0); + Box x1018 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1017, x1018, x7, 0x2d319b24); + Box x1019 = new Box((int)0); + Box x1020 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1019, x1020, x7, 0x19b409a9); + Box x1021 = new Box((int)0); + Box x1022 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1021, x1022, 0x0, (x1020).get(), (x1017).get()); + Box x1023 = new Box((int)0); + Box x1024 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1023, x1024, (x1022).get(), (x1018).get(), (x1015).get()); + Box x1025 = new Box((int)0); + Box x1026 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1025, x1026, (x1024).get(), (x1016).get(), (x1013).get()); + Box x1027 = new Box((int)0); + Box x1028 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1027, x1028, (x1026).get(), (x1014).get(), (x1011).get()); + Box x1029 = new Box((int)0); + Box x1030 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1029, x1030, (x1028).get(), (x1012).get(), (x1009).get()); + Box x1031 = new Box((int)0); + Box x1032 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1031, x1032, (x1030).get(), (x1010).get(), (x1007).get()); + Box x1033 = new Box((int)0); + Box x1034 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1033, x1034, (x1032).get(), (x1008).get(), (x1005).get()); + Box x1035 = new Box((int)0); + Box x1036 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1035, x1036, (x1034).get(), (x1006).get(), (x1003).get()); + Box x1037 = new Box((int)0); + Box x1038 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1037, x1038, (x1036).get(), (x1004).get(), (x1001).get()); + Box x1039 = new Box((int)0); + Box x1040 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1039, x1040, (x1038).get(), (x1002).get(), (x999).get()); + Box x1041 = new Box((int)0); + Box x1042 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1041, x1042, (x1040).get(), (x1000).get(), (x997).get()); + Box x1043 = new Box((int)0); + Box x1044 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1043, x1044, 0x0, (x973).get(), (x1019).get()); + Box x1045 = new Box((int)0); + Box x1046 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1045, x1046, (x1044).get(), (x975).get(), (x1021).get()); + Box x1047 = new Box((int)0); + Box x1048 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1047, x1048, (x1046).get(), (x977).get(), (x1023).get()); + Box x1049 = new Box((int)0); + Box x1050 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1049, x1050, (x1048).get(), (x979).get(), (x1025).get()); + Box x1051 = new Box((int)0); + Box x1052 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1051, x1052, (x1050).get(), (x981).get(), (x1027).get()); + Box x1053 = new Box((int)0); + Box x1054 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1053, x1054, (x1052).get(), (x983).get(), (x1029).get()); + Box x1055 = new Box((int)0); + Box x1056 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1055, x1056, (x1054).get(), (x985).get(), (x1031).get()); + Box x1057 = new Box((int)0); + Box x1058 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1057, x1058, (x1056).get(), (x987).get(), (x1033).get()); + Box x1059 = new Box((int)0); + Box x1060 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1059, x1060, (x1058).get(), (x989).get(), (x1035).get()); + Box x1061 = new Box((int)0); + Box x1062 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1061, x1062, (x1060).get(), (x991).get(), (x1037).get()); + Box x1063 = new Box((int)0); + Box x1064 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1063, x1064, (x1062).get(), (x993).get(), (x1039).get()); + Box x1065 = new Box((int)0); + Box x1066 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1065, x1066, (x1064).get(), (x995).get(), (x1041).get()); + Box x1067 = new Box((int)0); + Box x1068 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1067, x1068, (x1043).get(), 0xe88fdc45); + Box x1069 = new Box((int)0); + Box x1070 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1069, x1070, (x1067).get(), 0xffffffff); + Box x1071 = new Box((int)0); + Box x1072 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1071, x1072, (x1067).get(), 0xffffffff); + Box x1073 = new Box((int)0); + Box x1074 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1073, x1074, (x1067).get(), 0xffffffff); + Box x1075 = new Box((int)0); + Box x1076 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1075, x1076, (x1067).get(), 0xffffffff); + Box x1077 = new Box((int)0); + Box x1078 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1077, x1078, (x1067).get(), 0xffffffff); + Box x1079 = new Box((int)0); + Box x1080 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1079, x1080, (x1067).get(), 0xffffffff); + Box x1081 = new Box((int)0); + Box x1082 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1081, x1082, (x1067).get(), 0xc7634d81); + Box x1083 = new Box((int)0); + Box x1084 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1083, x1084, (x1067).get(), 0xf4372ddf); + Box x1085 = new Box((int)0); + Box x1086 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1085, x1086, (x1067).get(), 0x581a0db2); + Box x1087 = new Box((int)0); + Box x1088 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1087, x1088, (x1067).get(), 0x48b0a77a); + Box x1089 = new Box((int)0); + Box x1090 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1089, x1090, (x1067).get(), 0xecec196a); + Box x1091 = new Box((int)0); + Box x1092 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1091, x1092, (x1067).get(), 0xccc52973); + Box x1093 = new Box((int)0); + Box x1094 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1093, x1094, 0x0, (x1092).get(), (x1089).get()); + Box x1095 = new Box((int)0); + Box x1096 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1095, x1096, (x1094).get(), (x1090).get(), (x1087).get()); + Box x1097 = new Box((int)0); + Box x1098 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1097, x1098, (x1096).get(), (x1088).get(), (x1085).get()); + Box x1099 = new Box((int)0); + Box x1100 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1099, x1100, (x1098).get(), (x1086).get(), (x1083).get()); + Box x1101 = new Box((int)0); + Box x1102 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1101, x1102, (x1100).get(), (x1084).get(), (x1081).get()); + Box x1103 = new Box((int)0); + Box x1104 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1103, x1104, (x1102).get(), (x1082).get(), (x1079).get()); + Box x1105 = new Box((int)0); + Box x1106 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1105, x1106, (x1104).get(), (x1080).get(), (x1077).get()); + Box x1107 = new Box((int)0); + Box x1108 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1107, x1108, (x1106).get(), (x1078).get(), (x1075).get()); + Box x1109 = new Box((int)0); + Box x1110 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1109, x1110, (x1108).get(), (x1076).get(), (x1073).get()); + Box x1111 = new Box((int)0); + Box x1112 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1111, x1112, (x1110).get(), (x1074).get(), (x1071).get()); + Box x1113 = new Box((int)0); + Box x1114 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1113, x1114, (x1112).get(), (x1072).get(), (x1069).get()); + Box x1115 = new Box((int)0); + Box x1116 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1115, x1116, 0x0, (x1043).get(), (x1091).get()); + Box x1117 = new Box((int)0); + Box x1118 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1117, x1118, (x1116).get(), (x1045).get(), (x1093).get()); + Box x1119 = new Box((int)0); + Box x1120 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1119, x1120, (x1118).get(), (x1047).get(), (x1095).get()); + Box x1121 = new Box((int)0); + Box x1122 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1121, x1122, (x1120).get(), (x1049).get(), (x1097).get()); + Box x1123 = new Box((int)0); + Box x1124 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1123, x1124, (x1122).get(), (x1051).get(), (x1099).get()); + Box x1125 = new Box((int)0); + Box x1126 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1125, x1126, (x1124).get(), (x1053).get(), (x1101).get()); + Box x1127 = new Box((int)0); + Box x1128 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1127, x1128, (x1126).get(), (x1055).get(), (x1103).get()); + Box x1129 = new Box((int)0); + Box x1130 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1129, x1130, (x1128).get(), (x1057).get(), (x1105).get()); + Box x1131 = new Box((int)0); + Box x1132 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1131, x1132, (x1130).get(), (x1059).get(), (x1107).get()); + Box x1133 = new Box((int)0); + Box x1134 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1133, x1134, (x1132).get(), (x1061).get(), (x1109).get()); + Box x1135 = new Box((int)0); + Box x1136 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1135, x1136, (x1134).get(), (x1063).get(), (x1111).get()); + Box x1137 = new Box((int)0); + Box x1138 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1137, x1138, (x1136).get(), (x1065).get(), (x1113).get()); + Box x1139 = new Box((int)0); + Box x1140 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1139, x1140, (x1138).get(), (((x1066).get() + (x996).get()) + ((x1042).get() + (x998).get())), ((x1114).get() + (x1070).get())); + Box x1141 = new Box((int)0); + Box x1142 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1141, x1142, x8, 0xc84ee01); + Box x1143 = new Box((int)0); + Box x1144 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1143, x1144, x8, 0x2b39bf21); + Box x1145 = new Box((int)0); + Box x1146 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1145, x1146, x8, 0x3fb05b7a); + Box x1147 = new Box((int)0); + Box x1148 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1147, x1148, x8, 0x28266895); + Box x1149 = new Box((int)0); + Box x1150 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1149, x1150, x8, 0xd40d4917); + Box x1151 = new Box((int)0); + Box x1152 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1151, x1152, x8, 0x4aab1cc5); + Box x1153 = new Box((int)0); + Box x1154 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1153, x1154, x8, 0xbc3e483a); + Box x1155 = new Box((int)0); + Box x1156 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1155, x1156, x8, 0xfcb82947); + Box x1157 = new Box((int)0); + Box x1158 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1157, x1158, x8, 0xff3d81e5); + Box x1159 = new Box((int)0); + Box x1160 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1159, x1160, x8, 0xdf1aa419); + Box x1161 = new Box((int)0); + Box x1162 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1161, x1162, x8, 0x2d319b24); + Box x1163 = new Box((int)0); + Box x1164 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1163, x1164, x8, 0x19b409a9); + Box x1165 = new Box((int)0); + Box x1166 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1165, x1166, 0x0, (x1164).get(), (x1161).get()); + Box x1167 = new Box((int)0); + Box x1168 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1167, x1168, (x1166).get(), (x1162).get(), (x1159).get()); + Box x1169 = new Box((int)0); + Box x1170 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1169, x1170, (x1168).get(), (x1160).get(), (x1157).get()); + Box x1171 = new Box((int)0); + Box x1172 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1171, x1172, (x1170).get(), (x1158).get(), (x1155).get()); + Box x1173 = new Box((int)0); + Box x1174 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1173, x1174, (x1172).get(), (x1156).get(), (x1153).get()); + Box x1175 = new Box((int)0); + Box x1176 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1175, x1176, (x1174).get(), (x1154).get(), (x1151).get()); + Box x1177 = new Box((int)0); + Box x1178 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1177, x1178, (x1176).get(), (x1152).get(), (x1149).get()); + Box x1179 = new Box((int)0); + Box x1180 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1179, x1180, (x1178).get(), (x1150).get(), (x1147).get()); + Box x1181 = new Box((int)0); + Box x1182 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1181, x1182, (x1180).get(), (x1148).get(), (x1145).get()); + Box x1183 = new Box((int)0); + Box x1184 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1183, x1184, (x1182).get(), (x1146).get(), (x1143).get()); + Box x1185 = new Box((int)0); + Box x1186 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1185, x1186, (x1184).get(), (x1144).get(), (x1141).get()); + Box x1187 = new Box((int)0); + Box x1188 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1187, x1188, 0x0, (x1117).get(), (x1163).get()); + Box x1189 = new Box((int)0); + Box x1190 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1189, x1190, (x1188).get(), (x1119).get(), (x1165).get()); + Box x1191 = new Box((int)0); + Box x1192 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1191, x1192, (x1190).get(), (x1121).get(), (x1167).get()); + Box x1193 = new Box((int)0); + Box x1194 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1193, x1194, (x1192).get(), (x1123).get(), (x1169).get()); + Box x1195 = new Box((int)0); + Box x1196 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1195, x1196, (x1194).get(), (x1125).get(), (x1171).get()); + Box x1197 = new Box((int)0); + Box x1198 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1197, x1198, (x1196).get(), (x1127).get(), (x1173).get()); + Box x1199 = new Box((int)0); + Box x1200 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1199, x1200, (x1198).get(), (x1129).get(), (x1175).get()); + Box x1201 = new Box((int)0); + Box x1202 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1201, x1202, (x1200).get(), (x1131).get(), (x1177).get()); + Box x1203 = new Box((int)0); + Box x1204 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1203, x1204, (x1202).get(), (x1133).get(), (x1179).get()); + Box x1205 = new Box((int)0); + Box x1206 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1205, x1206, (x1204).get(), (x1135).get(), (x1181).get()); + Box x1207 = new Box((int)0); + Box x1208 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1207, x1208, (x1206).get(), (x1137).get(), (x1183).get()); + Box x1209 = new Box((int)0); + Box x1210 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1209, x1210, (x1208).get(), (x1139).get(), (x1185).get()); + Box x1211 = new Box((int)0); + Box x1212 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1211, x1212, (x1187).get(), 0xe88fdc45); + Box x1213 = new Box((int)0); + Box x1214 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1213, x1214, (x1211).get(), 0xffffffff); + Box x1215 = new Box((int)0); + Box x1216 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1215, x1216, (x1211).get(), 0xffffffff); + Box x1217 = new Box((int)0); + Box x1218 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1217, x1218, (x1211).get(), 0xffffffff); + Box x1219 = new Box((int)0); + Box x1220 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1219, x1220, (x1211).get(), 0xffffffff); + Box x1221 = new Box((int)0); + Box x1222 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1221, x1222, (x1211).get(), 0xffffffff); + Box x1223 = new Box((int)0); + Box x1224 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1223, x1224, (x1211).get(), 0xffffffff); + Box x1225 = new Box((int)0); + Box x1226 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1225, x1226, (x1211).get(), 0xc7634d81); + Box x1227 = new Box((int)0); + Box x1228 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1227, x1228, (x1211).get(), 0xf4372ddf); + Box x1229 = new Box((int)0); + Box x1230 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1229, x1230, (x1211).get(), 0x581a0db2); + Box x1231 = new Box((int)0); + Box x1232 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1231, x1232, (x1211).get(), 0x48b0a77a); + Box x1233 = new Box((int)0); + Box x1234 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1233, x1234, (x1211).get(), 0xecec196a); + Box x1235 = new Box((int)0); + Box x1236 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1235, x1236, (x1211).get(), 0xccc52973); + Box x1237 = new Box((int)0); + Box x1238 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1237, x1238, 0x0, (x1236).get(), (x1233).get()); + Box x1239 = new Box((int)0); + Box x1240 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1239, x1240, (x1238).get(), (x1234).get(), (x1231).get()); + Box x1241 = new Box((int)0); + Box x1242 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1241, x1242, (x1240).get(), (x1232).get(), (x1229).get()); + Box x1243 = new Box((int)0); + Box x1244 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1243, x1244, (x1242).get(), (x1230).get(), (x1227).get()); + Box x1245 = new Box((int)0); + Box x1246 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1245, x1246, (x1244).get(), (x1228).get(), (x1225).get()); + Box x1247 = new Box((int)0); + Box x1248 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1247, x1248, (x1246).get(), (x1226).get(), (x1223).get()); + Box x1249 = new Box((int)0); + Box x1250 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1249, x1250, (x1248).get(), (x1224).get(), (x1221).get()); + Box x1251 = new Box((int)0); + Box x1252 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1251, x1252, (x1250).get(), (x1222).get(), (x1219).get()); + Box x1253 = new Box((int)0); + Box x1254 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1253, x1254, (x1252).get(), (x1220).get(), (x1217).get()); + Box x1255 = new Box((int)0); + Box x1256 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1255, x1256, (x1254).get(), (x1218).get(), (x1215).get()); + Box x1257 = new Box((int)0); + Box x1258 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1257, x1258, (x1256).get(), (x1216).get(), (x1213).get()); + Box x1259 = new Box((int)0); + Box x1260 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1259, x1260, 0x0, (x1187).get(), (x1235).get()); + Box x1261 = new Box((int)0); + Box x1262 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1261, x1262, (x1260).get(), (x1189).get(), (x1237).get()); + Box x1263 = new Box((int)0); + Box x1264 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1263, x1264, (x1262).get(), (x1191).get(), (x1239).get()); + Box x1265 = new Box((int)0); + Box x1266 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1265, x1266, (x1264).get(), (x1193).get(), (x1241).get()); + Box x1267 = new Box((int)0); + Box x1268 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1267, x1268, (x1266).get(), (x1195).get(), (x1243).get()); + Box x1269 = new Box((int)0); + Box x1270 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1269, x1270, (x1268).get(), (x1197).get(), (x1245).get()); + Box x1271 = new Box((int)0); + Box x1272 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1271, x1272, (x1270).get(), (x1199).get(), (x1247).get()); + Box x1273 = new Box((int)0); + Box x1274 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1273, x1274, (x1272).get(), (x1201).get(), (x1249).get()); + Box x1275 = new Box((int)0); + Box x1276 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1275, x1276, (x1274).get(), (x1203).get(), (x1251).get()); + Box x1277 = new Box((int)0); + Box x1278 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1277, x1278, (x1276).get(), (x1205).get(), (x1253).get()); + Box x1279 = new Box((int)0); + Box x1280 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1279, x1280, (x1278).get(), (x1207).get(), (x1255).get()); + Box x1281 = new Box((int)0); + Box x1282 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1281, x1282, (x1280).get(), (x1209).get(), (x1257).get()); + Box x1283 = new Box((int)0); + Box x1284 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1283, x1284, (x1282).get(), (((x1210).get() + (x1140).get()) + ((x1186).get() + (x1142).get())), ((x1258).get() + (x1214).get())); + Box x1285 = new Box((int)0); + Box x1286 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1285, x1286, x9, 0xc84ee01); + Box x1287 = new Box((int)0); + Box x1288 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1287, x1288, x9, 0x2b39bf21); + Box x1289 = new Box((int)0); + Box x1290 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1289, x1290, x9, 0x3fb05b7a); + Box x1291 = new Box((int)0); + Box x1292 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1291, x1292, x9, 0x28266895); + Box x1293 = new Box((int)0); + Box x1294 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1293, x1294, x9, 0xd40d4917); + Box x1295 = new Box((int)0); + Box x1296 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1295, x1296, x9, 0x4aab1cc5); + Box x1297 = new Box((int)0); + Box x1298 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1297, x1298, x9, 0xbc3e483a); + Box x1299 = new Box((int)0); + Box x1300 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1299, x1300, x9, 0xfcb82947); + Box x1301 = new Box((int)0); + Box x1302 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1301, x1302, x9, 0xff3d81e5); + Box x1303 = new Box((int)0); + Box x1304 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1303, x1304, x9, 0xdf1aa419); + Box x1305 = new Box((int)0); + Box x1306 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1305, x1306, x9, 0x2d319b24); + Box x1307 = new Box((int)0); + Box x1308 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1307, x1308, x9, 0x19b409a9); + Box x1309 = new Box((int)0); + Box x1310 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1309, x1310, 0x0, (x1308).get(), (x1305).get()); + Box x1311 = new Box((int)0); + Box x1312 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1311, x1312, (x1310).get(), (x1306).get(), (x1303).get()); + Box x1313 = new Box((int)0); + Box x1314 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1313, x1314, (x1312).get(), (x1304).get(), (x1301).get()); + Box x1315 = new Box((int)0); + Box x1316 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1315, x1316, (x1314).get(), (x1302).get(), (x1299).get()); + Box x1317 = new Box((int)0); + Box x1318 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1317, x1318, (x1316).get(), (x1300).get(), (x1297).get()); + Box x1319 = new Box((int)0); + Box x1320 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1319, x1320, (x1318).get(), (x1298).get(), (x1295).get()); + Box x1321 = new Box((int)0); + Box x1322 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1321, x1322, (x1320).get(), (x1296).get(), (x1293).get()); + Box x1323 = new Box((int)0); + Box x1324 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1323, x1324, (x1322).get(), (x1294).get(), (x1291).get()); + Box x1325 = new Box((int)0); + Box x1326 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1325, x1326, (x1324).get(), (x1292).get(), (x1289).get()); + Box x1327 = new Box((int)0); + Box x1328 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1327, x1328, (x1326).get(), (x1290).get(), (x1287).get()); + Box x1329 = new Box((int)0); + Box x1330 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1329, x1330, (x1328).get(), (x1288).get(), (x1285).get()); + Box x1331 = new Box((int)0); + Box x1332 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1331, x1332, 0x0, (x1261).get(), (x1307).get()); + Box x1333 = new Box((int)0); + Box x1334 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1333, x1334, (x1332).get(), (x1263).get(), (x1309).get()); + Box x1335 = new Box((int)0); + Box x1336 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1335, x1336, (x1334).get(), (x1265).get(), (x1311).get()); + Box x1337 = new Box((int)0); + Box x1338 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1337, x1338, (x1336).get(), (x1267).get(), (x1313).get()); + Box x1339 = new Box((int)0); + Box x1340 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1339, x1340, (x1338).get(), (x1269).get(), (x1315).get()); + Box x1341 = new Box((int)0); + Box x1342 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1341, x1342, (x1340).get(), (x1271).get(), (x1317).get()); + Box x1343 = new Box((int)0); + Box x1344 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1343, x1344, (x1342).get(), (x1273).get(), (x1319).get()); + Box x1345 = new Box((int)0); + Box x1346 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1345, x1346, (x1344).get(), (x1275).get(), (x1321).get()); + Box x1347 = new Box((int)0); + Box x1348 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1347, x1348, (x1346).get(), (x1277).get(), (x1323).get()); + Box x1349 = new Box((int)0); + Box x1350 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1349, x1350, (x1348).get(), (x1279).get(), (x1325).get()); + Box x1351 = new Box((int)0); + Box x1352 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1351, x1352, (x1350).get(), (x1281).get(), (x1327).get()); + Box x1353 = new Box((int)0); + Box x1354 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1353, x1354, (x1352).get(), (x1283).get(), (x1329).get()); + Box x1355 = new Box((int)0); + Box x1356 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1355, x1356, (x1331).get(), 0xe88fdc45); + Box x1357 = new Box((int)0); + Box x1358 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1357, x1358, (x1355).get(), 0xffffffff); + Box x1359 = new Box((int)0); + Box x1360 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1359, x1360, (x1355).get(), 0xffffffff); + Box x1361 = new Box((int)0); + Box x1362 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1361, x1362, (x1355).get(), 0xffffffff); + Box x1363 = new Box((int)0); + Box x1364 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1363, x1364, (x1355).get(), 0xffffffff); + Box x1365 = new Box((int)0); + Box x1366 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1365, x1366, (x1355).get(), 0xffffffff); + Box x1367 = new Box((int)0); + Box x1368 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1367, x1368, (x1355).get(), 0xffffffff); + Box x1369 = new Box((int)0); + Box x1370 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1369, x1370, (x1355).get(), 0xc7634d81); + Box x1371 = new Box((int)0); + Box x1372 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1371, x1372, (x1355).get(), 0xf4372ddf); + Box x1373 = new Box((int)0); + Box x1374 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1373, x1374, (x1355).get(), 0x581a0db2); + Box x1375 = new Box((int)0); + Box x1376 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1375, x1376, (x1355).get(), 0x48b0a77a); + Box x1377 = new Box((int)0); + Box x1378 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1377, x1378, (x1355).get(), 0xecec196a); + Box x1379 = new Box((int)0); + Box x1380 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1379, x1380, (x1355).get(), 0xccc52973); + Box x1381 = new Box((int)0); + Box x1382 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1381, x1382, 0x0, (x1380).get(), (x1377).get()); + Box x1383 = new Box((int)0); + Box x1384 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1383, x1384, (x1382).get(), (x1378).get(), (x1375).get()); + Box x1385 = new Box((int)0); + Box x1386 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1385, x1386, (x1384).get(), (x1376).get(), (x1373).get()); + Box x1387 = new Box((int)0); + Box x1388 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1387, x1388, (x1386).get(), (x1374).get(), (x1371).get()); + Box x1389 = new Box((int)0); + Box x1390 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1389, x1390, (x1388).get(), (x1372).get(), (x1369).get()); + Box x1391 = new Box((int)0); + Box x1392 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1391, x1392, (x1390).get(), (x1370).get(), (x1367).get()); + Box x1393 = new Box((int)0); + Box x1394 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1393, x1394, (x1392).get(), (x1368).get(), (x1365).get()); + Box x1395 = new Box((int)0); + Box x1396 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1395, x1396, (x1394).get(), (x1366).get(), (x1363).get()); + Box x1397 = new Box((int)0); + Box x1398 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1397, x1398, (x1396).get(), (x1364).get(), (x1361).get()); + Box x1399 = new Box((int)0); + Box x1400 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1399, x1400, (x1398).get(), (x1362).get(), (x1359).get()); + Box x1401 = new Box((int)0); + Box x1402 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1401, x1402, (x1400).get(), (x1360).get(), (x1357).get()); + Box x1403 = new Box((int)0); + Box x1404 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1403, x1404, 0x0, (x1331).get(), (x1379).get()); + Box x1405 = new Box((int)0); + Box x1406 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1405, x1406, (x1404).get(), (x1333).get(), (x1381).get()); + Box x1407 = new Box((int)0); + Box x1408 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1407, x1408, (x1406).get(), (x1335).get(), (x1383).get()); + Box x1409 = new Box((int)0); + Box x1410 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1409, x1410, (x1408).get(), (x1337).get(), (x1385).get()); + Box x1411 = new Box((int)0); + Box x1412 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1411, x1412, (x1410).get(), (x1339).get(), (x1387).get()); + Box x1413 = new Box((int)0); + Box x1414 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1413, x1414, (x1412).get(), (x1341).get(), (x1389).get()); + Box x1415 = new Box((int)0); + Box x1416 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1415, x1416, (x1414).get(), (x1343).get(), (x1391).get()); + Box x1417 = new Box((int)0); + Box x1418 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1417, x1418, (x1416).get(), (x1345).get(), (x1393).get()); + Box x1419 = new Box((int)0); + Box x1420 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1419, x1420, (x1418).get(), (x1347).get(), (x1395).get()); + Box x1421 = new Box((int)0); + Box x1422 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1421, x1422, (x1420).get(), (x1349).get(), (x1397).get()); + Box x1423 = new Box((int)0); + Box x1424 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1423, x1424, (x1422).get(), (x1351).get(), (x1399).get()); + Box x1425 = new Box((int)0); + Box x1426 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1425, x1426, (x1424).get(), (x1353).get(), (x1401).get()); + Box x1427 = new Box((int)0); + Box x1428 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1427, x1428, (x1426).get(), (((x1354).get() + (x1284).get()) + ((x1330).get() + (x1286).get())), ((x1402).get() + (x1358).get())); + Box x1429 = new Box((int)0); + Box x1430 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1429, x1430, x10, 0xc84ee01); + Box x1431 = new Box((int)0); + Box x1432 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1431, x1432, x10, 0x2b39bf21); + Box x1433 = new Box((int)0); + Box x1434 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1433, x1434, x10, 0x3fb05b7a); + Box x1435 = new Box((int)0); + Box x1436 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1435, x1436, x10, 0x28266895); + Box x1437 = new Box((int)0); + Box x1438 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1437, x1438, x10, 0xd40d4917); + Box x1439 = new Box((int)0); + Box x1440 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1439, x1440, x10, 0x4aab1cc5); + Box x1441 = new Box((int)0); + Box x1442 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1441, x1442, x10, 0xbc3e483a); + Box x1443 = new Box((int)0); + Box x1444 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1443, x1444, x10, 0xfcb82947); + Box x1445 = new Box((int)0); + Box x1446 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1445, x1446, x10, 0xff3d81e5); + Box x1447 = new Box((int)0); + Box x1448 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1447, x1448, x10, 0xdf1aa419); + Box x1449 = new Box((int)0); + Box x1450 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1449, x1450, x10, 0x2d319b24); + Box x1451 = new Box((int)0); + Box x1452 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1451, x1452, x10, 0x19b409a9); + Box x1453 = new Box((int)0); + Box x1454 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1453, x1454, 0x0, (x1452).get(), (x1449).get()); + Box x1455 = new Box((int)0); + Box x1456 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1455, x1456, (x1454).get(), (x1450).get(), (x1447).get()); + Box x1457 = new Box((int)0); + Box x1458 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1457, x1458, (x1456).get(), (x1448).get(), (x1445).get()); + Box x1459 = new Box((int)0); + Box x1460 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1459, x1460, (x1458).get(), (x1446).get(), (x1443).get()); + Box x1461 = new Box((int)0); + Box x1462 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1461, x1462, (x1460).get(), (x1444).get(), (x1441).get()); + Box x1463 = new Box((int)0); + Box x1464 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1463, x1464, (x1462).get(), (x1442).get(), (x1439).get()); + Box x1465 = new Box((int)0); + Box x1466 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1465, x1466, (x1464).get(), (x1440).get(), (x1437).get()); + Box x1467 = new Box((int)0); + Box x1468 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1467, x1468, (x1466).get(), (x1438).get(), (x1435).get()); + Box x1469 = new Box((int)0); + Box x1470 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1469, x1470, (x1468).get(), (x1436).get(), (x1433).get()); + Box x1471 = new Box((int)0); + Box x1472 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1471, x1472, (x1470).get(), (x1434).get(), (x1431).get()); + Box x1473 = new Box((int)0); + Box x1474 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1473, x1474, (x1472).get(), (x1432).get(), (x1429).get()); + Box x1475 = new Box((int)0); + Box x1476 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1475, x1476, 0x0, (x1405).get(), (x1451).get()); + Box x1477 = new Box((int)0); + Box x1478 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1477, x1478, (x1476).get(), (x1407).get(), (x1453).get()); + Box x1479 = new Box((int)0); + Box x1480 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1479, x1480, (x1478).get(), (x1409).get(), (x1455).get()); + Box x1481 = new Box((int)0); + Box x1482 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1481, x1482, (x1480).get(), (x1411).get(), (x1457).get()); + Box x1483 = new Box((int)0); + Box x1484 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1483, x1484, (x1482).get(), (x1413).get(), (x1459).get()); + Box x1485 = new Box((int)0); + Box x1486 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1485, x1486, (x1484).get(), (x1415).get(), (x1461).get()); + Box x1487 = new Box((int)0); + Box x1488 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1487, x1488, (x1486).get(), (x1417).get(), (x1463).get()); + Box x1489 = new Box((int)0); + Box x1490 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1489, x1490, (x1488).get(), (x1419).get(), (x1465).get()); + Box x1491 = new Box((int)0); + Box x1492 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1491, x1492, (x1490).get(), (x1421).get(), (x1467).get()); + Box x1493 = new Box((int)0); + Box x1494 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1493, x1494, (x1492).get(), (x1423).get(), (x1469).get()); + Box x1495 = new Box((int)0); + Box x1496 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1495, x1496, (x1494).get(), (x1425).get(), (x1471).get()); + Box x1497 = new Box((int)0); + Box x1498 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1497, x1498, (x1496).get(), (x1427).get(), (x1473).get()); + Box x1499 = new Box((int)0); + Box x1500 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1499, x1500, (x1475).get(), 0xe88fdc45); + Box x1501 = new Box((int)0); + Box x1502 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1501, x1502, (x1499).get(), 0xffffffff); + Box x1503 = new Box((int)0); + Box x1504 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1503, x1504, (x1499).get(), 0xffffffff); + Box x1505 = new Box((int)0); + Box x1506 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1505, x1506, (x1499).get(), 0xffffffff); + Box x1507 = new Box((int)0); + Box x1508 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1507, x1508, (x1499).get(), 0xffffffff); + Box x1509 = new Box((int)0); + Box x1510 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1509, x1510, (x1499).get(), 0xffffffff); + Box x1511 = new Box((int)0); + Box x1512 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1511, x1512, (x1499).get(), 0xffffffff); + Box x1513 = new Box((int)0); + Box x1514 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1513, x1514, (x1499).get(), 0xc7634d81); + Box x1515 = new Box((int)0); + Box x1516 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1515, x1516, (x1499).get(), 0xf4372ddf); + Box x1517 = new Box((int)0); + Box x1518 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1517, x1518, (x1499).get(), 0x581a0db2); + Box x1519 = new Box((int)0); + Box x1520 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1519, x1520, (x1499).get(), 0x48b0a77a); + Box x1521 = new Box((int)0); + Box x1522 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1521, x1522, (x1499).get(), 0xecec196a); + Box x1523 = new Box((int)0); + Box x1524 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1523, x1524, (x1499).get(), 0xccc52973); + Box x1525 = new Box((int)0); + Box x1526 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1525, x1526, 0x0, (x1524).get(), (x1521).get()); + Box x1527 = new Box((int)0); + Box x1528 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1527, x1528, (x1526).get(), (x1522).get(), (x1519).get()); + Box x1529 = new Box((int)0); + Box x1530 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1529, x1530, (x1528).get(), (x1520).get(), (x1517).get()); + Box x1531 = new Box((int)0); + Box x1532 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1531, x1532, (x1530).get(), (x1518).get(), (x1515).get()); + Box x1533 = new Box((int)0); + Box x1534 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1533, x1534, (x1532).get(), (x1516).get(), (x1513).get()); + Box x1535 = new Box((int)0); + Box x1536 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1535, x1536, (x1534).get(), (x1514).get(), (x1511).get()); + Box x1537 = new Box((int)0); + Box x1538 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1537, x1538, (x1536).get(), (x1512).get(), (x1509).get()); + Box x1539 = new Box((int)0); + Box x1540 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1539, x1540, (x1538).get(), (x1510).get(), (x1507).get()); + Box x1541 = new Box((int)0); + Box x1542 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1541, x1542, (x1540).get(), (x1508).get(), (x1505).get()); + Box x1543 = new Box((int)0); + Box x1544 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1543, x1544, (x1542).get(), (x1506).get(), (x1503).get()); + Box x1545 = new Box((int)0); + Box x1546 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1545, x1546, (x1544).get(), (x1504).get(), (x1501).get()); + Box x1547 = new Box((int)0); + Box x1548 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1547, x1548, 0x0, (x1475).get(), (x1523).get()); + Box x1549 = new Box((int)0); + Box x1550 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1549, x1550, (x1548).get(), (x1477).get(), (x1525).get()); + Box x1551 = new Box((int)0); + Box x1552 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1551, x1552, (x1550).get(), (x1479).get(), (x1527).get()); + Box x1553 = new Box((int)0); + Box x1554 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1553, x1554, (x1552).get(), (x1481).get(), (x1529).get()); + Box x1555 = new Box((int)0); + Box x1556 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1555, x1556, (x1554).get(), (x1483).get(), (x1531).get()); + Box x1557 = new Box((int)0); + Box x1558 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1557, x1558, (x1556).get(), (x1485).get(), (x1533).get()); + Box x1559 = new Box((int)0); + Box x1560 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1559, x1560, (x1558).get(), (x1487).get(), (x1535).get()); + Box x1561 = new Box((int)0); + Box x1562 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1561, x1562, (x1560).get(), (x1489).get(), (x1537).get()); + Box x1563 = new Box((int)0); + Box x1564 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1563, x1564, (x1562).get(), (x1491).get(), (x1539).get()); + Box x1565 = new Box((int)0); + Box x1566 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1565, x1566, (x1564).get(), (x1493).get(), (x1541).get()); + Box x1567 = new Box((int)0); + Box x1568 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1567, x1568, (x1566).get(), (x1495).get(), (x1543).get()); + Box x1569 = new Box((int)0); + Box x1570 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1569, x1570, (x1568).get(), (x1497).get(), (x1545).get()); + Box x1571 = new Box((int)0); + Box x1572 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1571, x1572, (x1570).get(), (((x1498).get() + (x1428).get()) + ((x1474).get() + (x1430).get())), ((x1546).get() + (x1502).get())); + Box x1573 = new Box((int)0); + Box x1574 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1573, x1574, x11, 0xc84ee01); + Box x1575 = new Box((int)0); + Box x1576 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1575, x1576, x11, 0x2b39bf21); + Box x1577 = new Box((int)0); + Box x1578 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1577, x1578, x11, 0x3fb05b7a); + Box x1579 = new Box((int)0); + Box x1580 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1579, x1580, x11, 0x28266895); + Box x1581 = new Box((int)0); + Box x1582 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1581, x1582, x11, 0xd40d4917); + Box x1583 = new Box((int)0); + Box x1584 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1583, x1584, x11, 0x4aab1cc5); + Box x1585 = new Box((int)0); + Box x1586 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1585, x1586, x11, 0xbc3e483a); + Box x1587 = new Box((int)0); + Box x1588 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1587, x1588, x11, 0xfcb82947); + Box x1589 = new Box((int)0); + Box x1590 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1589, x1590, x11, 0xff3d81e5); + Box x1591 = new Box((int)0); + Box x1592 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1591, x1592, x11, 0xdf1aa419); + Box x1593 = new Box((int)0); + Box x1594 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1593, x1594, x11, 0x2d319b24); + Box x1595 = new Box((int)0); + Box x1596 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1595, x1596, x11, 0x19b409a9); + Box x1597 = new Box((int)0); + Box x1598 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1597, x1598, 0x0, (x1596).get(), (x1593).get()); + Box x1599 = new Box((int)0); + Box x1600 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1599, x1600, (x1598).get(), (x1594).get(), (x1591).get()); + Box x1601 = new Box((int)0); + Box x1602 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1601, x1602, (x1600).get(), (x1592).get(), (x1589).get()); + Box x1603 = new Box((int)0); + Box x1604 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1603, x1604, (x1602).get(), (x1590).get(), (x1587).get()); + Box x1605 = new Box((int)0); + Box x1606 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1605, x1606, (x1604).get(), (x1588).get(), (x1585).get()); + Box x1607 = new Box((int)0); + Box x1608 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1607, x1608, (x1606).get(), (x1586).get(), (x1583).get()); + Box x1609 = new Box((int)0); + Box x1610 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1609, x1610, (x1608).get(), (x1584).get(), (x1581).get()); + Box x1611 = new Box((int)0); + Box x1612 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1611, x1612, (x1610).get(), (x1582).get(), (x1579).get()); + Box x1613 = new Box((int)0); + Box x1614 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1613, x1614, (x1612).get(), (x1580).get(), (x1577).get()); + Box x1615 = new Box((int)0); + Box x1616 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1615, x1616, (x1614).get(), (x1578).get(), (x1575).get()); + Box x1617 = new Box((int)0); + Box x1618 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1617, x1618, (x1616).get(), (x1576).get(), (x1573).get()); + Box x1619 = new Box((int)0); + Box x1620 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1619, x1620, 0x0, (x1549).get(), (x1595).get()); + Box x1621 = new Box((int)0); + Box x1622 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1621, x1622, (x1620).get(), (x1551).get(), (x1597).get()); + Box x1623 = new Box((int)0); + Box x1624 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1623, x1624, (x1622).get(), (x1553).get(), (x1599).get()); + Box x1625 = new Box((int)0); + Box x1626 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1625, x1626, (x1624).get(), (x1555).get(), (x1601).get()); + Box x1627 = new Box((int)0); + Box x1628 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1627, x1628, (x1626).get(), (x1557).get(), (x1603).get()); + Box x1629 = new Box((int)0); + Box x1630 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1629, x1630, (x1628).get(), (x1559).get(), (x1605).get()); + Box x1631 = new Box((int)0); + Box x1632 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1631, x1632, (x1630).get(), (x1561).get(), (x1607).get()); + Box x1633 = new Box((int)0); + Box x1634 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1633, x1634, (x1632).get(), (x1563).get(), (x1609).get()); + Box x1635 = new Box((int)0); + Box x1636 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1635, x1636, (x1634).get(), (x1565).get(), (x1611).get()); + Box x1637 = new Box((int)0); + Box x1638 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1637, x1638, (x1636).get(), (x1567).get(), (x1613).get()); + Box x1639 = new Box((int)0); + Box x1640 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1639, x1640, (x1638).get(), (x1569).get(), (x1615).get()); + Box x1641 = new Box((int)0); + Box x1642 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1641, x1642, (x1640).get(), (x1571).get(), (x1617).get()); + Box x1643 = new Box((int)0); + Box x1644 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1643, x1644, (x1619).get(), 0xe88fdc45); + Box x1645 = new Box((int)0); + Box x1646 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1645, x1646, (x1643).get(), 0xffffffff); + Box x1647 = new Box((int)0); + Box x1648 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1647, x1648, (x1643).get(), 0xffffffff); + Box x1649 = new Box((int)0); + Box x1650 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1649, x1650, (x1643).get(), 0xffffffff); + Box x1651 = new Box((int)0); + Box x1652 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1651, x1652, (x1643).get(), 0xffffffff); + Box x1653 = new Box((int)0); + Box x1654 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1653, x1654, (x1643).get(), 0xffffffff); + Box x1655 = new Box((int)0); + Box x1656 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1655, x1656, (x1643).get(), 0xffffffff); + Box x1657 = new Box((int)0); + Box x1658 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1657, x1658, (x1643).get(), 0xc7634d81); + Box x1659 = new Box((int)0); + Box x1660 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1659, x1660, (x1643).get(), 0xf4372ddf); + Box x1661 = new Box((int)0); + Box x1662 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1661, x1662, (x1643).get(), 0x581a0db2); + Box x1663 = new Box((int)0); + Box x1664 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1663, x1664, (x1643).get(), 0x48b0a77a); + Box x1665 = new Box((int)0); + Box x1666 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1665, x1666, (x1643).get(), 0xecec196a); + Box x1667 = new Box((int)0); + Box x1668 = new Box((int)0); + fiat_P384Scalar_mulx_u32(x1667, x1668, (x1643).get(), 0xccc52973); + Box x1669 = new Box((int)0); + Box x1670 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1669, x1670, 0x0, (x1668).get(), (x1665).get()); + Box x1671 = new Box((int)0); + Box x1672 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1671, x1672, (x1670).get(), (x1666).get(), (x1663).get()); + Box x1673 = new Box((int)0); + Box x1674 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1673, x1674, (x1672).get(), (x1664).get(), (x1661).get()); + Box x1675 = new Box((int)0); + Box x1676 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1675, x1676, (x1674).get(), (x1662).get(), (x1659).get()); + Box x1677 = new Box((int)0); + Box x1678 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1677, x1678, (x1676).get(), (x1660).get(), (x1657).get()); + Box x1679 = new Box((int)0); + Box x1680 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1679, x1680, (x1678).get(), (x1658).get(), (x1655).get()); + Box x1681 = new Box((int)0); + Box x1682 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1681, x1682, (x1680).get(), (x1656).get(), (x1653).get()); + Box x1683 = new Box((int)0); + Box x1684 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1683, x1684, (x1682).get(), (x1654).get(), (x1651).get()); + Box x1685 = new Box((int)0); + Box x1686 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1685, x1686, (x1684).get(), (x1652).get(), (x1649).get()); + Box x1687 = new Box((int)0); + Box x1688 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1687, x1688, (x1686).get(), (x1650).get(), (x1647).get()); + Box x1689 = new Box((int)0); + Box x1690 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1689, x1690, (x1688).get(), (x1648).get(), (x1645).get()); + Box x1691 = new Box((int)0); + Box x1692 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1691, x1692, 0x0, (x1619).get(), (x1667).get()); + Box x1693 = new Box((int)0); + Box x1694 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1693, x1694, (x1692).get(), (x1621).get(), (x1669).get()); + Box x1695 = new Box((int)0); + Box x1696 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1695, x1696, (x1694).get(), (x1623).get(), (x1671).get()); + Box x1697 = new Box((int)0); + Box x1698 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1697, x1698, (x1696).get(), (x1625).get(), (x1673).get()); + Box x1699 = new Box((int)0); + Box x1700 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1699, x1700, (x1698).get(), (x1627).get(), (x1675).get()); + Box x1701 = new Box((int)0); + Box x1702 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1701, x1702, (x1700).get(), (x1629).get(), (x1677).get()); + Box x1703 = new Box((int)0); + Box x1704 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1703, x1704, (x1702).get(), (x1631).get(), (x1679).get()); + Box x1705 = new Box((int)0); + Box x1706 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1705, x1706, (x1704).get(), (x1633).get(), (x1681).get()); + Box x1707 = new Box((int)0); + Box x1708 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1707, x1708, (x1706).get(), (x1635).get(), (x1683).get()); + Box x1709 = new Box((int)0); + Box x1710 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1709, x1710, (x1708).get(), (x1637).get(), (x1685).get()); + Box x1711 = new Box((int)0); + Box x1712 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1711, x1712, (x1710).get(), (x1639).get(), (x1687).get()); + Box x1713 = new Box((int)0); + Box x1714 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1713, x1714, (x1712).get(), (x1641).get(), (x1689).get()); + Box x1715 = new Box((int)0); + Box x1716 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1715, x1716, (x1714).get(), (((x1642).get() + (x1572).get()) + ((x1618).get() + (x1574).get())), ((x1690).get() + (x1646).get())); + Box x1717 = new Box((int)0); + Box x1718 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1717, x1718, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x1693).get(), 0xccc52973); + Box x1719 = new Box((int)0); + Box x1720 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1719, x1720, (x1718).get(), (x1695).get(), 0xecec196a); + Box x1721 = new Box((int)0); + Box x1722 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1721, x1722, (x1720).get(), (x1697).get(), 0x48b0a77a); + Box x1723 = new Box((int)0); + Box x1724 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1723, x1724, (x1722).get(), (x1699).get(), 0x581a0db2); + Box x1725 = new Box((int)0); + Box x1726 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1725, x1726, (x1724).get(), (x1701).get(), 0xf4372ddf); + Box x1727 = new Box((int)0); + Box x1728 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1727, x1728, (x1726).get(), (x1703).get(), 0xc7634d81); + Box x1729 = new Box((int)0); + Box x1730 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1729, x1730, (x1728).get(), (x1705).get(), 0xffffffff); + Box x1731 = new Box((int)0); + Box x1732 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1731, x1732, (x1730).get(), (x1707).get(), 0xffffffff); + Box x1733 = new Box((int)0); + Box x1734 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1733, x1734, (x1732).get(), (x1709).get(), 0xffffffff); + Box x1735 = new Box((int)0); + Box x1736 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1735, x1736, (x1734).get(), (x1711).get(), 0xffffffff); + Box x1737 = new Box((int)0); + Box x1738 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1737, x1738, (x1736).get(), (x1713).get(), 0xffffffff); + Box x1739 = new Box((int)0); + Box x1740 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1739, x1740, (x1738).get(), (x1715).get(), 0xffffffff); + Box x1741 = new Box((int)0); + Box x1742 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x1741, x1742, (x1740).get(), (x1716).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x1743 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1743, (x1742).get(), (x1717).get(), (x1693).get()); + Box x1744 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1744, (x1742).get(), (x1719).get(), (x1695).get()); + Box x1745 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1745, (x1742).get(), (x1721).get(), (x1697).get()); + Box x1746 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1746, (x1742).get(), (x1723).get(), (x1699).get()); + Box x1747 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1747, (x1742).get(), (x1725).get(), (x1701).get()); + Box x1748 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1748, (x1742).get(), (x1727).get(), (x1703).get()); + Box x1749 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1749, (x1742).get(), (x1729).get(), (x1705).get()); + Box x1750 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1750, (x1742).get(), (x1731).get(), (x1707).get()); + Box x1751 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1751, (x1742).get(), (x1733).get(), (x1709).get()); + Box x1752 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1752, (x1742).get(), (x1735).get(), (x1711).get()); + Box x1753 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1753, (x1742).get(), (x1737).get(), (x1713).get()); + Box x1754 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1754, (x1742).get(), (x1739).get(), (x1715).get()); + out1[0] = (x1743).get(); + out1[1] = (x1744).get(); + out1[2] = (x1745).get(); + out1[3] = (x1746).get(); + out1[4] = (x1747).get(); + out1[5] = (x1748).get(); + out1[6] = (x1749).get(); + out1[7] = (x1750).get(); + out1[8] = (x1751).get(); + out1[9] = (x1752).get(); + out1[10] = (x1753).get(); + out1[11] = (x1754).get(); +} + +/** + * The function fiat_P384Scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ */ +public static void fiat_P384Scalar_nonzero(Box out1, final int[] arg1) { + int x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | ((arg1[7]) | ((arg1[8]) | ((arg1[9]) | ((arg1[10]) | (arg1[11])))))))))))); + out1.set(x1); +} + +/** + * The function fiat_P384Scalar_selectznz is a multi-limb conditional select.

+ *

+ * Postconditions:

+ * out1 = (if arg1 = 0 then arg2 else arg3)

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_selectznz(int[] out1, int arg1, final int[] arg2, final int[] arg3) { + Box x1 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x1, arg1, (arg2[0]), (arg3[0])); + Box x2 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x2, arg1, (arg2[1]), (arg3[1])); + Box x3 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x3, arg1, (arg2[2]), (arg3[2])); + Box x4 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x4, arg1, (arg2[3]), (arg3[3])); + Box x5 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x5, arg1, (arg2[4]), (arg3[4])); + Box x6 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x6, arg1, (arg2[5]), (arg3[5])); + Box x7 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x7, arg1, (arg2[6]), (arg3[6])); + Box x8 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x8, arg1, (arg2[7]), (arg3[7])); + Box x9 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x9, arg1, (arg2[8]), (arg3[8])); + Box x10 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x10, arg1, (arg2[9]), (arg3[9])); + Box x11 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x11, arg1, (arg2[10]), (arg3[10])); + Box x12 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x12, arg1, (arg2[11]), (arg3[11])); + out1[0] = (x1).get(); + out1[1] = (x2).get(); + out1[2] = (x3).get(); + out1[3] = (x4).get(); + out1[4] = (x5).get(); + out1[5] = (x6).get(); + out1[6] = (x7).get(); + out1[7] = (x8).get(); + out1[8] = (x9).get(); + out1[9] = (x10).get(); + out1[10] = (x11).get(); + out1[11] = (x12).get(); +} + +/** + * The function fiat_P384Scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47]

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]

+ */ +public static void fiat_P384Scalar_to_bytes(int[] out1, final int[] arg1) { + int x1 = (arg1[11]); + int x2 = (arg1[10]); + int x3 = (arg1[9]); + int x4 = (arg1[8]); + int x5 = (arg1[7]); + int x6 = (arg1[6]); + int x7 = (arg1[5]); + int x8 = (arg1[4]); + int x9 = (arg1[3]); + int x10 = (arg1[2]); + int x11 = (arg1[1]); + int x12 = (arg1[0]); + int x13 = (x12 & 0xff); + int x14 = (x12 >>> 8); + int x15 = (x14 & 0xff); + int x16 = (x14 >>> 8); + int x17 = (x16 & 0xff); + int x18 = (x16 >>> 8); + int x19 = (x11 & 0xff); + int x20 = (x11 >>> 8); + int x21 = (x20 & 0xff); + int x22 = (x20 >>> 8); + int x23 = (x22 & 0xff); + int x24 = (x22 >>> 8); + int x25 = (x10 & 0xff); + int x26 = (x10 >>> 8); + int x27 = (x26 & 0xff); + int x28 = (x26 >>> 8); + int x29 = (x28 & 0xff); + int x30 = (x28 >>> 8); + int x31 = (x9 & 0xff); + int x32 = (x9 >>> 8); + int x33 = (x32 & 0xff); + int x34 = (x32 >>> 8); + int x35 = (x34 & 0xff); + int x36 = (x34 >>> 8); + int x37 = (x8 & 0xff); + int x38 = (x8 >>> 8); + int x39 = (x38 & 0xff); + int x40 = (x38 >>> 8); + int x41 = (x40 & 0xff); + int x42 = (x40 >>> 8); + int x43 = (x7 & 0xff); + int x44 = (x7 >>> 8); + int x45 = (x44 & 0xff); + int x46 = (x44 >>> 8); + int x47 = (x46 & 0xff); + int x48 = (x46 >>> 8); + int x49 = (x6 & 0xff); + int x50 = (x6 >>> 8); + int x51 = (x50 & 0xff); + int x52 = (x50 >>> 8); + int x53 = (x52 & 0xff); + int x54 = (x52 >>> 8); + int x55 = (x5 & 0xff); + int x56 = (x5 >>> 8); + int x57 = (x56 & 0xff); + int x58 = (x56 >>> 8); + int x59 = (x58 & 0xff); + int x60 = (x58 >>> 8); + int x61 = (x4 & 0xff); + int x62 = (x4 >>> 8); + int x63 = (x62 & 0xff); + int x64 = (x62 >>> 8); + int x65 = (x64 & 0xff); + int x66 = (x64 >>> 8); + int x67 = (x3 & 0xff); + int x68 = (x3 >>> 8); + int x69 = (x68 & 0xff); + int x70 = (x68 >>> 8); + int x71 = (x70 & 0xff); + int x72 = (x70 >>> 8); + int x73 = (x2 & 0xff); + int x74 = (x2 >>> 8); + int x75 = (x74 & 0xff); + int x76 = (x74 >>> 8); + int x77 = (x76 & 0xff); + int x78 = (x76 >>> 8); + int x79 = (x1 & 0xff); + int x80 = (x1 >>> 8); + int x81 = (x80 & 0xff); + int x82 = (x80 >>> 8); + int x83 = (x82 & 0xff); + int x84 = (x82 >>> 8); + out1[0] = x13; + out1[1] = x15; + out1[2] = x17; + out1[3] = x18; + out1[4] = x19; + out1[5] = x21; + out1[6] = x23; + out1[7] = x24; + out1[8] = x25; + out1[9] = x27; + out1[10] = x29; + out1[11] = x30; + out1[12] = x31; + out1[13] = x33; + out1[14] = x35; + out1[15] = x36; + out1[16] = x37; + out1[17] = x39; + out1[18] = x41; + out1[19] = x42; + out1[20] = x43; + out1[21] = x45; + out1[22] = x47; + out1[23] = x48; + out1[24] = x49; + out1[25] = x51; + out1[26] = x53; + out1[27] = x54; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; + out1[32] = x61; + out1[33] = x63; + out1[34] = x65; + out1[35] = x66; + out1[36] = x67; + out1[37] = x69; + out1[38] = x71; + out1[39] = x72; + out1[40] = x73; + out1[41] = x75; + out1[42] = x77; + out1[43] = x78; + out1[44] = x79; + out1[45] = x81; + out1[46] = x83; + out1[47] = x84; +} + +/** + * The function fiat_P384Scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order.

+ *

+ * Preconditions:

+ * 0 ≤ bytes_eval arg1 < m

+ * Postconditions:

+ * eval out1 mod m = bytes_eval arg1 mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_from_bytes(int[] out1, final int[] arg1) { + int x1 = ((arg1[47]) << 24); + int x2 = ((arg1[46]) << 16); + int x3 = ((arg1[45]) << 8); + int x4 = (arg1[44]); + int x5 = ((arg1[43]) << 24); + int x6 = ((arg1[42]) << 16); + int x7 = ((arg1[41]) << 8); + int x8 = (arg1[40]); + int x9 = ((arg1[39]) << 24); + int x10 = ((arg1[38]) << 16); + int x11 = ((arg1[37]) << 8); + int x12 = (arg1[36]); + int x13 = ((arg1[35]) << 24); + int x14 = ((arg1[34]) << 16); + int x15 = ((arg1[33]) << 8); + int x16 = (arg1[32]); + int x17 = ((arg1[31]) << 24); + int x18 = ((arg1[30]) << 16); + int x19 = ((arg1[29]) << 8); + int x20 = (arg1[28]); + int x21 = ((arg1[27]) << 24); + int x22 = ((arg1[26]) << 16); + int x23 = ((arg1[25]) << 8); + int x24 = (arg1[24]); + int x25 = ((arg1[23]) << 24); + int x26 = ((arg1[22]) << 16); + int x27 = ((arg1[21]) << 8); + int x28 = (arg1[20]); + int x29 = ((arg1[19]) << 24); + int x30 = ((arg1[18]) << 16); + int x31 = ((arg1[17]) << 8); + int x32 = (arg1[16]); + int x33 = ((arg1[15]) << 24); + int x34 = ((arg1[14]) << 16); + int x35 = ((arg1[13]) << 8); + int x36 = (arg1[12]); + int x37 = ((arg1[11]) << 24); + int x38 = ((arg1[10]) << 16); + int x39 = ((arg1[9]) << 8); + int x40 = (arg1[8]); + int x41 = ((arg1[7]) << 24); + int x42 = ((arg1[6]) << 16); + int x43 = ((arg1[5]) << 8); + int x44 = (arg1[4]); + int x45 = ((arg1[3]) << 24); + int x46 = ((arg1[2]) << 16); + int x47 = ((arg1[1]) << 8); + int x48 = (arg1[0]); + int x49 = (x47 + x48); + int x50 = (x46 + x49); + int x51 = (x45 + x50); + int x52 = (x43 + x44); + int x53 = (x42 + x52); + int x54 = (x41 + x53); + int x55 = (x39 + x40); + int x56 = (x38 + x55); + int x57 = (x37 + x56); + int x58 = (x35 + x36); + int x59 = (x34 + x58); + int x60 = (x33 + x59); + int x61 = (x31 + x32); + int x62 = (x30 + x61); + int x63 = (x29 + x62); + int x64 = (x27 + x28); + int x65 = (x26 + x64); + int x66 = (x25 + x65); + int x67 = (x23 + x24); + int x68 = (x22 + x67); + int x69 = (x21 + x68); + int x70 = (x19 + x20); + int x71 = (x18 + x70); + int x72 = (x17 + x71); + int x73 = (x15 + x16); + int x74 = (x14 + x73); + int x75 = (x13 + x74); + int x76 = (x11 + x12); + int x77 = (x10 + x76); + int x78 = (x9 + x77); + int x79 = (x7 + x8); + int x80 = (x6 + x79); + int x81 = (x5 + x80); + int x82 = (x3 + x4); + int x83 = (x2 + x82); + int x84 = (x1 + x83); + out1[0] = x51; + out1[1] = x54; + out1[2] = x57; + out1[3] = x60; + out1[4] = x63; + out1[5] = x66; + out1[6] = x69; + out1[7] = x72; + out1[8] = x75; + out1[9] = x78; + out1[10] = x81; + out1[11] = x84; +} + +/** + * The function fiat_P384Scalar_set_one returns the field element one in the Montgomery domain.

+ *

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = 1 mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_set_one(int[] out1) { + out1[0] = 0x333ad68d; + out1[1] = 0x1313e695; + out1[2] = 0xb74f5885; + out1[3] = 0xa7e5f24d; + out1[4] = 0xbc8d220; + out1[5] = 0x389cb27e; + out1[6] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[7] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[8] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[9] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[10] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[11] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); +} + +/** + * The function fiat_P384Scalar_msat returns the saturated representation of the prime modulus.

+ *

+ * Postconditions:

+ * twos_complement_eval out1 = m

+ * 0 ≤ eval out1 < m

+ *

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_msat(int[] out1) { + out1[0] = 0xccc52973; + out1[1] = 0xecec196a; + out1[2] = 0x48b0a77a; + out1[3] = 0x581a0db2; + out1[4] = 0xf4372ddf; + out1[5] = 0xc7634d81; + out1[6] = 0xffffffff; + out1[7] = 0xffffffff; + out1[8] = 0xffffffff; + out1[9] = 0xffffffff; + out1[10] = 0xffffffff; + out1[11] = 0xffffffff; + out1[12] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); +} + +/** + * The function fiat_P384Scalar_divstep computes a divstep.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg4 < m

+ * 0 ≤ eval arg5 < m

+ * Postconditions:

+ * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1)

+ * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2)

+ * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋)

+ * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m)

+ * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m)

+ * 0 ≤ eval out5 < m

+ * 0 ≤ eval out5 < m

+ * 0 ≤ eval out2 < m

+ * 0 ≤ eval out3 < m

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0xffffffff]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_divstep(Box out1, int[] out2, int[] out3, int[] out4, int[] out5, int arg1, final int[] arg2, final int[] arg3, final int[] arg4, final int[] arg5) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x1, x2, 0x0, (~arg1), 0x1); + int x3 = (((x1).get() >>> 31) & ((arg3[0]) & 0x1)); + Box x4 = new Box((int)0); + Box x5 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x4, x5, 0x0, (~arg1), 0x1); + Box x6 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x6, x3, arg1, (x4).get()); + Box x7 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x7, x3, (arg2[0]), (arg3[0])); + Box x8 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x8, x3, (arg2[1]), (arg3[1])); + Box x9 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x9, x3, (arg2[2]), (arg3[2])); + Box x10 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x10, x3, (arg2[3]), (arg3[3])); + Box x11 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x11, x3, (arg2[4]), (arg3[4])); + Box x12 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x12, x3, (arg2[5]), (arg3[5])); + Box x13 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x13, x3, (arg2[6]), (arg3[6])); + Box x14 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x14, x3, (arg2[7]), (arg3[7])); + Box x15 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x15, x3, (arg2[8]), (arg3[8])); + Box x16 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x16, x3, (arg2[9]), (arg3[9])); + Box x17 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x17, x3, (arg2[10]), (arg3[10])); + Box x18 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x18, x3, (arg2[11]), (arg3[11])); + Box x19 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x19, x3, (arg2[12]), (arg3[12])); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x20, x21, 0x0, 0x1, (~(arg2[0]))); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x22, x23, (x21).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[1]))); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x24, x25, (x23).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[2]))); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x26, x27, (x25).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[3]))); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x28, x29, (x27).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[4]))); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x30, x31, (x29).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[5]))); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x32, x33, (x31).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[6]))); + Box x34 = new Box((int)0); + Box x35 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x34, x35, (x33).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[7]))); + Box x36 = new Box((int)0); + Box x37 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x36, x37, (x35).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[8]))); + Box x38 = new Box((int)0); + Box x39 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x38, x39, (x37).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[9]))); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x40, x41, (x39).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[10]))); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x42, x43, (x41).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[11]))); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x44, x45, (x43).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[12]))); + Box x46 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x46, x3, (arg3[0]), (x20).get()); + Box x47 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x47, x3, (arg3[1]), (x22).get()); + Box x48 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x48, x3, (arg3[2]), (x24).get()); + Box x49 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x49, x3, (arg3[3]), (x26).get()); + Box x50 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x50, x3, (arg3[4]), (x28).get()); + Box x51 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x51, x3, (arg3[5]), (x30).get()); + Box x52 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x52, x3, (arg3[6]), (x32).get()); + Box x53 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x53, x3, (arg3[7]), (x34).get()); + Box x54 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x54, x3, (arg3[8]), (x36).get()); + Box x55 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x55, x3, (arg3[9]), (x38).get()); + Box x56 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x56, x3, (arg3[10]), (x40).get()); + Box x57 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x57, x3, (arg3[11]), (x42).get()); + Box x58 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x58, x3, (arg3[12]), (x44).get()); + Box x59 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x59, x3, (arg4[0]), (arg5[0])); + Box x60 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x60, x3, (arg4[1]), (arg5[1])); + Box x61 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x61, x3, (arg4[2]), (arg5[2])); + Box x62 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x62, x3, (arg4[3]), (arg5[3])); + Box x63 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x63, x3, (arg4[4]), (arg5[4])); + Box x64 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x64, x3, (arg4[5]), (arg5[5])); + Box x65 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x65, x3, (arg4[6]), (arg5[6])); + Box x66 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x66, x3, (arg4[7]), (arg5[7])); + Box x67 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x67, x3, (arg4[8]), (arg5[8])); + Box x68 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x68, x3, (arg4[9]), (arg5[9])); + Box x69 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x69, x3, (arg4[10]), (arg5[10])); + Box x70 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x70, x3, (arg4[11]), (arg5[11])); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x71, x72, 0x0, (x59).get(), (x59).get()); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x73, x74, (x72).get(), (x60).get(), (x60).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x75, x76, (x74).get(), (x61).get(), (x61).get()); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x77, x78, (x76).get(), (x62).get(), (x62).get()); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x79, x80, (x78).get(), (x63).get(), (x63).get()); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x81, x82, (x80).get(), (x64).get(), (x64).get()); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x83, x84, (x82).get(), (x65).get(), (x65).get()); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x85, x86, (x84).get(), (x66).get(), (x66).get()); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x87, x88, (x86).get(), (x67).get(), (x67).get()); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x89, x90, (x88).get(), (x68).get(), (x68).get()); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x91, x92, (x90).get(), (x69).get(), (x69).get()); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x93, x94, (x92).get(), (x70).get(), (x70).get()); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x95, x96, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x71).get(), 0xccc52973); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x97, x98, (x96).get(), (x73).get(), 0xecec196a); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x99, x100, (x98).get(), (x75).get(), 0x48b0a77a); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x101, x102, (x100).get(), (x77).get(), 0x581a0db2); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x103, x104, (x102).get(), (x79).get(), 0xf4372ddf); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x105, x106, (x104).get(), (x81).get(), 0xc7634d81); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x107, x108, (x106).get(), (x83).get(), 0xffffffff); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x109, x110, (x108).get(), (x85).get(), 0xffffffff); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x111, x112, (x110).get(), (x87).get(), 0xffffffff); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x113, x114, (x112).get(), (x89).get(), 0xffffffff); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x115, x116, (x114).get(), (x91).get(), 0xffffffff); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x117, x118, (x116).get(), (x93).get(), 0xffffffff); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x119, x120, (x118).get(), (x94).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + int x121 = (arg4[11]); + int x122 = (arg4[10]); + int x123 = (arg4[9]); + int x124 = (arg4[8]); + int x125 = (arg4[7]); + int x126 = (arg4[6]); + int x127 = (arg4[5]); + int x128 = (arg4[4]); + int x129 = (arg4[3]); + int x130 = (arg4[2]); + int x131 = (arg4[1]); + int x132 = (arg4[0]); + Box x133 = new Box((int)0); + Box x134 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x133, x134, 0x0, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x132); + Box x135 = new Box((int)0); + Box x136 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x135, x136, (x134).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x131); + Box x137 = new Box((int)0); + Box x138 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x137, x138, (x136).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x130); + Box x139 = new Box((int)0); + Box x140 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x139, x140, (x138).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x129); + Box x141 = new Box((int)0); + Box x142 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x141, x142, (x140).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x128); + Box x143 = new Box((int)0); + Box x144 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x143, x144, (x142).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x127); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x145, x146, (x144).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x126); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x147, x148, (x146).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x125); + Box x149 = new Box((int)0); + Box x150 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x149, x150, (x148).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x124); + Box x151 = new Box((int)0); + Box x152 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x151, x152, (x150).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x123); + Box x153 = new Box((int)0); + Box x154 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x153, x154, (x152).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x122); + Box x155 = new Box((int)0); + Box x156 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x155, x156, (x154).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x121); + Box x157 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x157, (x156).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), 0xffffffff); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x158, x159, 0x0, (x133).get(), ((x157).get() & 0xccc52973)); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x160, x161, (x159).get(), (x135).get(), ((x157).get() & 0xecec196a)); + Box x162 = new Box((int)0); + Box x163 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x162, x163, (x161).get(), (x137).get(), ((x157).get() & 0x48b0a77a)); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x164, x165, (x163).get(), (x139).get(), ((x157).get() & 0x581a0db2)); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x166, x167, (x165).get(), (x141).get(), ((x157).get() & 0xf4372ddf)); + Box x168 = new Box((int)0); + Box x169 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x168, x169, (x167).get(), (x143).get(), ((x157).get() & 0xc7634d81)); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x170, x171, (x169).get(), (x145).get(), (x157).get()); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x172, x173, (x171).get(), (x147).get(), (x157).get()); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x174, x175, (x173).get(), (x149).get(), (x157).get()); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x176, x177, (x175).get(), (x151).get(), (x157).get()); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x178, x179, (x177).get(), (x153).get(), (x157).get()); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x180, x181, (x179).get(), (x155).get(), (x157).get()); + Box x182 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x182, x3, (arg5[0]), (x158).get()); + Box x183 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x183, x3, (arg5[1]), (x160).get()); + Box x184 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x184, x3, (arg5[2]), (x162).get()); + Box x185 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x185, x3, (arg5[3]), (x164).get()); + Box x186 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x186, x3, (arg5[4]), (x166).get()); + Box x187 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x187, x3, (arg5[5]), (x168).get()); + Box x188 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x188, x3, (arg5[6]), (x170).get()); + Box x189 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x189, x3, (arg5[7]), (x172).get()); + Box x190 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x190, x3, (arg5[8]), (x174).get()); + Box x191 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x191, x3, (arg5[9]), (x176).get()); + Box x192 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x192, x3, (arg5[10]), (x178).get()); + Box x193 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x193, x3, (arg5[11]), (x180).get()); + int x194 = ((x46).get() & 0x1); + Box x195 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x195, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x7).get()); + Box x196 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x196, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x8).get()); + Box x197 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x197, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x9).get()); + Box x198 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x198, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x10).get()); + Box x199 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x199, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x11).get()); + Box x200 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x200, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x12).get()); + Box x201 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x201, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x13).get()); + Box x202 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x202, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x14).get()); + Box x203 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x203, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x15).get()); + Box x204 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x204, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x16).get()); + Box x205 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x205, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x17).get()); + Box x206 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x206, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x18).get()); + Box x207 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x207, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x19).get()); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x208, x209, 0x0, (x46).get(), (x195).get()); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x210, x211, (x209).get(), (x47).get(), (x196).get()); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x212, x213, (x211).get(), (x48).get(), (x197).get()); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x214, x215, (x213).get(), (x49).get(), (x198).get()); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x216, x217, (x215).get(), (x50).get(), (x199).get()); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x218, x219, (x217).get(), (x51).get(), (x200).get()); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x220, x221, (x219).get(), (x52).get(), (x201).get()); + Box x222 = new Box((int)0); + Box x223 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x222, x223, (x221).get(), (x53).get(), (x202).get()); + Box x224 = new Box((int)0); + Box x225 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x224, x225, (x223).get(), (x54).get(), (x203).get()); + Box x226 = new Box((int)0); + Box x227 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x226, x227, (x225).get(), (x55).get(), (x204).get()); + Box x228 = new Box((int)0); + Box x229 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x228, x229, (x227).get(), (x56).get(), (x205).get()); + Box x230 = new Box((int)0); + Box x231 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x230, x231, (x229).get(), (x57).get(), (x206).get()); + Box x232 = new Box((int)0); + Box x233 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x232, x233, (x231).get(), (x58).get(), (x207).get()); + Box x234 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x234, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x59).get()); + Box x235 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x235, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x60).get()); + Box x236 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x236, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x61).get()); + Box x237 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x237, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x62).get()); + Box x238 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x238, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x63).get()); + Box x239 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x239, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x64).get()); + Box x240 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x240, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x65).get()); + Box x241 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x241, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x66).get()); + Box x242 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x242, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x67).get()); + Box x243 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x243, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x68).get()); + Box x244 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x244, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x69).get()); + Box x245 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x245, x194, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x70).get()); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x246, x247, 0x0, (x182).get(), (x234).get()); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x248, x249, (x247).get(), (x183).get(), (x235).get()); + Box x250 = new Box((int)0); + Box x251 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x250, x251, (x249).get(), (x184).get(), (x236).get()); + Box x252 = new Box((int)0); + Box x253 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x252, x253, (x251).get(), (x185).get(), (x237).get()); + Box x254 = new Box((int)0); + Box x255 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x254, x255, (x253).get(), (x186).get(), (x238).get()); + Box x256 = new Box((int)0); + Box x257 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x256, x257, (x255).get(), (x187).get(), (x239).get()); + Box x258 = new Box((int)0); + Box x259 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x258, x259, (x257).get(), (x188).get(), (x240).get()); + Box x260 = new Box((int)0); + Box x261 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x260, x261, (x259).get(), (x189).get(), (x241).get()); + Box x262 = new Box((int)0); + Box x263 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x262, x263, (x261).get(), (x190).get(), (x242).get()); + Box x264 = new Box((int)0); + Box x265 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x264, x265, (x263).get(), (x191).get(), (x243).get()); + Box x266 = new Box((int)0); + Box x267 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x266, x267, (x265).get(), (x192).get(), (x244).get()); + Box x268 = new Box((int)0); + Box x269 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x268, x269, (x267).get(), (x193).get(), (x245).get()); + Box x270 = new Box((int)0); + Box x271 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x270, x271, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x246).get(), 0xccc52973); + Box x272 = new Box((int)0); + Box x273 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x272, x273, (x271).get(), (x248).get(), 0xecec196a); + Box x274 = new Box((int)0); + Box x275 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x274, x275, (x273).get(), (x250).get(), 0x48b0a77a); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x276, x277, (x275).get(), (x252).get(), 0x581a0db2); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x278, x279, (x277).get(), (x254).get(), 0xf4372ddf); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x280, x281, (x279).get(), (x256).get(), 0xc7634d81); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x282, x283, (x281).get(), (x258).get(), 0xffffffff); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x284, x285, (x283).get(), (x260).get(), 0xffffffff); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x286, x287, (x285).get(), (x262).get(), 0xffffffff); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x288, x289, (x287).get(), (x264).get(), 0xffffffff); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x290, x291, (x289).get(), (x266).get(), 0xffffffff); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x292, x293, (x291).get(), (x268).get(), 0xffffffff); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_P384Scalar_subborrowx_u32(x294, x295, (x293).get(), (x269).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_P384Scalar_addcarryx_u32(x296, x297, 0x0, (x6).get(), 0x1); + int x298 = (((x208).get() >>> 1) | (((x210).get() << 31) & 0xffffffff)); + int x299 = (((x210).get() >>> 1) | (((x212).get() << 31) & 0xffffffff)); + int x300 = (((x212).get() >>> 1) | (((x214).get() << 31) & 0xffffffff)); + int x301 = (((x214).get() >>> 1) | (((x216).get() << 31) & 0xffffffff)); + int x302 = (((x216).get() >>> 1) | (((x218).get() << 31) & 0xffffffff)); + int x303 = (((x218).get() >>> 1) | (((x220).get() << 31) & 0xffffffff)); + int x304 = (((x220).get() >>> 1) | (((x222).get() << 31) & 0xffffffff)); + int x305 = (((x222).get() >>> 1) | (((x224).get() << 31) & 0xffffffff)); + int x306 = (((x224).get() >>> 1) | (((x226).get() << 31) & 0xffffffff)); + int x307 = (((x226).get() >>> 1) | (((x228).get() << 31) & 0xffffffff)); + int x308 = (((x228).get() >>> 1) | (((x230).get() << 31) & 0xffffffff)); + int x309 = (((x230).get() >>> 1) | (((x232).get() << 31) & 0xffffffff)); + int x310 = (((x232).get() & 0x80000000) | ((x232).get() >>> 1)); + Box x311 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x311, (x120).get(), (x95).get(), (x71).get()); + Box x312 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x312, (x120).get(), (x97).get(), (x73).get()); + Box x313 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x313, (x120).get(), (x99).get(), (x75).get()); + Box x314 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x314, (x120).get(), (x101).get(), (x77).get()); + Box x315 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x315, (x120).get(), (x103).get(), (x79).get()); + Box x316 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x316, (x120).get(), (x105).get(), (x81).get()); + Box x317 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x317, (x120).get(), (x107).get(), (x83).get()); + Box x318 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x318, (x120).get(), (x109).get(), (x85).get()); + Box x319 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x319, (x120).get(), (x111).get(), (x87).get()); + Box x320 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x320, (x120).get(), (x113).get(), (x89).get()); + Box x321 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x321, (x120).get(), (x115).get(), (x91).get()); + Box x322 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x322, (x120).get(), (x117).get(), (x93).get()); + Box x323 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x323, (x295).get(), (x270).get(), (x246).get()); + Box x324 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x324, (x295).get(), (x272).get(), (x248).get()); + Box x325 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x325, (x295).get(), (x274).get(), (x250).get()); + Box x326 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x326, (x295).get(), (x276).get(), (x252).get()); + Box x327 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x327, (x295).get(), (x278).get(), (x254).get()); + Box x328 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x328, (x295).get(), (x280).get(), (x256).get()); + Box x329 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x329, (x295).get(), (x282).get(), (x258).get()); + Box x330 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x330, (x295).get(), (x284).get(), (x260).get()); + Box x331 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x331, (x295).get(), (x286).get(), (x262).get()); + Box x332 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x332, (x295).get(), (x288).get(), (x264).get()); + Box x333 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x333, (x295).get(), (x290).get(), (x266).get()); + Box x334 = new Box((int)0); + fiat_P384Scalar_cmovznz_u32(x334, (x295).get(), (x292).get(), (x268).get()); + out1.set((x296).get()); + out2[0] = (x7).get(); + out2[1] = (x8).get(); + out2[2] = (x9).get(); + out2[3] = (x10).get(); + out2[4] = (x11).get(); + out2[5] = (x12).get(); + out2[6] = (x13).get(); + out2[7] = (x14).get(); + out2[8] = (x15).get(); + out2[9] = (x16).get(); + out2[10] = (x17).get(); + out2[11] = (x18).get(); + out2[12] = (x19).get(); + out3[0] = x298; + out3[1] = x299; + out3[2] = x300; + out3[3] = x301; + out3[4] = x302; + out3[5] = x303; + out3[6] = x304; + out3[7] = x305; + out3[8] = x306; + out3[9] = x307; + out3[10] = x308; + out3[11] = x309; + out3[12] = x310; + out4[0] = (x311).get(); + out4[1] = (x312).get(); + out4[2] = (x313).get(); + out4[3] = (x314).get(); + out4[4] = (x315).get(); + out4[5] = (x316).get(); + out4[6] = (x317).get(); + out4[7] = (x318).get(); + out4[8] = (x319).get(); + out4[9] = (x320).get(); + out4[10] = (x321).get(); + out4[11] = (x322).get(); + out5[0] = (x323).get(); + out5[1] = (x324).get(); + out5[2] = (x325).get(); + out5[3] = (x326).get(); + out5[4] = (x327).get(); + out5[5] = (x328).get(); + out5[6] = (x329).get(); + out5[7] = (x330).get(); + out5[8] = (x331).get(); + out5[9] = (x332).get(); + out5[10] = (x333).get(); + out5[11] = (x334).get(); +} + +/** + * The function fiat_P384Scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form).

+ *

+ * Postconditions:

+ * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋)

+ * 0 ≤ eval out1 < m

+ *

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_P384Scalar_divstep_precomp(int[] out1) { + out1[0] = 0xe6045b6a; + out1[1] = 0x49589ae0; + out1[2] = 0x870040ed; + out1[3] = 0x3c9a5352; + out1[4] = 0x977dc242; + out1[5] = 0xdacb097e; + out1[6] = 0xd1ecbe36; + out1[7] = 0xb5ab30a6; + out1[8] = 0x1f959973; + out1[9] = 0x97d7a108; + out1[10] = 0xd27192bc; + out1[11] = 0x2ba012f8; +} + +} diff --git a/fiat-java/src/FiatSecp256K1Scalar.java b/fiat-java/src/FiatSecp256K1Scalar.java new file mode 100644 index 0000000000..d1cd89c2d9 --- /dev/null +++ b/fiat-java/src/FiatSecp256K1Scalar.java @@ -0,0 +1,5650 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Java --cmovznz-by-mul --widen-carry --widen-bytes --internal-static --package-name fiat_crypto --class-case UpperCamelCase --no-field-element-typedefs Secp256K1Scalar 32 '2^256 - 432420386565659656852420866394968145599' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: Secp256K1Scalar */ +/* machine_wordsize = 32 (from "32") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141 (from "2^256 - 432420386565659656852420866394968145599") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +package fiat_crypto; + +public final class FiatSecp256K1Scalar { + +static class Box { + private T value; + public Box(T value) { this.value = value; } + public void set(T value) { this.value = value; } + public T get() { return this.value; } +} + + + +/** + * The function fiat_Secp256K1Scalar_addcarryx_u32 is an addition with carry.

+ *

+ * Postconditions:

+ * out1 = (arg1 + arg2 + arg3) mod 2^32

+ * out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [0x0 ~> 0xffffffff]

+ * arg3: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [0x0 ~> 0x1]

+ */ +static void fiat_Secp256K1Scalar_addcarryx_u32(Box out1, Box out2, int arg1, int arg2, int arg3) { + long x1 = (((long) Integer.toUnsignedLong(((Number) (arg1)).intValue()) + (long) Integer.toUnsignedLong(((Number) (arg2)).intValue())) + (long) Integer.toUnsignedLong(((Number) (arg3)).intValue())); + int x2 = ((int) Integer.toUnsignedLong(((Number) (x1)).intValue()) & 0xffffffff); + int x3 = (int) Integer.toUnsignedLong(((Number) ((x1 >>> 32))).intValue()); + out1.set(x2); + out2.set(x3); +} + +/** + * The function fiat_Secp256K1Scalar_subborrowx_u32 is a subtraction with borrow.

+ *

+ * Postconditions:

+ * out1 = (-arg1 + arg2 + -arg3) mod 2^32

+ * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [0x0 ~> 0xffffffff]

+ * arg3: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [0x0 ~> 0x1]

+ */ +static void fiat_Secp256K1Scalar_subborrowx_u32(Box out1, Box out2, int arg1, int arg2, int arg3) { + long x1 = (((long) Integer.toUnsignedLong(((Number) (arg2)).intValue()) - (long) Integer.toUnsignedLong(((Number) (arg1)).intValue())) - (long) Integer.toUnsignedLong(((Number) (arg3)).intValue())); + int x2 = (int) Integer.toUnsignedLong(((Number) ((x1 >>> 32))).intValue()); + int x3 = ((int) Integer.toUnsignedLong(((Number) (x1)).intValue()) & 0xffffffff); + out1.set(x3); + out2.set(((int) Integer.toUnsignedLong(((Number) (0x0)).intValue()) - (int) Integer.toUnsignedLong(((Number) (x2)).intValue()))); +} + +/** + * The function fiat_Secp256K1Scalar_mulx_u32 is a multiplication, returning the full double-width result.

+ *

+ * Postconditions:

+ * out1 = (arg1 * arg2) mod 2^32

+ * out2 = ⌊arg1 * arg2 / 2^32⌋

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0xffffffff]

+ * arg2: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [0x0 ~> 0xffffffff]

+ */ +static void fiat_Secp256K1Scalar_mulx_u32(Box out1, Box out2, int arg1, int arg2) { + long x1 = ((long) Integer.toUnsignedLong(((Number) (arg1)).intValue()) * (long) Integer.toUnsignedLong(((Number) (arg2)).intValue())); + int x2 = ((int) Integer.toUnsignedLong(((Number) (x1)).intValue()) & 0xffffffff); + int x3 = (int) Integer.toUnsignedLong(((Number) ((x1 >>> 32))).intValue()); + out1.set(x2); + out2.set(x3); +} + +/** + * The function fiat_Secp256K1Scalar_cmovznz_u32 is a single-word conditional move.

+ *

+ * Postconditions:

+ * out1 = (if arg1 = 0 then arg2 else arg3)

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [0x0 ~> 0xffffffff]

+ * arg3: [0x0 ~> 0xffffffff]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ */ +static void fiat_Secp256K1Scalar_cmovznz_u32(Box out1, int arg1, int arg2, int arg3) { + int x1 = (arg1 * 0xffffffff); + int x2 = ((x1 & arg3) | ((~x1) & arg2)); + out1.set(x2); +} + +/** + * The function fiat_Secp256K1Scalar_mul multiplies two field elements in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * 0 ≤ eval arg2 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_mul(int[] out1, final int[] arg1, final int[] arg2) { + int x1 = (arg1[1]); + int x2 = (arg1[2]); + int x3 = (arg1[3]); + int x4 = (arg1[4]); + int x5 = (arg1[5]); + int x6 = (arg1[6]); + int x7 = (arg1[7]); + int x8 = (arg1[0]); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x9, x10, x8, (arg2[7])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x11, x12, x8, (arg2[6])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x13, x14, x8, (arg2[5])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x15, x16, x8, (arg2[4])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x17, x18, x8, (arg2[3])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x19, x20, x8, (arg2[2])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x21, x22, x8, (arg2[1])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x23, x24, x8, (arg2[0])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x37, x38, (x36).get(), (x12).get(), (x9).get()); + int x39 = ((x38).get() + (x10).get()); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x40, x41, (x23).get(), 0x5588b13f); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x42, x43, (x40).get(), 0xffffffff); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x44, x45, (x40).get(), 0xffffffff); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x46, x47, (x40).get(), 0xffffffff); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x48, x49, (x40).get(), 0xfffffffe); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x50, x51, (x40).get(), 0xbaaedce6); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x52, x53, (x40).get(), 0xaf48a03b); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x54, x55, (x40).get(), 0xbfd25e8c); + Box x56 = new Box((int)0); + Box x57 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x56, x57, (x40).get(), 0xd0364141); + Box x58 = new Box((int)0); + Box x59 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x58, x59, 0x0, (x57).get(), (x54).get()); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x60, x61, (x59).get(), (x55).get(), (x52).get()); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x62, x63, (x61).get(), (x53).get(), (x50).get()); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x64, x65, (x63).get(), (x51).get(), (x48).get()); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x66, x67, (x65).get(), (x49).get(), (x46).get()); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x68, x69, (x67).get(), (x47).get(), (x44).get()); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x70, x71, (x69).get(), (x45).get(), (x42).get()); + int x72 = ((x71).get() + (x43).get()); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x73, x74, 0x0, (x23).get(), (x56).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x75, x76, (x74).get(), (x25).get(), (x58).get()); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x77, x78, (x76).get(), (x27).get(), (x60).get()); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x79, x80, (x78).get(), (x29).get(), (x62).get()); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x81, x82, (x80).get(), (x31).get(), (x64).get()); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x83, x84, (x82).get(), (x33).get(), (x66).get()); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x85, x86, (x84).get(), (x35).get(), (x68).get()); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x87, x88, (x86).get(), (x37).get(), (x70).get()); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x89, x90, (x88).get(), x39, x72); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x91, x92, x1, (arg2[7])); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x93, x94, x1, (arg2[6])); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x95, x96, x1, (arg2[5])); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x97, x98, x1, (arg2[4])); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x99, x100, x1, (arg2[3])); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x101, x102, x1, (arg2[2])); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x103, x104, x1, (arg2[1])); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x105, x106, x1, (arg2[0])); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x107, x108, 0x0, (x106).get(), (x103).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x109, x110, (x108).get(), (x104).get(), (x101).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x111, x112, (x110).get(), (x102).get(), (x99).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x113, x114, (x112).get(), (x100).get(), (x97).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x115, x116, (x114).get(), (x98).get(), (x95).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x117, x118, (x116).get(), (x96).get(), (x93).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x119, x120, (x118).get(), (x94).get(), (x91).get()); + int x121 = ((x120).get() + (x92).get()); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x122, x123, 0x0, (x75).get(), (x105).get()); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x124, x125, (x123).get(), (x77).get(), (x107).get()); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x126, x127, (x125).get(), (x79).get(), (x109).get()); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x128, x129, (x127).get(), (x81).get(), (x111).get()); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x130, x131, (x129).get(), (x83).get(), (x113).get()); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x132, x133, (x131).get(), (x85).get(), (x115).get()); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x134, x135, (x133).get(), (x87).get(), (x117).get()); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x136, x137, (x135).get(), (x89).get(), (x119).get()); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x138, x139, (x137).get(), (x90).get(), x121); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x140, x141, (x122).get(), 0x5588b13f); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x142, x143, (x140).get(), 0xffffffff); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x144, x145, (x140).get(), 0xffffffff); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x146, x147, (x140).get(), 0xffffffff); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x148, x149, (x140).get(), 0xfffffffe); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x150, x151, (x140).get(), 0xbaaedce6); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x152, x153, (x140).get(), 0xaf48a03b); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x154, x155, (x140).get(), 0xbfd25e8c); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x156, x157, (x140).get(), 0xd0364141); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x158, x159, 0x0, (x157).get(), (x154).get()); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x160, x161, (x159).get(), (x155).get(), (x152).get()); + Box x162 = new Box((int)0); + Box x163 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x162, x163, (x161).get(), (x153).get(), (x150).get()); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x164, x165, (x163).get(), (x151).get(), (x148).get()); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x166, x167, (x165).get(), (x149).get(), (x146).get()); + Box x168 = new Box((int)0); + Box x169 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x168, x169, (x167).get(), (x147).get(), (x144).get()); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x170, x171, (x169).get(), (x145).get(), (x142).get()); + int x172 = ((x171).get() + (x143).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x173, x174, 0x0, (x122).get(), (x156).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x175, x176, (x174).get(), (x124).get(), (x158).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x177, x178, (x176).get(), (x126).get(), (x160).get()); + Box x179 = new Box((int)0); + Box x180 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x179, x180, (x178).get(), (x128).get(), (x162).get()); + Box x181 = new Box((int)0); + Box x182 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x181, x182, (x180).get(), (x130).get(), (x164).get()); + Box x183 = new Box((int)0); + Box x184 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x183, x184, (x182).get(), (x132).get(), (x166).get()); + Box x185 = new Box((int)0); + Box x186 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x185, x186, (x184).get(), (x134).get(), (x168).get()); + Box x187 = new Box((int)0); + Box x188 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x187, x188, (x186).get(), (x136).get(), (x170).get()); + Box x189 = new Box((int)0); + Box x190 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x189, x190, (x188).get(), (x138).get(), x172); + int x191 = ((x190).get() + (x139).get()); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x192, x193, x2, (arg2[7])); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x194, x195, x2, (arg2[6])); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x196, x197, x2, (arg2[5])); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x198, x199, x2, (arg2[4])); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x200, x201, x2, (arg2[3])); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x202, x203, x2, (arg2[2])); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x204, x205, x2, (arg2[1])); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x206, x207, x2, (arg2[0])); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x208, x209, 0x0, (x207).get(), (x204).get()); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x210, x211, (x209).get(), (x205).get(), (x202).get()); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x212, x213, (x211).get(), (x203).get(), (x200).get()); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x214, x215, (x213).get(), (x201).get(), (x198).get()); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x216, x217, (x215).get(), (x199).get(), (x196).get()); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x218, x219, (x217).get(), (x197).get(), (x194).get()); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x220, x221, (x219).get(), (x195).get(), (x192).get()); + int x222 = ((x221).get() + (x193).get()); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x223, x224, 0x0, (x175).get(), (x206).get()); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x225, x226, (x224).get(), (x177).get(), (x208).get()); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x227, x228, (x226).get(), (x179).get(), (x210).get()); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x229, x230, (x228).get(), (x181).get(), (x212).get()); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x231, x232, (x230).get(), (x183).get(), (x214).get()); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x233, x234, (x232).get(), (x185).get(), (x216).get()); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x235, x236, (x234).get(), (x187).get(), (x218).get()); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x237, x238, (x236).get(), (x189).get(), (x220).get()); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x239, x240, (x238).get(), x191, x222); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x241, x242, (x223).get(), 0x5588b13f); + Box x243 = new Box((int)0); + Box x244 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x243, x244, (x241).get(), 0xffffffff); + Box x245 = new Box((int)0); + Box x246 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x245, x246, (x241).get(), 0xffffffff); + Box x247 = new Box((int)0); + Box x248 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x247, x248, (x241).get(), 0xffffffff); + Box x249 = new Box((int)0); + Box x250 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x249, x250, (x241).get(), 0xfffffffe); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x251, x252, (x241).get(), 0xbaaedce6); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x253, x254, (x241).get(), 0xaf48a03b); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x255, x256, (x241).get(), 0xbfd25e8c); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x257, x258, (x241).get(), 0xd0364141); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x259, x260, 0x0, (x258).get(), (x255).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x261, x262, (x260).get(), (x256).get(), (x253).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x263, x264, (x262).get(), (x254).get(), (x251).get()); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x265, x266, (x264).get(), (x252).get(), (x249).get()); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x267, x268, (x266).get(), (x250).get(), (x247).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x269, x270, (x268).get(), (x248).get(), (x245).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x271, x272, (x270).get(), (x246).get(), (x243).get()); + int x273 = ((x272).get() + (x244).get()); + Box x274 = new Box((int)0); + Box x275 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x274, x275, 0x0, (x223).get(), (x257).get()); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x276, x277, (x275).get(), (x225).get(), (x259).get()); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x278, x279, (x277).get(), (x227).get(), (x261).get()); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x280, x281, (x279).get(), (x229).get(), (x263).get()); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x282, x283, (x281).get(), (x231).get(), (x265).get()); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x284, x285, (x283).get(), (x233).get(), (x267).get()); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x286, x287, (x285).get(), (x235).get(), (x269).get()); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x288, x289, (x287).get(), (x237).get(), (x271).get()); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x290, x291, (x289).get(), (x239).get(), x273); + int x292 = ((x291).get() + (x240).get()); + Box x293 = new Box((int)0); + Box x294 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x293, x294, x3, (arg2[7])); + Box x295 = new Box((int)0); + Box x296 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x295, x296, x3, (arg2[6])); + Box x297 = new Box((int)0); + Box x298 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x297, x298, x3, (arg2[5])); + Box x299 = new Box((int)0); + Box x300 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x299, x300, x3, (arg2[4])); + Box x301 = new Box((int)0); + Box x302 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x301, x302, x3, (arg2[3])); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x303, x304, x3, (arg2[2])); + Box x305 = new Box((int)0); + Box x306 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x305, x306, x3, (arg2[1])); + Box x307 = new Box((int)0); + Box x308 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x307, x308, x3, (arg2[0])); + Box x309 = new Box((int)0); + Box x310 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x309, x310, 0x0, (x308).get(), (x305).get()); + Box x311 = new Box((int)0); + Box x312 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x311, x312, (x310).get(), (x306).get(), (x303).get()); + Box x313 = new Box((int)0); + Box x314 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x313, x314, (x312).get(), (x304).get(), (x301).get()); + Box x315 = new Box((int)0); + Box x316 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x315, x316, (x314).get(), (x302).get(), (x299).get()); + Box x317 = new Box((int)0); + Box x318 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x317, x318, (x316).get(), (x300).get(), (x297).get()); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x319, x320, (x318).get(), (x298).get(), (x295).get()); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x321, x322, (x320).get(), (x296).get(), (x293).get()); + int x323 = ((x322).get() + (x294).get()); + Box x324 = new Box((int)0); + Box x325 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x324, x325, 0x0, (x276).get(), (x307).get()); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x326, x327, (x325).get(), (x278).get(), (x309).get()); + Box x328 = new Box((int)0); + Box x329 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x328, x329, (x327).get(), (x280).get(), (x311).get()); + Box x330 = new Box((int)0); + Box x331 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x330, x331, (x329).get(), (x282).get(), (x313).get()); + Box x332 = new Box((int)0); + Box x333 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x332, x333, (x331).get(), (x284).get(), (x315).get()); + Box x334 = new Box((int)0); + Box x335 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x334, x335, (x333).get(), (x286).get(), (x317).get()); + Box x336 = new Box((int)0); + Box x337 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x336, x337, (x335).get(), (x288).get(), (x319).get()); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x338, x339, (x337).get(), (x290).get(), (x321).get()); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x340, x341, (x339).get(), x292, x323); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x342, x343, (x324).get(), 0x5588b13f); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x344, x345, (x342).get(), 0xffffffff); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x346, x347, (x342).get(), 0xffffffff); + Box x348 = new Box((int)0); + Box x349 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x348, x349, (x342).get(), 0xffffffff); + Box x350 = new Box((int)0); + Box x351 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x350, x351, (x342).get(), 0xfffffffe); + Box x352 = new Box((int)0); + Box x353 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x352, x353, (x342).get(), 0xbaaedce6); + Box x354 = new Box((int)0); + Box x355 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x354, x355, (x342).get(), 0xaf48a03b); + Box x356 = new Box((int)0); + Box x357 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x356, x357, (x342).get(), 0xbfd25e8c); + Box x358 = new Box((int)0); + Box x359 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x358, x359, (x342).get(), 0xd0364141); + Box x360 = new Box((int)0); + Box x361 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x360, x361, 0x0, (x359).get(), (x356).get()); + Box x362 = new Box((int)0); + Box x363 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x362, x363, (x361).get(), (x357).get(), (x354).get()); + Box x364 = new Box((int)0); + Box x365 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x364, x365, (x363).get(), (x355).get(), (x352).get()); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x366, x367, (x365).get(), (x353).get(), (x350).get()); + Box x368 = new Box((int)0); + Box x369 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x368, x369, (x367).get(), (x351).get(), (x348).get()); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x370, x371, (x369).get(), (x349).get(), (x346).get()); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x372, x373, (x371).get(), (x347).get(), (x344).get()); + int x374 = ((x373).get() + (x345).get()); + Box x375 = new Box((int)0); + Box x376 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x375, x376, 0x0, (x324).get(), (x358).get()); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x377, x378, (x376).get(), (x326).get(), (x360).get()); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x379, x380, (x378).get(), (x328).get(), (x362).get()); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x381, x382, (x380).get(), (x330).get(), (x364).get()); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x383, x384, (x382).get(), (x332).get(), (x366).get()); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x385, x386, (x384).get(), (x334).get(), (x368).get()); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x387, x388, (x386).get(), (x336).get(), (x370).get()); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x389, x390, (x388).get(), (x338).get(), (x372).get()); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x391, x392, (x390).get(), (x340).get(), x374); + int x393 = ((x392).get() + (x341).get()); + Box x394 = new Box((int)0); + Box x395 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x394, x395, x4, (arg2[7])); + Box x396 = new Box((int)0); + Box x397 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x396, x397, x4, (arg2[6])); + Box x398 = new Box((int)0); + Box x399 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x398, x399, x4, (arg2[5])); + Box x400 = new Box((int)0); + Box x401 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x400, x401, x4, (arg2[4])); + Box x402 = new Box((int)0); + Box x403 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x402, x403, x4, (arg2[3])); + Box x404 = new Box((int)0); + Box x405 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x404, x405, x4, (arg2[2])); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x406, x407, x4, (arg2[1])); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x408, x409, x4, (arg2[0])); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x410, x411, 0x0, (x409).get(), (x406).get()); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x412, x413, (x411).get(), (x407).get(), (x404).get()); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x414, x415, (x413).get(), (x405).get(), (x402).get()); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x416, x417, (x415).get(), (x403).get(), (x400).get()); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x418, x419, (x417).get(), (x401).get(), (x398).get()); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x420, x421, (x419).get(), (x399).get(), (x396).get()); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x422, x423, (x421).get(), (x397).get(), (x394).get()); + int x424 = ((x423).get() + (x395).get()); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x425, x426, 0x0, (x377).get(), (x408).get()); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x427, x428, (x426).get(), (x379).get(), (x410).get()); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x429, x430, (x428).get(), (x381).get(), (x412).get()); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x431, x432, (x430).get(), (x383).get(), (x414).get()); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x433, x434, (x432).get(), (x385).get(), (x416).get()); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x435, x436, (x434).get(), (x387).get(), (x418).get()); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x437, x438, (x436).get(), (x389).get(), (x420).get()); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x439, x440, (x438).get(), (x391).get(), (x422).get()); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x441, x442, (x440).get(), x393, x424); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x443, x444, (x425).get(), 0x5588b13f); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x445, x446, (x443).get(), 0xffffffff); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x447, x448, (x443).get(), 0xffffffff); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x449, x450, (x443).get(), 0xffffffff); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x451, x452, (x443).get(), 0xfffffffe); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x453, x454, (x443).get(), 0xbaaedce6); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x455, x456, (x443).get(), 0xaf48a03b); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x457, x458, (x443).get(), 0xbfd25e8c); + Box x459 = new Box((int)0); + Box x460 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x459, x460, (x443).get(), 0xd0364141); + Box x461 = new Box((int)0); + Box x462 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x461, x462, 0x0, (x460).get(), (x457).get()); + Box x463 = new Box((int)0); + Box x464 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x463, x464, (x462).get(), (x458).get(), (x455).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x465, x466, (x464).get(), (x456).get(), (x453).get()); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x467, x468, (x466).get(), (x454).get(), (x451).get()); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x469, x470, (x468).get(), (x452).get(), (x449).get()); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x471, x472, (x470).get(), (x450).get(), (x447).get()); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x473, x474, (x472).get(), (x448).get(), (x445).get()); + int x475 = ((x474).get() + (x446).get()); + Box x476 = new Box((int)0); + Box x477 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x476, x477, 0x0, (x425).get(), (x459).get()); + Box x478 = new Box((int)0); + Box x479 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x478, x479, (x477).get(), (x427).get(), (x461).get()); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x480, x481, (x479).get(), (x429).get(), (x463).get()); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x482, x483, (x481).get(), (x431).get(), (x465).get()); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x484, x485, (x483).get(), (x433).get(), (x467).get()); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x486, x487, (x485).get(), (x435).get(), (x469).get()); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x488, x489, (x487).get(), (x437).get(), (x471).get()); + Box x490 = new Box((int)0); + Box x491 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x490, x491, (x489).get(), (x439).get(), (x473).get()); + Box x492 = new Box((int)0); + Box x493 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x492, x493, (x491).get(), (x441).get(), x475); + int x494 = ((x493).get() + (x442).get()); + Box x495 = new Box((int)0); + Box x496 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x495, x496, x5, (arg2[7])); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x497, x498, x5, (arg2[6])); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x499, x500, x5, (arg2[5])); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x501, x502, x5, (arg2[4])); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x503, x504, x5, (arg2[3])); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x505, x506, x5, (arg2[2])); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x507, x508, x5, (arg2[1])); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x509, x510, x5, (arg2[0])); + Box x511 = new Box((int)0); + Box x512 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x511, x512, 0x0, (x510).get(), (x507).get()); + Box x513 = new Box((int)0); + Box x514 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x513, x514, (x512).get(), (x508).get(), (x505).get()); + Box x515 = new Box((int)0); + Box x516 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x515, x516, (x514).get(), (x506).get(), (x503).get()); + Box x517 = new Box((int)0); + Box x518 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x517, x518, (x516).get(), (x504).get(), (x501).get()); + Box x519 = new Box((int)0); + Box x520 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x519, x520, (x518).get(), (x502).get(), (x499).get()); + Box x521 = new Box((int)0); + Box x522 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x521, x522, (x520).get(), (x500).get(), (x497).get()); + Box x523 = new Box((int)0); + Box x524 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x523, x524, (x522).get(), (x498).get(), (x495).get()); + int x525 = ((x524).get() + (x496).get()); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x526, x527, 0x0, (x478).get(), (x509).get()); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x528, x529, (x527).get(), (x480).get(), (x511).get()); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x530, x531, (x529).get(), (x482).get(), (x513).get()); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x532, x533, (x531).get(), (x484).get(), (x515).get()); + Box x534 = new Box((int)0); + Box x535 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x534, x535, (x533).get(), (x486).get(), (x517).get()); + Box x536 = new Box((int)0); + Box x537 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x536, x537, (x535).get(), (x488).get(), (x519).get()); + Box x538 = new Box((int)0); + Box x539 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x538, x539, (x537).get(), (x490).get(), (x521).get()); + Box x540 = new Box((int)0); + Box x541 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x540, x541, (x539).get(), (x492).get(), (x523).get()); + Box x542 = new Box((int)0); + Box x543 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x542, x543, (x541).get(), x494, x525); + Box x544 = new Box((int)0); + Box x545 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x544, x545, (x526).get(), 0x5588b13f); + Box x546 = new Box((int)0); + Box x547 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x546, x547, (x544).get(), 0xffffffff); + Box x548 = new Box((int)0); + Box x549 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x548, x549, (x544).get(), 0xffffffff); + Box x550 = new Box((int)0); + Box x551 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x550, x551, (x544).get(), 0xffffffff); + Box x552 = new Box((int)0); + Box x553 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x552, x553, (x544).get(), 0xfffffffe); + Box x554 = new Box((int)0); + Box x555 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x554, x555, (x544).get(), 0xbaaedce6); + Box x556 = new Box((int)0); + Box x557 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x556, x557, (x544).get(), 0xaf48a03b); + Box x558 = new Box((int)0); + Box x559 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x558, x559, (x544).get(), 0xbfd25e8c); + Box x560 = new Box((int)0); + Box x561 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x560, x561, (x544).get(), 0xd0364141); + Box x562 = new Box((int)0); + Box x563 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x562, x563, 0x0, (x561).get(), (x558).get()); + Box x564 = new Box((int)0); + Box x565 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x564, x565, (x563).get(), (x559).get(), (x556).get()); + Box x566 = new Box((int)0); + Box x567 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x566, x567, (x565).get(), (x557).get(), (x554).get()); + Box x568 = new Box((int)0); + Box x569 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x568, x569, (x567).get(), (x555).get(), (x552).get()); + Box x570 = new Box((int)0); + Box x571 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x570, x571, (x569).get(), (x553).get(), (x550).get()); + Box x572 = new Box((int)0); + Box x573 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x572, x573, (x571).get(), (x551).get(), (x548).get()); + Box x574 = new Box((int)0); + Box x575 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x574, x575, (x573).get(), (x549).get(), (x546).get()); + int x576 = ((x575).get() + (x547).get()); + Box x577 = new Box((int)0); + Box x578 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x577, x578, 0x0, (x526).get(), (x560).get()); + Box x579 = new Box((int)0); + Box x580 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x579, x580, (x578).get(), (x528).get(), (x562).get()); + Box x581 = new Box((int)0); + Box x582 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x581, x582, (x580).get(), (x530).get(), (x564).get()); + Box x583 = new Box((int)0); + Box x584 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x583, x584, (x582).get(), (x532).get(), (x566).get()); + Box x585 = new Box((int)0); + Box x586 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x585, x586, (x584).get(), (x534).get(), (x568).get()); + Box x587 = new Box((int)0); + Box x588 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x587, x588, (x586).get(), (x536).get(), (x570).get()); + Box x589 = new Box((int)0); + Box x590 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x589, x590, (x588).get(), (x538).get(), (x572).get()); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x591, x592, (x590).get(), (x540).get(), (x574).get()); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x593, x594, (x592).get(), (x542).get(), x576); + int x595 = ((x594).get() + (x543).get()); + Box x596 = new Box((int)0); + Box x597 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x596, x597, x6, (arg2[7])); + Box x598 = new Box((int)0); + Box x599 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x598, x599, x6, (arg2[6])); + Box x600 = new Box((int)0); + Box x601 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x600, x601, x6, (arg2[5])); + Box x602 = new Box((int)0); + Box x603 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x602, x603, x6, (arg2[4])); + Box x604 = new Box((int)0); + Box x605 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x604, x605, x6, (arg2[3])); + Box x606 = new Box((int)0); + Box x607 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x606, x607, x6, (arg2[2])); + Box x608 = new Box((int)0); + Box x609 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x608, x609, x6, (arg2[1])); + Box x610 = new Box((int)0); + Box x611 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x610, x611, x6, (arg2[0])); + Box x612 = new Box((int)0); + Box x613 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x612, x613, 0x0, (x611).get(), (x608).get()); + Box x614 = new Box((int)0); + Box x615 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x614, x615, (x613).get(), (x609).get(), (x606).get()); + Box x616 = new Box((int)0); + Box x617 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x616, x617, (x615).get(), (x607).get(), (x604).get()); + Box x618 = new Box((int)0); + Box x619 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x618, x619, (x617).get(), (x605).get(), (x602).get()); + Box x620 = new Box((int)0); + Box x621 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x620, x621, (x619).get(), (x603).get(), (x600).get()); + Box x622 = new Box((int)0); + Box x623 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x622, x623, (x621).get(), (x601).get(), (x598).get()); + Box x624 = new Box((int)0); + Box x625 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x624, x625, (x623).get(), (x599).get(), (x596).get()); + int x626 = ((x625).get() + (x597).get()); + Box x627 = new Box((int)0); + Box x628 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x627, x628, 0x0, (x579).get(), (x610).get()); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x629, x630, (x628).get(), (x581).get(), (x612).get()); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x631, x632, (x630).get(), (x583).get(), (x614).get()); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x633, x634, (x632).get(), (x585).get(), (x616).get()); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x635, x636, (x634).get(), (x587).get(), (x618).get()); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x637, x638, (x636).get(), (x589).get(), (x620).get()); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x639, x640, (x638).get(), (x591).get(), (x622).get()); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x641, x642, (x640).get(), (x593).get(), (x624).get()); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x643, x644, (x642).get(), x595, x626); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x645, x646, (x627).get(), 0x5588b13f); + Box x647 = new Box((int)0); + Box x648 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x647, x648, (x645).get(), 0xffffffff); + Box x649 = new Box((int)0); + Box x650 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x649, x650, (x645).get(), 0xffffffff); + Box x651 = new Box((int)0); + Box x652 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x651, x652, (x645).get(), 0xffffffff); + Box x653 = new Box((int)0); + Box x654 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x653, x654, (x645).get(), 0xfffffffe); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x655, x656, (x645).get(), 0xbaaedce6); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x657, x658, (x645).get(), 0xaf48a03b); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x659, x660, (x645).get(), 0xbfd25e8c); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x661, x662, (x645).get(), 0xd0364141); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x663, x664, 0x0, (x662).get(), (x659).get()); + Box x665 = new Box((int)0); + Box x666 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x665, x666, (x664).get(), (x660).get(), (x657).get()); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x667, x668, (x666).get(), (x658).get(), (x655).get()); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x669, x670, (x668).get(), (x656).get(), (x653).get()); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x671, x672, (x670).get(), (x654).get(), (x651).get()); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x673, x674, (x672).get(), (x652).get(), (x649).get()); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x675, x676, (x674).get(), (x650).get(), (x647).get()); + int x677 = ((x676).get() + (x648).get()); + Box x678 = new Box((int)0); + Box x679 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x678, x679, 0x0, (x627).get(), (x661).get()); + Box x680 = new Box((int)0); + Box x681 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x680, x681, (x679).get(), (x629).get(), (x663).get()); + Box x682 = new Box((int)0); + Box x683 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x682, x683, (x681).get(), (x631).get(), (x665).get()); + Box x684 = new Box((int)0); + Box x685 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x684, x685, (x683).get(), (x633).get(), (x667).get()); + Box x686 = new Box((int)0); + Box x687 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x686, x687, (x685).get(), (x635).get(), (x669).get()); + Box x688 = new Box((int)0); + Box x689 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x688, x689, (x687).get(), (x637).get(), (x671).get()); + Box x690 = new Box((int)0); + Box x691 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x690, x691, (x689).get(), (x639).get(), (x673).get()); + Box x692 = new Box((int)0); + Box x693 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x692, x693, (x691).get(), (x641).get(), (x675).get()); + Box x694 = new Box((int)0); + Box x695 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x694, x695, (x693).get(), (x643).get(), x677); + int x696 = ((x695).get() + (x644).get()); + Box x697 = new Box((int)0); + Box x698 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x697, x698, x7, (arg2[7])); + Box x699 = new Box((int)0); + Box x700 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x699, x700, x7, (arg2[6])); + Box x701 = new Box((int)0); + Box x702 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x701, x702, x7, (arg2[5])); + Box x703 = new Box((int)0); + Box x704 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x703, x704, x7, (arg2[4])); + Box x705 = new Box((int)0); + Box x706 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x705, x706, x7, (arg2[3])); + Box x707 = new Box((int)0); + Box x708 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x707, x708, x7, (arg2[2])); + Box x709 = new Box((int)0); + Box x710 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x709, x710, x7, (arg2[1])); + Box x711 = new Box((int)0); + Box x712 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x711, x712, x7, (arg2[0])); + Box x713 = new Box((int)0); + Box x714 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x713, x714, 0x0, (x712).get(), (x709).get()); + Box x715 = new Box((int)0); + Box x716 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x715, x716, (x714).get(), (x710).get(), (x707).get()); + Box x717 = new Box((int)0); + Box x718 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x717, x718, (x716).get(), (x708).get(), (x705).get()); + Box x719 = new Box((int)0); + Box x720 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x719, x720, (x718).get(), (x706).get(), (x703).get()); + Box x721 = new Box((int)0); + Box x722 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x721, x722, (x720).get(), (x704).get(), (x701).get()); + Box x723 = new Box((int)0); + Box x724 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x723, x724, (x722).get(), (x702).get(), (x699).get()); + Box x725 = new Box((int)0); + Box x726 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x725, x726, (x724).get(), (x700).get(), (x697).get()); + int x727 = ((x726).get() + (x698).get()); + Box x728 = new Box((int)0); + Box x729 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x728, x729, 0x0, (x680).get(), (x711).get()); + Box x730 = new Box((int)0); + Box x731 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x730, x731, (x729).get(), (x682).get(), (x713).get()); + Box x732 = new Box((int)0); + Box x733 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x732, x733, (x731).get(), (x684).get(), (x715).get()); + Box x734 = new Box((int)0); + Box x735 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x734, x735, (x733).get(), (x686).get(), (x717).get()); + Box x736 = new Box((int)0); + Box x737 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x736, x737, (x735).get(), (x688).get(), (x719).get()); + Box x738 = new Box((int)0); + Box x739 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x738, x739, (x737).get(), (x690).get(), (x721).get()); + Box x740 = new Box((int)0); + Box x741 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x740, x741, (x739).get(), (x692).get(), (x723).get()); + Box x742 = new Box((int)0); + Box x743 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x742, x743, (x741).get(), (x694).get(), (x725).get()); + Box x744 = new Box((int)0); + Box x745 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x744, x745, (x743).get(), x696, x727); + Box x746 = new Box((int)0); + Box x747 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x746, x747, (x728).get(), 0x5588b13f); + Box x748 = new Box((int)0); + Box x749 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x748, x749, (x746).get(), 0xffffffff); + Box x750 = new Box((int)0); + Box x751 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x750, x751, (x746).get(), 0xffffffff); + Box x752 = new Box((int)0); + Box x753 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x752, x753, (x746).get(), 0xffffffff); + Box x754 = new Box((int)0); + Box x755 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x754, x755, (x746).get(), 0xfffffffe); + Box x756 = new Box((int)0); + Box x757 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x756, x757, (x746).get(), 0xbaaedce6); + Box x758 = new Box((int)0); + Box x759 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x758, x759, (x746).get(), 0xaf48a03b); + Box x760 = new Box((int)0); + Box x761 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x760, x761, (x746).get(), 0xbfd25e8c); + Box x762 = new Box((int)0); + Box x763 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x762, x763, (x746).get(), 0xd0364141); + Box x764 = new Box((int)0); + Box x765 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x764, x765, 0x0, (x763).get(), (x760).get()); + Box x766 = new Box((int)0); + Box x767 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x766, x767, (x765).get(), (x761).get(), (x758).get()); + Box x768 = new Box((int)0); + Box x769 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x768, x769, (x767).get(), (x759).get(), (x756).get()); + Box x770 = new Box((int)0); + Box x771 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x770, x771, (x769).get(), (x757).get(), (x754).get()); + Box x772 = new Box((int)0); + Box x773 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x772, x773, (x771).get(), (x755).get(), (x752).get()); + Box x774 = new Box((int)0); + Box x775 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x774, x775, (x773).get(), (x753).get(), (x750).get()); + Box x776 = new Box((int)0); + Box x777 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x776, x777, (x775).get(), (x751).get(), (x748).get()); + int x778 = ((x777).get() + (x749).get()); + Box x779 = new Box((int)0); + Box x780 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x779, x780, 0x0, (x728).get(), (x762).get()); + Box x781 = new Box((int)0); + Box x782 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x781, x782, (x780).get(), (x730).get(), (x764).get()); + Box x783 = new Box((int)0); + Box x784 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x783, x784, (x782).get(), (x732).get(), (x766).get()); + Box x785 = new Box((int)0); + Box x786 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x785, x786, (x784).get(), (x734).get(), (x768).get()); + Box x787 = new Box((int)0); + Box x788 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x787, x788, (x786).get(), (x736).get(), (x770).get()); + Box x789 = new Box((int)0); + Box x790 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x789, x790, (x788).get(), (x738).get(), (x772).get()); + Box x791 = new Box((int)0); + Box x792 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x791, x792, (x790).get(), (x740).get(), (x774).get()); + Box x793 = new Box((int)0); + Box x794 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x793, x794, (x792).get(), (x742).get(), (x776).get()); + Box x795 = new Box((int)0); + Box x796 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x795, x796, (x794).get(), (x744).get(), x778); + int x797 = ((x796).get() + (x745).get()); + Box x798 = new Box((int)0); + Box x799 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x798, x799, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x781).get(), 0xd0364141); + Box x800 = new Box((int)0); + Box x801 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x800, x801, (x799).get(), (x783).get(), 0xbfd25e8c); + Box x802 = new Box((int)0); + Box x803 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x802, x803, (x801).get(), (x785).get(), 0xaf48a03b); + Box x804 = new Box((int)0); + Box x805 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x804, x805, (x803).get(), (x787).get(), 0xbaaedce6); + Box x806 = new Box((int)0); + Box x807 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x806, x807, (x805).get(), (x789).get(), 0xfffffffe); + Box x808 = new Box((int)0); + Box x809 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x808, x809, (x807).get(), (x791).get(), 0xffffffff); + Box x810 = new Box((int)0); + Box x811 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x810, x811, (x809).get(), (x793).get(), 0xffffffff); + Box x812 = new Box((int)0); + Box x813 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x812, x813, (x811).get(), (x795).get(), 0xffffffff); + Box x814 = new Box((int)0); + Box x815 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x814, x815, (x813).get(), x797, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x816 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x816, (x815).get(), (x798).get(), (x781).get()); + Box x817 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x817, (x815).get(), (x800).get(), (x783).get()); + Box x818 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x818, (x815).get(), (x802).get(), (x785).get()); + Box x819 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x819, (x815).get(), (x804).get(), (x787).get()); + Box x820 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x820, (x815).get(), (x806).get(), (x789).get()); + Box x821 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x821, (x815).get(), (x808).get(), (x791).get()); + Box x822 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x822, (x815).get(), (x810).get(), (x793).get()); + Box x823 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x823, (x815).get(), (x812).get(), (x795).get()); + out1[0] = (x816).get(); + out1[1] = (x817).get(); + out1[2] = (x818).get(); + out1[3] = (x819).get(); + out1[4] = (x820).get(); + out1[5] = (x821).get(); + out1[6] = (x822).get(); + out1[7] = (x823).get(); +} + +/** + * The function fiat_Secp256K1Scalar_square squares a field element in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_square(int[] out1, final int[] arg1) { + int x1 = (arg1[1]); + int x2 = (arg1[2]); + int x3 = (arg1[3]); + int x4 = (arg1[4]); + int x5 = (arg1[5]); + int x6 = (arg1[6]); + int x7 = (arg1[7]); + int x8 = (arg1[0]); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x9, x10, x8, (arg1[7])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x11, x12, x8, (arg1[6])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x13, x14, x8, (arg1[5])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x15, x16, x8, (arg1[4])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x17, x18, x8, (arg1[3])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x19, x20, x8, (arg1[2])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x21, x22, x8, (arg1[1])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x23, x24, x8, (arg1[0])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x37, x38, (x36).get(), (x12).get(), (x9).get()); + int x39 = ((x38).get() + (x10).get()); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x40, x41, (x23).get(), 0x5588b13f); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x42, x43, (x40).get(), 0xffffffff); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x44, x45, (x40).get(), 0xffffffff); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x46, x47, (x40).get(), 0xffffffff); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x48, x49, (x40).get(), 0xfffffffe); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x50, x51, (x40).get(), 0xbaaedce6); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x52, x53, (x40).get(), 0xaf48a03b); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x54, x55, (x40).get(), 0xbfd25e8c); + Box x56 = new Box((int)0); + Box x57 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x56, x57, (x40).get(), 0xd0364141); + Box x58 = new Box((int)0); + Box x59 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x58, x59, 0x0, (x57).get(), (x54).get()); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x60, x61, (x59).get(), (x55).get(), (x52).get()); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x62, x63, (x61).get(), (x53).get(), (x50).get()); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x64, x65, (x63).get(), (x51).get(), (x48).get()); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x66, x67, (x65).get(), (x49).get(), (x46).get()); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x68, x69, (x67).get(), (x47).get(), (x44).get()); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x70, x71, (x69).get(), (x45).get(), (x42).get()); + int x72 = ((x71).get() + (x43).get()); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x73, x74, 0x0, (x23).get(), (x56).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x75, x76, (x74).get(), (x25).get(), (x58).get()); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x77, x78, (x76).get(), (x27).get(), (x60).get()); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x79, x80, (x78).get(), (x29).get(), (x62).get()); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x81, x82, (x80).get(), (x31).get(), (x64).get()); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x83, x84, (x82).get(), (x33).get(), (x66).get()); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x85, x86, (x84).get(), (x35).get(), (x68).get()); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x87, x88, (x86).get(), (x37).get(), (x70).get()); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x89, x90, (x88).get(), x39, x72); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x91, x92, x1, (arg1[7])); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x93, x94, x1, (arg1[6])); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x95, x96, x1, (arg1[5])); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x97, x98, x1, (arg1[4])); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x99, x100, x1, (arg1[3])); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x101, x102, x1, (arg1[2])); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x103, x104, x1, (arg1[1])); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x105, x106, x1, (arg1[0])); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x107, x108, 0x0, (x106).get(), (x103).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x109, x110, (x108).get(), (x104).get(), (x101).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x111, x112, (x110).get(), (x102).get(), (x99).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x113, x114, (x112).get(), (x100).get(), (x97).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x115, x116, (x114).get(), (x98).get(), (x95).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x117, x118, (x116).get(), (x96).get(), (x93).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x119, x120, (x118).get(), (x94).get(), (x91).get()); + int x121 = ((x120).get() + (x92).get()); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x122, x123, 0x0, (x75).get(), (x105).get()); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x124, x125, (x123).get(), (x77).get(), (x107).get()); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x126, x127, (x125).get(), (x79).get(), (x109).get()); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x128, x129, (x127).get(), (x81).get(), (x111).get()); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x130, x131, (x129).get(), (x83).get(), (x113).get()); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x132, x133, (x131).get(), (x85).get(), (x115).get()); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x134, x135, (x133).get(), (x87).get(), (x117).get()); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x136, x137, (x135).get(), (x89).get(), (x119).get()); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x138, x139, (x137).get(), (x90).get(), x121); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x140, x141, (x122).get(), 0x5588b13f); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x142, x143, (x140).get(), 0xffffffff); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x144, x145, (x140).get(), 0xffffffff); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x146, x147, (x140).get(), 0xffffffff); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x148, x149, (x140).get(), 0xfffffffe); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x150, x151, (x140).get(), 0xbaaedce6); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x152, x153, (x140).get(), 0xaf48a03b); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x154, x155, (x140).get(), 0xbfd25e8c); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x156, x157, (x140).get(), 0xd0364141); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x158, x159, 0x0, (x157).get(), (x154).get()); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x160, x161, (x159).get(), (x155).get(), (x152).get()); + Box x162 = new Box((int)0); + Box x163 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x162, x163, (x161).get(), (x153).get(), (x150).get()); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x164, x165, (x163).get(), (x151).get(), (x148).get()); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x166, x167, (x165).get(), (x149).get(), (x146).get()); + Box x168 = new Box((int)0); + Box x169 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x168, x169, (x167).get(), (x147).get(), (x144).get()); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x170, x171, (x169).get(), (x145).get(), (x142).get()); + int x172 = ((x171).get() + (x143).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x173, x174, 0x0, (x122).get(), (x156).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x175, x176, (x174).get(), (x124).get(), (x158).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x177, x178, (x176).get(), (x126).get(), (x160).get()); + Box x179 = new Box((int)0); + Box x180 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x179, x180, (x178).get(), (x128).get(), (x162).get()); + Box x181 = new Box((int)0); + Box x182 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x181, x182, (x180).get(), (x130).get(), (x164).get()); + Box x183 = new Box((int)0); + Box x184 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x183, x184, (x182).get(), (x132).get(), (x166).get()); + Box x185 = new Box((int)0); + Box x186 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x185, x186, (x184).get(), (x134).get(), (x168).get()); + Box x187 = new Box((int)0); + Box x188 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x187, x188, (x186).get(), (x136).get(), (x170).get()); + Box x189 = new Box((int)0); + Box x190 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x189, x190, (x188).get(), (x138).get(), x172); + int x191 = ((x190).get() + (x139).get()); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x192, x193, x2, (arg1[7])); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x194, x195, x2, (arg1[6])); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x196, x197, x2, (arg1[5])); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x198, x199, x2, (arg1[4])); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x200, x201, x2, (arg1[3])); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x202, x203, x2, (arg1[2])); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x204, x205, x2, (arg1[1])); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x206, x207, x2, (arg1[0])); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x208, x209, 0x0, (x207).get(), (x204).get()); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x210, x211, (x209).get(), (x205).get(), (x202).get()); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x212, x213, (x211).get(), (x203).get(), (x200).get()); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x214, x215, (x213).get(), (x201).get(), (x198).get()); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x216, x217, (x215).get(), (x199).get(), (x196).get()); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x218, x219, (x217).get(), (x197).get(), (x194).get()); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x220, x221, (x219).get(), (x195).get(), (x192).get()); + int x222 = ((x221).get() + (x193).get()); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x223, x224, 0x0, (x175).get(), (x206).get()); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x225, x226, (x224).get(), (x177).get(), (x208).get()); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x227, x228, (x226).get(), (x179).get(), (x210).get()); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x229, x230, (x228).get(), (x181).get(), (x212).get()); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x231, x232, (x230).get(), (x183).get(), (x214).get()); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x233, x234, (x232).get(), (x185).get(), (x216).get()); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x235, x236, (x234).get(), (x187).get(), (x218).get()); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x237, x238, (x236).get(), (x189).get(), (x220).get()); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x239, x240, (x238).get(), x191, x222); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x241, x242, (x223).get(), 0x5588b13f); + Box x243 = new Box((int)0); + Box x244 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x243, x244, (x241).get(), 0xffffffff); + Box x245 = new Box((int)0); + Box x246 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x245, x246, (x241).get(), 0xffffffff); + Box x247 = new Box((int)0); + Box x248 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x247, x248, (x241).get(), 0xffffffff); + Box x249 = new Box((int)0); + Box x250 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x249, x250, (x241).get(), 0xfffffffe); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x251, x252, (x241).get(), 0xbaaedce6); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x253, x254, (x241).get(), 0xaf48a03b); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x255, x256, (x241).get(), 0xbfd25e8c); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x257, x258, (x241).get(), 0xd0364141); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x259, x260, 0x0, (x258).get(), (x255).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x261, x262, (x260).get(), (x256).get(), (x253).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x263, x264, (x262).get(), (x254).get(), (x251).get()); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x265, x266, (x264).get(), (x252).get(), (x249).get()); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x267, x268, (x266).get(), (x250).get(), (x247).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x269, x270, (x268).get(), (x248).get(), (x245).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x271, x272, (x270).get(), (x246).get(), (x243).get()); + int x273 = ((x272).get() + (x244).get()); + Box x274 = new Box((int)0); + Box x275 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x274, x275, 0x0, (x223).get(), (x257).get()); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x276, x277, (x275).get(), (x225).get(), (x259).get()); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x278, x279, (x277).get(), (x227).get(), (x261).get()); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x280, x281, (x279).get(), (x229).get(), (x263).get()); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x282, x283, (x281).get(), (x231).get(), (x265).get()); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x284, x285, (x283).get(), (x233).get(), (x267).get()); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x286, x287, (x285).get(), (x235).get(), (x269).get()); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x288, x289, (x287).get(), (x237).get(), (x271).get()); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x290, x291, (x289).get(), (x239).get(), x273); + int x292 = ((x291).get() + (x240).get()); + Box x293 = new Box((int)0); + Box x294 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x293, x294, x3, (arg1[7])); + Box x295 = new Box((int)0); + Box x296 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x295, x296, x3, (arg1[6])); + Box x297 = new Box((int)0); + Box x298 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x297, x298, x3, (arg1[5])); + Box x299 = new Box((int)0); + Box x300 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x299, x300, x3, (arg1[4])); + Box x301 = new Box((int)0); + Box x302 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x301, x302, x3, (arg1[3])); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x303, x304, x3, (arg1[2])); + Box x305 = new Box((int)0); + Box x306 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x305, x306, x3, (arg1[1])); + Box x307 = new Box((int)0); + Box x308 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x307, x308, x3, (arg1[0])); + Box x309 = new Box((int)0); + Box x310 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x309, x310, 0x0, (x308).get(), (x305).get()); + Box x311 = new Box((int)0); + Box x312 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x311, x312, (x310).get(), (x306).get(), (x303).get()); + Box x313 = new Box((int)0); + Box x314 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x313, x314, (x312).get(), (x304).get(), (x301).get()); + Box x315 = new Box((int)0); + Box x316 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x315, x316, (x314).get(), (x302).get(), (x299).get()); + Box x317 = new Box((int)0); + Box x318 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x317, x318, (x316).get(), (x300).get(), (x297).get()); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x319, x320, (x318).get(), (x298).get(), (x295).get()); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x321, x322, (x320).get(), (x296).get(), (x293).get()); + int x323 = ((x322).get() + (x294).get()); + Box x324 = new Box((int)0); + Box x325 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x324, x325, 0x0, (x276).get(), (x307).get()); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x326, x327, (x325).get(), (x278).get(), (x309).get()); + Box x328 = new Box((int)0); + Box x329 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x328, x329, (x327).get(), (x280).get(), (x311).get()); + Box x330 = new Box((int)0); + Box x331 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x330, x331, (x329).get(), (x282).get(), (x313).get()); + Box x332 = new Box((int)0); + Box x333 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x332, x333, (x331).get(), (x284).get(), (x315).get()); + Box x334 = new Box((int)0); + Box x335 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x334, x335, (x333).get(), (x286).get(), (x317).get()); + Box x336 = new Box((int)0); + Box x337 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x336, x337, (x335).get(), (x288).get(), (x319).get()); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x338, x339, (x337).get(), (x290).get(), (x321).get()); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x340, x341, (x339).get(), x292, x323); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x342, x343, (x324).get(), 0x5588b13f); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x344, x345, (x342).get(), 0xffffffff); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x346, x347, (x342).get(), 0xffffffff); + Box x348 = new Box((int)0); + Box x349 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x348, x349, (x342).get(), 0xffffffff); + Box x350 = new Box((int)0); + Box x351 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x350, x351, (x342).get(), 0xfffffffe); + Box x352 = new Box((int)0); + Box x353 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x352, x353, (x342).get(), 0xbaaedce6); + Box x354 = new Box((int)0); + Box x355 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x354, x355, (x342).get(), 0xaf48a03b); + Box x356 = new Box((int)0); + Box x357 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x356, x357, (x342).get(), 0xbfd25e8c); + Box x358 = new Box((int)0); + Box x359 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x358, x359, (x342).get(), 0xd0364141); + Box x360 = new Box((int)0); + Box x361 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x360, x361, 0x0, (x359).get(), (x356).get()); + Box x362 = new Box((int)0); + Box x363 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x362, x363, (x361).get(), (x357).get(), (x354).get()); + Box x364 = new Box((int)0); + Box x365 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x364, x365, (x363).get(), (x355).get(), (x352).get()); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x366, x367, (x365).get(), (x353).get(), (x350).get()); + Box x368 = new Box((int)0); + Box x369 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x368, x369, (x367).get(), (x351).get(), (x348).get()); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x370, x371, (x369).get(), (x349).get(), (x346).get()); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x372, x373, (x371).get(), (x347).get(), (x344).get()); + int x374 = ((x373).get() + (x345).get()); + Box x375 = new Box((int)0); + Box x376 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x375, x376, 0x0, (x324).get(), (x358).get()); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x377, x378, (x376).get(), (x326).get(), (x360).get()); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x379, x380, (x378).get(), (x328).get(), (x362).get()); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x381, x382, (x380).get(), (x330).get(), (x364).get()); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x383, x384, (x382).get(), (x332).get(), (x366).get()); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x385, x386, (x384).get(), (x334).get(), (x368).get()); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x387, x388, (x386).get(), (x336).get(), (x370).get()); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x389, x390, (x388).get(), (x338).get(), (x372).get()); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x391, x392, (x390).get(), (x340).get(), x374); + int x393 = ((x392).get() + (x341).get()); + Box x394 = new Box((int)0); + Box x395 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x394, x395, x4, (arg1[7])); + Box x396 = new Box((int)0); + Box x397 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x396, x397, x4, (arg1[6])); + Box x398 = new Box((int)0); + Box x399 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x398, x399, x4, (arg1[5])); + Box x400 = new Box((int)0); + Box x401 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x400, x401, x4, (arg1[4])); + Box x402 = new Box((int)0); + Box x403 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x402, x403, x4, (arg1[3])); + Box x404 = new Box((int)0); + Box x405 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x404, x405, x4, (arg1[2])); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x406, x407, x4, (arg1[1])); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x408, x409, x4, (arg1[0])); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x410, x411, 0x0, (x409).get(), (x406).get()); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x412, x413, (x411).get(), (x407).get(), (x404).get()); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x414, x415, (x413).get(), (x405).get(), (x402).get()); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x416, x417, (x415).get(), (x403).get(), (x400).get()); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x418, x419, (x417).get(), (x401).get(), (x398).get()); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x420, x421, (x419).get(), (x399).get(), (x396).get()); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x422, x423, (x421).get(), (x397).get(), (x394).get()); + int x424 = ((x423).get() + (x395).get()); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x425, x426, 0x0, (x377).get(), (x408).get()); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x427, x428, (x426).get(), (x379).get(), (x410).get()); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x429, x430, (x428).get(), (x381).get(), (x412).get()); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x431, x432, (x430).get(), (x383).get(), (x414).get()); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x433, x434, (x432).get(), (x385).get(), (x416).get()); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x435, x436, (x434).get(), (x387).get(), (x418).get()); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x437, x438, (x436).get(), (x389).get(), (x420).get()); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x439, x440, (x438).get(), (x391).get(), (x422).get()); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x441, x442, (x440).get(), x393, x424); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x443, x444, (x425).get(), 0x5588b13f); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x445, x446, (x443).get(), 0xffffffff); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x447, x448, (x443).get(), 0xffffffff); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x449, x450, (x443).get(), 0xffffffff); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x451, x452, (x443).get(), 0xfffffffe); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x453, x454, (x443).get(), 0xbaaedce6); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x455, x456, (x443).get(), 0xaf48a03b); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x457, x458, (x443).get(), 0xbfd25e8c); + Box x459 = new Box((int)0); + Box x460 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x459, x460, (x443).get(), 0xd0364141); + Box x461 = new Box((int)0); + Box x462 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x461, x462, 0x0, (x460).get(), (x457).get()); + Box x463 = new Box((int)0); + Box x464 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x463, x464, (x462).get(), (x458).get(), (x455).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x465, x466, (x464).get(), (x456).get(), (x453).get()); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x467, x468, (x466).get(), (x454).get(), (x451).get()); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x469, x470, (x468).get(), (x452).get(), (x449).get()); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x471, x472, (x470).get(), (x450).get(), (x447).get()); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x473, x474, (x472).get(), (x448).get(), (x445).get()); + int x475 = ((x474).get() + (x446).get()); + Box x476 = new Box((int)0); + Box x477 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x476, x477, 0x0, (x425).get(), (x459).get()); + Box x478 = new Box((int)0); + Box x479 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x478, x479, (x477).get(), (x427).get(), (x461).get()); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x480, x481, (x479).get(), (x429).get(), (x463).get()); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x482, x483, (x481).get(), (x431).get(), (x465).get()); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x484, x485, (x483).get(), (x433).get(), (x467).get()); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x486, x487, (x485).get(), (x435).get(), (x469).get()); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x488, x489, (x487).get(), (x437).get(), (x471).get()); + Box x490 = new Box((int)0); + Box x491 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x490, x491, (x489).get(), (x439).get(), (x473).get()); + Box x492 = new Box((int)0); + Box x493 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x492, x493, (x491).get(), (x441).get(), x475); + int x494 = ((x493).get() + (x442).get()); + Box x495 = new Box((int)0); + Box x496 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x495, x496, x5, (arg1[7])); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x497, x498, x5, (arg1[6])); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x499, x500, x5, (arg1[5])); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x501, x502, x5, (arg1[4])); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x503, x504, x5, (arg1[3])); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x505, x506, x5, (arg1[2])); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x507, x508, x5, (arg1[1])); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x509, x510, x5, (arg1[0])); + Box x511 = new Box((int)0); + Box x512 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x511, x512, 0x0, (x510).get(), (x507).get()); + Box x513 = new Box((int)0); + Box x514 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x513, x514, (x512).get(), (x508).get(), (x505).get()); + Box x515 = new Box((int)0); + Box x516 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x515, x516, (x514).get(), (x506).get(), (x503).get()); + Box x517 = new Box((int)0); + Box x518 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x517, x518, (x516).get(), (x504).get(), (x501).get()); + Box x519 = new Box((int)0); + Box x520 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x519, x520, (x518).get(), (x502).get(), (x499).get()); + Box x521 = new Box((int)0); + Box x522 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x521, x522, (x520).get(), (x500).get(), (x497).get()); + Box x523 = new Box((int)0); + Box x524 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x523, x524, (x522).get(), (x498).get(), (x495).get()); + int x525 = ((x524).get() + (x496).get()); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x526, x527, 0x0, (x478).get(), (x509).get()); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x528, x529, (x527).get(), (x480).get(), (x511).get()); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x530, x531, (x529).get(), (x482).get(), (x513).get()); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x532, x533, (x531).get(), (x484).get(), (x515).get()); + Box x534 = new Box((int)0); + Box x535 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x534, x535, (x533).get(), (x486).get(), (x517).get()); + Box x536 = new Box((int)0); + Box x537 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x536, x537, (x535).get(), (x488).get(), (x519).get()); + Box x538 = new Box((int)0); + Box x539 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x538, x539, (x537).get(), (x490).get(), (x521).get()); + Box x540 = new Box((int)0); + Box x541 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x540, x541, (x539).get(), (x492).get(), (x523).get()); + Box x542 = new Box((int)0); + Box x543 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x542, x543, (x541).get(), x494, x525); + Box x544 = new Box((int)0); + Box x545 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x544, x545, (x526).get(), 0x5588b13f); + Box x546 = new Box((int)0); + Box x547 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x546, x547, (x544).get(), 0xffffffff); + Box x548 = new Box((int)0); + Box x549 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x548, x549, (x544).get(), 0xffffffff); + Box x550 = new Box((int)0); + Box x551 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x550, x551, (x544).get(), 0xffffffff); + Box x552 = new Box((int)0); + Box x553 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x552, x553, (x544).get(), 0xfffffffe); + Box x554 = new Box((int)0); + Box x555 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x554, x555, (x544).get(), 0xbaaedce6); + Box x556 = new Box((int)0); + Box x557 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x556, x557, (x544).get(), 0xaf48a03b); + Box x558 = new Box((int)0); + Box x559 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x558, x559, (x544).get(), 0xbfd25e8c); + Box x560 = new Box((int)0); + Box x561 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x560, x561, (x544).get(), 0xd0364141); + Box x562 = new Box((int)0); + Box x563 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x562, x563, 0x0, (x561).get(), (x558).get()); + Box x564 = new Box((int)0); + Box x565 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x564, x565, (x563).get(), (x559).get(), (x556).get()); + Box x566 = new Box((int)0); + Box x567 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x566, x567, (x565).get(), (x557).get(), (x554).get()); + Box x568 = new Box((int)0); + Box x569 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x568, x569, (x567).get(), (x555).get(), (x552).get()); + Box x570 = new Box((int)0); + Box x571 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x570, x571, (x569).get(), (x553).get(), (x550).get()); + Box x572 = new Box((int)0); + Box x573 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x572, x573, (x571).get(), (x551).get(), (x548).get()); + Box x574 = new Box((int)0); + Box x575 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x574, x575, (x573).get(), (x549).get(), (x546).get()); + int x576 = ((x575).get() + (x547).get()); + Box x577 = new Box((int)0); + Box x578 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x577, x578, 0x0, (x526).get(), (x560).get()); + Box x579 = new Box((int)0); + Box x580 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x579, x580, (x578).get(), (x528).get(), (x562).get()); + Box x581 = new Box((int)0); + Box x582 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x581, x582, (x580).get(), (x530).get(), (x564).get()); + Box x583 = new Box((int)0); + Box x584 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x583, x584, (x582).get(), (x532).get(), (x566).get()); + Box x585 = new Box((int)0); + Box x586 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x585, x586, (x584).get(), (x534).get(), (x568).get()); + Box x587 = new Box((int)0); + Box x588 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x587, x588, (x586).get(), (x536).get(), (x570).get()); + Box x589 = new Box((int)0); + Box x590 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x589, x590, (x588).get(), (x538).get(), (x572).get()); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x591, x592, (x590).get(), (x540).get(), (x574).get()); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x593, x594, (x592).get(), (x542).get(), x576); + int x595 = ((x594).get() + (x543).get()); + Box x596 = new Box((int)0); + Box x597 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x596, x597, x6, (arg1[7])); + Box x598 = new Box((int)0); + Box x599 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x598, x599, x6, (arg1[6])); + Box x600 = new Box((int)0); + Box x601 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x600, x601, x6, (arg1[5])); + Box x602 = new Box((int)0); + Box x603 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x602, x603, x6, (arg1[4])); + Box x604 = new Box((int)0); + Box x605 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x604, x605, x6, (arg1[3])); + Box x606 = new Box((int)0); + Box x607 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x606, x607, x6, (arg1[2])); + Box x608 = new Box((int)0); + Box x609 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x608, x609, x6, (arg1[1])); + Box x610 = new Box((int)0); + Box x611 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x610, x611, x6, (arg1[0])); + Box x612 = new Box((int)0); + Box x613 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x612, x613, 0x0, (x611).get(), (x608).get()); + Box x614 = new Box((int)0); + Box x615 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x614, x615, (x613).get(), (x609).get(), (x606).get()); + Box x616 = new Box((int)0); + Box x617 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x616, x617, (x615).get(), (x607).get(), (x604).get()); + Box x618 = new Box((int)0); + Box x619 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x618, x619, (x617).get(), (x605).get(), (x602).get()); + Box x620 = new Box((int)0); + Box x621 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x620, x621, (x619).get(), (x603).get(), (x600).get()); + Box x622 = new Box((int)0); + Box x623 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x622, x623, (x621).get(), (x601).get(), (x598).get()); + Box x624 = new Box((int)0); + Box x625 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x624, x625, (x623).get(), (x599).get(), (x596).get()); + int x626 = ((x625).get() + (x597).get()); + Box x627 = new Box((int)0); + Box x628 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x627, x628, 0x0, (x579).get(), (x610).get()); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x629, x630, (x628).get(), (x581).get(), (x612).get()); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x631, x632, (x630).get(), (x583).get(), (x614).get()); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x633, x634, (x632).get(), (x585).get(), (x616).get()); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x635, x636, (x634).get(), (x587).get(), (x618).get()); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x637, x638, (x636).get(), (x589).get(), (x620).get()); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x639, x640, (x638).get(), (x591).get(), (x622).get()); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x641, x642, (x640).get(), (x593).get(), (x624).get()); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x643, x644, (x642).get(), x595, x626); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x645, x646, (x627).get(), 0x5588b13f); + Box x647 = new Box((int)0); + Box x648 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x647, x648, (x645).get(), 0xffffffff); + Box x649 = new Box((int)0); + Box x650 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x649, x650, (x645).get(), 0xffffffff); + Box x651 = new Box((int)0); + Box x652 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x651, x652, (x645).get(), 0xffffffff); + Box x653 = new Box((int)0); + Box x654 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x653, x654, (x645).get(), 0xfffffffe); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x655, x656, (x645).get(), 0xbaaedce6); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x657, x658, (x645).get(), 0xaf48a03b); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x659, x660, (x645).get(), 0xbfd25e8c); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x661, x662, (x645).get(), 0xd0364141); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x663, x664, 0x0, (x662).get(), (x659).get()); + Box x665 = new Box((int)0); + Box x666 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x665, x666, (x664).get(), (x660).get(), (x657).get()); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x667, x668, (x666).get(), (x658).get(), (x655).get()); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x669, x670, (x668).get(), (x656).get(), (x653).get()); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x671, x672, (x670).get(), (x654).get(), (x651).get()); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x673, x674, (x672).get(), (x652).get(), (x649).get()); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x675, x676, (x674).get(), (x650).get(), (x647).get()); + int x677 = ((x676).get() + (x648).get()); + Box x678 = new Box((int)0); + Box x679 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x678, x679, 0x0, (x627).get(), (x661).get()); + Box x680 = new Box((int)0); + Box x681 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x680, x681, (x679).get(), (x629).get(), (x663).get()); + Box x682 = new Box((int)0); + Box x683 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x682, x683, (x681).get(), (x631).get(), (x665).get()); + Box x684 = new Box((int)0); + Box x685 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x684, x685, (x683).get(), (x633).get(), (x667).get()); + Box x686 = new Box((int)0); + Box x687 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x686, x687, (x685).get(), (x635).get(), (x669).get()); + Box x688 = new Box((int)0); + Box x689 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x688, x689, (x687).get(), (x637).get(), (x671).get()); + Box x690 = new Box((int)0); + Box x691 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x690, x691, (x689).get(), (x639).get(), (x673).get()); + Box x692 = new Box((int)0); + Box x693 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x692, x693, (x691).get(), (x641).get(), (x675).get()); + Box x694 = new Box((int)0); + Box x695 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x694, x695, (x693).get(), (x643).get(), x677); + int x696 = ((x695).get() + (x644).get()); + Box x697 = new Box((int)0); + Box x698 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x697, x698, x7, (arg1[7])); + Box x699 = new Box((int)0); + Box x700 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x699, x700, x7, (arg1[6])); + Box x701 = new Box((int)0); + Box x702 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x701, x702, x7, (arg1[5])); + Box x703 = new Box((int)0); + Box x704 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x703, x704, x7, (arg1[4])); + Box x705 = new Box((int)0); + Box x706 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x705, x706, x7, (arg1[3])); + Box x707 = new Box((int)0); + Box x708 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x707, x708, x7, (arg1[2])); + Box x709 = new Box((int)0); + Box x710 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x709, x710, x7, (arg1[1])); + Box x711 = new Box((int)0); + Box x712 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x711, x712, x7, (arg1[0])); + Box x713 = new Box((int)0); + Box x714 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x713, x714, 0x0, (x712).get(), (x709).get()); + Box x715 = new Box((int)0); + Box x716 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x715, x716, (x714).get(), (x710).get(), (x707).get()); + Box x717 = new Box((int)0); + Box x718 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x717, x718, (x716).get(), (x708).get(), (x705).get()); + Box x719 = new Box((int)0); + Box x720 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x719, x720, (x718).get(), (x706).get(), (x703).get()); + Box x721 = new Box((int)0); + Box x722 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x721, x722, (x720).get(), (x704).get(), (x701).get()); + Box x723 = new Box((int)0); + Box x724 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x723, x724, (x722).get(), (x702).get(), (x699).get()); + Box x725 = new Box((int)0); + Box x726 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x725, x726, (x724).get(), (x700).get(), (x697).get()); + int x727 = ((x726).get() + (x698).get()); + Box x728 = new Box((int)0); + Box x729 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x728, x729, 0x0, (x680).get(), (x711).get()); + Box x730 = new Box((int)0); + Box x731 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x730, x731, (x729).get(), (x682).get(), (x713).get()); + Box x732 = new Box((int)0); + Box x733 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x732, x733, (x731).get(), (x684).get(), (x715).get()); + Box x734 = new Box((int)0); + Box x735 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x734, x735, (x733).get(), (x686).get(), (x717).get()); + Box x736 = new Box((int)0); + Box x737 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x736, x737, (x735).get(), (x688).get(), (x719).get()); + Box x738 = new Box((int)0); + Box x739 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x738, x739, (x737).get(), (x690).get(), (x721).get()); + Box x740 = new Box((int)0); + Box x741 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x740, x741, (x739).get(), (x692).get(), (x723).get()); + Box x742 = new Box((int)0); + Box x743 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x742, x743, (x741).get(), (x694).get(), (x725).get()); + Box x744 = new Box((int)0); + Box x745 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x744, x745, (x743).get(), x696, x727); + Box x746 = new Box((int)0); + Box x747 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x746, x747, (x728).get(), 0x5588b13f); + Box x748 = new Box((int)0); + Box x749 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x748, x749, (x746).get(), 0xffffffff); + Box x750 = new Box((int)0); + Box x751 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x750, x751, (x746).get(), 0xffffffff); + Box x752 = new Box((int)0); + Box x753 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x752, x753, (x746).get(), 0xffffffff); + Box x754 = new Box((int)0); + Box x755 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x754, x755, (x746).get(), 0xfffffffe); + Box x756 = new Box((int)0); + Box x757 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x756, x757, (x746).get(), 0xbaaedce6); + Box x758 = new Box((int)0); + Box x759 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x758, x759, (x746).get(), 0xaf48a03b); + Box x760 = new Box((int)0); + Box x761 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x760, x761, (x746).get(), 0xbfd25e8c); + Box x762 = new Box((int)0); + Box x763 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x762, x763, (x746).get(), 0xd0364141); + Box x764 = new Box((int)0); + Box x765 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x764, x765, 0x0, (x763).get(), (x760).get()); + Box x766 = new Box((int)0); + Box x767 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x766, x767, (x765).get(), (x761).get(), (x758).get()); + Box x768 = new Box((int)0); + Box x769 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x768, x769, (x767).get(), (x759).get(), (x756).get()); + Box x770 = new Box((int)0); + Box x771 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x770, x771, (x769).get(), (x757).get(), (x754).get()); + Box x772 = new Box((int)0); + Box x773 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x772, x773, (x771).get(), (x755).get(), (x752).get()); + Box x774 = new Box((int)0); + Box x775 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x774, x775, (x773).get(), (x753).get(), (x750).get()); + Box x776 = new Box((int)0); + Box x777 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x776, x777, (x775).get(), (x751).get(), (x748).get()); + int x778 = ((x777).get() + (x749).get()); + Box x779 = new Box((int)0); + Box x780 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x779, x780, 0x0, (x728).get(), (x762).get()); + Box x781 = new Box((int)0); + Box x782 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x781, x782, (x780).get(), (x730).get(), (x764).get()); + Box x783 = new Box((int)0); + Box x784 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x783, x784, (x782).get(), (x732).get(), (x766).get()); + Box x785 = new Box((int)0); + Box x786 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x785, x786, (x784).get(), (x734).get(), (x768).get()); + Box x787 = new Box((int)0); + Box x788 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x787, x788, (x786).get(), (x736).get(), (x770).get()); + Box x789 = new Box((int)0); + Box x790 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x789, x790, (x788).get(), (x738).get(), (x772).get()); + Box x791 = new Box((int)0); + Box x792 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x791, x792, (x790).get(), (x740).get(), (x774).get()); + Box x793 = new Box((int)0); + Box x794 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x793, x794, (x792).get(), (x742).get(), (x776).get()); + Box x795 = new Box((int)0); + Box x796 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x795, x796, (x794).get(), (x744).get(), x778); + int x797 = ((x796).get() + (x745).get()); + Box x798 = new Box((int)0); + Box x799 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x798, x799, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x781).get(), 0xd0364141); + Box x800 = new Box((int)0); + Box x801 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x800, x801, (x799).get(), (x783).get(), 0xbfd25e8c); + Box x802 = new Box((int)0); + Box x803 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x802, x803, (x801).get(), (x785).get(), 0xaf48a03b); + Box x804 = new Box((int)0); + Box x805 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x804, x805, (x803).get(), (x787).get(), 0xbaaedce6); + Box x806 = new Box((int)0); + Box x807 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x806, x807, (x805).get(), (x789).get(), 0xfffffffe); + Box x808 = new Box((int)0); + Box x809 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x808, x809, (x807).get(), (x791).get(), 0xffffffff); + Box x810 = new Box((int)0); + Box x811 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x810, x811, (x809).get(), (x793).get(), 0xffffffff); + Box x812 = new Box((int)0); + Box x813 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x812, x813, (x811).get(), (x795).get(), 0xffffffff); + Box x814 = new Box((int)0); + Box x815 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x814, x815, (x813).get(), x797, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x816 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x816, (x815).get(), (x798).get(), (x781).get()); + Box x817 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x817, (x815).get(), (x800).get(), (x783).get()); + Box x818 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x818, (x815).get(), (x802).get(), (x785).get()); + Box x819 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x819, (x815).get(), (x804).get(), (x787).get()); + Box x820 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x820, (x815).get(), (x806).get(), (x789).get()); + Box x821 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x821, (x815).get(), (x808).get(), (x791).get()); + Box x822 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x822, (x815).get(), (x810).get(), (x793).get()); + Box x823 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x823, (x815).get(), (x812).get(), (x795).get()); + out1[0] = (x816).get(); + out1[1] = (x817).get(); + out1[2] = (x818).get(); + out1[3] = (x819).get(); + out1[4] = (x820).get(); + out1[5] = (x821).get(); + out1[6] = (x822).get(); + out1[7] = (x823).get(); +} + +/** + * The function fiat_Secp256K1Scalar_add adds two field elements in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * 0 ≤ eval arg2 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_add(int[] out1, final int[] arg1, final int[] arg2) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x1, x2, 0x0, (arg1[0]), (arg2[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x3, x4, (x2).get(), (arg1[1]), (arg2[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x5, x6, (x4).get(), (arg1[2]), (arg2[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x7, x8, (x6).get(), (arg1[3]), (arg2[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x9, x10, (x8).get(), (arg1[4]), (arg2[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x11, x12, (x10).get(), (arg1[5]), (arg2[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x13, x14, (x12).get(), (arg1[6]), (arg2[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x15, x16, (x14).get(), (arg1[7]), (arg2[7])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x17, x18, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x1).get(), 0xd0364141); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x19, x20, (x18).get(), (x3).get(), 0xbfd25e8c); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x21, x22, (x20).get(), (x5).get(), 0xaf48a03b); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x23, x24, (x22).get(), (x7).get(), 0xbaaedce6); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x25, x26, (x24).get(), (x9).get(), 0xfffffffe); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x27, x28, (x26).get(), (x11).get(), 0xffffffff); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x29, x30, (x28).get(), (x13).get(), 0xffffffff); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x31, x32, (x30).get(), (x15).get(), 0xffffffff); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x33, x34, (x32).get(), (x16).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x35 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x35, (x34).get(), (x17).get(), (x1).get()); + Box x36 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x36, (x34).get(), (x19).get(), (x3).get()); + Box x37 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x37, (x34).get(), (x21).get(), (x5).get()); + Box x38 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x38, (x34).get(), (x23).get(), (x7).get()); + Box x39 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x39, (x34).get(), (x25).get(), (x9).get()); + Box x40 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x40, (x34).get(), (x27).get(), (x11).get()); + Box x41 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x41, (x34).get(), (x29).get(), (x13).get()); + Box x42 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x42, (x34).get(), (x31).get(), (x15).get()); + out1[0] = (x35).get(); + out1[1] = (x36).get(); + out1[2] = (x37).get(); + out1[3] = (x38).get(); + out1[4] = (x39).get(); + out1[5] = (x40).get(); + out1[6] = (x41).get(); + out1[7] = (x42).get(); +} + +/** + * The function fiat_Secp256K1Scalar_sub subtracts two field elements in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * 0 ≤ eval arg2 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_sub(int[] out1, final int[] arg1, final int[] arg2) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x1, x2, 0x0, (arg1[0]), (arg2[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x3, x4, (x2).get(), (arg1[1]), (arg2[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x5, x6, (x4).get(), (arg1[2]), (arg2[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x7, x8, (x6).get(), (arg1[3]), (arg2[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x9, x10, (x8).get(), (arg1[4]), (arg2[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x11, x12, (x10).get(), (arg1[5]), (arg2[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x13, x14, (x12).get(), (arg1[6]), (arg2[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x15, x16, (x14).get(), (arg1[7]), (arg2[7])); + Box x17 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x17, (x16).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), 0xffffffff); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x18, x19, 0x0, (x1).get(), ((x17).get() & 0xd0364141)); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x20, x21, (x19).get(), (x3).get(), ((x17).get() & 0xbfd25e8c)); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x22, x23, (x21).get(), (x5).get(), ((x17).get() & 0xaf48a03b)); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x24, x25, (x23).get(), (x7).get(), ((x17).get() & 0xbaaedce6)); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x26, x27, (x25).get(), (x9).get(), ((x17).get() & 0xfffffffe)); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x28, x29, (x27).get(), (x11).get(), (x17).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x30, x31, (x29).get(), (x13).get(), (x17).get()); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x32, x33, (x31).get(), (x15).get(), (x17).get()); + out1[0] = (x18).get(); + out1[1] = (x20).get(); + out1[2] = (x22).get(); + out1[3] = (x24).get(); + out1[4] = (x26).get(); + out1[5] = (x28).get(); + out1[6] = (x30).get(); + out1[7] = (x32).get(); +} + +/** + * The function fiat_Secp256K1Scalar_opp negates a field element in the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_opp(int[] out1, final int[] arg1) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x1, x2, 0x0, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x3, x4, (x2).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x5, x6, (x4).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x7, x8, (x6).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x9, x10, (x8).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x11, x12, (x10).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x13, x14, (x12).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x15, x16, (x14).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[7])); + Box x17 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x17, (x16).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), 0xffffffff); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x18, x19, 0x0, (x1).get(), ((x17).get() & 0xd0364141)); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x20, x21, (x19).get(), (x3).get(), ((x17).get() & 0xbfd25e8c)); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x22, x23, (x21).get(), (x5).get(), ((x17).get() & 0xaf48a03b)); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x24, x25, (x23).get(), (x7).get(), ((x17).get() & 0xbaaedce6)); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x26, x27, (x25).get(), (x9).get(), ((x17).get() & 0xfffffffe)); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x28, x29, (x27).get(), (x11).get(), (x17).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x30, x31, (x29).get(), (x13).get(), (x17).get()); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x32, x33, (x31).get(), (x15).get(), (x17).get()); + out1[0] = (x18).get(); + out1[1] = (x20).get(); + out1[2] = (x22).get(); + out1[3] = (x24).get(); + out1[4] = (x26).get(); + out1[5] = (x28).get(); + out1[6] = (x30).get(); + out1[7] = (x32).get(); +} + +/** + * The function fiat_Secp256K1Scalar_from_montgomery translates a field element out of the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_from_montgomery(int[] out1, final int[] arg1) { + int x1 = (arg1[0]); + Box x2 = new Box((int)0); + Box x3 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x2, x3, x1, 0x5588b13f); + Box x4 = new Box((int)0); + Box x5 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x4, x5, (x2).get(), 0xffffffff); + Box x6 = new Box((int)0); + Box x7 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x6, x7, (x2).get(), 0xffffffff); + Box x8 = new Box((int)0); + Box x9 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x8, x9, (x2).get(), 0xffffffff); + Box x10 = new Box((int)0); + Box x11 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x10, x11, (x2).get(), 0xfffffffe); + Box x12 = new Box((int)0); + Box x13 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x12, x13, (x2).get(), 0xbaaedce6); + Box x14 = new Box((int)0); + Box x15 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x14, x15, (x2).get(), 0xaf48a03b); + Box x16 = new Box((int)0); + Box x17 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x16, x17, (x2).get(), 0xbfd25e8c); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x18, x19, (x2).get(), 0xd0364141); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x20, x21, 0x0, (x19).get(), (x16).get()); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x22, x23, (x21).get(), (x17).get(), (x14).get()); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x24, x25, (x23).get(), (x15).get(), (x12).get()); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x26, x27, (x25).get(), (x13).get(), (x10).get()); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x28, x29, (x27).get(), (x11).get(), (x8).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x30, x31, (x29).get(), (x9).get(), (x6).get()); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x32, x33, (x31).get(), (x7).get(), (x4).get()); + Box x34 = new Box((int)0); + Box x35 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x34, x35, 0x0, x1, (x18).get()); + Box x36 = new Box((int)0); + Box x37 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x36, x37, (x35).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x20).get()); + Box x38 = new Box((int)0); + Box x39 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x38, x39, (x37).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x22).get()); + Box x40 = new Box((int)0); + Box x41 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x40, x41, (x39).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x24).get()); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x42, x43, (x41).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x26).get()); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x44, x45, (x43).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x28).get()); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x46, x47, (x45).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x30).get()); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x48, x49, (x47).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x32).get()); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x50, x51, (x49).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), ((x33).get() + (x5).get())); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x52, x53, 0x0, (x36).get(), (arg1[1])); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x54, x55, (x53).get(), (x38).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x56 = new Box((int)0); + Box x57 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x56, x57, (x55).get(), (x40).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x58 = new Box((int)0); + Box x59 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x58, x59, (x57).get(), (x42).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x60, x61, (x59).get(), (x44).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x62, x63, (x61).get(), (x46).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x64, x65, (x63).get(), (x48).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x66, x67, (x65).get(), (x50).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x68, x69, (x52).get(), 0x5588b13f); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x70, x71, (x68).get(), 0xffffffff); + Box x72 = new Box((int)0); + Box x73 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x72, x73, (x68).get(), 0xffffffff); + Box x74 = new Box((int)0); + Box x75 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x74, x75, (x68).get(), 0xffffffff); + Box x76 = new Box((int)0); + Box x77 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x76, x77, (x68).get(), 0xfffffffe); + Box x78 = new Box((int)0); + Box x79 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x78, x79, (x68).get(), 0xbaaedce6); + Box x80 = new Box((int)0); + Box x81 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x80, x81, (x68).get(), 0xaf48a03b); + Box x82 = new Box((int)0); + Box x83 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x82, x83, (x68).get(), 0xbfd25e8c); + Box x84 = new Box((int)0); + Box x85 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x84, x85, (x68).get(), 0xd0364141); + Box x86 = new Box((int)0); + Box x87 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x86, x87, 0x0, (x85).get(), (x82).get()); + Box x88 = new Box((int)0); + Box x89 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x88, x89, (x87).get(), (x83).get(), (x80).get()); + Box x90 = new Box((int)0); + Box x91 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x90, x91, (x89).get(), (x81).get(), (x78).get()); + Box x92 = new Box((int)0); + Box x93 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x92, x93, (x91).get(), (x79).get(), (x76).get()); + Box x94 = new Box((int)0); + Box x95 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x94, x95, (x93).get(), (x77).get(), (x74).get()); + Box x96 = new Box((int)0); + Box x97 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x96, x97, (x95).get(), (x75).get(), (x72).get()); + Box x98 = new Box((int)0); + Box x99 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x98, x99, (x97).get(), (x73).get(), (x70).get()); + Box x100 = new Box((int)0); + Box x101 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x100, x101, 0x0, (x52).get(), (x84).get()); + Box x102 = new Box((int)0); + Box x103 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x102, x103, (x101).get(), (x54).get(), (x86).get()); + Box x104 = new Box((int)0); + Box x105 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x104, x105, (x103).get(), (x56).get(), (x88).get()); + Box x106 = new Box((int)0); + Box x107 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x106, x107, (x105).get(), (x58).get(), (x90).get()); + Box x108 = new Box((int)0); + Box x109 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x108, x109, (x107).get(), (x60).get(), (x92).get()); + Box x110 = new Box((int)0); + Box x111 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x110, x111, (x109).get(), (x62).get(), (x94).get()); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x112, x113, (x111).get(), (x64).get(), (x96).get()); + Box x114 = new Box((int)0); + Box x115 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x114, x115, (x113).get(), (x66).get(), (x98).get()); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x116, x117, (x115).get(), ((x67).get() + (x51).get()), ((x99).get() + (x71).get())); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x118, x119, 0x0, (x102).get(), (arg1[2])); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x120, x121, (x119).get(), (x104).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x122, x123, (x121).get(), (x106).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x124, x125, (x123).get(), (x108).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x126, x127, (x125).get(), (x110).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x128, x129, (x127).get(), (x112).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x130, x131, (x129).get(), (x114).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x132, x133, (x131).get(), (x116).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x134, x135, (x118).get(), 0x5588b13f); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x136, x137, (x134).get(), 0xffffffff); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x138, x139, (x134).get(), 0xffffffff); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x140, x141, (x134).get(), 0xffffffff); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x142, x143, (x134).get(), 0xfffffffe); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x144, x145, (x134).get(), 0xbaaedce6); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x146, x147, (x134).get(), 0xaf48a03b); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x148, x149, (x134).get(), 0xbfd25e8c); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x150, x151, (x134).get(), 0xd0364141); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x152, x153, 0x0, (x151).get(), (x148).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x154, x155, (x153).get(), (x149).get(), (x146).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x156, x157, (x155).get(), (x147).get(), (x144).get()); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x158, x159, (x157).get(), (x145).get(), (x142).get()); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x160, x161, (x159).get(), (x143).get(), (x140).get()); + Box x162 = new Box((int)0); + Box x163 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x162, x163, (x161).get(), (x141).get(), (x138).get()); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x164, x165, (x163).get(), (x139).get(), (x136).get()); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x166, x167, 0x0, (x118).get(), (x150).get()); + Box x168 = new Box((int)0); + Box x169 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x168, x169, (x167).get(), (x120).get(), (x152).get()); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x170, x171, (x169).get(), (x122).get(), (x154).get()); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x172, x173, (x171).get(), (x124).get(), (x156).get()); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x174, x175, (x173).get(), (x126).get(), (x158).get()); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x176, x177, (x175).get(), (x128).get(), (x160).get()); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x178, x179, (x177).get(), (x130).get(), (x162).get()); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x180, x181, (x179).get(), (x132).get(), (x164).get()); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x182, x183, (x181).get(), ((x133).get() + (x117).get()), ((x165).get() + (x137).get())); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x184, x185, 0x0, (x168).get(), (arg1[3])); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x186, x187, (x185).get(), (x170).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x188, x189, (x187).get(), (x172).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x190, x191, (x189).get(), (x174).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x192, x193, (x191).get(), (x176).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x194, x195, (x193).get(), (x178).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x196, x197, (x195).get(), (x180).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x198, x199, (x197).get(), (x182).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x200, x201, (x184).get(), 0x5588b13f); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x202, x203, (x200).get(), 0xffffffff); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x204, x205, (x200).get(), 0xffffffff); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x206, x207, (x200).get(), 0xffffffff); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x208, x209, (x200).get(), 0xfffffffe); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x210, x211, (x200).get(), 0xbaaedce6); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x212, x213, (x200).get(), 0xaf48a03b); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x214, x215, (x200).get(), 0xbfd25e8c); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x216, x217, (x200).get(), 0xd0364141); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x218, x219, 0x0, (x217).get(), (x214).get()); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x220, x221, (x219).get(), (x215).get(), (x212).get()); + Box x222 = new Box((int)0); + Box x223 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x222, x223, (x221).get(), (x213).get(), (x210).get()); + Box x224 = new Box((int)0); + Box x225 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x224, x225, (x223).get(), (x211).get(), (x208).get()); + Box x226 = new Box((int)0); + Box x227 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x226, x227, (x225).get(), (x209).get(), (x206).get()); + Box x228 = new Box((int)0); + Box x229 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x228, x229, (x227).get(), (x207).get(), (x204).get()); + Box x230 = new Box((int)0); + Box x231 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x230, x231, (x229).get(), (x205).get(), (x202).get()); + Box x232 = new Box((int)0); + Box x233 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x232, x233, 0x0, (x184).get(), (x216).get()); + Box x234 = new Box((int)0); + Box x235 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x234, x235, (x233).get(), (x186).get(), (x218).get()); + Box x236 = new Box((int)0); + Box x237 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x236, x237, (x235).get(), (x188).get(), (x220).get()); + Box x238 = new Box((int)0); + Box x239 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x238, x239, (x237).get(), (x190).get(), (x222).get()); + Box x240 = new Box((int)0); + Box x241 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x240, x241, (x239).get(), (x192).get(), (x224).get()); + Box x242 = new Box((int)0); + Box x243 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x242, x243, (x241).get(), (x194).get(), (x226).get()); + Box x244 = new Box((int)0); + Box x245 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x244, x245, (x243).get(), (x196).get(), (x228).get()); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x246, x247, (x245).get(), (x198).get(), (x230).get()); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x248, x249, (x247).get(), ((x199).get() + (x183).get()), ((x231).get() + (x203).get())); + Box x250 = new Box((int)0); + Box x251 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x250, x251, 0x0, (x234).get(), (arg1[4])); + Box x252 = new Box((int)0); + Box x253 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x252, x253, (x251).get(), (x236).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x254 = new Box((int)0); + Box x255 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x254, x255, (x253).get(), (x238).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x256 = new Box((int)0); + Box x257 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x256, x257, (x255).get(), (x240).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x258 = new Box((int)0); + Box x259 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x258, x259, (x257).get(), (x242).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x260 = new Box((int)0); + Box x261 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x260, x261, (x259).get(), (x244).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x262 = new Box((int)0); + Box x263 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x262, x263, (x261).get(), (x246).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x264 = new Box((int)0); + Box x265 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x264, x265, (x263).get(), (x248).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x266 = new Box((int)0); + Box x267 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x266, x267, (x250).get(), 0x5588b13f); + Box x268 = new Box((int)0); + Box x269 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x268, x269, (x266).get(), 0xffffffff); + Box x270 = new Box((int)0); + Box x271 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x270, x271, (x266).get(), 0xffffffff); + Box x272 = new Box((int)0); + Box x273 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x272, x273, (x266).get(), 0xffffffff); + Box x274 = new Box((int)0); + Box x275 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x274, x275, (x266).get(), 0xfffffffe); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x276, x277, (x266).get(), 0xbaaedce6); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x278, x279, (x266).get(), 0xaf48a03b); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x280, x281, (x266).get(), 0xbfd25e8c); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x282, x283, (x266).get(), 0xd0364141); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x284, x285, 0x0, (x283).get(), (x280).get()); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x286, x287, (x285).get(), (x281).get(), (x278).get()); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x288, x289, (x287).get(), (x279).get(), (x276).get()); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x290, x291, (x289).get(), (x277).get(), (x274).get()); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x292, x293, (x291).get(), (x275).get(), (x272).get()); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x294, x295, (x293).get(), (x273).get(), (x270).get()); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x296, x297, (x295).get(), (x271).get(), (x268).get()); + Box x298 = new Box((int)0); + Box x299 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x298, x299, 0x0, (x250).get(), (x282).get()); + Box x300 = new Box((int)0); + Box x301 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x300, x301, (x299).get(), (x252).get(), (x284).get()); + Box x302 = new Box((int)0); + Box x303 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x302, x303, (x301).get(), (x254).get(), (x286).get()); + Box x304 = new Box((int)0); + Box x305 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x304, x305, (x303).get(), (x256).get(), (x288).get()); + Box x306 = new Box((int)0); + Box x307 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x306, x307, (x305).get(), (x258).get(), (x290).get()); + Box x308 = new Box((int)0); + Box x309 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x308, x309, (x307).get(), (x260).get(), (x292).get()); + Box x310 = new Box((int)0); + Box x311 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x310, x311, (x309).get(), (x262).get(), (x294).get()); + Box x312 = new Box((int)0); + Box x313 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x312, x313, (x311).get(), (x264).get(), (x296).get()); + Box x314 = new Box((int)0); + Box x315 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x314, x315, (x313).get(), ((x265).get() + (x249).get()), ((x297).get() + (x269).get())); + Box x316 = new Box((int)0); + Box x317 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x316, x317, 0x0, (x300).get(), (arg1[5])); + Box x318 = new Box((int)0); + Box x319 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x318, x319, (x317).get(), (x302).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x320 = new Box((int)0); + Box x321 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x320, x321, (x319).get(), (x304).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x322 = new Box((int)0); + Box x323 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x322, x323, (x321).get(), (x306).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x324 = new Box((int)0); + Box x325 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x324, x325, (x323).get(), (x308).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x326, x327, (x325).get(), (x310).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x328 = new Box((int)0); + Box x329 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x328, x329, (x327).get(), (x312).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x330 = new Box((int)0); + Box x331 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x330, x331, (x329).get(), (x314).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x332 = new Box((int)0); + Box x333 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x332, x333, (x316).get(), 0x5588b13f); + Box x334 = new Box((int)0); + Box x335 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x334, x335, (x332).get(), 0xffffffff); + Box x336 = new Box((int)0); + Box x337 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x336, x337, (x332).get(), 0xffffffff); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x338, x339, (x332).get(), 0xffffffff); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x340, x341, (x332).get(), 0xfffffffe); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x342, x343, (x332).get(), 0xbaaedce6); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x344, x345, (x332).get(), 0xaf48a03b); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x346, x347, (x332).get(), 0xbfd25e8c); + Box x348 = new Box((int)0); + Box x349 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x348, x349, (x332).get(), 0xd0364141); + Box x350 = new Box((int)0); + Box x351 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x350, x351, 0x0, (x349).get(), (x346).get()); + Box x352 = new Box((int)0); + Box x353 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x352, x353, (x351).get(), (x347).get(), (x344).get()); + Box x354 = new Box((int)0); + Box x355 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x354, x355, (x353).get(), (x345).get(), (x342).get()); + Box x356 = new Box((int)0); + Box x357 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x356, x357, (x355).get(), (x343).get(), (x340).get()); + Box x358 = new Box((int)0); + Box x359 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x358, x359, (x357).get(), (x341).get(), (x338).get()); + Box x360 = new Box((int)0); + Box x361 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x360, x361, (x359).get(), (x339).get(), (x336).get()); + Box x362 = new Box((int)0); + Box x363 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x362, x363, (x361).get(), (x337).get(), (x334).get()); + Box x364 = new Box((int)0); + Box x365 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x364, x365, 0x0, (x316).get(), (x348).get()); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x366, x367, (x365).get(), (x318).get(), (x350).get()); + Box x368 = new Box((int)0); + Box x369 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x368, x369, (x367).get(), (x320).get(), (x352).get()); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x370, x371, (x369).get(), (x322).get(), (x354).get()); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x372, x373, (x371).get(), (x324).get(), (x356).get()); + Box x374 = new Box((int)0); + Box x375 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x374, x375, (x373).get(), (x326).get(), (x358).get()); + Box x376 = new Box((int)0); + Box x377 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x376, x377, (x375).get(), (x328).get(), (x360).get()); + Box x378 = new Box((int)0); + Box x379 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x378, x379, (x377).get(), (x330).get(), (x362).get()); + Box x380 = new Box((int)0); + Box x381 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x380, x381, (x379).get(), ((x331).get() + (x315).get()), ((x363).get() + (x335).get())); + Box x382 = new Box((int)0); + Box x383 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x382, x383, 0x0, (x366).get(), (arg1[6])); + Box x384 = new Box((int)0); + Box x385 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x384, x385, (x383).get(), (x368).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x386 = new Box((int)0); + Box x387 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x386, x387, (x385).get(), (x370).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x388 = new Box((int)0); + Box x389 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x388, x389, (x387).get(), (x372).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x390 = new Box((int)0); + Box x391 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x390, x391, (x389).get(), (x374).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x392 = new Box((int)0); + Box x393 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x392, x393, (x391).get(), (x376).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x394 = new Box((int)0); + Box x395 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x394, x395, (x393).get(), (x378).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x396 = new Box((int)0); + Box x397 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x396, x397, (x395).get(), (x380).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x398 = new Box((int)0); + Box x399 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x398, x399, (x382).get(), 0x5588b13f); + Box x400 = new Box((int)0); + Box x401 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x400, x401, (x398).get(), 0xffffffff); + Box x402 = new Box((int)0); + Box x403 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x402, x403, (x398).get(), 0xffffffff); + Box x404 = new Box((int)0); + Box x405 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x404, x405, (x398).get(), 0xffffffff); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x406, x407, (x398).get(), 0xfffffffe); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x408, x409, (x398).get(), 0xbaaedce6); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x410, x411, (x398).get(), 0xaf48a03b); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x412, x413, (x398).get(), 0xbfd25e8c); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x414, x415, (x398).get(), 0xd0364141); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x416, x417, 0x0, (x415).get(), (x412).get()); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x418, x419, (x417).get(), (x413).get(), (x410).get()); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x420, x421, (x419).get(), (x411).get(), (x408).get()); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x422, x423, (x421).get(), (x409).get(), (x406).get()); + Box x424 = new Box((int)0); + Box x425 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x424, x425, (x423).get(), (x407).get(), (x404).get()); + Box x426 = new Box((int)0); + Box x427 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x426, x427, (x425).get(), (x405).get(), (x402).get()); + Box x428 = new Box((int)0); + Box x429 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x428, x429, (x427).get(), (x403).get(), (x400).get()); + Box x430 = new Box((int)0); + Box x431 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x430, x431, 0x0, (x382).get(), (x414).get()); + Box x432 = new Box((int)0); + Box x433 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x432, x433, (x431).get(), (x384).get(), (x416).get()); + Box x434 = new Box((int)0); + Box x435 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x434, x435, (x433).get(), (x386).get(), (x418).get()); + Box x436 = new Box((int)0); + Box x437 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x436, x437, (x435).get(), (x388).get(), (x420).get()); + Box x438 = new Box((int)0); + Box x439 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x438, x439, (x437).get(), (x390).get(), (x422).get()); + Box x440 = new Box((int)0); + Box x441 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x440, x441, (x439).get(), (x392).get(), (x424).get()); + Box x442 = new Box((int)0); + Box x443 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x442, x443, (x441).get(), (x394).get(), (x426).get()); + Box x444 = new Box((int)0); + Box x445 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x444, x445, (x443).get(), (x396).get(), (x428).get()); + Box x446 = new Box((int)0); + Box x447 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x446, x447, (x445).get(), ((x397).get() + (x381).get()), ((x429).get() + (x401).get())); + Box x448 = new Box((int)0); + Box x449 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x448, x449, 0x0, (x432).get(), (arg1[7])); + Box x450 = new Box((int)0); + Box x451 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x450, x451, (x449).get(), (x434).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x452 = new Box((int)0); + Box x453 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x452, x453, (x451).get(), (x436).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x454 = new Box((int)0); + Box x455 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x454, x455, (x453).get(), (x438).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x456 = new Box((int)0); + Box x457 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x456, x457, (x455).get(), (x440).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x458 = new Box((int)0); + Box x459 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x458, x459, (x457).get(), (x442).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x460 = new Box((int)0); + Box x461 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x460, x461, (x459).get(), (x444).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x462 = new Box((int)0); + Box x463 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x462, x463, (x461).get(), (x446).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x464 = new Box((int)0); + Box x465 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x464, x465, (x448).get(), 0x5588b13f); + Box x466 = new Box((int)0); + Box x467 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x466, x467, (x464).get(), 0xffffffff); + Box x468 = new Box((int)0); + Box x469 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x468, x469, (x464).get(), 0xffffffff); + Box x470 = new Box((int)0); + Box x471 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x470, x471, (x464).get(), 0xffffffff); + Box x472 = new Box((int)0); + Box x473 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x472, x473, (x464).get(), 0xfffffffe); + Box x474 = new Box((int)0); + Box x475 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x474, x475, (x464).get(), 0xbaaedce6); + Box x476 = new Box((int)0); + Box x477 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x476, x477, (x464).get(), 0xaf48a03b); + Box x478 = new Box((int)0); + Box x479 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x478, x479, (x464).get(), 0xbfd25e8c); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x480, x481, (x464).get(), 0xd0364141); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x482, x483, 0x0, (x481).get(), (x478).get()); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x484, x485, (x483).get(), (x479).get(), (x476).get()); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x486, x487, (x485).get(), (x477).get(), (x474).get()); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x488, x489, (x487).get(), (x475).get(), (x472).get()); + Box x490 = new Box((int)0); + Box x491 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x490, x491, (x489).get(), (x473).get(), (x470).get()); + Box x492 = new Box((int)0); + Box x493 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x492, x493, (x491).get(), (x471).get(), (x468).get()); + Box x494 = new Box((int)0); + Box x495 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x494, x495, (x493).get(), (x469).get(), (x466).get()); + Box x496 = new Box((int)0); + Box x497 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x496, x497, 0x0, (x448).get(), (x480).get()); + Box x498 = new Box((int)0); + Box x499 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x498, x499, (x497).get(), (x450).get(), (x482).get()); + Box x500 = new Box((int)0); + Box x501 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x500, x501, (x499).get(), (x452).get(), (x484).get()); + Box x502 = new Box((int)0); + Box x503 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x502, x503, (x501).get(), (x454).get(), (x486).get()); + Box x504 = new Box((int)0); + Box x505 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x504, x505, (x503).get(), (x456).get(), (x488).get()); + Box x506 = new Box((int)0); + Box x507 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x506, x507, (x505).get(), (x458).get(), (x490).get()); + Box x508 = new Box((int)0); + Box x509 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x508, x509, (x507).get(), (x460).get(), (x492).get()); + Box x510 = new Box((int)0); + Box x511 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x510, x511, (x509).get(), (x462).get(), (x494).get()); + Box x512 = new Box((int)0); + Box x513 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x512, x513, (x511).get(), ((x463).get() + (x447).get()), ((x495).get() + (x467).get())); + Box x514 = new Box((int)0); + Box x515 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x514, x515, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x498).get(), 0xd0364141); + Box x516 = new Box((int)0); + Box x517 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x516, x517, (x515).get(), (x500).get(), 0xbfd25e8c); + Box x518 = new Box((int)0); + Box x519 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x518, x519, (x517).get(), (x502).get(), 0xaf48a03b); + Box x520 = new Box((int)0); + Box x521 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x520, x521, (x519).get(), (x504).get(), 0xbaaedce6); + Box x522 = new Box((int)0); + Box x523 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x522, x523, (x521).get(), (x506).get(), 0xfffffffe); + Box x524 = new Box((int)0); + Box x525 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x524, x525, (x523).get(), (x508).get(), 0xffffffff); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x526, x527, (x525).get(), (x510).get(), 0xffffffff); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x528, x529, (x527).get(), (x512).get(), 0xffffffff); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x530, x531, (x529).get(), (x513).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x532 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x532, (x531).get(), (x514).get(), (x498).get()); + Box x533 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x533, (x531).get(), (x516).get(), (x500).get()); + Box x534 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x534, (x531).get(), (x518).get(), (x502).get()); + Box x535 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x535, (x531).get(), (x520).get(), (x504).get()); + Box x536 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x536, (x531).get(), (x522).get(), (x506).get()); + Box x537 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x537, (x531).get(), (x524).get(), (x508).get()); + Box x538 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x538, (x531).get(), (x526).get(), (x510).get()); + Box x539 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x539, (x531).get(), (x528).get(), (x512).get()); + out1[0] = (x532).get(); + out1[1] = (x533).get(); + out1[2] = (x534).get(); + out1[3] = (x535).get(); + out1[4] = (x536).get(); + out1[5] = (x537).get(); + out1[6] = (x538).get(); + out1[7] = (x539).get(); +} + +/** + * The function fiat_Secp256K1Scalar_to_montgomery translates a field element into the Montgomery domain.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = eval arg1 mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_to_montgomery(int[] out1, final int[] arg1) { + int x1 = (arg1[1]); + int x2 = (arg1[2]); + int x3 = (arg1[3]); + int x4 = (arg1[4]); + int x5 = (arg1[5]); + int x6 = (arg1[6]); + int x7 = (arg1[7]); + int x8 = (arg1[0]); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x9, x10, x8, 0x9d671cd5); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x11, x12, x8, 0x81c69bc5); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x13, x14, x8, 0xe697f5e4); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x15, x16, x8, 0x5bcd07c6); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x17, x18, x8, 0x741496c2); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x19, x20, x8, 0xe7cf878); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x21, x22, x8, 0x896cf214); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x23, x24, x8, 0x67d7d140); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x37, x38, (x36).get(), (x12).get(), (x9).get()); + Box x39 = new Box((int)0); + Box x40 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x39, x40, (x23).get(), 0x5588b13f); + Box x41 = new Box((int)0); + Box x42 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x41, x42, (x39).get(), 0xffffffff); + Box x43 = new Box((int)0); + Box x44 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x43, x44, (x39).get(), 0xffffffff); + Box x45 = new Box((int)0); + Box x46 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x45, x46, (x39).get(), 0xffffffff); + Box x47 = new Box((int)0); + Box x48 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x47, x48, (x39).get(), 0xfffffffe); + Box x49 = new Box((int)0); + Box x50 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x49, x50, (x39).get(), 0xbaaedce6); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x51, x52, (x39).get(), 0xaf48a03b); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x53, x54, (x39).get(), 0xbfd25e8c); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x55, x56, (x39).get(), 0xd0364141); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x57, x58, 0x0, (x56).get(), (x53).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x59, x60, (x58).get(), (x54).get(), (x51).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x61, x62, (x60).get(), (x52).get(), (x49).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x63, x64, (x62).get(), (x50).get(), (x47).get()); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x65, x66, (x64).get(), (x48).get(), (x45).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x67, x68, (x66).get(), (x46).get(), (x43).get()); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x69, x70, (x68).get(), (x44).get(), (x41).get()); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x71, x72, 0x0, (x23).get(), (x55).get()); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x73, x74, (x72).get(), (x25).get(), (x57).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x75, x76, (x74).get(), (x27).get(), (x59).get()); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x77, x78, (x76).get(), (x29).get(), (x61).get()); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x79, x80, (x78).get(), (x31).get(), (x63).get()); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x81, x82, (x80).get(), (x33).get(), (x65).get()); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x83, x84, (x82).get(), (x35).get(), (x67).get()); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x85, x86, (x84).get(), (x37).get(), (x69).get()); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x87, x88, (x86).get(), ((x38).get() + (x10).get()), ((x70).get() + (x42).get())); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x89, x90, x1, 0x9d671cd5); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x91, x92, x1, 0x81c69bc5); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x93, x94, x1, 0xe697f5e4); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x95, x96, x1, 0x5bcd07c6); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x97, x98, x1, 0x741496c2); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x99, x100, x1, 0xe7cf878); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x101, x102, x1, 0x896cf214); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x103, x104, x1, 0x67d7d140); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x105, x106, 0x0, (x104).get(), (x101).get()); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x107, x108, (x106).get(), (x102).get(), (x99).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x109, x110, (x108).get(), (x100).get(), (x97).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x111, x112, (x110).get(), (x98).get(), (x95).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x113, x114, (x112).get(), (x96).get(), (x93).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x115, x116, (x114).get(), (x94).get(), (x91).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x117, x118, (x116).get(), (x92).get(), (x89).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x119, x120, 0x0, (x73).get(), (x103).get()); + Box x121 = new Box((int)0); + Box x122 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x121, x122, (x120).get(), (x75).get(), (x105).get()); + Box x123 = new Box((int)0); + Box x124 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x123, x124, (x122).get(), (x77).get(), (x107).get()); + Box x125 = new Box((int)0); + Box x126 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x125, x126, (x124).get(), (x79).get(), (x109).get()); + Box x127 = new Box((int)0); + Box x128 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x127, x128, (x126).get(), (x81).get(), (x111).get()); + Box x129 = new Box((int)0); + Box x130 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x129, x130, (x128).get(), (x83).get(), (x113).get()); + Box x131 = new Box((int)0); + Box x132 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x131, x132, (x130).get(), (x85).get(), (x115).get()); + Box x133 = new Box((int)0); + Box x134 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x133, x134, (x132).get(), (x87).get(), (x117).get()); + Box x135 = new Box((int)0); + Box x136 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x135, x136, (x119).get(), 0x5588b13f); + Box x137 = new Box((int)0); + Box x138 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x137, x138, (x135).get(), 0xffffffff); + Box x139 = new Box((int)0); + Box x140 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x139, x140, (x135).get(), 0xffffffff); + Box x141 = new Box((int)0); + Box x142 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x141, x142, (x135).get(), 0xffffffff); + Box x143 = new Box((int)0); + Box x144 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x143, x144, (x135).get(), 0xfffffffe); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x145, x146, (x135).get(), 0xbaaedce6); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x147, x148, (x135).get(), 0xaf48a03b); + Box x149 = new Box((int)0); + Box x150 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x149, x150, (x135).get(), 0xbfd25e8c); + Box x151 = new Box((int)0); + Box x152 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x151, x152, (x135).get(), 0xd0364141); + Box x153 = new Box((int)0); + Box x154 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x153, x154, 0x0, (x152).get(), (x149).get()); + Box x155 = new Box((int)0); + Box x156 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x155, x156, (x154).get(), (x150).get(), (x147).get()); + Box x157 = new Box((int)0); + Box x158 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x157, x158, (x156).get(), (x148).get(), (x145).get()); + Box x159 = new Box((int)0); + Box x160 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x159, x160, (x158).get(), (x146).get(), (x143).get()); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x161, x162, (x160).get(), (x144).get(), (x141).get()); + Box x163 = new Box((int)0); + Box x164 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x163, x164, (x162).get(), (x142).get(), (x139).get()); + Box x165 = new Box((int)0); + Box x166 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x165, x166, (x164).get(), (x140).get(), (x137).get()); + Box x167 = new Box((int)0); + Box x168 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x167, x168, 0x0, (x119).get(), (x151).get()); + Box x169 = new Box((int)0); + Box x170 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x169, x170, (x168).get(), (x121).get(), (x153).get()); + Box x171 = new Box((int)0); + Box x172 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x171, x172, (x170).get(), (x123).get(), (x155).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x173, x174, (x172).get(), (x125).get(), (x157).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x175, x176, (x174).get(), (x127).get(), (x159).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x177, x178, (x176).get(), (x129).get(), (x161).get()); + Box x179 = new Box((int)0); + Box x180 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x179, x180, (x178).get(), (x131).get(), (x163).get()); + Box x181 = new Box((int)0); + Box x182 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x181, x182, (x180).get(), (x133).get(), (x165).get()); + Box x183 = new Box((int)0); + Box x184 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x183, x184, (x182).get(), (((x134).get() + (x88).get()) + ((x118).get() + (x90).get())), ((x166).get() + (x138).get())); + Box x185 = new Box((int)0); + Box x186 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x185, x186, x2, 0x9d671cd5); + Box x187 = new Box((int)0); + Box x188 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x187, x188, x2, 0x81c69bc5); + Box x189 = new Box((int)0); + Box x190 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x189, x190, x2, 0xe697f5e4); + Box x191 = new Box((int)0); + Box x192 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x191, x192, x2, 0x5bcd07c6); + Box x193 = new Box((int)0); + Box x194 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x193, x194, x2, 0x741496c2); + Box x195 = new Box((int)0); + Box x196 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x195, x196, x2, 0xe7cf878); + Box x197 = new Box((int)0); + Box x198 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x197, x198, x2, 0x896cf214); + Box x199 = new Box((int)0); + Box x200 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x199, x200, x2, 0x67d7d140); + Box x201 = new Box((int)0); + Box x202 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x201, x202, 0x0, (x200).get(), (x197).get()); + Box x203 = new Box((int)0); + Box x204 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x203, x204, (x202).get(), (x198).get(), (x195).get()); + Box x205 = new Box((int)0); + Box x206 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x205, x206, (x204).get(), (x196).get(), (x193).get()); + Box x207 = new Box((int)0); + Box x208 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x207, x208, (x206).get(), (x194).get(), (x191).get()); + Box x209 = new Box((int)0); + Box x210 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x209, x210, (x208).get(), (x192).get(), (x189).get()); + Box x211 = new Box((int)0); + Box x212 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x211, x212, (x210).get(), (x190).get(), (x187).get()); + Box x213 = new Box((int)0); + Box x214 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x213, x214, (x212).get(), (x188).get(), (x185).get()); + Box x215 = new Box((int)0); + Box x216 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x215, x216, 0x0, (x169).get(), (x199).get()); + Box x217 = new Box((int)0); + Box x218 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x217, x218, (x216).get(), (x171).get(), (x201).get()); + Box x219 = new Box((int)0); + Box x220 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x219, x220, (x218).get(), (x173).get(), (x203).get()); + Box x221 = new Box((int)0); + Box x222 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x221, x222, (x220).get(), (x175).get(), (x205).get()); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x223, x224, (x222).get(), (x177).get(), (x207).get()); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x225, x226, (x224).get(), (x179).get(), (x209).get()); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x227, x228, (x226).get(), (x181).get(), (x211).get()); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x229, x230, (x228).get(), (x183).get(), (x213).get()); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x231, x232, (x215).get(), 0x5588b13f); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x233, x234, (x231).get(), 0xffffffff); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x235, x236, (x231).get(), 0xffffffff); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x237, x238, (x231).get(), 0xffffffff); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x239, x240, (x231).get(), 0xfffffffe); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x241, x242, (x231).get(), 0xbaaedce6); + Box x243 = new Box((int)0); + Box x244 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x243, x244, (x231).get(), 0xaf48a03b); + Box x245 = new Box((int)0); + Box x246 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x245, x246, (x231).get(), 0xbfd25e8c); + Box x247 = new Box((int)0); + Box x248 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x247, x248, (x231).get(), 0xd0364141); + Box x249 = new Box((int)0); + Box x250 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x249, x250, 0x0, (x248).get(), (x245).get()); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x251, x252, (x250).get(), (x246).get(), (x243).get()); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x253, x254, (x252).get(), (x244).get(), (x241).get()); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x255, x256, (x254).get(), (x242).get(), (x239).get()); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x257, x258, (x256).get(), (x240).get(), (x237).get()); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x259, x260, (x258).get(), (x238).get(), (x235).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x261, x262, (x260).get(), (x236).get(), (x233).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x263, x264, 0x0, (x215).get(), (x247).get()); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x265, x266, (x264).get(), (x217).get(), (x249).get()); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x267, x268, (x266).get(), (x219).get(), (x251).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x269, x270, (x268).get(), (x221).get(), (x253).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x271, x272, (x270).get(), (x223).get(), (x255).get()); + Box x273 = new Box((int)0); + Box x274 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x273, x274, (x272).get(), (x225).get(), (x257).get()); + Box x275 = new Box((int)0); + Box x276 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x275, x276, (x274).get(), (x227).get(), (x259).get()); + Box x277 = new Box((int)0); + Box x278 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x277, x278, (x276).get(), (x229).get(), (x261).get()); + Box x279 = new Box((int)0); + Box x280 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x279, x280, (x278).get(), (((x230).get() + (x184).get()) + ((x214).get() + (x186).get())), ((x262).get() + (x234).get())); + Box x281 = new Box((int)0); + Box x282 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x281, x282, x3, 0x9d671cd5); + Box x283 = new Box((int)0); + Box x284 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x283, x284, x3, 0x81c69bc5); + Box x285 = new Box((int)0); + Box x286 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x285, x286, x3, 0xe697f5e4); + Box x287 = new Box((int)0); + Box x288 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x287, x288, x3, 0x5bcd07c6); + Box x289 = new Box((int)0); + Box x290 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x289, x290, x3, 0x741496c2); + Box x291 = new Box((int)0); + Box x292 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x291, x292, x3, 0xe7cf878); + Box x293 = new Box((int)0); + Box x294 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x293, x294, x3, 0x896cf214); + Box x295 = new Box((int)0); + Box x296 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x295, x296, x3, 0x67d7d140); + Box x297 = new Box((int)0); + Box x298 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x297, x298, 0x0, (x296).get(), (x293).get()); + Box x299 = new Box((int)0); + Box x300 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x299, x300, (x298).get(), (x294).get(), (x291).get()); + Box x301 = new Box((int)0); + Box x302 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x301, x302, (x300).get(), (x292).get(), (x289).get()); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x303, x304, (x302).get(), (x290).get(), (x287).get()); + Box x305 = new Box((int)0); + Box x306 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x305, x306, (x304).get(), (x288).get(), (x285).get()); + Box x307 = new Box((int)0); + Box x308 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x307, x308, (x306).get(), (x286).get(), (x283).get()); + Box x309 = new Box((int)0); + Box x310 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x309, x310, (x308).get(), (x284).get(), (x281).get()); + Box x311 = new Box((int)0); + Box x312 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x311, x312, 0x0, (x265).get(), (x295).get()); + Box x313 = new Box((int)0); + Box x314 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x313, x314, (x312).get(), (x267).get(), (x297).get()); + Box x315 = new Box((int)0); + Box x316 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x315, x316, (x314).get(), (x269).get(), (x299).get()); + Box x317 = new Box((int)0); + Box x318 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x317, x318, (x316).get(), (x271).get(), (x301).get()); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x319, x320, (x318).get(), (x273).get(), (x303).get()); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x321, x322, (x320).get(), (x275).get(), (x305).get()); + Box x323 = new Box((int)0); + Box x324 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x323, x324, (x322).get(), (x277).get(), (x307).get()); + Box x325 = new Box((int)0); + Box x326 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x325, x326, (x324).get(), (x279).get(), (x309).get()); + Box x327 = new Box((int)0); + Box x328 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x327, x328, (x311).get(), 0x5588b13f); + Box x329 = new Box((int)0); + Box x330 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x329, x330, (x327).get(), 0xffffffff); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x331, x332, (x327).get(), 0xffffffff); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x333, x334, (x327).get(), 0xffffffff); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x335, x336, (x327).get(), 0xfffffffe); + Box x337 = new Box((int)0); + Box x338 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x337, x338, (x327).get(), 0xbaaedce6); + Box x339 = new Box((int)0); + Box x340 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x339, x340, (x327).get(), 0xaf48a03b); + Box x341 = new Box((int)0); + Box x342 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x341, x342, (x327).get(), 0xbfd25e8c); + Box x343 = new Box((int)0); + Box x344 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x343, x344, (x327).get(), 0xd0364141); + Box x345 = new Box((int)0); + Box x346 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x345, x346, 0x0, (x344).get(), (x341).get()); + Box x347 = new Box((int)0); + Box x348 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x347, x348, (x346).get(), (x342).get(), (x339).get()); + Box x349 = new Box((int)0); + Box x350 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x349, x350, (x348).get(), (x340).get(), (x337).get()); + Box x351 = new Box((int)0); + Box x352 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x351, x352, (x350).get(), (x338).get(), (x335).get()); + Box x353 = new Box((int)0); + Box x354 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x353, x354, (x352).get(), (x336).get(), (x333).get()); + Box x355 = new Box((int)0); + Box x356 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x355, x356, (x354).get(), (x334).get(), (x331).get()); + Box x357 = new Box((int)0); + Box x358 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x357, x358, (x356).get(), (x332).get(), (x329).get()); + Box x359 = new Box((int)0); + Box x360 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x359, x360, 0x0, (x311).get(), (x343).get()); + Box x361 = new Box((int)0); + Box x362 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x361, x362, (x360).get(), (x313).get(), (x345).get()); + Box x363 = new Box((int)0); + Box x364 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x363, x364, (x362).get(), (x315).get(), (x347).get()); + Box x365 = new Box((int)0); + Box x366 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x365, x366, (x364).get(), (x317).get(), (x349).get()); + Box x367 = new Box((int)0); + Box x368 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x367, x368, (x366).get(), (x319).get(), (x351).get()); + Box x369 = new Box((int)0); + Box x370 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x369, x370, (x368).get(), (x321).get(), (x353).get()); + Box x371 = new Box((int)0); + Box x372 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x371, x372, (x370).get(), (x323).get(), (x355).get()); + Box x373 = new Box((int)0); + Box x374 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x373, x374, (x372).get(), (x325).get(), (x357).get()); + Box x375 = new Box((int)0); + Box x376 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x375, x376, (x374).get(), (((x326).get() + (x280).get()) + ((x310).get() + (x282).get())), ((x358).get() + (x330).get())); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x377, x378, x4, 0x9d671cd5); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x379, x380, x4, 0x81c69bc5); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x381, x382, x4, 0xe697f5e4); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x383, x384, x4, 0x5bcd07c6); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x385, x386, x4, 0x741496c2); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x387, x388, x4, 0xe7cf878); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x389, x390, x4, 0x896cf214); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x391, x392, x4, 0x67d7d140); + Box x393 = new Box((int)0); + Box x394 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x393, x394, 0x0, (x392).get(), (x389).get()); + Box x395 = new Box((int)0); + Box x396 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x395, x396, (x394).get(), (x390).get(), (x387).get()); + Box x397 = new Box((int)0); + Box x398 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x397, x398, (x396).get(), (x388).get(), (x385).get()); + Box x399 = new Box((int)0); + Box x400 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x399, x400, (x398).get(), (x386).get(), (x383).get()); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x401, x402, (x400).get(), (x384).get(), (x381).get()); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x403, x404, (x402).get(), (x382).get(), (x379).get()); + Box x405 = new Box((int)0); + Box x406 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x405, x406, (x404).get(), (x380).get(), (x377).get()); + Box x407 = new Box((int)0); + Box x408 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x407, x408, 0x0, (x361).get(), (x391).get()); + Box x409 = new Box((int)0); + Box x410 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x409, x410, (x408).get(), (x363).get(), (x393).get()); + Box x411 = new Box((int)0); + Box x412 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x411, x412, (x410).get(), (x365).get(), (x395).get()); + Box x413 = new Box((int)0); + Box x414 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x413, x414, (x412).get(), (x367).get(), (x397).get()); + Box x415 = new Box((int)0); + Box x416 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x415, x416, (x414).get(), (x369).get(), (x399).get()); + Box x417 = new Box((int)0); + Box x418 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x417, x418, (x416).get(), (x371).get(), (x401).get()); + Box x419 = new Box((int)0); + Box x420 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x419, x420, (x418).get(), (x373).get(), (x403).get()); + Box x421 = new Box((int)0); + Box x422 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x421, x422, (x420).get(), (x375).get(), (x405).get()); + Box x423 = new Box((int)0); + Box x424 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x423, x424, (x407).get(), 0x5588b13f); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x425, x426, (x423).get(), 0xffffffff); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x427, x428, (x423).get(), 0xffffffff); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x429, x430, (x423).get(), 0xffffffff); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x431, x432, (x423).get(), 0xfffffffe); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x433, x434, (x423).get(), 0xbaaedce6); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x435, x436, (x423).get(), 0xaf48a03b); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x437, x438, (x423).get(), 0xbfd25e8c); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x439, x440, (x423).get(), 0xd0364141); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x441, x442, 0x0, (x440).get(), (x437).get()); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x443, x444, (x442).get(), (x438).get(), (x435).get()); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x445, x446, (x444).get(), (x436).get(), (x433).get()); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x447, x448, (x446).get(), (x434).get(), (x431).get()); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x449, x450, (x448).get(), (x432).get(), (x429).get()); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x451, x452, (x450).get(), (x430).get(), (x427).get()); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x453, x454, (x452).get(), (x428).get(), (x425).get()); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x455, x456, 0x0, (x407).get(), (x439).get()); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x457, x458, (x456).get(), (x409).get(), (x441).get()); + Box x459 = new Box((int)0); + Box x460 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x459, x460, (x458).get(), (x411).get(), (x443).get()); + Box x461 = new Box((int)0); + Box x462 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x461, x462, (x460).get(), (x413).get(), (x445).get()); + Box x463 = new Box((int)0); + Box x464 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x463, x464, (x462).get(), (x415).get(), (x447).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x465, x466, (x464).get(), (x417).get(), (x449).get()); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x467, x468, (x466).get(), (x419).get(), (x451).get()); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x469, x470, (x468).get(), (x421).get(), (x453).get()); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x471, x472, (x470).get(), (((x422).get() + (x376).get()) + ((x406).get() + (x378).get())), ((x454).get() + (x426).get())); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x473, x474, x5, 0x9d671cd5); + Box x475 = new Box((int)0); + Box x476 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x475, x476, x5, 0x81c69bc5); + Box x477 = new Box((int)0); + Box x478 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x477, x478, x5, 0xe697f5e4); + Box x479 = new Box((int)0); + Box x480 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x479, x480, x5, 0x5bcd07c6); + Box x481 = new Box((int)0); + Box x482 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x481, x482, x5, 0x741496c2); + Box x483 = new Box((int)0); + Box x484 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x483, x484, x5, 0xe7cf878); + Box x485 = new Box((int)0); + Box x486 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x485, x486, x5, 0x896cf214); + Box x487 = new Box((int)0); + Box x488 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x487, x488, x5, 0x67d7d140); + Box x489 = new Box((int)0); + Box x490 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x489, x490, 0x0, (x488).get(), (x485).get()); + Box x491 = new Box((int)0); + Box x492 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x491, x492, (x490).get(), (x486).get(), (x483).get()); + Box x493 = new Box((int)0); + Box x494 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x493, x494, (x492).get(), (x484).get(), (x481).get()); + Box x495 = new Box((int)0); + Box x496 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x495, x496, (x494).get(), (x482).get(), (x479).get()); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x497, x498, (x496).get(), (x480).get(), (x477).get()); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x499, x500, (x498).get(), (x478).get(), (x475).get()); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x501, x502, (x500).get(), (x476).get(), (x473).get()); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x503, x504, 0x0, (x457).get(), (x487).get()); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x505, x506, (x504).get(), (x459).get(), (x489).get()); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x507, x508, (x506).get(), (x461).get(), (x491).get()); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x509, x510, (x508).get(), (x463).get(), (x493).get()); + Box x511 = new Box((int)0); + Box x512 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x511, x512, (x510).get(), (x465).get(), (x495).get()); + Box x513 = new Box((int)0); + Box x514 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x513, x514, (x512).get(), (x467).get(), (x497).get()); + Box x515 = new Box((int)0); + Box x516 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x515, x516, (x514).get(), (x469).get(), (x499).get()); + Box x517 = new Box((int)0); + Box x518 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x517, x518, (x516).get(), (x471).get(), (x501).get()); + Box x519 = new Box((int)0); + Box x520 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x519, x520, (x503).get(), 0x5588b13f); + Box x521 = new Box((int)0); + Box x522 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x521, x522, (x519).get(), 0xffffffff); + Box x523 = new Box((int)0); + Box x524 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x523, x524, (x519).get(), 0xffffffff); + Box x525 = new Box((int)0); + Box x526 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x525, x526, (x519).get(), 0xffffffff); + Box x527 = new Box((int)0); + Box x528 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x527, x528, (x519).get(), 0xfffffffe); + Box x529 = new Box((int)0); + Box x530 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x529, x530, (x519).get(), 0xbaaedce6); + Box x531 = new Box((int)0); + Box x532 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x531, x532, (x519).get(), 0xaf48a03b); + Box x533 = new Box((int)0); + Box x534 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x533, x534, (x519).get(), 0xbfd25e8c); + Box x535 = new Box((int)0); + Box x536 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x535, x536, (x519).get(), 0xd0364141); + Box x537 = new Box((int)0); + Box x538 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x537, x538, 0x0, (x536).get(), (x533).get()); + Box x539 = new Box((int)0); + Box x540 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x539, x540, (x538).get(), (x534).get(), (x531).get()); + Box x541 = new Box((int)0); + Box x542 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x541, x542, (x540).get(), (x532).get(), (x529).get()); + Box x543 = new Box((int)0); + Box x544 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x543, x544, (x542).get(), (x530).get(), (x527).get()); + Box x545 = new Box((int)0); + Box x546 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x545, x546, (x544).get(), (x528).get(), (x525).get()); + Box x547 = new Box((int)0); + Box x548 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x547, x548, (x546).get(), (x526).get(), (x523).get()); + Box x549 = new Box((int)0); + Box x550 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x549, x550, (x548).get(), (x524).get(), (x521).get()); + Box x551 = new Box((int)0); + Box x552 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x551, x552, 0x0, (x503).get(), (x535).get()); + Box x553 = new Box((int)0); + Box x554 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x553, x554, (x552).get(), (x505).get(), (x537).get()); + Box x555 = new Box((int)0); + Box x556 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x555, x556, (x554).get(), (x507).get(), (x539).get()); + Box x557 = new Box((int)0); + Box x558 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x557, x558, (x556).get(), (x509).get(), (x541).get()); + Box x559 = new Box((int)0); + Box x560 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x559, x560, (x558).get(), (x511).get(), (x543).get()); + Box x561 = new Box((int)0); + Box x562 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x561, x562, (x560).get(), (x513).get(), (x545).get()); + Box x563 = new Box((int)0); + Box x564 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x563, x564, (x562).get(), (x515).get(), (x547).get()); + Box x565 = new Box((int)0); + Box x566 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x565, x566, (x564).get(), (x517).get(), (x549).get()); + Box x567 = new Box((int)0); + Box x568 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x567, x568, (x566).get(), (((x518).get() + (x472).get()) + ((x502).get() + (x474).get())), ((x550).get() + (x522).get())); + Box x569 = new Box((int)0); + Box x570 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x569, x570, x6, 0x9d671cd5); + Box x571 = new Box((int)0); + Box x572 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x571, x572, x6, 0x81c69bc5); + Box x573 = new Box((int)0); + Box x574 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x573, x574, x6, 0xe697f5e4); + Box x575 = new Box((int)0); + Box x576 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x575, x576, x6, 0x5bcd07c6); + Box x577 = new Box((int)0); + Box x578 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x577, x578, x6, 0x741496c2); + Box x579 = new Box((int)0); + Box x580 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x579, x580, x6, 0xe7cf878); + Box x581 = new Box((int)0); + Box x582 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x581, x582, x6, 0x896cf214); + Box x583 = new Box((int)0); + Box x584 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x583, x584, x6, 0x67d7d140); + Box x585 = new Box((int)0); + Box x586 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x585, x586, 0x0, (x584).get(), (x581).get()); + Box x587 = new Box((int)0); + Box x588 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x587, x588, (x586).get(), (x582).get(), (x579).get()); + Box x589 = new Box((int)0); + Box x590 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x589, x590, (x588).get(), (x580).get(), (x577).get()); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x591, x592, (x590).get(), (x578).get(), (x575).get()); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x593, x594, (x592).get(), (x576).get(), (x573).get()); + Box x595 = new Box((int)0); + Box x596 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x595, x596, (x594).get(), (x574).get(), (x571).get()); + Box x597 = new Box((int)0); + Box x598 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x597, x598, (x596).get(), (x572).get(), (x569).get()); + Box x599 = new Box((int)0); + Box x600 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x599, x600, 0x0, (x553).get(), (x583).get()); + Box x601 = new Box((int)0); + Box x602 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x601, x602, (x600).get(), (x555).get(), (x585).get()); + Box x603 = new Box((int)0); + Box x604 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x603, x604, (x602).get(), (x557).get(), (x587).get()); + Box x605 = new Box((int)0); + Box x606 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x605, x606, (x604).get(), (x559).get(), (x589).get()); + Box x607 = new Box((int)0); + Box x608 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x607, x608, (x606).get(), (x561).get(), (x591).get()); + Box x609 = new Box((int)0); + Box x610 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x609, x610, (x608).get(), (x563).get(), (x593).get()); + Box x611 = new Box((int)0); + Box x612 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x611, x612, (x610).get(), (x565).get(), (x595).get()); + Box x613 = new Box((int)0); + Box x614 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x613, x614, (x612).get(), (x567).get(), (x597).get()); + Box x615 = new Box((int)0); + Box x616 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x615, x616, (x599).get(), 0x5588b13f); + Box x617 = new Box((int)0); + Box x618 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x617, x618, (x615).get(), 0xffffffff); + Box x619 = new Box((int)0); + Box x620 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x619, x620, (x615).get(), 0xffffffff); + Box x621 = new Box((int)0); + Box x622 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x621, x622, (x615).get(), 0xffffffff); + Box x623 = new Box((int)0); + Box x624 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x623, x624, (x615).get(), 0xfffffffe); + Box x625 = new Box((int)0); + Box x626 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x625, x626, (x615).get(), 0xbaaedce6); + Box x627 = new Box((int)0); + Box x628 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x627, x628, (x615).get(), 0xaf48a03b); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x629, x630, (x615).get(), 0xbfd25e8c); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x631, x632, (x615).get(), 0xd0364141); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x633, x634, 0x0, (x632).get(), (x629).get()); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x635, x636, (x634).get(), (x630).get(), (x627).get()); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x637, x638, (x636).get(), (x628).get(), (x625).get()); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x639, x640, (x638).get(), (x626).get(), (x623).get()); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x641, x642, (x640).get(), (x624).get(), (x621).get()); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x643, x644, (x642).get(), (x622).get(), (x619).get()); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x645, x646, (x644).get(), (x620).get(), (x617).get()); + Box x647 = new Box((int)0); + Box x648 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x647, x648, 0x0, (x599).get(), (x631).get()); + Box x649 = new Box((int)0); + Box x650 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x649, x650, (x648).get(), (x601).get(), (x633).get()); + Box x651 = new Box((int)0); + Box x652 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x651, x652, (x650).get(), (x603).get(), (x635).get()); + Box x653 = new Box((int)0); + Box x654 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x653, x654, (x652).get(), (x605).get(), (x637).get()); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x655, x656, (x654).get(), (x607).get(), (x639).get()); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x657, x658, (x656).get(), (x609).get(), (x641).get()); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x659, x660, (x658).get(), (x611).get(), (x643).get()); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x661, x662, (x660).get(), (x613).get(), (x645).get()); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x663, x664, (x662).get(), (((x614).get() + (x568).get()) + ((x598).get() + (x570).get())), ((x646).get() + (x618).get())); + Box x665 = new Box((int)0); + Box x666 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x665, x666, x7, 0x9d671cd5); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x667, x668, x7, 0x81c69bc5); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x669, x670, x7, 0xe697f5e4); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x671, x672, x7, 0x5bcd07c6); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x673, x674, x7, 0x741496c2); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x675, x676, x7, 0xe7cf878); + Box x677 = new Box((int)0); + Box x678 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x677, x678, x7, 0x896cf214); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x679, x680, x7, 0x67d7d140); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x681, x682, 0x0, (x680).get(), (x677).get()); + Box x683 = new Box((int)0); + Box x684 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x683, x684, (x682).get(), (x678).get(), (x675).get()); + Box x685 = new Box((int)0); + Box x686 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x685, x686, (x684).get(), (x676).get(), (x673).get()); + Box x687 = new Box((int)0); + Box x688 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x687, x688, (x686).get(), (x674).get(), (x671).get()); + Box x689 = new Box((int)0); + Box x690 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x689, x690, (x688).get(), (x672).get(), (x669).get()); + Box x691 = new Box((int)0); + Box x692 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x691, x692, (x690).get(), (x670).get(), (x667).get()); + Box x693 = new Box((int)0); + Box x694 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x693, x694, (x692).get(), (x668).get(), (x665).get()); + Box x695 = new Box((int)0); + Box x696 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x695, x696, 0x0, (x649).get(), (x679).get()); + Box x697 = new Box((int)0); + Box x698 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x697, x698, (x696).get(), (x651).get(), (x681).get()); + Box x699 = new Box((int)0); + Box x700 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x699, x700, (x698).get(), (x653).get(), (x683).get()); + Box x701 = new Box((int)0); + Box x702 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x701, x702, (x700).get(), (x655).get(), (x685).get()); + Box x703 = new Box((int)0); + Box x704 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x703, x704, (x702).get(), (x657).get(), (x687).get()); + Box x705 = new Box((int)0); + Box x706 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x705, x706, (x704).get(), (x659).get(), (x689).get()); + Box x707 = new Box((int)0); + Box x708 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x707, x708, (x706).get(), (x661).get(), (x691).get()); + Box x709 = new Box((int)0); + Box x710 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x709, x710, (x708).get(), (x663).get(), (x693).get()); + Box x711 = new Box((int)0); + Box x712 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x711, x712, (x695).get(), 0x5588b13f); + Box x713 = new Box((int)0); + Box x714 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x713, x714, (x711).get(), 0xffffffff); + Box x715 = new Box((int)0); + Box x716 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x715, x716, (x711).get(), 0xffffffff); + Box x717 = new Box((int)0); + Box x718 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x717, x718, (x711).get(), 0xffffffff); + Box x719 = new Box((int)0); + Box x720 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x719, x720, (x711).get(), 0xfffffffe); + Box x721 = new Box((int)0); + Box x722 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x721, x722, (x711).get(), 0xbaaedce6); + Box x723 = new Box((int)0); + Box x724 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x723, x724, (x711).get(), 0xaf48a03b); + Box x725 = new Box((int)0); + Box x726 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x725, x726, (x711).get(), 0xbfd25e8c); + Box x727 = new Box((int)0); + Box x728 = new Box((int)0); + fiat_Secp256K1Scalar_mulx_u32(x727, x728, (x711).get(), 0xd0364141); + Box x729 = new Box((int)0); + Box x730 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x729, x730, 0x0, (x728).get(), (x725).get()); + Box x731 = new Box((int)0); + Box x732 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x731, x732, (x730).get(), (x726).get(), (x723).get()); + Box x733 = new Box((int)0); + Box x734 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x733, x734, (x732).get(), (x724).get(), (x721).get()); + Box x735 = new Box((int)0); + Box x736 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x735, x736, (x734).get(), (x722).get(), (x719).get()); + Box x737 = new Box((int)0); + Box x738 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x737, x738, (x736).get(), (x720).get(), (x717).get()); + Box x739 = new Box((int)0); + Box x740 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x739, x740, (x738).get(), (x718).get(), (x715).get()); + Box x741 = new Box((int)0); + Box x742 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x741, x742, (x740).get(), (x716).get(), (x713).get()); + Box x743 = new Box((int)0); + Box x744 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x743, x744, 0x0, (x695).get(), (x727).get()); + Box x745 = new Box((int)0); + Box x746 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x745, x746, (x744).get(), (x697).get(), (x729).get()); + Box x747 = new Box((int)0); + Box x748 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x747, x748, (x746).get(), (x699).get(), (x731).get()); + Box x749 = new Box((int)0); + Box x750 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x749, x750, (x748).get(), (x701).get(), (x733).get()); + Box x751 = new Box((int)0); + Box x752 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x751, x752, (x750).get(), (x703).get(), (x735).get()); + Box x753 = new Box((int)0); + Box x754 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x753, x754, (x752).get(), (x705).get(), (x737).get()); + Box x755 = new Box((int)0); + Box x756 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x755, x756, (x754).get(), (x707).get(), (x739).get()); + Box x757 = new Box((int)0); + Box x758 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x757, x758, (x756).get(), (x709).get(), (x741).get()); + Box x759 = new Box((int)0); + Box x760 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x759, x760, (x758).get(), (((x710).get() + (x664).get()) + ((x694).get() + (x666).get())), ((x742).get() + (x714).get())); + Box x761 = new Box((int)0); + Box x762 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x761, x762, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x745).get(), 0xd0364141); + Box x763 = new Box((int)0); + Box x764 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x763, x764, (x762).get(), (x747).get(), 0xbfd25e8c); + Box x765 = new Box((int)0); + Box x766 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x765, x766, (x764).get(), (x749).get(), 0xaf48a03b); + Box x767 = new Box((int)0); + Box x768 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x767, x768, (x766).get(), (x751).get(), 0xbaaedce6); + Box x769 = new Box((int)0); + Box x770 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x769, x770, (x768).get(), (x753).get(), 0xfffffffe); + Box x771 = new Box((int)0); + Box x772 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x771, x772, (x770).get(), (x755).get(), 0xffffffff); + Box x773 = new Box((int)0); + Box x774 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x773, x774, (x772).get(), (x757).get(), 0xffffffff); + Box x775 = new Box((int)0); + Box x776 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x775, x776, (x774).get(), (x759).get(), 0xffffffff); + Box x777 = new Box((int)0); + Box x778 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x777, x778, (x776).get(), (x760).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x779 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x779, (x778).get(), (x761).get(), (x745).get()); + Box x780 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x780, (x778).get(), (x763).get(), (x747).get()); + Box x781 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x781, (x778).get(), (x765).get(), (x749).get()); + Box x782 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x782, (x778).get(), (x767).get(), (x751).get()); + Box x783 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x783, (x778).get(), (x769).get(), (x753).get()); + Box x784 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x784, (x778).get(), (x771).get(), (x755).get()); + Box x785 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x785, (x778).get(), (x773).get(), (x757).get()); + Box x786 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x786, (x778).get(), (x775).get(), (x759).get()); + out1[0] = (x779).get(); + out1[1] = (x780).get(); + out1[2] = (x781).get(); + out1[3] = (x782).get(); + out1[4] = (x783).get(); + out1[5] = (x784).get(); + out1[6] = (x785).get(); + out1[7] = (x786).get(); +} + +/** + * The function fiat_Secp256K1Scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ */ +public static void fiat_Secp256K1Scalar_nonzero(Box out1, final int[] arg1) { + int x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | (arg1[7])))))))); + out1.set(x1); +} + +/** + * The function fiat_Secp256K1Scalar_selectznz is a multi-limb conditional select.

+ *

+ * Postconditions:

+ * out1 = (if arg1 = 0 then arg2 else arg3)

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0x1]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_selectznz(int[] out1, int arg1, final int[] arg2, final int[] arg3) { + Box x1 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x1, arg1, (arg2[0]), (arg3[0])); + Box x2 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x2, arg1, (arg2[1]), (arg3[1])); + Box x3 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x3, arg1, (arg2[2]), (arg3[2])); + Box x4 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x4, arg1, (arg2[3]), (arg3[3])); + Box x5 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x5, arg1, (arg2[4]), (arg3[4])); + Box x6 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x6, arg1, (arg2[5]), (arg3[5])); + Box x7 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x7, arg1, (arg2[6]), (arg3[6])); + Box x8 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x8, arg1, (arg2[7]), (arg3[7])); + out1[0] = (x1).get(); + out1[1] = (x2).get(); + out1[2] = (x3).get(); + out1[3] = (x4).get(); + out1[4] = (x5).get(); + out1[5] = (x6).get(); + out1[6] = (x7).get(); + out1[7] = (x8).get(); +} + +/** + * The function fiat_Secp256K1Scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg1 < m

+ * Postconditions:

+ * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31]

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]

+ */ +public static void fiat_Secp256K1Scalar_to_bytes(int[] out1, final int[] arg1) { + int x1 = (arg1[7]); + int x2 = (arg1[6]); + int x3 = (arg1[5]); + int x4 = (arg1[4]); + int x5 = (arg1[3]); + int x6 = (arg1[2]); + int x7 = (arg1[1]); + int x8 = (arg1[0]); + int x9 = (x8 & 0xff); + int x10 = (x8 >>> 8); + int x11 = (x10 & 0xff); + int x12 = (x10 >>> 8); + int x13 = (x12 & 0xff); + int x14 = (x12 >>> 8); + int x15 = (x7 & 0xff); + int x16 = (x7 >>> 8); + int x17 = (x16 & 0xff); + int x18 = (x16 >>> 8); + int x19 = (x18 & 0xff); + int x20 = (x18 >>> 8); + int x21 = (x6 & 0xff); + int x22 = (x6 >>> 8); + int x23 = (x22 & 0xff); + int x24 = (x22 >>> 8); + int x25 = (x24 & 0xff); + int x26 = (x24 >>> 8); + int x27 = (x5 & 0xff); + int x28 = (x5 >>> 8); + int x29 = (x28 & 0xff); + int x30 = (x28 >>> 8); + int x31 = (x30 & 0xff); + int x32 = (x30 >>> 8); + int x33 = (x4 & 0xff); + int x34 = (x4 >>> 8); + int x35 = (x34 & 0xff); + int x36 = (x34 >>> 8); + int x37 = (x36 & 0xff); + int x38 = (x36 >>> 8); + int x39 = (x3 & 0xff); + int x40 = (x3 >>> 8); + int x41 = (x40 & 0xff); + int x42 = (x40 >>> 8); + int x43 = (x42 & 0xff); + int x44 = (x42 >>> 8); + int x45 = (x2 & 0xff); + int x46 = (x2 >>> 8); + int x47 = (x46 & 0xff); + int x48 = (x46 >>> 8); + int x49 = (x48 & 0xff); + int x50 = (x48 >>> 8); + int x51 = (x1 & 0xff); + int x52 = (x1 >>> 8); + int x53 = (x52 & 0xff); + int x54 = (x52 >>> 8); + int x55 = (x54 & 0xff); + int x56 = (x54 >>> 8); + out1[0] = x9; + out1[1] = x11; + out1[2] = x13; + out1[3] = x14; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x26; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x38; + out1[20] = x39; + out1[21] = x41; + out1[22] = x43; + out1[23] = x44; + out1[24] = x45; + out1[25] = x47; + out1[26] = x49; + out1[27] = x50; + out1[28] = x51; + out1[29] = x53; + out1[30] = x55; + out1[31] = x56; +} + +/** + * The function fiat_Secp256K1Scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order.

+ *

+ * Preconditions:

+ * 0 ≤ bytes_eval arg1 < m

+ * Postconditions:

+ * eval out1 mod m = bytes_eval arg1 mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Input Bounds:

+ * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_from_bytes(int[] out1, final int[] arg1) { + int x1 = ((arg1[31]) << 24); + int x2 = ((arg1[30]) << 16); + int x3 = ((arg1[29]) << 8); + int x4 = (arg1[28]); + int x5 = ((arg1[27]) << 24); + int x6 = ((arg1[26]) << 16); + int x7 = ((arg1[25]) << 8); + int x8 = (arg1[24]); + int x9 = ((arg1[23]) << 24); + int x10 = ((arg1[22]) << 16); + int x11 = ((arg1[21]) << 8); + int x12 = (arg1[20]); + int x13 = ((arg1[19]) << 24); + int x14 = ((arg1[18]) << 16); + int x15 = ((arg1[17]) << 8); + int x16 = (arg1[16]); + int x17 = ((arg1[15]) << 24); + int x18 = ((arg1[14]) << 16); + int x19 = ((arg1[13]) << 8); + int x20 = (arg1[12]); + int x21 = ((arg1[11]) << 24); + int x22 = ((arg1[10]) << 16); + int x23 = ((arg1[9]) << 8); + int x24 = (arg1[8]); + int x25 = ((arg1[7]) << 24); + int x26 = ((arg1[6]) << 16); + int x27 = ((arg1[5]) << 8); + int x28 = (arg1[4]); + int x29 = ((arg1[3]) << 24); + int x30 = ((arg1[2]) << 16); + int x31 = ((arg1[1]) << 8); + int x32 = (arg1[0]); + int x33 = (x31 + x32); + int x34 = (x30 + x33); + int x35 = (x29 + x34); + int x36 = (x27 + x28); + int x37 = (x26 + x36); + int x38 = (x25 + x37); + int x39 = (x23 + x24); + int x40 = (x22 + x39); + int x41 = (x21 + x40); + int x42 = (x19 + x20); + int x43 = (x18 + x42); + int x44 = (x17 + x43); + int x45 = (x15 + x16); + int x46 = (x14 + x45); + int x47 = (x13 + x46); + int x48 = (x11 + x12); + int x49 = (x10 + x48); + int x50 = (x9 + x49); + int x51 = (x7 + x8); + int x52 = (x6 + x51); + int x53 = (x5 + x52); + int x54 = (x3 + x4); + int x55 = (x2 + x54); + int x56 = (x1 + x55); + out1[0] = x35; + out1[1] = x38; + out1[2] = x41; + out1[3] = x44; + out1[4] = x47; + out1[5] = x50; + out1[6] = x53; + out1[7] = x56; +} + +/** + * The function fiat_Secp256K1Scalar_set_one returns the field element one in the Montgomery domain.

+ *

+ * Postconditions:

+ * eval (from_montgomery out1) mod m = 1 mod m

+ * 0 ≤ eval out1 < m

+ *

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_set_one(int[] out1) { + out1[0] = 0x2fc9bebf; + out1[1] = 0x402da173; + out1[2] = 0x50b75fc4; + out1[3] = 0x45512319; + out1[4] = 0x1; + out1[5] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[6] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[7] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); +} + +/** + * The function fiat_Secp256K1Scalar_msat returns the saturated representation of the prime modulus.

+ *

+ * Postconditions:

+ * twos_complement_eval out1 = m

+ * 0 ≤ eval out1 < m

+ *

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_msat(int[] out1) { + out1[0] = 0xd0364141; + out1[1] = 0xbfd25e8c; + out1[2] = 0xaf48a03b; + out1[3] = 0xbaaedce6; + out1[4] = 0xfffffffe; + out1[5] = 0xffffffff; + out1[6] = 0xffffffff; + out1[7] = 0xffffffff; + out1[8] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); +} + +/** + * The function fiat_Secp256K1Scalar_divstep computes a divstep.

+ *

+ * Preconditions:

+ * 0 ≤ eval arg4 < m

+ * 0 ≤ eval arg5 < m

+ * Postconditions:

+ * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1)

+ * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2)

+ * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋)

+ * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m)

+ * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m)

+ * 0 ≤ eval out5 < m

+ * 0 ≤ eval out5 < m

+ * 0 ≤ eval out2 < m

+ * 0 ≤ eval out3 < m

+ *

+ * Input Bounds:

+ * arg1: [0x0 ~> 0xffffffff]

+ * arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * Output Bounds:

+ * out1: [0x0 ~> 0xffffffff]

+ * out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ * out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_divstep(Box out1, int[] out2, int[] out3, int[] out4, int[] out5, int arg1, final int[] arg2, final int[] arg3, final int[] arg4, final int[] arg5) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x1, x2, 0x0, (~arg1), 0x1); + int x3 = (((x1).get() >>> 31) & ((arg3[0]) & 0x1)); + Box x4 = new Box((int)0); + Box x5 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x4, x5, 0x0, (~arg1), 0x1); + Box x6 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x6, x3, arg1, (x4).get()); + Box x7 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x7, x3, (arg2[0]), (arg3[0])); + Box x8 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x8, x3, (arg2[1]), (arg3[1])); + Box x9 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x9, x3, (arg2[2]), (arg3[2])); + Box x10 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x10, x3, (arg2[3]), (arg3[3])); + Box x11 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x11, x3, (arg2[4]), (arg3[4])); + Box x12 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x12, x3, (arg2[5]), (arg3[5])); + Box x13 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x13, x3, (arg2[6]), (arg3[6])); + Box x14 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x14, x3, (arg2[7]), (arg3[7])); + Box x15 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x15, x3, (arg2[8]), (arg3[8])); + Box x16 = new Box((int)0); + Box x17 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x16, x17, 0x0, 0x1, (~(arg2[0]))); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x18, x19, (x17).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[1]))); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x20, x21, (x19).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[2]))); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x22, x23, (x21).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[3]))); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x24, x25, (x23).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[4]))); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x26, x27, (x25).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[5]))); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x28, x29, (x27).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[6]))); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x30, x31, (x29).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[7]))); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x32, x33, (x31).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[8]))); + Box x34 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x34, x3, (arg3[0]), (x16).get()); + Box x35 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x35, x3, (arg3[1]), (x18).get()); + Box x36 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x36, x3, (arg3[2]), (x20).get()); + Box x37 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x37, x3, (arg3[3]), (x22).get()); + Box x38 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x38, x3, (arg3[4]), (x24).get()); + Box x39 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x39, x3, (arg3[5]), (x26).get()); + Box x40 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x40, x3, (arg3[6]), (x28).get()); + Box x41 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x41, x3, (arg3[7]), (x30).get()); + Box x42 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x42, x3, (arg3[8]), (x32).get()); + Box x43 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x43, x3, (arg4[0]), (arg5[0])); + Box x44 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x44, x3, (arg4[1]), (arg5[1])); + Box x45 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x45, x3, (arg4[2]), (arg5[2])); + Box x46 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x46, x3, (arg4[3]), (arg5[3])); + Box x47 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x47, x3, (arg4[4]), (arg5[4])); + Box x48 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x48, x3, (arg4[5]), (arg5[5])); + Box x49 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x49, x3, (arg4[6]), (arg5[6])); + Box x50 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x50, x3, (arg4[7]), (arg5[7])); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x51, x52, 0x0, (x43).get(), (x43).get()); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x53, x54, (x52).get(), (x44).get(), (x44).get()); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x55, x56, (x54).get(), (x45).get(), (x45).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x57, x58, (x56).get(), (x46).get(), (x46).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x59, x60, (x58).get(), (x47).get(), (x47).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x61, x62, (x60).get(), (x48).get(), (x48).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x63, x64, (x62).get(), (x49).get(), (x49).get()); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x65, x66, (x64).get(), (x50).get(), (x50).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x67, x68, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x51).get(), 0xd0364141); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x69, x70, (x68).get(), (x53).get(), 0xbfd25e8c); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x71, x72, (x70).get(), (x55).get(), 0xaf48a03b); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x73, x74, (x72).get(), (x57).get(), 0xbaaedce6); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x75, x76, (x74).get(), (x59).get(), 0xfffffffe); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x77, x78, (x76).get(), (x61).get(), 0xffffffff); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x79, x80, (x78).get(), (x63).get(), 0xffffffff); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x81, x82, (x80).get(), (x65).get(), 0xffffffff); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x83, x84, (x82).get(), (x66).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + int x85 = (arg4[7]); + int x86 = (arg4[6]); + int x87 = (arg4[5]); + int x88 = (arg4[4]); + int x89 = (arg4[3]); + int x90 = (arg4[2]); + int x91 = (arg4[1]); + int x92 = (arg4[0]); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x93, x94, 0x0, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x92); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x95, x96, (x94).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x91); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x97, x98, (x96).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x90); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x99, x100, (x98).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x89); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x101, x102, (x100).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x88); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x103, x104, (x102).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x87); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x105, x106, (x104).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x86); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x107, x108, (x106).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x85); + Box x109 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x109, (x108).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), 0xffffffff); + Box x110 = new Box((int)0); + Box x111 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x110, x111, 0x0, (x93).get(), ((x109).get() & 0xd0364141)); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x112, x113, (x111).get(), (x95).get(), ((x109).get() & 0xbfd25e8c)); + Box x114 = new Box((int)0); + Box x115 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x114, x115, (x113).get(), (x97).get(), ((x109).get() & 0xaf48a03b)); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x116, x117, (x115).get(), (x99).get(), ((x109).get() & 0xbaaedce6)); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x118, x119, (x117).get(), (x101).get(), ((x109).get() & 0xfffffffe)); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x120, x121, (x119).get(), (x103).get(), (x109).get()); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x122, x123, (x121).get(), (x105).get(), (x109).get()); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x124, x125, (x123).get(), (x107).get(), (x109).get()); + Box x126 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x126, x3, (arg5[0]), (x110).get()); + Box x127 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x127, x3, (arg5[1]), (x112).get()); + Box x128 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x128, x3, (arg5[2]), (x114).get()); + Box x129 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x129, x3, (arg5[3]), (x116).get()); + Box x130 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x130, x3, (arg5[4]), (x118).get()); + Box x131 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x131, x3, (arg5[5]), (x120).get()); + Box x132 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x132, x3, (arg5[6]), (x122).get()); + Box x133 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x133, x3, (arg5[7]), (x124).get()); + int x134 = ((x34).get() & 0x1); + Box x135 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x135, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x7).get()); + Box x136 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x136, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x8).get()); + Box x137 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x137, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x9).get()); + Box x138 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x138, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x10).get()); + Box x139 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x139, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x11).get()); + Box x140 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x140, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x12).get()); + Box x141 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x141, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x13).get()); + Box x142 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x142, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x14).get()); + Box x143 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x143, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x15).get()); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x144, x145, 0x0, (x34).get(), (x135).get()); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x146, x147, (x145).get(), (x35).get(), (x136).get()); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x148, x149, (x147).get(), (x36).get(), (x137).get()); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x150, x151, (x149).get(), (x37).get(), (x138).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x152, x153, (x151).get(), (x38).get(), (x139).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x154, x155, (x153).get(), (x39).get(), (x140).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x156, x157, (x155).get(), (x40).get(), (x141).get()); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x158, x159, (x157).get(), (x41).get(), (x142).get()); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x160, x161, (x159).get(), (x42).get(), (x143).get()); + Box x162 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x162, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x43).get()); + Box x163 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x163, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x44).get()); + Box x164 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x164, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x45).get()); + Box x165 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x165, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x46).get()); + Box x166 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x166, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x47).get()); + Box x167 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x167, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x48).get()); + Box x168 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x168, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x49).get()); + Box x169 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x169, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x50).get()); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x170, x171, 0x0, (x126).get(), (x162).get()); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x172, x173, (x171).get(), (x127).get(), (x163).get()); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x174, x175, (x173).get(), (x128).get(), (x164).get()); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x176, x177, (x175).get(), (x129).get(), (x165).get()); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x178, x179, (x177).get(), (x130).get(), (x166).get()); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x180, x181, (x179).get(), (x131).get(), (x167).get()); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x182, x183, (x181).get(), (x132).get(), (x168).get()); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x184, x185, (x183).get(), (x133).get(), (x169).get()); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x186, x187, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x170).get(), 0xd0364141); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x188, x189, (x187).get(), (x172).get(), 0xbfd25e8c); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x190, x191, (x189).get(), (x174).get(), 0xaf48a03b); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x192, x193, (x191).get(), (x176).get(), 0xbaaedce6); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x194, x195, (x193).get(), (x178).get(), 0xfffffffe); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x196, x197, (x195).get(), (x180).get(), 0xffffffff); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x198, x199, (x197).get(), (x182).get(), 0xffffffff); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x200, x201, (x199).get(), (x184).get(), 0xffffffff); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Secp256K1Scalar_subborrowx_u32(x202, x203, (x201).get(), (x185).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_Secp256K1Scalar_addcarryx_u32(x204, x205, 0x0, (x6).get(), 0x1); + int x206 = (((x144).get() >>> 1) | (((x146).get() << 31) & 0xffffffff)); + int x207 = (((x146).get() >>> 1) | (((x148).get() << 31) & 0xffffffff)); + int x208 = (((x148).get() >>> 1) | (((x150).get() << 31) & 0xffffffff)); + int x209 = (((x150).get() >>> 1) | (((x152).get() << 31) & 0xffffffff)); + int x210 = (((x152).get() >>> 1) | (((x154).get() << 31) & 0xffffffff)); + int x211 = (((x154).get() >>> 1) | (((x156).get() << 31) & 0xffffffff)); + int x212 = (((x156).get() >>> 1) | (((x158).get() << 31) & 0xffffffff)); + int x213 = (((x158).get() >>> 1) | (((x160).get() << 31) & 0xffffffff)); + int x214 = (((x160).get() & 0x80000000) | ((x160).get() >>> 1)); + Box x215 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x215, (x84).get(), (x67).get(), (x51).get()); + Box x216 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x216, (x84).get(), (x69).get(), (x53).get()); + Box x217 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x217, (x84).get(), (x71).get(), (x55).get()); + Box x218 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x218, (x84).get(), (x73).get(), (x57).get()); + Box x219 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x219, (x84).get(), (x75).get(), (x59).get()); + Box x220 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x220, (x84).get(), (x77).get(), (x61).get()); + Box x221 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x221, (x84).get(), (x79).get(), (x63).get()); + Box x222 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x222, (x84).get(), (x81).get(), (x65).get()); + Box x223 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x223, (x203).get(), (x186).get(), (x170).get()); + Box x224 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x224, (x203).get(), (x188).get(), (x172).get()); + Box x225 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x225, (x203).get(), (x190).get(), (x174).get()); + Box x226 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x226, (x203).get(), (x192).get(), (x176).get()); + Box x227 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x227, (x203).get(), (x194).get(), (x178).get()); + Box x228 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x228, (x203).get(), (x196).get(), (x180).get()); + Box x229 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x229, (x203).get(), (x198).get(), (x182).get()); + Box x230 = new Box((int)0); + fiat_Secp256K1Scalar_cmovznz_u32(x230, (x203).get(), (x200).get(), (x184).get()); + out1.set((x204).get()); + out2[0] = (x7).get(); + out2[1] = (x8).get(); + out2[2] = (x9).get(); + out2[3] = (x10).get(); + out2[4] = (x11).get(); + out2[5] = (x12).get(); + out2[6] = (x13).get(); + out2[7] = (x14).get(); + out2[8] = (x15).get(); + out3[0] = x206; + out3[1] = x207; + out3[2] = x208; + out3[3] = x209; + out3[4] = x210; + out3[5] = x211; + out3[6] = x212; + out3[7] = x213; + out3[8] = x214; + out4[0] = (x215).get(); + out4[1] = (x216).get(); + out4[2] = (x217).get(); + out4[3] = (x218).get(); + out4[4] = (x219).get(); + out4[5] = (x220).get(); + out4[6] = (x221).get(); + out4[7] = (x222).get(); + out5[0] = (x223).get(); + out5[1] = (x224).get(); + out5[2] = (x225).get(); + out5[3] = (x226).get(); + out5[4] = (x227).get(); + out5[5] = (x228).get(); + out5[6] = (x229).get(); + out5[7] = (x230).get(); +} + +/** + * The function fiat_Secp256K1Scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form).

+ *

+ * Postconditions:

+ * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋)

+ * 0 ≤ eval out1 < m

+ *

+ * Output Bounds:

+ * out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]

+ */ +public static void fiat_Secp256K1Scalar_divstep_precomp(int[] out1) { + out1[0] = 0x2b9cb4e9; + out1[1] = 0xd7431a4d; + out1[2] = 0x32d9c503; + out1[3] = 0xab67d35a; + out1[4] = 0x859ce35f; + out1[5] = 0xadf6c7e5; + out1[6] = 0x1df6c379; + out1[7] = 0x61544145; +} + +} diff --git a/fiat-json/src/curve25519_scalar_32.json b/fiat-json/src/curve25519_scalar_32.json new file mode 100644 index 0000000000..31104c0165 --- /dev/null +++ b/fiat-json/src/curve25519_scalar_32.json @@ -0,0 +1,74132 @@ +[ + { + "operation": "fiat_25519_scalar_addcarryx_u32", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_subborrowx_u32", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "i64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "i1", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_mulx_u32", + "arguments": [ + { + "datatype": "u32", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "out2", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "*", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_cmovznz_u32", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "body": [ + { + "datatype": "u1", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_mul", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "x53" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x58" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x107" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "x135" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x138", + "x139" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x140", + "x141" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x142", + "x143" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x144" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x146" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x149", + "x150" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x163" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x194" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x195", + "x196" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "x204" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x205", + "x206" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x207", + "x208" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x209", + "x210" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x211", + "x212" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x213", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x215", + "x216" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x217", + "x218" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x219", + "x220" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x221", + "x222" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "x230" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x231" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x233" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x234", + "x235" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x236", + "x237" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x238", + "x239" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x240", + "x241" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x242", + "x243" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x244", + "x245" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x246", + "x247" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x250" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x251", + "x252" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x253", + "x254" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x255", + "x256" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x257", + "x258" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x259", + "x260" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x261", + "x262" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x263", + "x264" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x265", + "x266" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x267", + "x268" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x269", + "x270" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x271", + "x272" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x273", + "x274" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x275", + "x276" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x277", + "x278" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x279", + "x280" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x281" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x282", + "x283" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x284", + "x285" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x286", + "x287" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x288", + "x289" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x290", + "x291" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x292", + "x293" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x294", + "x295" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x296", + "x297" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x298", + "x299" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x300", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x302", + "x303" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x304", + "x305" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x306", + "x307" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x308", + "x309" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x310", + "x311" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x312", + "x313" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x316", + "x317" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x318" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x320" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x321", + "x322" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x323", + "x324" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x325", + "x326" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x327", + "x328" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x329", + "x330" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x337" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x338", + "x339" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x340", + "x341" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x342", + "x343" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x344", + "x345" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x346", + "x347" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x348", + "x349" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x350", + "x351" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x352", + "x353" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x354", + "x355" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x356", + "x357" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x358", + "x359" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x360", + "x361" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x362", + "x363" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x364", + "x365" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x366", + "x367" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x368" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x369", + "x370" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x371", + "x372" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x373", + "x374" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x375", + "x376" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x377", + "x378" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x393", + "x394" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x395", + "x396" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x399", + "x400" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x401", + "x402" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x403", + "x404" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x405" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x407" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x408", + "x409" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x410", + "x411" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x412", + "x413" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x414", + "x415" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x416", + "x417" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x418", + "x419" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x420", + "x421" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x422", + "x423" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x424" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x425", + "x426" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x427", + "x428" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x431", + "x432" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "x440" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "x444" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x445", + "x446" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x447", + "x448" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x449", + "x450" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x451", + "x452" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x453", + "x454" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x455" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x456", + "x457" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x458", + "x459" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x460", + "x461" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x462", + "x463" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x464", + "x465" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x466", + "x467" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x468", + "x469" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x470", + "x471" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x472", + "x473" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x474", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x476", + "x477" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x478", + "x479" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x480", + "x481" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x482", + "x483" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x484", + "x485" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x486", + "x487" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x488", + "x489" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x490", + "x491" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x492" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x494" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x495", + "x496" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x497", + "x498" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x499", + "x500" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x501", + "x502" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x503", + "x504" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x505", + "x506" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x507", + "x508" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x509", + "x510" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x511" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x512", + "x513" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x514", + "x515" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x516", + "x517" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x518", + "x519" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x520", + "x521" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x522", + "x523" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x524", + "x525" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x526", + "x527" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x528", + "x529" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x530", + "x531" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x532", + "x533" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x520" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x534", + "x535" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x536", + "x537" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x538", + "x539" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x540", + "x541" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x542" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x541" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x543", + "x544" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x545", + "x546" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x547", + "x548" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x549", + "x550" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x551", + "x552" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x553", + "x554" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x555", + "x556" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x507" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x557", + "x558" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x540" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x559", + "x560" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x561", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x563", + "x564" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x565", + "x566" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x567", + "x568" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x569", + "x570" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x571", + "x572" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x573", + "x574" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x575", + "x576" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x577", + "x578" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x579" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x581" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x582", + "x583" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x545" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x584", + "x585" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x586", + "x587" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x577" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x588", + "x589" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x551" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x590", + "x591" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x592", + "x593" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x555" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x594", + "x595" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x596", + "x597" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x598" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x599", + "x600" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x601", + "x602" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x603", + "x604" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x605", + "x606" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x607", + "x608" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x609", + "x610" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x611", + "x612" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x613", + "x614" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x615", + "x616" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x617", + "x618" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x616" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x619", + "x620" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x610" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x621", + "x622" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x623", + "x624" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x625", + "x626" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x627", + "x628" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x629" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x600" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x630", + "x631" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x632", + "x633" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x634", + "x635" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x636", + "x637" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x638", + "x639" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x640", + "x641" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x642", + "x643" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x644", + "x645" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x646", + "x647" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x648", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x650", + "x651" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x652", + "x653" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x654", + "x655" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x656", + "x657" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x658", + "x659" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x660", + "x661" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x656" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x662", + "x663" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x664", + "x665" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x666" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x665" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x668" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "x670" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x660" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x662" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x636" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x677", + "x678" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x681", + "x682" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x683", + "x684" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x646" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x685" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x684" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x647" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x686", + "x687" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x688", + "x689" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x687" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x690", + "x691" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x689" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x692", + "x693" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x691" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x694", + "x695" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x693" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x696", + "x697" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x695" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x698", + "x699" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x700", + "x701" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x703" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x685" + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x704" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x705" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x706" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x707" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x708" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x709" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x710" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x698" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x711" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x704" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x705" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x706" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x707" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x708" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x709" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x710" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_square", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "x53" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x58" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x107" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "x135" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x138", + "x139" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x140", + "x141" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x142", + "x143" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x144" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x146" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x149", + "x150" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x163" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x194" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x195", + "x196" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "x204" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x205", + "x206" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x207", + "x208" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x209", + "x210" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x211", + "x212" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x213", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x215", + "x216" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x217", + "x218" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x219", + "x220" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x221", + "x222" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "x230" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x231" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x233" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x234", + "x235" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x236", + "x237" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x238", + "x239" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x240", + "x241" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x242", + "x243" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x244", + "x245" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x246", + "x247" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x250" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x251", + "x252" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x253", + "x254" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x255", + "x256" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x257", + "x258" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x259", + "x260" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x261", + "x262" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x263", + "x264" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x265", + "x266" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x267", + "x268" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x269", + "x270" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x271", + "x272" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x273", + "x274" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x275", + "x276" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x277", + "x278" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x279", + "x280" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x281" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x282", + "x283" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x284", + "x285" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x286", + "x287" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x288", + "x289" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x290", + "x291" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x292", + "x293" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x294", + "x295" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x296", + "x297" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x298", + "x299" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x300", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x302", + "x303" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x304", + "x305" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x306", + "x307" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x308", + "x309" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x310", + "x311" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x312", + "x313" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x316", + "x317" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x318" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x320" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x321", + "x322" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x323", + "x324" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x325", + "x326" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x327", + "x328" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x329", + "x330" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x337" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x338", + "x339" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x340", + "x341" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x342", + "x343" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x344", + "x345" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x346", + "x347" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x348", + "x349" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x350", + "x351" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x352", + "x353" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x354", + "x355" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x356", + "x357" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x358", + "x359" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x360", + "x361" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x362", + "x363" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x364", + "x365" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x366", + "x367" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x368" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x369", + "x370" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x371", + "x372" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x373", + "x374" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x375", + "x376" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x377", + "x378" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x393", + "x394" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x395", + "x396" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x399", + "x400" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x401", + "x402" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x403", + "x404" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x405" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x407" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x408", + "x409" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x410", + "x411" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x412", + "x413" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x414", + "x415" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x416", + "x417" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x418", + "x419" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x420", + "x421" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x422", + "x423" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x424" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x425", + "x426" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x427", + "x428" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x431", + "x432" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "x440" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "x444" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x445", + "x446" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x447", + "x448" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x449", + "x450" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x451", + "x452" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x453", + "x454" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x455" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x456", + "x457" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x458", + "x459" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x460", + "x461" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x462", + "x463" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x464", + "x465" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x466", + "x467" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x468", + "x469" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x470", + "x471" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x472", + "x473" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x474", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x476", + "x477" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x478", + "x479" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x480", + "x481" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x482", + "x483" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x484", + "x485" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x486", + "x487" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x488", + "x489" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x490", + "x491" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x492" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x494" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x495", + "x496" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x497", + "x498" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x499", + "x500" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x501", + "x502" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x503", + "x504" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x505", + "x506" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x507", + "x508" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x509", + "x510" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x511" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x512", + "x513" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x514", + "x515" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x516", + "x517" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x518", + "x519" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x520", + "x521" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x522", + "x523" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x524", + "x525" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x526", + "x527" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x528", + "x529" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x530", + "x531" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x532", + "x533" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x520" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x534", + "x535" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x536", + "x537" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x538", + "x539" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x540", + "x541" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x542" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x541" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x543", + "x544" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x545", + "x546" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x547", + "x548" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x549", + "x550" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x551", + "x552" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x553", + "x554" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x555", + "x556" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x507" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x557", + "x558" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x540" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x559", + "x560" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x561", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x563", + "x564" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x565", + "x566" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x567", + "x568" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x569", + "x570" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x571", + "x572" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x573", + "x574" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x575", + "x576" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x577", + "x578" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x579" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x581" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x582", + "x583" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x545" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x584", + "x585" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x586", + "x587" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x577" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x588", + "x589" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x551" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x590", + "x591" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x592", + "x593" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x555" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x594", + "x595" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x596", + "x597" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x598" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x599", + "x600" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x601", + "x602" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x603", + "x604" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x605", + "x606" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x607", + "x608" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x609", + "x610" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x611", + "x612" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x613", + "x614" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x615", + "x616" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x617", + "x618" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x616" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x619", + "x620" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x610" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x621", + "x622" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x623", + "x624" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x625", + "x626" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x627", + "x628" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x629" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x600" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x630", + "x631" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x632", + "x633" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x634", + "x635" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x636", + "x637" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x638", + "x639" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x640", + "x641" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x642", + "x643" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x644", + "x645" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x646", + "x647" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x648", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x650", + "x651" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x652", + "x653" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x654", + "x655" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x656", + "x657" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x658", + "x659" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x660", + "x661" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x656" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x662", + "x663" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x664", + "x665" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x666" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x665" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x668" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "x670" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x660" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x662" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x636" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x677", + "x678" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x681", + "x682" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x683", + "x684" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x646" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x685" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x684" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x647" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x686", + "x687" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x688", + "x689" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x687" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x690", + "x691" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x689" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x692", + "x693" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x691" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x694", + "x695" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x693" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x696", + "x697" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x695" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x698", + "x699" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x700", + "x701" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x703" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x685" + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x704" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x705" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x706" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x707" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x708" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x709" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x710" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x698" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x711" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x704" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x705" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x706" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x707" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x708" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x709" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x710" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_add", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x34" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x35" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x36" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x37" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x38" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x41" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_sub", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x17" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + "0x0", + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0x5cf5d3ed" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0x5812631a" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xa2f79cd6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0x14def9de" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0x10000000" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_opp", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x17" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + "0x0", + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0x5cf5d3ed" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0x5812631a" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xa2f79cd6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0x14def9de" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0x10000000" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_from_montgomery", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x2", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "x5" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x6", + "x7" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x8", + "x9" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "x37" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x53" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "x135" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x138", + "x139" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x140", + "x141" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x142", + "x143" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "x161" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "x203" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x214", + "x215" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x217" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x218", + "x219" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x220", + "x221" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x222", + "x223" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x224", + "x225" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x226", + "x227" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x228", + "x229" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x230", + "x231" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x232", + "x233" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x234", + "x235" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x236", + "x237" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x238", + "x239" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x240", + "x241" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x242", + "x243" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x244", + "x245" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x246", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x250", + "x251" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x252", + "x253" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x254", + "x255" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x256", + "x257" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x258", + "x259" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x260", + "x261" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x262", + "x263" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x265" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x266", + "x267" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x268", + "x269" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x270", + "x271" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x272", + "x273" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x274", + "x275" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x276", + "x277" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x278", + "x279" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x280", + "x281" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x282", + "x283" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x284", + "x285" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x286", + "x287" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x288", + "x289" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x290", + "x291" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x292", + "x293" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x294", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x296", + "x297" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x298", + "x299" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x300", + "x301" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x302", + "x303" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x304", + "x305" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x306", + "x307" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x308", + "x309" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x310", + "x311" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x313" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x316", + "x317" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x318", + "x319" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x320", + "x321" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x322", + "x323" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x324", + "x325" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x326", + "x327" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x328" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x329", + "x330" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x337", + "x338" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x339", + "x340" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x341", + "x342" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x343", + "x344" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x346" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + }, + "0x0", + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x347" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x348" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x349" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x350" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x351" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x352" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x353" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x354" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x347" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x348" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x349" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x350" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x351" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x352" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x353" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_to_montgomery", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x399411b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x7c309a3d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xceec73d2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x17f5be65" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xd00e1ba7" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x68859347" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xa40611e3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x449c0f01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x399411b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x7c309a3d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xceec73d2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x17f5be65" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xd00e1ba7" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x68859347" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xa40611e3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x449c0f01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "x126" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x131", + "x132" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x138" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x149", + "x150" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x399411b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x7c309a3d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xceec73d2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x17f5be65" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xd00e1ba7" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x68859347" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xa40611e3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x167", + "x168" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x449c0f01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x181", + "x182" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x183", + "x184" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x185", + "x186" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x189", + "x190" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x191", + "x192" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x193", + "x194" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x195", + "x196" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "x204" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x205", + "x206" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x207", + "x208" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x209", + "x210" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x211", + "x212" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x213", + "x214" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x215", + "x216" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x218" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x219", + "x220" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x221", + "x222" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "x230" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x231", + "x232" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x233", + "x234" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x399411b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x235", + "x236" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x7c309a3d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x237", + "x238" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xceec73d2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x239", + "x240" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x17f5be65" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "x242" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xd00e1ba7" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x243", + "x244" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x68859347" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x245", + "x246" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xa40611e3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x247", + "x248" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x449c0f01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x249", + "x250" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x251", + "x252" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x253", + "x254" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x255", + "x256" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x257", + "x258" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x259", + "x260" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x261", + "x262" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x263", + "x264" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x265", + "x266" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x267", + "x268" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x269", + "x270" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x271", + "x272" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x273", + "x274" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x275", + "x276" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x277", + "x278" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x279", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x281", + "x282" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x283", + "x284" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x285", + "x286" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x287", + "x288" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x289", + "x290" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x291", + "x292" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x298" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x299", + "x300" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x301", + "x302" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x303", + "x304" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x305", + "x306" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x307", + "x308" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x309", + "x310" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x311", + "x312" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x313", + "x314" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x399411b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x315", + "x316" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x7c309a3d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x317", + "x318" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xceec73d2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x319", + "x320" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x17f5be65" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x321", + "x322" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xd00e1ba7" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x323", + "x324" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x68859347" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x325", + "x326" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xa40611e3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x327", + "x328" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x449c0f01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x329", + "x330" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x337", + "x338" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x339", + "x340" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x341", + "x342" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x343", + "x344" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x345", + "x346" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x347", + "x348" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x349", + "x350" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x351", + "x352" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x353", + "x354" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x355", + "x356" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x357", + "x358" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x359", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x361", + "x362" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x363", + "x364" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x365", + "x366" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x367", + "x368" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x369", + "x370" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x371", + "x372" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x373", + "x374" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x375", + "x376" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x378" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "x388" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x393", + "x394" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x399411b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x395", + "x396" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x7c309a3d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xceec73d2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x399", + "x400" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x17f5be65" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x401", + "x402" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xd00e1ba7" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x403", + "x404" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x68859347" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x405", + "x406" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xa40611e3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x407", + "x408" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x449c0f01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x409", + "x410" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x411", + "x412" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x413", + "x414" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x415", + "x416" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x417", + "x418" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x419", + "x420" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x421", + "x422" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x423", + "x424" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x425", + "x426" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x427", + "x428" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x431", + "x432" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "x444" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x445", + "x446" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x447", + "x448" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x449", + "x450" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x451", + "x452" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x453", + "x454" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x455", + "x456" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x458" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x459", + "x460" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x461", + "x462" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x463", + "x464" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x465", + "x466" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x467", + "x468" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x469", + "x470" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x471", + "x472" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x473", + "x474" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x399411b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x475", + "x476" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x7c309a3d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x477", + "x478" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xceec73d2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x479", + "x480" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x17f5be65" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x481", + "x482" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xd00e1ba7" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x483", + "x484" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x68859347" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x485", + "x486" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xa40611e3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x487", + "x488" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x449c0f01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x489", + "x490" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x491", + "x492" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x493", + "x494" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x495", + "x496" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x497", + "x498" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x499", + "x500" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x501", + "x502" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x503", + "x504" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x505", + "x506" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x507", + "x508" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x509", + "x510" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x493" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x511", + "x512" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x513", + "x514" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x515", + "x516" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x517", + "x518" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x519", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x521", + "x522" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x523", + "x524" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x525", + "x526" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x527", + "x528" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x529", + "x530" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x531", + "x532" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x533", + "x534" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x535", + "x536" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x538" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x539", + "x540" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x541", + "x542" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x540" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x507" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x543", + "x544" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x545", + "x546" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x547", + "x548" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x549", + "x550" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x551", + "x552" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x553", + "x554" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x399411b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x555", + "x556" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x7c309a3d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x557", + "x558" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xceec73d2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x559", + "x560" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x17f5be65" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x561", + "x562" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xd00e1ba7" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x563", + "x564" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x68859347" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x565", + "x566" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xa40611e3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x567", + "x568" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x449c0f01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x569", + "x570" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x571", + "x572" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x573", + "x574" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x575", + "x576" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x577", + "x578" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x579", + "x580" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x555" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x581", + "x582" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x580" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x583", + "x584" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x585", + "x586" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x541" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x587", + "x588" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x589", + "x590" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x545" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x591", + "x592" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x593", + "x594" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x577" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x595", + "x596" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x551" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x597", + "x598" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x599", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + }, + "0x12547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x601", + "x602" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x603", + "x604" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x605", + "x606" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x607", + "x608" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x609", + "x610" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x611", + "x612" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x610" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x613", + "x614" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x615", + "x616" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x618" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x619", + "x620" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x621", + "x622" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x623", + "x624" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x625", + "x626" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x616" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x627", + "x628" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x629", + "x630" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x631", + "x632" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x633" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x634", + "x635" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x636", + "x637" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x638", + "x639" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x640", + "x641" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x642", + "x643" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x644", + "x645" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x646", + "x647" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x648", + "x649" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x647" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x651" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + }, + "0x0", + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x652" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x653" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x636" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x654" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x655" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x656" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x657" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x658" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x646" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x659" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x652" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x653" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x654" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x655" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x656" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x657" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x658" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_nonzero", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_selectznz", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32[8]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_to_bytes", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0x1fffffff" + ] + } + ], + "returns": [ + { + "datatype": "u8[32]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0x1f" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u8", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[12]" + ], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[13]" + ], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[14]" + ], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[15]" + ], + "operation": "static_cast", + "arguments": [ + "x32" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[16]" + ], + "operation": "static_cast", + "arguments": [ + "x33" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[17]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[18]" + ], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[19]" + ], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[20]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[21]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[22]" + ], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[23]" + ], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[24]" + ], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[25]" + ], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[26]" + ], + "operation": "static_cast", + "arguments": [ + "x49" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[27]" + ], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[28]" + ], + "operation": "static_cast", + "arguments": [ + "x51" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[29]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[30]" + ], + "operation": "static_cast", + "arguments": [ + "x55" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[31]" + ], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_from_bytes", + "arguments": [ + { + "datatype": "u8[32]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0x1f" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0x1fffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[31]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[30]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[29]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[28]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[27]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[26]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[25]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[24]" + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[23]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[22]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[21]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + "arg1[20]" + ] + }, + { + "datatype": "u32", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[19]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[18]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[17]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + "arg1[16]" + ] + }, + { + "datatype": "u32", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[15]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[14]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[13]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + "arg1[12]" + ] + }, + { + "datatype": "u32", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u32", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_set_one", + "arguments": [], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0x8d98951d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xd6ec3174" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x737dcf70" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xc6ef5bf4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0xfffffff" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_msat", + "arguments": [], + "returns": [ + { + "datatype": "u32[9]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[8]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_divstep", + "arguments": [ + { + "datatype": "u32", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32[9]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[9]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32[9]", + "name": "out2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[9]", + "name": "out3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "out4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "out5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "31" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + "0x1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x12" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x13" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x14" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x15" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + "0x1", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x34" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x35" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x36" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x37" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x38" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x41" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x43" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x44" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x45" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x46" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x47" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[4]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x48" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[5]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x49" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[6]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x50" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x84" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x85" + ], + "operation": "static_cast", + "arguments": [ + "arg4[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x86" + ], + "operation": "static_cast", + "arguments": [ + "arg4[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x87" + ], + "operation": "static_cast", + "arguments": [ + "arg4[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x88" + ], + "operation": "static_cast", + "arguments": [ + "arg4[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x89" + ], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x90" + ], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x91" + ], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x92" + ], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x109" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + "0x0", + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0x5cf5d3ed" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0x5812631a" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0xa2f79cd6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0x14def9de" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0x10000000" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x126" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x127" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x128" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x129" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x130" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x131" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x132" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x133" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x134" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "0x1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x135" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x136" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x137" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x138" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x139" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x140" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x141" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x142" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x143" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x162" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x163" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x164" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x165" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x166" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x167" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x168" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x169" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + "0x5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + "0x5812631a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + "0xa2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + "0x14def9de" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + "0x10000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x203" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x1" + ] + }, + { + "datatype": "u32", + "name": [ + "x206" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x207" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x208" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x209" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x210" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x211" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x212" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x213" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x214" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "0x80000000" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x215" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x216" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x217" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x218" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x219" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x220" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x221" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x222" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x223" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x224" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x225" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x226" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x227" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x228" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x229" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x230" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out2[0]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[1]" + ], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[2]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[3]" + ], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[4]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[5]" + ], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[6]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[7]" + ], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[8]" + ], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[0]" + ], + "operation": "static_cast", + "arguments": [ + "x206" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[1]" + ], + "operation": "static_cast", + "arguments": [ + "x207" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[2]" + ], + "operation": "static_cast", + "arguments": [ + "x208" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[3]" + ], + "operation": "static_cast", + "arguments": [ + "x209" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[4]" + ], + "operation": "static_cast", + "arguments": [ + "x210" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[5]" + ], + "operation": "static_cast", + "arguments": [ + "x211" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[6]" + ], + "operation": "static_cast", + "arguments": [ + "x212" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[7]" + ], + "operation": "static_cast", + "arguments": [ + "x213" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[8]" + ], + "operation": "static_cast", + "arguments": [ + "x214" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[0]" + ], + "operation": "static_cast", + "arguments": [ + "x215" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[1]" + ], + "operation": "static_cast", + "arguments": [ + "x216" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[2]" + ], + "operation": "static_cast", + "arguments": [ + "x217" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[3]" + ], + "operation": "static_cast", + "arguments": [ + "x218" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[4]" + ], + "operation": "static_cast", + "arguments": [ + "x219" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[5]" + ], + "operation": "static_cast", + "arguments": [ + "x220" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[6]" + ], + "operation": "static_cast", + "arguments": [ + "x221" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[7]" + ], + "operation": "static_cast", + "arguments": [ + "x222" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[0]" + ], + "operation": "static_cast", + "arguments": [ + "x223" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[1]" + ], + "operation": "static_cast", + "arguments": [ + "x224" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[2]" + ], + "operation": "static_cast", + "arguments": [ + "x225" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[3]" + ], + "operation": "static_cast", + "arguments": [ + "x226" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[4]" + ], + "operation": "static_cast", + "arguments": [ + "x227" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[5]" + ], + "operation": "static_cast", + "arguments": [ + "x228" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[6]" + ], + "operation": "static_cast", + "arguments": [ + "x229" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[7]" + ], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_divstep_precomp", + "arguments": [], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0x36a7cb92" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xd70af844" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xb0b8b159" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x5f71c978" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x74947f1a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0xe76d8169" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0xf193e4ff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0x19a2d36" + ] + } + ] + } +] diff --git a/fiat-json/src/curve25519_scalar_64.json b/fiat-json/src/curve25519_scalar_64.json new file mode 100644 index 0000000000..c1edf1ab31 --- /dev/null +++ b/fiat-json/src/curve25519_scalar_64.json @@ -0,0 +1,26554 @@ +[ + { + "operation": "fiat_25519_scalar_addcarryx_u64", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "u128", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_subborrowx_u64", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "i128", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "i1", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_mulx_u64", + "arguments": [ + { + "datatype": "u64", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "out2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "body": [ + { + "datatype": "u128", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "*", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_cmovznz_u64", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "body": [ + { + "datatype": "u1", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_mul", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x76" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x78" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x87" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x102" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x123" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x134" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x149" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x170" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x181" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x191" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x192" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x193" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x194" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x195" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x192" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x193" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_square", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x76" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x78" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x87" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x102" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x123" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x134" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x149" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x170" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x181" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x191" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x192" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x193" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x194" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x195" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x192" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x193" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_add", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x18" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x20" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x21" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_sub", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0", + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0x5812631a5cf5d3ed" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0x14def9dea2f79cd6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0x1000000000000000" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_opp", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0", + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0x5812631a5cf5d3ed" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0x14def9dea2f79cd6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0x1000000000000000" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_from_montgomery", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x2", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "x5" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x6", + "x7" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x8", + "x9" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x13" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "x37" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x53" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x77" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x84" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x94" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + "0x0", + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x95" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x96" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x97" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x98" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x95" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x96" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x97" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_to_montgomery", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x399411b7c309a3d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xceec73d217f5be65" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xd00e1ba768859347" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xa40611e3449c0f01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x399411b7c309a3d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xceec73d217f5be65" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xd00e1ba768859347" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xa40611e3449c0f01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x70" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x399411b7c309a3d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xceec73d217f5be65" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xd00e1ba768859347" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xa40611e3449c0f01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x399411b7c309a3d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xceec73d217f5be65" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xd00e1ba768859347" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xa40611e3449c0f01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "x126" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x131", + "x132" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + "0xd2b51da312547e1b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x150" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x157" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "x161" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x167" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + "0x0", + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x168" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x169" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x170" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x171" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x168" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x169" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x170" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_nonzero", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_selectznz", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64[4]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_to_bytes", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0x1fffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u8[32]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0x1f" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u8", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x57" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x58" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x59" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x60" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[12]" + ], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[13]" + ], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[14]" + ], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[15]" + ], + "operation": "static_cast", + "arguments": [ + "x32" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[16]" + ], + "operation": "static_cast", + "arguments": [ + "x33" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[17]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[18]" + ], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[19]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[20]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[21]" + ], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[22]" + ], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[23]" + ], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[24]" + ], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[25]" + ], + "operation": "static_cast", + "arguments": [ + "x49" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[26]" + ], + "operation": "static_cast", + "arguments": [ + "x51" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[27]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[28]" + ], + "operation": "static_cast", + "arguments": [ + "x55" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[29]" + ], + "operation": "static_cast", + "arguments": [ + "x57" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[30]" + ], + "operation": "static_cast", + "arguments": [ + "x59" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[31]" + ], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_from_bytes", + "arguments": [ + { + "datatype": "u8[32]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0x1f" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0x1fffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[31]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[30]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[29]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[28]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[27]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[26]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[25]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[24]" + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[23]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[22]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[21]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[20]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[19]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[18]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[17]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + "arg1[16]" + ] + }, + { + "datatype": "u64", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[15]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[14]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[13]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[12]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u64", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x57" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x58" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x59" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x60" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_set_one", + "arguments": [], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xd6ec31748d98951d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xc6ef5bf4737dcf70" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xfffffffffffffff" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_msat", + "arguments": [], + "returns": [ + { + "datatype": "u64[5]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_divstep", + "arguments": [ + { + "datatype": "u64", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64[5]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[5]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64[5]", + "name": "out2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[5]", + "name": "out3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "out4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "out5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "63" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + "0x1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x7" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x8" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x10" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x11" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + "0x1", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x23" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x24" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x25" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x26" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x27" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x29" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x48" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x61" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0x0", + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + "0x5812631a5cf5d3ed" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + "0x14def9dea2f79cd6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + "0x1000000000000000" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x70" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x71" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x72" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x73" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x74" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "0x1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x75" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x76" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x77" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x78" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x79" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x90" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x91" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x92" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x93" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + "0x5812631a5cf5d3ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + "0x14def9dea2f79cd6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0x1000000000000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x111" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x1" + ] + }, + { + "datatype": "u64", + "name": [ + "x114" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x115" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x116" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x117" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x118" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + "0x8000000000000000" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + "1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x119" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x120" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x121" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x122" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x123" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x124" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x125" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x126" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out2[0]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[1]" + ], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[2]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[3]" + ], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[4]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[0]" + ], + "operation": "static_cast", + "arguments": [ + "x114" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[1]" + ], + "operation": "static_cast", + "arguments": [ + "x115" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[2]" + ], + "operation": "static_cast", + "arguments": [ + "x116" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[3]" + ], + "operation": "static_cast", + "arguments": [ + "x117" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[4]" + ], + "operation": "static_cast", + "arguments": [ + "x118" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[0]" + ], + "operation": "static_cast", + "arguments": [ + "x119" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[1]" + ], + "operation": "static_cast", + "arguments": [ + "x120" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[2]" + ], + "operation": "static_cast", + "arguments": [ + "x121" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[3]" + ], + "operation": "static_cast", + "arguments": [ + "x122" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[0]" + ], + "operation": "static_cast", + "arguments": [ + "x123" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[1]" + ], + "operation": "static_cast", + "arguments": [ + "x124" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[2]" + ], + "operation": "static_cast", + "arguments": [ + "x125" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[3]" + ], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "operation": "fiat_25519_scalar_divstep_precomp", + "arguments": [], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xd70af84436a7cb92" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x5f71c978b0b8b159" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xe76d816974947f1a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x19a2d36f193e4ff" + ] + } + ] + } +] diff --git a/fiat-json/src/p256_scalar_32.json b/fiat-json/src/p256_scalar_32.json new file mode 100644 index 0000000000..990f50c7cd --- /dev/null +++ b/fiat-json/src/p256_scalar_32.json @@ -0,0 +1,82238 @@ +[ + { + "operation": "fiat_p256_scalar_addcarryx_u32", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_subborrowx_u32", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "i64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "i1", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_mulx_u32", + "arguments": [ + { + "datatype": "u32", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "out2", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "*", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_cmovznz_u32", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "body": [ + { + "datatype": "u1", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_mul", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "x53" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x66" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x68" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x115" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x138", + "x139" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x140", + "x141" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x142", + "x143" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x160" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x167", + "x168" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x179" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "x203" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x210" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x211", + "x212" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x213", + "x214" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x215", + "x216" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x217", + "x218" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x219", + "x220" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x221", + "x222" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x231", + "x232" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x233", + "x234" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x235", + "x236" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x237", + "x238" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x239", + "x240" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "x242" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x243", + "x244" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x245", + "x246" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x247", + "x248" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x249", + "x250" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x251", + "x252" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x253", + "x254" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x255" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x257" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x258", + "x259" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x260", + "x261" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x262", + "x263" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x264", + "x265" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x266", + "x267" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x268", + "x269" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x270", + "x271" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x272", + "x273" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x274" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x275", + "x276" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x277", + "x278" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x279", + "x280" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x281", + "x282" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x283", + "x284" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x285", + "x286" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x287", + "x288" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x289", + "x290" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x291", + "x292" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x297", + "x298" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x299", + "x300" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x301", + "x302" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x303", + "x304" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x305" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x306", + "x307" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x308", + "x309" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x310", + "x311" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x312", + "x313" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x316", + "x317" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x318", + "x319" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x320", + "x321" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x322", + "x323" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x324", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x326", + "x327" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x328", + "x329" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x330", + "x331" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x332", + "x333" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x334", + "x335" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x336", + "x337" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x338", + "x339" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x340", + "x341" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x342", + "x343" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x344", + "x345" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x346", + "x347" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x348", + "x349" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x350" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x352" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x353", + "x354" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x355", + "x356" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x357", + "x358" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x359", + "x360" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x361", + "x362" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x363", + "x364" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x365", + "x366" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x367", + "x368" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x369" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x370", + "x371" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x372", + "x373" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x374", + "x375" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x376", + "x377" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x378", + "x379" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x380", + "x381" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x382", + "x383" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x384", + "x385" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x386", + "x387" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x388", + "x389" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x390", + "x391" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x392", + "x393" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x394", + "x395" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x396", + "x397" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x398", + "x399" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x400" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x401", + "x402" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x403", + "x404" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x405", + "x406" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x407", + "x408" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x409", + "x410" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x411", + "x412" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x413", + "x414" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x415", + "x416" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x417", + "x418" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x419", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x421", + "x422" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x423", + "x424" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x425", + "x426" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x427", + "x428" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x431", + "x432" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "x440" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "x444" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x445" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x447" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x448", + "x449" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x450", + "x451" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x452", + "x453" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x454", + "x455" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x456", + "x457" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x458", + "x459" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x460", + "x461" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x462", + "x463" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x464" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x465", + "x466" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x467", + "x468" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x469", + "x470" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x471", + "x472" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x473", + "x474" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x475", + "x476" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x477", + "x478" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x479", + "x480" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x481", + "x482" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x483", + "x484" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x485", + "x486" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x487", + "x488" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x489", + "x490" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x491", + "x492" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x493", + "x494" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x495" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x496", + "x497" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x498", + "x499" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x500", + "x501" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x502", + "x503" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x504", + "x505" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x506", + "x507" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x508", + "x509" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x507" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x510", + "x511" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x493" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x512", + "x513" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x514", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x516", + "x517" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x518", + "x519" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x520", + "x521" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x522", + "x523" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x524", + "x525" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x526", + "x527" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x528", + "x529" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x530", + "x531" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x532", + "x533" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x534", + "x535" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x536", + "x537" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x520" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x538", + "x539" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x540" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x542" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x543", + "x544" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x545", + "x546" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x547", + "x548" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x549", + "x550" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x551", + "x552" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x553", + "x554" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x540" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x555", + "x556" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x557", + "x558" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x559" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x560", + "x561" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x562", + "x563" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x564", + "x565" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x566", + "x567" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x568", + "x569" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x570", + "x571" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x572", + "x573" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x574", + "x575" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x576", + "x577" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x578", + "x579" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x577" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x580", + "x581" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x582", + "x583" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x584", + "x585" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x586", + "x587" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x588", + "x589" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x590" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x591", + "x592" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x593", + "x594" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x545" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x595", + "x596" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x597", + "x598" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x580" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x599", + "x600" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x551" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x601", + "x602" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x600" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x603", + "x604" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x555" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x605", + "x606" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x607", + "x608" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x609", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x611", + "x612" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x613", + "x614" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x615", + "x616" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x617", + "x618" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x619", + "x620" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x621", + "x622" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x623", + "x624" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x625", + "x626" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x627", + "x628" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x629", + "x630" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x631", + "x632" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x633", + "x634" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x616" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x635" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x637" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x638", + "x639" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x640", + "x641" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x642", + "x643" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x644", + "x645" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x646", + "x647" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x648", + "x649" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x647" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x650", + "x651" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x652", + "x653" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x654" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x655", + "x656" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x657", + "x658" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x659", + "x660" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x661", + "x662" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x663", + "x664" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x665", + "x666" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x667", + "x668" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "x670" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x667" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x665" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x677", + "x678" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x662" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x681", + "x682" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x660" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x683", + "x684" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x685" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x656" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x686", + "x687" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x688", + "x689" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x687" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x690", + "x691" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x689" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x692", + "x693" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x691" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x694", + "x695" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x693" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x646" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x696", + "x697" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x695" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x698", + "x699" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x700", + "x701" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x702", + "x703" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x685" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x704", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x706", + "x707" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x708", + "x709" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x710", + "x711" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x712", + "x713" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x714", + "x715" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x716", + "x717" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x718", + "x719" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x720", + "x721" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x719" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x716" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x722", + "x723" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x721" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x717" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x714" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x724", + "x725" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x723" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x715" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x712" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x726", + "x727" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x713" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x710" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x728", + "x729" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x727" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x708" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x730" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x729" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x732" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x718" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x733", + "x734" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x732" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x720" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x735", + "x736" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x734" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x722" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x737", + "x738" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x736" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x724" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x739", + "x740" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x738" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x726" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x741", + "x742" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x740" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x743", + "x744" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x698" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x745", + "x746" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x744" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x706" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x747", + "x748" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x702" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x707" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x749" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x748" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x750", + "x751" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x752", + "x753" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x751" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x754", + "x755" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x753" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x756", + "x757" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x755" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x758", + "x759" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x757" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x741" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x760", + "x761" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x759" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x743" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x762", + "x763" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x761" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x745" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x764", + "x765" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x763" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x747" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x767" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x765" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x749" + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x768" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x750" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x769" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x752" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x770" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x754" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x771" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x756" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x772" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x758" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x741" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x773" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x760" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x743" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x774" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x762" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x745" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x775" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x764" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x747" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x768" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x769" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x770" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x771" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x772" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x773" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x774" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x775" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_square", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "x53" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x66" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x68" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x115" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x138", + "x139" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x140", + "x141" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x142", + "x143" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x160" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x167", + "x168" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x179" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "x203" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x210" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x211", + "x212" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x213", + "x214" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x215", + "x216" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x217", + "x218" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x219", + "x220" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x221", + "x222" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x231", + "x232" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x233", + "x234" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x235", + "x236" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x237", + "x238" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x239", + "x240" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "x242" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x243", + "x244" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x245", + "x246" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x247", + "x248" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x249", + "x250" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x251", + "x252" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x253", + "x254" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x255" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x257" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x258", + "x259" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x260", + "x261" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x262", + "x263" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x264", + "x265" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x266", + "x267" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x268", + "x269" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x270", + "x271" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x272", + "x273" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x274" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x275", + "x276" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x277", + "x278" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x279", + "x280" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x281", + "x282" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x283", + "x284" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x285", + "x286" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x287", + "x288" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x289", + "x290" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x291", + "x292" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x297", + "x298" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x299", + "x300" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x301", + "x302" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x303", + "x304" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x305" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x306", + "x307" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x308", + "x309" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x310", + "x311" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x312", + "x313" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x316", + "x317" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x318", + "x319" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x320", + "x321" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x322", + "x323" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x324", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x326", + "x327" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x328", + "x329" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x330", + "x331" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x332", + "x333" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x334", + "x335" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x336", + "x337" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x338", + "x339" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x340", + "x341" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x342", + "x343" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x344", + "x345" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x346", + "x347" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x348", + "x349" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x350" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x352" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x353", + "x354" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x355", + "x356" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x357", + "x358" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x359", + "x360" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x361", + "x362" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x363", + "x364" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x365", + "x366" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x367", + "x368" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x369" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x370", + "x371" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x372", + "x373" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x374", + "x375" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x376", + "x377" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x378", + "x379" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x380", + "x381" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x382", + "x383" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x384", + "x385" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x386", + "x387" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x388", + "x389" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x390", + "x391" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x392", + "x393" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x394", + "x395" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x396", + "x397" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x398", + "x399" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x400" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x401", + "x402" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x403", + "x404" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x405", + "x406" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x407", + "x408" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x409", + "x410" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x411", + "x412" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x413", + "x414" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x415", + "x416" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x417", + "x418" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x419", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x421", + "x422" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x423", + "x424" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x425", + "x426" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x427", + "x428" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x431", + "x432" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "x440" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "x444" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x445" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x447" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x448", + "x449" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x450", + "x451" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x452", + "x453" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x454", + "x455" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x456", + "x457" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x458", + "x459" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x460", + "x461" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x462", + "x463" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x464" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x465", + "x466" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x467", + "x468" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x469", + "x470" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x471", + "x472" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x473", + "x474" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x475", + "x476" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x477", + "x478" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x479", + "x480" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x481", + "x482" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x483", + "x484" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x485", + "x486" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x487", + "x488" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x489", + "x490" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x491", + "x492" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x493", + "x494" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x495" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x496", + "x497" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x498", + "x499" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x500", + "x501" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x502", + "x503" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x504", + "x505" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x506", + "x507" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x508", + "x509" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x507" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x510", + "x511" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x493" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x512", + "x513" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x514", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x516", + "x517" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x518", + "x519" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x520", + "x521" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x522", + "x523" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x524", + "x525" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x526", + "x527" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x528", + "x529" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x530", + "x531" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x532", + "x533" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x534", + "x535" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x536", + "x537" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x520" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x538", + "x539" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x540" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x542" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x543", + "x544" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x545", + "x546" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x547", + "x548" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x549", + "x550" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x551", + "x552" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x553", + "x554" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x540" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x555", + "x556" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x557", + "x558" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x559" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x560", + "x561" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x562", + "x563" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x564", + "x565" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x566", + "x567" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x568", + "x569" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x570", + "x571" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x572", + "x573" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x574", + "x575" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x576", + "x577" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x578", + "x579" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x577" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x580", + "x581" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x582", + "x583" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x584", + "x585" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x586", + "x587" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x588", + "x589" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x590" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x591", + "x592" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x593", + "x594" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x545" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x595", + "x596" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x597", + "x598" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x580" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x599", + "x600" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x551" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x601", + "x602" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x600" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x603", + "x604" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x555" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x605", + "x606" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x607", + "x608" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x609", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x611", + "x612" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x613", + "x614" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x615", + "x616" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x617", + "x618" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x619", + "x620" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x621", + "x622" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x623", + "x624" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x625", + "x626" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x627", + "x628" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x629", + "x630" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x631", + "x632" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x633", + "x634" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x616" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x635" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x637" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x638", + "x639" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x640", + "x641" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x642", + "x643" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x644", + "x645" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x646", + "x647" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x648", + "x649" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x647" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x650", + "x651" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x652", + "x653" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x654" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x655", + "x656" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x657", + "x658" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x659", + "x660" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x661", + "x662" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x663", + "x664" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x665", + "x666" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x667", + "x668" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "x670" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x667" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x665" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x677", + "x678" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x662" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x681", + "x682" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x660" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x683", + "x684" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x685" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x656" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x686", + "x687" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x688", + "x689" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x687" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x690", + "x691" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x689" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x692", + "x693" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x691" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x694", + "x695" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x693" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x646" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x696", + "x697" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x695" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x698", + "x699" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x700", + "x701" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x702", + "x703" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x685" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x704", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x706", + "x707" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x708", + "x709" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x710", + "x711" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x712", + "x713" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x714", + "x715" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x716", + "x717" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x718", + "x719" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x720", + "x721" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x719" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x716" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x722", + "x723" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x721" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x717" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x714" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x724", + "x725" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x723" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x715" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x712" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x726", + "x727" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x713" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x710" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x728", + "x729" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x727" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x708" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x730" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x729" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x732" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x718" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x733", + "x734" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x732" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x720" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x735", + "x736" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x734" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x722" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x737", + "x738" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x736" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x724" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x739", + "x740" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x738" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x726" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x741", + "x742" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x740" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x743", + "x744" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x698" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x745", + "x746" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x744" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x706" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x747", + "x748" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x702" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x707" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x749" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x748" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x750", + "x751" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x752", + "x753" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x751" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x754", + "x755" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x753" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x756", + "x757" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x755" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x758", + "x759" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x757" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x741" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x760", + "x761" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x759" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x743" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x762", + "x763" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x761" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x745" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x764", + "x765" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x763" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x747" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x767" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x765" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x749" + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x768" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x750" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x769" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x752" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x770" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x754" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x771" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x756" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x772" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x758" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x741" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x773" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x760" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x743" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x774" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x762" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x745" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x775" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x764" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x747" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x768" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x769" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x770" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x771" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x772" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x773" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x774" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x775" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_add", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x34" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x35" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x36" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x37" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x38" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x41" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_sub", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x17" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + "0x0", + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xfc632551" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xf3b9cac2" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xa7179e84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xbce6faad" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_opp", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x17" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + "0x0", + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xfc632551" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xf3b9cac2" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xa7179e84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xbce6faad" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_from_montgomery", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x2", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "x5" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x6", + "x7" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x8", + "x9" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "x37" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "x53" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "x135" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x138", + "x139" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x140", + "x141" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x142", + "x143" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x147" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "x161" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "x203" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x207" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x214", + "x215" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x218", + "x219" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x220", + "x221" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x222", + "x223" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x224", + "x225" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x226", + "x227" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x228", + "x229" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x230", + "x231" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x232", + "x233" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x234", + "x235" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x236", + "x237" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x238", + "x239" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x240", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x242", + "x243" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x244", + "x245" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x246", + "x247" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x250", + "x251" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x252", + "x253" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x254", + "x255" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x256", + "x257" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x258", + "x259" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x260", + "x261" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x262", + "x263" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x264", + "x265" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x267" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x268", + "x269" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x270", + "x271" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x272", + "x273" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x274", + "x275" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x276", + "x277" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x278", + "x279" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x280", + "x281" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x282", + "x283" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x284", + "x285" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x286", + "x287" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x288", + "x289" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x290", + "x291" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x292", + "x293" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x294", + "x295" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x296", + "x297" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x298", + "x299" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x300", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x302", + "x303" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x304", + "x305" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x306", + "x307" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x308", + "x309" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x310", + "x311" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x312", + "x313" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x316", + "x317" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x318", + "x319" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x320", + "x321" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x322", + "x323" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x324", + "x325" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x327" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x328", + "x329" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x330", + "x331" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x332", + "x333" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x334", + "x335" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x336", + "x337" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x338", + "x339" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x340", + "x341" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x342", + "x343" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x344", + "x345" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x346", + "x347" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x348", + "x349" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x350", + "x351" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x352", + "x353" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x354", + "x355" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x356", + "x357" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x358", + "x359" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x360", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x362", + "x363" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x364", + "x365" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x366", + "x367" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x368", + "x369" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x370", + "x371" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x372", + "x373" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x374", + "x375" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x376", + "x377" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x378", + "x379" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x380", + "x381" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x382", + "x383" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x384", + "x385" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x387" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x388", + "x389" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x390", + "x391" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x392", + "x393" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x394", + "x395" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x396", + "x397" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x398", + "x399" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x400", + "x401" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x402", + "x403" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x404", + "x405" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x406", + "x407" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x408", + "x409" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x410", + "x411" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x412", + "x413" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x414", + "x415" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x416", + "x417" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x418", + "x419" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x420", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x422", + "x423" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x424", + "x425" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x426", + "x427" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x428", + "x429" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x430", + "x431" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x432", + "x433" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x434", + "x435" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x436", + "x437" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x438", + "x439" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x440", + "x441" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x442", + "x443" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x444", + "x445" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x447" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x448", + "x449" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x450", + "x451" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x452", + "x453" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x454", + "x455" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x456", + "x457" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x458", + "x459" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x460", + "x461" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x462", + "x463" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x464", + "x465" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x466", + "x467" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x468", + "x469" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x470", + "x471" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x472", + "x473" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x474", + "x475" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x476", + "x477" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x478", + "x479" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x481" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x482" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x483" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x484" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x485" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x486" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x487" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x488" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x489" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x482" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x483" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x484" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x485" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x486" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x487" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x488" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_to_montgomery", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x66e12d94" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xf3d95620" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x2845b239" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x2b6bec59" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x4699799c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x49bd6fa6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x83244c95" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xbe79eea2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x66e12d94" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xf3d95620" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x2845b239" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x2b6bec59" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x4699799c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x49bd6fa6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x83244c95" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xbe79eea2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "x126" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x131", + "x132" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x149", + "x150" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x156" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x167", + "x168" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x66e12d94" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xf3d95620" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x2845b239" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x2b6bec59" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x181", + "x182" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x4699799c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x183", + "x184" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x49bd6fa6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x185", + "x186" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x83244c95" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xbe79eea2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x189", + "x190" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x191", + "x192" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x193", + "x194" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x195", + "x196" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "x204" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x205", + "x206" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x207", + "x208" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x209", + "x210" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x211", + "x212" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x213", + "x214" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x215", + "x216" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x217", + "x218" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x219", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x221", + "x222" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "x230" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x231", + "x232" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x233", + "x234" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x235", + "x236" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x237", + "x238" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x239", + "x240" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "x242" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x243", + "x244" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x246" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x247", + "x248" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x249", + "x250" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x251", + "x252" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x253", + "x254" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x255", + "x256" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x257", + "x258" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x259", + "x260" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x261", + "x262" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x263", + "x264" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x66e12d94" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x265", + "x266" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xf3d95620" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x267", + "x268" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x2845b239" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x269", + "x270" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x2b6bec59" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x271", + "x272" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x4699799c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x273", + "x274" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x49bd6fa6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x275", + "x276" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x83244c95" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x277", + "x278" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xbe79eea2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x279", + "x280" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x281", + "x282" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x283", + "x284" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x285", + "x286" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x287", + "x288" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x289", + "x290" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x291", + "x292" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x297", + "x298" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x299", + "x300" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x301", + "x302" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x303", + "x304" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x305", + "x306" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x307", + "x308" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x309", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x311", + "x312" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x313", + "x314" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x315", + "x316" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x317", + "x318" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x319", + "x320" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x321", + "x322" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x323", + "x324" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x325", + "x326" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x327", + "x328" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x329", + "x330" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x336" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x337", + "x338" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x339", + "x340" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x341", + "x342" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x343", + "x344" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x345", + "x346" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x347", + "x348" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x349", + "x350" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x351", + "x352" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x353", + "x354" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x66e12d94" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x355", + "x356" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xf3d95620" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x357", + "x358" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x2845b239" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x359", + "x360" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x2b6bec59" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x361", + "x362" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x4699799c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x363", + "x364" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x49bd6fa6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x365", + "x366" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x83244c95" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x367", + "x368" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xbe79eea2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x369", + "x370" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x371", + "x372" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x373", + "x374" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x375", + "x376" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x377", + "x378" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "x388" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x393", + "x394" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x395", + "x396" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x399", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x401", + "x402" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x403", + "x404" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x405", + "x406" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x407", + "x408" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x409", + "x410" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x411", + "x412" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x413", + "x414" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x415", + "x416" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x417", + "x418" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x419", + "x420" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x421", + "x422" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x423", + "x424" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x426" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x427", + "x428" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x431", + "x432" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "x440" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "x444" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x66e12d94" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x445", + "x446" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xf3d95620" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x447", + "x448" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x2845b239" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x449", + "x450" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x2b6bec59" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x451", + "x452" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x4699799c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x453", + "x454" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x49bd6fa6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x455", + "x456" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x83244c95" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x457", + "x458" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xbe79eea2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x459", + "x460" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x461", + "x462" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x463", + "x464" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x465", + "x466" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x467", + "x468" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x469", + "x470" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x471", + "x472" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x473", + "x474" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x475", + "x476" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x477", + "x478" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x479", + "x480" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x481", + "x482" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x483", + "x484" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x485", + "x486" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x487", + "x488" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x489", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x491", + "x492" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x493", + "x494" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x495", + "x496" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x497", + "x498" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x499", + "x500" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x501", + "x502" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x503", + "x504" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x505", + "x506" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x507", + "x508" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x509", + "x510" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x511", + "x512" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x513", + "x514" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x493" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x516" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x517", + "x518" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x519", + "x520" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x507" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x521", + "x522" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x520" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x523", + "x524" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x525", + "x526" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x527", + "x528" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x529", + "x530" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x531", + "x532" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x533", + "x534" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x66e12d94" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x535", + "x536" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xf3d95620" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x537", + "x538" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x2845b239" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x539", + "x540" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x2b6bec59" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x541", + "x542" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x4699799c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x543", + "x544" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x49bd6fa6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x545", + "x546" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x83244c95" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x547", + "x548" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xbe79eea2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x549", + "x550" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x545" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x551", + "x552" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x553", + "x554" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x541" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x555", + "x556" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x557", + "x558" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x540" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x559", + "x560" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x561", + "x562" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x563", + "x564" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x565", + "x566" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x567", + "x568" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x551" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x569", + "x570" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x571", + "x572" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x555" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x573", + "x574" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x575", + "x576" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x577", + "x578" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x579", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x581", + "x582" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x583", + "x584" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x585", + "x586" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x587", + "x588" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x589", + "x590" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x591", + "x592" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x593", + "x594" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x595", + "x596" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x597", + "x598" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x599", + "x600" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x601", + "x602" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x600" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x603", + "x604" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x606" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x607", + "x608" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x609", + "x610" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x611", + "x612" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x610" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x613", + "x614" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x615", + "x616" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x617", + "x618" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x616" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x619", + "x620" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x577" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x621", + "x622" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x623", + "x624" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x66e12d94" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x625", + "x626" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xf3d95620" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x627", + "x628" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x2845b239" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x629", + "x630" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x2b6bec59" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x631", + "x632" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x4699799c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x633", + "x634" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x49bd6fa6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x635", + "x636" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x83244c95" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x637", + "x638" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xbe79eea2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x639", + "x640" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x641", + "x642" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x636" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x643", + "x644" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x645", + "x646" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x647", + "x648" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x646" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x649", + "x650" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x651", + "x652" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x653", + "x654" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x655", + "x656" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x657", + "x658" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x656" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x659", + "x660" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x661", + "x662" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x660" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x663", + "x664" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x662" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x647" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x665", + "x666" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x667", + "x668" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + }, + "0xee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x677", + "x678" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x681", + "x682" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x683", + "x684" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x685", + "x686" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x687", + "x688" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x689", + "x690" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x691", + "x692" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x693", + "x694" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x696" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x697", + "x698" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x685" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x699", + "x700" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x698" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x687" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x701", + "x702" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x689" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x703", + "x704" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x702" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x691" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x705", + "x706" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x693" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x707", + "x708" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x706" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x665" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x709", + "x710" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x708" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x667" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x711", + "x712" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x710" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x713", + "x714" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x715", + "x716" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x714" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x717", + "x718" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x716" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x719", + "x720" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x718" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x721", + "x722" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x720" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x705" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x723", + "x724" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x722" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x707" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x725", + "x726" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x724" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x727", + "x728" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x726" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x730" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x712" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x731" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x713" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x732" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x715" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x733" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x717" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x734" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x719" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x735" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x721" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x705" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x736" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x723" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x707" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x737" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x738" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x727" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x731" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x732" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x733" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x734" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x735" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x736" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x737" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x738" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_nonzero", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_selectznz", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32[8]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_to_bytes", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u8[32]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u8", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[12]" + ], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[13]" + ], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[14]" + ], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[15]" + ], + "operation": "static_cast", + "arguments": [ + "x32" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[16]" + ], + "operation": "static_cast", + "arguments": [ + "x33" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[17]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[18]" + ], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[19]" + ], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[20]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[21]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[22]" + ], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[23]" + ], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[24]" + ], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[25]" + ], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[26]" + ], + "operation": "static_cast", + "arguments": [ + "x49" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[27]" + ], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[28]" + ], + "operation": "static_cast", + "arguments": [ + "x51" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[29]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[30]" + ], + "operation": "static_cast", + "arguments": [ + "x55" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[31]" + ], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_from_bytes", + "arguments": [ + { + "datatype": "u8[32]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[31]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[30]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[29]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[28]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[27]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[26]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[25]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[24]" + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[23]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[22]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[21]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + "arg1[20]" + ] + }, + { + "datatype": "u32", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[19]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[18]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[17]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + "arg1[16]" + ] + }, + { + "datatype": "u32", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[15]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[14]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[13]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + "arg1[12]" + ] + }, + { + "datatype": "u32", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u32", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_set_one", + "arguments": [], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0x39cdaaf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xc46353d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x58e8617b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x43190552" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_msat", + "arguments": [], + "returns": [ + { + "datatype": "u32[9]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[8]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_divstep", + "arguments": [ + { + "datatype": "u32", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32[9]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[9]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32[9]", + "name": "out2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[9]", + "name": "out3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "out4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "out5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "31" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + "0x1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x12" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x13" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x14" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x15" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + "0x1", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x34" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x35" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x36" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x37" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x38" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x41" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x43" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x44" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x45" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x46" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x47" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[4]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x48" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[5]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x49" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[6]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x50" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x84" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x85" + ], + "operation": "static_cast", + "arguments": [ + "arg4[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x86" + ], + "operation": "static_cast", + "arguments": [ + "arg4[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x87" + ], + "operation": "static_cast", + "arguments": [ + "arg4[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x88" + ], + "operation": "static_cast", + "arguments": [ + "arg4[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x89" + ], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x90" + ], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x91" + ], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x92" + ], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x109" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + "0x0", + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0xfc632551" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0xf3b9cac2" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0xa7179e84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0xbce6faad" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x126" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x127" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x128" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x129" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x130" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x131" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x132" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x133" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x134" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "0x1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x135" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x136" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x137" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x138" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x139" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x140" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x141" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x142" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x143" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x162" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x163" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x164" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x165" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x166" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x167" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x168" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x169" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + "0xfc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + "0xf3b9cac2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + "0xa7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + "0xbce6faad" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x203" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x1" + ] + }, + { + "datatype": "u32", + "name": [ + "x206" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x207" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x208" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x209" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x210" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x211" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x212" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x213" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x214" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "0x80000000" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x215" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x216" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x217" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x218" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x219" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x220" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x221" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x222" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x223" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x224" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x225" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x226" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x227" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x228" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x229" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x230" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out2[0]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[1]" + ], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[2]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[3]" + ], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[4]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[5]" + ], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[6]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[7]" + ], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[8]" + ], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[0]" + ], + "operation": "static_cast", + "arguments": [ + "x206" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[1]" + ], + "operation": "static_cast", + "arguments": [ + "x207" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[2]" + ], + "operation": "static_cast", + "arguments": [ + "x208" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[3]" + ], + "operation": "static_cast", + "arguments": [ + "x209" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[4]" + ], + "operation": "static_cast", + "arguments": [ + "x210" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[5]" + ], + "operation": "static_cast", + "arguments": [ + "x211" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[6]" + ], + "operation": "static_cast", + "arguments": [ + "x212" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[7]" + ], + "operation": "static_cast", + "arguments": [ + "x213" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[8]" + ], + "operation": "static_cast", + "arguments": [ + "x214" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[0]" + ], + "operation": "static_cast", + "arguments": [ + "x215" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[1]" + ], + "operation": "static_cast", + "arguments": [ + "x216" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[2]" + ], + "operation": "static_cast", + "arguments": [ + "x217" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[3]" + ], + "operation": "static_cast", + "arguments": [ + "x218" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[4]" + ], + "operation": "static_cast", + "arguments": [ + "x219" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[5]" + ], + "operation": "static_cast", + "arguments": [ + "x220" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[6]" + ], + "operation": "static_cast", + "arguments": [ + "x221" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[7]" + ], + "operation": "static_cast", + "arguments": [ + "x222" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[0]" + ], + "operation": "static_cast", + "arguments": [ + "x223" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[1]" + ], + "operation": "static_cast", + "arguments": [ + "x224" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[2]" + ], + "operation": "static_cast", + "arguments": [ + "x225" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[3]" + ], + "operation": "static_cast", + "arguments": [ + "x226" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[4]" + ], + "operation": "static_cast", + "arguments": [ + "x227" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[5]" + ], + "operation": "static_cast", + "arguments": [ + "x228" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[6]" + ], + "operation": "static_cast", + "arguments": [ + "x229" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[7]" + ], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_divstep_precomp", + "arguments": [], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xb7fcfbb5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xd739262f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x20074414" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x8ac6f75d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0xb5e3c256" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0xc67428bf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0xeda7aedf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0x444962f2" + ] + } + ] + } +] diff --git a/fiat-json/src/p256_scalar_64.json b/fiat-json/src/p256_scalar_64.json new file mode 100644 index 0000000000..e4f40b1e6b --- /dev/null +++ b/fiat-json/src/p256_scalar_64.json @@ -0,0 +1,29169 @@ +[ + { + "operation": "fiat_p256_scalar_addcarryx_u64", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "u128", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_subborrowx_u64", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "i128", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "i1", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_mulx_u64", + "arguments": [ + { + "datatype": "u64", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "out2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "body": [ + { + "datatype": "u128", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "*", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_cmovznz_u64", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "body": [ + { + "datatype": "u1", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_mul", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x61" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x88" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x99" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x114" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x131", + "x132" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x141" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x143" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x152" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x167" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x194" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x196" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "x204" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x205" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x215" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x216" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x217" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x218" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x219" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x216" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x217" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x218" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_square", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x61" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x88" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x99" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x114" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x131", + "x132" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x141" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x143" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x152" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x167" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x194" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x196" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "x204" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x205" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x215" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x216" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x217" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x218" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x219" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x216" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x217" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x218" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_add", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x18" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x20" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x21" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_sub", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0", + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xf3b9cac2fc632551" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xbce6faada7179e84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xffffffff00000000" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_opp", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0", + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xf3b9cac2fc632551" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xbce6faada7179e84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xffffffff00000000" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_from_montgomery", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x2", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "x5" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x6", + "x7" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x8", + "x9" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "x37" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x49" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "x53" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x79" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x109" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x116" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x126" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + "0x0", + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x127" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x128" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x129" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x130" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x127" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x128" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x129" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_to_montgomery", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x66e12d94f3d95620" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x2845b2392b6bec59" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x4699799c49bd6fa6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x83244c95be79eea2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x66e12d94f3d95620" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x2845b2392b6bec59" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x4699799c49bd6fa6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x83244c95be79eea2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x66e12d94f3d95620" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x2845b2392b6bec59" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x4699799c49bd6fa6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x83244c95be79eea2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "x126" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x132" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x66e12d94f3d95620" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x2845b2392b6bec59" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x4699799c49bd6fa6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x83244c95be79eea2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x149", + "x150" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + "0xccd1c8aaee00bc4f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x167", + "x168" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x181", + "x182" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x183", + "x184" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x185", + "x186" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x189", + "x190" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x191", + "x192" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x193", + "x194" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x195", + "x196" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x198" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x199" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x200" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x201" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x202" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x199" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x200" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x201" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_nonzero", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_selectznz", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64[4]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_to_bytes", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u8[32]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u8", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x57" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x58" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x59" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x60" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[12]" + ], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[13]" + ], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[14]" + ], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[15]" + ], + "operation": "static_cast", + "arguments": [ + "x32" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[16]" + ], + "operation": "static_cast", + "arguments": [ + "x33" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[17]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[18]" + ], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[19]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[20]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[21]" + ], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[22]" + ], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[23]" + ], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[24]" + ], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[25]" + ], + "operation": "static_cast", + "arguments": [ + "x49" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[26]" + ], + "operation": "static_cast", + "arguments": [ + "x51" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[27]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[28]" + ], + "operation": "static_cast", + "arguments": [ + "x55" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[29]" + ], + "operation": "static_cast", + "arguments": [ + "x57" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[30]" + ], + "operation": "static_cast", + "arguments": [ + "x59" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[31]" + ], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_from_bytes", + "arguments": [ + { + "datatype": "u8[32]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[31]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[30]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[29]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[28]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[27]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[26]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[25]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[24]" + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[23]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[22]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[21]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[20]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[19]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[18]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[17]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + "arg1[16]" + ] + }, + { + "datatype": "u64", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[15]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[14]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[13]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[12]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u64", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x57" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x58" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x59" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x60" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_set_one", + "arguments": [], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xc46353d039cdaaf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x4319055258e8617b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_msat", + "arguments": [], + "returns": [ + { + "datatype": "u64[5]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_divstep", + "arguments": [ + { + "datatype": "u64", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64[5]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[5]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64[5]", + "name": "out2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[5]", + "name": "out3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "out4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "out5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "63" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + "0x1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x7" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x8" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x10" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x11" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + "0x1", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x23" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x24" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x25" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x26" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x27" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x29" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x48" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x61" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0x0", + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + "0xf3b9cac2fc632551" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + "0xbce6faada7179e84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + "0xffffffff00000000" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x70" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x71" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x72" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x73" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x74" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "0x1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x75" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x76" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x77" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x78" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x79" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x90" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x91" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x92" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x93" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + "0xf3b9cac2fc632551" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + "0xbce6faada7179e84" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x111" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x1" + ] + }, + { + "datatype": "u64", + "name": [ + "x114" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x115" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x116" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x117" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x118" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + "0x8000000000000000" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + "1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x119" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x120" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x121" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x122" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x123" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x124" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x125" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x126" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out2[0]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[1]" + ], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[2]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[3]" + ], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[4]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[0]" + ], + "operation": "static_cast", + "arguments": [ + "x114" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[1]" + ], + "operation": "static_cast", + "arguments": [ + "x115" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[2]" + ], + "operation": "static_cast", + "arguments": [ + "x116" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[3]" + ], + "operation": "static_cast", + "arguments": [ + "x117" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[4]" + ], + "operation": "static_cast", + "arguments": [ + "x118" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[0]" + ], + "operation": "static_cast", + "arguments": [ + "x119" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[1]" + ], + "operation": "static_cast", + "arguments": [ + "x120" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[2]" + ], + "operation": "static_cast", + "arguments": [ + "x121" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[3]" + ], + "operation": "static_cast", + "arguments": [ + "x122" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[0]" + ], + "operation": "static_cast", + "arguments": [ + "x123" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[1]" + ], + "operation": "static_cast", + "arguments": [ + "x124" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[2]" + ], + "operation": "static_cast", + "arguments": [ + "x125" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[3]" + ], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "operation": "fiat_p256_scalar_divstep_precomp", + "arguments": [], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xd739262fb7fcfbb5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x8ac6f75d20074414" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xc67428bfb5e3c256" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x444962f2eda7aedf" + ] + } + ] + } +] diff --git a/fiat-json/src/p384_scalar_32.json b/fiat-json/src/p384_scalar_32.json new file mode 100644 index 0000000000..c0f04ee4fb --- /dev/null +++ b/fiat-json/src/p384_scalar_32.json @@ -0,0 +1,180117 @@ +[ + { + "operation": "fiat_p384_scalar_addcarryx_u32", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_subborrowx_u32", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "i64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "i1", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_mulx_u32", + "arguments": [ + { + "datatype": "u32", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "out2", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "*", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_cmovznz_u32", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "body": [ + { + "datatype": "u1", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_mul", + "arguments": [ + { + "datatype": "u32[12]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[12]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[12]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + { + "datatype": "u32", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x59" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x108" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "x126" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x131", + "x132" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x149", + "x150" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x167", + "x168" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x181" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "x203" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x214", + "x215" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x218", + "x219" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x220", + "x221" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x222", + "x223" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x224", + "x225" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x226", + "x227" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x228", + "x229" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x230", + "x231" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x232", + "x233" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x234", + "x235" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x236", + "x237" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x238", + "x239" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x240", + "x241" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x242", + "x243" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x244", + "x245" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x246", + "x247" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x250", + "x251" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x252", + "x253" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x254", + "x255" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x256" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x258" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x259", + "x260" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x261", + "x262" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x263", + "x264" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x265", + "x266" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x267", + "x268" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x269", + "x270" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x271", + "x272" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x273", + "x274" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x275", + "x276" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x277", + "x278" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x279", + "x280" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x281", + "x282" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x283" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x284", + "x285" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x286", + "x287" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x288", + "x289" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x290", + "x291" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x292", + "x293" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x294", + "x295" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x296", + "x297" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x298", + "x299" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x300", + "x301" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x302", + "x303" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x304", + "x305" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x306", + "x307" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x308", + "x309" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x310", + "x311" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x312", + "x313" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x316", + "x317" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x318", + "x319" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x320", + "x321" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x322", + "x323" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x324", + "x325" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x326", + "x327" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x328", + "x329" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x330" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x337", + "x338" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x339", + "x340" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x341", + "x342" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x343", + "x344" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x345", + "x346" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x347", + "x348" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x349", + "x350" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x351", + "x352" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x353", + "x354" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x355", + "x356" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x357", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x359", + "x360" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x361", + "x362" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x363", + "x364" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x365", + "x366" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x367", + "x368" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x369", + "x370" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x371", + "x372" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x373", + "x374" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x375", + "x376" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x377", + "x378" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "x388" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x393", + "x394" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x395", + "x396" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x399", + "x400" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x401", + "x402" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x403", + "x404" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x405" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x407" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x408", + "x409" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x410", + "x411" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x412", + "x413" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x414", + "x415" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x416", + "x417" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x418", + "x419" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x420", + "x421" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x422", + "x423" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x424", + "x425" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x426", + "x427" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x428", + "x429" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x430", + "x431" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x432" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "x440" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "x444" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x445", + "x446" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x447", + "x448" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x449", + "x450" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x451", + "x452" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x453", + "x454" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x455", + "x456" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x457", + "x458" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x459", + "x460" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x461", + "x462" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x463", + "x464" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x465", + "x466" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x467", + "x468" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x469", + "x470" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x471", + "x472" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x473", + "x474" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x475", + "x476" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x477", + "x478" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x479" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x480", + "x481" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x482", + "x483" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x484", + "x485" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x486", + "x487" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x488", + "x489" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x490", + "x491" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x492", + "x493" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x494", + "x495" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x493" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x496", + "x497" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x498", + "x499" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x500", + "x501" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x502", + "x503" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x504", + "x505" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x506", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x508", + "x509" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x510", + "x511" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x512", + "x513" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x514", + "x515" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x516", + "x517" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x518", + "x519" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x520", + "x521" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x522", + "x523" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x524", + "x525" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x526", + "x527" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x528", + "x529" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x530", + "x531" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x532", + "x533" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x534", + "x535" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x536", + "x537" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x538", + "x539" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x540", + "x541" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x520" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x542", + "x543" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x541" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x544", + "x545" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x546", + "x547" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x545" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x548", + "x549" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x550", + "x551" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x552", + "x553" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x551" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x554" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x556" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x557", + "x558" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x559", + "x560" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x561", + "x562" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x563", + "x564" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x565", + "x566" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x540" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x567", + "x568" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x569", + "x570" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x571", + "x572" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x573", + "x574" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x575", + "x576" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x577", + "x578" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x579", + "x580" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x581" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x580" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x582", + "x583" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x584", + "x585" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x586", + "x587" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x588", + "x589" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x590", + "x591" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x592", + "x593" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x594", + "x595" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x596", + "x597" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x598", + "x599" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x600", + "x601" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x602", + "x603" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x604", + "x605" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x606", + "x607" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x608", + "x609" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x600" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x610", + "x611" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x612", + "x613" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x614", + "x615" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x616", + "x617" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x618", + "x619" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x620", + "x621" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x622", + "x623" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x624", + "x625" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x626", + "x627" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x628" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x629", + "x630" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x631", + "x632" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x633", + "x634" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x635", + "x636" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x610" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x637", + "x638" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x636" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x639", + "x640" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x641", + "x642" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x616" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x643", + "x644" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x645", + "x646" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x647", + "x648" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x646" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x649", + "x650" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x577" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x651", + "x652" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x653", + "x654" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x655", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x657", + "x658" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x659", + "x660" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x661", + "x662" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x663", + "x664" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x665", + "x666" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x667", + "x668" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "x670" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x677", + "x678" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x681", + "x682" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x683", + "x684" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x685", + "x686" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x687", + "x688" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x689", + "x690" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x691", + "x692" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x667" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x693", + "x694" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x665" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x695", + "x696" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x697", + "x698" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x699", + "x700" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x698" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x662" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x701", + "x702" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x660" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x703" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x702" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x705" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x706", + "x707" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x705" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x708", + "x709" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x707" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x710", + "x711" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x685" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x712", + "x713" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x687" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x714", + "x715" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x713" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x689" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x716", + "x717" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x715" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x691" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x718", + "x719" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x717" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x693" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x720", + "x721" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x719" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x695" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x722", + "x723" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x721" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x647" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x724", + "x725" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x723" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x726", + "x727" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x728", + "x729" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x727" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x730" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x729" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x731", + "x732" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x733", + "x734" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x735", + "x736" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x737", + "x738" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x739", + "x740" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x741", + "x742" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x743", + "x744" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x745", + "x746" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x747", + "x748" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x749", + "x750" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x751", + "x752" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x753", + "x754" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x755", + "x756" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x754" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x751" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x757", + "x758" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x756" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x752" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x749" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x759", + "x760" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x758" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x750" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x747" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x761", + "x762" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x760" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x748" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x745" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x763", + "x764" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x762" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x743" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x765", + "x766" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x764" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x744" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x741" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x767", + "x768" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x766" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x769", + "x770" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x768" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x740" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x771", + "x772" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x770" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x738" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x773", + "x774" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x772" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x736" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x775", + "x776" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x774" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x734" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x731" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x777" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x776" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x732" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x778", + "x779" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x706" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x753" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x780", + "x781" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x708" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x755" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x782", + "x783" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x781" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x710" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x757" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x784", + "x785" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x783" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x712" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x759" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x786", + "x787" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x785" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x714" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x761" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x788", + "x789" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x787" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x716" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x763" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x790", + "x791" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x789" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x718" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x765" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x792", + "x793" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x791" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x720" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x794", + "x795" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x793" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x722" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x769" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x796", + "x797" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x795" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x724" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x771" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x798", + "x799" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x797" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x726" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x773" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x800", + "x801" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x775" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x802", + "x803" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x801" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x777" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x804", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x806", + "x807" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x808", + "x809" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x810", + "x811" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x812", + "x813" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x814", + "x815" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x816", + "x817" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x818", + "x819" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x820", + "x821" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x822", + "x823" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x824", + "x825" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x826", + "x827" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x828", + "x829" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x830", + "x831" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x829" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x826" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x832", + "x833" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x831" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x827" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x824" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x834", + "x835" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x833" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x825" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x822" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x836", + "x837" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x835" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x823" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x820" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x838", + "x839" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x837" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x821" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x818" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x840", + "x841" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x839" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x819" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x816" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x842", + "x843" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x841" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x817" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x814" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x844", + "x845" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x843" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x812" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x846", + "x847" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x845" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x813" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x810" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x848", + "x849" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x847" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x811" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x808" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x850", + "x851" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x849" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x809" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x806" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x852" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x851" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x807" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x854" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x828" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x855", + "x856" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x854" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x780" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x830" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x857", + "x858" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x856" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x782" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x832" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x859", + "x860" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x858" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x784" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x834" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x861", + "x862" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x860" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x836" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x863", + "x864" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x862" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x788" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x838" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x865", + "x866" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x864" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x790" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x840" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x867", + "x868" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x866" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x792" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x842" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x869", + "x870" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x868" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x794" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x844" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x871", + "x872" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x870" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x796" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x846" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x873", + "x874" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x872" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x798" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x848" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x875", + "x876" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x874" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x800" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x850" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x877", + "x878" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x876" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x802" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x852" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x879" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x878" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x803" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x880", + "x881" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x882", + "x883" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x884", + "x885" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x886", + "x887" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x888", + "x889" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x890", + "x891" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x892", + "x893" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x894", + "x895" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x896", + "x897" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x898", + "x899" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x900", + "x901" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x902", + "x903" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x904", + "x905" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x903" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x900" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x906", + "x907" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x905" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x901" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x898" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x908", + "x909" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x907" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x899" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x896" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x910", + "x911" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x909" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x897" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x894" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x912", + "x913" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x911" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x895" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x892" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x914", + "x915" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x913" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x893" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x890" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x916", + "x917" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x915" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x891" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x888" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x918", + "x919" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x917" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x889" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x886" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x920", + "x921" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x919" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x887" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x922", + "x923" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x921" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x885" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x882" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x924", + "x925" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x883" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x880" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x926" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x925" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x881" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x927", + "x928" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x855" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x902" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x929", + "x930" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x928" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x857" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x904" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x931", + "x932" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x930" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x859" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x906" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x933", + "x934" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x932" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x861" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x908" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x935", + "x936" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x934" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x863" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x910" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x937", + "x938" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x936" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x865" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x912" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x939", + "x940" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x938" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x867" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x914" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x941", + "x942" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x940" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x869" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x916" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x943", + "x944" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x942" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x871" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x918" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x945", + "x946" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x944" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x873" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x920" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x947", + "x948" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x946" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x875" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x922" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x949", + "x950" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x948" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x877" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x924" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x951", + "x952" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x950" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x879" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x926" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x953", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x927" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x955", + "x956" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x957", + "x958" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x959", + "x960" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x961", + "x962" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x963", + "x964" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x965", + "x966" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x967", + "x968" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x969", + "x970" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x971", + "x972" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x973", + "x974" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x975", + "x976" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x977", + "x978" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x979", + "x980" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x978" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x975" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x981", + "x982" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x980" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x976" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x973" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x983", + "x984" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x974" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x971" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x985", + "x986" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x984" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x972" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x969" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x987", + "x988" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x986" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x970" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x967" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x989", + "x990" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x988" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x968" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x965" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x991", + "x992" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x990" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x966" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x963" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x993", + "x994" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x992" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x964" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x961" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x995", + "x996" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x994" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x962" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x959" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x997", + "x998" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x996" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x960" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x957" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x999", + "x1000" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x998" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x958" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x955" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1001" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1000" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x956" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1003" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x927" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x977" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1004", + "x1005" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1003" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x929" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x979" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1006", + "x1007" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1005" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x931" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x981" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1008", + "x1009" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1007" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x933" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x983" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1010", + "x1011" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1009" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x935" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x985" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1012", + "x1013" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1011" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x937" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x987" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1014", + "x1015" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1013" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x939" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x989" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1016", + "x1017" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1015" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x941" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x991" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1018", + "x1019" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1017" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x943" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x993" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1020", + "x1021" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1019" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x945" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x995" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1022", + "x1023" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1021" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x947" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x997" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1024", + "x1025" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1023" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x949" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x999" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1026", + "x1027" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1025" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x951" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1001" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1028" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1027" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x952" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1029", + "x1030" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1031", + "x1032" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1033", + "x1034" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1035", + "x1036" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1037", + "x1038" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1039", + "x1040" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1041", + "x1042" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1043", + "x1044" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1045", + "x1046" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1047", + "x1048" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1049", + "x1050" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1051", + "x1052" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1053", + "x1054" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1052" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1049" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1055", + "x1056" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1054" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1050" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1047" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1057", + "x1058" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1056" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1048" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1045" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1059", + "x1060" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1058" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1046" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1043" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1061", + "x1062" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1060" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1044" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1041" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1063", + "x1064" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1062" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1042" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1039" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1065", + "x1066" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1064" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1040" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1037" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1067", + "x1068" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1066" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1038" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1035" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1069", + "x1070" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1068" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1036" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1033" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1071", + "x1072" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1070" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1034" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1031" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1073", + "x1074" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1072" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1032" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1029" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1075" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1074" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1030" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1076", + "x1077" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1004" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1051" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1078", + "x1079" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1077" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1006" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1053" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1080", + "x1081" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1079" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1008" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1055" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1082", + "x1083" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1081" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1010" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1057" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1084", + "x1085" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1083" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1012" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1059" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1086", + "x1087" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1085" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1014" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1061" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1088", + "x1089" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1087" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1016" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1063" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1090", + "x1091" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1089" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1018" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1065" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1092", + "x1093" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1091" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1020" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1094", + "x1095" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1093" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1022" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1069" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1096", + "x1097" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1095" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1024" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1071" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1098", + "x1099" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1097" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1026" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1073" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1100", + "x1101" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1099" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1028" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1075" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1102", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1076" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1104", + "x1105" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1106", + "x1107" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1108", + "x1109" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1110", + "x1111" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1112", + "x1113" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1114", + "x1115" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1116", + "x1117" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1118", + "x1119" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1120", + "x1121" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1122", + "x1123" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1124", + "x1125" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1126", + "x1127" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1128", + "x1129" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1124" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1130", + "x1131" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1122" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1132", + "x1133" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1120" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1134", + "x1135" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1118" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1136", + "x1137" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1135" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1116" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1138", + "x1139" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1137" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1114" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1140", + "x1141" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1139" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1142", + "x1143" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1144", + "x1145" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1108" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1146", + "x1147" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1148", + "x1149" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1104" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1150" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1105" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1152" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1076" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1126" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1153", + "x1154" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1152" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1078" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1128" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1155", + "x1156" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1154" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1130" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1157", + "x1158" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1156" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1082" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1132" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1159", + "x1160" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1084" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1134" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1161", + "x1162" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1160" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1086" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1136" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1163", + "x1164" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1162" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1088" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1138" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1165", + "x1166" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1090" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1140" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1167", + "x1168" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1092" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1142" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1169", + "x1170" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1094" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1144" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1171", + "x1172" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1096" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1146" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1173", + "x1174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1098" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1148" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1175", + "x1176" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1150" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1177" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1176" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1101" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1178", + "x1179" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1180", + "x1181" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1182", + "x1183" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1184", + "x1185" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1186", + "x1187" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1188", + "x1189" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1190", + "x1191" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1192", + "x1193" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1194", + "x1195" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1196", + "x1197" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1198", + "x1199" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1200", + "x1201" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1202", + "x1203" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1198" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1204", + "x1205" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1196" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1206", + "x1207" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1194" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1208", + "x1209" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1192" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1210", + "x1211" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1190" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1212", + "x1213" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1188" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1214", + "x1215" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1186" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1216", + "x1217" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1184" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1218", + "x1219" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1182" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1220", + "x1221" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1180" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1222", + "x1223" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1178" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1224" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1225", + "x1226" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1200" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1227", + "x1228" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1202" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1229", + "x1230" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1204" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1231", + "x1232" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1206" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1233", + "x1234" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1232" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1208" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1235", + "x1236" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1210" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1237", + "x1238" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1212" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1239", + "x1240" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1214" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1241", + "x1242" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1240" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1216" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1243", + "x1244" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1242" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1218" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1245", + "x1246" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1244" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1220" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1247", + "x1248" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1222" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1249", + "x1250" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1177" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1224" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1251", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1225" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1253", + "x1254" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1255", + "x1256" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1257", + "x1258" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1259", + "x1260" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1261", + "x1262" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1263", + "x1264" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1265", + "x1266" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1267", + "x1268" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1269", + "x1270" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1271", + "x1272" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1273", + "x1274" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1275", + "x1276" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1277", + "x1278" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1273" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1279", + "x1280" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1271" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1281", + "x1282" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1269" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1283", + "x1284" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1267" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1285", + "x1286" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1265" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1287", + "x1288" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1263" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1289", + "x1290" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1261" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1291", + "x1292" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1259" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1293", + "x1294" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1257" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1295", + "x1296" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1294" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1255" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1297", + "x1298" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1253" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1299" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1254" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1301" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1275" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1302", + "x1303" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1301" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1277" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1304", + "x1305" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1303" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1279" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1306", + "x1307" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1305" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1231" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1281" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1308", + "x1309" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1233" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1283" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1310", + "x1311" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1285" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1312", + "x1313" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1287" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1314", + "x1315" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1289" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1316", + "x1317" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1241" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1291" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1318", + "x1319" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1243" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1293" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1320", + "x1321" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1245" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1295" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1322", + "x1323" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1247" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1297" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1324", + "x1325" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1323" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1249" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1299" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1326" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1325" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1250" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1327", + "x1328" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1329", + "x1330" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1331", + "x1332" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1333", + "x1334" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1335", + "x1336" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1337", + "x1338" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1339", + "x1340" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1341", + "x1342" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1343", + "x1344" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1345", + "x1346" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1347", + "x1348" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1349", + "x1350" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1351", + "x1352" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1350" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1347" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1353", + "x1354" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1352" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1348" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1345" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1355", + "x1356" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1354" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1343" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1357", + "x1358" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1356" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1344" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1341" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1359", + "x1360" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1358" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1342" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1339" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1361", + "x1362" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1360" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1337" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1363", + "x1364" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1362" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1335" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1365", + "x1366" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1364" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1336" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1333" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1367", + "x1368" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1366" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1331" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1369", + "x1370" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1368" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1329" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1371", + "x1372" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1370" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1330" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1327" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1373" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1372" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1328" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1374", + "x1375" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1302" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1349" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1376", + "x1377" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1375" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1304" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1351" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1378", + "x1379" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1377" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1306" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1353" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1380", + "x1381" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1379" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1308" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1382", + "x1383" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1381" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1310" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1357" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1384", + "x1385" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1312" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1359" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1386", + "x1387" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1314" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1361" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1388", + "x1389" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1387" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1316" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1363" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1390", + "x1391" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1389" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1318" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1365" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1392", + "x1393" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1391" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1367" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1394", + "x1395" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1393" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1369" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1396", + "x1397" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1395" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1371" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1398", + "x1399" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1397" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1326" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1373" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1400", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1374" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1402", + "x1403" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1404", + "x1405" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1406", + "x1407" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1408", + "x1409" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1410", + "x1411" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1412", + "x1413" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1414", + "x1415" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1416", + "x1417" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1418", + "x1419" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1420", + "x1421" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1422", + "x1423" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1424", + "x1425" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1426", + "x1427" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1425" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1422" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1428", + "x1429" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1423" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1420" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1430", + "x1431" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1429" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1418" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1432", + "x1433" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1431" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1416" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1434", + "x1435" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1433" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1414" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1436", + "x1437" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1435" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1412" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1438", + "x1439" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1437" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1410" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1440", + "x1441" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1439" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1408" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1442", + "x1443" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1441" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1406" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1444", + "x1445" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1443" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1404" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1446", + "x1447" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1445" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1402" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1448" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1447" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1403" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1450" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1424" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1451", + "x1452" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1426" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1453", + "x1454" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1428" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1455", + "x1456" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1430" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1457", + "x1458" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1432" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1459", + "x1460" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1434" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1461", + "x1462" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1436" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1463", + "x1464" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1438" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1465", + "x1466" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1440" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1467", + "x1468" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1466" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1392" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1442" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1469", + "x1470" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1394" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1444" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1471", + "x1472" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1446" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1473", + "x1474" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1398" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1475" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1474" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1399" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1476", + "x1477" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1478", + "x1479" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1480", + "x1481" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1482", + "x1483" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1484", + "x1485" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1486", + "x1487" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1488", + "x1489" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1490", + "x1491" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1492", + "x1493" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1494", + "x1495" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1496", + "x1497" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1498", + "x1499" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1500", + "x1501" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1496" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1502", + "x1503" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1501" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1497" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1494" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1504", + "x1505" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1503" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1495" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1492" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1506", + "x1507" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1505" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1493" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1490" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1508", + "x1509" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1507" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1488" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1510", + "x1511" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1509" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1486" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1512", + "x1513" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1511" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1484" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1514", + "x1515" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1513" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1482" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1516", + "x1517" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1515" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1480" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1518", + "x1519" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1517" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1478" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1520", + "x1521" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1519" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1479" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1476" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1522" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1521" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1477" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1523", + "x1524" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1451" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1498" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1525", + "x1526" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1524" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1453" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1500" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1527", + "x1528" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1526" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1455" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1502" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1529", + "x1530" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1528" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1457" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1504" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1531", + "x1532" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1530" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1459" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1506" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1533", + "x1534" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1532" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1461" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1508" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1535", + "x1536" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1534" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1463" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1510" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1537", + "x1538" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1536" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1465" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1512" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1539", + "x1540" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1538" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1467" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1514" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1541", + "x1542" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1540" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1516" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1543", + "x1544" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1518" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1545", + "x1546" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1544" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1473" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1520" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1547", + "x1548" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1546" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1475" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1522" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1549", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1523" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1551", + "x1552" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1553", + "x1554" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1555", + "x1556" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1557", + "x1558" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1559", + "x1560" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1561", + "x1562" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1563", + "x1564" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1565", + "x1566" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1567", + "x1568" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1569", + "x1570" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1571", + "x1572" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1573", + "x1574" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1575", + "x1576" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1574" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1571" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1577", + "x1578" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1572" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1569" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1579", + "x1580" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1570" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1567" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1581", + "x1582" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1580" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1568" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1565" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1583", + "x1584" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1582" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1566" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1563" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1585", + "x1586" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1584" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1564" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1561" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1587", + "x1588" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1562" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1559" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1589", + "x1590" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1560" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1557" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1591", + "x1592" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1590" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1558" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1555" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1593", + "x1594" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1553" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1595", + "x1596" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1594" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1551" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1597" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1596" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1552" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1599" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1523" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1573" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1600", + "x1601" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1599" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1525" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1575" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1602", + "x1603" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1601" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1577" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1604", + "x1605" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1603" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1579" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1606", + "x1607" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1605" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1581" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1608", + "x1609" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1607" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1533" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1583" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1610", + "x1611" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1609" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1535" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1585" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1612", + "x1613" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1611" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1537" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1587" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1614", + "x1615" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1613" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1539" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1589" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1616", + "x1617" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1615" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1541" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1591" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1618", + "x1619" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1617" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1543" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1593" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1620", + "x1621" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1619" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1545" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1595" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1622", + "x1623" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1621" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1547" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1597" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1624" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1623" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1548" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1625", + "x1626" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1627", + "x1628" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1629", + "x1630" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1631", + "x1632" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1633", + "x1634" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1635", + "x1636" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1637", + "x1638" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1639", + "x1640" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1641", + "x1642" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1643", + "x1644" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1645", + "x1646" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1647", + "x1648" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1649", + "x1650" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1648" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1645" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1651", + "x1652" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1650" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1646" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1653", + "x1654" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1652" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1644" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1641" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1655", + "x1656" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1654" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1642" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1639" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1657", + "x1658" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1656" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1637" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1659", + "x1660" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1658" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1635" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1661", + "x1662" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1660" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1636" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1633" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1663", + "x1664" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1662" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1631" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1665", + "x1666" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1664" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1629" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1667", + "x1668" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1666" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1627" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1669", + "x1670" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1625" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1671" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1626" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1672", + "x1673" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1600" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1647" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1674", + "x1675" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1673" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1602" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1649" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1676", + "x1677" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1675" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1604" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1651" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1678", + "x1679" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1677" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1653" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1680", + "x1681" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1679" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1608" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1655" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1682", + "x1683" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1681" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1610" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1657" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1684", + "x1685" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1683" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1612" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1659" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1686", + "x1687" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1685" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1614" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1661" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1688", + "x1689" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1687" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1616" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1663" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1690", + "x1691" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1689" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1618" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1665" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1692", + "x1693" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1691" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1620" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1667" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1694", + "x1695" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1693" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1622" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1669" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1696", + "x1697" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1695" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1624" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1671" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1698", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1672" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1700", + "x1701" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1702", + "x1703" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1704", + "x1705" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1706", + "x1707" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1708", + "x1709" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1710", + "x1711" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1712", + "x1713" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1714", + "x1715" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1716", + "x1717" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1718", + "x1719" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1720", + "x1721" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1722", + "x1723" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1724", + "x1725" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1723" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1720" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1726", + "x1727" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1725" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1721" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1718" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1728", + "x1729" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1727" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1719" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1716" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1730", + "x1731" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1729" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1717" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1714" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1732", + "x1733" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1731" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1715" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1712" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1734", + "x1735" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1733" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1713" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1710" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1736", + "x1737" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1735" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1711" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1708" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1738", + "x1739" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1737" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1709" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1706" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1740", + "x1741" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1739" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1707" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1704" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1742", + "x1743" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1741" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1705" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1702" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1744", + "x1745" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1743" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1700" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1746" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1745" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1701" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1748" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1722" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1749", + "x1750" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1748" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1724" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1751", + "x1752" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1750" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1726" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1753", + "x1754" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1752" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1728" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1755", + "x1756" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1754" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1730" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1757", + "x1758" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1756" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1732" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1759", + "x1760" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1758" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1734" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1761", + "x1762" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1760" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1736" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1763", + "x1764" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1762" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1738" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1765", + "x1766" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1764" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1740" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1767", + "x1768" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1766" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1769", + "x1770" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1768" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1744" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1771", + "x1772" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1770" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1696" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1746" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1773" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1772" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1697" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1774", + "x1775" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1749" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1776", + "x1777" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1775" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1751" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1778", + "x1779" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1777" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1753" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1780", + "x1781" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1779" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1755" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1782", + "x1783" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1781" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1757" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1784", + "x1785" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1783" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1759" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1786", + "x1787" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1785" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1761" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1788", + "x1789" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1787" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1763" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1790", + "x1791" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1789" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1765" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1792", + "x1793" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1791" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1767" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1794", + "x1795" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1793" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1769" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1796", + "x1797" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1795" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1771" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1799" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1797" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1773" + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x1800" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1774" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1749" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1801" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1776" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1751" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1802" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1753" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1803" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1780" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1755" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1804" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1782" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1757" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1805" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1784" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1759" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1806" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1786" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1761" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1807" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1788" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1763" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1808" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1790" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1765" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1809" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1792" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1767" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1810" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1794" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1769" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1811" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1796" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1771" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x1800" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x1801" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x1802" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x1803" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x1804" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x1805" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x1806" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x1807" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x1808" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x1809" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x1810" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x1811" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_square", + "arguments": [ + { + "datatype": "u32[12]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[12]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + { + "datatype": "u32", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x59" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x108" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "x126" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x131", + "x132" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x149", + "x150" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x167", + "x168" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x181" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "x203" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x214", + "x215" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x218", + "x219" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x220", + "x221" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x222", + "x223" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x224", + "x225" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x226", + "x227" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x228", + "x229" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x230", + "x231" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x232", + "x233" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x234", + "x235" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x236", + "x237" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x238", + "x239" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x240", + "x241" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x242", + "x243" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x244", + "x245" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x246", + "x247" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x250", + "x251" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x252", + "x253" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x254", + "x255" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x256" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x258" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x259", + "x260" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x261", + "x262" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x263", + "x264" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x265", + "x266" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x267", + "x268" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x269", + "x270" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x271", + "x272" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x273", + "x274" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x275", + "x276" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x277", + "x278" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x279", + "x280" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x281", + "x282" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x283" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x284", + "x285" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x286", + "x287" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x288", + "x289" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x290", + "x291" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x292", + "x293" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x294", + "x295" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x296", + "x297" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x298", + "x299" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x300", + "x301" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x302", + "x303" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x304", + "x305" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x306", + "x307" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x308", + "x309" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x310", + "x311" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x312", + "x313" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x316", + "x317" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x318", + "x319" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x320", + "x321" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x322", + "x323" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x324", + "x325" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x326", + "x327" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x328", + "x329" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x330" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x337", + "x338" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x339", + "x340" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x341", + "x342" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x343", + "x344" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x345", + "x346" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x347", + "x348" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x349", + "x350" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x351", + "x352" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x353", + "x354" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x355", + "x356" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x357", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x359", + "x360" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x361", + "x362" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x363", + "x364" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x365", + "x366" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x367", + "x368" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x369", + "x370" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x371", + "x372" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x373", + "x374" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x375", + "x376" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x377", + "x378" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "x388" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x393", + "x394" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x395", + "x396" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x399", + "x400" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x401", + "x402" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x403", + "x404" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x405" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x407" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x408", + "x409" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x410", + "x411" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x412", + "x413" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x414", + "x415" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x416", + "x417" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x418", + "x419" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x420", + "x421" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x422", + "x423" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x424", + "x425" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x426", + "x427" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x428", + "x429" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x430", + "x431" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x432" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "x440" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "x444" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x445", + "x446" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x447", + "x448" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x449", + "x450" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x451", + "x452" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x453", + "x454" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x455", + "x456" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x457", + "x458" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x459", + "x460" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x461", + "x462" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x463", + "x464" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x465", + "x466" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x467", + "x468" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x469", + "x470" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x471", + "x472" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x473", + "x474" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x475", + "x476" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x477", + "x478" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x479" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x480", + "x481" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x482", + "x483" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x484", + "x485" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x486", + "x487" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x488", + "x489" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x490", + "x491" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x492", + "x493" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x494", + "x495" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x493" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x496", + "x497" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x498", + "x499" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x500", + "x501" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x502", + "x503" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x504", + "x505" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x506", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x508", + "x509" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x510", + "x511" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x512", + "x513" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x514", + "x515" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x516", + "x517" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x518", + "x519" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x520", + "x521" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x522", + "x523" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x524", + "x525" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x526", + "x527" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x528", + "x529" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x530", + "x531" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x532", + "x533" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x534", + "x535" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x536", + "x537" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x538", + "x539" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x540", + "x541" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x520" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x542", + "x543" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x541" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x544", + "x545" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x546", + "x547" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x545" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x548", + "x549" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x550", + "x551" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x552", + "x553" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x551" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x554" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x556" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x557", + "x558" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x559", + "x560" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x561", + "x562" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x563", + "x564" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x565", + "x566" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x540" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x567", + "x568" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x569", + "x570" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x571", + "x572" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x573", + "x574" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x575", + "x576" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x577", + "x578" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x579", + "x580" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x581" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x580" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x582", + "x583" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x584", + "x585" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x586", + "x587" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x588", + "x589" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x590", + "x591" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x592", + "x593" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x594", + "x595" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x596", + "x597" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x598", + "x599" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x600", + "x601" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x602", + "x603" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x604", + "x605" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x606", + "x607" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x608", + "x609" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x600" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x610", + "x611" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x612", + "x613" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x614", + "x615" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x616", + "x617" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x618", + "x619" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x620", + "x621" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x622", + "x623" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x624", + "x625" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x626", + "x627" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x628" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x629", + "x630" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x631", + "x632" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x633", + "x634" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x635", + "x636" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x610" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x637", + "x638" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x636" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x639", + "x640" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x641", + "x642" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x616" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x643", + "x644" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x645", + "x646" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x647", + "x648" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x646" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x649", + "x650" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x577" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x651", + "x652" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x653", + "x654" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x655", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x657", + "x658" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x659", + "x660" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x661", + "x662" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x663", + "x664" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x665", + "x666" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x667", + "x668" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "x670" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x677", + "x678" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x681", + "x682" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x683", + "x684" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x685", + "x686" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x687", + "x688" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x689", + "x690" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x691", + "x692" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x667" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x693", + "x694" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x665" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x695", + "x696" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x697", + "x698" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x699", + "x700" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x698" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x662" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x701", + "x702" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x660" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x703" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x702" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x705" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x706", + "x707" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x705" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x708", + "x709" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x707" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x710", + "x711" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x685" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x712", + "x713" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x687" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x714", + "x715" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x713" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x689" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x716", + "x717" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x715" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x691" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x718", + "x719" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x717" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x693" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x720", + "x721" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x719" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x695" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x722", + "x723" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x721" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x647" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x724", + "x725" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x723" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x726", + "x727" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x728", + "x729" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x727" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x730" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x729" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x731", + "x732" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x733", + "x734" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x735", + "x736" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x737", + "x738" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x739", + "x740" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x741", + "x742" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x743", + "x744" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x745", + "x746" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x747", + "x748" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x749", + "x750" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x751", + "x752" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x753", + "x754" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x755", + "x756" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x754" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x751" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x757", + "x758" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x756" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x752" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x749" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x759", + "x760" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x758" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x750" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x747" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x761", + "x762" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x760" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x748" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x745" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x763", + "x764" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x762" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x743" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x765", + "x766" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x764" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x744" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x741" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x767", + "x768" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x766" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x769", + "x770" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x768" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x740" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x771", + "x772" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x770" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x738" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x773", + "x774" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x772" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x736" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x775", + "x776" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x774" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x734" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x731" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x777" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x776" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x732" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x778", + "x779" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x706" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x753" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x780", + "x781" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x708" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x755" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x782", + "x783" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x781" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x710" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x757" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x784", + "x785" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x783" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x712" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x759" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x786", + "x787" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x785" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x714" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x761" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x788", + "x789" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x787" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x716" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x763" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x790", + "x791" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x789" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x718" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x765" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x792", + "x793" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x791" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x720" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x794", + "x795" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x793" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x722" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x769" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x796", + "x797" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x795" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x724" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x771" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x798", + "x799" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x797" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x726" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x773" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x800", + "x801" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x775" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x802", + "x803" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x801" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x777" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x804", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x806", + "x807" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x808", + "x809" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x810", + "x811" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x812", + "x813" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x814", + "x815" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x816", + "x817" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x818", + "x819" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x820", + "x821" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x822", + "x823" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x824", + "x825" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x826", + "x827" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x828", + "x829" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x830", + "x831" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x829" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x826" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x832", + "x833" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x831" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x827" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x824" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x834", + "x835" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x833" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x825" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x822" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x836", + "x837" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x835" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x823" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x820" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x838", + "x839" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x837" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x821" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x818" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x840", + "x841" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x839" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x819" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x816" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x842", + "x843" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x841" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x817" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x814" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x844", + "x845" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x843" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x812" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x846", + "x847" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x845" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x813" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x810" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x848", + "x849" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x847" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x811" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x808" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x850", + "x851" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x849" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x809" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x806" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x852" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x851" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x807" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x854" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x828" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x855", + "x856" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x854" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x780" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x830" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x857", + "x858" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x856" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x782" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x832" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x859", + "x860" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x858" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x784" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x834" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x861", + "x862" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x860" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x836" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x863", + "x864" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x862" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x788" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x838" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x865", + "x866" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x864" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x790" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x840" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x867", + "x868" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x866" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x792" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x842" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x869", + "x870" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x868" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x794" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x844" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x871", + "x872" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x870" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x796" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x846" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x873", + "x874" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x872" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x798" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x848" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x875", + "x876" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x874" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x800" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x850" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x877", + "x878" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x876" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x802" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x852" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x879" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x878" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x803" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x880", + "x881" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x882", + "x883" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x884", + "x885" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x886", + "x887" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x888", + "x889" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x890", + "x891" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x892", + "x893" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x894", + "x895" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x896", + "x897" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x898", + "x899" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x900", + "x901" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x902", + "x903" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x904", + "x905" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x903" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x900" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x906", + "x907" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x905" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x901" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x898" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x908", + "x909" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x907" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x899" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x896" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x910", + "x911" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x909" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x897" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x894" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x912", + "x913" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x911" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x895" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x892" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x914", + "x915" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x913" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x893" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x890" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x916", + "x917" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x915" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x891" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x888" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x918", + "x919" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x917" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x889" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x886" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x920", + "x921" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x919" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x887" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x922", + "x923" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x921" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x885" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x882" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x924", + "x925" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x883" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x880" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x926" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x925" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x881" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x927", + "x928" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x855" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x902" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x929", + "x930" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x928" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x857" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x904" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x931", + "x932" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x930" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x859" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x906" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x933", + "x934" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x932" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x861" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x908" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x935", + "x936" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x934" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x863" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x910" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x937", + "x938" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x936" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x865" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x912" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x939", + "x940" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x938" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x867" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x914" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x941", + "x942" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x940" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x869" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x916" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x943", + "x944" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x942" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x871" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x918" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x945", + "x946" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x944" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x873" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x920" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x947", + "x948" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x946" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x875" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x922" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x949", + "x950" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x948" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x877" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x924" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x951", + "x952" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x950" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x879" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x926" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x953", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x927" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x955", + "x956" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x957", + "x958" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x959", + "x960" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x961", + "x962" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x963", + "x964" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x965", + "x966" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x967", + "x968" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x969", + "x970" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x971", + "x972" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x973", + "x974" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x975", + "x976" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x977", + "x978" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x979", + "x980" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x978" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x975" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x981", + "x982" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x980" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x976" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x973" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x983", + "x984" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x974" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x971" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x985", + "x986" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x984" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x972" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x969" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x987", + "x988" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x986" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x970" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x967" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x989", + "x990" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x988" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x968" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x965" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x991", + "x992" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x990" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x966" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x963" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x993", + "x994" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x992" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x964" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x961" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x995", + "x996" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x994" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x962" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x959" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x997", + "x998" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x996" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x960" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x957" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x999", + "x1000" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x998" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x958" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x955" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1001" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1000" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x956" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1003" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x927" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x977" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1004", + "x1005" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1003" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x929" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x979" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1006", + "x1007" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1005" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x931" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x981" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1008", + "x1009" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1007" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x933" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x983" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1010", + "x1011" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1009" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x935" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x985" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1012", + "x1013" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1011" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x937" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x987" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1014", + "x1015" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1013" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x939" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x989" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1016", + "x1017" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1015" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x941" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x991" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1018", + "x1019" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1017" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x943" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x993" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1020", + "x1021" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1019" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x945" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x995" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1022", + "x1023" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1021" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x947" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x997" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1024", + "x1025" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1023" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x949" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x999" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1026", + "x1027" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1025" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x951" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1001" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1028" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1027" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x952" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1029", + "x1030" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1031", + "x1032" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1033", + "x1034" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1035", + "x1036" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1037", + "x1038" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1039", + "x1040" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1041", + "x1042" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1043", + "x1044" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1045", + "x1046" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1047", + "x1048" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1049", + "x1050" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1051", + "x1052" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1053", + "x1054" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1052" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1049" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1055", + "x1056" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1054" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1050" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1047" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1057", + "x1058" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1056" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1048" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1045" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1059", + "x1060" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1058" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1046" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1043" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1061", + "x1062" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1060" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1044" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1041" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1063", + "x1064" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1062" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1042" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1039" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1065", + "x1066" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1064" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1040" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1037" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1067", + "x1068" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1066" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1038" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1035" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1069", + "x1070" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1068" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1036" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1033" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1071", + "x1072" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1070" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1034" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1031" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1073", + "x1074" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1072" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1032" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1029" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1075" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1074" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1030" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1076", + "x1077" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1004" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1051" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1078", + "x1079" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1077" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1006" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1053" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1080", + "x1081" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1079" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1008" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1055" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1082", + "x1083" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1081" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1010" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1057" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1084", + "x1085" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1083" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1012" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1059" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1086", + "x1087" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1085" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1014" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1061" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1088", + "x1089" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1087" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1016" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1063" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1090", + "x1091" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1089" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1018" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1065" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1092", + "x1093" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1091" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1020" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1094", + "x1095" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1093" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1022" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1069" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1096", + "x1097" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1095" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1024" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1071" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1098", + "x1099" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1097" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1026" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1073" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1100", + "x1101" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1099" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1028" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1075" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1102", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1076" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1104", + "x1105" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1106", + "x1107" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1108", + "x1109" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1110", + "x1111" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1112", + "x1113" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1114", + "x1115" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1116", + "x1117" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1118", + "x1119" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1120", + "x1121" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1122", + "x1123" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1124", + "x1125" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1126", + "x1127" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1128", + "x1129" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1124" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1130", + "x1131" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1122" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1132", + "x1133" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1120" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1134", + "x1135" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1118" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1136", + "x1137" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1135" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1116" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1138", + "x1139" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1137" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1114" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1140", + "x1141" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1139" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1142", + "x1143" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1144", + "x1145" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1108" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1146", + "x1147" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1148", + "x1149" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1104" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1150" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1105" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1152" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1076" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1126" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1153", + "x1154" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1152" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1078" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1128" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1155", + "x1156" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1154" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1130" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1157", + "x1158" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1156" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1082" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1132" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1159", + "x1160" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1084" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1134" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1161", + "x1162" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1160" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1086" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1136" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1163", + "x1164" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1162" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1088" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1138" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1165", + "x1166" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1090" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1140" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1167", + "x1168" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1092" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1142" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1169", + "x1170" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1094" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1144" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1171", + "x1172" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1096" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1146" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1173", + "x1174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1098" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1148" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1175", + "x1176" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1150" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1177" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1176" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1101" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1178", + "x1179" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1180", + "x1181" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1182", + "x1183" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1184", + "x1185" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1186", + "x1187" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1188", + "x1189" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1190", + "x1191" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1192", + "x1193" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1194", + "x1195" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1196", + "x1197" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1198", + "x1199" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1200", + "x1201" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1202", + "x1203" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1198" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1204", + "x1205" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1196" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1206", + "x1207" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1194" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1208", + "x1209" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1192" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1210", + "x1211" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1190" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1212", + "x1213" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1188" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1214", + "x1215" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1186" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1216", + "x1217" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1184" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1218", + "x1219" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1182" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1220", + "x1221" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1180" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1222", + "x1223" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1178" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1224" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1225", + "x1226" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1200" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1227", + "x1228" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1202" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1229", + "x1230" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1204" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1231", + "x1232" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1206" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1233", + "x1234" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1232" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1208" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1235", + "x1236" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1210" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1237", + "x1238" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1212" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1239", + "x1240" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1214" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1241", + "x1242" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1240" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1216" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1243", + "x1244" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1242" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1218" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1245", + "x1246" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1244" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1220" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1247", + "x1248" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1222" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1249", + "x1250" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1177" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1224" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1251", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1225" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1253", + "x1254" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1255", + "x1256" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1257", + "x1258" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1259", + "x1260" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1261", + "x1262" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1263", + "x1264" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1265", + "x1266" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1267", + "x1268" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1269", + "x1270" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1271", + "x1272" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1273", + "x1274" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1275", + "x1276" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1277", + "x1278" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1273" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1279", + "x1280" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1271" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1281", + "x1282" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1269" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1283", + "x1284" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1267" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1285", + "x1286" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1265" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1287", + "x1288" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1263" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1289", + "x1290" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1261" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1291", + "x1292" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1259" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1293", + "x1294" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1257" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1295", + "x1296" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1294" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1255" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1297", + "x1298" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1253" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1299" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1254" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1301" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1275" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1302", + "x1303" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1301" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1277" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1304", + "x1305" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1303" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1279" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1306", + "x1307" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1305" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1231" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1281" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1308", + "x1309" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1233" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1283" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1310", + "x1311" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1285" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1312", + "x1313" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1287" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1314", + "x1315" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1289" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1316", + "x1317" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1241" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1291" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1318", + "x1319" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1243" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1293" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1320", + "x1321" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1245" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1295" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1322", + "x1323" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1247" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1297" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1324", + "x1325" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1323" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1249" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1299" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1326" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1325" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1250" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1327", + "x1328" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1329", + "x1330" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1331", + "x1332" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1333", + "x1334" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1335", + "x1336" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1337", + "x1338" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1339", + "x1340" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1341", + "x1342" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1343", + "x1344" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1345", + "x1346" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1347", + "x1348" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1349", + "x1350" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1351", + "x1352" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1350" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1347" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1353", + "x1354" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1352" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1348" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1345" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1355", + "x1356" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1354" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1343" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1357", + "x1358" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1356" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1344" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1341" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1359", + "x1360" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1358" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1342" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1339" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1361", + "x1362" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1360" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1337" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1363", + "x1364" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1362" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1335" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1365", + "x1366" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1364" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1336" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1333" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1367", + "x1368" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1366" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1331" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1369", + "x1370" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1368" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1329" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1371", + "x1372" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1370" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1330" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1327" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1373" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1372" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1328" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1374", + "x1375" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1302" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1349" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1376", + "x1377" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1375" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1304" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1351" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1378", + "x1379" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1377" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1306" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1353" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1380", + "x1381" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1379" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1308" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1382", + "x1383" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1381" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1310" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1357" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1384", + "x1385" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1312" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1359" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1386", + "x1387" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1314" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1361" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1388", + "x1389" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1387" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1316" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1363" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1390", + "x1391" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1389" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1318" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1365" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1392", + "x1393" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1391" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1367" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1394", + "x1395" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1393" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1369" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1396", + "x1397" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1395" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1371" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1398", + "x1399" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1397" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1326" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1373" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1400", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1374" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1402", + "x1403" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1404", + "x1405" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1406", + "x1407" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1408", + "x1409" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1410", + "x1411" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1412", + "x1413" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1414", + "x1415" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1416", + "x1417" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1418", + "x1419" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1420", + "x1421" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1422", + "x1423" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1424", + "x1425" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1426", + "x1427" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1425" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1422" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1428", + "x1429" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1423" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1420" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1430", + "x1431" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1429" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1418" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1432", + "x1433" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1431" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1416" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1434", + "x1435" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1433" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1414" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1436", + "x1437" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1435" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1412" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1438", + "x1439" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1437" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1410" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1440", + "x1441" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1439" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1408" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1442", + "x1443" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1441" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1406" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1444", + "x1445" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1443" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1404" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1446", + "x1447" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1445" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1402" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1448" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1447" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1403" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1450" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1424" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1451", + "x1452" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1426" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1453", + "x1454" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1428" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1455", + "x1456" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1430" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1457", + "x1458" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1432" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1459", + "x1460" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1434" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1461", + "x1462" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1436" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1463", + "x1464" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1438" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1465", + "x1466" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1440" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1467", + "x1468" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1466" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1392" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1442" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1469", + "x1470" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1394" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1444" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1471", + "x1472" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1446" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1473", + "x1474" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1398" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1475" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1474" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1399" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1476", + "x1477" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1478", + "x1479" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1480", + "x1481" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1482", + "x1483" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1484", + "x1485" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1486", + "x1487" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1488", + "x1489" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1490", + "x1491" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1492", + "x1493" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1494", + "x1495" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1496", + "x1497" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1498", + "x1499" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1500", + "x1501" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1496" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1502", + "x1503" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1501" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1497" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1494" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1504", + "x1505" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1503" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1495" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1492" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1506", + "x1507" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1505" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1493" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1490" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1508", + "x1509" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1507" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1488" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1510", + "x1511" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1509" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1486" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1512", + "x1513" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1511" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1484" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1514", + "x1515" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1513" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1482" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1516", + "x1517" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1515" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1480" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1518", + "x1519" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1517" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1478" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1520", + "x1521" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1519" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1479" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1476" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1522" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1521" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1477" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1523", + "x1524" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1451" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1498" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1525", + "x1526" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1524" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1453" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1500" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1527", + "x1528" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1526" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1455" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1502" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1529", + "x1530" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1528" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1457" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1504" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1531", + "x1532" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1530" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1459" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1506" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1533", + "x1534" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1532" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1461" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1508" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1535", + "x1536" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1534" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1463" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1510" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1537", + "x1538" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1536" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1465" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1512" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1539", + "x1540" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1538" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1467" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1514" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1541", + "x1542" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1540" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1516" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1543", + "x1544" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1518" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1545", + "x1546" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1544" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1473" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1520" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1547", + "x1548" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1546" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1475" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1522" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1549", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1523" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1551", + "x1552" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1553", + "x1554" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1555", + "x1556" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1557", + "x1558" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1559", + "x1560" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1561", + "x1562" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1563", + "x1564" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1565", + "x1566" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1567", + "x1568" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1569", + "x1570" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1571", + "x1572" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1573", + "x1574" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1575", + "x1576" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1574" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1571" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1577", + "x1578" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1572" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1569" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1579", + "x1580" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1570" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1567" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1581", + "x1582" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1580" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1568" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1565" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1583", + "x1584" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1582" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1566" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1563" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1585", + "x1586" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1584" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1564" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1561" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1587", + "x1588" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1562" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1559" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1589", + "x1590" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1560" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1557" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1591", + "x1592" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1590" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1558" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1555" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1593", + "x1594" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1553" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1595", + "x1596" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1594" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1551" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1597" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1596" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1552" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1599" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1523" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1573" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1600", + "x1601" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1599" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1525" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1575" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1602", + "x1603" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1601" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1577" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1604", + "x1605" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1603" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1579" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1606", + "x1607" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1605" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1581" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1608", + "x1609" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1607" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1533" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1583" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1610", + "x1611" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1609" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1535" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1585" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1612", + "x1613" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1611" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1537" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1587" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1614", + "x1615" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1613" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1539" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1589" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1616", + "x1617" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1615" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1541" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1591" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1618", + "x1619" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1617" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1543" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1593" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1620", + "x1621" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1619" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1545" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1595" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1622", + "x1623" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1621" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1547" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1597" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1624" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1623" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1548" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1625", + "x1626" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1627", + "x1628" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1629", + "x1630" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1631", + "x1632" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1633", + "x1634" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1635", + "x1636" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1637", + "x1638" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1639", + "x1640" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1641", + "x1642" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1643", + "x1644" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1645", + "x1646" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1647", + "x1648" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1649", + "x1650" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1648" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1645" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1651", + "x1652" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1650" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1646" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1653", + "x1654" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1652" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1644" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1641" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1655", + "x1656" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1654" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1642" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1639" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1657", + "x1658" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1656" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1637" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1659", + "x1660" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1658" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1635" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1661", + "x1662" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1660" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1636" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1633" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1663", + "x1664" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1662" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1631" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1665", + "x1666" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1664" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1629" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1667", + "x1668" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1666" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1627" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1669", + "x1670" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1625" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1671" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1626" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1672", + "x1673" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1600" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1647" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1674", + "x1675" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1673" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1602" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1649" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1676", + "x1677" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1675" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1604" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1651" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1678", + "x1679" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1677" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1653" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1680", + "x1681" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1679" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1608" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1655" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1682", + "x1683" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1681" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1610" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1657" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1684", + "x1685" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1683" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1612" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1659" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1686", + "x1687" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1685" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1614" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1661" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1688", + "x1689" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1687" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1616" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1663" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1690", + "x1691" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1689" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1618" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1665" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1692", + "x1693" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1691" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1620" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1667" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1694", + "x1695" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1693" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1622" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1669" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1696", + "x1697" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1695" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1624" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1671" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1698", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1672" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1700", + "x1701" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1702", + "x1703" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1704", + "x1705" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1706", + "x1707" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1708", + "x1709" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1710", + "x1711" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1712", + "x1713" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1714", + "x1715" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1716", + "x1717" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1718", + "x1719" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1720", + "x1721" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1722", + "x1723" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1724", + "x1725" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1723" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1720" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1726", + "x1727" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1725" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1721" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1718" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1728", + "x1729" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1727" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1719" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1716" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1730", + "x1731" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1729" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1717" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1714" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1732", + "x1733" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1731" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1715" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1712" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1734", + "x1735" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1733" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1713" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1710" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1736", + "x1737" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1735" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1711" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1708" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1738", + "x1739" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1737" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1709" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1706" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1740", + "x1741" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1739" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1707" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1704" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1742", + "x1743" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1741" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1705" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1702" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1744", + "x1745" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1743" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1700" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1746" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1745" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1701" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1748" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1722" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1749", + "x1750" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1748" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1724" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1751", + "x1752" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1750" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1726" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1753", + "x1754" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1752" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1728" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1755", + "x1756" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1754" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1730" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1757", + "x1758" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1756" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1732" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1759", + "x1760" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1758" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1734" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1761", + "x1762" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1760" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1736" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1763", + "x1764" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1762" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1738" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1765", + "x1766" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1764" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1740" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1767", + "x1768" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1766" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1769", + "x1770" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1768" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1744" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1771", + "x1772" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1770" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1696" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1746" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1773" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1772" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1697" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1774", + "x1775" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1749" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1776", + "x1777" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1775" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1751" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1778", + "x1779" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1777" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1753" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1780", + "x1781" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1779" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1755" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1782", + "x1783" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1781" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1757" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1784", + "x1785" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1783" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1759" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1786", + "x1787" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1785" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1761" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1788", + "x1789" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1787" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1763" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1790", + "x1791" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1789" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1765" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1792", + "x1793" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1791" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1767" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1794", + "x1795" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1793" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1769" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1796", + "x1797" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1795" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1771" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1799" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1797" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1773" + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x1800" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1774" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1749" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1801" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1776" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1751" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1802" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1753" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1803" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1780" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1755" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1804" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1782" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1757" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1805" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1784" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1759" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1806" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1786" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1761" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1807" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1788" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1763" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1808" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1790" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1765" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1809" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1792" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1767" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1810" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1794" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1769" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1811" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1796" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1771" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x1800" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x1801" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x1802" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x1803" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x1804" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x1805" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x1806" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x1807" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x1808" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x1809" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x1810" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x1811" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_add", + "arguments": [ + { + "datatype": "u32[12]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[12]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[12]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x50" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x51" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x52" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x53" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x54" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x55" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x56" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x57" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x58" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x59" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x60" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x61" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x62" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x51" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x55" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x56" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x57" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x58" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x59" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x60" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_sub", + "arguments": [ + { + "datatype": "u32[12]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[12]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[12]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x25" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + "0x0", + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + "0xccc52973" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + "0xecec196a" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + "0x48b0a77a" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + "0x581a0db2" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + "0xf4372ddf" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "x37" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + "0xc7634d81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_opp", + "arguments": [ + { + "datatype": "u32[12]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[12]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x25" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + "0x0", + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + "0xccc52973" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + "0xecec196a" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + "0x48b0a77a" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + "0x581a0db2" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + "0xf4372ddf" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "x37" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + "0xc7634d81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_from_montgomery", + "arguments": [ + { + "datatype": "u32[12]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[12]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x2", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "x5" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x6", + "x7" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x8", + "x9" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "x37" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x51" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "x53" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "x135" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x138", + "x139" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x140", + "x141" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x142", + "x143" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x149" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "x161" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "x203" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x214", + "x215" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x218", + "x219" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x220", + "x221" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x222", + "x223" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x224", + "x225" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x226", + "x227" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x228", + "x229" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x230", + "x231" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x232", + "x233" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x234", + "x235" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x236", + "x237" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x238", + "x239" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x240", + "x241" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x242", + "x243" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x244", + "x245" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x247" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x250", + "x251" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x252", + "x253" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x254", + "x255" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x256", + "x257" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x258", + "x259" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x260", + "x261" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x262", + "x263" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x264", + "x265" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x266", + "x267" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x268", + "x269" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x270", + "x271" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x272", + "x273" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x274", + "x275" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x276", + "x277" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x278", + "x279" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x280", + "x281" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x282", + "x283" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x284", + "x285" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x286", + "x287" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x288", + "x289" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x290", + "x291" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x292", + "x293" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x294", + "x295" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x296", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x298", + "x299" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x300", + "x301" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x302", + "x303" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x304", + "x305" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x306", + "x307" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x308", + "x309" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x310", + "x311" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x312", + "x313" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x316", + "x317" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x318", + "x319" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x320", + "x321" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x322", + "x323" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x324", + "x325" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x326", + "x327" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x328", + "x329" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x330", + "x331" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x332", + "x333" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x334", + "x335" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x336", + "x337" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x338", + "x339" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x340", + "x341" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x342", + "x343" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x345" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x346", + "x347" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x348", + "x349" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x350", + "x351" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x352", + "x353" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x354", + "x355" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x356", + "x357" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x358", + "x359" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x360", + "x361" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x362", + "x363" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x364", + "x365" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x366", + "x367" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x368", + "x369" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x370", + "x371" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x372", + "x373" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x374", + "x375" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x376", + "x377" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x378", + "x379" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x380", + "x381" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x382", + "x383" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x384", + "x385" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x386", + "x387" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x388", + "x389" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x390", + "x391" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x392", + "x393" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x394", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x396", + "x397" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x398", + "x399" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x400", + "x401" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x402", + "x403" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x404", + "x405" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x406", + "x407" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x408", + "x409" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x410", + "x411" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x412", + "x413" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x414", + "x415" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x416", + "x417" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x418", + "x419" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x420", + "x421" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x422", + "x423" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x424", + "x425" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x426", + "x427" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x428", + "x429" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x430", + "x431" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x432", + "x433" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x434", + "x435" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x436", + "x437" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x438", + "x439" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x440", + "x441" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x443" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x444", + "x445" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x446", + "x447" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x448", + "x449" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x450", + "x451" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x452", + "x453" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x454", + "x455" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x456", + "x457" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x458", + "x459" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x460", + "x461" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x462", + "x463" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x464", + "x465" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x466", + "x467" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x468", + "x469" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x470", + "x471" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x472", + "x473" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x474", + "x475" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x476", + "x477" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x478", + "x479" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x480", + "x481" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x482", + "x483" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x484", + "x485" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x486", + "x487" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x488", + "x489" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x490", + "x491" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x492", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x494", + "x495" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x496", + "x497" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x498", + "x499" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x500", + "x501" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x502", + "x503" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x504", + "x505" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x506", + "x507" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x508", + "x509" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x510", + "x511" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x512", + "x513" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x514", + "x515" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x516", + "x517" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x518", + "x519" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x520", + "x521" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x522", + "x523" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x524", + "x525" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x526", + "x527" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x528", + "x529" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x507" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x530", + "x531" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x532", + "x533" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x534", + "x535" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x536", + "x537" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x538", + "x539" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x541" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x542", + "x543" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x541" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x544", + "x545" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x520" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x546", + "x547" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x545" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x548", + "x549" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x550", + "x551" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x552", + "x553" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x551" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x554", + "x555" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x556", + "x557" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x555" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x558", + "x559" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x560", + "x561" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x562", + "x563" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x564", + "x565" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x566", + "x567" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x568", + "x569" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x570", + "x571" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x572", + "x573" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x574", + "x575" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x576", + "x577" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x578", + "x579" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x577" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x580", + "x581" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x582", + "x583" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x584", + "x585" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x586", + "x587" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x588", + "x589" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x590", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x592", + "x593" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x594", + "x595" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x596", + "x597" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x598", + "x599" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x600", + "x601" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x602", + "x603" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x604", + "x605" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x606", + "x607" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x608", + "x609" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x610", + "x611" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x612", + "x613" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x614", + "x615" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x616", + "x617" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x618", + "x619" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x610" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x620", + "x621" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x622", + "x623" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x624", + "x625" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x626", + "x627" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x628", + "x629" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x600" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x630", + "x631" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x632", + "x633" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x634", + "x635" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x636", + "x637" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x639" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x640", + "x641" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x616" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x642", + "x643" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x644", + "x645" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x646", + "x647" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x648", + "x649" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x647" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x650", + "x651" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x652", + "x653" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x580" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x654", + "x655" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x656", + "x657" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x658", + "x659" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x660", + "x661" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x636" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x662", + "x663" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x664", + "x665" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x666", + "x667" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x665" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x668", + "x669" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x667" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x670", + "x671" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x646" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x672", + "x673" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x674", + "x675" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x676", + "x677" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x678", + "x679" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x680", + "x681" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x656" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x682", + "x683" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x684", + "x685" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x660" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x686", + "x687" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x685" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x662" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x688", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x690", + "x691" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x692", + "x693" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x694", + "x695" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x696", + "x697" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x698", + "x699" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x700", + "x701" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x702", + "x703" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x704", + "x705" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x706", + "x707" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x708", + "x709" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x710", + "x711" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x712", + "x713" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x714", + "x715" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x713" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x710" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x716", + "x717" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x715" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x708" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x718", + "x719" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x717" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x706" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x720", + "x721" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x719" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x707" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x722", + "x723" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x721" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x705" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x702" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x724", + "x725" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x723" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x700" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x726", + "x727" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x698" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x728", + "x729" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x727" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x730", + "x731" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x729" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x694" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x732", + "x733" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x731" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x695" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x692" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x734", + "x735" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x693" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x737" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x712" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x738", + "x739" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x714" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x740", + "x741" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x716" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x742", + "x743" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x741" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x718" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x744", + "x745" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x743" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x720" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x746", + "x747" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x745" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x722" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x748", + "x749" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x747" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x724" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x750", + "x751" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x749" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x726" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x752", + "x753" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x751" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x754", + "x755" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x753" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x756", + "x757" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x755" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x732" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x758", + "x759" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x757" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x734" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x760", + "x761" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x759" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x687" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x691" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x762", + "x763" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x738" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x764", + "x765" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x763" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x740" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x766", + "x767" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x765" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x742" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x768", + "x769" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x744" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x770", + "x771" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x769" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x772", + "x773" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x771" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x748" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x774", + "x775" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x773" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x750" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x776", + "x777" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x775" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x752" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x778", + "x779" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x777" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x754" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x780", + "x781" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x756" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x782", + "x783" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x781" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x758" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x784", + "x785" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x783" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x760" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x786", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x762" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x788", + "x789" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x790", + "x791" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x792", + "x793" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x794", + "x795" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x796", + "x797" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x798", + "x799" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x800", + "x801" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x802", + "x803" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x804", + "x805" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x806", + "x807" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x808", + "x809" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x810", + "x811" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x812", + "x813" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x811" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x808" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x814", + "x815" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x813" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x809" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x806" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x816", + "x817" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x807" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x818", + "x819" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x817" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x805" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x802" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x820", + "x821" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x819" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x803" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x800" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x822", + "x823" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x821" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x801" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x798" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x824", + "x825" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x823" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x796" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x826", + "x827" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x825" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x797" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x794" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x828", + "x829" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x827" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x795" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x792" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x830", + "x831" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x829" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x793" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x790" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x832", + "x833" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x831" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x791" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x788" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x835" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x762" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x810" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x836", + "x837" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x835" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x764" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x812" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x838", + "x839" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x837" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x766" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x814" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x840", + "x841" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x839" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x768" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x816" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x842", + "x843" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x841" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x770" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x818" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x844", + "x845" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x843" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x772" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x820" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x846", + "x847" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x845" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x774" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x822" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x848", + "x849" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x847" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x776" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x824" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x850", + "x851" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x849" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x826" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x852", + "x853" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x851" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x780" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x828" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x854", + "x855" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x853" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x782" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x830" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x856", + "x857" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x855" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x784" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x832" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x858", + "x859" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x857" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x785" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x761" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x833" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x789" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x860", + "x861" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x836" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x862", + "x863" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x861" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x838" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x864", + "x865" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x863" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x840" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x866", + "x867" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x865" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x842" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x868", + "x869" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x867" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x844" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x870", + "x871" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x869" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x846" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x872", + "x873" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x871" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x848" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x874", + "x875" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x873" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x850" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x876", + "x877" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x875" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x852" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x878", + "x879" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x877" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x854" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x880", + "x881" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x879" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x856" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x882", + "x883" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x881" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x858" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x884", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x860" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x886", + "x887" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x888", + "x889" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x890", + "x891" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x892", + "x893" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x894", + "x895" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x896", + "x897" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x898", + "x899" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x900", + "x901" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x902", + "x903" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x904", + "x905" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x906", + "x907" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x908", + "x909" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x910", + "x911" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x909" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x906" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x912", + "x913" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x911" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x907" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x904" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x914", + "x915" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x913" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x905" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x902" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x916", + "x917" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x915" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x903" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x900" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x918", + "x919" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x917" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x901" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x898" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x920", + "x921" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x919" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x899" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x896" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x922", + "x923" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x921" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x897" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x894" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x924", + "x925" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x895" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x892" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x926", + "x927" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x925" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x893" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x890" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x928", + "x929" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x927" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x891" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x888" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x930", + "x931" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x929" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x889" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x886" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x933" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x860" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x908" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x934", + "x935" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x933" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x862" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x910" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x936", + "x937" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x935" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x864" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x912" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x938", + "x939" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x937" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x866" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x914" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x940", + "x941" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x939" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x868" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x916" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x942", + "x943" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x941" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x870" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x918" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x944", + "x945" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x943" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x872" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x920" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x946", + "x947" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x945" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x874" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x922" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x948", + "x949" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x947" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x876" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x924" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x950", + "x951" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x949" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x878" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x926" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x952", + "x953" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x951" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x880" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x928" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x954", + "x955" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x882" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x930" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x956", + "x957" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x955" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x883" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x859" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x931" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x887" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x958", + "x959" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x934" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x960", + "x961" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x959" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x936" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x962", + "x963" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x961" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x938" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x964", + "x965" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x963" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x940" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x966", + "x967" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x965" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x942" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x968", + "x969" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x967" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x944" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x970", + "x971" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x969" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x946" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x972", + "x973" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x971" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x948" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x974", + "x975" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x973" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x950" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x976", + "x977" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x975" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x952" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x978", + "x979" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x977" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x954" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x980", + "x981" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x979" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x956" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x982", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x958" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x984", + "x985" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x986", + "x987" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x988", + "x989" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x990", + "x991" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x992", + "x993" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x994", + "x995" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x996", + "x997" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x998", + "x999" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1000", + "x1001" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1002", + "x1003" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1004", + "x1005" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1006", + "x1007" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1008", + "x1009" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1007" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1004" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1010", + "x1011" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1009" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1005" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1002" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1012", + "x1013" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1011" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1003" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1000" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1014", + "x1015" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1013" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1001" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x998" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1016", + "x1017" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1015" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x999" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x996" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1018", + "x1019" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1017" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x997" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x994" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1020", + "x1021" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1019" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x995" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x992" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1022", + "x1023" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1021" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x993" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x990" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1024", + "x1025" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1023" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x991" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x988" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1026", + "x1027" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1025" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x989" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x986" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1028", + "x1029" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1027" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x987" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x984" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1031" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x958" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1006" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1032", + "x1033" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1031" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x960" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1008" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1034", + "x1035" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1033" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x962" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1010" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1036", + "x1037" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1035" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x964" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1012" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1038", + "x1039" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1037" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x966" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1014" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1040", + "x1041" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1039" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x968" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1016" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1042", + "x1043" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1041" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x970" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1018" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1044", + "x1045" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1043" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x972" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1020" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1046", + "x1047" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1045" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x974" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1022" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1048", + "x1049" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1047" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x976" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1024" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1050", + "x1051" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1049" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x978" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1026" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1052", + "x1053" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1051" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x980" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1028" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1054", + "x1055" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1053" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x981" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x957" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1029" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x985" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1056", + "x1057" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1032" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1058", + "x1059" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1057" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1034" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1060", + "x1061" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1059" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1036" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1062", + "x1063" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1061" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1038" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1064", + "x1065" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1063" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1040" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1066", + "x1067" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1065" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1042" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1068", + "x1069" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1044" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1070", + "x1071" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1069" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1046" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1072", + "x1073" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1071" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1048" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1074", + "x1075" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1073" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1050" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1076", + "x1077" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1075" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1052" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1078", + "x1079" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1077" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1054" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1080", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1056" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1082", + "x1083" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1084", + "x1085" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1086", + "x1087" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1088", + "x1089" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1090", + "x1091" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1092", + "x1093" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1094", + "x1095" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1096", + "x1097" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1098", + "x1099" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1100", + "x1101" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1102", + "x1103" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1104", + "x1105" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1106", + "x1107" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1105" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1108", + "x1109" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1103" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1100" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1110", + "x1111" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1101" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1098" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1112", + "x1113" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1099" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1096" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1114", + "x1115" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1097" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1094" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1116", + "x1117" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1095" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1092" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1118", + "x1119" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1093" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1090" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1120", + "x1121" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1091" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1088" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1122", + "x1123" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1089" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1086" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1124", + "x1125" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1087" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1084" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1126", + "x1127" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1085" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1082" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1129" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1056" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1104" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1130", + "x1131" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1058" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1132", + "x1133" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1060" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1108" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1134", + "x1135" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1062" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1136", + "x1137" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1135" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1064" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1138", + "x1139" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1137" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1066" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1114" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1140", + "x1141" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1139" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1068" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1116" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1142", + "x1143" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1070" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1118" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1144", + "x1145" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1072" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1120" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1146", + "x1147" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1074" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1122" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1148", + "x1149" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1076" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1124" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1150", + "x1151" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1078" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1126" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1152", + "x1153" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1079" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1055" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1083" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1154", + "x1155" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1130" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1156", + "x1157" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1132" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1158", + "x1159" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1134" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1160", + "x1161" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1136" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1162", + "x1163" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1138" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1164", + "x1165" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1140" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1166", + "x1167" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1142" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1168", + "x1169" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1144" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1170", + "x1171" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1146" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1172", + "x1173" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1148" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1174", + "x1175" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1150" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1176", + "x1177" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1152" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1179" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1177" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1153" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x1180" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1154" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1130" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1181" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1156" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1132" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1182" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1134" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1183" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1160" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1136" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1184" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1162" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1138" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1185" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1140" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1186" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1142" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1187" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1144" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1188" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1146" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1189" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1148" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1190" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1150" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1191" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1152" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x1180" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x1181" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x1182" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x1183" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x1184" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x1185" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x1186" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x1187" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x1188" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x1189" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x1190" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x1191" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_to_montgomery", + "arguments": [ + { + "datatype": "u32[12]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[12]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + { + "datatype": "u32", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xc84ee01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0x2b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0x3fb05b7a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0x28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xd40d4917" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0x4aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xbc3e483a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xfcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xff3d81e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xdf1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0x2d319b24" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0x19b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "x126" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x131", + "x132" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xc84ee01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x2b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x3fb05b7a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xd40d4917" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x4aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xbc3e483a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xfcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x149", + "x150" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xff3d81e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xdf1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x2d319b24" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x19b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x167", + "x168" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x181", + "x182" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x183", + "x184" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x185", + "x186" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x189", + "x190" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x191", + "x192" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x193", + "x194" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x195", + "x196" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x205", + "x206" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x207", + "x208" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x209", + "x210" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x211", + "x212" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x213", + "x214" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x215", + "x216" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x217", + "x218" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x219", + "x220" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x221", + "x222" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "x230" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x231", + "x232" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x233", + "x234" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x235", + "x236" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x237", + "x238" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x239", + "x240" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "x242" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x243", + "x244" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x245", + "x246" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x247", + "x248" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x249", + "x250" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x252" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x253", + "x254" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x255", + "x256" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x257", + "x258" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x259", + "x260" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x261", + "x262" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x263", + "x264" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x265", + "x266" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x267", + "x268" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x269", + "x270" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x271", + "x272" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x273", + "x274" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x275", + "x276" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x277", + "x278" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xc84ee01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x279", + "x280" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x2b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x281", + "x282" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x3fb05b7a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x283", + "x284" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x285", + "x286" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xd40d4917" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x287", + "x288" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x4aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x289", + "x290" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xbc3e483a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x291", + "x292" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xfcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xff3d81e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xdf1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x297", + "x298" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x2d319b24" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x299", + "x300" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x19b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x301", + "x302" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x303", + "x304" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x305", + "x306" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x307", + "x308" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x309", + "x310" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x311", + "x312" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x313", + "x314" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x315", + "x316" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x317", + "x318" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x319", + "x320" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x321", + "x322" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x323", + "x324" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x325", + "x326" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x327", + "x328" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x329", + "x330" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x337", + "x338" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x339", + "x340" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x341", + "x342" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x343", + "x344" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x345", + "x346" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x347", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x349", + "x350" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x351", + "x352" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x353", + "x354" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x355", + "x356" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x357", + "x358" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x359", + "x360" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x361", + "x362" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x363", + "x364" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x365", + "x366" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x367", + "x368" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x369", + "x370" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x371", + "x372" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x373", + "x374" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x375", + "x376" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x377", + "x378" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "x388" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x393", + "x394" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x396" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x399", + "x400" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x401", + "x402" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x403", + "x404" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x405", + "x406" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x407", + "x408" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x409", + "x410" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x411", + "x412" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x413", + "x414" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x415", + "x416" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x417", + "x418" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x419", + "x420" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x421", + "x422" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xc84ee01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x423", + "x424" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x2b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x425", + "x426" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x3fb05b7a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x427", + "x428" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xd40d4917" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x431", + "x432" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x4aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xbc3e483a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xfcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xff3d81e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "x440" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xdf1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x2d319b24" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "x444" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x19b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x445", + "x446" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x447", + "x448" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x449", + "x450" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x451", + "x452" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x453", + "x454" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x455", + "x456" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x457", + "x458" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x459", + "x460" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x461", + "x462" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x463", + "x464" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x465", + "x466" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x467", + "x468" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x469", + "x470" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x471", + "x472" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x473", + "x474" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x475", + "x476" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x477", + "x478" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x479", + "x480" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x481", + "x482" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x483", + "x484" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x485", + "x486" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x487", + "x488" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x489", + "x490" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x491", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x493", + "x494" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x495", + "x496" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x497", + "x498" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x499", + "x500" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x501", + "x502" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x503", + "x504" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x505", + "x506" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x507", + "x508" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x509", + "x510" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x511", + "x512" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x513", + "x514" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x515", + "x516" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x517", + "x518" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x519", + "x520" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x521", + "x522" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x520" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x523", + "x524" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x507" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x525", + "x526" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x527", + "x528" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x529", + "x530" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x531", + "x532" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x533", + "x534" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x535", + "x536" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x537", + "x538" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x493" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x540" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x541", + "x542" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x540" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x543", + "x544" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x545", + "x546" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x547", + "x548" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x549", + "x550" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x551", + "x552" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x553", + "x554" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x555", + "x556" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x557", + "x558" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x559", + "x560" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x561", + "x562" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x563", + "x564" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x565", + "x566" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xc84ee01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x567", + "x568" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x2b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x569", + "x570" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x3fb05b7a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x571", + "x572" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x573", + "x574" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xd40d4917" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x575", + "x576" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x4aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x577", + "x578" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xbc3e483a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x579", + "x580" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xfcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x581", + "x582" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xff3d81e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x583", + "x584" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xdf1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x585", + "x586" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x2d319b24" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x587", + "x588" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x19b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x589", + "x590" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x591", + "x592" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x593", + "x594" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x595", + "x596" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x597", + "x598" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x580" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x577" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x599", + "x600" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x601", + "x602" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x600" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x603", + "x604" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x605", + "x606" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x607", + "x608" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x609", + "x610" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x611", + "x612" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x541" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x613", + "x614" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x615", + "x616" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x545" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x617", + "x618" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x616" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x619", + "x620" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x621", + "x622" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x551" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x623", + "x624" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x625", + "x626" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x555" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x627", + "x628" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x629", + "x630" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x631", + "x632" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x633", + "x634" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x635", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x637", + "x638" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x639", + "x640" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x641", + "x642" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x643", + "x644" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x645", + "x646" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x647", + "x648" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x649", + "x650" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x651", + "x652" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x653", + "x654" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x655", + "x656" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x657", + "x658" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x659", + "x660" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x661", + "x662" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x660" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x663", + "x664" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x662" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x665", + "x666" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x656" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x667", + "x668" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "x670" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x647" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x646" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x677", + "x678" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x681", + "x682" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x684" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x685", + "x686" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x687", + "x688" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x689", + "x690" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x665" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x691", + "x692" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x667" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x693", + "x694" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x695", + "x696" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x697", + "x698" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x699", + "x700" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x698" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x701", + "x702" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x703", + "x704" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x702" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x705", + "x706" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x707", + "x708" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x706" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x610" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x638" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x709", + "x710" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xc84ee01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x711", + "x712" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x2b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x713", + "x714" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x3fb05b7a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x715", + "x716" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x717", + "x718" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xd40d4917" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x719", + "x720" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x4aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x721", + "x722" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xbc3e483a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x723", + "x724" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xfcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x725", + "x726" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xff3d81e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x727", + "x728" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xdf1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x729", + "x730" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x2d319b24" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x731", + "x732" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x19b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x733", + "x734" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x732" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x729" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x735", + "x736" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x734" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x727" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x737", + "x738" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x736" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x739", + "x740" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x738" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x726" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x723" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x741", + "x742" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x740" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x724" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x721" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x743", + "x744" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x722" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x719" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x745", + "x746" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x744" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x720" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x717" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x747", + "x748" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x718" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x715" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x749", + "x750" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x748" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x716" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x713" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x751", + "x752" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x750" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x714" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x753", + "x754" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x752" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x712" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x755", + "x756" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x685" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x731" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x757", + "x758" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x756" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x687" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x759", + "x760" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x758" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x689" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x761", + "x762" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x760" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x691" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x763", + "x764" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x762" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x693" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x765", + "x766" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x764" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x695" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x741" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x767", + "x768" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x766" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x743" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x769", + "x770" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x768" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x745" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x771", + "x772" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x770" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x747" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x773", + "x774" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x772" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x749" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x775", + "x776" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x774" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x705" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x751" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x777", + "x778" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x776" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x707" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x753" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x779", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x755" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x781", + "x782" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x783", + "x784" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x785", + "x786" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x787", + "x788" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x789", + "x790" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x791", + "x792" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x793", + "x794" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x795", + "x796" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x797", + "x798" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x799", + "x800" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x801", + "x802" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x803", + "x804" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x779" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x805", + "x806" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x801" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x807", + "x808" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x806" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x802" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x799" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x809", + "x810" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x808" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x800" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x797" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x811", + "x812" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x810" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x798" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x795" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x813", + "x814" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x812" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x796" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x793" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x815", + "x816" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x814" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x794" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x791" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x817", + "x818" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x816" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x792" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x789" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x819", + "x820" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x818" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x790" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x787" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x821", + "x822" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x820" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x788" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x785" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x823", + "x824" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x822" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x783" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x825", + "x826" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x824" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x784" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x781" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x828" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x755" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x803" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x829", + "x830" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x828" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x757" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x805" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x831", + "x832" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x830" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x759" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x807" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x833", + "x834" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x832" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x761" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x809" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x835", + "x836" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x834" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x763" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x811" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x837", + "x838" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x836" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x765" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x813" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x839", + "x840" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x838" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x841", + "x842" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x840" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x769" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x817" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x843", + "x844" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x842" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x771" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x819" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x845", + "x846" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x844" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x773" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x821" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x847", + "x848" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x846" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x775" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x823" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x849", + "x850" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x848" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x777" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x825" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x851", + "x852" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x850" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x708" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x754" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x710" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x826" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x782" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x853", + "x854" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xc84ee01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x855", + "x856" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x2b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x857", + "x858" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x3fb05b7a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x859", + "x860" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x861", + "x862" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xd40d4917" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x863", + "x864" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x4aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x865", + "x866" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xbc3e483a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x867", + "x868" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xfcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x869", + "x870" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xff3d81e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x871", + "x872" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xdf1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x873", + "x874" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x2d319b24" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x875", + "x876" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x19b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x877", + "x878" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x876" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x873" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x879", + "x880" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x878" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x874" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x871" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x881", + "x882" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x880" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x872" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x869" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x883", + "x884" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x882" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x870" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x867" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x885", + "x886" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x884" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x868" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x865" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x887", + "x888" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x886" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x866" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x863" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x889", + "x890" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x888" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x864" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x861" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x891", + "x892" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x890" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x862" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x859" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x893", + "x894" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x892" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x860" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x857" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x895", + "x896" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x894" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x858" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x855" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x897", + "x898" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x896" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x856" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x853" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x899", + "x900" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x829" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x875" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x901", + "x902" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x900" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x831" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x877" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x903", + "x904" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x902" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x833" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x879" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x905", + "x906" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x904" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x835" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x881" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x907", + "x908" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x906" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x837" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x883" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x909", + "x910" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x908" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x839" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x885" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x911", + "x912" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x910" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x841" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x887" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x913", + "x914" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x912" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x843" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x889" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x915", + "x916" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x914" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x845" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x891" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x917", + "x918" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x916" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x847" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x893" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x919", + "x920" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x918" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x849" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x895" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x921", + "x922" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x920" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x851" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x897" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x923", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x899" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x925", + "x926" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x927", + "x928" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x929", + "x930" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x931", + "x932" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x933", + "x934" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x935", + "x936" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x937", + "x938" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x939", + "x940" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x941", + "x942" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x943", + "x944" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x945", + "x946" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x947", + "x948" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x923" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x949", + "x950" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x948" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x945" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x951", + "x952" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x950" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x946" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x943" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x953", + "x954" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x952" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x944" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x941" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x955", + "x956" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x954" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x942" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x939" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x957", + "x958" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x956" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x940" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x937" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x959", + "x960" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x958" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x938" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x935" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x961", + "x962" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x960" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x936" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x933" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x963", + "x964" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x962" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x934" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x931" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x965", + "x966" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x964" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x932" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x929" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x967", + "x968" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x966" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x930" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x927" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x969", + "x970" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x968" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x928" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x925" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x972" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x899" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x947" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x973", + "x974" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x972" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x901" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x949" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x975", + "x976" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x974" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x903" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x951" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x977", + "x978" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x976" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x905" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x953" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x979", + "x980" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x978" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x907" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x955" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x981", + "x982" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x980" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x909" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x957" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x983", + "x984" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x982" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x911" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x959" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x985", + "x986" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x984" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x913" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x961" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x987", + "x988" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x986" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x915" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x963" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x989", + "x990" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x988" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x917" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x965" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x991", + "x992" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x990" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x919" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x967" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x993", + "x994" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x992" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x921" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x969" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x995", + "x996" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x994" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x922" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x852" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x898" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x854" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x970" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x926" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x997", + "x998" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xc84ee01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x999", + "x1000" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x2b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1001", + "x1002" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x3fb05b7a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1003", + "x1004" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1005", + "x1006" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xd40d4917" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1007", + "x1008" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x4aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1009", + "x1010" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xbc3e483a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1011", + "x1012" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xfcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1013", + "x1014" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xff3d81e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1015", + "x1016" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xdf1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1017", + "x1018" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x2d319b24" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1019", + "x1020" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x19b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1021", + "x1022" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1020" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1017" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1023", + "x1024" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1022" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1018" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1015" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1025", + "x1026" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1024" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1016" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1013" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1027", + "x1028" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1026" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1014" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1011" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1029", + "x1030" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1028" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1012" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1009" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1031", + "x1032" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1030" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1010" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1007" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1033", + "x1034" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1032" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1008" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1005" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1035", + "x1036" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1034" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1006" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1003" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1037", + "x1038" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1036" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1004" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1001" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1039", + "x1040" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1038" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1002" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x999" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1041", + "x1042" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1040" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1000" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x997" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1043", + "x1044" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x973" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1019" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1045", + "x1046" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1044" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x975" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1021" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1047", + "x1048" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1046" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x977" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1023" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1049", + "x1050" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1048" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x979" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1025" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1051", + "x1052" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1050" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x981" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1027" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1053", + "x1054" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1052" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x983" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1029" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1055", + "x1056" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1054" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x985" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1031" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1057", + "x1058" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1056" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x987" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1033" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1059", + "x1060" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1058" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x989" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1035" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1061", + "x1062" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1060" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x991" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1037" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1063", + "x1064" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1062" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x993" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1039" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1065", + "x1066" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1064" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x995" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1041" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1067", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1043" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1069", + "x1070" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1071", + "x1072" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1073", + "x1074" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1075", + "x1076" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1077", + "x1078" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1079", + "x1080" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1081", + "x1082" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1083", + "x1084" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1085", + "x1086" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1087", + "x1088" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1089", + "x1090" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1091", + "x1092" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1067" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1093", + "x1094" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1092" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1089" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1095", + "x1096" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1094" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1090" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1087" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1097", + "x1098" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1096" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1088" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1085" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1099", + "x1100" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1098" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1086" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1083" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1101", + "x1102" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1084" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1081" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1103", + "x1104" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1082" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1079" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1105", + "x1106" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1080" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1077" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1107", + "x1108" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1078" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1075" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1109", + "x1110" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1076" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1073" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1111", + "x1112" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1074" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1071" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1113", + "x1114" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1072" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1069" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1116" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1043" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1091" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1117", + "x1118" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1045" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1093" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1119", + "x1120" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1047" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1095" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1121", + "x1122" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1049" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1097" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1123", + "x1124" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1051" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1099" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1125", + "x1126" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1053" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1127", + "x1128" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1055" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1129", + "x1130" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1128" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1057" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1131", + "x1132" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1130" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1059" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1107" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1133", + "x1134" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1132" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1061" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1109" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1135", + "x1136" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1134" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1063" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1111" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1137", + "x1138" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1136" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1065" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1113" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1139", + "x1140" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1138" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1066" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x996" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1042" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x998" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1070" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1141", + "x1142" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xc84ee01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1143", + "x1144" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x2b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1145", + "x1146" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x3fb05b7a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1147", + "x1148" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1149", + "x1150" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xd40d4917" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1151", + "x1152" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x4aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1153", + "x1154" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xbc3e483a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1155", + "x1156" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xfcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1157", + "x1158" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xff3d81e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1159", + "x1160" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xdf1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1161", + "x1162" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x2d319b24" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1163", + "x1164" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x19b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1165", + "x1166" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1161" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1167", + "x1168" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1162" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1159" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1169", + "x1170" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1160" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1157" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1171", + "x1172" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1155" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1173", + "x1174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1156" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1153" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1175", + "x1176" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1154" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1151" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1177", + "x1178" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1152" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1149" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1179", + "x1180" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1178" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1150" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1181", + "x1182" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1180" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1148" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1145" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1183", + "x1184" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1182" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1146" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1143" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1185", + "x1186" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1184" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1144" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1187", + "x1188" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1163" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1189", + "x1190" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1165" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1191", + "x1192" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1167" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1193", + "x1194" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1169" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1195", + "x1196" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1194" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1171" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1197", + "x1198" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1173" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1199", + "x1200" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1175" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1201", + "x1202" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1200" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1177" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1203", + "x1204" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1202" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1179" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1205", + "x1206" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1204" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1135" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1181" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1207", + "x1208" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1206" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1137" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1183" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1209", + "x1210" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1208" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1139" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1185" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1211", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1187" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1213", + "x1214" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1215", + "x1216" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1217", + "x1218" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1219", + "x1220" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1221", + "x1222" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1223", + "x1224" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1225", + "x1226" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1227", + "x1228" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1229", + "x1230" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1231", + "x1232" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1233", + "x1234" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1235", + "x1236" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1211" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1237", + "x1238" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1233" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1239", + "x1240" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1231" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1241", + "x1242" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1240" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1232" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1229" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1243", + "x1244" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1242" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1227" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1245", + "x1246" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1244" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1225" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1247", + "x1248" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1223" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1249", + "x1250" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1224" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1221" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1251", + "x1252" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1250" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1222" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1219" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1253", + "x1254" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1220" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1217" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1255", + "x1256" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1254" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1218" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1215" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1257", + "x1258" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1216" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1213" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1260" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1235" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1261", + "x1262" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1237" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1263", + "x1264" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1239" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1265", + "x1266" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1241" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1267", + "x1268" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1243" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1269", + "x1270" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1245" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1271", + "x1272" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1247" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1273", + "x1274" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1249" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1275", + "x1276" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1251" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1277", + "x1278" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1253" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1279", + "x1280" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1255" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1281", + "x1282" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1257" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1283", + "x1284" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1210" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1140" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1142" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1214" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1285", + "x1286" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xc84ee01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1287", + "x1288" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0x2b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1289", + "x1290" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0x3fb05b7a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1291", + "x1292" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0x28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1293", + "x1294" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xd40d4917" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1295", + "x1296" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0x4aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1297", + "x1298" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xbc3e483a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1299", + "x1300" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xfcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1301", + "x1302" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xff3d81e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1303", + "x1304" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xdf1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1305", + "x1306" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0x2d319b24" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1307", + "x1308" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0x19b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1309", + "x1310" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1308" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1305" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1311", + "x1312" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1310" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1306" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1303" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1313", + "x1314" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1312" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1304" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1301" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1315", + "x1316" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1314" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1302" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1299" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1317", + "x1318" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1316" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1300" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1297" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1319", + "x1320" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1318" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1295" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1321", + "x1322" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1293" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1323", + "x1324" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1294" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1291" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1325", + "x1326" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1289" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1327", + "x1328" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1326" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1287" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1329", + "x1330" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1285" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1331", + "x1332" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1307" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1333", + "x1334" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1309" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1335", + "x1336" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1311" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1337", + "x1338" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1336" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1313" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1339", + "x1340" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1315" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1341", + "x1342" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1317" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1343", + "x1344" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1342" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1319" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1345", + "x1346" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1344" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1321" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1347", + "x1348" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1323" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1349", + "x1350" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1348" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1325" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1351", + "x1352" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1350" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1327" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1353", + "x1354" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1352" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1283" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1329" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1355", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1331" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1357", + "x1358" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1359", + "x1360" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1361", + "x1362" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1363", + "x1364" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1365", + "x1366" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1367", + "x1368" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1369", + "x1370" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1371", + "x1372" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1373", + "x1374" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1375", + "x1376" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1377", + "x1378" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1379", + "x1380" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1355" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1381", + "x1382" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1377" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1383", + "x1384" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1375" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1385", + "x1386" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1373" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1387", + "x1388" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1371" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1389", + "x1390" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1372" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1369" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1391", + "x1392" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1370" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1367" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1393", + "x1394" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1392" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1368" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1365" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1395", + "x1396" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1394" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1366" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1363" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1397", + "x1398" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1364" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1361" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1399", + "x1400" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1398" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1362" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1359" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1401", + "x1402" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1400" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1360" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1357" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1404" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1379" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1405", + "x1406" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1404" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1381" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1407", + "x1408" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1406" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1383" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1409", + "x1410" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1408" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1385" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1411", + "x1412" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1410" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1387" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1413", + "x1414" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1412" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1389" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1415", + "x1416" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1414" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1391" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1417", + "x1418" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1416" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1393" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1419", + "x1420" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1395" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1421", + "x1422" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1420" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1397" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1423", + "x1424" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1422" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1399" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1425", + "x1426" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1424" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1401" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1427", + "x1428" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1426" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1354" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1284" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1330" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1286" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1402" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1358" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1429", + "x1430" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xc84ee01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1431", + "x1432" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0x2b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1433", + "x1434" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0x3fb05b7a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1435", + "x1436" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0x28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1437", + "x1438" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xd40d4917" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1439", + "x1440" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0x4aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1441", + "x1442" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xbc3e483a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1443", + "x1444" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xfcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1445", + "x1446" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xff3d81e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1447", + "x1448" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xdf1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1449", + "x1450" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0x2d319b24" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1451", + "x1452" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0x19b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1453", + "x1454" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1449" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1455", + "x1456" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1447" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1457", + "x1458" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1445" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1459", + "x1460" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1446" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1443" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1461", + "x1462" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1444" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1441" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1463", + "x1464" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1442" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1439" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1465", + "x1466" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1437" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1467", + "x1468" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1466" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1435" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1469", + "x1470" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1433" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1471", + "x1472" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1434" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1431" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1473", + "x1474" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1432" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1429" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1475", + "x1476" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1451" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1477", + "x1478" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1476" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1453" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1479", + "x1480" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1455" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1481", + "x1482" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1480" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1457" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1483", + "x1484" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1482" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1459" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1485", + "x1486" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1484" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1461" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1487", + "x1488" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1486" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1463" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1489", + "x1490" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1488" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1465" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1491", + "x1492" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1490" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1467" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1493", + "x1494" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1492" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1423" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1469" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1495", + "x1496" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1494" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1425" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1471" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1497", + "x1498" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1496" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1473" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1499", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1475" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1501", + "x1502" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1503", + "x1504" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1505", + "x1506" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1507", + "x1508" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1509", + "x1510" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1511", + "x1512" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1513", + "x1514" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1515", + "x1516" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1517", + "x1518" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1519", + "x1520" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1521", + "x1522" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1523", + "x1524" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1499" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1525", + "x1526" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1524" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1521" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1527", + "x1528" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1526" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1522" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1519" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1529", + "x1530" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1528" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1520" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1517" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1531", + "x1532" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1530" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1518" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1515" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1533", + "x1534" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1532" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1516" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1513" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1535", + "x1536" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1534" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1514" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1511" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1537", + "x1538" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1536" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1512" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1509" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1539", + "x1540" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1538" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1510" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1507" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1541", + "x1542" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1540" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1508" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1505" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1543", + "x1544" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1506" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1503" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1545", + "x1546" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1544" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1501" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1548" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1475" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1523" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1549", + "x1550" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1548" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1477" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1525" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1551", + "x1552" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1550" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1479" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1527" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1553", + "x1554" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1552" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1529" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1555", + "x1556" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1531" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1557", + "x1558" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1533" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1559", + "x1560" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1558" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1535" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1561", + "x1562" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1560" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1537" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1563", + "x1564" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1562" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1539" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1565", + "x1566" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1564" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1493" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1541" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1567", + "x1568" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1566" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1495" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1543" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1569", + "x1570" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1568" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1497" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1545" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1571", + "x1572" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1570" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1498" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1428" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1474" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1430" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1546" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1502" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1573", + "x1574" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0xc84ee01" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1575", + "x1576" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0x2b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1577", + "x1578" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0x3fb05b7a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1579", + "x1580" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0x28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1581", + "x1582" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0xd40d4917" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1583", + "x1584" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0x4aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1585", + "x1586" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0xbc3e483a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1587", + "x1588" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0xfcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1589", + "x1590" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0xff3d81e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1591", + "x1592" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0xdf1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1593", + "x1594" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0x2d319b24" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1595", + "x1596" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0x19b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1597", + "x1598" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1596" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1593" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1599", + "x1600" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1598" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1594" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1591" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1601", + "x1602" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1600" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1589" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1603", + "x1604" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1602" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1590" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1587" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1605", + "x1606" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1604" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1585" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1607", + "x1608" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1583" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1609", + "x1610" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1608" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1584" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1581" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1611", + "x1612" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1610" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1582" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1579" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1613", + "x1614" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1612" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1580" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1577" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1615", + "x1616" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1614" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1575" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1617", + "x1618" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1616" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1573" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1619", + "x1620" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1549" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1595" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1621", + "x1622" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1620" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1551" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1597" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1623", + "x1624" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1622" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1553" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1599" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1625", + "x1626" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1624" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1555" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1601" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1627", + "x1628" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1626" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1603" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1629", + "x1630" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1559" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1605" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1631", + "x1632" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1561" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1607" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1633", + "x1634" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1609" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1635", + "x1636" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1565" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1611" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1637", + "x1638" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1636" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1567" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1613" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1639", + "x1640" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1569" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1615" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1641", + "x1642" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1571" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1617" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1643", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1619" + ] + } + ] + }, + "0xe88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1645", + "x1646" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1647", + "x1648" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1649", + "x1650" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1651", + "x1652" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1653", + "x1654" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1655", + "x1656" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1657", + "x1658" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1659", + "x1660" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1661", + "x1662" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1663", + "x1664" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1665", + "x1666" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1667", + "x1668" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1643" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1669", + "x1670" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1665" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1671", + "x1672" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1666" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1663" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1673", + "x1674" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1664" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1661" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1675", + "x1676" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1662" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1659" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1677", + "x1678" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1660" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1657" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1679", + "x1680" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1658" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1655" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1681", + "x1682" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1656" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1653" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1683", + "x1684" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1654" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1651" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1685", + "x1686" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1652" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1649" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1687", + "x1688" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1650" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1647" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1689", + "x1690" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1648" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1645" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1692" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1619" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1667" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1693", + "x1694" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1621" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1669" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1695", + "x1696" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1623" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1671" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1697", + "x1698" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1696" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1625" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1673" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1699", + "x1700" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1698" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1627" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1675" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1701", + "x1702" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1629" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1677" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1703", + "x1704" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1702" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1631" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1679" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1705", + "x1706" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1704" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1633" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1681" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1707", + "x1708" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1706" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1635" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1683" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1709", + "x1710" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1708" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1685" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1711", + "x1712" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1710" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1687" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1713", + "x1714" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1712" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1689" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1715", + "x1716" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1714" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1642" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1572" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1618" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1574" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1646" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1717", + "x1718" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1693" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1719", + "x1720" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1718" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1695" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1721", + "x1722" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1720" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1697" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1723", + "x1724" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1722" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1699" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1725", + "x1726" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1724" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1701" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1727", + "x1728" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1726" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1703" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1729", + "x1730" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1728" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1705" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1731", + "x1732" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1707" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1733", + "x1734" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1732" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1709" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1735", + "x1736" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1734" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1711" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1737", + "x1738" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1736" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1713" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x1739", + "x1740" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1738" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1715" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x1742" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1740" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1716" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x1743" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1717" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1693" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1744" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1719" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1695" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1745" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1721" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1697" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1746" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1723" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1699" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1747" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1725" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1701" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1748" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1727" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1703" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1749" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1729" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1705" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1750" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1731" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1707" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1751" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1733" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1709" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1752" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1735" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1711" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1753" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1737" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1713" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x1754" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1739" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1715" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x1743" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x1744" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x1745" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x1746" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x1747" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x1748" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x1749" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x1750" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x1751" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x1752" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x1753" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x1754" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_nonzero", + "arguments": [ + { + "datatype": "u32[12]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_selectznz", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32[12]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[12]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[12]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[8]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[9]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[10]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x12" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[11]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_to_bytes", + "arguments": [ + { + "datatype": "u32[12]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u8[48]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u8", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x57" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x58" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x59" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x60" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x61" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x62" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x63" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x64" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x65" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x66" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x67" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x68" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x69" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x70" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x71" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x72" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x73" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x74" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x75" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x76" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x77" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x78" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x79" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x80" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x81" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x82" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x83" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x84" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[12]" + ], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[13]" + ], + "operation": "static_cast", + "arguments": [ + "x33" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[14]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[15]" + ], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[16]" + ], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[17]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[18]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[19]" + ], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[20]" + ], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[21]" + ], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[22]" + ], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[23]" + ], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[24]" + ], + "operation": "static_cast", + "arguments": [ + "x49" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[25]" + ], + "operation": "static_cast", + "arguments": [ + "x51" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[26]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[27]" + ], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[28]" + ], + "operation": "static_cast", + "arguments": [ + "x55" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[29]" + ], + "operation": "static_cast", + "arguments": [ + "x57" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[30]" + ], + "operation": "static_cast", + "arguments": [ + "x59" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[31]" + ], + "operation": "static_cast", + "arguments": [ + "x60" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[32]" + ], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[33]" + ], + "operation": "static_cast", + "arguments": [ + "x63" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[34]" + ], + "operation": "static_cast", + "arguments": [ + "x65" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[35]" + ], + "operation": "static_cast", + "arguments": [ + "x66" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[36]" + ], + "operation": "static_cast", + "arguments": [ + "x67" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[37]" + ], + "operation": "static_cast", + "arguments": [ + "x69" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[38]" + ], + "operation": "static_cast", + "arguments": [ + "x71" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[39]" + ], + "operation": "static_cast", + "arguments": [ + "x72" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[40]" + ], + "operation": "static_cast", + "arguments": [ + "x73" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[41]" + ], + "operation": "static_cast", + "arguments": [ + "x75" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[42]" + ], + "operation": "static_cast", + "arguments": [ + "x77" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[43]" + ], + "operation": "static_cast", + "arguments": [ + "x78" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[44]" + ], + "operation": "static_cast", + "arguments": [ + "x79" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[45]" + ], + "operation": "static_cast", + "arguments": [ + "x81" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[46]" + ], + "operation": "static_cast", + "arguments": [ + "x83" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[47]" + ], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_from_bytes", + "arguments": [ + { + "datatype": "u8[48]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff" + ] + } + ], + "returns": [ + { + "datatype": "u32[12]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[47]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[46]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[45]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[44]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[43]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[42]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[41]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[40]" + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[39]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[38]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[37]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + "arg1[36]" + ] + }, + { + "datatype": "u32", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[35]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[34]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[33]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + "arg1[32]" + ] + }, + { + "datatype": "u32", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[31]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[30]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[29]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + "arg1[28]" + ] + }, + { + "datatype": "u32", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[27]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[26]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[25]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + "arg1[24]" + ] + }, + { + "datatype": "u32", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[23]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[22]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[21]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + "arg1[20]" + ] + }, + { + "datatype": "u32", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[19]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[18]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[17]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + "arg1[16]" + ] + }, + { + "datatype": "u32", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[15]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[14]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[13]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + "arg1[12]" + ] + }, + { + "datatype": "u32", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u32", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x57" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x58" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x59" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x60" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x61" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x62" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x63" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x64" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x65" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x66" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x67" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x68" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x69" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x70" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x71" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x72" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x73" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x74" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x75" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x76" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x77" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x78" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x79" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x80" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x81" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x82" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x83" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x84" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x51" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x57" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x60" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x63" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x66" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x69" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x72" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x75" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x78" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x81" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_set_one", + "arguments": [], + "returns": [ + { + "datatype": "u32[12]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0x333ad68d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x1313e695" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xb74f5885" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xa7e5f24d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0xbc8d220" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0x389cb27e" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[8]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[9]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[10]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[11]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_msat", + "arguments": [], + "returns": [ + { + "datatype": "u32[13]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[8]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[9]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[10]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[11]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[12]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_divstep", + "arguments": [ + { + "datatype": "u32", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32[13]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[13]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[12]", + "name": "arg4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[12]", + "name": "arg5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32[13]", + "name": "out2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[13]", + "name": "out3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[12]", + "name": "out4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[12]", + "name": "out5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "31" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + "0x1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x12" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x13" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x14" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x15" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[8]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x16" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[9]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x17" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[10]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x18" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[11]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x19" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[12]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[12]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + "0x1", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "x37" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[9]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[10]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[11]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[12]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x46" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x47" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x48" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x49" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x50" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x51" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x52" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x53" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x54" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x55" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[9]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x56" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[10]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x57" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[11]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x58" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[12]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x59" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x60" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x61" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x62" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x63" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[4]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x64" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[5]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x65" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[6]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x66" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x67" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[8]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x68" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[9]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[9]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x69" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[10]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[10]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x70" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[11]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[11]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x120" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x121" + ], + "operation": "static_cast", + "arguments": [ + "arg4[11]" + ] + }, + { + "datatype": "u32", + "name": [ + "x122" + ], + "operation": "static_cast", + "arguments": [ + "arg4[10]" + ] + }, + { + "datatype": "u32", + "name": [ + "x123" + ], + "operation": "static_cast", + "arguments": [ + "arg4[9]" + ] + }, + { + "datatype": "u32", + "name": [ + "x124" + ], + "operation": "static_cast", + "arguments": [ + "arg4[8]" + ] + }, + { + "datatype": "u32", + "name": [ + "x125" + ], + "operation": "static_cast", + "arguments": [ + "arg4[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x126" + ], + "operation": "static_cast", + "arguments": [ + "arg4[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x127" + ], + "operation": "static_cast", + "arguments": [ + "arg4[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x128" + ], + "operation": "static_cast", + "arguments": [ + "arg4[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x129" + ], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x130" + ], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x131" + ], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x132" + ], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x149", + "x150" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x157" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + "0x0", + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + }, + "0xccc52973" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "x161" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + }, + "0xecec196a" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + }, + "0x48b0a77a" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + }, + "0x581a0db2" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + }, + "0xf4372ddf" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + }, + "0xc7634d81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x182" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x183" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x184" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x185" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x186" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x187" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x188" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x189" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x190" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x191" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[9]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x192" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[10]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x193" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[11]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x194" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + "0x1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x195" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x196" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x197" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x198" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x199" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x200" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x201" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x202" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x203" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x204" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x205" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x206" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x207" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x214", + "x215" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x218", + "x219" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x220", + "x221" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x222", + "x223" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x224", + "x225" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x226", + "x227" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x228", + "x229" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x230", + "x231" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x232", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x234" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x235" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x236" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x237" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x238" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x239" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x240" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x241" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x242" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x243" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x244" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x245" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x246", + "x247" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x250", + "x251" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x252", + "x253" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x254", + "x255" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x256", + "x257" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x258", + "x259" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x260", + "x261" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x262", + "x263" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x264", + "x265" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x266", + "x267" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x268", + "x269" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x270", + "x271" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + "0xccc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x272", + "x273" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + "0xecec196a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x274", + "x275" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + "0x48b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x276", + "x277" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + "0x581a0db2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x278", + "x279" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + "0xf4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x280", + "x281" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + "0xc7634d81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x282", + "x283" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x284", + "x285" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x286", + "x287" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x288", + "x289" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x290", + "x291" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x292", + "x293" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x295" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x296", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x1" + ] + }, + { + "datatype": "u32", + "name": [ + "x298" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x299" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x300" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x301" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x302" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x303" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x304" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x305" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x306" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x307" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x308" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x309" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x310" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + "0x80000000" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + "1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x311" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x312" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x313" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x314" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x315" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x316" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x317" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x318" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x319" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x320" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x321" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x322" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x323" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x324" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x325" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x326" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x327" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x328" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x329" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x330" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x331" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x332" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x333" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x334" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out2[0]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[1]" + ], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[2]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[3]" + ], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[4]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[5]" + ], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[6]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[7]" + ], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[8]" + ], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[9]" + ], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[10]" + ], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[11]" + ], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[12]" + ], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[0]" + ], + "operation": "static_cast", + "arguments": [ + "x298" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[1]" + ], + "operation": "static_cast", + "arguments": [ + "x299" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[2]" + ], + "operation": "static_cast", + "arguments": [ + "x300" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[3]" + ], + "operation": "static_cast", + "arguments": [ + "x301" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[4]" + ], + "operation": "static_cast", + "arguments": [ + "x302" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[5]" + ], + "operation": "static_cast", + "arguments": [ + "x303" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[6]" + ], + "operation": "static_cast", + "arguments": [ + "x304" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[7]" + ], + "operation": "static_cast", + "arguments": [ + "x305" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[8]" + ], + "operation": "static_cast", + "arguments": [ + "x306" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[9]" + ], + "operation": "static_cast", + "arguments": [ + "x307" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[10]" + ], + "operation": "static_cast", + "arguments": [ + "x308" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[11]" + ], + "operation": "static_cast", + "arguments": [ + "x309" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[12]" + ], + "operation": "static_cast", + "arguments": [ + "x310" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[0]" + ], + "operation": "static_cast", + "arguments": [ + "x311" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[1]" + ], + "operation": "static_cast", + "arguments": [ + "x312" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[2]" + ], + "operation": "static_cast", + "arguments": [ + "x313" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[3]" + ], + "operation": "static_cast", + "arguments": [ + "x314" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[4]" + ], + "operation": "static_cast", + "arguments": [ + "x315" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[5]" + ], + "operation": "static_cast", + "arguments": [ + "x316" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[6]" + ], + "operation": "static_cast", + "arguments": [ + "x317" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[7]" + ], + "operation": "static_cast", + "arguments": [ + "x318" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[8]" + ], + "operation": "static_cast", + "arguments": [ + "x319" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[9]" + ], + "operation": "static_cast", + "arguments": [ + "x320" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[10]" + ], + "operation": "static_cast", + "arguments": [ + "x321" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[11]" + ], + "operation": "static_cast", + "arguments": [ + "x322" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[0]" + ], + "operation": "static_cast", + "arguments": [ + "x323" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[1]" + ], + "operation": "static_cast", + "arguments": [ + "x324" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[2]" + ], + "operation": "static_cast", + "arguments": [ + "x325" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[3]" + ], + "operation": "static_cast", + "arguments": [ + "x326" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[4]" + ], + "operation": "static_cast", + "arguments": [ + "x327" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[5]" + ], + "operation": "static_cast", + "arguments": [ + "x328" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[6]" + ], + "operation": "static_cast", + "arguments": [ + "x329" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[7]" + ], + "operation": "static_cast", + "arguments": [ + "x330" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[8]" + ], + "operation": "static_cast", + "arguments": [ + "x331" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[9]" + ], + "operation": "static_cast", + "arguments": [ + "x332" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[10]" + ], + "operation": "static_cast", + "arguments": [ + "x333" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[11]" + ], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_divstep_precomp", + "arguments": [], + "returns": [ + { + "datatype": "u32[12]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xe6045b6a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x49589ae0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x870040ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x3c9a5352" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x977dc242" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0xdacb097e" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0xd1ecbe36" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0xb5ab30a6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[8]" + ], + "operation": "=", + "arguments": [ + "0x1f959973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[9]" + ], + "operation": "=", + "arguments": [ + "0x97d7a108" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[10]" + ], + "operation": "=", + "arguments": [ + "0xd27192bc" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[11]" + ], + "operation": "=", + "arguments": [ + "0x2ba012f8" + ] + } + ] + } +] diff --git a/fiat-json/src/p384_scalar_64.json b/fiat-json/src/p384_scalar_64.json new file mode 100644 index 0000000000..32b3834af2 --- /dev/null +++ b/fiat-json/src/p384_scalar_64.json @@ -0,0 +1,55884 @@ +[ + { + "operation": "fiat_p384_scalar_addcarryx_u64", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "u128", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_subborrowx_u64", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "i128", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "i1", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_mulx_u64", + "arguments": [ + { + "datatype": "u64", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "out2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "body": [ + { + "datatype": "u128", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "*", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_cmovznz_u64", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "body": [ + { + "datatype": "u1", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_mul", + "arguments": [ + { + "datatype": "u64[6]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[6]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[6]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u64", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "x37" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "x53" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x91" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x130" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x132" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x145" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "x161" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x168" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x181", + "x182" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x183", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x185", + "x186" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x189", + "x190" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x191", + "x192" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x193", + "x194" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x195", + "x196" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "x204" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x205", + "x206" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x207" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x209" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x214", + "x215" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x218", + "x219" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x220", + "x221" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x222" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "x230" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x231", + "x232" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x233", + "x234" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x235", + "x236" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x237", + "x238" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x239", + "x240" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "x242" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x243", + "x244" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x245" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x246", + "x247" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x250", + "x251" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x252", + "x253" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x254", + "x255" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x256", + "x257" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x258", + "x259" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x260", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x262", + "x263" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x264", + "x265" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x266", + "x267" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x268", + "x269" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x270", + "x271" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x272", + "x273" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x274", + "x275" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x276", + "x277" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x278", + "x279" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x280", + "x281" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x282", + "x283" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x284" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x286" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x287", + "x288" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x289", + "x290" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x291", + "x292" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x297", + "x298" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x299" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x300", + "x301" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x302", + "x303" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x304", + "x305" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x306", + "x307" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x308", + "x309" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x310", + "x311" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x312", + "x313" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x316", + "x317" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x318", + "x319" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x320", + "x321" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x322" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x323", + "x324" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x325", + "x326" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x327", + "x328" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x329", + "x330" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x337", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x339", + "x340" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x341", + "x342" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x343", + "x344" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x345", + "x346" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x347", + "x348" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x349", + "x350" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x351", + "x352" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x353", + "x354" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x355", + "x356" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x357", + "x358" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x359", + "x360" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x361" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x363" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x364", + "x365" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x366", + "x367" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x368", + "x369" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x370", + "x371" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x372", + "x373" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x374", + "x375" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x376" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x377", + "x378" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "x388" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x393", + "x394" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x395", + "x396" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x399" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x400", + "x401" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x402", + "x403" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x404", + "x405" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x406", + "x407" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x408", + "x409" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x410", + "x411" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x412", + "x413" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x414", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x416", + "x417" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x418", + "x419" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x420", + "x421" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x422", + "x423" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x424", + "x425" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x426", + "x427" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x428", + "x429" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x430", + "x431" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x432", + "x433" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x434", + "x435" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x436", + "x437" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x438" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x440" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "x444" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x445", + "x446" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x447", + "x448" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x449", + "x450" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x451", + "x452" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x453" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x454", + "x455" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x456", + "x457" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x458", + "x459" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x460", + "x461" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x462", + "x463" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x464", + "x465" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x467" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x468" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x469" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x470" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x471" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x472" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x473" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x468" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x469" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x470" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x471" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x472" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_square", + "arguments": [ + { + "datatype": "u64[6]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[6]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u64", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "x37" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "x53" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x91" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x130" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x132" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x145" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "x161" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x168" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x181", + "x182" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x183", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x185", + "x186" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x189", + "x190" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x191", + "x192" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x193", + "x194" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x195", + "x196" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "x204" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x205", + "x206" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x207" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x209" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x214", + "x215" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x218", + "x219" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x220", + "x221" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x222" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "x230" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x231", + "x232" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x233", + "x234" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x235", + "x236" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x237", + "x238" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x239", + "x240" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "x242" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x243", + "x244" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x245" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x246", + "x247" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x250", + "x251" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x252", + "x253" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x254", + "x255" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x256", + "x257" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x258", + "x259" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x260", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x262", + "x263" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x264", + "x265" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x266", + "x267" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x268", + "x269" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x270", + "x271" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x272", + "x273" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x274", + "x275" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x276", + "x277" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x278", + "x279" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x280", + "x281" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x282", + "x283" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x284" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x286" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x287", + "x288" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x289", + "x290" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x291", + "x292" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x297", + "x298" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x299" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x300", + "x301" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x302", + "x303" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x304", + "x305" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x306", + "x307" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x308", + "x309" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x310", + "x311" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x312", + "x313" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x316", + "x317" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x318", + "x319" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x320", + "x321" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x322" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x323", + "x324" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x325", + "x326" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x327", + "x328" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x329", + "x330" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x337", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x339", + "x340" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x341", + "x342" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x343", + "x344" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x345", + "x346" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x347", + "x348" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x349", + "x350" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x351", + "x352" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x353", + "x354" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x355", + "x356" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x357", + "x358" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x359", + "x360" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x361" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x363" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x364", + "x365" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x366", + "x367" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x368", + "x369" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x370", + "x371" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x372", + "x373" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x374", + "x375" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x376" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x377", + "x378" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "x388" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x393", + "x394" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x395", + "x396" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x399" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x400", + "x401" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x402", + "x403" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x404", + "x405" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x406", + "x407" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x408", + "x409" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x410", + "x411" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x412", + "x413" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x414", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x416", + "x417" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x418", + "x419" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x420", + "x421" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x422", + "x423" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x424", + "x425" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x426", + "x427" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x428", + "x429" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x430", + "x431" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x432", + "x433" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x434", + "x435" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x436", + "x437" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x438" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x440" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "x444" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x445", + "x446" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x447", + "x448" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x449", + "x450" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x451", + "x452" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x453" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x454", + "x455" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x456", + "x457" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x458", + "x459" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x460", + "x461" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x462", + "x463" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x464", + "x465" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x467" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x468" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x469" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x470" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x471" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x472" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x473" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x468" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x469" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x470" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x471" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x472" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_add", + "arguments": [ + { + "datatype": "u64[6]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[6]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[6]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x26" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x27" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x29" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x31" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x32" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_sub", + "arguments": [ + { + "datatype": "u64[6]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[6]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[6]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x13" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + "0x0", + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + "0xecec196accc52973" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + "0x581a0db248b0a77a" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + "0xc7634d81f4372ddf" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_opp", + "arguments": [ + { + "datatype": "u64[6]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[6]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x13" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + "0x0", + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + "0xecec196accc52973" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + "0x581a0db248b0a77a" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + "0xc7634d81f4372ddf" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_from_montgomery", + "arguments": [ + { + "datatype": "u64[6]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[6]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x2", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "x5" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x6", + "x7" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x8", + "x9" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "x37" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x77" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "x135" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x138", + "x139" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x140", + "x141" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x142", + "x143" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "x161" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x214", + "x215" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x218", + "x219" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x220", + "x221" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x222", + "x223" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x224", + "x225" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x227" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x228", + "x229" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x230", + "x231" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x232", + "x233" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x234", + "x235" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x236", + "x237" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x238", + "x239" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x240", + "x241" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x242", + "x243" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x244", + "x245" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x246", + "x247" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x250", + "x251" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x252", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x254", + "x255" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x256", + "x257" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x258", + "x259" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x260", + "x261" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x262", + "x263" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x264", + "x265" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x266", + "x267" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x268", + "x269" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x270", + "x271" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x272", + "x273" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x274", + "x275" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x277" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x278", + "x279" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x280", + "x281" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x282", + "x283" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x284", + "x285" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x286", + "x287" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x288", + "x289" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x290", + "x291" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x292", + "x293" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x294", + "x295" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x296", + "x297" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x298", + "x299" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x300", + "x301" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x303" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x304" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x305" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x306" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x307" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x308" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x309" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x304" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x305" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x306" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x307" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x308" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_to_montgomery", + "arguments": [ + { + "datatype": "u64[6]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[6]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u64", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xc84ee012b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x3fb05b7a28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xd40d49174aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xbc3e483afcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xff3d81e5df1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x2d319b2419b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xc84ee012b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x3fb05b7a28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xd40d49174aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xbc3e483afcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xff3d81e5df1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x2d319b2419b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x126" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x131", + "x132" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xc84ee012b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x3fb05b7a28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xd40d49174aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xbc3e483afcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xff3d81e5df1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x149", + "x150" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x2d319b2419b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x167", + "x168" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x181", + "x182" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x183", + "x184" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x185", + "x186" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x189", + "x190" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x191", + "x192" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x193", + "x194" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x195", + "x196" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x198" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "x204" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x205", + "x206" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x207", + "x208" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x209", + "x210" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x211", + "x212" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xc84ee012b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x213", + "x214" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x3fb05b7a28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x215", + "x216" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xd40d49174aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x217", + "x218" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xbc3e483afcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x219", + "x220" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xff3d81e5df1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x221", + "x222" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x2d319b2419b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "x230" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x231", + "x232" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x233", + "x234" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x235", + "x236" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x237", + "x238" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x239", + "x240" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "x242" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x243", + "x244" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x245", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x247", + "x248" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x249", + "x250" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x251", + "x252" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x253", + "x254" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x255", + "x256" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x257", + "x258" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x259", + "x260" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x261", + "x262" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x263", + "x264" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x265", + "x266" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x267", + "x268" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x270" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x271", + "x272" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x273", + "x274" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x275", + "x276" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x277", + "x278" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x279", + "x280" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x281", + "x282" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x283", + "x284" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xc84ee012b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x285", + "x286" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x3fb05b7a28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x287", + "x288" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xd40d49174aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x289", + "x290" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xbc3e483afcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x291", + "x292" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xff3d81e5df1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x2d319b2419b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x297", + "x298" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x299", + "x300" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x301", + "x302" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x303", + "x304" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x305", + "x306" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x307", + "x308" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x309", + "x310" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x311", + "x312" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x313", + "x314" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x315", + "x316" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x317", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x319", + "x320" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x321", + "x322" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x323", + "x324" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x325", + "x326" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x327", + "x328" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x329", + "x330" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x337", + "x338" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x339", + "x340" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x342" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x343", + "x344" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x345", + "x346" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x347", + "x348" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x349", + "x350" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x351", + "x352" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x353", + "x354" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x355", + "x356" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xc84ee012b39bf21" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x357", + "x358" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x3fb05b7a28266895" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x359", + "x360" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xd40d49174aab1cc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x361", + "x362" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xbc3e483afcb82947" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x363", + "x364" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xff3d81e5df1aa419" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x365", + "x366" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x2d319b2419b409a9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x367", + "x368" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x369", + "x370" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x371", + "x372" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x373", + "x374" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x375", + "x376" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x377", + "x378" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "x388" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + }, + "0x6ed46089e88fdc45" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x393", + "x394" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x395", + "x396" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x399", + "x400" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x401", + "x402" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x403", + "x404" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x405", + "x406" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x407", + "x408" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x409", + "x410" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x411", + "x412" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x414" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x415", + "x416" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x417", + "x418" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x419", + "x420" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x421", + "x422" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x423", + "x424" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x425", + "x426" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x427", + "x428" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x431", + "x432" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x440" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x441" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x442" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x443" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x444" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x445" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x446" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x441" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x442" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x443" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x444" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x445" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_nonzero", + "arguments": [ + { + "datatype": "u64[6]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_selectznz", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64[6]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[6]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[6]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x5" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_to_bytes", + "arguments": [ + { + "datatype": "u64[6]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u8[48]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u8", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x57" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x58" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x59" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x60" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x61" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x62" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x63" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x64" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x65" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x66" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x67" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x68" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x69" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x70" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x71" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x72" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x73" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x74" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x75" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x76" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x77" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x78" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x79" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x80" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x81" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x82" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x83" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x84" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x85" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x86" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x87" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x88" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x89" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x90" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[12]" + ], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[13]" + ], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[14]" + ], + "operation": "static_cast", + "arguments": [ + "x33" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[15]" + ], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[16]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[17]" + ], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[18]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[19]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[20]" + ], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[21]" + ], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[22]" + ], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[23]" + ], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[24]" + ], + "operation": "static_cast", + "arguments": [ + "x49" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[25]" + ], + "operation": "static_cast", + "arguments": [ + "x51" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[26]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[27]" + ], + "operation": "static_cast", + "arguments": [ + "x55" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[28]" + ], + "operation": "static_cast", + "arguments": [ + "x57" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[29]" + ], + "operation": "static_cast", + "arguments": [ + "x59" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[30]" + ], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[31]" + ], + "operation": "static_cast", + "arguments": [ + "x62" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[32]" + ], + "operation": "static_cast", + "arguments": [ + "x63" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[33]" + ], + "operation": "static_cast", + "arguments": [ + "x65" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[34]" + ], + "operation": "static_cast", + "arguments": [ + "x67" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[35]" + ], + "operation": "static_cast", + "arguments": [ + "x69" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[36]" + ], + "operation": "static_cast", + "arguments": [ + "x71" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[37]" + ], + "operation": "static_cast", + "arguments": [ + "x73" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[38]" + ], + "operation": "static_cast", + "arguments": [ + "x75" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[39]" + ], + "operation": "static_cast", + "arguments": [ + "x76" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[40]" + ], + "operation": "static_cast", + "arguments": [ + "x77" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[41]" + ], + "operation": "static_cast", + "arguments": [ + "x79" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[42]" + ], + "operation": "static_cast", + "arguments": [ + "x81" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[43]" + ], + "operation": "static_cast", + "arguments": [ + "x83" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[44]" + ], + "operation": "static_cast", + "arguments": [ + "x85" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[45]" + ], + "operation": "static_cast", + "arguments": [ + "x87" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[46]" + ], + "operation": "static_cast", + "arguments": [ + "x89" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[47]" + ], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_from_bytes", + "arguments": [ + { + "datatype": "u8[48]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff" + ] + } + ], + "returns": [ + { + "datatype": "u64[6]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[47]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[46]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[45]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[44]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[43]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[42]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[41]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[40]" + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[39]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[38]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[37]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[36]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[35]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[34]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[33]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + "arg1[32]" + ] + }, + { + "datatype": "u64", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[31]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[30]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[29]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[28]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[27]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[26]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[25]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + "arg1[24]" + ] + }, + { + "datatype": "u64", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[23]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[22]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[21]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[20]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[19]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[18]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[17]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + "arg1[16]" + ] + }, + { + "datatype": "u64", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[15]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[14]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[13]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[12]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u64", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x57" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x58" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x59" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x60" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x61" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x62" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x63" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x64" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x65" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x66" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x67" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x68" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x69" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x70" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x71" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x72" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x73" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x74" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x75" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x76" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x77" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x78" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x79" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x80" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x81" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x82" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x83" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x84" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x85" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x86" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x87" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x88" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x89" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x90" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x55" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x62" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x69" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x76" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x83" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_set_one", + "arguments": [], + "returns": [ + { + "datatype": "u64[6]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0x1313e695333ad68d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xa7e5f24db74f5885" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x389cb27e0bc8d220" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_msat", + "arguments": [], + "returns": [ + { + "datatype": "u64[7]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_divstep", + "arguments": [ + { + "datatype": "u64", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64[7]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[7]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[6]", + "name": "arg4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[6]", + "name": "arg5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64[7]", + "name": "out2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[7]", + "name": "out3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[6]", + "name": "out4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[6]", + "name": "out5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "63" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + "0x1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x7" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x8" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x10" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x11" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x12" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x13" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + "0x1", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x29" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x31" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x32" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x33" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x34" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x35" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x37" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x38" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x39" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[4]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x40" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[5]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x66" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x67" + ], + "operation": "static_cast", + "arguments": [ + "arg4[5]" + ] + }, + { + "datatype": "u64", + "name": [ + "x68" + ], + "operation": "static_cast", + "arguments": [ + "arg4[4]" + ] + }, + { + "datatype": "u64", + "name": [ + "x69" + ], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x70" + ], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x71" + ], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x72" + ], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x85" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + "0x0", + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + }, + "0xecec196accc52973" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + }, + "0x581a0db248b0a77a" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + }, + "0xc7634d81f4372ddf" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x98" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x99" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x100" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x101" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x102" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x103" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[5]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x104" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "0x1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x105" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x106" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x107" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x108" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x109" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x110" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x111" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x126" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x127" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x128" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x129" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x130" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x131" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "x135" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x138", + "x139" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x140", + "x141" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x142", + "x143" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + "0xecec196accc52973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0x581a0db248b0a77a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + "0xc7634d81f4372ddf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x157" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x1" + ] + }, + { + "datatype": "u64", + "name": [ + "x160" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x161" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x162" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x163" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x164" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x165" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x166" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + "0x8000000000000000" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + "1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x167" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x168" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x169" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x170" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x171" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x172" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x173" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x174" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x175" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x176" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x177" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x178" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out2[0]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[1]" + ], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[2]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[3]" + ], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[4]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[5]" + ], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[6]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[0]" + ], + "operation": "static_cast", + "arguments": [ + "x160" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[1]" + ], + "operation": "static_cast", + "arguments": [ + "x161" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[2]" + ], + "operation": "static_cast", + "arguments": [ + "x162" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[3]" + ], + "operation": "static_cast", + "arguments": [ + "x163" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[4]" + ], + "operation": "static_cast", + "arguments": [ + "x164" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[5]" + ], + "operation": "static_cast", + "arguments": [ + "x165" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[6]" + ], + "operation": "static_cast", + "arguments": [ + "x166" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[0]" + ], + "operation": "static_cast", + "arguments": [ + "x167" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[1]" + ], + "operation": "static_cast", + "arguments": [ + "x168" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[2]" + ], + "operation": "static_cast", + "arguments": [ + "x169" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[3]" + ], + "operation": "static_cast", + "arguments": [ + "x170" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[4]" + ], + "operation": "static_cast", + "arguments": [ + "x171" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[5]" + ], + "operation": "static_cast", + "arguments": [ + "x172" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[0]" + ], + "operation": "static_cast", + "arguments": [ + "x173" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[1]" + ], + "operation": "static_cast", + "arguments": [ + "x174" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[2]" + ], + "operation": "static_cast", + "arguments": [ + "x175" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[3]" + ], + "operation": "static_cast", + "arguments": [ + "x176" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[4]" + ], + "operation": "static_cast", + "arguments": [ + "x177" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[5]" + ], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "operation": "fiat_p384_scalar_divstep_precomp", + "arguments": [], + "returns": [ + { + "datatype": "u64[6]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0x49589ae0e6045b6a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x3c9a5352870040ed" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xdacb097e977dc242" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xb5ab30a6d1ecbe36" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x97d7a1081f959973" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0x2ba012f8d27192bc" + ] + } + ] + } +] diff --git a/fiat-json/src/secp256k1_scalar_32.json b/fiat-json/src/secp256k1_scalar_32.json new file mode 100644 index 0000000000..d9841a29b2 --- /dev/null +++ b/fiat-json/src/secp256k1_scalar_32.json @@ -0,0 +1,86988 @@ +[ + { + "operation": "fiat_secp256k1_scalar_addcarryx_u32", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_subborrowx_u32", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "i64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "i1", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_mulx_u32", + "arguments": [ + { + "datatype": "u32", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "out2", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "*", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_cmovznz_u32", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "body": [ + { + "datatype": "u1", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + "0xffffffff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_mul", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "x53" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x72" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x74" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x121" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "x135" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x138", + "x139" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x140", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x142", + "x143" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "x161" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x172" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x181", + "x182" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x183", + "x184" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x185", + "x186" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x189", + "x190" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x191" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "x203" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x214", + "x215" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x218", + "x219" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x220", + "x221" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x222" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "x230" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x231", + "x232" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x233", + "x234" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x235", + "x236" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x237", + "x238" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x239", + "x240" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x243", + "x244" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x245", + "x246" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x247", + "x248" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x249", + "x250" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x251", + "x252" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x253", + "x254" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x255", + "x256" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x257", + "x258" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x259", + "x260" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x261", + "x262" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x263", + "x264" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x265", + "x266" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x267", + "x268" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x269", + "x270" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x271", + "x272" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x273" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x275" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x276", + "x277" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x278", + "x279" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x280", + "x281" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x282", + "x283" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x284", + "x285" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x286", + "x287" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x288", + "x289" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x290", + "x291" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x292" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x297", + "x298" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x299", + "x300" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x301", + "x302" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x303", + "x304" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x305", + "x306" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x307", + "x308" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x309", + "x310" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x311", + "x312" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x313", + "x314" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x315", + "x316" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x317", + "x318" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x319", + "x320" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x321", + "x322" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x323" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x324", + "x325" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x326", + "x327" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x328", + "x329" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x330", + "x331" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x332", + "x333" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x334", + "x335" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x336", + "x337" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x338", + "x339" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x340", + "x341" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x342", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x344", + "x345" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x346", + "x347" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x348", + "x349" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x350", + "x351" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x352", + "x353" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x354", + "x355" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x356", + "x357" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x358", + "x359" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x360", + "x361" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x362", + "x363" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x364", + "x365" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x366", + "x367" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x368", + "x369" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x370", + "x371" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x372", + "x373" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x374" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x376" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x377", + "x378" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "x388" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x393" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x394", + "x395" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x396", + "x397" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x398", + "x399" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x400", + "x401" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x402", + "x403" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x404", + "x405" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x406", + "x407" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x408", + "x409" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x410", + "x411" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x412", + "x413" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x414", + "x415" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x416", + "x417" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x418", + "x419" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x420", + "x421" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x422", + "x423" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x424" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x425", + "x426" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x427", + "x428" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x431", + "x432" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "x440" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x445", + "x446" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x447", + "x448" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x449", + "x450" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x451", + "x452" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x453", + "x454" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x455", + "x456" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x457", + "x458" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x459", + "x460" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x461", + "x462" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x463", + "x464" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x465", + "x466" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x467", + "x468" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x469", + "x470" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x471", + "x472" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x473", + "x474" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x475" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x477" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x478", + "x479" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x480", + "x481" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x482", + "x483" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x484", + "x485" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x486", + "x487" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x488", + "x489" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x490", + "x491" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x492", + "x493" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x494" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x493" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x495", + "x496" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x497", + "x498" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x499", + "x500" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x501", + "x502" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x503", + "x504" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x505", + "x506" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x507", + "x508" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x509", + "x510" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x511", + "x512" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x507" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x513", + "x514" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x515", + "x516" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x517", + "x518" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x519", + "x520" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x521", + "x522" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x520" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x523", + "x524" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x525" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x526", + "x527" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x528", + "x529" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x530", + "x531" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x532", + "x533" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x534", + "x535" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x536", + "x537" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x538", + "x539" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x540", + "x541" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x542", + "x543" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x541" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x544", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x546", + "x547" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x548", + "x549" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x550", + "x551" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x552", + "x553" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x554", + "x555" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x556", + "x557" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x558", + "x559" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x560", + "x561" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x562", + "x563" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x564", + "x565" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x566", + "x567" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x568", + "x569" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x555" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x570", + "x571" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x572", + "x573" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x551" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x574", + "x575" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x576" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x578" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x579", + "x580" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x581", + "x582" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x580" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x583", + "x584" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x585", + "x586" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x587", + "x588" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x589", + "x590" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x591", + "x592" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x540" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x593", + "x594" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x595" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x596", + "x597" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x598", + "x599" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x600", + "x601" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x602", + "x603" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x604", + "x605" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x606", + "x607" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x608", + "x609" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x610", + "x611" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x612", + "x613" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x614", + "x615" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x616", + "x617" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x618", + "x619" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x620", + "x621" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x600" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x622", + "x623" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x624", + "x625" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x626" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x627", + "x628" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x610" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x629", + "x630" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x631", + "x632" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x633", + "x634" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x616" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x635", + "x636" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x637", + "x638" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x636" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x639", + "x640" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x641", + "x642" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x643", + "x644" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x645", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x647", + "x648" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x649", + "x650" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x651", + "x652" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x653", + "x654" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x655", + "x656" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x657", + "x658" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x659", + "x660" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x661", + "x662" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x663", + "x664" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x662" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x665", + "x666" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x660" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x667", + "x668" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "x670" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x656" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x647" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x677" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x679" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x680", + "x681" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x682", + "x683" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x665" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x684", + "x685" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x667" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x686", + "x687" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x685" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x688", + "x689" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x687" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x690", + "x691" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x689" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x692", + "x693" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x691" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x694", + "x695" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x693" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x696" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x695" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x697", + "x698" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x699", + "x700" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x701", + "x702" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x703", + "x704" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x705", + "x706" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x707", + "x708" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x709", + "x710" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x711", + "x712" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x713", + "x714" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x712" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x715", + "x716" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x714" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x710" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x707" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x717", + "x718" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x716" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x708" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x705" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x719", + "x720" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x718" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x706" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x721", + "x722" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x720" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x723", + "x724" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x722" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x702" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x725", + "x726" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x724" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x727" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x726" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x698" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x728", + "x729" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x730", + "x731" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x729" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x713" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x732", + "x733" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x731" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x715" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x734", + "x735" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x717" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x736", + "x737" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x719" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x738", + "x739" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x721" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x740", + "x741" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x723" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x742", + "x743" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x741" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x744", + "x745" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x743" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x727" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x746", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x748", + "x749" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x750", + "x751" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x752", + "x753" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x754", + "x755" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x756", + "x757" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x758", + "x759" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x760", + "x761" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x762", + "x763" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x764", + "x765" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x763" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x760" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x766", + "x767" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x765" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x761" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x758" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x768", + "x769" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x759" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x756" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x770", + "x771" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x769" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x757" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x754" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x772", + "x773" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x771" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x755" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x752" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x774", + "x775" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x773" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x753" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x750" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x776", + "x777" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x775" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x751" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x748" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x778" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x777" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x749" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x780" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x762" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x781", + "x782" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x780" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x764" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x783", + "x784" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x782" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x732" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x766" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x785", + "x786" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x784" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x734" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x768" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x787", + "x788" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x736" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x770" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x789", + "x790" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x788" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x738" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x772" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x791", + "x792" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x790" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x740" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x774" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x793", + "x794" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x792" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x776" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x795", + "x796" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x794" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x744" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x797" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x796" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x745" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x798", + "x799" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x781" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x800", + "x801" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x783" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x802", + "x803" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x801" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x785" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x804", + "x805" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x803" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x787" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x806", + "x807" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x805" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x789" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x808", + "x809" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x807" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x791" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x810", + "x811" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x809" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x793" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x812", + "x813" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x811" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x795" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x815" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x813" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x797" + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x816" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x798" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x781" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x817" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x800" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x783" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x818" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x802" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x785" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x819" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x787" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x820" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x806" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x789" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x821" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x808" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x791" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x822" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x810" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x793" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x823" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x812" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x795" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x816" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x817" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x818" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x819" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x820" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x821" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x822" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x823" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_square", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "x53" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x72" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x74" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x121" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "x135" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x138", + "x139" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x140", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x142", + "x143" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "x161" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x166", + "x167" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x172" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x181", + "x182" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x183", + "x184" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x185", + "x186" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x189", + "x190" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x191" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "x203" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x214", + "x215" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x218", + "x219" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x220", + "x221" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x222" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "x230" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x231", + "x232" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x233", + "x234" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x235", + "x236" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x237", + "x238" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x239", + "x240" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x243", + "x244" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x245", + "x246" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x247", + "x248" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x249", + "x250" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x251", + "x252" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x253", + "x254" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x255", + "x256" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x257", + "x258" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x259", + "x260" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x261", + "x262" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x263", + "x264" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x265", + "x266" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x267", + "x268" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x269", + "x270" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x271", + "x272" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x273" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x275" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x276", + "x277" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x278", + "x279" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x280", + "x281" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x282", + "x283" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x284", + "x285" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x286", + "x287" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x288", + "x289" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x290", + "x291" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x292" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x297", + "x298" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x299", + "x300" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x301", + "x302" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x303", + "x304" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x305", + "x306" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x307", + "x308" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x309", + "x310" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x311", + "x312" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x313", + "x314" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x315", + "x316" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x317", + "x318" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x319", + "x320" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x321", + "x322" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x323" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x324", + "x325" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x326", + "x327" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x328", + "x329" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x330", + "x331" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x332", + "x333" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x334", + "x335" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x336", + "x337" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x338", + "x339" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x340", + "x341" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x342", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x344", + "x345" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x346", + "x347" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x348", + "x349" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x350", + "x351" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x352", + "x353" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x354", + "x355" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x356", + "x357" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x358", + "x359" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x360", + "x361" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x362", + "x363" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x364", + "x365" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x366", + "x367" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x368", + "x369" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x370", + "x371" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x372", + "x373" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x374" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x376" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x377", + "x378" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "x388" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x393" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x394", + "x395" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x396", + "x397" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x398", + "x399" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x400", + "x401" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x402", + "x403" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x404", + "x405" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x406", + "x407" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x408", + "x409" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x410", + "x411" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x412", + "x413" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x414", + "x415" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x416", + "x417" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x418", + "x419" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x420", + "x421" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x422", + "x423" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x424" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x425", + "x426" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x427", + "x428" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x431", + "x432" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "x440" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x445", + "x446" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x447", + "x448" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x449", + "x450" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x451", + "x452" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x453", + "x454" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x455", + "x456" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x457", + "x458" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x459", + "x460" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x461", + "x462" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x463", + "x464" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x465", + "x466" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x467", + "x468" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x469", + "x470" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x471", + "x472" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x473", + "x474" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x475" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x477" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x478", + "x479" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x480", + "x481" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x482", + "x483" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x484", + "x485" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x486", + "x487" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x488", + "x489" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x490", + "x491" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x492", + "x493" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x494" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x493" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x495", + "x496" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x497", + "x498" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x499", + "x500" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x501", + "x502" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x503", + "x504" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x505", + "x506" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x507", + "x508" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x509", + "x510" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x511", + "x512" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x507" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x513", + "x514" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x515", + "x516" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x517", + "x518" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x519", + "x520" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x521", + "x522" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x520" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x523", + "x524" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x525" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x526", + "x527" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x528", + "x529" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x530", + "x531" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x532", + "x533" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x534", + "x535" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x536", + "x537" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x538", + "x539" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x540", + "x541" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x542", + "x543" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x541" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x544", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x546", + "x547" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x548", + "x549" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x550", + "x551" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x552", + "x553" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x554", + "x555" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x556", + "x557" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x558", + "x559" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x560", + "x561" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x562", + "x563" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x564", + "x565" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x566", + "x567" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x568", + "x569" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x555" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x570", + "x571" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x572", + "x573" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x551" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x574", + "x575" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x576" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x578" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x579", + "x580" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x581", + "x582" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x580" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x583", + "x584" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x585", + "x586" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x587", + "x588" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x589", + "x590" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x591", + "x592" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x540" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x593", + "x594" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x595" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x596", + "x597" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x598", + "x599" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x600", + "x601" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x602", + "x603" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x604", + "x605" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x606", + "x607" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x608", + "x609" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x610", + "x611" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x612", + "x613" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x614", + "x615" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x616", + "x617" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x618", + "x619" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x620", + "x621" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x600" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x622", + "x623" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x624", + "x625" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x626" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x627", + "x628" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x610" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x629", + "x630" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x631", + "x632" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x633", + "x634" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x616" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x635", + "x636" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x637", + "x638" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x636" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x639", + "x640" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x641", + "x642" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x643", + "x644" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x645", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x647", + "x648" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x649", + "x650" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x651", + "x652" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x653", + "x654" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x655", + "x656" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x657", + "x658" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x659", + "x660" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x661", + "x662" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x663", + "x664" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x662" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x665", + "x666" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x660" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x667", + "x668" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "x670" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x656" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x647" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x677" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x679" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x680", + "x681" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x682", + "x683" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x665" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x684", + "x685" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x667" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x686", + "x687" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x685" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x688", + "x689" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x687" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x690", + "x691" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x689" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x692", + "x693" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x691" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x694", + "x695" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x693" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x696" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x695" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x697", + "x698" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x699", + "x700" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x701", + "x702" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x703", + "x704" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x705", + "x706" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x707", + "x708" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x709", + "x710" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x711", + "x712" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x713", + "x714" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x712" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x715", + "x716" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x714" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x710" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x707" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x717", + "x718" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x716" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x708" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x705" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x719", + "x720" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x718" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x706" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x721", + "x722" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x720" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x723", + "x724" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x722" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x702" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x725", + "x726" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x724" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x727" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x726" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x698" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x728", + "x729" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x730", + "x731" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x729" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x713" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x732", + "x733" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x731" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x715" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x734", + "x735" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x717" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x736", + "x737" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x719" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x738", + "x739" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x721" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x740", + "x741" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x723" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x742", + "x743" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x741" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x744", + "x745" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x743" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x727" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x746", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x748", + "x749" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x750", + "x751" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x752", + "x753" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x754", + "x755" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x756", + "x757" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x758", + "x759" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x760", + "x761" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x762", + "x763" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x764", + "x765" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x763" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x760" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x766", + "x767" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x765" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x761" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x758" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x768", + "x769" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x759" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x756" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x770", + "x771" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x769" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x757" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x754" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x772", + "x773" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x771" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x755" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x752" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x774", + "x775" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x773" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x753" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x750" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x776", + "x777" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x775" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x751" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x748" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x778" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x777" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x749" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x780" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x762" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x781", + "x782" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x780" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x764" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x783", + "x784" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x782" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x732" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x766" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x785", + "x786" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x784" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x734" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x768" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x787", + "x788" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x736" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x770" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x789", + "x790" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x788" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x738" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x772" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x791", + "x792" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x790" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x740" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x774" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x793", + "x794" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x792" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x776" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x795", + "x796" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x794" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x744" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x797" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x796" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x745" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x798", + "x799" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x781" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x800", + "x801" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x799" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x783" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x802", + "x803" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x801" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x785" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x804", + "x805" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x803" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x787" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x806", + "x807" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x805" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x789" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x808", + "x809" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x807" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x791" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x810", + "x811" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x809" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x793" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x812", + "x813" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x811" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x795" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x815" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x813" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x797" + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x816" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x798" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x781" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x817" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x800" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x783" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x818" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x802" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x785" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x819" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x804" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x787" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x820" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x806" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x789" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x821" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x808" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x791" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x822" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x810" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x793" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x823" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x815" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x812" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x795" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x816" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x817" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x818" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x819" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x820" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x821" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x822" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x823" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_add", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x34" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x35" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x36" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x37" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x38" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x41" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_sub", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x17" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + "0x0", + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xd0364141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xbfd25e8c" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xaf48a03b" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xbaaedce6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xfffffffe" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_opp", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x17" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + "0x0", + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xd0364141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xbfd25e8c" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xaf48a03b" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xbaaedce6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xfffffffe" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_from_montgomery", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x2", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "x5" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x6", + "x7" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x8", + "x9" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "x37" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x52", + "x53" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x138", + "x139" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x140", + "x141" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x142", + "x143" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "x161" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x164", + "x165" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x167" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "x203" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x214", + "x215" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x218", + "x219" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x220", + "x221" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x222", + "x223" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x224", + "x225" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x226", + "x227" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x228", + "x229" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x230", + "x231" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x233" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x234", + "x235" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x236", + "x237" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x238", + "x239" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x240", + "x241" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x242", + "x243" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x244", + "x245" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x246", + "x247" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x250", + "x251" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x252", + "x253" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x254", + "x255" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x256", + "x257" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x258", + "x259" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x260", + "x261" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x262", + "x263" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x264", + "x265" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x266", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x268", + "x269" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x270", + "x271" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x272", + "x273" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x274", + "x275" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x276", + "x277" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x278", + "x279" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x280", + "x281" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x282", + "x283" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x284", + "x285" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x286", + "x287" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x288", + "x289" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x290", + "x291" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x292", + "x293" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x294", + "x295" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x296", + "x297" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x299" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x300", + "x301" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x302", + "x303" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x304", + "x305" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x306", + "x307" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x308", + "x309" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x310", + "x311" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x312", + "x313" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x316", + "x317" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x318", + "x319" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x320", + "x321" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x322", + "x323" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x324", + "x325" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x326", + "x327" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x328", + "x329" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x330", + "x331" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x332", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x334", + "x335" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x336", + "x337" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x338", + "x339" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x340", + "x341" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x342", + "x343" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x344", + "x345" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x346", + "x347" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x348", + "x349" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x350", + "x351" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x352", + "x353" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x354", + "x355" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x356", + "x357" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x358", + "x359" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x360", + "x361" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x359" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x362", + "x363" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x365" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x366", + "x367" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x368", + "x369" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x370", + "x371" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x372", + "x373" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x374", + "x375" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x376", + "x377" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x378", + "x379" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x380", + "x381" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x382", + "x383" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x384", + "x385" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x386", + "x387" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x388", + "x389" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x390", + "x391" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x392", + "x393" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x394", + "x395" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x396", + "x397" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x398", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x400", + "x401" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x402", + "x403" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x404", + "x405" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x406", + "x407" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x408", + "x409" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x410", + "x411" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x412", + "x413" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x414", + "x415" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x416", + "x417" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x418", + "x419" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x420", + "x421" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x422", + "x423" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x424", + "x425" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x426", + "x427" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x428", + "x429" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x431" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x432", + "x433" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x434", + "x435" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x436", + "x437" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x438", + "x439" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x440", + "x441" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x424" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x442", + "x443" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x444", + "x445" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x446", + "x447" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x448", + "x449" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x450", + "x451" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x452", + "x453" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x454", + "x455" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x456", + "x457" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x458", + "x459" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x460", + "x461" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x462", + "x463" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x464", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x466", + "x467" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x468", + "x469" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x470", + "x471" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x472", + "x473" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x474", + "x475" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x476", + "x477" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x478", + "x479" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x480", + "x481" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x482", + "x483" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x484", + "x485" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x486", + "x487" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x488", + "x489" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x490", + "x491" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x492", + "x493" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x494", + "x495" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x493" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x497" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x498", + "x499" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x500", + "x501" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x502", + "x503" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x504", + "x505" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x506", + "x507" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x508", + "x509" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x507" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x510", + "x511" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x512", + "x513" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x514", + "x515" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x516", + "x517" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x518", + "x519" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x520", + "x521" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x522", + "x523" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x524", + "x525" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x526", + "x527" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x528", + "x529" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x531" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x532" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x533" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x534" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x535" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x520" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x536" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x537" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x538" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x539" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x532" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x533" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x534" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x535" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x536" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x537" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x538" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_to_montgomery", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x9d671cd5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x81c69bc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xe697f5e4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x5bcd07c6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x741496c2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xe7cf878" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x896cf214" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x67d7d140" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x72" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x9d671cd5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x81c69bc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xe697f5e4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x5bcd07c6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x741496c2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xe7cf878" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x896cf214" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x67d7d140" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "x126" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x131", + "x132" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x149", + "x150" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x168" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x179", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x181", + "x182" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x183", + "x184" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x185", + "x186" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x9d671cd5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x81c69bc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x189", + "x190" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xe697f5e4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x191", + "x192" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x5bcd07c6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x193", + "x194" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x741496c2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x195", + "x196" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xe7cf878" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x896cf214" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x67d7d140" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "x204" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x205", + "x206" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x207", + "x208" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x209", + "x210" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x211", + "x212" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x213", + "x214" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x215", + "x216" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x217", + "x218" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x219", + "x220" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x218" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x221", + "x222" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x220" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x223", + "x224" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x222" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x225", + "x226" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x224" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x227", + "x228" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x229", + "x230" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x231", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x233", + "x234" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x235", + "x236" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x237", + "x238" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x239", + "x240" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "x242" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x243", + "x244" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x245", + "x246" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x247", + "x248" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x249", + "x250" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x251", + "x252" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x253", + "x254" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x255", + "x256" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x239" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x257", + "x258" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x256" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x259", + "x260" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x235" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x261", + "x262" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x260" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x236" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x233" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x264" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x247" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x265", + "x266" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x267", + "x268" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x251" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x269", + "x270" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x253" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x271", + "x272" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x255" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x273", + "x274" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x225" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x257" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x275", + "x276" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x259" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x277", + "x278" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x261" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x279", + "x280" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x214" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x262" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x281", + "x282" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x9d671cd5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x283", + "x284" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x81c69bc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x285", + "x286" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xe697f5e4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x287", + "x288" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x5bcd07c6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x289", + "x290" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x741496c2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x291", + "x292" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xe7cf878" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x896cf214" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x67d7d140" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x297", + "x298" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x293" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x299", + "x300" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x301", + "x302" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x303", + "x304" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x305", + "x306" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x285" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x307", + "x308" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x306" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x283" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x309", + "x310" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x281" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x311", + "x312" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x313", + "x314" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x312" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x297" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x315", + "x316" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x299" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x317", + "x318" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x316" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x301" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x319", + "x320" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x318" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x321", + "x322" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x305" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x323", + "x324" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x322" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x307" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x325", + "x326" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x327", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x329", + "x330" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x337", + "x338" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x339", + "x340" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x341", + "x342" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x343", + "x344" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x327" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x345", + "x346" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x347", + "x348" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x339" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x349", + "x350" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x337" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x351", + "x352" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x335" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x353", + "x354" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x355", + "x356" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x354" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x357", + "x358" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x360" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x311" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x343" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x361", + "x362" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x360" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x345" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x363", + "x364" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x365", + "x366" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x349" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x367", + "x368" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x351" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x369", + "x370" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x371", + "x372" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x373", + "x374" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x357" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x375", + "x376" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x326" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x358" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x330" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x377", + "x378" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x9d671cd5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x81c69bc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xe697f5e4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x5bcd07c6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x741496c2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "x388" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xe7cf878" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x896cf214" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x67d7d140" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x393", + "x394" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x392" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x395", + "x396" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x394" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x388" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x385" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x399", + "x400" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x401", + "x402" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x384" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x381" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x403", + "x404" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x405", + "x406" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x377" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x407", + "x408" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x361" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x391" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x409", + "x410" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x363" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x393" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x411", + "x412" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x365" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x413", + "x414" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x412" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x367" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x415", + "x416" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x369" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x417", + "x418" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x416" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x401" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x419", + "x420" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x403" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x421", + "x422" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x405" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x423", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x425", + "x426" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x427", + "x428" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x431", + "x432" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x433", + "x434" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x435", + "x436" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x437", + "x438" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "x440" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x441", + "x442" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x443", + "x444" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x435" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x445", + "x446" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x447", + "x448" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x449", + "x450" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x451", + "x452" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x450" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x453", + "x454" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x428" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x425" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x456" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x457", + "x458" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x441" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x459", + "x460" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x461", + "x462" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x445" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x463", + "x464" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x447" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x465", + "x466" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x449" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x467", + "x468" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x451" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x469", + "x470" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x453" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x471", + "x472" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x422" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x378" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x426" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x473", + "x474" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x9d671cd5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x475", + "x476" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x81c69bc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x477", + "x478" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xe697f5e4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x479", + "x480" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x5bcd07c6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x481", + "x482" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x741496c2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x483", + "x484" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xe7cf878" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x485", + "x486" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x896cf214" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x487", + "x488" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x67d7d140" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x489", + "x490" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x485" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x491", + "x492" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x483" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x493", + "x494" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x492" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x481" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x495", + "x496" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x494" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x479" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x497", + "x498" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x499", + "x500" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x501", + "x502" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x503", + "x504" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x487" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x505", + "x506" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x489" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x507", + "x508" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x509", + "x510" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x493" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x511", + "x512" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x495" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x513", + "x514" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x512" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x467" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x497" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x515", + "x516" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x514" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x499" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x517", + "x518" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x516" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x519", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x521", + "x522" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x523", + "x524" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x525", + "x526" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x527", + "x528" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x529", + "x530" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x531", + "x532" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x533", + "x534" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x535", + "x536" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x537", + "x538" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x536" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x533" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x539", + "x540" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x538" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x531" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x541", + "x542" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x540" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x532" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x529" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x543", + "x544" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x530" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x545", + "x546" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x544" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x528" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x547", + "x548" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x546" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x526" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x549", + "x550" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x548" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x524" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x552" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x535" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x553", + "x554" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x505" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x555", + "x556" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x507" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x557", + "x558" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x541" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x559", + "x560" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x561", + "x562" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x545" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x563", + "x564" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x565", + "x566" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x567", + "x568" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x566" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x518" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x522" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x569", + "x570" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x9d671cd5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x571", + "x572" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x81c69bc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x573", + "x574" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xe697f5e4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x575", + "x576" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x5bcd07c6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x577", + "x578" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x741496c2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x579", + "x580" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xe7cf878" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x581", + "x582" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x896cf214" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x583", + "x584" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x67d7d140" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x585", + "x586" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x581" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x587", + "x588" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x582" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x579" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x589", + "x590" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x580" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x577" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x591", + "x592" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x590" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x578" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x575" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x593", + "x594" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x592" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x576" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x573" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x595", + "x596" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x594" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x574" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x571" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x597", + "x598" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x596" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x572" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x569" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x599", + "x600" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x601", + "x602" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x600" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x555" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x603", + "x604" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x605", + "x606" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x604" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x559" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x589" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x607", + "x608" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x591" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x609", + "x610" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x608" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x593" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x611", + "x612" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x610" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x565" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x595" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x613", + "x614" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x612" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x567" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x615", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x617", + "x618" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x619", + "x620" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x621", + "x622" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x623", + "x624" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x625", + "x626" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x627", + "x628" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x629", + "x630" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x631", + "x632" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x615" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x633", + "x634" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x632" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x629" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x635", + "x636" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x637", + "x638" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x636" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x639", + "x640" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x641", + "x642" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x640" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x624" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x621" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x643", + "x644" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x642" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x622" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x645", + "x646" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x644" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x620" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x648" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x649", + "x650" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x601" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x633" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x651", + "x652" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x653", + "x654" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x655", + "x656" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x639" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x657", + "x658" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x656" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x609" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x641" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x659", + "x660" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x643" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x661", + "x662" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x660" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x613" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x645" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x663", + "x664" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x662" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x614" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x568" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x598" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x570" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x646" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x618" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x665", + "x666" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x9d671cd5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x667", + "x668" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x81c69bc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "x670" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xe697f5e4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x5bcd07c6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x741496c2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xe7cf878" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x677", + "x678" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x896cf214" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x67d7d140" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x681", + "x682" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x677" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x683", + "x684" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x682" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x678" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x675" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x685", + "x686" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x684" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x673" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x687", + "x688" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x686" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x671" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x689", + "x690" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x688" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x669" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x691", + "x692" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x667" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x693", + "x694" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x692" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x665" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x695", + "x696" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x697", + "x698" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x681" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x699", + "x700" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x698" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x683" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x701", + "x702" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x685" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x703", + "x704" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x702" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x687" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x705", + "x706" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x704" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x689" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x707", + "x708" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x706" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x691" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x709", + "x710" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x708" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x693" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x711", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x695" + ] + } + ] + }, + "0x5588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x713", + "x714" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x715", + "x716" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x717", + "x718" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x719", + "x720" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x721", + "x722" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x723", + "x724" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x725", + "x726" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x727", + "x728" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x729", + "x730" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x731", + "x732" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x730" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x726" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x723" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x733", + "x734" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x732" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x724" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x721" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x735", + "x736" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x734" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x722" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x719" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x737", + "x738" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x736" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x720" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x717" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x739", + "x740" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x738" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x718" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x715" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x741", + "x742" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x740" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x716" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x713" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x744" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x695" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x727" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x745", + "x746" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x744" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x729" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x747", + "x748" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x746" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x731" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x749", + "x750" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x748" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x751", + "x752" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x750" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x753", + "x754" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x752" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x705" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x755", + "x756" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x754" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x707" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x757", + "x758" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x756" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x741" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x759", + "x760" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x758" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x710" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x694" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x714" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x761", + "x762" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x745" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x763", + "x764" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x762" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x747" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x765", + "x766" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x764" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x749" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x767", + "x768" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x766" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x751" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x769", + "x770" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x768" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x753" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x771", + "x772" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x770" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x755" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x773", + "x774" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x772" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x757" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x775", + "x776" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x774" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x759" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x778" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x776" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x760" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x779" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x761" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x745" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x780" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x763" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x747" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x781" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x765" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x749" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x782" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x751" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x783" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x769" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x753" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x784" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x771" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x755" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x785" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x773" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x757" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x786" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x778" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x775" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x759" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x779" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x780" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x781" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x782" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x783" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x784" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x785" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x786" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_nonzero", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_selectznz", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u32[8]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_to_bytes", + "arguments": [ + { + "datatype": "u32[8]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u8[32]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u8", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[12]" + ], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[13]" + ], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[14]" + ], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[15]" + ], + "operation": "static_cast", + "arguments": [ + "x32" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[16]" + ], + "operation": "static_cast", + "arguments": [ + "x33" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[17]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[18]" + ], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[19]" + ], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[20]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[21]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[22]" + ], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[23]" + ], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[24]" + ], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[25]" + ], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[26]" + ], + "operation": "static_cast", + "arguments": [ + "x49" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[27]" + ], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[28]" + ], + "operation": "static_cast", + "arguments": [ + "x51" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[29]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[30]" + ], + "operation": "static_cast", + "arguments": [ + "x55" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[31]" + ], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_from_bytes", + "arguments": [ + { + "datatype": "u8[32]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff" + ] + } + ], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "u32", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[31]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[30]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[29]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[28]" + ] + }, + { + "datatype": "u32", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[27]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[26]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[25]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[24]" + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[23]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[22]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[21]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + "arg1[20]" + ] + }, + { + "datatype": "u32", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[19]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[18]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[17]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + "arg1[16]" + ] + }, + { + "datatype": "u32", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[15]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[14]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[13]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + "arg1[12]" + ] + }, + { + "datatype": "u32", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u32", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u32", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_set_one", + "arguments": [], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0x2fc9bebf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x402da173" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x50b75fc4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x45512319" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x1" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_msat", + "arguments": [], + "returns": [ + { + "datatype": "u32[9]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[8]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_divstep", + "arguments": [ + { + "datatype": "u32", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32[9]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[9]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "arg5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u32", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffff" + }, + { + "datatype": "u32[9]", + "name": "out2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[9]", + "name": "out3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "out4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + }, + { + "datatype": "u32[8]", + "name": "out5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "31" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + "0x1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u32", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x7" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x8" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x10" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x11" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x12" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x13" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x14" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[7]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x15" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[8]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + "0x1", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[5]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[6]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[7]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[8]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x34" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x35" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x36" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x37" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x38" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x39" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x40" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x41" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x42" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[8]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x43" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x44" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x45" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x46" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x47" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[4]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x48" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[5]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x49" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[6]" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x50" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[7]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x84" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x85" + ], + "operation": "static_cast", + "arguments": [ + "arg4[7]" + ] + }, + { + "datatype": "u32", + "name": [ + "x86" + ], + "operation": "static_cast", + "arguments": [ + "arg4[6]" + ] + }, + { + "datatype": "u32", + "name": [ + "x87" + ], + "operation": "static_cast", + "arguments": [ + "arg4[5]" + ] + }, + { + "datatype": "u32", + "name": [ + "x88" + ], + "operation": "static_cast", + "arguments": [ + "arg4[4]" + ] + }, + { + "datatype": "u32", + "name": [ + "x89" + ], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u32", + "name": [ + "x90" + ], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u32", + "name": [ + "x91" + ], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u32", + "name": [ + "x92" + ], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x109" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + "0x0", + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0xd0364141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0xbfd25e8c" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0xaf48a03b" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0xbaaedce6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0xfffffffe" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x120", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x126" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x127" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x128" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x129" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x130" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[4]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x131" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[5]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x132" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[6]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x133" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[7]" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x134" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "0x1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x135" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x136" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x137" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x138" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x139" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x140" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x141" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x142" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x143" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x152", + "x153" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x154", + "x155" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x156", + "x157" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x158", + "x159" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x160", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x162" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x163" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x164" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x165" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x166" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x167" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x168" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x169" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + "0xd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + "0xbfd25e8c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + "0xaf48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + "0xbaaedce6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x196", + "x197" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x203" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x1" + ] + }, + { + "datatype": "u32", + "name": [ + "x206" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x207" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x208" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x209" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x210" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x211" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x212" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x213" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "31" + ] + }, + "0xffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x214" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "0x80000000" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + "1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x215" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x216" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x217" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x218" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x219" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x220" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x221" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x222" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x223" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x224" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x225" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x226" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x227" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x228" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x229" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x230" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out2[0]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[1]" + ], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[2]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[3]" + ], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[4]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[5]" + ], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[6]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[7]" + ], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u32", + "name": [ + "out2[8]" + ], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[0]" + ], + "operation": "static_cast", + "arguments": [ + "x206" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[1]" + ], + "operation": "static_cast", + "arguments": [ + "x207" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[2]" + ], + "operation": "static_cast", + "arguments": [ + "x208" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[3]" + ], + "operation": "static_cast", + "arguments": [ + "x209" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[4]" + ], + "operation": "static_cast", + "arguments": [ + "x210" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[5]" + ], + "operation": "static_cast", + "arguments": [ + "x211" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[6]" + ], + "operation": "static_cast", + "arguments": [ + "x212" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[7]" + ], + "operation": "static_cast", + "arguments": [ + "x213" + ] + }, + { + "datatype": "u32", + "name": [ + "out3[8]" + ], + "operation": "static_cast", + "arguments": [ + "x214" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[0]" + ], + "operation": "static_cast", + "arguments": [ + "x215" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[1]" + ], + "operation": "static_cast", + "arguments": [ + "x216" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[2]" + ], + "operation": "static_cast", + "arguments": [ + "x217" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[3]" + ], + "operation": "static_cast", + "arguments": [ + "x218" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[4]" + ], + "operation": "static_cast", + "arguments": [ + "x219" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[5]" + ], + "operation": "static_cast", + "arguments": [ + "x220" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[6]" + ], + "operation": "static_cast", + "arguments": [ + "x221" + ] + }, + { + "datatype": "u32", + "name": [ + "out4[7]" + ], + "operation": "static_cast", + "arguments": [ + "x222" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[0]" + ], + "operation": "static_cast", + "arguments": [ + "x223" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[1]" + ], + "operation": "static_cast", + "arguments": [ + "x224" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[2]" + ], + "operation": "static_cast", + "arguments": [ + "x225" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[3]" + ], + "operation": "static_cast", + "arguments": [ + "x226" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[4]" + ], + "operation": "static_cast", + "arguments": [ + "x227" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[5]" + ], + "operation": "static_cast", + "arguments": [ + "x228" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[6]" + ], + "operation": "static_cast", + "arguments": [ + "x229" + ] + }, + { + "datatype": "u32", + "name": [ + "out5[7]" + ], + "operation": "static_cast", + "arguments": [ + "x230" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_divstep_precomp", + "arguments": [], + "returns": [ + { + "datatype": "u32[8]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff", + "0xffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0x2b9cb4e9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xd7431a4d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x32d9c503" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xab67d35a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x859ce35f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0xadf6c7e5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0x1df6c379" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0x61544145" + ] + } + ] + } +] diff --git a/fiat-json/src/secp256k1_scalar_64.json b/fiat-json/src/secp256k1_scalar_64.json new file mode 100644 index 0000000000..050111c354 --- /dev/null +++ b/fiat-json/src/secp256k1_scalar_64.json @@ -0,0 +1,29414 @@ +[ + { + "operation": "fiat_secp256k1_scalar_addcarryx_u64", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "u128", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_subborrowx_u64", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u1", + "name": "out2", + "lbound": "0x0", + "ubound": "0x1" + } + ], + "body": [ + { + "datatype": "i128", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "-", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "i1", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u1", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_mulx_u64", + "arguments": [ + { + "datatype": "u64", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "out2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "body": [ + { + "datatype": "u128", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "*", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u128", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [ + "out2" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_cmovznz_u64", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64", + "name": "arg2", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64", + "name": "arg3", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "body": [ + { + "datatype": "u1", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "!", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "i1", + "name": [], + "operation": "-", + "arguments": [ + "0x0", + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + "0xffffffffffffffff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_mul", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x61" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x88" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x99" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x114" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x131", + "x132" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x141" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x143" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x152" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x167" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x194" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x196" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "x204" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x205" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x215" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x216" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x217" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x218" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x219" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x216" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x217" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x218" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_square", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x61" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "x71" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x88" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x99" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x114" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x131", + "x132" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x141" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x143" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x144", + "x145" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x146", + "x147" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x148", + "x149" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x150", + "x151" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x152" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x167" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x168", + "x169" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x170", + "x171" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x182", + "x183" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x184", + "x185" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x186", + "x187" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x190", + "x191" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x192", + "x193" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x194" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x196" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x201", + "x202" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x203", + "x204" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x205" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x206", + "x207" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x208", + "x209" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x210", + "x211" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x209" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x212", + "x213" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x215" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x213" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x216" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x217" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x199" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x218" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x210" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x219" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x215" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x212" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x216" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x217" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x218" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x219" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_add", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x18" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x20" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x21" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_sub", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0", + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xbfd25e8cd0364141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xbaaedce6af48a03b" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xfffffffffffffffe" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_opp", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "x2" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x3", + "x4" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + "0x0", + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xbfd25e8cd0364141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xbaaedce6af48a03b" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + "0xfffffffffffffffe" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_from_montgomery", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x2", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "x5" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x6", + "x7" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x8", + "x9" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "x21" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x22", + "x23" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x24", + "x25" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x26", + "x27" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x28", + "x29" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x30", + "x31" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x32", + "x33" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x34", + "x35" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x36", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x40", + "x41" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x42", + "x43" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x44", + "x45" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x46", + "x47" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x48", + "x49" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x50", + "x51" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x53" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x56", + "x57" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "x69" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x70", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x74", + "x75" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x110", + "x111" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "x113" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x114", + "x115" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x116", + "x117" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x118", + "x119" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x121" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x122", + "x123" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x124", + "x125" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x126", + "x127" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x128", + "x129" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x132", + "x133" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x134", + "x135" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x136", + "x137" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x139" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x140" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x141" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x142" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x143" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x140" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x141" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x142" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_to_montgomery", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x5", + "x6" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x9d671cd581c69bc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xe697f5e45bcd07c6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x741496c20e7cf878" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x896cf21467d7d140" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x27", + "x28" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x29", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x9d671cd581c69bc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xe697f5e45bcd07c6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x741496c20e7cf878" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x896cf21467d7d140" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x61", + "x62" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x63", + "x64" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x65", + "x66" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x69", + "x70" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x71", + "x72" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x75", + "x76" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x84" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x9d671cd581c69bc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xe697f5e45bcd07c6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x741496c20e7cf878" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x896cf21467d7d140" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x105", + "x106" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x107", + "x108" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x89" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x117", + "x118" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x121", + "x122" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x123", + "x124" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "x126" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x127", + "x128" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x128" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x132" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x129" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x9d671cd581c69bc5" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xe697f5e45bcd07c6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x741496c20e7cf878" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x896cf21467d7d140" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x149", + "x150" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x148" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x151", + "x152" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x146" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x143" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x153", + "x154" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x144" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x155", + "x156" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x156" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x151" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x160" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x153" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + "0x4b0dff665588b13f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x167", + "x168" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x175", + "x176" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x170" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x167" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x177", + "x178" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x168" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x180" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x181", + "x182" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x183", + "x184" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x185", + "x186" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x140" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x142" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x189", + "x190" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x191", + "x192" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x193", + "x194" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x195", + "x196" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x198" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x199" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x200" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x201" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x202" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x187" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x199" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x200" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x201" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_nonzero", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_selectznz", + "arguments": [ + { + "datatype": "u1", + "name": "arg1", + "lbound": "0x0", + "ubound": "0x1" + }, + { + "datatype": "u64[4]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_to_bytes", + "arguments": [ + { + "datatype": "u64[4]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u8[32]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u8", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x57" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x58" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x59" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + }, + "0xff" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x60" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[8]" + ], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[9]" + ], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[10]" + ], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[11]" + ], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[12]" + ], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[13]" + ], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[14]" + ], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[15]" + ], + "operation": "static_cast", + "arguments": [ + "x32" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[16]" + ], + "operation": "static_cast", + "arguments": [ + "x33" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[17]" + ], + "operation": "static_cast", + "arguments": [ + "x35" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[18]" + ], + "operation": "static_cast", + "arguments": [ + "x37" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[19]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[20]" + ], + "operation": "static_cast", + "arguments": [ + "x41" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[21]" + ], + "operation": "static_cast", + "arguments": [ + "x43" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[22]" + ], + "operation": "static_cast", + "arguments": [ + "x45" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[23]" + ], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[24]" + ], + "operation": "static_cast", + "arguments": [ + "x47" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[25]" + ], + "operation": "static_cast", + "arguments": [ + "x49" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[26]" + ], + "operation": "static_cast", + "arguments": [ + "x51" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[27]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[28]" + ], + "operation": "static_cast", + "arguments": [ + "x55" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[29]" + ], + "operation": "static_cast", + "arguments": [ + "x57" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[30]" + ], + "operation": "static_cast", + "arguments": [ + "x59" + ] + }, + { + "datatype": "u8", + "name": [ + "out1[31]" + ], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_from_bytes", + "arguments": [ + { + "datatype": "u8[32]", + "name": "arg1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff", + "0xff" + ] + } + ], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "u64", + "name": [ + "x1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[31]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x2" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[30]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[29]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x4" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[28]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x5" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[27]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[26]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x7" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[25]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x8" + ], + "operation": "static_cast", + "arguments": [ + "arg1[24]" + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[23]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x10" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[22]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x11" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[21]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x12" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[20]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x13" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[19]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x14" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[18]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x15" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[17]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x16" + ], + "operation": "static_cast", + "arguments": [ + "arg1[16]" + ] + }, + { + "datatype": "u64", + "name": [ + "x17" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[15]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x18" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[14]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x19" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[13]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x20" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[12]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x21" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[11]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[10]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x23" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[9]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x24" + ], + "operation": "static_cast", + "arguments": [ + "arg1[8]" + ] + }, + { + "datatype": "u64", + "name": [ + "x25" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + }, + "56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x26" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + }, + "48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x27" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + }, + "40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[4]" + ] + }, + "32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x29" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + }, + "24" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + }, + "16" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x31" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + }, + "8" + ] + } + ] + }, + { + "datatype": "u8", + "name": [ + "x32" + ], + "operation": "static_cast", + "arguments": [ + "arg1[0]" + ] + }, + { + "datatype": "u64", + "name": [ + "x33" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x35" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x36" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x37" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x38" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x39" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x40" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x41" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x42" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x43" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x44" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x45" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x46" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x47" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x48" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x53" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x54" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u8", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x55" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x57" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x58" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x59" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x60" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x39" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x46" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x53" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_set_one", + "arguments": [], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0x402da1732fc9bebf" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x4551231950b75fc4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x1" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_msat", + "arguments": [], + "returns": [ + { + "datatype": "u64[5]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_divstep", + "arguments": [ + { + "datatype": "u64", + "name": "arg1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64[5]", + "name": "arg2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[5]", + "name": "arg3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "arg5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "returns": [ + { + "datatype": "u64", + "name": "out1", + "lbound": "0x0", + "ubound": "0xffffffffffffffff" + }, + { + "datatype": "u64[5]", + "name": "out2", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[5]", + "name": "out3", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "out4", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + }, + { + "datatype": "u64[4]", + "name": "out5", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "x1", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u1", + "name": [ + "x3" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + "63" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + "0x1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + } + ] + } + ] + }, + "0x1" + ] + }, + { + "datatype": "u64", + "name": [ + "x6" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x7" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x8" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x9" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x10" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x11" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + "0x1", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[0]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[1]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x15" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[2]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[3]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x20", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "~", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg2[4]" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x22" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x23" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x24" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x16" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x25" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x26" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg3[4]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x27" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x28" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x29" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x30" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x31", + "x32" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x33", + "x34" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x41", + "x42" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x48" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x38" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x49" + ], + "operation": "static_cast", + "arguments": [ + "arg4[3]" + ] + }, + { + "datatype": "u64", + "name": [ + "x50" + ], + "operation": "static_cast", + "arguments": [ + "arg4[2]" + ] + }, + { + "datatype": "u64", + "name": [ + "x51" + ], + "operation": "static_cast", + "arguments": [ + "arg4[1]" + ] + }, + { + "datatype": "u64", + "name": [ + "x52" + ], + "operation": "static_cast", + "arguments": [ + "arg4[0]" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x53", + "x54" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x52" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x55", + "x56" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x57", + "x58" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x59", + "x60" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x49" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x61" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + }, + "0x0", + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x62", + "x63" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + "0xbfd25e8cd0364141" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x64", + "x65" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x55" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + "0xbaaedce6af48a03b" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "x67" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + }, + "0xfffffffffffffffe" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x68", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x70" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[0]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x71" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[1]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x72" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[2]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x73" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg5[3]" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "u1", + "name": [ + "x74" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + "0x1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x75" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x76" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x77" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x78" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x10" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x79" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x80", + "x81" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x75" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x82", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x81" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x76" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x77" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x85" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x25" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x87" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x26" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x90" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x27" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x91" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x92" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x29" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x93" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + }, + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x90" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x95" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x71" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x98", + "x99" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x73" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x93" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x102", + "x103" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + "0xbfd25e8cd0364141" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x104", + "x105" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + }, + "0xbaaedce6af48a03b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x106", + "x107" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x105" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + }, + "0xfffffffffffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x111" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x112", + "_" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x1" + ] + }, + { + "datatype": "u64", + "name": [ + "x114" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x115" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x116" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x117" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + }, + "1" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "<<", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + "63" + ] + }, + "0xffffffffffffffff" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x118" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "|", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + "0x8000000000000000" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": ">>", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + }, + "1" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x119" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x31" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x120" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x41" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x33" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x121" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x122" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x48" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x45" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x123" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x124" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x125" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x126" + ], + "operation": "cmovznz", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out2[0]" + ], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[1]" + ], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[2]" + ], + "operation": "static_cast", + "arguments": [ + "x9" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[3]" + ], + "operation": "static_cast", + "arguments": [ + "x10" + ] + }, + { + "datatype": "u64", + "name": [ + "out2[4]" + ], + "operation": "static_cast", + "arguments": [ + "x11" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[0]" + ], + "operation": "static_cast", + "arguments": [ + "x114" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[1]" + ], + "operation": "static_cast", + "arguments": [ + "x115" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[2]" + ], + "operation": "static_cast", + "arguments": [ + "x116" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[3]" + ], + "operation": "static_cast", + "arguments": [ + "x117" + ] + }, + { + "datatype": "u64", + "name": [ + "out3[4]" + ], + "operation": "static_cast", + "arguments": [ + "x118" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[0]" + ], + "operation": "static_cast", + "arguments": [ + "x119" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[1]" + ], + "operation": "static_cast", + "arguments": [ + "x120" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[2]" + ], + "operation": "static_cast", + "arguments": [ + "x121" + ] + }, + { + "datatype": "u64", + "name": [ + "out4[3]" + ], + "operation": "static_cast", + "arguments": [ + "x122" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[0]" + ], + "operation": "static_cast", + "arguments": [ + "x123" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[1]" + ], + "operation": "static_cast", + "arguments": [ + "x124" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[2]" + ], + "operation": "static_cast", + "arguments": [ + "x125" + ] + }, + { + "datatype": "u64", + "name": [ + "out5[3]" + ], + "operation": "static_cast", + "arguments": [ + "x126" + ] + } + ] + }, + { + "operation": "fiat_secp256k1_scalar_divstep_precomp", + "arguments": [], + "returns": [ + { + "datatype": "u64[4]", + "name": "out1", + "lbound": [ + "0x0", + "0x0", + "0x0", + "0x0" + ], + "ubound": [ + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff", + "0xffffffffffffffff" + ] + } + ], + "body": [ + { + "datatype": "(auto)", + "name": [ + "out1[0]" + ], + "operation": "=", + "arguments": [ + "0xd7431a4d2b9cb4e9" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xab67d35a32d9c503" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xadf6c7e5859ce35f" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x615441451df6c379" + ] + } + ] + } +] diff --git a/fiat-rust/src/curve25519_scalar_32.rs b/fiat-rust/src/curve25519_scalar_32.rs new file mode 100644 index 0000000000..e38b24c239 --- /dev/null +++ b/fiat-rust/src/curve25519_scalar_32.rs @@ -0,0 +1,4796 @@ +//! Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline 25519_scalar 32 '2^252 + 27742317777372353535851937790883648493' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +//! curve description: 25519_scalar +//! machine_wordsize = 32 (from "32") +//! requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +//! m = 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed (from "2^252 + 27742317777372353535851937790883648493") +//! +//! NOTE: In addition to the bounds specified above each function, all +//! functions synthesized for this Montgomery arithmetic require the +//! input to be strictly less than the prime modulus (m), and also +//! require the input to be in the unique saturated representation. +//! All functions also ensure that these two properties are true of +//! return values. +//! +//! Computed values: +//! eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) +//! bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +//! twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in +//! if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 + +#![allow(unused_parens)] +#![allow(non_camel_case_types)] + +pub type fiat_25519_scalar_u1 = u8; +pub type fiat_25519_scalar_i1 = i8; +pub type fiat_25519_scalar_u2 = u8; +pub type fiat_25519_scalar_i2 = i8; + +/* The type fiat_25519_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +pub type fiat_25519_scalar_montgomery_domain_field_element = [u32; 8]; + +/* The type fiat_25519_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +pub type fiat_25519_scalar_non_montgomery_domain_field_element = [u32; 8]; + + +/// The function fiat_25519_scalar_addcarryx_u32 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^32 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_25519_scalar_addcarryx_u32(out1: &mut u32, out2: &mut fiat_25519_scalar_u1, arg1: fiat_25519_scalar_u1, arg2: u32, arg3: u32) -> () { + let x1: u64 = (((arg1 as u64) + (arg2 as u64)) + (arg3 as u64)); + let x2: u32 = ((x1 & (0xffffffff as u64)) as u32); + let x3: fiat_25519_scalar_u1 = ((x1 >> 32) as fiat_25519_scalar_u1); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_25519_scalar_subborrowx_u32 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^32 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_25519_scalar_subborrowx_u32(out1: &mut u32, out2: &mut fiat_25519_scalar_u1, arg1: fiat_25519_scalar_u1, arg2: u32, arg3: u32) -> () { + let x1: i64 = (((arg2 as i64) - (arg1 as i64)) - (arg3 as i64)); + let x2: fiat_25519_scalar_i1 = ((x1 >> 32) as fiat_25519_scalar_i1); + let x3: u32 = ((x1 & (0xffffffff as i64)) as u32); + *out1 = x3; + *out2 = (((0x0 as fiat_25519_scalar_i2) - (x2 as fiat_25519_scalar_i2)) as fiat_25519_scalar_u1); +} + +/// The function fiat_25519_scalar_mulx_u32 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^32 +/// out2 = ⌊arg1 * arg2 / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0xffffffff] +#[inline] +pub fn fiat_25519_scalar_mulx_u32(out1: &mut u32, out2: &mut u32, arg1: u32, arg2: u32) -> () { + let x1: u64 = ((arg1 as u64) * (arg2 as u64)); + let x2: u32 = ((x1 & (0xffffffff as u64)) as u32); + let x3: u32 = ((x1 >> 32) as u32); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_25519_scalar_cmovznz_u32 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +#[inline] +pub fn fiat_25519_scalar_cmovznz_u32(out1: &mut u32, arg1: fiat_25519_scalar_u1, arg2: u32, arg3: u32) -> () { + let x1: fiat_25519_scalar_u1 = (!(!arg1)); + let x2: u32 = ((((((0x0 as fiat_25519_scalar_i2) - (x1 as fiat_25519_scalar_i2)) as fiat_25519_scalar_i1) as i64) & (0xffffffff as i64)) as u32); + let x3: u32 = ((x2 & arg3) | ((!x2) & arg2)); + *out1 = x3; +} + +/// The function fiat_25519_scalar_mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_mul(out1: &mut fiat_25519_scalar_montgomery_domain_field_element, arg1: &fiat_25519_scalar_montgomery_domain_field_element, arg2: &fiat_25519_scalar_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[1]); + let x2: u32 = (arg1[2]); + let x3: u32 = (arg1[3]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[5]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[7]); + let x8: u32 = (arg1[0]); + let mut x9: u32 = 0; + let mut x10: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x9, &mut x10, x8, (arg2[7])); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x11, &mut x12, x8, (arg2[6])); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x13, &mut x14, x8, (arg2[5])); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x15, &mut x16, x8, (arg2[4])); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x17, &mut x18, x8, (arg2[3])); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x19, &mut x20, x8, (arg2[2])); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x21, &mut x22, x8, (arg2[1])); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x23, &mut x24, x8, (arg2[0])); + let mut x25: u32 = 0; + let mut x26: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x37, &mut x38, x36, x12, x9); + let x39: u32 = ((x38 as u32) + x10); + let mut x40: u32 = 0; + let mut x41: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x40, &mut x41, x23, 0x12547e1b); + let mut x42: u32 = 0; + let mut x43: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x42, &mut x43, x40, 0x10000000); + let mut x44: u32 = 0; + let mut x45: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x44, &mut x45, x40, 0x14def9de); + let mut x46: u32 = 0; + let mut x47: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x46, &mut x47, x40, 0xa2f79cd6); + let mut x48: u32 = 0; + let mut x49: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x48, &mut x49, x40, 0x5812631a); + let mut x50: u32 = 0; + let mut x51: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x50, &mut x51, x40, 0x5cf5d3ed); + let mut x52: u32 = 0; + let mut x53: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x52, &mut x53, 0x0, x51, x48); + let mut x54: u32 = 0; + let mut x55: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x54, &mut x55, x53, x49, x46); + let mut x56: u32 = 0; + let mut x57: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x56, &mut x57, x55, x47, x44); + let x58: u32 = ((x57 as u32) + x45); + let mut x59: u32 = 0; + let mut x60: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x59, &mut x60, 0x0, x23, x50); + let mut x61: u32 = 0; + let mut x62: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x61, &mut x62, x60, x25, x52); + let mut x63: u32 = 0; + let mut x64: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x63, &mut x64, x62, x27, x54); + let mut x65: u32 = 0; + let mut x66: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x65, &mut x66, x64, x29, x56); + let mut x67: u32 = 0; + let mut x68: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x67, &mut x68, x66, x31, x58); + let mut x69: u32 = 0; + let mut x70: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x69, &mut x70, x68, x33, (0x0 as u32)); + let mut x71: u32 = 0; + let mut x72: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x71, &mut x72, x70, x35, (0x0 as u32)); + let mut x73: u32 = 0; + let mut x74: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x73, &mut x74, x72, x37, x42); + let mut x75: u32 = 0; + let mut x76: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x75, &mut x76, x74, x39, x43); + let mut x77: u32 = 0; + let mut x78: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x77, &mut x78, x1, (arg2[7])); + let mut x79: u32 = 0; + let mut x80: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x79, &mut x80, x1, (arg2[6])); + let mut x81: u32 = 0; + let mut x82: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x81, &mut x82, x1, (arg2[5])); + let mut x83: u32 = 0; + let mut x84: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x83, &mut x84, x1, (arg2[4])); + let mut x85: u32 = 0; + let mut x86: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x85, &mut x86, x1, (arg2[3])); + let mut x87: u32 = 0; + let mut x88: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x87, &mut x88, x1, (arg2[2])); + let mut x89: u32 = 0; + let mut x90: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x89, &mut x90, x1, (arg2[1])); + let mut x91: u32 = 0; + let mut x92: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x91, &mut x92, x1, (arg2[0])); + let mut x93: u32 = 0; + let mut x94: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x93, &mut x94, 0x0, x92, x89); + let mut x95: u32 = 0; + let mut x96: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x95, &mut x96, x94, x90, x87); + let mut x97: u32 = 0; + let mut x98: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x97, &mut x98, x96, x88, x85); + let mut x99: u32 = 0; + let mut x100: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x99, &mut x100, x98, x86, x83); + let mut x101: u32 = 0; + let mut x102: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x101, &mut x102, x100, x84, x81); + let mut x103: u32 = 0; + let mut x104: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x103, &mut x104, x102, x82, x79); + let mut x105: u32 = 0; + let mut x106: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x105, &mut x106, x104, x80, x77); + let x107: u32 = ((x106 as u32) + x78); + let mut x108: u32 = 0; + let mut x109: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x108, &mut x109, 0x0, x61, x91); + let mut x110: u32 = 0; + let mut x111: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x110, &mut x111, x109, x63, x93); + let mut x112: u32 = 0; + let mut x113: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x112, &mut x113, x111, x65, x95); + let mut x114: u32 = 0; + let mut x115: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x114, &mut x115, x113, x67, x97); + let mut x116: u32 = 0; + let mut x117: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x116, &mut x117, x115, x69, x99); + let mut x118: u32 = 0; + let mut x119: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x118, &mut x119, x117, x71, x101); + let mut x120: u32 = 0; + let mut x121: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x120, &mut x121, x119, x73, x103); + let mut x122: u32 = 0; + let mut x123: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x122, &mut x123, x121, x75, x105); + let mut x124: u32 = 0; + let mut x125: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x124, &mut x125, x123, (x76 as u32), x107); + let mut x126: u32 = 0; + let mut x127: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x126, &mut x127, x108, 0x12547e1b); + let mut x128: u32 = 0; + let mut x129: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x128, &mut x129, x126, 0x10000000); + let mut x130: u32 = 0; + let mut x131: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x130, &mut x131, x126, 0x14def9de); + let mut x132: u32 = 0; + let mut x133: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x132, &mut x133, x126, 0xa2f79cd6); + let mut x134: u32 = 0; + let mut x135: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x134, &mut x135, x126, 0x5812631a); + let mut x136: u32 = 0; + let mut x137: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x136, &mut x137, x126, 0x5cf5d3ed); + let mut x138: u32 = 0; + let mut x139: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x138, &mut x139, 0x0, x137, x134); + let mut x140: u32 = 0; + let mut x141: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x140, &mut x141, x139, x135, x132); + let mut x142: u32 = 0; + let mut x143: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x142, &mut x143, x141, x133, x130); + let x144: u32 = ((x143 as u32) + x131); + let mut x145: u32 = 0; + let mut x146: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x145, &mut x146, 0x0, x108, x136); + let mut x147: u32 = 0; + let mut x148: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x147, &mut x148, x146, x110, x138); + let mut x149: u32 = 0; + let mut x150: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x149, &mut x150, x148, x112, x140); + let mut x151: u32 = 0; + let mut x152: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x151, &mut x152, x150, x114, x142); + let mut x153: u32 = 0; + let mut x154: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x153, &mut x154, x152, x116, x144); + let mut x155: u32 = 0; + let mut x156: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x155, &mut x156, x154, x118, (0x0 as u32)); + let mut x157: u32 = 0; + let mut x158: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x157, &mut x158, x156, x120, (0x0 as u32)); + let mut x159: u32 = 0; + let mut x160: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x159, &mut x160, x158, x122, x128); + let mut x161: u32 = 0; + let mut x162: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x161, &mut x162, x160, x124, x129); + let x163: u32 = ((x162 as u32) + (x125 as u32)); + let mut x164: u32 = 0; + let mut x165: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x164, &mut x165, x2, (arg2[7])); + let mut x166: u32 = 0; + let mut x167: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x166, &mut x167, x2, (arg2[6])); + let mut x168: u32 = 0; + let mut x169: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x168, &mut x169, x2, (arg2[5])); + let mut x170: u32 = 0; + let mut x171: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x170, &mut x171, x2, (arg2[4])); + let mut x172: u32 = 0; + let mut x173: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x172, &mut x173, x2, (arg2[3])); + let mut x174: u32 = 0; + let mut x175: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x174, &mut x175, x2, (arg2[2])); + let mut x176: u32 = 0; + let mut x177: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x176, &mut x177, x2, (arg2[1])); + let mut x178: u32 = 0; + let mut x179: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x178, &mut x179, x2, (arg2[0])); + let mut x180: u32 = 0; + let mut x181: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x180, &mut x181, 0x0, x179, x176); + let mut x182: u32 = 0; + let mut x183: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x182, &mut x183, x181, x177, x174); + let mut x184: u32 = 0; + let mut x185: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x184, &mut x185, x183, x175, x172); + let mut x186: u32 = 0; + let mut x187: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x186, &mut x187, x185, x173, x170); + let mut x188: u32 = 0; + let mut x189: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x188, &mut x189, x187, x171, x168); + let mut x190: u32 = 0; + let mut x191: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x190, &mut x191, x189, x169, x166); + let mut x192: u32 = 0; + let mut x193: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x192, &mut x193, x191, x167, x164); + let x194: u32 = ((x193 as u32) + x165); + let mut x195: u32 = 0; + let mut x196: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x195, &mut x196, 0x0, x147, x178); + let mut x197: u32 = 0; + let mut x198: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x197, &mut x198, x196, x149, x180); + let mut x199: u32 = 0; + let mut x200: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x199, &mut x200, x198, x151, x182); + let mut x201: u32 = 0; + let mut x202: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x201, &mut x202, x200, x153, x184); + let mut x203: u32 = 0; + let mut x204: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x203, &mut x204, x202, x155, x186); + let mut x205: u32 = 0; + let mut x206: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x205, &mut x206, x204, x157, x188); + let mut x207: u32 = 0; + let mut x208: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x207, &mut x208, x206, x159, x190); + let mut x209: u32 = 0; + let mut x210: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x209, &mut x210, x208, x161, x192); + let mut x211: u32 = 0; + let mut x212: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x211, &mut x212, x210, x163, x194); + let mut x213: u32 = 0; + let mut x214: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x213, &mut x214, x195, 0x12547e1b); + let mut x215: u32 = 0; + let mut x216: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x215, &mut x216, x213, 0x10000000); + let mut x217: u32 = 0; + let mut x218: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x217, &mut x218, x213, 0x14def9de); + let mut x219: u32 = 0; + let mut x220: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x219, &mut x220, x213, 0xa2f79cd6); + let mut x221: u32 = 0; + let mut x222: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x221, &mut x222, x213, 0x5812631a); + let mut x223: u32 = 0; + let mut x224: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x223, &mut x224, x213, 0x5cf5d3ed); + let mut x225: u32 = 0; + let mut x226: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x225, &mut x226, 0x0, x224, x221); + let mut x227: u32 = 0; + let mut x228: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x227, &mut x228, x226, x222, x219); + let mut x229: u32 = 0; + let mut x230: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x229, &mut x230, x228, x220, x217); + let x231: u32 = ((x230 as u32) + x218); + let mut x232: u32 = 0; + let mut x233: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x232, &mut x233, 0x0, x195, x223); + let mut x234: u32 = 0; + let mut x235: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x234, &mut x235, x233, x197, x225); + let mut x236: u32 = 0; + let mut x237: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x236, &mut x237, x235, x199, x227); + let mut x238: u32 = 0; + let mut x239: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x238, &mut x239, x237, x201, x229); + let mut x240: u32 = 0; + let mut x241: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x240, &mut x241, x239, x203, x231); + let mut x242: u32 = 0; + let mut x243: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x242, &mut x243, x241, x205, (0x0 as u32)); + let mut x244: u32 = 0; + let mut x245: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x244, &mut x245, x243, x207, (0x0 as u32)); + let mut x246: u32 = 0; + let mut x247: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x246, &mut x247, x245, x209, x215); + let mut x248: u32 = 0; + let mut x249: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x248, &mut x249, x247, x211, x216); + let x250: u32 = ((x249 as u32) + (x212 as u32)); + let mut x251: u32 = 0; + let mut x252: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x251, &mut x252, x3, (arg2[7])); + let mut x253: u32 = 0; + let mut x254: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x253, &mut x254, x3, (arg2[6])); + let mut x255: u32 = 0; + let mut x256: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x255, &mut x256, x3, (arg2[5])); + let mut x257: u32 = 0; + let mut x258: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x257, &mut x258, x3, (arg2[4])); + let mut x259: u32 = 0; + let mut x260: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x259, &mut x260, x3, (arg2[3])); + let mut x261: u32 = 0; + let mut x262: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x261, &mut x262, x3, (arg2[2])); + let mut x263: u32 = 0; + let mut x264: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x263, &mut x264, x3, (arg2[1])); + let mut x265: u32 = 0; + let mut x266: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x265, &mut x266, x3, (arg2[0])); + let mut x267: u32 = 0; + let mut x268: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x267, &mut x268, 0x0, x266, x263); + let mut x269: u32 = 0; + let mut x270: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x269, &mut x270, x268, x264, x261); + let mut x271: u32 = 0; + let mut x272: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x271, &mut x272, x270, x262, x259); + let mut x273: u32 = 0; + let mut x274: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x273, &mut x274, x272, x260, x257); + let mut x275: u32 = 0; + let mut x276: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x275, &mut x276, x274, x258, x255); + let mut x277: u32 = 0; + let mut x278: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x277, &mut x278, x276, x256, x253); + let mut x279: u32 = 0; + let mut x280: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x279, &mut x280, x278, x254, x251); + let x281: u32 = ((x280 as u32) + x252); + let mut x282: u32 = 0; + let mut x283: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x282, &mut x283, 0x0, x234, x265); + let mut x284: u32 = 0; + let mut x285: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x284, &mut x285, x283, x236, x267); + let mut x286: u32 = 0; + let mut x287: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x286, &mut x287, x285, x238, x269); + let mut x288: u32 = 0; + let mut x289: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x288, &mut x289, x287, x240, x271); + let mut x290: u32 = 0; + let mut x291: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x290, &mut x291, x289, x242, x273); + let mut x292: u32 = 0; + let mut x293: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x292, &mut x293, x291, x244, x275); + let mut x294: u32 = 0; + let mut x295: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x294, &mut x295, x293, x246, x277); + let mut x296: u32 = 0; + let mut x297: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x296, &mut x297, x295, x248, x279); + let mut x298: u32 = 0; + let mut x299: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x298, &mut x299, x297, x250, x281); + let mut x300: u32 = 0; + let mut x301: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x300, &mut x301, x282, 0x12547e1b); + let mut x302: u32 = 0; + let mut x303: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x302, &mut x303, x300, 0x10000000); + let mut x304: u32 = 0; + let mut x305: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x304, &mut x305, x300, 0x14def9de); + let mut x306: u32 = 0; + let mut x307: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x306, &mut x307, x300, 0xa2f79cd6); + let mut x308: u32 = 0; + let mut x309: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x308, &mut x309, x300, 0x5812631a); + let mut x310: u32 = 0; + let mut x311: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x310, &mut x311, x300, 0x5cf5d3ed); + let mut x312: u32 = 0; + let mut x313: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x312, &mut x313, 0x0, x311, x308); + let mut x314: u32 = 0; + let mut x315: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x314, &mut x315, x313, x309, x306); + let mut x316: u32 = 0; + let mut x317: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x316, &mut x317, x315, x307, x304); + let x318: u32 = ((x317 as u32) + x305); + let mut x319: u32 = 0; + let mut x320: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x319, &mut x320, 0x0, x282, x310); + let mut x321: u32 = 0; + let mut x322: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x321, &mut x322, x320, x284, x312); + let mut x323: u32 = 0; + let mut x324: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x323, &mut x324, x322, x286, x314); + let mut x325: u32 = 0; + let mut x326: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x325, &mut x326, x324, x288, x316); + let mut x327: u32 = 0; + let mut x328: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x327, &mut x328, x326, x290, x318); + let mut x329: u32 = 0; + let mut x330: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x329, &mut x330, x328, x292, (0x0 as u32)); + let mut x331: u32 = 0; + let mut x332: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x331, &mut x332, x330, x294, (0x0 as u32)); + let mut x333: u32 = 0; + let mut x334: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x333, &mut x334, x332, x296, x302); + let mut x335: u32 = 0; + let mut x336: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x335, &mut x336, x334, x298, x303); + let x337: u32 = ((x336 as u32) + (x299 as u32)); + let mut x338: u32 = 0; + let mut x339: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x338, &mut x339, x4, (arg2[7])); + let mut x340: u32 = 0; + let mut x341: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x340, &mut x341, x4, (arg2[6])); + let mut x342: u32 = 0; + let mut x343: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x342, &mut x343, x4, (arg2[5])); + let mut x344: u32 = 0; + let mut x345: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x344, &mut x345, x4, (arg2[4])); + let mut x346: u32 = 0; + let mut x347: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x346, &mut x347, x4, (arg2[3])); + let mut x348: u32 = 0; + let mut x349: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x348, &mut x349, x4, (arg2[2])); + let mut x350: u32 = 0; + let mut x351: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x350, &mut x351, x4, (arg2[1])); + let mut x352: u32 = 0; + let mut x353: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x352, &mut x353, x4, (arg2[0])); + let mut x354: u32 = 0; + let mut x355: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x354, &mut x355, 0x0, x353, x350); + let mut x356: u32 = 0; + let mut x357: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x356, &mut x357, x355, x351, x348); + let mut x358: u32 = 0; + let mut x359: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x358, &mut x359, x357, x349, x346); + let mut x360: u32 = 0; + let mut x361: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x360, &mut x361, x359, x347, x344); + let mut x362: u32 = 0; + let mut x363: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x362, &mut x363, x361, x345, x342); + let mut x364: u32 = 0; + let mut x365: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x364, &mut x365, x363, x343, x340); + let mut x366: u32 = 0; + let mut x367: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x366, &mut x367, x365, x341, x338); + let x368: u32 = ((x367 as u32) + x339); + let mut x369: u32 = 0; + let mut x370: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x369, &mut x370, 0x0, x321, x352); + let mut x371: u32 = 0; + let mut x372: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x371, &mut x372, x370, x323, x354); + let mut x373: u32 = 0; + let mut x374: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x373, &mut x374, x372, x325, x356); + let mut x375: u32 = 0; + let mut x376: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x375, &mut x376, x374, x327, x358); + let mut x377: u32 = 0; + let mut x378: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x377, &mut x378, x376, x329, x360); + let mut x379: u32 = 0; + let mut x380: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x379, &mut x380, x378, x331, x362); + let mut x381: u32 = 0; + let mut x382: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x381, &mut x382, x380, x333, x364); + let mut x383: u32 = 0; + let mut x384: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x383, &mut x384, x382, x335, x366); + let mut x385: u32 = 0; + let mut x386: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x385, &mut x386, x384, x337, x368); + let mut x387: u32 = 0; + let mut x388: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x387, &mut x388, x369, 0x12547e1b); + let mut x389: u32 = 0; + let mut x390: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x389, &mut x390, x387, 0x10000000); + let mut x391: u32 = 0; + let mut x392: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x391, &mut x392, x387, 0x14def9de); + let mut x393: u32 = 0; + let mut x394: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x393, &mut x394, x387, 0xa2f79cd6); + let mut x395: u32 = 0; + let mut x396: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x395, &mut x396, x387, 0x5812631a); + let mut x397: u32 = 0; + let mut x398: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x397, &mut x398, x387, 0x5cf5d3ed); + let mut x399: u32 = 0; + let mut x400: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x399, &mut x400, 0x0, x398, x395); + let mut x401: u32 = 0; + let mut x402: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x401, &mut x402, x400, x396, x393); + let mut x403: u32 = 0; + let mut x404: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x403, &mut x404, x402, x394, x391); + let x405: u32 = ((x404 as u32) + x392); + let mut x406: u32 = 0; + let mut x407: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x406, &mut x407, 0x0, x369, x397); + let mut x408: u32 = 0; + let mut x409: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x408, &mut x409, x407, x371, x399); + let mut x410: u32 = 0; + let mut x411: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x410, &mut x411, x409, x373, x401); + let mut x412: u32 = 0; + let mut x413: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x412, &mut x413, x411, x375, x403); + let mut x414: u32 = 0; + let mut x415: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x414, &mut x415, x413, x377, x405); + let mut x416: u32 = 0; + let mut x417: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x416, &mut x417, x415, x379, (0x0 as u32)); + let mut x418: u32 = 0; + let mut x419: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x418, &mut x419, x417, x381, (0x0 as u32)); + let mut x420: u32 = 0; + let mut x421: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x420, &mut x421, x419, x383, x389); + let mut x422: u32 = 0; + let mut x423: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x422, &mut x423, x421, x385, x390); + let x424: u32 = ((x423 as u32) + (x386 as u32)); + let mut x425: u32 = 0; + let mut x426: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x425, &mut x426, x5, (arg2[7])); + let mut x427: u32 = 0; + let mut x428: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x427, &mut x428, x5, (arg2[6])); + let mut x429: u32 = 0; + let mut x430: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x429, &mut x430, x5, (arg2[5])); + let mut x431: u32 = 0; + let mut x432: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x431, &mut x432, x5, (arg2[4])); + let mut x433: u32 = 0; + let mut x434: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x433, &mut x434, x5, (arg2[3])); + let mut x435: u32 = 0; + let mut x436: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x435, &mut x436, x5, (arg2[2])); + let mut x437: u32 = 0; + let mut x438: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x437, &mut x438, x5, (arg2[1])); + let mut x439: u32 = 0; + let mut x440: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x439, &mut x440, x5, (arg2[0])); + let mut x441: u32 = 0; + let mut x442: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x441, &mut x442, 0x0, x440, x437); + let mut x443: u32 = 0; + let mut x444: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x443, &mut x444, x442, x438, x435); + let mut x445: u32 = 0; + let mut x446: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x445, &mut x446, x444, x436, x433); + let mut x447: u32 = 0; + let mut x448: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x447, &mut x448, x446, x434, x431); + let mut x449: u32 = 0; + let mut x450: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x449, &mut x450, x448, x432, x429); + let mut x451: u32 = 0; + let mut x452: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x451, &mut x452, x450, x430, x427); + let mut x453: u32 = 0; + let mut x454: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x453, &mut x454, x452, x428, x425); + let x455: u32 = ((x454 as u32) + x426); + let mut x456: u32 = 0; + let mut x457: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x456, &mut x457, 0x0, x408, x439); + let mut x458: u32 = 0; + let mut x459: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x458, &mut x459, x457, x410, x441); + let mut x460: u32 = 0; + let mut x461: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x460, &mut x461, x459, x412, x443); + let mut x462: u32 = 0; + let mut x463: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x462, &mut x463, x461, x414, x445); + let mut x464: u32 = 0; + let mut x465: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x464, &mut x465, x463, x416, x447); + let mut x466: u32 = 0; + let mut x467: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x466, &mut x467, x465, x418, x449); + let mut x468: u32 = 0; + let mut x469: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x468, &mut x469, x467, x420, x451); + let mut x470: u32 = 0; + let mut x471: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x470, &mut x471, x469, x422, x453); + let mut x472: u32 = 0; + let mut x473: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x472, &mut x473, x471, x424, x455); + let mut x474: u32 = 0; + let mut x475: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x474, &mut x475, x456, 0x12547e1b); + let mut x476: u32 = 0; + let mut x477: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x476, &mut x477, x474, 0x10000000); + let mut x478: u32 = 0; + let mut x479: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x478, &mut x479, x474, 0x14def9de); + let mut x480: u32 = 0; + let mut x481: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x480, &mut x481, x474, 0xa2f79cd6); + let mut x482: u32 = 0; + let mut x483: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x482, &mut x483, x474, 0x5812631a); + let mut x484: u32 = 0; + let mut x485: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x484, &mut x485, x474, 0x5cf5d3ed); + let mut x486: u32 = 0; + let mut x487: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x486, &mut x487, 0x0, x485, x482); + let mut x488: u32 = 0; + let mut x489: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x488, &mut x489, x487, x483, x480); + let mut x490: u32 = 0; + let mut x491: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x490, &mut x491, x489, x481, x478); + let x492: u32 = ((x491 as u32) + x479); + let mut x493: u32 = 0; + let mut x494: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x493, &mut x494, 0x0, x456, x484); + let mut x495: u32 = 0; + let mut x496: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x495, &mut x496, x494, x458, x486); + let mut x497: u32 = 0; + let mut x498: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x497, &mut x498, x496, x460, x488); + let mut x499: u32 = 0; + let mut x500: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x499, &mut x500, x498, x462, x490); + let mut x501: u32 = 0; + let mut x502: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x501, &mut x502, x500, x464, x492); + let mut x503: u32 = 0; + let mut x504: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x503, &mut x504, x502, x466, (0x0 as u32)); + let mut x505: u32 = 0; + let mut x506: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x505, &mut x506, x504, x468, (0x0 as u32)); + let mut x507: u32 = 0; + let mut x508: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x507, &mut x508, x506, x470, x476); + let mut x509: u32 = 0; + let mut x510: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x509, &mut x510, x508, x472, x477); + let x511: u32 = ((x510 as u32) + (x473 as u32)); + let mut x512: u32 = 0; + let mut x513: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x512, &mut x513, x6, (arg2[7])); + let mut x514: u32 = 0; + let mut x515: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x514, &mut x515, x6, (arg2[6])); + let mut x516: u32 = 0; + let mut x517: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x516, &mut x517, x6, (arg2[5])); + let mut x518: u32 = 0; + let mut x519: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x518, &mut x519, x6, (arg2[4])); + let mut x520: u32 = 0; + let mut x521: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x520, &mut x521, x6, (arg2[3])); + let mut x522: u32 = 0; + let mut x523: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x522, &mut x523, x6, (arg2[2])); + let mut x524: u32 = 0; + let mut x525: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x524, &mut x525, x6, (arg2[1])); + let mut x526: u32 = 0; + let mut x527: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x526, &mut x527, x6, (arg2[0])); + let mut x528: u32 = 0; + let mut x529: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x528, &mut x529, 0x0, x527, x524); + let mut x530: u32 = 0; + let mut x531: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x530, &mut x531, x529, x525, x522); + let mut x532: u32 = 0; + let mut x533: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x532, &mut x533, x531, x523, x520); + let mut x534: u32 = 0; + let mut x535: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x534, &mut x535, x533, x521, x518); + let mut x536: u32 = 0; + let mut x537: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x536, &mut x537, x535, x519, x516); + let mut x538: u32 = 0; + let mut x539: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x538, &mut x539, x537, x517, x514); + let mut x540: u32 = 0; + let mut x541: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x540, &mut x541, x539, x515, x512); + let x542: u32 = ((x541 as u32) + x513); + let mut x543: u32 = 0; + let mut x544: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x543, &mut x544, 0x0, x495, x526); + let mut x545: u32 = 0; + let mut x546: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x545, &mut x546, x544, x497, x528); + let mut x547: u32 = 0; + let mut x548: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x547, &mut x548, x546, x499, x530); + let mut x549: u32 = 0; + let mut x550: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x549, &mut x550, x548, x501, x532); + let mut x551: u32 = 0; + let mut x552: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x551, &mut x552, x550, x503, x534); + let mut x553: u32 = 0; + let mut x554: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x553, &mut x554, x552, x505, x536); + let mut x555: u32 = 0; + let mut x556: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x555, &mut x556, x554, x507, x538); + let mut x557: u32 = 0; + let mut x558: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x557, &mut x558, x556, x509, x540); + let mut x559: u32 = 0; + let mut x560: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x559, &mut x560, x558, x511, x542); + let mut x561: u32 = 0; + let mut x562: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x561, &mut x562, x543, 0x12547e1b); + let mut x563: u32 = 0; + let mut x564: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x563, &mut x564, x561, 0x10000000); + let mut x565: u32 = 0; + let mut x566: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x565, &mut x566, x561, 0x14def9de); + let mut x567: u32 = 0; + let mut x568: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x567, &mut x568, x561, 0xa2f79cd6); + let mut x569: u32 = 0; + let mut x570: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x569, &mut x570, x561, 0x5812631a); + let mut x571: u32 = 0; + let mut x572: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x571, &mut x572, x561, 0x5cf5d3ed); + let mut x573: u32 = 0; + let mut x574: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x573, &mut x574, 0x0, x572, x569); + let mut x575: u32 = 0; + let mut x576: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x575, &mut x576, x574, x570, x567); + let mut x577: u32 = 0; + let mut x578: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x577, &mut x578, x576, x568, x565); + let x579: u32 = ((x578 as u32) + x566); + let mut x580: u32 = 0; + let mut x581: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x580, &mut x581, 0x0, x543, x571); + let mut x582: u32 = 0; + let mut x583: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x582, &mut x583, x581, x545, x573); + let mut x584: u32 = 0; + let mut x585: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x584, &mut x585, x583, x547, x575); + let mut x586: u32 = 0; + let mut x587: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x586, &mut x587, x585, x549, x577); + let mut x588: u32 = 0; + let mut x589: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x588, &mut x589, x587, x551, x579); + let mut x590: u32 = 0; + let mut x591: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x590, &mut x591, x589, x553, (0x0 as u32)); + let mut x592: u32 = 0; + let mut x593: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x592, &mut x593, x591, x555, (0x0 as u32)); + let mut x594: u32 = 0; + let mut x595: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x594, &mut x595, x593, x557, x563); + let mut x596: u32 = 0; + let mut x597: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x596, &mut x597, x595, x559, x564); + let x598: u32 = ((x597 as u32) + (x560 as u32)); + let mut x599: u32 = 0; + let mut x600: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x599, &mut x600, x7, (arg2[7])); + let mut x601: u32 = 0; + let mut x602: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x601, &mut x602, x7, (arg2[6])); + let mut x603: u32 = 0; + let mut x604: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x603, &mut x604, x7, (arg2[5])); + let mut x605: u32 = 0; + let mut x606: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x605, &mut x606, x7, (arg2[4])); + let mut x607: u32 = 0; + let mut x608: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x607, &mut x608, x7, (arg2[3])); + let mut x609: u32 = 0; + let mut x610: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x609, &mut x610, x7, (arg2[2])); + let mut x611: u32 = 0; + let mut x612: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x611, &mut x612, x7, (arg2[1])); + let mut x613: u32 = 0; + let mut x614: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x613, &mut x614, x7, (arg2[0])); + let mut x615: u32 = 0; + let mut x616: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x615, &mut x616, 0x0, x614, x611); + let mut x617: u32 = 0; + let mut x618: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x617, &mut x618, x616, x612, x609); + let mut x619: u32 = 0; + let mut x620: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x619, &mut x620, x618, x610, x607); + let mut x621: u32 = 0; + let mut x622: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x621, &mut x622, x620, x608, x605); + let mut x623: u32 = 0; + let mut x624: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x623, &mut x624, x622, x606, x603); + let mut x625: u32 = 0; + let mut x626: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x625, &mut x626, x624, x604, x601); + let mut x627: u32 = 0; + let mut x628: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x627, &mut x628, x626, x602, x599); + let x629: u32 = ((x628 as u32) + x600); + let mut x630: u32 = 0; + let mut x631: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x630, &mut x631, 0x0, x582, x613); + let mut x632: u32 = 0; + let mut x633: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x632, &mut x633, x631, x584, x615); + let mut x634: u32 = 0; + let mut x635: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x634, &mut x635, x633, x586, x617); + let mut x636: u32 = 0; + let mut x637: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x636, &mut x637, x635, x588, x619); + let mut x638: u32 = 0; + let mut x639: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x638, &mut x639, x637, x590, x621); + let mut x640: u32 = 0; + let mut x641: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x640, &mut x641, x639, x592, x623); + let mut x642: u32 = 0; + let mut x643: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x642, &mut x643, x641, x594, x625); + let mut x644: u32 = 0; + let mut x645: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x644, &mut x645, x643, x596, x627); + let mut x646: u32 = 0; + let mut x647: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x646, &mut x647, x645, x598, x629); + let mut x648: u32 = 0; + let mut x649: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x648, &mut x649, x630, 0x12547e1b); + let mut x650: u32 = 0; + let mut x651: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x650, &mut x651, x648, 0x10000000); + let mut x652: u32 = 0; + let mut x653: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x652, &mut x653, x648, 0x14def9de); + let mut x654: u32 = 0; + let mut x655: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x654, &mut x655, x648, 0xa2f79cd6); + let mut x656: u32 = 0; + let mut x657: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x656, &mut x657, x648, 0x5812631a); + let mut x658: u32 = 0; + let mut x659: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x658, &mut x659, x648, 0x5cf5d3ed); + let mut x660: u32 = 0; + let mut x661: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x660, &mut x661, 0x0, x659, x656); + let mut x662: u32 = 0; + let mut x663: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x662, &mut x663, x661, x657, x654); + let mut x664: u32 = 0; + let mut x665: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x664, &mut x665, x663, x655, x652); + let x666: u32 = ((x665 as u32) + x653); + let mut x667: u32 = 0; + let mut x668: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x667, &mut x668, 0x0, x630, x658); + let mut x669: u32 = 0; + let mut x670: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x669, &mut x670, x668, x632, x660); + let mut x671: u32 = 0; + let mut x672: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x671, &mut x672, x670, x634, x662); + let mut x673: u32 = 0; + let mut x674: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x673, &mut x674, x672, x636, x664); + let mut x675: u32 = 0; + let mut x676: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x675, &mut x676, x674, x638, x666); + let mut x677: u32 = 0; + let mut x678: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x677, &mut x678, x676, x640, (0x0 as u32)); + let mut x679: u32 = 0; + let mut x680: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x679, &mut x680, x678, x642, (0x0 as u32)); + let mut x681: u32 = 0; + let mut x682: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x681, &mut x682, x680, x644, x650); + let mut x683: u32 = 0; + let mut x684: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x683, &mut x684, x682, x646, x651); + let x685: u32 = ((x684 as u32) + (x647 as u32)); + let mut x686: u32 = 0; + let mut x687: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x686, &mut x687, 0x0, x669, 0x5cf5d3ed); + let mut x688: u32 = 0; + let mut x689: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x688, &mut x689, x687, x671, 0x5812631a); + let mut x690: u32 = 0; + let mut x691: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x690, &mut x691, x689, x673, 0xa2f79cd6); + let mut x692: u32 = 0; + let mut x693: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x692, &mut x693, x691, x675, 0x14def9de); + let mut x694: u32 = 0; + let mut x695: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x694, &mut x695, x693, x677, (0x0 as u32)); + let mut x696: u32 = 0; + let mut x697: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x696, &mut x697, x695, x679, (0x0 as u32)); + let mut x698: u32 = 0; + let mut x699: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x698, &mut x699, x697, x681, (0x0 as u32)); + let mut x700: u32 = 0; + let mut x701: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x700, &mut x701, x699, x683, 0x10000000); + let mut x702: u32 = 0; + let mut x703: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x702, &mut x703, x701, x685, (0x0 as u32)); + let mut x704: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x704, x703, x686, x669); + let mut x705: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x705, x703, x688, x671); + let mut x706: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x706, x703, x690, x673); + let mut x707: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x707, x703, x692, x675); + let mut x708: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x708, x703, x694, x677); + let mut x709: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x709, x703, x696, x679); + let mut x710: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x710, x703, x698, x681); + let mut x711: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x711, x703, x700, x683); + out1[0] = x704; + out1[1] = x705; + out1[2] = x706; + out1[3] = x707; + out1[4] = x708; + out1[5] = x709; + out1[6] = x710; + out1[7] = x711; +} + +/// The function fiat_25519_scalar_square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_square(out1: &mut fiat_25519_scalar_montgomery_domain_field_element, arg1: &fiat_25519_scalar_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[1]); + let x2: u32 = (arg1[2]); + let x3: u32 = (arg1[3]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[5]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[7]); + let x8: u32 = (arg1[0]); + let mut x9: u32 = 0; + let mut x10: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x9, &mut x10, x8, (arg1[7])); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x11, &mut x12, x8, (arg1[6])); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x13, &mut x14, x8, (arg1[5])); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x15, &mut x16, x8, (arg1[4])); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x17, &mut x18, x8, (arg1[3])); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x19, &mut x20, x8, (arg1[2])); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x21, &mut x22, x8, (arg1[1])); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x23, &mut x24, x8, (arg1[0])); + let mut x25: u32 = 0; + let mut x26: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x37, &mut x38, x36, x12, x9); + let x39: u32 = ((x38 as u32) + x10); + let mut x40: u32 = 0; + let mut x41: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x40, &mut x41, x23, 0x12547e1b); + let mut x42: u32 = 0; + let mut x43: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x42, &mut x43, x40, 0x10000000); + let mut x44: u32 = 0; + let mut x45: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x44, &mut x45, x40, 0x14def9de); + let mut x46: u32 = 0; + let mut x47: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x46, &mut x47, x40, 0xa2f79cd6); + let mut x48: u32 = 0; + let mut x49: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x48, &mut x49, x40, 0x5812631a); + let mut x50: u32 = 0; + let mut x51: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x50, &mut x51, x40, 0x5cf5d3ed); + let mut x52: u32 = 0; + let mut x53: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x52, &mut x53, 0x0, x51, x48); + let mut x54: u32 = 0; + let mut x55: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x54, &mut x55, x53, x49, x46); + let mut x56: u32 = 0; + let mut x57: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x56, &mut x57, x55, x47, x44); + let x58: u32 = ((x57 as u32) + x45); + let mut x59: u32 = 0; + let mut x60: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x59, &mut x60, 0x0, x23, x50); + let mut x61: u32 = 0; + let mut x62: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x61, &mut x62, x60, x25, x52); + let mut x63: u32 = 0; + let mut x64: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x63, &mut x64, x62, x27, x54); + let mut x65: u32 = 0; + let mut x66: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x65, &mut x66, x64, x29, x56); + let mut x67: u32 = 0; + let mut x68: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x67, &mut x68, x66, x31, x58); + let mut x69: u32 = 0; + let mut x70: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x69, &mut x70, x68, x33, (0x0 as u32)); + let mut x71: u32 = 0; + let mut x72: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x71, &mut x72, x70, x35, (0x0 as u32)); + let mut x73: u32 = 0; + let mut x74: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x73, &mut x74, x72, x37, x42); + let mut x75: u32 = 0; + let mut x76: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x75, &mut x76, x74, x39, x43); + let mut x77: u32 = 0; + let mut x78: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x77, &mut x78, x1, (arg1[7])); + let mut x79: u32 = 0; + let mut x80: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x79, &mut x80, x1, (arg1[6])); + let mut x81: u32 = 0; + let mut x82: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x81, &mut x82, x1, (arg1[5])); + let mut x83: u32 = 0; + let mut x84: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x83, &mut x84, x1, (arg1[4])); + let mut x85: u32 = 0; + let mut x86: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x85, &mut x86, x1, (arg1[3])); + let mut x87: u32 = 0; + let mut x88: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x87, &mut x88, x1, (arg1[2])); + let mut x89: u32 = 0; + let mut x90: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x89, &mut x90, x1, (arg1[1])); + let mut x91: u32 = 0; + let mut x92: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x91, &mut x92, x1, (arg1[0])); + let mut x93: u32 = 0; + let mut x94: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x93, &mut x94, 0x0, x92, x89); + let mut x95: u32 = 0; + let mut x96: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x95, &mut x96, x94, x90, x87); + let mut x97: u32 = 0; + let mut x98: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x97, &mut x98, x96, x88, x85); + let mut x99: u32 = 0; + let mut x100: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x99, &mut x100, x98, x86, x83); + let mut x101: u32 = 0; + let mut x102: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x101, &mut x102, x100, x84, x81); + let mut x103: u32 = 0; + let mut x104: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x103, &mut x104, x102, x82, x79); + let mut x105: u32 = 0; + let mut x106: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x105, &mut x106, x104, x80, x77); + let x107: u32 = ((x106 as u32) + x78); + let mut x108: u32 = 0; + let mut x109: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x108, &mut x109, 0x0, x61, x91); + let mut x110: u32 = 0; + let mut x111: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x110, &mut x111, x109, x63, x93); + let mut x112: u32 = 0; + let mut x113: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x112, &mut x113, x111, x65, x95); + let mut x114: u32 = 0; + let mut x115: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x114, &mut x115, x113, x67, x97); + let mut x116: u32 = 0; + let mut x117: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x116, &mut x117, x115, x69, x99); + let mut x118: u32 = 0; + let mut x119: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x118, &mut x119, x117, x71, x101); + let mut x120: u32 = 0; + let mut x121: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x120, &mut x121, x119, x73, x103); + let mut x122: u32 = 0; + let mut x123: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x122, &mut x123, x121, x75, x105); + let mut x124: u32 = 0; + let mut x125: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x124, &mut x125, x123, (x76 as u32), x107); + let mut x126: u32 = 0; + let mut x127: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x126, &mut x127, x108, 0x12547e1b); + let mut x128: u32 = 0; + let mut x129: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x128, &mut x129, x126, 0x10000000); + let mut x130: u32 = 0; + let mut x131: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x130, &mut x131, x126, 0x14def9de); + let mut x132: u32 = 0; + let mut x133: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x132, &mut x133, x126, 0xa2f79cd6); + let mut x134: u32 = 0; + let mut x135: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x134, &mut x135, x126, 0x5812631a); + let mut x136: u32 = 0; + let mut x137: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x136, &mut x137, x126, 0x5cf5d3ed); + let mut x138: u32 = 0; + let mut x139: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x138, &mut x139, 0x0, x137, x134); + let mut x140: u32 = 0; + let mut x141: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x140, &mut x141, x139, x135, x132); + let mut x142: u32 = 0; + let mut x143: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x142, &mut x143, x141, x133, x130); + let x144: u32 = ((x143 as u32) + x131); + let mut x145: u32 = 0; + let mut x146: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x145, &mut x146, 0x0, x108, x136); + let mut x147: u32 = 0; + let mut x148: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x147, &mut x148, x146, x110, x138); + let mut x149: u32 = 0; + let mut x150: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x149, &mut x150, x148, x112, x140); + let mut x151: u32 = 0; + let mut x152: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x151, &mut x152, x150, x114, x142); + let mut x153: u32 = 0; + let mut x154: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x153, &mut x154, x152, x116, x144); + let mut x155: u32 = 0; + let mut x156: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x155, &mut x156, x154, x118, (0x0 as u32)); + let mut x157: u32 = 0; + let mut x158: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x157, &mut x158, x156, x120, (0x0 as u32)); + let mut x159: u32 = 0; + let mut x160: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x159, &mut x160, x158, x122, x128); + let mut x161: u32 = 0; + let mut x162: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x161, &mut x162, x160, x124, x129); + let x163: u32 = ((x162 as u32) + (x125 as u32)); + let mut x164: u32 = 0; + let mut x165: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x164, &mut x165, x2, (arg1[7])); + let mut x166: u32 = 0; + let mut x167: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x166, &mut x167, x2, (arg1[6])); + let mut x168: u32 = 0; + let mut x169: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x168, &mut x169, x2, (arg1[5])); + let mut x170: u32 = 0; + let mut x171: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x170, &mut x171, x2, (arg1[4])); + let mut x172: u32 = 0; + let mut x173: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x172, &mut x173, x2, (arg1[3])); + let mut x174: u32 = 0; + let mut x175: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x174, &mut x175, x2, (arg1[2])); + let mut x176: u32 = 0; + let mut x177: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x176, &mut x177, x2, (arg1[1])); + let mut x178: u32 = 0; + let mut x179: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x178, &mut x179, x2, (arg1[0])); + let mut x180: u32 = 0; + let mut x181: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x180, &mut x181, 0x0, x179, x176); + let mut x182: u32 = 0; + let mut x183: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x182, &mut x183, x181, x177, x174); + let mut x184: u32 = 0; + let mut x185: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x184, &mut x185, x183, x175, x172); + let mut x186: u32 = 0; + let mut x187: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x186, &mut x187, x185, x173, x170); + let mut x188: u32 = 0; + let mut x189: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x188, &mut x189, x187, x171, x168); + let mut x190: u32 = 0; + let mut x191: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x190, &mut x191, x189, x169, x166); + let mut x192: u32 = 0; + let mut x193: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x192, &mut x193, x191, x167, x164); + let x194: u32 = ((x193 as u32) + x165); + let mut x195: u32 = 0; + let mut x196: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x195, &mut x196, 0x0, x147, x178); + let mut x197: u32 = 0; + let mut x198: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x197, &mut x198, x196, x149, x180); + let mut x199: u32 = 0; + let mut x200: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x199, &mut x200, x198, x151, x182); + let mut x201: u32 = 0; + let mut x202: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x201, &mut x202, x200, x153, x184); + let mut x203: u32 = 0; + let mut x204: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x203, &mut x204, x202, x155, x186); + let mut x205: u32 = 0; + let mut x206: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x205, &mut x206, x204, x157, x188); + let mut x207: u32 = 0; + let mut x208: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x207, &mut x208, x206, x159, x190); + let mut x209: u32 = 0; + let mut x210: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x209, &mut x210, x208, x161, x192); + let mut x211: u32 = 0; + let mut x212: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x211, &mut x212, x210, x163, x194); + let mut x213: u32 = 0; + let mut x214: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x213, &mut x214, x195, 0x12547e1b); + let mut x215: u32 = 0; + let mut x216: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x215, &mut x216, x213, 0x10000000); + let mut x217: u32 = 0; + let mut x218: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x217, &mut x218, x213, 0x14def9de); + let mut x219: u32 = 0; + let mut x220: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x219, &mut x220, x213, 0xa2f79cd6); + let mut x221: u32 = 0; + let mut x222: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x221, &mut x222, x213, 0x5812631a); + let mut x223: u32 = 0; + let mut x224: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x223, &mut x224, x213, 0x5cf5d3ed); + let mut x225: u32 = 0; + let mut x226: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x225, &mut x226, 0x0, x224, x221); + let mut x227: u32 = 0; + let mut x228: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x227, &mut x228, x226, x222, x219); + let mut x229: u32 = 0; + let mut x230: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x229, &mut x230, x228, x220, x217); + let x231: u32 = ((x230 as u32) + x218); + let mut x232: u32 = 0; + let mut x233: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x232, &mut x233, 0x0, x195, x223); + let mut x234: u32 = 0; + let mut x235: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x234, &mut x235, x233, x197, x225); + let mut x236: u32 = 0; + let mut x237: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x236, &mut x237, x235, x199, x227); + let mut x238: u32 = 0; + let mut x239: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x238, &mut x239, x237, x201, x229); + let mut x240: u32 = 0; + let mut x241: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x240, &mut x241, x239, x203, x231); + let mut x242: u32 = 0; + let mut x243: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x242, &mut x243, x241, x205, (0x0 as u32)); + let mut x244: u32 = 0; + let mut x245: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x244, &mut x245, x243, x207, (0x0 as u32)); + let mut x246: u32 = 0; + let mut x247: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x246, &mut x247, x245, x209, x215); + let mut x248: u32 = 0; + let mut x249: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x248, &mut x249, x247, x211, x216); + let x250: u32 = ((x249 as u32) + (x212 as u32)); + let mut x251: u32 = 0; + let mut x252: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x251, &mut x252, x3, (arg1[7])); + let mut x253: u32 = 0; + let mut x254: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x253, &mut x254, x3, (arg1[6])); + let mut x255: u32 = 0; + let mut x256: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x255, &mut x256, x3, (arg1[5])); + let mut x257: u32 = 0; + let mut x258: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x257, &mut x258, x3, (arg1[4])); + let mut x259: u32 = 0; + let mut x260: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x259, &mut x260, x3, (arg1[3])); + let mut x261: u32 = 0; + let mut x262: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x261, &mut x262, x3, (arg1[2])); + let mut x263: u32 = 0; + let mut x264: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x263, &mut x264, x3, (arg1[1])); + let mut x265: u32 = 0; + let mut x266: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x265, &mut x266, x3, (arg1[0])); + let mut x267: u32 = 0; + let mut x268: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x267, &mut x268, 0x0, x266, x263); + let mut x269: u32 = 0; + let mut x270: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x269, &mut x270, x268, x264, x261); + let mut x271: u32 = 0; + let mut x272: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x271, &mut x272, x270, x262, x259); + let mut x273: u32 = 0; + let mut x274: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x273, &mut x274, x272, x260, x257); + let mut x275: u32 = 0; + let mut x276: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x275, &mut x276, x274, x258, x255); + let mut x277: u32 = 0; + let mut x278: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x277, &mut x278, x276, x256, x253); + let mut x279: u32 = 0; + let mut x280: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x279, &mut x280, x278, x254, x251); + let x281: u32 = ((x280 as u32) + x252); + let mut x282: u32 = 0; + let mut x283: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x282, &mut x283, 0x0, x234, x265); + let mut x284: u32 = 0; + let mut x285: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x284, &mut x285, x283, x236, x267); + let mut x286: u32 = 0; + let mut x287: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x286, &mut x287, x285, x238, x269); + let mut x288: u32 = 0; + let mut x289: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x288, &mut x289, x287, x240, x271); + let mut x290: u32 = 0; + let mut x291: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x290, &mut x291, x289, x242, x273); + let mut x292: u32 = 0; + let mut x293: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x292, &mut x293, x291, x244, x275); + let mut x294: u32 = 0; + let mut x295: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x294, &mut x295, x293, x246, x277); + let mut x296: u32 = 0; + let mut x297: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x296, &mut x297, x295, x248, x279); + let mut x298: u32 = 0; + let mut x299: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x298, &mut x299, x297, x250, x281); + let mut x300: u32 = 0; + let mut x301: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x300, &mut x301, x282, 0x12547e1b); + let mut x302: u32 = 0; + let mut x303: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x302, &mut x303, x300, 0x10000000); + let mut x304: u32 = 0; + let mut x305: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x304, &mut x305, x300, 0x14def9de); + let mut x306: u32 = 0; + let mut x307: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x306, &mut x307, x300, 0xa2f79cd6); + let mut x308: u32 = 0; + let mut x309: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x308, &mut x309, x300, 0x5812631a); + let mut x310: u32 = 0; + let mut x311: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x310, &mut x311, x300, 0x5cf5d3ed); + let mut x312: u32 = 0; + let mut x313: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x312, &mut x313, 0x0, x311, x308); + let mut x314: u32 = 0; + let mut x315: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x314, &mut x315, x313, x309, x306); + let mut x316: u32 = 0; + let mut x317: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x316, &mut x317, x315, x307, x304); + let x318: u32 = ((x317 as u32) + x305); + let mut x319: u32 = 0; + let mut x320: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x319, &mut x320, 0x0, x282, x310); + let mut x321: u32 = 0; + let mut x322: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x321, &mut x322, x320, x284, x312); + let mut x323: u32 = 0; + let mut x324: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x323, &mut x324, x322, x286, x314); + let mut x325: u32 = 0; + let mut x326: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x325, &mut x326, x324, x288, x316); + let mut x327: u32 = 0; + let mut x328: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x327, &mut x328, x326, x290, x318); + let mut x329: u32 = 0; + let mut x330: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x329, &mut x330, x328, x292, (0x0 as u32)); + let mut x331: u32 = 0; + let mut x332: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x331, &mut x332, x330, x294, (0x0 as u32)); + let mut x333: u32 = 0; + let mut x334: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x333, &mut x334, x332, x296, x302); + let mut x335: u32 = 0; + let mut x336: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x335, &mut x336, x334, x298, x303); + let x337: u32 = ((x336 as u32) + (x299 as u32)); + let mut x338: u32 = 0; + let mut x339: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x338, &mut x339, x4, (arg1[7])); + let mut x340: u32 = 0; + let mut x341: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x340, &mut x341, x4, (arg1[6])); + let mut x342: u32 = 0; + let mut x343: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x342, &mut x343, x4, (arg1[5])); + let mut x344: u32 = 0; + let mut x345: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x344, &mut x345, x4, (arg1[4])); + let mut x346: u32 = 0; + let mut x347: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x346, &mut x347, x4, (arg1[3])); + let mut x348: u32 = 0; + let mut x349: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x348, &mut x349, x4, (arg1[2])); + let mut x350: u32 = 0; + let mut x351: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x350, &mut x351, x4, (arg1[1])); + let mut x352: u32 = 0; + let mut x353: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x352, &mut x353, x4, (arg1[0])); + let mut x354: u32 = 0; + let mut x355: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x354, &mut x355, 0x0, x353, x350); + let mut x356: u32 = 0; + let mut x357: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x356, &mut x357, x355, x351, x348); + let mut x358: u32 = 0; + let mut x359: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x358, &mut x359, x357, x349, x346); + let mut x360: u32 = 0; + let mut x361: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x360, &mut x361, x359, x347, x344); + let mut x362: u32 = 0; + let mut x363: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x362, &mut x363, x361, x345, x342); + let mut x364: u32 = 0; + let mut x365: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x364, &mut x365, x363, x343, x340); + let mut x366: u32 = 0; + let mut x367: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x366, &mut x367, x365, x341, x338); + let x368: u32 = ((x367 as u32) + x339); + let mut x369: u32 = 0; + let mut x370: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x369, &mut x370, 0x0, x321, x352); + let mut x371: u32 = 0; + let mut x372: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x371, &mut x372, x370, x323, x354); + let mut x373: u32 = 0; + let mut x374: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x373, &mut x374, x372, x325, x356); + let mut x375: u32 = 0; + let mut x376: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x375, &mut x376, x374, x327, x358); + let mut x377: u32 = 0; + let mut x378: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x377, &mut x378, x376, x329, x360); + let mut x379: u32 = 0; + let mut x380: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x379, &mut x380, x378, x331, x362); + let mut x381: u32 = 0; + let mut x382: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x381, &mut x382, x380, x333, x364); + let mut x383: u32 = 0; + let mut x384: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x383, &mut x384, x382, x335, x366); + let mut x385: u32 = 0; + let mut x386: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x385, &mut x386, x384, x337, x368); + let mut x387: u32 = 0; + let mut x388: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x387, &mut x388, x369, 0x12547e1b); + let mut x389: u32 = 0; + let mut x390: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x389, &mut x390, x387, 0x10000000); + let mut x391: u32 = 0; + let mut x392: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x391, &mut x392, x387, 0x14def9de); + let mut x393: u32 = 0; + let mut x394: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x393, &mut x394, x387, 0xa2f79cd6); + let mut x395: u32 = 0; + let mut x396: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x395, &mut x396, x387, 0x5812631a); + let mut x397: u32 = 0; + let mut x398: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x397, &mut x398, x387, 0x5cf5d3ed); + let mut x399: u32 = 0; + let mut x400: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x399, &mut x400, 0x0, x398, x395); + let mut x401: u32 = 0; + let mut x402: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x401, &mut x402, x400, x396, x393); + let mut x403: u32 = 0; + let mut x404: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x403, &mut x404, x402, x394, x391); + let x405: u32 = ((x404 as u32) + x392); + let mut x406: u32 = 0; + let mut x407: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x406, &mut x407, 0x0, x369, x397); + let mut x408: u32 = 0; + let mut x409: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x408, &mut x409, x407, x371, x399); + let mut x410: u32 = 0; + let mut x411: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x410, &mut x411, x409, x373, x401); + let mut x412: u32 = 0; + let mut x413: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x412, &mut x413, x411, x375, x403); + let mut x414: u32 = 0; + let mut x415: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x414, &mut x415, x413, x377, x405); + let mut x416: u32 = 0; + let mut x417: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x416, &mut x417, x415, x379, (0x0 as u32)); + let mut x418: u32 = 0; + let mut x419: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x418, &mut x419, x417, x381, (0x0 as u32)); + let mut x420: u32 = 0; + let mut x421: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x420, &mut x421, x419, x383, x389); + let mut x422: u32 = 0; + let mut x423: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x422, &mut x423, x421, x385, x390); + let x424: u32 = ((x423 as u32) + (x386 as u32)); + let mut x425: u32 = 0; + let mut x426: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x425, &mut x426, x5, (arg1[7])); + let mut x427: u32 = 0; + let mut x428: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x427, &mut x428, x5, (arg1[6])); + let mut x429: u32 = 0; + let mut x430: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x429, &mut x430, x5, (arg1[5])); + let mut x431: u32 = 0; + let mut x432: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x431, &mut x432, x5, (arg1[4])); + let mut x433: u32 = 0; + let mut x434: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x433, &mut x434, x5, (arg1[3])); + let mut x435: u32 = 0; + let mut x436: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x435, &mut x436, x5, (arg1[2])); + let mut x437: u32 = 0; + let mut x438: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x437, &mut x438, x5, (arg1[1])); + let mut x439: u32 = 0; + let mut x440: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x439, &mut x440, x5, (arg1[0])); + let mut x441: u32 = 0; + let mut x442: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x441, &mut x442, 0x0, x440, x437); + let mut x443: u32 = 0; + let mut x444: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x443, &mut x444, x442, x438, x435); + let mut x445: u32 = 0; + let mut x446: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x445, &mut x446, x444, x436, x433); + let mut x447: u32 = 0; + let mut x448: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x447, &mut x448, x446, x434, x431); + let mut x449: u32 = 0; + let mut x450: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x449, &mut x450, x448, x432, x429); + let mut x451: u32 = 0; + let mut x452: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x451, &mut x452, x450, x430, x427); + let mut x453: u32 = 0; + let mut x454: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x453, &mut x454, x452, x428, x425); + let x455: u32 = ((x454 as u32) + x426); + let mut x456: u32 = 0; + let mut x457: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x456, &mut x457, 0x0, x408, x439); + let mut x458: u32 = 0; + let mut x459: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x458, &mut x459, x457, x410, x441); + let mut x460: u32 = 0; + let mut x461: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x460, &mut x461, x459, x412, x443); + let mut x462: u32 = 0; + let mut x463: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x462, &mut x463, x461, x414, x445); + let mut x464: u32 = 0; + let mut x465: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x464, &mut x465, x463, x416, x447); + let mut x466: u32 = 0; + let mut x467: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x466, &mut x467, x465, x418, x449); + let mut x468: u32 = 0; + let mut x469: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x468, &mut x469, x467, x420, x451); + let mut x470: u32 = 0; + let mut x471: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x470, &mut x471, x469, x422, x453); + let mut x472: u32 = 0; + let mut x473: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x472, &mut x473, x471, x424, x455); + let mut x474: u32 = 0; + let mut x475: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x474, &mut x475, x456, 0x12547e1b); + let mut x476: u32 = 0; + let mut x477: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x476, &mut x477, x474, 0x10000000); + let mut x478: u32 = 0; + let mut x479: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x478, &mut x479, x474, 0x14def9de); + let mut x480: u32 = 0; + let mut x481: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x480, &mut x481, x474, 0xa2f79cd6); + let mut x482: u32 = 0; + let mut x483: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x482, &mut x483, x474, 0x5812631a); + let mut x484: u32 = 0; + let mut x485: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x484, &mut x485, x474, 0x5cf5d3ed); + let mut x486: u32 = 0; + let mut x487: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x486, &mut x487, 0x0, x485, x482); + let mut x488: u32 = 0; + let mut x489: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x488, &mut x489, x487, x483, x480); + let mut x490: u32 = 0; + let mut x491: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x490, &mut x491, x489, x481, x478); + let x492: u32 = ((x491 as u32) + x479); + let mut x493: u32 = 0; + let mut x494: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x493, &mut x494, 0x0, x456, x484); + let mut x495: u32 = 0; + let mut x496: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x495, &mut x496, x494, x458, x486); + let mut x497: u32 = 0; + let mut x498: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x497, &mut x498, x496, x460, x488); + let mut x499: u32 = 0; + let mut x500: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x499, &mut x500, x498, x462, x490); + let mut x501: u32 = 0; + let mut x502: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x501, &mut x502, x500, x464, x492); + let mut x503: u32 = 0; + let mut x504: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x503, &mut x504, x502, x466, (0x0 as u32)); + let mut x505: u32 = 0; + let mut x506: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x505, &mut x506, x504, x468, (0x0 as u32)); + let mut x507: u32 = 0; + let mut x508: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x507, &mut x508, x506, x470, x476); + let mut x509: u32 = 0; + let mut x510: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x509, &mut x510, x508, x472, x477); + let x511: u32 = ((x510 as u32) + (x473 as u32)); + let mut x512: u32 = 0; + let mut x513: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x512, &mut x513, x6, (arg1[7])); + let mut x514: u32 = 0; + let mut x515: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x514, &mut x515, x6, (arg1[6])); + let mut x516: u32 = 0; + let mut x517: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x516, &mut x517, x6, (arg1[5])); + let mut x518: u32 = 0; + let mut x519: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x518, &mut x519, x6, (arg1[4])); + let mut x520: u32 = 0; + let mut x521: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x520, &mut x521, x6, (arg1[3])); + let mut x522: u32 = 0; + let mut x523: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x522, &mut x523, x6, (arg1[2])); + let mut x524: u32 = 0; + let mut x525: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x524, &mut x525, x6, (arg1[1])); + let mut x526: u32 = 0; + let mut x527: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x526, &mut x527, x6, (arg1[0])); + let mut x528: u32 = 0; + let mut x529: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x528, &mut x529, 0x0, x527, x524); + let mut x530: u32 = 0; + let mut x531: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x530, &mut x531, x529, x525, x522); + let mut x532: u32 = 0; + let mut x533: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x532, &mut x533, x531, x523, x520); + let mut x534: u32 = 0; + let mut x535: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x534, &mut x535, x533, x521, x518); + let mut x536: u32 = 0; + let mut x537: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x536, &mut x537, x535, x519, x516); + let mut x538: u32 = 0; + let mut x539: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x538, &mut x539, x537, x517, x514); + let mut x540: u32 = 0; + let mut x541: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x540, &mut x541, x539, x515, x512); + let x542: u32 = ((x541 as u32) + x513); + let mut x543: u32 = 0; + let mut x544: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x543, &mut x544, 0x0, x495, x526); + let mut x545: u32 = 0; + let mut x546: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x545, &mut x546, x544, x497, x528); + let mut x547: u32 = 0; + let mut x548: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x547, &mut x548, x546, x499, x530); + let mut x549: u32 = 0; + let mut x550: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x549, &mut x550, x548, x501, x532); + let mut x551: u32 = 0; + let mut x552: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x551, &mut x552, x550, x503, x534); + let mut x553: u32 = 0; + let mut x554: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x553, &mut x554, x552, x505, x536); + let mut x555: u32 = 0; + let mut x556: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x555, &mut x556, x554, x507, x538); + let mut x557: u32 = 0; + let mut x558: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x557, &mut x558, x556, x509, x540); + let mut x559: u32 = 0; + let mut x560: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x559, &mut x560, x558, x511, x542); + let mut x561: u32 = 0; + let mut x562: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x561, &mut x562, x543, 0x12547e1b); + let mut x563: u32 = 0; + let mut x564: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x563, &mut x564, x561, 0x10000000); + let mut x565: u32 = 0; + let mut x566: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x565, &mut x566, x561, 0x14def9de); + let mut x567: u32 = 0; + let mut x568: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x567, &mut x568, x561, 0xa2f79cd6); + let mut x569: u32 = 0; + let mut x570: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x569, &mut x570, x561, 0x5812631a); + let mut x571: u32 = 0; + let mut x572: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x571, &mut x572, x561, 0x5cf5d3ed); + let mut x573: u32 = 0; + let mut x574: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x573, &mut x574, 0x0, x572, x569); + let mut x575: u32 = 0; + let mut x576: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x575, &mut x576, x574, x570, x567); + let mut x577: u32 = 0; + let mut x578: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x577, &mut x578, x576, x568, x565); + let x579: u32 = ((x578 as u32) + x566); + let mut x580: u32 = 0; + let mut x581: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x580, &mut x581, 0x0, x543, x571); + let mut x582: u32 = 0; + let mut x583: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x582, &mut x583, x581, x545, x573); + let mut x584: u32 = 0; + let mut x585: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x584, &mut x585, x583, x547, x575); + let mut x586: u32 = 0; + let mut x587: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x586, &mut x587, x585, x549, x577); + let mut x588: u32 = 0; + let mut x589: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x588, &mut x589, x587, x551, x579); + let mut x590: u32 = 0; + let mut x591: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x590, &mut x591, x589, x553, (0x0 as u32)); + let mut x592: u32 = 0; + let mut x593: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x592, &mut x593, x591, x555, (0x0 as u32)); + let mut x594: u32 = 0; + let mut x595: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x594, &mut x595, x593, x557, x563); + let mut x596: u32 = 0; + let mut x597: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x596, &mut x597, x595, x559, x564); + let x598: u32 = ((x597 as u32) + (x560 as u32)); + let mut x599: u32 = 0; + let mut x600: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x599, &mut x600, x7, (arg1[7])); + let mut x601: u32 = 0; + let mut x602: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x601, &mut x602, x7, (arg1[6])); + let mut x603: u32 = 0; + let mut x604: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x603, &mut x604, x7, (arg1[5])); + let mut x605: u32 = 0; + let mut x606: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x605, &mut x606, x7, (arg1[4])); + let mut x607: u32 = 0; + let mut x608: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x607, &mut x608, x7, (arg1[3])); + let mut x609: u32 = 0; + let mut x610: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x609, &mut x610, x7, (arg1[2])); + let mut x611: u32 = 0; + let mut x612: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x611, &mut x612, x7, (arg1[1])); + let mut x613: u32 = 0; + let mut x614: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x613, &mut x614, x7, (arg1[0])); + let mut x615: u32 = 0; + let mut x616: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x615, &mut x616, 0x0, x614, x611); + let mut x617: u32 = 0; + let mut x618: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x617, &mut x618, x616, x612, x609); + let mut x619: u32 = 0; + let mut x620: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x619, &mut x620, x618, x610, x607); + let mut x621: u32 = 0; + let mut x622: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x621, &mut x622, x620, x608, x605); + let mut x623: u32 = 0; + let mut x624: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x623, &mut x624, x622, x606, x603); + let mut x625: u32 = 0; + let mut x626: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x625, &mut x626, x624, x604, x601); + let mut x627: u32 = 0; + let mut x628: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x627, &mut x628, x626, x602, x599); + let x629: u32 = ((x628 as u32) + x600); + let mut x630: u32 = 0; + let mut x631: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x630, &mut x631, 0x0, x582, x613); + let mut x632: u32 = 0; + let mut x633: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x632, &mut x633, x631, x584, x615); + let mut x634: u32 = 0; + let mut x635: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x634, &mut x635, x633, x586, x617); + let mut x636: u32 = 0; + let mut x637: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x636, &mut x637, x635, x588, x619); + let mut x638: u32 = 0; + let mut x639: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x638, &mut x639, x637, x590, x621); + let mut x640: u32 = 0; + let mut x641: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x640, &mut x641, x639, x592, x623); + let mut x642: u32 = 0; + let mut x643: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x642, &mut x643, x641, x594, x625); + let mut x644: u32 = 0; + let mut x645: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x644, &mut x645, x643, x596, x627); + let mut x646: u32 = 0; + let mut x647: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x646, &mut x647, x645, x598, x629); + let mut x648: u32 = 0; + let mut x649: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x648, &mut x649, x630, 0x12547e1b); + let mut x650: u32 = 0; + let mut x651: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x650, &mut x651, x648, 0x10000000); + let mut x652: u32 = 0; + let mut x653: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x652, &mut x653, x648, 0x14def9de); + let mut x654: u32 = 0; + let mut x655: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x654, &mut x655, x648, 0xa2f79cd6); + let mut x656: u32 = 0; + let mut x657: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x656, &mut x657, x648, 0x5812631a); + let mut x658: u32 = 0; + let mut x659: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x658, &mut x659, x648, 0x5cf5d3ed); + let mut x660: u32 = 0; + let mut x661: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x660, &mut x661, 0x0, x659, x656); + let mut x662: u32 = 0; + let mut x663: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x662, &mut x663, x661, x657, x654); + let mut x664: u32 = 0; + let mut x665: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x664, &mut x665, x663, x655, x652); + let x666: u32 = ((x665 as u32) + x653); + let mut x667: u32 = 0; + let mut x668: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x667, &mut x668, 0x0, x630, x658); + let mut x669: u32 = 0; + let mut x670: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x669, &mut x670, x668, x632, x660); + let mut x671: u32 = 0; + let mut x672: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x671, &mut x672, x670, x634, x662); + let mut x673: u32 = 0; + let mut x674: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x673, &mut x674, x672, x636, x664); + let mut x675: u32 = 0; + let mut x676: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x675, &mut x676, x674, x638, x666); + let mut x677: u32 = 0; + let mut x678: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x677, &mut x678, x676, x640, (0x0 as u32)); + let mut x679: u32 = 0; + let mut x680: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x679, &mut x680, x678, x642, (0x0 as u32)); + let mut x681: u32 = 0; + let mut x682: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x681, &mut x682, x680, x644, x650); + let mut x683: u32 = 0; + let mut x684: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x683, &mut x684, x682, x646, x651); + let x685: u32 = ((x684 as u32) + (x647 as u32)); + let mut x686: u32 = 0; + let mut x687: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x686, &mut x687, 0x0, x669, 0x5cf5d3ed); + let mut x688: u32 = 0; + let mut x689: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x688, &mut x689, x687, x671, 0x5812631a); + let mut x690: u32 = 0; + let mut x691: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x690, &mut x691, x689, x673, 0xa2f79cd6); + let mut x692: u32 = 0; + let mut x693: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x692, &mut x693, x691, x675, 0x14def9de); + let mut x694: u32 = 0; + let mut x695: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x694, &mut x695, x693, x677, (0x0 as u32)); + let mut x696: u32 = 0; + let mut x697: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x696, &mut x697, x695, x679, (0x0 as u32)); + let mut x698: u32 = 0; + let mut x699: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x698, &mut x699, x697, x681, (0x0 as u32)); + let mut x700: u32 = 0; + let mut x701: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x700, &mut x701, x699, x683, 0x10000000); + let mut x702: u32 = 0; + let mut x703: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x702, &mut x703, x701, x685, (0x0 as u32)); + let mut x704: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x704, x703, x686, x669); + let mut x705: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x705, x703, x688, x671); + let mut x706: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x706, x703, x690, x673); + let mut x707: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x707, x703, x692, x675); + let mut x708: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x708, x703, x694, x677); + let mut x709: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x709, x703, x696, x679); + let mut x710: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x710, x703, x698, x681); + let mut x711: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x711, x703, x700, x683); + out1[0] = x704; + out1[1] = x705; + out1[2] = x706; + out1[3] = x707; + out1[4] = x708; + out1[5] = x709; + out1[6] = x710; + out1[7] = x711; +} + +/// The function fiat_25519_scalar_add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_add(out1: &mut fiat_25519_scalar_montgomery_domain_field_element, arg1: &fiat_25519_scalar_montgomery_domain_field_element, arg2: &fiat_25519_scalar_montgomery_domain_field_element) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u32 = 0; + let mut x4: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u32 = 0; + let mut x6: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u32 = 0; + let mut x8: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u32 = 0; + let mut x10: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u32 = 0; + let mut x12: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u32 = 0; + let mut x14: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x13, &mut x14, x12, (arg1[6]), (arg2[6])); + let mut x15: u32 = 0; + let mut x16: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x15, &mut x16, x14, (arg1[7]), (arg2[7])); + let mut x17: u32 = 0; + let mut x18: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x17, &mut x18, 0x0, x1, 0x5cf5d3ed); + let mut x19: u32 = 0; + let mut x20: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x19, &mut x20, x18, x3, 0x5812631a); + let mut x21: u32 = 0; + let mut x22: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x21, &mut x22, x20, x5, 0xa2f79cd6); + let mut x23: u32 = 0; + let mut x24: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x23, &mut x24, x22, x7, 0x14def9de); + let mut x25: u32 = 0; + let mut x26: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x25, &mut x26, x24, x9, (0x0 as u32)); + let mut x27: u32 = 0; + let mut x28: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x27, &mut x28, x26, x11, (0x0 as u32)); + let mut x29: u32 = 0; + let mut x30: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x29, &mut x30, x28, x13, (0x0 as u32)); + let mut x31: u32 = 0; + let mut x32: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x31, &mut x32, x30, x15, 0x10000000); + let mut x33: u32 = 0; + let mut x34: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x33, &mut x34, x32, (x16 as u32), (0x0 as u32)); + let mut x35: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x35, x34, x17, x1); + let mut x36: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x36, x34, x19, x3); + let mut x37: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x37, x34, x21, x5); + let mut x38: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x38, x34, x23, x7); + let mut x39: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x39, x34, x25, x9); + let mut x40: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x40, x34, x27, x11); + let mut x41: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x41, x34, x29, x13); + let mut x42: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x42, x34, x31, x15); + out1[0] = x35; + out1[1] = x36; + out1[2] = x37; + out1[3] = x38; + out1[4] = x39; + out1[5] = x40; + out1[6] = x41; + out1[7] = x42; +} + +/// The function fiat_25519_scalar_sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_sub(out1: &mut fiat_25519_scalar_montgomery_domain_field_element, arg1: &fiat_25519_scalar_montgomery_domain_field_element, arg2: &fiat_25519_scalar_montgomery_domain_field_element) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u32 = 0; + let mut x4: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u32 = 0; + let mut x6: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u32 = 0; + let mut x8: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u32 = 0; + let mut x10: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u32 = 0; + let mut x12: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u32 = 0; + let mut x14: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x13, &mut x14, x12, (arg1[6]), (arg2[6])); + let mut x15: u32 = 0; + let mut x16: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x15, &mut x16, x14, (arg1[7]), (arg2[7])); + let mut x17: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x17, x16, (0x0 as u32), 0xffffffff); + let mut x18: u32 = 0; + let mut x19: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x18, &mut x19, 0x0, x1, (x17 & 0x5cf5d3ed)); + let mut x20: u32 = 0; + let mut x21: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x20, &mut x21, x19, x3, (x17 & 0x5812631a)); + let mut x22: u32 = 0; + let mut x23: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x22, &mut x23, x21, x5, (x17 & 0xa2f79cd6)); + let mut x24: u32 = 0; + let mut x25: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x24, &mut x25, x23, x7, (x17 & 0x14def9de)); + let mut x26: u32 = 0; + let mut x27: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x26, &mut x27, x25, x9, (0x0 as u32)); + let mut x28: u32 = 0; + let mut x29: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x28, &mut x29, x27, x11, (0x0 as u32)); + let mut x30: u32 = 0; + let mut x31: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x13, (0x0 as u32)); + let mut x32: u32 = 0; + let mut x33: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x15, (x17 & 0x10000000)); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/// The function fiat_25519_scalar_opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_opp(out1: &mut fiat_25519_scalar_montgomery_domain_field_element, arg1: &fiat_25519_scalar_montgomery_domain_field_element) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x1, &mut x2, 0x0, (0x0 as u32), (arg1[0])); + let mut x3: u32 = 0; + let mut x4: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x3, &mut x4, x2, (0x0 as u32), (arg1[1])); + let mut x5: u32 = 0; + let mut x6: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x5, &mut x6, x4, (0x0 as u32), (arg1[2])); + let mut x7: u32 = 0; + let mut x8: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x7, &mut x8, x6, (0x0 as u32), (arg1[3])); + let mut x9: u32 = 0; + let mut x10: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x9, &mut x10, x8, (0x0 as u32), (arg1[4])); + let mut x11: u32 = 0; + let mut x12: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x11, &mut x12, x10, (0x0 as u32), (arg1[5])); + let mut x13: u32 = 0; + let mut x14: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x13, &mut x14, x12, (0x0 as u32), (arg1[6])); + let mut x15: u32 = 0; + let mut x16: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x15, &mut x16, x14, (0x0 as u32), (arg1[7])); + let mut x17: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x17, x16, (0x0 as u32), 0xffffffff); + let mut x18: u32 = 0; + let mut x19: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x18, &mut x19, 0x0, x1, (x17 & 0x5cf5d3ed)); + let mut x20: u32 = 0; + let mut x21: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x20, &mut x21, x19, x3, (x17 & 0x5812631a)); + let mut x22: u32 = 0; + let mut x23: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x22, &mut x23, x21, x5, (x17 & 0xa2f79cd6)); + let mut x24: u32 = 0; + let mut x25: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x24, &mut x25, x23, x7, (x17 & 0x14def9de)); + let mut x26: u32 = 0; + let mut x27: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x26, &mut x27, x25, x9, (0x0 as u32)); + let mut x28: u32 = 0; + let mut x29: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x28, &mut x29, x27, x11, (0x0 as u32)); + let mut x30: u32 = 0; + let mut x31: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x13, (0x0 as u32)); + let mut x32: u32 = 0; + let mut x33: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x15, (x17 & 0x10000000)); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/// The function fiat_25519_scalar_from_montgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_from_montgomery(out1: &mut fiat_25519_scalar_non_montgomery_domain_field_element, arg1: &fiat_25519_scalar_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[0]); + let mut x2: u32 = 0; + let mut x3: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x2, &mut x3, x1, 0x12547e1b); + let mut x4: u32 = 0; + let mut x5: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x4, &mut x5, x2, 0x10000000); + let mut x6: u32 = 0; + let mut x7: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x6, &mut x7, x2, 0x14def9de); + let mut x8: u32 = 0; + let mut x9: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x8, &mut x9, x2, 0xa2f79cd6); + let mut x10: u32 = 0; + let mut x11: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x10, &mut x11, x2, 0x5812631a); + let mut x12: u32 = 0; + let mut x13: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x12, &mut x13, x2, 0x5cf5d3ed); + let mut x14: u32 = 0; + let mut x15: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x14, &mut x15, 0x0, x13, x10); + let mut x16: u32 = 0; + let mut x17: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x16, &mut x17, x15, x11, x8); + let mut x18: u32 = 0; + let mut x19: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x18, &mut x19, x17, x9, x6); + let mut x20: u32 = 0; + let mut x21: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x20, &mut x21, 0x0, x1, x12); + let mut x22: u32 = 0; + let mut x23: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x22, &mut x23, x21, (0x0 as u32), x14); + let mut x24: u32 = 0; + let mut x25: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x24, &mut x25, x23, (0x0 as u32), x16); + let mut x26: u32 = 0; + let mut x27: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x26, &mut x27, x25, (0x0 as u32), x18); + let mut x28: u32 = 0; + let mut x29: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x28, &mut x29, 0x0, x22, (arg1[1])); + let mut x30: u32 = 0; + let mut x31: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x24, (0x0 as u32)); + let mut x32: u32 = 0; + let mut x33: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x26, (0x0 as u32)); + let mut x34: u32 = 0; + let mut x35: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x34, &mut x35, x28, 0x12547e1b); + let mut x36: u32 = 0; + let mut x37: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x36, &mut x37, x34, 0x10000000); + let mut x38: u32 = 0; + let mut x39: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x38, &mut x39, x34, 0x14def9de); + let mut x40: u32 = 0; + let mut x41: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x40, &mut x41, x34, 0xa2f79cd6); + let mut x42: u32 = 0; + let mut x43: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x42, &mut x43, x34, 0x5812631a); + let mut x44: u32 = 0; + let mut x45: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x44, &mut x45, x34, 0x5cf5d3ed); + let mut x46: u32 = 0; + let mut x47: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x46, &mut x47, 0x0, x45, x42); + let mut x48: u32 = 0; + let mut x49: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x48, &mut x49, x47, x43, x40); + let mut x50: u32 = 0; + let mut x51: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x50, &mut x51, x49, x41, x38); + let mut x52: u32 = 0; + let mut x53: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x52, &mut x53, 0x0, x28, x44); + let mut x54: u32 = 0; + let mut x55: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x54, &mut x55, x53, x30, x46); + let mut x56: u32 = 0; + let mut x57: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x56, &mut x57, x55, x32, x48); + let mut x58: u32 = 0; + let mut x59: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x58, &mut x59, x57, ((x33 as u32) + ((x27 as u32) + ((x19 as u32) + x7))), x50); + let mut x60: u32 = 0; + let mut x61: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x60, &mut x61, 0x0, x5, x36); + let mut x62: u32 = 0; + let mut x63: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x62, &mut x63, 0x0, x54, (arg1[2])); + let mut x64: u32 = 0; + let mut x65: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x64, &mut x65, x63, x56, (0x0 as u32)); + let mut x66: u32 = 0; + let mut x67: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x66, &mut x67, x65, x58, (0x0 as u32)); + let mut x68: u32 = 0; + let mut x69: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x68, &mut x69, x62, 0x12547e1b); + let mut x70: u32 = 0; + let mut x71: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x70, &mut x71, x68, 0x10000000); + let mut x72: u32 = 0; + let mut x73: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x72, &mut x73, x68, 0x14def9de); + let mut x74: u32 = 0; + let mut x75: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x74, &mut x75, x68, 0xa2f79cd6); + let mut x76: u32 = 0; + let mut x77: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x76, &mut x77, x68, 0x5812631a); + let mut x78: u32 = 0; + let mut x79: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x78, &mut x79, x68, 0x5cf5d3ed); + let mut x80: u32 = 0; + let mut x81: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x80, &mut x81, 0x0, x79, x76); + let mut x82: u32 = 0; + let mut x83: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x82, &mut x83, x81, x77, x74); + let mut x84: u32 = 0; + let mut x85: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x84, &mut x85, x83, x75, x72); + let mut x86: u32 = 0; + let mut x87: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x86, &mut x87, 0x0, x62, x78); + let mut x88: u32 = 0; + let mut x89: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x88, &mut x89, x87, x64, x80); + let mut x90: u32 = 0; + let mut x91: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x90, &mut x91, x89, x66, x82); + let mut x92: u32 = 0; + let mut x93: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x92, &mut x93, x91, ((x67 as u32) + ((x59 as u32) + ((x51 as u32) + x39))), x84); + let mut x94: u32 = 0; + let mut x95: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x94, &mut x95, 0x0, ((x61 as u32) + x37), x70); + let mut x96: u32 = 0; + let mut x97: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x96, &mut x97, 0x0, x88, (arg1[3])); + let mut x98: u32 = 0; + let mut x99: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x98, &mut x99, x97, x90, (0x0 as u32)); + let mut x100: u32 = 0; + let mut x101: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x100, &mut x101, x99, x92, (0x0 as u32)); + let mut x102: u32 = 0; + let mut x103: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x102, &mut x103, x96, 0x12547e1b); + let mut x104: u32 = 0; + let mut x105: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x104, &mut x105, x102, 0x10000000); + let mut x106: u32 = 0; + let mut x107: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x106, &mut x107, x102, 0x14def9de); + let mut x108: u32 = 0; + let mut x109: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x108, &mut x109, x102, 0xa2f79cd6); + let mut x110: u32 = 0; + let mut x111: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x110, &mut x111, x102, 0x5812631a); + let mut x112: u32 = 0; + let mut x113: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x112, &mut x113, x102, 0x5cf5d3ed); + let mut x114: u32 = 0; + let mut x115: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x114, &mut x115, 0x0, x113, x110); + let mut x116: u32 = 0; + let mut x117: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x116, &mut x117, x115, x111, x108); + let mut x118: u32 = 0; + let mut x119: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x118, &mut x119, x117, x109, x106); + let mut x120: u32 = 0; + let mut x121: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x120, &mut x121, 0x0, x96, x112); + let mut x122: u32 = 0; + let mut x123: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x122, &mut x123, x121, x98, x114); + let mut x124: u32 = 0; + let mut x125: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x100, x116); + let mut x126: u32 = 0; + let mut x127: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x126, &mut x127, x125, ((x101 as u32) + ((x93 as u32) + ((x85 as u32) + x73))), x118); + let mut x128: u32 = 0; + let mut x129: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x128, &mut x129, x127, x4, ((x119 as u32) + x107)); + let mut x130: u32 = 0; + let mut x131: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x130, &mut x131, x129, x60, (0x0 as u32)); + let mut x132: u32 = 0; + let mut x133: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x132, &mut x133, x131, x94, (0x0 as u32)); + let mut x134: u32 = 0; + let mut x135: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x134, &mut x135, x133, ((x95 as u32) + x71), x104); + let mut x136: u32 = 0; + let mut x137: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x136, &mut x137, 0x0, x122, (arg1[4])); + let mut x138: u32 = 0; + let mut x139: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x138, &mut x139, x137, x124, (0x0 as u32)); + let mut x140: u32 = 0; + let mut x141: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x140, &mut x141, x139, x126, (0x0 as u32)); + let mut x142: u32 = 0; + let mut x143: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x142, &mut x143, x141, x128, (0x0 as u32)); + let mut x144: u32 = 0; + let mut x145: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x144, &mut x145, x143, x130, (0x0 as u32)); + let mut x146: u32 = 0; + let mut x147: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x146, &mut x147, x145, x132, (0x0 as u32)); + let mut x148: u32 = 0; + let mut x149: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x148, &mut x149, x147, x134, (0x0 as u32)); + let mut x150: u32 = 0; + let mut x151: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x150, &mut x151, x136, 0x12547e1b); + let mut x152: u32 = 0; + let mut x153: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x152, &mut x153, x150, 0x10000000); + let mut x154: u32 = 0; + let mut x155: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x154, &mut x155, x150, 0x14def9de); + let mut x156: u32 = 0; + let mut x157: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x156, &mut x157, x150, 0xa2f79cd6); + let mut x158: u32 = 0; + let mut x159: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x158, &mut x159, x150, 0x5812631a); + let mut x160: u32 = 0; + let mut x161: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x160, &mut x161, x150, 0x5cf5d3ed); + let mut x162: u32 = 0; + let mut x163: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x162, &mut x163, 0x0, x161, x158); + let mut x164: u32 = 0; + let mut x165: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x164, &mut x165, x163, x159, x156); + let mut x166: u32 = 0; + let mut x167: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x166, &mut x167, x165, x157, x154); + let mut x168: u32 = 0; + let mut x169: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x168, &mut x169, 0x0, x136, x160); + let mut x170: u32 = 0; + let mut x171: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x170, &mut x171, x169, x138, x162); + let mut x172: u32 = 0; + let mut x173: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x172, &mut x173, x171, x140, x164); + let mut x174: u32 = 0; + let mut x175: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x174, &mut x175, x173, x142, x166); + let mut x176: u32 = 0; + let mut x177: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x176, &mut x177, x175, x144, ((x167 as u32) + x155)); + let mut x178: u32 = 0; + let mut x179: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x178, &mut x179, x177, x146, (0x0 as u32)); + let mut x180: u32 = 0; + let mut x181: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x180, &mut x181, x179, x148, (0x0 as u32)); + let mut x182: u32 = 0; + let mut x183: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x182, &mut x183, x181, ((x149 as u32) + ((x135 as u32) + x105)), x152); + let mut x184: u32 = 0; + let mut x185: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x184, &mut x185, 0x0, x170, (arg1[5])); + let mut x186: u32 = 0; + let mut x187: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x186, &mut x187, x185, x172, (0x0 as u32)); + let mut x188: u32 = 0; + let mut x189: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x188, &mut x189, x187, x174, (0x0 as u32)); + let mut x190: u32 = 0; + let mut x191: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x190, &mut x191, x189, x176, (0x0 as u32)); + let mut x192: u32 = 0; + let mut x193: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x192, &mut x193, x191, x178, (0x0 as u32)); + let mut x194: u32 = 0; + let mut x195: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x194, &mut x195, x193, x180, (0x0 as u32)); + let mut x196: u32 = 0; + let mut x197: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x196, &mut x197, x195, x182, (0x0 as u32)); + let mut x198: u32 = 0; + let mut x199: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x198, &mut x199, x184, 0x12547e1b); + let mut x200: u32 = 0; + let mut x201: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x200, &mut x201, x198, 0x10000000); + let mut x202: u32 = 0; + let mut x203: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x202, &mut x203, x198, 0x14def9de); + let mut x204: u32 = 0; + let mut x205: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x204, &mut x205, x198, 0xa2f79cd6); + let mut x206: u32 = 0; + let mut x207: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x206, &mut x207, x198, 0x5812631a); + let mut x208: u32 = 0; + let mut x209: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x208, &mut x209, x198, 0x5cf5d3ed); + let mut x210: u32 = 0; + let mut x211: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x210, &mut x211, 0x0, x209, x206); + let mut x212: u32 = 0; + let mut x213: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x212, &mut x213, x211, x207, x204); + let mut x214: u32 = 0; + let mut x215: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x214, &mut x215, x213, x205, x202); + let mut x216: u32 = 0; + let mut x217: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x216, &mut x217, 0x0, x184, x208); + let mut x218: u32 = 0; + let mut x219: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x218, &mut x219, x217, x186, x210); + let mut x220: u32 = 0; + let mut x221: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x220, &mut x221, x219, x188, x212); + let mut x222: u32 = 0; + let mut x223: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x222, &mut x223, x221, x190, x214); + let mut x224: u32 = 0; + let mut x225: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x224, &mut x225, x223, x192, ((x215 as u32) + x203)); + let mut x226: u32 = 0; + let mut x227: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x226, &mut x227, x225, x194, (0x0 as u32)); + let mut x228: u32 = 0; + let mut x229: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x228, &mut x229, x227, x196, (0x0 as u32)); + let mut x230: u32 = 0; + let mut x231: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x230, &mut x231, x229, ((x197 as u32) + ((x183 as u32) + x153)), x200); + let mut x232: u32 = 0; + let mut x233: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x232, &mut x233, 0x0, x218, (arg1[6])); + let mut x234: u32 = 0; + let mut x235: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x234, &mut x235, x233, x220, (0x0 as u32)); + let mut x236: u32 = 0; + let mut x237: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x236, &mut x237, x235, x222, (0x0 as u32)); + let mut x238: u32 = 0; + let mut x239: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x238, &mut x239, x237, x224, (0x0 as u32)); + let mut x240: u32 = 0; + let mut x241: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x240, &mut x241, x239, x226, (0x0 as u32)); + let mut x242: u32 = 0; + let mut x243: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x242, &mut x243, x241, x228, (0x0 as u32)); + let mut x244: u32 = 0; + let mut x245: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x244, &mut x245, x243, x230, (0x0 as u32)); + let mut x246: u32 = 0; + let mut x247: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x246, &mut x247, x232, 0x12547e1b); + let mut x248: u32 = 0; + let mut x249: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x248, &mut x249, x246, 0x10000000); + let mut x250: u32 = 0; + let mut x251: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x250, &mut x251, x246, 0x14def9de); + let mut x252: u32 = 0; + let mut x253: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x252, &mut x253, x246, 0xa2f79cd6); + let mut x254: u32 = 0; + let mut x255: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x254, &mut x255, x246, 0x5812631a); + let mut x256: u32 = 0; + let mut x257: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x256, &mut x257, x246, 0x5cf5d3ed); + let mut x258: u32 = 0; + let mut x259: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x258, &mut x259, 0x0, x257, x254); + let mut x260: u32 = 0; + let mut x261: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x260, &mut x261, x259, x255, x252); + let mut x262: u32 = 0; + let mut x263: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x262, &mut x263, x261, x253, x250); + let mut x264: u32 = 0; + let mut x265: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x264, &mut x265, 0x0, x232, x256); + let mut x266: u32 = 0; + let mut x267: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x266, &mut x267, x265, x234, x258); + let mut x268: u32 = 0; + let mut x269: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x268, &mut x269, x267, x236, x260); + let mut x270: u32 = 0; + let mut x271: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x270, &mut x271, x269, x238, x262); + let mut x272: u32 = 0; + let mut x273: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x272, &mut x273, x271, x240, ((x263 as u32) + x251)); + let mut x274: u32 = 0; + let mut x275: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x274, &mut x275, x273, x242, (0x0 as u32)); + let mut x276: u32 = 0; + let mut x277: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x276, &mut x277, x275, x244, (0x0 as u32)); + let mut x278: u32 = 0; + let mut x279: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x278, &mut x279, x277, ((x245 as u32) + ((x231 as u32) + x201)), x248); + let mut x280: u32 = 0; + let mut x281: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x280, &mut x281, 0x0, x266, (arg1[7])); + let mut x282: u32 = 0; + let mut x283: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x282, &mut x283, x281, x268, (0x0 as u32)); + let mut x284: u32 = 0; + let mut x285: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x284, &mut x285, x283, x270, (0x0 as u32)); + let mut x286: u32 = 0; + let mut x287: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x286, &mut x287, x285, x272, (0x0 as u32)); + let mut x288: u32 = 0; + let mut x289: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x288, &mut x289, x287, x274, (0x0 as u32)); + let mut x290: u32 = 0; + let mut x291: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x290, &mut x291, x289, x276, (0x0 as u32)); + let mut x292: u32 = 0; + let mut x293: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x292, &mut x293, x291, x278, (0x0 as u32)); + let mut x294: u32 = 0; + let mut x295: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x294, &mut x295, x280, 0x12547e1b); + let mut x296: u32 = 0; + let mut x297: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x296, &mut x297, x294, 0x10000000); + let mut x298: u32 = 0; + let mut x299: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x298, &mut x299, x294, 0x14def9de); + let mut x300: u32 = 0; + let mut x301: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x300, &mut x301, x294, 0xa2f79cd6); + let mut x302: u32 = 0; + let mut x303: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x302, &mut x303, x294, 0x5812631a); + let mut x304: u32 = 0; + let mut x305: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x304, &mut x305, x294, 0x5cf5d3ed); + let mut x306: u32 = 0; + let mut x307: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x306, &mut x307, 0x0, x305, x302); + let mut x308: u32 = 0; + let mut x309: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x308, &mut x309, x307, x303, x300); + let mut x310: u32 = 0; + let mut x311: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x310, &mut x311, x309, x301, x298); + let mut x312: u32 = 0; + let mut x313: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x312, &mut x313, 0x0, x280, x304); + let mut x314: u32 = 0; + let mut x315: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x314, &mut x315, x313, x282, x306); + let mut x316: u32 = 0; + let mut x317: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x316, &mut x317, x315, x284, x308); + let mut x318: u32 = 0; + let mut x319: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x318, &mut x319, x317, x286, x310); + let mut x320: u32 = 0; + let mut x321: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x320, &mut x321, x319, x288, ((x311 as u32) + x299)); + let mut x322: u32 = 0; + let mut x323: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x322, &mut x323, x321, x290, (0x0 as u32)); + let mut x324: u32 = 0; + let mut x325: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x324, &mut x325, x323, x292, (0x0 as u32)); + let mut x326: u32 = 0; + let mut x327: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x326, &mut x327, x325, ((x293 as u32) + ((x279 as u32) + x249)), x296); + let x328: u32 = ((x327 as u32) + x297); + let mut x329: u32 = 0; + let mut x330: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x329, &mut x330, 0x0, x314, 0x5cf5d3ed); + let mut x331: u32 = 0; + let mut x332: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x331, &mut x332, x330, x316, 0x5812631a); + let mut x333: u32 = 0; + let mut x334: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x333, &mut x334, x332, x318, 0xa2f79cd6); + let mut x335: u32 = 0; + let mut x336: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x335, &mut x336, x334, x320, 0x14def9de); + let mut x337: u32 = 0; + let mut x338: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x337, &mut x338, x336, x322, (0x0 as u32)); + let mut x339: u32 = 0; + let mut x340: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x339, &mut x340, x338, x324, (0x0 as u32)); + let mut x341: u32 = 0; + let mut x342: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x341, &mut x342, x340, x326, (0x0 as u32)); + let mut x343: u32 = 0; + let mut x344: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x343, &mut x344, x342, x328, 0x10000000); + let mut x345: u32 = 0; + let mut x346: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x345, &mut x346, x344, (0x0 as u32), (0x0 as u32)); + let mut x347: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x347, x346, x329, x314); + let mut x348: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x348, x346, x331, x316); + let mut x349: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x349, x346, x333, x318); + let mut x350: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x350, x346, x335, x320); + let mut x351: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x351, x346, x337, x322); + let mut x352: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x352, x346, x339, x324); + let mut x353: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x353, x346, x341, x326); + let mut x354: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x354, x346, x343, x328); + out1[0] = x347; + out1[1] = x348; + out1[2] = x349; + out1[3] = x350; + out1[4] = x351; + out1[5] = x352; + out1[6] = x353; + out1[7] = x354; +} + +/// The function fiat_25519_scalar_to_montgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_to_montgomery(out1: &mut fiat_25519_scalar_montgomery_domain_field_element, arg1: &fiat_25519_scalar_non_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[1]); + let x2: u32 = (arg1[2]); + let x3: u32 = (arg1[3]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[5]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[7]); + let x8: u32 = (arg1[0]); + let mut x9: u32 = 0; + let mut x10: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x9, &mut x10, x8, 0x399411b); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x11, &mut x12, x8, 0x7c309a3d); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x13, &mut x14, x8, 0xceec73d2); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x15, &mut x16, x8, 0x17f5be65); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x17, &mut x18, x8, 0xd00e1ba7); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x19, &mut x20, x8, 0x68859347); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x21, &mut x22, x8, 0xa40611e3); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x23, &mut x24, x8, 0x449c0f01); + let mut x25: u32 = 0; + let mut x26: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x37, &mut x38, x36, x12, x9); + let mut x39: u32 = 0; + let mut x40: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x39, &mut x40, x23, 0x12547e1b); + let mut x41: u32 = 0; + let mut x42: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x41, &mut x42, x39, 0x10000000); + let mut x43: u32 = 0; + let mut x44: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x43, &mut x44, x39, 0x14def9de); + let mut x45: u32 = 0; + let mut x46: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x45, &mut x46, x39, 0xa2f79cd6); + let mut x47: u32 = 0; + let mut x48: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x47, &mut x48, x39, 0x5812631a); + let mut x49: u32 = 0; + let mut x50: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x49, &mut x50, x39, 0x5cf5d3ed); + let mut x51: u32 = 0; + let mut x52: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x51, &mut x52, 0x0, x50, x47); + let mut x53: u32 = 0; + let mut x54: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x53, &mut x54, x52, x48, x45); + let mut x55: u32 = 0; + let mut x56: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x55, &mut x56, x54, x46, x43); + let mut x57: u32 = 0; + let mut x58: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x57, &mut x58, 0x0, x23, x49); + let mut x59: u32 = 0; + let mut x60: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x59, &mut x60, x58, x25, x51); + let mut x61: u32 = 0; + let mut x62: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x61, &mut x62, x60, x27, x53); + let mut x63: u32 = 0; + let mut x64: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x63, &mut x64, x62, x29, x55); + let mut x65: u32 = 0; + let mut x66: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x65, &mut x66, x64, x31, ((x56 as u32) + x44)); + let mut x67: u32 = 0; + let mut x68: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x67, &mut x68, x66, x33, (0x0 as u32)); + let mut x69: u32 = 0; + let mut x70: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x69, &mut x70, x68, x35, (0x0 as u32)); + let mut x71: u32 = 0; + let mut x72: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x71, &mut x72, x70, x37, x41); + let mut x73: u32 = 0; + let mut x74: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x73, &mut x74, x1, 0x399411b); + let mut x75: u32 = 0; + let mut x76: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x75, &mut x76, x1, 0x7c309a3d); + let mut x77: u32 = 0; + let mut x78: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x77, &mut x78, x1, 0xceec73d2); + let mut x79: u32 = 0; + let mut x80: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x79, &mut x80, x1, 0x17f5be65); + let mut x81: u32 = 0; + let mut x82: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x81, &mut x82, x1, 0xd00e1ba7); + let mut x83: u32 = 0; + let mut x84: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x83, &mut x84, x1, 0x68859347); + let mut x85: u32 = 0; + let mut x86: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x85, &mut x86, x1, 0xa40611e3); + let mut x87: u32 = 0; + let mut x88: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x87, &mut x88, x1, 0x449c0f01); + let mut x89: u32 = 0; + let mut x90: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x89, &mut x90, 0x0, x88, x85); + let mut x91: u32 = 0; + let mut x92: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x91, &mut x92, x90, x86, x83); + let mut x93: u32 = 0; + let mut x94: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x93, &mut x94, x92, x84, x81); + let mut x95: u32 = 0; + let mut x96: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x95, &mut x96, x94, x82, x79); + let mut x97: u32 = 0; + let mut x98: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x97, &mut x98, x96, x80, x77); + let mut x99: u32 = 0; + let mut x100: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x99, &mut x100, x98, x78, x75); + let mut x101: u32 = 0; + let mut x102: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x101, &mut x102, x100, x76, x73); + let mut x103: u32 = 0; + let mut x104: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x103, &mut x104, 0x0, x59, x87); + let mut x105: u32 = 0; + let mut x106: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x105, &mut x106, x104, x61, x89); + let mut x107: u32 = 0; + let mut x108: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x107, &mut x108, x106, x63, x91); + let mut x109: u32 = 0; + let mut x110: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x109, &mut x110, x108, x65, x93); + let mut x111: u32 = 0; + let mut x112: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x67, x95); + let mut x113: u32 = 0; + let mut x114: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x113, &mut x114, x112, x69, x97); + let mut x115: u32 = 0; + let mut x116: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x115, &mut x116, x114, x71, x99); + let mut x117: u32 = 0; + let mut x118: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x117, &mut x118, x116, (((x72 as u32) + ((x38 as u32) + x10)) + x42), x101); + let mut x119: u32 = 0; + let mut x120: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x119, &mut x120, x103, 0x12547e1b); + let mut x121: u32 = 0; + let mut x122: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x121, &mut x122, x119, 0x10000000); + let mut x123: u32 = 0; + let mut x124: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x123, &mut x124, x119, 0x14def9de); + let mut x125: u32 = 0; + let mut x126: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x125, &mut x126, x119, 0xa2f79cd6); + let mut x127: u32 = 0; + let mut x128: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x127, &mut x128, x119, 0x5812631a); + let mut x129: u32 = 0; + let mut x130: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x129, &mut x130, x119, 0x5cf5d3ed); + let mut x131: u32 = 0; + let mut x132: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x131, &mut x132, 0x0, x130, x127); + let mut x133: u32 = 0; + let mut x134: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x133, &mut x134, x132, x128, x125); + let mut x135: u32 = 0; + let mut x136: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x135, &mut x136, x134, x126, x123); + let mut x137: u32 = 0; + let mut x138: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x137, &mut x138, 0x0, x103, x129); + let mut x139: u32 = 0; + let mut x140: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x139, &mut x140, x138, x105, x131); + let mut x141: u32 = 0; + let mut x142: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x141, &mut x142, x140, x107, x133); + let mut x143: u32 = 0; + let mut x144: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x143, &mut x144, x142, x109, x135); + let mut x145: u32 = 0; + let mut x146: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x145, &mut x146, x144, x111, ((x136 as u32) + x124)); + let mut x147: u32 = 0; + let mut x148: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x147, &mut x148, x146, x113, (0x0 as u32)); + let mut x149: u32 = 0; + let mut x150: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x149, &mut x150, x148, x115, (0x0 as u32)); + let mut x151: u32 = 0; + let mut x152: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x151, &mut x152, x150, x117, x121); + let mut x153: u32 = 0; + let mut x154: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x153, &mut x154, x2, 0x399411b); + let mut x155: u32 = 0; + let mut x156: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x155, &mut x156, x2, 0x7c309a3d); + let mut x157: u32 = 0; + let mut x158: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x157, &mut x158, x2, 0xceec73d2); + let mut x159: u32 = 0; + let mut x160: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x159, &mut x160, x2, 0x17f5be65); + let mut x161: u32 = 0; + let mut x162: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x161, &mut x162, x2, 0xd00e1ba7); + let mut x163: u32 = 0; + let mut x164: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x163, &mut x164, x2, 0x68859347); + let mut x165: u32 = 0; + let mut x166: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x165, &mut x166, x2, 0xa40611e3); + let mut x167: u32 = 0; + let mut x168: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x167, &mut x168, x2, 0x449c0f01); + let mut x169: u32 = 0; + let mut x170: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x169, &mut x170, 0x0, x168, x165); + let mut x171: u32 = 0; + let mut x172: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x171, &mut x172, x170, x166, x163); + let mut x173: u32 = 0; + let mut x174: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x173, &mut x174, x172, x164, x161); + let mut x175: u32 = 0; + let mut x176: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x175, &mut x176, x174, x162, x159); + let mut x177: u32 = 0; + let mut x178: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x177, &mut x178, x176, x160, x157); + let mut x179: u32 = 0; + let mut x180: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x179, &mut x180, x178, x158, x155); + let mut x181: u32 = 0; + let mut x182: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x181, &mut x182, x180, x156, x153); + let mut x183: u32 = 0; + let mut x184: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x183, &mut x184, 0x0, x139, x167); + let mut x185: u32 = 0; + let mut x186: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x185, &mut x186, x184, x141, x169); + let mut x187: u32 = 0; + let mut x188: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x187, &mut x188, x186, x143, x171); + let mut x189: u32 = 0; + let mut x190: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x189, &mut x190, x188, x145, x173); + let mut x191: u32 = 0; + let mut x192: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x191, &mut x192, x190, x147, x175); + let mut x193: u32 = 0; + let mut x194: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x193, &mut x194, x192, x149, x177); + let mut x195: u32 = 0; + let mut x196: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x195, &mut x196, x194, x151, x179); + let mut x197: u32 = 0; + let mut x198: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x197, &mut x198, x196, (((x152 as u32) + ((x118 as u32) + ((x102 as u32) + x74))) + x122), x181); + let mut x199: u32 = 0; + let mut x200: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x199, &mut x200, x183, 0x12547e1b); + let mut x201: u32 = 0; + let mut x202: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x201, &mut x202, x199, 0x10000000); + let mut x203: u32 = 0; + let mut x204: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x203, &mut x204, x199, 0x14def9de); + let mut x205: u32 = 0; + let mut x206: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x205, &mut x206, x199, 0xa2f79cd6); + let mut x207: u32 = 0; + let mut x208: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x207, &mut x208, x199, 0x5812631a); + let mut x209: u32 = 0; + let mut x210: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x209, &mut x210, x199, 0x5cf5d3ed); + let mut x211: u32 = 0; + let mut x212: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x211, &mut x212, 0x0, x210, x207); + let mut x213: u32 = 0; + let mut x214: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x213, &mut x214, x212, x208, x205); + let mut x215: u32 = 0; + let mut x216: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x215, &mut x216, x214, x206, x203); + let mut x217: u32 = 0; + let mut x218: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x217, &mut x218, 0x0, x183, x209); + let mut x219: u32 = 0; + let mut x220: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x219, &mut x220, x218, x185, x211); + let mut x221: u32 = 0; + let mut x222: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x221, &mut x222, x220, x187, x213); + let mut x223: u32 = 0; + let mut x224: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x223, &mut x224, x222, x189, x215); + let mut x225: u32 = 0; + let mut x226: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x225, &mut x226, x224, x191, ((x216 as u32) + x204)); + let mut x227: u32 = 0; + let mut x228: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x227, &mut x228, x226, x193, (0x0 as u32)); + let mut x229: u32 = 0; + let mut x230: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x229, &mut x230, x228, x195, (0x0 as u32)); + let mut x231: u32 = 0; + let mut x232: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x231, &mut x232, x230, x197, x201); + let mut x233: u32 = 0; + let mut x234: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x233, &mut x234, x3, 0x399411b); + let mut x235: u32 = 0; + let mut x236: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x235, &mut x236, x3, 0x7c309a3d); + let mut x237: u32 = 0; + let mut x238: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x237, &mut x238, x3, 0xceec73d2); + let mut x239: u32 = 0; + let mut x240: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x239, &mut x240, x3, 0x17f5be65); + let mut x241: u32 = 0; + let mut x242: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x241, &mut x242, x3, 0xd00e1ba7); + let mut x243: u32 = 0; + let mut x244: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x243, &mut x244, x3, 0x68859347); + let mut x245: u32 = 0; + let mut x246: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x245, &mut x246, x3, 0xa40611e3); + let mut x247: u32 = 0; + let mut x248: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x247, &mut x248, x3, 0x449c0f01); + let mut x249: u32 = 0; + let mut x250: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x249, &mut x250, 0x0, x248, x245); + let mut x251: u32 = 0; + let mut x252: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x251, &mut x252, x250, x246, x243); + let mut x253: u32 = 0; + let mut x254: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x253, &mut x254, x252, x244, x241); + let mut x255: u32 = 0; + let mut x256: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x255, &mut x256, x254, x242, x239); + let mut x257: u32 = 0; + let mut x258: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x257, &mut x258, x256, x240, x237); + let mut x259: u32 = 0; + let mut x260: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x259, &mut x260, x258, x238, x235); + let mut x261: u32 = 0; + let mut x262: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x261, &mut x262, x260, x236, x233); + let mut x263: u32 = 0; + let mut x264: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x263, &mut x264, 0x0, x219, x247); + let mut x265: u32 = 0; + let mut x266: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x265, &mut x266, x264, x221, x249); + let mut x267: u32 = 0; + let mut x268: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x267, &mut x268, x266, x223, x251); + let mut x269: u32 = 0; + let mut x270: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x269, &mut x270, x268, x225, x253); + let mut x271: u32 = 0; + let mut x272: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x271, &mut x272, x270, x227, x255); + let mut x273: u32 = 0; + let mut x274: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x273, &mut x274, x272, x229, x257); + let mut x275: u32 = 0; + let mut x276: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x275, &mut x276, x274, x231, x259); + let mut x277: u32 = 0; + let mut x278: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x277, &mut x278, x276, (((x232 as u32) + ((x198 as u32) + ((x182 as u32) + x154))) + x202), x261); + let mut x279: u32 = 0; + let mut x280: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x279, &mut x280, x263, 0x12547e1b); + let mut x281: u32 = 0; + let mut x282: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x281, &mut x282, x279, 0x10000000); + let mut x283: u32 = 0; + let mut x284: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x283, &mut x284, x279, 0x14def9de); + let mut x285: u32 = 0; + let mut x286: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x285, &mut x286, x279, 0xa2f79cd6); + let mut x287: u32 = 0; + let mut x288: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x287, &mut x288, x279, 0x5812631a); + let mut x289: u32 = 0; + let mut x290: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x289, &mut x290, x279, 0x5cf5d3ed); + let mut x291: u32 = 0; + let mut x292: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x291, &mut x292, 0x0, x290, x287); + let mut x293: u32 = 0; + let mut x294: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x293, &mut x294, x292, x288, x285); + let mut x295: u32 = 0; + let mut x296: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x295, &mut x296, x294, x286, x283); + let mut x297: u32 = 0; + let mut x298: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x297, &mut x298, 0x0, x263, x289); + let mut x299: u32 = 0; + let mut x300: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x299, &mut x300, x298, x265, x291); + let mut x301: u32 = 0; + let mut x302: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x301, &mut x302, x300, x267, x293); + let mut x303: u32 = 0; + let mut x304: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x303, &mut x304, x302, x269, x295); + let mut x305: u32 = 0; + let mut x306: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x305, &mut x306, x304, x271, ((x296 as u32) + x284)); + let mut x307: u32 = 0; + let mut x308: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x307, &mut x308, x306, x273, (0x0 as u32)); + let mut x309: u32 = 0; + let mut x310: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x309, &mut x310, x308, x275, (0x0 as u32)); + let mut x311: u32 = 0; + let mut x312: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x311, &mut x312, x310, x277, x281); + let mut x313: u32 = 0; + let mut x314: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x313, &mut x314, x4, 0x399411b); + let mut x315: u32 = 0; + let mut x316: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x315, &mut x316, x4, 0x7c309a3d); + let mut x317: u32 = 0; + let mut x318: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x317, &mut x318, x4, 0xceec73d2); + let mut x319: u32 = 0; + let mut x320: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x319, &mut x320, x4, 0x17f5be65); + let mut x321: u32 = 0; + let mut x322: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x321, &mut x322, x4, 0xd00e1ba7); + let mut x323: u32 = 0; + let mut x324: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x323, &mut x324, x4, 0x68859347); + let mut x325: u32 = 0; + let mut x326: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x325, &mut x326, x4, 0xa40611e3); + let mut x327: u32 = 0; + let mut x328: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x327, &mut x328, x4, 0x449c0f01); + let mut x329: u32 = 0; + let mut x330: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x329, &mut x330, 0x0, x328, x325); + let mut x331: u32 = 0; + let mut x332: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x331, &mut x332, x330, x326, x323); + let mut x333: u32 = 0; + let mut x334: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x333, &mut x334, x332, x324, x321); + let mut x335: u32 = 0; + let mut x336: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x335, &mut x336, x334, x322, x319); + let mut x337: u32 = 0; + let mut x338: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x337, &mut x338, x336, x320, x317); + let mut x339: u32 = 0; + let mut x340: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x339, &mut x340, x338, x318, x315); + let mut x341: u32 = 0; + let mut x342: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x341, &mut x342, x340, x316, x313); + let mut x343: u32 = 0; + let mut x344: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x343, &mut x344, 0x0, x299, x327); + let mut x345: u32 = 0; + let mut x346: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x345, &mut x346, x344, x301, x329); + let mut x347: u32 = 0; + let mut x348: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x347, &mut x348, x346, x303, x331); + let mut x349: u32 = 0; + let mut x350: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x349, &mut x350, x348, x305, x333); + let mut x351: u32 = 0; + let mut x352: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x351, &mut x352, x350, x307, x335); + let mut x353: u32 = 0; + let mut x354: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x353, &mut x354, x352, x309, x337); + let mut x355: u32 = 0; + let mut x356: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x355, &mut x356, x354, x311, x339); + let mut x357: u32 = 0; + let mut x358: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x357, &mut x358, x356, (((x312 as u32) + ((x278 as u32) + ((x262 as u32) + x234))) + x282), x341); + let mut x359: u32 = 0; + let mut x360: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x359, &mut x360, x343, 0x12547e1b); + let mut x361: u32 = 0; + let mut x362: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x361, &mut x362, x359, 0x10000000); + let mut x363: u32 = 0; + let mut x364: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x363, &mut x364, x359, 0x14def9de); + let mut x365: u32 = 0; + let mut x366: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x365, &mut x366, x359, 0xa2f79cd6); + let mut x367: u32 = 0; + let mut x368: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x367, &mut x368, x359, 0x5812631a); + let mut x369: u32 = 0; + let mut x370: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x369, &mut x370, x359, 0x5cf5d3ed); + let mut x371: u32 = 0; + let mut x372: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x371, &mut x372, 0x0, x370, x367); + let mut x373: u32 = 0; + let mut x374: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x373, &mut x374, x372, x368, x365); + let mut x375: u32 = 0; + let mut x376: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x375, &mut x376, x374, x366, x363); + let mut x377: u32 = 0; + let mut x378: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x377, &mut x378, 0x0, x343, x369); + let mut x379: u32 = 0; + let mut x380: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x379, &mut x380, x378, x345, x371); + let mut x381: u32 = 0; + let mut x382: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x381, &mut x382, x380, x347, x373); + let mut x383: u32 = 0; + let mut x384: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x383, &mut x384, x382, x349, x375); + let mut x385: u32 = 0; + let mut x386: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x385, &mut x386, x384, x351, ((x376 as u32) + x364)); + let mut x387: u32 = 0; + let mut x388: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x387, &mut x388, x386, x353, (0x0 as u32)); + let mut x389: u32 = 0; + let mut x390: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x389, &mut x390, x388, x355, (0x0 as u32)); + let mut x391: u32 = 0; + let mut x392: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x391, &mut x392, x390, x357, x361); + let mut x393: u32 = 0; + let mut x394: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x393, &mut x394, x5, 0x399411b); + let mut x395: u32 = 0; + let mut x396: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x395, &mut x396, x5, 0x7c309a3d); + let mut x397: u32 = 0; + let mut x398: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x397, &mut x398, x5, 0xceec73d2); + let mut x399: u32 = 0; + let mut x400: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x399, &mut x400, x5, 0x17f5be65); + let mut x401: u32 = 0; + let mut x402: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x401, &mut x402, x5, 0xd00e1ba7); + let mut x403: u32 = 0; + let mut x404: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x403, &mut x404, x5, 0x68859347); + let mut x405: u32 = 0; + let mut x406: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x405, &mut x406, x5, 0xa40611e3); + let mut x407: u32 = 0; + let mut x408: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x407, &mut x408, x5, 0x449c0f01); + let mut x409: u32 = 0; + let mut x410: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x409, &mut x410, 0x0, x408, x405); + let mut x411: u32 = 0; + let mut x412: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x411, &mut x412, x410, x406, x403); + let mut x413: u32 = 0; + let mut x414: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x413, &mut x414, x412, x404, x401); + let mut x415: u32 = 0; + let mut x416: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x415, &mut x416, x414, x402, x399); + let mut x417: u32 = 0; + let mut x418: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x417, &mut x418, x416, x400, x397); + let mut x419: u32 = 0; + let mut x420: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x419, &mut x420, x418, x398, x395); + let mut x421: u32 = 0; + let mut x422: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x421, &mut x422, x420, x396, x393); + let mut x423: u32 = 0; + let mut x424: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x423, &mut x424, 0x0, x379, x407); + let mut x425: u32 = 0; + let mut x426: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x425, &mut x426, x424, x381, x409); + let mut x427: u32 = 0; + let mut x428: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x427, &mut x428, x426, x383, x411); + let mut x429: u32 = 0; + let mut x430: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x429, &mut x430, x428, x385, x413); + let mut x431: u32 = 0; + let mut x432: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x431, &mut x432, x430, x387, x415); + let mut x433: u32 = 0; + let mut x434: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x433, &mut x434, x432, x389, x417); + let mut x435: u32 = 0; + let mut x436: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x435, &mut x436, x434, x391, x419); + let mut x437: u32 = 0; + let mut x438: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x437, &mut x438, x436, (((x392 as u32) + ((x358 as u32) + ((x342 as u32) + x314))) + x362), x421); + let mut x439: u32 = 0; + let mut x440: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x439, &mut x440, x423, 0x12547e1b); + let mut x441: u32 = 0; + let mut x442: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x441, &mut x442, x439, 0x10000000); + let mut x443: u32 = 0; + let mut x444: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x443, &mut x444, x439, 0x14def9de); + let mut x445: u32 = 0; + let mut x446: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x445, &mut x446, x439, 0xa2f79cd6); + let mut x447: u32 = 0; + let mut x448: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x447, &mut x448, x439, 0x5812631a); + let mut x449: u32 = 0; + let mut x450: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x449, &mut x450, x439, 0x5cf5d3ed); + let mut x451: u32 = 0; + let mut x452: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x451, &mut x452, 0x0, x450, x447); + let mut x453: u32 = 0; + let mut x454: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x453, &mut x454, x452, x448, x445); + let mut x455: u32 = 0; + let mut x456: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x455, &mut x456, x454, x446, x443); + let mut x457: u32 = 0; + let mut x458: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x457, &mut x458, 0x0, x423, x449); + let mut x459: u32 = 0; + let mut x460: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x459, &mut x460, x458, x425, x451); + let mut x461: u32 = 0; + let mut x462: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x461, &mut x462, x460, x427, x453); + let mut x463: u32 = 0; + let mut x464: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x463, &mut x464, x462, x429, x455); + let mut x465: u32 = 0; + let mut x466: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x465, &mut x466, x464, x431, ((x456 as u32) + x444)); + let mut x467: u32 = 0; + let mut x468: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x467, &mut x468, x466, x433, (0x0 as u32)); + let mut x469: u32 = 0; + let mut x470: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x469, &mut x470, x468, x435, (0x0 as u32)); + let mut x471: u32 = 0; + let mut x472: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x471, &mut x472, x470, x437, x441); + let mut x473: u32 = 0; + let mut x474: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x473, &mut x474, x6, 0x399411b); + let mut x475: u32 = 0; + let mut x476: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x475, &mut x476, x6, 0x7c309a3d); + let mut x477: u32 = 0; + let mut x478: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x477, &mut x478, x6, 0xceec73d2); + let mut x479: u32 = 0; + let mut x480: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x479, &mut x480, x6, 0x17f5be65); + let mut x481: u32 = 0; + let mut x482: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x481, &mut x482, x6, 0xd00e1ba7); + let mut x483: u32 = 0; + let mut x484: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x483, &mut x484, x6, 0x68859347); + let mut x485: u32 = 0; + let mut x486: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x485, &mut x486, x6, 0xa40611e3); + let mut x487: u32 = 0; + let mut x488: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x487, &mut x488, x6, 0x449c0f01); + let mut x489: u32 = 0; + let mut x490: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x489, &mut x490, 0x0, x488, x485); + let mut x491: u32 = 0; + let mut x492: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x491, &mut x492, x490, x486, x483); + let mut x493: u32 = 0; + let mut x494: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x493, &mut x494, x492, x484, x481); + let mut x495: u32 = 0; + let mut x496: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x495, &mut x496, x494, x482, x479); + let mut x497: u32 = 0; + let mut x498: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x497, &mut x498, x496, x480, x477); + let mut x499: u32 = 0; + let mut x500: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x499, &mut x500, x498, x478, x475); + let mut x501: u32 = 0; + let mut x502: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x501, &mut x502, x500, x476, x473); + let mut x503: u32 = 0; + let mut x504: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x503, &mut x504, 0x0, x459, x487); + let mut x505: u32 = 0; + let mut x506: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x505, &mut x506, x504, x461, x489); + let mut x507: u32 = 0; + let mut x508: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x507, &mut x508, x506, x463, x491); + let mut x509: u32 = 0; + let mut x510: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x509, &mut x510, x508, x465, x493); + let mut x511: u32 = 0; + let mut x512: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x511, &mut x512, x510, x467, x495); + let mut x513: u32 = 0; + let mut x514: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x513, &mut x514, x512, x469, x497); + let mut x515: u32 = 0; + let mut x516: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x515, &mut x516, x514, x471, x499); + let mut x517: u32 = 0; + let mut x518: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x517, &mut x518, x516, (((x472 as u32) + ((x438 as u32) + ((x422 as u32) + x394))) + x442), x501); + let mut x519: u32 = 0; + let mut x520: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x519, &mut x520, x503, 0x12547e1b); + let mut x521: u32 = 0; + let mut x522: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x521, &mut x522, x519, 0x10000000); + let mut x523: u32 = 0; + let mut x524: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x523, &mut x524, x519, 0x14def9de); + let mut x525: u32 = 0; + let mut x526: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x525, &mut x526, x519, 0xa2f79cd6); + let mut x527: u32 = 0; + let mut x528: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x527, &mut x528, x519, 0x5812631a); + let mut x529: u32 = 0; + let mut x530: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x529, &mut x530, x519, 0x5cf5d3ed); + let mut x531: u32 = 0; + let mut x532: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x531, &mut x532, 0x0, x530, x527); + let mut x533: u32 = 0; + let mut x534: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x533, &mut x534, x532, x528, x525); + let mut x535: u32 = 0; + let mut x536: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x535, &mut x536, x534, x526, x523); + let mut x537: u32 = 0; + let mut x538: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x537, &mut x538, 0x0, x503, x529); + let mut x539: u32 = 0; + let mut x540: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x539, &mut x540, x538, x505, x531); + let mut x541: u32 = 0; + let mut x542: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x541, &mut x542, x540, x507, x533); + let mut x543: u32 = 0; + let mut x544: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x543, &mut x544, x542, x509, x535); + let mut x545: u32 = 0; + let mut x546: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x545, &mut x546, x544, x511, ((x536 as u32) + x524)); + let mut x547: u32 = 0; + let mut x548: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x547, &mut x548, x546, x513, (0x0 as u32)); + let mut x549: u32 = 0; + let mut x550: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x549, &mut x550, x548, x515, (0x0 as u32)); + let mut x551: u32 = 0; + let mut x552: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x551, &mut x552, x550, x517, x521); + let mut x553: u32 = 0; + let mut x554: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x553, &mut x554, x7, 0x399411b); + let mut x555: u32 = 0; + let mut x556: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x555, &mut x556, x7, 0x7c309a3d); + let mut x557: u32 = 0; + let mut x558: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x557, &mut x558, x7, 0xceec73d2); + let mut x559: u32 = 0; + let mut x560: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x559, &mut x560, x7, 0x17f5be65); + let mut x561: u32 = 0; + let mut x562: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x561, &mut x562, x7, 0xd00e1ba7); + let mut x563: u32 = 0; + let mut x564: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x563, &mut x564, x7, 0x68859347); + let mut x565: u32 = 0; + let mut x566: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x565, &mut x566, x7, 0xa40611e3); + let mut x567: u32 = 0; + let mut x568: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x567, &mut x568, x7, 0x449c0f01); + let mut x569: u32 = 0; + let mut x570: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x569, &mut x570, 0x0, x568, x565); + let mut x571: u32 = 0; + let mut x572: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x571, &mut x572, x570, x566, x563); + let mut x573: u32 = 0; + let mut x574: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x573, &mut x574, x572, x564, x561); + let mut x575: u32 = 0; + let mut x576: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x575, &mut x576, x574, x562, x559); + let mut x577: u32 = 0; + let mut x578: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x577, &mut x578, x576, x560, x557); + let mut x579: u32 = 0; + let mut x580: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x579, &mut x580, x578, x558, x555); + let mut x581: u32 = 0; + let mut x582: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x581, &mut x582, x580, x556, x553); + let mut x583: u32 = 0; + let mut x584: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x583, &mut x584, 0x0, x539, x567); + let mut x585: u32 = 0; + let mut x586: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x585, &mut x586, x584, x541, x569); + let mut x587: u32 = 0; + let mut x588: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x587, &mut x588, x586, x543, x571); + let mut x589: u32 = 0; + let mut x590: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x589, &mut x590, x588, x545, x573); + let mut x591: u32 = 0; + let mut x592: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x591, &mut x592, x590, x547, x575); + let mut x593: u32 = 0; + let mut x594: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x593, &mut x594, x592, x549, x577); + let mut x595: u32 = 0; + let mut x596: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x595, &mut x596, x594, x551, x579); + let mut x597: u32 = 0; + let mut x598: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x597, &mut x598, x596, (((x552 as u32) + ((x518 as u32) + ((x502 as u32) + x474))) + x522), x581); + let mut x599: u32 = 0; + let mut x600: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x599, &mut x600, x583, 0x12547e1b); + let mut x601: u32 = 0; + let mut x602: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x601, &mut x602, x599, 0x10000000); + let mut x603: u32 = 0; + let mut x604: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x603, &mut x604, x599, 0x14def9de); + let mut x605: u32 = 0; + let mut x606: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x605, &mut x606, x599, 0xa2f79cd6); + let mut x607: u32 = 0; + let mut x608: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x607, &mut x608, x599, 0x5812631a); + let mut x609: u32 = 0; + let mut x610: u32 = 0; + fiat_25519_scalar_mulx_u32(&mut x609, &mut x610, x599, 0x5cf5d3ed); + let mut x611: u32 = 0; + let mut x612: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x611, &mut x612, 0x0, x610, x607); + let mut x613: u32 = 0; + let mut x614: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x613, &mut x614, x612, x608, x605); + let mut x615: u32 = 0; + let mut x616: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x615, &mut x616, x614, x606, x603); + let mut x617: u32 = 0; + let mut x618: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x617, &mut x618, 0x0, x583, x609); + let mut x619: u32 = 0; + let mut x620: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x619, &mut x620, x618, x585, x611); + let mut x621: u32 = 0; + let mut x622: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x621, &mut x622, x620, x587, x613); + let mut x623: u32 = 0; + let mut x624: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x623, &mut x624, x622, x589, x615); + let mut x625: u32 = 0; + let mut x626: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x625, &mut x626, x624, x591, ((x616 as u32) + x604)); + let mut x627: u32 = 0; + let mut x628: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x627, &mut x628, x626, x593, (0x0 as u32)); + let mut x629: u32 = 0; + let mut x630: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x629, &mut x630, x628, x595, (0x0 as u32)); + let mut x631: u32 = 0; + let mut x632: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x631, &mut x632, x630, x597, x601); + let x633: u32 = (((x632 as u32) + ((x598 as u32) + ((x582 as u32) + x554))) + x602); + let mut x634: u32 = 0; + let mut x635: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x634, &mut x635, 0x0, x619, 0x5cf5d3ed); + let mut x636: u32 = 0; + let mut x637: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x636, &mut x637, x635, x621, 0x5812631a); + let mut x638: u32 = 0; + let mut x639: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x638, &mut x639, x637, x623, 0xa2f79cd6); + let mut x640: u32 = 0; + let mut x641: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x640, &mut x641, x639, x625, 0x14def9de); + let mut x642: u32 = 0; + let mut x643: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x642, &mut x643, x641, x627, (0x0 as u32)); + let mut x644: u32 = 0; + let mut x645: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x644, &mut x645, x643, x629, (0x0 as u32)); + let mut x646: u32 = 0; + let mut x647: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x646, &mut x647, x645, x631, (0x0 as u32)); + let mut x648: u32 = 0; + let mut x649: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x648, &mut x649, x647, x633, 0x10000000); + let mut x650: u32 = 0; + let mut x651: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x650, &mut x651, x649, (0x0 as u32), (0x0 as u32)); + let mut x652: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x652, x651, x634, x619); + let mut x653: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x653, x651, x636, x621); + let mut x654: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x654, x651, x638, x623); + let mut x655: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x655, x651, x640, x625); + let mut x656: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x656, x651, x642, x627); + let mut x657: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x657, x651, x644, x629); + let mut x658: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x658, x651, x646, x631); + let mut x659: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x659, x651, x648, x633); + out1[0] = x652; + out1[1] = x653; + out1[2] = x654; + out1[3] = x655; + out1[4] = x656; + out1[5] = x657; + out1[6] = x658; + out1[7] = x659; +} + +/// The function fiat_25519_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +#[inline] +pub fn fiat_25519_scalar_nonzero(out1: &mut u32, arg1: &[u32; 8]) -> () { + let x1: u32 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | (arg1[7])))))))); + *out1 = x1; +} + +/// The function fiat_25519_scalar_selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_25519_scalar_selectznz(out1: &mut [u32; 8], arg1: fiat_25519_scalar_u1, arg2: &[u32; 8], arg3: &[u32; 8]) -> () { + let mut x1: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x1, arg1, (arg2[0]), (arg3[0])); + let mut x2: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x2, arg1, (arg2[1]), (arg3[1])); + let mut x3: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x3, arg1, (arg2[2]), (arg3[2])); + let mut x4: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x4, arg1, (arg2[3]), (arg3[3])); + let mut x5: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x5, arg1, (arg2[4]), (arg3[4])); + let mut x6: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x6, arg1, (arg2[5]), (arg3[5])); + let mut x7: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x7, arg1, (arg2[6]), (arg3[6])); + let mut x8: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x8, arg1, (arg2[7]), (arg3[7])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; + out1[6] = x7; + out1[7] = x8; +} + +/// The function fiat_25519_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0x1fffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] +#[inline] +pub fn fiat_25519_scalar_to_bytes(out1: &mut [u8; 32], arg1: &[u32; 8]) -> () { + let x1: u32 = (arg1[7]); + let x2: u32 = (arg1[6]); + let x3: u32 = (arg1[5]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[3]); + let x6: u32 = (arg1[2]); + let x7: u32 = (arg1[1]); + let x8: u32 = (arg1[0]); + let x9: u8 = ((x8 & (0xff as u32)) as u8); + let x10: u32 = (x8 >> 8); + let x11: u8 = ((x10 & (0xff as u32)) as u8); + let x12: u32 = (x10 >> 8); + let x13: u8 = ((x12 & (0xff as u32)) as u8); + let x14: u8 = ((x12 >> 8) as u8); + let x15: u8 = ((x7 & (0xff as u32)) as u8); + let x16: u32 = (x7 >> 8); + let x17: u8 = ((x16 & (0xff as u32)) as u8); + let x18: u32 = (x16 >> 8); + let x19: u8 = ((x18 & (0xff as u32)) as u8); + let x20: u8 = ((x18 >> 8) as u8); + let x21: u8 = ((x6 & (0xff as u32)) as u8); + let x22: u32 = (x6 >> 8); + let x23: u8 = ((x22 & (0xff as u32)) as u8); + let x24: u32 = (x22 >> 8); + let x25: u8 = ((x24 & (0xff as u32)) as u8); + let x26: u8 = ((x24 >> 8) as u8); + let x27: u8 = ((x5 & (0xff as u32)) as u8); + let x28: u32 = (x5 >> 8); + let x29: u8 = ((x28 & (0xff as u32)) as u8); + let x30: u32 = (x28 >> 8); + let x31: u8 = ((x30 & (0xff as u32)) as u8); + let x32: u8 = ((x30 >> 8) as u8); + let x33: u8 = ((x4 & (0xff as u32)) as u8); + let x34: u32 = (x4 >> 8); + let x35: u8 = ((x34 & (0xff as u32)) as u8); + let x36: u32 = (x34 >> 8); + let x37: u8 = ((x36 & (0xff as u32)) as u8); + let x38: u8 = ((x36 >> 8) as u8); + let x39: u8 = ((x3 & (0xff as u32)) as u8); + let x40: u32 = (x3 >> 8); + let x41: u8 = ((x40 & (0xff as u32)) as u8); + let x42: u32 = (x40 >> 8); + let x43: u8 = ((x42 & (0xff as u32)) as u8); + let x44: u8 = ((x42 >> 8) as u8); + let x45: u8 = ((x2 & (0xff as u32)) as u8); + let x46: u32 = (x2 >> 8); + let x47: u8 = ((x46 & (0xff as u32)) as u8); + let x48: u32 = (x46 >> 8); + let x49: u8 = ((x48 & (0xff as u32)) as u8); + let x50: u8 = ((x48 >> 8) as u8); + let x51: u8 = ((x1 & (0xff as u32)) as u8); + let x52: u32 = (x1 >> 8); + let x53: u8 = ((x52 & (0xff as u32)) as u8); + let x54: u32 = (x52 >> 8); + let x55: u8 = ((x54 & (0xff as u32)) as u8); + let x56: u8 = ((x54 >> 8) as u8); + out1[0] = x9; + out1[1] = x11; + out1[2] = x13; + out1[3] = x14; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x26; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x38; + out1[20] = x39; + out1[21] = x41; + out1[22] = x43; + out1[23] = x44; + out1[24] = x45; + out1[25] = x47; + out1[26] = x49; + out1[27] = x50; + out1[28] = x51; + out1[29] = x53; + out1[30] = x55; + out1[31] = x56; +} + +/// The function fiat_25519_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0x1fffffff]] +#[inline] +pub fn fiat_25519_scalar_from_bytes(out1: &mut [u32; 8], arg1: &[u8; 32]) -> () { + let x1: u32 = (((arg1[31]) as u32) << 24); + let x2: u32 = (((arg1[30]) as u32) << 16); + let x3: u32 = (((arg1[29]) as u32) << 8); + let x4: u8 = (arg1[28]); + let x5: u32 = (((arg1[27]) as u32) << 24); + let x6: u32 = (((arg1[26]) as u32) << 16); + let x7: u32 = (((arg1[25]) as u32) << 8); + let x8: u8 = (arg1[24]); + let x9: u32 = (((arg1[23]) as u32) << 24); + let x10: u32 = (((arg1[22]) as u32) << 16); + let x11: u32 = (((arg1[21]) as u32) << 8); + let x12: u8 = (arg1[20]); + let x13: u32 = (((arg1[19]) as u32) << 24); + let x14: u32 = (((arg1[18]) as u32) << 16); + let x15: u32 = (((arg1[17]) as u32) << 8); + let x16: u8 = (arg1[16]); + let x17: u32 = (((arg1[15]) as u32) << 24); + let x18: u32 = (((arg1[14]) as u32) << 16); + let x19: u32 = (((arg1[13]) as u32) << 8); + let x20: u8 = (arg1[12]); + let x21: u32 = (((arg1[11]) as u32) << 24); + let x22: u32 = (((arg1[10]) as u32) << 16); + let x23: u32 = (((arg1[9]) as u32) << 8); + let x24: u8 = (arg1[8]); + let x25: u32 = (((arg1[7]) as u32) << 24); + let x26: u32 = (((arg1[6]) as u32) << 16); + let x27: u32 = (((arg1[5]) as u32) << 8); + let x28: u8 = (arg1[4]); + let x29: u32 = (((arg1[3]) as u32) << 24); + let x30: u32 = (((arg1[2]) as u32) << 16); + let x31: u32 = (((arg1[1]) as u32) << 8); + let x32: u8 = (arg1[0]); + let x33: u32 = (x31 + (x32 as u32)); + let x34: u32 = (x30 + x33); + let x35: u32 = (x29 + x34); + let x36: u32 = (x27 + (x28 as u32)); + let x37: u32 = (x26 + x36); + let x38: u32 = (x25 + x37); + let x39: u32 = (x23 + (x24 as u32)); + let x40: u32 = (x22 + x39); + let x41: u32 = (x21 + x40); + let x42: u32 = (x19 + (x20 as u32)); + let x43: u32 = (x18 + x42); + let x44: u32 = (x17 + x43); + let x45: u32 = (x15 + (x16 as u32)); + let x46: u32 = (x14 + x45); + let x47: u32 = (x13 + x46); + let x48: u32 = (x11 + (x12 as u32)); + let x49: u32 = (x10 + x48); + let x50: u32 = (x9 + x49); + let x51: u32 = (x7 + (x8 as u32)); + let x52: u32 = (x6 + x51); + let x53: u32 = (x5 + x52); + let x54: u32 = (x3 + (x4 as u32)); + let x55: u32 = (x2 + x54); + let x56: u32 = (x1 + x55); + out1[0] = x35; + out1[1] = x38; + out1[2] = x41; + out1[3] = x44; + out1[4] = x47; + out1[5] = x50; + out1[6] = x53; + out1[7] = x56; +} + +/// The function fiat_25519_scalar_set_one returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_set_one(out1: &mut fiat_25519_scalar_montgomery_domain_field_element) -> () { + out1[0] = 0x8d98951d; + out1[1] = 0xd6ec3174; + out1[2] = 0x737dcf70; + out1[3] = 0xc6ef5bf4; + out1[4] = 0xfffffffe; + out1[5] = 0xffffffff; + out1[6] = 0xffffffff; + out1[7] = 0xfffffff; +} + +/// The function fiat_25519_scalar_msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_25519_scalar_msat(out1: &mut [u32; 9]) -> () { + out1[0] = 0x5cf5d3ed; + out1[1] = 0x5812631a; + out1[2] = 0xa2f79cd6; + out1[3] = 0x14def9de; + out1[4] = (0x0 as u32); + out1[5] = (0x0 as u32); + out1[6] = (0x0 as u32); + out1[7] = 0x10000000; + out1[8] = (0x0 as u32); +} + +/// The function fiat_25519_scalar_divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_25519_scalar_divstep(out1: &mut u32, out2: &mut [u32; 9], out3: &mut [u32; 9], out4: &mut [u32; 8], out5: &mut [u32; 8], arg1: u32, arg2: &[u32; 9], arg3: &[u32; 9], arg4: &[u32; 8], arg5: &[u32; 8]) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x1, &mut x2, 0x0, (!arg1), (0x1 as u32)); + let x3: fiat_25519_scalar_u1 = (((x1 >> 31) as fiat_25519_scalar_u1) & (((arg3[0]) & (0x1 as u32)) as fiat_25519_scalar_u1)); + let mut x4: u32 = 0; + let mut x5: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x4, &mut x5, 0x0, (!arg1), (0x1 as u32)); + let mut x6: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x6, x3, arg1, x4); + let mut x7: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x7, x3, (arg2[0]), (arg3[0])); + let mut x8: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x8, x3, (arg2[1]), (arg3[1])); + let mut x9: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x9, x3, (arg2[2]), (arg3[2])); + let mut x10: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x10, x3, (arg2[3]), (arg3[3])); + let mut x11: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x11, x3, (arg2[4]), (arg3[4])); + let mut x12: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x12, x3, (arg2[5]), (arg3[5])); + let mut x13: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x13, x3, (arg2[6]), (arg3[6])); + let mut x14: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x14, x3, (arg2[7]), (arg3[7])); + let mut x15: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x15, x3, (arg2[8]), (arg3[8])); + let mut x16: u32 = 0; + let mut x17: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x16, &mut x17, 0x0, (0x1 as u32), (!(arg2[0]))); + let mut x18: u32 = 0; + let mut x19: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x18, &mut x19, x17, (0x0 as u32), (!(arg2[1]))); + let mut x20: u32 = 0; + let mut x21: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x20, &mut x21, x19, (0x0 as u32), (!(arg2[2]))); + let mut x22: u32 = 0; + let mut x23: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x22, &mut x23, x21, (0x0 as u32), (!(arg2[3]))); + let mut x24: u32 = 0; + let mut x25: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x24, &mut x25, x23, (0x0 as u32), (!(arg2[4]))); + let mut x26: u32 = 0; + let mut x27: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x26, &mut x27, x25, (0x0 as u32), (!(arg2[5]))); + let mut x28: u32 = 0; + let mut x29: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x28, &mut x29, x27, (0x0 as u32), (!(arg2[6]))); + let mut x30: u32 = 0; + let mut x31: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x30, &mut x31, x29, (0x0 as u32), (!(arg2[7]))); + let mut x32: u32 = 0; + let mut x33: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x32, &mut x33, x31, (0x0 as u32), (!(arg2[8]))); + let mut x34: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x34, x3, (arg3[0]), x16); + let mut x35: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x35, x3, (arg3[1]), x18); + let mut x36: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x36, x3, (arg3[2]), x20); + let mut x37: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x37, x3, (arg3[3]), x22); + let mut x38: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x38, x3, (arg3[4]), x24); + let mut x39: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x39, x3, (arg3[5]), x26); + let mut x40: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x40, x3, (arg3[6]), x28); + let mut x41: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x41, x3, (arg3[7]), x30); + let mut x42: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x42, x3, (arg3[8]), x32); + let mut x43: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x43, x3, (arg4[0]), (arg5[0])); + let mut x44: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x44, x3, (arg4[1]), (arg5[1])); + let mut x45: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x45, x3, (arg4[2]), (arg5[2])); + let mut x46: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x46, x3, (arg4[3]), (arg5[3])); + let mut x47: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x47, x3, (arg4[4]), (arg5[4])); + let mut x48: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x48, x3, (arg4[5]), (arg5[5])); + let mut x49: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x49, x3, (arg4[6]), (arg5[6])); + let mut x50: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x50, x3, (arg4[7]), (arg5[7])); + let mut x51: u32 = 0; + let mut x52: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x51, &mut x52, 0x0, x43, x43); + let mut x53: u32 = 0; + let mut x54: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x53, &mut x54, x52, x44, x44); + let mut x55: u32 = 0; + let mut x56: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x55, &mut x56, x54, x45, x45); + let mut x57: u32 = 0; + let mut x58: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x57, &mut x58, x56, x46, x46); + let mut x59: u32 = 0; + let mut x60: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x59, &mut x60, x58, x47, x47); + let mut x61: u32 = 0; + let mut x62: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x61, &mut x62, x60, x48, x48); + let mut x63: u32 = 0; + let mut x64: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x63, &mut x64, x62, x49, x49); + let mut x65: u32 = 0; + let mut x66: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x65, &mut x66, x64, x50, x50); + let mut x67: u32 = 0; + let mut x68: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x67, &mut x68, 0x0, x51, 0x5cf5d3ed); + let mut x69: u32 = 0; + let mut x70: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x69, &mut x70, x68, x53, 0x5812631a); + let mut x71: u32 = 0; + let mut x72: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x71, &mut x72, x70, x55, 0xa2f79cd6); + let mut x73: u32 = 0; + let mut x74: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x73, &mut x74, x72, x57, 0x14def9de); + let mut x75: u32 = 0; + let mut x76: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x75, &mut x76, x74, x59, (0x0 as u32)); + let mut x77: u32 = 0; + let mut x78: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x77, &mut x78, x76, x61, (0x0 as u32)); + let mut x79: u32 = 0; + let mut x80: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x79, &mut x80, x78, x63, (0x0 as u32)); + let mut x81: u32 = 0; + let mut x82: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x81, &mut x82, x80, x65, 0x10000000); + let mut x83: u32 = 0; + let mut x84: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x83, &mut x84, x82, (x66 as u32), (0x0 as u32)); + let x85: u32 = (arg4[7]); + let x86: u32 = (arg4[6]); + let x87: u32 = (arg4[5]); + let x88: u32 = (arg4[4]); + let x89: u32 = (arg4[3]); + let x90: u32 = (arg4[2]); + let x91: u32 = (arg4[1]); + let x92: u32 = (arg4[0]); + let mut x93: u32 = 0; + let mut x94: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x93, &mut x94, 0x0, (0x0 as u32), x92); + let mut x95: u32 = 0; + let mut x96: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x95, &mut x96, x94, (0x0 as u32), x91); + let mut x97: u32 = 0; + let mut x98: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x97, &mut x98, x96, (0x0 as u32), x90); + let mut x99: u32 = 0; + let mut x100: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x99, &mut x100, x98, (0x0 as u32), x89); + let mut x101: u32 = 0; + let mut x102: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x101, &mut x102, x100, (0x0 as u32), x88); + let mut x103: u32 = 0; + let mut x104: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x103, &mut x104, x102, (0x0 as u32), x87); + let mut x105: u32 = 0; + let mut x106: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x105, &mut x106, x104, (0x0 as u32), x86); + let mut x107: u32 = 0; + let mut x108: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x107, &mut x108, x106, (0x0 as u32), x85); + let mut x109: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x109, x108, (0x0 as u32), 0xffffffff); + let mut x110: u32 = 0; + let mut x111: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x110, &mut x111, 0x0, x93, (x109 & 0x5cf5d3ed)); + let mut x112: u32 = 0; + let mut x113: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x112, &mut x113, x111, x95, (x109 & 0x5812631a)); + let mut x114: u32 = 0; + let mut x115: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x114, &mut x115, x113, x97, (x109 & 0xa2f79cd6)); + let mut x116: u32 = 0; + let mut x117: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x116, &mut x117, x115, x99, (x109 & 0x14def9de)); + let mut x118: u32 = 0; + let mut x119: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x118, &mut x119, x117, x101, (0x0 as u32)); + let mut x120: u32 = 0; + let mut x121: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x120, &mut x121, x119, x103, (0x0 as u32)); + let mut x122: u32 = 0; + let mut x123: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x122, &mut x123, x121, x105, (0x0 as u32)); + let mut x124: u32 = 0; + let mut x125: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x107, (x109 & 0x10000000)); + let mut x126: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x126, x3, (arg5[0]), x110); + let mut x127: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x127, x3, (arg5[1]), x112); + let mut x128: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x128, x3, (arg5[2]), x114); + let mut x129: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x129, x3, (arg5[3]), x116); + let mut x130: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x130, x3, (arg5[4]), x118); + let mut x131: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x131, x3, (arg5[5]), x120); + let mut x132: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x132, x3, (arg5[6]), x122); + let mut x133: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x133, x3, (arg5[7]), x124); + let x134: fiat_25519_scalar_u1 = ((x34 & (0x1 as u32)) as fiat_25519_scalar_u1); + let mut x135: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x135, x134, (0x0 as u32), x7); + let mut x136: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x136, x134, (0x0 as u32), x8); + let mut x137: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x137, x134, (0x0 as u32), x9); + let mut x138: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x138, x134, (0x0 as u32), x10); + let mut x139: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x139, x134, (0x0 as u32), x11); + let mut x140: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x140, x134, (0x0 as u32), x12); + let mut x141: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x141, x134, (0x0 as u32), x13); + let mut x142: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x142, x134, (0x0 as u32), x14); + let mut x143: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x143, x134, (0x0 as u32), x15); + let mut x144: u32 = 0; + let mut x145: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x144, &mut x145, 0x0, x34, x135); + let mut x146: u32 = 0; + let mut x147: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x146, &mut x147, x145, x35, x136); + let mut x148: u32 = 0; + let mut x149: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x148, &mut x149, x147, x36, x137); + let mut x150: u32 = 0; + let mut x151: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x150, &mut x151, x149, x37, x138); + let mut x152: u32 = 0; + let mut x153: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x152, &mut x153, x151, x38, x139); + let mut x154: u32 = 0; + let mut x155: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x154, &mut x155, x153, x39, x140); + let mut x156: u32 = 0; + let mut x157: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x156, &mut x157, x155, x40, x141); + let mut x158: u32 = 0; + let mut x159: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x158, &mut x159, x157, x41, x142); + let mut x160: u32 = 0; + let mut x161: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x42, x143); + let mut x162: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x162, x134, (0x0 as u32), x43); + let mut x163: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x163, x134, (0x0 as u32), x44); + let mut x164: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x164, x134, (0x0 as u32), x45); + let mut x165: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x165, x134, (0x0 as u32), x46); + let mut x166: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x166, x134, (0x0 as u32), x47); + let mut x167: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x167, x134, (0x0 as u32), x48); + let mut x168: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x168, x134, (0x0 as u32), x49); + let mut x169: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x169, x134, (0x0 as u32), x50); + let mut x170: u32 = 0; + let mut x171: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x170, &mut x171, 0x0, x126, x162); + let mut x172: u32 = 0; + let mut x173: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x172, &mut x173, x171, x127, x163); + let mut x174: u32 = 0; + let mut x175: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x174, &mut x175, x173, x128, x164); + let mut x176: u32 = 0; + let mut x177: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x176, &mut x177, x175, x129, x165); + let mut x178: u32 = 0; + let mut x179: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x178, &mut x179, x177, x130, x166); + let mut x180: u32 = 0; + let mut x181: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x180, &mut x181, x179, x131, x167); + let mut x182: u32 = 0; + let mut x183: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x182, &mut x183, x181, x132, x168); + let mut x184: u32 = 0; + let mut x185: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x184, &mut x185, x183, x133, x169); + let mut x186: u32 = 0; + let mut x187: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x186, &mut x187, 0x0, x170, 0x5cf5d3ed); + let mut x188: u32 = 0; + let mut x189: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x188, &mut x189, x187, x172, 0x5812631a); + let mut x190: u32 = 0; + let mut x191: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x190, &mut x191, x189, x174, 0xa2f79cd6); + let mut x192: u32 = 0; + let mut x193: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x192, &mut x193, x191, x176, 0x14def9de); + let mut x194: u32 = 0; + let mut x195: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x194, &mut x195, x193, x178, (0x0 as u32)); + let mut x196: u32 = 0; + let mut x197: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x196, &mut x197, x195, x180, (0x0 as u32)); + let mut x198: u32 = 0; + let mut x199: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x198, &mut x199, x197, x182, (0x0 as u32)); + let mut x200: u32 = 0; + let mut x201: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x200, &mut x201, x199, x184, 0x10000000); + let mut x202: u32 = 0; + let mut x203: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u32(&mut x202, &mut x203, x201, (x185 as u32), (0x0 as u32)); + let mut x204: u32 = 0; + let mut x205: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u32(&mut x204, &mut x205, 0x0, x6, (0x1 as u32)); + let x206: u32 = ((x144 >> 1) | ((x146 << 31) & 0xffffffff)); + let x207: u32 = ((x146 >> 1) | ((x148 << 31) & 0xffffffff)); + let x208: u32 = ((x148 >> 1) | ((x150 << 31) & 0xffffffff)); + let x209: u32 = ((x150 >> 1) | ((x152 << 31) & 0xffffffff)); + let x210: u32 = ((x152 >> 1) | ((x154 << 31) & 0xffffffff)); + let x211: u32 = ((x154 >> 1) | ((x156 << 31) & 0xffffffff)); + let x212: u32 = ((x156 >> 1) | ((x158 << 31) & 0xffffffff)); + let x213: u32 = ((x158 >> 1) | ((x160 << 31) & 0xffffffff)); + let x214: u32 = ((x160 & 0x80000000) | (x160 >> 1)); + let mut x215: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x215, x84, x67, x51); + let mut x216: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x216, x84, x69, x53); + let mut x217: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x217, x84, x71, x55); + let mut x218: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x218, x84, x73, x57); + let mut x219: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x219, x84, x75, x59); + let mut x220: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x220, x84, x77, x61); + let mut x221: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x221, x84, x79, x63); + let mut x222: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x222, x84, x81, x65); + let mut x223: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x223, x203, x186, x170); + let mut x224: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x224, x203, x188, x172); + let mut x225: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x225, x203, x190, x174); + let mut x226: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x226, x203, x192, x176); + let mut x227: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x227, x203, x194, x178); + let mut x228: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x228, x203, x196, x180); + let mut x229: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x229, x203, x198, x182); + let mut x230: u32 = 0; + fiat_25519_scalar_cmovznz_u32(&mut x230, x203, x200, x184); + *out1 = x204; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out2[7] = x14; + out2[8] = x15; + out3[0] = x206; + out3[1] = x207; + out3[2] = x208; + out3[3] = x209; + out3[4] = x210; + out3[5] = x211; + out3[6] = x212; + out3[7] = x213; + out3[8] = x214; + out4[0] = x215; + out4[1] = x216; + out4[2] = x217; + out4[3] = x218; + out4[4] = x219; + out4[5] = x220; + out4[6] = x221; + out4[7] = x222; + out5[0] = x223; + out5[1] = x224; + out5[2] = x225; + out5[3] = x226; + out5[4] = x227; + out5[5] = x228; + out5[6] = x229; + out5[7] = x230; +} + +/// The function fiat_25519_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_25519_scalar_divstep_precomp(out1: &mut [u32; 8]) -> () { + out1[0] = 0x36a7cb92; + out1[1] = 0xd70af844; + out1[2] = 0xb0b8b159; + out1[3] = 0x5f71c978; + out1[4] = 0x74947f1a; + out1[5] = 0xe76d8169; + out1[6] = 0xf193e4ff; + out1[7] = 0x19a2d36; +} diff --git a/fiat-rust/src/curve25519_scalar_64.rs b/fiat-rust/src/curve25519_scalar_64.rs new file mode 100644 index 0000000000..dc45f1b8ef --- /dev/null +++ b/fiat-rust/src/curve25519_scalar_64.rs @@ -0,0 +1,1830 @@ +//! Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline 25519_scalar 64 '2^252 + 27742317777372353535851937790883648493' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +//! curve description: 25519_scalar +//! machine_wordsize = 64 (from "64") +//! requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +//! m = 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed (from "2^252 + 27742317777372353535851937790883648493") +//! +//! NOTE: In addition to the bounds specified above each function, all +//! functions synthesized for this Montgomery arithmetic require the +//! input to be strictly less than the prime modulus (m), and also +//! require the input to be in the unique saturated representation. +//! All functions also ensure that these two properties are true of +//! return values. +//! +//! Computed values: +//! eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) +//! bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +//! twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in +//! if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 + +#![allow(unused_parens)] +#![allow(non_camel_case_types)] + +pub type fiat_25519_scalar_u1 = u8; +pub type fiat_25519_scalar_i1 = i8; +pub type fiat_25519_scalar_u2 = u8; +pub type fiat_25519_scalar_i2 = i8; + +/* The type fiat_25519_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +pub type fiat_25519_scalar_montgomery_domain_field_element = [u64; 4]; + +/* The type fiat_25519_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +pub type fiat_25519_scalar_non_montgomery_domain_field_element = [u64; 4]; + + +/// The function fiat_25519_scalar_addcarryx_u64 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^64 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_25519_scalar_addcarryx_u64(out1: &mut u64, out2: &mut fiat_25519_scalar_u1, arg1: fiat_25519_scalar_u1, arg2: u64, arg3: u64) -> () { + let x1: u128 = (((arg1 as u128) + (arg2 as u128)) + (arg3 as u128)); + let x2: u64 = ((x1 & (0xffffffffffffffff as u128)) as u64); + let x3: fiat_25519_scalar_u1 = ((x1 >> 64) as fiat_25519_scalar_u1); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_25519_scalar_subborrowx_u64 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^64 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_25519_scalar_subborrowx_u64(out1: &mut u64, out2: &mut fiat_25519_scalar_u1, arg1: fiat_25519_scalar_u1, arg2: u64, arg3: u64) -> () { + let x1: i128 = (((arg2 as i128) - (arg1 as i128)) - (arg3 as i128)); + let x2: fiat_25519_scalar_i1 = ((x1 >> 64) as fiat_25519_scalar_i1); + let x3: u64 = ((x1 & (0xffffffffffffffff as i128)) as u64); + *out1 = x3; + *out2 = (((0x0 as fiat_25519_scalar_i2) - (x2 as fiat_25519_scalar_i2)) as fiat_25519_scalar_u1); +} + +/// The function fiat_25519_scalar_mulx_u64 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^64 +/// out2 = ⌊arg1 * arg2 / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0xffffffffffffffff] +#[inline] +pub fn fiat_25519_scalar_mulx_u64(out1: &mut u64, out2: &mut u64, arg1: u64, arg2: u64) -> () { + let x1: u128 = ((arg1 as u128) * (arg2 as u128)); + let x2: u64 = ((x1 & (0xffffffffffffffff as u128)) as u64); + let x3: u64 = ((x1 >> 64) as u64); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_25519_scalar_cmovznz_u64 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +#[inline] +pub fn fiat_25519_scalar_cmovznz_u64(out1: &mut u64, arg1: fiat_25519_scalar_u1, arg2: u64, arg3: u64) -> () { + let x1: fiat_25519_scalar_u1 = (!(!arg1)); + let x2: u64 = ((((((0x0 as fiat_25519_scalar_i2) - (x1 as fiat_25519_scalar_i2)) as fiat_25519_scalar_i1) as i128) & (0xffffffffffffffff as i128)) as u64); + let x3: u64 = ((x2 & arg3) | ((!x2) & arg2)); + *out1 = x3; +} + +/// The function fiat_25519_scalar_mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_mul(out1: &mut fiat_25519_scalar_montgomery_domain_field_element, arg1: &fiat_25519_scalar_montgomery_domain_field_element, arg2: &fiat_25519_scalar_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[1]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[0]); + let mut x5: u64 = 0; + let mut x6: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x5, &mut x6, x4, (arg2[3])); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x7, &mut x8, x4, (arg2[2])); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x9, &mut x10, x4, (arg2[1])); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x11, &mut x12, x4, (arg2[0])); + let mut x13: u64 = 0; + let mut x14: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x17, &mut x18, x16, x8, x5); + let x19: u64 = ((x18 as u64) + x6); + let mut x20: u64 = 0; + let mut x21: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x20, &mut x21, x11, 0xd2b51da312547e1b); + let mut x22: u64 = 0; + let mut x23: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x22, &mut x23, x20, 0x1000000000000000); + let mut x24: u64 = 0; + let mut x25: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x24, &mut x25, x20, 0x14def9dea2f79cd6); + let mut x26: u64 = 0; + let mut x27: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x26, &mut x27, x20, 0x5812631a5cf5d3ed); + let mut x28: u64 = 0; + let mut x29: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x28, &mut x29, 0x0, x27, x24); + let x30: u64 = ((x29 as u64) + x25); + let mut x31: u64 = 0; + let mut x32: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x31, &mut x32, 0x0, x11, x26); + let mut x33: u64 = 0; + let mut x34: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x33, &mut x34, x32, x13, x28); + let mut x35: u64 = 0; + let mut x36: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x35, &mut x36, x34, x15, x30); + let mut x37: u64 = 0; + let mut x38: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x37, &mut x38, x36, x17, x22); + let mut x39: u64 = 0; + let mut x40: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x39, &mut x40, x38, x19, x23); + let mut x41: u64 = 0; + let mut x42: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x41, &mut x42, x1, (arg2[3])); + let mut x43: u64 = 0; + let mut x44: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x43, &mut x44, x1, (arg2[2])); + let mut x45: u64 = 0; + let mut x46: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x45, &mut x46, x1, (arg2[1])); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x47, &mut x48, x1, (arg2[0])); + let mut x49: u64 = 0; + let mut x50: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x49, &mut x50, 0x0, x48, x45); + let mut x51: u64 = 0; + let mut x52: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x51, &mut x52, x50, x46, x43); + let mut x53: u64 = 0; + let mut x54: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x53, &mut x54, x52, x44, x41); + let x55: u64 = ((x54 as u64) + x42); + let mut x56: u64 = 0; + let mut x57: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x56, &mut x57, 0x0, x33, x47); + let mut x58: u64 = 0; + let mut x59: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x58, &mut x59, x57, x35, x49); + let mut x60: u64 = 0; + let mut x61: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x60, &mut x61, x59, x37, x51); + let mut x62: u64 = 0; + let mut x63: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x62, &mut x63, x61, x39, x53); + let mut x64: u64 = 0; + let mut x65: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x64, &mut x65, x63, (x40 as u64), x55); + let mut x66: u64 = 0; + let mut x67: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x66, &mut x67, x56, 0xd2b51da312547e1b); + let mut x68: u64 = 0; + let mut x69: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x68, &mut x69, x66, 0x1000000000000000); + let mut x70: u64 = 0; + let mut x71: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x70, &mut x71, x66, 0x14def9dea2f79cd6); + let mut x72: u64 = 0; + let mut x73: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x72, &mut x73, x66, 0x5812631a5cf5d3ed); + let mut x74: u64 = 0; + let mut x75: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x74, &mut x75, 0x0, x73, x70); + let x76: u64 = ((x75 as u64) + x71); + let mut x77: u64 = 0; + let mut x78: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x77, &mut x78, 0x0, x56, x72); + let mut x79: u64 = 0; + let mut x80: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x79, &mut x80, x78, x58, x74); + let mut x81: u64 = 0; + let mut x82: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x81, &mut x82, x80, x60, x76); + let mut x83: u64 = 0; + let mut x84: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x83, &mut x84, x82, x62, x68); + let mut x85: u64 = 0; + let mut x86: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x85, &mut x86, x84, x64, x69); + let x87: u64 = ((x86 as u64) + (x65 as u64)); + let mut x88: u64 = 0; + let mut x89: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x88, &mut x89, x2, (arg2[3])); + let mut x90: u64 = 0; + let mut x91: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x90, &mut x91, x2, (arg2[2])); + let mut x92: u64 = 0; + let mut x93: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x92, &mut x93, x2, (arg2[1])); + let mut x94: u64 = 0; + let mut x95: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x94, &mut x95, x2, (arg2[0])); + let mut x96: u64 = 0; + let mut x97: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x96, &mut x97, 0x0, x95, x92); + let mut x98: u64 = 0; + let mut x99: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x98, &mut x99, x97, x93, x90); + let mut x100: u64 = 0; + let mut x101: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x100, &mut x101, x99, x91, x88); + let x102: u64 = ((x101 as u64) + x89); + let mut x103: u64 = 0; + let mut x104: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x103, &mut x104, 0x0, x79, x94); + let mut x105: u64 = 0; + let mut x106: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x105, &mut x106, x104, x81, x96); + let mut x107: u64 = 0; + let mut x108: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x107, &mut x108, x106, x83, x98); + let mut x109: u64 = 0; + let mut x110: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x109, &mut x110, x108, x85, x100); + let mut x111: u64 = 0; + let mut x112: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x111, &mut x112, x110, x87, x102); + let mut x113: u64 = 0; + let mut x114: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x113, &mut x114, x103, 0xd2b51da312547e1b); + let mut x115: u64 = 0; + let mut x116: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x115, &mut x116, x113, 0x1000000000000000); + let mut x117: u64 = 0; + let mut x118: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x117, &mut x118, x113, 0x14def9dea2f79cd6); + let mut x119: u64 = 0; + let mut x120: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x119, &mut x120, x113, 0x5812631a5cf5d3ed); + let mut x121: u64 = 0; + let mut x122: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x121, &mut x122, 0x0, x120, x117); + let x123: u64 = ((x122 as u64) + x118); + let mut x124: u64 = 0; + let mut x125: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x124, &mut x125, 0x0, x103, x119); + let mut x126: u64 = 0; + let mut x127: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x126, &mut x127, x125, x105, x121); + let mut x128: u64 = 0; + let mut x129: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x128, &mut x129, x127, x107, x123); + let mut x130: u64 = 0; + let mut x131: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x130, &mut x131, x129, x109, x115); + let mut x132: u64 = 0; + let mut x133: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x132, &mut x133, x131, x111, x116); + let x134: u64 = ((x133 as u64) + (x112 as u64)); + let mut x135: u64 = 0; + let mut x136: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x135, &mut x136, x3, (arg2[3])); + let mut x137: u64 = 0; + let mut x138: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x137, &mut x138, x3, (arg2[2])); + let mut x139: u64 = 0; + let mut x140: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x139, &mut x140, x3, (arg2[1])); + let mut x141: u64 = 0; + let mut x142: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x141, &mut x142, x3, (arg2[0])); + let mut x143: u64 = 0; + let mut x144: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x143, &mut x144, 0x0, x142, x139); + let mut x145: u64 = 0; + let mut x146: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x145, &mut x146, x144, x140, x137); + let mut x147: u64 = 0; + let mut x148: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x147, &mut x148, x146, x138, x135); + let x149: u64 = ((x148 as u64) + x136); + let mut x150: u64 = 0; + let mut x151: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x150, &mut x151, 0x0, x126, x141); + let mut x152: u64 = 0; + let mut x153: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x152, &mut x153, x151, x128, x143); + let mut x154: u64 = 0; + let mut x155: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x154, &mut x155, x153, x130, x145); + let mut x156: u64 = 0; + let mut x157: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x156, &mut x157, x155, x132, x147); + let mut x158: u64 = 0; + let mut x159: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x158, &mut x159, x157, x134, x149); + let mut x160: u64 = 0; + let mut x161: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x160, &mut x161, x150, 0xd2b51da312547e1b); + let mut x162: u64 = 0; + let mut x163: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x162, &mut x163, x160, 0x1000000000000000); + let mut x164: u64 = 0; + let mut x165: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x164, &mut x165, x160, 0x14def9dea2f79cd6); + let mut x166: u64 = 0; + let mut x167: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x166, &mut x167, x160, 0x5812631a5cf5d3ed); + let mut x168: u64 = 0; + let mut x169: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x168, &mut x169, 0x0, x167, x164); + let x170: u64 = ((x169 as u64) + x165); + let mut x171: u64 = 0; + let mut x172: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x171, &mut x172, 0x0, x150, x166); + let mut x173: u64 = 0; + let mut x174: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x173, &mut x174, x172, x152, x168); + let mut x175: u64 = 0; + let mut x176: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x175, &mut x176, x174, x154, x170); + let mut x177: u64 = 0; + let mut x178: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x177, &mut x178, x176, x156, x162); + let mut x179: u64 = 0; + let mut x180: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x179, &mut x180, x178, x158, x163); + let x181: u64 = ((x180 as u64) + (x159 as u64)); + let mut x182: u64 = 0; + let mut x183: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x182, &mut x183, 0x0, x173, 0x5812631a5cf5d3ed); + let mut x184: u64 = 0; + let mut x185: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x184, &mut x185, x183, x175, 0x14def9dea2f79cd6); + let mut x186: u64 = 0; + let mut x187: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x186, &mut x187, x185, x177, (0x0 as u64)); + let mut x188: u64 = 0; + let mut x189: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x188, &mut x189, x187, x179, 0x1000000000000000); + let mut x190: u64 = 0; + let mut x191: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x190, &mut x191, x189, x181, (0x0 as u64)); + let mut x192: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x192, x191, x182, x173); + let mut x193: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x193, x191, x184, x175); + let mut x194: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x194, x191, x186, x177); + let mut x195: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x195, x191, x188, x179); + out1[0] = x192; + out1[1] = x193; + out1[2] = x194; + out1[3] = x195; +} + +/// The function fiat_25519_scalar_square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_square(out1: &mut fiat_25519_scalar_montgomery_domain_field_element, arg1: &fiat_25519_scalar_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[1]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[0]); + let mut x5: u64 = 0; + let mut x6: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x5, &mut x6, x4, (arg1[3])); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x7, &mut x8, x4, (arg1[2])); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x9, &mut x10, x4, (arg1[1])); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x11, &mut x12, x4, (arg1[0])); + let mut x13: u64 = 0; + let mut x14: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x17, &mut x18, x16, x8, x5); + let x19: u64 = ((x18 as u64) + x6); + let mut x20: u64 = 0; + let mut x21: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x20, &mut x21, x11, 0xd2b51da312547e1b); + let mut x22: u64 = 0; + let mut x23: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x22, &mut x23, x20, 0x1000000000000000); + let mut x24: u64 = 0; + let mut x25: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x24, &mut x25, x20, 0x14def9dea2f79cd6); + let mut x26: u64 = 0; + let mut x27: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x26, &mut x27, x20, 0x5812631a5cf5d3ed); + let mut x28: u64 = 0; + let mut x29: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x28, &mut x29, 0x0, x27, x24); + let x30: u64 = ((x29 as u64) + x25); + let mut x31: u64 = 0; + let mut x32: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x31, &mut x32, 0x0, x11, x26); + let mut x33: u64 = 0; + let mut x34: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x33, &mut x34, x32, x13, x28); + let mut x35: u64 = 0; + let mut x36: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x35, &mut x36, x34, x15, x30); + let mut x37: u64 = 0; + let mut x38: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x37, &mut x38, x36, x17, x22); + let mut x39: u64 = 0; + let mut x40: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x39, &mut x40, x38, x19, x23); + let mut x41: u64 = 0; + let mut x42: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x41, &mut x42, x1, (arg1[3])); + let mut x43: u64 = 0; + let mut x44: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x43, &mut x44, x1, (arg1[2])); + let mut x45: u64 = 0; + let mut x46: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x45, &mut x46, x1, (arg1[1])); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x47, &mut x48, x1, (arg1[0])); + let mut x49: u64 = 0; + let mut x50: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x49, &mut x50, 0x0, x48, x45); + let mut x51: u64 = 0; + let mut x52: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x51, &mut x52, x50, x46, x43); + let mut x53: u64 = 0; + let mut x54: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x53, &mut x54, x52, x44, x41); + let x55: u64 = ((x54 as u64) + x42); + let mut x56: u64 = 0; + let mut x57: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x56, &mut x57, 0x0, x33, x47); + let mut x58: u64 = 0; + let mut x59: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x58, &mut x59, x57, x35, x49); + let mut x60: u64 = 0; + let mut x61: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x60, &mut x61, x59, x37, x51); + let mut x62: u64 = 0; + let mut x63: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x62, &mut x63, x61, x39, x53); + let mut x64: u64 = 0; + let mut x65: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x64, &mut x65, x63, (x40 as u64), x55); + let mut x66: u64 = 0; + let mut x67: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x66, &mut x67, x56, 0xd2b51da312547e1b); + let mut x68: u64 = 0; + let mut x69: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x68, &mut x69, x66, 0x1000000000000000); + let mut x70: u64 = 0; + let mut x71: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x70, &mut x71, x66, 0x14def9dea2f79cd6); + let mut x72: u64 = 0; + let mut x73: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x72, &mut x73, x66, 0x5812631a5cf5d3ed); + let mut x74: u64 = 0; + let mut x75: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x74, &mut x75, 0x0, x73, x70); + let x76: u64 = ((x75 as u64) + x71); + let mut x77: u64 = 0; + let mut x78: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x77, &mut x78, 0x0, x56, x72); + let mut x79: u64 = 0; + let mut x80: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x79, &mut x80, x78, x58, x74); + let mut x81: u64 = 0; + let mut x82: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x81, &mut x82, x80, x60, x76); + let mut x83: u64 = 0; + let mut x84: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x83, &mut x84, x82, x62, x68); + let mut x85: u64 = 0; + let mut x86: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x85, &mut x86, x84, x64, x69); + let x87: u64 = ((x86 as u64) + (x65 as u64)); + let mut x88: u64 = 0; + let mut x89: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x88, &mut x89, x2, (arg1[3])); + let mut x90: u64 = 0; + let mut x91: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x90, &mut x91, x2, (arg1[2])); + let mut x92: u64 = 0; + let mut x93: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x92, &mut x93, x2, (arg1[1])); + let mut x94: u64 = 0; + let mut x95: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x94, &mut x95, x2, (arg1[0])); + let mut x96: u64 = 0; + let mut x97: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x96, &mut x97, 0x0, x95, x92); + let mut x98: u64 = 0; + let mut x99: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x98, &mut x99, x97, x93, x90); + let mut x100: u64 = 0; + let mut x101: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x100, &mut x101, x99, x91, x88); + let x102: u64 = ((x101 as u64) + x89); + let mut x103: u64 = 0; + let mut x104: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x103, &mut x104, 0x0, x79, x94); + let mut x105: u64 = 0; + let mut x106: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x105, &mut x106, x104, x81, x96); + let mut x107: u64 = 0; + let mut x108: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x107, &mut x108, x106, x83, x98); + let mut x109: u64 = 0; + let mut x110: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x109, &mut x110, x108, x85, x100); + let mut x111: u64 = 0; + let mut x112: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x111, &mut x112, x110, x87, x102); + let mut x113: u64 = 0; + let mut x114: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x113, &mut x114, x103, 0xd2b51da312547e1b); + let mut x115: u64 = 0; + let mut x116: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x115, &mut x116, x113, 0x1000000000000000); + let mut x117: u64 = 0; + let mut x118: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x117, &mut x118, x113, 0x14def9dea2f79cd6); + let mut x119: u64 = 0; + let mut x120: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x119, &mut x120, x113, 0x5812631a5cf5d3ed); + let mut x121: u64 = 0; + let mut x122: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x121, &mut x122, 0x0, x120, x117); + let x123: u64 = ((x122 as u64) + x118); + let mut x124: u64 = 0; + let mut x125: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x124, &mut x125, 0x0, x103, x119); + let mut x126: u64 = 0; + let mut x127: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x126, &mut x127, x125, x105, x121); + let mut x128: u64 = 0; + let mut x129: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x128, &mut x129, x127, x107, x123); + let mut x130: u64 = 0; + let mut x131: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x130, &mut x131, x129, x109, x115); + let mut x132: u64 = 0; + let mut x133: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x132, &mut x133, x131, x111, x116); + let x134: u64 = ((x133 as u64) + (x112 as u64)); + let mut x135: u64 = 0; + let mut x136: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x135, &mut x136, x3, (arg1[3])); + let mut x137: u64 = 0; + let mut x138: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x137, &mut x138, x3, (arg1[2])); + let mut x139: u64 = 0; + let mut x140: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x139, &mut x140, x3, (arg1[1])); + let mut x141: u64 = 0; + let mut x142: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x141, &mut x142, x3, (arg1[0])); + let mut x143: u64 = 0; + let mut x144: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x143, &mut x144, 0x0, x142, x139); + let mut x145: u64 = 0; + let mut x146: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x145, &mut x146, x144, x140, x137); + let mut x147: u64 = 0; + let mut x148: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x147, &mut x148, x146, x138, x135); + let x149: u64 = ((x148 as u64) + x136); + let mut x150: u64 = 0; + let mut x151: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x150, &mut x151, 0x0, x126, x141); + let mut x152: u64 = 0; + let mut x153: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x152, &mut x153, x151, x128, x143); + let mut x154: u64 = 0; + let mut x155: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x154, &mut x155, x153, x130, x145); + let mut x156: u64 = 0; + let mut x157: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x156, &mut x157, x155, x132, x147); + let mut x158: u64 = 0; + let mut x159: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x158, &mut x159, x157, x134, x149); + let mut x160: u64 = 0; + let mut x161: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x160, &mut x161, x150, 0xd2b51da312547e1b); + let mut x162: u64 = 0; + let mut x163: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x162, &mut x163, x160, 0x1000000000000000); + let mut x164: u64 = 0; + let mut x165: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x164, &mut x165, x160, 0x14def9dea2f79cd6); + let mut x166: u64 = 0; + let mut x167: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x166, &mut x167, x160, 0x5812631a5cf5d3ed); + let mut x168: u64 = 0; + let mut x169: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x168, &mut x169, 0x0, x167, x164); + let x170: u64 = ((x169 as u64) + x165); + let mut x171: u64 = 0; + let mut x172: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x171, &mut x172, 0x0, x150, x166); + let mut x173: u64 = 0; + let mut x174: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x173, &mut x174, x172, x152, x168); + let mut x175: u64 = 0; + let mut x176: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x175, &mut x176, x174, x154, x170); + let mut x177: u64 = 0; + let mut x178: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x177, &mut x178, x176, x156, x162); + let mut x179: u64 = 0; + let mut x180: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x179, &mut x180, x178, x158, x163); + let x181: u64 = ((x180 as u64) + (x159 as u64)); + let mut x182: u64 = 0; + let mut x183: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x182, &mut x183, 0x0, x173, 0x5812631a5cf5d3ed); + let mut x184: u64 = 0; + let mut x185: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x184, &mut x185, x183, x175, 0x14def9dea2f79cd6); + let mut x186: u64 = 0; + let mut x187: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x186, &mut x187, x185, x177, (0x0 as u64)); + let mut x188: u64 = 0; + let mut x189: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x188, &mut x189, x187, x179, 0x1000000000000000); + let mut x190: u64 = 0; + let mut x191: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x190, &mut x191, x189, x181, (0x0 as u64)); + let mut x192: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x192, x191, x182, x173); + let mut x193: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x193, x191, x184, x175); + let mut x194: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x194, x191, x186, x177); + let mut x195: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x195, x191, x188, x179); + out1[0] = x192; + out1[1] = x193; + out1[2] = x194; + out1[3] = x195; +} + +/// The function fiat_25519_scalar_add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_add(out1: &mut fiat_25519_scalar_montgomery_domain_field_element, arg1: &fiat_25519_scalar_montgomery_domain_field_element, arg2: &fiat_25519_scalar_montgomery_domain_field_element) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u64 = 0; + let mut x4: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u64 = 0; + let mut x6: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u64 = 0; + let mut x8: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u64 = 0; + let mut x10: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x9, &mut x10, 0x0, x1, 0x5812631a5cf5d3ed); + let mut x11: u64 = 0; + let mut x12: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x11, &mut x12, x10, x3, 0x14def9dea2f79cd6); + let mut x13: u64 = 0; + let mut x14: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x13, &mut x14, x12, x5, (0x0 as u64)); + let mut x15: u64 = 0; + let mut x16: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x15, &mut x16, x14, x7, 0x1000000000000000); + let mut x17: u64 = 0; + let mut x18: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x17, &mut x18, x16, (x8 as u64), (0x0 as u64)); + let mut x19: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x19, x18, x9, x1); + let mut x20: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x20, x18, x11, x3); + let mut x21: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x21, x18, x13, x5); + let mut x22: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/// The function fiat_25519_scalar_sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_sub(out1: &mut fiat_25519_scalar_montgomery_domain_field_element, arg1: &fiat_25519_scalar_montgomery_domain_field_element, arg2: &fiat_25519_scalar_montgomery_domain_field_element) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u64 = 0; + let mut x4: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u64 = 0; + let mut x6: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u64 = 0; + let mut x8: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x9, x8, (0x0 as u64), 0xffffffffffffffff); + let mut x10: u64 = 0; + let mut x11: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x10, &mut x11, 0x0, x1, (x9 & 0x5812631a5cf5d3ed)); + let mut x12: u64 = 0; + let mut x13: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x12, &mut x13, x11, x3, (x9 & 0x14def9dea2f79cd6)); + let mut x14: u64 = 0; + let mut x15: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x14, &mut x15, x13, x5, (0x0 as u64)); + let mut x16: u64 = 0; + let mut x17: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x7, (x9 & 0x1000000000000000)); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fiat_25519_scalar_opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_opp(out1: &mut fiat_25519_scalar_montgomery_domain_field_element, arg1: &fiat_25519_scalar_montgomery_domain_field_element) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x1, &mut x2, 0x0, (0x0 as u64), (arg1[0])); + let mut x3: u64 = 0; + let mut x4: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x3, &mut x4, x2, (0x0 as u64), (arg1[1])); + let mut x5: u64 = 0; + let mut x6: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x5, &mut x6, x4, (0x0 as u64), (arg1[2])); + let mut x7: u64 = 0; + let mut x8: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x7, &mut x8, x6, (0x0 as u64), (arg1[3])); + let mut x9: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x9, x8, (0x0 as u64), 0xffffffffffffffff); + let mut x10: u64 = 0; + let mut x11: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x10, &mut x11, 0x0, x1, (x9 & 0x5812631a5cf5d3ed)); + let mut x12: u64 = 0; + let mut x13: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x12, &mut x13, x11, x3, (x9 & 0x14def9dea2f79cd6)); + let mut x14: u64 = 0; + let mut x15: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x14, &mut x15, x13, x5, (0x0 as u64)); + let mut x16: u64 = 0; + let mut x17: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x7, (x9 & 0x1000000000000000)); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fiat_25519_scalar_from_montgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_from_montgomery(out1: &mut fiat_25519_scalar_non_montgomery_domain_field_element, arg1: &fiat_25519_scalar_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[0]); + let mut x2: u64 = 0; + let mut x3: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x2, &mut x3, x1, 0xd2b51da312547e1b); + let mut x4: u64 = 0; + let mut x5: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x4, &mut x5, x2, 0x1000000000000000); + let mut x6: u64 = 0; + let mut x7: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x6, &mut x7, x2, 0x14def9dea2f79cd6); + let mut x8: u64 = 0; + let mut x9: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x8, &mut x9, x2, 0x5812631a5cf5d3ed); + let mut x10: u64 = 0; + let mut x11: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x10, &mut x11, 0x0, x9, x6); + let mut x12: u64 = 0; + let mut x13: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x12, &mut x13, 0x0, x1, x8); + let mut x14: u64 = 0; + let mut x15: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x14, &mut x15, x13, (0x0 as u64), x10); + let mut x16: u64 = 0; + let mut x17: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x16, &mut x17, 0x0, x14, (arg1[1])); + let mut x18: u64 = 0; + let mut x19: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x18, &mut x19, x16, 0xd2b51da312547e1b); + let mut x20: u64 = 0; + let mut x21: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x20, &mut x21, x18, 0x1000000000000000); + let mut x22: u64 = 0; + let mut x23: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x22, &mut x23, x18, 0x14def9dea2f79cd6); + let mut x24: u64 = 0; + let mut x25: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x24, &mut x25, x18, 0x5812631a5cf5d3ed); + let mut x26: u64 = 0; + let mut x27: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x26, &mut x27, 0x0, x25, x22); + let mut x28: u64 = 0; + let mut x29: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x28, &mut x29, 0x0, x16, x24); + let mut x30: u64 = 0; + let mut x31: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x30, &mut x31, x29, ((x17 as u64) + ((x15 as u64) + ((x11 as u64) + x7))), x26); + let mut x32: u64 = 0; + let mut x33: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x32, &mut x33, x31, x4, ((x27 as u64) + x23)); + let mut x34: u64 = 0; + let mut x35: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x34, &mut x35, x33, x5, x20); + let mut x36: u64 = 0; + let mut x37: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x36, &mut x37, 0x0, x30, (arg1[2])); + let mut x38: u64 = 0; + let mut x39: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x38, &mut x39, x37, x32, (0x0 as u64)); + let mut x40: u64 = 0; + let mut x41: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x40, &mut x41, x39, x34, (0x0 as u64)); + let mut x42: u64 = 0; + let mut x43: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x42, &mut x43, x36, 0xd2b51da312547e1b); + let mut x44: u64 = 0; + let mut x45: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x44, &mut x45, x42, 0x1000000000000000); + let mut x46: u64 = 0; + let mut x47: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x46, &mut x47, x42, 0x14def9dea2f79cd6); + let mut x48: u64 = 0; + let mut x49: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x48, &mut x49, x42, 0x5812631a5cf5d3ed); + let mut x50: u64 = 0; + let mut x51: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x50, &mut x51, 0x0, x49, x46); + let mut x52: u64 = 0; + let mut x53: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x52, &mut x53, 0x0, x36, x48); + let mut x54: u64 = 0; + let mut x55: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x54, &mut x55, x53, x38, x50); + let mut x56: u64 = 0; + let mut x57: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x56, &mut x57, x55, x40, ((x51 as u64) + x47)); + let mut x58: u64 = 0; + let mut x59: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x58, &mut x59, x57, ((x41 as u64) + ((x35 as u64) + x21)), x44); + let mut x60: u64 = 0; + let mut x61: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x60, &mut x61, 0x0, x54, (arg1[3])); + let mut x62: u64 = 0; + let mut x63: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x62, &mut x63, x61, x56, (0x0 as u64)); + let mut x64: u64 = 0; + let mut x65: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x64, &mut x65, x63, x58, (0x0 as u64)); + let mut x66: u64 = 0; + let mut x67: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x66, &mut x67, x60, 0xd2b51da312547e1b); + let mut x68: u64 = 0; + let mut x69: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x68, &mut x69, x66, 0x1000000000000000); + let mut x70: u64 = 0; + let mut x71: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x70, &mut x71, x66, 0x14def9dea2f79cd6); + let mut x72: u64 = 0; + let mut x73: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x72, &mut x73, x66, 0x5812631a5cf5d3ed); + let mut x74: u64 = 0; + let mut x75: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x74, &mut x75, 0x0, x73, x70); + let mut x76: u64 = 0; + let mut x77: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x76, &mut x77, 0x0, x60, x72); + let mut x78: u64 = 0; + let mut x79: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x78, &mut x79, x77, x62, x74); + let mut x80: u64 = 0; + let mut x81: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x80, &mut x81, x79, x64, ((x75 as u64) + x71)); + let mut x82: u64 = 0; + let mut x83: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x82, &mut x83, x81, ((x65 as u64) + ((x59 as u64) + x45)), x68); + let x84: u64 = ((x83 as u64) + x69); + let mut x85: u64 = 0; + let mut x86: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x85, &mut x86, 0x0, x78, 0x5812631a5cf5d3ed); + let mut x87: u64 = 0; + let mut x88: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x87, &mut x88, x86, x80, 0x14def9dea2f79cd6); + let mut x89: u64 = 0; + let mut x90: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x89, &mut x90, x88, x82, (0x0 as u64)); + let mut x91: u64 = 0; + let mut x92: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x91, &mut x92, x90, x84, 0x1000000000000000); + let mut x93: u64 = 0; + let mut x94: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x93, &mut x94, x92, (0x0 as u64), (0x0 as u64)); + let mut x95: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x95, x94, x85, x78); + let mut x96: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x96, x94, x87, x80); + let mut x97: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x97, x94, x89, x82); + let mut x98: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x98, x94, x91, x84); + out1[0] = x95; + out1[1] = x96; + out1[2] = x97; + out1[3] = x98; +} + +/// The function fiat_25519_scalar_to_montgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_to_montgomery(out1: &mut fiat_25519_scalar_montgomery_domain_field_element, arg1: &fiat_25519_scalar_non_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[1]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[0]); + let mut x5: u64 = 0; + let mut x6: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x5, &mut x6, x4, 0x399411b7c309a3d); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x7, &mut x8, x4, 0xceec73d217f5be65); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x9, &mut x10, x4, 0xd00e1ba768859347); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x11, &mut x12, x4, 0xa40611e3449c0f01); + let mut x13: u64 = 0; + let mut x14: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x17, &mut x18, x16, x8, x5); + let mut x19: u64 = 0; + let mut x20: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x19, &mut x20, x11, 0xd2b51da312547e1b); + let mut x21: u64 = 0; + let mut x22: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x21, &mut x22, x19, 0x1000000000000000); + let mut x23: u64 = 0; + let mut x24: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x23, &mut x24, x19, 0x14def9dea2f79cd6); + let mut x25: u64 = 0; + let mut x26: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x25, &mut x26, x19, 0x5812631a5cf5d3ed); + let mut x27: u64 = 0; + let mut x28: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x27, &mut x28, 0x0, x26, x23); + let mut x29: u64 = 0; + let mut x30: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x29, &mut x30, 0x0, x11, x25); + let mut x31: u64 = 0; + let mut x32: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x31, &mut x32, x30, x13, x27); + let mut x33: u64 = 0; + let mut x34: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x33, &mut x34, x32, x15, ((x28 as u64) + x24)); + let mut x35: u64 = 0; + let mut x36: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x35, &mut x36, x34, x17, x21); + let mut x37: u64 = 0; + let mut x38: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x37, &mut x38, x1, 0x399411b7c309a3d); + let mut x39: u64 = 0; + let mut x40: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x39, &mut x40, x1, 0xceec73d217f5be65); + let mut x41: u64 = 0; + let mut x42: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x41, &mut x42, x1, 0xd00e1ba768859347); + let mut x43: u64 = 0; + let mut x44: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x43, &mut x44, x1, 0xa40611e3449c0f01); + let mut x45: u64 = 0; + let mut x46: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x45, &mut x46, 0x0, x44, x41); + let mut x47: u64 = 0; + let mut x48: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x47, &mut x48, x46, x42, x39); + let mut x49: u64 = 0; + let mut x50: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x49, &mut x50, x48, x40, x37); + let mut x51: u64 = 0; + let mut x52: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x51, &mut x52, 0x0, x31, x43); + let mut x53: u64 = 0; + let mut x54: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x53, &mut x54, x52, x33, x45); + let mut x55: u64 = 0; + let mut x56: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x55, &mut x56, x54, x35, x47); + let mut x57: u64 = 0; + let mut x58: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x57, &mut x58, x56, (((x36 as u64) + ((x18 as u64) + x6)) + x22), x49); + let mut x59: u64 = 0; + let mut x60: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x59, &mut x60, x51, 0xd2b51da312547e1b); + let mut x61: u64 = 0; + let mut x62: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x61, &mut x62, x59, 0x1000000000000000); + let mut x63: u64 = 0; + let mut x64: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x63, &mut x64, x59, 0x14def9dea2f79cd6); + let mut x65: u64 = 0; + let mut x66: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x65, &mut x66, x59, 0x5812631a5cf5d3ed); + let mut x67: u64 = 0; + let mut x68: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x67, &mut x68, 0x0, x66, x63); + let mut x69: u64 = 0; + let mut x70: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x69, &mut x70, 0x0, x51, x65); + let mut x71: u64 = 0; + let mut x72: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x71, &mut x72, x70, x53, x67); + let mut x73: u64 = 0; + let mut x74: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x73, &mut x74, x72, x55, ((x68 as u64) + x64)); + let mut x75: u64 = 0; + let mut x76: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x75, &mut x76, x74, x57, x61); + let mut x77: u64 = 0; + let mut x78: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x77, &mut x78, x2, 0x399411b7c309a3d); + let mut x79: u64 = 0; + let mut x80: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x79, &mut x80, x2, 0xceec73d217f5be65); + let mut x81: u64 = 0; + let mut x82: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x81, &mut x82, x2, 0xd00e1ba768859347); + let mut x83: u64 = 0; + let mut x84: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x83, &mut x84, x2, 0xa40611e3449c0f01); + let mut x85: u64 = 0; + let mut x86: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x85, &mut x86, 0x0, x84, x81); + let mut x87: u64 = 0; + let mut x88: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x87, &mut x88, x86, x82, x79); + let mut x89: u64 = 0; + let mut x90: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x89, &mut x90, x88, x80, x77); + let mut x91: u64 = 0; + let mut x92: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x91, &mut x92, 0x0, x71, x83); + let mut x93: u64 = 0; + let mut x94: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x93, &mut x94, x92, x73, x85); + let mut x95: u64 = 0; + let mut x96: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x95, &mut x96, x94, x75, x87); + let mut x97: u64 = 0; + let mut x98: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x97, &mut x98, x96, (((x76 as u64) + ((x58 as u64) + ((x50 as u64) + x38))) + x62), x89); + let mut x99: u64 = 0; + let mut x100: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x99, &mut x100, x91, 0xd2b51da312547e1b); + let mut x101: u64 = 0; + let mut x102: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x101, &mut x102, x99, 0x1000000000000000); + let mut x103: u64 = 0; + let mut x104: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x103, &mut x104, x99, 0x14def9dea2f79cd6); + let mut x105: u64 = 0; + let mut x106: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x105, &mut x106, x99, 0x5812631a5cf5d3ed); + let mut x107: u64 = 0; + let mut x108: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x107, &mut x108, 0x0, x106, x103); + let mut x109: u64 = 0; + let mut x110: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x109, &mut x110, 0x0, x91, x105); + let mut x111: u64 = 0; + let mut x112: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x111, &mut x112, x110, x93, x107); + let mut x113: u64 = 0; + let mut x114: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x113, &mut x114, x112, x95, ((x108 as u64) + x104)); + let mut x115: u64 = 0; + let mut x116: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x115, &mut x116, x114, x97, x101); + let mut x117: u64 = 0; + let mut x118: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x117, &mut x118, x3, 0x399411b7c309a3d); + let mut x119: u64 = 0; + let mut x120: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x119, &mut x120, x3, 0xceec73d217f5be65); + let mut x121: u64 = 0; + let mut x122: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x121, &mut x122, x3, 0xd00e1ba768859347); + let mut x123: u64 = 0; + let mut x124: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x123, &mut x124, x3, 0xa40611e3449c0f01); + let mut x125: u64 = 0; + let mut x126: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x125, &mut x126, 0x0, x124, x121); + let mut x127: u64 = 0; + let mut x128: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x127, &mut x128, x126, x122, x119); + let mut x129: u64 = 0; + let mut x130: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x129, &mut x130, x128, x120, x117); + let mut x131: u64 = 0; + let mut x132: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x131, &mut x132, 0x0, x111, x123); + let mut x133: u64 = 0; + let mut x134: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x133, &mut x134, x132, x113, x125); + let mut x135: u64 = 0; + let mut x136: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x135, &mut x136, x134, x115, x127); + let mut x137: u64 = 0; + let mut x138: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x137, &mut x138, x136, (((x116 as u64) + ((x98 as u64) + ((x90 as u64) + x78))) + x102), x129); + let mut x139: u64 = 0; + let mut x140: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x139, &mut x140, x131, 0xd2b51da312547e1b); + let mut x141: u64 = 0; + let mut x142: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x141, &mut x142, x139, 0x1000000000000000); + let mut x143: u64 = 0; + let mut x144: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x143, &mut x144, x139, 0x14def9dea2f79cd6); + let mut x145: u64 = 0; + let mut x146: u64 = 0; + fiat_25519_scalar_mulx_u64(&mut x145, &mut x146, x139, 0x5812631a5cf5d3ed); + let mut x147: u64 = 0; + let mut x148: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x147, &mut x148, 0x0, x146, x143); + let mut x149: u64 = 0; + let mut x150: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x149, &mut x150, 0x0, x131, x145); + let mut x151: u64 = 0; + let mut x152: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x151, &mut x152, x150, x133, x147); + let mut x153: u64 = 0; + let mut x154: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x153, &mut x154, x152, x135, ((x148 as u64) + x144)); + let mut x155: u64 = 0; + let mut x156: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x155, &mut x156, x154, x137, x141); + let x157: u64 = (((x156 as u64) + ((x138 as u64) + ((x130 as u64) + x118))) + x142); + let mut x158: u64 = 0; + let mut x159: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x158, &mut x159, 0x0, x151, 0x5812631a5cf5d3ed); + let mut x160: u64 = 0; + let mut x161: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x160, &mut x161, x159, x153, 0x14def9dea2f79cd6); + let mut x162: u64 = 0; + let mut x163: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x162, &mut x163, x161, x155, (0x0 as u64)); + let mut x164: u64 = 0; + let mut x165: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x164, &mut x165, x163, x157, 0x1000000000000000); + let mut x166: u64 = 0; + let mut x167: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x166, &mut x167, x165, (0x0 as u64), (0x0 as u64)); + let mut x168: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x168, x167, x158, x151); + let mut x169: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x169, x167, x160, x153); + let mut x170: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x170, x167, x162, x155); + let mut x171: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x171, x167, x164, x157); + out1[0] = x168; + out1[1] = x169; + out1[2] = x170; + out1[3] = x171; +} + +/// The function fiat_25519_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +#[inline] +pub fn fiat_25519_scalar_nonzero(out1: &mut u64, arg1: &[u64; 4]) -> () { + let x1: u64 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3])))); + *out1 = x1; +} + +/// The function fiat_25519_scalar_selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_25519_scalar_selectznz(out1: &mut [u64; 4], arg1: fiat_25519_scalar_u1, arg2: &[u64; 4], arg3: &[u64; 4]) -> () { + let mut x1: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x1, arg1, (arg2[0]), (arg3[0])); + let mut x2: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x2, arg1, (arg2[1]), (arg3[1])); + let mut x3: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x3, arg1, (arg2[2]), (arg3[2])); + let mut x4: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/// The function fiat_25519_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1fffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] +#[inline] +pub fn fiat_25519_scalar_to_bytes(out1: &mut [u8; 32], arg1: &[u64; 4]) -> () { + let x1: u64 = (arg1[3]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[1]); + let x4: u64 = (arg1[0]); + let x5: u8 = ((x4 & (0xff as u64)) as u8); + let x6: u64 = (x4 >> 8); + let x7: u8 = ((x6 & (0xff as u64)) as u8); + let x8: u64 = (x6 >> 8); + let x9: u8 = ((x8 & (0xff as u64)) as u8); + let x10: u64 = (x8 >> 8); + let x11: u8 = ((x10 & (0xff as u64)) as u8); + let x12: u64 = (x10 >> 8); + let x13: u8 = ((x12 & (0xff as u64)) as u8); + let x14: u64 = (x12 >> 8); + let x15: u8 = ((x14 & (0xff as u64)) as u8); + let x16: u64 = (x14 >> 8); + let x17: u8 = ((x16 & (0xff as u64)) as u8); + let x18: u8 = ((x16 >> 8) as u8); + let x19: u8 = ((x3 & (0xff as u64)) as u8); + let x20: u64 = (x3 >> 8); + let x21: u8 = ((x20 & (0xff as u64)) as u8); + let x22: u64 = (x20 >> 8); + let x23: u8 = ((x22 & (0xff as u64)) as u8); + let x24: u64 = (x22 >> 8); + let x25: u8 = ((x24 & (0xff as u64)) as u8); + let x26: u64 = (x24 >> 8); + let x27: u8 = ((x26 & (0xff as u64)) as u8); + let x28: u64 = (x26 >> 8); + let x29: u8 = ((x28 & (0xff as u64)) as u8); + let x30: u64 = (x28 >> 8); + let x31: u8 = ((x30 & (0xff as u64)) as u8); + let x32: u8 = ((x30 >> 8) as u8); + let x33: u8 = ((x2 & (0xff as u64)) as u8); + let x34: u64 = (x2 >> 8); + let x35: u8 = ((x34 & (0xff as u64)) as u8); + let x36: u64 = (x34 >> 8); + let x37: u8 = ((x36 & (0xff as u64)) as u8); + let x38: u64 = (x36 >> 8); + let x39: u8 = ((x38 & (0xff as u64)) as u8); + let x40: u64 = (x38 >> 8); + let x41: u8 = ((x40 & (0xff as u64)) as u8); + let x42: u64 = (x40 >> 8); + let x43: u8 = ((x42 & (0xff as u64)) as u8); + let x44: u64 = (x42 >> 8); + let x45: u8 = ((x44 & (0xff as u64)) as u8); + let x46: u8 = ((x44 >> 8) as u8); + let x47: u8 = ((x1 & (0xff as u64)) as u8); + let x48: u64 = (x1 >> 8); + let x49: u8 = ((x48 & (0xff as u64)) as u8); + let x50: u64 = (x48 >> 8); + let x51: u8 = ((x50 & (0xff as u64)) as u8); + let x52: u64 = (x50 >> 8); + let x53: u8 = ((x52 & (0xff as u64)) as u8); + let x54: u64 = (x52 >> 8); + let x55: u8 = ((x54 & (0xff as u64)) as u8); + let x56: u64 = (x54 >> 8); + let x57: u8 = ((x56 & (0xff as u64)) as u8); + let x58: u64 = (x56 >> 8); + let x59: u8 = ((x58 & (0xff as u64)) as u8); + let x60: u8 = ((x58 >> 8) as u8); + out1[0] = x5; + out1[1] = x7; + out1[2] = x9; + out1[3] = x11; + out1[4] = x13; + out1[5] = x15; + out1[6] = x17; + out1[7] = x18; + out1[8] = x19; + out1[9] = x21; + out1[10] = x23; + out1[11] = x25; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x39; + out1[20] = x41; + out1[21] = x43; + out1[22] = x45; + out1[23] = x46; + out1[24] = x47; + out1[25] = x49; + out1[26] = x51; + out1[27] = x53; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; +} + +/// The function fiat_25519_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1fffffffffffffff]] +#[inline] +pub fn fiat_25519_scalar_from_bytes(out1: &mut [u64; 4], arg1: &[u8; 32]) -> () { + let x1: u64 = (((arg1[31]) as u64) << 56); + let x2: u64 = (((arg1[30]) as u64) << 48); + let x3: u64 = (((arg1[29]) as u64) << 40); + let x4: u64 = (((arg1[28]) as u64) << 32); + let x5: u64 = (((arg1[27]) as u64) << 24); + let x6: u64 = (((arg1[26]) as u64) << 16); + let x7: u64 = (((arg1[25]) as u64) << 8); + let x8: u8 = (arg1[24]); + let x9: u64 = (((arg1[23]) as u64) << 56); + let x10: u64 = (((arg1[22]) as u64) << 48); + let x11: u64 = (((arg1[21]) as u64) << 40); + let x12: u64 = (((arg1[20]) as u64) << 32); + let x13: u64 = (((arg1[19]) as u64) << 24); + let x14: u64 = (((arg1[18]) as u64) << 16); + let x15: u64 = (((arg1[17]) as u64) << 8); + let x16: u8 = (arg1[16]); + let x17: u64 = (((arg1[15]) as u64) << 56); + let x18: u64 = (((arg1[14]) as u64) << 48); + let x19: u64 = (((arg1[13]) as u64) << 40); + let x20: u64 = (((arg1[12]) as u64) << 32); + let x21: u64 = (((arg1[11]) as u64) << 24); + let x22: u64 = (((arg1[10]) as u64) << 16); + let x23: u64 = (((arg1[9]) as u64) << 8); + let x24: u8 = (arg1[8]); + let x25: u64 = (((arg1[7]) as u64) << 56); + let x26: u64 = (((arg1[6]) as u64) << 48); + let x27: u64 = (((arg1[5]) as u64) << 40); + let x28: u64 = (((arg1[4]) as u64) << 32); + let x29: u64 = (((arg1[3]) as u64) << 24); + let x30: u64 = (((arg1[2]) as u64) << 16); + let x31: u64 = (((arg1[1]) as u64) << 8); + let x32: u8 = (arg1[0]); + let x33: u64 = (x31 + (x32 as u64)); + let x34: u64 = (x30 + x33); + let x35: u64 = (x29 + x34); + let x36: u64 = (x28 + x35); + let x37: u64 = (x27 + x36); + let x38: u64 = (x26 + x37); + let x39: u64 = (x25 + x38); + let x40: u64 = (x23 + (x24 as u64)); + let x41: u64 = (x22 + x40); + let x42: u64 = (x21 + x41); + let x43: u64 = (x20 + x42); + let x44: u64 = (x19 + x43); + let x45: u64 = (x18 + x44); + let x46: u64 = (x17 + x45); + let x47: u64 = (x15 + (x16 as u64)); + let x48: u64 = (x14 + x47); + let x49: u64 = (x13 + x48); + let x50: u64 = (x12 + x49); + let x51: u64 = (x11 + x50); + let x52: u64 = (x10 + x51); + let x53: u64 = (x9 + x52); + let x54: u64 = (x7 + (x8 as u64)); + let x55: u64 = (x6 + x54); + let x56: u64 = (x5 + x55); + let x57: u64 = (x4 + x56); + let x58: u64 = (x3 + x57); + let x59: u64 = (x2 + x58); + let x60: u64 = (x1 + x59); + out1[0] = x39; + out1[1] = x46; + out1[2] = x53; + out1[3] = x60; +} + +/// The function fiat_25519_scalar_set_one returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_25519_scalar_set_one(out1: &mut fiat_25519_scalar_montgomery_domain_field_element) -> () { + out1[0] = 0xd6ec31748d98951d; + out1[1] = 0xc6ef5bf4737dcf70; + out1[2] = 0xfffffffffffffffe; + out1[3] = 0xfffffffffffffff; +} + +/// The function fiat_25519_scalar_msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_25519_scalar_msat(out1: &mut [u64; 5]) -> () { + out1[0] = 0x5812631a5cf5d3ed; + out1[1] = 0x14def9dea2f79cd6; + out1[2] = (0x0 as u64); + out1[3] = 0x1000000000000000; + out1[4] = (0x0 as u64); +} + +/// The function fiat_25519_scalar_divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_25519_scalar_divstep(out1: &mut u64, out2: &mut [u64; 5], out3: &mut [u64; 5], out4: &mut [u64; 4], out5: &mut [u64; 4], arg1: u64, arg2: &[u64; 5], arg3: &[u64; 5], arg4: &[u64; 4], arg5: &[u64; 4]) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x1, &mut x2, 0x0, (!arg1), (0x1 as u64)); + let x3: fiat_25519_scalar_u1 = (((x1 >> 63) as fiat_25519_scalar_u1) & (((arg3[0]) & (0x1 as u64)) as fiat_25519_scalar_u1)); + let mut x4: u64 = 0; + let mut x5: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x4, &mut x5, 0x0, (!arg1), (0x1 as u64)); + let mut x6: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x6, x3, arg1, x4); + let mut x7: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x7, x3, (arg2[0]), (arg3[0])); + let mut x8: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x8, x3, (arg2[1]), (arg3[1])); + let mut x9: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x9, x3, (arg2[2]), (arg3[2])); + let mut x10: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x10, x3, (arg2[3]), (arg3[3])); + let mut x11: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x11, x3, (arg2[4]), (arg3[4])); + let mut x12: u64 = 0; + let mut x13: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x12, &mut x13, 0x0, (0x1 as u64), (!(arg2[0]))); + let mut x14: u64 = 0; + let mut x15: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x14, &mut x15, x13, (0x0 as u64), (!(arg2[1]))); + let mut x16: u64 = 0; + let mut x17: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x16, &mut x17, x15, (0x0 as u64), (!(arg2[2]))); + let mut x18: u64 = 0; + let mut x19: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x18, &mut x19, x17, (0x0 as u64), (!(arg2[3]))); + let mut x20: u64 = 0; + let mut x21: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x20, &mut x21, x19, (0x0 as u64), (!(arg2[4]))); + let mut x22: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x22, x3, (arg3[0]), x12); + let mut x23: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x23, x3, (arg3[1]), x14); + let mut x24: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x24, x3, (arg3[2]), x16); + let mut x25: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x25, x3, (arg3[3]), x18); + let mut x26: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x26, x3, (arg3[4]), x20); + let mut x27: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x27, x3, (arg4[0]), (arg5[0])); + let mut x28: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x28, x3, (arg4[1]), (arg5[1])); + let mut x29: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x29, x3, (arg4[2]), (arg5[2])); + let mut x30: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x30, x3, (arg4[3]), (arg5[3])); + let mut x31: u64 = 0; + let mut x32: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x31, &mut x32, 0x0, x27, x27); + let mut x33: u64 = 0; + let mut x34: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x33, &mut x34, x32, x28, x28); + let mut x35: u64 = 0; + let mut x36: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x35, &mut x36, x34, x29, x29); + let mut x37: u64 = 0; + let mut x38: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x37, &mut x38, x36, x30, x30); + let mut x39: u64 = 0; + let mut x40: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x39, &mut x40, 0x0, x31, 0x5812631a5cf5d3ed); + let mut x41: u64 = 0; + let mut x42: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x41, &mut x42, x40, x33, 0x14def9dea2f79cd6); + let mut x43: u64 = 0; + let mut x44: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x43, &mut x44, x42, x35, (0x0 as u64)); + let mut x45: u64 = 0; + let mut x46: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x45, &mut x46, x44, x37, 0x1000000000000000); + let mut x47: u64 = 0; + let mut x48: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x47, &mut x48, x46, (x38 as u64), (0x0 as u64)); + let x49: u64 = (arg4[3]); + let x50: u64 = (arg4[2]); + let x51: u64 = (arg4[1]); + let x52: u64 = (arg4[0]); + let mut x53: u64 = 0; + let mut x54: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x53, &mut x54, 0x0, (0x0 as u64), x52); + let mut x55: u64 = 0; + let mut x56: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x55, &mut x56, x54, (0x0 as u64), x51); + let mut x57: u64 = 0; + let mut x58: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x57, &mut x58, x56, (0x0 as u64), x50); + let mut x59: u64 = 0; + let mut x60: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x59, &mut x60, x58, (0x0 as u64), x49); + let mut x61: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x61, x60, (0x0 as u64), 0xffffffffffffffff); + let mut x62: u64 = 0; + let mut x63: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x62, &mut x63, 0x0, x53, (x61 & 0x5812631a5cf5d3ed)); + let mut x64: u64 = 0; + let mut x65: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x64, &mut x65, x63, x55, (x61 & 0x14def9dea2f79cd6)); + let mut x66: u64 = 0; + let mut x67: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x66, &mut x67, x65, x57, (0x0 as u64)); + let mut x68: u64 = 0; + let mut x69: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x68, &mut x69, x67, x59, (x61 & 0x1000000000000000)); + let mut x70: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x70, x3, (arg5[0]), x62); + let mut x71: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x71, x3, (arg5[1]), x64); + let mut x72: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x72, x3, (arg5[2]), x66); + let mut x73: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x73, x3, (arg5[3]), x68); + let x74: fiat_25519_scalar_u1 = ((x22 & (0x1 as u64)) as fiat_25519_scalar_u1); + let mut x75: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x75, x74, (0x0 as u64), x7); + let mut x76: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x76, x74, (0x0 as u64), x8); + let mut x77: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x77, x74, (0x0 as u64), x9); + let mut x78: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x78, x74, (0x0 as u64), x10); + let mut x79: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x79, x74, (0x0 as u64), x11); + let mut x80: u64 = 0; + let mut x81: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x80, &mut x81, 0x0, x22, x75); + let mut x82: u64 = 0; + let mut x83: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x82, &mut x83, x81, x23, x76); + let mut x84: u64 = 0; + let mut x85: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x84, &mut x85, x83, x24, x77); + let mut x86: u64 = 0; + let mut x87: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x86, &mut x87, x85, x25, x78); + let mut x88: u64 = 0; + let mut x89: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x88, &mut x89, x87, x26, x79); + let mut x90: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x90, x74, (0x0 as u64), x27); + let mut x91: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x91, x74, (0x0 as u64), x28); + let mut x92: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x92, x74, (0x0 as u64), x29); + let mut x93: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x93, x74, (0x0 as u64), x30); + let mut x94: u64 = 0; + let mut x95: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x94, &mut x95, 0x0, x70, x90); + let mut x96: u64 = 0; + let mut x97: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x96, &mut x97, x95, x71, x91); + let mut x98: u64 = 0; + let mut x99: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x98, &mut x99, x97, x72, x92); + let mut x100: u64 = 0; + let mut x101: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x100, &mut x101, x99, x73, x93); + let mut x102: u64 = 0; + let mut x103: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x102, &mut x103, 0x0, x94, 0x5812631a5cf5d3ed); + let mut x104: u64 = 0; + let mut x105: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x104, &mut x105, x103, x96, 0x14def9dea2f79cd6); + let mut x106: u64 = 0; + let mut x107: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x106, &mut x107, x105, x98, (0x0 as u64)); + let mut x108: u64 = 0; + let mut x109: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x108, &mut x109, x107, x100, 0x1000000000000000); + let mut x110: u64 = 0; + let mut x111: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_subborrowx_u64(&mut x110, &mut x111, x109, (x101 as u64), (0x0 as u64)); + let mut x112: u64 = 0; + let mut x113: fiat_25519_scalar_u1 = 0; + fiat_25519_scalar_addcarryx_u64(&mut x112, &mut x113, 0x0, x6, (0x1 as u64)); + let x114: u64 = ((x80 >> 1) | ((x82 << 63) & 0xffffffffffffffff)); + let x115: u64 = ((x82 >> 1) | ((x84 << 63) & 0xffffffffffffffff)); + let x116: u64 = ((x84 >> 1) | ((x86 << 63) & 0xffffffffffffffff)); + let x117: u64 = ((x86 >> 1) | ((x88 << 63) & 0xffffffffffffffff)); + let x118: u64 = ((x88 & 0x8000000000000000) | (x88 >> 1)); + let mut x119: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x119, x48, x39, x31); + let mut x120: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x120, x48, x41, x33); + let mut x121: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x121, x48, x43, x35); + let mut x122: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x122, x48, x45, x37); + let mut x123: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x123, x111, x102, x94); + let mut x124: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x124, x111, x104, x96); + let mut x125: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x125, x111, x106, x98); + let mut x126: u64 = 0; + fiat_25519_scalar_cmovznz_u64(&mut x126, x111, x108, x100); + *out1 = x112; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out3[0] = x114; + out3[1] = x115; + out3[2] = x116; + out3[3] = x117; + out3[4] = x118; + out4[0] = x119; + out4[1] = x120; + out4[2] = x121; + out4[3] = x122; + out5[0] = x123; + out5[1] = x124; + out5[2] = x125; + out5[3] = x126; +} + +/// The function fiat_25519_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_25519_scalar_divstep_precomp(out1: &mut [u64; 4]) -> () { + out1[0] = 0xd70af84436a7cb92; + out1[1] = 0x5f71c978b0b8b159; + out1[2] = 0xe76d816974947f1a; + out1[3] = 0x19a2d36f193e4ff; +} diff --git a/fiat-rust/src/lib.rs b/fiat-rust/src/lib.rs index 00cf28fca6..3a0d1ca25e 100644 --- a/fiat-rust/src/lib.rs +++ b/fiat-rust/src/lib.rs @@ -2,12 +2,18 @@ #![cfg_attr(not(feature = "std"), no_std)] pub mod curve25519_32; pub mod curve25519_64; +pub mod curve25519_scalar_32; +pub mod curve25519_scalar_64; pub mod p224_32; pub mod p224_64; pub mod p256_32; pub mod p256_64; +pub mod p256_scalar_32; +pub mod p256_scalar_64; pub mod p384_32; pub mod p384_64; +pub mod p384_scalar_32; +pub mod p384_scalar_64; pub mod p434_64; pub mod p448_solinas_32; pub mod p448_solinas_64; @@ -16,3 +22,5 @@ pub mod poly1305_32; pub mod poly1305_64; pub mod secp256k1_32; pub mod secp256k1_64; +pub mod secp256k1_scalar_32; +pub mod secp256k1_scalar_64; diff --git a/fiat-rust/src/p256_scalar_32.rs b/fiat-rust/src/p256_scalar_32.rs new file mode 100644 index 0000000000..4028e42edc --- /dev/null +++ b/fiat-rust/src/p256_scalar_32.rs @@ -0,0 +1,5310 @@ +//! Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline p256_scalar 32 '2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +//! curve description: p256_scalar +//! machine_wordsize = 32 (from "32") +//! requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +//! m = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 (from "2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247") +//! +//! NOTE: In addition to the bounds specified above each function, all +//! functions synthesized for this Montgomery arithmetic require the +//! input to be strictly less than the prime modulus (m), and also +//! require the input to be in the unique saturated representation. +//! All functions also ensure that these two properties are true of +//! return values. +//! +//! Computed values: +//! eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) +//! bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +//! twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in +//! if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 + +#![allow(unused_parens)] +#![allow(non_camel_case_types)] + +pub type fiat_p256_scalar_u1 = u8; +pub type fiat_p256_scalar_i1 = i8; +pub type fiat_p256_scalar_u2 = u8; +pub type fiat_p256_scalar_i2 = i8; + +/* The type fiat_p256_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +pub type fiat_p256_scalar_montgomery_domain_field_element = [u32; 8]; + +/* The type fiat_p256_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +pub type fiat_p256_scalar_non_montgomery_domain_field_element = [u32; 8]; + + +/// The function fiat_p256_scalar_addcarryx_u32 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^32 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_p256_scalar_addcarryx_u32(out1: &mut u32, out2: &mut fiat_p256_scalar_u1, arg1: fiat_p256_scalar_u1, arg2: u32, arg3: u32) -> () { + let x1: u64 = (((arg1 as u64) + (arg2 as u64)) + (arg3 as u64)); + let x2: u32 = ((x1 & (0xffffffff as u64)) as u32); + let x3: fiat_p256_scalar_u1 = ((x1 >> 32) as fiat_p256_scalar_u1); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_p256_scalar_subborrowx_u32 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^32 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_p256_scalar_subborrowx_u32(out1: &mut u32, out2: &mut fiat_p256_scalar_u1, arg1: fiat_p256_scalar_u1, arg2: u32, arg3: u32) -> () { + let x1: i64 = (((arg2 as i64) - (arg1 as i64)) - (arg3 as i64)); + let x2: fiat_p256_scalar_i1 = ((x1 >> 32) as fiat_p256_scalar_i1); + let x3: u32 = ((x1 & (0xffffffff as i64)) as u32); + *out1 = x3; + *out2 = (((0x0 as fiat_p256_scalar_i2) - (x2 as fiat_p256_scalar_i2)) as fiat_p256_scalar_u1); +} + +/// The function fiat_p256_scalar_mulx_u32 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^32 +/// out2 = ⌊arg1 * arg2 / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0xffffffff] +#[inline] +pub fn fiat_p256_scalar_mulx_u32(out1: &mut u32, out2: &mut u32, arg1: u32, arg2: u32) -> () { + let x1: u64 = ((arg1 as u64) * (arg2 as u64)); + let x2: u32 = ((x1 & (0xffffffff as u64)) as u32); + let x3: u32 = ((x1 >> 32) as u32); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_p256_scalar_cmovznz_u32 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +#[inline] +pub fn fiat_p256_scalar_cmovznz_u32(out1: &mut u32, arg1: fiat_p256_scalar_u1, arg2: u32, arg3: u32) -> () { + let x1: fiat_p256_scalar_u1 = (!(!arg1)); + let x2: u32 = ((((((0x0 as fiat_p256_scalar_i2) - (x1 as fiat_p256_scalar_i2)) as fiat_p256_scalar_i1) as i64) & (0xffffffff as i64)) as u32); + let x3: u32 = ((x2 & arg3) | ((!x2) & arg2)); + *out1 = x3; +} + +/// The function fiat_p256_scalar_mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_mul(out1: &mut fiat_p256_scalar_montgomery_domain_field_element, arg1: &fiat_p256_scalar_montgomery_domain_field_element, arg2: &fiat_p256_scalar_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[1]); + let x2: u32 = (arg1[2]); + let x3: u32 = (arg1[3]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[5]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[7]); + let x8: u32 = (arg1[0]); + let mut x9: u32 = 0; + let mut x10: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x9, &mut x10, x8, (arg2[7])); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x11, &mut x12, x8, (arg2[6])); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x13, &mut x14, x8, (arg2[5])); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x15, &mut x16, x8, (arg2[4])); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x17, &mut x18, x8, (arg2[3])); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x19, &mut x20, x8, (arg2[2])); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x21, &mut x22, x8, (arg2[1])); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x23, &mut x24, x8, (arg2[0])); + let mut x25: u32 = 0; + let mut x26: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x37, &mut x38, x36, x12, x9); + let x39: u32 = ((x38 as u32) + x10); + let mut x40: u32 = 0; + let mut x41: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x40, &mut x41, x23, 0xee00bc4f); + let mut x42: u32 = 0; + let mut x43: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x42, &mut x43, x40, 0xffffffff); + let mut x44: u32 = 0; + let mut x45: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x44, &mut x45, x40, 0xffffffff); + let mut x46: u32 = 0; + let mut x47: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x46, &mut x47, x40, 0xffffffff); + let mut x48: u32 = 0; + let mut x49: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x48, &mut x49, x40, 0xbce6faad); + let mut x50: u32 = 0; + let mut x51: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x50, &mut x51, x40, 0xa7179e84); + let mut x52: u32 = 0; + let mut x53: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x52, &mut x53, x40, 0xf3b9cac2); + let mut x54: u32 = 0; + let mut x55: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x54, &mut x55, x40, 0xfc632551); + let mut x56: u32 = 0; + let mut x57: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x56, &mut x57, 0x0, x55, x52); + let mut x58: u32 = 0; + let mut x59: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x58, &mut x59, x57, x53, x50); + let mut x60: u32 = 0; + let mut x61: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x60, &mut x61, x59, x51, x48); + let mut x62: u32 = 0; + let mut x63: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x62, &mut x63, x61, x49, x46); + let mut x64: u32 = 0; + let mut x65: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x64, &mut x65, x63, x47, x44); + let x66: u32 = ((x65 as u32) + x45); + let mut x67: u32 = 0; + let mut x68: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x67, &mut x68, 0x0, x23, x54); + let mut x69: u32 = 0; + let mut x70: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x69, &mut x70, x68, x25, x56); + let mut x71: u32 = 0; + let mut x72: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x71, &mut x72, x70, x27, x58); + let mut x73: u32 = 0; + let mut x74: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x73, &mut x74, x72, x29, x60); + let mut x75: u32 = 0; + let mut x76: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x75, &mut x76, x74, x31, x62); + let mut x77: u32 = 0; + let mut x78: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x77, &mut x78, x76, x33, x64); + let mut x79: u32 = 0; + let mut x80: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x79, &mut x80, x78, x35, x66); + let mut x81: u32 = 0; + let mut x82: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x81, &mut x82, x80, x37, x42); + let mut x83: u32 = 0; + let mut x84: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x83, &mut x84, x82, x39, x43); + let mut x85: u32 = 0; + let mut x86: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x85, &mut x86, x1, (arg2[7])); + let mut x87: u32 = 0; + let mut x88: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x87, &mut x88, x1, (arg2[6])); + let mut x89: u32 = 0; + let mut x90: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x89, &mut x90, x1, (arg2[5])); + let mut x91: u32 = 0; + let mut x92: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x91, &mut x92, x1, (arg2[4])); + let mut x93: u32 = 0; + let mut x94: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x93, &mut x94, x1, (arg2[3])); + let mut x95: u32 = 0; + let mut x96: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x95, &mut x96, x1, (arg2[2])); + let mut x97: u32 = 0; + let mut x98: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x97, &mut x98, x1, (arg2[1])); + let mut x99: u32 = 0; + let mut x100: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x99, &mut x100, x1, (arg2[0])); + let mut x101: u32 = 0; + let mut x102: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x101, &mut x102, 0x0, x100, x97); + let mut x103: u32 = 0; + let mut x104: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x103, &mut x104, x102, x98, x95); + let mut x105: u32 = 0; + let mut x106: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x105, &mut x106, x104, x96, x93); + let mut x107: u32 = 0; + let mut x108: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x107, &mut x108, x106, x94, x91); + let mut x109: u32 = 0; + let mut x110: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x109, &mut x110, x108, x92, x89); + let mut x111: u32 = 0; + let mut x112: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x90, x87); + let mut x113: u32 = 0; + let mut x114: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x113, &mut x114, x112, x88, x85); + let x115: u32 = ((x114 as u32) + x86); + let mut x116: u32 = 0; + let mut x117: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x116, &mut x117, 0x0, x69, x99); + let mut x118: u32 = 0; + let mut x119: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x118, &mut x119, x117, x71, x101); + let mut x120: u32 = 0; + let mut x121: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x120, &mut x121, x119, x73, x103); + let mut x122: u32 = 0; + let mut x123: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x122, &mut x123, x121, x75, x105); + let mut x124: u32 = 0; + let mut x125: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x77, x107); + let mut x126: u32 = 0; + let mut x127: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x126, &mut x127, x125, x79, x109); + let mut x128: u32 = 0; + let mut x129: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x128, &mut x129, x127, x81, x111); + let mut x130: u32 = 0; + let mut x131: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x130, &mut x131, x129, x83, x113); + let mut x132: u32 = 0; + let mut x133: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x132, &mut x133, x131, (x84 as u32), x115); + let mut x134: u32 = 0; + let mut x135: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x134, &mut x135, x116, 0xee00bc4f); + let mut x136: u32 = 0; + let mut x137: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x136, &mut x137, x134, 0xffffffff); + let mut x138: u32 = 0; + let mut x139: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x138, &mut x139, x134, 0xffffffff); + let mut x140: u32 = 0; + let mut x141: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x140, &mut x141, x134, 0xffffffff); + let mut x142: u32 = 0; + let mut x143: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x142, &mut x143, x134, 0xbce6faad); + let mut x144: u32 = 0; + let mut x145: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x144, &mut x145, x134, 0xa7179e84); + let mut x146: u32 = 0; + let mut x147: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x146, &mut x147, x134, 0xf3b9cac2); + let mut x148: u32 = 0; + let mut x149: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x148, &mut x149, x134, 0xfc632551); + let mut x150: u32 = 0; + let mut x151: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x150, &mut x151, 0x0, x149, x146); + let mut x152: u32 = 0; + let mut x153: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x152, &mut x153, x151, x147, x144); + let mut x154: u32 = 0; + let mut x155: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x154, &mut x155, x153, x145, x142); + let mut x156: u32 = 0; + let mut x157: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x156, &mut x157, x155, x143, x140); + let mut x158: u32 = 0; + let mut x159: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x158, &mut x159, x157, x141, x138); + let x160: u32 = ((x159 as u32) + x139); + let mut x161: u32 = 0; + let mut x162: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x161, &mut x162, 0x0, x116, x148); + let mut x163: u32 = 0; + let mut x164: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x163, &mut x164, x162, x118, x150); + let mut x165: u32 = 0; + let mut x166: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x165, &mut x166, x164, x120, x152); + let mut x167: u32 = 0; + let mut x168: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x167, &mut x168, x166, x122, x154); + let mut x169: u32 = 0; + let mut x170: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x169, &mut x170, x168, x124, x156); + let mut x171: u32 = 0; + let mut x172: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x171, &mut x172, x170, x126, x158); + let mut x173: u32 = 0; + let mut x174: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x173, &mut x174, x172, x128, x160); + let mut x175: u32 = 0; + let mut x176: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x175, &mut x176, x174, x130, x136); + let mut x177: u32 = 0; + let mut x178: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x177, &mut x178, x176, x132, x137); + let x179: u32 = ((x178 as u32) + (x133 as u32)); + let mut x180: u32 = 0; + let mut x181: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x180, &mut x181, x2, (arg2[7])); + let mut x182: u32 = 0; + let mut x183: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x182, &mut x183, x2, (arg2[6])); + let mut x184: u32 = 0; + let mut x185: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x184, &mut x185, x2, (arg2[5])); + let mut x186: u32 = 0; + let mut x187: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x186, &mut x187, x2, (arg2[4])); + let mut x188: u32 = 0; + let mut x189: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x188, &mut x189, x2, (arg2[3])); + let mut x190: u32 = 0; + let mut x191: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x190, &mut x191, x2, (arg2[2])); + let mut x192: u32 = 0; + let mut x193: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x192, &mut x193, x2, (arg2[1])); + let mut x194: u32 = 0; + let mut x195: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x194, &mut x195, x2, (arg2[0])); + let mut x196: u32 = 0; + let mut x197: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x196, &mut x197, 0x0, x195, x192); + let mut x198: u32 = 0; + let mut x199: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x198, &mut x199, x197, x193, x190); + let mut x200: u32 = 0; + let mut x201: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x200, &mut x201, x199, x191, x188); + let mut x202: u32 = 0; + let mut x203: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x202, &mut x203, x201, x189, x186); + let mut x204: u32 = 0; + let mut x205: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x204, &mut x205, x203, x187, x184); + let mut x206: u32 = 0; + let mut x207: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x206, &mut x207, x205, x185, x182); + let mut x208: u32 = 0; + let mut x209: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x208, &mut x209, x207, x183, x180); + let x210: u32 = ((x209 as u32) + x181); + let mut x211: u32 = 0; + let mut x212: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x211, &mut x212, 0x0, x163, x194); + let mut x213: u32 = 0; + let mut x214: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x213, &mut x214, x212, x165, x196); + let mut x215: u32 = 0; + let mut x216: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x215, &mut x216, x214, x167, x198); + let mut x217: u32 = 0; + let mut x218: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x217, &mut x218, x216, x169, x200); + let mut x219: u32 = 0; + let mut x220: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x219, &mut x220, x218, x171, x202); + let mut x221: u32 = 0; + let mut x222: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x221, &mut x222, x220, x173, x204); + let mut x223: u32 = 0; + let mut x224: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x223, &mut x224, x222, x175, x206); + let mut x225: u32 = 0; + let mut x226: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x225, &mut x226, x224, x177, x208); + let mut x227: u32 = 0; + let mut x228: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x227, &mut x228, x226, x179, x210); + let mut x229: u32 = 0; + let mut x230: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x229, &mut x230, x211, 0xee00bc4f); + let mut x231: u32 = 0; + let mut x232: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x231, &mut x232, x229, 0xffffffff); + let mut x233: u32 = 0; + let mut x234: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x233, &mut x234, x229, 0xffffffff); + let mut x235: u32 = 0; + let mut x236: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x235, &mut x236, x229, 0xffffffff); + let mut x237: u32 = 0; + let mut x238: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x237, &mut x238, x229, 0xbce6faad); + let mut x239: u32 = 0; + let mut x240: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x239, &mut x240, x229, 0xa7179e84); + let mut x241: u32 = 0; + let mut x242: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x241, &mut x242, x229, 0xf3b9cac2); + let mut x243: u32 = 0; + let mut x244: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x243, &mut x244, x229, 0xfc632551); + let mut x245: u32 = 0; + let mut x246: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x245, &mut x246, 0x0, x244, x241); + let mut x247: u32 = 0; + let mut x248: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x247, &mut x248, x246, x242, x239); + let mut x249: u32 = 0; + let mut x250: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x249, &mut x250, x248, x240, x237); + let mut x251: u32 = 0; + let mut x252: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x251, &mut x252, x250, x238, x235); + let mut x253: u32 = 0; + let mut x254: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x253, &mut x254, x252, x236, x233); + let x255: u32 = ((x254 as u32) + x234); + let mut x256: u32 = 0; + let mut x257: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x256, &mut x257, 0x0, x211, x243); + let mut x258: u32 = 0; + let mut x259: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x258, &mut x259, x257, x213, x245); + let mut x260: u32 = 0; + let mut x261: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x260, &mut x261, x259, x215, x247); + let mut x262: u32 = 0; + let mut x263: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x262, &mut x263, x261, x217, x249); + let mut x264: u32 = 0; + let mut x265: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x264, &mut x265, x263, x219, x251); + let mut x266: u32 = 0; + let mut x267: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x266, &mut x267, x265, x221, x253); + let mut x268: u32 = 0; + let mut x269: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x268, &mut x269, x267, x223, x255); + let mut x270: u32 = 0; + let mut x271: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x270, &mut x271, x269, x225, x231); + let mut x272: u32 = 0; + let mut x273: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x272, &mut x273, x271, x227, x232); + let x274: u32 = ((x273 as u32) + (x228 as u32)); + let mut x275: u32 = 0; + let mut x276: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x275, &mut x276, x3, (arg2[7])); + let mut x277: u32 = 0; + let mut x278: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x277, &mut x278, x3, (arg2[6])); + let mut x279: u32 = 0; + let mut x280: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x279, &mut x280, x3, (arg2[5])); + let mut x281: u32 = 0; + let mut x282: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x281, &mut x282, x3, (arg2[4])); + let mut x283: u32 = 0; + let mut x284: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x283, &mut x284, x3, (arg2[3])); + let mut x285: u32 = 0; + let mut x286: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x285, &mut x286, x3, (arg2[2])); + let mut x287: u32 = 0; + let mut x288: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x287, &mut x288, x3, (arg2[1])); + let mut x289: u32 = 0; + let mut x290: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x289, &mut x290, x3, (arg2[0])); + let mut x291: u32 = 0; + let mut x292: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x291, &mut x292, 0x0, x290, x287); + let mut x293: u32 = 0; + let mut x294: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x293, &mut x294, x292, x288, x285); + let mut x295: u32 = 0; + let mut x296: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x295, &mut x296, x294, x286, x283); + let mut x297: u32 = 0; + let mut x298: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x297, &mut x298, x296, x284, x281); + let mut x299: u32 = 0; + let mut x300: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x299, &mut x300, x298, x282, x279); + let mut x301: u32 = 0; + let mut x302: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x301, &mut x302, x300, x280, x277); + let mut x303: u32 = 0; + let mut x304: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x303, &mut x304, x302, x278, x275); + let x305: u32 = ((x304 as u32) + x276); + let mut x306: u32 = 0; + let mut x307: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x306, &mut x307, 0x0, x258, x289); + let mut x308: u32 = 0; + let mut x309: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x308, &mut x309, x307, x260, x291); + let mut x310: u32 = 0; + let mut x311: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x310, &mut x311, x309, x262, x293); + let mut x312: u32 = 0; + let mut x313: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x312, &mut x313, x311, x264, x295); + let mut x314: u32 = 0; + let mut x315: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x314, &mut x315, x313, x266, x297); + let mut x316: u32 = 0; + let mut x317: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x316, &mut x317, x315, x268, x299); + let mut x318: u32 = 0; + let mut x319: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x318, &mut x319, x317, x270, x301); + let mut x320: u32 = 0; + let mut x321: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x320, &mut x321, x319, x272, x303); + let mut x322: u32 = 0; + let mut x323: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x322, &mut x323, x321, x274, x305); + let mut x324: u32 = 0; + let mut x325: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x324, &mut x325, x306, 0xee00bc4f); + let mut x326: u32 = 0; + let mut x327: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x326, &mut x327, x324, 0xffffffff); + let mut x328: u32 = 0; + let mut x329: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x328, &mut x329, x324, 0xffffffff); + let mut x330: u32 = 0; + let mut x331: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x330, &mut x331, x324, 0xffffffff); + let mut x332: u32 = 0; + let mut x333: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x332, &mut x333, x324, 0xbce6faad); + let mut x334: u32 = 0; + let mut x335: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x334, &mut x335, x324, 0xa7179e84); + let mut x336: u32 = 0; + let mut x337: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x336, &mut x337, x324, 0xf3b9cac2); + let mut x338: u32 = 0; + let mut x339: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x338, &mut x339, x324, 0xfc632551); + let mut x340: u32 = 0; + let mut x341: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x340, &mut x341, 0x0, x339, x336); + let mut x342: u32 = 0; + let mut x343: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x342, &mut x343, x341, x337, x334); + let mut x344: u32 = 0; + let mut x345: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x344, &mut x345, x343, x335, x332); + let mut x346: u32 = 0; + let mut x347: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x346, &mut x347, x345, x333, x330); + let mut x348: u32 = 0; + let mut x349: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x348, &mut x349, x347, x331, x328); + let x350: u32 = ((x349 as u32) + x329); + let mut x351: u32 = 0; + let mut x352: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x351, &mut x352, 0x0, x306, x338); + let mut x353: u32 = 0; + let mut x354: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x353, &mut x354, x352, x308, x340); + let mut x355: u32 = 0; + let mut x356: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x355, &mut x356, x354, x310, x342); + let mut x357: u32 = 0; + let mut x358: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x357, &mut x358, x356, x312, x344); + let mut x359: u32 = 0; + let mut x360: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x359, &mut x360, x358, x314, x346); + let mut x361: u32 = 0; + let mut x362: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x361, &mut x362, x360, x316, x348); + let mut x363: u32 = 0; + let mut x364: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x363, &mut x364, x362, x318, x350); + let mut x365: u32 = 0; + let mut x366: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x365, &mut x366, x364, x320, x326); + let mut x367: u32 = 0; + let mut x368: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x367, &mut x368, x366, x322, x327); + let x369: u32 = ((x368 as u32) + (x323 as u32)); + let mut x370: u32 = 0; + let mut x371: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x370, &mut x371, x4, (arg2[7])); + let mut x372: u32 = 0; + let mut x373: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x372, &mut x373, x4, (arg2[6])); + let mut x374: u32 = 0; + let mut x375: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x374, &mut x375, x4, (arg2[5])); + let mut x376: u32 = 0; + let mut x377: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x376, &mut x377, x4, (arg2[4])); + let mut x378: u32 = 0; + let mut x379: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x378, &mut x379, x4, (arg2[3])); + let mut x380: u32 = 0; + let mut x381: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x380, &mut x381, x4, (arg2[2])); + let mut x382: u32 = 0; + let mut x383: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x382, &mut x383, x4, (arg2[1])); + let mut x384: u32 = 0; + let mut x385: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x384, &mut x385, x4, (arg2[0])); + let mut x386: u32 = 0; + let mut x387: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x386, &mut x387, 0x0, x385, x382); + let mut x388: u32 = 0; + let mut x389: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x388, &mut x389, x387, x383, x380); + let mut x390: u32 = 0; + let mut x391: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x390, &mut x391, x389, x381, x378); + let mut x392: u32 = 0; + let mut x393: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x392, &mut x393, x391, x379, x376); + let mut x394: u32 = 0; + let mut x395: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x394, &mut x395, x393, x377, x374); + let mut x396: u32 = 0; + let mut x397: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x396, &mut x397, x395, x375, x372); + let mut x398: u32 = 0; + let mut x399: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x398, &mut x399, x397, x373, x370); + let x400: u32 = ((x399 as u32) + x371); + let mut x401: u32 = 0; + let mut x402: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x401, &mut x402, 0x0, x353, x384); + let mut x403: u32 = 0; + let mut x404: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x403, &mut x404, x402, x355, x386); + let mut x405: u32 = 0; + let mut x406: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x405, &mut x406, x404, x357, x388); + let mut x407: u32 = 0; + let mut x408: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x407, &mut x408, x406, x359, x390); + let mut x409: u32 = 0; + let mut x410: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x409, &mut x410, x408, x361, x392); + let mut x411: u32 = 0; + let mut x412: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x411, &mut x412, x410, x363, x394); + let mut x413: u32 = 0; + let mut x414: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x413, &mut x414, x412, x365, x396); + let mut x415: u32 = 0; + let mut x416: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x415, &mut x416, x414, x367, x398); + let mut x417: u32 = 0; + let mut x418: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x417, &mut x418, x416, x369, x400); + let mut x419: u32 = 0; + let mut x420: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x419, &mut x420, x401, 0xee00bc4f); + let mut x421: u32 = 0; + let mut x422: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x421, &mut x422, x419, 0xffffffff); + let mut x423: u32 = 0; + let mut x424: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x423, &mut x424, x419, 0xffffffff); + let mut x425: u32 = 0; + let mut x426: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x425, &mut x426, x419, 0xffffffff); + let mut x427: u32 = 0; + let mut x428: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x427, &mut x428, x419, 0xbce6faad); + let mut x429: u32 = 0; + let mut x430: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x429, &mut x430, x419, 0xa7179e84); + let mut x431: u32 = 0; + let mut x432: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x431, &mut x432, x419, 0xf3b9cac2); + let mut x433: u32 = 0; + let mut x434: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x433, &mut x434, x419, 0xfc632551); + let mut x435: u32 = 0; + let mut x436: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x435, &mut x436, 0x0, x434, x431); + let mut x437: u32 = 0; + let mut x438: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x437, &mut x438, x436, x432, x429); + let mut x439: u32 = 0; + let mut x440: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x439, &mut x440, x438, x430, x427); + let mut x441: u32 = 0; + let mut x442: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x441, &mut x442, x440, x428, x425); + let mut x443: u32 = 0; + let mut x444: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x443, &mut x444, x442, x426, x423); + let x445: u32 = ((x444 as u32) + x424); + let mut x446: u32 = 0; + let mut x447: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x446, &mut x447, 0x0, x401, x433); + let mut x448: u32 = 0; + let mut x449: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x448, &mut x449, x447, x403, x435); + let mut x450: u32 = 0; + let mut x451: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x450, &mut x451, x449, x405, x437); + let mut x452: u32 = 0; + let mut x453: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x452, &mut x453, x451, x407, x439); + let mut x454: u32 = 0; + let mut x455: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x454, &mut x455, x453, x409, x441); + let mut x456: u32 = 0; + let mut x457: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x456, &mut x457, x455, x411, x443); + let mut x458: u32 = 0; + let mut x459: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x458, &mut x459, x457, x413, x445); + let mut x460: u32 = 0; + let mut x461: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x460, &mut x461, x459, x415, x421); + let mut x462: u32 = 0; + let mut x463: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x462, &mut x463, x461, x417, x422); + let x464: u32 = ((x463 as u32) + (x418 as u32)); + let mut x465: u32 = 0; + let mut x466: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x465, &mut x466, x5, (arg2[7])); + let mut x467: u32 = 0; + let mut x468: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x467, &mut x468, x5, (arg2[6])); + let mut x469: u32 = 0; + let mut x470: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x469, &mut x470, x5, (arg2[5])); + let mut x471: u32 = 0; + let mut x472: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x471, &mut x472, x5, (arg2[4])); + let mut x473: u32 = 0; + let mut x474: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x473, &mut x474, x5, (arg2[3])); + let mut x475: u32 = 0; + let mut x476: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x475, &mut x476, x5, (arg2[2])); + let mut x477: u32 = 0; + let mut x478: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x477, &mut x478, x5, (arg2[1])); + let mut x479: u32 = 0; + let mut x480: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x479, &mut x480, x5, (arg2[0])); + let mut x481: u32 = 0; + let mut x482: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x481, &mut x482, 0x0, x480, x477); + let mut x483: u32 = 0; + let mut x484: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x483, &mut x484, x482, x478, x475); + let mut x485: u32 = 0; + let mut x486: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x485, &mut x486, x484, x476, x473); + let mut x487: u32 = 0; + let mut x488: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x487, &mut x488, x486, x474, x471); + let mut x489: u32 = 0; + let mut x490: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x489, &mut x490, x488, x472, x469); + let mut x491: u32 = 0; + let mut x492: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x491, &mut x492, x490, x470, x467); + let mut x493: u32 = 0; + let mut x494: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x493, &mut x494, x492, x468, x465); + let x495: u32 = ((x494 as u32) + x466); + let mut x496: u32 = 0; + let mut x497: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x496, &mut x497, 0x0, x448, x479); + let mut x498: u32 = 0; + let mut x499: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x498, &mut x499, x497, x450, x481); + let mut x500: u32 = 0; + let mut x501: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x500, &mut x501, x499, x452, x483); + let mut x502: u32 = 0; + let mut x503: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x502, &mut x503, x501, x454, x485); + let mut x504: u32 = 0; + let mut x505: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x504, &mut x505, x503, x456, x487); + let mut x506: u32 = 0; + let mut x507: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x506, &mut x507, x505, x458, x489); + let mut x508: u32 = 0; + let mut x509: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x508, &mut x509, x507, x460, x491); + let mut x510: u32 = 0; + let mut x511: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x510, &mut x511, x509, x462, x493); + let mut x512: u32 = 0; + let mut x513: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x512, &mut x513, x511, x464, x495); + let mut x514: u32 = 0; + let mut x515: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x514, &mut x515, x496, 0xee00bc4f); + let mut x516: u32 = 0; + let mut x517: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x516, &mut x517, x514, 0xffffffff); + let mut x518: u32 = 0; + let mut x519: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x518, &mut x519, x514, 0xffffffff); + let mut x520: u32 = 0; + let mut x521: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x520, &mut x521, x514, 0xffffffff); + let mut x522: u32 = 0; + let mut x523: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x522, &mut x523, x514, 0xbce6faad); + let mut x524: u32 = 0; + let mut x525: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x524, &mut x525, x514, 0xa7179e84); + let mut x526: u32 = 0; + let mut x527: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x526, &mut x527, x514, 0xf3b9cac2); + let mut x528: u32 = 0; + let mut x529: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x528, &mut x529, x514, 0xfc632551); + let mut x530: u32 = 0; + let mut x531: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x530, &mut x531, 0x0, x529, x526); + let mut x532: u32 = 0; + let mut x533: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x532, &mut x533, x531, x527, x524); + let mut x534: u32 = 0; + let mut x535: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x534, &mut x535, x533, x525, x522); + let mut x536: u32 = 0; + let mut x537: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x536, &mut x537, x535, x523, x520); + let mut x538: u32 = 0; + let mut x539: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x538, &mut x539, x537, x521, x518); + let x540: u32 = ((x539 as u32) + x519); + let mut x541: u32 = 0; + let mut x542: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x541, &mut x542, 0x0, x496, x528); + let mut x543: u32 = 0; + let mut x544: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x543, &mut x544, x542, x498, x530); + let mut x545: u32 = 0; + let mut x546: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x545, &mut x546, x544, x500, x532); + let mut x547: u32 = 0; + let mut x548: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x547, &mut x548, x546, x502, x534); + let mut x549: u32 = 0; + let mut x550: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x549, &mut x550, x548, x504, x536); + let mut x551: u32 = 0; + let mut x552: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x551, &mut x552, x550, x506, x538); + let mut x553: u32 = 0; + let mut x554: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x553, &mut x554, x552, x508, x540); + let mut x555: u32 = 0; + let mut x556: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x555, &mut x556, x554, x510, x516); + let mut x557: u32 = 0; + let mut x558: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x557, &mut x558, x556, x512, x517); + let x559: u32 = ((x558 as u32) + (x513 as u32)); + let mut x560: u32 = 0; + let mut x561: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x560, &mut x561, x6, (arg2[7])); + let mut x562: u32 = 0; + let mut x563: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x562, &mut x563, x6, (arg2[6])); + let mut x564: u32 = 0; + let mut x565: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x564, &mut x565, x6, (arg2[5])); + let mut x566: u32 = 0; + let mut x567: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x566, &mut x567, x6, (arg2[4])); + let mut x568: u32 = 0; + let mut x569: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x568, &mut x569, x6, (arg2[3])); + let mut x570: u32 = 0; + let mut x571: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x570, &mut x571, x6, (arg2[2])); + let mut x572: u32 = 0; + let mut x573: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x572, &mut x573, x6, (arg2[1])); + let mut x574: u32 = 0; + let mut x575: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x574, &mut x575, x6, (arg2[0])); + let mut x576: u32 = 0; + let mut x577: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x576, &mut x577, 0x0, x575, x572); + let mut x578: u32 = 0; + let mut x579: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x578, &mut x579, x577, x573, x570); + let mut x580: u32 = 0; + let mut x581: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x580, &mut x581, x579, x571, x568); + let mut x582: u32 = 0; + let mut x583: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x582, &mut x583, x581, x569, x566); + let mut x584: u32 = 0; + let mut x585: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x584, &mut x585, x583, x567, x564); + let mut x586: u32 = 0; + let mut x587: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x586, &mut x587, x585, x565, x562); + let mut x588: u32 = 0; + let mut x589: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x588, &mut x589, x587, x563, x560); + let x590: u32 = ((x589 as u32) + x561); + let mut x591: u32 = 0; + let mut x592: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x591, &mut x592, 0x0, x543, x574); + let mut x593: u32 = 0; + let mut x594: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x593, &mut x594, x592, x545, x576); + let mut x595: u32 = 0; + let mut x596: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x595, &mut x596, x594, x547, x578); + let mut x597: u32 = 0; + let mut x598: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x597, &mut x598, x596, x549, x580); + let mut x599: u32 = 0; + let mut x600: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x599, &mut x600, x598, x551, x582); + let mut x601: u32 = 0; + let mut x602: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x601, &mut x602, x600, x553, x584); + let mut x603: u32 = 0; + let mut x604: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x603, &mut x604, x602, x555, x586); + let mut x605: u32 = 0; + let mut x606: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x605, &mut x606, x604, x557, x588); + let mut x607: u32 = 0; + let mut x608: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x607, &mut x608, x606, x559, x590); + let mut x609: u32 = 0; + let mut x610: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x609, &mut x610, x591, 0xee00bc4f); + let mut x611: u32 = 0; + let mut x612: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x611, &mut x612, x609, 0xffffffff); + let mut x613: u32 = 0; + let mut x614: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x613, &mut x614, x609, 0xffffffff); + let mut x615: u32 = 0; + let mut x616: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x615, &mut x616, x609, 0xffffffff); + let mut x617: u32 = 0; + let mut x618: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x617, &mut x618, x609, 0xbce6faad); + let mut x619: u32 = 0; + let mut x620: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x619, &mut x620, x609, 0xa7179e84); + let mut x621: u32 = 0; + let mut x622: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x621, &mut x622, x609, 0xf3b9cac2); + let mut x623: u32 = 0; + let mut x624: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x623, &mut x624, x609, 0xfc632551); + let mut x625: u32 = 0; + let mut x626: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x625, &mut x626, 0x0, x624, x621); + let mut x627: u32 = 0; + let mut x628: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x627, &mut x628, x626, x622, x619); + let mut x629: u32 = 0; + let mut x630: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x629, &mut x630, x628, x620, x617); + let mut x631: u32 = 0; + let mut x632: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x631, &mut x632, x630, x618, x615); + let mut x633: u32 = 0; + let mut x634: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x633, &mut x634, x632, x616, x613); + let x635: u32 = ((x634 as u32) + x614); + let mut x636: u32 = 0; + let mut x637: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x636, &mut x637, 0x0, x591, x623); + let mut x638: u32 = 0; + let mut x639: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x638, &mut x639, x637, x593, x625); + let mut x640: u32 = 0; + let mut x641: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x640, &mut x641, x639, x595, x627); + let mut x642: u32 = 0; + let mut x643: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x642, &mut x643, x641, x597, x629); + let mut x644: u32 = 0; + let mut x645: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x644, &mut x645, x643, x599, x631); + let mut x646: u32 = 0; + let mut x647: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x646, &mut x647, x645, x601, x633); + let mut x648: u32 = 0; + let mut x649: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x648, &mut x649, x647, x603, x635); + let mut x650: u32 = 0; + let mut x651: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x650, &mut x651, x649, x605, x611); + let mut x652: u32 = 0; + let mut x653: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x652, &mut x653, x651, x607, x612); + let x654: u32 = ((x653 as u32) + (x608 as u32)); + let mut x655: u32 = 0; + let mut x656: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x655, &mut x656, x7, (arg2[7])); + let mut x657: u32 = 0; + let mut x658: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x657, &mut x658, x7, (arg2[6])); + let mut x659: u32 = 0; + let mut x660: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x659, &mut x660, x7, (arg2[5])); + let mut x661: u32 = 0; + let mut x662: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x661, &mut x662, x7, (arg2[4])); + let mut x663: u32 = 0; + let mut x664: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x663, &mut x664, x7, (arg2[3])); + let mut x665: u32 = 0; + let mut x666: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x665, &mut x666, x7, (arg2[2])); + let mut x667: u32 = 0; + let mut x668: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x667, &mut x668, x7, (arg2[1])); + let mut x669: u32 = 0; + let mut x670: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x669, &mut x670, x7, (arg2[0])); + let mut x671: u32 = 0; + let mut x672: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x671, &mut x672, 0x0, x670, x667); + let mut x673: u32 = 0; + let mut x674: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x673, &mut x674, x672, x668, x665); + let mut x675: u32 = 0; + let mut x676: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x675, &mut x676, x674, x666, x663); + let mut x677: u32 = 0; + let mut x678: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x677, &mut x678, x676, x664, x661); + let mut x679: u32 = 0; + let mut x680: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x679, &mut x680, x678, x662, x659); + let mut x681: u32 = 0; + let mut x682: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x681, &mut x682, x680, x660, x657); + let mut x683: u32 = 0; + let mut x684: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x683, &mut x684, x682, x658, x655); + let x685: u32 = ((x684 as u32) + x656); + let mut x686: u32 = 0; + let mut x687: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x686, &mut x687, 0x0, x638, x669); + let mut x688: u32 = 0; + let mut x689: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x688, &mut x689, x687, x640, x671); + let mut x690: u32 = 0; + let mut x691: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x690, &mut x691, x689, x642, x673); + let mut x692: u32 = 0; + let mut x693: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x692, &mut x693, x691, x644, x675); + let mut x694: u32 = 0; + let mut x695: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x694, &mut x695, x693, x646, x677); + let mut x696: u32 = 0; + let mut x697: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x696, &mut x697, x695, x648, x679); + let mut x698: u32 = 0; + let mut x699: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x698, &mut x699, x697, x650, x681); + let mut x700: u32 = 0; + let mut x701: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x700, &mut x701, x699, x652, x683); + let mut x702: u32 = 0; + let mut x703: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x702, &mut x703, x701, x654, x685); + let mut x704: u32 = 0; + let mut x705: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x704, &mut x705, x686, 0xee00bc4f); + let mut x706: u32 = 0; + let mut x707: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x706, &mut x707, x704, 0xffffffff); + let mut x708: u32 = 0; + let mut x709: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x708, &mut x709, x704, 0xffffffff); + let mut x710: u32 = 0; + let mut x711: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x710, &mut x711, x704, 0xffffffff); + let mut x712: u32 = 0; + let mut x713: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x712, &mut x713, x704, 0xbce6faad); + let mut x714: u32 = 0; + let mut x715: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x714, &mut x715, x704, 0xa7179e84); + let mut x716: u32 = 0; + let mut x717: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x716, &mut x717, x704, 0xf3b9cac2); + let mut x718: u32 = 0; + let mut x719: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x718, &mut x719, x704, 0xfc632551); + let mut x720: u32 = 0; + let mut x721: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x720, &mut x721, 0x0, x719, x716); + let mut x722: u32 = 0; + let mut x723: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x722, &mut x723, x721, x717, x714); + let mut x724: u32 = 0; + let mut x725: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x724, &mut x725, x723, x715, x712); + let mut x726: u32 = 0; + let mut x727: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x726, &mut x727, x725, x713, x710); + let mut x728: u32 = 0; + let mut x729: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x728, &mut x729, x727, x711, x708); + let x730: u32 = ((x729 as u32) + x709); + let mut x731: u32 = 0; + let mut x732: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x731, &mut x732, 0x0, x686, x718); + let mut x733: u32 = 0; + let mut x734: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x733, &mut x734, x732, x688, x720); + let mut x735: u32 = 0; + let mut x736: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x735, &mut x736, x734, x690, x722); + let mut x737: u32 = 0; + let mut x738: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x737, &mut x738, x736, x692, x724); + let mut x739: u32 = 0; + let mut x740: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x739, &mut x740, x738, x694, x726); + let mut x741: u32 = 0; + let mut x742: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x741, &mut x742, x740, x696, x728); + let mut x743: u32 = 0; + let mut x744: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x743, &mut x744, x742, x698, x730); + let mut x745: u32 = 0; + let mut x746: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x745, &mut x746, x744, x700, x706); + let mut x747: u32 = 0; + let mut x748: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x747, &mut x748, x746, x702, x707); + let x749: u32 = ((x748 as u32) + (x703 as u32)); + let mut x750: u32 = 0; + let mut x751: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x750, &mut x751, 0x0, x733, 0xfc632551); + let mut x752: u32 = 0; + let mut x753: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x752, &mut x753, x751, x735, 0xf3b9cac2); + let mut x754: u32 = 0; + let mut x755: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x754, &mut x755, x753, x737, 0xa7179e84); + let mut x756: u32 = 0; + let mut x757: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x756, &mut x757, x755, x739, 0xbce6faad); + let mut x758: u32 = 0; + let mut x759: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x758, &mut x759, x757, x741, 0xffffffff); + let mut x760: u32 = 0; + let mut x761: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x760, &mut x761, x759, x743, 0xffffffff); + let mut x762: u32 = 0; + let mut x763: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x762, &mut x763, x761, x745, (0x0 as u32)); + let mut x764: u32 = 0; + let mut x765: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x764, &mut x765, x763, x747, 0xffffffff); + let mut x766: u32 = 0; + let mut x767: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x766, &mut x767, x765, x749, (0x0 as u32)); + let mut x768: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x768, x767, x750, x733); + let mut x769: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x769, x767, x752, x735); + let mut x770: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x770, x767, x754, x737); + let mut x771: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x771, x767, x756, x739); + let mut x772: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x772, x767, x758, x741); + let mut x773: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x773, x767, x760, x743); + let mut x774: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x774, x767, x762, x745); + let mut x775: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x775, x767, x764, x747); + out1[0] = x768; + out1[1] = x769; + out1[2] = x770; + out1[3] = x771; + out1[4] = x772; + out1[5] = x773; + out1[6] = x774; + out1[7] = x775; +} + +/// The function fiat_p256_scalar_square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_square(out1: &mut fiat_p256_scalar_montgomery_domain_field_element, arg1: &fiat_p256_scalar_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[1]); + let x2: u32 = (arg1[2]); + let x3: u32 = (arg1[3]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[5]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[7]); + let x8: u32 = (arg1[0]); + let mut x9: u32 = 0; + let mut x10: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x9, &mut x10, x8, (arg1[7])); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x11, &mut x12, x8, (arg1[6])); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x13, &mut x14, x8, (arg1[5])); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x15, &mut x16, x8, (arg1[4])); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x17, &mut x18, x8, (arg1[3])); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x19, &mut x20, x8, (arg1[2])); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x21, &mut x22, x8, (arg1[1])); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x23, &mut x24, x8, (arg1[0])); + let mut x25: u32 = 0; + let mut x26: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x37, &mut x38, x36, x12, x9); + let x39: u32 = ((x38 as u32) + x10); + let mut x40: u32 = 0; + let mut x41: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x40, &mut x41, x23, 0xee00bc4f); + let mut x42: u32 = 0; + let mut x43: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x42, &mut x43, x40, 0xffffffff); + let mut x44: u32 = 0; + let mut x45: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x44, &mut x45, x40, 0xffffffff); + let mut x46: u32 = 0; + let mut x47: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x46, &mut x47, x40, 0xffffffff); + let mut x48: u32 = 0; + let mut x49: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x48, &mut x49, x40, 0xbce6faad); + let mut x50: u32 = 0; + let mut x51: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x50, &mut x51, x40, 0xa7179e84); + let mut x52: u32 = 0; + let mut x53: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x52, &mut x53, x40, 0xf3b9cac2); + let mut x54: u32 = 0; + let mut x55: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x54, &mut x55, x40, 0xfc632551); + let mut x56: u32 = 0; + let mut x57: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x56, &mut x57, 0x0, x55, x52); + let mut x58: u32 = 0; + let mut x59: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x58, &mut x59, x57, x53, x50); + let mut x60: u32 = 0; + let mut x61: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x60, &mut x61, x59, x51, x48); + let mut x62: u32 = 0; + let mut x63: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x62, &mut x63, x61, x49, x46); + let mut x64: u32 = 0; + let mut x65: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x64, &mut x65, x63, x47, x44); + let x66: u32 = ((x65 as u32) + x45); + let mut x67: u32 = 0; + let mut x68: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x67, &mut x68, 0x0, x23, x54); + let mut x69: u32 = 0; + let mut x70: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x69, &mut x70, x68, x25, x56); + let mut x71: u32 = 0; + let mut x72: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x71, &mut x72, x70, x27, x58); + let mut x73: u32 = 0; + let mut x74: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x73, &mut x74, x72, x29, x60); + let mut x75: u32 = 0; + let mut x76: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x75, &mut x76, x74, x31, x62); + let mut x77: u32 = 0; + let mut x78: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x77, &mut x78, x76, x33, x64); + let mut x79: u32 = 0; + let mut x80: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x79, &mut x80, x78, x35, x66); + let mut x81: u32 = 0; + let mut x82: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x81, &mut x82, x80, x37, x42); + let mut x83: u32 = 0; + let mut x84: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x83, &mut x84, x82, x39, x43); + let mut x85: u32 = 0; + let mut x86: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x85, &mut x86, x1, (arg1[7])); + let mut x87: u32 = 0; + let mut x88: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x87, &mut x88, x1, (arg1[6])); + let mut x89: u32 = 0; + let mut x90: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x89, &mut x90, x1, (arg1[5])); + let mut x91: u32 = 0; + let mut x92: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x91, &mut x92, x1, (arg1[4])); + let mut x93: u32 = 0; + let mut x94: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x93, &mut x94, x1, (arg1[3])); + let mut x95: u32 = 0; + let mut x96: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x95, &mut x96, x1, (arg1[2])); + let mut x97: u32 = 0; + let mut x98: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x97, &mut x98, x1, (arg1[1])); + let mut x99: u32 = 0; + let mut x100: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x99, &mut x100, x1, (arg1[0])); + let mut x101: u32 = 0; + let mut x102: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x101, &mut x102, 0x0, x100, x97); + let mut x103: u32 = 0; + let mut x104: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x103, &mut x104, x102, x98, x95); + let mut x105: u32 = 0; + let mut x106: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x105, &mut x106, x104, x96, x93); + let mut x107: u32 = 0; + let mut x108: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x107, &mut x108, x106, x94, x91); + let mut x109: u32 = 0; + let mut x110: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x109, &mut x110, x108, x92, x89); + let mut x111: u32 = 0; + let mut x112: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x90, x87); + let mut x113: u32 = 0; + let mut x114: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x113, &mut x114, x112, x88, x85); + let x115: u32 = ((x114 as u32) + x86); + let mut x116: u32 = 0; + let mut x117: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x116, &mut x117, 0x0, x69, x99); + let mut x118: u32 = 0; + let mut x119: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x118, &mut x119, x117, x71, x101); + let mut x120: u32 = 0; + let mut x121: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x120, &mut x121, x119, x73, x103); + let mut x122: u32 = 0; + let mut x123: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x122, &mut x123, x121, x75, x105); + let mut x124: u32 = 0; + let mut x125: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x77, x107); + let mut x126: u32 = 0; + let mut x127: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x126, &mut x127, x125, x79, x109); + let mut x128: u32 = 0; + let mut x129: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x128, &mut x129, x127, x81, x111); + let mut x130: u32 = 0; + let mut x131: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x130, &mut x131, x129, x83, x113); + let mut x132: u32 = 0; + let mut x133: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x132, &mut x133, x131, (x84 as u32), x115); + let mut x134: u32 = 0; + let mut x135: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x134, &mut x135, x116, 0xee00bc4f); + let mut x136: u32 = 0; + let mut x137: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x136, &mut x137, x134, 0xffffffff); + let mut x138: u32 = 0; + let mut x139: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x138, &mut x139, x134, 0xffffffff); + let mut x140: u32 = 0; + let mut x141: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x140, &mut x141, x134, 0xffffffff); + let mut x142: u32 = 0; + let mut x143: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x142, &mut x143, x134, 0xbce6faad); + let mut x144: u32 = 0; + let mut x145: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x144, &mut x145, x134, 0xa7179e84); + let mut x146: u32 = 0; + let mut x147: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x146, &mut x147, x134, 0xf3b9cac2); + let mut x148: u32 = 0; + let mut x149: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x148, &mut x149, x134, 0xfc632551); + let mut x150: u32 = 0; + let mut x151: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x150, &mut x151, 0x0, x149, x146); + let mut x152: u32 = 0; + let mut x153: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x152, &mut x153, x151, x147, x144); + let mut x154: u32 = 0; + let mut x155: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x154, &mut x155, x153, x145, x142); + let mut x156: u32 = 0; + let mut x157: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x156, &mut x157, x155, x143, x140); + let mut x158: u32 = 0; + let mut x159: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x158, &mut x159, x157, x141, x138); + let x160: u32 = ((x159 as u32) + x139); + let mut x161: u32 = 0; + let mut x162: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x161, &mut x162, 0x0, x116, x148); + let mut x163: u32 = 0; + let mut x164: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x163, &mut x164, x162, x118, x150); + let mut x165: u32 = 0; + let mut x166: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x165, &mut x166, x164, x120, x152); + let mut x167: u32 = 0; + let mut x168: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x167, &mut x168, x166, x122, x154); + let mut x169: u32 = 0; + let mut x170: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x169, &mut x170, x168, x124, x156); + let mut x171: u32 = 0; + let mut x172: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x171, &mut x172, x170, x126, x158); + let mut x173: u32 = 0; + let mut x174: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x173, &mut x174, x172, x128, x160); + let mut x175: u32 = 0; + let mut x176: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x175, &mut x176, x174, x130, x136); + let mut x177: u32 = 0; + let mut x178: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x177, &mut x178, x176, x132, x137); + let x179: u32 = ((x178 as u32) + (x133 as u32)); + let mut x180: u32 = 0; + let mut x181: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x180, &mut x181, x2, (arg1[7])); + let mut x182: u32 = 0; + let mut x183: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x182, &mut x183, x2, (arg1[6])); + let mut x184: u32 = 0; + let mut x185: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x184, &mut x185, x2, (arg1[5])); + let mut x186: u32 = 0; + let mut x187: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x186, &mut x187, x2, (arg1[4])); + let mut x188: u32 = 0; + let mut x189: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x188, &mut x189, x2, (arg1[3])); + let mut x190: u32 = 0; + let mut x191: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x190, &mut x191, x2, (arg1[2])); + let mut x192: u32 = 0; + let mut x193: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x192, &mut x193, x2, (arg1[1])); + let mut x194: u32 = 0; + let mut x195: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x194, &mut x195, x2, (arg1[0])); + let mut x196: u32 = 0; + let mut x197: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x196, &mut x197, 0x0, x195, x192); + let mut x198: u32 = 0; + let mut x199: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x198, &mut x199, x197, x193, x190); + let mut x200: u32 = 0; + let mut x201: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x200, &mut x201, x199, x191, x188); + let mut x202: u32 = 0; + let mut x203: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x202, &mut x203, x201, x189, x186); + let mut x204: u32 = 0; + let mut x205: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x204, &mut x205, x203, x187, x184); + let mut x206: u32 = 0; + let mut x207: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x206, &mut x207, x205, x185, x182); + let mut x208: u32 = 0; + let mut x209: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x208, &mut x209, x207, x183, x180); + let x210: u32 = ((x209 as u32) + x181); + let mut x211: u32 = 0; + let mut x212: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x211, &mut x212, 0x0, x163, x194); + let mut x213: u32 = 0; + let mut x214: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x213, &mut x214, x212, x165, x196); + let mut x215: u32 = 0; + let mut x216: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x215, &mut x216, x214, x167, x198); + let mut x217: u32 = 0; + let mut x218: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x217, &mut x218, x216, x169, x200); + let mut x219: u32 = 0; + let mut x220: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x219, &mut x220, x218, x171, x202); + let mut x221: u32 = 0; + let mut x222: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x221, &mut x222, x220, x173, x204); + let mut x223: u32 = 0; + let mut x224: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x223, &mut x224, x222, x175, x206); + let mut x225: u32 = 0; + let mut x226: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x225, &mut x226, x224, x177, x208); + let mut x227: u32 = 0; + let mut x228: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x227, &mut x228, x226, x179, x210); + let mut x229: u32 = 0; + let mut x230: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x229, &mut x230, x211, 0xee00bc4f); + let mut x231: u32 = 0; + let mut x232: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x231, &mut x232, x229, 0xffffffff); + let mut x233: u32 = 0; + let mut x234: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x233, &mut x234, x229, 0xffffffff); + let mut x235: u32 = 0; + let mut x236: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x235, &mut x236, x229, 0xffffffff); + let mut x237: u32 = 0; + let mut x238: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x237, &mut x238, x229, 0xbce6faad); + let mut x239: u32 = 0; + let mut x240: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x239, &mut x240, x229, 0xa7179e84); + let mut x241: u32 = 0; + let mut x242: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x241, &mut x242, x229, 0xf3b9cac2); + let mut x243: u32 = 0; + let mut x244: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x243, &mut x244, x229, 0xfc632551); + let mut x245: u32 = 0; + let mut x246: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x245, &mut x246, 0x0, x244, x241); + let mut x247: u32 = 0; + let mut x248: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x247, &mut x248, x246, x242, x239); + let mut x249: u32 = 0; + let mut x250: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x249, &mut x250, x248, x240, x237); + let mut x251: u32 = 0; + let mut x252: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x251, &mut x252, x250, x238, x235); + let mut x253: u32 = 0; + let mut x254: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x253, &mut x254, x252, x236, x233); + let x255: u32 = ((x254 as u32) + x234); + let mut x256: u32 = 0; + let mut x257: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x256, &mut x257, 0x0, x211, x243); + let mut x258: u32 = 0; + let mut x259: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x258, &mut x259, x257, x213, x245); + let mut x260: u32 = 0; + let mut x261: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x260, &mut x261, x259, x215, x247); + let mut x262: u32 = 0; + let mut x263: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x262, &mut x263, x261, x217, x249); + let mut x264: u32 = 0; + let mut x265: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x264, &mut x265, x263, x219, x251); + let mut x266: u32 = 0; + let mut x267: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x266, &mut x267, x265, x221, x253); + let mut x268: u32 = 0; + let mut x269: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x268, &mut x269, x267, x223, x255); + let mut x270: u32 = 0; + let mut x271: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x270, &mut x271, x269, x225, x231); + let mut x272: u32 = 0; + let mut x273: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x272, &mut x273, x271, x227, x232); + let x274: u32 = ((x273 as u32) + (x228 as u32)); + let mut x275: u32 = 0; + let mut x276: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x275, &mut x276, x3, (arg1[7])); + let mut x277: u32 = 0; + let mut x278: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x277, &mut x278, x3, (arg1[6])); + let mut x279: u32 = 0; + let mut x280: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x279, &mut x280, x3, (arg1[5])); + let mut x281: u32 = 0; + let mut x282: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x281, &mut x282, x3, (arg1[4])); + let mut x283: u32 = 0; + let mut x284: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x283, &mut x284, x3, (arg1[3])); + let mut x285: u32 = 0; + let mut x286: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x285, &mut x286, x3, (arg1[2])); + let mut x287: u32 = 0; + let mut x288: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x287, &mut x288, x3, (arg1[1])); + let mut x289: u32 = 0; + let mut x290: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x289, &mut x290, x3, (arg1[0])); + let mut x291: u32 = 0; + let mut x292: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x291, &mut x292, 0x0, x290, x287); + let mut x293: u32 = 0; + let mut x294: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x293, &mut x294, x292, x288, x285); + let mut x295: u32 = 0; + let mut x296: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x295, &mut x296, x294, x286, x283); + let mut x297: u32 = 0; + let mut x298: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x297, &mut x298, x296, x284, x281); + let mut x299: u32 = 0; + let mut x300: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x299, &mut x300, x298, x282, x279); + let mut x301: u32 = 0; + let mut x302: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x301, &mut x302, x300, x280, x277); + let mut x303: u32 = 0; + let mut x304: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x303, &mut x304, x302, x278, x275); + let x305: u32 = ((x304 as u32) + x276); + let mut x306: u32 = 0; + let mut x307: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x306, &mut x307, 0x0, x258, x289); + let mut x308: u32 = 0; + let mut x309: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x308, &mut x309, x307, x260, x291); + let mut x310: u32 = 0; + let mut x311: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x310, &mut x311, x309, x262, x293); + let mut x312: u32 = 0; + let mut x313: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x312, &mut x313, x311, x264, x295); + let mut x314: u32 = 0; + let mut x315: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x314, &mut x315, x313, x266, x297); + let mut x316: u32 = 0; + let mut x317: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x316, &mut x317, x315, x268, x299); + let mut x318: u32 = 0; + let mut x319: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x318, &mut x319, x317, x270, x301); + let mut x320: u32 = 0; + let mut x321: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x320, &mut x321, x319, x272, x303); + let mut x322: u32 = 0; + let mut x323: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x322, &mut x323, x321, x274, x305); + let mut x324: u32 = 0; + let mut x325: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x324, &mut x325, x306, 0xee00bc4f); + let mut x326: u32 = 0; + let mut x327: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x326, &mut x327, x324, 0xffffffff); + let mut x328: u32 = 0; + let mut x329: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x328, &mut x329, x324, 0xffffffff); + let mut x330: u32 = 0; + let mut x331: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x330, &mut x331, x324, 0xffffffff); + let mut x332: u32 = 0; + let mut x333: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x332, &mut x333, x324, 0xbce6faad); + let mut x334: u32 = 0; + let mut x335: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x334, &mut x335, x324, 0xa7179e84); + let mut x336: u32 = 0; + let mut x337: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x336, &mut x337, x324, 0xf3b9cac2); + let mut x338: u32 = 0; + let mut x339: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x338, &mut x339, x324, 0xfc632551); + let mut x340: u32 = 0; + let mut x341: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x340, &mut x341, 0x0, x339, x336); + let mut x342: u32 = 0; + let mut x343: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x342, &mut x343, x341, x337, x334); + let mut x344: u32 = 0; + let mut x345: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x344, &mut x345, x343, x335, x332); + let mut x346: u32 = 0; + let mut x347: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x346, &mut x347, x345, x333, x330); + let mut x348: u32 = 0; + let mut x349: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x348, &mut x349, x347, x331, x328); + let x350: u32 = ((x349 as u32) + x329); + let mut x351: u32 = 0; + let mut x352: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x351, &mut x352, 0x0, x306, x338); + let mut x353: u32 = 0; + let mut x354: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x353, &mut x354, x352, x308, x340); + let mut x355: u32 = 0; + let mut x356: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x355, &mut x356, x354, x310, x342); + let mut x357: u32 = 0; + let mut x358: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x357, &mut x358, x356, x312, x344); + let mut x359: u32 = 0; + let mut x360: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x359, &mut x360, x358, x314, x346); + let mut x361: u32 = 0; + let mut x362: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x361, &mut x362, x360, x316, x348); + let mut x363: u32 = 0; + let mut x364: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x363, &mut x364, x362, x318, x350); + let mut x365: u32 = 0; + let mut x366: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x365, &mut x366, x364, x320, x326); + let mut x367: u32 = 0; + let mut x368: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x367, &mut x368, x366, x322, x327); + let x369: u32 = ((x368 as u32) + (x323 as u32)); + let mut x370: u32 = 0; + let mut x371: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x370, &mut x371, x4, (arg1[7])); + let mut x372: u32 = 0; + let mut x373: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x372, &mut x373, x4, (arg1[6])); + let mut x374: u32 = 0; + let mut x375: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x374, &mut x375, x4, (arg1[5])); + let mut x376: u32 = 0; + let mut x377: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x376, &mut x377, x4, (arg1[4])); + let mut x378: u32 = 0; + let mut x379: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x378, &mut x379, x4, (arg1[3])); + let mut x380: u32 = 0; + let mut x381: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x380, &mut x381, x4, (arg1[2])); + let mut x382: u32 = 0; + let mut x383: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x382, &mut x383, x4, (arg1[1])); + let mut x384: u32 = 0; + let mut x385: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x384, &mut x385, x4, (arg1[0])); + let mut x386: u32 = 0; + let mut x387: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x386, &mut x387, 0x0, x385, x382); + let mut x388: u32 = 0; + let mut x389: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x388, &mut x389, x387, x383, x380); + let mut x390: u32 = 0; + let mut x391: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x390, &mut x391, x389, x381, x378); + let mut x392: u32 = 0; + let mut x393: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x392, &mut x393, x391, x379, x376); + let mut x394: u32 = 0; + let mut x395: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x394, &mut x395, x393, x377, x374); + let mut x396: u32 = 0; + let mut x397: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x396, &mut x397, x395, x375, x372); + let mut x398: u32 = 0; + let mut x399: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x398, &mut x399, x397, x373, x370); + let x400: u32 = ((x399 as u32) + x371); + let mut x401: u32 = 0; + let mut x402: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x401, &mut x402, 0x0, x353, x384); + let mut x403: u32 = 0; + let mut x404: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x403, &mut x404, x402, x355, x386); + let mut x405: u32 = 0; + let mut x406: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x405, &mut x406, x404, x357, x388); + let mut x407: u32 = 0; + let mut x408: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x407, &mut x408, x406, x359, x390); + let mut x409: u32 = 0; + let mut x410: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x409, &mut x410, x408, x361, x392); + let mut x411: u32 = 0; + let mut x412: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x411, &mut x412, x410, x363, x394); + let mut x413: u32 = 0; + let mut x414: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x413, &mut x414, x412, x365, x396); + let mut x415: u32 = 0; + let mut x416: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x415, &mut x416, x414, x367, x398); + let mut x417: u32 = 0; + let mut x418: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x417, &mut x418, x416, x369, x400); + let mut x419: u32 = 0; + let mut x420: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x419, &mut x420, x401, 0xee00bc4f); + let mut x421: u32 = 0; + let mut x422: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x421, &mut x422, x419, 0xffffffff); + let mut x423: u32 = 0; + let mut x424: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x423, &mut x424, x419, 0xffffffff); + let mut x425: u32 = 0; + let mut x426: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x425, &mut x426, x419, 0xffffffff); + let mut x427: u32 = 0; + let mut x428: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x427, &mut x428, x419, 0xbce6faad); + let mut x429: u32 = 0; + let mut x430: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x429, &mut x430, x419, 0xa7179e84); + let mut x431: u32 = 0; + let mut x432: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x431, &mut x432, x419, 0xf3b9cac2); + let mut x433: u32 = 0; + let mut x434: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x433, &mut x434, x419, 0xfc632551); + let mut x435: u32 = 0; + let mut x436: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x435, &mut x436, 0x0, x434, x431); + let mut x437: u32 = 0; + let mut x438: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x437, &mut x438, x436, x432, x429); + let mut x439: u32 = 0; + let mut x440: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x439, &mut x440, x438, x430, x427); + let mut x441: u32 = 0; + let mut x442: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x441, &mut x442, x440, x428, x425); + let mut x443: u32 = 0; + let mut x444: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x443, &mut x444, x442, x426, x423); + let x445: u32 = ((x444 as u32) + x424); + let mut x446: u32 = 0; + let mut x447: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x446, &mut x447, 0x0, x401, x433); + let mut x448: u32 = 0; + let mut x449: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x448, &mut x449, x447, x403, x435); + let mut x450: u32 = 0; + let mut x451: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x450, &mut x451, x449, x405, x437); + let mut x452: u32 = 0; + let mut x453: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x452, &mut x453, x451, x407, x439); + let mut x454: u32 = 0; + let mut x455: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x454, &mut x455, x453, x409, x441); + let mut x456: u32 = 0; + let mut x457: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x456, &mut x457, x455, x411, x443); + let mut x458: u32 = 0; + let mut x459: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x458, &mut x459, x457, x413, x445); + let mut x460: u32 = 0; + let mut x461: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x460, &mut x461, x459, x415, x421); + let mut x462: u32 = 0; + let mut x463: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x462, &mut x463, x461, x417, x422); + let x464: u32 = ((x463 as u32) + (x418 as u32)); + let mut x465: u32 = 0; + let mut x466: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x465, &mut x466, x5, (arg1[7])); + let mut x467: u32 = 0; + let mut x468: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x467, &mut x468, x5, (arg1[6])); + let mut x469: u32 = 0; + let mut x470: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x469, &mut x470, x5, (arg1[5])); + let mut x471: u32 = 0; + let mut x472: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x471, &mut x472, x5, (arg1[4])); + let mut x473: u32 = 0; + let mut x474: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x473, &mut x474, x5, (arg1[3])); + let mut x475: u32 = 0; + let mut x476: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x475, &mut x476, x5, (arg1[2])); + let mut x477: u32 = 0; + let mut x478: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x477, &mut x478, x5, (arg1[1])); + let mut x479: u32 = 0; + let mut x480: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x479, &mut x480, x5, (arg1[0])); + let mut x481: u32 = 0; + let mut x482: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x481, &mut x482, 0x0, x480, x477); + let mut x483: u32 = 0; + let mut x484: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x483, &mut x484, x482, x478, x475); + let mut x485: u32 = 0; + let mut x486: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x485, &mut x486, x484, x476, x473); + let mut x487: u32 = 0; + let mut x488: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x487, &mut x488, x486, x474, x471); + let mut x489: u32 = 0; + let mut x490: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x489, &mut x490, x488, x472, x469); + let mut x491: u32 = 0; + let mut x492: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x491, &mut x492, x490, x470, x467); + let mut x493: u32 = 0; + let mut x494: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x493, &mut x494, x492, x468, x465); + let x495: u32 = ((x494 as u32) + x466); + let mut x496: u32 = 0; + let mut x497: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x496, &mut x497, 0x0, x448, x479); + let mut x498: u32 = 0; + let mut x499: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x498, &mut x499, x497, x450, x481); + let mut x500: u32 = 0; + let mut x501: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x500, &mut x501, x499, x452, x483); + let mut x502: u32 = 0; + let mut x503: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x502, &mut x503, x501, x454, x485); + let mut x504: u32 = 0; + let mut x505: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x504, &mut x505, x503, x456, x487); + let mut x506: u32 = 0; + let mut x507: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x506, &mut x507, x505, x458, x489); + let mut x508: u32 = 0; + let mut x509: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x508, &mut x509, x507, x460, x491); + let mut x510: u32 = 0; + let mut x511: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x510, &mut x511, x509, x462, x493); + let mut x512: u32 = 0; + let mut x513: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x512, &mut x513, x511, x464, x495); + let mut x514: u32 = 0; + let mut x515: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x514, &mut x515, x496, 0xee00bc4f); + let mut x516: u32 = 0; + let mut x517: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x516, &mut x517, x514, 0xffffffff); + let mut x518: u32 = 0; + let mut x519: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x518, &mut x519, x514, 0xffffffff); + let mut x520: u32 = 0; + let mut x521: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x520, &mut x521, x514, 0xffffffff); + let mut x522: u32 = 0; + let mut x523: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x522, &mut x523, x514, 0xbce6faad); + let mut x524: u32 = 0; + let mut x525: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x524, &mut x525, x514, 0xa7179e84); + let mut x526: u32 = 0; + let mut x527: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x526, &mut x527, x514, 0xf3b9cac2); + let mut x528: u32 = 0; + let mut x529: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x528, &mut x529, x514, 0xfc632551); + let mut x530: u32 = 0; + let mut x531: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x530, &mut x531, 0x0, x529, x526); + let mut x532: u32 = 0; + let mut x533: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x532, &mut x533, x531, x527, x524); + let mut x534: u32 = 0; + let mut x535: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x534, &mut x535, x533, x525, x522); + let mut x536: u32 = 0; + let mut x537: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x536, &mut x537, x535, x523, x520); + let mut x538: u32 = 0; + let mut x539: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x538, &mut x539, x537, x521, x518); + let x540: u32 = ((x539 as u32) + x519); + let mut x541: u32 = 0; + let mut x542: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x541, &mut x542, 0x0, x496, x528); + let mut x543: u32 = 0; + let mut x544: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x543, &mut x544, x542, x498, x530); + let mut x545: u32 = 0; + let mut x546: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x545, &mut x546, x544, x500, x532); + let mut x547: u32 = 0; + let mut x548: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x547, &mut x548, x546, x502, x534); + let mut x549: u32 = 0; + let mut x550: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x549, &mut x550, x548, x504, x536); + let mut x551: u32 = 0; + let mut x552: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x551, &mut x552, x550, x506, x538); + let mut x553: u32 = 0; + let mut x554: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x553, &mut x554, x552, x508, x540); + let mut x555: u32 = 0; + let mut x556: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x555, &mut x556, x554, x510, x516); + let mut x557: u32 = 0; + let mut x558: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x557, &mut x558, x556, x512, x517); + let x559: u32 = ((x558 as u32) + (x513 as u32)); + let mut x560: u32 = 0; + let mut x561: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x560, &mut x561, x6, (arg1[7])); + let mut x562: u32 = 0; + let mut x563: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x562, &mut x563, x6, (arg1[6])); + let mut x564: u32 = 0; + let mut x565: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x564, &mut x565, x6, (arg1[5])); + let mut x566: u32 = 0; + let mut x567: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x566, &mut x567, x6, (arg1[4])); + let mut x568: u32 = 0; + let mut x569: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x568, &mut x569, x6, (arg1[3])); + let mut x570: u32 = 0; + let mut x571: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x570, &mut x571, x6, (arg1[2])); + let mut x572: u32 = 0; + let mut x573: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x572, &mut x573, x6, (arg1[1])); + let mut x574: u32 = 0; + let mut x575: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x574, &mut x575, x6, (arg1[0])); + let mut x576: u32 = 0; + let mut x577: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x576, &mut x577, 0x0, x575, x572); + let mut x578: u32 = 0; + let mut x579: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x578, &mut x579, x577, x573, x570); + let mut x580: u32 = 0; + let mut x581: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x580, &mut x581, x579, x571, x568); + let mut x582: u32 = 0; + let mut x583: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x582, &mut x583, x581, x569, x566); + let mut x584: u32 = 0; + let mut x585: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x584, &mut x585, x583, x567, x564); + let mut x586: u32 = 0; + let mut x587: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x586, &mut x587, x585, x565, x562); + let mut x588: u32 = 0; + let mut x589: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x588, &mut x589, x587, x563, x560); + let x590: u32 = ((x589 as u32) + x561); + let mut x591: u32 = 0; + let mut x592: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x591, &mut x592, 0x0, x543, x574); + let mut x593: u32 = 0; + let mut x594: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x593, &mut x594, x592, x545, x576); + let mut x595: u32 = 0; + let mut x596: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x595, &mut x596, x594, x547, x578); + let mut x597: u32 = 0; + let mut x598: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x597, &mut x598, x596, x549, x580); + let mut x599: u32 = 0; + let mut x600: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x599, &mut x600, x598, x551, x582); + let mut x601: u32 = 0; + let mut x602: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x601, &mut x602, x600, x553, x584); + let mut x603: u32 = 0; + let mut x604: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x603, &mut x604, x602, x555, x586); + let mut x605: u32 = 0; + let mut x606: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x605, &mut x606, x604, x557, x588); + let mut x607: u32 = 0; + let mut x608: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x607, &mut x608, x606, x559, x590); + let mut x609: u32 = 0; + let mut x610: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x609, &mut x610, x591, 0xee00bc4f); + let mut x611: u32 = 0; + let mut x612: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x611, &mut x612, x609, 0xffffffff); + let mut x613: u32 = 0; + let mut x614: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x613, &mut x614, x609, 0xffffffff); + let mut x615: u32 = 0; + let mut x616: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x615, &mut x616, x609, 0xffffffff); + let mut x617: u32 = 0; + let mut x618: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x617, &mut x618, x609, 0xbce6faad); + let mut x619: u32 = 0; + let mut x620: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x619, &mut x620, x609, 0xa7179e84); + let mut x621: u32 = 0; + let mut x622: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x621, &mut x622, x609, 0xf3b9cac2); + let mut x623: u32 = 0; + let mut x624: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x623, &mut x624, x609, 0xfc632551); + let mut x625: u32 = 0; + let mut x626: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x625, &mut x626, 0x0, x624, x621); + let mut x627: u32 = 0; + let mut x628: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x627, &mut x628, x626, x622, x619); + let mut x629: u32 = 0; + let mut x630: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x629, &mut x630, x628, x620, x617); + let mut x631: u32 = 0; + let mut x632: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x631, &mut x632, x630, x618, x615); + let mut x633: u32 = 0; + let mut x634: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x633, &mut x634, x632, x616, x613); + let x635: u32 = ((x634 as u32) + x614); + let mut x636: u32 = 0; + let mut x637: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x636, &mut x637, 0x0, x591, x623); + let mut x638: u32 = 0; + let mut x639: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x638, &mut x639, x637, x593, x625); + let mut x640: u32 = 0; + let mut x641: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x640, &mut x641, x639, x595, x627); + let mut x642: u32 = 0; + let mut x643: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x642, &mut x643, x641, x597, x629); + let mut x644: u32 = 0; + let mut x645: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x644, &mut x645, x643, x599, x631); + let mut x646: u32 = 0; + let mut x647: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x646, &mut x647, x645, x601, x633); + let mut x648: u32 = 0; + let mut x649: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x648, &mut x649, x647, x603, x635); + let mut x650: u32 = 0; + let mut x651: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x650, &mut x651, x649, x605, x611); + let mut x652: u32 = 0; + let mut x653: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x652, &mut x653, x651, x607, x612); + let x654: u32 = ((x653 as u32) + (x608 as u32)); + let mut x655: u32 = 0; + let mut x656: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x655, &mut x656, x7, (arg1[7])); + let mut x657: u32 = 0; + let mut x658: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x657, &mut x658, x7, (arg1[6])); + let mut x659: u32 = 0; + let mut x660: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x659, &mut x660, x7, (arg1[5])); + let mut x661: u32 = 0; + let mut x662: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x661, &mut x662, x7, (arg1[4])); + let mut x663: u32 = 0; + let mut x664: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x663, &mut x664, x7, (arg1[3])); + let mut x665: u32 = 0; + let mut x666: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x665, &mut x666, x7, (arg1[2])); + let mut x667: u32 = 0; + let mut x668: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x667, &mut x668, x7, (arg1[1])); + let mut x669: u32 = 0; + let mut x670: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x669, &mut x670, x7, (arg1[0])); + let mut x671: u32 = 0; + let mut x672: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x671, &mut x672, 0x0, x670, x667); + let mut x673: u32 = 0; + let mut x674: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x673, &mut x674, x672, x668, x665); + let mut x675: u32 = 0; + let mut x676: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x675, &mut x676, x674, x666, x663); + let mut x677: u32 = 0; + let mut x678: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x677, &mut x678, x676, x664, x661); + let mut x679: u32 = 0; + let mut x680: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x679, &mut x680, x678, x662, x659); + let mut x681: u32 = 0; + let mut x682: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x681, &mut x682, x680, x660, x657); + let mut x683: u32 = 0; + let mut x684: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x683, &mut x684, x682, x658, x655); + let x685: u32 = ((x684 as u32) + x656); + let mut x686: u32 = 0; + let mut x687: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x686, &mut x687, 0x0, x638, x669); + let mut x688: u32 = 0; + let mut x689: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x688, &mut x689, x687, x640, x671); + let mut x690: u32 = 0; + let mut x691: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x690, &mut x691, x689, x642, x673); + let mut x692: u32 = 0; + let mut x693: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x692, &mut x693, x691, x644, x675); + let mut x694: u32 = 0; + let mut x695: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x694, &mut x695, x693, x646, x677); + let mut x696: u32 = 0; + let mut x697: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x696, &mut x697, x695, x648, x679); + let mut x698: u32 = 0; + let mut x699: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x698, &mut x699, x697, x650, x681); + let mut x700: u32 = 0; + let mut x701: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x700, &mut x701, x699, x652, x683); + let mut x702: u32 = 0; + let mut x703: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x702, &mut x703, x701, x654, x685); + let mut x704: u32 = 0; + let mut x705: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x704, &mut x705, x686, 0xee00bc4f); + let mut x706: u32 = 0; + let mut x707: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x706, &mut x707, x704, 0xffffffff); + let mut x708: u32 = 0; + let mut x709: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x708, &mut x709, x704, 0xffffffff); + let mut x710: u32 = 0; + let mut x711: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x710, &mut x711, x704, 0xffffffff); + let mut x712: u32 = 0; + let mut x713: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x712, &mut x713, x704, 0xbce6faad); + let mut x714: u32 = 0; + let mut x715: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x714, &mut x715, x704, 0xa7179e84); + let mut x716: u32 = 0; + let mut x717: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x716, &mut x717, x704, 0xf3b9cac2); + let mut x718: u32 = 0; + let mut x719: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x718, &mut x719, x704, 0xfc632551); + let mut x720: u32 = 0; + let mut x721: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x720, &mut x721, 0x0, x719, x716); + let mut x722: u32 = 0; + let mut x723: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x722, &mut x723, x721, x717, x714); + let mut x724: u32 = 0; + let mut x725: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x724, &mut x725, x723, x715, x712); + let mut x726: u32 = 0; + let mut x727: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x726, &mut x727, x725, x713, x710); + let mut x728: u32 = 0; + let mut x729: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x728, &mut x729, x727, x711, x708); + let x730: u32 = ((x729 as u32) + x709); + let mut x731: u32 = 0; + let mut x732: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x731, &mut x732, 0x0, x686, x718); + let mut x733: u32 = 0; + let mut x734: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x733, &mut x734, x732, x688, x720); + let mut x735: u32 = 0; + let mut x736: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x735, &mut x736, x734, x690, x722); + let mut x737: u32 = 0; + let mut x738: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x737, &mut x738, x736, x692, x724); + let mut x739: u32 = 0; + let mut x740: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x739, &mut x740, x738, x694, x726); + let mut x741: u32 = 0; + let mut x742: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x741, &mut x742, x740, x696, x728); + let mut x743: u32 = 0; + let mut x744: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x743, &mut x744, x742, x698, x730); + let mut x745: u32 = 0; + let mut x746: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x745, &mut x746, x744, x700, x706); + let mut x747: u32 = 0; + let mut x748: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x747, &mut x748, x746, x702, x707); + let x749: u32 = ((x748 as u32) + (x703 as u32)); + let mut x750: u32 = 0; + let mut x751: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x750, &mut x751, 0x0, x733, 0xfc632551); + let mut x752: u32 = 0; + let mut x753: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x752, &mut x753, x751, x735, 0xf3b9cac2); + let mut x754: u32 = 0; + let mut x755: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x754, &mut x755, x753, x737, 0xa7179e84); + let mut x756: u32 = 0; + let mut x757: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x756, &mut x757, x755, x739, 0xbce6faad); + let mut x758: u32 = 0; + let mut x759: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x758, &mut x759, x757, x741, 0xffffffff); + let mut x760: u32 = 0; + let mut x761: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x760, &mut x761, x759, x743, 0xffffffff); + let mut x762: u32 = 0; + let mut x763: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x762, &mut x763, x761, x745, (0x0 as u32)); + let mut x764: u32 = 0; + let mut x765: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x764, &mut x765, x763, x747, 0xffffffff); + let mut x766: u32 = 0; + let mut x767: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x766, &mut x767, x765, x749, (0x0 as u32)); + let mut x768: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x768, x767, x750, x733); + let mut x769: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x769, x767, x752, x735); + let mut x770: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x770, x767, x754, x737); + let mut x771: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x771, x767, x756, x739); + let mut x772: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x772, x767, x758, x741); + let mut x773: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x773, x767, x760, x743); + let mut x774: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x774, x767, x762, x745); + let mut x775: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x775, x767, x764, x747); + out1[0] = x768; + out1[1] = x769; + out1[2] = x770; + out1[3] = x771; + out1[4] = x772; + out1[5] = x773; + out1[6] = x774; + out1[7] = x775; +} + +/// The function fiat_p256_scalar_add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_add(out1: &mut fiat_p256_scalar_montgomery_domain_field_element, arg1: &fiat_p256_scalar_montgomery_domain_field_element, arg2: &fiat_p256_scalar_montgomery_domain_field_element) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u32 = 0; + let mut x4: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u32 = 0; + let mut x6: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u32 = 0; + let mut x8: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u32 = 0; + let mut x10: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u32 = 0; + let mut x12: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u32 = 0; + let mut x14: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x13, &mut x14, x12, (arg1[6]), (arg2[6])); + let mut x15: u32 = 0; + let mut x16: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x15, &mut x16, x14, (arg1[7]), (arg2[7])); + let mut x17: u32 = 0; + let mut x18: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x17, &mut x18, 0x0, x1, 0xfc632551); + let mut x19: u32 = 0; + let mut x20: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x19, &mut x20, x18, x3, 0xf3b9cac2); + let mut x21: u32 = 0; + let mut x22: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x21, &mut x22, x20, x5, 0xa7179e84); + let mut x23: u32 = 0; + let mut x24: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x23, &mut x24, x22, x7, 0xbce6faad); + let mut x25: u32 = 0; + let mut x26: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x25, &mut x26, x24, x9, 0xffffffff); + let mut x27: u32 = 0; + let mut x28: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x27, &mut x28, x26, x11, 0xffffffff); + let mut x29: u32 = 0; + let mut x30: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x29, &mut x30, x28, x13, (0x0 as u32)); + let mut x31: u32 = 0; + let mut x32: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x31, &mut x32, x30, x15, 0xffffffff); + let mut x33: u32 = 0; + let mut x34: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x33, &mut x34, x32, (x16 as u32), (0x0 as u32)); + let mut x35: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x35, x34, x17, x1); + let mut x36: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x36, x34, x19, x3); + let mut x37: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x37, x34, x21, x5); + let mut x38: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x38, x34, x23, x7); + let mut x39: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x39, x34, x25, x9); + let mut x40: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x40, x34, x27, x11); + let mut x41: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x41, x34, x29, x13); + let mut x42: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x42, x34, x31, x15); + out1[0] = x35; + out1[1] = x36; + out1[2] = x37; + out1[3] = x38; + out1[4] = x39; + out1[5] = x40; + out1[6] = x41; + out1[7] = x42; +} + +/// The function fiat_p256_scalar_sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_sub(out1: &mut fiat_p256_scalar_montgomery_domain_field_element, arg1: &fiat_p256_scalar_montgomery_domain_field_element, arg2: &fiat_p256_scalar_montgomery_domain_field_element) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u32 = 0; + let mut x4: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u32 = 0; + let mut x6: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u32 = 0; + let mut x8: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u32 = 0; + let mut x10: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u32 = 0; + let mut x12: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u32 = 0; + let mut x14: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x13, &mut x14, x12, (arg1[6]), (arg2[6])); + let mut x15: u32 = 0; + let mut x16: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x15, &mut x16, x14, (arg1[7]), (arg2[7])); + let mut x17: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x17, x16, (0x0 as u32), 0xffffffff); + let mut x18: u32 = 0; + let mut x19: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x18, &mut x19, 0x0, x1, (x17 & 0xfc632551)); + let mut x20: u32 = 0; + let mut x21: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x20, &mut x21, x19, x3, (x17 & 0xf3b9cac2)); + let mut x22: u32 = 0; + let mut x23: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x22, &mut x23, x21, x5, (x17 & 0xa7179e84)); + let mut x24: u32 = 0; + let mut x25: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x24, &mut x25, x23, x7, (x17 & 0xbce6faad)); + let mut x26: u32 = 0; + let mut x27: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x26, &mut x27, x25, x9, x17); + let mut x28: u32 = 0; + let mut x29: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x28, &mut x29, x27, x11, x17); + let mut x30: u32 = 0; + let mut x31: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x13, (0x0 as u32)); + let mut x32: u32 = 0; + let mut x33: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x15, x17); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/// The function fiat_p256_scalar_opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_opp(out1: &mut fiat_p256_scalar_montgomery_domain_field_element, arg1: &fiat_p256_scalar_montgomery_domain_field_element) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x1, &mut x2, 0x0, (0x0 as u32), (arg1[0])); + let mut x3: u32 = 0; + let mut x4: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x3, &mut x4, x2, (0x0 as u32), (arg1[1])); + let mut x5: u32 = 0; + let mut x6: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x5, &mut x6, x4, (0x0 as u32), (arg1[2])); + let mut x7: u32 = 0; + let mut x8: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x7, &mut x8, x6, (0x0 as u32), (arg1[3])); + let mut x9: u32 = 0; + let mut x10: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x9, &mut x10, x8, (0x0 as u32), (arg1[4])); + let mut x11: u32 = 0; + let mut x12: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x11, &mut x12, x10, (0x0 as u32), (arg1[5])); + let mut x13: u32 = 0; + let mut x14: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x13, &mut x14, x12, (0x0 as u32), (arg1[6])); + let mut x15: u32 = 0; + let mut x16: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x15, &mut x16, x14, (0x0 as u32), (arg1[7])); + let mut x17: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x17, x16, (0x0 as u32), 0xffffffff); + let mut x18: u32 = 0; + let mut x19: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x18, &mut x19, 0x0, x1, (x17 & 0xfc632551)); + let mut x20: u32 = 0; + let mut x21: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x20, &mut x21, x19, x3, (x17 & 0xf3b9cac2)); + let mut x22: u32 = 0; + let mut x23: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x22, &mut x23, x21, x5, (x17 & 0xa7179e84)); + let mut x24: u32 = 0; + let mut x25: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x24, &mut x25, x23, x7, (x17 & 0xbce6faad)); + let mut x26: u32 = 0; + let mut x27: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x26, &mut x27, x25, x9, x17); + let mut x28: u32 = 0; + let mut x29: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x28, &mut x29, x27, x11, x17); + let mut x30: u32 = 0; + let mut x31: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x13, (0x0 as u32)); + let mut x32: u32 = 0; + let mut x33: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x15, x17); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/// The function fiat_p256_scalar_from_montgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_from_montgomery(out1: &mut fiat_p256_scalar_non_montgomery_domain_field_element, arg1: &fiat_p256_scalar_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[0]); + let mut x2: u32 = 0; + let mut x3: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x2, &mut x3, x1, 0xee00bc4f); + let mut x4: u32 = 0; + let mut x5: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x4, &mut x5, x2, 0xffffffff); + let mut x6: u32 = 0; + let mut x7: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x6, &mut x7, x2, 0xffffffff); + let mut x8: u32 = 0; + let mut x9: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x8, &mut x9, x2, 0xffffffff); + let mut x10: u32 = 0; + let mut x11: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x10, &mut x11, x2, 0xbce6faad); + let mut x12: u32 = 0; + let mut x13: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x12, &mut x13, x2, 0xa7179e84); + let mut x14: u32 = 0; + let mut x15: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x14, &mut x15, x2, 0xf3b9cac2); + let mut x16: u32 = 0; + let mut x17: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x16, &mut x17, x2, 0xfc632551); + let mut x18: u32 = 0; + let mut x19: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x18, &mut x19, 0x0, x17, x14); + let mut x20: u32 = 0; + let mut x21: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x20, &mut x21, x19, x15, x12); + let mut x22: u32 = 0; + let mut x23: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x22, &mut x23, x21, x13, x10); + let mut x24: u32 = 0; + let mut x25: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x24, &mut x25, x23, x11, x8); + let mut x26: u32 = 0; + let mut x27: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x26, &mut x27, x25, x9, x6); + let mut x28: u32 = 0; + let mut x29: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x28, &mut x29, 0x0, x1, x16); + let mut x30: u32 = 0; + let mut x31: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x30, &mut x31, x29, (0x0 as u32), x18); + let mut x32: u32 = 0; + let mut x33: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x32, &mut x33, x31, (0x0 as u32), x20); + let mut x34: u32 = 0; + let mut x35: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x34, &mut x35, x33, (0x0 as u32), x22); + let mut x36: u32 = 0; + let mut x37: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x36, &mut x37, x35, (0x0 as u32), x24); + let mut x38: u32 = 0; + let mut x39: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x38, &mut x39, x37, (0x0 as u32), x26); + let mut x40: u32 = 0; + let mut x41: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x40, &mut x41, x39, (0x0 as u32), ((x27 as u32) + x7)); + let mut x42: u32 = 0; + let mut x43: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x42, &mut x43, x41, (0x0 as u32), x4); + let mut x44: u32 = 0; + let mut x45: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x44, &mut x45, 0x0, x30, (arg1[1])); + let mut x46: u32 = 0; + let mut x47: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x46, &mut x47, x45, x32, (0x0 as u32)); + let mut x48: u32 = 0; + let mut x49: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x48, &mut x49, x47, x34, (0x0 as u32)); + let mut x50: u32 = 0; + let mut x51: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x50, &mut x51, x49, x36, (0x0 as u32)); + let mut x52: u32 = 0; + let mut x53: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x52, &mut x53, x51, x38, (0x0 as u32)); + let mut x54: u32 = 0; + let mut x55: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x54, &mut x55, x53, x40, (0x0 as u32)); + let mut x56: u32 = 0; + let mut x57: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x56, &mut x57, x55, x42, (0x0 as u32)); + let mut x58: u32 = 0; + let mut x59: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x58, &mut x59, x57, ((x43 as u32) + x5), (0x0 as u32)); + let mut x60: u32 = 0; + let mut x61: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x60, &mut x61, x44, 0xee00bc4f); + let mut x62: u32 = 0; + let mut x63: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x62, &mut x63, x60, 0xffffffff); + let mut x64: u32 = 0; + let mut x65: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x64, &mut x65, x60, 0xffffffff); + let mut x66: u32 = 0; + let mut x67: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x66, &mut x67, x60, 0xffffffff); + let mut x68: u32 = 0; + let mut x69: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x68, &mut x69, x60, 0xbce6faad); + let mut x70: u32 = 0; + let mut x71: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x70, &mut x71, x60, 0xa7179e84); + let mut x72: u32 = 0; + let mut x73: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x72, &mut x73, x60, 0xf3b9cac2); + let mut x74: u32 = 0; + let mut x75: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x74, &mut x75, x60, 0xfc632551); + let mut x76: u32 = 0; + let mut x77: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x76, &mut x77, 0x0, x75, x72); + let mut x78: u32 = 0; + let mut x79: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x78, &mut x79, x77, x73, x70); + let mut x80: u32 = 0; + let mut x81: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x80, &mut x81, x79, x71, x68); + let mut x82: u32 = 0; + let mut x83: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x82, &mut x83, x81, x69, x66); + let mut x84: u32 = 0; + let mut x85: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x84, &mut x85, x83, x67, x64); + let mut x86: u32 = 0; + let mut x87: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x86, &mut x87, 0x0, x44, x74); + let mut x88: u32 = 0; + let mut x89: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x88, &mut x89, x87, x46, x76); + let mut x90: u32 = 0; + let mut x91: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x90, &mut x91, x89, x48, x78); + let mut x92: u32 = 0; + let mut x93: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x92, &mut x93, x91, x50, x80); + let mut x94: u32 = 0; + let mut x95: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x94, &mut x95, x93, x52, x82); + let mut x96: u32 = 0; + let mut x97: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x96, &mut x97, x95, x54, x84); + let mut x98: u32 = 0; + let mut x99: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x98, &mut x99, x97, x56, ((x85 as u32) + x65)); + let mut x100: u32 = 0; + let mut x101: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x100, &mut x101, x99, x58, x62); + let mut x102: u32 = 0; + let mut x103: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x102, &mut x103, x101, (x59 as u32), x63); + let mut x104: u32 = 0; + let mut x105: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x104, &mut x105, 0x0, x88, (arg1[2])); + let mut x106: u32 = 0; + let mut x107: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x106, &mut x107, x105, x90, (0x0 as u32)); + let mut x108: u32 = 0; + let mut x109: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x108, &mut x109, x107, x92, (0x0 as u32)); + let mut x110: u32 = 0; + let mut x111: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x110, &mut x111, x109, x94, (0x0 as u32)); + let mut x112: u32 = 0; + let mut x113: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x112, &mut x113, x111, x96, (0x0 as u32)); + let mut x114: u32 = 0; + let mut x115: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x114, &mut x115, x113, x98, (0x0 as u32)); + let mut x116: u32 = 0; + let mut x117: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x116, &mut x117, x115, x100, (0x0 as u32)); + let mut x118: u32 = 0; + let mut x119: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x118, &mut x119, x117, x102, (0x0 as u32)); + let mut x120: u32 = 0; + let mut x121: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x120, &mut x121, x104, 0xee00bc4f); + let mut x122: u32 = 0; + let mut x123: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x122, &mut x123, x120, 0xffffffff); + let mut x124: u32 = 0; + let mut x125: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x124, &mut x125, x120, 0xffffffff); + let mut x126: u32 = 0; + let mut x127: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x126, &mut x127, x120, 0xffffffff); + let mut x128: u32 = 0; + let mut x129: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x128, &mut x129, x120, 0xbce6faad); + let mut x130: u32 = 0; + let mut x131: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x130, &mut x131, x120, 0xa7179e84); + let mut x132: u32 = 0; + let mut x133: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x132, &mut x133, x120, 0xf3b9cac2); + let mut x134: u32 = 0; + let mut x135: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x134, &mut x135, x120, 0xfc632551); + let mut x136: u32 = 0; + let mut x137: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x136, &mut x137, 0x0, x135, x132); + let mut x138: u32 = 0; + let mut x139: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x138, &mut x139, x137, x133, x130); + let mut x140: u32 = 0; + let mut x141: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x140, &mut x141, x139, x131, x128); + let mut x142: u32 = 0; + let mut x143: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x142, &mut x143, x141, x129, x126); + let mut x144: u32 = 0; + let mut x145: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x144, &mut x145, x143, x127, x124); + let mut x146: u32 = 0; + let mut x147: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x146, &mut x147, 0x0, x104, x134); + let mut x148: u32 = 0; + let mut x149: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x148, &mut x149, x147, x106, x136); + let mut x150: u32 = 0; + let mut x151: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x150, &mut x151, x149, x108, x138); + let mut x152: u32 = 0; + let mut x153: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x152, &mut x153, x151, x110, x140); + let mut x154: u32 = 0; + let mut x155: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x154, &mut x155, x153, x112, x142); + let mut x156: u32 = 0; + let mut x157: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x156, &mut x157, x155, x114, x144); + let mut x158: u32 = 0; + let mut x159: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x158, &mut x159, x157, x116, ((x145 as u32) + x125)); + let mut x160: u32 = 0; + let mut x161: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x118, x122); + let mut x162: u32 = 0; + let mut x163: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x162, &mut x163, x161, ((x119 as u32) + (x103 as u32)), x123); + let mut x164: u32 = 0; + let mut x165: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x164, &mut x165, 0x0, x148, (arg1[3])); + let mut x166: u32 = 0; + let mut x167: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x166, &mut x167, x165, x150, (0x0 as u32)); + let mut x168: u32 = 0; + let mut x169: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x168, &mut x169, x167, x152, (0x0 as u32)); + let mut x170: u32 = 0; + let mut x171: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x170, &mut x171, x169, x154, (0x0 as u32)); + let mut x172: u32 = 0; + let mut x173: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x172, &mut x173, x171, x156, (0x0 as u32)); + let mut x174: u32 = 0; + let mut x175: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x174, &mut x175, x173, x158, (0x0 as u32)); + let mut x176: u32 = 0; + let mut x177: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x176, &mut x177, x175, x160, (0x0 as u32)); + let mut x178: u32 = 0; + let mut x179: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x178, &mut x179, x177, x162, (0x0 as u32)); + let mut x180: u32 = 0; + let mut x181: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x180, &mut x181, x164, 0xee00bc4f); + let mut x182: u32 = 0; + let mut x183: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x182, &mut x183, x180, 0xffffffff); + let mut x184: u32 = 0; + let mut x185: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x184, &mut x185, x180, 0xffffffff); + let mut x186: u32 = 0; + let mut x187: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x186, &mut x187, x180, 0xffffffff); + let mut x188: u32 = 0; + let mut x189: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x188, &mut x189, x180, 0xbce6faad); + let mut x190: u32 = 0; + let mut x191: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x190, &mut x191, x180, 0xa7179e84); + let mut x192: u32 = 0; + let mut x193: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x192, &mut x193, x180, 0xf3b9cac2); + let mut x194: u32 = 0; + let mut x195: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x194, &mut x195, x180, 0xfc632551); + let mut x196: u32 = 0; + let mut x197: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x196, &mut x197, 0x0, x195, x192); + let mut x198: u32 = 0; + let mut x199: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x198, &mut x199, x197, x193, x190); + let mut x200: u32 = 0; + let mut x201: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x200, &mut x201, x199, x191, x188); + let mut x202: u32 = 0; + let mut x203: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x202, &mut x203, x201, x189, x186); + let mut x204: u32 = 0; + let mut x205: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x204, &mut x205, x203, x187, x184); + let mut x206: u32 = 0; + let mut x207: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x206, &mut x207, 0x0, x164, x194); + let mut x208: u32 = 0; + let mut x209: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x208, &mut x209, x207, x166, x196); + let mut x210: u32 = 0; + let mut x211: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x210, &mut x211, x209, x168, x198); + let mut x212: u32 = 0; + let mut x213: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x212, &mut x213, x211, x170, x200); + let mut x214: u32 = 0; + let mut x215: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x214, &mut x215, x213, x172, x202); + let mut x216: u32 = 0; + let mut x217: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x216, &mut x217, x215, x174, x204); + let mut x218: u32 = 0; + let mut x219: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x218, &mut x219, x217, x176, ((x205 as u32) + x185)); + let mut x220: u32 = 0; + let mut x221: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x220, &mut x221, x219, x178, x182); + let mut x222: u32 = 0; + let mut x223: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x222, &mut x223, x221, ((x179 as u32) + (x163 as u32)), x183); + let mut x224: u32 = 0; + let mut x225: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x224, &mut x225, 0x0, x208, (arg1[4])); + let mut x226: u32 = 0; + let mut x227: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x226, &mut x227, x225, x210, (0x0 as u32)); + let mut x228: u32 = 0; + let mut x229: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x228, &mut x229, x227, x212, (0x0 as u32)); + let mut x230: u32 = 0; + let mut x231: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x230, &mut x231, x229, x214, (0x0 as u32)); + let mut x232: u32 = 0; + let mut x233: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x232, &mut x233, x231, x216, (0x0 as u32)); + let mut x234: u32 = 0; + let mut x235: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x234, &mut x235, x233, x218, (0x0 as u32)); + let mut x236: u32 = 0; + let mut x237: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x236, &mut x237, x235, x220, (0x0 as u32)); + let mut x238: u32 = 0; + let mut x239: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x238, &mut x239, x237, x222, (0x0 as u32)); + let mut x240: u32 = 0; + let mut x241: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x240, &mut x241, x224, 0xee00bc4f); + let mut x242: u32 = 0; + let mut x243: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x242, &mut x243, x240, 0xffffffff); + let mut x244: u32 = 0; + let mut x245: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x244, &mut x245, x240, 0xffffffff); + let mut x246: u32 = 0; + let mut x247: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x246, &mut x247, x240, 0xffffffff); + let mut x248: u32 = 0; + let mut x249: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x248, &mut x249, x240, 0xbce6faad); + let mut x250: u32 = 0; + let mut x251: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x250, &mut x251, x240, 0xa7179e84); + let mut x252: u32 = 0; + let mut x253: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x252, &mut x253, x240, 0xf3b9cac2); + let mut x254: u32 = 0; + let mut x255: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x254, &mut x255, x240, 0xfc632551); + let mut x256: u32 = 0; + let mut x257: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x256, &mut x257, 0x0, x255, x252); + let mut x258: u32 = 0; + let mut x259: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x258, &mut x259, x257, x253, x250); + let mut x260: u32 = 0; + let mut x261: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x260, &mut x261, x259, x251, x248); + let mut x262: u32 = 0; + let mut x263: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x262, &mut x263, x261, x249, x246); + let mut x264: u32 = 0; + let mut x265: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x264, &mut x265, x263, x247, x244); + let mut x266: u32 = 0; + let mut x267: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x266, &mut x267, 0x0, x224, x254); + let mut x268: u32 = 0; + let mut x269: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x268, &mut x269, x267, x226, x256); + let mut x270: u32 = 0; + let mut x271: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x270, &mut x271, x269, x228, x258); + let mut x272: u32 = 0; + let mut x273: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x272, &mut x273, x271, x230, x260); + let mut x274: u32 = 0; + let mut x275: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x274, &mut x275, x273, x232, x262); + let mut x276: u32 = 0; + let mut x277: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x276, &mut x277, x275, x234, x264); + let mut x278: u32 = 0; + let mut x279: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x278, &mut x279, x277, x236, ((x265 as u32) + x245)); + let mut x280: u32 = 0; + let mut x281: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x280, &mut x281, x279, x238, x242); + let mut x282: u32 = 0; + let mut x283: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x282, &mut x283, x281, ((x239 as u32) + (x223 as u32)), x243); + let mut x284: u32 = 0; + let mut x285: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x284, &mut x285, 0x0, x268, (arg1[5])); + let mut x286: u32 = 0; + let mut x287: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x286, &mut x287, x285, x270, (0x0 as u32)); + let mut x288: u32 = 0; + let mut x289: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x288, &mut x289, x287, x272, (0x0 as u32)); + let mut x290: u32 = 0; + let mut x291: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x290, &mut x291, x289, x274, (0x0 as u32)); + let mut x292: u32 = 0; + let mut x293: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x292, &mut x293, x291, x276, (0x0 as u32)); + let mut x294: u32 = 0; + let mut x295: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x294, &mut x295, x293, x278, (0x0 as u32)); + let mut x296: u32 = 0; + let mut x297: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x296, &mut x297, x295, x280, (0x0 as u32)); + let mut x298: u32 = 0; + let mut x299: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x298, &mut x299, x297, x282, (0x0 as u32)); + let mut x300: u32 = 0; + let mut x301: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x300, &mut x301, x284, 0xee00bc4f); + let mut x302: u32 = 0; + let mut x303: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x302, &mut x303, x300, 0xffffffff); + let mut x304: u32 = 0; + let mut x305: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x304, &mut x305, x300, 0xffffffff); + let mut x306: u32 = 0; + let mut x307: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x306, &mut x307, x300, 0xffffffff); + let mut x308: u32 = 0; + let mut x309: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x308, &mut x309, x300, 0xbce6faad); + let mut x310: u32 = 0; + let mut x311: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x310, &mut x311, x300, 0xa7179e84); + let mut x312: u32 = 0; + let mut x313: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x312, &mut x313, x300, 0xf3b9cac2); + let mut x314: u32 = 0; + let mut x315: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x314, &mut x315, x300, 0xfc632551); + let mut x316: u32 = 0; + let mut x317: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x316, &mut x317, 0x0, x315, x312); + let mut x318: u32 = 0; + let mut x319: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x318, &mut x319, x317, x313, x310); + let mut x320: u32 = 0; + let mut x321: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x320, &mut x321, x319, x311, x308); + let mut x322: u32 = 0; + let mut x323: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x322, &mut x323, x321, x309, x306); + let mut x324: u32 = 0; + let mut x325: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x324, &mut x325, x323, x307, x304); + let mut x326: u32 = 0; + let mut x327: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x326, &mut x327, 0x0, x284, x314); + let mut x328: u32 = 0; + let mut x329: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x328, &mut x329, x327, x286, x316); + let mut x330: u32 = 0; + let mut x331: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x330, &mut x331, x329, x288, x318); + let mut x332: u32 = 0; + let mut x333: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x332, &mut x333, x331, x290, x320); + let mut x334: u32 = 0; + let mut x335: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x334, &mut x335, x333, x292, x322); + let mut x336: u32 = 0; + let mut x337: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x336, &mut x337, x335, x294, x324); + let mut x338: u32 = 0; + let mut x339: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x338, &mut x339, x337, x296, ((x325 as u32) + x305)); + let mut x340: u32 = 0; + let mut x341: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x340, &mut x341, x339, x298, x302); + let mut x342: u32 = 0; + let mut x343: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x342, &mut x343, x341, ((x299 as u32) + (x283 as u32)), x303); + let mut x344: u32 = 0; + let mut x345: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x344, &mut x345, 0x0, x328, (arg1[6])); + let mut x346: u32 = 0; + let mut x347: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x346, &mut x347, x345, x330, (0x0 as u32)); + let mut x348: u32 = 0; + let mut x349: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x348, &mut x349, x347, x332, (0x0 as u32)); + let mut x350: u32 = 0; + let mut x351: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x350, &mut x351, x349, x334, (0x0 as u32)); + let mut x352: u32 = 0; + let mut x353: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x352, &mut x353, x351, x336, (0x0 as u32)); + let mut x354: u32 = 0; + let mut x355: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x354, &mut x355, x353, x338, (0x0 as u32)); + let mut x356: u32 = 0; + let mut x357: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x356, &mut x357, x355, x340, (0x0 as u32)); + let mut x358: u32 = 0; + let mut x359: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x358, &mut x359, x357, x342, (0x0 as u32)); + let mut x360: u32 = 0; + let mut x361: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x360, &mut x361, x344, 0xee00bc4f); + let mut x362: u32 = 0; + let mut x363: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x362, &mut x363, x360, 0xffffffff); + let mut x364: u32 = 0; + let mut x365: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x364, &mut x365, x360, 0xffffffff); + let mut x366: u32 = 0; + let mut x367: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x366, &mut x367, x360, 0xffffffff); + let mut x368: u32 = 0; + let mut x369: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x368, &mut x369, x360, 0xbce6faad); + let mut x370: u32 = 0; + let mut x371: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x370, &mut x371, x360, 0xa7179e84); + let mut x372: u32 = 0; + let mut x373: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x372, &mut x373, x360, 0xf3b9cac2); + let mut x374: u32 = 0; + let mut x375: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x374, &mut x375, x360, 0xfc632551); + let mut x376: u32 = 0; + let mut x377: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x376, &mut x377, 0x0, x375, x372); + let mut x378: u32 = 0; + let mut x379: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x378, &mut x379, x377, x373, x370); + let mut x380: u32 = 0; + let mut x381: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x380, &mut x381, x379, x371, x368); + let mut x382: u32 = 0; + let mut x383: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x382, &mut x383, x381, x369, x366); + let mut x384: u32 = 0; + let mut x385: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x384, &mut x385, x383, x367, x364); + let mut x386: u32 = 0; + let mut x387: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x386, &mut x387, 0x0, x344, x374); + let mut x388: u32 = 0; + let mut x389: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x388, &mut x389, x387, x346, x376); + let mut x390: u32 = 0; + let mut x391: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x390, &mut x391, x389, x348, x378); + let mut x392: u32 = 0; + let mut x393: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x392, &mut x393, x391, x350, x380); + let mut x394: u32 = 0; + let mut x395: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x394, &mut x395, x393, x352, x382); + let mut x396: u32 = 0; + let mut x397: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x396, &mut x397, x395, x354, x384); + let mut x398: u32 = 0; + let mut x399: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x398, &mut x399, x397, x356, ((x385 as u32) + x365)); + let mut x400: u32 = 0; + let mut x401: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x400, &mut x401, x399, x358, x362); + let mut x402: u32 = 0; + let mut x403: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x402, &mut x403, x401, ((x359 as u32) + (x343 as u32)), x363); + let mut x404: u32 = 0; + let mut x405: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x404, &mut x405, 0x0, x388, (arg1[7])); + let mut x406: u32 = 0; + let mut x407: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x406, &mut x407, x405, x390, (0x0 as u32)); + let mut x408: u32 = 0; + let mut x409: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x408, &mut x409, x407, x392, (0x0 as u32)); + let mut x410: u32 = 0; + let mut x411: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x410, &mut x411, x409, x394, (0x0 as u32)); + let mut x412: u32 = 0; + let mut x413: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x412, &mut x413, x411, x396, (0x0 as u32)); + let mut x414: u32 = 0; + let mut x415: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x414, &mut x415, x413, x398, (0x0 as u32)); + let mut x416: u32 = 0; + let mut x417: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x416, &mut x417, x415, x400, (0x0 as u32)); + let mut x418: u32 = 0; + let mut x419: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x418, &mut x419, x417, x402, (0x0 as u32)); + let mut x420: u32 = 0; + let mut x421: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x420, &mut x421, x404, 0xee00bc4f); + let mut x422: u32 = 0; + let mut x423: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x422, &mut x423, x420, 0xffffffff); + let mut x424: u32 = 0; + let mut x425: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x424, &mut x425, x420, 0xffffffff); + let mut x426: u32 = 0; + let mut x427: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x426, &mut x427, x420, 0xffffffff); + let mut x428: u32 = 0; + let mut x429: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x428, &mut x429, x420, 0xbce6faad); + let mut x430: u32 = 0; + let mut x431: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x430, &mut x431, x420, 0xa7179e84); + let mut x432: u32 = 0; + let mut x433: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x432, &mut x433, x420, 0xf3b9cac2); + let mut x434: u32 = 0; + let mut x435: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x434, &mut x435, x420, 0xfc632551); + let mut x436: u32 = 0; + let mut x437: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x436, &mut x437, 0x0, x435, x432); + let mut x438: u32 = 0; + let mut x439: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x438, &mut x439, x437, x433, x430); + let mut x440: u32 = 0; + let mut x441: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x440, &mut x441, x439, x431, x428); + let mut x442: u32 = 0; + let mut x443: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x442, &mut x443, x441, x429, x426); + let mut x444: u32 = 0; + let mut x445: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x444, &mut x445, x443, x427, x424); + let mut x446: u32 = 0; + let mut x447: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x446, &mut x447, 0x0, x404, x434); + let mut x448: u32 = 0; + let mut x449: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x448, &mut x449, x447, x406, x436); + let mut x450: u32 = 0; + let mut x451: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x450, &mut x451, x449, x408, x438); + let mut x452: u32 = 0; + let mut x453: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x452, &mut x453, x451, x410, x440); + let mut x454: u32 = 0; + let mut x455: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x454, &mut x455, x453, x412, x442); + let mut x456: u32 = 0; + let mut x457: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x456, &mut x457, x455, x414, x444); + let mut x458: u32 = 0; + let mut x459: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x458, &mut x459, x457, x416, ((x445 as u32) + x425)); + let mut x460: u32 = 0; + let mut x461: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x460, &mut x461, x459, x418, x422); + let mut x462: u32 = 0; + let mut x463: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x462, &mut x463, x461, ((x419 as u32) + (x403 as u32)), x423); + let mut x464: u32 = 0; + let mut x465: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x464, &mut x465, 0x0, x448, 0xfc632551); + let mut x466: u32 = 0; + let mut x467: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x466, &mut x467, x465, x450, 0xf3b9cac2); + let mut x468: u32 = 0; + let mut x469: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x468, &mut x469, x467, x452, 0xa7179e84); + let mut x470: u32 = 0; + let mut x471: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x470, &mut x471, x469, x454, 0xbce6faad); + let mut x472: u32 = 0; + let mut x473: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x472, &mut x473, x471, x456, 0xffffffff); + let mut x474: u32 = 0; + let mut x475: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x474, &mut x475, x473, x458, 0xffffffff); + let mut x476: u32 = 0; + let mut x477: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x476, &mut x477, x475, x460, (0x0 as u32)); + let mut x478: u32 = 0; + let mut x479: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x478, &mut x479, x477, x462, 0xffffffff); + let mut x480: u32 = 0; + let mut x481: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x480, &mut x481, x479, (x463 as u32), (0x0 as u32)); + let mut x482: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x482, x481, x464, x448); + let mut x483: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x483, x481, x466, x450); + let mut x484: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x484, x481, x468, x452); + let mut x485: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x485, x481, x470, x454); + let mut x486: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x486, x481, x472, x456); + let mut x487: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x487, x481, x474, x458); + let mut x488: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x488, x481, x476, x460); + let mut x489: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x489, x481, x478, x462); + out1[0] = x482; + out1[1] = x483; + out1[2] = x484; + out1[3] = x485; + out1[4] = x486; + out1[5] = x487; + out1[6] = x488; + out1[7] = x489; +} + +/// The function fiat_p256_scalar_to_montgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_to_montgomery(out1: &mut fiat_p256_scalar_montgomery_domain_field_element, arg1: &fiat_p256_scalar_non_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[1]); + let x2: u32 = (arg1[2]); + let x3: u32 = (arg1[3]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[5]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[7]); + let x8: u32 = (arg1[0]); + let mut x9: u32 = 0; + let mut x10: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x9, &mut x10, x8, 0x66e12d94); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x11, &mut x12, x8, 0xf3d95620); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x13, &mut x14, x8, 0x2845b239); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x15, &mut x16, x8, 0x2b6bec59); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x17, &mut x18, x8, 0x4699799c); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x19, &mut x20, x8, 0x49bd6fa6); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x21, &mut x22, x8, 0x83244c95); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x23, &mut x24, x8, 0xbe79eea2); + let mut x25: u32 = 0; + let mut x26: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x37, &mut x38, x36, x12, x9); + let mut x39: u32 = 0; + let mut x40: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x39, &mut x40, x23, 0xee00bc4f); + let mut x41: u32 = 0; + let mut x42: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x41, &mut x42, x39, 0xffffffff); + let mut x43: u32 = 0; + let mut x44: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x43, &mut x44, x39, 0xffffffff); + let mut x45: u32 = 0; + let mut x46: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x45, &mut x46, x39, 0xffffffff); + let mut x47: u32 = 0; + let mut x48: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x47, &mut x48, x39, 0xbce6faad); + let mut x49: u32 = 0; + let mut x50: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x49, &mut x50, x39, 0xa7179e84); + let mut x51: u32 = 0; + let mut x52: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x51, &mut x52, x39, 0xf3b9cac2); + let mut x53: u32 = 0; + let mut x54: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x53, &mut x54, x39, 0xfc632551); + let mut x55: u32 = 0; + let mut x56: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x55, &mut x56, 0x0, x54, x51); + let mut x57: u32 = 0; + let mut x58: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x57, &mut x58, x56, x52, x49); + let mut x59: u32 = 0; + let mut x60: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x59, &mut x60, x58, x50, x47); + let mut x61: u32 = 0; + let mut x62: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x61, &mut x62, x60, x48, x45); + let mut x63: u32 = 0; + let mut x64: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x63, &mut x64, x62, x46, x43); + let mut x65: u32 = 0; + let mut x66: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x65, &mut x66, 0x0, x23, x53); + let mut x67: u32 = 0; + let mut x68: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x67, &mut x68, x66, x25, x55); + let mut x69: u32 = 0; + let mut x70: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x69, &mut x70, x68, x27, x57); + let mut x71: u32 = 0; + let mut x72: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x71, &mut x72, x70, x29, x59); + let mut x73: u32 = 0; + let mut x74: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x73, &mut x74, x72, x31, x61); + let mut x75: u32 = 0; + let mut x76: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x75, &mut x76, x74, x33, x63); + let mut x77: u32 = 0; + let mut x78: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x77, &mut x78, x76, x35, ((x64 as u32) + x44)); + let mut x79: u32 = 0; + let mut x80: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x79, &mut x80, x78, x37, x41); + let mut x81: u32 = 0; + let mut x82: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x81, &mut x82, x80, ((x38 as u32) + x10), x42); + let mut x83: u32 = 0; + let mut x84: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x83, &mut x84, x1, 0x66e12d94); + let mut x85: u32 = 0; + let mut x86: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x85, &mut x86, x1, 0xf3d95620); + let mut x87: u32 = 0; + let mut x88: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x87, &mut x88, x1, 0x2845b239); + let mut x89: u32 = 0; + let mut x90: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x89, &mut x90, x1, 0x2b6bec59); + let mut x91: u32 = 0; + let mut x92: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x91, &mut x92, x1, 0x4699799c); + let mut x93: u32 = 0; + let mut x94: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x93, &mut x94, x1, 0x49bd6fa6); + let mut x95: u32 = 0; + let mut x96: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x95, &mut x96, x1, 0x83244c95); + let mut x97: u32 = 0; + let mut x98: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x97, &mut x98, x1, 0xbe79eea2); + let mut x99: u32 = 0; + let mut x100: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x99, &mut x100, 0x0, x98, x95); + let mut x101: u32 = 0; + let mut x102: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x101, &mut x102, x100, x96, x93); + let mut x103: u32 = 0; + let mut x104: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x103, &mut x104, x102, x94, x91); + let mut x105: u32 = 0; + let mut x106: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x105, &mut x106, x104, x92, x89); + let mut x107: u32 = 0; + let mut x108: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x107, &mut x108, x106, x90, x87); + let mut x109: u32 = 0; + let mut x110: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x109, &mut x110, x108, x88, x85); + let mut x111: u32 = 0; + let mut x112: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x86, x83); + let mut x113: u32 = 0; + let mut x114: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x113, &mut x114, 0x0, x67, x97); + let mut x115: u32 = 0; + let mut x116: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x115, &mut x116, x114, x69, x99); + let mut x117: u32 = 0; + let mut x118: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x117, &mut x118, x116, x71, x101); + let mut x119: u32 = 0; + let mut x120: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x119, &mut x120, x118, x73, x103); + let mut x121: u32 = 0; + let mut x122: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x121, &mut x122, x120, x75, x105); + let mut x123: u32 = 0; + let mut x124: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x123, &mut x124, x122, x77, x107); + let mut x125: u32 = 0; + let mut x126: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x125, &mut x126, x124, x79, x109); + let mut x127: u32 = 0; + let mut x128: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x127, &mut x128, x126, x81, x111); + let mut x129: u32 = 0; + let mut x130: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x129, &mut x130, x113, 0xee00bc4f); + let mut x131: u32 = 0; + let mut x132: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x131, &mut x132, x129, 0xffffffff); + let mut x133: u32 = 0; + let mut x134: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x133, &mut x134, x129, 0xffffffff); + let mut x135: u32 = 0; + let mut x136: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x135, &mut x136, x129, 0xffffffff); + let mut x137: u32 = 0; + let mut x138: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x137, &mut x138, x129, 0xbce6faad); + let mut x139: u32 = 0; + let mut x140: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x139, &mut x140, x129, 0xa7179e84); + let mut x141: u32 = 0; + let mut x142: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x141, &mut x142, x129, 0xf3b9cac2); + let mut x143: u32 = 0; + let mut x144: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x143, &mut x144, x129, 0xfc632551); + let mut x145: u32 = 0; + let mut x146: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x145, &mut x146, 0x0, x144, x141); + let mut x147: u32 = 0; + let mut x148: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x147, &mut x148, x146, x142, x139); + let mut x149: u32 = 0; + let mut x150: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x149, &mut x150, x148, x140, x137); + let mut x151: u32 = 0; + let mut x152: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x151, &mut x152, x150, x138, x135); + let mut x153: u32 = 0; + let mut x154: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x153, &mut x154, x152, x136, x133); + let mut x155: u32 = 0; + let mut x156: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x155, &mut x156, 0x0, x113, x143); + let mut x157: u32 = 0; + let mut x158: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x157, &mut x158, x156, x115, x145); + let mut x159: u32 = 0; + let mut x160: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x159, &mut x160, x158, x117, x147); + let mut x161: u32 = 0; + let mut x162: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x161, &mut x162, x160, x119, x149); + let mut x163: u32 = 0; + let mut x164: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x163, &mut x164, x162, x121, x151); + let mut x165: u32 = 0; + let mut x166: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x165, &mut x166, x164, x123, x153); + let mut x167: u32 = 0; + let mut x168: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x167, &mut x168, x166, x125, ((x154 as u32) + x134)); + let mut x169: u32 = 0; + let mut x170: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x169, &mut x170, x168, x127, x131); + let mut x171: u32 = 0; + let mut x172: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x171, &mut x172, x170, (((x128 as u32) + (x82 as u32)) + ((x112 as u32) + x84)), x132); + let mut x173: u32 = 0; + let mut x174: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x173, &mut x174, x2, 0x66e12d94); + let mut x175: u32 = 0; + let mut x176: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x175, &mut x176, x2, 0xf3d95620); + let mut x177: u32 = 0; + let mut x178: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x177, &mut x178, x2, 0x2845b239); + let mut x179: u32 = 0; + let mut x180: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x179, &mut x180, x2, 0x2b6bec59); + let mut x181: u32 = 0; + let mut x182: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x181, &mut x182, x2, 0x4699799c); + let mut x183: u32 = 0; + let mut x184: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x183, &mut x184, x2, 0x49bd6fa6); + let mut x185: u32 = 0; + let mut x186: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x185, &mut x186, x2, 0x83244c95); + let mut x187: u32 = 0; + let mut x188: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x187, &mut x188, x2, 0xbe79eea2); + let mut x189: u32 = 0; + let mut x190: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x189, &mut x190, 0x0, x188, x185); + let mut x191: u32 = 0; + let mut x192: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x191, &mut x192, x190, x186, x183); + let mut x193: u32 = 0; + let mut x194: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x193, &mut x194, x192, x184, x181); + let mut x195: u32 = 0; + let mut x196: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x195, &mut x196, x194, x182, x179); + let mut x197: u32 = 0; + let mut x198: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x197, &mut x198, x196, x180, x177); + let mut x199: u32 = 0; + let mut x200: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x199, &mut x200, x198, x178, x175); + let mut x201: u32 = 0; + let mut x202: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x201, &mut x202, x200, x176, x173); + let mut x203: u32 = 0; + let mut x204: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x203, &mut x204, 0x0, x157, x187); + let mut x205: u32 = 0; + let mut x206: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x205, &mut x206, x204, x159, x189); + let mut x207: u32 = 0; + let mut x208: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x207, &mut x208, x206, x161, x191); + let mut x209: u32 = 0; + let mut x210: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x209, &mut x210, x208, x163, x193); + let mut x211: u32 = 0; + let mut x212: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x211, &mut x212, x210, x165, x195); + let mut x213: u32 = 0; + let mut x214: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x213, &mut x214, x212, x167, x197); + let mut x215: u32 = 0; + let mut x216: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x215, &mut x216, x214, x169, x199); + let mut x217: u32 = 0; + let mut x218: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x217, &mut x218, x216, x171, x201); + let mut x219: u32 = 0; + let mut x220: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x219, &mut x220, x203, 0xee00bc4f); + let mut x221: u32 = 0; + let mut x222: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x221, &mut x222, x219, 0xffffffff); + let mut x223: u32 = 0; + let mut x224: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x223, &mut x224, x219, 0xffffffff); + let mut x225: u32 = 0; + let mut x226: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x225, &mut x226, x219, 0xffffffff); + let mut x227: u32 = 0; + let mut x228: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x227, &mut x228, x219, 0xbce6faad); + let mut x229: u32 = 0; + let mut x230: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x229, &mut x230, x219, 0xa7179e84); + let mut x231: u32 = 0; + let mut x232: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x231, &mut x232, x219, 0xf3b9cac2); + let mut x233: u32 = 0; + let mut x234: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x233, &mut x234, x219, 0xfc632551); + let mut x235: u32 = 0; + let mut x236: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x235, &mut x236, 0x0, x234, x231); + let mut x237: u32 = 0; + let mut x238: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x237, &mut x238, x236, x232, x229); + let mut x239: u32 = 0; + let mut x240: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x239, &mut x240, x238, x230, x227); + let mut x241: u32 = 0; + let mut x242: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x241, &mut x242, x240, x228, x225); + let mut x243: u32 = 0; + let mut x244: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x243, &mut x244, x242, x226, x223); + let mut x245: u32 = 0; + let mut x246: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x245, &mut x246, 0x0, x203, x233); + let mut x247: u32 = 0; + let mut x248: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x247, &mut x248, x246, x205, x235); + let mut x249: u32 = 0; + let mut x250: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x249, &mut x250, x248, x207, x237); + let mut x251: u32 = 0; + let mut x252: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x251, &mut x252, x250, x209, x239); + let mut x253: u32 = 0; + let mut x254: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x253, &mut x254, x252, x211, x241); + let mut x255: u32 = 0; + let mut x256: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x255, &mut x256, x254, x213, x243); + let mut x257: u32 = 0; + let mut x258: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x257, &mut x258, x256, x215, ((x244 as u32) + x224)); + let mut x259: u32 = 0; + let mut x260: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x259, &mut x260, x258, x217, x221); + let mut x261: u32 = 0; + let mut x262: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x261, &mut x262, x260, (((x218 as u32) + (x172 as u32)) + ((x202 as u32) + x174)), x222); + let mut x263: u32 = 0; + let mut x264: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x263, &mut x264, x3, 0x66e12d94); + let mut x265: u32 = 0; + let mut x266: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x265, &mut x266, x3, 0xf3d95620); + let mut x267: u32 = 0; + let mut x268: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x267, &mut x268, x3, 0x2845b239); + let mut x269: u32 = 0; + let mut x270: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x269, &mut x270, x3, 0x2b6bec59); + let mut x271: u32 = 0; + let mut x272: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x271, &mut x272, x3, 0x4699799c); + let mut x273: u32 = 0; + let mut x274: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x273, &mut x274, x3, 0x49bd6fa6); + let mut x275: u32 = 0; + let mut x276: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x275, &mut x276, x3, 0x83244c95); + let mut x277: u32 = 0; + let mut x278: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x277, &mut x278, x3, 0xbe79eea2); + let mut x279: u32 = 0; + let mut x280: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x279, &mut x280, 0x0, x278, x275); + let mut x281: u32 = 0; + let mut x282: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x281, &mut x282, x280, x276, x273); + let mut x283: u32 = 0; + let mut x284: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x283, &mut x284, x282, x274, x271); + let mut x285: u32 = 0; + let mut x286: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x285, &mut x286, x284, x272, x269); + let mut x287: u32 = 0; + let mut x288: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x287, &mut x288, x286, x270, x267); + let mut x289: u32 = 0; + let mut x290: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x289, &mut x290, x288, x268, x265); + let mut x291: u32 = 0; + let mut x292: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x291, &mut x292, x290, x266, x263); + let mut x293: u32 = 0; + let mut x294: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x293, &mut x294, 0x0, x247, x277); + let mut x295: u32 = 0; + let mut x296: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x295, &mut x296, x294, x249, x279); + let mut x297: u32 = 0; + let mut x298: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x297, &mut x298, x296, x251, x281); + let mut x299: u32 = 0; + let mut x300: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x299, &mut x300, x298, x253, x283); + let mut x301: u32 = 0; + let mut x302: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x301, &mut x302, x300, x255, x285); + let mut x303: u32 = 0; + let mut x304: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x303, &mut x304, x302, x257, x287); + let mut x305: u32 = 0; + let mut x306: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x305, &mut x306, x304, x259, x289); + let mut x307: u32 = 0; + let mut x308: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x307, &mut x308, x306, x261, x291); + let mut x309: u32 = 0; + let mut x310: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x309, &mut x310, x293, 0xee00bc4f); + let mut x311: u32 = 0; + let mut x312: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x311, &mut x312, x309, 0xffffffff); + let mut x313: u32 = 0; + let mut x314: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x313, &mut x314, x309, 0xffffffff); + let mut x315: u32 = 0; + let mut x316: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x315, &mut x316, x309, 0xffffffff); + let mut x317: u32 = 0; + let mut x318: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x317, &mut x318, x309, 0xbce6faad); + let mut x319: u32 = 0; + let mut x320: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x319, &mut x320, x309, 0xa7179e84); + let mut x321: u32 = 0; + let mut x322: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x321, &mut x322, x309, 0xf3b9cac2); + let mut x323: u32 = 0; + let mut x324: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x323, &mut x324, x309, 0xfc632551); + let mut x325: u32 = 0; + let mut x326: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x325, &mut x326, 0x0, x324, x321); + let mut x327: u32 = 0; + let mut x328: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x327, &mut x328, x326, x322, x319); + let mut x329: u32 = 0; + let mut x330: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x329, &mut x330, x328, x320, x317); + let mut x331: u32 = 0; + let mut x332: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x331, &mut x332, x330, x318, x315); + let mut x333: u32 = 0; + let mut x334: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x333, &mut x334, x332, x316, x313); + let mut x335: u32 = 0; + let mut x336: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x335, &mut x336, 0x0, x293, x323); + let mut x337: u32 = 0; + let mut x338: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x337, &mut x338, x336, x295, x325); + let mut x339: u32 = 0; + let mut x340: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x339, &mut x340, x338, x297, x327); + let mut x341: u32 = 0; + let mut x342: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x341, &mut x342, x340, x299, x329); + let mut x343: u32 = 0; + let mut x344: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x343, &mut x344, x342, x301, x331); + let mut x345: u32 = 0; + let mut x346: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x345, &mut x346, x344, x303, x333); + let mut x347: u32 = 0; + let mut x348: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x347, &mut x348, x346, x305, ((x334 as u32) + x314)); + let mut x349: u32 = 0; + let mut x350: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x349, &mut x350, x348, x307, x311); + let mut x351: u32 = 0; + let mut x352: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x351, &mut x352, x350, (((x308 as u32) + (x262 as u32)) + ((x292 as u32) + x264)), x312); + let mut x353: u32 = 0; + let mut x354: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x353, &mut x354, x4, 0x66e12d94); + let mut x355: u32 = 0; + let mut x356: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x355, &mut x356, x4, 0xf3d95620); + let mut x357: u32 = 0; + let mut x358: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x357, &mut x358, x4, 0x2845b239); + let mut x359: u32 = 0; + let mut x360: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x359, &mut x360, x4, 0x2b6bec59); + let mut x361: u32 = 0; + let mut x362: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x361, &mut x362, x4, 0x4699799c); + let mut x363: u32 = 0; + let mut x364: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x363, &mut x364, x4, 0x49bd6fa6); + let mut x365: u32 = 0; + let mut x366: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x365, &mut x366, x4, 0x83244c95); + let mut x367: u32 = 0; + let mut x368: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x367, &mut x368, x4, 0xbe79eea2); + let mut x369: u32 = 0; + let mut x370: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x369, &mut x370, 0x0, x368, x365); + let mut x371: u32 = 0; + let mut x372: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x371, &mut x372, x370, x366, x363); + let mut x373: u32 = 0; + let mut x374: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x373, &mut x374, x372, x364, x361); + let mut x375: u32 = 0; + let mut x376: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x375, &mut x376, x374, x362, x359); + let mut x377: u32 = 0; + let mut x378: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x377, &mut x378, x376, x360, x357); + let mut x379: u32 = 0; + let mut x380: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x379, &mut x380, x378, x358, x355); + let mut x381: u32 = 0; + let mut x382: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x381, &mut x382, x380, x356, x353); + let mut x383: u32 = 0; + let mut x384: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x383, &mut x384, 0x0, x337, x367); + let mut x385: u32 = 0; + let mut x386: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x385, &mut x386, x384, x339, x369); + let mut x387: u32 = 0; + let mut x388: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x387, &mut x388, x386, x341, x371); + let mut x389: u32 = 0; + let mut x390: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x389, &mut x390, x388, x343, x373); + let mut x391: u32 = 0; + let mut x392: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x391, &mut x392, x390, x345, x375); + let mut x393: u32 = 0; + let mut x394: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x393, &mut x394, x392, x347, x377); + let mut x395: u32 = 0; + let mut x396: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x395, &mut x396, x394, x349, x379); + let mut x397: u32 = 0; + let mut x398: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x397, &mut x398, x396, x351, x381); + let mut x399: u32 = 0; + let mut x400: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x399, &mut x400, x383, 0xee00bc4f); + let mut x401: u32 = 0; + let mut x402: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x401, &mut x402, x399, 0xffffffff); + let mut x403: u32 = 0; + let mut x404: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x403, &mut x404, x399, 0xffffffff); + let mut x405: u32 = 0; + let mut x406: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x405, &mut x406, x399, 0xffffffff); + let mut x407: u32 = 0; + let mut x408: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x407, &mut x408, x399, 0xbce6faad); + let mut x409: u32 = 0; + let mut x410: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x409, &mut x410, x399, 0xa7179e84); + let mut x411: u32 = 0; + let mut x412: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x411, &mut x412, x399, 0xf3b9cac2); + let mut x413: u32 = 0; + let mut x414: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x413, &mut x414, x399, 0xfc632551); + let mut x415: u32 = 0; + let mut x416: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x415, &mut x416, 0x0, x414, x411); + let mut x417: u32 = 0; + let mut x418: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x417, &mut x418, x416, x412, x409); + let mut x419: u32 = 0; + let mut x420: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x419, &mut x420, x418, x410, x407); + let mut x421: u32 = 0; + let mut x422: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x421, &mut x422, x420, x408, x405); + let mut x423: u32 = 0; + let mut x424: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x423, &mut x424, x422, x406, x403); + let mut x425: u32 = 0; + let mut x426: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x425, &mut x426, 0x0, x383, x413); + let mut x427: u32 = 0; + let mut x428: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x427, &mut x428, x426, x385, x415); + let mut x429: u32 = 0; + let mut x430: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x429, &mut x430, x428, x387, x417); + let mut x431: u32 = 0; + let mut x432: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x431, &mut x432, x430, x389, x419); + let mut x433: u32 = 0; + let mut x434: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x433, &mut x434, x432, x391, x421); + let mut x435: u32 = 0; + let mut x436: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x435, &mut x436, x434, x393, x423); + let mut x437: u32 = 0; + let mut x438: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x437, &mut x438, x436, x395, ((x424 as u32) + x404)); + let mut x439: u32 = 0; + let mut x440: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x439, &mut x440, x438, x397, x401); + let mut x441: u32 = 0; + let mut x442: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x441, &mut x442, x440, (((x398 as u32) + (x352 as u32)) + ((x382 as u32) + x354)), x402); + let mut x443: u32 = 0; + let mut x444: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x443, &mut x444, x5, 0x66e12d94); + let mut x445: u32 = 0; + let mut x446: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x445, &mut x446, x5, 0xf3d95620); + let mut x447: u32 = 0; + let mut x448: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x447, &mut x448, x5, 0x2845b239); + let mut x449: u32 = 0; + let mut x450: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x449, &mut x450, x5, 0x2b6bec59); + let mut x451: u32 = 0; + let mut x452: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x451, &mut x452, x5, 0x4699799c); + let mut x453: u32 = 0; + let mut x454: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x453, &mut x454, x5, 0x49bd6fa6); + let mut x455: u32 = 0; + let mut x456: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x455, &mut x456, x5, 0x83244c95); + let mut x457: u32 = 0; + let mut x458: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x457, &mut x458, x5, 0xbe79eea2); + let mut x459: u32 = 0; + let mut x460: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x459, &mut x460, 0x0, x458, x455); + let mut x461: u32 = 0; + let mut x462: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x461, &mut x462, x460, x456, x453); + let mut x463: u32 = 0; + let mut x464: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x463, &mut x464, x462, x454, x451); + let mut x465: u32 = 0; + let mut x466: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x465, &mut x466, x464, x452, x449); + let mut x467: u32 = 0; + let mut x468: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x467, &mut x468, x466, x450, x447); + let mut x469: u32 = 0; + let mut x470: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x469, &mut x470, x468, x448, x445); + let mut x471: u32 = 0; + let mut x472: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x471, &mut x472, x470, x446, x443); + let mut x473: u32 = 0; + let mut x474: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x473, &mut x474, 0x0, x427, x457); + let mut x475: u32 = 0; + let mut x476: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x475, &mut x476, x474, x429, x459); + let mut x477: u32 = 0; + let mut x478: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x477, &mut x478, x476, x431, x461); + let mut x479: u32 = 0; + let mut x480: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x479, &mut x480, x478, x433, x463); + let mut x481: u32 = 0; + let mut x482: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x481, &mut x482, x480, x435, x465); + let mut x483: u32 = 0; + let mut x484: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x483, &mut x484, x482, x437, x467); + let mut x485: u32 = 0; + let mut x486: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x485, &mut x486, x484, x439, x469); + let mut x487: u32 = 0; + let mut x488: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x487, &mut x488, x486, x441, x471); + let mut x489: u32 = 0; + let mut x490: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x489, &mut x490, x473, 0xee00bc4f); + let mut x491: u32 = 0; + let mut x492: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x491, &mut x492, x489, 0xffffffff); + let mut x493: u32 = 0; + let mut x494: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x493, &mut x494, x489, 0xffffffff); + let mut x495: u32 = 0; + let mut x496: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x495, &mut x496, x489, 0xffffffff); + let mut x497: u32 = 0; + let mut x498: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x497, &mut x498, x489, 0xbce6faad); + let mut x499: u32 = 0; + let mut x500: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x499, &mut x500, x489, 0xa7179e84); + let mut x501: u32 = 0; + let mut x502: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x501, &mut x502, x489, 0xf3b9cac2); + let mut x503: u32 = 0; + let mut x504: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x503, &mut x504, x489, 0xfc632551); + let mut x505: u32 = 0; + let mut x506: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x505, &mut x506, 0x0, x504, x501); + let mut x507: u32 = 0; + let mut x508: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x507, &mut x508, x506, x502, x499); + let mut x509: u32 = 0; + let mut x510: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x509, &mut x510, x508, x500, x497); + let mut x511: u32 = 0; + let mut x512: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x511, &mut x512, x510, x498, x495); + let mut x513: u32 = 0; + let mut x514: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x513, &mut x514, x512, x496, x493); + let mut x515: u32 = 0; + let mut x516: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x515, &mut x516, 0x0, x473, x503); + let mut x517: u32 = 0; + let mut x518: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x517, &mut x518, x516, x475, x505); + let mut x519: u32 = 0; + let mut x520: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x519, &mut x520, x518, x477, x507); + let mut x521: u32 = 0; + let mut x522: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x521, &mut x522, x520, x479, x509); + let mut x523: u32 = 0; + let mut x524: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x523, &mut x524, x522, x481, x511); + let mut x525: u32 = 0; + let mut x526: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x525, &mut x526, x524, x483, x513); + let mut x527: u32 = 0; + let mut x528: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x527, &mut x528, x526, x485, ((x514 as u32) + x494)); + let mut x529: u32 = 0; + let mut x530: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x529, &mut x530, x528, x487, x491); + let mut x531: u32 = 0; + let mut x532: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x531, &mut x532, x530, (((x488 as u32) + (x442 as u32)) + ((x472 as u32) + x444)), x492); + let mut x533: u32 = 0; + let mut x534: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x533, &mut x534, x6, 0x66e12d94); + let mut x535: u32 = 0; + let mut x536: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x535, &mut x536, x6, 0xf3d95620); + let mut x537: u32 = 0; + let mut x538: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x537, &mut x538, x6, 0x2845b239); + let mut x539: u32 = 0; + let mut x540: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x539, &mut x540, x6, 0x2b6bec59); + let mut x541: u32 = 0; + let mut x542: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x541, &mut x542, x6, 0x4699799c); + let mut x543: u32 = 0; + let mut x544: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x543, &mut x544, x6, 0x49bd6fa6); + let mut x545: u32 = 0; + let mut x546: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x545, &mut x546, x6, 0x83244c95); + let mut x547: u32 = 0; + let mut x548: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x547, &mut x548, x6, 0xbe79eea2); + let mut x549: u32 = 0; + let mut x550: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x549, &mut x550, 0x0, x548, x545); + let mut x551: u32 = 0; + let mut x552: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x551, &mut x552, x550, x546, x543); + let mut x553: u32 = 0; + let mut x554: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x553, &mut x554, x552, x544, x541); + let mut x555: u32 = 0; + let mut x556: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x555, &mut x556, x554, x542, x539); + let mut x557: u32 = 0; + let mut x558: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x557, &mut x558, x556, x540, x537); + let mut x559: u32 = 0; + let mut x560: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x559, &mut x560, x558, x538, x535); + let mut x561: u32 = 0; + let mut x562: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x561, &mut x562, x560, x536, x533); + let mut x563: u32 = 0; + let mut x564: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x563, &mut x564, 0x0, x517, x547); + let mut x565: u32 = 0; + let mut x566: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x565, &mut x566, x564, x519, x549); + let mut x567: u32 = 0; + let mut x568: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x567, &mut x568, x566, x521, x551); + let mut x569: u32 = 0; + let mut x570: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x569, &mut x570, x568, x523, x553); + let mut x571: u32 = 0; + let mut x572: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x571, &mut x572, x570, x525, x555); + let mut x573: u32 = 0; + let mut x574: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x573, &mut x574, x572, x527, x557); + let mut x575: u32 = 0; + let mut x576: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x575, &mut x576, x574, x529, x559); + let mut x577: u32 = 0; + let mut x578: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x577, &mut x578, x576, x531, x561); + let mut x579: u32 = 0; + let mut x580: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x579, &mut x580, x563, 0xee00bc4f); + let mut x581: u32 = 0; + let mut x582: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x581, &mut x582, x579, 0xffffffff); + let mut x583: u32 = 0; + let mut x584: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x583, &mut x584, x579, 0xffffffff); + let mut x585: u32 = 0; + let mut x586: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x585, &mut x586, x579, 0xffffffff); + let mut x587: u32 = 0; + let mut x588: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x587, &mut x588, x579, 0xbce6faad); + let mut x589: u32 = 0; + let mut x590: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x589, &mut x590, x579, 0xa7179e84); + let mut x591: u32 = 0; + let mut x592: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x591, &mut x592, x579, 0xf3b9cac2); + let mut x593: u32 = 0; + let mut x594: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x593, &mut x594, x579, 0xfc632551); + let mut x595: u32 = 0; + let mut x596: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x595, &mut x596, 0x0, x594, x591); + let mut x597: u32 = 0; + let mut x598: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x597, &mut x598, x596, x592, x589); + let mut x599: u32 = 0; + let mut x600: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x599, &mut x600, x598, x590, x587); + let mut x601: u32 = 0; + let mut x602: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x601, &mut x602, x600, x588, x585); + let mut x603: u32 = 0; + let mut x604: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x603, &mut x604, x602, x586, x583); + let mut x605: u32 = 0; + let mut x606: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x605, &mut x606, 0x0, x563, x593); + let mut x607: u32 = 0; + let mut x608: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x607, &mut x608, x606, x565, x595); + let mut x609: u32 = 0; + let mut x610: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x609, &mut x610, x608, x567, x597); + let mut x611: u32 = 0; + let mut x612: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x611, &mut x612, x610, x569, x599); + let mut x613: u32 = 0; + let mut x614: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x613, &mut x614, x612, x571, x601); + let mut x615: u32 = 0; + let mut x616: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x615, &mut x616, x614, x573, x603); + let mut x617: u32 = 0; + let mut x618: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x617, &mut x618, x616, x575, ((x604 as u32) + x584)); + let mut x619: u32 = 0; + let mut x620: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x619, &mut x620, x618, x577, x581); + let mut x621: u32 = 0; + let mut x622: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x621, &mut x622, x620, (((x578 as u32) + (x532 as u32)) + ((x562 as u32) + x534)), x582); + let mut x623: u32 = 0; + let mut x624: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x623, &mut x624, x7, 0x66e12d94); + let mut x625: u32 = 0; + let mut x626: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x625, &mut x626, x7, 0xf3d95620); + let mut x627: u32 = 0; + let mut x628: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x627, &mut x628, x7, 0x2845b239); + let mut x629: u32 = 0; + let mut x630: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x629, &mut x630, x7, 0x2b6bec59); + let mut x631: u32 = 0; + let mut x632: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x631, &mut x632, x7, 0x4699799c); + let mut x633: u32 = 0; + let mut x634: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x633, &mut x634, x7, 0x49bd6fa6); + let mut x635: u32 = 0; + let mut x636: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x635, &mut x636, x7, 0x83244c95); + let mut x637: u32 = 0; + let mut x638: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x637, &mut x638, x7, 0xbe79eea2); + let mut x639: u32 = 0; + let mut x640: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x639, &mut x640, 0x0, x638, x635); + let mut x641: u32 = 0; + let mut x642: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x641, &mut x642, x640, x636, x633); + let mut x643: u32 = 0; + let mut x644: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x643, &mut x644, x642, x634, x631); + let mut x645: u32 = 0; + let mut x646: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x645, &mut x646, x644, x632, x629); + let mut x647: u32 = 0; + let mut x648: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x647, &mut x648, x646, x630, x627); + let mut x649: u32 = 0; + let mut x650: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x649, &mut x650, x648, x628, x625); + let mut x651: u32 = 0; + let mut x652: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x651, &mut x652, x650, x626, x623); + let mut x653: u32 = 0; + let mut x654: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x653, &mut x654, 0x0, x607, x637); + let mut x655: u32 = 0; + let mut x656: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x655, &mut x656, x654, x609, x639); + let mut x657: u32 = 0; + let mut x658: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x657, &mut x658, x656, x611, x641); + let mut x659: u32 = 0; + let mut x660: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x659, &mut x660, x658, x613, x643); + let mut x661: u32 = 0; + let mut x662: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x661, &mut x662, x660, x615, x645); + let mut x663: u32 = 0; + let mut x664: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x663, &mut x664, x662, x617, x647); + let mut x665: u32 = 0; + let mut x666: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x665, &mut x666, x664, x619, x649); + let mut x667: u32 = 0; + let mut x668: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x667, &mut x668, x666, x621, x651); + let mut x669: u32 = 0; + let mut x670: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x669, &mut x670, x653, 0xee00bc4f); + let mut x671: u32 = 0; + let mut x672: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x671, &mut x672, x669, 0xffffffff); + let mut x673: u32 = 0; + let mut x674: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x673, &mut x674, x669, 0xffffffff); + let mut x675: u32 = 0; + let mut x676: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x675, &mut x676, x669, 0xffffffff); + let mut x677: u32 = 0; + let mut x678: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x677, &mut x678, x669, 0xbce6faad); + let mut x679: u32 = 0; + let mut x680: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x679, &mut x680, x669, 0xa7179e84); + let mut x681: u32 = 0; + let mut x682: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x681, &mut x682, x669, 0xf3b9cac2); + let mut x683: u32 = 0; + let mut x684: u32 = 0; + fiat_p256_scalar_mulx_u32(&mut x683, &mut x684, x669, 0xfc632551); + let mut x685: u32 = 0; + let mut x686: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x685, &mut x686, 0x0, x684, x681); + let mut x687: u32 = 0; + let mut x688: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x687, &mut x688, x686, x682, x679); + let mut x689: u32 = 0; + let mut x690: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x689, &mut x690, x688, x680, x677); + let mut x691: u32 = 0; + let mut x692: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x691, &mut x692, x690, x678, x675); + let mut x693: u32 = 0; + let mut x694: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x693, &mut x694, x692, x676, x673); + let mut x695: u32 = 0; + let mut x696: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x695, &mut x696, 0x0, x653, x683); + let mut x697: u32 = 0; + let mut x698: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x697, &mut x698, x696, x655, x685); + let mut x699: u32 = 0; + let mut x700: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x699, &mut x700, x698, x657, x687); + let mut x701: u32 = 0; + let mut x702: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x701, &mut x702, x700, x659, x689); + let mut x703: u32 = 0; + let mut x704: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x703, &mut x704, x702, x661, x691); + let mut x705: u32 = 0; + let mut x706: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x705, &mut x706, x704, x663, x693); + let mut x707: u32 = 0; + let mut x708: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x707, &mut x708, x706, x665, ((x694 as u32) + x674)); + let mut x709: u32 = 0; + let mut x710: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x709, &mut x710, x708, x667, x671); + let mut x711: u32 = 0; + let mut x712: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x711, &mut x712, x710, (((x668 as u32) + (x622 as u32)) + ((x652 as u32) + x624)), x672); + let mut x713: u32 = 0; + let mut x714: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x713, &mut x714, 0x0, x697, 0xfc632551); + let mut x715: u32 = 0; + let mut x716: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x715, &mut x716, x714, x699, 0xf3b9cac2); + let mut x717: u32 = 0; + let mut x718: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x717, &mut x718, x716, x701, 0xa7179e84); + let mut x719: u32 = 0; + let mut x720: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x719, &mut x720, x718, x703, 0xbce6faad); + let mut x721: u32 = 0; + let mut x722: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x721, &mut x722, x720, x705, 0xffffffff); + let mut x723: u32 = 0; + let mut x724: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x723, &mut x724, x722, x707, 0xffffffff); + let mut x725: u32 = 0; + let mut x726: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x725, &mut x726, x724, x709, (0x0 as u32)); + let mut x727: u32 = 0; + let mut x728: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x727, &mut x728, x726, x711, 0xffffffff); + let mut x729: u32 = 0; + let mut x730: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x729, &mut x730, x728, (x712 as u32), (0x0 as u32)); + let mut x731: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x731, x730, x713, x697); + let mut x732: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x732, x730, x715, x699); + let mut x733: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x733, x730, x717, x701); + let mut x734: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x734, x730, x719, x703); + let mut x735: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x735, x730, x721, x705); + let mut x736: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x736, x730, x723, x707); + let mut x737: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x737, x730, x725, x709); + let mut x738: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x738, x730, x727, x711); + out1[0] = x731; + out1[1] = x732; + out1[2] = x733; + out1[3] = x734; + out1[4] = x735; + out1[5] = x736; + out1[6] = x737; + out1[7] = x738; +} + +/// The function fiat_p256_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +#[inline] +pub fn fiat_p256_scalar_nonzero(out1: &mut u32, arg1: &[u32; 8]) -> () { + let x1: u32 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | (arg1[7])))))))); + *out1 = x1; +} + +/// The function fiat_p256_scalar_selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_p256_scalar_selectznz(out1: &mut [u32; 8], arg1: fiat_p256_scalar_u1, arg2: &[u32; 8], arg3: &[u32; 8]) -> () { + let mut x1: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x1, arg1, (arg2[0]), (arg3[0])); + let mut x2: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x2, arg1, (arg2[1]), (arg3[1])); + let mut x3: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x3, arg1, (arg2[2]), (arg3[2])); + let mut x4: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x4, arg1, (arg2[3]), (arg3[3])); + let mut x5: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x5, arg1, (arg2[4]), (arg3[4])); + let mut x6: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x6, arg1, (arg2[5]), (arg3[5])); + let mut x7: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x7, arg1, (arg2[6]), (arg3[6])); + let mut x8: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x8, arg1, (arg2[7]), (arg3[7])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; + out1[6] = x7; + out1[7] = x8; +} + +/// The function fiat_p256_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +#[inline] +pub fn fiat_p256_scalar_to_bytes(out1: &mut [u8; 32], arg1: &[u32; 8]) -> () { + let x1: u32 = (arg1[7]); + let x2: u32 = (arg1[6]); + let x3: u32 = (arg1[5]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[3]); + let x6: u32 = (arg1[2]); + let x7: u32 = (arg1[1]); + let x8: u32 = (arg1[0]); + let x9: u8 = ((x8 & (0xff as u32)) as u8); + let x10: u32 = (x8 >> 8); + let x11: u8 = ((x10 & (0xff as u32)) as u8); + let x12: u32 = (x10 >> 8); + let x13: u8 = ((x12 & (0xff as u32)) as u8); + let x14: u8 = ((x12 >> 8) as u8); + let x15: u8 = ((x7 & (0xff as u32)) as u8); + let x16: u32 = (x7 >> 8); + let x17: u8 = ((x16 & (0xff as u32)) as u8); + let x18: u32 = (x16 >> 8); + let x19: u8 = ((x18 & (0xff as u32)) as u8); + let x20: u8 = ((x18 >> 8) as u8); + let x21: u8 = ((x6 & (0xff as u32)) as u8); + let x22: u32 = (x6 >> 8); + let x23: u8 = ((x22 & (0xff as u32)) as u8); + let x24: u32 = (x22 >> 8); + let x25: u8 = ((x24 & (0xff as u32)) as u8); + let x26: u8 = ((x24 >> 8) as u8); + let x27: u8 = ((x5 & (0xff as u32)) as u8); + let x28: u32 = (x5 >> 8); + let x29: u8 = ((x28 & (0xff as u32)) as u8); + let x30: u32 = (x28 >> 8); + let x31: u8 = ((x30 & (0xff as u32)) as u8); + let x32: u8 = ((x30 >> 8) as u8); + let x33: u8 = ((x4 & (0xff as u32)) as u8); + let x34: u32 = (x4 >> 8); + let x35: u8 = ((x34 & (0xff as u32)) as u8); + let x36: u32 = (x34 >> 8); + let x37: u8 = ((x36 & (0xff as u32)) as u8); + let x38: u8 = ((x36 >> 8) as u8); + let x39: u8 = ((x3 & (0xff as u32)) as u8); + let x40: u32 = (x3 >> 8); + let x41: u8 = ((x40 & (0xff as u32)) as u8); + let x42: u32 = (x40 >> 8); + let x43: u8 = ((x42 & (0xff as u32)) as u8); + let x44: u8 = ((x42 >> 8) as u8); + let x45: u8 = ((x2 & (0xff as u32)) as u8); + let x46: u32 = (x2 >> 8); + let x47: u8 = ((x46 & (0xff as u32)) as u8); + let x48: u32 = (x46 >> 8); + let x49: u8 = ((x48 & (0xff as u32)) as u8); + let x50: u8 = ((x48 >> 8) as u8); + let x51: u8 = ((x1 & (0xff as u32)) as u8); + let x52: u32 = (x1 >> 8); + let x53: u8 = ((x52 & (0xff as u32)) as u8); + let x54: u32 = (x52 >> 8); + let x55: u8 = ((x54 & (0xff as u32)) as u8); + let x56: u8 = ((x54 >> 8) as u8); + out1[0] = x9; + out1[1] = x11; + out1[2] = x13; + out1[3] = x14; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x26; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x38; + out1[20] = x39; + out1[21] = x41; + out1[22] = x43; + out1[23] = x44; + out1[24] = x45; + out1[25] = x47; + out1[26] = x49; + out1[27] = x50; + out1[28] = x51; + out1[29] = x53; + out1[30] = x55; + out1[31] = x56; +} + +/// The function fiat_p256_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_p256_scalar_from_bytes(out1: &mut [u32; 8], arg1: &[u8; 32]) -> () { + let x1: u32 = (((arg1[31]) as u32) << 24); + let x2: u32 = (((arg1[30]) as u32) << 16); + let x3: u32 = (((arg1[29]) as u32) << 8); + let x4: u8 = (arg1[28]); + let x5: u32 = (((arg1[27]) as u32) << 24); + let x6: u32 = (((arg1[26]) as u32) << 16); + let x7: u32 = (((arg1[25]) as u32) << 8); + let x8: u8 = (arg1[24]); + let x9: u32 = (((arg1[23]) as u32) << 24); + let x10: u32 = (((arg1[22]) as u32) << 16); + let x11: u32 = (((arg1[21]) as u32) << 8); + let x12: u8 = (arg1[20]); + let x13: u32 = (((arg1[19]) as u32) << 24); + let x14: u32 = (((arg1[18]) as u32) << 16); + let x15: u32 = (((arg1[17]) as u32) << 8); + let x16: u8 = (arg1[16]); + let x17: u32 = (((arg1[15]) as u32) << 24); + let x18: u32 = (((arg1[14]) as u32) << 16); + let x19: u32 = (((arg1[13]) as u32) << 8); + let x20: u8 = (arg1[12]); + let x21: u32 = (((arg1[11]) as u32) << 24); + let x22: u32 = (((arg1[10]) as u32) << 16); + let x23: u32 = (((arg1[9]) as u32) << 8); + let x24: u8 = (arg1[8]); + let x25: u32 = (((arg1[7]) as u32) << 24); + let x26: u32 = (((arg1[6]) as u32) << 16); + let x27: u32 = (((arg1[5]) as u32) << 8); + let x28: u8 = (arg1[4]); + let x29: u32 = (((arg1[3]) as u32) << 24); + let x30: u32 = (((arg1[2]) as u32) << 16); + let x31: u32 = (((arg1[1]) as u32) << 8); + let x32: u8 = (arg1[0]); + let x33: u32 = (x31 + (x32 as u32)); + let x34: u32 = (x30 + x33); + let x35: u32 = (x29 + x34); + let x36: u32 = (x27 + (x28 as u32)); + let x37: u32 = (x26 + x36); + let x38: u32 = (x25 + x37); + let x39: u32 = (x23 + (x24 as u32)); + let x40: u32 = (x22 + x39); + let x41: u32 = (x21 + x40); + let x42: u32 = (x19 + (x20 as u32)); + let x43: u32 = (x18 + x42); + let x44: u32 = (x17 + x43); + let x45: u32 = (x15 + (x16 as u32)); + let x46: u32 = (x14 + x45); + let x47: u32 = (x13 + x46); + let x48: u32 = (x11 + (x12 as u32)); + let x49: u32 = (x10 + x48); + let x50: u32 = (x9 + x49); + let x51: u32 = (x7 + (x8 as u32)); + let x52: u32 = (x6 + x51); + let x53: u32 = (x5 + x52); + let x54: u32 = (x3 + (x4 as u32)); + let x55: u32 = (x2 + x54); + let x56: u32 = (x1 + x55); + out1[0] = x35; + out1[1] = x38; + out1[2] = x41; + out1[3] = x44; + out1[4] = x47; + out1[5] = x50; + out1[6] = x53; + out1[7] = x56; +} + +/// The function fiat_p256_scalar_set_one returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_set_one(out1: &mut fiat_p256_scalar_montgomery_domain_field_element) -> () { + out1[0] = 0x39cdaaf; + out1[1] = 0xc46353d; + out1[2] = 0x58e8617b; + out1[3] = 0x43190552; + out1[4] = (0x0 as u32); + out1[5] = (0x0 as u32); + out1[6] = 0xffffffff; + out1[7] = (0x0 as u32); +} + +/// The function fiat_p256_scalar_msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_p256_scalar_msat(out1: &mut [u32; 9]) -> () { + out1[0] = 0xfc632551; + out1[1] = 0xf3b9cac2; + out1[2] = 0xa7179e84; + out1[3] = 0xbce6faad; + out1[4] = 0xffffffff; + out1[5] = 0xffffffff; + out1[6] = (0x0 as u32); + out1[7] = 0xffffffff; + out1[8] = (0x0 as u32); +} + +/// The function fiat_p256_scalar_divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_p256_scalar_divstep(out1: &mut u32, out2: &mut [u32; 9], out3: &mut [u32; 9], out4: &mut [u32; 8], out5: &mut [u32; 8], arg1: u32, arg2: &[u32; 9], arg3: &[u32; 9], arg4: &[u32; 8], arg5: &[u32; 8]) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x1, &mut x2, 0x0, (!arg1), (0x1 as u32)); + let x3: fiat_p256_scalar_u1 = (((x1 >> 31) as fiat_p256_scalar_u1) & (((arg3[0]) & (0x1 as u32)) as fiat_p256_scalar_u1)); + let mut x4: u32 = 0; + let mut x5: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x4, &mut x5, 0x0, (!arg1), (0x1 as u32)); + let mut x6: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x6, x3, arg1, x4); + let mut x7: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x7, x3, (arg2[0]), (arg3[0])); + let mut x8: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x8, x3, (arg2[1]), (arg3[1])); + let mut x9: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x9, x3, (arg2[2]), (arg3[2])); + let mut x10: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x10, x3, (arg2[3]), (arg3[3])); + let mut x11: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x11, x3, (arg2[4]), (arg3[4])); + let mut x12: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x12, x3, (arg2[5]), (arg3[5])); + let mut x13: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x13, x3, (arg2[6]), (arg3[6])); + let mut x14: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x14, x3, (arg2[7]), (arg3[7])); + let mut x15: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x15, x3, (arg2[8]), (arg3[8])); + let mut x16: u32 = 0; + let mut x17: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x16, &mut x17, 0x0, (0x1 as u32), (!(arg2[0]))); + let mut x18: u32 = 0; + let mut x19: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x18, &mut x19, x17, (0x0 as u32), (!(arg2[1]))); + let mut x20: u32 = 0; + let mut x21: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x20, &mut x21, x19, (0x0 as u32), (!(arg2[2]))); + let mut x22: u32 = 0; + let mut x23: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x22, &mut x23, x21, (0x0 as u32), (!(arg2[3]))); + let mut x24: u32 = 0; + let mut x25: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x24, &mut x25, x23, (0x0 as u32), (!(arg2[4]))); + let mut x26: u32 = 0; + let mut x27: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x26, &mut x27, x25, (0x0 as u32), (!(arg2[5]))); + let mut x28: u32 = 0; + let mut x29: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x28, &mut x29, x27, (0x0 as u32), (!(arg2[6]))); + let mut x30: u32 = 0; + let mut x31: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x30, &mut x31, x29, (0x0 as u32), (!(arg2[7]))); + let mut x32: u32 = 0; + let mut x33: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x32, &mut x33, x31, (0x0 as u32), (!(arg2[8]))); + let mut x34: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x34, x3, (arg3[0]), x16); + let mut x35: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x35, x3, (arg3[1]), x18); + let mut x36: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x36, x3, (arg3[2]), x20); + let mut x37: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x37, x3, (arg3[3]), x22); + let mut x38: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x38, x3, (arg3[4]), x24); + let mut x39: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x39, x3, (arg3[5]), x26); + let mut x40: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x40, x3, (arg3[6]), x28); + let mut x41: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x41, x3, (arg3[7]), x30); + let mut x42: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x42, x3, (arg3[8]), x32); + let mut x43: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x43, x3, (arg4[0]), (arg5[0])); + let mut x44: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x44, x3, (arg4[1]), (arg5[1])); + let mut x45: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x45, x3, (arg4[2]), (arg5[2])); + let mut x46: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x46, x3, (arg4[3]), (arg5[3])); + let mut x47: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x47, x3, (arg4[4]), (arg5[4])); + let mut x48: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x48, x3, (arg4[5]), (arg5[5])); + let mut x49: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x49, x3, (arg4[6]), (arg5[6])); + let mut x50: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x50, x3, (arg4[7]), (arg5[7])); + let mut x51: u32 = 0; + let mut x52: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x51, &mut x52, 0x0, x43, x43); + let mut x53: u32 = 0; + let mut x54: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x53, &mut x54, x52, x44, x44); + let mut x55: u32 = 0; + let mut x56: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x55, &mut x56, x54, x45, x45); + let mut x57: u32 = 0; + let mut x58: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x57, &mut x58, x56, x46, x46); + let mut x59: u32 = 0; + let mut x60: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x59, &mut x60, x58, x47, x47); + let mut x61: u32 = 0; + let mut x62: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x61, &mut x62, x60, x48, x48); + let mut x63: u32 = 0; + let mut x64: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x63, &mut x64, x62, x49, x49); + let mut x65: u32 = 0; + let mut x66: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x65, &mut x66, x64, x50, x50); + let mut x67: u32 = 0; + let mut x68: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x67, &mut x68, 0x0, x51, 0xfc632551); + let mut x69: u32 = 0; + let mut x70: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x69, &mut x70, x68, x53, 0xf3b9cac2); + let mut x71: u32 = 0; + let mut x72: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x71, &mut x72, x70, x55, 0xa7179e84); + let mut x73: u32 = 0; + let mut x74: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x73, &mut x74, x72, x57, 0xbce6faad); + let mut x75: u32 = 0; + let mut x76: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x75, &mut x76, x74, x59, 0xffffffff); + let mut x77: u32 = 0; + let mut x78: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x77, &mut x78, x76, x61, 0xffffffff); + let mut x79: u32 = 0; + let mut x80: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x79, &mut x80, x78, x63, (0x0 as u32)); + let mut x81: u32 = 0; + let mut x82: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x81, &mut x82, x80, x65, 0xffffffff); + let mut x83: u32 = 0; + let mut x84: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x83, &mut x84, x82, (x66 as u32), (0x0 as u32)); + let x85: u32 = (arg4[7]); + let x86: u32 = (arg4[6]); + let x87: u32 = (arg4[5]); + let x88: u32 = (arg4[4]); + let x89: u32 = (arg4[3]); + let x90: u32 = (arg4[2]); + let x91: u32 = (arg4[1]); + let x92: u32 = (arg4[0]); + let mut x93: u32 = 0; + let mut x94: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x93, &mut x94, 0x0, (0x0 as u32), x92); + let mut x95: u32 = 0; + let mut x96: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x95, &mut x96, x94, (0x0 as u32), x91); + let mut x97: u32 = 0; + let mut x98: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x97, &mut x98, x96, (0x0 as u32), x90); + let mut x99: u32 = 0; + let mut x100: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x99, &mut x100, x98, (0x0 as u32), x89); + let mut x101: u32 = 0; + let mut x102: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x101, &mut x102, x100, (0x0 as u32), x88); + let mut x103: u32 = 0; + let mut x104: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x103, &mut x104, x102, (0x0 as u32), x87); + let mut x105: u32 = 0; + let mut x106: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x105, &mut x106, x104, (0x0 as u32), x86); + let mut x107: u32 = 0; + let mut x108: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x107, &mut x108, x106, (0x0 as u32), x85); + let mut x109: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x109, x108, (0x0 as u32), 0xffffffff); + let mut x110: u32 = 0; + let mut x111: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x110, &mut x111, 0x0, x93, (x109 & 0xfc632551)); + let mut x112: u32 = 0; + let mut x113: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x112, &mut x113, x111, x95, (x109 & 0xf3b9cac2)); + let mut x114: u32 = 0; + let mut x115: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x114, &mut x115, x113, x97, (x109 & 0xa7179e84)); + let mut x116: u32 = 0; + let mut x117: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x116, &mut x117, x115, x99, (x109 & 0xbce6faad)); + let mut x118: u32 = 0; + let mut x119: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x118, &mut x119, x117, x101, x109); + let mut x120: u32 = 0; + let mut x121: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x120, &mut x121, x119, x103, x109); + let mut x122: u32 = 0; + let mut x123: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x122, &mut x123, x121, x105, (0x0 as u32)); + let mut x124: u32 = 0; + let mut x125: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x107, x109); + let mut x126: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x126, x3, (arg5[0]), x110); + let mut x127: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x127, x3, (arg5[1]), x112); + let mut x128: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x128, x3, (arg5[2]), x114); + let mut x129: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x129, x3, (arg5[3]), x116); + let mut x130: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x130, x3, (arg5[4]), x118); + let mut x131: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x131, x3, (arg5[5]), x120); + let mut x132: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x132, x3, (arg5[6]), x122); + let mut x133: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x133, x3, (arg5[7]), x124); + let x134: fiat_p256_scalar_u1 = ((x34 & (0x1 as u32)) as fiat_p256_scalar_u1); + let mut x135: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x135, x134, (0x0 as u32), x7); + let mut x136: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x136, x134, (0x0 as u32), x8); + let mut x137: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x137, x134, (0x0 as u32), x9); + let mut x138: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x138, x134, (0x0 as u32), x10); + let mut x139: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x139, x134, (0x0 as u32), x11); + let mut x140: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x140, x134, (0x0 as u32), x12); + let mut x141: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x141, x134, (0x0 as u32), x13); + let mut x142: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x142, x134, (0x0 as u32), x14); + let mut x143: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x143, x134, (0x0 as u32), x15); + let mut x144: u32 = 0; + let mut x145: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x144, &mut x145, 0x0, x34, x135); + let mut x146: u32 = 0; + let mut x147: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x146, &mut x147, x145, x35, x136); + let mut x148: u32 = 0; + let mut x149: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x148, &mut x149, x147, x36, x137); + let mut x150: u32 = 0; + let mut x151: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x150, &mut x151, x149, x37, x138); + let mut x152: u32 = 0; + let mut x153: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x152, &mut x153, x151, x38, x139); + let mut x154: u32 = 0; + let mut x155: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x154, &mut x155, x153, x39, x140); + let mut x156: u32 = 0; + let mut x157: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x156, &mut x157, x155, x40, x141); + let mut x158: u32 = 0; + let mut x159: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x158, &mut x159, x157, x41, x142); + let mut x160: u32 = 0; + let mut x161: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x42, x143); + let mut x162: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x162, x134, (0x0 as u32), x43); + let mut x163: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x163, x134, (0x0 as u32), x44); + let mut x164: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x164, x134, (0x0 as u32), x45); + let mut x165: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x165, x134, (0x0 as u32), x46); + let mut x166: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x166, x134, (0x0 as u32), x47); + let mut x167: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x167, x134, (0x0 as u32), x48); + let mut x168: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x168, x134, (0x0 as u32), x49); + let mut x169: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x169, x134, (0x0 as u32), x50); + let mut x170: u32 = 0; + let mut x171: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x170, &mut x171, 0x0, x126, x162); + let mut x172: u32 = 0; + let mut x173: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x172, &mut x173, x171, x127, x163); + let mut x174: u32 = 0; + let mut x175: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x174, &mut x175, x173, x128, x164); + let mut x176: u32 = 0; + let mut x177: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x176, &mut x177, x175, x129, x165); + let mut x178: u32 = 0; + let mut x179: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x178, &mut x179, x177, x130, x166); + let mut x180: u32 = 0; + let mut x181: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x180, &mut x181, x179, x131, x167); + let mut x182: u32 = 0; + let mut x183: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x182, &mut x183, x181, x132, x168); + let mut x184: u32 = 0; + let mut x185: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x184, &mut x185, x183, x133, x169); + let mut x186: u32 = 0; + let mut x187: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x186, &mut x187, 0x0, x170, 0xfc632551); + let mut x188: u32 = 0; + let mut x189: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x188, &mut x189, x187, x172, 0xf3b9cac2); + let mut x190: u32 = 0; + let mut x191: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x190, &mut x191, x189, x174, 0xa7179e84); + let mut x192: u32 = 0; + let mut x193: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x192, &mut x193, x191, x176, 0xbce6faad); + let mut x194: u32 = 0; + let mut x195: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x194, &mut x195, x193, x178, 0xffffffff); + let mut x196: u32 = 0; + let mut x197: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x196, &mut x197, x195, x180, 0xffffffff); + let mut x198: u32 = 0; + let mut x199: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x198, &mut x199, x197, x182, (0x0 as u32)); + let mut x200: u32 = 0; + let mut x201: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x200, &mut x201, x199, x184, 0xffffffff); + let mut x202: u32 = 0; + let mut x203: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u32(&mut x202, &mut x203, x201, (x185 as u32), (0x0 as u32)); + let mut x204: u32 = 0; + let mut x205: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u32(&mut x204, &mut x205, 0x0, x6, (0x1 as u32)); + let x206: u32 = ((x144 >> 1) | ((x146 << 31) & 0xffffffff)); + let x207: u32 = ((x146 >> 1) | ((x148 << 31) & 0xffffffff)); + let x208: u32 = ((x148 >> 1) | ((x150 << 31) & 0xffffffff)); + let x209: u32 = ((x150 >> 1) | ((x152 << 31) & 0xffffffff)); + let x210: u32 = ((x152 >> 1) | ((x154 << 31) & 0xffffffff)); + let x211: u32 = ((x154 >> 1) | ((x156 << 31) & 0xffffffff)); + let x212: u32 = ((x156 >> 1) | ((x158 << 31) & 0xffffffff)); + let x213: u32 = ((x158 >> 1) | ((x160 << 31) & 0xffffffff)); + let x214: u32 = ((x160 & 0x80000000) | (x160 >> 1)); + let mut x215: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x215, x84, x67, x51); + let mut x216: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x216, x84, x69, x53); + let mut x217: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x217, x84, x71, x55); + let mut x218: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x218, x84, x73, x57); + let mut x219: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x219, x84, x75, x59); + let mut x220: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x220, x84, x77, x61); + let mut x221: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x221, x84, x79, x63); + let mut x222: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x222, x84, x81, x65); + let mut x223: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x223, x203, x186, x170); + let mut x224: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x224, x203, x188, x172); + let mut x225: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x225, x203, x190, x174); + let mut x226: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x226, x203, x192, x176); + let mut x227: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x227, x203, x194, x178); + let mut x228: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x228, x203, x196, x180); + let mut x229: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x229, x203, x198, x182); + let mut x230: u32 = 0; + fiat_p256_scalar_cmovznz_u32(&mut x230, x203, x200, x184); + *out1 = x204; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out2[7] = x14; + out2[8] = x15; + out3[0] = x206; + out3[1] = x207; + out3[2] = x208; + out3[3] = x209; + out3[4] = x210; + out3[5] = x211; + out3[6] = x212; + out3[7] = x213; + out3[8] = x214; + out4[0] = x215; + out4[1] = x216; + out4[2] = x217; + out4[3] = x218; + out4[4] = x219; + out4[5] = x220; + out4[6] = x221; + out4[7] = x222; + out5[0] = x223; + out5[1] = x224; + out5[2] = x225; + out5[3] = x226; + out5[4] = x227; + out5[5] = x228; + out5[6] = x229; + out5[7] = x230; +} + +/// The function fiat_p256_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_p256_scalar_divstep_precomp(out1: &mut [u32; 8]) -> () { + out1[0] = 0xb7fcfbb5; + out1[1] = 0xd739262f; + out1[2] = 0x20074414; + out1[3] = 0x8ac6f75d; + out1[4] = 0xb5e3c256; + out1[5] = 0xc67428bf; + out1[6] = 0xeda7aedf; + out1[7] = 0x444962f2; +} diff --git a/fiat-rust/src/p256_scalar_64.rs b/fiat-rust/src/p256_scalar_64.rs new file mode 100644 index 0000000000..3467605c99 --- /dev/null +++ b/fiat-rust/src/p256_scalar_64.rs @@ -0,0 +1,1997 @@ +//! Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline p256_scalar 64 '2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +//! curve description: p256_scalar +//! machine_wordsize = 64 (from "64") +//! requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +//! m = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 (from "2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247") +//! +//! NOTE: In addition to the bounds specified above each function, all +//! functions synthesized for this Montgomery arithmetic require the +//! input to be strictly less than the prime modulus (m), and also +//! require the input to be in the unique saturated representation. +//! All functions also ensure that these two properties are true of +//! return values. +//! +//! Computed values: +//! eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) +//! bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +//! twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in +//! if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 + +#![allow(unused_parens)] +#![allow(non_camel_case_types)] + +pub type fiat_p256_scalar_u1 = u8; +pub type fiat_p256_scalar_i1 = i8; +pub type fiat_p256_scalar_u2 = u8; +pub type fiat_p256_scalar_i2 = i8; + +/* The type fiat_p256_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +pub type fiat_p256_scalar_montgomery_domain_field_element = [u64; 4]; + +/* The type fiat_p256_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +pub type fiat_p256_scalar_non_montgomery_domain_field_element = [u64; 4]; + + +/// The function fiat_p256_scalar_addcarryx_u64 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^64 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_p256_scalar_addcarryx_u64(out1: &mut u64, out2: &mut fiat_p256_scalar_u1, arg1: fiat_p256_scalar_u1, arg2: u64, arg3: u64) -> () { + let x1: u128 = (((arg1 as u128) + (arg2 as u128)) + (arg3 as u128)); + let x2: u64 = ((x1 & (0xffffffffffffffff as u128)) as u64); + let x3: fiat_p256_scalar_u1 = ((x1 >> 64) as fiat_p256_scalar_u1); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_p256_scalar_subborrowx_u64 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^64 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_p256_scalar_subborrowx_u64(out1: &mut u64, out2: &mut fiat_p256_scalar_u1, arg1: fiat_p256_scalar_u1, arg2: u64, arg3: u64) -> () { + let x1: i128 = (((arg2 as i128) - (arg1 as i128)) - (arg3 as i128)); + let x2: fiat_p256_scalar_i1 = ((x1 >> 64) as fiat_p256_scalar_i1); + let x3: u64 = ((x1 & (0xffffffffffffffff as i128)) as u64); + *out1 = x3; + *out2 = (((0x0 as fiat_p256_scalar_i2) - (x2 as fiat_p256_scalar_i2)) as fiat_p256_scalar_u1); +} + +/// The function fiat_p256_scalar_mulx_u64 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^64 +/// out2 = ⌊arg1 * arg2 / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0xffffffffffffffff] +#[inline] +pub fn fiat_p256_scalar_mulx_u64(out1: &mut u64, out2: &mut u64, arg1: u64, arg2: u64) -> () { + let x1: u128 = ((arg1 as u128) * (arg2 as u128)); + let x2: u64 = ((x1 & (0xffffffffffffffff as u128)) as u64); + let x3: u64 = ((x1 >> 64) as u64); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_p256_scalar_cmovznz_u64 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +#[inline] +pub fn fiat_p256_scalar_cmovznz_u64(out1: &mut u64, arg1: fiat_p256_scalar_u1, arg2: u64, arg3: u64) -> () { + let x1: fiat_p256_scalar_u1 = (!(!arg1)); + let x2: u64 = ((((((0x0 as fiat_p256_scalar_i2) - (x1 as fiat_p256_scalar_i2)) as fiat_p256_scalar_i1) as i128) & (0xffffffffffffffff as i128)) as u64); + let x3: u64 = ((x2 & arg3) | ((!x2) & arg2)); + *out1 = x3; +} + +/// The function fiat_p256_scalar_mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_mul(out1: &mut fiat_p256_scalar_montgomery_domain_field_element, arg1: &fiat_p256_scalar_montgomery_domain_field_element, arg2: &fiat_p256_scalar_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[1]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[0]); + let mut x5: u64 = 0; + let mut x6: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x5, &mut x6, x4, (arg2[3])); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x7, &mut x8, x4, (arg2[2])); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x9, &mut x10, x4, (arg2[1])); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x11, &mut x12, x4, (arg2[0])); + let mut x13: u64 = 0; + let mut x14: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x17, &mut x18, x16, x8, x5); + let x19: u64 = ((x18 as u64) + x6); + let mut x20: u64 = 0; + let mut x21: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x20, &mut x21, x11, 0xccd1c8aaee00bc4f); + let mut x22: u64 = 0; + let mut x23: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x22, &mut x23, x20, 0xffffffff00000000); + let mut x24: u64 = 0; + let mut x25: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x24, &mut x25, x20, 0xffffffffffffffff); + let mut x26: u64 = 0; + let mut x27: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x26, &mut x27, x20, 0xbce6faada7179e84); + let mut x28: u64 = 0; + let mut x29: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x28, &mut x29, x20, 0xf3b9cac2fc632551); + let mut x30: u64 = 0; + let mut x31: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x30, &mut x31, 0x0, x29, x26); + let mut x32: u64 = 0; + let mut x33: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x32, &mut x33, x31, x27, x24); + let mut x34: u64 = 0; + let mut x35: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x34, &mut x35, x33, x25, x22); + let x36: u64 = ((x35 as u64) + x23); + let mut x37: u64 = 0; + let mut x38: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x37, &mut x38, 0x0, x11, x28); + let mut x39: u64 = 0; + let mut x40: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x39, &mut x40, x38, x13, x30); + let mut x41: u64 = 0; + let mut x42: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x41, &mut x42, x40, x15, x32); + let mut x43: u64 = 0; + let mut x44: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x43, &mut x44, x42, x17, x34); + let mut x45: u64 = 0; + let mut x46: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x45, &mut x46, x44, x19, x36); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x47, &mut x48, x1, (arg2[3])); + let mut x49: u64 = 0; + let mut x50: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x49, &mut x50, x1, (arg2[2])); + let mut x51: u64 = 0; + let mut x52: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x51, &mut x52, x1, (arg2[1])); + let mut x53: u64 = 0; + let mut x54: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x53, &mut x54, x1, (arg2[0])); + let mut x55: u64 = 0; + let mut x56: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x55, &mut x56, 0x0, x54, x51); + let mut x57: u64 = 0; + let mut x58: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x57, &mut x58, x56, x52, x49); + let mut x59: u64 = 0; + let mut x60: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x59, &mut x60, x58, x50, x47); + let x61: u64 = ((x60 as u64) + x48); + let mut x62: u64 = 0; + let mut x63: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x62, &mut x63, 0x0, x39, x53); + let mut x64: u64 = 0; + let mut x65: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x64, &mut x65, x63, x41, x55); + let mut x66: u64 = 0; + let mut x67: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x66, &mut x67, x65, x43, x57); + let mut x68: u64 = 0; + let mut x69: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x68, &mut x69, x67, x45, x59); + let mut x70: u64 = 0; + let mut x71: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x70, &mut x71, x69, (x46 as u64), x61); + let mut x72: u64 = 0; + let mut x73: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x72, &mut x73, x62, 0xccd1c8aaee00bc4f); + let mut x74: u64 = 0; + let mut x75: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x74, &mut x75, x72, 0xffffffff00000000); + let mut x76: u64 = 0; + let mut x77: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x76, &mut x77, x72, 0xffffffffffffffff); + let mut x78: u64 = 0; + let mut x79: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x78, &mut x79, x72, 0xbce6faada7179e84); + let mut x80: u64 = 0; + let mut x81: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x80, &mut x81, x72, 0xf3b9cac2fc632551); + let mut x82: u64 = 0; + let mut x83: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x82, &mut x83, 0x0, x81, x78); + let mut x84: u64 = 0; + let mut x85: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x84, &mut x85, x83, x79, x76); + let mut x86: u64 = 0; + let mut x87: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x86, &mut x87, x85, x77, x74); + let x88: u64 = ((x87 as u64) + x75); + let mut x89: u64 = 0; + let mut x90: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x89, &mut x90, 0x0, x62, x80); + let mut x91: u64 = 0; + let mut x92: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x91, &mut x92, x90, x64, x82); + let mut x93: u64 = 0; + let mut x94: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x93, &mut x94, x92, x66, x84); + let mut x95: u64 = 0; + let mut x96: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x95, &mut x96, x94, x68, x86); + let mut x97: u64 = 0; + let mut x98: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x97, &mut x98, x96, x70, x88); + let x99: u64 = ((x98 as u64) + (x71 as u64)); + let mut x100: u64 = 0; + let mut x101: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x100, &mut x101, x2, (arg2[3])); + let mut x102: u64 = 0; + let mut x103: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x102, &mut x103, x2, (arg2[2])); + let mut x104: u64 = 0; + let mut x105: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x104, &mut x105, x2, (arg2[1])); + let mut x106: u64 = 0; + let mut x107: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x106, &mut x107, x2, (arg2[0])); + let mut x108: u64 = 0; + let mut x109: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x108, &mut x109, 0x0, x107, x104); + let mut x110: u64 = 0; + let mut x111: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x110, &mut x111, x109, x105, x102); + let mut x112: u64 = 0; + let mut x113: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x112, &mut x113, x111, x103, x100); + let x114: u64 = ((x113 as u64) + x101); + let mut x115: u64 = 0; + let mut x116: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x115, &mut x116, 0x0, x91, x106); + let mut x117: u64 = 0; + let mut x118: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x117, &mut x118, x116, x93, x108); + let mut x119: u64 = 0; + let mut x120: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x119, &mut x120, x118, x95, x110); + let mut x121: u64 = 0; + let mut x122: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x121, &mut x122, x120, x97, x112); + let mut x123: u64 = 0; + let mut x124: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x123, &mut x124, x122, x99, x114); + let mut x125: u64 = 0; + let mut x126: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x125, &mut x126, x115, 0xccd1c8aaee00bc4f); + let mut x127: u64 = 0; + let mut x128: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x127, &mut x128, x125, 0xffffffff00000000); + let mut x129: u64 = 0; + let mut x130: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x129, &mut x130, x125, 0xffffffffffffffff); + let mut x131: u64 = 0; + let mut x132: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x131, &mut x132, x125, 0xbce6faada7179e84); + let mut x133: u64 = 0; + let mut x134: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x133, &mut x134, x125, 0xf3b9cac2fc632551); + let mut x135: u64 = 0; + let mut x136: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x135, &mut x136, 0x0, x134, x131); + let mut x137: u64 = 0; + let mut x138: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x137, &mut x138, x136, x132, x129); + let mut x139: u64 = 0; + let mut x140: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x139, &mut x140, x138, x130, x127); + let x141: u64 = ((x140 as u64) + x128); + let mut x142: u64 = 0; + let mut x143: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x142, &mut x143, 0x0, x115, x133); + let mut x144: u64 = 0; + let mut x145: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x144, &mut x145, x143, x117, x135); + let mut x146: u64 = 0; + let mut x147: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x146, &mut x147, x145, x119, x137); + let mut x148: u64 = 0; + let mut x149: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x148, &mut x149, x147, x121, x139); + let mut x150: u64 = 0; + let mut x151: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x150, &mut x151, x149, x123, x141); + let x152: u64 = ((x151 as u64) + (x124 as u64)); + let mut x153: u64 = 0; + let mut x154: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x153, &mut x154, x3, (arg2[3])); + let mut x155: u64 = 0; + let mut x156: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x155, &mut x156, x3, (arg2[2])); + let mut x157: u64 = 0; + let mut x158: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x157, &mut x158, x3, (arg2[1])); + let mut x159: u64 = 0; + let mut x160: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x159, &mut x160, x3, (arg2[0])); + let mut x161: u64 = 0; + let mut x162: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x161, &mut x162, 0x0, x160, x157); + let mut x163: u64 = 0; + let mut x164: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x163, &mut x164, x162, x158, x155); + let mut x165: u64 = 0; + let mut x166: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x165, &mut x166, x164, x156, x153); + let x167: u64 = ((x166 as u64) + x154); + let mut x168: u64 = 0; + let mut x169: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x168, &mut x169, 0x0, x144, x159); + let mut x170: u64 = 0; + let mut x171: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x170, &mut x171, x169, x146, x161); + let mut x172: u64 = 0; + let mut x173: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x172, &mut x173, x171, x148, x163); + let mut x174: u64 = 0; + let mut x175: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x174, &mut x175, x173, x150, x165); + let mut x176: u64 = 0; + let mut x177: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x176, &mut x177, x175, x152, x167); + let mut x178: u64 = 0; + let mut x179: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x178, &mut x179, x168, 0xccd1c8aaee00bc4f); + let mut x180: u64 = 0; + let mut x181: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x180, &mut x181, x178, 0xffffffff00000000); + let mut x182: u64 = 0; + let mut x183: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x182, &mut x183, x178, 0xffffffffffffffff); + let mut x184: u64 = 0; + let mut x185: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x184, &mut x185, x178, 0xbce6faada7179e84); + let mut x186: u64 = 0; + let mut x187: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x186, &mut x187, x178, 0xf3b9cac2fc632551); + let mut x188: u64 = 0; + let mut x189: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x188, &mut x189, 0x0, x187, x184); + let mut x190: u64 = 0; + let mut x191: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x190, &mut x191, x189, x185, x182); + let mut x192: u64 = 0; + let mut x193: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x192, &mut x193, x191, x183, x180); + let x194: u64 = ((x193 as u64) + x181); + let mut x195: u64 = 0; + let mut x196: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x195, &mut x196, 0x0, x168, x186); + let mut x197: u64 = 0; + let mut x198: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x197, &mut x198, x196, x170, x188); + let mut x199: u64 = 0; + let mut x200: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x199, &mut x200, x198, x172, x190); + let mut x201: u64 = 0; + let mut x202: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x201, &mut x202, x200, x174, x192); + let mut x203: u64 = 0; + let mut x204: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x203, &mut x204, x202, x176, x194); + let x205: u64 = ((x204 as u64) + (x177 as u64)); + let mut x206: u64 = 0; + let mut x207: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x206, &mut x207, 0x0, x197, 0xf3b9cac2fc632551); + let mut x208: u64 = 0; + let mut x209: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x208, &mut x209, x207, x199, 0xbce6faada7179e84); + let mut x210: u64 = 0; + let mut x211: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x210, &mut x211, x209, x201, 0xffffffffffffffff); + let mut x212: u64 = 0; + let mut x213: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x212, &mut x213, x211, x203, 0xffffffff00000000); + let mut x214: u64 = 0; + let mut x215: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x214, &mut x215, x213, x205, (0x0 as u64)); + let mut x216: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x216, x215, x206, x197); + let mut x217: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x217, x215, x208, x199); + let mut x218: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x218, x215, x210, x201); + let mut x219: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/// The function fiat_p256_scalar_square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_square(out1: &mut fiat_p256_scalar_montgomery_domain_field_element, arg1: &fiat_p256_scalar_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[1]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[0]); + let mut x5: u64 = 0; + let mut x6: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x5, &mut x6, x4, (arg1[3])); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x7, &mut x8, x4, (arg1[2])); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x9, &mut x10, x4, (arg1[1])); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x11, &mut x12, x4, (arg1[0])); + let mut x13: u64 = 0; + let mut x14: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x17, &mut x18, x16, x8, x5); + let x19: u64 = ((x18 as u64) + x6); + let mut x20: u64 = 0; + let mut x21: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x20, &mut x21, x11, 0xccd1c8aaee00bc4f); + let mut x22: u64 = 0; + let mut x23: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x22, &mut x23, x20, 0xffffffff00000000); + let mut x24: u64 = 0; + let mut x25: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x24, &mut x25, x20, 0xffffffffffffffff); + let mut x26: u64 = 0; + let mut x27: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x26, &mut x27, x20, 0xbce6faada7179e84); + let mut x28: u64 = 0; + let mut x29: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x28, &mut x29, x20, 0xf3b9cac2fc632551); + let mut x30: u64 = 0; + let mut x31: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x30, &mut x31, 0x0, x29, x26); + let mut x32: u64 = 0; + let mut x33: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x32, &mut x33, x31, x27, x24); + let mut x34: u64 = 0; + let mut x35: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x34, &mut x35, x33, x25, x22); + let x36: u64 = ((x35 as u64) + x23); + let mut x37: u64 = 0; + let mut x38: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x37, &mut x38, 0x0, x11, x28); + let mut x39: u64 = 0; + let mut x40: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x39, &mut x40, x38, x13, x30); + let mut x41: u64 = 0; + let mut x42: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x41, &mut x42, x40, x15, x32); + let mut x43: u64 = 0; + let mut x44: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x43, &mut x44, x42, x17, x34); + let mut x45: u64 = 0; + let mut x46: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x45, &mut x46, x44, x19, x36); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x47, &mut x48, x1, (arg1[3])); + let mut x49: u64 = 0; + let mut x50: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x49, &mut x50, x1, (arg1[2])); + let mut x51: u64 = 0; + let mut x52: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x51, &mut x52, x1, (arg1[1])); + let mut x53: u64 = 0; + let mut x54: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x53, &mut x54, x1, (arg1[0])); + let mut x55: u64 = 0; + let mut x56: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x55, &mut x56, 0x0, x54, x51); + let mut x57: u64 = 0; + let mut x58: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x57, &mut x58, x56, x52, x49); + let mut x59: u64 = 0; + let mut x60: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x59, &mut x60, x58, x50, x47); + let x61: u64 = ((x60 as u64) + x48); + let mut x62: u64 = 0; + let mut x63: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x62, &mut x63, 0x0, x39, x53); + let mut x64: u64 = 0; + let mut x65: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x64, &mut x65, x63, x41, x55); + let mut x66: u64 = 0; + let mut x67: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x66, &mut x67, x65, x43, x57); + let mut x68: u64 = 0; + let mut x69: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x68, &mut x69, x67, x45, x59); + let mut x70: u64 = 0; + let mut x71: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x70, &mut x71, x69, (x46 as u64), x61); + let mut x72: u64 = 0; + let mut x73: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x72, &mut x73, x62, 0xccd1c8aaee00bc4f); + let mut x74: u64 = 0; + let mut x75: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x74, &mut x75, x72, 0xffffffff00000000); + let mut x76: u64 = 0; + let mut x77: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x76, &mut x77, x72, 0xffffffffffffffff); + let mut x78: u64 = 0; + let mut x79: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x78, &mut x79, x72, 0xbce6faada7179e84); + let mut x80: u64 = 0; + let mut x81: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x80, &mut x81, x72, 0xf3b9cac2fc632551); + let mut x82: u64 = 0; + let mut x83: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x82, &mut x83, 0x0, x81, x78); + let mut x84: u64 = 0; + let mut x85: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x84, &mut x85, x83, x79, x76); + let mut x86: u64 = 0; + let mut x87: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x86, &mut x87, x85, x77, x74); + let x88: u64 = ((x87 as u64) + x75); + let mut x89: u64 = 0; + let mut x90: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x89, &mut x90, 0x0, x62, x80); + let mut x91: u64 = 0; + let mut x92: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x91, &mut x92, x90, x64, x82); + let mut x93: u64 = 0; + let mut x94: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x93, &mut x94, x92, x66, x84); + let mut x95: u64 = 0; + let mut x96: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x95, &mut x96, x94, x68, x86); + let mut x97: u64 = 0; + let mut x98: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x97, &mut x98, x96, x70, x88); + let x99: u64 = ((x98 as u64) + (x71 as u64)); + let mut x100: u64 = 0; + let mut x101: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x100, &mut x101, x2, (arg1[3])); + let mut x102: u64 = 0; + let mut x103: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x102, &mut x103, x2, (arg1[2])); + let mut x104: u64 = 0; + let mut x105: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x104, &mut x105, x2, (arg1[1])); + let mut x106: u64 = 0; + let mut x107: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x106, &mut x107, x2, (arg1[0])); + let mut x108: u64 = 0; + let mut x109: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x108, &mut x109, 0x0, x107, x104); + let mut x110: u64 = 0; + let mut x111: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x110, &mut x111, x109, x105, x102); + let mut x112: u64 = 0; + let mut x113: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x112, &mut x113, x111, x103, x100); + let x114: u64 = ((x113 as u64) + x101); + let mut x115: u64 = 0; + let mut x116: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x115, &mut x116, 0x0, x91, x106); + let mut x117: u64 = 0; + let mut x118: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x117, &mut x118, x116, x93, x108); + let mut x119: u64 = 0; + let mut x120: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x119, &mut x120, x118, x95, x110); + let mut x121: u64 = 0; + let mut x122: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x121, &mut x122, x120, x97, x112); + let mut x123: u64 = 0; + let mut x124: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x123, &mut x124, x122, x99, x114); + let mut x125: u64 = 0; + let mut x126: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x125, &mut x126, x115, 0xccd1c8aaee00bc4f); + let mut x127: u64 = 0; + let mut x128: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x127, &mut x128, x125, 0xffffffff00000000); + let mut x129: u64 = 0; + let mut x130: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x129, &mut x130, x125, 0xffffffffffffffff); + let mut x131: u64 = 0; + let mut x132: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x131, &mut x132, x125, 0xbce6faada7179e84); + let mut x133: u64 = 0; + let mut x134: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x133, &mut x134, x125, 0xf3b9cac2fc632551); + let mut x135: u64 = 0; + let mut x136: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x135, &mut x136, 0x0, x134, x131); + let mut x137: u64 = 0; + let mut x138: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x137, &mut x138, x136, x132, x129); + let mut x139: u64 = 0; + let mut x140: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x139, &mut x140, x138, x130, x127); + let x141: u64 = ((x140 as u64) + x128); + let mut x142: u64 = 0; + let mut x143: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x142, &mut x143, 0x0, x115, x133); + let mut x144: u64 = 0; + let mut x145: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x144, &mut x145, x143, x117, x135); + let mut x146: u64 = 0; + let mut x147: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x146, &mut x147, x145, x119, x137); + let mut x148: u64 = 0; + let mut x149: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x148, &mut x149, x147, x121, x139); + let mut x150: u64 = 0; + let mut x151: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x150, &mut x151, x149, x123, x141); + let x152: u64 = ((x151 as u64) + (x124 as u64)); + let mut x153: u64 = 0; + let mut x154: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x153, &mut x154, x3, (arg1[3])); + let mut x155: u64 = 0; + let mut x156: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x155, &mut x156, x3, (arg1[2])); + let mut x157: u64 = 0; + let mut x158: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x157, &mut x158, x3, (arg1[1])); + let mut x159: u64 = 0; + let mut x160: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x159, &mut x160, x3, (arg1[0])); + let mut x161: u64 = 0; + let mut x162: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x161, &mut x162, 0x0, x160, x157); + let mut x163: u64 = 0; + let mut x164: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x163, &mut x164, x162, x158, x155); + let mut x165: u64 = 0; + let mut x166: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x165, &mut x166, x164, x156, x153); + let x167: u64 = ((x166 as u64) + x154); + let mut x168: u64 = 0; + let mut x169: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x168, &mut x169, 0x0, x144, x159); + let mut x170: u64 = 0; + let mut x171: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x170, &mut x171, x169, x146, x161); + let mut x172: u64 = 0; + let mut x173: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x172, &mut x173, x171, x148, x163); + let mut x174: u64 = 0; + let mut x175: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x174, &mut x175, x173, x150, x165); + let mut x176: u64 = 0; + let mut x177: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x176, &mut x177, x175, x152, x167); + let mut x178: u64 = 0; + let mut x179: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x178, &mut x179, x168, 0xccd1c8aaee00bc4f); + let mut x180: u64 = 0; + let mut x181: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x180, &mut x181, x178, 0xffffffff00000000); + let mut x182: u64 = 0; + let mut x183: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x182, &mut x183, x178, 0xffffffffffffffff); + let mut x184: u64 = 0; + let mut x185: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x184, &mut x185, x178, 0xbce6faada7179e84); + let mut x186: u64 = 0; + let mut x187: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x186, &mut x187, x178, 0xf3b9cac2fc632551); + let mut x188: u64 = 0; + let mut x189: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x188, &mut x189, 0x0, x187, x184); + let mut x190: u64 = 0; + let mut x191: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x190, &mut x191, x189, x185, x182); + let mut x192: u64 = 0; + let mut x193: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x192, &mut x193, x191, x183, x180); + let x194: u64 = ((x193 as u64) + x181); + let mut x195: u64 = 0; + let mut x196: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x195, &mut x196, 0x0, x168, x186); + let mut x197: u64 = 0; + let mut x198: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x197, &mut x198, x196, x170, x188); + let mut x199: u64 = 0; + let mut x200: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x199, &mut x200, x198, x172, x190); + let mut x201: u64 = 0; + let mut x202: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x201, &mut x202, x200, x174, x192); + let mut x203: u64 = 0; + let mut x204: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x203, &mut x204, x202, x176, x194); + let x205: u64 = ((x204 as u64) + (x177 as u64)); + let mut x206: u64 = 0; + let mut x207: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x206, &mut x207, 0x0, x197, 0xf3b9cac2fc632551); + let mut x208: u64 = 0; + let mut x209: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x208, &mut x209, x207, x199, 0xbce6faada7179e84); + let mut x210: u64 = 0; + let mut x211: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x210, &mut x211, x209, x201, 0xffffffffffffffff); + let mut x212: u64 = 0; + let mut x213: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x212, &mut x213, x211, x203, 0xffffffff00000000); + let mut x214: u64 = 0; + let mut x215: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x214, &mut x215, x213, x205, (0x0 as u64)); + let mut x216: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x216, x215, x206, x197); + let mut x217: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x217, x215, x208, x199); + let mut x218: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x218, x215, x210, x201); + let mut x219: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/// The function fiat_p256_scalar_add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_add(out1: &mut fiat_p256_scalar_montgomery_domain_field_element, arg1: &fiat_p256_scalar_montgomery_domain_field_element, arg2: &fiat_p256_scalar_montgomery_domain_field_element) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u64 = 0; + let mut x4: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u64 = 0; + let mut x6: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u64 = 0; + let mut x8: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u64 = 0; + let mut x10: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x9, &mut x10, 0x0, x1, 0xf3b9cac2fc632551); + let mut x11: u64 = 0; + let mut x12: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x11, &mut x12, x10, x3, 0xbce6faada7179e84); + let mut x13: u64 = 0; + let mut x14: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x13, &mut x14, x12, x5, 0xffffffffffffffff); + let mut x15: u64 = 0; + let mut x16: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x15, &mut x16, x14, x7, 0xffffffff00000000); + let mut x17: u64 = 0; + let mut x18: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x17, &mut x18, x16, (x8 as u64), (0x0 as u64)); + let mut x19: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x19, x18, x9, x1); + let mut x20: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x20, x18, x11, x3); + let mut x21: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x21, x18, x13, x5); + let mut x22: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/// The function fiat_p256_scalar_sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_sub(out1: &mut fiat_p256_scalar_montgomery_domain_field_element, arg1: &fiat_p256_scalar_montgomery_domain_field_element, arg2: &fiat_p256_scalar_montgomery_domain_field_element) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u64 = 0; + let mut x4: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u64 = 0; + let mut x6: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u64 = 0; + let mut x8: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x9, x8, (0x0 as u64), 0xffffffffffffffff); + let mut x10: u64 = 0; + let mut x11: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x10, &mut x11, 0x0, x1, (x9 & 0xf3b9cac2fc632551)); + let mut x12: u64 = 0; + let mut x13: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x12, &mut x13, x11, x3, (x9 & 0xbce6faada7179e84)); + let mut x14: u64 = 0; + let mut x15: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x14, &mut x15, x13, x5, x9); + let mut x16: u64 = 0; + let mut x17: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x7, (x9 & 0xffffffff00000000)); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fiat_p256_scalar_opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_opp(out1: &mut fiat_p256_scalar_montgomery_domain_field_element, arg1: &fiat_p256_scalar_montgomery_domain_field_element) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x1, &mut x2, 0x0, (0x0 as u64), (arg1[0])); + let mut x3: u64 = 0; + let mut x4: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x3, &mut x4, x2, (0x0 as u64), (arg1[1])); + let mut x5: u64 = 0; + let mut x6: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x5, &mut x6, x4, (0x0 as u64), (arg1[2])); + let mut x7: u64 = 0; + let mut x8: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x7, &mut x8, x6, (0x0 as u64), (arg1[3])); + let mut x9: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x9, x8, (0x0 as u64), 0xffffffffffffffff); + let mut x10: u64 = 0; + let mut x11: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x10, &mut x11, 0x0, x1, (x9 & 0xf3b9cac2fc632551)); + let mut x12: u64 = 0; + let mut x13: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x12, &mut x13, x11, x3, (x9 & 0xbce6faada7179e84)); + let mut x14: u64 = 0; + let mut x15: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x14, &mut x15, x13, x5, x9); + let mut x16: u64 = 0; + let mut x17: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x7, (x9 & 0xffffffff00000000)); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fiat_p256_scalar_from_montgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_from_montgomery(out1: &mut fiat_p256_scalar_non_montgomery_domain_field_element, arg1: &fiat_p256_scalar_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[0]); + let mut x2: u64 = 0; + let mut x3: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x2, &mut x3, x1, 0xccd1c8aaee00bc4f); + let mut x4: u64 = 0; + let mut x5: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x4, &mut x5, x2, 0xffffffff00000000); + let mut x6: u64 = 0; + let mut x7: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x6, &mut x7, x2, 0xffffffffffffffff); + let mut x8: u64 = 0; + let mut x9: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x8, &mut x9, x2, 0xbce6faada7179e84); + let mut x10: u64 = 0; + let mut x11: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x10, &mut x11, x2, 0xf3b9cac2fc632551); + let mut x12: u64 = 0; + let mut x13: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x12, &mut x13, 0x0, x11, x8); + let mut x14: u64 = 0; + let mut x15: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x14, &mut x15, x13, x9, x6); + let mut x16: u64 = 0; + let mut x17: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x7, x4); + let mut x18: u64 = 0; + let mut x19: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x18, &mut x19, 0x0, x1, x10); + let mut x20: u64 = 0; + let mut x21: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x20, &mut x21, x19, (0x0 as u64), x12); + let mut x22: u64 = 0; + let mut x23: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x22, &mut x23, x21, (0x0 as u64), x14); + let mut x24: u64 = 0; + let mut x25: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x24, &mut x25, x23, (0x0 as u64), x16); + let mut x26: u64 = 0; + let mut x27: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x26, &mut x27, 0x0, x20, (arg1[1])); + let mut x28: u64 = 0; + let mut x29: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x28, &mut x29, x27, x22, (0x0 as u64)); + let mut x30: u64 = 0; + let mut x31: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x30, &mut x31, x29, x24, (0x0 as u64)); + let mut x32: u64 = 0; + let mut x33: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x32, &mut x33, x26, 0xccd1c8aaee00bc4f); + let mut x34: u64 = 0; + let mut x35: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x34, &mut x35, x32, 0xffffffff00000000); + let mut x36: u64 = 0; + let mut x37: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x36, &mut x37, x32, 0xffffffffffffffff); + let mut x38: u64 = 0; + let mut x39: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x38, &mut x39, x32, 0xbce6faada7179e84); + let mut x40: u64 = 0; + let mut x41: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x40, &mut x41, x32, 0xf3b9cac2fc632551); + let mut x42: u64 = 0; + let mut x43: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x42, &mut x43, 0x0, x41, x38); + let mut x44: u64 = 0; + let mut x45: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x44, &mut x45, x43, x39, x36); + let mut x46: u64 = 0; + let mut x47: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x46, &mut x47, x45, x37, x34); + let mut x48: u64 = 0; + let mut x49: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x48, &mut x49, 0x0, x26, x40); + let mut x50: u64 = 0; + let mut x51: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x50, &mut x51, x49, x28, x42); + let mut x52: u64 = 0; + let mut x53: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x52, &mut x53, x51, x30, x44); + let mut x54: u64 = 0; + let mut x55: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x54, &mut x55, x53, ((x31 as u64) + ((x25 as u64) + ((x17 as u64) + x5))), x46); + let mut x56: u64 = 0; + let mut x57: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x56, &mut x57, 0x0, x50, (arg1[2])); + let mut x58: u64 = 0; + let mut x59: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x58, &mut x59, x57, x52, (0x0 as u64)); + let mut x60: u64 = 0; + let mut x61: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x60, &mut x61, x59, x54, (0x0 as u64)); + let mut x62: u64 = 0; + let mut x63: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x62, &mut x63, x56, 0xccd1c8aaee00bc4f); + let mut x64: u64 = 0; + let mut x65: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x64, &mut x65, x62, 0xffffffff00000000); + let mut x66: u64 = 0; + let mut x67: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x66, &mut x67, x62, 0xffffffffffffffff); + let mut x68: u64 = 0; + let mut x69: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x68, &mut x69, x62, 0xbce6faada7179e84); + let mut x70: u64 = 0; + let mut x71: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x70, &mut x71, x62, 0xf3b9cac2fc632551); + let mut x72: u64 = 0; + let mut x73: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x72, &mut x73, 0x0, x71, x68); + let mut x74: u64 = 0; + let mut x75: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x74, &mut x75, x73, x69, x66); + let mut x76: u64 = 0; + let mut x77: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x76, &mut x77, x75, x67, x64); + let mut x78: u64 = 0; + let mut x79: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x78, &mut x79, 0x0, x56, x70); + let mut x80: u64 = 0; + let mut x81: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x80, &mut x81, x79, x58, x72); + let mut x82: u64 = 0; + let mut x83: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x82, &mut x83, x81, x60, x74); + let mut x84: u64 = 0; + let mut x85: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x84, &mut x85, x83, ((x61 as u64) + ((x55 as u64) + ((x47 as u64) + x35))), x76); + let mut x86: u64 = 0; + let mut x87: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x86, &mut x87, 0x0, x80, (arg1[3])); + let mut x88: u64 = 0; + let mut x89: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x88, &mut x89, x87, x82, (0x0 as u64)); + let mut x90: u64 = 0; + let mut x91: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x90, &mut x91, x89, x84, (0x0 as u64)); + let mut x92: u64 = 0; + let mut x93: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x92, &mut x93, x86, 0xccd1c8aaee00bc4f); + let mut x94: u64 = 0; + let mut x95: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x94, &mut x95, x92, 0xffffffff00000000); + let mut x96: u64 = 0; + let mut x97: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x96, &mut x97, x92, 0xffffffffffffffff); + let mut x98: u64 = 0; + let mut x99: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x98, &mut x99, x92, 0xbce6faada7179e84); + let mut x100: u64 = 0; + let mut x101: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x100, &mut x101, x92, 0xf3b9cac2fc632551); + let mut x102: u64 = 0; + let mut x103: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x102, &mut x103, 0x0, x101, x98); + let mut x104: u64 = 0; + let mut x105: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x104, &mut x105, x103, x99, x96); + let mut x106: u64 = 0; + let mut x107: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x106, &mut x107, x105, x97, x94); + let mut x108: u64 = 0; + let mut x109: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x108, &mut x109, 0x0, x86, x100); + let mut x110: u64 = 0; + let mut x111: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x110, &mut x111, x109, x88, x102); + let mut x112: u64 = 0; + let mut x113: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x112, &mut x113, x111, x90, x104); + let mut x114: u64 = 0; + let mut x115: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x114, &mut x115, x113, ((x91 as u64) + ((x85 as u64) + ((x77 as u64) + x65))), x106); + let x116: u64 = ((x115 as u64) + ((x107 as u64) + x95)); + let mut x117: u64 = 0; + let mut x118: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x117, &mut x118, 0x0, x110, 0xf3b9cac2fc632551); + let mut x119: u64 = 0; + let mut x120: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x119, &mut x120, x118, x112, 0xbce6faada7179e84); + let mut x121: u64 = 0; + let mut x122: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x121, &mut x122, x120, x114, 0xffffffffffffffff); + let mut x123: u64 = 0; + let mut x124: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x123, &mut x124, x122, x116, 0xffffffff00000000); + let mut x125: u64 = 0; + let mut x126: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x125, &mut x126, x124, (0x0 as u64), (0x0 as u64)); + let mut x127: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x127, x126, x117, x110); + let mut x128: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x128, x126, x119, x112); + let mut x129: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x129, x126, x121, x114); + let mut x130: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x130, x126, x123, x116); + out1[0] = x127; + out1[1] = x128; + out1[2] = x129; + out1[3] = x130; +} + +/// The function fiat_p256_scalar_to_montgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_to_montgomery(out1: &mut fiat_p256_scalar_montgomery_domain_field_element, arg1: &fiat_p256_scalar_non_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[1]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[0]); + let mut x5: u64 = 0; + let mut x6: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x5, &mut x6, x4, 0x66e12d94f3d95620); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x7, &mut x8, x4, 0x2845b2392b6bec59); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x9, &mut x10, x4, 0x4699799c49bd6fa6); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x11, &mut x12, x4, 0x83244c95be79eea2); + let mut x13: u64 = 0; + let mut x14: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x17, &mut x18, x16, x8, x5); + let mut x19: u64 = 0; + let mut x20: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x19, &mut x20, x11, 0xccd1c8aaee00bc4f); + let mut x21: u64 = 0; + let mut x22: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x21, &mut x22, x19, 0xffffffff00000000); + let mut x23: u64 = 0; + let mut x24: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x23, &mut x24, x19, 0xffffffffffffffff); + let mut x25: u64 = 0; + let mut x26: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x25, &mut x26, x19, 0xbce6faada7179e84); + let mut x27: u64 = 0; + let mut x28: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x27, &mut x28, x19, 0xf3b9cac2fc632551); + let mut x29: u64 = 0; + let mut x30: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x29, &mut x30, 0x0, x28, x25); + let mut x31: u64 = 0; + let mut x32: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x31, &mut x32, x30, x26, x23); + let mut x33: u64 = 0; + let mut x34: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x33, &mut x34, x32, x24, x21); + let mut x35: u64 = 0; + let mut x36: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x35, &mut x36, 0x0, x11, x27); + let mut x37: u64 = 0; + let mut x38: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x37, &mut x38, x36, x13, x29); + let mut x39: u64 = 0; + let mut x40: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x39, &mut x40, x38, x15, x31); + let mut x41: u64 = 0; + let mut x42: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x41, &mut x42, x40, x17, x33); + let mut x43: u64 = 0; + let mut x44: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x43, &mut x44, x42, ((x18 as u64) + x6), ((x34 as u64) + x22)); + let mut x45: u64 = 0; + let mut x46: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x45, &mut x46, x1, 0x66e12d94f3d95620); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x47, &mut x48, x1, 0x2845b2392b6bec59); + let mut x49: u64 = 0; + let mut x50: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x49, &mut x50, x1, 0x4699799c49bd6fa6); + let mut x51: u64 = 0; + let mut x52: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x51, &mut x52, x1, 0x83244c95be79eea2); + let mut x53: u64 = 0; + let mut x54: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x53, &mut x54, 0x0, x52, x49); + let mut x55: u64 = 0; + let mut x56: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x55, &mut x56, x54, x50, x47); + let mut x57: u64 = 0; + let mut x58: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x57, &mut x58, x56, x48, x45); + let mut x59: u64 = 0; + let mut x60: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x59, &mut x60, 0x0, x37, x51); + let mut x61: u64 = 0; + let mut x62: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x61, &mut x62, x60, x39, x53); + let mut x63: u64 = 0; + let mut x64: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x63, &mut x64, x62, x41, x55); + let mut x65: u64 = 0; + let mut x66: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x65, &mut x66, x64, x43, x57); + let mut x67: u64 = 0; + let mut x68: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x67, &mut x68, x59, 0xccd1c8aaee00bc4f); + let mut x69: u64 = 0; + let mut x70: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x69, &mut x70, x67, 0xffffffff00000000); + let mut x71: u64 = 0; + let mut x72: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x71, &mut x72, x67, 0xffffffffffffffff); + let mut x73: u64 = 0; + let mut x74: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x73, &mut x74, x67, 0xbce6faada7179e84); + let mut x75: u64 = 0; + let mut x76: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x75, &mut x76, x67, 0xf3b9cac2fc632551); + let mut x77: u64 = 0; + let mut x78: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x77, &mut x78, 0x0, x76, x73); + let mut x79: u64 = 0; + let mut x80: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x79, &mut x80, x78, x74, x71); + let mut x81: u64 = 0; + let mut x82: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x81, &mut x82, x80, x72, x69); + let mut x83: u64 = 0; + let mut x84: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x83, &mut x84, 0x0, x59, x75); + let mut x85: u64 = 0; + let mut x86: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x85, &mut x86, x84, x61, x77); + let mut x87: u64 = 0; + let mut x88: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x87, &mut x88, x86, x63, x79); + let mut x89: u64 = 0; + let mut x90: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x89, &mut x90, x88, x65, x81); + let mut x91: u64 = 0; + let mut x92: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x91, &mut x92, x90, (((x66 as u64) + (x44 as u64)) + ((x58 as u64) + x46)), ((x82 as u64) + x70)); + let mut x93: u64 = 0; + let mut x94: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x93, &mut x94, x2, 0x66e12d94f3d95620); + let mut x95: u64 = 0; + let mut x96: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x95, &mut x96, x2, 0x2845b2392b6bec59); + let mut x97: u64 = 0; + let mut x98: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x97, &mut x98, x2, 0x4699799c49bd6fa6); + let mut x99: u64 = 0; + let mut x100: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x99, &mut x100, x2, 0x83244c95be79eea2); + let mut x101: u64 = 0; + let mut x102: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x101, &mut x102, 0x0, x100, x97); + let mut x103: u64 = 0; + let mut x104: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x103, &mut x104, x102, x98, x95); + let mut x105: u64 = 0; + let mut x106: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x105, &mut x106, x104, x96, x93); + let mut x107: u64 = 0; + let mut x108: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x107, &mut x108, 0x0, x85, x99); + let mut x109: u64 = 0; + let mut x110: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x109, &mut x110, x108, x87, x101); + let mut x111: u64 = 0; + let mut x112: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x111, &mut x112, x110, x89, x103); + let mut x113: u64 = 0; + let mut x114: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x113, &mut x114, x112, x91, x105); + let mut x115: u64 = 0; + let mut x116: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x115, &mut x116, x107, 0xccd1c8aaee00bc4f); + let mut x117: u64 = 0; + let mut x118: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x117, &mut x118, x115, 0xffffffff00000000); + let mut x119: u64 = 0; + let mut x120: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x119, &mut x120, x115, 0xffffffffffffffff); + let mut x121: u64 = 0; + let mut x122: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x121, &mut x122, x115, 0xbce6faada7179e84); + let mut x123: u64 = 0; + let mut x124: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x123, &mut x124, x115, 0xf3b9cac2fc632551); + let mut x125: u64 = 0; + let mut x126: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x125, &mut x126, 0x0, x124, x121); + let mut x127: u64 = 0; + let mut x128: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x127, &mut x128, x126, x122, x119); + let mut x129: u64 = 0; + let mut x130: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x129, &mut x130, x128, x120, x117); + let mut x131: u64 = 0; + let mut x132: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x131, &mut x132, 0x0, x107, x123); + let mut x133: u64 = 0; + let mut x134: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x133, &mut x134, x132, x109, x125); + let mut x135: u64 = 0; + let mut x136: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x135, &mut x136, x134, x111, x127); + let mut x137: u64 = 0; + let mut x138: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x137, &mut x138, x136, x113, x129); + let mut x139: u64 = 0; + let mut x140: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x139, &mut x140, x138, (((x114 as u64) + (x92 as u64)) + ((x106 as u64) + x94)), ((x130 as u64) + x118)); + let mut x141: u64 = 0; + let mut x142: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x141, &mut x142, x3, 0x66e12d94f3d95620); + let mut x143: u64 = 0; + let mut x144: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x143, &mut x144, x3, 0x2845b2392b6bec59); + let mut x145: u64 = 0; + let mut x146: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x145, &mut x146, x3, 0x4699799c49bd6fa6); + let mut x147: u64 = 0; + let mut x148: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x147, &mut x148, x3, 0x83244c95be79eea2); + let mut x149: u64 = 0; + let mut x150: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x149, &mut x150, 0x0, x148, x145); + let mut x151: u64 = 0; + let mut x152: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x151, &mut x152, x150, x146, x143); + let mut x153: u64 = 0; + let mut x154: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x153, &mut x154, x152, x144, x141); + let mut x155: u64 = 0; + let mut x156: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x155, &mut x156, 0x0, x133, x147); + let mut x157: u64 = 0; + let mut x158: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x157, &mut x158, x156, x135, x149); + let mut x159: u64 = 0; + let mut x160: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x159, &mut x160, x158, x137, x151); + let mut x161: u64 = 0; + let mut x162: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x161, &mut x162, x160, x139, x153); + let mut x163: u64 = 0; + let mut x164: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x163, &mut x164, x155, 0xccd1c8aaee00bc4f); + let mut x165: u64 = 0; + let mut x166: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x165, &mut x166, x163, 0xffffffff00000000); + let mut x167: u64 = 0; + let mut x168: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x167, &mut x168, x163, 0xffffffffffffffff); + let mut x169: u64 = 0; + let mut x170: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x169, &mut x170, x163, 0xbce6faada7179e84); + let mut x171: u64 = 0; + let mut x172: u64 = 0; + fiat_p256_scalar_mulx_u64(&mut x171, &mut x172, x163, 0xf3b9cac2fc632551); + let mut x173: u64 = 0; + let mut x174: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x173, &mut x174, 0x0, x172, x169); + let mut x175: u64 = 0; + let mut x176: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x175, &mut x176, x174, x170, x167); + let mut x177: u64 = 0; + let mut x178: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x177, &mut x178, x176, x168, x165); + let mut x179: u64 = 0; + let mut x180: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x179, &mut x180, 0x0, x155, x171); + let mut x181: u64 = 0; + let mut x182: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x181, &mut x182, x180, x157, x173); + let mut x183: u64 = 0; + let mut x184: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x183, &mut x184, x182, x159, x175); + let mut x185: u64 = 0; + let mut x186: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x185, &mut x186, x184, x161, x177); + let mut x187: u64 = 0; + let mut x188: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x187, &mut x188, x186, (((x162 as u64) + (x140 as u64)) + ((x154 as u64) + x142)), ((x178 as u64) + x166)); + let mut x189: u64 = 0; + let mut x190: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x189, &mut x190, 0x0, x181, 0xf3b9cac2fc632551); + let mut x191: u64 = 0; + let mut x192: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x191, &mut x192, x190, x183, 0xbce6faada7179e84); + let mut x193: u64 = 0; + let mut x194: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x193, &mut x194, x192, x185, 0xffffffffffffffff); + let mut x195: u64 = 0; + let mut x196: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x195, &mut x196, x194, x187, 0xffffffff00000000); + let mut x197: u64 = 0; + let mut x198: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x197, &mut x198, x196, (x188 as u64), (0x0 as u64)); + let mut x199: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x199, x198, x189, x181); + let mut x200: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x200, x198, x191, x183); + let mut x201: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x201, x198, x193, x185); + let mut x202: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x202, x198, x195, x187); + out1[0] = x199; + out1[1] = x200; + out1[2] = x201; + out1[3] = x202; +} + +/// The function fiat_p256_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +#[inline] +pub fn fiat_p256_scalar_nonzero(out1: &mut u64, arg1: &[u64; 4]) -> () { + let x1: u64 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3])))); + *out1 = x1; +} + +/// The function fiat_p256_scalar_selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_p256_scalar_selectznz(out1: &mut [u64; 4], arg1: fiat_p256_scalar_u1, arg2: &[u64; 4], arg3: &[u64; 4]) -> () { + let mut x1: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x1, arg1, (arg2[0]), (arg3[0])); + let mut x2: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x2, arg1, (arg2[1]), (arg3[1])); + let mut x3: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x3, arg1, (arg2[2]), (arg3[2])); + let mut x4: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/// The function fiat_p256_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +#[inline] +pub fn fiat_p256_scalar_to_bytes(out1: &mut [u8; 32], arg1: &[u64; 4]) -> () { + let x1: u64 = (arg1[3]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[1]); + let x4: u64 = (arg1[0]); + let x5: u8 = ((x4 & (0xff as u64)) as u8); + let x6: u64 = (x4 >> 8); + let x7: u8 = ((x6 & (0xff as u64)) as u8); + let x8: u64 = (x6 >> 8); + let x9: u8 = ((x8 & (0xff as u64)) as u8); + let x10: u64 = (x8 >> 8); + let x11: u8 = ((x10 & (0xff as u64)) as u8); + let x12: u64 = (x10 >> 8); + let x13: u8 = ((x12 & (0xff as u64)) as u8); + let x14: u64 = (x12 >> 8); + let x15: u8 = ((x14 & (0xff as u64)) as u8); + let x16: u64 = (x14 >> 8); + let x17: u8 = ((x16 & (0xff as u64)) as u8); + let x18: u8 = ((x16 >> 8) as u8); + let x19: u8 = ((x3 & (0xff as u64)) as u8); + let x20: u64 = (x3 >> 8); + let x21: u8 = ((x20 & (0xff as u64)) as u8); + let x22: u64 = (x20 >> 8); + let x23: u8 = ((x22 & (0xff as u64)) as u8); + let x24: u64 = (x22 >> 8); + let x25: u8 = ((x24 & (0xff as u64)) as u8); + let x26: u64 = (x24 >> 8); + let x27: u8 = ((x26 & (0xff as u64)) as u8); + let x28: u64 = (x26 >> 8); + let x29: u8 = ((x28 & (0xff as u64)) as u8); + let x30: u64 = (x28 >> 8); + let x31: u8 = ((x30 & (0xff as u64)) as u8); + let x32: u8 = ((x30 >> 8) as u8); + let x33: u8 = ((x2 & (0xff as u64)) as u8); + let x34: u64 = (x2 >> 8); + let x35: u8 = ((x34 & (0xff as u64)) as u8); + let x36: u64 = (x34 >> 8); + let x37: u8 = ((x36 & (0xff as u64)) as u8); + let x38: u64 = (x36 >> 8); + let x39: u8 = ((x38 & (0xff as u64)) as u8); + let x40: u64 = (x38 >> 8); + let x41: u8 = ((x40 & (0xff as u64)) as u8); + let x42: u64 = (x40 >> 8); + let x43: u8 = ((x42 & (0xff as u64)) as u8); + let x44: u64 = (x42 >> 8); + let x45: u8 = ((x44 & (0xff as u64)) as u8); + let x46: u8 = ((x44 >> 8) as u8); + let x47: u8 = ((x1 & (0xff as u64)) as u8); + let x48: u64 = (x1 >> 8); + let x49: u8 = ((x48 & (0xff as u64)) as u8); + let x50: u64 = (x48 >> 8); + let x51: u8 = ((x50 & (0xff as u64)) as u8); + let x52: u64 = (x50 >> 8); + let x53: u8 = ((x52 & (0xff as u64)) as u8); + let x54: u64 = (x52 >> 8); + let x55: u8 = ((x54 & (0xff as u64)) as u8); + let x56: u64 = (x54 >> 8); + let x57: u8 = ((x56 & (0xff as u64)) as u8); + let x58: u64 = (x56 >> 8); + let x59: u8 = ((x58 & (0xff as u64)) as u8); + let x60: u8 = ((x58 >> 8) as u8); + out1[0] = x5; + out1[1] = x7; + out1[2] = x9; + out1[3] = x11; + out1[4] = x13; + out1[5] = x15; + out1[6] = x17; + out1[7] = x18; + out1[8] = x19; + out1[9] = x21; + out1[10] = x23; + out1[11] = x25; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x39; + out1[20] = x41; + out1[21] = x43; + out1[22] = x45; + out1[23] = x46; + out1[24] = x47; + out1[25] = x49; + out1[26] = x51; + out1[27] = x53; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; +} + +/// The function fiat_p256_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_p256_scalar_from_bytes(out1: &mut [u64; 4], arg1: &[u8; 32]) -> () { + let x1: u64 = (((arg1[31]) as u64) << 56); + let x2: u64 = (((arg1[30]) as u64) << 48); + let x3: u64 = (((arg1[29]) as u64) << 40); + let x4: u64 = (((arg1[28]) as u64) << 32); + let x5: u64 = (((arg1[27]) as u64) << 24); + let x6: u64 = (((arg1[26]) as u64) << 16); + let x7: u64 = (((arg1[25]) as u64) << 8); + let x8: u8 = (arg1[24]); + let x9: u64 = (((arg1[23]) as u64) << 56); + let x10: u64 = (((arg1[22]) as u64) << 48); + let x11: u64 = (((arg1[21]) as u64) << 40); + let x12: u64 = (((arg1[20]) as u64) << 32); + let x13: u64 = (((arg1[19]) as u64) << 24); + let x14: u64 = (((arg1[18]) as u64) << 16); + let x15: u64 = (((arg1[17]) as u64) << 8); + let x16: u8 = (arg1[16]); + let x17: u64 = (((arg1[15]) as u64) << 56); + let x18: u64 = (((arg1[14]) as u64) << 48); + let x19: u64 = (((arg1[13]) as u64) << 40); + let x20: u64 = (((arg1[12]) as u64) << 32); + let x21: u64 = (((arg1[11]) as u64) << 24); + let x22: u64 = (((arg1[10]) as u64) << 16); + let x23: u64 = (((arg1[9]) as u64) << 8); + let x24: u8 = (arg1[8]); + let x25: u64 = (((arg1[7]) as u64) << 56); + let x26: u64 = (((arg1[6]) as u64) << 48); + let x27: u64 = (((arg1[5]) as u64) << 40); + let x28: u64 = (((arg1[4]) as u64) << 32); + let x29: u64 = (((arg1[3]) as u64) << 24); + let x30: u64 = (((arg1[2]) as u64) << 16); + let x31: u64 = (((arg1[1]) as u64) << 8); + let x32: u8 = (arg1[0]); + let x33: u64 = (x31 + (x32 as u64)); + let x34: u64 = (x30 + x33); + let x35: u64 = (x29 + x34); + let x36: u64 = (x28 + x35); + let x37: u64 = (x27 + x36); + let x38: u64 = (x26 + x37); + let x39: u64 = (x25 + x38); + let x40: u64 = (x23 + (x24 as u64)); + let x41: u64 = (x22 + x40); + let x42: u64 = (x21 + x41); + let x43: u64 = (x20 + x42); + let x44: u64 = (x19 + x43); + let x45: u64 = (x18 + x44); + let x46: u64 = (x17 + x45); + let x47: u64 = (x15 + (x16 as u64)); + let x48: u64 = (x14 + x47); + let x49: u64 = (x13 + x48); + let x50: u64 = (x12 + x49); + let x51: u64 = (x11 + x50); + let x52: u64 = (x10 + x51); + let x53: u64 = (x9 + x52); + let x54: u64 = (x7 + (x8 as u64)); + let x55: u64 = (x6 + x54); + let x56: u64 = (x5 + x55); + let x57: u64 = (x4 + x56); + let x58: u64 = (x3 + x57); + let x59: u64 = (x2 + x58); + let x60: u64 = (x1 + x59); + out1[0] = x39; + out1[1] = x46; + out1[2] = x53; + out1[3] = x60; +} + +/// The function fiat_p256_scalar_set_one returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p256_scalar_set_one(out1: &mut fiat_p256_scalar_montgomery_domain_field_element) -> () { + out1[0] = 0xc46353d039cdaaf; + out1[1] = 0x4319055258e8617b; + out1[2] = (0x0 as u64); + out1[3] = 0xffffffff; +} + +/// The function fiat_p256_scalar_msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_p256_scalar_msat(out1: &mut [u64; 5]) -> () { + out1[0] = 0xf3b9cac2fc632551; + out1[1] = 0xbce6faada7179e84; + out1[2] = 0xffffffffffffffff; + out1[3] = 0xffffffff00000000; + out1[4] = (0x0 as u64); +} + +/// The function fiat_p256_scalar_divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_p256_scalar_divstep(out1: &mut u64, out2: &mut [u64; 5], out3: &mut [u64; 5], out4: &mut [u64; 4], out5: &mut [u64; 4], arg1: u64, arg2: &[u64; 5], arg3: &[u64; 5], arg4: &[u64; 4], arg5: &[u64; 4]) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x1, &mut x2, 0x0, (!arg1), (0x1 as u64)); + let x3: fiat_p256_scalar_u1 = (((x1 >> 63) as fiat_p256_scalar_u1) & (((arg3[0]) & (0x1 as u64)) as fiat_p256_scalar_u1)); + let mut x4: u64 = 0; + let mut x5: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x4, &mut x5, 0x0, (!arg1), (0x1 as u64)); + let mut x6: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x6, x3, arg1, x4); + let mut x7: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x7, x3, (arg2[0]), (arg3[0])); + let mut x8: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x8, x3, (arg2[1]), (arg3[1])); + let mut x9: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x9, x3, (arg2[2]), (arg3[2])); + let mut x10: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x10, x3, (arg2[3]), (arg3[3])); + let mut x11: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x11, x3, (arg2[4]), (arg3[4])); + let mut x12: u64 = 0; + let mut x13: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x12, &mut x13, 0x0, (0x1 as u64), (!(arg2[0]))); + let mut x14: u64 = 0; + let mut x15: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x14, &mut x15, x13, (0x0 as u64), (!(arg2[1]))); + let mut x16: u64 = 0; + let mut x17: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x16, &mut x17, x15, (0x0 as u64), (!(arg2[2]))); + let mut x18: u64 = 0; + let mut x19: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x18, &mut x19, x17, (0x0 as u64), (!(arg2[3]))); + let mut x20: u64 = 0; + let mut x21: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x20, &mut x21, x19, (0x0 as u64), (!(arg2[4]))); + let mut x22: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x22, x3, (arg3[0]), x12); + let mut x23: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x23, x3, (arg3[1]), x14); + let mut x24: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x24, x3, (arg3[2]), x16); + let mut x25: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x25, x3, (arg3[3]), x18); + let mut x26: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x26, x3, (arg3[4]), x20); + let mut x27: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x27, x3, (arg4[0]), (arg5[0])); + let mut x28: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x28, x3, (arg4[1]), (arg5[1])); + let mut x29: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x29, x3, (arg4[2]), (arg5[2])); + let mut x30: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x30, x3, (arg4[3]), (arg5[3])); + let mut x31: u64 = 0; + let mut x32: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x31, &mut x32, 0x0, x27, x27); + let mut x33: u64 = 0; + let mut x34: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x33, &mut x34, x32, x28, x28); + let mut x35: u64 = 0; + let mut x36: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x35, &mut x36, x34, x29, x29); + let mut x37: u64 = 0; + let mut x38: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x37, &mut x38, x36, x30, x30); + let mut x39: u64 = 0; + let mut x40: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x39, &mut x40, 0x0, x31, 0xf3b9cac2fc632551); + let mut x41: u64 = 0; + let mut x42: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x41, &mut x42, x40, x33, 0xbce6faada7179e84); + let mut x43: u64 = 0; + let mut x44: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x43, &mut x44, x42, x35, 0xffffffffffffffff); + let mut x45: u64 = 0; + let mut x46: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x45, &mut x46, x44, x37, 0xffffffff00000000); + let mut x47: u64 = 0; + let mut x48: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x47, &mut x48, x46, (x38 as u64), (0x0 as u64)); + let x49: u64 = (arg4[3]); + let x50: u64 = (arg4[2]); + let x51: u64 = (arg4[1]); + let x52: u64 = (arg4[0]); + let mut x53: u64 = 0; + let mut x54: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x53, &mut x54, 0x0, (0x0 as u64), x52); + let mut x55: u64 = 0; + let mut x56: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x55, &mut x56, x54, (0x0 as u64), x51); + let mut x57: u64 = 0; + let mut x58: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x57, &mut x58, x56, (0x0 as u64), x50); + let mut x59: u64 = 0; + let mut x60: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x59, &mut x60, x58, (0x0 as u64), x49); + let mut x61: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x61, x60, (0x0 as u64), 0xffffffffffffffff); + let mut x62: u64 = 0; + let mut x63: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x62, &mut x63, 0x0, x53, (x61 & 0xf3b9cac2fc632551)); + let mut x64: u64 = 0; + let mut x65: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x64, &mut x65, x63, x55, (x61 & 0xbce6faada7179e84)); + let mut x66: u64 = 0; + let mut x67: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x66, &mut x67, x65, x57, x61); + let mut x68: u64 = 0; + let mut x69: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x68, &mut x69, x67, x59, (x61 & 0xffffffff00000000)); + let mut x70: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x70, x3, (arg5[0]), x62); + let mut x71: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x71, x3, (arg5[1]), x64); + let mut x72: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x72, x3, (arg5[2]), x66); + let mut x73: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x73, x3, (arg5[3]), x68); + let x74: fiat_p256_scalar_u1 = ((x22 & (0x1 as u64)) as fiat_p256_scalar_u1); + let mut x75: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x75, x74, (0x0 as u64), x7); + let mut x76: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x76, x74, (0x0 as u64), x8); + let mut x77: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x77, x74, (0x0 as u64), x9); + let mut x78: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x78, x74, (0x0 as u64), x10); + let mut x79: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x79, x74, (0x0 as u64), x11); + let mut x80: u64 = 0; + let mut x81: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x80, &mut x81, 0x0, x22, x75); + let mut x82: u64 = 0; + let mut x83: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x82, &mut x83, x81, x23, x76); + let mut x84: u64 = 0; + let mut x85: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x84, &mut x85, x83, x24, x77); + let mut x86: u64 = 0; + let mut x87: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x86, &mut x87, x85, x25, x78); + let mut x88: u64 = 0; + let mut x89: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x88, &mut x89, x87, x26, x79); + let mut x90: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x90, x74, (0x0 as u64), x27); + let mut x91: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x91, x74, (0x0 as u64), x28); + let mut x92: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x92, x74, (0x0 as u64), x29); + let mut x93: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x93, x74, (0x0 as u64), x30); + let mut x94: u64 = 0; + let mut x95: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x94, &mut x95, 0x0, x70, x90); + let mut x96: u64 = 0; + let mut x97: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x96, &mut x97, x95, x71, x91); + let mut x98: u64 = 0; + let mut x99: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x98, &mut x99, x97, x72, x92); + let mut x100: u64 = 0; + let mut x101: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x100, &mut x101, x99, x73, x93); + let mut x102: u64 = 0; + let mut x103: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x102, &mut x103, 0x0, x94, 0xf3b9cac2fc632551); + let mut x104: u64 = 0; + let mut x105: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x104, &mut x105, x103, x96, 0xbce6faada7179e84); + let mut x106: u64 = 0; + let mut x107: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x106, &mut x107, x105, x98, 0xffffffffffffffff); + let mut x108: u64 = 0; + let mut x109: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x108, &mut x109, x107, x100, 0xffffffff00000000); + let mut x110: u64 = 0; + let mut x111: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_subborrowx_u64(&mut x110, &mut x111, x109, (x101 as u64), (0x0 as u64)); + let mut x112: u64 = 0; + let mut x113: fiat_p256_scalar_u1 = 0; + fiat_p256_scalar_addcarryx_u64(&mut x112, &mut x113, 0x0, x6, (0x1 as u64)); + let x114: u64 = ((x80 >> 1) | ((x82 << 63) & 0xffffffffffffffff)); + let x115: u64 = ((x82 >> 1) | ((x84 << 63) & 0xffffffffffffffff)); + let x116: u64 = ((x84 >> 1) | ((x86 << 63) & 0xffffffffffffffff)); + let x117: u64 = ((x86 >> 1) | ((x88 << 63) & 0xffffffffffffffff)); + let x118: u64 = ((x88 & 0x8000000000000000) | (x88 >> 1)); + let mut x119: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x119, x48, x39, x31); + let mut x120: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x120, x48, x41, x33); + let mut x121: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x121, x48, x43, x35); + let mut x122: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x122, x48, x45, x37); + let mut x123: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x123, x111, x102, x94); + let mut x124: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x124, x111, x104, x96); + let mut x125: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x125, x111, x106, x98); + let mut x126: u64 = 0; + fiat_p256_scalar_cmovznz_u64(&mut x126, x111, x108, x100); + *out1 = x112; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out3[0] = x114; + out3[1] = x115; + out3[2] = x116; + out3[3] = x117; + out3[4] = x118; + out4[0] = x119; + out4[1] = x120; + out4[2] = x121; + out4[3] = x122; + out5[0] = x123; + out5[1] = x124; + out5[2] = x125; + out5[3] = x126; +} + +/// The function fiat_p256_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_p256_scalar_divstep_precomp(out1: &mut [u64; 4]) -> () { + out1[0] = 0xd739262fb7fcfbb5; + out1[1] = 0x8ac6f75d20074414; + out1[2] = 0xc67428bfb5e3c256; + out1[3] = 0x444962f2eda7aedf; +} diff --git a/fiat-rust/src/p384_scalar_32.rs b/fiat-rust/src/p384_scalar_32.rs new file mode 100644 index 0000000000..ef07b88f17 --- /dev/null +++ b/fiat-rust/src/p384_scalar_32.rs @@ -0,0 +1,11377 @@ +//! Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline p384_scalar 32 '2^384 - 1388124618062372383947042015309946732620727252194336364173' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +//! curve description: p384_scalar +//! machine_wordsize = 32 (from "32") +//! requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +//! m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from "2^384 - 1388124618062372383947042015309946732620727252194336364173") +//! +//! NOTE: In addition to the bounds specified above each function, all +//! functions synthesized for this Montgomery arithmetic require the +//! input to be strictly less than the prime modulus (m), and also +//! require the input to be in the unique saturated representation. +//! All functions also ensure that these two properties are true of +//! return values. +//! +//! Computed values: +//! eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) +//! bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) +//! twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) in +//! if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384 + +#![allow(unused_parens)] +#![allow(non_camel_case_types)] + +pub type fiat_p384_scalar_u1 = u8; +pub type fiat_p384_scalar_i1 = i8; +pub type fiat_p384_scalar_u2 = u8; +pub type fiat_p384_scalar_i2 = i8; + +/* The type fiat_p384_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +pub type fiat_p384_scalar_montgomery_domain_field_element = [u32; 12]; + +/* The type fiat_p384_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +pub type fiat_p384_scalar_non_montgomery_domain_field_element = [u32; 12]; + + +/// The function fiat_p384_scalar_addcarryx_u32 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^32 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_p384_scalar_addcarryx_u32(out1: &mut u32, out2: &mut fiat_p384_scalar_u1, arg1: fiat_p384_scalar_u1, arg2: u32, arg3: u32) -> () { + let x1: u64 = (((arg1 as u64) + (arg2 as u64)) + (arg3 as u64)); + let x2: u32 = ((x1 & (0xffffffff as u64)) as u32); + let x3: fiat_p384_scalar_u1 = ((x1 >> 32) as fiat_p384_scalar_u1); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_p384_scalar_subborrowx_u32 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^32 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_p384_scalar_subborrowx_u32(out1: &mut u32, out2: &mut fiat_p384_scalar_u1, arg1: fiat_p384_scalar_u1, arg2: u32, arg3: u32) -> () { + let x1: i64 = (((arg2 as i64) - (arg1 as i64)) - (arg3 as i64)); + let x2: fiat_p384_scalar_i1 = ((x1 >> 32) as fiat_p384_scalar_i1); + let x3: u32 = ((x1 & (0xffffffff as i64)) as u32); + *out1 = x3; + *out2 = (((0x0 as fiat_p384_scalar_i2) - (x2 as fiat_p384_scalar_i2)) as fiat_p384_scalar_u1); +} + +/// The function fiat_p384_scalar_mulx_u32 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^32 +/// out2 = ⌊arg1 * arg2 / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0xffffffff] +#[inline] +pub fn fiat_p384_scalar_mulx_u32(out1: &mut u32, out2: &mut u32, arg1: u32, arg2: u32) -> () { + let x1: u64 = ((arg1 as u64) * (arg2 as u64)); + let x2: u32 = ((x1 & (0xffffffff as u64)) as u32); + let x3: u32 = ((x1 >> 32) as u32); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_p384_scalar_cmovznz_u32 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +#[inline] +pub fn fiat_p384_scalar_cmovznz_u32(out1: &mut u32, arg1: fiat_p384_scalar_u1, arg2: u32, arg3: u32) -> () { + let x1: fiat_p384_scalar_u1 = (!(!arg1)); + let x2: u32 = ((((((0x0 as fiat_p384_scalar_i2) - (x1 as fiat_p384_scalar_i2)) as fiat_p384_scalar_i1) as i64) & (0xffffffff as i64)) as u32); + let x3: u32 = ((x2 & arg3) | ((!x2) & arg2)); + *out1 = x3; +} + +/// The function fiat_p384_scalar_mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_mul(out1: &mut fiat_p384_scalar_montgomery_domain_field_element, arg1: &fiat_p384_scalar_montgomery_domain_field_element, arg2: &fiat_p384_scalar_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[1]); + let x2: u32 = (arg1[2]); + let x3: u32 = (arg1[3]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[5]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[7]); + let x8: u32 = (arg1[8]); + let x9: u32 = (arg1[9]); + let x10: u32 = (arg1[10]); + let x11: u32 = (arg1[11]); + let x12: u32 = (arg1[0]); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x13, &mut x14, x12, (arg2[11])); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x15, &mut x16, x12, (arg2[10])); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x17, &mut x18, x12, (arg2[9])); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x19, &mut x20, x12, (arg2[8])); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x21, &mut x22, x12, (arg2[7])); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x23, &mut x24, x12, (arg2[6])); + let mut x25: u32 = 0; + let mut x26: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x25, &mut x26, x12, (arg2[5])); + let mut x27: u32 = 0; + let mut x28: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x27, &mut x28, x12, (arg2[4])); + let mut x29: u32 = 0; + let mut x30: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x29, &mut x30, x12, (arg2[3])); + let mut x31: u32 = 0; + let mut x32: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x31, &mut x32, x12, (arg2[2])); + let mut x33: u32 = 0; + let mut x34: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x33, &mut x34, x12, (arg2[1])); + let mut x35: u32 = 0; + let mut x36: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x35, &mut x36, x12, (arg2[0])); + let mut x37: u32 = 0; + let mut x38: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x37, &mut x38, 0x0, x36, x33); + let mut x39: u32 = 0; + let mut x40: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x39, &mut x40, x38, x34, x31); + let mut x41: u32 = 0; + let mut x42: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x41, &mut x42, x40, x32, x29); + let mut x43: u32 = 0; + let mut x44: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x43, &mut x44, x42, x30, x27); + let mut x45: u32 = 0; + let mut x46: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x45, &mut x46, x44, x28, x25); + let mut x47: u32 = 0; + let mut x48: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x47, &mut x48, x46, x26, x23); + let mut x49: u32 = 0; + let mut x50: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x49, &mut x50, x48, x24, x21); + let mut x51: u32 = 0; + let mut x52: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x51, &mut x52, x50, x22, x19); + let mut x53: u32 = 0; + let mut x54: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x53, &mut x54, x52, x20, x17); + let mut x55: u32 = 0; + let mut x56: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x55, &mut x56, x54, x18, x15); + let mut x57: u32 = 0; + let mut x58: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x57, &mut x58, x56, x16, x13); + let x59: u32 = ((x58 as u32) + x14); + let mut x60: u32 = 0; + let mut x61: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x60, &mut x61, x35, 0xe88fdc45); + let mut x62: u32 = 0; + let mut x63: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x62, &mut x63, x60, 0xffffffff); + let mut x64: u32 = 0; + let mut x65: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x64, &mut x65, x60, 0xffffffff); + let mut x66: u32 = 0; + let mut x67: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x66, &mut x67, x60, 0xffffffff); + let mut x68: u32 = 0; + let mut x69: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x68, &mut x69, x60, 0xffffffff); + let mut x70: u32 = 0; + let mut x71: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x70, &mut x71, x60, 0xffffffff); + let mut x72: u32 = 0; + let mut x73: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x72, &mut x73, x60, 0xffffffff); + let mut x74: u32 = 0; + let mut x75: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x74, &mut x75, x60, 0xc7634d81); + let mut x76: u32 = 0; + let mut x77: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x76, &mut x77, x60, 0xf4372ddf); + let mut x78: u32 = 0; + let mut x79: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x78, &mut x79, x60, 0x581a0db2); + let mut x80: u32 = 0; + let mut x81: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x80, &mut x81, x60, 0x48b0a77a); + let mut x82: u32 = 0; + let mut x83: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x82, &mut x83, x60, 0xecec196a); + let mut x84: u32 = 0; + let mut x85: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x84, &mut x85, x60, 0xccc52973); + let mut x86: u32 = 0; + let mut x87: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x86, &mut x87, 0x0, x85, x82); + let mut x88: u32 = 0; + let mut x89: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x88, &mut x89, x87, x83, x80); + let mut x90: u32 = 0; + let mut x91: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x90, &mut x91, x89, x81, x78); + let mut x92: u32 = 0; + let mut x93: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x92, &mut x93, x91, x79, x76); + let mut x94: u32 = 0; + let mut x95: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x94, &mut x95, x93, x77, x74); + let mut x96: u32 = 0; + let mut x97: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x96, &mut x97, x95, x75, x72); + let mut x98: u32 = 0; + let mut x99: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x98, &mut x99, x97, x73, x70); + let mut x100: u32 = 0; + let mut x101: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x100, &mut x101, x99, x71, x68); + let mut x102: u32 = 0; + let mut x103: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x102, &mut x103, x101, x69, x66); + let mut x104: u32 = 0; + let mut x105: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x104, &mut x105, x103, x67, x64); + let mut x106: u32 = 0; + let mut x107: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x106, &mut x107, x105, x65, x62); + let x108: u32 = ((x107 as u32) + x63); + let mut x109: u32 = 0; + let mut x110: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x109, &mut x110, 0x0, x35, x84); + let mut x111: u32 = 0; + let mut x112: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x37, x86); + let mut x113: u32 = 0; + let mut x114: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x113, &mut x114, x112, x39, x88); + let mut x115: u32 = 0; + let mut x116: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x115, &mut x116, x114, x41, x90); + let mut x117: u32 = 0; + let mut x118: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x117, &mut x118, x116, x43, x92); + let mut x119: u32 = 0; + let mut x120: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x119, &mut x120, x118, x45, x94); + let mut x121: u32 = 0; + let mut x122: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x121, &mut x122, x120, x47, x96); + let mut x123: u32 = 0; + let mut x124: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x123, &mut x124, x122, x49, x98); + let mut x125: u32 = 0; + let mut x126: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x125, &mut x126, x124, x51, x100); + let mut x127: u32 = 0; + let mut x128: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x127, &mut x128, x126, x53, x102); + let mut x129: u32 = 0; + let mut x130: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x129, &mut x130, x128, x55, x104); + let mut x131: u32 = 0; + let mut x132: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x131, &mut x132, x130, x57, x106); + let mut x133: u32 = 0; + let mut x134: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x133, &mut x134, x132, x59, x108); + let mut x135: u32 = 0; + let mut x136: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x135, &mut x136, x1, (arg2[11])); + let mut x137: u32 = 0; + let mut x138: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x137, &mut x138, x1, (arg2[10])); + let mut x139: u32 = 0; + let mut x140: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x139, &mut x140, x1, (arg2[9])); + let mut x141: u32 = 0; + let mut x142: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x141, &mut x142, x1, (arg2[8])); + let mut x143: u32 = 0; + let mut x144: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x143, &mut x144, x1, (arg2[7])); + let mut x145: u32 = 0; + let mut x146: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x145, &mut x146, x1, (arg2[6])); + let mut x147: u32 = 0; + let mut x148: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x147, &mut x148, x1, (arg2[5])); + let mut x149: u32 = 0; + let mut x150: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x149, &mut x150, x1, (arg2[4])); + let mut x151: u32 = 0; + let mut x152: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x151, &mut x152, x1, (arg2[3])); + let mut x153: u32 = 0; + let mut x154: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x153, &mut x154, x1, (arg2[2])); + let mut x155: u32 = 0; + let mut x156: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x155, &mut x156, x1, (arg2[1])); + let mut x157: u32 = 0; + let mut x158: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x157, &mut x158, x1, (arg2[0])); + let mut x159: u32 = 0; + let mut x160: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x159, &mut x160, 0x0, x158, x155); + let mut x161: u32 = 0; + let mut x162: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x161, &mut x162, x160, x156, x153); + let mut x163: u32 = 0; + let mut x164: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x163, &mut x164, x162, x154, x151); + let mut x165: u32 = 0; + let mut x166: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x165, &mut x166, x164, x152, x149); + let mut x167: u32 = 0; + let mut x168: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x167, &mut x168, x166, x150, x147); + let mut x169: u32 = 0; + let mut x170: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x169, &mut x170, x168, x148, x145); + let mut x171: u32 = 0; + let mut x172: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x171, &mut x172, x170, x146, x143); + let mut x173: u32 = 0; + let mut x174: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x173, &mut x174, x172, x144, x141); + let mut x175: u32 = 0; + let mut x176: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x175, &mut x176, x174, x142, x139); + let mut x177: u32 = 0; + let mut x178: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x177, &mut x178, x176, x140, x137); + let mut x179: u32 = 0; + let mut x180: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x179, &mut x180, x178, x138, x135); + let x181: u32 = ((x180 as u32) + x136); + let mut x182: u32 = 0; + let mut x183: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x182, &mut x183, 0x0, x111, x157); + let mut x184: u32 = 0; + let mut x185: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x184, &mut x185, x183, x113, x159); + let mut x186: u32 = 0; + let mut x187: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x186, &mut x187, x185, x115, x161); + let mut x188: u32 = 0; + let mut x189: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x188, &mut x189, x187, x117, x163); + let mut x190: u32 = 0; + let mut x191: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x190, &mut x191, x189, x119, x165); + let mut x192: u32 = 0; + let mut x193: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x192, &mut x193, x191, x121, x167); + let mut x194: u32 = 0; + let mut x195: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x194, &mut x195, x193, x123, x169); + let mut x196: u32 = 0; + let mut x197: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x196, &mut x197, x195, x125, x171); + let mut x198: u32 = 0; + let mut x199: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x198, &mut x199, x197, x127, x173); + let mut x200: u32 = 0; + let mut x201: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x200, &mut x201, x199, x129, x175); + let mut x202: u32 = 0; + let mut x203: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x202, &mut x203, x201, x131, x177); + let mut x204: u32 = 0; + let mut x205: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x204, &mut x205, x203, x133, x179); + let mut x206: u32 = 0; + let mut x207: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x206, &mut x207, x205, (x134 as u32), x181); + let mut x208: u32 = 0; + let mut x209: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x208, &mut x209, x182, 0xe88fdc45); + let mut x210: u32 = 0; + let mut x211: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x210, &mut x211, x208, 0xffffffff); + let mut x212: u32 = 0; + let mut x213: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x212, &mut x213, x208, 0xffffffff); + let mut x214: u32 = 0; + let mut x215: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x214, &mut x215, x208, 0xffffffff); + let mut x216: u32 = 0; + let mut x217: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x216, &mut x217, x208, 0xffffffff); + let mut x218: u32 = 0; + let mut x219: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x218, &mut x219, x208, 0xffffffff); + let mut x220: u32 = 0; + let mut x221: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x220, &mut x221, x208, 0xffffffff); + let mut x222: u32 = 0; + let mut x223: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x222, &mut x223, x208, 0xc7634d81); + let mut x224: u32 = 0; + let mut x225: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x224, &mut x225, x208, 0xf4372ddf); + let mut x226: u32 = 0; + let mut x227: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x226, &mut x227, x208, 0x581a0db2); + let mut x228: u32 = 0; + let mut x229: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x228, &mut x229, x208, 0x48b0a77a); + let mut x230: u32 = 0; + let mut x231: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x230, &mut x231, x208, 0xecec196a); + let mut x232: u32 = 0; + let mut x233: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x232, &mut x233, x208, 0xccc52973); + let mut x234: u32 = 0; + let mut x235: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x234, &mut x235, 0x0, x233, x230); + let mut x236: u32 = 0; + let mut x237: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x236, &mut x237, x235, x231, x228); + let mut x238: u32 = 0; + let mut x239: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x238, &mut x239, x237, x229, x226); + let mut x240: u32 = 0; + let mut x241: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x240, &mut x241, x239, x227, x224); + let mut x242: u32 = 0; + let mut x243: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x242, &mut x243, x241, x225, x222); + let mut x244: u32 = 0; + let mut x245: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x244, &mut x245, x243, x223, x220); + let mut x246: u32 = 0; + let mut x247: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x246, &mut x247, x245, x221, x218); + let mut x248: u32 = 0; + let mut x249: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x248, &mut x249, x247, x219, x216); + let mut x250: u32 = 0; + let mut x251: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x250, &mut x251, x249, x217, x214); + let mut x252: u32 = 0; + let mut x253: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x252, &mut x253, x251, x215, x212); + let mut x254: u32 = 0; + let mut x255: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x254, &mut x255, x253, x213, x210); + let x256: u32 = ((x255 as u32) + x211); + let mut x257: u32 = 0; + let mut x258: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x257, &mut x258, 0x0, x182, x232); + let mut x259: u32 = 0; + let mut x260: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x259, &mut x260, x258, x184, x234); + let mut x261: u32 = 0; + let mut x262: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x261, &mut x262, x260, x186, x236); + let mut x263: u32 = 0; + let mut x264: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x263, &mut x264, x262, x188, x238); + let mut x265: u32 = 0; + let mut x266: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x265, &mut x266, x264, x190, x240); + let mut x267: u32 = 0; + let mut x268: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x267, &mut x268, x266, x192, x242); + let mut x269: u32 = 0; + let mut x270: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x269, &mut x270, x268, x194, x244); + let mut x271: u32 = 0; + let mut x272: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x271, &mut x272, x270, x196, x246); + let mut x273: u32 = 0; + let mut x274: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x273, &mut x274, x272, x198, x248); + let mut x275: u32 = 0; + let mut x276: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x275, &mut x276, x274, x200, x250); + let mut x277: u32 = 0; + let mut x278: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x277, &mut x278, x276, x202, x252); + let mut x279: u32 = 0; + let mut x280: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x279, &mut x280, x278, x204, x254); + let mut x281: u32 = 0; + let mut x282: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x281, &mut x282, x280, x206, x256); + let x283: u32 = ((x282 as u32) + (x207 as u32)); + let mut x284: u32 = 0; + let mut x285: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x284, &mut x285, x2, (arg2[11])); + let mut x286: u32 = 0; + let mut x287: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x286, &mut x287, x2, (arg2[10])); + let mut x288: u32 = 0; + let mut x289: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x288, &mut x289, x2, (arg2[9])); + let mut x290: u32 = 0; + let mut x291: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x290, &mut x291, x2, (arg2[8])); + let mut x292: u32 = 0; + let mut x293: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x292, &mut x293, x2, (arg2[7])); + let mut x294: u32 = 0; + let mut x295: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x294, &mut x295, x2, (arg2[6])); + let mut x296: u32 = 0; + let mut x297: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x296, &mut x297, x2, (arg2[5])); + let mut x298: u32 = 0; + let mut x299: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x298, &mut x299, x2, (arg2[4])); + let mut x300: u32 = 0; + let mut x301: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x300, &mut x301, x2, (arg2[3])); + let mut x302: u32 = 0; + let mut x303: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x302, &mut x303, x2, (arg2[2])); + let mut x304: u32 = 0; + let mut x305: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x304, &mut x305, x2, (arg2[1])); + let mut x306: u32 = 0; + let mut x307: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x306, &mut x307, x2, (arg2[0])); + let mut x308: u32 = 0; + let mut x309: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x308, &mut x309, 0x0, x307, x304); + let mut x310: u32 = 0; + let mut x311: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x310, &mut x311, x309, x305, x302); + let mut x312: u32 = 0; + let mut x313: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x312, &mut x313, x311, x303, x300); + let mut x314: u32 = 0; + let mut x315: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x314, &mut x315, x313, x301, x298); + let mut x316: u32 = 0; + let mut x317: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x316, &mut x317, x315, x299, x296); + let mut x318: u32 = 0; + let mut x319: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x318, &mut x319, x317, x297, x294); + let mut x320: u32 = 0; + let mut x321: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x320, &mut x321, x319, x295, x292); + let mut x322: u32 = 0; + let mut x323: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x322, &mut x323, x321, x293, x290); + let mut x324: u32 = 0; + let mut x325: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x324, &mut x325, x323, x291, x288); + let mut x326: u32 = 0; + let mut x327: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x326, &mut x327, x325, x289, x286); + let mut x328: u32 = 0; + let mut x329: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x328, &mut x329, x327, x287, x284); + let x330: u32 = ((x329 as u32) + x285); + let mut x331: u32 = 0; + let mut x332: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x331, &mut x332, 0x0, x259, x306); + let mut x333: u32 = 0; + let mut x334: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x333, &mut x334, x332, x261, x308); + let mut x335: u32 = 0; + let mut x336: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x335, &mut x336, x334, x263, x310); + let mut x337: u32 = 0; + let mut x338: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x337, &mut x338, x336, x265, x312); + let mut x339: u32 = 0; + let mut x340: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x339, &mut x340, x338, x267, x314); + let mut x341: u32 = 0; + let mut x342: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x341, &mut x342, x340, x269, x316); + let mut x343: u32 = 0; + let mut x344: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x343, &mut x344, x342, x271, x318); + let mut x345: u32 = 0; + let mut x346: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x345, &mut x346, x344, x273, x320); + let mut x347: u32 = 0; + let mut x348: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x347, &mut x348, x346, x275, x322); + let mut x349: u32 = 0; + let mut x350: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x349, &mut x350, x348, x277, x324); + let mut x351: u32 = 0; + let mut x352: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x351, &mut x352, x350, x279, x326); + let mut x353: u32 = 0; + let mut x354: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x353, &mut x354, x352, x281, x328); + let mut x355: u32 = 0; + let mut x356: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x355, &mut x356, x354, x283, x330); + let mut x357: u32 = 0; + let mut x358: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x357, &mut x358, x331, 0xe88fdc45); + let mut x359: u32 = 0; + let mut x360: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x359, &mut x360, x357, 0xffffffff); + let mut x361: u32 = 0; + let mut x362: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x361, &mut x362, x357, 0xffffffff); + let mut x363: u32 = 0; + let mut x364: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x363, &mut x364, x357, 0xffffffff); + let mut x365: u32 = 0; + let mut x366: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x365, &mut x366, x357, 0xffffffff); + let mut x367: u32 = 0; + let mut x368: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x367, &mut x368, x357, 0xffffffff); + let mut x369: u32 = 0; + let mut x370: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x369, &mut x370, x357, 0xffffffff); + let mut x371: u32 = 0; + let mut x372: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x371, &mut x372, x357, 0xc7634d81); + let mut x373: u32 = 0; + let mut x374: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x373, &mut x374, x357, 0xf4372ddf); + let mut x375: u32 = 0; + let mut x376: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x375, &mut x376, x357, 0x581a0db2); + let mut x377: u32 = 0; + let mut x378: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x377, &mut x378, x357, 0x48b0a77a); + let mut x379: u32 = 0; + let mut x380: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x379, &mut x380, x357, 0xecec196a); + let mut x381: u32 = 0; + let mut x382: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x381, &mut x382, x357, 0xccc52973); + let mut x383: u32 = 0; + let mut x384: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x383, &mut x384, 0x0, x382, x379); + let mut x385: u32 = 0; + let mut x386: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x385, &mut x386, x384, x380, x377); + let mut x387: u32 = 0; + let mut x388: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x387, &mut x388, x386, x378, x375); + let mut x389: u32 = 0; + let mut x390: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x389, &mut x390, x388, x376, x373); + let mut x391: u32 = 0; + let mut x392: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x391, &mut x392, x390, x374, x371); + let mut x393: u32 = 0; + let mut x394: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x393, &mut x394, x392, x372, x369); + let mut x395: u32 = 0; + let mut x396: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x395, &mut x396, x394, x370, x367); + let mut x397: u32 = 0; + let mut x398: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x397, &mut x398, x396, x368, x365); + let mut x399: u32 = 0; + let mut x400: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x399, &mut x400, x398, x366, x363); + let mut x401: u32 = 0; + let mut x402: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x401, &mut x402, x400, x364, x361); + let mut x403: u32 = 0; + let mut x404: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x403, &mut x404, x402, x362, x359); + let x405: u32 = ((x404 as u32) + x360); + let mut x406: u32 = 0; + let mut x407: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x406, &mut x407, 0x0, x331, x381); + let mut x408: u32 = 0; + let mut x409: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x408, &mut x409, x407, x333, x383); + let mut x410: u32 = 0; + let mut x411: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x410, &mut x411, x409, x335, x385); + let mut x412: u32 = 0; + let mut x413: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x412, &mut x413, x411, x337, x387); + let mut x414: u32 = 0; + let mut x415: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x414, &mut x415, x413, x339, x389); + let mut x416: u32 = 0; + let mut x417: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x416, &mut x417, x415, x341, x391); + let mut x418: u32 = 0; + let mut x419: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x418, &mut x419, x417, x343, x393); + let mut x420: u32 = 0; + let mut x421: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x420, &mut x421, x419, x345, x395); + let mut x422: u32 = 0; + let mut x423: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x422, &mut x423, x421, x347, x397); + let mut x424: u32 = 0; + let mut x425: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x424, &mut x425, x423, x349, x399); + let mut x426: u32 = 0; + let mut x427: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x426, &mut x427, x425, x351, x401); + let mut x428: u32 = 0; + let mut x429: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x428, &mut x429, x427, x353, x403); + let mut x430: u32 = 0; + let mut x431: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x430, &mut x431, x429, x355, x405); + let x432: u32 = ((x431 as u32) + (x356 as u32)); + let mut x433: u32 = 0; + let mut x434: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x433, &mut x434, x3, (arg2[11])); + let mut x435: u32 = 0; + let mut x436: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x435, &mut x436, x3, (arg2[10])); + let mut x437: u32 = 0; + let mut x438: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x437, &mut x438, x3, (arg2[9])); + let mut x439: u32 = 0; + let mut x440: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x439, &mut x440, x3, (arg2[8])); + let mut x441: u32 = 0; + let mut x442: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x441, &mut x442, x3, (arg2[7])); + let mut x443: u32 = 0; + let mut x444: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x443, &mut x444, x3, (arg2[6])); + let mut x445: u32 = 0; + let mut x446: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x445, &mut x446, x3, (arg2[5])); + let mut x447: u32 = 0; + let mut x448: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x447, &mut x448, x3, (arg2[4])); + let mut x449: u32 = 0; + let mut x450: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x449, &mut x450, x3, (arg2[3])); + let mut x451: u32 = 0; + let mut x452: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x451, &mut x452, x3, (arg2[2])); + let mut x453: u32 = 0; + let mut x454: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x453, &mut x454, x3, (arg2[1])); + let mut x455: u32 = 0; + let mut x456: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x455, &mut x456, x3, (arg2[0])); + let mut x457: u32 = 0; + let mut x458: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x457, &mut x458, 0x0, x456, x453); + let mut x459: u32 = 0; + let mut x460: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x459, &mut x460, x458, x454, x451); + let mut x461: u32 = 0; + let mut x462: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x461, &mut x462, x460, x452, x449); + let mut x463: u32 = 0; + let mut x464: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x463, &mut x464, x462, x450, x447); + let mut x465: u32 = 0; + let mut x466: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x465, &mut x466, x464, x448, x445); + let mut x467: u32 = 0; + let mut x468: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x467, &mut x468, x466, x446, x443); + let mut x469: u32 = 0; + let mut x470: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x469, &mut x470, x468, x444, x441); + let mut x471: u32 = 0; + let mut x472: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x471, &mut x472, x470, x442, x439); + let mut x473: u32 = 0; + let mut x474: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x473, &mut x474, x472, x440, x437); + let mut x475: u32 = 0; + let mut x476: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x475, &mut x476, x474, x438, x435); + let mut x477: u32 = 0; + let mut x478: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x477, &mut x478, x476, x436, x433); + let x479: u32 = ((x478 as u32) + x434); + let mut x480: u32 = 0; + let mut x481: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x480, &mut x481, 0x0, x408, x455); + let mut x482: u32 = 0; + let mut x483: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x482, &mut x483, x481, x410, x457); + let mut x484: u32 = 0; + let mut x485: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x484, &mut x485, x483, x412, x459); + let mut x486: u32 = 0; + let mut x487: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x486, &mut x487, x485, x414, x461); + let mut x488: u32 = 0; + let mut x489: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x488, &mut x489, x487, x416, x463); + let mut x490: u32 = 0; + let mut x491: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x490, &mut x491, x489, x418, x465); + let mut x492: u32 = 0; + let mut x493: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x492, &mut x493, x491, x420, x467); + let mut x494: u32 = 0; + let mut x495: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x494, &mut x495, x493, x422, x469); + let mut x496: u32 = 0; + let mut x497: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x496, &mut x497, x495, x424, x471); + let mut x498: u32 = 0; + let mut x499: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x498, &mut x499, x497, x426, x473); + let mut x500: u32 = 0; + let mut x501: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x500, &mut x501, x499, x428, x475); + let mut x502: u32 = 0; + let mut x503: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x502, &mut x503, x501, x430, x477); + let mut x504: u32 = 0; + let mut x505: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x504, &mut x505, x503, x432, x479); + let mut x506: u32 = 0; + let mut x507: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x506, &mut x507, x480, 0xe88fdc45); + let mut x508: u32 = 0; + let mut x509: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x508, &mut x509, x506, 0xffffffff); + let mut x510: u32 = 0; + let mut x511: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x510, &mut x511, x506, 0xffffffff); + let mut x512: u32 = 0; + let mut x513: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x512, &mut x513, x506, 0xffffffff); + let mut x514: u32 = 0; + let mut x515: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x514, &mut x515, x506, 0xffffffff); + let mut x516: u32 = 0; + let mut x517: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x516, &mut x517, x506, 0xffffffff); + let mut x518: u32 = 0; + let mut x519: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x518, &mut x519, x506, 0xffffffff); + let mut x520: u32 = 0; + let mut x521: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x520, &mut x521, x506, 0xc7634d81); + let mut x522: u32 = 0; + let mut x523: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x522, &mut x523, x506, 0xf4372ddf); + let mut x524: u32 = 0; + let mut x525: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x524, &mut x525, x506, 0x581a0db2); + let mut x526: u32 = 0; + let mut x527: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x526, &mut x527, x506, 0x48b0a77a); + let mut x528: u32 = 0; + let mut x529: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x528, &mut x529, x506, 0xecec196a); + let mut x530: u32 = 0; + let mut x531: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x530, &mut x531, x506, 0xccc52973); + let mut x532: u32 = 0; + let mut x533: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x532, &mut x533, 0x0, x531, x528); + let mut x534: u32 = 0; + let mut x535: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x534, &mut x535, x533, x529, x526); + let mut x536: u32 = 0; + let mut x537: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x536, &mut x537, x535, x527, x524); + let mut x538: u32 = 0; + let mut x539: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x538, &mut x539, x537, x525, x522); + let mut x540: u32 = 0; + let mut x541: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x540, &mut x541, x539, x523, x520); + let mut x542: u32 = 0; + let mut x543: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x542, &mut x543, x541, x521, x518); + let mut x544: u32 = 0; + let mut x545: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x544, &mut x545, x543, x519, x516); + let mut x546: u32 = 0; + let mut x547: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x546, &mut x547, x545, x517, x514); + let mut x548: u32 = 0; + let mut x549: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x548, &mut x549, x547, x515, x512); + let mut x550: u32 = 0; + let mut x551: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x550, &mut x551, x549, x513, x510); + let mut x552: u32 = 0; + let mut x553: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x552, &mut x553, x551, x511, x508); + let x554: u32 = ((x553 as u32) + x509); + let mut x555: u32 = 0; + let mut x556: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x555, &mut x556, 0x0, x480, x530); + let mut x557: u32 = 0; + let mut x558: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x557, &mut x558, x556, x482, x532); + let mut x559: u32 = 0; + let mut x560: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x559, &mut x560, x558, x484, x534); + let mut x561: u32 = 0; + let mut x562: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x561, &mut x562, x560, x486, x536); + let mut x563: u32 = 0; + let mut x564: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x563, &mut x564, x562, x488, x538); + let mut x565: u32 = 0; + let mut x566: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x565, &mut x566, x564, x490, x540); + let mut x567: u32 = 0; + let mut x568: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x567, &mut x568, x566, x492, x542); + let mut x569: u32 = 0; + let mut x570: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x569, &mut x570, x568, x494, x544); + let mut x571: u32 = 0; + let mut x572: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x571, &mut x572, x570, x496, x546); + let mut x573: u32 = 0; + let mut x574: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x573, &mut x574, x572, x498, x548); + let mut x575: u32 = 0; + let mut x576: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x575, &mut x576, x574, x500, x550); + let mut x577: u32 = 0; + let mut x578: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x577, &mut x578, x576, x502, x552); + let mut x579: u32 = 0; + let mut x580: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x579, &mut x580, x578, x504, x554); + let x581: u32 = ((x580 as u32) + (x505 as u32)); + let mut x582: u32 = 0; + let mut x583: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x582, &mut x583, x4, (arg2[11])); + let mut x584: u32 = 0; + let mut x585: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x584, &mut x585, x4, (arg2[10])); + let mut x586: u32 = 0; + let mut x587: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x586, &mut x587, x4, (arg2[9])); + let mut x588: u32 = 0; + let mut x589: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x588, &mut x589, x4, (arg2[8])); + let mut x590: u32 = 0; + let mut x591: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x590, &mut x591, x4, (arg2[7])); + let mut x592: u32 = 0; + let mut x593: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x592, &mut x593, x4, (arg2[6])); + let mut x594: u32 = 0; + let mut x595: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x594, &mut x595, x4, (arg2[5])); + let mut x596: u32 = 0; + let mut x597: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x596, &mut x597, x4, (arg2[4])); + let mut x598: u32 = 0; + let mut x599: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x598, &mut x599, x4, (arg2[3])); + let mut x600: u32 = 0; + let mut x601: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x600, &mut x601, x4, (arg2[2])); + let mut x602: u32 = 0; + let mut x603: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x602, &mut x603, x4, (arg2[1])); + let mut x604: u32 = 0; + let mut x605: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x604, &mut x605, x4, (arg2[0])); + let mut x606: u32 = 0; + let mut x607: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x606, &mut x607, 0x0, x605, x602); + let mut x608: u32 = 0; + let mut x609: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x608, &mut x609, x607, x603, x600); + let mut x610: u32 = 0; + let mut x611: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x610, &mut x611, x609, x601, x598); + let mut x612: u32 = 0; + let mut x613: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x612, &mut x613, x611, x599, x596); + let mut x614: u32 = 0; + let mut x615: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x614, &mut x615, x613, x597, x594); + let mut x616: u32 = 0; + let mut x617: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x616, &mut x617, x615, x595, x592); + let mut x618: u32 = 0; + let mut x619: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x618, &mut x619, x617, x593, x590); + let mut x620: u32 = 0; + let mut x621: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x620, &mut x621, x619, x591, x588); + let mut x622: u32 = 0; + let mut x623: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x622, &mut x623, x621, x589, x586); + let mut x624: u32 = 0; + let mut x625: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x624, &mut x625, x623, x587, x584); + let mut x626: u32 = 0; + let mut x627: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x626, &mut x627, x625, x585, x582); + let x628: u32 = ((x627 as u32) + x583); + let mut x629: u32 = 0; + let mut x630: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x629, &mut x630, 0x0, x557, x604); + let mut x631: u32 = 0; + let mut x632: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x631, &mut x632, x630, x559, x606); + let mut x633: u32 = 0; + let mut x634: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x633, &mut x634, x632, x561, x608); + let mut x635: u32 = 0; + let mut x636: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x635, &mut x636, x634, x563, x610); + let mut x637: u32 = 0; + let mut x638: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x637, &mut x638, x636, x565, x612); + let mut x639: u32 = 0; + let mut x640: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x639, &mut x640, x638, x567, x614); + let mut x641: u32 = 0; + let mut x642: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x641, &mut x642, x640, x569, x616); + let mut x643: u32 = 0; + let mut x644: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x643, &mut x644, x642, x571, x618); + let mut x645: u32 = 0; + let mut x646: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x645, &mut x646, x644, x573, x620); + let mut x647: u32 = 0; + let mut x648: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x647, &mut x648, x646, x575, x622); + let mut x649: u32 = 0; + let mut x650: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x649, &mut x650, x648, x577, x624); + let mut x651: u32 = 0; + let mut x652: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x651, &mut x652, x650, x579, x626); + let mut x653: u32 = 0; + let mut x654: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x653, &mut x654, x652, x581, x628); + let mut x655: u32 = 0; + let mut x656: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x655, &mut x656, x629, 0xe88fdc45); + let mut x657: u32 = 0; + let mut x658: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x657, &mut x658, x655, 0xffffffff); + let mut x659: u32 = 0; + let mut x660: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x659, &mut x660, x655, 0xffffffff); + let mut x661: u32 = 0; + let mut x662: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x661, &mut x662, x655, 0xffffffff); + let mut x663: u32 = 0; + let mut x664: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x663, &mut x664, x655, 0xffffffff); + let mut x665: u32 = 0; + let mut x666: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x665, &mut x666, x655, 0xffffffff); + let mut x667: u32 = 0; + let mut x668: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x667, &mut x668, x655, 0xffffffff); + let mut x669: u32 = 0; + let mut x670: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x669, &mut x670, x655, 0xc7634d81); + let mut x671: u32 = 0; + let mut x672: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x671, &mut x672, x655, 0xf4372ddf); + let mut x673: u32 = 0; + let mut x674: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x673, &mut x674, x655, 0x581a0db2); + let mut x675: u32 = 0; + let mut x676: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x675, &mut x676, x655, 0x48b0a77a); + let mut x677: u32 = 0; + let mut x678: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x677, &mut x678, x655, 0xecec196a); + let mut x679: u32 = 0; + let mut x680: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x679, &mut x680, x655, 0xccc52973); + let mut x681: u32 = 0; + let mut x682: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x681, &mut x682, 0x0, x680, x677); + let mut x683: u32 = 0; + let mut x684: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x683, &mut x684, x682, x678, x675); + let mut x685: u32 = 0; + let mut x686: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x685, &mut x686, x684, x676, x673); + let mut x687: u32 = 0; + let mut x688: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x687, &mut x688, x686, x674, x671); + let mut x689: u32 = 0; + let mut x690: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x689, &mut x690, x688, x672, x669); + let mut x691: u32 = 0; + let mut x692: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x691, &mut x692, x690, x670, x667); + let mut x693: u32 = 0; + let mut x694: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x693, &mut x694, x692, x668, x665); + let mut x695: u32 = 0; + let mut x696: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x695, &mut x696, x694, x666, x663); + let mut x697: u32 = 0; + let mut x698: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x697, &mut x698, x696, x664, x661); + let mut x699: u32 = 0; + let mut x700: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x699, &mut x700, x698, x662, x659); + let mut x701: u32 = 0; + let mut x702: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x701, &mut x702, x700, x660, x657); + let x703: u32 = ((x702 as u32) + x658); + let mut x704: u32 = 0; + let mut x705: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x704, &mut x705, 0x0, x629, x679); + let mut x706: u32 = 0; + let mut x707: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x706, &mut x707, x705, x631, x681); + let mut x708: u32 = 0; + let mut x709: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x708, &mut x709, x707, x633, x683); + let mut x710: u32 = 0; + let mut x711: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x710, &mut x711, x709, x635, x685); + let mut x712: u32 = 0; + let mut x713: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x712, &mut x713, x711, x637, x687); + let mut x714: u32 = 0; + let mut x715: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x714, &mut x715, x713, x639, x689); + let mut x716: u32 = 0; + let mut x717: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x716, &mut x717, x715, x641, x691); + let mut x718: u32 = 0; + let mut x719: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x718, &mut x719, x717, x643, x693); + let mut x720: u32 = 0; + let mut x721: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x720, &mut x721, x719, x645, x695); + let mut x722: u32 = 0; + let mut x723: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x722, &mut x723, x721, x647, x697); + let mut x724: u32 = 0; + let mut x725: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x724, &mut x725, x723, x649, x699); + let mut x726: u32 = 0; + let mut x727: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x726, &mut x727, x725, x651, x701); + let mut x728: u32 = 0; + let mut x729: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x728, &mut x729, x727, x653, x703); + let x730: u32 = ((x729 as u32) + (x654 as u32)); + let mut x731: u32 = 0; + let mut x732: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x731, &mut x732, x5, (arg2[11])); + let mut x733: u32 = 0; + let mut x734: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x733, &mut x734, x5, (arg2[10])); + let mut x735: u32 = 0; + let mut x736: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x735, &mut x736, x5, (arg2[9])); + let mut x737: u32 = 0; + let mut x738: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x737, &mut x738, x5, (arg2[8])); + let mut x739: u32 = 0; + let mut x740: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x739, &mut x740, x5, (arg2[7])); + let mut x741: u32 = 0; + let mut x742: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x741, &mut x742, x5, (arg2[6])); + let mut x743: u32 = 0; + let mut x744: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x743, &mut x744, x5, (arg2[5])); + let mut x745: u32 = 0; + let mut x746: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x745, &mut x746, x5, (arg2[4])); + let mut x747: u32 = 0; + let mut x748: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x747, &mut x748, x5, (arg2[3])); + let mut x749: u32 = 0; + let mut x750: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x749, &mut x750, x5, (arg2[2])); + let mut x751: u32 = 0; + let mut x752: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x751, &mut x752, x5, (arg2[1])); + let mut x753: u32 = 0; + let mut x754: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x753, &mut x754, x5, (arg2[0])); + let mut x755: u32 = 0; + let mut x756: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x755, &mut x756, 0x0, x754, x751); + let mut x757: u32 = 0; + let mut x758: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x757, &mut x758, x756, x752, x749); + let mut x759: u32 = 0; + let mut x760: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x759, &mut x760, x758, x750, x747); + let mut x761: u32 = 0; + let mut x762: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x761, &mut x762, x760, x748, x745); + let mut x763: u32 = 0; + let mut x764: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x763, &mut x764, x762, x746, x743); + let mut x765: u32 = 0; + let mut x766: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x765, &mut x766, x764, x744, x741); + let mut x767: u32 = 0; + let mut x768: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x767, &mut x768, x766, x742, x739); + let mut x769: u32 = 0; + let mut x770: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x769, &mut x770, x768, x740, x737); + let mut x771: u32 = 0; + let mut x772: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x771, &mut x772, x770, x738, x735); + let mut x773: u32 = 0; + let mut x774: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x773, &mut x774, x772, x736, x733); + let mut x775: u32 = 0; + let mut x776: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x775, &mut x776, x774, x734, x731); + let x777: u32 = ((x776 as u32) + x732); + let mut x778: u32 = 0; + let mut x779: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x778, &mut x779, 0x0, x706, x753); + let mut x780: u32 = 0; + let mut x781: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x780, &mut x781, x779, x708, x755); + let mut x782: u32 = 0; + let mut x783: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x782, &mut x783, x781, x710, x757); + let mut x784: u32 = 0; + let mut x785: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x784, &mut x785, x783, x712, x759); + let mut x786: u32 = 0; + let mut x787: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x786, &mut x787, x785, x714, x761); + let mut x788: u32 = 0; + let mut x789: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x788, &mut x789, x787, x716, x763); + let mut x790: u32 = 0; + let mut x791: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x790, &mut x791, x789, x718, x765); + let mut x792: u32 = 0; + let mut x793: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x792, &mut x793, x791, x720, x767); + let mut x794: u32 = 0; + let mut x795: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x794, &mut x795, x793, x722, x769); + let mut x796: u32 = 0; + let mut x797: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x796, &mut x797, x795, x724, x771); + let mut x798: u32 = 0; + let mut x799: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x798, &mut x799, x797, x726, x773); + let mut x800: u32 = 0; + let mut x801: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x800, &mut x801, x799, x728, x775); + let mut x802: u32 = 0; + let mut x803: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x802, &mut x803, x801, x730, x777); + let mut x804: u32 = 0; + let mut x805: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x804, &mut x805, x778, 0xe88fdc45); + let mut x806: u32 = 0; + let mut x807: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x806, &mut x807, x804, 0xffffffff); + let mut x808: u32 = 0; + let mut x809: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x808, &mut x809, x804, 0xffffffff); + let mut x810: u32 = 0; + let mut x811: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x810, &mut x811, x804, 0xffffffff); + let mut x812: u32 = 0; + let mut x813: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x812, &mut x813, x804, 0xffffffff); + let mut x814: u32 = 0; + let mut x815: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x814, &mut x815, x804, 0xffffffff); + let mut x816: u32 = 0; + let mut x817: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x816, &mut x817, x804, 0xffffffff); + let mut x818: u32 = 0; + let mut x819: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x818, &mut x819, x804, 0xc7634d81); + let mut x820: u32 = 0; + let mut x821: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x820, &mut x821, x804, 0xf4372ddf); + let mut x822: u32 = 0; + let mut x823: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x822, &mut x823, x804, 0x581a0db2); + let mut x824: u32 = 0; + let mut x825: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x824, &mut x825, x804, 0x48b0a77a); + let mut x826: u32 = 0; + let mut x827: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x826, &mut x827, x804, 0xecec196a); + let mut x828: u32 = 0; + let mut x829: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x828, &mut x829, x804, 0xccc52973); + let mut x830: u32 = 0; + let mut x831: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x830, &mut x831, 0x0, x829, x826); + let mut x832: u32 = 0; + let mut x833: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x832, &mut x833, x831, x827, x824); + let mut x834: u32 = 0; + let mut x835: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x834, &mut x835, x833, x825, x822); + let mut x836: u32 = 0; + let mut x837: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x836, &mut x837, x835, x823, x820); + let mut x838: u32 = 0; + let mut x839: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x838, &mut x839, x837, x821, x818); + let mut x840: u32 = 0; + let mut x841: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x840, &mut x841, x839, x819, x816); + let mut x842: u32 = 0; + let mut x843: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x842, &mut x843, x841, x817, x814); + let mut x844: u32 = 0; + let mut x845: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x844, &mut x845, x843, x815, x812); + let mut x846: u32 = 0; + let mut x847: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x846, &mut x847, x845, x813, x810); + let mut x848: u32 = 0; + let mut x849: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x848, &mut x849, x847, x811, x808); + let mut x850: u32 = 0; + let mut x851: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x850, &mut x851, x849, x809, x806); + let x852: u32 = ((x851 as u32) + x807); + let mut x853: u32 = 0; + let mut x854: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x853, &mut x854, 0x0, x778, x828); + let mut x855: u32 = 0; + let mut x856: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x855, &mut x856, x854, x780, x830); + let mut x857: u32 = 0; + let mut x858: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x857, &mut x858, x856, x782, x832); + let mut x859: u32 = 0; + let mut x860: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x859, &mut x860, x858, x784, x834); + let mut x861: u32 = 0; + let mut x862: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x861, &mut x862, x860, x786, x836); + let mut x863: u32 = 0; + let mut x864: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x863, &mut x864, x862, x788, x838); + let mut x865: u32 = 0; + let mut x866: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x865, &mut x866, x864, x790, x840); + let mut x867: u32 = 0; + let mut x868: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x867, &mut x868, x866, x792, x842); + let mut x869: u32 = 0; + let mut x870: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x869, &mut x870, x868, x794, x844); + let mut x871: u32 = 0; + let mut x872: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x871, &mut x872, x870, x796, x846); + let mut x873: u32 = 0; + let mut x874: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x873, &mut x874, x872, x798, x848); + let mut x875: u32 = 0; + let mut x876: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x875, &mut x876, x874, x800, x850); + let mut x877: u32 = 0; + let mut x878: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x877, &mut x878, x876, x802, x852); + let x879: u32 = ((x878 as u32) + (x803 as u32)); + let mut x880: u32 = 0; + let mut x881: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x880, &mut x881, x6, (arg2[11])); + let mut x882: u32 = 0; + let mut x883: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x882, &mut x883, x6, (arg2[10])); + let mut x884: u32 = 0; + let mut x885: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x884, &mut x885, x6, (arg2[9])); + let mut x886: u32 = 0; + let mut x887: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x886, &mut x887, x6, (arg2[8])); + let mut x888: u32 = 0; + let mut x889: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x888, &mut x889, x6, (arg2[7])); + let mut x890: u32 = 0; + let mut x891: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x890, &mut x891, x6, (arg2[6])); + let mut x892: u32 = 0; + let mut x893: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x892, &mut x893, x6, (arg2[5])); + let mut x894: u32 = 0; + let mut x895: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x894, &mut x895, x6, (arg2[4])); + let mut x896: u32 = 0; + let mut x897: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x896, &mut x897, x6, (arg2[3])); + let mut x898: u32 = 0; + let mut x899: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x898, &mut x899, x6, (arg2[2])); + let mut x900: u32 = 0; + let mut x901: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x900, &mut x901, x6, (arg2[1])); + let mut x902: u32 = 0; + let mut x903: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x902, &mut x903, x6, (arg2[0])); + let mut x904: u32 = 0; + let mut x905: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x904, &mut x905, 0x0, x903, x900); + let mut x906: u32 = 0; + let mut x907: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x906, &mut x907, x905, x901, x898); + let mut x908: u32 = 0; + let mut x909: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x908, &mut x909, x907, x899, x896); + let mut x910: u32 = 0; + let mut x911: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x910, &mut x911, x909, x897, x894); + let mut x912: u32 = 0; + let mut x913: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x912, &mut x913, x911, x895, x892); + let mut x914: u32 = 0; + let mut x915: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x914, &mut x915, x913, x893, x890); + let mut x916: u32 = 0; + let mut x917: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x916, &mut x917, x915, x891, x888); + let mut x918: u32 = 0; + let mut x919: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x918, &mut x919, x917, x889, x886); + let mut x920: u32 = 0; + let mut x921: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x920, &mut x921, x919, x887, x884); + let mut x922: u32 = 0; + let mut x923: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x922, &mut x923, x921, x885, x882); + let mut x924: u32 = 0; + let mut x925: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x924, &mut x925, x923, x883, x880); + let x926: u32 = ((x925 as u32) + x881); + let mut x927: u32 = 0; + let mut x928: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x927, &mut x928, 0x0, x855, x902); + let mut x929: u32 = 0; + let mut x930: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x929, &mut x930, x928, x857, x904); + let mut x931: u32 = 0; + let mut x932: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x931, &mut x932, x930, x859, x906); + let mut x933: u32 = 0; + let mut x934: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x933, &mut x934, x932, x861, x908); + let mut x935: u32 = 0; + let mut x936: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x935, &mut x936, x934, x863, x910); + let mut x937: u32 = 0; + let mut x938: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x937, &mut x938, x936, x865, x912); + let mut x939: u32 = 0; + let mut x940: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x939, &mut x940, x938, x867, x914); + let mut x941: u32 = 0; + let mut x942: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x941, &mut x942, x940, x869, x916); + let mut x943: u32 = 0; + let mut x944: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x943, &mut x944, x942, x871, x918); + let mut x945: u32 = 0; + let mut x946: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x945, &mut x946, x944, x873, x920); + let mut x947: u32 = 0; + let mut x948: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x947, &mut x948, x946, x875, x922); + let mut x949: u32 = 0; + let mut x950: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x949, &mut x950, x948, x877, x924); + let mut x951: u32 = 0; + let mut x952: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x951, &mut x952, x950, x879, x926); + let mut x953: u32 = 0; + let mut x954: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x953, &mut x954, x927, 0xe88fdc45); + let mut x955: u32 = 0; + let mut x956: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x955, &mut x956, x953, 0xffffffff); + let mut x957: u32 = 0; + let mut x958: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x957, &mut x958, x953, 0xffffffff); + let mut x959: u32 = 0; + let mut x960: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x959, &mut x960, x953, 0xffffffff); + let mut x961: u32 = 0; + let mut x962: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x961, &mut x962, x953, 0xffffffff); + let mut x963: u32 = 0; + let mut x964: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x963, &mut x964, x953, 0xffffffff); + let mut x965: u32 = 0; + let mut x966: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x965, &mut x966, x953, 0xffffffff); + let mut x967: u32 = 0; + let mut x968: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x967, &mut x968, x953, 0xc7634d81); + let mut x969: u32 = 0; + let mut x970: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x969, &mut x970, x953, 0xf4372ddf); + let mut x971: u32 = 0; + let mut x972: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x971, &mut x972, x953, 0x581a0db2); + let mut x973: u32 = 0; + let mut x974: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x973, &mut x974, x953, 0x48b0a77a); + let mut x975: u32 = 0; + let mut x976: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x975, &mut x976, x953, 0xecec196a); + let mut x977: u32 = 0; + let mut x978: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x977, &mut x978, x953, 0xccc52973); + let mut x979: u32 = 0; + let mut x980: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x979, &mut x980, 0x0, x978, x975); + let mut x981: u32 = 0; + let mut x982: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x981, &mut x982, x980, x976, x973); + let mut x983: u32 = 0; + let mut x984: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x983, &mut x984, x982, x974, x971); + let mut x985: u32 = 0; + let mut x986: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x985, &mut x986, x984, x972, x969); + let mut x987: u32 = 0; + let mut x988: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x987, &mut x988, x986, x970, x967); + let mut x989: u32 = 0; + let mut x990: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x989, &mut x990, x988, x968, x965); + let mut x991: u32 = 0; + let mut x992: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x991, &mut x992, x990, x966, x963); + let mut x993: u32 = 0; + let mut x994: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x993, &mut x994, x992, x964, x961); + let mut x995: u32 = 0; + let mut x996: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x995, &mut x996, x994, x962, x959); + let mut x997: u32 = 0; + let mut x998: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x997, &mut x998, x996, x960, x957); + let mut x999: u32 = 0; + let mut x1000: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x999, &mut x1000, x998, x958, x955); + let x1001: u32 = ((x1000 as u32) + x956); + let mut x1002: u32 = 0; + let mut x1003: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1002, &mut x1003, 0x0, x927, x977); + let mut x1004: u32 = 0; + let mut x1005: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1004, &mut x1005, x1003, x929, x979); + let mut x1006: u32 = 0; + let mut x1007: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1006, &mut x1007, x1005, x931, x981); + let mut x1008: u32 = 0; + let mut x1009: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1008, &mut x1009, x1007, x933, x983); + let mut x1010: u32 = 0; + let mut x1011: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1010, &mut x1011, x1009, x935, x985); + let mut x1012: u32 = 0; + let mut x1013: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1012, &mut x1013, x1011, x937, x987); + let mut x1014: u32 = 0; + let mut x1015: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1014, &mut x1015, x1013, x939, x989); + let mut x1016: u32 = 0; + let mut x1017: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1016, &mut x1017, x1015, x941, x991); + let mut x1018: u32 = 0; + let mut x1019: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1018, &mut x1019, x1017, x943, x993); + let mut x1020: u32 = 0; + let mut x1021: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1020, &mut x1021, x1019, x945, x995); + let mut x1022: u32 = 0; + let mut x1023: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1022, &mut x1023, x1021, x947, x997); + let mut x1024: u32 = 0; + let mut x1025: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1024, &mut x1025, x1023, x949, x999); + let mut x1026: u32 = 0; + let mut x1027: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1026, &mut x1027, x1025, x951, x1001); + let x1028: u32 = ((x1027 as u32) + (x952 as u32)); + let mut x1029: u32 = 0; + let mut x1030: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1029, &mut x1030, x7, (arg2[11])); + let mut x1031: u32 = 0; + let mut x1032: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1031, &mut x1032, x7, (arg2[10])); + let mut x1033: u32 = 0; + let mut x1034: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1033, &mut x1034, x7, (arg2[9])); + let mut x1035: u32 = 0; + let mut x1036: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1035, &mut x1036, x7, (arg2[8])); + let mut x1037: u32 = 0; + let mut x1038: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1037, &mut x1038, x7, (arg2[7])); + let mut x1039: u32 = 0; + let mut x1040: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1039, &mut x1040, x7, (arg2[6])); + let mut x1041: u32 = 0; + let mut x1042: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1041, &mut x1042, x7, (arg2[5])); + let mut x1043: u32 = 0; + let mut x1044: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1043, &mut x1044, x7, (arg2[4])); + let mut x1045: u32 = 0; + let mut x1046: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1045, &mut x1046, x7, (arg2[3])); + let mut x1047: u32 = 0; + let mut x1048: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1047, &mut x1048, x7, (arg2[2])); + let mut x1049: u32 = 0; + let mut x1050: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1049, &mut x1050, x7, (arg2[1])); + let mut x1051: u32 = 0; + let mut x1052: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1051, &mut x1052, x7, (arg2[0])); + let mut x1053: u32 = 0; + let mut x1054: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1053, &mut x1054, 0x0, x1052, x1049); + let mut x1055: u32 = 0; + let mut x1056: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1055, &mut x1056, x1054, x1050, x1047); + let mut x1057: u32 = 0; + let mut x1058: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1057, &mut x1058, x1056, x1048, x1045); + let mut x1059: u32 = 0; + let mut x1060: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1059, &mut x1060, x1058, x1046, x1043); + let mut x1061: u32 = 0; + let mut x1062: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1061, &mut x1062, x1060, x1044, x1041); + let mut x1063: u32 = 0; + let mut x1064: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1063, &mut x1064, x1062, x1042, x1039); + let mut x1065: u32 = 0; + let mut x1066: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1065, &mut x1066, x1064, x1040, x1037); + let mut x1067: u32 = 0; + let mut x1068: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1067, &mut x1068, x1066, x1038, x1035); + let mut x1069: u32 = 0; + let mut x1070: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1069, &mut x1070, x1068, x1036, x1033); + let mut x1071: u32 = 0; + let mut x1072: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1071, &mut x1072, x1070, x1034, x1031); + let mut x1073: u32 = 0; + let mut x1074: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1073, &mut x1074, x1072, x1032, x1029); + let x1075: u32 = ((x1074 as u32) + x1030); + let mut x1076: u32 = 0; + let mut x1077: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1076, &mut x1077, 0x0, x1004, x1051); + let mut x1078: u32 = 0; + let mut x1079: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1078, &mut x1079, x1077, x1006, x1053); + let mut x1080: u32 = 0; + let mut x1081: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1080, &mut x1081, x1079, x1008, x1055); + let mut x1082: u32 = 0; + let mut x1083: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1082, &mut x1083, x1081, x1010, x1057); + let mut x1084: u32 = 0; + let mut x1085: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1084, &mut x1085, x1083, x1012, x1059); + let mut x1086: u32 = 0; + let mut x1087: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1086, &mut x1087, x1085, x1014, x1061); + let mut x1088: u32 = 0; + let mut x1089: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1088, &mut x1089, x1087, x1016, x1063); + let mut x1090: u32 = 0; + let mut x1091: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1090, &mut x1091, x1089, x1018, x1065); + let mut x1092: u32 = 0; + let mut x1093: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1092, &mut x1093, x1091, x1020, x1067); + let mut x1094: u32 = 0; + let mut x1095: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1094, &mut x1095, x1093, x1022, x1069); + let mut x1096: u32 = 0; + let mut x1097: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1096, &mut x1097, x1095, x1024, x1071); + let mut x1098: u32 = 0; + let mut x1099: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1098, &mut x1099, x1097, x1026, x1073); + let mut x1100: u32 = 0; + let mut x1101: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1100, &mut x1101, x1099, x1028, x1075); + let mut x1102: u32 = 0; + let mut x1103: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1102, &mut x1103, x1076, 0xe88fdc45); + let mut x1104: u32 = 0; + let mut x1105: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1104, &mut x1105, x1102, 0xffffffff); + let mut x1106: u32 = 0; + let mut x1107: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1106, &mut x1107, x1102, 0xffffffff); + let mut x1108: u32 = 0; + let mut x1109: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1108, &mut x1109, x1102, 0xffffffff); + let mut x1110: u32 = 0; + let mut x1111: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1110, &mut x1111, x1102, 0xffffffff); + let mut x1112: u32 = 0; + let mut x1113: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1112, &mut x1113, x1102, 0xffffffff); + let mut x1114: u32 = 0; + let mut x1115: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1114, &mut x1115, x1102, 0xffffffff); + let mut x1116: u32 = 0; + let mut x1117: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1116, &mut x1117, x1102, 0xc7634d81); + let mut x1118: u32 = 0; + let mut x1119: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1118, &mut x1119, x1102, 0xf4372ddf); + let mut x1120: u32 = 0; + let mut x1121: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1120, &mut x1121, x1102, 0x581a0db2); + let mut x1122: u32 = 0; + let mut x1123: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1122, &mut x1123, x1102, 0x48b0a77a); + let mut x1124: u32 = 0; + let mut x1125: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1124, &mut x1125, x1102, 0xecec196a); + let mut x1126: u32 = 0; + let mut x1127: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1126, &mut x1127, x1102, 0xccc52973); + let mut x1128: u32 = 0; + let mut x1129: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1128, &mut x1129, 0x0, x1127, x1124); + let mut x1130: u32 = 0; + let mut x1131: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1130, &mut x1131, x1129, x1125, x1122); + let mut x1132: u32 = 0; + let mut x1133: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1132, &mut x1133, x1131, x1123, x1120); + let mut x1134: u32 = 0; + let mut x1135: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1134, &mut x1135, x1133, x1121, x1118); + let mut x1136: u32 = 0; + let mut x1137: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1136, &mut x1137, x1135, x1119, x1116); + let mut x1138: u32 = 0; + let mut x1139: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1138, &mut x1139, x1137, x1117, x1114); + let mut x1140: u32 = 0; + let mut x1141: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1140, &mut x1141, x1139, x1115, x1112); + let mut x1142: u32 = 0; + let mut x1143: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1142, &mut x1143, x1141, x1113, x1110); + let mut x1144: u32 = 0; + let mut x1145: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1144, &mut x1145, x1143, x1111, x1108); + let mut x1146: u32 = 0; + let mut x1147: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1146, &mut x1147, x1145, x1109, x1106); + let mut x1148: u32 = 0; + let mut x1149: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1148, &mut x1149, x1147, x1107, x1104); + let x1150: u32 = ((x1149 as u32) + x1105); + let mut x1151: u32 = 0; + let mut x1152: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1151, &mut x1152, 0x0, x1076, x1126); + let mut x1153: u32 = 0; + let mut x1154: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1153, &mut x1154, x1152, x1078, x1128); + let mut x1155: u32 = 0; + let mut x1156: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1155, &mut x1156, x1154, x1080, x1130); + let mut x1157: u32 = 0; + let mut x1158: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1157, &mut x1158, x1156, x1082, x1132); + let mut x1159: u32 = 0; + let mut x1160: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1159, &mut x1160, x1158, x1084, x1134); + let mut x1161: u32 = 0; + let mut x1162: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1161, &mut x1162, x1160, x1086, x1136); + let mut x1163: u32 = 0; + let mut x1164: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1163, &mut x1164, x1162, x1088, x1138); + let mut x1165: u32 = 0; + let mut x1166: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1165, &mut x1166, x1164, x1090, x1140); + let mut x1167: u32 = 0; + let mut x1168: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1167, &mut x1168, x1166, x1092, x1142); + let mut x1169: u32 = 0; + let mut x1170: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1169, &mut x1170, x1168, x1094, x1144); + let mut x1171: u32 = 0; + let mut x1172: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1171, &mut x1172, x1170, x1096, x1146); + let mut x1173: u32 = 0; + let mut x1174: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1173, &mut x1174, x1172, x1098, x1148); + let mut x1175: u32 = 0; + let mut x1176: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1175, &mut x1176, x1174, x1100, x1150); + let x1177: u32 = ((x1176 as u32) + (x1101 as u32)); + let mut x1178: u32 = 0; + let mut x1179: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1178, &mut x1179, x8, (arg2[11])); + let mut x1180: u32 = 0; + let mut x1181: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1180, &mut x1181, x8, (arg2[10])); + let mut x1182: u32 = 0; + let mut x1183: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1182, &mut x1183, x8, (arg2[9])); + let mut x1184: u32 = 0; + let mut x1185: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1184, &mut x1185, x8, (arg2[8])); + let mut x1186: u32 = 0; + let mut x1187: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1186, &mut x1187, x8, (arg2[7])); + let mut x1188: u32 = 0; + let mut x1189: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1188, &mut x1189, x8, (arg2[6])); + let mut x1190: u32 = 0; + let mut x1191: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1190, &mut x1191, x8, (arg2[5])); + let mut x1192: u32 = 0; + let mut x1193: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1192, &mut x1193, x8, (arg2[4])); + let mut x1194: u32 = 0; + let mut x1195: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1194, &mut x1195, x8, (arg2[3])); + let mut x1196: u32 = 0; + let mut x1197: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1196, &mut x1197, x8, (arg2[2])); + let mut x1198: u32 = 0; + let mut x1199: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1198, &mut x1199, x8, (arg2[1])); + let mut x1200: u32 = 0; + let mut x1201: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1200, &mut x1201, x8, (arg2[0])); + let mut x1202: u32 = 0; + let mut x1203: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1202, &mut x1203, 0x0, x1201, x1198); + let mut x1204: u32 = 0; + let mut x1205: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1204, &mut x1205, x1203, x1199, x1196); + let mut x1206: u32 = 0; + let mut x1207: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1206, &mut x1207, x1205, x1197, x1194); + let mut x1208: u32 = 0; + let mut x1209: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1208, &mut x1209, x1207, x1195, x1192); + let mut x1210: u32 = 0; + let mut x1211: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1210, &mut x1211, x1209, x1193, x1190); + let mut x1212: u32 = 0; + let mut x1213: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1212, &mut x1213, x1211, x1191, x1188); + let mut x1214: u32 = 0; + let mut x1215: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1214, &mut x1215, x1213, x1189, x1186); + let mut x1216: u32 = 0; + let mut x1217: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1216, &mut x1217, x1215, x1187, x1184); + let mut x1218: u32 = 0; + let mut x1219: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1218, &mut x1219, x1217, x1185, x1182); + let mut x1220: u32 = 0; + let mut x1221: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1220, &mut x1221, x1219, x1183, x1180); + let mut x1222: u32 = 0; + let mut x1223: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1222, &mut x1223, x1221, x1181, x1178); + let x1224: u32 = ((x1223 as u32) + x1179); + let mut x1225: u32 = 0; + let mut x1226: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1225, &mut x1226, 0x0, x1153, x1200); + let mut x1227: u32 = 0; + let mut x1228: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1227, &mut x1228, x1226, x1155, x1202); + let mut x1229: u32 = 0; + let mut x1230: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1229, &mut x1230, x1228, x1157, x1204); + let mut x1231: u32 = 0; + let mut x1232: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1231, &mut x1232, x1230, x1159, x1206); + let mut x1233: u32 = 0; + let mut x1234: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1233, &mut x1234, x1232, x1161, x1208); + let mut x1235: u32 = 0; + let mut x1236: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1235, &mut x1236, x1234, x1163, x1210); + let mut x1237: u32 = 0; + let mut x1238: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1237, &mut x1238, x1236, x1165, x1212); + let mut x1239: u32 = 0; + let mut x1240: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1239, &mut x1240, x1238, x1167, x1214); + let mut x1241: u32 = 0; + let mut x1242: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1241, &mut x1242, x1240, x1169, x1216); + let mut x1243: u32 = 0; + let mut x1244: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1243, &mut x1244, x1242, x1171, x1218); + let mut x1245: u32 = 0; + let mut x1246: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1245, &mut x1246, x1244, x1173, x1220); + let mut x1247: u32 = 0; + let mut x1248: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1247, &mut x1248, x1246, x1175, x1222); + let mut x1249: u32 = 0; + let mut x1250: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1249, &mut x1250, x1248, x1177, x1224); + let mut x1251: u32 = 0; + let mut x1252: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1251, &mut x1252, x1225, 0xe88fdc45); + let mut x1253: u32 = 0; + let mut x1254: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1253, &mut x1254, x1251, 0xffffffff); + let mut x1255: u32 = 0; + let mut x1256: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1255, &mut x1256, x1251, 0xffffffff); + let mut x1257: u32 = 0; + let mut x1258: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1257, &mut x1258, x1251, 0xffffffff); + let mut x1259: u32 = 0; + let mut x1260: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1259, &mut x1260, x1251, 0xffffffff); + let mut x1261: u32 = 0; + let mut x1262: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1261, &mut x1262, x1251, 0xffffffff); + let mut x1263: u32 = 0; + let mut x1264: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1263, &mut x1264, x1251, 0xffffffff); + let mut x1265: u32 = 0; + let mut x1266: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1265, &mut x1266, x1251, 0xc7634d81); + let mut x1267: u32 = 0; + let mut x1268: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1267, &mut x1268, x1251, 0xf4372ddf); + let mut x1269: u32 = 0; + let mut x1270: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1269, &mut x1270, x1251, 0x581a0db2); + let mut x1271: u32 = 0; + let mut x1272: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1271, &mut x1272, x1251, 0x48b0a77a); + let mut x1273: u32 = 0; + let mut x1274: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1273, &mut x1274, x1251, 0xecec196a); + let mut x1275: u32 = 0; + let mut x1276: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1275, &mut x1276, x1251, 0xccc52973); + let mut x1277: u32 = 0; + let mut x1278: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1277, &mut x1278, 0x0, x1276, x1273); + let mut x1279: u32 = 0; + let mut x1280: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1279, &mut x1280, x1278, x1274, x1271); + let mut x1281: u32 = 0; + let mut x1282: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1281, &mut x1282, x1280, x1272, x1269); + let mut x1283: u32 = 0; + let mut x1284: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1283, &mut x1284, x1282, x1270, x1267); + let mut x1285: u32 = 0; + let mut x1286: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1285, &mut x1286, x1284, x1268, x1265); + let mut x1287: u32 = 0; + let mut x1288: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1287, &mut x1288, x1286, x1266, x1263); + let mut x1289: u32 = 0; + let mut x1290: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1289, &mut x1290, x1288, x1264, x1261); + let mut x1291: u32 = 0; + let mut x1292: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1291, &mut x1292, x1290, x1262, x1259); + let mut x1293: u32 = 0; + let mut x1294: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1293, &mut x1294, x1292, x1260, x1257); + let mut x1295: u32 = 0; + let mut x1296: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1295, &mut x1296, x1294, x1258, x1255); + let mut x1297: u32 = 0; + let mut x1298: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1297, &mut x1298, x1296, x1256, x1253); + let x1299: u32 = ((x1298 as u32) + x1254); + let mut x1300: u32 = 0; + let mut x1301: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1300, &mut x1301, 0x0, x1225, x1275); + let mut x1302: u32 = 0; + let mut x1303: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1302, &mut x1303, x1301, x1227, x1277); + let mut x1304: u32 = 0; + let mut x1305: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1304, &mut x1305, x1303, x1229, x1279); + let mut x1306: u32 = 0; + let mut x1307: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1306, &mut x1307, x1305, x1231, x1281); + let mut x1308: u32 = 0; + let mut x1309: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1308, &mut x1309, x1307, x1233, x1283); + let mut x1310: u32 = 0; + let mut x1311: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1310, &mut x1311, x1309, x1235, x1285); + let mut x1312: u32 = 0; + let mut x1313: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1312, &mut x1313, x1311, x1237, x1287); + let mut x1314: u32 = 0; + let mut x1315: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1314, &mut x1315, x1313, x1239, x1289); + let mut x1316: u32 = 0; + let mut x1317: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1316, &mut x1317, x1315, x1241, x1291); + let mut x1318: u32 = 0; + let mut x1319: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1318, &mut x1319, x1317, x1243, x1293); + let mut x1320: u32 = 0; + let mut x1321: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1320, &mut x1321, x1319, x1245, x1295); + let mut x1322: u32 = 0; + let mut x1323: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1322, &mut x1323, x1321, x1247, x1297); + let mut x1324: u32 = 0; + let mut x1325: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1324, &mut x1325, x1323, x1249, x1299); + let x1326: u32 = ((x1325 as u32) + (x1250 as u32)); + let mut x1327: u32 = 0; + let mut x1328: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1327, &mut x1328, x9, (arg2[11])); + let mut x1329: u32 = 0; + let mut x1330: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1329, &mut x1330, x9, (arg2[10])); + let mut x1331: u32 = 0; + let mut x1332: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1331, &mut x1332, x9, (arg2[9])); + let mut x1333: u32 = 0; + let mut x1334: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1333, &mut x1334, x9, (arg2[8])); + let mut x1335: u32 = 0; + let mut x1336: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1335, &mut x1336, x9, (arg2[7])); + let mut x1337: u32 = 0; + let mut x1338: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1337, &mut x1338, x9, (arg2[6])); + let mut x1339: u32 = 0; + let mut x1340: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1339, &mut x1340, x9, (arg2[5])); + let mut x1341: u32 = 0; + let mut x1342: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1341, &mut x1342, x9, (arg2[4])); + let mut x1343: u32 = 0; + let mut x1344: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1343, &mut x1344, x9, (arg2[3])); + let mut x1345: u32 = 0; + let mut x1346: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1345, &mut x1346, x9, (arg2[2])); + let mut x1347: u32 = 0; + let mut x1348: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1347, &mut x1348, x9, (arg2[1])); + let mut x1349: u32 = 0; + let mut x1350: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1349, &mut x1350, x9, (arg2[0])); + let mut x1351: u32 = 0; + let mut x1352: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1351, &mut x1352, 0x0, x1350, x1347); + let mut x1353: u32 = 0; + let mut x1354: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1353, &mut x1354, x1352, x1348, x1345); + let mut x1355: u32 = 0; + let mut x1356: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1355, &mut x1356, x1354, x1346, x1343); + let mut x1357: u32 = 0; + let mut x1358: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1357, &mut x1358, x1356, x1344, x1341); + let mut x1359: u32 = 0; + let mut x1360: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1359, &mut x1360, x1358, x1342, x1339); + let mut x1361: u32 = 0; + let mut x1362: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1361, &mut x1362, x1360, x1340, x1337); + let mut x1363: u32 = 0; + let mut x1364: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1363, &mut x1364, x1362, x1338, x1335); + let mut x1365: u32 = 0; + let mut x1366: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1365, &mut x1366, x1364, x1336, x1333); + let mut x1367: u32 = 0; + let mut x1368: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1367, &mut x1368, x1366, x1334, x1331); + let mut x1369: u32 = 0; + let mut x1370: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1369, &mut x1370, x1368, x1332, x1329); + let mut x1371: u32 = 0; + let mut x1372: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1371, &mut x1372, x1370, x1330, x1327); + let x1373: u32 = ((x1372 as u32) + x1328); + let mut x1374: u32 = 0; + let mut x1375: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1374, &mut x1375, 0x0, x1302, x1349); + let mut x1376: u32 = 0; + let mut x1377: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1376, &mut x1377, x1375, x1304, x1351); + let mut x1378: u32 = 0; + let mut x1379: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1378, &mut x1379, x1377, x1306, x1353); + let mut x1380: u32 = 0; + let mut x1381: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1380, &mut x1381, x1379, x1308, x1355); + let mut x1382: u32 = 0; + let mut x1383: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1382, &mut x1383, x1381, x1310, x1357); + let mut x1384: u32 = 0; + let mut x1385: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1384, &mut x1385, x1383, x1312, x1359); + let mut x1386: u32 = 0; + let mut x1387: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1386, &mut x1387, x1385, x1314, x1361); + let mut x1388: u32 = 0; + let mut x1389: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1388, &mut x1389, x1387, x1316, x1363); + let mut x1390: u32 = 0; + let mut x1391: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1390, &mut x1391, x1389, x1318, x1365); + let mut x1392: u32 = 0; + let mut x1393: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1392, &mut x1393, x1391, x1320, x1367); + let mut x1394: u32 = 0; + let mut x1395: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1394, &mut x1395, x1393, x1322, x1369); + let mut x1396: u32 = 0; + let mut x1397: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1396, &mut x1397, x1395, x1324, x1371); + let mut x1398: u32 = 0; + let mut x1399: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1398, &mut x1399, x1397, x1326, x1373); + let mut x1400: u32 = 0; + let mut x1401: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1400, &mut x1401, x1374, 0xe88fdc45); + let mut x1402: u32 = 0; + let mut x1403: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1402, &mut x1403, x1400, 0xffffffff); + let mut x1404: u32 = 0; + let mut x1405: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1404, &mut x1405, x1400, 0xffffffff); + let mut x1406: u32 = 0; + let mut x1407: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1406, &mut x1407, x1400, 0xffffffff); + let mut x1408: u32 = 0; + let mut x1409: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1408, &mut x1409, x1400, 0xffffffff); + let mut x1410: u32 = 0; + let mut x1411: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1410, &mut x1411, x1400, 0xffffffff); + let mut x1412: u32 = 0; + let mut x1413: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1412, &mut x1413, x1400, 0xffffffff); + let mut x1414: u32 = 0; + let mut x1415: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1414, &mut x1415, x1400, 0xc7634d81); + let mut x1416: u32 = 0; + let mut x1417: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1416, &mut x1417, x1400, 0xf4372ddf); + let mut x1418: u32 = 0; + let mut x1419: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1418, &mut x1419, x1400, 0x581a0db2); + let mut x1420: u32 = 0; + let mut x1421: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1420, &mut x1421, x1400, 0x48b0a77a); + let mut x1422: u32 = 0; + let mut x1423: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1422, &mut x1423, x1400, 0xecec196a); + let mut x1424: u32 = 0; + let mut x1425: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1424, &mut x1425, x1400, 0xccc52973); + let mut x1426: u32 = 0; + let mut x1427: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1426, &mut x1427, 0x0, x1425, x1422); + let mut x1428: u32 = 0; + let mut x1429: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1428, &mut x1429, x1427, x1423, x1420); + let mut x1430: u32 = 0; + let mut x1431: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1430, &mut x1431, x1429, x1421, x1418); + let mut x1432: u32 = 0; + let mut x1433: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1432, &mut x1433, x1431, x1419, x1416); + let mut x1434: u32 = 0; + let mut x1435: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1434, &mut x1435, x1433, x1417, x1414); + let mut x1436: u32 = 0; + let mut x1437: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1436, &mut x1437, x1435, x1415, x1412); + let mut x1438: u32 = 0; + let mut x1439: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1438, &mut x1439, x1437, x1413, x1410); + let mut x1440: u32 = 0; + let mut x1441: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1440, &mut x1441, x1439, x1411, x1408); + let mut x1442: u32 = 0; + let mut x1443: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1442, &mut x1443, x1441, x1409, x1406); + let mut x1444: u32 = 0; + let mut x1445: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1444, &mut x1445, x1443, x1407, x1404); + let mut x1446: u32 = 0; + let mut x1447: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1446, &mut x1447, x1445, x1405, x1402); + let x1448: u32 = ((x1447 as u32) + x1403); + let mut x1449: u32 = 0; + let mut x1450: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1449, &mut x1450, 0x0, x1374, x1424); + let mut x1451: u32 = 0; + let mut x1452: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1451, &mut x1452, x1450, x1376, x1426); + let mut x1453: u32 = 0; + let mut x1454: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1453, &mut x1454, x1452, x1378, x1428); + let mut x1455: u32 = 0; + let mut x1456: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1455, &mut x1456, x1454, x1380, x1430); + let mut x1457: u32 = 0; + let mut x1458: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1457, &mut x1458, x1456, x1382, x1432); + let mut x1459: u32 = 0; + let mut x1460: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1459, &mut x1460, x1458, x1384, x1434); + let mut x1461: u32 = 0; + let mut x1462: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1461, &mut x1462, x1460, x1386, x1436); + let mut x1463: u32 = 0; + let mut x1464: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1463, &mut x1464, x1462, x1388, x1438); + let mut x1465: u32 = 0; + let mut x1466: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1465, &mut x1466, x1464, x1390, x1440); + let mut x1467: u32 = 0; + let mut x1468: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1467, &mut x1468, x1466, x1392, x1442); + let mut x1469: u32 = 0; + let mut x1470: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1469, &mut x1470, x1468, x1394, x1444); + let mut x1471: u32 = 0; + let mut x1472: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1471, &mut x1472, x1470, x1396, x1446); + let mut x1473: u32 = 0; + let mut x1474: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1473, &mut x1474, x1472, x1398, x1448); + let x1475: u32 = ((x1474 as u32) + (x1399 as u32)); + let mut x1476: u32 = 0; + let mut x1477: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1476, &mut x1477, x10, (arg2[11])); + let mut x1478: u32 = 0; + let mut x1479: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1478, &mut x1479, x10, (arg2[10])); + let mut x1480: u32 = 0; + let mut x1481: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1480, &mut x1481, x10, (arg2[9])); + let mut x1482: u32 = 0; + let mut x1483: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1482, &mut x1483, x10, (arg2[8])); + let mut x1484: u32 = 0; + let mut x1485: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1484, &mut x1485, x10, (arg2[7])); + let mut x1486: u32 = 0; + let mut x1487: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1486, &mut x1487, x10, (arg2[6])); + let mut x1488: u32 = 0; + let mut x1489: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1488, &mut x1489, x10, (arg2[5])); + let mut x1490: u32 = 0; + let mut x1491: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1490, &mut x1491, x10, (arg2[4])); + let mut x1492: u32 = 0; + let mut x1493: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1492, &mut x1493, x10, (arg2[3])); + let mut x1494: u32 = 0; + let mut x1495: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1494, &mut x1495, x10, (arg2[2])); + let mut x1496: u32 = 0; + let mut x1497: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1496, &mut x1497, x10, (arg2[1])); + let mut x1498: u32 = 0; + let mut x1499: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1498, &mut x1499, x10, (arg2[0])); + let mut x1500: u32 = 0; + let mut x1501: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1500, &mut x1501, 0x0, x1499, x1496); + let mut x1502: u32 = 0; + let mut x1503: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1502, &mut x1503, x1501, x1497, x1494); + let mut x1504: u32 = 0; + let mut x1505: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1504, &mut x1505, x1503, x1495, x1492); + let mut x1506: u32 = 0; + let mut x1507: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1506, &mut x1507, x1505, x1493, x1490); + let mut x1508: u32 = 0; + let mut x1509: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1508, &mut x1509, x1507, x1491, x1488); + let mut x1510: u32 = 0; + let mut x1511: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1510, &mut x1511, x1509, x1489, x1486); + let mut x1512: u32 = 0; + let mut x1513: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1512, &mut x1513, x1511, x1487, x1484); + let mut x1514: u32 = 0; + let mut x1515: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1514, &mut x1515, x1513, x1485, x1482); + let mut x1516: u32 = 0; + let mut x1517: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1516, &mut x1517, x1515, x1483, x1480); + let mut x1518: u32 = 0; + let mut x1519: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1518, &mut x1519, x1517, x1481, x1478); + let mut x1520: u32 = 0; + let mut x1521: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1520, &mut x1521, x1519, x1479, x1476); + let x1522: u32 = ((x1521 as u32) + x1477); + let mut x1523: u32 = 0; + let mut x1524: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1523, &mut x1524, 0x0, x1451, x1498); + let mut x1525: u32 = 0; + let mut x1526: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1525, &mut x1526, x1524, x1453, x1500); + let mut x1527: u32 = 0; + let mut x1528: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1527, &mut x1528, x1526, x1455, x1502); + let mut x1529: u32 = 0; + let mut x1530: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1529, &mut x1530, x1528, x1457, x1504); + let mut x1531: u32 = 0; + let mut x1532: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1531, &mut x1532, x1530, x1459, x1506); + let mut x1533: u32 = 0; + let mut x1534: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1533, &mut x1534, x1532, x1461, x1508); + let mut x1535: u32 = 0; + let mut x1536: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1535, &mut x1536, x1534, x1463, x1510); + let mut x1537: u32 = 0; + let mut x1538: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1537, &mut x1538, x1536, x1465, x1512); + let mut x1539: u32 = 0; + let mut x1540: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1539, &mut x1540, x1538, x1467, x1514); + let mut x1541: u32 = 0; + let mut x1542: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1541, &mut x1542, x1540, x1469, x1516); + let mut x1543: u32 = 0; + let mut x1544: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1543, &mut x1544, x1542, x1471, x1518); + let mut x1545: u32 = 0; + let mut x1546: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1545, &mut x1546, x1544, x1473, x1520); + let mut x1547: u32 = 0; + let mut x1548: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1547, &mut x1548, x1546, x1475, x1522); + let mut x1549: u32 = 0; + let mut x1550: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1549, &mut x1550, x1523, 0xe88fdc45); + let mut x1551: u32 = 0; + let mut x1552: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1551, &mut x1552, x1549, 0xffffffff); + let mut x1553: u32 = 0; + let mut x1554: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1553, &mut x1554, x1549, 0xffffffff); + let mut x1555: u32 = 0; + let mut x1556: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1555, &mut x1556, x1549, 0xffffffff); + let mut x1557: u32 = 0; + let mut x1558: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1557, &mut x1558, x1549, 0xffffffff); + let mut x1559: u32 = 0; + let mut x1560: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1559, &mut x1560, x1549, 0xffffffff); + let mut x1561: u32 = 0; + let mut x1562: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1561, &mut x1562, x1549, 0xffffffff); + let mut x1563: u32 = 0; + let mut x1564: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1563, &mut x1564, x1549, 0xc7634d81); + let mut x1565: u32 = 0; + let mut x1566: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1565, &mut x1566, x1549, 0xf4372ddf); + let mut x1567: u32 = 0; + let mut x1568: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1567, &mut x1568, x1549, 0x581a0db2); + let mut x1569: u32 = 0; + let mut x1570: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1569, &mut x1570, x1549, 0x48b0a77a); + let mut x1571: u32 = 0; + let mut x1572: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1571, &mut x1572, x1549, 0xecec196a); + let mut x1573: u32 = 0; + let mut x1574: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1573, &mut x1574, x1549, 0xccc52973); + let mut x1575: u32 = 0; + let mut x1576: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1575, &mut x1576, 0x0, x1574, x1571); + let mut x1577: u32 = 0; + let mut x1578: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1577, &mut x1578, x1576, x1572, x1569); + let mut x1579: u32 = 0; + let mut x1580: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1579, &mut x1580, x1578, x1570, x1567); + let mut x1581: u32 = 0; + let mut x1582: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1581, &mut x1582, x1580, x1568, x1565); + let mut x1583: u32 = 0; + let mut x1584: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1583, &mut x1584, x1582, x1566, x1563); + let mut x1585: u32 = 0; + let mut x1586: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1585, &mut x1586, x1584, x1564, x1561); + let mut x1587: u32 = 0; + let mut x1588: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1587, &mut x1588, x1586, x1562, x1559); + let mut x1589: u32 = 0; + let mut x1590: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1589, &mut x1590, x1588, x1560, x1557); + let mut x1591: u32 = 0; + let mut x1592: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1591, &mut x1592, x1590, x1558, x1555); + let mut x1593: u32 = 0; + let mut x1594: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1593, &mut x1594, x1592, x1556, x1553); + let mut x1595: u32 = 0; + let mut x1596: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1595, &mut x1596, x1594, x1554, x1551); + let x1597: u32 = ((x1596 as u32) + x1552); + let mut x1598: u32 = 0; + let mut x1599: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1598, &mut x1599, 0x0, x1523, x1573); + let mut x1600: u32 = 0; + let mut x1601: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1600, &mut x1601, x1599, x1525, x1575); + let mut x1602: u32 = 0; + let mut x1603: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1602, &mut x1603, x1601, x1527, x1577); + let mut x1604: u32 = 0; + let mut x1605: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1604, &mut x1605, x1603, x1529, x1579); + let mut x1606: u32 = 0; + let mut x1607: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1606, &mut x1607, x1605, x1531, x1581); + let mut x1608: u32 = 0; + let mut x1609: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1608, &mut x1609, x1607, x1533, x1583); + let mut x1610: u32 = 0; + let mut x1611: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1610, &mut x1611, x1609, x1535, x1585); + let mut x1612: u32 = 0; + let mut x1613: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1612, &mut x1613, x1611, x1537, x1587); + let mut x1614: u32 = 0; + let mut x1615: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1614, &mut x1615, x1613, x1539, x1589); + let mut x1616: u32 = 0; + let mut x1617: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1616, &mut x1617, x1615, x1541, x1591); + let mut x1618: u32 = 0; + let mut x1619: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1618, &mut x1619, x1617, x1543, x1593); + let mut x1620: u32 = 0; + let mut x1621: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1620, &mut x1621, x1619, x1545, x1595); + let mut x1622: u32 = 0; + let mut x1623: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1622, &mut x1623, x1621, x1547, x1597); + let x1624: u32 = ((x1623 as u32) + (x1548 as u32)); + let mut x1625: u32 = 0; + let mut x1626: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1625, &mut x1626, x11, (arg2[11])); + let mut x1627: u32 = 0; + let mut x1628: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1627, &mut x1628, x11, (arg2[10])); + let mut x1629: u32 = 0; + let mut x1630: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1629, &mut x1630, x11, (arg2[9])); + let mut x1631: u32 = 0; + let mut x1632: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1631, &mut x1632, x11, (arg2[8])); + let mut x1633: u32 = 0; + let mut x1634: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1633, &mut x1634, x11, (arg2[7])); + let mut x1635: u32 = 0; + let mut x1636: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1635, &mut x1636, x11, (arg2[6])); + let mut x1637: u32 = 0; + let mut x1638: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1637, &mut x1638, x11, (arg2[5])); + let mut x1639: u32 = 0; + let mut x1640: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1639, &mut x1640, x11, (arg2[4])); + let mut x1641: u32 = 0; + let mut x1642: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1641, &mut x1642, x11, (arg2[3])); + let mut x1643: u32 = 0; + let mut x1644: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1643, &mut x1644, x11, (arg2[2])); + let mut x1645: u32 = 0; + let mut x1646: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1645, &mut x1646, x11, (arg2[1])); + let mut x1647: u32 = 0; + let mut x1648: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1647, &mut x1648, x11, (arg2[0])); + let mut x1649: u32 = 0; + let mut x1650: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1649, &mut x1650, 0x0, x1648, x1645); + let mut x1651: u32 = 0; + let mut x1652: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1651, &mut x1652, x1650, x1646, x1643); + let mut x1653: u32 = 0; + let mut x1654: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1653, &mut x1654, x1652, x1644, x1641); + let mut x1655: u32 = 0; + let mut x1656: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1655, &mut x1656, x1654, x1642, x1639); + let mut x1657: u32 = 0; + let mut x1658: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1657, &mut x1658, x1656, x1640, x1637); + let mut x1659: u32 = 0; + let mut x1660: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1659, &mut x1660, x1658, x1638, x1635); + let mut x1661: u32 = 0; + let mut x1662: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1661, &mut x1662, x1660, x1636, x1633); + let mut x1663: u32 = 0; + let mut x1664: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1663, &mut x1664, x1662, x1634, x1631); + let mut x1665: u32 = 0; + let mut x1666: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1665, &mut x1666, x1664, x1632, x1629); + let mut x1667: u32 = 0; + let mut x1668: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1667, &mut x1668, x1666, x1630, x1627); + let mut x1669: u32 = 0; + let mut x1670: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1669, &mut x1670, x1668, x1628, x1625); + let x1671: u32 = ((x1670 as u32) + x1626); + let mut x1672: u32 = 0; + let mut x1673: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1672, &mut x1673, 0x0, x1600, x1647); + let mut x1674: u32 = 0; + let mut x1675: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1674, &mut x1675, x1673, x1602, x1649); + let mut x1676: u32 = 0; + let mut x1677: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1676, &mut x1677, x1675, x1604, x1651); + let mut x1678: u32 = 0; + let mut x1679: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1678, &mut x1679, x1677, x1606, x1653); + let mut x1680: u32 = 0; + let mut x1681: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1680, &mut x1681, x1679, x1608, x1655); + let mut x1682: u32 = 0; + let mut x1683: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1682, &mut x1683, x1681, x1610, x1657); + let mut x1684: u32 = 0; + let mut x1685: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1684, &mut x1685, x1683, x1612, x1659); + let mut x1686: u32 = 0; + let mut x1687: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1686, &mut x1687, x1685, x1614, x1661); + let mut x1688: u32 = 0; + let mut x1689: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1688, &mut x1689, x1687, x1616, x1663); + let mut x1690: u32 = 0; + let mut x1691: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1690, &mut x1691, x1689, x1618, x1665); + let mut x1692: u32 = 0; + let mut x1693: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1692, &mut x1693, x1691, x1620, x1667); + let mut x1694: u32 = 0; + let mut x1695: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1694, &mut x1695, x1693, x1622, x1669); + let mut x1696: u32 = 0; + let mut x1697: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1696, &mut x1697, x1695, x1624, x1671); + let mut x1698: u32 = 0; + let mut x1699: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1698, &mut x1699, x1672, 0xe88fdc45); + let mut x1700: u32 = 0; + let mut x1701: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1700, &mut x1701, x1698, 0xffffffff); + let mut x1702: u32 = 0; + let mut x1703: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1702, &mut x1703, x1698, 0xffffffff); + let mut x1704: u32 = 0; + let mut x1705: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1704, &mut x1705, x1698, 0xffffffff); + let mut x1706: u32 = 0; + let mut x1707: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1706, &mut x1707, x1698, 0xffffffff); + let mut x1708: u32 = 0; + let mut x1709: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1708, &mut x1709, x1698, 0xffffffff); + let mut x1710: u32 = 0; + let mut x1711: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1710, &mut x1711, x1698, 0xffffffff); + let mut x1712: u32 = 0; + let mut x1713: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1712, &mut x1713, x1698, 0xc7634d81); + let mut x1714: u32 = 0; + let mut x1715: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1714, &mut x1715, x1698, 0xf4372ddf); + let mut x1716: u32 = 0; + let mut x1717: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1716, &mut x1717, x1698, 0x581a0db2); + let mut x1718: u32 = 0; + let mut x1719: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1718, &mut x1719, x1698, 0x48b0a77a); + let mut x1720: u32 = 0; + let mut x1721: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1720, &mut x1721, x1698, 0xecec196a); + let mut x1722: u32 = 0; + let mut x1723: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1722, &mut x1723, x1698, 0xccc52973); + let mut x1724: u32 = 0; + let mut x1725: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1724, &mut x1725, 0x0, x1723, x1720); + let mut x1726: u32 = 0; + let mut x1727: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1726, &mut x1727, x1725, x1721, x1718); + let mut x1728: u32 = 0; + let mut x1729: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1728, &mut x1729, x1727, x1719, x1716); + let mut x1730: u32 = 0; + let mut x1731: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1730, &mut x1731, x1729, x1717, x1714); + let mut x1732: u32 = 0; + let mut x1733: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1732, &mut x1733, x1731, x1715, x1712); + let mut x1734: u32 = 0; + let mut x1735: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1734, &mut x1735, x1733, x1713, x1710); + let mut x1736: u32 = 0; + let mut x1737: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1736, &mut x1737, x1735, x1711, x1708); + let mut x1738: u32 = 0; + let mut x1739: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1738, &mut x1739, x1737, x1709, x1706); + let mut x1740: u32 = 0; + let mut x1741: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1740, &mut x1741, x1739, x1707, x1704); + let mut x1742: u32 = 0; + let mut x1743: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1742, &mut x1743, x1741, x1705, x1702); + let mut x1744: u32 = 0; + let mut x1745: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1744, &mut x1745, x1743, x1703, x1700); + let x1746: u32 = ((x1745 as u32) + x1701); + let mut x1747: u32 = 0; + let mut x1748: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1747, &mut x1748, 0x0, x1672, x1722); + let mut x1749: u32 = 0; + let mut x1750: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1749, &mut x1750, x1748, x1674, x1724); + let mut x1751: u32 = 0; + let mut x1752: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1751, &mut x1752, x1750, x1676, x1726); + let mut x1753: u32 = 0; + let mut x1754: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1753, &mut x1754, x1752, x1678, x1728); + let mut x1755: u32 = 0; + let mut x1756: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1755, &mut x1756, x1754, x1680, x1730); + let mut x1757: u32 = 0; + let mut x1758: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1757, &mut x1758, x1756, x1682, x1732); + let mut x1759: u32 = 0; + let mut x1760: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1759, &mut x1760, x1758, x1684, x1734); + let mut x1761: u32 = 0; + let mut x1762: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1761, &mut x1762, x1760, x1686, x1736); + let mut x1763: u32 = 0; + let mut x1764: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1763, &mut x1764, x1762, x1688, x1738); + let mut x1765: u32 = 0; + let mut x1766: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1765, &mut x1766, x1764, x1690, x1740); + let mut x1767: u32 = 0; + let mut x1768: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1767, &mut x1768, x1766, x1692, x1742); + let mut x1769: u32 = 0; + let mut x1770: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1769, &mut x1770, x1768, x1694, x1744); + let mut x1771: u32 = 0; + let mut x1772: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1771, &mut x1772, x1770, x1696, x1746); + let x1773: u32 = ((x1772 as u32) + (x1697 as u32)); + let mut x1774: u32 = 0; + let mut x1775: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1774, &mut x1775, 0x0, x1749, 0xccc52973); + let mut x1776: u32 = 0; + let mut x1777: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1776, &mut x1777, x1775, x1751, 0xecec196a); + let mut x1778: u32 = 0; + let mut x1779: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1778, &mut x1779, x1777, x1753, 0x48b0a77a); + let mut x1780: u32 = 0; + let mut x1781: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1780, &mut x1781, x1779, x1755, 0x581a0db2); + let mut x1782: u32 = 0; + let mut x1783: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1782, &mut x1783, x1781, x1757, 0xf4372ddf); + let mut x1784: u32 = 0; + let mut x1785: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1784, &mut x1785, x1783, x1759, 0xc7634d81); + let mut x1786: u32 = 0; + let mut x1787: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1786, &mut x1787, x1785, x1761, 0xffffffff); + let mut x1788: u32 = 0; + let mut x1789: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1788, &mut x1789, x1787, x1763, 0xffffffff); + let mut x1790: u32 = 0; + let mut x1791: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1790, &mut x1791, x1789, x1765, 0xffffffff); + let mut x1792: u32 = 0; + let mut x1793: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1792, &mut x1793, x1791, x1767, 0xffffffff); + let mut x1794: u32 = 0; + let mut x1795: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1794, &mut x1795, x1793, x1769, 0xffffffff); + let mut x1796: u32 = 0; + let mut x1797: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1796, &mut x1797, x1795, x1771, 0xffffffff); + let mut x1798: u32 = 0; + let mut x1799: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1798, &mut x1799, x1797, x1773, (0x0 as u32)); + let mut x1800: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1800, x1799, x1774, x1749); + let mut x1801: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1801, x1799, x1776, x1751); + let mut x1802: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1802, x1799, x1778, x1753); + let mut x1803: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1803, x1799, x1780, x1755); + let mut x1804: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1804, x1799, x1782, x1757); + let mut x1805: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1805, x1799, x1784, x1759); + let mut x1806: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1806, x1799, x1786, x1761); + let mut x1807: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1807, x1799, x1788, x1763); + let mut x1808: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1808, x1799, x1790, x1765); + let mut x1809: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1809, x1799, x1792, x1767); + let mut x1810: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1810, x1799, x1794, x1769); + let mut x1811: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1811, x1799, x1796, x1771); + out1[0] = x1800; + out1[1] = x1801; + out1[2] = x1802; + out1[3] = x1803; + out1[4] = x1804; + out1[5] = x1805; + out1[6] = x1806; + out1[7] = x1807; + out1[8] = x1808; + out1[9] = x1809; + out1[10] = x1810; + out1[11] = x1811; +} + +/// The function fiat_p384_scalar_square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_square(out1: &mut fiat_p384_scalar_montgomery_domain_field_element, arg1: &fiat_p384_scalar_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[1]); + let x2: u32 = (arg1[2]); + let x3: u32 = (arg1[3]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[5]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[7]); + let x8: u32 = (arg1[8]); + let x9: u32 = (arg1[9]); + let x10: u32 = (arg1[10]); + let x11: u32 = (arg1[11]); + let x12: u32 = (arg1[0]); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x13, &mut x14, x12, (arg1[11])); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x15, &mut x16, x12, (arg1[10])); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x17, &mut x18, x12, (arg1[9])); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x19, &mut x20, x12, (arg1[8])); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x21, &mut x22, x12, (arg1[7])); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x23, &mut x24, x12, (arg1[6])); + let mut x25: u32 = 0; + let mut x26: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x25, &mut x26, x12, (arg1[5])); + let mut x27: u32 = 0; + let mut x28: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x27, &mut x28, x12, (arg1[4])); + let mut x29: u32 = 0; + let mut x30: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x29, &mut x30, x12, (arg1[3])); + let mut x31: u32 = 0; + let mut x32: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x31, &mut x32, x12, (arg1[2])); + let mut x33: u32 = 0; + let mut x34: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x33, &mut x34, x12, (arg1[1])); + let mut x35: u32 = 0; + let mut x36: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x35, &mut x36, x12, (arg1[0])); + let mut x37: u32 = 0; + let mut x38: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x37, &mut x38, 0x0, x36, x33); + let mut x39: u32 = 0; + let mut x40: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x39, &mut x40, x38, x34, x31); + let mut x41: u32 = 0; + let mut x42: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x41, &mut x42, x40, x32, x29); + let mut x43: u32 = 0; + let mut x44: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x43, &mut x44, x42, x30, x27); + let mut x45: u32 = 0; + let mut x46: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x45, &mut x46, x44, x28, x25); + let mut x47: u32 = 0; + let mut x48: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x47, &mut x48, x46, x26, x23); + let mut x49: u32 = 0; + let mut x50: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x49, &mut x50, x48, x24, x21); + let mut x51: u32 = 0; + let mut x52: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x51, &mut x52, x50, x22, x19); + let mut x53: u32 = 0; + let mut x54: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x53, &mut x54, x52, x20, x17); + let mut x55: u32 = 0; + let mut x56: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x55, &mut x56, x54, x18, x15); + let mut x57: u32 = 0; + let mut x58: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x57, &mut x58, x56, x16, x13); + let x59: u32 = ((x58 as u32) + x14); + let mut x60: u32 = 0; + let mut x61: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x60, &mut x61, x35, 0xe88fdc45); + let mut x62: u32 = 0; + let mut x63: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x62, &mut x63, x60, 0xffffffff); + let mut x64: u32 = 0; + let mut x65: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x64, &mut x65, x60, 0xffffffff); + let mut x66: u32 = 0; + let mut x67: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x66, &mut x67, x60, 0xffffffff); + let mut x68: u32 = 0; + let mut x69: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x68, &mut x69, x60, 0xffffffff); + let mut x70: u32 = 0; + let mut x71: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x70, &mut x71, x60, 0xffffffff); + let mut x72: u32 = 0; + let mut x73: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x72, &mut x73, x60, 0xffffffff); + let mut x74: u32 = 0; + let mut x75: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x74, &mut x75, x60, 0xc7634d81); + let mut x76: u32 = 0; + let mut x77: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x76, &mut x77, x60, 0xf4372ddf); + let mut x78: u32 = 0; + let mut x79: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x78, &mut x79, x60, 0x581a0db2); + let mut x80: u32 = 0; + let mut x81: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x80, &mut x81, x60, 0x48b0a77a); + let mut x82: u32 = 0; + let mut x83: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x82, &mut x83, x60, 0xecec196a); + let mut x84: u32 = 0; + let mut x85: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x84, &mut x85, x60, 0xccc52973); + let mut x86: u32 = 0; + let mut x87: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x86, &mut x87, 0x0, x85, x82); + let mut x88: u32 = 0; + let mut x89: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x88, &mut x89, x87, x83, x80); + let mut x90: u32 = 0; + let mut x91: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x90, &mut x91, x89, x81, x78); + let mut x92: u32 = 0; + let mut x93: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x92, &mut x93, x91, x79, x76); + let mut x94: u32 = 0; + let mut x95: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x94, &mut x95, x93, x77, x74); + let mut x96: u32 = 0; + let mut x97: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x96, &mut x97, x95, x75, x72); + let mut x98: u32 = 0; + let mut x99: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x98, &mut x99, x97, x73, x70); + let mut x100: u32 = 0; + let mut x101: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x100, &mut x101, x99, x71, x68); + let mut x102: u32 = 0; + let mut x103: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x102, &mut x103, x101, x69, x66); + let mut x104: u32 = 0; + let mut x105: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x104, &mut x105, x103, x67, x64); + let mut x106: u32 = 0; + let mut x107: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x106, &mut x107, x105, x65, x62); + let x108: u32 = ((x107 as u32) + x63); + let mut x109: u32 = 0; + let mut x110: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x109, &mut x110, 0x0, x35, x84); + let mut x111: u32 = 0; + let mut x112: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x37, x86); + let mut x113: u32 = 0; + let mut x114: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x113, &mut x114, x112, x39, x88); + let mut x115: u32 = 0; + let mut x116: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x115, &mut x116, x114, x41, x90); + let mut x117: u32 = 0; + let mut x118: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x117, &mut x118, x116, x43, x92); + let mut x119: u32 = 0; + let mut x120: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x119, &mut x120, x118, x45, x94); + let mut x121: u32 = 0; + let mut x122: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x121, &mut x122, x120, x47, x96); + let mut x123: u32 = 0; + let mut x124: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x123, &mut x124, x122, x49, x98); + let mut x125: u32 = 0; + let mut x126: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x125, &mut x126, x124, x51, x100); + let mut x127: u32 = 0; + let mut x128: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x127, &mut x128, x126, x53, x102); + let mut x129: u32 = 0; + let mut x130: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x129, &mut x130, x128, x55, x104); + let mut x131: u32 = 0; + let mut x132: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x131, &mut x132, x130, x57, x106); + let mut x133: u32 = 0; + let mut x134: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x133, &mut x134, x132, x59, x108); + let mut x135: u32 = 0; + let mut x136: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x135, &mut x136, x1, (arg1[11])); + let mut x137: u32 = 0; + let mut x138: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x137, &mut x138, x1, (arg1[10])); + let mut x139: u32 = 0; + let mut x140: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x139, &mut x140, x1, (arg1[9])); + let mut x141: u32 = 0; + let mut x142: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x141, &mut x142, x1, (arg1[8])); + let mut x143: u32 = 0; + let mut x144: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x143, &mut x144, x1, (arg1[7])); + let mut x145: u32 = 0; + let mut x146: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x145, &mut x146, x1, (arg1[6])); + let mut x147: u32 = 0; + let mut x148: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x147, &mut x148, x1, (arg1[5])); + let mut x149: u32 = 0; + let mut x150: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x149, &mut x150, x1, (arg1[4])); + let mut x151: u32 = 0; + let mut x152: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x151, &mut x152, x1, (arg1[3])); + let mut x153: u32 = 0; + let mut x154: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x153, &mut x154, x1, (arg1[2])); + let mut x155: u32 = 0; + let mut x156: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x155, &mut x156, x1, (arg1[1])); + let mut x157: u32 = 0; + let mut x158: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x157, &mut x158, x1, (arg1[0])); + let mut x159: u32 = 0; + let mut x160: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x159, &mut x160, 0x0, x158, x155); + let mut x161: u32 = 0; + let mut x162: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x161, &mut x162, x160, x156, x153); + let mut x163: u32 = 0; + let mut x164: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x163, &mut x164, x162, x154, x151); + let mut x165: u32 = 0; + let mut x166: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x165, &mut x166, x164, x152, x149); + let mut x167: u32 = 0; + let mut x168: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x167, &mut x168, x166, x150, x147); + let mut x169: u32 = 0; + let mut x170: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x169, &mut x170, x168, x148, x145); + let mut x171: u32 = 0; + let mut x172: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x171, &mut x172, x170, x146, x143); + let mut x173: u32 = 0; + let mut x174: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x173, &mut x174, x172, x144, x141); + let mut x175: u32 = 0; + let mut x176: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x175, &mut x176, x174, x142, x139); + let mut x177: u32 = 0; + let mut x178: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x177, &mut x178, x176, x140, x137); + let mut x179: u32 = 0; + let mut x180: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x179, &mut x180, x178, x138, x135); + let x181: u32 = ((x180 as u32) + x136); + let mut x182: u32 = 0; + let mut x183: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x182, &mut x183, 0x0, x111, x157); + let mut x184: u32 = 0; + let mut x185: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x184, &mut x185, x183, x113, x159); + let mut x186: u32 = 0; + let mut x187: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x186, &mut x187, x185, x115, x161); + let mut x188: u32 = 0; + let mut x189: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x188, &mut x189, x187, x117, x163); + let mut x190: u32 = 0; + let mut x191: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x190, &mut x191, x189, x119, x165); + let mut x192: u32 = 0; + let mut x193: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x192, &mut x193, x191, x121, x167); + let mut x194: u32 = 0; + let mut x195: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x194, &mut x195, x193, x123, x169); + let mut x196: u32 = 0; + let mut x197: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x196, &mut x197, x195, x125, x171); + let mut x198: u32 = 0; + let mut x199: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x198, &mut x199, x197, x127, x173); + let mut x200: u32 = 0; + let mut x201: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x200, &mut x201, x199, x129, x175); + let mut x202: u32 = 0; + let mut x203: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x202, &mut x203, x201, x131, x177); + let mut x204: u32 = 0; + let mut x205: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x204, &mut x205, x203, x133, x179); + let mut x206: u32 = 0; + let mut x207: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x206, &mut x207, x205, (x134 as u32), x181); + let mut x208: u32 = 0; + let mut x209: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x208, &mut x209, x182, 0xe88fdc45); + let mut x210: u32 = 0; + let mut x211: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x210, &mut x211, x208, 0xffffffff); + let mut x212: u32 = 0; + let mut x213: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x212, &mut x213, x208, 0xffffffff); + let mut x214: u32 = 0; + let mut x215: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x214, &mut x215, x208, 0xffffffff); + let mut x216: u32 = 0; + let mut x217: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x216, &mut x217, x208, 0xffffffff); + let mut x218: u32 = 0; + let mut x219: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x218, &mut x219, x208, 0xffffffff); + let mut x220: u32 = 0; + let mut x221: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x220, &mut x221, x208, 0xffffffff); + let mut x222: u32 = 0; + let mut x223: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x222, &mut x223, x208, 0xc7634d81); + let mut x224: u32 = 0; + let mut x225: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x224, &mut x225, x208, 0xf4372ddf); + let mut x226: u32 = 0; + let mut x227: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x226, &mut x227, x208, 0x581a0db2); + let mut x228: u32 = 0; + let mut x229: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x228, &mut x229, x208, 0x48b0a77a); + let mut x230: u32 = 0; + let mut x231: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x230, &mut x231, x208, 0xecec196a); + let mut x232: u32 = 0; + let mut x233: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x232, &mut x233, x208, 0xccc52973); + let mut x234: u32 = 0; + let mut x235: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x234, &mut x235, 0x0, x233, x230); + let mut x236: u32 = 0; + let mut x237: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x236, &mut x237, x235, x231, x228); + let mut x238: u32 = 0; + let mut x239: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x238, &mut x239, x237, x229, x226); + let mut x240: u32 = 0; + let mut x241: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x240, &mut x241, x239, x227, x224); + let mut x242: u32 = 0; + let mut x243: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x242, &mut x243, x241, x225, x222); + let mut x244: u32 = 0; + let mut x245: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x244, &mut x245, x243, x223, x220); + let mut x246: u32 = 0; + let mut x247: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x246, &mut x247, x245, x221, x218); + let mut x248: u32 = 0; + let mut x249: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x248, &mut x249, x247, x219, x216); + let mut x250: u32 = 0; + let mut x251: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x250, &mut x251, x249, x217, x214); + let mut x252: u32 = 0; + let mut x253: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x252, &mut x253, x251, x215, x212); + let mut x254: u32 = 0; + let mut x255: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x254, &mut x255, x253, x213, x210); + let x256: u32 = ((x255 as u32) + x211); + let mut x257: u32 = 0; + let mut x258: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x257, &mut x258, 0x0, x182, x232); + let mut x259: u32 = 0; + let mut x260: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x259, &mut x260, x258, x184, x234); + let mut x261: u32 = 0; + let mut x262: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x261, &mut x262, x260, x186, x236); + let mut x263: u32 = 0; + let mut x264: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x263, &mut x264, x262, x188, x238); + let mut x265: u32 = 0; + let mut x266: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x265, &mut x266, x264, x190, x240); + let mut x267: u32 = 0; + let mut x268: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x267, &mut x268, x266, x192, x242); + let mut x269: u32 = 0; + let mut x270: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x269, &mut x270, x268, x194, x244); + let mut x271: u32 = 0; + let mut x272: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x271, &mut x272, x270, x196, x246); + let mut x273: u32 = 0; + let mut x274: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x273, &mut x274, x272, x198, x248); + let mut x275: u32 = 0; + let mut x276: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x275, &mut x276, x274, x200, x250); + let mut x277: u32 = 0; + let mut x278: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x277, &mut x278, x276, x202, x252); + let mut x279: u32 = 0; + let mut x280: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x279, &mut x280, x278, x204, x254); + let mut x281: u32 = 0; + let mut x282: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x281, &mut x282, x280, x206, x256); + let x283: u32 = ((x282 as u32) + (x207 as u32)); + let mut x284: u32 = 0; + let mut x285: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x284, &mut x285, x2, (arg1[11])); + let mut x286: u32 = 0; + let mut x287: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x286, &mut x287, x2, (arg1[10])); + let mut x288: u32 = 0; + let mut x289: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x288, &mut x289, x2, (arg1[9])); + let mut x290: u32 = 0; + let mut x291: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x290, &mut x291, x2, (arg1[8])); + let mut x292: u32 = 0; + let mut x293: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x292, &mut x293, x2, (arg1[7])); + let mut x294: u32 = 0; + let mut x295: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x294, &mut x295, x2, (arg1[6])); + let mut x296: u32 = 0; + let mut x297: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x296, &mut x297, x2, (arg1[5])); + let mut x298: u32 = 0; + let mut x299: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x298, &mut x299, x2, (arg1[4])); + let mut x300: u32 = 0; + let mut x301: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x300, &mut x301, x2, (arg1[3])); + let mut x302: u32 = 0; + let mut x303: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x302, &mut x303, x2, (arg1[2])); + let mut x304: u32 = 0; + let mut x305: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x304, &mut x305, x2, (arg1[1])); + let mut x306: u32 = 0; + let mut x307: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x306, &mut x307, x2, (arg1[0])); + let mut x308: u32 = 0; + let mut x309: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x308, &mut x309, 0x0, x307, x304); + let mut x310: u32 = 0; + let mut x311: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x310, &mut x311, x309, x305, x302); + let mut x312: u32 = 0; + let mut x313: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x312, &mut x313, x311, x303, x300); + let mut x314: u32 = 0; + let mut x315: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x314, &mut x315, x313, x301, x298); + let mut x316: u32 = 0; + let mut x317: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x316, &mut x317, x315, x299, x296); + let mut x318: u32 = 0; + let mut x319: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x318, &mut x319, x317, x297, x294); + let mut x320: u32 = 0; + let mut x321: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x320, &mut x321, x319, x295, x292); + let mut x322: u32 = 0; + let mut x323: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x322, &mut x323, x321, x293, x290); + let mut x324: u32 = 0; + let mut x325: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x324, &mut x325, x323, x291, x288); + let mut x326: u32 = 0; + let mut x327: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x326, &mut x327, x325, x289, x286); + let mut x328: u32 = 0; + let mut x329: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x328, &mut x329, x327, x287, x284); + let x330: u32 = ((x329 as u32) + x285); + let mut x331: u32 = 0; + let mut x332: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x331, &mut x332, 0x0, x259, x306); + let mut x333: u32 = 0; + let mut x334: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x333, &mut x334, x332, x261, x308); + let mut x335: u32 = 0; + let mut x336: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x335, &mut x336, x334, x263, x310); + let mut x337: u32 = 0; + let mut x338: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x337, &mut x338, x336, x265, x312); + let mut x339: u32 = 0; + let mut x340: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x339, &mut x340, x338, x267, x314); + let mut x341: u32 = 0; + let mut x342: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x341, &mut x342, x340, x269, x316); + let mut x343: u32 = 0; + let mut x344: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x343, &mut x344, x342, x271, x318); + let mut x345: u32 = 0; + let mut x346: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x345, &mut x346, x344, x273, x320); + let mut x347: u32 = 0; + let mut x348: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x347, &mut x348, x346, x275, x322); + let mut x349: u32 = 0; + let mut x350: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x349, &mut x350, x348, x277, x324); + let mut x351: u32 = 0; + let mut x352: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x351, &mut x352, x350, x279, x326); + let mut x353: u32 = 0; + let mut x354: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x353, &mut x354, x352, x281, x328); + let mut x355: u32 = 0; + let mut x356: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x355, &mut x356, x354, x283, x330); + let mut x357: u32 = 0; + let mut x358: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x357, &mut x358, x331, 0xe88fdc45); + let mut x359: u32 = 0; + let mut x360: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x359, &mut x360, x357, 0xffffffff); + let mut x361: u32 = 0; + let mut x362: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x361, &mut x362, x357, 0xffffffff); + let mut x363: u32 = 0; + let mut x364: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x363, &mut x364, x357, 0xffffffff); + let mut x365: u32 = 0; + let mut x366: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x365, &mut x366, x357, 0xffffffff); + let mut x367: u32 = 0; + let mut x368: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x367, &mut x368, x357, 0xffffffff); + let mut x369: u32 = 0; + let mut x370: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x369, &mut x370, x357, 0xffffffff); + let mut x371: u32 = 0; + let mut x372: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x371, &mut x372, x357, 0xc7634d81); + let mut x373: u32 = 0; + let mut x374: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x373, &mut x374, x357, 0xf4372ddf); + let mut x375: u32 = 0; + let mut x376: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x375, &mut x376, x357, 0x581a0db2); + let mut x377: u32 = 0; + let mut x378: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x377, &mut x378, x357, 0x48b0a77a); + let mut x379: u32 = 0; + let mut x380: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x379, &mut x380, x357, 0xecec196a); + let mut x381: u32 = 0; + let mut x382: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x381, &mut x382, x357, 0xccc52973); + let mut x383: u32 = 0; + let mut x384: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x383, &mut x384, 0x0, x382, x379); + let mut x385: u32 = 0; + let mut x386: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x385, &mut x386, x384, x380, x377); + let mut x387: u32 = 0; + let mut x388: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x387, &mut x388, x386, x378, x375); + let mut x389: u32 = 0; + let mut x390: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x389, &mut x390, x388, x376, x373); + let mut x391: u32 = 0; + let mut x392: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x391, &mut x392, x390, x374, x371); + let mut x393: u32 = 0; + let mut x394: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x393, &mut x394, x392, x372, x369); + let mut x395: u32 = 0; + let mut x396: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x395, &mut x396, x394, x370, x367); + let mut x397: u32 = 0; + let mut x398: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x397, &mut x398, x396, x368, x365); + let mut x399: u32 = 0; + let mut x400: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x399, &mut x400, x398, x366, x363); + let mut x401: u32 = 0; + let mut x402: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x401, &mut x402, x400, x364, x361); + let mut x403: u32 = 0; + let mut x404: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x403, &mut x404, x402, x362, x359); + let x405: u32 = ((x404 as u32) + x360); + let mut x406: u32 = 0; + let mut x407: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x406, &mut x407, 0x0, x331, x381); + let mut x408: u32 = 0; + let mut x409: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x408, &mut x409, x407, x333, x383); + let mut x410: u32 = 0; + let mut x411: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x410, &mut x411, x409, x335, x385); + let mut x412: u32 = 0; + let mut x413: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x412, &mut x413, x411, x337, x387); + let mut x414: u32 = 0; + let mut x415: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x414, &mut x415, x413, x339, x389); + let mut x416: u32 = 0; + let mut x417: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x416, &mut x417, x415, x341, x391); + let mut x418: u32 = 0; + let mut x419: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x418, &mut x419, x417, x343, x393); + let mut x420: u32 = 0; + let mut x421: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x420, &mut x421, x419, x345, x395); + let mut x422: u32 = 0; + let mut x423: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x422, &mut x423, x421, x347, x397); + let mut x424: u32 = 0; + let mut x425: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x424, &mut x425, x423, x349, x399); + let mut x426: u32 = 0; + let mut x427: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x426, &mut x427, x425, x351, x401); + let mut x428: u32 = 0; + let mut x429: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x428, &mut x429, x427, x353, x403); + let mut x430: u32 = 0; + let mut x431: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x430, &mut x431, x429, x355, x405); + let x432: u32 = ((x431 as u32) + (x356 as u32)); + let mut x433: u32 = 0; + let mut x434: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x433, &mut x434, x3, (arg1[11])); + let mut x435: u32 = 0; + let mut x436: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x435, &mut x436, x3, (arg1[10])); + let mut x437: u32 = 0; + let mut x438: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x437, &mut x438, x3, (arg1[9])); + let mut x439: u32 = 0; + let mut x440: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x439, &mut x440, x3, (arg1[8])); + let mut x441: u32 = 0; + let mut x442: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x441, &mut x442, x3, (arg1[7])); + let mut x443: u32 = 0; + let mut x444: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x443, &mut x444, x3, (arg1[6])); + let mut x445: u32 = 0; + let mut x446: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x445, &mut x446, x3, (arg1[5])); + let mut x447: u32 = 0; + let mut x448: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x447, &mut x448, x3, (arg1[4])); + let mut x449: u32 = 0; + let mut x450: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x449, &mut x450, x3, (arg1[3])); + let mut x451: u32 = 0; + let mut x452: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x451, &mut x452, x3, (arg1[2])); + let mut x453: u32 = 0; + let mut x454: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x453, &mut x454, x3, (arg1[1])); + let mut x455: u32 = 0; + let mut x456: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x455, &mut x456, x3, (arg1[0])); + let mut x457: u32 = 0; + let mut x458: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x457, &mut x458, 0x0, x456, x453); + let mut x459: u32 = 0; + let mut x460: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x459, &mut x460, x458, x454, x451); + let mut x461: u32 = 0; + let mut x462: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x461, &mut x462, x460, x452, x449); + let mut x463: u32 = 0; + let mut x464: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x463, &mut x464, x462, x450, x447); + let mut x465: u32 = 0; + let mut x466: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x465, &mut x466, x464, x448, x445); + let mut x467: u32 = 0; + let mut x468: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x467, &mut x468, x466, x446, x443); + let mut x469: u32 = 0; + let mut x470: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x469, &mut x470, x468, x444, x441); + let mut x471: u32 = 0; + let mut x472: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x471, &mut x472, x470, x442, x439); + let mut x473: u32 = 0; + let mut x474: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x473, &mut x474, x472, x440, x437); + let mut x475: u32 = 0; + let mut x476: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x475, &mut x476, x474, x438, x435); + let mut x477: u32 = 0; + let mut x478: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x477, &mut x478, x476, x436, x433); + let x479: u32 = ((x478 as u32) + x434); + let mut x480: u32 = 0; + let mut x481: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x480, &mut x481, 0x0, x408, x455); + let mut x482: u32 = 0; + let mut x483: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x482, &mut x483, x481, x410, x457); + let mut x484: u32 = 0; + let mut x485: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x484, &mut x485, x483, x412, x459); + let mut x486: u32 = 0; + let mut x487: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x486, &mut x487, x485, x414, x461); + let mut x488: u32 = 0; + let mut x489: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x488, &mut x489, x487, x416, x463); + let mut x490: u32 = 0; + let mut x491: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x490, &mut x491, x489, x418, x465); + let mut x492: u32 = 0; + let mut x493: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x492, &mut x493, x491, x420, x467); + let mut x494: u32 = 0; + let mut x495: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x494, &mut x495, x493, x422, x469); + let mut x496: u32 = 0; + let mut x497: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x496, &mut x497, x495, x424, x471); + let mut x498: u32 = 0; + let mut x499: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x498, &mut x499, x497, x426, x473); + let mut x500: u32 = 0; + let mut x501: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x500, &mut x501, x499, x428, x475); + let mut x502: u32 = 0; + let mut x503: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x502, &mut x503, x501, x430, x477); + let mut x504: u32 = 0; + let mut x505: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x504, &mut x505, x503, x432, x479); + let mut x506: u32 = 0; + let mut x507: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x506, &mut x507, x480, 0xe88fdc45); + let mut x508: u32 = 0; + let mut x509: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x508, &mut x509, x506, 0xffffffff); + let mut x510: u32 = 0; + let mut x511: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x510, &mut x511, x506, 0xffffffff); + let mut x512: u32 = 0; + let mut x513: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x512, &mut x513, x506, 0xffffffff); + let mut x514: u32 = 0; + let mut x515: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x514, &mut x515, x506, 0xffffffff); + let mut x516: u32 = 0; + let mut x517: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x516, &mut x517, x506, 0xffffffff); + let mut x518: u32 = 0; + let mut x519: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x518, &mut x519, x506, 0xffffffff); + let mut x520: u32 = 0; + let mut x521: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x520, &mut x521, x506, 0xc7634d81); + let mut x522: u32 = 0; + let mut x523: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x522, &mut x523, x506, 0xf4372ddf); + let mut x524: u32 = 0; + let mut x525: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x524, &mut x525, x506, 0x581a0db2); + let mut x526: u32 = 0; + let mut x527: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x526, &mut x527, x506, 0x48b0a77a); + let mut x528: u32 = 0; + let mut x529: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x528, &mut x529, x506, 0xecec196a); + let mut x530: u32 = 0; + let mut x531: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x530, &mut x531, x506, 0xccc52973); + let mut x532: u32 = 0; + let mut x533: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x532, &mut x533, 0x0, x531, x528); + let mut x534: u32 = 0; + let mut x535: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x534, &mut x535, x533, x529, x526); + let mut x536: u32 = 0; + let mut x537: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x536, &mut x537, x535, x527, x524); + let mut x538: u32 = 0; + let mut x539: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x538, &mut x539, x537, x525, x522); + let mut x540: u32 = 0; + let mut x541: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x540, &mut x541, x539, x523, x520); + let mut x542: u32 = 0; + let mut x543: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x542, &mut x543, x541, x521, x518); + let mut x544: u32 = 0; + let mut x545: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x544, &mut x545, x543, x519, x516); + let mut x546: u32 = 0; + let mut x547: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x546, &mut x547, x545, x517, x514); + let mut x548: u32 = 0; + let mut x549: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x548, &mut x549, x547, x515, x512); + let mut x550: u32 = 0; + let mut x551: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x550, &mut x551, x549, x513, x510); + let mut x552: u32 = 0; + let mut x553: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x552, &mut x553, x551, x511, x508); + let x554: u32 = ((x553 as u32) + x509); + let mut x555: u32 = 0; + let mut x556: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x555, &mut x556, 0x0, x480, x530); + let mut x557: u32 = 0; + let mut x558: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x557, &mut x558, x556, x482, x532); + let mut x559: u32 = 0; + let mut x560: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x559, &mut x560, x558, x484, x534); + let mut x561: u32 = 0; + let mut x562: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x561, &mut x562, x560, x486, x536); + let mut x563: u32 = 0; + let mut x564: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x563, &mut x564, x562, x488, x538); + let mut x565: u32 = 0; + let mut x566: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x565, &mut x566, x564, x490, x540); + let mut x567: u32 = 0; + let mut x568: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x567, &mut x568, x566, x492, x542); + let mut x569: u32 = 0; + let mut x570: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x569, &mut x570, x568, x494, x544); + let mut x571: u32 = 0; + let mut x572: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x571, &mut x572, x570, x496, x546); + let mut x573: u32 = 0; + let mut x574: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x573, &mut x574, x572, x498, x548); + let mut x575: u32 = 0; + let mut x576: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x575, &mut x576, x574, x500, x550); + let mut x577: u32 = 0; + let mut x578: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x577, &mut x578, x576, x502, x552); + let mut x579: u32 = 0; + let mut x580: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x579, &mut x580, x578, x504, x554); + let x581: u32 = ((x580 as u32) + (x505 as u32)); + let mut x582: u32 = 0; + let mut x583: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x582, &mut x583, x4, (arg1[11])); + let mut x584: u32 = 0; + let mut x585: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x584, &mut x585, x4, (arg1[10])); + let mut x586: u32 = 0; + let mut x587: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x586, &mut x587, x4, (arg1[9])); + let mut x588: u32 = 0; + let mut x589: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x588, &mut x589, x4, (arg1[8])); + let mut x590: u32 = 0; + let mut x591: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x590, &mut x591, x4, (arg1[7])); + let mut x592: u32 = 0; + let mut x593: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x592, &mut x593, x4, (arg1[6])); + let mut x594: u32 = 0; + let mut x595: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x594, &mut x595, x4, (arg1[5])); + let mut x596: u32 = 0; + let mut x597: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x596, &mut x597, x4, (arg1[4])); + let mut x598: u32 = 0; + let mut x599: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x598, &mut x599, x4, (arg1[3])); + let mut x600: u32 = 0; + let mut x601: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x600, &mut x601, x4, (arg1[2])); + let mut x602: u32 = 0; + let mut x603: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x602, &mut x603, x4, (arg1[1])); + let mut x604: u32 = 0; + let mut x605: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x604, &mut x605, x4, (arg1[0])); + let mut x606: u32 = 0; + let mut x607: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x606, &mut x607, 0x0, x605, x602); + let mut x608: u32 = 0; + let mut x609: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x608, &mut x609, x607, x603, x600); + let mut x610: u32 = 0; + let mut x611: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x610, &mut x611, x609, x601, x598); + let mut x612: u32 = 0; + let mut x613: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x612, &mut x613, x611, x599, x596); + let mut x614: u32 = 0; + let mut x615: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x614, &mut x615, x613, x597, x594); + let mut x616: u32 = 0; + let mut x617: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x616, &mut x617, x615, x595, x592); + let mut x618: u32 = 0; + let mut x619: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x618, &mut x619, x617, x593, x590); + let mut x620: u32 = 0; + let mut x621: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x620, &mut x621, x619, x591, x588); + let mut x622: u32 = 0; + let mut x623: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x622, &mut x623, x621, x589, x586); + let mut x624: u32 = 0; + let mut x625: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x624, &mut x625, x623, x587, x584); + let mut x626: u32 = 0; + let mut x627: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x626, &mut x627, x625, x585, x582); + let x628: u32 = ((x627 as u32) + x583); + let mut x629: u32 = 0; + let mut x630: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x629, &mut x630, 0x0, x557, x604); + let mut x631: u32 = 0; + let mut x632: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x631, &mut x632, x630, x559, x606); + let mut x633: u32 = 0; + let mut x634: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x633, &mut x634, x632, x561, x608); + let mut x635: u32 = 0; + let mut x636: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x635, &mut x636, x634, x563, x610); + let mut x637: u32 = 0; + let mut x638: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x637, &mut x638, x636, x565, x612); + let mut x639: u32 = 0; + let mut x640: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x639, &mut x640, x638, x567, x614); + let mut x641: u32 = 0; + let mut x642: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x641, &mut x642, x640, x569, x616); + let mut x643: u32 = 0; + let mut x644: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x643, &mut x644, x642, x571, x618); + let mut x645: u32 = 0; + let mut x646: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x645, &mut x646, x644, x573, x620); + let mut x647: u32 = 0; + let mut x648: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x647, &mut x648, x646, x575, x622); + let mut x649: u32 = 0; + let mut x650: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x649, &mut x650, x648, x577, x624); + let mut x651: u32 = 0; + let mut x652: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x651, &mut x652, x650, x579, x626); + let mut x653: u32 = 0; + let mut x654: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x653, &mut x654, x652, x581, x628); + let mut x655: u32 = 0; + let mut x656: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x655, &mut x656, x629, 0xe88fdc45); + let mut x657: u32 = 0; + let mut x658: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x657, &mut x658, x655, 0xffffffff); + let mut x659: u32 = 0; + let mut x660: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x659, &mut x660, x655, 0xffffffff); + let mut x661: u32 = 0; + let mut x662: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x661, &mut x662, x655, 0xffffffff); + let mut x663: u32 = 0; + let mut x664: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x663, &mut x664, x655, 0xffffffff); + let mut x665: u32 = 0; + let mut x666: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x665, &mut x666, x655, 0xffffffff); + let mut x667: u32 = 0; + let mut x668: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x667, &mut x668, x655, 0xffffffff); + let mut x669: u32 = 0; + let mut x670: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x669, &mut x670, x655, 0xc7634d81); + let mut x671: u32 = 0; + let mut x672: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x671, &mut x672, x655, 0xf4372ddf); + let mut x673: u32 = 0; + let mut x674: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x673, &mut x674, x655, 0x581a0db2); + let mut x675: u32 = 0; + let mut x676: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x675, &mut x676, x655, 0x48b0a77a); + let mut x677: u32 = 0; + let mut x678: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x677, &mut x678, x655, 0xecec196a); + let mut x679: u32 = 0; + let mut x680: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x679, &mut x680, x655, 0xccc52973); + let mut x681: u32 = 0; + let mut x682: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x681, &mut x682, 0x0, x680, x677); + let mut x683: u32 = 0; + let mut x684: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x683, &mut x684, x682, x678, x675); + let mut x685: u32 = 0; + let mut x686: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x685, &mut x686, x684, x676, x673); + let mut x687: u32 = 0; + let mut x688: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x687, &mut x688, x686, x674, x671); + let mut x689: u32 = 0; + let mut x690: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x689, &mut x690, x688, x672, x669); + let mut x691: u32 = 0; + let mut x692: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x691, &mut x692, x690, x670, x667); + let mut x693: u32 = 0; + let mut x694: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x693, &mut x694, x692, x668, x665); + let mut x695: u32 = 0; + let mut x696: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x695, &mut x696, x694, x666, x663); + let mut x697: u32 = 0; + let mut x698: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x697, &mut x698, x696, x664, x661); + let mut x699: u32 = 0; + let mut x700: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x699, &mut x700, x698, x662, x659); + let mut x701: u32 = 0; + let mut x702: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x701, &mut x702, x700, x660, x657); + let x703: u32 = ((x702 as u32) + x658); + let mut x704: u32 = 0; + let mut x705: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x704, &mut x705, 0x0, x629, x679); + let mut x706: u32 = 0; + let mut x707: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x706, &mut x707, x705, x631, x681); + let mut x708: u32 = 0; + let mut x709: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x708, &mut x709, x707, x633, x683); + let mut x710: u32 = 0; + let mut x711: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x710, &mut x711, x709, x635, x685); + let mut x712: u32 = 0; + let mut x713: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x712, &mut x713, x711, x637, x687); + let mut x714: u32 = 0; + let mut x715: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x714, &mut x715, x713, x639, x689); + let mut x716: u32 = 0; + let mut x717: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x716, &mut x717, x715, x641, x691); + let mut x718: u32 = 0; + let mut x719: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x718, &mut x719, x717, x643, x693); + let mut x720: u32 = 0; + let mut x721: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x720, &mut x721, x719, x645, x695); + let mut x722: u32 = 0; + let mut x723: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x722, &mut x723, x721, x647, x697); + let mut x724: u32 = 0; + let mut x725: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x724, &mut x725, x723, x649, x699); + let mut x726: u32 = 0; + let mut x727: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x726, &mut x727, x725, x651, x701); + let mut x728: u32 = 0; + let mut x729: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x728, &mut x729, x727, x653, x703); + let x730: u32 = ((x729 as u32) + (x654 as u32)); + let mut x731: u32 = 0; + let mut x732: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x731, &mut x732, x5, (arg1[11])); + let mut x733: u32 = 0; + let mut x734: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x733, &mut x734, x5, (arg1[10])); + let mut x735: u32 = 0; + let mut x736: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x735, &mut x736, x5, (arg1[9])); + let mut x737: u32 = 0; + let mut x738: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x737, &mut x738, x5, (arg1[8])); + let mut x739: u32 = 0; + let mut x740: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x739, &mut x740, x5, (arg1[7])); + let mut x741: u32 = 0; + let mut x742: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x741, &mut x742, x5, (arg1[6])); + let mut x743: u32 = 0; + let mut x744: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x743, &mut x744, x5, (arg1[5])); + let mut x745: u32 = 0; + let mut x746: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x745, &mut x746, x5, (arg1[4])); + let mut x747: u32 = 0; + let mut x748: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x747, &mut x748, x5, (arg1[3])); + let mut x749: u32 = 0; + let mut x750: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x749, &mut x750, x5, (arg1[2])); + let mut x751: u32 = 0; + let mut x752: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x751, &mut x752, x5, (arg1[1])); + let mut x753: u32 = 0; + let mut x754: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x753, &mut x754, x5, (arg1[0])); + let mut x755: u32 = 0; + let mut x756: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x755, &mut x756, 0x0, x754, x751); + let mut x757: u32 = 0; + let mut x758: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x757, &mut x758, x756, x752, x749); + let mut x759: u32 = 0; + let mut x760: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x759, &mut x760, x758, x750, x747); + let mut x761: u32 = 0; + let mut x762: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x761, &mut x762, x760, x748, x745); + let mut x763: u32 = 0; + let mut x764: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x763, &mut x764, x762, x746, x743); + let mut x765: u32 = 0; + let mut x766: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x765, &mut x766, x764, x744, x741); + let mut x767: u32 = 0; + let mut x768: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x767, &mut x768, x766, x742, x739); + let mut x769: u32 = 0; + let mut x770: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x769, &mut x770, x768, x740, x737); + let mut x771: u32 = 0; + let mut x772: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x771, &mut x772, x770, x738, x735); + let mut x773: u32 = 0; + let mut x774: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x773, &mut x774, x772, x736, x733); + let mut x775: u32 = 0; + let mut x776: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x775, &mut x776, x774, x734, x731); + let x777: u32 = ((x776 as u32) + x732); + let mut x778: u32 = 0; + let mut x779: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x778, &mut x779, 0x0, x706, x753); + let mut x780: u32 = 0; + let mut x781: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x780, &mut x781, x779, x708, x755); + let mut x782: u32 = 0; + let mut x783: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x782, &mut x783, x781, x710, x757); + let mut x784: u32 = 0; + let mut x785: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x784, &mut x785, x783, x712, x759); + let mut x786: u32 = 0; + let mut x787: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x786, &mut x787, x785, x714, x761); + let mut x788: u32 = 0; + let mut x789: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x788, &mut x789, x787, x716, x763); + let mut x790: u32 = 0; + let mut x791: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x790, &mut x791, x789, x718, x765); + let mut x792: u32 = 0; + let mut x793: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x792, &mut x793, x791, x720, x767); + let mut x794: u32 = 0; + let mut x795: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x794, &mut x795, x793, x722, x769); + let mut x796: u32 = 0; + let mut x797: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x796, &mut x797, x795, x724, x771); + let mut x798: u32 = 0; + let mut x799: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x798, &mut x799, x797, x726, x773); + let mut x800: u32 = 0; + let mut x801: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x800, &mut x801, x799, x728, x775); + let mut x802: u32 = 0; + let mut x803: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x802, &mut x803, x801, x730, x777); + let mut x804: u32 = 0; + let mut x805: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x804, &mut x805, x778, 0xe88fdc45); + let mut x806: u32 = 0; + let mut x807: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x806, &mut x807, x804, 0xffffffff); + let mut x808: u32 = 0; + let mut x809: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x808, &mut x809, x804, 0xffffffff); + let mut x810: u32 = 0; + let mut x811: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x810, &mut x811, x804, 0xffffffff); + let mut x812: u32 = 0; + let mut x813: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x812, &mut x813, x804, 0xffffffff); + let mut x814: u32 = 0; + let mut x815: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x814, &mut x815, x804, 0xffffffff); + let mut x816: u32 = 0; + let mut x817: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x816, &mut x817, x804, 0xffffffff); + let mut x818: u32 = 0; + let mut x819: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x818, &mut x819, x804, 0xc7634d81); + let mut x820: u32 = 0; + let mut x821: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x820, &mut x821, x804, 0xf4372ddf); + let mut x822: u32 = 0; + let mut x823: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x822, &mut x823, x804, 0x581a0db2); + let mut x824: u32 = 0; + let mut x825: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x824, &mut x825, x804, 0x48b0a77a); + let mut x826: u32 = 0; + let mut x827: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x826, &mut x827, x804, 0xecec196a); + let mut x828: u32 = 0; + let mut x829: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x828, &mut x829, x804, 0xccc52973); + let mut x830: u32 = 0; + let mut x831: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x830, &mut x831, 0x0, x829, x826); + let mut x832: u32 = 0; + let mut x833: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x832, &mut x833, x831, x827, x824); + let mut x834: u32 = 0; + let mut x835: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x834, &mut x835, x833, x825, x822); + let mut x836: u32 = 0; + let mut x837: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x836, &mut x837, x835, x823, x820); + let mut x838: u32 = 0; + let mut x839: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x838, &mut x839, x837, x821, x818); + let mut x840: u32 = 0; + let mut x841: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x840, &mut x841, x839, x819, x816); + let mut x842: u32 = 0; + let mut x843: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x842, &mut x843, x841, x817, x814); + let mut x844: u32 = 0; + let mut x845: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x844, &mut x845, x843, x815, x812); + let mut x846: u32 = 0; + let mut x847: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x846, &mut x847, x845, x813, x810); + let mut x848: u32 = 0; + let mut x849: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x848, &mut x849, x847, x811, x808); + let mut x850: u32 = 0; + let mut x851: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x850, &mut x851, x849, x809, x806); + let x852: u32 = ((x851 as u32) + x807); + let mut x853: u32 = 0; + let mut x854: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x853, &mut x854, 0x0, x778, x828); + let mut x855: u32 = 0; + let mut x856: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x855, &mut x856, x854, x780, x830); + let mut x857: u32 = 0; + let mut x858: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x857, &mut x858, x856, x782, x832); + let mut x859: u32 = 0; + let mut x860: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x859, &mut x860, x858, x784, x834); + let mut x861: u32 = 0; + let mut x862: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x861, &mut x862, x860, x786, x836); + let mut x863: u32 = 0; + let mut x864: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x863, &mut x864, x862, x788, x838); + let mut x865: u32 = 0; + let mut x866: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x865, &mut x866, x864, x790, x840); + let mut x867: u32 = 0; + let mut x868: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x867, &mut x868, x866, x792, x842); + let mut x869: u32 = 0; + let mut x870: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x869, &mut x870, x868, x794, x844); + let mut x871: u32 = 0; + let mut x872: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x871, &mut x872, x870, x796, x846); + let mut x873: u32 = 0; + let mut x874: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x873, &mut x874, x872, x798, x848); + let mut x875: u32 = 0; + let mut x876: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x875, &mut x876, x874, x800, x850); + let mut x877: u32 = 0; + let mut x878: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x877, &mut x878, x876, x802, x852); + let x879: u32 = ((x878 as u32) + (x803 as u32)); + let mut x880: u32 = 0; + let mut x881: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x880, &mut x881, x6, (arg1[11])); + let mut x882: u32 = 0; + let mut x883: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x882, &mut x883, x6, (arg1[10])); + let mut x884: u32 = 0; + let mut x885: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x884, &mut x885, x6, (arg1[9])); + let mut x886: u32 = 0; + let mut x887: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x886, &mut x887, x6, (arg1[8])); + let mut x888: u32 = 0; + let mut x889: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x888, &mut x889, x6, (arg1[7])); + let mut x890: u32 = 0; + let mut x891: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x890, &mut x891, x6, (arg1[6])); + let mut x892: u32 = 0; + let mut x893: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x892, &mut x893, x6, (arg1[5])); + let mut x894: u32 = 0; + let mut x895: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x894, &mut x895, x6, (arg1[4])); + let mut x896: u32 = 0; + let mut x897: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x896, &mut x897, x6, (arg1[3])); + let mut x898: u32 = 0; + let mut x899: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x898, &mut x899, x6, (arg1[2])); + let mut x900: u32 = 0; + let mut x901: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x900, &mut x901, x6, (arg1[1])); + let mut x902: u32 = 0; + let mut x903: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x902, &mut x903, x6, (arg1[0])); + let mut x904: u32 = 0; + let mut x905: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x904, &mut x905, 0x0, x903, x900); + let mut x906: u32 = 0; + let mut x907: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x906, &mut x907, x905, x901, x898); + let mut x908: u32 = 0; + let mut x909: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x908, &mut x909, x907, x899, x896); + let mut x910: u32 = 0; + let mut x911: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x910, &mut x911, x909, x897, x894); + let mut x912: u32 = 0; + let mut x913: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x912, &mut x913, x911, x895, x892); + let mut x914: u32 = 0; + let mut x915: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x914, &mut x915, x913, x893, x890); + let mut x916: u32 = 0; + let mut x917: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x916, &mut x917, x915, x891, x888); + let mut x918: u32 = 0; + let mut x919: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x918, &mut x919, x917, x889, x886); + let mut x920: u32 = 0; + let mut x921: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x920, &mut x921, x919, x887, x884); + let mut x922: u32 = 0; + let mut x923: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x922, &mut x923, x921, x885, x882); + let mut x924: u32 = 0; + let mut x925: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x924, &mut x925, x923, x883, x880); + let x926: u32 = ((x925 as u32) + x881); + let mut x927: u32 = 0; + let mut x928: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x927, &mut x928, 0x0, x855, x902); + let mut x929: u32 = 0; + let mut x930: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x929, &mut x930, x928, x857, x904); + let mut x931: u32 = 0; + let mut x932: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x931, &mut x932, x930, x859, x906); + let mut x933: u32 = 0; + let mut x934: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x933, &mut x934, x932, x861, x908); + let mut x935: u32 = 0; + let mut x936: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x935, &mut x936, x934, x863, x910); + let mut x937: u32 = 0; + let mut x938: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x937, &mut x938, x936, x865, x912); + let mut x939: u32 = 0; + let mut x940: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x939, &mut x940, x938, x867, x914); + let mut x941: u32 = 0; + let mut x942: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x941, &mut x942, x940, x869, x916); + let mut x943: u32 = 0; + let mut x944: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x943, &mut x944, x942, x871, x918); + let mut x945: u32 = 0; + let mut x946: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x945, &mut x946, x944, x873, x920); + let mut x947: u32 = 0; + let mut x948: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x947, &mut x948, x946, x875, x922); + let mut x949: u32 = 0; + let mut x950: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x949, &mut x950, x948, x877, x924); + let mut x951: u32 = 0; + let mut x952: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x951, &mut x952, x950, x879, x926); + let mut x953: u32 = 0; + let mut x954: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x953, &mut x954, x927, 0xe88fdc45); + let mut x955: u32 = 0; + let mut x956: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x955, &mut x956, x953, 0xffffffff); + let mut x957: u32 = 0; + let mut x958: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x957, &mut x958, x953, 0xffffffff); + let mut x959: u32 = 0; + let mut x960: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x959, &mut x960, x953, 0xffffffff); + let mut x961: u32 = 0; + let mut x962: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x961, &mut x962, x953, 0xffffffff); + let mut x963: u32 = 0; + let mut x964: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x963, &mut x964, x953, 0xffffffff); + let mut x965: u32 = 0; + let mut x966: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x965, &mut x966, x953, 0xffffffff); + let mut x967: u32 = 0; + let mut x968: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x967, &mut x968, x953, 0xc7634d81); + let mut x969: u32 = 0; + let mut x970: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x969, &mut x970, x953, 0xf4372ddf); + let mut x971: u32 = 0; + let mut x972: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x971, &mut x972, x953, 0x581a0db2); + let mut x973: u32 = 0; + let mut x974: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x973, &mut x974, x953, 0x48b0a77a); + let mut x975: u32 = 0; + let mut x976: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x975, &mut x976, x953, 0xecec196a); + let mut x977: u32 = 0; + let mut x978: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x977, &mut x978, x953, 0xccc52973); + let mut x979: u32 = 0; + let mut x980: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x979, &mut x980, 0x0, x978, x975); + let mut x981: u32 = 0; + let mut x982: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x981, &mut x982, x980, x976, x973); + let mut x983: u32 = 0; + let mut x984: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x983, &mut x984, x982, x974, x971); + let mut x985: u32 = 0; + let mut x986: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x985, &mut x986, x984, x972, x969); + let mut x987: u32 = 0; + let mut x988: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x987, &mut x988, x986, x970, x967); + let mut x989: u32 = 0; + let mut x990: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x989, &mut x990, x988, x968, x965); + let mut x991: u32 = 0; + let mut x992: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x991, &mut x992, x990, x966, x963); + let mut x993: u32 = 0; + let mut x994: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x993, &mut x994, x992, x964, x961); + let mut x995: u32 = 0; + let mut x996: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x995, &mut x996, x994, x962, x959); + let mut x997: u32 = 0; + let mut x998: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x997, &mut x998, x996, x960, x957); + let mut x999: u32 = 0; + let mut x1000: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x999, &mut x1000, x998, x958, x955); + let x1001: u32 = ((x1000 as u32) + x956); + let mut x1002: u32 = 0; + let mut x1003: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1002, &mut x1003, 0x0, x927, x977); + let mut x1004: u32 = 0; + let mut x1005: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1004, &mut x1005, x1003, x929, x979); + let mut x1006: u32 = 0; + let mut x1007: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1006, &mut x1007, x1005, x931, x981); + let mut x1008: u32 = 0; + let mut x1009: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1008, &mut x1009, x1007, x933, x983); + let mut x1010: u32 = 0; + let mut x1011: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1010, &mut x1011, x1009, x935, x985); + let mut x1012: u32 = 0; + let mut x1013: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1012, &mut x1013, x1011, x937, x987); + let mut x1014: u32 = 0; + let mut x1015: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1014, &mut x1015, x1013, x939, x989); + let mut x1016: u32 = 0; + let mut x1017: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1016, &mut x1017, x1015, x941, x991); + let mut x1018: u32 = 0; + let mut x1019: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1018, &mut x1019, x1017, x943, x993); + let mut x1020: u32 = 0; + let mut x1021: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1020, &mut x1021, x1019, x945, x995); + let mut x1022: u32 = 0; + let mut x1023: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1022, &mut x1023, x1021, x947, x997); + let mut x1024: u32 = 0; + let mut x1025: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1024, &mut x1025, x1023, x949, x999); + let mut x1026: u32 = 0; + let mut x1027: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1026, &mut x1027, x1025, x951, x1001); + let x1028: u32 = ((x1027 as u32) + (x952 as u32)); + let mut x1029: u32 = 0; + let mut x1030: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1029, &mut x1030, x7, (arg1[11])); + let mut x1031: u32 = 0; + let mut x1032: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1031, &mut x1032, x7, (arg1[10])); + let mut x1033: u32 = 0; + let mut x1034: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1033, &mut x1034, x7, (arg1[9])); + let mut x1035: u32 = 0; + let mut x1036: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1035, &mut x1036, x7, (arg1[8])); + let mut x1037: u32 = 0; + let mut x1038: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1037, &mut x1038, x7, (arg1[7])); + let mut x1039: u32 = 0; + let mut x1040: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1039, &mut x1040, x7, (arg1[6])); + let mut x1041: u32 = 0; + let mut x1042: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1041, &mut x1042, x7, (arg1[5])); + let mut x1043: u32 = 0; + let mut x1044: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1043, &mut x1044, x7, (arg1[4])); + let mut x1045: u32 = 0; + let mut x1046: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1045, &mut x1046, x7, (arg1[3])); + let mut x1047: u32 = 0; + let mut x1048: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1047, &mut x1048, x7, (arg1[2])); + let mut x1049: u32 = 0; + let mut x1050: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1049, &mut x1050, x7, (arg1[1])); + let mut x1051: u32 = 0; + let mut x1052: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1051, &mut x1052, x7, (arg1[0])); + let mut x1053: u32 = 0; + let mut x1054: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1053, &mut x1054, 0x0, x1052, x1049); + let mut x1055: u32 = 0; + let mut x1056: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1055, &mut x1056, x1054, x1050, x1047); + let mut x1057: u32 = 0; + let mut x1058: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1057, &mut x1058, x1056, x1048, x1045); + let mut x1059: u32 = 0; + let mut x1060: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1059, &mut x1060, x1058, x1046, x1043); + let mut x1061: u32 = 0; + let mut x1062: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1061, &mut x1062, x1060, x1044, x1041); + let mut x1063: u32 = 0; + let mut x1064: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1063, &mut x1064, x1062, x1042, x1039); + let mut x1065: u32 = 0; + let mut x1066: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1065, &mut x1066, x1064, x1040, x1037); + let mut x1067: u32 = 0; + let mut x1068: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1067, &mut x1068, x1066, x1038, x1035); + let mut x1069: u32 = 0; + let mut x1070: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1069, &mut x1070, x1068, x1036, x1033); + let mut x1071: u32 = 0; + let mut x1072: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1071, &mut x1072, x1070, x1034, x1031); + let mut x1073: u32 = 0; + let mut x1074: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1073, &mut x1074, x1072, x1032, x1029); + let x1075: u32 = ((x1074 as u32) + x1030); + let mut x1076: u32 = 0; + let mut x1077: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1076, &mut x1077, 0x0, x1004, x1051); + let mut x1078: u32 = 0; + let mut x1079: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1078, &mut x1079, x1077, x1006, x1053); + let mut x1080: u32 = 0; + let mut x1081: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1080, &mut x1081, x1079, x1008, x1055); + let mut x1082: u32 = 0; + let mut x1083: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1082, &mut x1083, x1081, x1010, x1057); + let mut x1084: u32 = 0; + let mut x1085: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1084, &mut x1085, x1083, x1012, x1059); + let mut x1086: u32 = 0; + let mut x1087: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1086, &mut x1087, x1085, x1014, x1061); + let mut x1088: u32 = 0; + let mut x1089: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1088, &mut x1089, x1087, x1016, x1063); + let mut x1090: u32 = 0; + let mut x1091: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1090, &mut x1091, x1089, x1018, x1065); + let mut x1092: u32 = 0; + let mut x1093: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1092, &mut x1093, x1091, x1020, x1067); + let mut x1094: u32 = 0; + let mut x1095: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1094, &mut x1095, x1093, x1022, x1069); + let mut x1096: u32 = 0; + let mut x1097: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1096, &mut x1097, x1095, x1024, x1071); + let mut x1098: u32 = 0; + let mut x1099: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1098, &mut x1099, x1097, x1026, x1073); + let mut x1100: u32 = 0; + let mut x1101: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1100, &mut x1101, x1099, x1028, x1075); + let mut x1102: u32 = 0; + let mut x1103: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1102, &mut x1103, x1076, 0xe88fdc45); + let mut x1104: u32 = 0; + let mut x1105: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1104, &mut x1105, x1102, 0xffffffff); + let mut x1106: u32 = 0; + let mut x1107: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1106, &mut x1107, x1102, 0xffffffff); + let mut x1108: u32 = 0; + let mut x1109: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1108, &mut x1109, x1102, 0xffffffff); + let mut x1110: u32 = 0; + let mut x1111: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1110, &mut x1111, x1102, 0xffffffff); + let mut x1112: u32 = 0; + let mut x1113: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1112, &mut x1113, x1102, 0xffffffff); + let mut x1114: u32 = 0; + let mut x1115: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1114, &mut x1115, x1102, 0xffffffff); + let mut x1116: u32 = 0; + let mut x1117: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1116, &mut x1117, x1102, 0xc7634d81); + let mut x1118: u32 = 0; + let mut x1119: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1118, &mut x1119, x1102, 0xf4372ddf); + let mut x1120: u32 = 0; + let mut x1121: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1120, &mut x1121, x1102, 0x581a0db2); + let mut x1122: u32 = 0; + let mut x1123: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1122, &mut x1123, x1102, 0x48b0a77a); + let mut x1124: u32 = 0; + let mut x1125: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1124, &mut x1125, x1102, 0xecec196a); + let mut x1126: u32 = 0; + let mut x1127: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1126, &mut x1127, x1102, 0xccc52973); + let mut x1128: u32 = 0; + let mut x1129: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1128, &mut x1129, 0x0, x1127, x1124); + let mut x1130: u32 = 0; + let mut x1131: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1130, &mut x1131, x1129, x1125, x1122); + let mut x1132: u32 = 0; + let mut x1133: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1132, &mut x1133, x1131, x1123, x1120); + let mut x1134: u32 = 0; + let mut x1135: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1134, &mut x1135, x1133, x1121, x1118); + let mut x1136: u32 = 0; + let mut x1137: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1136, &mut x1137, x1135, x1119, x1116); + let mut x1138: u32 = 0; + let mut x1139: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1138, &mut x1139, x1137, x1117, x1114); + let mut x1140: u32 = 0; + let mut x1141: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1140, &mut x1141, x1139, x1115, x1112); + let mut x1142: u32 = 0; + let mut x1143: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1142, &mut x1143, x1141, x1113, x1110); + let mut x1144: u32 = 0; + let mut x1145: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1144, &mut x1145, x1143, x1111, x1108); + let mut x1146: u32 = 0; + let mut x1147: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1146, &mut x1147, x1145, x1109, x1106); + let mut x1148: u32 = 0; + let mut x1149: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1148, &mut x1149, x1147, x1107, x1104); + let x1150: u32 = ((x1149 as u32) + x1105); + let mut x1151: u32 = 0; + let mut x1152: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1151, &mut x1152, 0x0, x1076, x1126); + let mut x1153: u32 = 0; + let mut x1154: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1153, &mut x1154, x1152, x1078, x1128); + let mut x1155: u32 = 0; + let mut x1156: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1155, &mut x1156, x1154, x1080, x1130); + let mut x1157: u32 = 0; + let mut x1158: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1157, &mut x1158, x1156, x1082, x1132); + let mut x1159: u32 = 0; + let mut x1160: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1159, &mut x1160, x1158, x1084, x1134); + let mut x1161: u32 = 0; + let mut x1162: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1161, &mut x1162, x1160, x1086, x1136); + let mut x1163: u32 = 0; + let mut x1164: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1163, &mut x1164, x1162, x1088, x1138); + let mut x1165: u32 = 0; + let mut x1166: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1165, &mut x1166, x1164, x1090, x1140); + let mut x1167: u32 = 0; + let mut x1168: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1167, &mut x1168, x1166, x1092, x1142); + let mut x1169: u32 = 0; + let mut x1170: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1169, &mut x1170, x1168, x1094, x1144); + let mut x1171: u32 = 0; + let mut x1172: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1171, &mut x1172, x1170, x1096, x1146); + let mut x1173: u32 = 0; + let mut x1174: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1173, &mut x1174, x1172, x1098, x1148); + let mut x1175: u32 = 0; + let mut x1176: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1175, &mut x1176, x1174, x1100, x1150); + let x1177: u32 = ((x1176 as u32) + (x1101 as u32)); + let mut x1178: u32 = 0; + let mut x1179: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1178, &mut x1179, x8, (arg1[11])); + let mut x1180: u32 = 0; + let mut x1181: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1180, &mut x1181, x8, (arg1[10])); + let mut x1182: u32 = 0; + let mut x1183: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1182, &mut x1183, x8, (arg1[9])); + let mut x1184: u32 = 0; + let mut x1185: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1184, &mut x1185, x8, (arg1[8])); + let mut x1186: u32 = 0; + let mut x1187: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1186, &mut x1187, x8, (arg1[7])); + let mut x1188: u32 = 0; + let mut x1189: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1188, &mut x1189, x8, (arg1[6])); + let mut x1190: u32 = 0; + let mut x1191: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1190, &mut x1191, x8, (arg1[5])); + let mut x1192: u32 = 0; + let mut x1193: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1192, &mut x1193, x8, (arg1[4])); + let mut x1194: u32 = 0; + let mut x1195: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1194, &mut x1195, x8, (arg1[3])); + let mut x1196: u32 = 0; + let mut x1197: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1196, &mut x1197, x8, (arg1[2])); + let mut x1198: u32 = 0; + let mut x1199: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1198, &mut x1199, x8, (arg1[1])); + let mut x1200: u32 = 0; + let mut x1201: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1200, &mut x1201, x8, (arg1[0])); + let mut x1202: u32 = 0; + let mut x1203: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1202, &mut x1203, 0x0, x1201, x1198); + let mut x1204: u32 = 0; + let mut x1205: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1204, &mut x1205, x1203, x1199, x1196); + let mut x1206: u32 = 0; + let mut x1207: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1206, &mut x1207, x1205, x1197, x1194); + let mut x1208: u32 = 0; + let mut x1209: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1208, &mut x1209, x1207, x1195, x1192); + let mut x1210: u32 = 0; + let mut x1211: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1210, &mut x1211, x1209, x1193, x1190); + let mut x1212: u32 = 0; + let mut x1213: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1212, &mut x1213, x1211, x1191, x1188); + let mut x1214: u32 = 0; + let mut x1215: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1214, &mut x1215, x1213, x1189, x1186); + let mut x1216: u32 = 0; + let mut x1217: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1216, &mut x1217, x1215, x1187, x1184); + let mut x1218: u32 = 0; + let mut x1219: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1218, &mut x1219, x1217, x1185, x1182); + let mut x1220: u32 = 0; + let mut x1221: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1220, &mut x1221, x1219, x1183, x1180); + let mut x1222: u32 = 0; + let mut x1223: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1222, &mut x1223, x1221, x1181, x1178); + let x1224: u32 = ((x1223 as u32) + x1179); + let mut x1225: u32 = 0; + let mut x1226: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1225, &mut x1226, 0x0, x1153, x1200); + let mut x1227: u32 = 0; + let mut x1228: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1227, &mut x1228, x1226, x1155, x1202); + let mut x1229: u32 = 0; + let mut x1230: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1229, &mut x1230, x1228, x1157, x1204); + let mut x1231: u32 = 0; + let mut x1232: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1231, &mut x1232, x1230, x1159, x1206); + let mut x1233: u32 = 0; + let mut x1234: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1233, &mut x1234, x1232, x1161, x1208); + let mut x1235: u32 = 0; + let mut x1236: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1235, &mut x1236, x1234, x1163, x1210); + let mut x1237: u32 = 0; + let mut x1238: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1237, &mut x1238, x1236, x1165, x1212); + let mut x1239: u32 = 0; + let mut x1240: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1239, &mut x1240, x1238, x1167, x1214); + let mut x1241: u32 = 0; + let mut x1242: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1241, &mut x1242, x1240, x1169, x1216); + let mut x1243: u32 = 0; + let mut x1244: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1243, &mut x1244, x1242, x1171, x1218); + let mut x1245: u32 = 0; + let mut x1246: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1245, &mut x1246, x1244, x1173, x1220); + let mut x1247: u32 = 0; + let mut x1248: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1247, &mut x1248, x1246, x1175, x1222); + let mut x1249: u32 = 0; + let mut x1250: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1249, &mut x1250, x1248, x1177, x1224); + let mut x1251: u32 = 0; + let mut x1252: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1251, &mut x1252, x1225, 0xe88fdc45); + let mut x1253: u32 = 0; + let mut x1254: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1253, &mut x1254, x1251, 0xffffffff); + let mut x1255: u32 = 0; + let mut x1256: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1255, &mut x1256, x1251, 0xffffffff); + let mut x1257: u32 = 0; + let mut x1258: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1257, &mut x1258, x1251, 0xffffffff); + let mut x1259: u32 = 0; + let mut x1260: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1259, &mut x1260, x1251, 0xffffffff); + let mut x1261: u32 = 0; + let mut x1262: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1261, &mut x1262, x1251, 0xffffffff); + let mut x1263: u32 = 0; + let mut x1264: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1263, &mut x1264, x1251, 0xffffffff); + let mut x1265: u32 = 0; + let mut x1266: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1265, &mut x1266, x1251, 0xc7634d81); + let mut x1267: u32 = 0; + let mut x1268: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1267, &mut x1268, x1251, 0xf4372ddf); + let mut x1269: u32 = 0; + let mut x1270: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1269, &mut x1270, x1251, 0x581a0db2); + let mut x1271: u32 = 0; + let mut x1272: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1271, &mut x1272, x1251, 0x48b0a77a); + let mut x1273: u32 = 0; + let mut x1274: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1273, &mut x1274, x1251, 0xecec196a); + let mut x1275: u32 = 0; + let mut x1276: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1275, &mut x1276, x1251, 0xccc52973); + let mut x1277: u32 = 0; + let mut x1278: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1277, &mut x1278, 0x0, x1276, x1273); + let mut x1279: u32 = 0; + let mut x1280: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1279, &mut x1280, x1278, x1274, x1271); + let mut x1281: u32 = 0; + let mut x1282: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1281, &mut x1282, x1280, x1272, x1269); + let mut x1283: u32 = 0; + let mut x1284: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1283, &mut x1284, x1282, x1270, x1267); + let mut x1285: u32 = 0; + let mut x1286: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1285, &mut x1286, x1284, x1268, x1265); + let mut x1287: u32 = 0; + let mut x1288: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1287, &mut x1288, x1286, x1266, x1263); + let mut x1289: u32 = 0; + let mut x1290: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1289, &mut x1290, x1288, x1264, x1261); + let mut x1291: u32 = 0; + let mut x1292: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1291, &mut x1292, x1290, x1262, x1259); + let mut x1293: u32 = 0; + let mut x1294: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1293, &mut x1294, x1292, x1260, x1257); + let mut x1295: u32 = 0; + let mut x1296: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1295, &mut x1296, x1294, x1258, x1255); + let mut x1297: u32 = 0; + let mut x1298: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1297, &mut x1298, x1296, x1256, x1253); + let x1299: u32 = ((x1298 as u32) + x1254); + let mut x1300: u32 = 0; + let mut x1301: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1300, &mut x1301, 0x0, x1225, x1275); + let mut x1302: u32 = 0; + let mut x1303: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1302, &mut x1303, x1301, x1227, x1277); + let mut x1304: u32 = 0; + let mut x1305: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1304, &mut x1305, x1303, x1229, x1279); + let mut x1306: u32 = 0; + let mut x1307: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1306, &mut x1307, x1305, x1231, x1281); + let mut x1308: u32 = 0; + let mut x1309: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1308, &mut x1309, x1307, x1233, x1283); + let mut x1310: u32 = 0; + let mut x1311: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1310, &mut x1311, x1309, x1235, x1285); + let mut x1312: u32 = 0; + let mut x1313: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1312, &mut x1313, x1311, x1237, x1287); + let mut x1314: u32 = 0; + let mut x1315: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1314, &mut x1315, x1313, x1239, x1289); + let mut x1316: u32 = 0; + let mut x1317: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1316, &mut x1317, x1315, x1241, x1291); + let mut x1318: u32 = 0; + let mut x1319: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1318, &mut x1319, x1317, x1243, x1293); + let mut x1320: u32 = 0; + let mut x1321: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1320, &mut x1321, x1319, x1245, x1295); + let mut x1322: u32 = 0; + let mut x1323: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1322, &mut x1323, x1321, x1247, x1297); + let mut x1324: u32 = 0; + let mut x1325: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1324, &mut x1325, x1323, x1249, x1299); + let x1326: u32 = ((x1325 as u32) + (x1250 as u32)); + let mut x1327: u32 = 0; + let mut x1328: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1327, &mut x1328, x9, (arg1[11])); + let mut x1329: u32 = 0; + let mut x1330: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1329, &mut x1330, x9, (arg1[10])); + let mut x1331: u32 = 0; + let mut x1332: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1331, &mut x1332, x9, (arg1[9])); + let mut x1333: u32 = 0; + let mut x1334: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1333, &mut x1334, x9, (arg1[8])); + let mut x1335: u32 = 0; + let mut x1336: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1335, &mut x1336, x9, (arg1[7])); + let mut x1337: u32 = 0; + let mut x1338: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1337, &mut x1338, x9, (arg1[6])); + let mut x1339: u32 = 0; + let mut x1340: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1339, &mut x1340, x9, (arg1[5])); + let mut x1341: u32 = 0; + let mut x1342: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1341, &mut x1342, x9, (arg1[4])); + let mut x1343: u32 = 0; + let mut x1344: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1343, &mut x1344, x9, (arg1[3])); + let mut x1345: u32 = 0; + let mut x1346: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1345, &mut x1346, x9, (arg1[2])); + let mut x1347: u32 = 0; + let mut x1348: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1347, &mut x1348, x9, (arg1[1])); + let mut x1349: u32 = 0; + let mut x1350: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1349, &mut x1350, x9, (arg1[0])); + let mut x1351: u32 = 0; + let mut x1352: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1351, &mut x1352, 0x0, x1350, x1347); + let mut x1353: u32 = 0; + let mut x1354: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1353, &mut x1354, x1352, x1348, x1345); + let mut x1355: u32 = 0; + let mut x1356: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1355, &mut x1356, x1354, x1346, x1343); + let mut x1357: u32 = 0; + let mut x1358: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1357, &mut x1358, x1356, x1344, x1341); + let mut x1359: u32 = 0; + let mut x1360: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1359, &mut x1360, x1358, x1342, x1339); + let mut x1361: u32 = 0; + let mut x1362: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1361, &mut x1362, x1360, x1340, x1337); + let mut x1363: u32 = 0; + let mut x1364: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1363, &mut x1364, x1362, x1338, x1335); + let mut x1365: u32 = 0; + let mut x1366: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1365, &mut x1366, x1364, x1336, x1333); + let mut x1367: u32 = 0; + let mut x1368: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1367, &mut x1368, x1366, x1334, x1331); + let mut x1369: u32 = 0; + let mut x1370: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1369, &mut x1370, x1368, x1332, x1329); + let mut x1371: u32 = 0; + let mut x1372: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1371, &mut x1372, x1370, x1330, x1327); + let x1373: u32 = ((x1372 as u32) + x1328); + let mut x1374: u32 = 0; + let mut x1375: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1374, &mut x1375, 0x0, x1302, x1349); + let mut x1376: u32 = 0; + let mut x1377: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1376, &mut x1377, x1375, x1304, x1351); + let mut x1378: u32 = 0; + let mut x1379: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1378, &mut x1379, x1377, x1306, x1353); + let mut x1380: u32 = 0; + let mut x1381: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1380, &mut x1381, x1379, x1308, x1355); + let mut x1382: u32 = 0; + let mut x1383: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1382, &mut x1383, x1381, x1310, x1357); + let mut x1384: u32 = 0; + let mut x1385: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1384, &mut x1385, x1383, x1312, x1359); + let mut x1386: u32 = 0; + let mut x1387: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1386, &mut x1387, x1385, x1314, x1361); + let mut x1388: u32 = 0; + let mut x1389: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1388, &mut x1389, x1387, x1316, x1363); + let mut x1390: u32 = 0; + let mut x1391: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1390, &mut x1391, x1389, x1318, x1365); + let mut x1392: u32 = 0; + let mut x1393: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1392, &mut x1393, x1391, x1320, x1367); + let mut x1394: u32 = 0; + let mut x1395: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1394, &mut x1395, x1393, x1322, x1369); + let mut x1396: u32 = 0; + let mut x1397: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1396, &mut x1397, x1395, x1324, x1371); + let mut x1398: u32 = 0; + let mut x1399: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1398, &mut x1399, x1397, x1326, x1373); + let mut x1400: u32 = 0; + let mut x1401: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1400, &mut x1401, x1374, 0xe88fdc45); + let mut x1402: u32 = 0; + let mut x1403: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1402, &mut x1403, x1400, 0xffffffff); + let mut x1404: u32 = 0; + let mut x1405: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1404, &mut x1405, x1400, 0xffffffff); + let mut x1406: u32 = 0; + let mut x1407: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1406, &mut x1407, x1400, 0xffffffff); + let mut x1408: u32 = 0; + let mut x1409: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1408, &mut x1409, x1400, 0xffffffff); + let mut x1410: u32 = 0; + let mut x1411: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1410, &mut x1411, x1400, 0xffffffff); + let mut x1412: u32 = 0; + let mut x1413: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1412, &mut x1413, x1400, 0xffffffff); + let mut x1414: u32 = 0; + let mut x1415: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1414, &mut x1415, x1400, 0xc7634d81); + let mut x1416: u32 = 0; + let mut x1417: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1416, &mut x1417, x1400, 0xf4372ddf); + let mut x1418: u32 = 0; + let mut x1419: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1418, &mut x1419, x1400, 0x581a0db2); + let mut x1420: u32 = 0; + let mut x1421: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1420, &mut x1421, x1400, 0x48b0a77a); + let mut x1422: u32 = 0; + let mut x1423: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1422, &mut x1423, x1400, 0xecec196a); + let mut x1424: u32 = 0; + let mut x1425: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1424, &mut x1425, x1400, 0xccc52973); + let mut x1426: u32 = 0; + let mut x1427: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1426, &mut x1427, 0x0, x1425, x1422); + let mut x1428: u32 = 0; + let mut x1429: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1428, &mut x1429, x1427, x1423, x1420); + let mut x1430: u32 = 0; + let mut x1431: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1430, &mut x1431, x1429, x1421, x1418); + let mut x1432: u32 = 0; + let mut x1433: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1432, &mut x1433, x1431, x1419, x1416); + let mut x1434: u32 = 0; + let mut x1435: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1434, &mut x1435, x1433, x1417, x1414); + let mut x1436: u32 = 0; + let mut x1437: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1436, &mut x1437, x1435, x1415, x1412); + let mut x1438: u32 = 0; + let mut x1439: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1438, &mut x1439, x1437, x1413, x1410); + let mut x1440: u32 = 0; + let mut x1441: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1440, &mut x1441, x1439, x1411, x1408); + let mut x1442: u32 = 0; + let mut x1443: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1442, &mut x1443, x1441, x1409, x1406); + let mut x1444: u32 = 0; + let mut x1445: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1444, &mut x1445, x1443, x1407, x1404); + let mut x1446: u32 = 0; + let mut x1447: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1446, &mut x1447, x1445, x1405, x1402); + let x1448: u32 = ((x1447 as u32) + x1403); + let mut x1449: u32 = 0; + let mut x1450: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1449, &mut x1450, 0x0, x1374, x1424); + let mut x1451: u32 = 0; + let mut x1452: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1451, &mut x1452, x1450, x1376, x1426); + let mut x1453: u32 = 0; + let mut x1454: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1453, &mut x1454, x1452, x1378, x1428); + let mut x1455: u32 = 0; + let mut x1456: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1455, &mut x1456, x1454, x1380, x1430); + let mut x1457: u32 = 0; + let mut x1458: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1457, &mut x1458, x1456, x1382, x1432); + let mut x1459: u32 = 0; + let mut x1460: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1459, &mut x1460, x1458, x1384, x1434); + let mut x1461: u32 = 0; + let mut x1462: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1461, &mut x1462, x1460, x1386, x1436); + let mut x1463: u32 = 0; + let mut x1464: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1463, &mut x1464, x1462, x1388, x1438); + let mut x1465: u32 = 0; + let mut x1466: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1465, &mut x1466, x1464, x1390, x1440); + let mut x1467: u32 = 0; + let mut x1468: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1467, &mut x1468, x1466, x1392, x1442); + let mut x1469: u32 = 0; + let mut x1470: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1469, &mut x1470, x1468, x1394, x1444); + let mut x1471: u32 = 0; + let mut x1472: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1471, &mut x1472, x1470, x1396, x1446); + let mut x1473: u32 = 0; + let mut x1474: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1473, &mut x1474, x1472, x1398, x1448); + let x1475: u32 = ((x1474 as u32) + (x1399 as u32)); + let mut x1476: u32 = 0; + let mut x1477: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1476, &mut x1477, x10, (arg1[11])); + let mut x1478: u32 = 0; + let mut x1479: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1478, &mut x1479, x10, (arg1[10])); + let mut x1480: u32 = 0; + let mut x1481: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1480, &mut x1481, x10, (arg1[9])); + let mut x1482: u32 = 0; + let mut x1483: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1482, &mut x1483, x10, (arg1[8])); + let mut x1484: u32 = 0; + let mut x1485: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1484, &mut x1485, x10, (arg1[7])); + let mut x1486: u32 = 0; + let mut x1487: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1486, &mut x1487, x10, (arg1[6])); + let mut x1488: u32 = 0; + let mut x1489: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1488, &mut x1489, x10, (arg1[5])); + let mut x1490: u32 = 0; + let mut x1491: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1490, &mut x1491, x10, (arg1[4])); + let mut x1492: u32 = 0; + let mut x1493: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1492, &mut x1493, x10, (arg1[3])); + let mut x1494: u32 = 0; + let mut x1495: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1494, &mut x1495, x10, (arg1[2])); + let mut x1496: u32 = 0; + let mut x1497: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1496, &mut x1497, x10, (arg1[1])); + let mut x1498: u32 = 0; + let mut x1499: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1498, &mut x1499, x10, (arg1[0])); + let mut x1500: u32 = 0; + let mut x1501: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1500, &mut x1501, 0x0, x1499, x1496); + let mut x1502: u32 = 0; + let mut x1503: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1502, &mut x1503, x1501, x1497, x1494); + let mut x1504: u32 = 0; + let mut x1505: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1504, &mut x1505, x1503, x1495, x1492); + let mut x1506: u32 = 0; + let mut x1507: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1506, &mut x1507, x1505, x1493, x1490); + let mut x1508: u32 = 0; + let mut x1509: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1508, &mut x1509, x1507, x1491, x1488); + let mut x1510: u32 = 0; + let mut x1511: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1510, &mut x1511, x1509, x1489, x1486); + let mut x1512: u32 = 0; + let mut x1513: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1512, &mut x1513, x1511, x1487, x1484); + let mut x1514: u32 = 0; + let mut x1515: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1514, &mut x1515, x1513, x1485, x1482); + let mut x1516: u32 = 0; + let mut x1517: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1516, &mut x1517, x1515, x1483, x1480); + let mut x1518: u32 = 0; + let mut x1519: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1518, &mut x1519, x1517, x1481, x1478); + let mut x1520: u32 = 0; + let mut x1521: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1520, &mut x1521, x1519, x1479, x1476); + let x1522: u32 = ((x1521 as u32) + x1477); + let mut x1523: u32 = 0; + let mut x1524: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1523, &mut x1524, 0x0, x1451, x1498); + let mut x1525: u32 = 0; + let mut x1526: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1525, &mut x1526, x1524, x1453, x1500); + let mut x1527: u32 = 0; + let mut x1528: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1527, &mut x1528, x1526, x1455, x1502); + let mut x1529: u32 = 0; + let mut x1530: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1529, &mut x1530, x1528, x1457, x1504); + let mut x1531: u32 = 0; + let mut x1532: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1531, &mut x1532, x1530, x1459, x1506); + let mut x1533: u32 = 0; + let mut x1534: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1533, &mut x1534, x1532, x1461, x1508); + let mut x1535: u32 = 0; + let mut x1536: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1535, &mut x1536, x1534, x1463, x1510); + let mut x1537: u32 = 0; + let mut x1538: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1537, &mut x1538, x1536, x1465, x1512); + let mut x1539: u32 = 0; + let mut x1540: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1539, &mut x1540, x1538, x1467, x1514); + let mut x1541: u32 = 0; + let mut x1542: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1541, &mut x1542, x1540, x1469, x1516); + let mut x1543: u32 = 0; + let mut x1544: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1543, &mut x1544, x1542, x1471, x1518); + let mut x1545: u32 = 0; + let mut x1546: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1545, &mut x1546, x1544, x1473, x1520); + let mut x1547: u32 = 0; + let mut x1548: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1547, &mut x1548, x1546, x1475, x1522); + let mut x1549: u32 = 0; + let mut x1550: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1549, &mut x1550, x1523, 0xe88fdc45); + let mut x1551: u32 = 0; + let mut x1552: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1551, &mut x1552, x1549, 0xffffffff); + let mut x1553: u32 = 0; + let mut x1554: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1553, &mut x1554, x1549, 0xffffffff); + let mut x1555: u32 = 0; + let mut x1556: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1555, &mut x1556, x1549, 0xffffffff); + let mut x1557: u32 = 0; + let mut x1558: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1557, &mut x1558, x1549, 0xffffffff); + let mut x1559: u32 = 0; + let mut x1560: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1559, &mut x1560, x1549, 0xffffffff); + let mut x1561: u32 = 0; + let mut x1562: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1561, &mut x1562, x1549, 0xffffffff); + let mut x1563: u32 = 0; + let mut x1564: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1563, &mut x1564, x1549, 0xc7634d81); + let mut x1565: u32 = 0; + let mut x1566: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1565, &mut x1566, x1549, 0xf4372ddf); + let mut x1567: u32 = 0; + let mut x1568: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1567, &mut x1568, x1549, 0x581a0db2); + let mut x1569: u32 = 0; + let mut x1570: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1569, &mut x1570, x1549, 0x48b0a77a); + let mut x1571: u32 = 0; + let mut x1572: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1571, &mut x1572, x1549, 0xecec196a); + let mut x1573: u32 = 0; + let mut x1574: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1573, &mut x1574, x1549, 0xccc52973); + let mut x1575: u32 = 0; + let mut x1576: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1575, &mut x1576, 0x0, x1574, x1571); + let mut x1577: u32 = 0; + let mut x1578: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1577, &mut x1578, x1576, x1572, x1569); + let mut x1579: u32 = 0; + let mut x1580: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1579, &mut x1580, x1578, x1570, x1567); + let mut x1581: u32 = 0; + let mut x1582: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1581, &mut x1582, x1580, x1568, x1565); + let mut x1583: u32 = 0; + let mut x1584: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1583, &mut x1584, x1582, x1566, x1563); + let mut x1585: u32 = 0; + let mut x1586: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1585, &mut x1586, x1584, x1564, x1561); + let mut x1587: u32 = 0; + let mut x1588: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1587, &mut x1588, x1586, x1562, x1559); + let mut x1589: u32 = 0; + let mut x1590: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1589, &mut x1590, x1588, x1560, x1557); + let mut x1591: u32 = 0; + let mut x1592: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1591, &mut x1592, x1590, x1558, x1555); + let mut x1593: u32 = 0; + let mut x1594: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1593, &mut x1594, x1592, x1556, x1553); + let mut x1595: u32 = 0; + let mut x1596: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1595, &mut x1596, x1594, x1554, x1551); + let x1597: u32 = ((x1596 as u32) + x1552); + let mut x1598: u32 = 0; + let mut x1599: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1598, &mut x1599, 0x0, x1523, x1573); + let mut x1600: u32 = 0; + let mut x1601: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1600, &mut x1601, x1599, x1525, x1575); + let mut x1602: u32 = 0; + let mut x1603: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1602, &mut x1603, x1601, x1527, x1577); + let mut x1604: u32 = 0; + let mut x1605: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1604, &mut x1605, x1603, x1529, x1579); + let mut x1606: u32 = 0; + let mut x1607: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1606, &mut x1607, x1605, x1531, x1581); + let mut x1608: u32 = 0; + let mut x1609: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1608, &mut x1609, x1607, x1533, x1583); + let mut x1610: u32 = 0; + let mut x1611: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1610, &mut x1611, x1609, x1535, x1585); + let mut x1612: u32 = 0; + let mut x1613: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1612, &mut x1613, x1611, x1537, x1587); + let mut x1614: u32 = 0; + let mut x1615: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1614, &mut x1615, x1613, x1539, x1589); + let mut x1616: u32 = 0; + let mut x1617: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1616, &mut x1617, x1615, x1541, x1591); + let mut x1618: u32 = 0; + let mut x1619: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1618, &mut x1619, x1617, x1543, x1593); + let mut x1620: u32 = 0; + let mut x1621: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1620, &mut x1621, x1619, x1545, x1595); + let mut x1622: u32 = 0; + let mut x1623: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1622, &mut x1623, x1621, x1547, x1597); + let x1624: u32 = ((x1623 as u32) + (x1548 as u32)); + let mut x1625: u32 = 0; + let mut x1626: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1625, &mut x1626, x11, (arg1[11])); + let mut x1627: u32 = 0; + let mut x1628: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1627, &mut x1628, x11, (arg1[10])); + let mut x1629: u32 = 0; + let mut x1630: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1629, &mut x1630, x11, (arg1[9])); + let mut x1631: u32 = 0; + let mut x1632: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1631, &mut x1632, x11, (arg1[8])); + let mut x1633: u32 = 0; + let mut x1634: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1633, &mut x1634, x11, (arg1[7])); + let mut x1635: u32 = 0; + let mut x1636: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1635, &mut x1636, x11, (arg1[6])); + let mut x1637: u32 = 0; + let mut x1638: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1637, &mut x1638, x11, (arg1[5])); + let mut x1639: u32 = 0; + let mut x1640: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1639, &mut x1640, x11, (arg1[4])); + let mut x1641: u32 = 0; + let mut x1642: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1641, &mut x1642, x11, (arg1[3])); + let mut x1643: u32 = 0; + let mut x1644: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1643, &mut x1644, x11, (arg1[2])); + let mut x1645: u32 = 0; + let mut x1646: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1645, &mut x1646, x11, (arg1[1])); + let mut x1647: u32 = 0; + let mut x1648: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1647, &mut x1648, x11, (arg1[0])); + let mut x1649: u32 = 0; + let mut x1650: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1649, &mut x1650, 0x0, x1648, x1645); + let mut x1651: u32 = 0; + let mut x1652: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1651, &mut x1652, x1650, x1646, x1643); + let mut x1653: u32 = 0; + let mut x1654: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1653, &mut x1654, x1652, x1644, x1641); + let mut x1655: u32 = 0; + let mut x1656: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1655, &mut x1656, x1654, x1642, x1639); + let mut x1657: u32 = 0; + let mut x1658: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1657, &mut x1658, x1656, x1640, x1637); + let mut x1659: u32 = 0; + let mut x1660: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1659, &mut x1660, x1658, x1638, x1635); + let mut x1661: u32 = 0; + let mut x1662: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1661, &mut x1662, x1660, x1636, x1633); + let mut x1663: u32 = 0; + let mut x1664: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1663, &mut x1664, x1662, x1634, x1631); + let mut x1665: u32 = 0; + let mut x1666: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1665, &mut x1666, x1664, x1632, x1629); + let mut x1667: u32 = 0; + let mut x1668: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1667, &mut x1668, x1666, x1630, x1627); + let mut x1669: u32 = 0; + let mut x1670: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1669, &mut x1670, x1668, x1628, x1625); + let x1671: u32 = ((x1670 as u32) + x1626); + let mut x1672: u32 = 0; + let mut x1673: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1672, &mut x1673, 0x0, x1600, x1647); + let mut x1674: u32 = 0; + let mut x1675: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1674, &mut x1675, x1673, x1602, x1649); + let mut x1676: u32 = 0; + let mut x1677: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1676, &mut x1677, x1675, x1604, x1651); + let mut x1678: u32 = 0; + let mut x1679: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1678, &mut x1679, x1677, x1606, x1653); + let mut x1680: u32 = 0; + let mut x1681: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1680, &mut x1681, x1679, x1608, x1655); + let mut x1682: u32 = 0; + let mut x1683: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1682, &mut x1683, x1681, x1610, x1657); + let mut x1684: u32 = 0; + let mut x1685: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1684, &mut x1685, x1683, x1612, x1659); + let mut x1686: u32 = 0; + let mut x1687: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1686, &mut x1687, x1685, x1614, x1661); + let mut x1688: u32 = 0; + let mut x1689: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1688, &mut x1689, x1687, x1616, x1663); + let mut x1690: u32 = 0; + let mut x1691: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1690, &mut x1691, x1689, x1618, x1665); + let mut x1692: u32 = 0; + let mut x1693: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1692, &mut x1693, x1691, x1620, x1667); + let mut x1694: u32 = 0; + let mut x1695: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1694, &mut x1695, x1693, x1622, x1669); + let mut x1696: u32 = 0; + let mut x1697: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1696, &mut x1697, x1695, x1624, x1671); + let mut x1698: u32 = 0; + let mut x1699: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1698, &mut x1699, x1672, 0xe88fdc45); + let mut x1700: u32 = 0; + let mut x1701: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1700, &mut x1701, x1698, 0xffffffff); + let mut x1702: u32 = 0; + let mut x1703: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1702, &mut x1703, x1698, 0xffffffff); + let mut x1704: u32 = 0; + let mut x1705: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1704, &mut x1705, x1698, 0xffffffff); + let mut x1706: u32 = 0; + let mut x1707: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1706, &mut x1707, x1698, 0xffffffff); + let mut x1708: u32 = 0; + let mut x1709: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1708, &mut x1709, x1698, 0xffffffff); + let mut x1710: u32 = 0; + let mut x1711: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1710, &mut x1711, x1698, 0xffffffff); + let mut x1712: u32 = 0; + let mut x1713: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1712, &mut x1713, x1698, 0xc7634d81); + let mut x1714: u32 = 0; + let mut x1715: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1714, &mut x1715, x1698, 0xf4372ddf); + let mut x1716: u32 = 0; + let mut x1717: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1716, &mut x1717, x1698, 0x581a0db2); + let mut x1718: u32 = 0; + let mut x1719: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1718, &mut x1719, x1698, 0x48b0a77a); + let mut x1720: u32 = 0; + let mut x1721: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1720, &mut x1721, x1698, 0xecec196a); + let mut x1722: u32 = 0; + let mut x1723: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1722, &mut x1723, x1698, 0xccc52973); + let mut x1724: u32 = 0; + let mut x1725: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1724, &mut x1725, 0x0, x1723, x1720); + let mut x1726: u32 = 0; + let mut x1727: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1726, &mut x1727, x1725, x1721, x1718); + let mut x1728: u32 = 0; + let mut x1729: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1728, &mut x1729, x1727, x1719, x1716); + let mut x1730: u32 = 0; + let mut x1731: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1730, &mut x1731, x1729, x1717, x1714); + let mut x1732: u32 = 0; + let mut x1733: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1732, &mut x1733, x1731, x1715, x1712); + let mut x1734: u32 = 0; + let mut x1735: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1734, &mut x1735, x1733, x1713, x1710); + let mut x1736: u32 = 0; + let mut x1737: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1736, &mut x1737, x1735, x1711, x1708); + let mut x1738: u32 = 0; + let mut x1739: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1738, &mut x1739, x1737, x1709, x1706); + let mut x1740: u32 = 0; + let mut x1741: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1740, &mut x1741, x1739, x1707, x1704); + let mut x1742: u32 = 0; + let mut x1743: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1742, &mut x1743, x1741, x1705, x1702); + let mut x1744: u32 = 0; + let mut x1745: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1744, &mut x1745, x1743, x1703, x1700); + let x1746: u32 = ((x1745 as u32) + x1701); + let mut x1747: u32 = 0; + let mut x1748: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1747, &mut x1748, 0x0, x1672, x1722); + let mut x1749: u32 = 0; + let mut x1750: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1749, &mut x1750, x1748, x1674, x1724); + let mut x1751: u32 = 0; + let mut x1752: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1751, &mut x1752, x1750, x1676, x1726); + let mut x1753: u32 = 0; + let mut x1754: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1753, &mut x1754, x1752, x1678, x1728); + let mut x1755: u32 = 0; + let mut x1756: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1755, &mut x1756, x1754, x1680, x1730); + let mut x1757: u32 = 0; + let mut x1758: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1757, &mut x1758, x1756, x1682, x1732); + let mut x1759: u32 = 0; + let mut x1760: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1759, &mut x1760, x1758, x1684, x1734); + let mut x1761: u32 = 0; + let mut x1762: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1761, &mut x1762, x1760, x1686, x1736); + let mut x1763: u32 = 0; + let mut x1764: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1763, &mut x1764, x1762, x1688, x1738); + let mut x1765: u32 = 0; + let mut x1766: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1765, &mut x1766, x1764, x1690, x1740); + let mut x1767: u32 = 0; + let mut x1768: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1767, &mut x1768, x1766, x1692, x1742); + let mut x1769: u32 = 0; + let mut x1770: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1769, &mut x1770, x1768, x1694, x1744); + let mut x1771: u32 = 0; + let mut x1772: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1771, &mut x1772, x1770, x1696, x1746); + let x1773: u32 = ((x1772 as u32) + (x1697 as u32)); + let mut x1774: u32 = 0; + let mut x1775: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1774, &mut x1775, 0x0, x1749, 0xccc52973); + let mut x1776: u32 = 0; + let mut x1777: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1776, &mut x1777, x1775, x1751, 0xecec196a); + let mut x1778: u32 = 0; + let mut x1779: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1778, &mut x1779, x1777, x1753, 0x48b0a77a); + let mut x1780: u32 = 0; + let mut x1781: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1780, &mut x1781, x1779, x1755, 0x581a0db2); + let mut x1782: u32 = 0; + let mut x1783: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1782, &mut x1783, x1781, x1757, 0xf4372ddf); + let mut x1784: u32 = 0; + let mut x1785: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1784, &mut x1785, x1783, x1759, 0xc7634d81); + let mut x1786: u32 = 0; + let mut x1787: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1786, &mut x1787, x1785, x1761, 0xffffffff); + let mut x1788: u32 = 0; + let mut x1789: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1788, &mut x1789, x1787, x1763, 0xffffffff); + let mut x1790: u32 = 0; + let mut x1791: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1790, &mut x1791, x1789, x1765, 0xffffffff); + let mut x1792: u32 = 0; + let mut x1793: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1792, &mut x1793, x1791, x1767, 0xffffffff); + let mut x1794: u32 = 0; + let mut x1795: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1794, &mut x1795, x1793, x1769, 0xffffffff); + let mut x1796: u32 = 0; + let mut x1797: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1796, &mut x1797, x1795, x1771, 0xffffffff); + let mut x1798: u32 = 0; + let mut x1799: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1798, &mut x1799, x1797, x1773, (0x0 as u32)); + let mut x1800: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1800, x1799, x1774, x1749); + let mut x1801: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1801, x1799, x1776, x1751); + let mut x1802: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1802, x1799, x1778, x1753); + let mut x1803: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1803, x1799, x1780, x1755); + let mut x1804: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1804, x1799, x1782, x1757); + let mut x1805: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1805, x1799, x1784, x1759); + let mut x1806: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1806, x1799, x1786, x1761); + let mut x1807: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1807, x1799, x1788, x1763); + let mut x1808: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1808, x1799, x1790, x1765); + let mut x1809: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1809, x1799, x1792, x1767); + let mut x1810: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1810, x1799, x1794, x1769); + let mut x1811: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1811, x1799, x1796, x1771); + out1[0] = x1800; + out1[1] = x1801; + out1[2] = x1802; + out1[3] = x1803; + out1[4] = x1804; + out1[5] = x1805; + out1[6] = x1806; + out1[7] = x1807; + out1[8] = x1808; + out1[9] = x1809; + out1[10] = x1810; + out1[11] = x1811; +} + +/// The function fiat_p384_scalar_add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_add(out1: &mut fiat_p384_scalar_montgomery_domain_field_element, arg1: &fiat_p384_scalar_montgomery_domain_field_element, arg2: &fiat_p384_scalar_montgomery_domain_field_element) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u32 = 0; + let mut x4: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u32 = 0; + let mut x6: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u32 = 0; + let mut x8: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u32 = 0; + let mut x10: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u32 = 0; + let mut x12: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u32 = 0; + let mut x14: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x13, &mut x14, x12, (arg1[6]), (arg2[6])); + let mut x15: u32 = 0; + let mut x16: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x15, &mut x16, x14, (arg1[7]), (arg2[7])); + let mut x17: u32 = 0; + let mut x18: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x17, &mut x18, x16, (arg1[8]), (arg2[8])); + let mut x19: u32 = 0; + let mut x20: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x19, &mut x20, x18, (arg1[9]), (arg2[9])); + let mut x21: u32 = 0; + let mut x22: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x21, &mut x22, x20, (arg1[10]), (arg2[10])); + let mut x23: u32 = 0; + let mut x24: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x23, &mut x24, x22, (arg1[11]), (arg2[11])); + let mut x25: u32 = 0; + let mut x26: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x25, &mut x26, 0x0, x1, 0xccc52973); + let mut x27: u32 = 0; + let mut x28: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x27, &mut x28, x26, x3, 0xecec196a); + let mut x29: u32 = 0; + let mut x30: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x29, &mut x30, x28, x5, 0x48b0a77a); + let mut x31: u32 = 0; + let mut x32: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x31, &mut x32, x30, x7, 0x581a0db2); + let mut x33: u32 = 0; + let mut x34: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x33, &mut x34, x32, x9, 0xf4372ddf); + let mut x35: u32 = 0; + let mut x36: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x35, &mut x36, x34, x11, 0xc7634d81); + let mut x37: u32 = 0; + let mut x38: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x37, &mut x38, x36, x13, 0xffffffff); + let mut x39: u32 = 0; + let mut x40: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x39, &mut x40, x38, x15, 0xffffffff); + let mut x41: u32 = 0; + let mut x42: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x41, &mut x42, x40, x17, 0xffffffff); + let mut x43: u32 = 0; + let mut x44: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x43, &mut x44, x42, x19, 0xffffffff); + let mut x45: u32 = 0; + let mut x46: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x45, &mut x46, x44, x21, 0xffffffff); + let mut x47: u32 = 0; + let mut x48: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x47, &mut x48, x46, x23, 0xffffffff); + let mut x49: u32 = 0; + let mut x50: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x49, &mut x50, x48, (x24 as u32), (0x0 as u32)); + let mut x51: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x51, x50, x25, x1); + let mut x52: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x52, x50, x27, x3); + let mut x53: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x53, x50, x29, x5); + let mut x54: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x54, x50, x31, x7); + let mut x55: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x55, x50, x33, x9); + let mut x56: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x56, x50, x35, x11); + let mut x57: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x57, x50, x37, x13); + let mut x58: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x58, x50, x39, x15); + let mut x59: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x59, x50, x41, x17); + let mut x60: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x60, x50, x43, x19); + let mut x61: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x61, x50, x45, x21); + let mut x62: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x62, x50, x47, x23); + out1[0] = x51; + out1[1] = x52; + out1[2] = x53; + out1[3] = x54; + out1[4] = x55; + out1[5] = x56; + out1[6] = x57; + out1[7] = x58; + out1[8] = x59; + out1[9] = x60; + out1[10] = x61; + out1[11] = x62; +} + +/// The function fiat_p384_scalar_sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_sub(out1: &mut fiat_p384_scalar_montgomery_domain_field_element, arg1: &fiat_p384_scalar_montgomery_domain_field_element, arg2: &fiat_p384_scalar_montgomery_domain_field_element) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u32 = 0; + let mut x4: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u32 = 0; + let mut x6: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u32 = 0; + let mut x8: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u32 = 0; + let mut x10: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u32 = 0; + let mut x12: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u32 = 0; + let mut x14: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x13, &mut x14, x12, (arg1[6]), (arg2[6])); + let mut x15: u32 = 0; + let mut x16: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x15, &mut x16, x14, (arg1[7]), (arg2[7])); + let mut x17: u32 = 0; + let mut x18: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x17, &mut x18, x16, (arg1[8]), (arg2[8])); + let mut x19: u32 = 0; + let mut x20: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x19, &mut x20, x18, (arg1[9]), (arg2[9])); + let mut x21: u32 = 0; + let mut x22: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x21, &mut x22, x20, (arg1[10]), (arg2[10])); + let mut x23: u32 = 0; + let mut x24: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x23, &mut x24, x22, (arg1[11]), (arg2[11])); + let mut x25: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x25, x24, (0x0 as u32), 0xffffffff); + let mut x26: u32 = 0; + let mut x27: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x26, &mut x27, 0x0, x1, (x25 & 0xccc52973)); + let mut x28: u32 = 0; + let mut x29: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x28, &mut x29, x27, x3, (x25 & 0xecec196a)); + let mut x30: u32 = 0; + let mut x31: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x5, (x25 & 0x48b0a77a)); + let mut x32: u32 = 0; + let mut x33: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x7, (x25 & 0x581a0db2)); + let mut x34: u32 = 0; + let mut x35: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x34, &mut x35, x33, x9, (x25 & 0xf4372ddf)); + let mut x36: u32 = 0; + let mut x37: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x36, &mut x37, x35, x11, (x25 & 0xc7634d81)); + let mut x38: u32 = 0; + let mut x39: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x38, &mut x39, x37, x13, x25); + let mut x40: u32 = 0; + let mut x41: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x40, &mut x41, x39, x15, x25); + let mut x42: u32 = 0; + let mut x43: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x42, &mut x43, x41, x17, x25); + let mut x44: u32 = 0; + let mut x45: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x44, &mut x45, x43, x19, x25); + let mut x46: u32 = 0; + let mut x47: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x46, &mut x47, x45, x21, x25); + let mut x48: u32 = 0; + let mut x49: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x48, &mut x49, x47, x23, x25); + out1[0] = x26; + out1[1] = x28; + out1[2] = x30; + out1[3] = x32; + out1[4] = x34; + out1[5] = x36; + out1[6] = x38; + out1[7] = x40; + out1[8] = x42; + out1[9] = x44; + out1[10] = x46; + out1[11] = x48; +} + +/// The function fiat_p384_scalar_opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_opp(out1: &mut fiat_p384_scalar_montgomery_domain_field_element, arg1: &fiat_p384_scalar_montgomery_domain_field_element) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1, &mut x2, 0x0, (0x0 as u32), (arg1[0])); + let mut x3: u32 = 0; + let mut x4: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x3, &mut x4, x2, (0x0 as u32), (arg1[1])); + let mut x5: u32 = 0; + let mut x6: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x5, &mut x6, x4, (0x0 as u32), (arg1[2])); + let mut x7: u32 = 0; + let mut x8: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x7, &mut x8, x6, (0x0 as u32), (arg1[3])); + let mut x9: u32 = 0; + let mut x10: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x9, &mut x10, x8, (0x0 as u32), (arg1[4])); + let mut x11: u32 = 0; + let mut x12: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x11, &mut x12, x10, (0x0 as u32), (arg1[5])); + let mut x13: u32 = 0; + let mut x14: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x13, &mut x14, x12, (0x0 as u32), (arg1[6])); + let mut x15: u32 = 0; + let mut x16: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x15, &mut x16, x14, (0x0 as u32), (arg1[7])); + let mut x17: u32 = 0; + let mut x18: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x17, &mut x18, x16, (0x0 as u32), (arg1[8])); + let mut x19: u32 = 0; + let mut x20: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x19, &mut x20, x18, (0x0 as u32), (arg1[9])); + let mut x21: u32 = 0; + let mut x22: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x21, &mut x22, x20, (0x0 as u32), (arg1[10])); + let mut x23: u32 = 0; + let mut x24: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x23, &mut x24, x22, (0x0 as u32), (arg1[11])); + let mut x25: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x25, x24, (0x0 as u32), 0xffffffff); + let mut x26: u32 = 0; + let mut x27: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x26, &mut x27, 0x0, x1, (x25 & 0xccc52973)); + let mut x28: u32 = 0; + let mut x29: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x28, &mut x29, x27, x3, (x25 & 0xecec196a)); + let mut x30: u32 = 0; + let mut x31: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x5, (x25 & 0x48b0a77a)); + let mut x32: u32 = 0; + let mut x33: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x7, (x25 & 0x581a0db2)); + let mut x34: u32 = 0; + let mut x35: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x34, &mut x35, x33, x9, (x25 & 0xf4372ddf)); + let mut x36: u32 = 0; + let mut x37: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x36, &mut x37, x35, x11, (x25 & 0xc7634d81)); + let mut x38: u32 = 0; + let mut x39: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x38, &mut x39, x37, x13, x25); + let mut x40: u32 = 0; + let mut x41: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x40, &mut x41, x39, x15, x25); + let mut x42: u32 = 0; + let mut x43: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x42, &mut x43, x41, x17, x25); + let mut x44: u32 = 0; + let mut x45: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x44, &mut x45, x43, x19, x25); + let mut x46: u32 = 0; + let mut x47: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x46, &mut x47, x45, x21, x25); + let mut x48: u32 = 0; + let mut x49: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x48, &mut x49, x47, x23, x25); + out1[0] = x26; + out1[1] = x28; + out1[2] = x30; + out1[3] = x32; + out1[4] = x34; + out1[5] = x36; + out1[6] = x38; + out1[7] = x40; + out1[8] = x42; + out1[9] = x44; + out1[10] = x46; + out1[11] = x48; +} + +/// The function fiat_p384_scalar_from_montgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^12) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_from_montgomery(out1: &mut fiat_p384_scalar_non_montgomery_domain_field_element, arg1: &fiat_p384_scalar_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[0]); + let mut x2: u32 = 0; + let mut x3: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x2, &mut x3, x1, 0xe88fdc45); + let mut x4: u32 = 0; + let mut x5: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x4, &mut x5, x2, 0xffffffff); + let mut x6: u32 = 0; + let mut x7: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x6, &mut x7, x2, 0xffffffff); + let mut x8: u32 = 0; + let mut x9: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x8, &mut x9, x2, 0xffffffff); + let mut x10: u32 = 0; + let mut x11: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x10, &mut x11, x2, 0xffffffff); + let mut x12: u32 = 0; + let mut x13: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x12, &mut x13, x2, 0xffffffff); + let mut x14: u32 = 0; + let mut x15: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x14, &mut x15, x2, 0xffffffff); + let mut x16: u32 = 0; + let mut x17: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x16, &mut x17, x2, 0xc7634d81); + let mut x18: u32 = 0; + let mut x19: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x18, &mut x19, x2, 0xf4372ddf); + let mut x20: u32 = 0; + let mut x21: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x20, &mut x21, x2, 0x581a0db2); + let mut x22: u32 = 0; + let mut x23: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x22, &mut x23, x2, 0x48b0a77a); + let mut x24: u32 = 0; + let mut x25: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x24, &mut x25, x2, 0xecec196a); + let mut x26: u32 = 0; + let mut x27: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x26, &mut x27, x2, 0xccc52973); + let mut x28: u32 = 0; + let mut x29: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x28, &mut x29, 0x0, x27, x24); + let mut x30: u32 = 0; + let mut x31: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x25, x22); + let mut x32: u32 = 0; + let mut x33: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x23, x20); + let mut x34: u32 = 0; + let mut x35: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x34, &mut x35, x33, x21, x18); + let mut x36: u32 = 0; + let mut x37: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x36, &mut x37, x35, x19, x16); + let mut x38: u32 = 0; + let mut x39: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x38, &mut x39, x37, x17, x14); + let mut x40: u32 = 0; + let mut x41: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x40, &mut x41, x39, x15, x12); + let mut x42: u32 = 0; + let mut x43: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x42, &mut x43, x41, x13, x10); + let mut x44: u32 = 0; + let mut x45: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x44, &mut x45, x43, x11, x8); + let mut x46: u32 = 0; + let mut x47: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x46, &mut x47, x45, x9, x6); + let mut x48: u32 = 0; + let mut x49: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x48, &mut x49, x47, x7, x4); + let mut x50: u32 = 0; + let mut x51: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x50, &mut x51, 0x0, x1, x26); + let mut x52: u32 = 0; + let mut x53: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x52, &mut x53, x51, (0x0 as u32), x28); + let mut x54: u32 = 0; + let mut x55: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x54, &mut x55, x53, (0x0 as u32), x30); + let mut x56: u32 = 0; + let mut x57: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x56, &mut x57, x55, (0x0 as u32), x32); + let mut x58: u32 = 0; + let mut x59: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x58, &mut x59, x57, (0x0 as u32), x34); + let mut x60: u32 = 0; + let mut x61: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x60, &mut x61, x59, (0x0 as u32), x36); + let mut x62: u32 = 0; + let mut x63: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x62, &mut x63, x61, (0x0 as u32), x38); + let mut x64: u32 = 0; + let mut x65: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x64, &mut x65, x63, (0x0 as u32), x40); + let mut x66: u32 = 0; + let mut x67: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x66, &mut x67, x65, (0x0 as u32), x42); + let mut x68: u32 = 0; + let mut x69: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x68, &mut x69, x67, (0x0 as u32), x44); + let mut x70: u32 = 0; + let mut x71: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x70, &mut x71, x69, (0x0 as u32), x46); + let mut x72: u32 = 0; + let mut x73: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x72, &mut x73, x71, (0x0 as u32), x48); + let mut x74: u32 = 0; + let mut x75: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x74, &mut x75, x73, (0x0 as u32), ((x49 as u32) + x5)); + let mut x76: u32 = 0; + let mut x77: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x76, &mut x77, 0x0, x52, (arg1[1])); + let mut x78: u32 = 0; + let mut x79: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x78, &mut x79, x77, x54, (0x0 as u32)); + let mut x80: u32 = 0; + let mut x81: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x80, &mut x81, x79, x56, (0x0 as u32)); + let mut x82: u32 = 0; + let mut x83: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x82, &mut x83, x81, x58, (0x0 as u32)); + let mut x84: u32 = 0; + let mut x85: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x84, &mut x85, x83, x60, (0x0 as u32)); + let mut x86: u32 = 0; + let mut x87: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x86, &mut x87, x85, x62, (0x0 as u32)); + let mut x88: u32 = 0; + let mut x89: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x88, &mut x89, x87, x64, (0x0 as u32)); + let mut x90: u32 = 0; + let mut x91: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x90, &mut x91, x89, x66, (0x0 as u32)); + let mut x92: u32 = 0; + let mut x93: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x92, &mut x93, x91, x68, (0x0 as u32)); + let mut x94: u32 = 0; + let mut x95: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x94, &mut x95, x93, x70, (0x0 as u32)); + let mut x96: u32 = 0; + let mut x97: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x96, &mut x97, x95, x72, (0x0 as u32)); + let mut x98: u32 = 0; + let mut x99: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x98, &mut x99, x97, x74, (0x0 as u32)); + let mut x100: u32 = 0; + let mut x101: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x100, &mut x101, x76, 0xe88fdc45); + let mut x102: u32 = 0; + let mut x103: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x102, &mut x103, x100, 0xffffffff); + let mut x104: u32 = 0; + let mut x105: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x104, &mut x105, x100, 0xffffffff); + let mut x106: u32 = 0; + let mut x107: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x106, &mut x107, x100, 0xffffffff); + let mut x108: u32 = 0; + let mut x109: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x108, &mut x109, x100, 0xffffffff); + let mut x110: u32 = 0; + let mut x111: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x110, &mut x111, x100, 0xffffffff); + let mut x112: u32 = 0; + let mut x113: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x112, &mut x113, x100, 0xffffffff); + let mut x114: u32 = 0; + let mut x115: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x114, &mut x115, x100, 0xc7634d81); + let mut x116: u32 = 0; + let mut x117: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x116, &mut x117, x100, 0xf4372ddf); + let mut x118: u32 = 0; + let mut x119: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x118, &mut x119, x100, 0x581a0db2); + let mut x120: u32 = 0; + let mut x121: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x120, &mut x121, x100, 0x48b0a77a); + let mut x122: u32 = 0; + let mut x123: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x122, &mut x123, x100, 0xecec196a); + let mut x124: u32 = 0; + let mut x125: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x124, &mut x125, x100, 0xccc52973); + let mut x126: u32 = 0; + let mut x127: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x126, &mut x127, 0x0, x125, x122); + let mut x128: u32 = 0; + let mut x129: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x128, &mut x129, x127, x123, x120); + let mut x130: u32 = 0; + let mut x131: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x130, &mut x131, x129, x121, x118); + let mut x132: u32 = 0; + let mut x133: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x132, &mut x133, x131, x119, x116); + let mut x134: u32 = 0; + let mut x135: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x134, &mut x135, x133, x117, x114); + let mut x136: u32 = 0; + let mut x137: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x136, &mut x137, x135, x115, x112); + let mut x138: u32 = 0; + let mut x139: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x138, &mut x139, x137, x113, x110); + let mut x140: u32 = 0; + let mut x141: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x140, &mut x141, x139, x111, x108); + let mut x142: u32 = 0; + let mut x143: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x142, &mut x143, x141, x109, x106); + let mut x144: u32 = 0; + let mut x145: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x144, &mut x145, x143, x107, x104); + let mut x146: u32 = 0; + let mut x147: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x146, &mut x147, x145, x105, x102); + let mut x148: u32 = 0; + let mut x149: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x148, &mut x149, 0x0, x76, x124); + let mut x150: u32 = 0; + let mut x151: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x150, &mut x151, x149, x78, x126); + let mut x152: u32 = 0; + let mut x153: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x152, &mut x153, x151, x80, x128); + let mut x154: u32 = 0; + let mut x155: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x154, &mut x155, x153, x82, x130); + let mut x156: u32 = 0; + let mut x157: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x156, &mut x157, x155, x84, x132); + let mut x158: u32 = 0; + let mut x159: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x158, &mut x159, x157, x86, x134); + let mut x160: u32 = 0; + let mut x161: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x88, x136); + let mut x162: u32 = 0; + let mut x163: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x162, &mut x163, x161, x90, x138); + let mut x164: u32 = 0; + let mut x165: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x164, &mut x165, x163, x92, x140); + let mut x166: u32 = 0; + let mut x167: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x166, &mut x167, x165, x94, x142); + let mut x168: u32 = 0; + let mut x169: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x168, &mut x169, x167, x96, x144); + let mut x170: u32 = 0; + let mut x171: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x170, &mut x171, x169, x98, x146); + let mut x172: u32 = 0; + let mut x173: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x172, &mut x173, x171, ((x99 as u32) + (x75 as u32)), ((x147 as u32) + x103)); + let mut x174: u32 = 0; + let mut x175: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x174, &mut x175, 0x0, x150, (arg1[2])); + let mut x176: u32 = 0; + let mut x177: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x176, &mut x177, x175, x152, (0x0 as u32)); + let mut x178: u32 = 0; + let mut x179: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x178, &mut x179, x177, x154, (0x0 as u32)); + let mut x180: u32 = 0; + let mut x181: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x180, &mut x181, x179, x156, (0x0 as u32)); + let mut x182: u32 = 0; + let mut x183: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x182, &mut x183, x181, x158, (0x0 as u32)); + let mut x184: u32 = 0; + let mut x185: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x184, &mut x185, x183, x160, (0x0 as u32)); + let mut x186: u32 = 0; + let mut x187: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x186, &mut x187, x185, x162, (0x0 as u32)); + let mut x188: u32 = 0; + let mut x189: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x188, &mut x189, x187, x164, (0x0 as u32)); + let mut x190: u32 = 0; + let mut x191: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x190, &mut x191, x189, x166, (0x0 as u32)); + let mut x192: u32 = 0; + let mut x193: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x192, &mut x193, x191, x168, (0x0 as u32)); + let mut x194: u32 = 0; + let mut x195: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x194, &mut x195, x193, x170, (0x0 as u32)); + let mut x196: u32 = 0; + let mut x197: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x196, &mut x197, x195, x172, (0x0 as u32)); + let mut x198: u32 = 0; + let mut x199: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x198, &mut x199, x174, 0xe88fdc45); + let mut x200: u32 = 0; + let mut x201: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x200, &mut x201, x198, 0xffffffff); + let mut x202: u32 = 0; + let mut x203: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x202, &mut x203, x198, 0xffffffff); + let mut x204: u32 = 0; + let mut x205: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x204, &mut x205, x198, 0xffffffff); + let mut x206: u32 = 0; + let mut x207: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x206, &mut x207, x198, 0xffffffff); + let mut x208: u32 = 0; + let mut x209: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x208, &mut x209, x198, 0xffffffff); + let mut x210: u32 = 0; + let mut x211: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x210, &mut x211, x198, 0xffffffff); + let mut x212: u32 = 0; + let mut x213: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x212, &mut x213, x198, 0xc7634d81); + let mut x214: u32 = 0; + let mut x215: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x214, &mut x215, x198, 0xf4372ddf); + let mut x216: u32 = 0; + let mut x217: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x216, &mut x217, x198, 0x581a0db2); + let mut x218: u32 = 0; + let mut x219: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x218, &mut x219, x198, 0x48b0a77a); + let mut x220: u32 = 0; + let mut x221: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x220, &mut x221, x198, 0xecec196a); + let mut x222: u32 = 0; + let mut x223: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x222, &mut x223, x198, 0xccc52973); + let mut x224: u32 = 0; + let mut x225: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x224, &mut x225, 0x0, x223, x220); + let mut x226: u32 = 0; + let mut x227: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x226, &mut x227, x225, x221, x218); + let mut x228: u32 = 0; + let mut x229: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x228, &mut x229, x227, x219, x216); + let mut x230: u32 = 0; + let mut x231: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x230, &mut x231, x229, x217, x214); + let mut x232: u32 = 0; + let mut x233: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x232, &mut x233, x231, x215, x212); + let mut x234: u32 = 0; + let mut x235: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x234, &mut x235, x233, x213, x210); + let mut x236: u32 = 0; + let mut x237: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x236, &mut x237, x235, x211, x208); + let mut x238: u32 = 0; + let mut x239: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x238, &mut x239, x237, x209, x206); + let mut x240: u32 = 0; + let mut x241: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x240, &mut x241, x239, x207, x204); + let mut x242: u32 = 0; + let mut x243: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x242, &mut x243, x241, x205, x202); + let mut x244: u32 = 0; + let mut x245: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x244, &mut x245, x243, x203, x200); + let mut x246: u32 = 0; + let mut x247: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x246, &mut x247, 0x0, x174, x222); + let mut x248: u32 = 0; + let mut x249: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x248, &mut x249, x247, x176, x224); + let mut x250: u32 = 0; + let mut x251: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x250, &mut x251, x249, x178, x226); + let mut x252: u32 = 0; + let mut x253: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x252, &mut x253, x251, x180, x228); + let mut x254: u32 = 0; + let mut x255: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x254, &mut x255, x253, x182, x230); + let mut x256: u32 = 0; + let mut x257: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x256, &mut x257, x255, x184, x232); + let mut x258: u32 = 0; + let mut x259: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x258, &mut x259, x257, x186, x234); + let mut x260: u32 = 0; + let mut x261: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x260, &mut x261, x259, x188, x236); + let mut x262: u32 = 0; + let mut x263: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x262, &mut x263, x261, x190, x238); + let mut x264: u32 = 0; + let mut x265: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x264, &mut x265, x263, x192, x240); + let mut x266: u32 = 0; + let mut x267: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x266, &mut x267, x265, x194, x242); + let mut x268: u32 = 0; + let mut x269: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x268, &mut x269, x267, x196, x244); + let mut x270: u32 = 0; + let mut x271: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x270, &mut x271, x269, ((x197 as u32) + (x173 as u32)), ((x245 as u32) + x201)); + let mut x272: u32 = 0; + let mut x273: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x272, &mut x273, 0x0, x248, (arg1[3])); + let mut x274: u32 = 0; + let mut x275: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x274, &mut x275, x273, x250, (0x0 as u32)); + let mut x276: u32 = 0; + let mut x277: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x276, &mut x277, x275, x252, (0x0 as u32)); + let mut x278: u32 = 0; + let mut x279: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x278, &mut x279, x277, x254, (0x0 as u32)); + let mut x280: u32 = 0; + let mut x281: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x280, &mut x281, x279, x256, (0x0 as u32)); + let mut x282: u32 = 0; + let mut x283: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x282, &mut x283, x281, x258, (0x0 as u32)); + let mut x284: u32 = 0; + let mut x285: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x284, &mut x285, x283, x260, (0x0 as u32)); + let mut x286: u32 = 0; + let mut x287: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x286, &mut x287, x285, x262, (0x0 as u32)); + let mut x288: u32 = 0; + let mut x289: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x288, &mut x289, x287, x264, (0x0 as u32)); + let mut x290: u32 = 0; + let mut x291: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x290, &mut x291, x289, x266, (0x0 as u32)); + let mut x292: u32 = 0; + let mut x293: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x292, &mut x293, x291, x268, (0x0 as u32)); + let mut x294: u32 = 0; + let mut x295: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x294, &mut x295, x293, x270, (0x0 as u32)); + let mut x296: u32 = 0; + let mut x297: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x296, &mut x297, x272, 0xe88fdc45); + let mut x298: u32 = 0; + let mut x299: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x298, &mut x299, x296, 0xffffffff); + let mut x300: u32 = 0; + let mut x301: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x300, &mut x301, x296, 0xffffffff); + let mut x302: u32 = 0; + let mut x303: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x302, &mut x303, x296, 0xffffffff); + let mut x304: u32 = 0; + let mut x305: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x304, &mut x305, x296, 0xffffffff); + let mut x306: u32 = 0; + let mut x307: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x306, &mut x307, x296, 0xffffffff); + let mut x308: u32 = 0; + let mut x309: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x308, &mut x309, x296, 0xffffffff); + let mut x310: u32 = 0; + let mut x311: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x310, &mut x311, x296, 0xc7634d81); + let mut x312: u32 = 0; + let mut x313: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x312, &mut x313, x296, 0xf4372ddf); + let mut x314: u32 = 0; + let mut x315: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x314, &mut x315, x296, 0x581a0db2); + let mut x316: u32 = 0; + let mut x317: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x316, &mut x317, x296, 0x48b0a77a); + let mut x318: u32 = 0; + let mut x319: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x318, &mut x319, x296, 0xecec196a); + let mut x320: u32 = 0; + let mut x321: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x320, &mut x321, x296, 0xccc52973); + let mut x322: u32 = 0; + let mut x323: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x322, &mut x323, 0x0, x321, x318); + let mut x324: u32 = 0; + let mut x325: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x324, &mut x325, x323, x319, x316); + let mut x326: u32 = 0; + let mut x327: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x326, &mut x327, x325, x317, x314); + let mut x328: u32 = 0; + let mut x329: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x328, &mut x329, x327, x315, x312); + let mut x330: u32 = 0; + let mut x331: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x330, &mut x331, x329, x313, x310); + let mut x332: u32 = 0; + let mut x333: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x332, &mut x333, x331, x311, x308); + let mut x334: u32 = 0; + let mut x335: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x334, &mut x335, x333, x309, x306); + let mut x336: u32 = 0; + let mut x337: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x336, &mut x337, x335, x307, x304); + let mut x338: u32 = 0; + let mut x339: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x338, &mut x339, x337, x305, x302); + let mut x340: u32 = 0; + let mut x341: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x340, &mut x341, x339, x303, x300); + let mut x342: u32 = 0; + let mut x343: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x342, &mut x343, x341, x301, x298); + let mut x344: u32 = 0; + let mut x345: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x344, &mut x345, 0x0, x272, x320); + let mut x346: u32 = 0; + let mut x347: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x346, &mut x347, x345, x274, x322); + let mut x348: u32 = 0; + let mut x349: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x348, &mut x349, x347, x276, x324); + let mut x350: u32 = 0; + let mut x351: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x350, &mut x351, x349, x278, x326); + let mut x352: u32 = 0; + let mut x353: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x352, &mut x353, x351, x280, x328); + let mut x354: u32 = 0; + let mut x355: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x354, &mut x355, x353, x282, x330); + let mut x356: u32 = 0; + let mut x357: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x356, &mut x357, x355, x284, x332); + let mut x358: u32 = 0; + let mut x359: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x358, &mut x359, x357, x286, x334); + let mut x360: u32 = 0; + let mut x361: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x360, &mut x361, x359, x288, x336); + let mut x362: u32 = 0; + let mut x363: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x362, &mut x363, x361, x290, x338); + let mut x364: u32 = 0; + let mut x365: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x364, &mut x365, x363, x292, x340); + let mut x366: u32 = 0; + let mut x367: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x366, &mut x367, x365, x294, x342); + let mut x368: u32 = 0; + let mut x369: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x368, &mut x369, x367, ((x295 as u32) + (x271 as u32)), ((x343 as u32) + x299)); + let mut x370: u32 = 0; + let mut x371: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x370, &mut x371, 0x0, x346, (arg1[4])); + let mut x372: u32 = 0; + let mut x373: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x372, &mut x373, x371, x348, (0x0 as u32)); + let mut x374: u32 = 0; + let mut x375: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x374, &mut x375, x373, x350, (0x0 as u32)); + let mut x376: u32 = 0; + let mut x377: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x376, &mut x377, x375, x352, (0x0 as u32)); + let mut x378: u32 = 0; + let mut x379: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x378, &mut x379, x377, x354, (0x0 as u32)); + let mut x380: u32 = 0; + let mut x381: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x380, &mut x381, x379, x356, (0x0 as u32)); + let mut x382: u32 = 0; + let mut x383: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x382, &mut x383, x381, x358, (0x0 as u32)); + let mut x384: u32 = 0; + let mut x385: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x384, &mut x385, x383, x360, (0x0 as u32)); + let mut x386: u32 = 0; + let mut x387: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x386, &mut x387, x385, x362, (0x0 as u32)); + let mut x388: u32 = 0; + let mut x389: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x388, &mut x389, x387, x364, (0x0 as u32)); + let mut x390: u32 = 0; + let mut x391: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x390, &mut x391, x389, x366, (0x0 as u32)); + let mut x392: u32 = 0; + let mut x393: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x392, &mut x393, x391, x368, (0x0 as u32)); + let mut x394: u32 = 0; + let mut x395: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x394, &mut x395, x370, 0xe88fdc45); + let mut x396: u32 = 0; + let mut x397: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x396, &mut x397, x394, 0xffffffff); + let mut x398: u32 = 0; + let mut x399: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x398, &mut x399, x394, 0xffffffff); + let mut x400: u32 = 0; + let mut x401: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x400, &mut x401, x394, 0xffffffff); + let mut x402: u32 = 0; + let mut x403: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x402, &mut x403, x394, 0xffffffff); + let mut x404: u32 = 0; + let mut x405: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x404, &mut x405, x394, 0xffffffff); + let mut x406: u32 = 0; + let mut x407: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x406, &mut x407, x394, 0xffffffff); + let mut x408: u32 = 0; + let mut x409: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x408, &mut x409, x394, 0xc7634d81); + let mut x410: u32 = 0; + let mut x411: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x410, &mut x411, x394, 0xf4372ddf); + let mut x412: u32 = 0; + let mut x413: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x412, &mut x413, x394, 0x581a0db2); + let mut x414: u32 = 0; + let mut x415: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x414, &mut x415, x394, 0x48b0a77a); + let mut x416: u32 = 0; + let mut x417: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x416, &mut x417, x394, 0xecec196a); + let mut x418: u32 = 0; + let mut x419: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x418, &mut x419, x394, 0xccc52973); + let mut x420: u32 = 0; + let mut x421: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x420, &mut x421, 0x0, x419, x416); + let mut x422: u32 = 0; + let mut x423: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x422, &mut x423, x421, x417, x414); + let mut x424: u32 = 0; + let mut x425: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x424, &mut x425, x423, x415, x412); + let mut x426: u32 = 0; + let mut x427: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x426, &mut x427, x425, x413, x410); + let mut x428: u32 = 0; + let mut x429: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x428, &mut x429, x427, x411, x408); + let mut x430: u32 = 0; + let mut x431: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x430, &mut x431, x429, x409, x406); + let mut x432: u32 = 0; + let mut x433: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x432, &mut x433, x431, x407, x404); + let mut x434: u32 = 0; + let mut x435: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x434, &mut x435, x433, x405, x402); + let mut x436: u32 = 0; + let mut x437: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x436, &mut x437, x435, x403, x400); + let mut x438: u32 = 0; + let mut x439: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x438, &mut x439, x437, x401, x398); + let mut x440: u32 = 0; + let mut x441: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x440, &mut x441, x439, x399, x396); + let mut x442: u32 = 0; + let mut x443: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x442, &mut x443, 0x0, x370, x418); + let mut x444: u32 = 0; + let mut x445: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x444, &mut x445, x443, x372, x420); + let mut x446: u32 = 0; + let mut x447: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x446, &mut x447, x445, x374, x422); + let mut x448: u32 = 0; + let mut x449: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x448, &mut x449, x447, x376, x424); + let mut x450: u32 = 0; + let mut x451: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x450, &mut x451, x449, x378, x426); + let mut x452: u32 = 0; + let mut x453: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x452, &mut x453, x451, x380, x428); + let mut x454: u32 = 0; + let mut x455: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x454, &mut x455, x453, x382, x430); + let mut x456: u32 = 0; + let mut x457: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x456, &mut x457, x455, x384, x432); + let mut x458: u32 = 0; + let mut x459: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x458, &mut x459, x457, x386, x434); + let mut x460: u32 = 0; + let mut x461: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x460, &mut x461, x459, x388, x436); + let mut x462: u32 = 0; + let mut x463: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x462, &mut x463, x461, x390, x438); + let mut x464: u32 = 0; + let mut x465: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x464, &mut x465, x463, x392, x440); + let mut x466: u32 = 0; + let mut x467: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x466, &mut x467, x465, ((x393 as u32) + (x369 as u32)), ((x441 as u32) + x397)); + let mut x468: u32 = 0; + let mut x469: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x468, &mut x469, 0x0, x444, (arg1[5])); + let mut x470: u32 = 0; + let mut x471: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x470, &mut x471, x469, x446, (0x0 as u32)); + let mut x472: u32 = 0; + let mut x473: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x472, &mut x473, x471, x448, (0x0 as u32)); + let mut x474: u32 = 0; + let mut x475: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x474, &mut x475, x473, x450, (0x0 as u32)); + let mut x476: u32 = 0; + let mut x477: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x476, &mut x477, x475, x452, (0x0 as u32)); + let mut x478: u32 = 0; + let mut x479: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x478, &mut x479, x477, x454, (0x0 as u32)); + let mut x480: u32 = 0; + let mut x481: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x480, &mut x481, x479, x456, (0x0 as u32)); + let mut x482: u32 = 0; + let mut x483: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x482, &mut x483, x481, x458, (0x0 as u32)); + let mut x484: u32 = 0; + let mut x485: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x484, &mut x485, x483, x460, (0x0 as u32)); + let mut x486: u32 = 0; + let mut x487: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x486, &mut x487, x485, x462, (0x0 as u32)); + let mut x488: u32 = 0; + let mut x489: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x488, &mut x489, x487, x464, (0x0 as u32)); + let mut x490: u32 = 0; + let mut x491: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x490, &mut x491, x489, x466, (0x0 as u32)); + let mut x492: u32 = 0; + let mut x493: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x492, &mut x493, x468, 0xe88fdc45); + let mut x494: u32 = 0; + let mut x495: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x494, &mut x495, x492, 0xffffffff); + let mut x496: u32 = 0; + let mut x497: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x496, &mut x497, x492, 0xffffffff); + let mut x498: u32 = 0; + let mut x499: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x498, &mut x499, x492, 0xffffffff); + let mut x500: u32 = 0; + let mut x501: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x500, &mut x501, x492, 0xffffffff); + let mut x502: u32 = 0; + let mut x503: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x502, &mut x503, x492, 0xffffffff); + let mut x504: u32 = 0; + let mut x505: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x504, &mut x505, x492, 0xffffffff); + let mut x506: u32 = 0; + let mut x507: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x506, &mut x507, x492, 0xc7634d81); + let mut x508: u32 = 0; + let mut x509: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x508, &mut x509, x492, 0xf4372ddf); + let mut x510: u32 = 0; + let mut x511: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x510, &mut x511, x492, 0x581a0db2); + let mut x512: u32 = 0; + let mut x513: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x512, &mut x513, x492, 0x48b0a77a); + let mut x514: u32 = 0; + let mut x515: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x514, &mut x515, x492, 0xecec196a); + let mut x516: u32 = 0; + let mut x517: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x516, &mut x517, x492, 0xccc52973); + let mut x518: u32 = 0; + let mut x519: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x518, &mut x519, 0x0, x517, x514); + let mut x520: u32 = 0; + let mut x521: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x520, &mut x521, x519, x515, x512); + let mut x522: u32 = 0; + let mut x523: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x522, &mut x523, x521, x513, x510); + let mut x524: u32 = 0; + let mut x525: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x524, &mut x525, x523, x511, x508); + let mut x526: u32 = 0; + let mut x527: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x526, &mut x527, x525, x509, x506); + let mut x528: u32 = 0; + let mut x529: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x528, &mut x529, x527, x507, x504); + let mut x530: u32 = 0; + let mut x531: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x530, &mut x531, x529, x505, x502); + let mut x532: u32 = 0; + let mut x533: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x532, &mut x533, x531, x503, x500); + let mut x534: u32 = 0; + let mut x535: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x534, &mut x535, x533, x501, x498); + let mut x536: u32 = 0; + let mut x537: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x536, &mut x537, x535, x499, x496); + let mut x538: u32 = 0; + let mut x539: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x538, &mut x539, x537, x497, x494); + let mut x540: u32 = 0; + let mut x541: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x540, &mut x541, 0x0, x468, x516); + let mut x542: u32 = 0; + let mut x543: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x542, &mut x543, x541, x470, x518); + let mut x544: u32 = 0; + let mut x545: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x544, &mut x545, x543, x472, x520); + let mut x546: u32 = 0; + let mut x547: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x546, &mut x547, x545, x474, x522); + let mut x548: u32 = 0; + let mut x549: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x548, &mut x549, x547, x476, x524); + let mut x550: u32 = 0; + let mut x551: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x550, &mut x551, x549, x478, x526); + let mut x552: u32 = 0; + let mut x553: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x552, &mut x553, x551, x480, x528); + let mut x554: u32 = 0; + let mut x555: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x554, &mut x555, x553, x482, x530); + let mut x556: u32 = 0; + let mut x557: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x556, &mut x557, x555, x484, x532); + let mut x558: u32 = 0; + let mut x559: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x558, &mut x559, x557, x486, x534); + let mut x560: u32 = 0; + let mut x561: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x560, &mut x561, x559, x488, x536); + let mut x562: u32 = 0; + let mut x563: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x562, &mut x563, x561, x490, x538); + let mut x564: u32 = 0; + let mut x565: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x564, &mut x565, x563, ((x491 as u32) + (x467 as u32)), ((x539 as u32) + x495)); + let mut x566: u32 = 0; + let mut x567: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x566, &mut x567, 0x0, x542, (arg1[6])); + let mut x568: u32 = 0; + let mut x569: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x568, &mut x569, x567, x544, (0x0 as u32)); + let mut x570: u32 = 0; + let mut x571: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x570, &mut x571, x569, x546, (0x0 as u32)); + let mut x572: u32 = 0; + let mut x573: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x572, &mut x573, x571, x548, (0x0 as u32)); + let mut x574: u32 = 0; + let mut x575: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x574, &mut x575, x573, x550, (0x0 as u32)); + let mut x576: u32 = 0; + let mut x577: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x576, &mut x577, x575, x552, (0x0 as u32)); + let mut x578: u32 = 0; + let mut x579: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x578, &mut x579, x577, x554, (0x0 as u32)); + let mut x580: u32 = 0; + let mut x581: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x580, &mut x581, x579, x556, (0x0 as u32)); + let mut x582: u32 = 0; + let mut x583: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x582, &mut x583, x581, x558, (0x0 as u32)); + let mut x584: u32 = 0; + let mut x585: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x584, &mut x585, x583, x560, (0x0 as u32)); + let mut x586: u32 = 0; + let mut x587: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x586, &mut x587, x585, x562, (0x0 as u32)); + let mut x588: u32 = 0; + let mut x589: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x588, &mut x589, x587, x564, (0x0 as u32)); + let mut x590: u32 = 0; + let mut x591: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x590, &mut x591, x566, 0xe88fdc45); + let mut x592: u32 = 0; + let mut x593: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x592, &mut x593, x590, 0xffffffff); + let mut x594: u32 = 0; + let mut x595: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x594, &mut x595, x590, 0xffffffff); + let mut x596: u32 = 0; + let mut x597: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x596, &mut x597, x590, 0xffffffff); + let mut x598: u32 = 0; + let mut x599: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x598, &mut x599, x590, 0xffffffff); + let mut x600: u32 = 0; + let mut x601: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x600, &mut x601, x590, 0xffffffff); + let mut x602: u32 = 0; + let mut x603: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x602, &mut x603, x590, 0xffffffff); + let mut x604: u32 = 0; + let mut x605: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x604, &mut x605, x590, 0xc7634d81); + let mut x606: u32 = 0; + let mut x607: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x606, &mut x607, x590, 0xf4372ddf); + let mut x608: u32 = 0; + let mut x609: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x608, &mut x609, x590, 0x581a0db2); + let mut x610: u32 = 0; + let mut x611: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x610, &mut x611, x590, 0x48b0a77a); + let mut x612: u32 = 0; + let mut x613: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x612, &mut x613, x590, 0xecec196a); + let mut x614: u32 = 0; + let mut x615: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x614, &mut x615, x590, 0xccc52973); + let mut x616: u32 = 0; + let mut x617: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x616, &mut x617, 0x0, x615, x612); + let mut x618: u32 = 0; + let mut x619: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x618, &mut x619, x617, x613, x610); + let mut x620: u32 = 0; + let mut x621: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x620, &mut x621, x619, x611, x608); + let mut x622: u32 = 0; + let mut x623: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x622, &mut x623, x621, x609, x606); + let mut x624: u32 = 0; + let mut x625: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x624, &mut x625, x623, x607, x604); + let mut x626: u32 = 0; + let mut x627: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x626, &mut x627, x625, x605, x602); + let mut x628: u32 = 0; + let mut x629: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x628, &mut x629, x627, x603, x600); + let mut x630: u32 = 0; + let mut x631: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x630, &mut x631, x629, x601, x598); + let mut x632: u32 = 0; + let mut x633: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x632, &mut x633, x631, x599, x596); + let mut x634: u32 = 0; + let mut x635: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x634, &mut x635, x633, x597, x594); + let mut x636: u32 = 0; + let mut x637: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x636, &mut x637, x635, x595, x592); + let mut x638: u32 = 0; + let mut x639: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x638, &mut x639, 0x0, x566, x614); + let mut x640: u32 = 0; + let mut x641: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x640, &mut x641, x639, x568, x616); + let mut x642: u32 = 0; + let mut x643: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x642, &mut x643, x641, x570, x618); + let mut x644: u32 = 0; + let mut x645: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x644, &mut x645, x643, x572, x620); + let mut x646: u32 = 0; + let mut x647: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x646, &mut x647, x645, x574, x622); + let mut x648: u32 = 0; + let mut x649: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x648, &mut x649, x647, x576, x624); + let mut x650: u32 = 0; + let mut x651: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x650, &mut x651, x649, x578, x626); + let mut x652: u32 = 0; + let mut x653: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x652, &mut x653, x651, x580, x628); + let mut x654: u32 = 0; + let mut x655: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x654, &mut x655, x653, x582, x630); + let mut x656: u32 = 0; + let mut x657: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x656, &mut x657, x655, x584, x632); + let mut x658: u32 = 0; + let mut x659: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x658, &mut x659, x657, x586, x634); + let mut x660: u32 = 0; + let mut x661: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x660, &mut x661, x659, x588, x636); + let mut x662: u32 = 0; + let mut x663: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x662, &mut x663, x661, ((x589 as u32) + (x565 as u32)), ((x637 as u32) + x593)); + let mut x664: u32 = 0; + let mut x665: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x664, &mut x665, 0x0, x640, (arg1[7])); + let mut x666: u32 = 0; + let mut x667: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x666, &mut x667, x665, x642, (0x0 as u32)); + let mut x668: u32 = 0; + let mut x669: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x668, &mut x669, x667, x644, (0x0 as u32)); + let mut x670: u32 = 0; + let mut x671: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x670, &mut x671, x669, x646, (0x0 as u32)); + let mut x672: u32 = 0; + let mut x673: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x672, &mut x673, x671, x648, (0x0 as u32)); + let mut x674: u32 = 0; + let mut x675: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x674, &mut x675, x673, x650, (0x0 as u32)); + let mut x676: u32 = 0; + let mut x677: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x676, &mut x677, x675, x652, (0x0 as u32)); + let mut x678: u32 = 0; + let mut x679: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x678, &mut x679, x677, x654, (0x0 as u32)); + let mut x680: u32 = 0; + let mut x681: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x680, &mut x681, x679, x656, (0x0 as u32)); + let mut x682: u32 = 0; + let mut x683: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x682, &mut x683, x681, x658, (0x0 as u32)); + let mut x684: u32 = 0; + let mut x685: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x684, &mut x685, x683, x660, (0x0 as u32)); + let mut x686: u32 = 0; + let mut x687: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x686, &mut x687, x685, x662, (0x0 as u32)); + let mut x688: u32 = 0; + let mut x689: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x688, &mut x689, x664, 0xe88fdc45); + let mut x690: u32 = 0; + let mut x691: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x690, &mut x691, x688, 0xffffffff); + let mut x692: u32 = 0; + let mut x693: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x692, &mut x693, x688, 0xffffffff); + let mut x694: u32 = 0; + let mut x695: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x694, &mut x695, x688, 0xffffffff); + let mut x696: u32 = 0; + let mut x697: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x696, &mut x697, x688, 0xffffffff); + let mut x698: u32 = 0; + let mut x699: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x698, &mut x699, x688, 0xffffffff); + let mut x700: u32 = 0; + let mut x701: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x700, &mut x701, x688, 0xffffffff); + let mut x702: u32 = 0; + let mut x703: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x702, &mut x703, x688, 0xc7634d81); + let mut x704: u32 = 0; + let mut x705: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x704, &mut x705, x688, 0xf4372ddf); + let mut x706: u32 = 0; + let mut x707: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x706, &mut x707, x688, 0x581a0db2); + let mut x708: u32 = 0; + let mut x709: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x708, &mut x709, x688, 0x48b0a77a); + let mut x710: u32 = 0; + let mut x711: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x710, &mut x711, x688, 0xecec196a); + let mut x712: u32 = 0; + let mut x713: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x712, &mut x713, x688, 0xccc52973); + let mut x714: u32 = 0; + let mut x715: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x714, &mut x715, 0x0, x713, x710); + let mut x716: u32 = 0; + let mut x717: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x716, &mut x717, x715, x711, x708); + let mut x718: u32 = 0; + let mut x719: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x718, &mut x719, x717, x709, x706); + let mut x720: u32 = 0; + let mut x721: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x720, &mut x721, x719, x707, x704); + let mut x722: u32 = 0; + let mut x723: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x722, &mut x723, x721, x705, x702); + let mut x724: u32 = 0; + let mut x725: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x724, &mut x725, x723, x703, x700); + let mut x726: u32 = 0; + let mut x727: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x726, &mut x727, x725, x701, x698); + let mut x728: u32 = 0; + let mut x729: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x728, &mut x729, x727, x699, x696); + let mut x730: u32 = 0; + let mut x731: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x730, &mut x731, x729, x697, x694); + let mut x732: u32 = 0; + let mut x733: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x732, &mut x733, x731, x695, x692); + let mut x734: u32 = 0; + let mut x735: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x734, &mut x735, x733, x693, x690); + let mut x736: u32 = 0; + let mut x737: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x736, &mut x737, 0x0, x664, x712); + let mut x738: u32 = 0; + let mut x739: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x738, &mut x739, x737, x666, x714); + let mut x740: u32 = 0; + let mut x741: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x740, &mut x741, x739, x668, x716); + let mut x742: u32 = 0; + let mut x743: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x742, &mut x743, x741, x670, x718); + let mut x744: u32 = 0; + let mut x745: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x744, &mut x745, x743, x672, x720); + let mut x746: u32 = 0; + let mut x747: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x746, &mut x747, x745, x674, x722); + let mut x748: u32 = 0; + let mut x749: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x748, &mut x749, x747, x676, x724); + let mut x750: u32 = 0; + let mut x751: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x750, &mut x751, x749, x678, x726); + let mut x752: u32 = 0; + let mut x753: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x752, &mut x753, x751, x680, x728); + let mut x754: u32 = 0; + let mut x755: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x754, &mut x755, x753, x682, x730); + let mut x756: u32 = 0; + let mut x757: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x756, &mut x757, x755, x684, x732); + let mut x758: u32 = 0; + let mut x759: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x758, &mut x759, x757, x686, x734); + let mut x760: u32 = 0; + let mut x761: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x760, &mut x761, x759, ((x687 as u32) + (x663 as u32)), ((x735 as u32) + x691)); + let mut x762: u32 = 0; + let mut x763: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x762, &mut x763, 0x0, x738, (arg1[8])); + let mut x764: u32 = 0; + let mut x765: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x764, &mut x765, x763, x740, (0x0 as u32)); + let mut x766: u32 = 0; + let mut x767: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x766, &mut x767, x765, x742, (0x0 as u32)); + let mut x768: u32 = 0; + let mut x769: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x768, &mut x769, x767, x744, (0x0 as u32)); + let mut x770: u32 = 0; + let mut x771: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x770, &mut x771, x769, x746, (0x0 as u32)); + let mut x772: u32 = 0; + let mut x773: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x772, &mut x773, x771, x748, (0x0 as u32)); + let mut x774: u32 = 0; + let mut x775: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x774, &mut x775, x773, x750, (0x0 as u32)); + let mut x776: u32 = 0; + let mut x777: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x776, &mut x777, x775, x752, (0x0 as u32)); + let mut x778: u32 = 0; + let mut x779: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x778, &mut x779, x777, x754, (0x0 as u32)); + let mut x780: u32 = 0; + let mut x781: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x780, &mut x781, x779, x756, (0x0 as u32)); + let mut x782: u32 = 0; + let mut x783: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x782, &mut x783, x781, x758, (0x0 as u32)); + let mut x784: u32 = 0; + let mut x785: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x784, &mut x785, x783, x760, (0x0 as u32)); + let mut x786: u32 = 0; + let mut x787: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x786, &mut x787, x762, 0xe88fdc45); + let mut x788: u32 = 0; + let mut x789: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x788, &mut x789, x786, 0xffffffff); + let mut x790: u32 = 0; + let mut x791: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x790, &mut x791, x786, 0xffffffff); + let mut x792: u32 = 0; + let mut x793: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x792, &mut x793, x786, 0xffffffff); + let mut x794: u32 = 0; + let mut x795: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x794, &mut x795, x786, 0xffffffff); + let mut x796: u32 = 0; + let mut x797: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x796, &mut x797, x786, 0xffffffff); + let mut x798: u32 = 0; + let mut x799: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x798, &mut x799, x786, 0xffffffff); + let mut x800: u32 = 0; + let mut x801: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x800, &mut x801, x786, 0xc7634d81); + let mut x802: u32 = 0; + let mut x803: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x802, &mut x803, x786, 0xf4372ddf); + let mut x804: u32 = 0; + let mut x805: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x804, &mut x805, x786, 0x581a0db2); + let mut x806: u32 = 0; + let mut x807: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x806, &mut x807, x786, 0x48b0a77a); + let mut x808: u32 = 0; + let mut x809: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x808, &mut x809, x786, 0xecec196a); + let mut x810: u32 = 0; + let mut x811: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x810, &mut x811, x786, 0xccc52973); + let mut x812: u32 = 0; + let mut x813: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x812, &mut x813, 0x0, x811, x808); + let mut x814: u32 = 0; + let mut x815: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x814, &mut x815, x813, x809, x806); + let mut x816: u32 = 0; + let mut x817: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x816, &mut x817, x815, x807, x804); + let mut x818: u32 = 0; + let mut x819: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x818, &mut x819, x817, x805, x802); + let mut x820: u32 = 0; + let mut x821: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x820, &mut x821, x819, x803, x800); + let mut x822: u32 = 0; + let mut x823: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x822, &mut x823, x821, x801, x798); + let mut x824: u32 = 0; + let mut x825: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x824, &mut x825, x823, x799, x796); + let mut x826: u32 = 0; + let mut x827: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x826, &mut x827, x825, x797, x794); + let mut x828: u32 = 0; + let mut x829: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x828, &mut x829, x827, x795, x792); + let mut x830: u32 = 0; + let mut x831: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x830, &mut x831, x829, x793, x790); + let mut x832: u32 = 0; + let mut x833: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x832, &mut x833, x831, x791, x788); + let mut x834: u32 = 0; + let mut x835: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x834, &mut x835, 0x0, x762, x810); + let mut x836: u32 = 0; + let mut x837: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x836, &mut x837, x835, x764, x812); + let mut x838: u32 = 0; + let mut x839: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x838, &mut x839, x837, x766, x814); + let mut x840: u32 = 0; + let mut x841: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x840, &mut x841, x839, x768, x816); + let mut x842: u32 = 0; + let mut x843: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x842, &mut x843, x841, x770, x818); + let mut x844: u32 = 0; + let mut x845: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x844, &mut x845, x843, x772, x820); + let mut x846: u32 = 0; + let mut x847: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x846, &mut x847, x845, x774, x822); + let mut x848: u32 = 0; + let mut x849: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x848, &mut x849, x847, x776, x824); + let mut x850: u32 = 0; + let mut x851: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x850, &mut x851, x849, x778, x826); + let mut x852: u32 = 0; + let mut x853: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x852, &mut x853, x851, x780, x828); + let mut x854: u32 = 0; + let mut x855: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x854, &mut x855, x853, x782, x830); + let mut x856: u32 = 0; + let mut x857: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x856, &mut x857, x855, x784, x832); + let mut x858: u32 = 0; + let mut x859: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x858, &mut x859, x857, ((x785 as u32) + (x761 as u32)), ((x833 as u32) + x789)); + let mut x860: u32 = 0; + let mut x861: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x860, &mut x861, 0x0, x836, (arg1[9])); + let mut x862: u32 = 0; + let mut x863: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x862, &mut x863, x861, x838, (0x0 as u32)); + let mut x864: u32 = 0; + let mut x865: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x864, &mut x865, x863, x840, (0x0 as u32)); + let mut x866: u32 = 0; + let mut x867: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x866, &mut x867, x865, x842, (0x0 as u32)); + let mut x868: u32 = 0; + let mut x869: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x868, &mut x869, x867, x844, (0x0 as u32)); + let mut x870: u32 = 0; + let mut x871: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x870, &mut x871, x869, x846, (0x0 as u32)); + let mut x872: u32 = 0; + let mut x873: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x872, &mut x873, x871, x848, (0x0 as u32)); + let mut x874: u32 = 0; + let mut x875: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x874, &mut x875, x873, x850, (0x0 as u32)); + let mut x876: u32 = 0; + let mut x877: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x876, &mut x877, x875, x852, (0x0 as u32)); + let mut x878: u32 = 0; + let mut x879: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x878, &mut x879, x877, x854, (0x0 as u32)); + let mut x880: u32 = 0; + let mut x881: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x880, &mut x881, x879, x856, (0x0 as u32)); + let mut x882: u32 = 0; + let mut x883: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x882, &mut x883, x881, x858, (0x0 as u32)); + let mut x884: u32 = 0; + let mut x885: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x884, &mut x885, x860, 0xe88fdc45); + let mut x886: u32 = 0; + let mut x887: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x886, &mut x887, x884, 0xffffffff); + let mut x888: u32 = 0; + let mut x889: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x888, &mut x889, x884, 0xffffffff); + let mut x890: u32 = 0; + let mut x891: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x890, &mut x891, x884, 0xffffffff); + let mut x892: u32 = 0; + let mut x893: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x892, &mut x893, x884, 0xffffffff); + let mut x894: u32 = 0; + let mut x895: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x894, &mut x895, x884, 0xffffffff); + let mut x896: u32 = 0; + let mut x897: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x896, &mut x897, x884, 0xffffffff); + let mut x898: u32 = 0; + let mut x899: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x898, &mut x899, x884, 0xc7634d81); + let mut x900: u32 = 0; + let mut x901: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x900, &mut x901, x884, 0xf4372ddf); + let mut x902: u32 = 0; + let mut x903: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x902, &mut x903, x884, 0x581a0db2); + let mut x904: u32 = 0; + let mut x905: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x904, &mut x905, x884, 0x48b0a77a); + let mut x906: u32 = 0; + let mut x907: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x906, &mut x907, x884, 0xecec196a); + let mut x908: u32 = 0; + let mut x909: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x908, &mut x909, x884, 0xccc52973); + let mut x910: u32 = 0; + let mut x911: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x910, &mut x911, 0x0, x909, x906); + let mut x912: u32 = 0; + let mut x913: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x912, &mut x913, x911, x907, x904); + let mut x914: u32 = 0; + let mut x915: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x914, &mut x915, x913, x905, x902); + let mut x916: u32 = 0; + let mut x917: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x916, &mut x917, x915, x903, x900); + let mut x918: u32 = 0; + let mut x919: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x918, &mut x919, x917, x901, x898); + let mut x920: u32 = 0; + let mut x921: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x920, &mut x921, x919, x899, x896); + let mut x922: u32 = 0; + let mut x923: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x922, &mut x923, x921, x897, x894); + let mut x924: u32 = 0; + let mut x925: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x924, &mut x925, x923, x895, x892); + let mut x926: u32 = 0; + let mut x927: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x926, &mut x927, x925, x893, x890); + let mut x928: u32 = 0; + let mut x929: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x928, &mut x929, x927, x891, x888); + let mut x930: u32 = 0; + let mut x931: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x930, &mut x931, x929, x889, x886); + let mut x932: u32 = 0; + let mut x933: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x932, &mut x933, 0x0, x860, x908); + let mut x934: u32 = 0; + let mut x935: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x934, &mut x935, x933, x862, x910); + let mut x936: u32 = 0; + let mut x937: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x936, &mut x937, x935, x864, x912); + let mut x938: u32 = 0; + let mut x939: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x938, &mut x939, x937, x866, x914); + let mut x940: u32 = 0; + let mut x941: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x940, &mut x941, x939, x868, x916); + let mut x942: u32 = 0; + let mut x943: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x942, &mut x943, x941, x870, x918); + let mut x944: u32 = 0; + let mut x945: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x944, &mut x945, x943, x872, x920); + let mut x946: u32 = 0; + let mut x947: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x946, &mut x947, x945, x874, x922); + let mut x948: u32 = 0; + let mut x949: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x948, &mut x949, x947, x876, x924); + let mut x950: u32 = 0; + let mut x951: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x950, &mut x951, x949, x878, x926); + let mut x952: u32 = 0; + let mut x953: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x952, &mut x953, x951, x880, x928); + let mut x954: u32 = 0; + let mut x955: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x954, &mut x955, x953, x882, x930); + let mut x956: u32 = 0; + let mut x957: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x956, &mut x957, x955, ((x883 as u32) + (x859 as u32)), ((x931 as u32) + x887)); + let mut x958: u32 = 0; + let mut x959: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x958, &mut x959, 0x0, x934, (arg1[10])); + let mut x960: u32 = 0; + let mut x961: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x960, &mut x961, x959, x936, (0x0 as u32)); + let mut x962: u32 = 0; + let mut x963: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x962, &mut x963, x961, x938, (0x0 as u32)); + let mut x964: u32 = 0; + let mut x965: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x964, &mut x965, x963, x940, (0x0 as u32)); + let mut x966: u32 = 0; + let mut x967: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x966, &mut x967, x965, x942, (0x0 as u32)); + let mut x968: u32 = 0; + let mut x969: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x968, &mut x969, x967, x944, (0x0 as u32)); + let mut x970: u32 = 0; + let mut x971: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x970, &mut x971, x969, x946, (0x0 as u32)); + let mut x972: u32 = 0; + let mut x973: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x972, &mut x973, x971, x948, (0x0 as u32)); + let mut x974: u32 = 0; + let mut x975: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x974, &mut x975, x973, x950, (0x0 as u32)); + let mut x976: u32 = 0; + let mut x977: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x976, &mut x977, x975, x952, (0x0 as u32)); + let mut x978: u32 = 0; + let mut x979: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x978, &mut x979, x977, x954, (0x0 as u32)); + let mut x980: u32 = 0; + let mut x981: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x980, &mut x981, x979, x956, (0x0 as u32)); + let mut x982: u32 = 0; + let mut x983: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x982, &mut x983, x958, 0xe88fdc45); + let mut x984: u32 = 0; + let mut x985: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x984, &mut x985, x982, 0xffffffff); + let mut x986: u32 = 0; + let mut x987: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x986, &mut x987, x982, 0xffffffff); + let mut x988: u32 = 0; + let mut x989: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x988, &mut x989, x982, 0xffffffff); + let mut x990: u32 = 0; + let mut x991: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x990, &mut x991, x982, 0xffffffff); + let mut x992: u32 = 0; + let mut x993: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x992, &mut x993, x982, 0xffffffff); + let mut x994: u32 = 0; + let mut x995: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x994, &mut x995, x982, 0xffffffff); + let mut x996: u32 = 0; + let mut x997: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x996, &mut x997, x982, 0xc7634d81); + let mut x998: u32 = 0; + let mut x999: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x998, &mut x999, x982, 0xf4372ddf); + let mut x1000: u32 = 0; + let mut x1001: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1000, &mut x1001, x982, 0x581a0db2); + let mut x1002: u32 = 0; + let mut x1003: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1002, &mut x1003, x982, 0x48b0a77a); + let mut x1004: u32 = 0; + let mut x1005: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1004, &mut x1005, x982, 0xecec196a); + let mut x1006: u32 = 0; + let mut x1007: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1006, &mut x1007, x982, 0xccc52973); + let mut x1008: u32 = 0; + let mut x1009: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1008, &mut x1009, 0x0, x1007, x1004); + let mut x1010: u32 = 0; + let mut x1011: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1010, &mut x1011, x1009, x1005, x1002); + let mut x1012: u32 = 0; + let mut x1013: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1012, &mut x1013, x1011, x1003, x1000); + let mut x1014: u32 = 0; + let mut x1015: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1014, &mut x1015, x1013, x1001, x998); + let mut x1016: u32 = 0; + let mut x1017: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1016, &mut x1017, x1015, x999, x996); + let mut x1018: u32 = 0; + let mut x1019: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1018, &mut x1019, x1017, x997, x994); + let mut x1020: u32 = 0; + let mut x1021: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1020, &mut x1021, x1019, x995, x992); + let mut x1022: u32 = 0; + let mut x1023: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1022, &mut x1023, x1021, x993, x990); + let mut x1024: u32 = 0; + let mut x1025: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1024, &mut x1025, x1023, x991, x988); + let mut x1026: u32 = 0; + let mut x1027: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1026, &mut x1027, x1025, x989, x986); + let mut x1028: u32 = 0; + let mut x1029: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1028, &mut x1029, x1027, x987, x984); + let mut x1030: u32 = 0; + let mut x1031: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1030, &mut x1031, 0x0, x958, x1006); + let mut x1032: u32 = 0; + let mut x1033: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1032, &mut x1033, x1031, x960, x1008); + let mut x1034: u32 = 0; + let mut x1035: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1034, &mut x1035, x1033, x962, x1010); + let mut x1036: u32 = 0; + let mut x1037: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1036, &mut x1037, x1035, x964, x1012); + let mut x1038: u32 = 0; + let mut x1039: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1038, &mut x1039, x1037, x966, x1014); + let mut x1040: u32 = 0; + let mut x1041: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1040, &mut x1041, x1039, x968, x1016); + let mut x1042: u32 = 0; + let mut x1043: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1042, &mut x1043, x1041, x970, x1018); + let mut x1044: u32 = 0; + let mut x1045: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1044, &mut x1045, x1043, x972, x1020); + let mut x1046: u32 = 0; + let mut x1047: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1046, &mut x1047, x1045, x974, x1022); + let mut x1048: u32 = 0; + let mut x1049: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1048, &mut x1049, x1047, x976, x1024); + let mut x1050: u32 = 0; + let mut x1051: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1050, &mut x1051, x1049, x978, x1026); + let mut x1052: u32 = 0; + let mut x1053: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1052, &mut x1053, x1051, x980, x1028); + let mut x1054: u32 = 0; + let mut x1055: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1054, &mut x1055, x1053, ((x981 as u32) + (x957 as u32)), ((x1029 as u32) + x985)); + let mut x1056: u32 = 0; + let mut x1057: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1056, &mut x1057, 0x0, x1032, (arg1[11])); + let mut x1058: u32 = 0; + let mut x1059: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1058, &mut x1059, x1057, x1034, (0x0 as u32)); + let mut x1060: u32 = 0; + let mut x1061: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1060, &mut x1061, x1059, x1036, (0x0 as u32)); + let mut x1062: u32 = 0; + let mut x1063: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1062, &mut x1063, x1061, x1038, (0x0 as u32)); + let mut x1064: u32 = 0; + let mut x1065: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1064, &mut x1065, x1063, x1040, (0x0 as u32)); + let mut x1066: u32 = 0; + let mut x1067: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1066, &mut x1067, x1065, x1042, (0x0 as u32)); + let mut x1068: u32 = 0; + let mut x1069: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1068, &mut x1069, x1067, x1044, (0x0 as u32)); + let mut x1070: u32 = 0; + let mut x1071: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1070, &mut x1071, x1069, x1046, (0x0 as u32)); + let mut x1072: u32 = 0; + let mut x1073: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1072, &mut x1073, x1071, x1048, (0x0 as u32)); + let mut x1074: u32 = 0; + let mut x1075: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1074, &mut x1075, x1073, x1050, (0x0 as u32)); + let mut x1076: u32 = 0; + let mut x1077: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1076, &mut x1077, x1075, x1052, (0x0 as u32)); + let mut x1078: u32 = 0; + let mut x1079: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1078, &mut x1079, x1077, x1054, (0x0 as u32)); + let mut x1080: u32 = 0; + let mut x1081: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1080, &mut x1081, x1056, 0xe88fdc45); + let mut x1082: u32 = 0; + let mut x1083: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1082, &mut x1083, x1080, 0xffffffff); + let mut x1084: u32 = 0; + let mut x1085: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1084, &mut x1085, x1080, 0xffffffff); + let mut x1086: u32 = 0; + let mut x1087: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1086, &mut x1087, x1080, 0xffffffff); + let mut x1088: u32 = 0; + let mut x1089: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1088, &mut x1089, x1080, 0xffffffff); + let mut x1090: u32 = 0; + let mut x1091: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1090, &mut x1091, x1080, 0xffffffff); + let mut x1092: u32 = 0; + let mut x1093: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1092, &mut x1093, x1080, 0xffffffff); + let mut x1094: u32 = 0; + let mut x1095: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1094, &mut x1095, x1080, 0xc7634d81); + let mut x1096: u32 = 0; + let mut x1097: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1096, &mut x1097, x1080, 0xf4372ddf); + let mut x1098: u32 = 0; + let mut x1099: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1098, &mut x1099, x1080, 0x581a0db2); + let mut x1100: u32 = 0; + let mut x1101: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1100, &mut x1101, x1080, 0x48b0a77a); + let mut x1102: u32 = 0; + let mut x1103: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1102, &mut x1103, x1080, 0xecec196a); + let mut x1104: u32 = 0; + let mut x1105: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1104, &mut x1105, x1080, 0xccc52973); + let mut x1106: u32 = 0; + let mut x1107: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1106, &mut x1107, 0x0, x1105, x1102); + let mut x1108: u32 = 0; + let mut x1109: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1108, &mut x1109, x1107, x1103, x1100); + let mut x1110: u32 = 0; + let mut x1111: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1110, &mut x1111, x1109, x1101, x1098); + let mut x1112: u32 = 0; + let mut x1113: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1112, &mut x1113, x1111, x1099, x1096); + let mut x1114: u32 = 0; + let mut x1115: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1114, &mut x1115, x1113, x1097, x1094); + let mut x1116: u32 = 0; + let mut x1117: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1116, &mut x1117, x1115, x1095, x1092); + let mut x1118: u32 = 0; + let mut x1119: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1118, &mut x1119, x1117, x1093, x1090); + let mut x1120: u32 = 0; + let mut x1121: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1120, &mut x1121, x1119, x1091, x1088); + let mut x1122: u32 = 0; + let mut x1123: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1122, &mut x1123, x1121, x1089, x1086); + let mut x1124: u32 = 0; + let mut x1125: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1124, &mut x1125, x1123, x1087, x1084); + let mut x1126: u32 = 0; + let mut x1127: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1126, &mut x1127, x1125, x1085, x1082); + let mut x1128: u32 = 0; + let mut x1129: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1128, &mut x1129, 0x0, x1056, x1104); + let mut x1130: u32 = 0; + let mut x1131: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1130, &mut x1131, x1129, x1058, x1106); + let mut x1132: u32 = 0; + let mut x1133: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1132, &mut x1133, x1131, x1060, x1108); + let mut x1134: u32 = 0; + let mut x1135: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1134, &mut x1135, x1133, x1062, x1110); + let mut x1136: u32 = 0; + let mut x1137: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1136, &mut x1137, x1135, x1064, x1112); + let mut x1138: u32 = 0; + let mut x1139: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1138, &mut x1139, x1137, x1066, x1114); + let mut x1140: u32 = 0; + let mut x1141: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1140, &mut x1141, x1139, x1068, x1116); + let mut x1142: u32 = 0; + let mut x1143: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1142, &mut x1143, x1141, x1070, x1118); + let mut x1144: u32 = 0; + let mut x1145: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1144, &mut x1145, x1143, x1072, x1120); + let mut x1146: u32 = 0; + let mut x1147: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1146, &mut x1147, x1145, x1074, x1122); + let mut x1148: u32 = 0; + let mut x1149: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1148, &mut x1149, x1147, x1076, x1124); + let mut x1150: u32 = 0; + let mut x1151: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1150, &mut x1151, x1149, x1078, x1126); + let mut x1152: u32 = 0; + let mut x1153: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1152, &mut x1153, x1151, ((x1079 as u32) + (x1055 as u32)), ((x1127 as u32) + x1083)); + let mut x1154: u32 = 0; + let mut x1155: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1154, &mut x1155, 0x0, x1130, 0xccc52973); + let mut x1156: u32 = 0; + let mut x1157: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1156, &mut x1157, x1155, x1132, 0xecec196a); + let mut x1158: u32 = 0; + let mut x1159: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1158, &mut x1159, x1157, x1134, 0x48b0a77a); + let mut x1160: u32 = 0; + let mut x1161: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1160, &mut x1161, x1159, x1136, 0x581a0db2); + let mut x1162: u32 = 0; + let mut x1163: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1162, &mut x1163, x1161, x1138, 0xf4372ddf); + let mut x1164: u32 = 0; + let mut x1165: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1164, &mut x1165, x1163, x1140, 0xc7634d81); + let mut x1166: u32 = 0; + let mut x1167: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1166, &mut x1167, x1165, x1142, 0xffffffff); + let mut x1168: u32 = 0; + let mut x1169: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1168, &mut x1169, x1167, x1144, 0xffffffff); + let mut x1170: u32 = 0; + let mut x1171: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1170, &mut x1171, x1169, x1146, 0xffffffff); + let mut x1172: u32 = 0; + let mut x1173: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1172, &mut x1173, x1171, x1148, 0xffffffff); + let mut x1174: u32 = 0; + let mut x1175: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1174, &mut x1175, x1173, x1150, 0xffffffff); + let mut x1176: u32 = 0; + let mut x1177: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1176, &mut x1177, x1175, x1152, 0xffffffff); + let mut x1178: u32 = 0; + let mut x1179: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1178, &mut x1179, x1177, (x1153 as u32), (0x0 as u32)); + let mut x1180: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1180, x1179, x1154, x1130); + let mut x1181: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1181, x1179, x1156, x1132); + let mut x1182: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1182, x1179, x1158, x1134); + let mut x1183: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1183, x1179, x1160, x1136); + let mut x1184: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1184, x1179, x1162, x1138); + let mut x1185: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1185, x1179, x1164, x1140); + let mut x1186: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1186, x1179, x1166, x1142); + let mut x1187: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1187, x1179, x1168, x1144); + let mut x1188: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1188, x1179, x1170, x1146); + let mut x1189: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1189, x1179, x1172, x1148); + let mut x1190: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1190, x1179, x1174, x1150); + let mut x1191: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1191, x1179, x1176, x1152); + out1[0] = x1180; + out1[1] = x1181; + out1[2] = x1182; + out1[3] = x1183; + out1[4] = x1184; + out1[5] = x1185; + out1[6] = x1186; + out1[7] = x1187; + out1[8] = x1188; + out1[9] = x1189; + out1[10] = x1190; + out1[11] = x1191; +} + +/// The function fiat_p384_scalar_to_montgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_to_montgomery(out1: &mut fiat_p384_scalar_montgomery_domain_field_element, arg1: &fiat_p384_scalar_non_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[1]); + let x2: u32 = (arg1[2]); + let x3: u32 = (arg1[3]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[5]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[7]); + let x8: u32 = (arg1[8]); + let x9: u32 = (arg1[9]); + let x10: u32 = (arg1[10]); + let x11: u32 = (arg1[11]); + let x12: u32 = (arg1[0]); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x13, &mut x14, x12, 0xc84ee01); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x15, &mut x16, x12, 0x2b39bf21); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x17, &mut x18, x12, 0x3fb05b7a); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x19, &mut x20, x12, 0x28266895); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x21, &mut x22, x12, 0xd40d4917); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x23, &mut x24, x12, 0x4aab1cc5); + let mut x25: u32 = 0; + let mut x26: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x25, &mut x26, x12, 0xbc3e483a); + let mut x27: u32 = 0; + let mut x28: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x27, &mut x28, x12, 0xfcb82947); + let mut x29: u32 = 0; + let mut x30: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x29, &mut x30, x12, 0xff3d81e5); + let mut x31: u32 = 0; + let mut x32: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x31, &mut x32, x12, 0xdf1aa419); + let mut x33: u32 = 0; + let mut x34: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x33, &mut x34, x12, 0x2d319b24); + let mut x35: u32 = 0; + let mut x36: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x35, &mut x36, x12, 0x19b409a9); + let mut x37: u32 = 0; + let mut x38: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x37, &mut x38, 0x0, x36, x33); + let mut x39: u32 = 0; + let mut x40: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x39, &mut x40, x38, x34, x31); + let mut x41: u32 = 0; + let mut x42: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x41, &mut x42, x40, x32, x29); + let mut x43: u32 = 0; + let mut x44: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x43, &mut x44, x42, x30, x27); + let mut x45: u32 = 0; + let mut x46: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x45, &mut x46, x44, x28, x25); + let mut x47: u32 = 0; + let mut x48: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x47, &mut x48, x46, x26, x23); + let mut x49: u32 = 0; + let mut x50: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x49, &mut x50, x48, x24, x21); + let mut x51: u32 = 0; + let mut x52: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x51, &mut x52, x50, x22, x19); + let mut x53: u32 = 0; + let mut x54: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x53, &mut x54, x52, x20, x17); + let mut x55: u32 = 0; + let mut x56: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x55, &mut x56, x54, x18, x15); + let mut x57: u32 = 0; + let mut x58: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x57, &mut x58, x56, x16, x13); + let mut x59: u32 = 0; + let mut x60: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x59, &mut x60, x35, 0xe88fdc45); + let mut x61: u32 = 0; + let mut x62: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x61, &mut x62, x59, 0xffffffff); + let mut x63: u32 = 0; + let mut x64: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x63, &mut x64, x59, 0xffffffff); + let mut x65: u32 = 0; + let mut x66: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x65, &mut x66, x59, 0xffffffff); + let mut x67: u32 = 0; + let mut x68: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x67, &mut x68, x59, 0xffffffff); + let mut x69: u32 = 0; + let mut x70: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x69, &mut x70, x59, 0xffffffff); + let mut x71: u32 = 0; + let mut x72: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x71, &mut x72, x59, 0xffffffff); + let mut x73: u32 = 0; + let mut x74: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x73, &mut x74, x59, 0xc7634d81); + let mut x75: u32 = 0; + let mut x76: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x75, &mut x76, x59, 0xf4372ddf); + let mut x77: u32 = 0; + let mut x78: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x77, &mut x78, x59, 0x581a0db2); + let mut x79: u32 = 0; + let mut x80: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x79, &mut x80, x59, 0x48b0a77a); + let mut x81: u32 = 0; + let mut x82: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x81, &mut x82, x59, 0xecec196a); + let mut x83: u32 = 0; + let mut x84: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x83, &mut x84, x59, 0xccc52973); + let mut x85: u32 = 0; + let mut x86: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x85, &mut x86, 0x0, x84, x81); + let mut x87: u32 = 0; + let mut x88: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x87, &mut x88, x86, x82, x79); + let mut x89: u32 = 0; + let mut x90: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x89, &mut x90, x88, x80, x77); + let mut x91: u32 = 0; + let mut x92: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x91, &mut x92, x90, x78, x75); + let mut x93: u32 = 0; + let mut x94: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x93, &mut x94, x92, x76, x73); + let mut x95: u32 = 0; + let mut x96: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x95, &mut x96, x94, x74, x71); + let mut x97: u32 = 0; + let mut x98: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x97, &mut x98, x96, x72, x69); + let mut x99: u32 = 0; + let mut x100: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x99, &mut x100, x98, x70, x67); + let mut x101: u32 = 0; + let mut x102: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x101, &mut x102, x100, x68, x65); + let mut x103: u32 = 0; + let mut x104: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x103, &mut x104, x102, x66, x63); + let mut x105: u32 = 0; + let mut x106: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x105, &mut x106, x104, x64, x61); + let mut x107: u32 = 0; + let mut x108: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x107, &mut x108, 0x0, x35, x83); + let mut x109: u32 = 0; + let mut x110: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x109, &mut x110, x108, x37, x85); + let mut x111: u32 = 0; + let mut x112: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x39, x87); + let mut x113: u32 = 0; + let mut x114: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x113, &mut x114, x112, x41, x89); + let mut x115: u32 = 0; + let mut x116: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x115, &mut x116, x114, x43, x91); + let mut x117: u32 = 0; + let mut x118: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x117, &mut x118, x116, x45, x93); + let mut x119: u32 = 0; + let mut x120: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x119, &mut x120, x118, x47, x95); + let mut x121: u32 = 0; + let mut x122: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x121, &mut x122, x120, x49, x97); + let mut x123: u32 = 0; + let mut x124: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x123, &mut x124, x122, x51, x99); + let mut x125: u32 = 0; + let mut x126: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x125, &mut x126, x124, x53, x101); + let mut x127: u32 = 0; + let mut x128: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x127, &mut x128, x126, x55, x103); + let mut x129: u32 = 0; + let mut x130: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x129, &mut x130, x128, x57, x105); + let mut x131: u32 = 0; + let mut x132: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x131, &mut x132, x130, ((x58 as u32) + x14), ((x106 as u32) + x62)); + let mut x133: u32 = 0; + let mut x134: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x133, &mut x134, x1, 0xc84ee01); + let mut x135: u32 = 0; + let mut x136: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x135, &mut x136, x1, 0x2b39bf21); + let mut x137: u32 = 0; + let mut x138: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x137, &mut x138, x1, 0x3fb05b7a); + let mut x139: u32 = 0; + let mut x140: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x139, &mut x140, x1, 0x28266895); + let mut x141: u32 = 0; + let mut x142: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x141, &mut x142, x1, 0xd40d4917); + let mut x143: u32 = 0; + let mut x144: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x143, &mut x144, x1, 0x4aab1cc5); + let mut x145: u32 = 0; + let mut x146: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x145, &mut x146, x1, 0xbc3e483a); + let mut x147: u32 = 0; + let mut x148: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x147, &mut x148, x1, 0xfcb82947); + let mut x149: u32 = 0; + let mut x150: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x149, &mut x150, x1, 0xff3d81e5); + let mut x151: u32 = 0; + let mut x152: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x151, &mut x152, x1, 0xdf1aa419); + let mut x153: u32 = 0; + let mut x154: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x153, &mut x154, x1, 0x2d319b24); + let mut x155: u32 = 0; + let mut x156: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x155, &mut x156, x1, 0x19b409a9); + let mut x157: u32 = 0; + let mut x158: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x157, &mut x158, 0x0, x156, x153); + let mut x159: u32 = 0; + let mut x160: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x159, &mut x160, x158, x154, x151); + let mut x161: u32 = 0; + let mut x162: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x161, &mut x162, x160, x152, x149); + let mut x163: u32 = 0; + let mut x164: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x163, &mut x164, x162, x150, x147); + let mut x165: u32 = 0; + let mut x166: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x165, &mut x166, x164, x148, x145); + let mut x167: u32 = 0; + let mut x168: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x167, &mut x168, x166, x146, x143); + let mut x169: u32 = 0; + let mut x170: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x169, &mut x170, x168, x144, x141); + let mut x171: u32 = 0; + let mut x172: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x171, &mut x172, x170, x142, x139); + let mut x173: u32 = 0; + let mut x174: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x173, &mut x174, x172, x140, x137); + let mut x175: u32 = 0; + let mut x176: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x175, &mut x176, x174, x138, x135); + let mut x177: u32 = 0; + let mut x178: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x177, &mut x178, x176, x136, x133); + let mut x179: u32 = 0; + let mut x180: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x179, &mut x180, 0x0, x109, x155); + let mut x181: u32 = 0; + let mut x182: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x181, &mut x182, x180, x111, x157); + let mut x183: u32 = 0; + let mut x184: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x183, &mut x184, x182, x113, x159); + let mut x185: u32 = 0; + let mut x186: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x185, &mut x186, x184, x115, x161); + let mut x187: u32 = 0; + let mut x188: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x187, &mut x188, x186, x117, x163); + let mut x189: u32 = 0; + let mut x190: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x189, &mut x190, x188, x119, x165); + let mut x191: u32 = 0; + let mut x192: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x191, &mut x192, x190, x121, x167); + let mut x193: u32 = 0; + let mut x194: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x193, &mut x194, x192, x123, x169); + let mut x195: u32 = 0; + let mut x196: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x195, &mut x196, x194, x125, x171); + let mut x197: u32 = 0; + let mut x198: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x197, &mut x198, x196, x127, x173); + let mut x199: u32 = 0; + let mut x200: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x199, &mut x200, x198, x129, x175); + let mut x201: u32 = 0; + let mut x202: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x201, &mut x202, x200, x131, x177); + let mut x203: u32 = 0; + let mut x204: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x203, &mut x204, x179, 0xe88fdc45); + let mut x205: u32 = 0; + let mut x206: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x205, &mut x206, x203, 0xffffffff); + let mut x207: u32 = 0; + let mut x208: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x207, &mut x208, x203, 0xffffffff); + let mut x209: u32 = 0; + let mut x210: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x209, &mut x210, x203, 0xffffffff); + let mut x211: u32 = 0; + let mut x212: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x211, &mut x212, x203, 0xffffffff); + let mut x213: u32 = 0; + let mut x214: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x213, &mut x214, x203, 0xffffffff); + let mut x215: u32 = 0; + let mut x216: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x215, &mut x216, x203, 0xffffffff); + let mut x217: u32 = 0; + let mut x218: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x217, &mut x218, x203, 0xc7634d81); + let mut x219: u32 = 0; + let mut x220: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x219, &mut x220, x203, 0xf4372ddf); + let mut x221: u32 = 0; + let mut x222: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x221, &mut x222, x203, 0x581a0db2); + let mut x223: u32 = 0; + let mut x224: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x223, &mut x224, x203, 0x48b0a77a); + let mut x225: u32 = 0; + let mut x226: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x225, &mut x226, x203, 0xecec196a); + let mut x227: u32 = 0; + let mut x228: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x227, &mut x228, x203, 0xccc52973); + let mut x229: u32 = 0; + let mut x230: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x229, &mut x230, 0x0, x228, x225); + let mut x231: u32 = 0; + let mut x232: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x231, &mut x232, x230, x226, x223); + let mut x233: u32 = 0; + let mut x234: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x233, &mut x234, x232, x224, x221); + let mut x235: u32 = 0; + let mut x236: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x235, &mut x236, x234, x222, x219); + let mut x237: u32 = 0; + let mut x238: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x237, &mut x238, x236, x220, x217); + let mut x239: u32 = 0; + let mut x240: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x239, &mut x240, x238, x218, x215); + let mut x241: u32 = 0; + let mut x242: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x241, &mut x242, x240, x216, x213); + let mut x243: u32 = 0; + let mut x244: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x243, &mut x244, x242, x214, x211); + let mut x245: u32 = 0; + let mut x246: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x245, &mut x246, x244, x212, x209); + let mut x247: u32 = 0; + let mut x248: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x247, &mut x248, x246, x210, x207); + let mut x249: u32 = 0; + let mut x250: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x249, &mut x250, x248, x208, x205); + let mut x251: u32 = 0; + let mut x252: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x251, &mut x252, 0x0, x179, x227); + let mut x253: u32 = 0; + let mut x254: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x253, &mut x254, x252, x181, x229); + let mut x255: u32 = 0; + let mut x256: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x255, &mut x256, x254, x183, x231); + let mut x257: u32 = 0; + let mut x258: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x257, &mut x258, x256, x185, x233); + let mut x259: u32 = 0; + let mut x260: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x259, &mut x260, x258, x187, x235); + let mut x261: u32 = 0; + let mut x262: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x261, &mut x262, x260, x189, x237); + let mut x263: u32 = 0; + let mut x264: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x263, &mut x264, x262, x191, x239); + let mut x265: u32 = 0; + let mut x266: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x265, &mut x266, x264, x193, x241); + let mut x267: u32 = 0; + let mut x268: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x267, &mut x268, x266, x195, x243); + let mut x269: u32 = 0; + let mut x270: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x269, &mut x270, x268, x197, x245); + let mut x271: u32 = 0; + let mut x272: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x271, &mut x272, x270, x199, x247); + let mut x273: u32 = 0; + let mut x274: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x273, &mut x274, x272, x201, x249); + let mut x275: u32 = 0; + let mut x276: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x275, &mut x276, x274, (((x202 as u32) + (x132 as u32)) + ((x178 as u32) + x134)), ((x250 as u32) + x206)); + let mut x277: u32 = 0; + let mut x278: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x277, &mut x278, x2, 0xc84ee01); + let mut x279: u32 = 0; + let mut x280: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x279, &mut x280, x2, 0x2b39bf21); + let mut x281: u32 = 0; + let mut x282: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x281, &mut x282, x2, 0x3fb05b7a); + let mut x283: u32 = 0; + let mut x284: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x283, &mut x284, x2, 0x28266895); + let mut x285: u32 = 0; + let mut x286: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x285, &mut x286, x2, 0xd40d4917); + let mut x287: u32 = 0; + let mut x288: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x287, &mut x288, x2, 0x4aab1cc5); + let mut x289: u32 = 0; + let mut x290: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x289, &mut x290, x2, 0xbc3e483a); + let mut x291: u32 = 0; + let mut x292: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x291, &mut x292, x2, 0xfcb82947); + let mut x293: u32 = 0; + let mut x294: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x293, &mut x294, x2, 0xff3d81e5); + let mut x295: u32 = 0; + let mut x296: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x295, &mut x296, x2, 0xdf1aa419); + let mut x297: u32 = 0; + let mut x298: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x297, &mut x298, x2, 0x2d319b24); + let mut x299: u32 = 0; + let mut x300: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x299, &mut x300, x2, 0x19b409a9); + let mut x301: u32 = 0; + let mut x302: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x301, &mut x302, 0x0, x300, x297); + let mut x303: u32 = 0; + let mut x304: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x303, &mut x304, x302, x298, x295); + let mut x305: u32 = 0; + let mut x306: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x305, &mut x306, x304, x296, x293); + let mut x307: u32 = 0; + let mut x308: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x307, &mut x308, x306, x294, x291); + let mut x309: u32 = 0; + let mut x310: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x309, &mut x310, x308, x292, x289); + let mut x311: u32 = 0; + let mut x312: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x311, &mut x312, x310, x290, x287); + let mut x313: u32 = 0; + let mut x314: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x313, &mut x314, x312, x288, x285); + let mut x315: u32 = 0; + let mut x316: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x315, &mut x316, x314, x286, x283); + let mut x317: u32 = 0; + let mut x318: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x317, &mut x318, x316, x284, x281); + let mut x319: u32 = 0; + let mut x320: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x319, &mut x320, x318, x282, x279); + let mut x321: u32 = 0; + let mut x322: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x321, &mut x322, x320, x280, x277); + let mut x323: u32 = 0; + let mut x324: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x323, &mut x324, 0x0, x253, x299); + let mut x325: u32 = 0; + let mut x326: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x325, &mut x326, x324, x255, x301); + let mut x327: u32 = 0; + let mut x328: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x327, &mut x328, x326, x257, x303); + let mut x329: u32 = 0; + let mut x330: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x329, &mut x330, x328, x259, x305); + let mut x331: u32 = 0; + let mut x332: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x331, &mut x332, x330, x261, x307); + let mut x333: u32 = 0; + let mut x334: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x333, &mut x334, x332, x263, x309); + let mut x335: u32 = 0; + let mut x336: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x335, &mut x336, x334, x265, x311); + let mut x337: u32 = 0; + let mut x338: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x337, &mut x338, x336, x267, x313); + let mut x339: u32 = 0; + let mut x340: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x339, &mut x340, x338, x269, x315); + let mut x341: u32 = 0; + let mut x342: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x341, &mut x342, x340, x271, x317); + let mut x343: u32 = 0; + let mut x344: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x343, &mut x344, x342, x273, x319); + let mut x345: u32 = 0; + let mut x346: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x345, &mut x346, x344, x275, x321); + let mut x347: u32 = 0; + let mut x348: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x347, &mut x348, x323, 0xe88fdc45); + let mut x349: u32 = 0; + let mut x350: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x349, &mut x350, x347, 0xffffffff); + let mut x351: u32 = 0; + let mut x352: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x351, &mut x352, x347, 0xffffffff); + let mut x353: u32 = 0; + let mut x354: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x353, &mut x354, x347, 0xffffffff); + let mut x355: u32 = 0; + let mut x356: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x355, &mut x356, x347, 0xffffffff); + let mut x357: u32 = 0; + let mut x358: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x357, &mut x358, x347, 0xffffffff); + let mut x359: u32 = 0; + let mut x360: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x359, &mut x360, x347, 0xffffffff); + let mut x361: u32 = 0; + let mut x362: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x361, &mut x362, x347, 0xc7634d81); + let mut x363: u32 = 0; + let mut x364: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x363, &mut x364, x347, 0xf4372ddf); + let mut x365: u32 = 0; + let mut x366: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x365, &mut x366, x347, 0x581a0db2); + let mut x367: u32 = 0; + let mut x368: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x367, &mut x368, x347, 0x48b0a77a); + let mut x369: u32 = 0; + let mut x370: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x369, &mut x370, x347, 0xecec196a); + let mut x371: u32 = 0; + let mut x372: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x371, &mut x372, x347, 0xccc52973); + let mut x373: u32 = 0; + let mut x374: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x373, &mut x374, 0x0, x372, x369); + let mut x375: u32 = 0; + let mut x376: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x375, &mut x376, x374, x370, x367); + let mut x377: u32 = 0; + let mut x378: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x377, &mut x378, x376, x368, x365); + let mut x379: u32 = 0; + let mut x380: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x379, &mut x380, x378, x366, x363); + let mut x381: u32 = 0; + let mut x382: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x381, &mut x382, x380, x364, x361); + let mut x383: u32 = 0; + let mut x384: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x383, &mut x384, x382, x362, x359); + let mut x385: u32 = 0; + let mut x386: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x385, &mut x386, x384, x360, x357); + let mut x387: u32 = 0; + let mut x388: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x387, &mut x388, x386, x358, x355); + let mut x389: u32 = 0; + let mut x390: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x389, &mut x390, x388, x356, x353); + let mut x391: u32 = 0; + let mut x392: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x391, &mut x392, x390, x354, x351); + let mut x393: u32 = 0; + let mut x394: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x393, &mut x394, x392, x352, x349); + let mut x395: u32 = 0; + let mut x396: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x395, &mut x396, 0x0, x323, x371); + let mut x397: u32 = 0; + let mut x398: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x397, &mut x398, x396, x325, x373); + let mut x399: u32 = 0; + let mut x400: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x399, &mut x400, x398, x327, x375); + let mut x401: u32 = 0; + let mut x402: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x401, &mut x402, x400, x329, x377); + let mut x403: u32 = 0; + let mut x404: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x403, &mut x404, x402, x331, x379); + let mut x405: u32 = 0; + let mut x406: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x405, &mut x406, x404, x333, x381); + let mut x407: u32 = 0; + let mut x408: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x407, &mut x408, x406, x335, x383); + let mut x409: u32 = 0; + let mut x410: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x409, &mut x410, x408, x337, x385); + let mut x411: u32 = 0; + let mut x412: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x411, &mut x412, x410, x339, x387); + let mut x413: u32 = 0; + let mut x414: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x413, &mut x414, x412, x341, x389); + let mut x415: u32 = 0; + let mut x416: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x415, &mut x416, x414, x343, x391); + let mut x417: u32 = 0; + let mut x418: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x417, &mut x418, x416, x345, x393); + let mut x419: u32 = 0; + let mut x420: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x419, &mut x420, x418, (((x346 as u32) + (x276 as u32)) + ((x322 as u32) + x278)), ((x394 as u32) + x350)); + let mut x421: u32 = 0; + let mut x422: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x421, &mut x422, x3, 0xc84ee01); + let mut x423: u32 = 0; + let mut x424: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x423, &mut x424, x3, 0x2b39bf21); + let mut x425: u32 = 0; + let mut x426: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x425, &mut x426, x3, 0x3fb05b7a); + let mut x427: u32 = 0; + let mut x428: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x427, &mut x428, x3, 0x28266895); + let mut x429: u32 = 0; + let mut x430: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x429, &mut x430, x3, 0xd40d4917); + let mut x431: u32 = 0; + let mut x432: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x431, &mut x432, x3, 0x4aab1cc5); + let mut x433: u32 = 0; + let mut x434: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x433, &mut x434, x3, 0xbc3e483a); + let mut x435: u32 = 0; + let mut x436: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x435, &mut x436, x3, 0xfcb82947); + let mut x437: u32 = 0; + let mut x438: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x437, &mut x438, x3, 0xff3d81e5); + let mut x439: u32 = 0; + let mut x440: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x439, &mut x440, x3, 0xdf1aa419); + let mut x441: u32 = 0; + let mut x442: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x441, &mut x442, x3, 0x2d319b24); + let mut x443: u32 = 0; + let mut x444: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x443, &mut x444, x3, 0x19b409a9); + let mut x445: u32 = 0; + let mut x446: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x445, &mut x446, 0x0, x444, x441); + let mut x447: u32 = 0; + let mut x448: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x447, &mut x448, x446, x442, x439); + let mut x449: u32 = 0; + let mut x450: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x449, &mut x450, x448, x440, x437); + let mut x451: u32 = 0; + let mut x452: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x451, &mut x452, x450, x438, x435); + let mut x453: u32 = 0; + let mut x454: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x453, &mut x454, x452, x436, x433); + let mut x455: u32 = 0; + let mut x456: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x455, &mut x456, x454, x434, x431); + let mut x457: u32 = 0; + let mut x458: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x457, &mut x458, x456, x432, x429); + let mut x459: u32 = 0; + let mut x460: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x459, &mut x460, x458, x430, x427); + let mut x461: u32 = 0; + let mut x462: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x461, &mut x462, x460, x428, x425); + let mut x463: u32 = 0; + let mut x464: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x463, &mut x464, x462, x426, x423); + let mut x465: u32 = 0; + let mut x466: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x465, &mut x466, x464, x424, x421); + let mut x467: u32 = 0; + let mut x468: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x467, &mut x468, 0x0, x397, x443); + let mut x469: u32 = 0; + let mut x470: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x469, &mut x470, x468, x399, x445); + let mut x471: u32 = 0; + let mut x472: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x471, &mut x472, x470, x401, x447); + let mut x473: u32 = 0; + let mut x474: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x473, &mut x474, x472, x403, x449); + let mut x475: u32 = 0; + let mut x476: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x475, &mut x476, x474, x405, x451); + let mut x477: u32 = 0; + let mut x478: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x477, &mut x478, x476, x407, x453); + let mut x479: u32 = 0; + let mut x480: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x479, &mut x480, x478, x409, x455); + let mut x481: u32 = 0; + let mut x482: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x481, &mut x482, x480, x411, x457); + let mut x483: u32 = 0; + let mut x484: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x483, &mut x484, x482, x413, x459); + let mut x485: u32 = 0; + let mut x486: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x485, &mut x486, x484, x415, x461); + let mut x487: u32 = 0; + let mut x488: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x487, &mut x488, x486, x417, x463); + let mut x489: u32 = 0; + let mut x490: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x489, &mut x490, x488, x419, x465); + let mut x491: u32 = 0; + let mut x492: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x491, &mut x492, x467, 0xe88fdc45); + let mut x493: u32 = 0; + let mut x494: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x493, &mut x494, x491, 0xffffffff); + let mut x495: u32 = 0; + let mut x496: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x495, &mut x496, x491, 0xffffffff); + let mut x497: u32 = 0; + let mut x498: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x497, &mut x498, x491, 0xffffffff); + let mut x499: u32 = 0; + let mut x500: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x499, &mut x500, x491, 0xffffffff); + let mut x501: u32 = 0; + let mut x502: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x501, &mut x502, x491, 0xffffffff); + let mut x503: u32 = 0; + let mut x504: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x503, &mut x504, x491, 0xffffffff); + let mut x505: u32 = 0; + let mut x506: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x505, &mut x506, x491, 0xc7634d81); + let mut x507: u32 = 0; + let mut x508: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x507, &mut x508, x491, 0xf4372ddf); + let mut x509: u32 = 0; + let mut x510: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x509, &mut x510, x491, 0x581a0db2); + let mut x511: u32 = 0; + let mut x512: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x511, &mut x512, x491, 0x48b0a77a); + let mut x513: u32 = 0; + let mut x514: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x513, &mut x514, x491, 0xecec196a); + let mut x515: u32 = 0; + let mut x516: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x515, &mut x516, x491, 0xccc52973); + let mut x517: u32 = 0; + let mut x518: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x517, &mut x518, 0x0, x516, x513); + let mut x519: u32 = 0; + let mut x520: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x519, &mut x520, x518, x514, x511); + let mut x521: u32 = 0; + let mut x522: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x521, &mut x522, x520, x512, x509); + let mut x523: u32 = 0; + let mut x524: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x523, &mut x524, x522, x510, x507); + let mut x525: u32 = 0; + let mut x526: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x525, &mut x526, x524, x508, x505); + let mut x527: u32 = 0; + let mut x528: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x527, &mut x528, x526, x506, x503); + let mut x529: u32 = 0; + let mut x530: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x529, &mut x530, x528, x504, x501); + let mut x531: u32 = 0; + let mut x532: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x531, &mut x532, x530, x502, x499); + let mut x533: u32 = 0; + let mut x534: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x533, &mut x534, x532, x500, x497); + let mut x535: u32 = 0; + let mut x536: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x535, &mut x536, x534, x498, x495); + let mut x537: u32 = 0; + let mut x538: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x537, &mut x538, x536, x496, x493); + let mut x539: u32 = 0; + let mut x540: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x539, &mut x540, 0x0, x467, x515); + let mut x541: u32 = 0; + let mut x542: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x541, &mut x542, x540, x469, x517); + let mut x543: u32 = 0; + let mut x544: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x543, &mut x544, x542, x471, x519); + let mut x545: u32 = 0; + let mut x546: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x545, &mut x546, x544, x473, x521); + let mut x547: u32 = 0; + let mut x548: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x547, &mut x548, x546, x475, x523); + let mut x549: u32 = 0; + let mut x550: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x549, &mut x550, x548, x477, x525); + let mut x551: u32 = 0; + let mut x552: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x551, &mut x552, x550, x479, x527); + let mut x553: u32 = 0; + let mut x554: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x553, &mut x554, x552, x481, x529); + let mut x555: u32 = 0; + let mut x556: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x555, &mut x556, x554, x483, x531); + let mut x557: u32 = 0; + let mut x558: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x557, &mut x558, x556, x485, x533); + let mut x559: u32 = 0; + let mut x560: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x559, &mut x560, x558, x487, x535); + let mut x561: u32 = 0; + let mut x562: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x561, &mut x562, x560, x489, x537); + let mut x563: u32 = 0; + let mut x564: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x563, &mut x564, x562, (((x490 as u32) + (x420 as u32)) + ((x466 as u32) + x422)), ((x538 as u32) + x494)); + let mut x565: u32 = 0; + let mut x566: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x565, &mut x566, x4, 0xc84ee01); + let mut x567: u32 = 0; + let mut x568: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x567, &mut x568, x4, 0x2b39bf21); + let mut x569: u32 = 0; + let mut x570: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x569, &mut x570, x4, 0x3fb05b7a); + let mut x571: u32 = 0; + let mut x572: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x571, &mut x572, x4, 0x28266895); + let mut x573: u32 = 0; + let mut x574: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x573, &mut x574, x4, 0xd40d4917); + let mut x575: u32 = 0; + let mut x576: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x575, &mut x576, x4, 0x4aab1cc5); + let mut x577: u32 = 0; + let mut x578: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x577, &mut x578, x4, 0xbc3e483a); + let mut x579: u32 = 0; + let mut x580: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x579, &mut x580, x4, 0xfcb82947); + let mut x581: u32 = 0; + let mut x582: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x581, &mut x582, x4, 0xff3d81e5); + let mut x583: u32 = 0; + let mut x584: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x583, &mut x584, x4, 0xdf1aa419); + let mut x585: u32 = 0; + let mut x586: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x585, &mut x586, x4, 0x2d319b24); + let mut x587: u32 = 0; + let mut x588: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x587, &mut x588, x4, 0x19b409a9); + let mut x589: u32 = 0; + let mut x590: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x589, &mut x590, 0x0, x588, x585); + let mut x591: u32 = 0; + let mut x592: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x591, &mut x592, x590, x586, x583); + let mut x593: u32 = 0; + let mut x594: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x593, &mut x594, x592, x584, x581); + let mut x595: u32 = 0; + let mut x596: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x595, &mut x596, x594, x582, x579); + let mut x597: u32 = 0; + let mut x598: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x597, &mut x598, x596, x580, x577); + let mut x599: u32 = 0; + let mut x600: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x599, &mut x600, x598, x578, x575); + let mut x601: u32 = 0; + let mut x602: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x601, &mut x602, x600, x576, x573); + let mut x603: u32 = 0; + let mut x604: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x603, &mut x604, x602, x574, x571); + let mut x605: u32 = 0; + let mut x606: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x605, &mut x606, x604, x572, x569); + let mut x607: u32 = 0; + let mut x608: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x607, &mut x608, x606, x570, x567); + let mut x609: u32 = 0; + let mut x610: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x609, &mut x610, x608, x568, x565); + let mut x611: u32 = 0; + let mut x612: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x611, &mut x612, 0x0, x541, x587); + let mut x613: u32 = 0; + let mut x614: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x613, &mut x614, x612, x543, x589); + let mut x615: u32 = 0; + let mut x616: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x615, &mut x616, x614, x545, x591); + let mut x617: u32 = 0; + let mut x618: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x617, &mut x618, x616, x547, x593); + let mut x619: u32 = 0; + let mut x620: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x619, &mut x620, x618, x549, x595); + let mut x621: u32 = 0; + let mut x622: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x621, &mut x622, x620, x551, x597); + let mut x623: u32 = 0; + let mut x624: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x623, &mut x624, x622, x553, x599); + let mut x625: u32 = 0; + let mut x626: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x625, &mut x626, x624, x555, x601); + let mut x627: u32 = 0; + let mut x628: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x627, &mut x628, x626, x557, x603); + let mut x629: u32 = 0; + let mut x630: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x629, &mut x630, x628, x559, x605); + let mut x631: u32 = 0; + let mut x632: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x631, &mut x632, x630, x561, x607); + let mut x633: u32 = 0; + let mut x634: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x633, &mut x634, x632, x563, x609); + let mut x635: u32 = 0; + let mut x636: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x635, &mut x636, x611, 0xe88fdc45); + let mut x637: u32 = 0; + let mut x638: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x637, &mut x638, x635, 0xffffffff); + let mut x639: u32 = 0; + let mut x640: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x639, &mut x640, x635, 0xffffffff); + let mut x641: u32 = 0; + let mut x642: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x641, &mut x642, x635, 0xffffffff); + let mut x643: u32 = 0; + let mut x644: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x643, &mut x644, x635, 0xffffffff); + let mut x645: u32 = 0; + let mut x646: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x645, &mut x646, x635, 0xffffffff); + let mut x647: u32 = 0; + let mut x648: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x647, &mut x648, x635, 0xffffffff); + let mut x649: u32 = 0; + let mut x650: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x649, &mut x650, x635, 0xc7634d81); + let mut x651: u32 = 0; + let mut x652: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x651, &mut x652, x635, 0xf4372ddf); + let mut x653: u32 = 0; + let mut x654: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x653, &mut x654, x635, 0x581a0db2); + let mut x655: u32 = 0; + let mut x656: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x655, &mut x656, x635, 0x48b0a77a); + let mut x657: u32 = 0; + let mut x658: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x657, &mut x658, x635, 0xecec196a); + let mut x659: u32 = 0; + let mut x660: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x659, &mut x660, x635, 0xccc52973); + let mut x661: u32 = 0; + let mut x662: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x661, &mut x662, 0x0, x660, x657); + let mut x663: u32 = 0; + let mut x664: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x663, &mut x664, x662, x658, x655); + let mut x665: u32 = 0; + let mut x666: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x665, &mut x666, x664, x656, x653); + let mut x667: u32 = 0; + let mut x668: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x667, &mut x668, x666, x654, x651); + let mut x669: u32 = 0; + let mut x670: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x669, &mut x670, x668, x652, x649); + let mut x671: u32 = 0; + let mut x672: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x671, &mut x672, x670, x650, x647); + let mut x673: u32 = 0; + let mut x674: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x673, &mut x674, x672, x648, x645); + let mut x675: u32 = 0; + let mut x676: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x675, &mut x676, x674, x646, x643); + let mut x677: u32 = 0; + let mut x678: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x677, &mut x678, x676, x644, x641); + let mut x679: u32 = 0; + let mut x680: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x679, &mut x680, x678, x642, x639); + let mut x681: u32 = 0; + let mut x682: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x681, &mut x682, x680, x640, x637); + let mut x683: u32 = 0; + let mut x684: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x683, &mut x684, 0x0, x611, x659); + let mut x685: u32 = 0; + let mut x686: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x685, &mut x686, x684, x613, x661); + let mut x687: u32 = 0; + let mut x688: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x687, &mut x688, x686, x615, x663); + let mut x689: u32 = 0; + let mut x690: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x689, &mut x690, x688, x617, x665); + let mut x691: u32 = 0; + let mut x692: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x691, &mut x692, x690, x619, x667); + let mut x693: u32 = 0; + let mut x694: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x693, &mut x694, x692, x621, x669); + let mut x695: u32 = 0; + let mut x696: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x695, &mut x696, x694, x623, x671); + let mut x697: u32 = 0; + let mut x698: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x697, &mut x698, x696, x625, x673); + let mut x699: u32 = 0; + let mut x700: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x699, &mut x700, x698, x627, x675); + let mut x701: u32 = 0; + let mut x702: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x701, &mut x702, x700, x629, x677); + let mut x703: u32 = 0; + let mut x704: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x703, &mut x704, x702, x631, x679); + let mut x705: u32 = 0; + let mut x706: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x705, &mut x706, x704, x633, x681); + let mut x707: u32 = 0; + let mut x708: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x707, &mut x708, x706, (((x634 as u32) + (x564 as u32)) + ((x610 as u32) + x566)), ((x682 as u32) + x638)); + let mut x709: u32 = 0; + let mut x710: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x709, &mut x710, x5, 0xc84ee01); + let mut x711: u32 = 0; + let mut x712: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x711, &mut x712, x5, 0x2b39bf21); + let mut x713: u32 = 0; + let mut x714: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x713, &mut x714, x5, 0x3fb05b7a); + let mut x715: u32 = 0; + let mut x716: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x715, &mut x716, x5, 0x28266895); + let mut x717: u32 = 0; + let mut x718: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x717, &mut x718, x5, 0xd40d4917); + let mut x719: u32 = 0; + let mut x720: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x719, &mut x720, x5, 0x4aab1cc5); + let mut x721: u32 = 0; + let mut x722: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x721, &mut x722, x5, 0xbc3e483a); + let mut x723: u32 = 0; + let mut x724: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x723, &mut x724, x5, 0xfcb82947); + let mut x725: u32 = 0; + let mut x726: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x725, &mut x726, x5, 0xff3d81e5); + let mut x727: u32 = 0; + let mut x728: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x727, &mut x728, x5, 0xdf1aa419); + let mut x729: u32 = 0; + let mut x730: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x729, &mut x730, x5, 0x2d319b24); + let mut x731: u32 = 0; + let mut x732: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x731, &mut x732, x5, 0x19b409a9); + let mut x733: u32 = 0; + let mut x734: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x733, &mut x734, 0x0, x732, x729); + let mut x735: u32 = 0; + let mut x736: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x735, &mut x736, x734, x730, x727); + let mut x737: u32 = 0; + let mut x738: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x737, &mut x738, x736, x728, x725); + let mut x739: u32 = 0; + let mut x740: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x739, &mut x740, x738, x726, x723); + let mut x741: u32 = 0; + let mut x742: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x741, &mut x742, x740, x724, x721); + let mut x743: u32 = 0; + let mut x744: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x743, &mut x744, x742, x722, x719); + let mut x745: u32 = 0; + let mut x746: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x745, &mut x746, x744, x720, x717); + let mut x747: u32 = 0; + let mut x748: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x747, &mut x748, x746, x718, x715); + let mut x749: u32 = 0; + let mut x750: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x749, &mut x750, x748, x716, x713); + let mut x751: u32 = 0; + let mut x752: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x751, &mut x752, x750, x714, x711); + let mut x753: u32 = 0; + let mut x754: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x753, &mut x754, x752, x712, x709); + let mut x755: u32 = 0; + let mut x756: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x755, &mut x756, 0x0, x685, x731); + let mut x757: u32 = 0; + let mut x758: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x757, &mut x758, x756, x687, x733); + let mut x759: u32 = 0; + let mut x760: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x759, &mut x760, x758, x689, x735); + let mut x761: u32 = 0; + let mut x762: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x761, &mut x762, x760, x691, x737); + let mut x763: u32 = 0; + let mut x764: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x763, &mut x764, x762, x693, x739); + let mut x765: u32 = 0; + let mut x766: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x765, &mut x766, x764, x695, x741); + let mut x767: u32 = 0; + let mut x768: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x767, &mut x768, x766, x697, x743); + let mut x769: u32 = 0; + let mut x770: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x769, &mut x770, x768, x699, x745); + let mut x771: u32 = 0; + let mut x772: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x771, &mut x772, x770, x701, x747); + let mut x773: u32 = 0; + let mut x774: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x773, &mut x774, x772, x703, x749); + let mut x775: u32 = 0; + let mut x776: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x775, &mut x776, x774, x705, x751); + let mut x777: u32 = 0; + let mut x778: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x777, &mut x778, x776, x707, x753); + let mut x779: u32 = 0; + let mut x780: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x779, &mut x780, x755, 0xe88fdc45); + let mut x781: u32 = 0; + let mut x782: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x781, &mut x782, x779, 0xffffffff); + let mut x783: u32 = 0; + let mut x784: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x783, &mut x784, x779, 0xffffffff); + let mut x785: u32 = 0; + let mut x786: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x785, &mut x786, x779, 0xffffffff); + let mut x787: u32 = 0; + let mut x788: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x787, &mut x788, x779, 0xffffffff); + let mut x789: u32 = 0; + let mut x790: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x789, &mut x790, x779, 0xffffffff); + let mut x791: u32 = 0; + let mut x792: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x791, &mut x792, x779, 0xffffffff); + let mut x793: u32 = 0; + let mut x794: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x793, &mut x794, x779, 0xc7634d81); + let mut x795: u32 = 0; + let mut x796: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x795, &mut x796, x779, 0xf4372ddf); + let mut x797: u32 = 0; + let mut x798: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x797, &mut x798, x779, 0x581a0db2); + let mut x799: u32 = 0; + let mut x800: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x799, &mut x800, x779, 0x48b0a77a); + let mut x801: u32 = 0; + let mut x802: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x801, &mut x802, x779, 0xecec196a); + let mut x803: u32 = 0; + let mut x804: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x803, &mut x804, x779, 0xccc52973); + let mut x805: u32 = 0; + let mut x806: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x805, &mut x806, 0x0, x804, x801); + let mut x807: u32 = 0; + let mut x808: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x807, &mut x808, x806, x802, x799); + let mut x809: u32 = 0; + let mut x810: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x809, &mut x810, x808, x800, x797); + let mut x811: u32 = 0; + let mut x812: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x811, &mut x812, x810, x798, x795); + let mut x813: u32 = 0; + let mut x814: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x813, &mut x814, x812, x796, x793); + let mut x815: u32 = 0; + let mut x816: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x815, &mut x816, x814, x794, x791); + let mut x817: u32 = 0; + let mut x818: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x817, &mut x818, x816, x792, x789); + let mut x819: u32 = 0; + let mut x820: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x819, &mut x820, x818, x790, x787); + let mut x821: u32 = 0; + let mut x822: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x821, &mut x822, x820, x788, x785); + let mut x823: u32 = 0; + let mut x824: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x823, &mut x824, x822, x786, x783); + let mut x825: u32 = 0; + let mut x826: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x825, &mut x826, x824, x784, x781); + let mut x827: u32 = 0; + let mut x828: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x827, &mut x828, 0x0, x755, x803); + let mut x829: u32 = 0; + let mut x830: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x829, &mut x830, x828, x757, x805); + let mut x831: u32 = 0; + let mut x832: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x831, &mut x832, x830, x759, x807); + let mut x833: u32 = 0; + let mut x834: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x833, &mut x834, x832, x761, x809); + let mut x835: u32 = 0; + let mut x836: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x835, &mut x836, x834, x763, x811); + let mut x837: u32 = 0; + let mut x838: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x837, &mut x838, x836, x765, x813); + let mut x839: u32 = 0; + let mut x840: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x839, &mut x840, x838, x767, x815); + let mut x841: u32 = 0; + let mut x842: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x841, &mut x842, x840, x769, x817); + let mut x843: u32 = 0; + let mut x844: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x843, &mut x844, x842, x771, x819); + let mut x845: u32 = 0; + let mut x846: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x845, &mut x846, x844, x773, x821); + let mut x847: u32 = 0; + let mut x848: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x847, &mut x848, x846, x775, x823); + let mut x849: u32 = 0; + let mut x850: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x849, &mut x850, x848, x777, x825); + let mut x851: u32 = 0; + let mut x852: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x851, &mut x852, x850, (((x778 as u32) + (x708 as u32)) + ((x754 as u32) + x710)), ((x826 as u32) + x782)); + let mut x853: u32 = 0; + let mut x854: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x853, &mut x854, x6, 0xc84ee01); + let mut x855: u32 = 0; + let mut x856: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x855, &mut x856, x6, 0x2b39bf21); + let mut x857: u32 = 0; + let mut x858: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x857, &mut x858, x6, 0x3fb05b7a); + let mut x859: u32 = 0; + let mut x860: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x859, &mut x860, x6, 0x28266895); + let mut x861: u32 = 0; + let mut x862: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x861, &mut x862, x6, 0xd40d4917); + let mut x863: u32 = 0; + let mut x864: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x863, &mut x864, x6, 0x4aab1cc5); + let mut x865: u32 = 0; + let mut x866: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x865, &mut x866, x6, 0xbc3e483a); + let mut x867: u32 = 0; + let mut x868: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x867, &mut x868, x6, 0xfcb82947); + let mut x869: u32 = 0; + let mut x870: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x869, &mut x870, x6, 0xff3d81e5); + let mut x871: u32 = 0; + let mut x872: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x871, &mut x872, x6, 0xdf1aa419); + let mut x873: u32 = 0; + let mut x874: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x873, &mut x874, x6, 0x2d319b24); + let mut x875: u32 = 0; + let mut x876: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x875, &mut x876, x6, 0x19b409a9); + let mut x877: u32 = 0; + let mut x878: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x877, &mut x878, 0x0, x876, x873); + let mut x879: u32 = 0; + let mut x880: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x879, &mut x880, x878, x874, x871); + let mut x881: u32 = 0; + let mut x882: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x881, &mut x882, x880, x872, x869); + let mut x883: u32 = 0; + let mut x884: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x883, &mut x884, x882, x870, x867); + let mut x885: u32 = 0; + let mut x886: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x885, &mut x886, x884, x868, x865); + let mut x887: u32 = 0; + let mut x888: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x887, &mut x888, x886, x866, x863); + let mut x889: u32 = 0; + let mut x890: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x889, &mut x890, x888, x864, x861); + let mut x891: u32 = 0; + let mut x892: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x891, &mut x892, x890, x862, x859); + let mut x893: u32 = 0; + let mut x894: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x893, &mut x894, x892, x860, x857); + let mut x895: u32 = 0; + let mut x896: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x895, &mut x896, x894, x858, x855); + let mut x897: u32 = 0; + let mut x898: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x897, &mut x898, x896, x856, x853); + let mut x899: u32 = 0; + let mut x900: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x899, &mut x900, 0x0, x829, x875); + let mut x901: u32 = 0; + let mut x902: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x901, &mut x902, x900, x831, x877); + let mut x903: u32 = 0; + let mut x904: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x903, &mut x904, x902, x833, x879); + let mut x905: u32 = 0; + let mut x906: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x905, &mut x906, x904, x835, x881); + let mut x907: u32 = 0; + let mut x908: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x907, &mut x908, x906, x837, x883); + let mut x909: u32 = 0; + let mut x910: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x909, &mut x910, x908, x839, x885); + let mut x911: u32 = 0; + let mut x912: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x911, &mut x912, x910, x841, x887); + let mut x913: u32 = 0; + let mut x914: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x913, &mut x914, x912, x843, x889); + let mut x915: u32 = 0; + let mut x916: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x915, &mut x916, x914, x845, x891); + let mut x917: u32 = 0; + let mut x918: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x917, &mut x918, x916, x847, x893); + let mut x919: u32 = 0; + let mut x920: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x919, &mut x920, x918, x849, x895); + let mut x921: u32 = 0; + let mut x922: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x921, &mut x922, x920, x851, x897); + let mut x923: u32 = 0; + let mut x924: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x923, &mut x924, x899, 0xe88fdc45); + let mut x925: u32 = 0; + let mut x926: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x925, &mut x926, x923, 0xffffffff); + let mut x927: u32 = 0; + let mut x928: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x927, &mut x928, x923, 0xffffffff); + let mut x929: u32 = 0; + let mut x930: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x929, &mut x930, x923, 0xffffffff); + let mut x931: u32 = 0; + let mut x932: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x931, &mut x932, x923, 0xffffffff); + let mut x933: u32 = 0; + let mut x934: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x933, &mut x934, x923, 0xffffffff); + let mut x935: u32 = 0; + let mut x936: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x935, &mut x936, x923, 0xffffffff); + let mut x937: u32 = 0; + let mut x938: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x937, &mut x938, x923, 0xc7634d81); + let mut x939: u32 = 0; + let mut x940: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x939, &mut x940, x923, 0xf4372ddf); + let mut x941: u32 = 0; + let mut x942: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x941, &mut x942, x923, 0x581a0db2); + let mut x943: u32 = 0; + let mut x944: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x943, &mut x944, x923, 0x48b0a77a); + let mut x945: u32 = 0; + let mut x946: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x945, &mut x946, x923, 0xecec196a); + let mut x947: u32 = 0; + let mut x948: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x947, &mut x948, x923, 0xccc52973); + let mut x949: u32 = 0; + let mut x950: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x949, &mut x950, 0x0, x948, x945); + let mut x951: u32 = 0; + let mut x952: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x951, &mut x952, x950, x946, x943); + let mut x953: u32 = 0; + let mut x954: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x953, &mut x954, x952, x944, x941); + let mut x955: u32 = 0; + let mut x956: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x955, &mut x956, x954, x942, x939); + let mut x957: u32 = 0; + let mut x958: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x957, &mut x958, x956, x940, x937); + let mut x959: u32 = 0; + let mut x960: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x959, &mut x960, x958, x938, x935); + let mut x961: u32 = 0; + let mut x962: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x961, &mut x962, x960, x936, x933); + let mut x963: u32 = 0; + let mut x964: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x963, &mut x964, x962, x934, x931); + let mut x965: u32 = 0; + let mut x966: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x965, &mut x966, x964, x932, x929); + let mut x967: u32 = 0; + let mut x968: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x967, &mut x968, x966, x930, x927); + let mut x969: u32 = 0; + let mut x970: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x969, &mut x970, x968, x928, x925); + let mut x971: u32 = 0; + let mut x972: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x971, &mut x972, 0x0, x899, x947); + let mut x973: u32 = 0; + let mut x974: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x973, &mut x974, x972, x901, x949); + let mut x975: u32 = 0; + let mut x976: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x975, &mut x976, x974, x903, x951); + let mut x977: u32 = 0; + let mut x978: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x977, &mut x978, x976, x905, x953); + let mut x979: u32 = 0; + let mut x980: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x979, &mut x980, x978, x907, x955); + let mut x981: u32 = 0; + let mut x982: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x981, &mut x982, x980, x909, x957); + let mut x983: u32 = 0; + let mut x984: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x983, &mut x984, x982, x911, x959); + let mut x985: u32 = 0; + let mut x986: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x985, &mut x986, x984, x913, x961); + let mut x987: u32 = 0; + let mut x988: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x987, &mut x988, x986, x915, x963); + let mut x989: u32 = 0; + let mut x990: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x989, &mut x990, x988, x917, x965); + let mut x991: u32 = 0; + let mut x992: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x991, &mut x992, x990, x919, x967); + let mut x993: u32 = 0; + let mut x994: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x993, &mut x994, x992, x921, x969); + let mut x995: u32 = 0; + let mut x996: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x995, &mut x996, x994, (((x922 as u32) + (x852 as u32)) + ((x898 as u32) + x854)), ((x970 as u32) + x926)); + let mut x997: u32 = 0; + let mut x998: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x997, &mut x998, x7, 0xc84ee01); + let mut x999: u32 = 0; + let mut x1000: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x999, &mut x1000, x7, 0x2b39bf21); + let mut x1001: u32 = 0; + let mut x1002: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1001, &mut x1002, x7, 0x3fb05b7a); + let mut x1003: u32 = 0; + let mut x1004: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1003, &mut x1004, x7, 0x28266895); + let mut x1005: u32 = 0; + let mut x1006: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1005, &mut x1006, x7, 0xd40d4917); + let mut x1007: u32 = 0; + let mut x1008: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1007, &mut x1008, x7, 0x4aab1cc5); + let mut x1009: u32 = 0; + let mut x1010: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1009, &mut x1010, x7, 0xbc3e483a); + let mut x1011: u32 = 0; + let mut x1012: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1011, &mut x1012, x7, 0xfcb82947); + let mut x1013: u32 = 0; + let mut x1014: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1013, &mut x1014, x7, 0xff3d81e5); + let mut x1015: u32 = 0; + let mut x1016: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1015, &mut x1016, x7, 0xdf1aa419); + let mut x1017: u32 = 0; + let mut x1018: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1017, &mut x1018, x7, 0x2d319b24); + let mut x1019: u32 = 0; + let mut x1020: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1019, &mut x1020, x7, 0x19b409a9); + let mut x1021: u32 = 0; + let mut x1022: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1021, &mut x1022, 0x0, x1020, x1017); + let mut x1023: u32 = 0; + let mut x1024: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1023, &mut x1024, x1022, x1018, x1015); + let mut x1025: u32 = 0; + let mut x1026: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1025, &mut x1026, x1024, x1016, x1013); + let mut x1027: u32 = 0; + let mut x1028: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1027, &mut x1028, x1026, x1014, x1011); + let mut x1029: u32 = 0; + let mut x1030: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1029, &mut x1030, x1028, x1012, x1009); + let mut x1031: u32 = 0; + let mut x1032: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1031, &mut x1032, x1030, x1010, x1007); + let mut x1033: u32 = 0; + let mut x1034: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1033, &mut x1034, x1032, x1008, x1005); + let mut x1035: u32 = 0; + let mut x1036: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1035, &mut x1036, x1034, x1006, x1003); + let mut x1037: u32 = 0; + let mut x1038: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1037, &mut x1038, x1036, x1004, x1001); + let mut x1039: u32 = 0; + let mut x1040: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1039, &mut x1040, x1038, x1002, x999); + let mut x1041: u32 = 0; + let mut x1042: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1041, &mut x1042, x1040, x1000, x997); + let mut x1043: u32 = 0; + let mut x1044: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1043, &mut x1044, 0x0, x973, x1019); + let mut x1045: u32 = 0; + let mut x1046: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1045, &mut x1046, x1044, x975, x1021); + let mut x1047: u32 = 0; + let mut x1048: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1047, &mut x1048, x1046, x977, x1023); + let mut x1049: u32 = 0; + let mut x1050: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1049, &mut x1050, x1048, x979, x1025); + let mut x1051: u32 = 0; + let mut x1052: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1051, &mut x1052, x1050, x981, x1027); + let mut x1053: u32 = 0; + let mut x1054: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1053, &mut x1054, x1052, x983, x1029); + let mut x1055: u32 = 0; + let mut x1056: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1055, &mut x1056, x1054, x985, x1031); + let mut x1057: u32 = 0; + let mut x1058: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1057, &mut x1058, x1056, x987, x1033); + let mut x1059: u32 = 0; + let mut x1060: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1059, &mut x1060, x1058, x989, x1035); + let mut x1061: u32 = 0; + let mut x1062: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1061, &mut x1062, x1060, x991, x1037); + let mut x1063: u32 = 0; + let mut x1064: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1063, &mut x1064, x1062, x993, x1039); + let mut x1065: u32 = 0; + let mut x1066: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1065, &mut x1066, x1064, x995, x1041); + let mut x1067: u32 = 0; + let mut x1068: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1067, &mut x1068, x1043, 0xe88fdc45); + let mut x1069: u32 = 0; + let mut x1070: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1069, &mut x1070, x1067, 0xffffffff); + let mut x1071: u32 = 0; + let mut x1072: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1071, &mut x1072, x1067, 0xffffffff); + let mut x1073: u32 = 0; + let mut x1074: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1073, &mut x1074, x1067, 0xffffffff); + let mut x1075: u32 = 0; + let mut x1076: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1075, &mut x1076, x1067, 0xffffffff); + let mut x1077: u32 = 0; + let mut x1078: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1077, &mut x1078, x1067, 0xffffffff); + let mut x1079: u32 = 0; + let mut x1080: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1079, &mut x1080, x1067, 0xffffffff); + let mut x1081: u32 = 0; + let mut x1082: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1081, &mut x1082, x1067, 0xc7634d81); + let mut x1083: u32 = 0; + let mut x1084: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1083, &mut x1084, x1067, 0xf4372ddf); + let mut x1085: u32 = 0; + let mut x1086: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1085, &mut x1086, x1067, 0x581a0db2); + let mut x1087: u32 = 0; + let mut x1088: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1087, &mut x1088, x1067, 0x48b0a77a); + let mut x1089: u32 = 0; + let mut x1090: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1089, &mut x1090, x1067, 0xecec196a); + let mut x1091: u32 = 0; + let mut x1092: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1091, &mut x1092, x1067, 0xccc52973); + let mut x1093: u32 = 0; + let mut x1094: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1093, &mut x1094, 0x0, x1092, x1089); + let mut x1095: u32 = 0; + let mut x1096: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1095, &mut x1096, x1094, x1090, x1087); + let mut x1097: u32 = 0; + let mut x1098: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1097, &mut x1098, x1096, x1088, x1085); + let mut x1099: u32 = 0; + let mut x1100: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1099, &mut x1100, x1098, x1086, x1083); + let mut x1101: u32 = 0; + let mut x1102: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1101, &mut x1102, x1100, x1084, x1081); + let mut x1103: u32 = 0; + let mut x1104: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1103, &mut x1104, x1102, x1082, x1079); + let mut x1105: u32 = 0; + let mut x1106: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1105, &mut x1106, x1104, x1080, x1077); + let mut x1107: u32 = 0; + let mut x1108: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1107, &mut x1108, x1106, x1078, x1075); + let mut x1109: u32 = 0; + let mut x1110: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1109, &mut x1110, x1108, x1076, x1073); + let mut x1111: u32 = 0; + let mut x1112: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1111, &mut x1112, x1110, x1074, x1071); + let mut x1113: u32 = 0; + let mut x1114: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1113, &mut x1114, x1112, x1072, x1069); + let mut x1115: u32 = 0; + let mut x1116: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1115, &mut x1116, 0x0, x1043, x1091); + let mut x1117: u32 = 0; + let mut x1118: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1117, &mut x1118, x1116, x1045, x1093); + let mut x1119: u32 = 0; + let mut x1120: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1119, &mut x1120, x1118, x1047, x1095); + let mut x1121: u32 = 0; + let mut x1122: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1121, &mut x1122, x1120, x1049, x1097); + let mut x1123: u32 = 0; + let mut x1124: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1123, &mut x1124, x1122, x1051, x1099); + let mut x1125: u32 = 0; + let mut x1126: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1125, &mut x1126, x1124, x1053, x1101); + let mut x1127: u32 = 0; + let mut x1128: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1127, &mut x1128, x1126, x1055, x1103); + let mut x1129: u32 = 0; + let mut x1130: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1129, &mut x1130, x1128, x1057, x1105); + let mut x1131: u32 = 0; + let mut x1132: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1131, &mut x1132, x1130, x1059, x1107); + let mut x1133: u32 = 0; + let mut x1134: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1133, &mut x1134, x1132, x1061, x1109); + let mut x1135: u32 = 0; + let mut x1136: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1135, &mut x1136, x1134, x1063, x1111); + let mut x1137: u32 = 0; + let mut x1138: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1137, &mut x1138, x1136, x1065, x1113); + let mut x1139: u32 = 0; + let mut x1140: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1139, &mut x1140, x1138, (((x1066 as u32) + (x996 as u32)) + ((x1042 as u32) + x998)), ((x1114 as u32) + x1070)); + let mut x1141: u32 = 0; + let mut x1142: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1141, &mut x1142, x8, 0xc84ee01); + let mut x1143: u32 = 0; + let mut x1144: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1143, &mut x1144, x8, 0x2b39bf21); + let mut x1145: u32 = 0; + let mut x1146: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1145, &mut x1146, x8, 0x3fb05b7a); + let mut x1147: u32 = 0; + let mut x1148: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1147, &mut x1148, x8, 0x28266895); + let mut x1149: u32 = 0; + let mut x1150: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1149, &mut x1150, x8, 0xd40d4917); + let mut x1151: u32 = 0; + let mut x1152: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1151, &mut x1152, x8, 0x4aab1cc5); + let mut x1153: u32 = 0; + let mut x1154: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1153, &mut x1154, x8, 0xbc3e483a); + let mut x1155: u32 = 0; + let mut x1156: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1155, &mut x1156, x8, 0xfcb82947); + let mut x1157: u32 = 0; + let mut x1158: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1157, &mut x1158, x8, 0xff3d81e5); + let mut x1159: u32 = 0; + let mut x1160: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1159, &mut x1160, x8, 0xdf1aa419); + let mut x1161: u32 = 0; + let mut x1162: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1161, &mut x1162, x8, 0x2d319b24); + let mut x1163: u32 = 0; + let mut x1164: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1163, &mut x1164, x8, 0x19b409a9); + let mut x1165: u32 = 0; + let mut x1166: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1165, &mut x1166, 0x0, x1164, x1161); + let mut x1167: u32 = 0; + let mut x1168: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1167, &mut x1168, x1166, x1162, x1159); + let mut x1169: u32 = 0; + let mut x1170: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1169, &mut x1170, x1168, x1160, x1157); + let mut x1171: u32 = 0; + let mut x1172: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1171, &mut x1172, x1170, x1158, x1155); + let mut x1173: u32 = 0; + let mut x1174: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1173, &mut x1174, x1172, x1156, x1153); + let mut x1175: u32 = 0; + let mut x1176: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1175, &mut x1176, x1174, x1154, x1151); + let mut x1177: u32 = 0; + let mut x1178: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1177, &mut x1178, x1176, x1152, x1149); + let mut x1179: u32 = 0; + let mut x1180: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1179, &mut x1180, x1178, x1150, x1147); + let mut x1181: u32 = 0; + let mut x1182: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1181, &mut x1182, x1180, x1148, x1145); + let mut x1183: u32 = 0; + let mut x1184: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1183, &mut x1184, x1182, x1146, x1143); + let mut x1185: u32 = 0; + let mut x1186: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1185, &mut x1186, x1184, x1144, x1141); + let mut x1187: u32 = 0; + let mut x1188: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1187, &mut x1188, 0x0, x1117, x1163); + let mut x1189: u32 = 0; + let mut x1190: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1189, &mut x1190, x1188, x1119, x1165); + let mut x1191: u32 = 0; + let mut x1192: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1191, &mut x1192, x1190, x1121, x1167); + let mut x1193: u32 = 0; + let mut x1194: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1193, &mut x1194, x1192, x1123, x1169); + let mut x1195: u32 = 0; + let mut x1196: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1195, &mut x1196, x1194, x1125, x1171); + let mut x1197: u32 = 0; + let mut x1198: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1197, &mut x1198, x1196, x1127, x1173); + let mut x1199: u32 = 0; + let mut x1200: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1199, &mut x1200, x1198, x1129, x1175); + let mut x1201: u32 = 0; + let mut x1202: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1201, &mut x1202, x1200, x1131, x1177); + let mut x1203: u32 = 0; + let mut x1204: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1203, &mut x1204, x1202, x1133, x1179); + let mut x1205: u32 = 0; + let mut x1206: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1205, &mut x1206, x1204, x1135, x1181); + let mut x1207: u32 = 0; + let mut x1208: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1207, &mut x1208, x1206, x1137, x1183); + let mut x1209: u32 = 0; + let mut x1210: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1209, &mut x1210, x1208, x1139, x1185); + let mut x1211: u32 = 0; + let mut x1212: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1211, &mut x1212, x1187, 0xe88fdc45); + let mut x1213: u32 = 0; + let mut x1214: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1213, &mut x1214, x1211, 0xffffffff); + let mut x1215: u32 = 0; + let mut x1216: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1215, &mut x1216, x1211, 0xffffffff); + let mut x1217: u32 = 0; + let mut x1218: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1217, &mut x1218, x1211, 0xffffffff); + let mut x1219: u32 = 0; + let mut x1220: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1219, &mut x1220, x1211, 0xffffffff); + let mut x1221: u32 = 0; + let mut x1222: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1221, &mut x1222, x1211, 0xffffffff); + let mut x1223: u32 = 0; + let mut x1224: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1223, &mut x1224, x1211, 0xffffffff); + let mut x1225: u32 = 0; + let mut x1226: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1225, &mut x1226, x1211, 0xc7634d81); + let mut x1227: u32 = 0; + let mut x1228: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1227, &mut x1228, x1211, 0xf4372ddf); + let mut x1229: u32 = 0; + let mut x1230: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1229, &mut x1230, x1211, 0x581a0db2); + let mut x1231: u32 = 0; + let mut x1232: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1231, &mut x1232, x1211, 0x48b0a77a); + let mut x1233: u32 = 0; + let mut x1234: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1233, &mut x1234, x1211, 0xecec196a); + let mut x1235: u32 = 0; + let mut x1236: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1235, &mut x1236, x1211, 0xccc52973); + let mut x1237: u32 = 0; + let mut x1238: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1237, &mut x1238, 0x0, x1236, x1233); + let mut x1239: u32 = 0; + let mut x1240: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1239, &mut x1240, x1238, x1234, x1231); + let mut x1241: u32 = 0; + let mut x1242: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1241, &mut x1242, x1240, x1232, x1229); + let mut x1243: u32 = 0; + let mut x1244: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1243, &mut x1244, x1242, x1230, x1227); + let mut x1245: u32 = 0; + let mut x1246: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1245, &mut x1246, x1244, x1228, x1225); + let mut x1247: u32 = 0; + let mut x1248: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1247, &mut x1248, x1246, x1226, x1223); + let mut x1249: u32 = 0; + let mut x1250: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1249, &mut x1250, x1248, x1224, x1221); + let mut x1251: u32 = 0; + let mut x1252: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1251, &mut x1252, x1250, x1222, x1219); + let mut x1253: u32 = 0; + let mut x1254: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1253, &mut x1254, x1252, x1220, x1217); + let mut x1255: u32 = 0; + let mut x1256: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1255, &mut x1256, x1254, x1218, x1215); + let mut x1257: u32 = 0; + let mut x1258: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1257, &mut x1258, x1256, x1216, x1213); + let mut x1259: u32 = 0; + let mut x1260: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1259, &mut x1260, 0x0, x1187, x1235); + let mut x1261: u32 = 0; + let mut x1262: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1261, &mut x1262, x1260, x1189, x1237); + let mut x1263: u32 = 0; + let mut x1264: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1263, &mut x1264, x1262, x1191, x1239); + let mut x1265: u32 = 0; + let mut x1266: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1265, &mut x1266, x1264, x1193, x1241); + let mut x1267: u32 = 0; + let mut x1268: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1267, &mut x1268, x1266, x1195, x1243); + let mut x1269: u32 = 0; + let mut x1270: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1269, &mut x1270, x1268, x1197, x1245); + let mut x1271: u32 = 0; + let mut x1272: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1271, &mut x1272, x1270, x1199, x1247); + let mut x1273: u32 = 0; + let mut x1274: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1273, &mut x1274, x1272, x1201, x1249); + let mut x1275: u32 = 0; + let mut x1276: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1275, &mut x1276, x1274, x1203, x1251); + let mut x1277: u32 = 0; + let mut x1278: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1277, &mut x1278, x1276, x1205, x1253); + let mut x1279: u32 = 0; + let mut x1280: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1279, &mut x1280, x1278, x1207, x1255); + let mut x1281: u32 = 0; + let mut x1282: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1281, &mut x1282, x1280, x1209, x1257); + let mut x1283: u32 = 0; + let mut x1284: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1283, &mut x1284, x1282, (((x1210 as u32) + (x1140 as u32)) + ((x1186 as u32) + x1142)), ((x1258 as u32) + x1214)); + let mut x1285: u32 = 0; + let mut x1286: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1285, &mut x1286, x9, 0xc84ee01); + let mut x1287: u32 = 0; + let mut x1288: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1287, &mut x1288, x9, 0x2b39bf21); + let mut x1289: u32 = 0; + let mut x1290: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1289, &mut x1290, x9, 0x3fb05b7a); + let mut x1291: u32 = 0; + let mut x1292: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1291, &mut x1292, x9, 0x28266895); + let mut x1293: u32 = 0; + let mut x1294: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1293, &mut x1294, x9, 0xd40d4917); + let mut x1295: u32 = 0; + let mut x1296: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1295, &mut x1296, x9, 0x4aab1cc5); + let mut x1297: u32 = 0; + let mut x1298: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1297, &mut x1298, x9, 0xbc3e483a); + let mut x1299: u32 = 0; + let mut x1300: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1299, &mut x1300, x9, 0xfcb82947); + let mut x1301: u32 = 0; + let mut x1302: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1301, &mut x1302, x9, 0xff3d81e5); + let mut x1303: u32 = 0; + let mut x1304: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1303, &mut x1304, x9, 0xdf1aa419); + let mut x1305: u32 = 0; + let mut x1306: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1305, &mut x1306, x9, 0x2d319b24); + let mut x1307: u32 = 0; + let mut x1308: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1307, &mut x1308, x9, 0x19b409a9); + let mut x1309: u32 = 0; + let mut x1310: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1309, &mut x1310, 0x0, x1308, x1305); + let mut x1311: u32 = 0; + let mut x1312: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1311, &mut x1312, x1310, x1306, x1303); + let mut x1313: u32 = 0; + let mut x1314: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1313, &mut x1314, x1312, x1304, x1301); + let mut x1315: u32 = 0; + let mut x1316: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1315, &mut x1316, x1314, x1302, x1299); + let mut x1317: u32 = 0; + let mut x1318: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1317, &mut x1318, x1316, x1300, x1297); + let mut x1319: u32 = 0; + let mut x1320: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1319, &mut x1320, x1318, x1298, x1295); + let mut x1321: u32 = 0; + let mut x1322: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1321, &mut x1322, x1320, x1296, x1293); + let mut x1323: u32 = 0; + let mut x1324: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1323, &mut x1324, x1322, x1294, x1291); + let mut x1325: u32 = 0; + let mut x1326: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1325, &mut x1326, x1324, x1292, x1289); + let mut x1327: u32 = 0; + let mut x1328: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1327, &mut x1328, x1326, x1290, x1287); + let mut x1329: u32 = 0; + let mut x1330: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1329, &mut x1330, x1328, x1288, x1285); + let mut x1331: u32 = 0; + let mut x1332: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1331, &mut x1332, 0x0, x1261, x1307); + let mut x1333: u32 = 0; + let mut x1334: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1333, &mut x1334, x1332, x1263, x1309); + let mut x1335: u32 = 0; + let mut x1336: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1335, &mut x1336, x1334, x1265, x1311); + let mut x1337: u32 = 0; + let mut x1338: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1337, &mut x1338, x1336, x1267, x1313); + let mut x1339: u32 = 0; + let mut x1340: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1339, &mut x1340, x1338, x1269, x1315); + let mut x1341: u32 = 0; + let mut x1342: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1341, &mut x1342, x1340, x1271, x1317); + let mut x1343: u32 = 0; + let mut x1344: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1343, &mut x1344, x1342, x1273, x1319); + let mut x1345: u32 = 0; + let mut x1346: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1345, &mut x1346, x1344, x1275, x1321); + let mut x1347: u32 = 0; + let mut x1348: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1347, &mut x1348, x1346, x1277, x1323); + let mut x1349: u32 = 0; + let mut x1350: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1349, &mut x1350, x1348, x1279, x1325); + let mut x1351: u32 = 0; + let mut x1352: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1351, &mut x1352, x1350, x1281, x1327); + let mut x1353: u32 = 0; + let mut x1354: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1353, &mut x1354, x1352, x1283, x1329); + let mut x1355: u32 = 0; + let mut x1356: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1355, &mut x1356, x1331, 0xe88fdc45); + let mut x1357: u32 = 0; + let mut x1358: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1357, &mut x1358, x1355, 0xffffffff); + let mut x1359: u32 = 0; + let mut x1360: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1359, &mut x1360, x1355, 0xffffffff); + let mut x1361: u32 = 0; + let mut x1362: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1361, &mut x1362, x1355, 0xffffffff); + let mut x1363: u32 = 0; + let mut x1364: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1363, &mut x1364, x1355, 0xffffffff); + let mut x1365: u32 = 0; + let mut x1366: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1365, &mut x1366, x1355, 0xffffffff); + let mut x1367: u32 = 0; + let mut x1368: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1367, &mut x1368, x1355, 0xffffffff); + let mut x1369: u32 = 0; + let mut x1370: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1369, &mut x1370, x1355, 0xc7634d81); + let mut x1371: u32 = 0; + let mut x1372: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1371, &mut x1372, x1355, 0xf4372ddf); + let mut x1373: u32 = 0; + let mut x1374: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1373, &mut x1374, x1355, 0x581a0db2); + let mut x1375: u32 = 0; + let mut x1376: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1375, &mut x1376, x1355, 0x48b0a77a); + let mut x1377: u32 = 0; + let mut x1378: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1377, &mut x1378, x1355, 0xecec196a); + let mut x1379: u32 = 0; + let mut x1380: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1379, &mut x1380, x1355, 0xccc52973); + let mut x1381: u32 = 0; + let mut x1382: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1381, &mut x1382, 0x0, x1380, x1377); + let mut x1383: u32 = 0; + let mut x1384: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1383, &mut x1384, x1382, x1378, x1375); + let mut x1385: u32 = 0; + let mut x1386: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1385, &mut x1386, x1384, x1376, x1373); + let mut x1387: u32 = 0; + let mut x1388: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1387, &mut x1388, x1386, x1374, x1371); + let mut x1389: u32 = 0; + let mut x1390: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1389, &mut x1390, x1388, x1372, x1369); + let mut x1391: u32 = 0; + let mut x1392: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1391, &mut x1392, x1390, x1370, x1367); + let mut x1393: u32 = 0; + let mut x1394: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1393, &mut x1394, x1392, x1368, x1365); + let mut x1395: u32 = 0; + let mut x1396: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1395, &mut x1396, x1394, x1366, x1363); + let mut x1397: u32 = 0; + let mut x1398: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1397, &mut x1398, x1396, x1364, x1361); + let mut x1399: u32 = 0; + let mut x1400: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1399, &mut x1400, x1398, x1362, x1359); + let mut x1401: u32 = 0; + let mut x1402: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1401, &mut x1402, x1400, x1360, x1357); + let mut x1403: u32 = 0; + let mut x1404: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1403, &mut x1404, 0x0, x1331, x1379); + let mut x1405: u32 = 0; + let mut x1406: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1405, &mut x1406, x1404, x1333, x1381); + let mut x1407: u32 = 0; + let mut x1408: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1407, &mut x1408, x1406, x1335, x1383); + let mut x1409: u32 = 0; + let mut x1410: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1409, &mut x1410, x1408, x1337, x1385); + let mut x1411: u32 = 0; + let mut x1412: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1411, &mut x1412, x1410, x1339, x1387); + let mut x1413: u32 = 0; + let mut x1414: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1413, &mut x1414, x1412, x1341, x1389); + let mut x1415: u32 = 0; + let mut x1416: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1415, &mut x1416, x1414, x1343, x1391); + let mut x1417: u32 = 0; + let mut x1418: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1417, &mut x1418, x1416, x1345, x1393); + let mut x1419: u32 = 0; + let mut x1420: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1419, &mut x1420, x1418, x1347, x1395); + let mut x1421: u32 = 0; + let mut x1422: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1421, &mut x1422, x1420, x1349, x1397); + let mut x1423: u32 = 0; + let mut x1424: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1423, &mut x1424, x1422, x1351, x1399); + let mut x1425: u32 = 0; + let mut x1426: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1425, &mut x1426, x1424, x1353, x1401); + let mut x1427: u32 = 0; + let mut x1428: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1427, &mut x1428, x1426, (((x1354 as u32) + (x1284 as u32)) + ((x1330 as u32) + x1286)), ((x1402 as u32) + x1358)); + let mut x1429: u32 = 0; + let mut x1430: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1429, &mut x1430, x10, 0xc84ee01); + let mut x1431: u32 = 0; + let mut x1432: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1431, &mut x1432, x10, 0x2b39bf21); + let mut x1433: u32 = 0; + let mut x1434: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1433, &mut x1434, x10, 0x3fb05b7a); + let mut x1435: u32 = 0; + let mut x1436: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1435, &mut x1436, x10, 0x28266895); + let mut x1437: u32 = 0; + let mut x1438: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1437, &mut x1438, x10, 0xd40d4917); + let mut x1439: u32 = 0; + let mut x1440: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1439, &mut x1440, x10, 0x4aab1cc5); + let mut x1441: u32 = 0; + let mut x1442: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1441, &mut x1442, x10, 0xbc3e483a); + let mut x1443: u32 = 0; + let mut x1444: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1443, &mut x1444, x10, 0xfcb82947); + let mut x1445: u32 = 0; + let mut x1446: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1445, &mut x1446, x10, 0xff3d81e5); + let mut x1447: u32 = 0; + let mut x1448: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1447, &mut x1448, x10, 0xdf1aa419); + let mut x1449: u32 = 0; + let mut x1450: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1449, &mut x1450, x10, 0x2d319b24); + let mut x1451: u32 = 0; + let mut x1452: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1451, &mut x1452, x10, 0x19b409a9); + let mut x1453: u32 = 0; + let mut x1454: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1453, &mut x1454, 0x0, x1452, x1449); + let mut x1455: u32 = 0; + let mut x1456: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1455, &mut x1456, x1454, x1450, x1447); + let mut x1457: u32 = 0; + let mut x1458: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1457, &mut x1458, x1456, x1448, x1445); + let mut x1459: u32 = 0; + let mut x1460: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1459, &mut x1460, x1458, x1446, x1443); + let mut x1461: u32 = 0; + let mut x1462: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1461, &mut x1462, x1460, x1444, x1441); + let mut x1463: u32 = 0; + let mut x1464: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1463, &mut x1464, x1462, x1442, x1439); + let mut x1465: u32 = 0; + let mut x1466: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1465, &mut x1466, x1464, x1440, x1437); + let mut x1467: u32 = 0; + let mut x1468: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1467, &mut x1468, x1466, x1438, x1435); + let mut x1469: u32 = 0; + let mut x1470: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1469, &mut x1470, x1468, x1436, x1433); + let mut x1471: u32 = 0; + let mut x1472: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1471, &mut x1472, x1470, x1434, x1431); + let mut x1473: u32 = 0; + let mut x1474: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1473, &mut x1474, x1472, x1432, x1429); + let mut x1475: u32 = 0; + let mut x1476: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1475, &mut x1476, 0x0, x1405, x1451); + let mut x1477: u32 = 0; + let mut x1478: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1477, &mut x1478, x1476, x1407, x1453); + let mut x1479: u32 = 0; + let mut x1480: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1479, &mut x1480, x1478, x1409, x1455); + let mut x1481: u32 = 0; + let mut x1482: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1481, &mut x1482, x1480, x1411, x1457); + let mut x1483: u32 = 0; + let mut x1484: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1483, &mut x1484, x1482, x1413, x1459); + let mut x1485: u32 = 0; + let mut x1486: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1485, &mut x1486, x1484, x1415, x1461); + let mut x1487: u32 = 0; + let mut x1488: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1487, &mut x1488, x1486, x1417, x1463); + let mut x1489: u32 = 0; + let mut x1490: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1489, &mut x1490, x1488, x1419, x1465); + let mut x1491: u32 = 0; + let mut x1492: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1491, &mut x1492, x1490, x1421, x1467); + let mut x1493: u32 = 0; + let mut x1494: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1493, &mut x1494, x1492, x1423, x1469); + let mut x1495: u32 = 0; + let mut x1496: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1495, &mut x1496, x1494, x1425, x1471); + let mut x1497: u32 = 0; + let mut x1498: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1497, &mut x1498, x1496, x1427, x1473); + let mut x1499: u32 = 0; + let mut x1500: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1499, &mut x1500, x1475, 0xe88fdc45); + let mut x1501: u32 = 0; + let mut x1502: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1501, &mut x1502, x1499, 0xffffffff); + let mut x1503: u32 = 0; + let mut x1504: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1503, &mut x1504, x1499, 0xffffffff); + let mut x1505: u32 = 0; + let mut x1506: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1505, &mut x1506, x1499, 0xffffffff); + let mut x1507: u32 = 0; + let mut x1508: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1507, &mut x1508, x1499, 0xffffffff); + let mut x1509: u32 = 0; + let mut x1510: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1509, &mut x1510, x1499, 0xffffffff); + let mut x1511: u32 = 0; + let mut x1512: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1511, &mut x1512, x1499, 0xffffffff); + let mut x1513: u32 = 0; + let mut x1514: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1513, &mut x1514, x1499, 0xc7634d81); + let mut x1515: u32 = 0; + let mut x1516: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1515, &mut x1516, x1499, 0xf4372ddf); + let mut x1517: u32 = 0; + let mut x1518: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1517, &mut x1518, x1499, 0x581a0db2); + let mut x1519: u32 = 0; + let mut x1520: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1519, &mut x1520, x1499, 0x48b0a77a); + let mut x1521: u32 = 0; + let mut x1522: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1521, &mut x1522, x1499, 0xecec196a); + let mut x1523: u32 = 0; + let mut x1524: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1523, &mut x1524, x1499, 0xccc52973); + let mut x1525: u32 = 0; + let mut x1526: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1525, &mut x1526, 0x0, x1524, x1521); + let mut x1527: u32 = 0; + let mut x1528: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1527, &mut x1528, x1526, x1522, x1519); + let mut x1529: u32 = 0; + let mut x1530: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1529, &mut x1530, x1528, x1520, x1517); + let mut x1531: u32 = 0; + let mut x1532: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1531, &mut x1532, x1530, x1518, x1515); + let mut x1533: u32 = 0; + let mut x1534: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1533, &mut x1534, x1532, x1516, x1513); + let mut x1535: u32 = 0; + let mut x1536: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1535, &mut x1536, x1534, x1514, x1511); + let mut x1537: u32 = 0; + let mut x1538: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1537, &mut x1538, x1536, x1512, x1509); + let mut x1539: u32 = 0; + let mut x1540: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1539, &mut x1540, x1538, x1510, x1507); + let mut x1541: u32 = 0; + let mut x1542: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1541, &mut x1542, x1540, x1508, x1505); + let mut x1543: u32 = 0; + let mut x1544: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1543, &mut x1544, x1542, x1506, x1503); + let mut x1545: u32 = 0; + let mut x1546: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1545, &mut x1546, x1544, x1504, x1501); + let mut x1547: u32 = 0; + let mut x1548: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1547, &mut x1548, 0x0, x1475, x1523); + let mut x1549: u32 = 0; + let mut x1550: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1549, &mut x1550, x1548, x1477, x1525); + let mut x1551: u32 = 0; + let mut x1552: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1551, &mut x1552, x1550, x1479, x1527); + let mut x1553: u32 = 0; + let mut x1554: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1553, &mut x1554, x1552, x1481, x1529); + let mut x1555: u32 = 0; + let mut x1556: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1555, &mut x1556, x1554, x1483, x1531); + let mut x1557: u32 = 0; + let mut x1558: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1557, &mut x1558, x1556, x1485, x1533); + let mut x1559: u32 = 0; + let mut x1560: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1559, &mut x1560, x1558, x1487, x1535); + let mut x1561: u32 = 0; + let mut x1562: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1561, &mut x1562, x1560, x1489, x1537); + let mut x1563: u32 = 0; + let mut x1564: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1563, &mut x1564, x1562, x1491, x1539); + let mut x1565: u32 = 0; + let mut x1566: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1565, &mut x1566, x1564, x1493, x1541); + let mut x1567: u32 = 0; + let mut x1568: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1567, &mut x1568, x1566, x1495, x1543); + let mut x1569: u32 = 0; + let mut x1570: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1569, &mut x1570, x1568, x1497, x1545); + let mut x1571: u32 = 0; + let mut x1572: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1571, &mut x1572, x1570, (((x1498 as u32) + (x1428 as u32)) + ((x1474 as u32) + x1430)), ((x1546 as u32) + x1502)); + let mut x1573: u32 = 0; + let mut x1574: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1573, &mut x1574, x11, 0xc84ee01); + let mut x1575: u32 = 0; + let mut x1576: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1575, &mut x1576, x11, 0x2b39bf21); + let mut x1577: u32 = 0; + let mut x1578: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1577, &mut x1578, x11, 0x3fb05b7a); + let mut x1579: u32 = 0; + let mut x1580: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1579, &mut x1580, x11, 0x28266895); + let mut x1581: u32 = 0; + let mut x1582: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1581, &mut x1582, x11, 0xd40d4917); + let mut x1583: u32 = 0; + let mut x1584: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1583, &mut x1584, x11, 0x4aab1cc5); + let mut x1585: u32 = 0; + let mut x1586: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1585, &mut x1586, x11, 0xbc3e483a); + let mut x1587: u32 = 0; + let mut x1588: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1587, &mut x1588, x11, 0xfcb82947); + let mut x1589: u32 = 0; + let mut x1590: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1589, &mut x1590, x11, 0xff3d81e5); + let mut x1591: u32 = 0; + let mut x1592: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1591, &mut x1592, x11, 0xdf1aa419); + let mut x1593: u32 = 0; + let mut x1594: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1593, &mut x1594, x11, 0x2d319b24); + let mut x1595: u32 = 0; + let mut x1596: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1595, &mut x1596, x11, 0x19b409a9); + let mut x1597: u32 = 0; + let mut x1598: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1597, &mut x1598, 0x0, x1596, x1593); + let mut x1599: u32 = 0; + let mut x1600: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1599, &mut x1600, x1598, x1594, x1591); + let mut x1601: u32 = 0; + let mut x1602: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1601, &mut x1602, x1600, x1592, x1589); + let mut x1603: u32 = 0; + let mut x1604: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1603, &mut x1604, x1602, x1590, x1587); + let mut x1605: u32 = 0; + let mut x1606: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1605, &mut x1606, x1604, x1588, x1585); + let mut x1607: u32 = 0; + let mut x1608: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1607, &mut x1608, x1606, x1586, x1583); + let mut x1609: u32 = 0; + let mut x1610: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1609, &mut x1610, x1608, x1584, x1581); + let mut x1611: u32 = 0; + let mut x1612: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1611, &mut x1612, x1610, x1582, x1579); + let mut x1613: u32 = 0; + let mut x1614: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1613, &mut x1614, x1612, x1580, x1577); + let mut x1615: u32 = 0; + let mut x1616: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1615, &mut x1616, x1614, x1578, x1575); + let mut x1617: u32 = 0; + let mut x1618: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1617, &mut x1618, x1616, x1576, x1573); + let mut x1619: u32 = 0; + let mut x1620: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1619, &mut x1620, 0x0, x1549, x1595); + let mut x1621: u32 = 0; + let mut x1622: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1621, &mut x1622, x1620, x1551, x1597); + let mut x1623: u32 = 0; + let mut x1624: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1623, &mut x1624, x1622, x1553, x1599); + let mut x1625: u32 = 0; + let mut x1626: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1625, &mut x1626, x1624, x1555, x1601); + let mut x1627: u32 = 0; + let mut x1628: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1627, &mut x1628, x1626, x1557, x1603); + let mut x1629: u32 = 0; + let mut x1630: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1629, &mut x1630, x1628, x1559, x1605); + let mut x1631: u32 = 0; + let mut x1632: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1631, &mut x1632, x1630, x1561, x1607); + let mut x1633: u32 = 0; + let mut x1634: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1633, &mut x1634, x1632, x1563, x1609); + let mut x1635: u32 = 0; + let mut x1636: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1635, &mut x1636, x1634, x1565, x1611); + let mut x1637: u32 = 0; + let mut x1638: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1637, &mut x1638, x1636, x1567, x1613); + let mut x1639: u32 = 0; + let mut x1640: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1639, &mut x1640, x1638, x1569, x1615); + let mut x1641: u32 = 0; + let mut x1642: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1641, &mut x1642, x1640, x1571, x1617); + let mut x1643: u32 = 0; + let mut x1644: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1643, &mut x1644, x1619, 0xe88fdc45); + let mut x1645: u32 = 0; + let mut x1646: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1645, &mut x1646, x1643, 0xffffffff); + let mut x1647: u32 = 0; + let mut x1648: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1647, &mut x1648, x1643, 0xffffffff); + let mut x1649: u32 = 0; + let mut x1650: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1649, &mut x1650, x1643, 0xffffffff); + let mut x1651: u32 = 0; + let mut x1652: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1651, &mut x1652, x1643, 0xffffffff); + let mut x1653: u32 = 0; + let mut x1654: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1653, &mut x1654, x1643, 0xffffffff); + let mut x1655: u32 = 0; + let mut x1656: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1655, &mut x1656, x1643, 0xffffffff); + let mut x1657: u32 = 0; + let mut x1658: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1657, &mut x1658, x1643, 0xc7634d81); + let mut x1659: u32 = 0; + let mut x1660: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1659, &mut x1660, x1643, 0xf4372ddf); + let mut x1661: u32 = 0; + let mut x1662: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1661, &mut x1662, x1643, 0x581a0db2); + let mut x1663: u32 = 0; + let mut x1664: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1663, &mut x1664, x1643, 0x48b0a77a); + let mut x1665: u32 = 0; + let mut x1666: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1665, &mut x1666, x1643, 0xecec196a); + let mut x1667: u32 = 0; + let mut x1668: u32 = 0; + fiat_p384_scalar_mulx_u32(&mut x1667, &mut x1668, x1643, 0xccc52973); + let mut x1669: u32 = 0; + let mut x1670: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1669, &mut x1670, 0x0, x1668, x1665); + let mut x1671: u32 = 0; + let mut x1672: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1671, &mut x1672, x1670, x1666, x1663); + let mut x1673: u32 = 0; + let mut x1674: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1673, &mut x1674, x1672, x1664, x1661); + let mut x1675: u32 = 0; + let mut x1676: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1675, &mut x1676, x1674, x1662, x1659); + let mut x1677: u32 = 0; + let mut x1678: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1677, &mut x1678, x1676, x1660, x1657); + let mut x1679: u32 = 0; + let mut x1680: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1679, &mut x1680, x1678, x1658, x1655); + let mut x1681: u32 = 0; + let mut x1682: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1681, &mut x1682, x1680, x1656, x1653); + let mut x1683: u32 = 0; + let mut x1684: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1683, &mut x1684, x1682, x1654, x1651); + let mut x1685: u32 = 0; + let mut x1686: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1685, &mut x1686, x1684, x1652, x1649); + let mut x1687: u32 = 0; + let mut x1688: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1687, &mut x1688, x1686, x1650, x1647); + let mut x1689: u32 = 0; + let mut x1690: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1689, &mut x1690, x1688, x1648, x1645); + let mut x1691: u32 = 0; + let mut x1692: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1691, &mut x1692, 0x0, x1619, x1667); + let mut x1693: u32 = 0; + let mut x1694: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1693, &mut x1694, x1692, x1621, x1669); + let mut x1695: u32 = 0; + let mut x1696: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1695, &mut x1696, x1694, x1623, x1671); + let mut x1697: u32 = 0; + let mut x1698: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1697, &mut x1698, x1696, x1625, x1673); + let mut x1699: u32 = 0; + let mut x1700: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1699, &mut x1700, x1698, x1627, x1675); + let mut x1701: u32 = 0; + let mut x1702: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1701, &mut x1702, x1700, x1629, x1677); + let mut x1703: u32 = 0; + let mut x1704: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1703, &mut x1704, x1702, x1631, x1679); + let mut x1705: u32 = 0; + let mut x1706: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1705, &mut x1706, x1704, x1633, x1681); + let mut x1707: u32 = 0; + let mut x1708: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1707, &mut x1708, x1706, x1635, x1683); + let mut x1709: u32 = 0; + let mut x1710: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1709, &mut x1710, x1708, x1637, x1685); + let mut x1711: u32 = 0; + let mut x1712: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1711, &mut x1712, x1710, x1639, x1687); + let mut x1713: u32 = 0; + let mut x1714: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1713, &mut x1714, x1712, x1641, x1689); + let mut x1715: u32 = 0; + let mut x1716: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1715, &mut x1716, x1714, (((x1642 as u32) + (x1572 as u32)) + ((x1618 as u32) + x1574)), ((x1690 as u32) + x1646)); + let mut x1717: u32 = 0; + let mut x1718: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1717, &mut x1718, 0x0, x1693, 0xccc52973); + let mut x1719: u32 = 0; + let mut x1720: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1719, &mut x1720, x1718, x1695, 0xecec196a); + let mut x1721: u32 = 0; + let mut x1722: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1721, &mut x1722, x1720, x1697, 0x48b0a77a); + let mut x1723: u32 = 0; + let mut x1724: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1723, &mut x1724, x1722, x1699, 0x581a0db2); + let mut x1725: u32 = 0; + let mut x1726: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1725, &mut x1726, x1724, x1701, 0xf4372ddf); + let mut x1727: u32 = 0; + let mut x1728: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1727, &mut x1728, x1726, x1703, 0xc7634d81); + let mut x1729: u32 = 0; + let mut x1730: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1729, &mut x1730, x1728, x1705, 0xffffffff); + let mut x1731: u32 = 0; + let mut x1732: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1731, &mut x1732, x1730, x1707, 0xffffffff); + let mut x1733: u32 = 0; + let mut x1734: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1733, &mut x1734, x1732, x1709, 0xffffffff); + let mut x1735: u32 = 0; + let mut x1736: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1735, &mut x1736, x1734, x1711, 0xffffffff); + let mut x1737: u32 = 0; + let mut x1738: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1737, &mut x1738, x1736, x1713, 0xffffffff); + let mut x1739: u32 = 0; + let mut x1740: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1739, &mut x1740, x1738, x1715, 0xffffffff); + let mut x1741: u32 = 0; + let mut x1742: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x1741, &mut x1742, x1740, (x1716 as u32), (0x0 as u32)); + let mut x1743: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1743, x1742, x1717, x1693); + let mut x1744: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1744, x1742, x1719, x1695); + let mut x1745: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1745, x1742, x1721, x1697); + let mut x1746: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1746, x1742, x1723, x1699); + let mut x1747: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1747, x1742, x1725, x1701); + let mut x1748: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1748, x1742, x1727, x1703); + let mut x1749: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1749, x1742, x1729, x1705); + let mut x1750: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1750, x1742, x1731, x1707); + let mut x1751: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1751, x1742, x1733, x1709); + let mut x1752: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1752, x1742, x1735, x1711); + let mut x1753: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1753, x1742, x1737, x1713); + let mut x1754: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1754, x1742, x1739, x1715); + out1[0] = x1743; + out1[1] = x1744; + out1[2] = x1745; + out1[3] = x1746; + out1[4] = x1747; + out1[5] = x1748; + out1[6] = x1749; + out1[7] = x1750; + out1[8] = x1751; + out1[9] = x1752; + out1[10] = x1753; + out1[11] = x1754; +} + +/// The function fiat_p384_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +#[inline] +pub fn fiat_p384_scalar_nonzero(out1: &mut u32, arg1: &[u32; 12]) -> () { + let x1: u32 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | ((arg1[7]) | ((arg1[8]) | ((arg1[9]) | ((arg1[10]) | (arg1[11])))))))))))); + *out1 = x1; +} + +/// The function fiat_p384_scalar_selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_p384_scalar_selectznz(out1: &mut [u32; 12], arg1: fiat_p384_scalar_u1, arg2: &[u32; 12], arg3: &[u32; 12]) -> () { + let mut x1: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x1, arg1, (arg2[0]), (arg3[0])); + let mut x2: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x2, arg1, (arg2[1]), (arg3[1])); + let mut x3: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x3, arg1, (arg2[2]), (arg3[2])); + let mut x4: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x4, arg1, (arg2[3]), (arg3[3])); + let mut x5: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x5, arg1, (arg2[4]), (arg3[4])); + let mut x6: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x6, arg1, (arg2[5]), (arg3[5])); + let mut x7: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x7, arg1, (arg2[6]), (arg3[6])); + let mut x8: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x8, arg1, (arg2[7]), (arg3[7])); + let mut x9: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x9, arg1, (arg2[8]), (arg3[8])); + let mut x10: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x10, arg1, (arg2[9]), (arg3[9])); + let mut x11: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x11, arg1, (arg2[10]), (arg3[10])); + let mut x12: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x12, arg1, (arg2[11]), (arg3[11])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; + out1[6] = x7; + out1[7] = x8; + out1[8] = x9; + out1[9] = x10; + out1[10] = x11; + out1[11] = x12; +} + +/// The function fiat_p384_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +#[inline] +pub fn fiat_p384_scalar_to_bytes(out1: &mut [u8; 48], arg1: &[u32; 12]) -> () { + let x1: u32 = (arg1[11]); + let x2: u32 = (arg1[10]); + let x3: u32 = (arg1[9]); + let x4: u32 = (arg1[8]); + let x5: u32 = (arg1[7]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[5]); + let x8: u32 = (arg1[4]); + let x9: u32 = (arg1[3]); + let x10: u32 = (arg1[2]); + let x11: u32 = (arg1[1]); + let x12: u32 = (arg1[0]); + let x13: u8 = ((x12 & (0xff as u32)) as u8); + let x14: u32 = (x12 >> 8); + let x15: u8 = ((x14 & (0xff as u32)) as u8); + let x16: u32 = (x14 >> 8); + let x17: u8 = ((x16 & (0xff as u32)) as u8); + let x18: u8 = ((x16 >> 8) as u8); + let x19: u8 = ((x11 & (0xff as u32)) as u8); + let x20: u32 = (x11 >> 8); + let x21: u8 = ((x20 & (0xff as u32)) as u8); + let x22: u32 = (x20 >> 8); + let x23: u8 = ((x22 & (0xff as u32)) as u8); + let x24: u8 = ((x22 >> 8) as u8); + let x25: u8 = ((x10 & (0xff as u32)) as u8); + let x26: u32 = (x10 >> 8); + let x27: u8 = ((x26 & (0xff as u32)) as u8); + let x28: u32 = (x26 >> 8); + let x29: u8 = ((x28 & (0xff as u32)) as u8); + let x30: u8 = ((x28 >> 8) as u8); + let x31: u8 = ((x9 & (0xff as u32)) as u8); + let x32: u32 = (x9 >> 8); + let x33: u8 = ((x32 & (0xff as u32)) as u8); + let x34: u32 = (x32 >> 8); + let x35: u8 = ((x34 & (0xff as u32)) as u8); + let x36: u8 = ((x34 >> 8) as u8); + let x37: u8 = ((x8 & (0xff as u32)) as u8); + let x38: u32 = (x8 >> 8); + let x39: u8 = ((x38 & (0xff as u32)) as u8); + let x40: u32 = (x38 >> 8); + let x41: u8 = ((x40 & (0xff as u32)) as u8); + let x42: u8 = ((x40 >> 8) as u8); + let x43: u8 = ((x7 & (0xff as u32)) as u8); + let x44: u32 = (x7 >> 8); + let x45: u8 = ((x44 & (0xff as u32)) as u8); + let x46: u32 = (x44 >> 8); + let x47: u8 = ((x46 & (0xff as u32)) as u8); + let x48: u8 = ((x46 >> 8) as u8); + let x49: u8 = ((x6 & (0xff as u32)) as u8); + let x50: u32 = (x6 >> 8); + let x51: u8 = ((x50 & (0xff as u32)) as u8); + let x52: u32 = (x50 >> 8); + let x53: u8 = ((x52 & (0xff as u32)) as u8); + let x54: u8 = ((x52 >> 8) as u8); + let x55: u8 = ((x5 & (0xff as u32)) as u8); + let x56: u32 = (x5 >> 8); + let x57: u8 = ((x56 & (0xff as u32)) as u8); + let x58: u32 = (x56 >> 8); + let x59: u8 = ((x58 & (0xff as u32)) as u8); + let x60: u8 = ((x58 >> 8) as u8); + let x61: u8 = ((x4 & (0xff as u32)) as u8); + let x62: u32 = (x4 >> 8); + let x63: u8 = ((x62 & (0xff as u32)) as u8); + let x64: u32 = (x62 >> 8); + let x65: u8 = ((x64 & (0xff as u32)) as u8); + let x66: u8 = ((x64 >> 8) as u8); + let x67: u8 = ((x3 & (0xff as u32)) as u8); + let x68: u32 = (x3 >> 8); + let x69: u8 = ((x68 & (0xff as u32)) as u8); + let x70: u32 = (x68 >> 8); + let x71: u8 = ((x70 & (0xff as u32)) as u8); + let x72: u8 = ((x70 >> 8) as u8); + let x73: u8 = ((x2 & (0xff as u32)) as u8); + let x74: u32 = (x2 >> 8); + let x75: u8 = ((x74 & (0xff as u32)) as u8); + let x76: u32 = (x74 >> 8); + let x77: u8 = ((x76 & (0xff as u32)) as u8); + let x78: u8 = ((x76 >> 8) as u8); + let x79: u8 = ((x1 & (0xff as u32)) as u8); + let x80: u32 = (x1 >> 8); + let x81: u8 = ((x80 & (0xff as u32)) as u8); + let x82: u32 = (x80 >> 8); + let x83: u8 = ((x82 & (0xff as u32)) as u8); + let x84: u8 = ((x82 >> 8) as u8); + out1[0] = x13; + out1[1] = x15; + out1[2] = x17; + out1[3] = x18; + out1[4] = x19; + out1[5] = x21; + out1[6] = x23; + out1[7] = x24; + out1[8] = x25; + out1[9] = x27; + out1[10] = x29; + out1[11] = x30; + out1[12] = x31; + out1[13] = x33; + out1[14] = x35; + out1[15] = x36; + out1[16] = x37; + out1[17] = x39; + out1[18] = x41; + out1[19] = x42; + out1[20] = x43; + out1[21] = x45; + out1[22] = x47; + out1[23] = x48; + out1[24] = x49; + out1[25] = x51; + out1[26] = x53; + out1[27] = x54; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; + out1[32] = x61; + out1[33] = x63; + out1[34] = x65; + out1[35] = x66; + out1[36] = x67; + out1[37] = x69; + out1[38] = x71; + out1[39] = x72; + out1[40] = x73; + out1[41] = x75; + out1[42] = x77; + out1[43] = x78; + out1[44] = x79; + out1[45] = x81; + out1[46] = x83; + out1[47] = x84; +} + +/// The function fiat_p384_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_p384_scalar_from_bytes(out1: &mut [u32; 12], arg1: &[u8; 48]) -> () { + let x1: u32 = (((arg1[47]) as u32) << 24); + let x2: u32 = (((arg1[46]) as u32) << 16); + let x3: u32 = (((arg1[45]) as u32) << 8); + let x4: u8 = (arg1[44]); + let x5: u32 = (((arg1[43]) as u32) << 24); + let x6: u32 = (((arg1[42]) as u32) << 16); + let x7: u32 = (((arg1[41]) as u32) << 8); + let x8: u8 = (arg1[40]); + let x9: u32 = (((arg1[39]) as u32) << 24); + let x10: u32 = (((arg1[38]) as u32) << 16); + let x11: u32 = (((arg1[37]) as u32) << 8); + let x12: u8 = (arg1[36]); + let x13: u32 = (((arg1[35]) as u32) << 24); + let x14: u32 = (((arg1[34]) as u32) << 16); + let x15: u32 = (((arg1[33]) as u32) << 8); + let x16: u8 = (arg1[32]); + let x17: u32 = (((arg1[31]) as u32) << 24); + let x18: u32 = (((arg1[30]) as u32) << 16); + let x19: u32 = (((arg1[29]) as u32) << 8); + let x20: u8 = (arg1[28]); + let x21: u32 = (((arg1[27]) as u32) << 24); + let x22: u32 = (((arg1[26]) as u32) << 16); + let x23: u32 = (((arg1[25]) as u32) << 8); + let x24: u8 = (arg1[24]); + let x25: u32 = (((arg1[23]) as u32) << 24); + let x26: u32 = (((arg1[22]) as u32) << 16); + let x27: u32 = (((arg1[21]) as u32) << 8); + let x28: u8 = (arg1[20]); + let x29: u32 = (((arg1[19]) as u32) << 24); + let x30: u32 = (((arg1[18]) as u32) << 16); + let x31: u32 = (((arg1[17]) as u32) << 8); + let x32: u8 = (arg1[16]); + let x33: u32 = (((arg1[15]) as u32) << 24); + let x34: u32 = (((arg1[14]) as u32) << 16); + let x35: u32 = (((arg1[13]) as u32) << 8); + let x36: u8 = (arg1[12]); + let x37: u32 = (((arg1[11]) as u32) << 24); + let x38: u32 = (((arg1[10]) as u32) << 16); + let x39: u32 = (((arg1[9]) as u32) << 8); + let x40: u8 = (arg1[8]); + let x41: u32 = (((arg1[7]) as u32) << 24); + let x42: u32 = (((arg1[6]) as u32) << 16); + let x43: u32 = (((arg1[5]) as u32) << 8); + let x44: u8 = (arg1[4]); + let x45: u32 = (((arg1[3]) as u32) << 24); + let x46: u32 = (((arg1[2]) as u32) << 16); + let x47: u32 = (((arg1[1]) as u32) << 8); + let x48: u8 = (arg1[0]); + let x49: u32 = (x47 + (x48 as u32)); + let x50: u32 = (x46 + x49); + let x51: u32 = (x45 + x50); + let x52: u32 = (x43 + (x44 as u32)); + let x53: u32 = (x42 + x52); + let x54: u32 = (x41 + x53); + let x55: u32 = (x39 + (x40 as u32)); + let x56: u32 = (x38 + x55); + let x57: u32 = (x37 + x56); + let x58: u32 = (x35 + (x36 as u32)); + let x59: u32 = (x34 + x58); + let x60: u32 = (x33 + x59); + let x61: u32 = (x31 + (x32 as u32)); + let x62: u32 = (x30 + x61); + let x63: u32 = (x29 + x62); + let x64: u32 = (x27 + (x28 as u32)); + let x65: u32 = (x26 + x64); + let x66: u32 = (x25 + x65); + let x67: u32 = (x23 + (x24 as u32)); + let x68: u32 = (x22 + x67); + let x69: u32 = (x21 + x68); + let x70: u32 = (x19 + (x20 as u32)); + let x71: u32 = (x18 + x70); + let x72: u32 = (x17 + x71); + let x73: u32 = (x15 + (x16 as u32)); + let x74: u32 = (x14 + x73); + let x75: u32 = (x13 + x74); + let x76: u32 = (x11 + (x12 as u32)); + let x77: u32 = (x10 + x76); + let x78: u32 = (x9 + x77); + let x79: u32 = (x7 + (x8 as u32)); + let x80: u32 = (x6 + x79); + let x81: u32 = (x5 + x80); + let x82: u32 = (x3 + (x4 as u32)); + let x83: u32 = (x2 + x82); + let x84: u32 = (x1 + x83); + out1[0] = x51; + out1[1] = x54; + out1[2] = x57; + out1[3] = x60; + out1[4] = x63; + out1[5] = x66; + out1[6] = x69; + out1[7] = x72; + out1[8] = x75; + out1[9] = x78; + out1[10] = x81; + out1[11] = x84; +} + +/// The function fiat_p384_scalar_set_one returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_set_one(out1: &mut fiat_p384_scalar_montgomery_domain_field_element) -> () { + out1[0] = 0x333ad68d; + out1[1] = 0x1313e695; + out1[2] = 0xb74f5885; + out1[3] = 0xa7e5f24d; + out1[4] = 0xbc8d220; + out1[5] = 0x389cb27e; + out1[6] = (0x0 as u32); + out1[7] = (0x0 as u32); + out1[8] = (0x0 as u32); + out1[9] = (0x0 as u32); + out1[10] = (0x0 as u32); + out1[11] = (0x0 as u32); +} + +/// The function fiat_p384_scalar_msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_p384_scalar_msat(out1: &mut [u32; 13]) -> () { + out1[0] = 0xccc52973; + out1[1] = 0xecec196a; + out1[2] = 0x48b0a77a; + out1[3] = 0x581a0db2; + out1[4] = 0xf4372ddf; + out1[5] = 0xc7634d81; + out1[6] = 0xffffffff; + out1[7] = 0xffffffff; + out1[8] = 0xffffffff; + out1[9] = 0xffffffff; + out1[10] = 0xffffffff; + out1[11] = 0xffffffff; + out1[12] = (0x0 as u32); +} + +/// The function fiat_p384_scalar_divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_p384_scalar_divstep(out1: &mut u32, out2: &mut [u32; 13], out3: &mut [u32; 13], out4: &mut [u32; 12], out5: &mut [u32; 12], arg1: u32, arg2: &[u32; 13], arg3: &[u32; 13], arg4: &[u32; 12], arg5: &[u32; 12]) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x1, &mut x2, 0x0, (!arg1), (0x1 as u32)); + let x3: fiat_p384_scalar_u1 = (((x1 >> 31) as fiat_p384_scalar_u1) & (((arg3[0]) & (0x1 as u32)) as fiat_p384_scalar_u1)); + let mut x4: u32 = 0; + let mut x5: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x4, &mut x5, 0x0, (!arg1), (0x1 as u32)); + let mut x6: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x6, x3, arg1, x4); + let mut x7: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x7, x3, (arg2[0]), (arg3[0])); + let mut x8: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x8, x3, (arg2[1]), (arg3[1])); + let mut x9: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x9, x3, (arg2[2]), (arg3[2])); + let mut x10: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x10, x3, (arg2[3]), (arg3[3])); + let mut x11: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x11, x3, (arg2[4]), (arg3[4])); + let mut x12: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x12, x3, (arg2[5]), (arg3[5])); + let mut x13: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x13, x3, (arg2[6]), (arg3[6])); + let mut x14: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x14, x3, (arg2[7]), (arg3[7])); + let mut x15: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x15, x3, (arg2[8]), (arg3[8])); + let mut x16: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x16, x3, (arg2[9]), (arg3[9])); + let mut x17: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x17, x3, (arg2[10]), (arg3[10])); + let mut x18: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x18, x3, (arg2[11]), (arg3[11])); + let mut x19: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x19, x3, (arg2[12]), (arg3[12])); + let mut x20: u32 = 0; + let mut x21: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x20, &mut x21, 0x0, (0x1 as u32), (!(arg2[0]))); + let mut x22: u32 = 0; + let mut x23: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x22, &mut x23, x21, (0x0 as u32), (!(arg2[1]))); + let mut x24: u32 = 0; + let mut x25: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x24, &mut x25, x23, (0x0 as u32), (!(arg2[2]))); + let mut x26: u32 = 0; + let mut x27: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x26, &mut x27, x25, (0x0 as u32), (!(arg2[3]))); + let mut x28: u32 = 0; + let mut x29: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x28, &mut x29, x27, (0x0 as u32), (!(arg2[4]))); + let mut x30: u32 = 0; + let mut x31: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x30, &mut x31, x29, (0x0 as u32), (!(arg2[5]))); + let mut x32: u32 = 0; + let mut x33: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x32, &mut x33, x31, (0x0 as u32), (!(arg2[6]))); + let mut x34: u32 = 0; + let mut x35: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x34, &mut x35, x33, (0x0 as u32), (!(arg2[7]))); + let mut x36: u32 = 0; + let mut x37: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x36, &mut x37, x35, (0x0 as u32), (!(arg2[8]))); + let mut x38: u32 = 0; + let mut x39: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x38, &mut x39, x37, (0x0 as u32), (!(arg2[9]))); + let mut x40: u32 = 0; + let mut x41: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x40, &mut x41, x39, (0x0 as u32), (!(arg2[10]))); + let mut x42: u32 = 0; + let mut x43: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x42, &mut x43, x41, (0x0 as u32), (!(arg2[11]))); + let mut x44: u32 = 0; + let mut x45: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x44, &mut x45, x43, (0x0 as u32), (!(arg2[12]))); + let mut x46: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x46, x3, (arg3[0]), x20); + let mut x47: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x47, x3, (arg3[1]), x22); + let mut x48: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x48, x3, (arg3[2]), x24); + let mut x49: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x49, x3, (arg3[3]), x26); + let mut x50: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x50, x3, (arg3[4]), x28); + let mut x51: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x51, x3, (arg3[5]), x30); + let mut x52: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x52, x3, (arg3[6]), x32); + let mut x53: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x53, x3, (arg3[7]), x34); + let mut x54: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x54, x3, (arg3[8]), x36); + let mut x55: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x55, x3, (arg3[9]), x38); + let mut x56: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x56, x3, (arg3[10]), x40); + let mut x57: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x57, x3, (arg3[11]), x42); + let mut x58: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x58, x3, (arg3[12]), x44); + let mut x59: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x59, x3, (arg4[0]), (arg5[0])); + let mut x60: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x60, x3, (arg4[1]), (arg5[1])); + let mut x61: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x61, x3, (arg4[2]), (arg5[2])); + let mut x62: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x62, x3, (arg4[3]), (arg5[3])); + let mut x63: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x63, x3, (arg4[4]), (arg5[4])); + let mut x64: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x64, x3, (arg4[5]), (arg5[5])); + let mut x65: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x65, x3, (arg4[6]), (arg5[6])); + let mut x66: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x66, x3, (arg4[7]), (arg5[7])); + let mut x67: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x67, x3, (arg4[8]), (arg5[8])); + let mut x68: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x68, x3, (arg4[9]), (arg5[9])); + let mut x69: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x69, x3, (arg4[10]), (arg5[10])); + let mut x70: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x70, x3, (arg4[11]), (arg5[11])); + let mut x71: u32 = 0; + let mut x72: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x71, &mut x72, 0x0, x59, x59); + let mut x73: u32 = 0; + let mut x74: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x73, &mut x74, x72, x60, x60); + let mut x75: u32 = 0; + let mut x76: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x75, &mut x76, x74, x61, x61); + let mut x77: u32 = 0; + let mut x78: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x77, &mut x78, x76, x62, x62); + let mut x79: u32 = 0; + let mut x80: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x79, &mut x80, x78, x63, x63); + let mut x81: u32 = 0; + let mut x82: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x81, &mut x82, x80, x64, x64); + let mut x83: u32 = 0; + let mut x84: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x83, &mut x84, x82, x65, x65); + let mut x85: u32 = 0; + let mut x86: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x85, &mut x86, x84, x66, x66); + let mut x87: u32 = 0; + let mut x88: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x87, &mut x88, x86, x67, x67); + let mut x89: u32 = 0; + let mut x90: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x89, &mut x90, x88, x68, x68); + let mut x91: u32 = 0; + let mut x92: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x91, &mut x92, x90, x69, x69); + let mut x93: u32 = 0; + let mut x94: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x93, &mut x94, x92, x70, x70); + let mut x95: u32 = 0; + let mut x96: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x95, &mut x96, 0x0, x71, 0xccc52973); + let mut x97: u32 = 0; + let mut x98: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x97, &mut x98, x96, x73, 0xecec196a); + let mut x99: u32 = 0; + let mut x100: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x99, &mut x100, x98, x75, 0x48b0a77a); + let mut x101: u32 = 0; + let mut x102: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x101, &mut x102, x100, x77, 0x581a0db2); + let mut x103: u32 = 0; + let mut x104: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x103, &mut x104, x102, x79, 0xf4372ddf); + let mut x105: u32 = 0; + let mut x106: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x105, &mut x106, x104, x81, 0xc7634d81); + let mut x107: u32 = 0; + let mut x108: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x107, &mut x108, x106, x83, 0xffffffff); + let mut x109: u32 = 0; + let mut x110: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x109, &mut x110, x108, x85, 0xffffffff); + let mut x111: u32 = 0; + let mut x112: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x111, &mut x112, x110, x87, 0xffffffff); + let mut x113: u32 = 0; + let mut x114: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x113, &mut x114, x112, x89, 0xffffffff); + let mut x115: u32 = 0; + let mut x116: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x115, &mut x116, x114, x91, 0xffffffff); + let mut x117: u32 = 0; + let mut x118: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x117, &mut x118, x116, x93, 0xffffffff); + let mut x119: u32 = 0; + let mut x120: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x119, &mut x120, x118, (x94 as u32), (0x0 as u32)); + let x121: u32 = (arg4[11]); + let x122: u32 = (arg4[10]); + let x123: u32 = (arg4[9]); + let x124: u32 = (arg4[8]); + let x125: u32 = (arg4[7]); + let x126: u32 = (arg4[6]); + let x127: u32 = (arg4[5]); + let x128: u32 = (arg4[4]); + let x129: u32 = (arg4[3]); + let x130: u32 = (arg4[2]); + let x131: u32 = (arg4[1]); + let x132: u32 = (arg4[0]); + let mut x133: u32 = 0; + let mut x134: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x133, &mut x134, 0x0, (0x0 as u32), x132); + let mut x135: u32 = 0; + let mut x136: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x135, &mut x136, x134, (0x0 as u32), x131); + let mut x137: u32 = 0; + let mut x138: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x137, &mut x138, x136, (0x0 as u32), x130); + let mut x139: u32 = 0; + let mut x140: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x139, &mut x140, x138, (0x0 as u32), x129); + let mut x141: u32 = 0; + let mut x142: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x141, &mut x142, x140, (0x0 as u32), x128); + let mut x143: u32 = 0; + let mut x144: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x143, &mut x144, x142, (0x0 as u32), x127); + let mut x145: u32 = 0; + let mut x146: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x145, &mut x146, x144, (0x0 as u32), x126); + let mut x147: u32 = 0; + let mut x148: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x147, &mut x148, x146, (0x0 as u32), x125); + let mut x149: u32 = 0; + let mut x150: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x149, &mut x150, x148, (0x0 as u32), x124); + let mut x151: u32 = 0; + let mut x152: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x151, &mut x152, x150, (0x0 as u32), x123); + let mut x153: u32 = 0; + let mut x154: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x153, &mut x154, x152, (0x0 as u32), x122); + let mut x155: u32 = 0; + let mut x156: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x155, &mut x156, x154, (0x0 as u32), x121); + let mut x157: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x157, x156, (0x0 as u32), 0xffffffff); + let mut x158: u32 = 0; + let mut x159: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x158, &mut x159, 0x0, x133, (x157 & 0xccc52973)); + let mut x160: u32 = 0; + let mut x161: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x135, (x157 & 0xecec196a)); + let mut x162: u32 = 0; + let mut x163: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x162, &mut x163, x161, x137, (x157 & 0x48b0a77a)); + let mut x164: u32 = 0; + let mut x165: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x164, &mut x165, x163, x139, (x157 & 0x581a0db2)); + let mut x166: u32 = 0; + let mut x167: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x166, &mut x167, x165, x141, (x157 & 0xf4372ddf)); + let mut x168: u32 = 0; + let mut x169: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x168, &mut x169, x167, x143, (x157 & 0xc7634d81)); + let mut x170: u32 = 0; + let mut x171: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x170, &mut x171, x169, x145, x157); + let mut x172: u32 = 0; + let mut x173: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x172, &mut x173, x171, x147, x157); + let mut x174: u32 = 0; + let mut x175: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x174, &mut x175, x173, x149, x157); + let mut x176: u32 = 0; + let mut x177: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x176, &mut x177, x175, x151, x157); + let mut x178: u32 = 0; + let mut x179: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x178, &mut x179, x177, x153, x157); + let mut x180: u32 = 0; + let mut x181: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x180, &mut x181, x179, x155, x157); + let mut x182: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x182, x3, (arg5[0]), x158); + let mut x183: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x183, x3, (arg5[1]), x160); + let mut x184: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x184, x3, (arg5[2]), x162); + let mut x185: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x185, x3, (arg5[3]), x164); + let mut x186: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x186, x3, (arg5[4]), x166); + let mut x187: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x187, x3, (arg5[5]), x168); + let mut x188: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x188, x3, (arg5[6]), x170); + let mut x189: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x189, x3, (arg5[7]), x172); + let mut x190: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x190, x3, (arg5[8]), x174); + let mut x191: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x191, x3, (arg5[9]), x176); + let mut x192: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x192, x3, (arg5[10]), x178); + let mut x193: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x193, x3, (arg5[11]), x180); + let x194: fiat_p384_scalar_u1 = ((x46 & (0x1 as u32)) as fiat_p384_scalar_u1); + let mut x195: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x195, x194, (0x0 as u32), x7); + let mut x196: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x196, x194, (0x0 as u32), x8); + let mut x197: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x197, x194, (0x0 as u32), x9); + let mut x198: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x198, x194, (0x0 as u32), x10); + let mut x199: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x199, x194, (0x0 as u32), x11); + let mut x200: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x200, x194, (0x0 as u32), x12); + let mut x201: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x201, x194, (0x0 as u32), x13); + let mut x202: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x202, x194, (0x0 as u32), x14); + let mut x203: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x203, x194, (0x0 as u32), x15); + let mut x204: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x204, x194, (0x0 as u32), x16); + let mut x205: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x205, x194, (0x0 as u32), x17); + let mut x206: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x206, x194, (0x0 as u32), x18); + let mut x207: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x207, x194, (0x0 as u32), x19); + let mut x208: u32 = 0; + let mut x209: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x208, &mut x209, 0x0, x46, x195); + let mut x210: u32 = 0; + let mut x211: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x210, &mut x211, x209, x47, x196); + let mut x212: u32 = 0; + let mut x213: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x212, &mut x213, x211, x48, x197); + let mut x214: u32 = 0; + let mut x215: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x214, &mut x215, x213, x49, x198); + let mut x216: u32 = 0; + let mut x217: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x216, &mut x217, x215, x50, x199); + let mut x218: u32 = 0; + let mut x219: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x218, &mut x219, x217, x51, x200); + let mut x220: u32 = 0; + let mut x221: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x220, &mut x221, x219, x52, x201); + let mut x222: u32 = 0; + let mut x223: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x222, &mut x223, x221, x53, x202); + let mut x224: u32 = 0; + let mut x225: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x224, &mut x225, x223, x54, x203); + let mut x226: u32 = 0; + let mut x227: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x226, &mut x227, x225, x55, x204); + let mut x228: u32 = 0; + let mut x229: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x228, &mut x229, x227, x56, x205); + let mut x230: u32 = 0; + let mut x231: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x230, &mut x231, x229, x57, x206); + let mut x232: u32 = 0; + let mut x233: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x232, &mut x233, x231, x58, x207); + let mut x234: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x234, x194, (0x0 as u32), x59); + let mut x235: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x235, x194, (0x0 as u32), x60); + let mut x236: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x236, x194, (0x0 as u32), x61); + let mut x237: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x237, x194, (0x0 as u32), x62); + let mut x238: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x238, x194, (0x0 as u32), x63); + let mut x239: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x239, x194, (0x0 as u32), x64); + let mut x240: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x240, x194, (0x0 as u32), x65); + let mut x241: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x241, x194, (0x0 as u32), x66); + let mut x242: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x242, x194, (0x0 as u32), x67); + let mut x243: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x243, x194, (0x0 as u32), x68); + let mut x244: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x244, x194, (0x0 as u32), x69); + let mut x245: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x245, x194, (0x0 as u32), x70); + let mut x246: u32 = 0; + let mut x247: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x246, &mut x247, 0x0, x182, x234); + let mut x248: u32 = 0; + let mut x249: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x248, &mut x249, x247, x183, x235); + let mut x250: u32 = 0; + let mut x251: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x250, &mut x251, x249, x184, x236); + let mut x252: u32 = 0; + let mut x253: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x252, &mut x253, x251, x185, x237); + let mut x254: u32 = 0; + let mut x255: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x254, &mut x255, x253, x186, x238); + let mut x256: u32 = 0; + let mut x257: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x256, &mut x257, x255, x187, x239); + let mut x258: u32 = 0; + let mut x259: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x258, &mut x259, x257, x188, x240); + let mut x260: u32 = 0; + let mut x261: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x260, &mut x261, x259, x189, x241); + let mut x262: u32 = 0; + let mut x263: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x262, &mut x263, x261, x190, x242); + let mut x264: u32 = 0; + let mut x265: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x264, &mut x265, x263, x191, x243); + let mut x266: u32 = 0; + let mut x267: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x266, &mut x267, x265, x192, x244); + let mut x268: u32 = 0; + let mut x269: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x268, &mut x269, x267, x193, x245); + let mut x270: u32 = 0; + let mut x271: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x270, &mut x271, 0x0, x246, 0xccc52973); + let mut x272: u32 = 0; + let mut x273: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x272, &mut x273, x271, x248, 0xecec196a); + let mut x274: u32 = 0; + let mut x275: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x274, &mut x275, x273, x250, 0x48b0a77a); + let mut x276: u32 = 0; + let mut x277: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x276, &mut x277, x275, x252, 0x581a0db2); + let mut x278: u32 = 0; + let mut x279: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x278, &mut x279, x277, x254, 0xf4372ddf); + let mut x280: u32 = 0; + let mut x281: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x280, &mut x281, x279, x256, 0xc7634d81); + let mut x282: u32 = 0; + let mut x283: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x282, &mut x283, x281, x258, 0xffffffff); + let mut x284: u32 = 0; + let mut x285: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x284, &mut x285, x283, x260, 0xffffffff); + let mut x286: u32 = 0; + let mut x287: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x286, &mut x287, x285, x262, 0xffffffff); + let mut x288: u32 = 0; + let mut x289: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x288, &mut x289, x287, x264, 0xffffffff); + let mut x290: u32 = 0; + let mut x291: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x290, &mut x291, x289, x266, 0xffffffff); + let mut x292: u32 = 0; + let mut x293: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x292, &mut x293, x291, x268, 0xffffffff); + let mut x294: u32 = 0; + let mut x295: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u32(&mut x294, &mut x295, x293, (x269 as u32), (0x0 as u32)); + let mut x296: u32 = 0; + let mut x297: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u32(&mut x296, &mut x297, 0x0, x6, (0x1 as u32)); + let x298: u32 = ((x208 >> 1) | ((x210 << 31) & 0xffffffff)); + let x299: u32 = ((x210 >> 1) | ((x212 << 31) & 0xffffffff)); + let x300: u32 = ((x212 >> 1) | ((x214 << 31) & 0xffffffff)); + let x301: u32 = ((x214 >> 1) | ((x216 << 31) & 0xffffffff)); + let x302: u32 = ((x216 >> 1) | ((x218 << 31) & 0xffffffff)); + let x303: u32 = ((x218 >> 1) | ((x220 << 31) & 0xffffffff)); + let x304: u32 = ((x220 >> 1) | ((x222 << 31) & 0xffffffff)); + let x305: u32 = ((x222 >> 1) | ((x224 << 31) & 0xffffffff)); + let x306: u32 = ((x224 >> 1) | ((x226 << 31) & 0xffffffff)); + let x307: u32 = ((x226 >> 1) | ((x228 << 31) & 0xffffffff)); + let x308: u32 = ((x228 >> 1) | ((x230 << 31) & 0xffffffff)); + let x309: u32 = ((x230 >> 1) | ((x232 << 31) & 0xffffffff)); + let x310: u32 = ((x232 & 0x80000000) | (x232 >> 1)); + let mut x311: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x311, x120, x95, x71); + let mut x312: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x312, x120, x97, x73); + let mut x313: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x313, x120, x99, x75); + let mut x314: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x314, x120, x101, x77); + let mut x315: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x315, x120, x103, x79); + let mut x316: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x316, x120, x105, x81); + let mut x317: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x317, x120, x107, x83); + let mut x318: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x318, x120, x109, x85); + let mut x319: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x319, x120, x111, x87); + let mut x320: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x320, x120, x113, x89); + let mut x321: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x321, x120, x115, x91); + let mut x322: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x322, x120, x117, x93); + let mut x323: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x323, x295, x270, x246); + let mut x324: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x324, x295, x272, x248); + let mut x325: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x325, x295, x274, x250); + let mut x326: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x326, x295, x276, x252); + let mut x327: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x327, x295, x278, x254); + let mut x328: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x328, x295, x280, x256); + let mut x329: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x329, x295, x282, x258); + let mut x330: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x330, x295, x284, x260); + let mut x331: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x331, x295, x286, x262); + let mut x332: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x332, x295, x288, x264); + let mut x333: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x333, x295, x290, x266); + let mut x334: u32 = 0; + fiat_p384_scalar_cmovznz_u32(&mut x334, x295, x292, x268); + *out1 = x296; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out2[7] = x14; + out2[8] = x15; + out2[9] = x16; + out2[10] = x17; + out2[11] = x18; + out2[12] = x19; + out3[0] = x298; + out3[1] = x299; + out3[2] = x300; + out3[3] = x301; + out3[4] = x302; + out3[5] = x303; + out3[6] = x304; + out3[7] = x305; + out3[8] = x306; + out3[9] = x307; + out3[10] = x308; + out3[11] = x309; + out3[12] = x310; + out4[0] = x311; + out4[1] = x312; + out4[2] = x313; + out4[3] = x314; + out4[4] = x315; + out4[5] = x316; + out4[6] = x317; + out4[7] = x318; + out4[8] = x319; + out4[9] = x320; + out4[10] = x321; + out4[11] = x322; + out5[0] = x323; + out5[1] = x324; + out5[2] = x325; + out5[3] = x326; + out5[4] = x327; + out5[5] = x328; + out5[6] = x329; + out5[7] = x330; + out5[8] = x331; + out5[9] = x332; + out5[10] = x333; + out5[11] = x334; +} + +/// The function fiat_p384_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_p384_scalar_divstep_precomp(out1: &mut [u32; 12]) -> () { + out1[0] = 0xe6045b6a; + out1[1] = 0x49589ae0; + out1[2] = 0x870040ed; + out1[3] = 0x3c9a5352; + out1[4] = 0x977dc242; + out1[5] = 0xdacb097e; + out1[6] = 0xd1ecbe36; + out1[7] = 0xb5ab30a6; + out1[8] = 0x1f959973; + out1[9] = 0x97d7a108; + out1[10] = 0xd27192bc; + out1[11] = 0x2ba012f8; +} diff --git a/fiat-rust/src/p384_scalar_64.rs b/fiat-rust/src/p384_scalar_64.rs new file mode 100644 index 0000000000..63474c2399 --- /dev/null +++ b/fiat-rust/src/p384_scalar_64.rs @@ -0,0 +1,3625 @@ +//! Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline p384_scalar 64 '2^384 - 1388124618062372383947042015309946732620727252194336364173' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +//! curve description: p384_scalar +//! machine_wordsize = 64 (from "64") +//! requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +//! m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from "2^384 - 1388124618062372383947042015309946732620727252194336364173") +//! +//! NOTE: In addition to the bounds specified above each function, all +//! functions synthesized for this Montgomery arithmetic require the +//! input to be strictly less than the prime modulus (m), and also +//! require the input to be in the unique saturated representation. +//! All functions also ensure that these two properties are true of +//! return values. +//! +//! Computed values: +//! eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) +//! bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) +//! twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) in +//! if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384 + +#![allow(unused_parens)] +#![allow(non_camel_case_types)] + +pub type fiat_p384_scalar_u1 = u8; +pub type fiat_p384_scalar_i1 = i8; +pub type fiat_p384_scalar_u2 = u8; +pub type fiat_p384_scalar_i2 = i8; + +/* The type fiat_p384_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +pub type fiat_p384_scalar_montgomery_domain_field_element = [u64; 6]; + +/* The type fiat_p384_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +pub type fiat_p384_scalar_non_montgomery_domain_field_element = [u64; 6]; + + +/// The function fiat_p384_scalar_addcarryx_u64 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^64 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_p384_scalar_addcarryx_u64(out1: &mut u64, out2: &mut fiat_p384_scalar_u1, arg1: fiat_p384_scalar_u1, arg2: u64, arg3: u64) -> () { + let x1: u128 = (((arg1 as u128) + (arg2 as u128)) + (arg3 as u128)); + let x2: u64 = ((x1 & (0xffffffffffffffff as u128)) as u64); + let x3: fiat_p384_scalar_u1 = ((x1 >> 64) as fiat_p384_scalar_u1); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_p384_scalar_subborrowx_u64 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^64 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_p384_scalar_subborrowx_u64(out1: &mut u64, out2: &mut fiat_p384_scalar_u1, arg1: fiat_p384_scalar_u1, arg2: u64, arg3: u64) -> () { + let x1: i128 = (((arg2 as i128) - (arg1 as i128)) - (arg3 as i128)); + let x2: fiat_p384_scalar_i1 = ((x1 >> 64) as fiat_p384_scalar_i1); + let x3: u64 = ((x1 & (0xffffffffffffffff as i128)) as u64); + *out1 = x3; + *out2 = (((0x0 as fiat_p384_scalar_i2) - (x2 as fiat_p384_scalar_i2)) as fiat_p384_scalar_u1); +} + +/// The function fiat_p384_scalar_mulx_u64 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^64 +/// out2 = ⌊arg1 * arg2 / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0xffffffffffffffff] +#[inline] +pub fn fiat_p384_scalar_mulx_u64(out1: &mut u64, out2: &mut u64, arg1: u64, arg2: u64) -> () { + let x1: u128 = ((arg1 as u128) * (arg2 as u128)); + let x2: u64 = ((x1 & (0xffffffffffffffff as u128)) as u64); + let x3: u64 = ((x1 >> 64) as u64); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_p384_scalar_cmovznz_u64 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +#[inline] +pub fn fiat_p384_scalar_cmovznz_u64(out1: &mut u64, arg1: fiat_p384_scalar_u1, arg2: u64, arg3: u64) -> () { + let x1: fiat_p384_scalar_u1 = (!(!arg1)); + let x2: u64 = ((((((0x0 as fiat_p384_scalar_i2) - (x1 as fiat_p384_scalar_i2)) as fiat_p384_scalar_i1) as i128) & (0xffffffffffffffff as i128)) as u64); + let x3: u64 = ((x2 & arg3) | ((!x2) & arg2)); + *out1 = x3; +} + +/// The function fiat_p384_scalar_mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_mul(out1: &mut fiat_p384_scalar_montgomery_domain_field_element, arg1: &fiat_p384_scalar_montgomery_domain_field_element, arg2: &fiat_p384_scalar_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[1]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[4]); + let x5: u64 = (arg1[5]); + let x6: u64 = (arg1[0]); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x7, &mut x8, x6, (arg2[5])); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x9, &mut x10, x6, (arg2[4])); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x11, &mut x12, x6, (arg2[3])); + let mut x13: u64 = 0; + let mut x14: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x13, &mut x14, x6, (arg2[2])); + let mut x15: u64 = 0; + let mut x16: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x15, &mut x16, x6, (arg2[1])); + let mut x17: u64 = 0; + let mut x18: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x17, &mut x18, x6, (arg2[0])); + let mut x19: u64 = 0; + let mut x20: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x19, &mut x20, 0x0, x18, x15); + let mut x21: u64 = 0; + let mut x22: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x21, &mut x22, x20, x16, x13); + let mut x23: u64 = 0; + let mut x24: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x23, &mut x24, x22, x14, x11); + let mut x25: u64 = 0; + let mut x26: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x25, &mut x26, x24, x12, x9); + let mut x27: u64 = 0; + let mut x28: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x27, &mut x28, x26, x10, x7); + let x29: u64 = ((x28 as u64) + x8); + let mut x30: u64 = 0; + let mut x31: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x30, &mut x31, x17, 0x6ed46089e88fdc45); + let mut x32: u64 = 0; + let mut x33: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x32, &mut x33, x30, 0xffffffffffffffff); + let mut x34: u64 = 0; + let mut x35: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x34, &mut x35, x30, 0xffffffffffffffff); + let mut x36: u64 = 0; + let mut x37: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x36, &mut x37, x30, 0xffffffffffffffff); + let mut x38: u64 = 0; + let mut x39: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x38, &mut x39, x30, 0xc7634d81f4372ddf); + let mut x40: u64 = 0; + let mut x41: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x40, &mut x41, x30, 0x581a0db248b0a77a); + let mut x42: u64 = 0; + let mut x43: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x42, &mut x43, x30, 0xecec196accc52973); + let mut x44: u64 = 0; + let mut x45: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x44, &mut x45, 0x0, x43, x40); + let mut x46: u64 = 0; + let mut x47: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x46, &mut x47, x45, x41, x38); + let mut x48: u64 = 0; + let mut x49: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x48, &mut x49, x47, x39, x36); + let mut x50: u64 = 0; + let mut x51: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x50, &mut x51, x49, x37, x34); + let mut x52: u64 = 0; + let mut x53: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x52, &mut x53, x51, x35, x32); + let x54: u64 = ((x53 as u64) + x33); + let mut x55: u64 = 0; + let mut x56: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x55, &mut x56, 0x0, x17, x42); + let mut x57: u64 = 0; + let mut x58: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x57, &mut x58, x56, x19, x44); + let mut x59: u64 = 0; + let mut x60: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x59, &mut x60, x58, x21, x46); + let mut x61: u64 = 0; + let mut x62: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x61, &mut x62, x60, x23, x48); + let mut x63: u64 = 0; + let mut x64: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x63, &mut x64, x62, x25, x50); + let mut x65: u64 = 0; + let mut x66: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x65, &mut x66, x64, x27, x52); + let mut x67: u64 = 0; + let mut x68: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x67, &mut x68, x66, x29, x54); + let mut x69: u64 = 0; + let mut x70: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x69, &mut x70, x1, (arg2[5])); + let mut x71: u64 = 0; + let mut x72: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x71, &mut x72, x1, (arg2[4])); + let mut x73: u64 = 0; + let mut x74: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x73, &mut x74, x1, (arg2[3])); + let mut x75: u64 = 0; + let mut x76: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x75, &mut x76, x1, (arg2[2])); + let mut x77: u64 = 0; + let mut x78: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x77, &mut x78, x1, (arg2[1])); + let mut x79: u64 = 0; + let mut x80: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x79, &mut x80, x1, (arg2[0])); + let mut x81: u64 = 0; + let mut x82: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x81, &mut x82, 0x0, x80, x77); + let mut x83: u64 = 0; + let mut x84: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x83, &mut x84, x82, x78, x75); + let mut x85: u64 = 0; + let mut x86: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x85, &mut x86, x84, x76, x73); + let mut x87: u64 = 0; + let mut x88: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x87, &mut x88, x86, x74, x71); + let mut x89: u64 = 0; + let mut x90: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x89, &mut x90, x88, x72, x69); + let x91: u64 = ((x90 as u64) + x70); + let mut x92: u64 = 0; + let mut x93: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x92, &mut x93, 0x0, x57, x79); + let mut x94: u64 = 0; + let mut x95: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x94, &mut x95, x93, x59, x81); + let mut x96: u64 = 0; + let mut x97: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x96, &mut x97, x95, x61, x83); + let mut x98: u64 = 0; + let mut x99: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x98, &mut x99, x97, x63, x85); + let mut x100: u64 = 0; + let mut x101: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x100, &mut x101, x99, x65, x87); + let mut x102: u64 = 0; + let mut x103: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x102, &mut x103, x101, x67, x89); + let mut x104: u64 = 0; + let mut x105: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x104, &mut x105, x103, (x68 as u64), x91); + let mut x106: u64 = 0; + let mut x107: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x106, &mut x107, x92, 0x6ed46089e88fdc45); + let mut x108: u64 = 0; + let mut x109: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x108, &mut x109, x106, 0xffffffffffffffff); + let mut x110: u64 = 0; + let mut x111: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x110, &mut x111, x106, 0xffffffffffffffff); + let mut x112: u64 = 0; + let mut x113: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x112, &mut x113, x106, 0xffffffffffffffff); + let mut x114: u64 = 0; + let mut x115: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x114, &mut x115, x106, 0xc7634d81f4372ddf); + let mut x116: u64 = 0; + let mut x117: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x116, &mut x117, x106, 0x581a0db248b0a77a); + let mut x118: u64 = 0; + let mut x119: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x118, &mut x119, x106, 0xecec196accc52973); + let mut x120: u64 = 0; + let mut x121: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x120, &mut x121, 0x0, x119, x116); + let mut x122: u64 = 0; + let mut x123: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x122, &mut x123, x121, x117, x114); + let mut x124: u64 = 0; + let mut x125: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x124, &mut x125, x123, x115, x112); + let mut x126: u64 = 0; + let mut x127: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x126, &mut x127, x125, x113, x110); + let mut x128: u64 = 0; + let mut x129: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x128, &mut x129, x127, x111, x108); + let x130: u64 = ((x129 as u64) + x109); + let mut x131: u64 = 0; + let mut x132: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x131, &mut x132, 0x0, x92, x118); + let mut x133: u64 = 0; + let mut x134: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x133, &mut x134, x132, x94, x120); + let mut x135: u64 = 0; + let mut x136: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x135, &mut x136, x134, x96, x122); + let mut x137: u64 = 0; + let mut x138: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x137, &mut x138, x136, x98, x124); + let mut x139: u64 = 0; + let mut x140: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x139, &mut x140, x138, x100, x126); + let mut x141: u64 = 0; + let mut x142: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x141, &mut x142, x140, x102, x128); + let mut x143: u64 = 0; + let mut x144: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x143, &mut x144, x142, x104, x130); + let x145: u64 = ((x144 as u64) + (x105 as u64)); + let mut x146: u64 = 0; + let mut x147: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x146, &mut x147, x2, (arg2[5])); + let mut x148: u64 = 0; + let mut x149: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x148, &mut x149, x2, (arg2[4])); + let mut x150: u64 = 0; + let mut x151: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x150, &mut x151, x2, (arg2[3])); + let mut x152: u64 = 0; + let mut x153: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x152, &mut x153, x2, (arg2[2])); + let mut x154: u64 = 0; + let mut x155: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x154, &mut x155, x2, (arg2[1])); + let mut x156: u64 = 0; + let mut x157: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x156, &mut x157, x2, (arg2[0])); + let mut x158: u64 = 0; + let mut x159: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x158, &mut x159, 0x0, x157, x154); + let mut x160: u64 = 0; + let mut x161: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x160, &mut x161, x159, x155, x152); + let mut x162: u64 = 0; + let mut x163: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x162, &mut x163, x161, x153, x150); + let mut x164: u64 = 0; + let mut x165: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x164, &mut x165, x163, x151, x148); + let mut x166: u64 = 0; + let mut x167: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x166, &mut x167, x165, x149, x146); + let x168: u64 = ((x167 as u64) + x147); + let mut x169: u64 = 0; + let mut x170: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x169, &mut x170, 0x0, x133, x156); + let mut x171: u64 = 0; + let mut x172: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x171, &mut x172, x170, x135, x158); + let mut x173: u64 = 0; + let mut x174: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x173, &mut x174, x172, x137, x160); + let mut x175: u64 = 0; + let mut x176: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x175, &mut x176, x174, x139, x162); + let mut x177: u64 = 0; + let mut x178: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x177, &mut x178, x176, x141, x164); + let mut x179: u64 = 0; + let mut x180: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x179, &mut x180, x178, x143, x166); + let mut x181: u64 = 0; + let mut x182: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x181, &mut x182, x180, x145, x168); + let mut x183: u64 = 0; + let mut x184: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x183, &mut x184, x169, 0x6ed46089e88fdc45); + let mut x185: u64 = 0; + let mut x186: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x185, &mut x186, x183, 0xffffffffffffffff); + let mut x187: u64 = 0; + let mut x188: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x187, &mut x188, x183, 0xffffffffffffffff); + let mut x189: u64 = 0; + let mut x190: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x189, &mut x190, x183, 0xffffffffffffffff); + let mut x191: u64 = 0; + let mut x192: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x191, &mut x192, x183, 0xc7634d81f4372ddf); + let mut x193: u64 = 0; + let mut x194: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x193, &mut x194, x183, 0x581a0db248b0a77a); + let mut x195: u64 = 0; + let mut x196: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x195, &mut x196, x183, 0xecec196accc52973); + let mut x197: u64 = 0; + let mut x198: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x197, &mut x198, 0x0, x196, x193); + let mut x199: u64 = 0; + let mut x200: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x199, &mut x200, x198, x194, x191); + let mut x201: u64 = 0; + let mut x202: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x201, &mut x202, x200, x192, x189); + let mut x203: u64 = 0; + let mut x204: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x203, &mut x204, x202, x190, x187); + let mut x205: u64 = 0; + let mut x206: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x205, &mut x206, x204, x188, x185); + let x207: u64 = ((x206 as u64) + x186); + let mut x208: u64 = 0; + let mut x209: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x208, &mut x209, 0x0, x169, x195); + let mut x210: u64 = 0; + let mut x211: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x210, &mut x211, x209, x171, x197); + let mut x212: u64 = 0; + let mut x213: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x212, &mut x213, x211, x173, x199); + let mut x214: u64 = 0; + let mut x215: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x214, &mut x215, x213, x175, x201); + let mut x216: u64 = 0; + let mut x217: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x216, &mut x217, x215, x177, x203); + let mut x218: u64 = 0; + let mut x219: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x218, &mut x219, x217, x179, x205); + let mut x220: u64 = 0; + let mut x221: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x220, &mut x221, x219, x181, x207); + let x222: u64 = ((x221 as u64) + (x182 as u64)); + let mut x223: u64 = 0; + let mut x224: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x223, &mut x224, x3, (arg2[5])); + let mut x225: u64 = 0; + let mut x226: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x225, &mut x226, x3, (arg2[4])); + let mut x227: u64 = 0; + let mut x228: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x227, &mut x228, x3, (arg2[3])); + let mut x229: u64 = 0; + let mut x230: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x229, &mut x230, x3, (arg2[2])); + let mut x231: u64 = 0; + let mut x232: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x231, &mut x232, x3, (arg2[1])); + let mut x233: u64 = 0; + let mut x234: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x233, &mut x234, x3, (arg2[0])); + let mut x235: u64 = 0; + let mut x236: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x235, &mut x236, 0x0, x234, x231); + let mut x237: u64 = 0; + let mut x238: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x237, &mut x238, x236, x232, x229); + let mut x239: u64 = 0; + let mut x240: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x239, &mut x240, x238, x230, x227); + let mut x241: u64 = 0; + let mut x242: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x241, &mut x242, x240, x228, x225); + let mut x243: u64 = 0; + let mut x244: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x243, &mut x244, x242, x226, x223); + let x245: u64 = ((x244 as u64) + x224); + let mut x246: u64 = 0; + let mut x247: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x246, &mut x247, 0x0, x210, x233); + let mut x248: u64 = 0; + let mut x249: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x248, &mut x249, x247, x212, x235); + let mut x250: u64 = 0; + let mut x251: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x250, &mut x251, x249, x214, x237); + let mut x252: u64 = 0; + let mut x253: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x252, &mut x253, x251, x216, x239); + let mut x254: u64 = 0; + let mut x255: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x254, &mut x255, x253, x218, x241); + let mut x256: u64 = 0; + let mut x257: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x256, &mut x257, x255, x220, x243); + let mut x258: u64 = 0; + let mut x259: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x258, &mut x259, x257, x222, x245); + let mut x260: u64 = 0; + let mut x261: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x260, &mut x261, x246, 0x6ed46089e88fdc45); + let mut x262: u64 = 0; + let mut x263: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x262, &mut x263, x260, 0xffffffffffffffff); + let mut x264: u64 = 0; + let mut x265: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x264, &mut x265, x260, 0xffffffffffffffff); + let mut x266: u64 = 0; + let mut x267: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x266, &mut x267, x260, 0xffffffffffffffff); + let mut x268: u64 = 0; + let mut x269: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x268, &mut x269, x260, 0xc7634d81f4372ddf); + let mut x270: u64 = 0; + let mut x271: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x270, &mut x271, x260, 0x581a0db248b0a77a); + let mut x272: u64 = 0; + let mut x273: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x272, &mut x273, x260, 0xecec196accc52973); + let mut x274: u64 = 0; + let mut x275: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x274, &mut x275, 0x0, x273, x270); + let mut x276: u64 = 0; + let mut x277: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x276, &mut x277, x275, x271, x268); + let mut x278: u64 = 0; + let mut x279: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x278, &mut x279, x277, x269, x266); + let mut x280: u64 = 0; + let mut x281: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x280, &mut x281, x279, x267, x264); + let mut x282: u64 = 0; + let mut x283: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x282, &mut x283, x281, x265, x262); + let x284: u64 = ((x283 as u64) + x263); + let mut x285: u64 = 0; + let mut x286: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x285, &mut x286, 0x0, x246, x272); + let mut x287: u64 = 0; + let mut x288: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x287, &mut x288, x286, x248, x274); + let mut x289: u64 = 0; + let mut x290: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x289, &mut x290, x288, x250, x276); + let mut x291: u64 = 0; + let mut x292: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x291, &mut x292, x290, x252, x278); + let mut x293: u64 = 0; + let mut x294: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x293, &mut x294, x292, x254, x280); + let mut x295: u64 = 0; + let mut x296: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x295, &mut x296, x294, x256, x282); + let mut x297: u64 = 0; + let mut x298: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x297, &mut x298, x296, x258, x284); + let x299: u64 = ((x298 as u64) + (x259 as u64)); + let mut x300: u64 = 0; + let mut x301: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x300, &mut x301, x4, (arg2[5])); + let mut x302: u64 = 0; + let mut x303: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x302, &mut x303, x4, (arg2[4])); + let mut x304: u64 = 0; + let mut x305: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x304, &mut x305, x4, (arg2[3])); + let mut x306: u64 = 0; + let mut x307: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x306, &mut x307, x4, (arg2[2])); + let mut x308: u64 = 0; + let mut x309: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x308, &mut x309, x4, (arg2[1])); + let mut x310: u64 = 0; + let mut x311: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x310, &mut x311, x4, (arg2[0])); + let mut x312: u64 = 0; + let mut x313: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x312, &mut x313, 0x0, x311, x308); + let mut x314: u64 = 0; + let mut x315: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x314, &mut x315, x313, x309, x306); + let mut x316: u64 = 0; + let mut x317: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x316, &mut x317, x315, x307, x304); + let mut x318: u64 = 0; + let mut x319: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x318, &mut x319, x317, x305, x302); + let mut x320: u64 = 0; + let mut x321: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x320, &mut x321, x319, x303, x300); + let x322: u64 = ((x321 as u64) + x301); + let mut x323: u64 = 0; + let mut x324: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x323, &mut x324, 0x0, x287, x310); + let mut x325: u64 = 0; + let mut x326: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x325, &mut x326, x324, x289, x312); + let mut x327: u64 = 0; + let mut x328: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x327, &mut x328, x326, x291, x314); + let mut x329: u64 = 0; + let mut x330: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x329, &mut x330, x328, x293, x316); + let mut x331: u64 = 0; + let mut x332: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x331, &mut x332, x330, x295, x318); + let mut x333: u64 = 0; + let mut x334: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x333, &mut x334, x332, x297, x320); + let mut x335: u64 = 0; + let mut x336: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x335, &mut x336, x334, x299, x322); + let mut x337: u64 = 0; + let mut x338: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x337, &mut x338, x323, 0x6ed46089e88fdc45); + let mut x339: u64 = 0; + let mut x340: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x339, &mut x340, x337, 0xffffffffffffffff); + let mut x341: u64 = 0; + let mut x342: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x341, &mut x342, x337, 0xffffffffffffffff); + let mut x343: u64 = 0; + let mut x344: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x343, &mut x344, x337, 0xffffffffffffffff); + let mut x345: u64 = 0; + let mut x346: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x345, &mut x346, x337, 0xc7634d81f4372ddf); + let mut x347: u64 = 0; + let mut x348: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x347, &mut x348, x337, 0x581a0db248b0a77a); + let mut x349: u64 = 0; + let mut x350: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x349, &mut x350, x337, 0xecec196accc52973); + let mut x351: u64 = 0; + let mut x352: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x351, &mut x352, 0x0, x350, x347); + let mut x353: u64 = 0; + let mut x354: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x353, &mut x354, x352, x348, x345); + let mut x355: u64 = 0; + let mut x356: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x355, &mut x356, x354, x346, x343); + let mut x357: u64 = 0; + let mut x358: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x357, &mut x358, x356, x344, x341); + let mut x359: u64 = 0; + let mut x360: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x359, &mut x360, x358, x342, x339); + let x361: u64 = ((x360 as u64) + x340); + let mut x362: u64 = 0; + let mut x363: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x362, &mut x363, 0x0, x323, x349); + let mut x364: u64 = 0; + let mut x365: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x364, &mut x365, x363, x325, x351); + let mut x366: u64 = 0; + let mut x367: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x366, &mut x367, x365, x327, x353); + let mut x368: u64 = 0; + let mut x369: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x368, &mut x369, x367, x329, x355); + let mut x370: u64 = 0; + let mut x371: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x370, &mut x371, x369, x331, x357); + let mut x372: u64 = 0; + let mut x373: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x372, &mut x373, x371, x333, x359); + let mut x374: u64 = 0; + let mut x375: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x374, &mut x375, x373, x335, x361); + let x376: u64 = ((x375 as u64) + (x336 as u64)); + let mut x377: u64 = 0; + let mut x378: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x377, &mut x378, x5, (arg2[5])); + let mut x379: u64 = 0; + let mut x380: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x379, &mut x380, x5, (arg2[4])); + let mut x381: u64 = 0; + let mut x382: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x381, &mut x382, x5, (arg2[3])); + let mut x383: u64 = 0; + let mut x384: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x383, &mut x384, x5, (arg2[2])); + let mut x385: u64 = 0; + let mut x386: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x385, &mut x386, x5, (arg2[1])); + let mut x387: u64 = 0; + let mut x388: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x387, &mut x388, x5, (arg2[0])); + let mut x389: u64 = 0; + let mut x390: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x389, &mut x390, 0x0, x388, x385); + let mut x391: u64 = 0; + let mut x392: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x391, &mut x392, x390, x386, x383); + let mut x393: u64 = 0; + let mut x394: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x393, &mut x394, x392, x384, x381); + let mut x395: u64 = 0; + let mut x396: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x395, &mut x396, x394, x382, x379); + let mut x397: u64 = 0; + let mut x398: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x397, &mut x398, x396, x380, x377); + let x399: u64 = ((x398 as u64) + x378); + let mut x400: u64 = 0; + let mut x401: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x400, &mut x401, 0x0, x364, x387); + let mut x402: u64 = 0; + let mut x403: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x402, &mut x403, x401, x366, x389); + let mut x404: u64 = 0; + let mut x405: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x404, &mut x405, x403, x368, x391); + let mut x406: u64 = 0; + let mut x407: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x406, &mut x407, x405, x370, x393); + let mut x408: u64 = 0; + let mut x409: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x408, &mut x409, x407, x372, x395); + let mut x410: u64 = 0; + let mut x411: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x410, &mut x411, x409, x374, x397); + let mut x412: u64 = 0; + let mut x413: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x412, &mut x413, x411, x376, x399); + let mut x414: u64 = 0; + let mut x415: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x414, &mut x415, x400, 0x6ed46089e88fdc45); + let mut x416: u64 = 0; + let mut x417: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x416, &mut x417, x414, 0xffffffffffffffff); + let mut x418: u64 = 0; + let mut x419: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x418, &mut x419, x414, 0xffffffffffffffff); + let mut x420: u64 = 0; + let mut x421: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x420, &mut x421, x414, 0xffffffffffffffff); + let mut x422: u64 = 0; + let mut x423: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x422, &mut x423, x414, 0xc7634d81f4372ddf); + let mut x424: u64 = 0; + let mut x425: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x424, &mut x425, x414, 0x581a0db248b0a77a); + let mut x426: u64 = 0; + let mut x427: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x426, &mut x427, x414, 0xecec196accc52973); + let mut x428: u64 = 0; + let mut x429: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x428, &mut x429, 0x0, x427, x424); + let mut x430: u64 = 0; + let mut x431: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x430, &mut x431, x429, x425, x422); + let mut x432: u64 = 0; + let mut x433: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x432, &mut x433, x431, x423, x420); + let mut x434: u64 = 0; + let mut x435: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x434, &mut x435, x433, x421, x418); + let mut x436: u64 = 0; + let mut x437: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x436, &mut x437, x435, x419, x416); + let x438: u64 = ((x437 as u64) + x417); + let mut x439: u64 = 0; + let mut x440: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x439, &mut x440, 0x0, x400, x426); + let mut x441: u64 = 0; + let mut x442: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x441, &mut x442, x440, x402, x428); + let mut x443: u64 = 0; + let mut x444: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x443, &mut x444, x442, x404, x430); + let mut x445: u64 = 0; + let mut x446: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x445, &mut x446, x444, x406, x432); + let mut x447: u64 = 0; + let mut x448: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x447, &mut x448, x446, x408, x434); + let mut x449: u64 = 0; + let mut x450: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x449, &mut x450, x448, x410, x436); + let mut x451: u64 = 0; + let mut x452: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x451, &mut x452, x450, x412, x438); + let x453: u64 = ((x452 as u64) + (x413 as u64)); + let mut x454: u64 = 0; + let mut x455: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x454, &mut x455, 0x0, x441, 0xecec196accc52973); + let mut x456: u64 = 0; + let mut x457: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x456, &mut x457, x455, x443, 0x581a0db248b0a77a); + let mut x458: u64 = 0; + let mut x459: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x458, &mut x459, x457, x445, 0xc7634d81f4372ddf); + let mut x460: u64 = 0; + let mut x461: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x460, &mut x461, x459, x447, 0xffffffffffffffff); + let mut x462: u64 = 0; + let mut x463: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x462, &mut x463, x461, x449, 0xffffffffffffffff); + let mut x464: u64 = 0; + let mut x465: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x464, &mut x465, x463, x451, 0xffffffffffffffff); + let mut x466: u64 = 0; + let mut x467: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x466, &mut x467, x465, x453, (0x0 as u64)); + let mut x468: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x468, x467, x454, x441); + let mut x469: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x469, x467, x456, x443); + let mut x470: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x470, x467, x458, x445); + let mut x471: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x471, x467, x460, x447); + let mut x472: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x472, x467, x462, x449); + let mut x473: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x473, x467, x464, x451); + out1[0] = x468; + out1[1] = x469; + out1[2] = x470; + out1[3] = x471; + out1[4] = x472; + out1[5] = x473; +} + +/// The function fiat_p384_scalar_square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_square(out1: &mut fiat_p384_scalar_montgomery_domain_field_element, arg1: &fiat_p384_scalar_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[1]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[4]); + let x5: u64 = (arg1[5]); + let x6: u64 = (arg1[0]); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x7, &mut x8, x6, (arg1[5])); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x9, &mut x10, x6, (arg1[4])); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x11, &mut x12, x6, (arg1[3])); + let mut x13: u64 = 0; + let mut x14: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x13, &mut x14, x6, (arg1[2])); + let mut x15: u64 = 0; + let mut x16: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x15, &mut x16, x6, (arg1[1])); + let mut x17: u64 = 0; + let mut x18: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x17, &mut x18, x6, (arg1[0])); + let mut x19: u64 = 0; + let mut x20: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x19, &mut x20, 0x0, x18, x15); + let mut x21: u64 = 0; + let mut x22: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x21, &mut x22, x20, x16, x13); + let mut x23: u64 = 0; + let mut x24: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x23, &mut x24, x22, x14, x11); + let mut x25: u64 = 0; + let mut x26: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x25, &mut x26, x24, x12, x9); + let mut x27: u64 = 0; + let mut x28: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x27, &mut x28, x26, x10, x7); + let x29: u64 = ((x28 as u64) + x8); + let mut x30: u64 = 0; + let mut x31: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x30, &mut x31, x17, 0x6ed46089e88fdc45); + let mut x32: u64 = 0; + let mut x33: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x32, &mut x33, x30, 0xffffffffffffffff); + let mut x34: u64 = 0; + let mut x35: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x34, &mut x35, x30, 0xffffffffffffffff); + let mut x36: u64 = 0; + let mut x37: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x36, &mut x37, x30, 0xffffffffffffffff); + let mut x38: u64 = 0; + let mut x39: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x38, &mut x39, x30, 0xc7634d81f4372ddf); + let mut x40: u64 = 0; + let mut x41: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x40, &mut x41, x30, 0x581a0db248b0a77a); + let mut x42: u64 = 0; + let mut x43: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x42, &mut x43, x30, 0xecec196accc52973); + let mut x44: u64 = 0; + let mut x45: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x44, &mut x45, 0x0, x43, x40); + let mut x46: u64 = 0; + let mut x47: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x46, &mut x47, x45, x41, x38); + let mut x48: u64 = 0; + let mut x49: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x48, &mut x49, x47, x39, x36); + let mut x50: u64 = 0; + let mut x51: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x50, &mut x51, x49, x37, x34); + let mut x52: u64 = 0; + let mut x53: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x52, &mut x53, x51, x35, x32); + let x54: u64 = ((x53 as u64) + x33); + let mut x55: u64 = 0; + let mut x56: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x55, &mut x56, 0x0, x17, x42); + let mut x57: u64 = 0; + let mut x58: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x57, &mut x58, x56, x19, x44); + let mut x59: u64 = 0; + let mut x60: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x59, &mut x60, x58, x21, x46); + let mut x61: u64 = 0; + let mut x62: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x61, &mut x62, x60, x23, x48); + let mut x63: u64 = 0; + let mut x64: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x63, &mut x64, x62, x25, x50); + let mut x65: u64 = 0; + let mut x66: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x65, &mut x66, x64, x27, x52); + let mut x67: u64 = 0; + let mut x68: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x67, &mut x68, x66, x29, x54); + let mut x69: u64 = 0; + let mut x70: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x69, &mut x70, x1, (arg1[5])); + let mut x71: u64 = 0; + let mut x72: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x71, &mut x72, x1, (arg1[4])); + let mut x73: u64 = 0; + let mut x74: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x73, &mut x74, x1, (arg1[3])); + let mut x75: u64 = 0; + let mut x76: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x75, &mut x76, x1, (arg1[2])); + let mut x77: u64 = 0; + let mut x78: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x77, &mut x78, x1, (arg1[1])); + let mut x79: u64 = 0; + let mut x80: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x79, &mut x80, x1, (arg1[0])); + let mut x81: u64 = 0; + let mut x82: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x81, &mut x82, 0x0, x80, x77); + let mut x83: u64 = 0; + let mut x84: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x83, &mut x84, x82, x78, x75); + let mut x85: u64 = 0; + let mut x86: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x85, &mut x86, x84, x76, x73); + let mut x87: u64 = 0; + let mut x88: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x87, &mut x88, x86, x74, x71); + let mut x89: u64 = 0; + let mut x90: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x89, &mut x90, x88, x72, x69); + let x91: u64 = ((x90 as u64) + x70); + let mut x92: u64 = 0; + let mut x93: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x92, &mut x93, 0x0, x57, x79); + let mut x94: u64 = 0; + let mut x95: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x94, &mut x95, x93, x59, x81); + let mut x96: u64 = 0; + let mut x97: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x96, &mut x97, x95, x61, x83); + let mut x98: u64 = 0; + let mut x99: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x98, &mut x99, x97, x63, x85); + let mut x100: u64 = 0; + let mut x101: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x100, &mut x101, x99, x65, x87); + let mut x102: u64 = 0; + let mut x103: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x102, &mut x103, x101, x67, x89); + let mut x104: u64 = 0; + let mut x105: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x104, &mut x105, x103, (x68 as u64), x91); + let mut x106: u64 = 0; + let mut x107: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x106, &mut x107, x92, 0x6ed46089e88fdc45); + let mut x108: u64 = 0; + let mut x109: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x108, &mut x109, x106, 0xffffffffffffffff); + let mut x110: u64 = 0; + let mut x111: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x110, &mut x111, x106, 0xffffffffffffffff); + let mut x112: u64 = 0; + let mut x113: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x112, &mut x113, x106, 0xffffffffffffffff); + let mut x114: u64 = 0; + let mut x115: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x114, &mut x115, x106, 0xc7634d81f4372ddf); + let mut x116: u64 = 0; + let mut x117: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x116, &mut x117, x106, 0x581a0db248b0a77a); + let mut x118: u64 = 0; + let mut x119: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x118, &mut x119, x106, 0xecec196accc52973); + let mut x120: u64 = 0; + let mut x121: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x120, &mut x121, 0x0, x119, x116); + let mut x122: u64 = 0; + let mut x123: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x122, &mut x123, x121, x117, x114); + let mut x124: u64 = 0; + let mut x125: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x124, &mut x125, x123, x115, x112); + let mut x126: u64 = 0; + let mut x127: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x126, &mut x127, x125, x113, x110); + let mut x128: u64 = 0; + let mut x129: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x128, &mut x129, x127, x111, x108); + let x130: u64 = ((x129 as u64) + x109); + let mut x131: u64 = 0; + let mut x132: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x131, &mut x132, 0x0, x92, x118); + let mut x133: u64 = 0; + let mut x134: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x133, &mut x134, x132, x94, x120); + let mut x135: u64 = 0; + let mut x136: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x135, &mut x136, x134, x96, x122); + let mut x137: u64 = 0; + let mut x138: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x137, &mut x138, x136, x98, x124); + let mut x139: u64 = 0; + let mut x140: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x139, &mut x140, x138, x100, x126); + let mut x141: u64 = 0; + let mut x142: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x141, &mut x142, x140, x102, x128); + let mut x143: u64 = 0; + let mut x144: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x143, &mut x144, x142, x104, x130); + let x145: u64 = ((x144 as u64) + (x105 as u64)); + let mut x146: u64 = 0; + let mut x147: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x146, &mut x147, x2, (arg1[5])); + let mut x148: u64 = 0; + let mut x149: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x148, &mut x149, x2, (arg1[4])); + let mut x150: u64 = 0; + let mut x151: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x150, &mut x151, x2, (arg1[3])); + let mut x152: u64 = 0; + let mut x153: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x152, &mut x153, x2, (arg1[2])); + let mut x154: u64 = 0; + let mut x155: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x154, &mut x155, x2, (arg1[1])); + let mut x156: u64 = 0; + let mut x157: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x156, &mut x157, x2, (arg1[0])); + let mut x158: u64 = 0; + let mut x159: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x158, &mut x159, 0x0, x157, x154); + let mut x160: u64 = 0; + let mut x161: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x160, &mut x161, x159, x155, x152); + let mut x162: u64 = 0; + let mut x163: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x162, &mut x163, x161, x153, x150); + let mut x164: u64 = 0; + let mut x165: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x164, &mut x165, x163, x151, x148); + let mut x166: u64 = 0; + let mut x167: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x166, &mut x167, x165, x149, x146); + let x168: u64 = ((x167 as u64) + x147); + let mut x169: u64 = 0; + let mut x170: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x169, &mut x170, 0x0, x133, x156); + let mut x171: u64 = 0; + let mut x172: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x171, &mut x172, x170, x135, x158); + let mut x173: u64 = 0; + let mut x174: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x173, &mut x174, x172, x137, x160); + let mut x175: u64 = 0; + let mut x176: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x175, &mut x176, x174, x139, x162); + let mut x177: u64 = 0; + let mut x178: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x177, &mut x178, x176, x141, x164); + let mut x179: u64 = 0; + let mut x180: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x179, &mut x180, x178, x143, x166); + let mut x181: u64 = 0; + let mut x182: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x181, &mut x182, x180, x145, x168); + let mut x183: u64 = 0; + let mut x184: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x183, &mut x184, x169, 0x6ed46089e88fdc45); + let mut x185: u64 = 0; + let mut x186: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x185, &mut x186, x183, 0xffffffffffffffff); + let mut x187: u64 = 0; + let mut x188: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x187, &mut x188, x183, 0xffffffffffffffff); + let mut x189: u64 = 0; + let mut x190: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x189, &mut x190, x183, 0xffffffffffffffff); + let mut x191: u64 = 0; + let mut x192: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x191, &mut x192, x183, 0xc7634d81f4372ddf); + let mut x193: u64 = 0; + let mut x194: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x193, &mut x194, x183, 0x581a0db248b0a77a); + let mut x195: u64 = 0; + let mut x196: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x195, &mut x196, x183, 0xecec196accc52973); + let mut x197: u64 = 0; + let mut x198: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x197, &mut x198, 0x0, x196, x193); + let mut x199: u64 = 0; + let mut x200: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x199, &mut x200, x198, x194, x191); + let mut x201: u64 = 0; + let mut x202: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x201, &mut x202, x200, x192, x189); + let mut x203: u64 = 0; + let mut x204: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x203, &mut x204, x202, x190, x187); + let mut x205: u64 = 0; + let mut x206: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x205, &mut x206, x204, x188, x185); + let x207: u64 = ((x206 as u64) + x186); + let mut x208: u64 = 0; + let mut x209: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x208, &mut x209, 0x0, x169, x195); + let mut x210: u64 = 0; + let mut x211: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x210, &mut x211, x209, x171, x197); + let mut x212: u64 = 0; + let mut x213: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x212, &mut x213, x211, x173, x199); + let mut x214: u64 = 0; + let mut x215: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x214, &mut x215, x213, x175, x201); + let mut x216: u64 = 0; + let mut x217: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x216, &mut x217, x215, x177, x203); + let mut x218: u64 = 0; + let mut x219: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x218, &mut x219, x217, x179, x205); + let mut x220: u64 = 0; + let mut x221: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x220, &mut x221, x219, x181, x207); + let x222: u64 = ((x221 as u64) + (x182 as u64)); + let mut x223: u64 = 0; + let mut x224: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x223, &mut x224, x3, (arg1[5])); + let mut x225: u64 = 0; + let mut x226: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x225, &mut x226, x3, (arg1[4])); + let mut x227: u64 = 0; + let mut x228: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x227, &mut x228, x3, (arg1[3])); + let mut x229: u64 = 0; + let mut x230: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x229, &mut x230, x3, (arg1[2])); + let mut x231: u64 = 0; + let mut x232: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x231, &mut x232, x3, (arg1[1])); + let mut x233: u64 = 0; + let mut x234: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x233, &mut x234, x3, (arg1[0])); + let mut x235: u64 = 0; + let mut x236: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x235, &mut x236, 0x0, x234, x231); + let mut x237: u64 = 0; + let mut x238: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x237, &mut x238, x236, x232, x229); + let mut x239: u64 = 0; + let mut x240: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x239, &mut x240, x238, x230, x227); + let mut x241: u64 = 0; + let mut x242: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x241, &mut x242, x240, x228, x225); + let mut x243: u64 = 0; + let mut x244: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x243, &mut x244, x242, x226, x223); + let x245: u64 = ((x244 as u64) + x224); + let mut x246: u64 = 0; + let mut x247: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x246, &mut x247, 0x0, x210, x233); + let mut x248: u64 = 0; + let mut x249: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x248, &mut x249, x247, x212, x235); + let mut x250: u64 = 0; + let mut x251: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x250, &mut x251, x249, x214, x237); + let mut x252: u64 = 0; + let mut x253: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x252, &mut x253, x251, x216, x239); + let mut x254: u64 = 0; + let mut x255: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x254, &mut x255, x253, x218, x241); + let mut x256: u64 = 0; + let mut x257: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x256, &mut x257, x255, x220, x243); + let mut x258: u64 = 0; + let mut x259: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x258, &mut x259, x257, x222, x245); + let mut x260: u64 = 0; + let mut x261: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x260, &mut x261, x246, 0x6ed46089e88fdc45); + let mut x262: u64 = 0; + let mut x263: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x262, &mut x263, x260, 0xffffffffffffffff); + let mut x264: u64 = 0; + let mut x265: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x264, &mut x265, x260, 0xffffffffffffffff); + let mut x266: u64 = 0; + let mut x267: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x266, &mut x267, x260, 0xffffffffffffffff); + let mut x268: u64 = 0; + let mut x269: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x268, &mut x269, x260, 0xc7634d81f4372ddf); + let mut x270: u64 = 0; + let mut x271: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x270, &mut x271, x260, 0x581a0db248b0a77a); + let mut x272: u64 = 0; + let mut x273: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x272, &mut x273, x260, 0xecec196accc52973); + let mut x274: u64 = 0; + let mut x275: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x274, &mut x275, 0x0, x273, x270); + let mut x276: u64 = 0; + let mut x277: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x276, &mut x277, x275, x271, x268); + let mut x278: u64 = 0; + let mut x279: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x278, &mut x279, x277, x269, x266); + let mut x280: u64 = 0; + let mut x281: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x280, &mut x281, x279, x267, x264); + let mut x282: u64 = 0; + let mut x283: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x282, &mut x283, x281, x265, x262); + let x284: u64 = ((x283 as u64) + x263); + let mut x285: u64 = 0; + let mut x286: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x285, &mut x286, 0x0, x246, x272); + let mut x287: u64 = 0; + let mut x288: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x287, &mut x288, x286, x248, x274); + let mut x289: u64 = 0; + let mut x290: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x289, &mut x290, x288, x250, x276); + let mut x291: u64 = 0; + let mut x292: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x291, &mut x292, x290, x252, x278); + let mut x293: u64 = 0; + let mut x294: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x293, &mut x294, x292, x254, x280); + let mut x295: u64 = 0; + let mut x296: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x295, &mut x296, x294, x256, x282); + let mut x297: u64 = 0; + let mut x298: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x297, &mut x298, x296, x258, x284); + let x299: u64 = ((x298 as u64) + (x259 as u64)); + let mut x300: u64 = 0; + let mut x301: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x300, &mut x301, x4, (arg1[5])); + let mut x302: u64 = 0; + let mut x303: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x302, &mut x303, x4, (arg1[4])); + let mut x304: u64 = 0; + let mut x305: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x304, &mut x305, x4, (arg1[3])); + let mut x306: u64 = 0; + let mut x307: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x306, &mut x307, x4, (arg1[2])); + let mut x308: u64 = 0; + let mut x309: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x308, &mut x309, x4, (arg1[1])); + let mut x310: u64 = 0; + let mut x311: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x310, &mut x311, x4, (arg1[0])); + let mut x312: u64 = 0; + let mut x313: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x312, &mut x313, 0x0, x311, x308); + let mut x314: u64 = 0; + let mut x315: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x314, &mut x315, x313, x309, x306); + let mut x316: u64 = 0; + let mut x317: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x316, &mut x317, x315, x307, x304); + let mut x318: u64 = 0; + let mut x319: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x318, &mut x319, x317, x305, x302); + let mut x320: u64 = 0; + let mut x321: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x320, &mut x321, x319, x303, x300); + let x322: u64 = ((x321 as u64) + x301); + let mut x323: u64 = 0; + let mut x324: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x323, &mut x324, 0x0, x287, x310); + let mut x325: u64 = 0; + let mut x326: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x325, &mut x326, x324, x289, x312); + let mut x327: u64 = 0; + let mut x328: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x327, &mut x328, x326, x291, x314); + let mut x329: u64 = 0; + let mut x330: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x329, &mut x330, x328, x293, x316); + let mut x331: u64 = 0; + let mut x332: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x331, &mut x332, x330, x295, x318); + let mut x333: u64 = 0; + let mut x334: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x333, &mut x334, x332, x297, x320); + let mut x335: u64 = 0; + let mut x336: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x335, &mut x336, x334, x299, x322); + let mut x337: u64 = 0; + let mut x338: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x337, &mut x338, x323, 0x6ed46089e88fdc45); + let mut x339: u64 = 0; + let mut x340: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x339, &mut x340, x337, 0xffffffffffffffff); + let mut x341: u64 = 0; + let mut x342: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x341, &mut x342, x337, 0xffffffffffffffff); + let mut x343: u64 = 0; + let mut x344: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x343, &mut x344, x337, 0xffffffffffffffff); + let mut x345: u64 = 0; + let mut x346: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x345, &mut x346, x337, 0xc7634d81f4372ddf); + let mut x347: u64 = 0; + let mut x348: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x347, &mut x348, x337, 0x581a0db248b0a77a); + let mut x349: u64 = 0; + let mut x350: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x349, &mut x350, x337, 0xecec196accc52973); + let mut x351: u64 = 0; + let mut x352: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x351, &mut x352, 0x0, x350, x347); + let mut x353: u64 = 0; + let mut x354: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x353, &mut x354, x352, x348, x345); + let mut x355: u64 = 0; + let mut x356: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x355, &mut x356, x354, x346, x343); + let mut x357: u64 = 0; + let mut x358: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x357, &mut x358, x356, x344, x341); + let mut x359: u64 = 0; + let mut x360: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x359, &mut x360, x358, x342, x339); + let x361: u64 = ((x360 as u64) + x340); + let mut x362: u64 = 0; + let mut x363: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x362, &mut x363, 0x0, x323, x349); + let mut x364: u64 = 0; + let mut x365: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x364, &mut x365, x363, x325, x351); + let mut x366: u64 = 0; + let mut x367: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x366, &mut x367, x365, x327, x353); + let mut x368: u64 = 0; + let mut x369: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x368, &mut x369, x367, x329, x355); + let mut x370: u64 = 0; + let mut x371: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x370, &mut x371, x369, x331, x357); + let mut x372: u64 = 0; + let mut x373: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x372, &mut x373, x371, x333, x359); + let mut x374: u64 = 0; + let mut x375: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x374, &mut x375, x373, x335, x361); + let x376: u64 = ((x375 as u64) + (x336 as u64)); + let mut x377: u64 = 0; + let mut x378: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x377, &mut x378, x5, (arg1[5])); + let mut x379: u64 = 0; + let mut x380: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x379, &mut x380, x5, (arg1[4])); + let mut x381: u64 = 0; + let mut x382: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x381, &mut x382, x5, (arg1[3])); + let mut x383: u64 = 0; + let mut x384: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x383, &mut x384, x5, (arg1[2])); + let mut x385: u64 = 0; + let mut x386: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x385, &mut x386, x5, (arg1[1])); + let mut x387: u64 = 0; + let mut x388: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x387, &mut x388, x5, (arg1[0])); + let mut x389: u64 = 0; + let mut x390: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x389, &mut x390, 0x0, x388, x385); + let mut x391: u64 = 0; + let mut x392: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x391, &mut x392, x390, x386, x383); + let mut x393: u64 = 0; + let mut x394: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x393, &mut x394, x392, x384, x381); + let mut x395: u64 = 0; + let mut x396: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x395, &mut x396, x394, x382, x379); + let mut x397: u64 = 0; + let mut x398: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x397, &mut x398, x396, x380, x377); + let x399: u64 = ((x398 as u64) + x378); + let mut x400: u64 = 0; + let mut x401: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x400, &mut x401, 0x0, x364, x387); + let mut x402: u64 = 0; + let mut x403: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x402, &mut x403, x401, x366, x389); + let mut x404: u64 = 0; + let mut x405: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x404, &mut x405, x403, x368, x391); + let mut x406: u64 = 0; + let mut x407: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x406, &mut x407, x405, x370, x393); + let mut x408: u64 = 0; + let mut x409: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x408, &mut x409, x407, x372, x395); + let mut x410: u64 = 0; + let mut x411: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x410, &mut x411, x409, x374, x397); + let mut x412: u64 = 0; + let mut x413: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x412, &mut x413, x411, x376, x399); + let mut x414: u64 = 0; + let mut x415: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x414, &mut x415, x400, 0x6ed46089e88fdc45); + let mut x416: u64 = 0; + let mut x417: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x416, &mut x417, x414, 0xffffffffffffffff); + let mut x418: u64 = 0; + let mut x419: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x418, &mut x419, x414, 0xffffffffffffffff); + let mut x420: u64 = 0; + let mut x421: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x420, &mut x421, x414, 0xffffffffffffffff); + let mut x422: u64 = 0; + let mut x423: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x422, &mut x423, x414, 0xc7634d81f4372ddf); + let mut x424: u64 = 0; + let mut x425: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x424, &mut x425, x414, 0x581a0db248b0a77a); + let mut x426: u64 = 0; + let mut x427: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x426, &mut x427, x414, 0xecec196accc52973); + let mut x428: u64 = 0; + let mut x429: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x428, &mut x429, 0x0, x427, x424); + let mut x430: u64 = 0; + let mut x431: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x430, &mut x431, x429, x425, x422); + let mut x432: u64 = 0; + let mut x433: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x432, &mut x433, x431, x423, x420); + let mut x434: u64 = 0; + let mut x435: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x434, &mut x435, x433, x421, x418); + let mut x436: u64 = 0; + let mut x437: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x436, &mut x437, x435, x419, x416); + let x438: u64 = ((x437 as u64) + x417); + let mut x439: u64 = 0; + let mut x440: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x439, &mut x440, 0x0, x400, x426); + let mut x441: u64 = 0; + let mut x442: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x441, &mut x442, x440, x402, x428); + let mut x443: u64 = 0; + let mut x444: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x443, &mut x444, x442, x404, x430); + let mut x445: u64 = 0; + let mut x446: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x445, &mut x446, x444, x406, x432); + let mut x447: u64 = 0; + let mut x448: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x447, &mut x448, x446, x408, x434); + let mut x449: u64 = 0; + let mut x450: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x449, &mut x450, x448, x410, x436); + let mut x451: u64 = 0; + let mut x452: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x451, &mut x452, x450, x412, x438); + let x453: u64 = ((x452 as u64) + (x413 as u64)); + let mut x454: u64 = 0; + let mut x455: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x454, &mut x455, 0x0, x441, 0xecec196accc52973); + let mut x456: u64 = 0; + let mut x457: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x456, &mut x457, x455, x443, 0x581a0db248b0a77a); + let mut x458: u64 = 0; + let mut x459: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x458, &mut x459, x457, x445, 0xc7634d81f4372ddf); + let mut x460: u64 = 0; + let mut x461: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x460, &mut x461, x459, x447, 0xffffffffffffffff); + let mut x462: u64 = 0; + let mut x463: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x462, &mut x463, x461, x449, 0xffffffffffffffff); + let mut x464: u64 = 0; + let mut x465: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x464, &mut x465, x463, x451, 0xffffffffffffffff); + let mut x466: u64 = 0; + let mut x467: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x466, &mut x467, x465, x453, (0x0 as u64)); + let mut x468: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x468, x467, x454, x441); + let mut x469: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x469, x467, x456, x443); + let mut x470: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x470, x467, x458, x445); + let mut x471: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x471, x467, x460, x447); + let mut x472: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x472, x467, x462, x449); + let mut x473: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x473, x467, x464, x451); + out1[0] = x468; + out1[1] = x469; + out1[2] = x470; + out1[3] = x471; + out1[4] = x472; + out1[5] = x473; +} + +/// The function fiat_p384_scalar_add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_add(out1: &mut fiat_p384_scalar_montgomery_domain_field_element, arg1: &fiat_p384_scalar_montgomery_domain_field_element, arg2: &fiat_p384_scalar_montgomery_domain_field_element) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u64 = 0; + let mut x4: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u64 = 0; + let mut x6: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u64 = 0; + let mut x8: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u64 = 0; + let mut x10: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u64 = 0; + let mut x12: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u64 = 0; + let mut x14: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x13, &mut x14, 0x0, x1, 0xecec196accc52973); + let mut x15: u64 = 0; + let mut x16: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x15, &mut x16, x14, x3, 0x581a0db248b0a77a); + let mut x17: u64 = 0; + let mut x18: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x17, &mut x18, x16, x5, 0xc7634d81f4372ddf); + let mut x19: u64 = 0; + let mut x20: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x19, &mut x20, x18, x7, 0xffffffffffffffff); + let mut x21: u64 = 0; + let mut x22: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x21, &mut x22, x20, x9, 0xffffffffffffffff); + let mut x23: u64 = 0; + let mut x24: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x23, &mut x24, x22, x11, 0xffffffffffffffff); + let mut x25: u64 = 0; + let mut x26: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x25, &mut x26, x24, (x12 as u64), (0x0 as u64)); + let mut x27: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x27, x26, x13, x1); + let mut x28: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x28, x26, x15, x3); + let mut x29: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x29, x26, x17, x5); + let mut x30: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x30, x26, x19, x7); + let mut x31: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x31, x26, x21, x9); + let mut x32: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x32, x26, x23, x11); + out1[0] = x27; + out1[1] = x28; + out1[2] = x29; + out1[3] = x30; + out1[4] = x31; + out1[5] = x32; +} + +/// The function fiat_p384_scalar_sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_sub(out1: &mut fiat_p384_scalar_montgomery_domain_field_element, arg1: &fiat_p384_scalar_montgomery_domain_field_element, arg2: &fiat_p384_scalar_montgomery_domain_field_element) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u64 = 0; + let mut x4: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u64 = 0; + let mut x6: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u64 = 0; + let mut x8: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u64 = 0; + let mut x10: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u64 = 0; + let mut x12: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x13, x12, (0x0 as u64), 0xffffffffffffffff); + let mut x14: u64 = 0; + let mut x15: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x14, &mut x15, 0x0, x1, (x13 & 0xecec196accc52973)); + let mut x16: u64 = 0; + let mut x17: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x3, (x13 & 0x581a0db248b0a77a)); + let mut x18: u64 = 0; + let mut x19: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x18, &mut x19, x17, x5, (x13 & 0xc7634d81f4372ddf)); + let mut x20: u64 = 0; + let mut x21: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x20, &mut x21, x19, x7, x13); + let mut x22: u64 = 0; + let mut x23: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x22, &mut x23, x21, x9, x13); + let mut x24: u64 = 0; + let mut x25: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x24, &mut x25, x23, x11, x13); + out1[0] = x14; + out1[1] = x16; + out1[2] = x18; + out1[3] = x20; + out1[4] = x22; + out1[5] = x24; +} + +/// The function fiat_p384_scalar_opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_opp(out1: &mut fiat_p384_scalar_montgomery_domain_field_element, arg1: &fiat_p384_scalar_montgomery_domain_field_element) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x1, &mut x2, 0x0, (0x0 as u64), (arg1[0])); + let mut x3: u64 = 0; + let mut x4: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x3, &mut x4, x2, (0x0 as u64), (arg1[1])); + let mut x5: u64 = 0; + let mut x6: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x5, &mut x6, x4, (0x0 as u64), (arg1[2])); + let mut x7: u64 = 0; + let mut x8: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x7, &mut x8, x6, (0x0 as u64), (arg1[3])); + let mut x9: u64 = 0; + let mut x10: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x9, &mut x10, x8, (0x0 as u64), (arg1[4])); + let mut x11: u64 = 0; + let mut x12: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x11, &mut x12, x10, (0x0 as u64), (arg1[5])); + let mut x13: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x13, x12, (0x0 as u64), 0xffffffffffffffff); + let mut x14: u64 = 0; + let mut x15: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x14, &mut x15, 0x0, x1, (x13 & 0xecec196accc52973)); + let mut x16: u64 = 0; + let mut x17: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x3, (x13 & 0x581a0db248b0a77a)); + let mut x18: u64 = 0; + let mut x19: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x18, &mut x19, x17, x5, (x13 & 0xc7634d81f4372ddf)); + let mut x20: u64 = 0; + let mut x21: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x20, &mut x21, x19, x7, x13); + let mut x22: u64 = 0; + let mut x23: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x22, &mut x23, x21, x9, x13); + let mut x24: u64 = 0; + let mut x25: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x24, &mut x25, x23, x11, x13); + out1[0] = x14; + out1[1] = x16; + out1[2] = x18; + out1[3] = x20; + out1[4] = x22; + out1[5] = x24; +} + +/// The function fiat_p384_scalar_from_montgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^6) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_from_montgomery(out1: &mut fiat_p384_scalar_non_montgomery_domain_field_element, arg1: &fiat_p384_scalar_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[0]); + let mut x2: u64 = 0; + let mut x3: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x2, &mut x3, x1, 0x6ed46089e88fdc45); + let mut x4: u64 = 0; + let mut x5: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x4, &mut x5, x2, 0xffffffffffffffff); + let mut x6: u64 = 0; + let mut x7: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x6, &mut x7, x2, 0xffffffffffffffff); + let mut x8: u64 = 0; + let mut x9: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x8, &mut x9, x2, 0xffffffffffffffff); + let mut x10: u64 = 0; + let mut x11: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x10, &mut x11, x2, 0xc7634d81f4372ddf); + let mut x12: u64 = 0; + let mut x13: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x12, &mut x13, x2, 0x581a0db248b0a77a); + let mut x14: u64 = 0; + let mut x15: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x14, &mut x15, x2, 0xecec196accc52973); + let mut x16: u64 = 0; + let mut x17: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x16, &mut x17, 0x0, x15, x12); + let mut x18: u64 = 0; + let mut x19: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x18, &mut x19, x17, x13, x10); + let mut x20: u64 = 0; + let mut x21: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x20, &mut x21, x19, x11, x8); + let mut x22: u64 = 0; + let mut x23: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x22, &mut x23, x21, x9, x6); + let mut x24: u64 = 0; + let mut x25: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x24, &mut x25, x23, x7, x4); + let mut x26: u64 = 0; + let mut x27: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x26, &mut x27, 0x0, x1, x14); + let mut x28: u64 = 0; + let mut x29: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x28, &mut x29, x27, (0x0 as u64), x16); + let mut x30: u64 = 0; + let mut x31: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x30, &mut x31, x29, (0x0 as u64), x18); + let mut x32: u64 = 0; + let mut x33: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x32, &mut x33, x31, (0x0 as u64), x20); + let mut x34: u64 = 0; + let mut x35: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x34, &mut x35, x33, (0x0 as u64), x22); + let mut x36: u64 = 0; + let mut x37: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x36, &mut x37, x35, (0x0 as u64), x24); + let mut x38: u64 = 0; + let mut x39: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x38, &mut x39, x37, (0x0 as u64), ((x25 as u64) + x5)); + let mut x40: u64 = 0; + let mut x41: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x40, &mut x41, 0x0, x28, (arg1[1])); + let mut x42: u64 = 0; + let mut x43: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x42, &mut x43, x41, x30, (0x0 as u64)); + let mut x44: u64 = 0; + let mut x45: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x44, &mut x45, x43, x32, (0x0 as u64)); + let mut x46: u64 = 0; + let mut x47: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x46, &mut x47, x45, x34, (0x0 as u64)); + let mut x48: u64 = 0; + let mut x49: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x48, &mut x49, x47, x36, (0x0 as u64)); + let mut x50: u64 = 0; + let mut x51: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x50, &mut x51, x49, x38, (0x0 as u64)); + let mut x52: u64 = 0; + let mut x53: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x52, &mut x53, x40, 0x6ed46089e88fdc45); + let mut x54: u64 = 0; + let mut x55: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x54, &mut x55, x52, 0xffffffffffffffff); + let mut x56: u64 = 0; + let mut x57: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x56, &mut x57, x52, 0xffffffffffffffff); + let mut x58: u64 = 0; + let mut x59: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x58, &mut x59, x52, 0xffffffffffffffff); + let mut x60: u64 = 0; + let mut x61: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x60, &mut x61, x52, 0xc7634d81f4372ddf); + let mut x62: u64 = 0; + let mut x63: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x62, &mut x63, x52, 0x581a0db248b0a77a); + let mut x64: u64 = 0; + let mut x65: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x64, &mut x65, x52, 0xecec196accc52973); + let mut x66: u64 = 0; + let mut x67: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x66, &mut x67, 0x0, x65, x62); + let mut x68: u64 = 0; + let mut x69: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x68, &mut x69, x67, x63, x60); + let mut x70: u64 = 0; + let mut x71: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x70, &mut x71, x69, x61, x58); + let mut x72: u64 = 0; + let mut x73: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x72, &mut x73, x71, x59, x56); + let mut x74: u64 = 0; + let mut x75: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x74, &mut x75, x73, x57, x54); + let mut x76: u64 = 0; + let mut x77: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x76, &mut x77, 0x0, x40, x64); + let mut x78: u64 = 0; + let mut x79: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x78, &mut x79, x77, x42, x66); + let mut x80: u64 = 0; + let mut x81: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x80, &mut x81, x79, x44, x68); + let mut x82: u64 = 0; + let mut x83: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x82, &mut x83, x81, x46, x70); + let mut x84: u64 = 0; + let mut x85: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x84, &mut x85, x83, x48, x72); + let mut x86: u64 = 0; + let mut x87: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x86, &mut x87, x85, x50, x74); + let mut x88: u64 = 0; + let mut x89: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x88, &mut x89, x87, ((x51 as u64) + (x39 as u64)), ((x75 as u64) + x55)); + let mut x90: u64 = 0; + let mut x91: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x90, &mut x91, 0x0, x78, (arg1[2])); + let mut x92: u64 = 0; + let mut x93: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x92, &mut x93, x91, x80, (0x0 as u64)); + let mut x94: u64 = 0; + let mut x95: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x94, &mut x95, x93, x82, (0x0 as u64)); + let mut x96: u64 = 0; + let mut x97: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x96, &mut x97, x95, x84, (0x0 as u64)); + let mut x98: u64 = 0; + let mut x99: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x98, &mut x99, x97, x86, (0x0 as u64)); + let mut x100: u64 = 0; + let mut x101: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x100, &mut x101, x99, x88, (0x0 as u64)); + let mut x102: u64 = 0; + let mut x103: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x102, &mut x103, x90, 0x6ed46089e88fdc45); + let mut x104: u64 = 0; + let mut x105: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x104, &mut x105, x102, 0xffffffffffffffff); + let mut x106: u64 = 0; + let mut x107: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x106, &mut x107, x102, 0xffffffffffffffff); + let mut x108: u64 = 0; + let mut x109: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x108, &mut x109, x102, 0xffffffffffffffff); + let mut x110: u64 = 0; + let mut x111: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x110, &mut x111, x102, 0xc7634d81f4372ddf); + let mut x112: u64 = 0; + let mut x113: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x112, &mut x113, x102, 0x581a0db248b0a77a); + let mut x114: u64 = 0; + let mut x115: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x114, &mut x115, x102, 0xecec196accc52973); + let mut x116: u64 = 0; + let mut x117: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x116, &mut x117, 0x0, x115, x112); + let mut x118: u64 = 0; + let mut x119: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x118, &mut x119, x117, x113, x110); + let mut x120: u64 = 0; + let mut x121: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x120, &mut x121, x119, x111, x108); + let mut x122: u64 = 0; + let mut x123: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x122, &mut x123, x121, x109, x106); + let mut x124: u64 = 0; + let mut x125: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x124, &mut x125, x123, x107, x104); + let mut x126: u64 = 0; + let mut x127: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x126, &mut x127, 0x0, x90, x114); + let mut x128: u64 = 0; + let mut x129: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x128, &mut x129, x127, x92, x116); + let mut x130: u64 = 0; + let mut x131: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x130, &mut x131, x129, x94, x118); + let mut x132: u64 = 0; + let mut x133: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x132, &mut x133, x131, x96, x120); + let mut x134: u64 = 0; + let mut x135: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x134, &mut x135, x133, x98, x122); + let mut x136: u64 = 0; + let mut x137: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x136, &mut x137, x135, x100, x124); + let mut x138: u64 = 0; + let mut x139: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x138, &mut x139, x137, ((x101 as u64) + (x89 as u64)), ((x125 as u64) + x105)); + let mut x140: u64 = 0; + let mut x141: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x140, &mut x141, 0x0, x128, (arg1[3])); + let mut x142: u64 = 0; + let mut x143: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x142, &mut x143, x141, x130, (0x0 as u64)); + let mut x144: u64 = 0; + let mut x145: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x144, &mut x145, x143, x132, (0x0 as u64)); + let mut x146: u64 = 0; + let mut x147: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x146, &mut x147, x145, x134, (0x0 as u64)); + let mut x148: u64 = 0; + let mut x149: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x148, &mut x149, x147, x136, (0x0 as u64)); + let mut x150: u64 = 0; + let mut x151: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x150, &mut x151, x149, x138, (0x0 as u64)); + let mut x152: u64 = 0; + let mut x153: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x152, &mut x153, x140, 0x6ed46089e88fdc45); + let mut x154: u64 = 0; + let mut x155: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x154, &mut x155, x152, 0xffffffffffffffff); + let mut x156: u64 = 0; + let mut x157: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x156, &mut x157, x152, 0xffffffffffffffff); + let mut x158: u64 = 0; + let mut x159: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x158, &mut x159, x152, 0xffffffffffffffff); + let mut x160: u64 = 0; + let mut x161: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x160, &mut x161, x152, 0xc7634d81f4372ddf); + let mut x162: u64 = 0; + let mut x163: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x162, &mut x163, x152, 0x581a0db248b0a77a); + let mut x164: u64 = 0; + let mut x165: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x164, &mut x165, x152, 0xecec196accc52973); + let mut x166: u64 = 0; + let mut x167: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x166, &mut x167, 0x0, x165, x162); + let mut x168: u64 = 0; + let mut x169: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x168, &mut x169, x167, x163, x160); + let mut x170: u64 = 0; + let mut x171: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x170, &mut x171, x169, x161, x158); + let mut x172: u64 = 0; + let mut x173: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x172, &mut x173, x171, x159, x156); + let mut x174: u64 = 0; + let mut x175: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x174, &mut x175, x173, x157, x154); + let mut x176: u64 = 0; + let mut x177: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x176, &mut x177, 0x0, x140, x164); + let mut x178: u64 = 0; + let mut x179: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x178, &mut x179, x177, x142, x166); + let mut x180: u64 = 0; + let mut x181: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x180, &mut x181, x179, x144, x168); + let mut x182: u64 = 0; + let mut x183: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x182, &mut x183, x181, x146, x170); + let mut x184: u64 = 0; + let mut x185: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x184, &mut x185, x183, x148, x172); + let mut x186: u64 = 0; + let mut x187: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x186, &mut x187, x185, x150, x174); + let mut x188: u64 = 0; + let mut x189: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x188, &mut x189, x187, ((x151 as u64) + (x139 as u64)), ((x175 as u64) + x155)); + let mut x190: u64 = 0; + let mut x191: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x190, &mut x191, 0x0, x178, (arg1[4])); + let mut x192: u64 = 0; + let mut x193: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x192, &mut x193, x191, x180, (0x0 as u64)); + let mut x194: u64 = 0; + let mut x195: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x194, &mut x195, x193, x182, (0x0 as u64)); + let mut x196: u64 = 0; + let mut x197: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x196, &mut x197, x195, x184, (0x0 as u64)); + let mut x198: u64 = 0; + let mut x199: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x198, &mut x199, x197, x186, (0x0 as u64)); + let mut x200: u64 = 0; + let mut x201: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x200, &mut x201, x199, x188, (0x0 as u64)); + let mut x202: u64 = 0; + let mut x203: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x202, &mut x203, x190, 0x6ed46089e88fdc45); + let mut x204: u64 = 0; + let mut x205: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x204, &mut x205, x202, 0xffffffffffffffff); + let mut x206: u64 = 0; + let mut x207: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x206, &mut x207, x202, 0xffffffffffffffff); + let mut x208: u64 = 0; + let mut x209: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x208, &mut x209, x202, 0xffffffffffffffff); + let mut x210: u64 = 0; + let mut x211: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x210, &mut x211, x202, 0xc7634d81f4372ddf); + let mut x212: u64 = 0; + let mut x213: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x212, &mut x213, x202, 0x581a0db248b0a77a); + let mut x214: u64 = 0; + let mut x215: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x214, &mut x215, x202, 0xecec196accc52973); + let mut x216: u64 = 0; + let mut x217: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x216, &mut x217, 0x0, x215, x212); + let mut x218: u64 = 0; + let mut x219: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x218, &mut x219, x217, x213, x210); + let mut x220: u64 = 0; + let mut x221: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x220, &mut x221, x219, x211, x208); + let mut x222: u64 = 0; + let mut x223: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x222, &mut x223, x221, x209, x206); + let mut x224: u64 = 0; + let mut x225: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x224, &mut x225, x223, x207, x204); + let mut x226: u64 = 0; + let mut x227: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x226, &mut x227, 0x0, x190, x214); + let mut x228: u64 = 0; + let mut x229: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x228, &mut x229, x227, x192, x216); + let mut x230: u64 = 0; + let mut x231: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x230, &mut x231, x229, x194, x218); + let mut x232: u64 = 0; + let mut x233: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x232, &mut x233, x231, x196, x220); + let mut x234: u64 = 0; + let mut x235: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x234, &mut x235, x233, x198, x222); + let mut x236: u64 = 0; + let mut x237: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x236, &mut x237, x235, x200, x224); + let mut x238: u64 = 0; + let mut x239: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x238, &mut x239, x237, ((x201 as u64) + (x189 as u64)), ((x225 as u64) + x205)); + let mut x240: u64 = 0; + let mut x241: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x240, &mut x241, 0x0, x228, (arg1[5])); + let mut x242: u64 = 0; + let mut x243: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x242, &mut x243, x241, x230, (0x0 as u64)); + let mut x244: u64 = 0; + let mut x245: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x244, &mut x245, x243, x232, (0x0 as u64)); + let mut x246: u64 = 0; + let mut x247: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x246, &mut x247, x245, x234, (0x0 as u64)); + let mut x248: u64 = 0; + let mut x249: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x248, &mut x249, x247, x236, (0x0 as u64)); + let mut x250: u64 = 0; + let mut x251: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x250, &mut x251, x249, x238, (0x0 as u64)); + let mut x252: u64 = 0; + let mut x253: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x252, &mut x253, x240, 0x6ed46089e88fdc45); + let mut x254: u64 = 0; + let mut x255: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x254, &mut x255, x252, 0xffffffffffffffff); + let mut x256: u64 = 0; + let mut x257: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x256, &mut x257, x252, 0xffffffffffffffff); + let mut x258: u64 = 0; + let mut x259: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x258, &mut x259, x252, 0xffffffffffffffff); + let mut x260: u64 = 0; + let mut x261: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x260, &mut x261, x252, 0xc7634d81f4372ddf); + let mut x262: u64 = 0; + let mut x263: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x262, &mut x263, x252, 0x581a0db248b0a77a); + let mut x264: u64 = 0; + let mut x265: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x264, &mut x265, x252, 0xecec196accc52973); + let mut x266: u64 = 0; + let mut x267: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x266, &mut x267, 0x0, x265, x262); + let mut x268: u64 = 0; + let mut x269: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x268, &mut x269, x267, x263, x260); + let mut x270: u64 = 0; + let mut x271: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x270, &mut x271, x269, x261, x258); + let mut x272: u64 = 0; + let mut x273: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x272, &mut x273, x271, x259, x256); + let mut x274: u64 = 0; + let mut x275: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x274, &mut x275, x273, x257, x254); + let mut x276: u64 = 0; + let mut x277: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x276, &mut x277, 0x0, x240, x264); + let mut x278: u64 = 0; + let mut x279: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x278, &mut x279, x277, x242, x266); + let mut x280: u64 = 0; + let mut x281: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x280, &mut x281, x279, x244, x268); + let mut x282: u64 = 0; + let mut x283: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x282, &mut x283, x281, x246, x270); + let mut x284: u64 = 0; + let mut x285: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x284, &mut x285, x283, x248, x272); + let mut x286: u64 = 0; + let mut x287: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x286, &mut x287, x285, x250, x274); + let mut x288: u64 = 0; + let mut x289: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x288, &mut x289, x287, ((x251 as u64) + (x239 as u64)), ((x275 as u64) + x255)); + let mut x290: u64 = 0; + let mut x291: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x290, &mut x291, 0x0, x278, 0xecec196accc52973); + let mut x292: u64 = 0; + let mut x293: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x292, &mut x293, x291, x280, 0x581a0db248b0a77a); + let mut x294: u64 = 0; + let mut x295: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x294, &mut x295, x293, x282, 0xc7634d81f4372ddf); + let mut x296: u64 = 0; + let mut x297: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x296, &mut x297, x295, x284, 0xffffffffffffffff); + let mut x298: u64 = 0; + let mut x299: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x298, &mut x299, x297, x286, 0xffffffffffffffff); + let mut x300: u64 = 0; + let mut x301: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x300, &mut x301, x299, x288, 0xffffffffffffffff); + let mut x302: u64 = 0; + let mut x303: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x302, &mut x303, x301, (x289 as u64), (0x0 as u64)); + let mut x304: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x304, x303, x290, x278); + let mut x305: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x305, x303, x292, x280); + let mut x306: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x306, x303, x294, x282); + let mut x307: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x307, x303, x296, x284); + let mut x308: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x308, x303, x298, x286); + let mut x309: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x309, x303, x300, x288); + out1[0] = x304; + out1[1] = x305; + out1[2] = x306; + out1[3] = x307; + out1[4] = x308; + out1[5] = x309; +} + +/// The function fiat_p384_scalar_to_montgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_to_montgomery(out1: &mut fiat_p384_scalar_montgomery_domain_field_element, arg1: &fiat_p384_scalar_non_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[1]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[4]); + let x5: u64 = (arg1[5]); + let x6: u64 = (arg1[0]); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x7, &mut x8, x6, 0xc84ee012b39bf21); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x9, &mut x10, x6, 0x3fb05b7a28266895); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x11, &mut x12, x6, 0xd40d49174aab1cc5); + let mut x13: u64 = 0; + let mut x14: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x13, &mut x14, x6, 0xbc3e483afcb82947); + let mut x15: u64 = 0; + let mut x16: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x15, &mut x16, x6, 0xff3d81e5df1aa419); + let mut x17: u64 = 0; + let mut x18: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x17, &mut x18, x6, 0x2d319b2419b409a9); + let mut x19: u64 = 0; + let mut x20: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x19, &mut x20, 0x0, x18, x15); + let mut x21: u64 = 0; + let mut x22: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x21, &mut x22, x20, x16, x13); + let mut x23: u64 = 0; + let mut x24: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x23, &mut x24, x22, x14, x11); + let mut x25: u64 = 0; + let mut x26: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x25, &mut x26, x24, x12, x9); + let mut x27: u64 = 0; + let mut x28: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x27, &mut x28, x26, x10, x7); + let mut x29: u64 = 0; + let mut x30: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x29, &mut x30, x17, 0x6ed46089e88fdc45); + let mut x31: u64 = 0; + let mut x32: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x31, &mut x32, x29, 0xffffffffffffffff); + let mut x33: u64 = 0; + let mut x34: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x33, &mut x34, x29, 0xffffffffffffffff); + let mut x35: u64 = 0; + let mut x36: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x35, &mut x36, x29, 0xffffffffffffffff); + let mut x37: u64 = 0; + let mut x38: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x37, &mut x38, x29, 0xc7634d81f4372ddf); + let mut x39: u64 = 0; + let mut x40: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x39, &mut x40, x29, 0x581a0db248b0a77a); + let mut x41: u64 = 0; + let mut x42: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x41, &mut x42, x29, 0xecec196accc52973); + let mut x43: u64 = 0; + let mut x44: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x43, &mut x44, 0x0, x42, x39); + let mut x45: u64 = 0; + let mut x46: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x45, &mut x46, x44, x40, x37); + let mut x47: u64 = 0; + let mut x48: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x47, &mut x48, x46, x38, x35); + let mut x49: u64 = 0; + let mut x50: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x49, &mut x50, x48, x36, x33); + let mut x51: u64 = 0; + let mut x52: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x51, &mut x52, x50, x34, x31); + let mut x53: u64 = 0; + let mut x54: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x53, &mut x54, 0x0, x17, x41); + let mut x55: u64 = 0; + let mut x56: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x55, &mut x56, x54, x19, x43); + let mut x57: u64 = 0; + let mut x58: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x57, &mut x58, x56, x21, x45); + let mut x59: u64 = 0; + let mut x60: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x59, &mut x60, x58, x23, x47); + let mut x61: u64 = 0; + let mut x62: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x61, &mut x62, x60, x25, x49); + let mut x63: u64 = 0; + let mut x64: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x63, &mut x64, x62, x27, x51); + let mut x65: u64 = 0; + let mut x66: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x65, &mut x66, x64, ((x28 as u64) + x8), ((x52 as u64) + x32)); + let mut x67: u64 = 0; + let mut x68: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x67, &mut x68, x1, 0xc84ee012b39bf21); + let mut x69: u64 = 0; + let mut x70: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x69, &mut x70, x1, 0x3fb05b7a28266895); + let mut x71: u64 = 0; + let mut x72: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x71, &mut x72, x1, 0xd40d49174aab1cc5); + let mut x73: u64 = 0; + let mut x74: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x73, &mut x74, x1, 0xbc3e483afcb82947); + let mut x75: u64 = 0; + let mut x76: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x75, &mut x76, x1, 0xff3d81e5df1aa419); + let mut x77: u64 = 0; + let mut x78: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x77, &mut x78, x1, 0x2d319b2419b409a9); + let mut x79: u64 = 0; + let mut x80: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x79, &mut x80, 0x0, x78, x75); + let mut x81: u64 = 0; + let mut x82: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x81, &mut x82, x80, x76, x73); + let mut x83: u64 = 0; + let mut x84: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x83, &mut x84, x82, x74, x71); + let mut x85: u64 = 0; + let mut x86: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x85, &mut x86, x84, x72, x69); + let mut x87: u64 = 0; + let mut x88: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x87, &mut x88, x86, x70, x67); + let mut x89: u64 = 0; + let mut x90: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x89, &mut x90, 0x0, x55, x77); + let mut x91: u64 = 0; + let mut x92: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x91, &mut x92, x90, x57, x79); + let mut x93: u64 = 0; + let mut x94: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x93, &mut x94, x92, x59, x81); + let mut x95: u64 = 0; + let mut x96: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x95, &mut x96, x94, x61, x83); + let mut x97: u64 = 0; + let mut x98: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x97, &mut x98, x96, x63, x85); + let mut x99: u64 = 0; + let mut x100: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x99, &mut x100, x98, x65, x87); + let mut x101: u64 = 0; + let mut x102: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x101, &mut x102, x89, 0x6ed46089e88fdc45); + let mut x103: u64 = 0; + let mut x104: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x103, &mut x104, x101, 0xffffffffffffffff); + let mut x105: u64 = 0; + let mut x106: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x105, &mut x106, x101, 0xffffffffffffffff); + let mut x107: u64 = 0; + let mut x108: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x107, &mut x108, x101, 0xffffffffffffffff); + let mut x109: u64 = 0; + let mut x110: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x109, &mut x110, x101, 0xc7634d81f4372ddf); + let mut x111: u64 = 0; + let mut x112: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x111, &mut x112, x101, 0x581a0db248b0a77a); + let mut x113: u64 = 0; + let mut x114: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x113, &mut x114, x101, 0xecec196accc52973); + let mut x115: u64 = 0; + let mut x116: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x115, &mut x116, 0x0, x114, x111); + let mut x117: u64 = 0; + let mut x118: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x117, &mut x118, x116, x112, x109); + let mut x119: u64 = 0; + let mut x120: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x119, &mut x120, x118, x110, x107); + let mut x121: u64 = 0; + let mut x122: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x121, &mut x122, x120, x108, x105); + let mut x123: u64 = 0; + let mut x124: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x123, &mut x124, x122, x106, x103); + let mut x125: u64 = 0; + let mut x126: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x125, &mut x126, 0x0, x89, x113); + let mut x127: u64 = 0; + let mut x128: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x127, &mut x128, x126, x91, x115); + let mut x129: u64 = 0; + let mut x130: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x129, &mut x130, x128, x93, x117); + let mut x131: u64 = 0; + let mut x132: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x131, &mut x132, x130, x95, x119); + let mut x133: u64 = 0; + let mut x134: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x133, &mut x134, x132, x97, x121); + let mut x135: u64 = 0; + let mut x136: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x135, &mut x136, x134, x99, x123); + let mut x137: u64 = 0; + let mut x138: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x137, &mut x138, x136, (((x100 as u64) + (x66 as u64)) + ((x88 as u64) + x68)), ((x124 as u64) + x104)); + let mut x139: u64 = 0; + let mut x140: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x139, &mut x140, x2, 0xc84ee012b39bf21); + let mut x141: u64 = 0; + let mut x142: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x141, &mut x142, x2, 0x3fb05b7a28266895); + let mut x143: u64 = 0; + let mut x144: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x143, &mut x144, x2, 0xd40d49174aab1cc5); + let mut x145: u64 = 0; + let mut x146: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x145, &mut x146, x2, 0xbc3e483afcb82947); + let mut x147: u64 = 0; + let mut x148: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x147, &mut x148, x2, 0xff3d81e5df1aa419); + let mut x149: u64 = 0; + let mut x150: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x149, &mut x150, x2, 0x2d319b2419b409a9); + let mut x151: u64 = 0; + let mut x152: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x151, &mut x152, 0x0, x150, x147); + let mut x153: u64 = 0; + let mut x154: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x153, &mut x154, x152, x148, x145); + let mut x155: u64 = 0; + let mut x156: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x155, &mut x156, x154, x146, x143); + let mut x157: u64 = 0; + let mut x158: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x157, &mut x158, x156, x144, x141); + let mut x159: u64 = 0; + let mut x160: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x159, &mut x160, x158, x142, x139); + let mut x161: u64 = 0; + let mut x162: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x161, &mut x162, 0x0, x127, x149); + let mut x163: u64 = 0; + let mut x164: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x163, &mut x164, x162, x129, x151); + let mut x165: u64 = 0; + let mut x166: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x165, &mut x166, x164, x131, x153); + let mut x167: u64 = 0; + let mut x168: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x167, &mut x168, x166, x133, x155); + let mut x169: u64 = 0; + let mut x170: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x169, &mut x170, x168, x135, x157); + let mut x171: u64 = 0; + let mut x172: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x171, &mut x172, x170, x137, x159); + let mut x173: u64 = 0; + let mut x174: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x173, &mut x174, x161, 0x6ed46089e88fdc45); + let mut x175: u64 = 0; + let mut x176: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x175, &mut x176, x173, 0xffffffffffffffff); + let mut x177: u64 = 0; + let mut x178: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x177, &mut x178, x173, 0xffffffffffffffff); + let mut x179: u64 = 0; + let mut x180: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x179, &mut x180, x173, 0xffffffffffffffff); + let mut x181: u64 = 0; + let mut x182: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x181, &mut x182, x173, 0xc7634d81f4372ddf); + let mut x183: u64 = 0; + let mut x184: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x183, &mut x184, x173, 0x581a0db248b0a77a); + let mut x185: u64 = 0; + let mut x186: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x185, &mut x186, x173, 0xecec196accc52973); + let mut x187: u64 = 0; + let mut x188: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x187, &mut x188, 0x0, x186, x183); + let mut x189: u64 = 0; + let mut x190: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x189, &mut x190, x188, x184, x181); + let mut x191: u64 = 0; + let mut x192: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x191, &mut x192, x190, x182, x179); + let mut x193: u64 = 0; + let mut x194: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x193, &mut x194, x192, x180, x177); + let mut x195: u64 = 0; + let mut x196: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x195, &mut x196, x194, x178, x175); + let mut x197: u64 = 0; + let mut x198: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x197, &mut x198, 0x0, x161, x185); + let mut x199: u64 = 0; + let mut x200: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x199, &mut x200, x198, x163, x187); + let mut x201: u64 = 0; + let mut x202: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x201, &mut x202, x200, x165, x189); + let mut x203: u64 = 0; + let mut x204: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x203, &mut x204, x202, x167, x191); + let mut x205: u64 = 0; + let mut x206: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x205, &mut x206, x204, x169, x193); + let mut x207: u64 = 0; + let mut x208: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x207, &mut x208, x206, x171, x195); + let mut x209: u64 = 0; + let mut x210: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x209, &mut x210, x208, (((x172 as u64) + (x138 as u64)) + ((x160 as u64) + x140)), ((x196 as u64) + x176)); + let mut x211: u64 = 0; + let mut x212: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x211, &mut x212, x3, 0xc84ee012b39bf21); + let mut x213: u64 = 0; + let mut x214: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x213, &mut x214, x3, 0x3fb05b7a28266895); + let mut x215: u64 = 0; + let mut x216: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x215, &mut x216, x3, 0xd40d49174aab1cc5); + let mut x217: u64 = 0; + let mut x218: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x217, &mut x218, x3, 0xbc3e483afcb82947); + let mut x219: u64 = 0; + let mut x220: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x219, &mut x220, x3, 0xff3d81e5df1aa419); + let mut x221: u64 = 0; + let mut x222: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x221, &mut x222, x3, 0x2d319b2419b409a9); + let mut x223: u64 = 0; + let mut x224: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x223, &mut x224, 0x0, x222, x219); + let mut x225: u64 = 0; + let mut x226: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x225, &mut x226, x224, x220, x217); + let mut x227: u64 = 0; + let mut x228: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x227, &mut x228, x226, x218, x215); + let mut x229: u64 = 0; + let mut x230: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x229, &mut x230, x228, x216, x213); + let mut x231: u64 = 0; + let mut x232: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x231, &mut x232, x230, x214, x211); + let mut x233: u64 = 0; + let mut x234: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x233, &mut x234, 0x0, x199, x221); + let mut x235: u64 = 0; + let mut x236: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x235, &mut x236, x234, x201, x223); + let mut x237: u64 = 0; + let mut x238: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x237, &mut x238, x236, x203, x225); + let mut x239: u64 = 0; + let mut x240: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x239, &mut x240, x238, x205, x227); + let mut x241: u64 = 0; + let mut x242: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x241, &mut x242, x240, x207, x229); + let mut x243: u64 = 0; + let mut x244: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x243, &mut x244, x242, x209, x231); + let mut x245: u64 = 0; + let mut x246: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x245, &mut x246, x233, 0x6ed46089e88fdc45); + let mut x247: u64 = 0; + let mut x248: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x247, &mut x248, x245, 0xffffffffffffffff); + let mut x249: u64 = 0; + let mut x250: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x249, &mut x250, x245, 0xffffffffffffffff); + let mut x251: u64 = 0; + let mut x252: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x251, &mut x252, x245, 0xffffffffffffffff); + let mut x253: u64 = 0; + let mut x254: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x253, &mut x254, x245, 0xc7634d81f4372ddf); + let mut x255: u64 = 0; + let mut x256: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x255, &mut x256, x245, 0x581a0db248b0a77a); + let mut x257: u64 = 0; + let mut x258: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x257, &mut x258, x245, 0xecec196accc52973); + let mut x259: u64 = 0; + let mut x260: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x259, &mut x260, 0x0, x258, x255); + let mut x261: u64 = 0; + let mut x262: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x261, &mut x262, x260, x256, x253); + let mut x263: u64 = 0; + let mut x264: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x263, &mut x264, x262, x254, x251); + let mut x265: u64 = 0; + let mut x266: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x265, &mut x266, x264, x252, x249); + let mut x267: u64 = 0; + let mut x268: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x267, &mut x268, x266, x250, x247); + let mut x269: u64 = 0; + let mut x270: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x269, &mut x270, 0x0, x233, x257); + let mut x271: u64 = 0; + let mut x272: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x271, &mut x272, x270, x235, x259); + let mut x273: u64 = 0; + let mut x274: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x273, &mut x274, x272, x237, x261); + let mut x275: u64 = 0; + let mut x276: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x275, &mut x276, x274, x239, x263); + let mut x277: u64 = 0; + let mut x278: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x277, &mut x278, x276, x241, x265); + let mut x279: u64 = 0; + let mut x280: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x279, &mut x280, x278, x243, x267); + let mut x281: u64 = 0; + let mut x282: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x281, &mut x282, x280, (((x244 as u64) + (x210 as u64)) + ((x232 as u64) + x212)), ((x268 as u64) + x248)); + let mut x283: u64 = 0; + let mut x284: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x283, &mut x284, x4, 0xc84ee012b39bf21); + let mut x285: u64 = 0; + let mut x286: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x285, &mut x286, x4, 0x3fb05b7a28266895); + let mut x287: u64 = 0; + let mut x288: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x287, &mut x288, x4, 0xd40d49174aab1cc5); + let mut x289: u64 = 0; + let mut x290: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x289, &mut x290, x4, 0xbc3e483afcb82947); + let mut x291: u64 = 0; + let mut x292: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x291, &mut x292, x4, 0xff3d81e5df1aa419); + let mut x293: u64 = 0; + let mut x294: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x293, &mut x294, x4, 0x2d319b2419b409a9); + let mut x295: u64 = 0; + let mut x296: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x295, &mut x296, 0x0, x294, x291); + let mut x297: u64 = 0; + let mut x298: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x297, &mut x298, x296, x292, x289); + let mut x299: u64 = 0; + let mut x300: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x299, &mut x300, x298, x290, x287); + let mut x301: u64 = 0; + let mut x302: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x301, &mut x302, x300, x288, x285); + let mut x303: u64 = 0; + let mut x304: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x303, &mut x304, x302, x286, x283); + let mut x305: u64 = 0; + let mut x306: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x305, &mut x306, 0x0, x271, x293); + let mut x307: u64 = 0; + let mut x308: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x307, &mut x308, x306, x273, x295); + let mut x309: u64 = 0; + let mut x310: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x309, &mut x310, x308, x275, x297); + let mut x311: u64 = 0; + let mut x312: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x311, &mut x312, x310, x277, x299); + let mut x313: u64 = 0; + let mut x314: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x313, &mut x314, x312, x279, x301); + let mut x315: u64 = 0; + let mut x316: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x315, &mut x316, x314, x281, x303); + let mut x317: u64 = 0; + let mut x318: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x317, &mut x318, x305, 0x6ed46089e88fdc45); + let mut x319: u64 = 0; + let mut x320: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x319, &mut x320, x317, 0xffffffffffffffff); + let mut x321: u64 = 0; + let mut x322: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x321, &mut x322, x317, 0xffffffffffffffff); + let mut x323: u64 = 0; + let mut x324: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x323, &mut x324, x317, 0xffffffffffffffff); + let mut x325: u64 = 0; + let mut x326: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x325, &mut x326, x317, 0xc7634d81f4372ddf); + let mut x327: u64 = 0; + let mut x328: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x327, &mut x328, x317, 0x581a0db248b0a77a); + let mut x329: u64 = 0; + let mut x330: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x329, &mut x330, x317, 0xecec196accc52973); + let mut x331: u64 = 0; + let mut x332: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x331, &mut x332, 0x0, x330, x327); + let mut x333: u64 = 0; + let mut x334: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x333, &mut x334, x332, x328, x325); + let mut x335: u64 = 0; + let mut x336: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x335, &mut x336, x334, x326, x323); + let mut x337: u64 = 0; + let mut x338: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x337, &mut x338, x336, x324, x321); + let mut x339: u64 = 0; + let mut x340: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x339, &mut x340, x338, x322, x319); + let mut x341: u64 = 0; + let mut x342: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x341, &mut x342, 0x0, x305, x329); + let mut x343: u64 = 0; + let mut x344: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x343, &mut x344, x342, x307, x331); + let mut x345: u64 = 0; + let mut x346: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x345, &mut x346, x344, x309, x333); + let mut x347: u64 = 0; + let mut x348: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x347, &mut x348, x346, x311, x335); + let mut x349: u64 = 0; + let mut x350: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x349, &mut x350, x348, x313, x337); + let mut x351: u64 = 0; + let mut x352: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x351, &mut x352, x350, x315, x339); + let mut x353: u64 = 0; + let mut x354: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x353, &mut x354, x352, (((x316 as u64) + (x282 as u64)) + ((x304 as u64) + x284)), ((x340 as u64) + x320)); + let mut x355: u64 = 0; + let mut x356: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x355, &mut x356, x5, 0xc84ee012b39bf21); + let mut x357: u64 = 0; + let mut x358: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x357, &mut x358, x5, 0x3fb05b7a28266895); + let mut x359: u64 = 0; + let mut x360: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x359, &mut x360, x5, 0xd40d49174aab1cc5); + let mut x361: u64 = 0; + let mut x362: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x361, &mut x362, x5, 0xbc3e483afcb82947); + let mut x363: u64 = 0; + let mut x364: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x363, &mut x364, x5, 0xff3d81e5df1aa419); + let mut x365: u64 = 0; + let mut x366: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x365, &mut x366, x5, 0x2d319b2419b409a9); + let mut x367: u64 = 0; + let mut x368: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x367, &mut x368, 0x0, x366, x363); + let mut x369: u64 = 0; + let mut x370: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x369, &mut x370, x368, x364, x361); + let mut x371: u64 = 0; + let mut x372: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x371, &mut x372, x370, x362, x359); + let mut x373: u64 = 0; + let mut x374: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x373, &mut x374, x372, x360, x357); + let mut x375: u64 = 0; + let mut x376: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x375, &mut x376, x374, x358, x355); + let mut x377: u64 = 0; + let mut x378: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x377, &mut x378, 0x0, x343, x365); + let mut x379: u64 = 0; + let mut x380: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x379, &mut x380, x378, x345, x367); + let mut x381: u64 = 0; + let mut x382: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x381, &mut x382, x380, x347, x369); + let mut x383: u64 = 0; + let mut x384: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x383, &mut x384, x382, x349, x371); + let mut x385: u64 = 0; + let mut x386: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x385, &mut x386, x384, x351, x373); + let mut x387: u64 = 0; + let mut x388: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x387, &mut x388, x386, x353, x375); + let mut x389: u64 = 0; + let mut x390: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x389, &mut x390, x377, 0x6ed46089e88fdc45); + let mut x391: u64 = 0; + let mut x392: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x391, &mut x392, x389, 0xffffffffffffffff); + let mut x393: u64 = 0; + let mut x394: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x393, &mut x394, x389, 0xffffffffffffffff); + let mut x395: u64 = 0; + let mut x396: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x395, &mut x396, x389, 0xffffffffffffffff); + let mut x397: u64 = 0; + let mut x398: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x397, &mut x398, x389, 0xc7634d81f4372ddf); + let mut x399: u64 = 0; + let mut x400: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x399, &mut x400, x389, 0x581a0db248b0a77a); + let mut x401: u64 = 0; + let mut x402: u64 = 0; + fiat_p384_scalar_mulx_u64(&mut x401, &mut x402, x389, 0xecec196accc52973); + let mut x403: u64 = 0; + let mut x404: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x403, &mut x404, 0x0, x402, x399); + let mut x405: u64 = 0; + let mut x406: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x405, &mut x406, x404, x400, x397); + let mut x407: u64 = 0; + let mut x408: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x407, &mut x408, x406, x398, x395); + let mut x409: u64 = 0; + let mut x410: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x409, &mut x410, x408, x396, x393); + let mut x411: u64 = 0; + let mut x412: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x411, &mut x412, x410, x394, x391); + let mut x413: u64 = 0; + let mut x414: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x413, &mut x414, 0x0, x377, x401); + let mut x415: u64 = 0; + let mut x416: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x415, &mut x416, x414, x379, x403); + let mut x417: u64 = 0; + let mut x418: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x417, &mut x418, x416, x381, x405); + let mut x419: u64 = 0; + let mut x420: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x419, &mut x420, x418, x383, x407); + let mut x421: u64 = 0; + let mut x422: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x421, &mut x422, x420, x385, x409); + let mut x423: u64 = 0; + let mut x424: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x423, &mut x424, x422, x387, x411); + let mut x425: u64 = 0; + let mut x426: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x425, &mut x426, x424, (((x388 as u64) + (x354 as u64)) + ((x376 as u64) + x356)), ((x412 as u64) + x392)); + let mut x427: u64 = 0; + let mut x428: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x427, &mut x428, 0x0, x415, 0xecec196accc52973); + let mut x429: u64 = 0; + let mut x430: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x429, &mut x430, x428, x417, 0x581a0db248b0a77a); + let mut x431: u64 = 0; + let mut x432: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x431, &mut x432, x430, x419, 0xc7634d81f4372ddf); + let mut x433: u64 = 0; + let mut x434: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x433, &mut x434, x432, x421, 0xffffffffffffffff); + let mut x435: u64 = 0; + let mut x436: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x435, &mut x436, x434, x423, 0xffffffffffffffff); + let mut x437: u64 = 0; + let mut x438: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x437, &mut x438, x436, x425, 0xffffffffffffffff); + let mut x439: u64 = 0; + let mut x440: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x439, &mut x440, x438, (x426 as u64), (0x0 as u64)); + let mut x441: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x441, x440, x427, x415); + let mut x442: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x442, x440, x429, x417); + let mut x443: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x443, x440, x431, x419); + let mut x444: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x444, x440, x433, x421); + let mut x445: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x445, x440, x435, x423); + let mut x446: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x446, x440, x437, x425); + out1[0] = x441; + out1[1] = x442; + out1[2] = x443; + out1[3] = x444; + out1[4] = x445; + out1[5] = x446; +} + +/// The function fiat_p384_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +#[inline] +pub fn fiat_p384_scalar_nonzero(out1: &mut u64, arg1: &[u64; 6]) -> () { + let x1: u64 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | (arg1[5])))))); + *out1 = x1; +} + +/// The function fiat_p384_scalar_selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_p384_scalar_selectznz(out1: &mut [u64; 6], arg1: fiat_p384_scalar_u1, arg2: &[u64; 6], arg3: &[u64; 6]) -> () { + let mut x1: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x1, arg1, (arg2[0]), (arg3[0])); + let mut x2: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x2, arg1, (arg2[1]), (arg3[1])); + let mut x3: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x3, arg1, (arg2[2]), (arg3[2])); + let mut x4: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x4, arg1, (arg2[3]), (arg3[3])); + let mut x5: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x5, arg1, (arg2[4]), (arg3[4])); + let mut x6: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x6, arg1, (arg2[5]), (arg3[5])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; +} + +/// The function fiat_p384_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +#[inline] +pub fn fiat_p384_scalar_to_bytes(out1: &mut [u8; 48], arg1: &[u64; 6]) -> () { + let x1: u64 = (arg1[5]); + let x2: u64 = (arg1[4]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[2]); + let x5: u64 = (arg1[1]); + let x6: u64 = (arg1[0]); + let x7: u8 = ((x6 & (0xff as u64)) as u8); + let x8: u64 = (x6 >> 8); + let x9: u8 = ((x8 & (0xff as u64)) as u8); + let x10: u64 = (x8 >> 8); + let x11: u8 = ((x10 & (0xff as u64)) as u8); + let x12: u64 = (x10 >> 8); + let x13: u8 = ((x12 & (0xff as u64)) as u8); + let x14: u64 = (x12 >> 8); + let x15: u8 = ((x14 & (0xff as u64)) as u8); + let x16: u64 = (x14 >> 8); + let x17: u8 = ((x16 & (0xff as u64)) as u8); + let x18: u64 = (x16 >> 8); + let x19: u8 = ((x18 & (0xff as u64)) as u8); + let x20: u8 = ((x18 >> 8) as u8); + let x21: u8 = ((x5 & (0xff as u64)) as u8); + let x22: u64 = (x5 >> 8); + let x23: u8 = ((x22 & (0xff as u64)) as u8); + let x24: u64 = (x22 >> 8); + let x25: u8 = ((x24 & (0xff as u64)) as u8); + let x26: u64 = (x24 >> 8); + let x27: u8 = ((x26 & (0xff as u64)) as u8); + let x28: u64 = (x26 >> 8); + let x29: u8 = ((x28 & (0xff as u64)) as u8); + let x30: u64 = (x28 >> 8); + let x31: u8 = ((x30 & (0xff as u64)) as u8); + let x32: u64 = (x30 >> 8); + let x33: u8 = ((x32 & (0xff as u64)) as u8); + let x34: u8 = ((x32 >> 8) as u8); + let x35: u8 = ((x4 & (0xff as u64)) as u8); + let x36: u64 = (x4 >> 8); + let x37: u8 = ((x36 & (0xff as u64)) as u8); + let x38: u64 = (x36 >> 8); + let x39: u8 = ((x38 & (0xff as u64)) as u8); + let x40: u64 = (x38 >> 8); + let x41: u8 = ((x40 & (0xff as u64)) as u8); + let x42: u64 = (x40 >> 8); + let x43: u8 = ((x42 & (0xff as u64)) as u8); + let x44: u64 = (x42 >> 8); + let x45: u8 = ((x44 & (0xff as u64)) as u8); + let x46: u64 = (x44 >> 8); + let x47: u8 = ((x46 & (0xff as u64)) as u8); + let x48: u8 = ((x46 >> 8) as u8); + let x49: u8 = ((x3 & (0xff as u64)) as u8); + let x50: u64 = (x3 >> 8); + let x51: u8 = ((x50 & (0xff as u64)) as u8); + let x52: u64 = (x50 >> 8); + let x53: u8 = ((x52 & (0xff as u64)) as u8); + let x54: u64 = (x52 >> 8); + let x55: u8 = ((x54 & (0xff as u64)) as u8); + let x56: u64 = (x54 >> 8); + let x57: u8 = ((x56 & (0xff as u64)) as u8); + let x58: u64 = (x56 >> 8); + let x59: u8 = ((x58 & (0xff as u64)) as u8); + let x60: u64 = (x58 >> 8); + let x61: u8 = ((x60 & (0xff as u64)) as u8); + let x62: u8 = ((x60 >> 8) as u8); + let x63: u8 = ((x2 & (0xff as u64)) as u8); + let x64: u64 = (x2 >> 8); + let x65: u8 = ((x64 & (0xff as u64)) as u8); + let x66: u64 = (x64 >> 8); + let x67: u8 = ((x66 & (0xff as u64)) as u8); + let x68: u64 = (x66 >> 8); + let x69: u8 = ((x68 & (0xff as u64)) as u8); + let x70: u64 = (x68 >> 8); + let x71: u8 = ((x70 & (0xff as u64)) as u8); + let x72: u64 = (x70 >> 8); + let x73: u8 = ((x72 & (0xff as u64)) as u8); + let x74: u64 = (x72 >> 8); + let x75: u8 = ((x74 & (0xff as u64)) as u8); + let x76: u8 = ((x74 >> 8) as u8); + let x77: u8 = ((x1 & (0xff as u64)) as u8); + let x78: u64 = (x1 >> 8); + let x79: u8 = ((x78 & (0xff as u64)) as u8); + let x80: u64 = (x78 >> 8); + let x81: u8 = ((x80 & (0xff as u64)) as u8); + let x82: u64 = (x80 >> 8); + let x83: u8 = ((x82 & (0xff as u64)) as u8); + let x84: u64 = (x82 >> 8); + let x85: u8 = ((x84 & (0xff as u64)) as u8); + let x86: u64 = (x84 >> 8); + let x87: u8 = ((x86 & (0xff as u64)) as u8); + let x88: u64 = (x86 >> 8); + let x89: u8 = ((x88 & (0xff as u64)) as u8); + let x90: u8 = ((x88 >> 8) as u8); + out1[0] = x7; + out1[1] = x9; + out1[2] = x11; + out1[3] = x13; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x27; + out1[12] = x29; + out1[13] = x31; + out1[14] = x33; + out1[15] = x34; + out1[16] = x35; + out1[17] = x37; + out1[18] = x39; + out1[19] = x41; + out1[20] = x43; + out1[21] = x45; + out1[22] = x47; + out1[23] = x48; + out1[24] = x49; + out1[25] = x51; + out1[26] = x53; + out1[27] = x55; + out1[28] = x57; + out1[29] = x59; + out1[30] = x61; + out1[31] = x62; + out1[32] = x63; + out1[33] = x65; + out1[34] = x67; + out1[35] = x69; + out1[36] = x71; + out1[37] = x73; + out1[38] = x75; + out1[39] = x76; + out1[40] = x77; + out1[41] = x79; + out1[42] = x81; + out1[43] = x83; + out1[44] = x85; + out1[45] = x87; + out1[46] = x89; + out1[47] = x90; +} + +/// The function fiat_p384_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_p384_scalar_from_bytes(out1: &mut [u64; 6], arg1: &[u8; 48]) -> () { + let x1: u64 = (((arg1[47]) as u64) << 56); + let x2: u64 = (((arg1[46]) as u64) << 48); + let x3: u64 = (((arg1[45]) as u64) << 40); + let x4: u64 = (((arg1[44]) as u64) << 32); + let x5: u64 = (((arg1[43]) as u64) << 24); + let x6: u64 = (((arg1[42]) as u64) << 16); + let x7: u64 = (((arg1[41]) as u64) << 8); + let x8: u8 = (arg1[40]); + let x9: u64 = (((arg1[39]) as u64) << 56); + let x10: u64 = (((arg1[38]) as u64) << 48); + let x11: u64 = (((arg1[37]) as u64) << 40); + let x12: u64 = (((arg1[36]) as u64) << 32); + let x13: u64 = (((arg1[35]) as u64) << 24); + let x14: u64 = (((arg1[34]) as u64) << 16); + let x15: u64 = (((arg1[33]) as u64) << 8); + let x16: u8 = (arg1[32]); + let x17: u64 = (((arg1[31]) as u64) << 56); + let x18: u64 = (((arg1[30]) as u64) << 48); + let x19: u64 = (((arg1[29]) as u64) << 40); + let x20: u64 = (((arg1[28]) as u64) << 32); + let x21: u64 = (((arg1[27]) as u64) << 24); + let x22: u64 = (((arg1[26]) as u64) << 16); + let x23: u64 = (((arg1[25]) as u64) << 8); + let x24: u8 = (arg1[24]); + let x25: u64 = (((arg1[23]) as u64) << 56); + let x26: u64 = (((arg1[22]) as u64) << 48); + let x27: u64 = (((arg1[21]) as u64) << 40); + let x28: u64 = (((arg1[20]) as u64) << 32); + let x29: u64 = (((arg1[19]) as u64) << 24); + let x30: u64 = (((arg1[18]) as u64) << 16); + let x31: u64 = (((arg1[17]) as u64) << 8); + let x32: u8 = (arg1[16]); + let x33: u64 = (((arg1[15]) as u64) << 56); + let x34: u64 = (((arg1[14]) as u64) << 48); + let x35: u64 = (((arg1[13]) as u64) << 40); + let x36: u64 = (((arg1[12]) as u64) << 32); + let x37: u64 = (((arg1[11]) as u64) << 24); + let x38: u64 = (((arg1[10]) as u64) << 16); + let x39: u64 = (((arg1[9]) as u64) << 8); + let x40: u8 = (arg1[8]); + let x41: u64 = (((arg1[7]) as u64) << 56); + let x42: u64 = (((arg1[6]) as u64) << 48); + let x43: u64 = (((arg1[5]) as u64) << 40); + let x44: u64 = (((arg1[4]) as u64) << 32); + let x45: u64 = (((arg1[3]) as u64) << 24); + let x46: u64 = (((arg1[2]) as u64) << 16); + let x47: u64 = (((arg1[1]) as u64) << 8); + let x48: u8 = (arg1[0]); + let x49: u64 = (x47 + (x48 as u64)); + let x50: u64 = (x46 + x49); + let x51: u64 = (x45 + x50); + let x52: u64 = (x44 + x51); + let x53: u64 = (x43 + x52); + let x54: u64 = (x42 + x53); + let x55: u64 = (x41 + x54); + let x56: u64 = (x39 + (x40 as u64)); + let x57: u64 = (x38 + x56); + let x58: u64 = (x37 + x57); + let x59: u64 = (x36 + x58); + let x60: u64 = (x35 + x59); + let x61: u64 = (x34 + x60); + let x62: u64 = (x33 + x61); + let x63: u64 = (x31 + (x32 as u64)); + let x64: u64 = (x30 + x63); + let x65: u64 = (x29 + x64); + let x66: u64 = (x28 + x65); + let x67: u64 = (x27 + x66); + let x68: u64 = (x26 + x67); + let x69: u64 = (x25 + x68); + let x70: u64 = (x23 + (x24 as u64)); + let x71: u64 = (x22 + x70); + let x72: u64 = (x21 + x71); + let x73: u64 = (x20 + x72); + let x74: u64 = (x19 + x73); + let x75: u64 = (x18 + x74); + let x76: u64 = (x17 + x75); + let x77: u64 = (x15 + (x16 as u64)); + let x78: u64 = (x14 + x77); + let x79: u64 = (x13 + x78); + let x80: u64 = (x12 + x79); + let x81: u64 = (x11 + x80); + let x82: u64 = (x10 + x81); + let x83: u64 = (x9 + x82); + let x84: u64 = (x7 + (x8 as u64)); + let x85: u64 = (x6 + x84); + let x86: u64 = (x5 + x85); + let x87: u64 = (x4 + x86); + let x88: u64 = (x3 + x87); + let x89: u64 = (x2 + x88); + let x90: u64 = (x1 + x89); + out1[0] = x55; + out1[1] = x62; + out1[2] = x69; + out1[3] = x76; + out1[4] = x83; + out1[5] = x90; +} + +/// The function fiat_p384_scalar_set_one returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_p384_scalar_set_one(out1: &mut fiat_p384_scalar_montgomery_domain_field_element) -> () { + out1[0] = 0x1313e695333ad68d; + out1[1] = 0xa7e5f24db74f5885; + out1[2] = 0x389cb27e0bc8d220; + out1[3] = (0x0 as u64); + out1[4] = (0x0 as u64); + out1[5] = (0x0 as u64); +} + +/// The function fiat_p384_scalar_msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_p384_scalar_msat(out1: &mut [u64; 7]) -> () { + out1[0] = 0xecec196accc52973; + out1[1] = 0x581a0db248b0a77a; + out1[2] = 0xc7634d81f4372ddf; + out1[3] = 0xffffffffffffffff; + out1[4] = 0xffffffffffffffff; + out1[5] = 0xffffffffffffffff; + out1[6] = (0x0 as u64); +} + +/// The function fiat_p384_scalar_divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_p384_scalar_divstep(out1: &mut u64, out2: &mut [u64; 7], out3: &mut [u64; 7], out4: &mut [u64; 6], out5: &mut [u64; 6], arg1: u64, arg2: &[u64; 7], arg3: &[u64; 7], arg4: &[u64; 6], arg5: &[u64; 6]) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x1, &mut x2, 0x0, (!arg1), (0x1 as u64)); + let x3: fiat_p384_scalar_u1 = (((x1 >> 63) as fiat_p384_scalar_u1) & (((arg3[0]) & (0x1 as u64)) as fiat_p384_scalar_u1)); + let mut x4: u64 = 0; + let mut x5: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x4, &mut x5, 0x0, (!arg1), (0x1 as u64)); + let mut x6: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x6, x3, arg1, x4); + let mut x7: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x7, x3, (arg2[0]), (arg3[0])); + let mut x8: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x8, x3, (arg2[1]), (arg3[1])); + let mut x9: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x9, x3, (arg2[2]), (arg3[2])); + let mut x10: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x10, x3, (arg2[3]), (arg3[3])); + let mut x11: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x11, x3, (arg2[4]), (arg3[4])); + let mut x12: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x12, x3, (arg2[5]), (arg3[5])); + let mut x13: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x13, x3, (arg2[6]), (arg3[6])); + let mut x14: u64 = 0; + let mut x15: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x14, &mut x15, 0x0, (0x1 as u64), (!(arg2[0]))); + let mut x16: u64 = 0; + let mut x17: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x16, &mut x17, x15, (0x0 as u64), (!(arg2[1]))); + let mut x18: u64 = 0; + let mut x19: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x18, &mut x19, x17, (0x0 as u64), (!(arg2[2]))); + let mut x20: u64 = 0; + let mut x21: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x20, &mut x21, x19, (0x0 as u64), (!(arg2[3]))); + let mut x22: u64 = 0; + let mut x23: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x22, &mut x23, x21, (0x0 as u64), (!(arg2[4]))); + let mut x24: u64 = 0; + let mut x25: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x24, &mut x25, x23, (0x0 as u64), (!(arg2[5]))); + let mut x26: u64 = 0; + let mut x27: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x26, &mut x27, x25, (0x0 as u64), (!(arg2[6]))); + let mut x28: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x28, x3, (arg3[0]), x14); + let mut x29: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x29, x3, (arg3[1]), x16); + let mut x30: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x30, x3, (arg3[2]), x18); + let mut x31: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x31, x3, (arg3[3]), x20); + let mut x32: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x32, x3, (arg3[4]), x22); + let mut x33: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x33, x3, (arg3[5]), x24); + let mut x34: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x34, x3, (arg3[6]), x26); + let mut x35: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x35, x3, (arg4[0]), (arg5[0])); + let mut x36: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x36, x3, (arg4[1]), (arg5[1])); + let mut x37: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x37, x3, (arg4[2]), (arg5[2])); + let mut x38: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x38, x3, (arg4[3]), (arg5[3])); + let mut x39: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x39, x3, (arg4[4]), (arg5[4])); + let mut x40: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x40, x3, (arg4[5]), (arg5[5])); + let mut x41: u64 = 0; + let mut x42: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x41, &mut x42, 0x0, x35, x35); + let mut x43: u64 = 0; + let mut x44: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x43, &mut x44, x42, x36, x36); + let mut x45: u64 = 0; + let mut x46: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x45, &mut x46, x44, x37, x37); + let mut x47: u64 = 0; + let mut x48: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x47, &mut x48, x46, x38, x38); + let mut x49: u64 = 0; + let mut x50: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x49, &mut x50, x48, x39, x39); + let mut x51: u64 = 0; + let mut x52: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x51, &mut x52, x50, x40, x40); + let mut x53: u64 = 0; + let mut x54: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x53, &mut x54, 0x0, x41, 0xecec196accc52973); + let mut x55: u64 = 0; + let mut x56: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x55, &mut x56, x54, x43, 0x581a0db248b0a77a); + let mut x57: u64 = 0; + let mut x58: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x57, &mut x58, x56, x45, 0xc7634d81f4372ddf); + let mut x59: u64 = 0; + let mut x60: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x59, &mut x60, x58, x47, 0xffffffffffffffff); + let mut x61: u64 = 0; + let mut x62: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x61, &mut x62, x60, x49, 0xffffffffffffffff); + let mut x63: u64 = 0; + let mut x64: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x63, &mut x64, x62, x51, 0xffffffffffffffff); + let mut x65: u64 = 0; + let mut x66: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x65, &mut x66, x64, (x52 as u64), (0x0 as u64)); + let x67: u64 = (arg4[5]); + let x68: u64 = (arg4[4]); + let x69: u64 = (arg4[3]); + let x70: u64 = (arg4[2]); + let x71: u64 = (arg4[1]); + let x72: u64 = (arg4[0]); + let mut x73: u64 = 0; + let mut x74: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x73, &mut x74, 0x0, (0x0 as u64), x72); + let mut x75: u64 = 0; + let mut x76: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x75, &mut x76, x74, (0x0 as u64), x71); + let mut x77: u64 = 0; + let mut x78: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x77, &mut x78, x76, (0x0 as u64), x70); + let mut x79: u64 = 0; + let mut x80: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x79, &mut x80, x78, (0x0 as u64), x69); + let mut x81: u64 = 0; + let mut x82: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x81, &mut x82, x80, (0x0 as u64), x68); + let mut x83: u64 = 0; + let mut x84: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x83, &mut x84, x82, (0x0 as u64), x67); + let mut x85: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x85, x84, (0x0 as u64), 0xffffffffffffffff); + let mut x86: u64 = 0; + let mut x87: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x86, &mut x87, 0x0, x73, (x85 & 0xecec196accc52973)); + let mut x88: u64 = 0; + let mut x89: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x88, &mut x89, x87, x75, (x85 & 0x581a0db248b0a77a)); + let mut x90: u64 = 0; + let mut x91: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x90, &mut x91, x89, x77, (x85 & 0xc7634d81f4372ddf)); + let mut x92: u64 = 0; + let mut x93: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x92, &mut x93, x91, x79, x85); + let mut x94: u64 = 0; + let mut x95: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x94, &mut x95, x93, x81, x85); + let mut x96: u64 = 0; + let mut x97: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x96, &mut x97, x95, x83, x85); + let mut x98: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x98, x3, (arg5[0]), x86); + let mut x99: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x99, x3, (arg5[1]), x88); + let mut x100: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x100, x3, (arg5[2]), x90); + let mut x101: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x101, x3, (arg5[3]), x92); + let mut x102: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x102, x3, (arg5[4]), x94); + let mut x103: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x103, x3, (arg5[5]), x96); + let x104: fiat_p384_scalar_u1 = ((x28 & (0x1 as u64)) as fiat_p384_scalar_u1); + let mut x105: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x105, x104, (0x0 as u64), x7); + let mut x106: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x106, x104, (0x0 as u64), x8); + let mut x107: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x107, x104, (0x0 as u64), x9); + let mut x108: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x108, x104, (0x0 as u64), x10); + let mut x109: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x109, x104, (0x0 as u64), x11); + let mut x110: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x110, x104, (0x0 as u64), x12); + let mut x111: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x111, x104, (0x0 as u64), x13); + let mut x112: u64 = 0; + let mut x113: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x112, &mut x113, 0x0, x28, x105); + let mut x114: u64 = 0; + let mut x115: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x114, &mut x115, x113, x29, x106); + let mut x116: u64 = 0; + let mut x117: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x116, &mut x117, x115, x30, x107); + let mut x118: u64 = 0; + let mut x119: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x118, &mut x119, x117, x31, x108); + let mut x120: u64 = 0; + let mut x121: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x120, &mut x121, x119, x32, x109); + let mut x122: u64 = 0; + let mut x123: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x122, &mut x123, x121, x33, x110); + let mut x124: u64 = 0; + let mut x125: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x124, &mut x125, x123, x34, x111); + let mut x126: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x126, x104, (0x0 as u64), x35); + let mut x127: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x127, x104, (0x0 as u64), x36); + let mut x128: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x128, x104, (0x0 as u64), x37); + let mut x129: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x129, x104, (0x0 as u64), x38); + let mut x130: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x130, x104, (0x0 as u64), x39); + let mut x131: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x131, x104, (0x0 as u64), x40); + let mut x132: u64 = 0; + let mut x133: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x132, &mut x133, 0x0, x98, x126); + let mut x134: u64 = 0; + let mut x135: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x134, &mut x135, x133, x99, x127); + let mut x136: u64 = 0; + let mut x137: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x136, &mut x137, x135, x100, x128); + let mut x138: u64 = 0; + let mut x139: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x138, &mut x139, x137, x101, x129); + let mut x140: u64 = 0; + let mut x141: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x140, &mut x141, x139, x102, x130); + let mut x142: u64 = 0; + let mut x143: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x142, &mut x143, x141, x103, x131); + let mut x144: u64 = 0; + let mut x145: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x144, &mut x145, 0x0, x132, 0xecec196accc52973); + let mut x146: u64 = 0; + let mut x147: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x146, &mut x147, x145, x134, 0x581a0db248b0a77a); + let mut x148: u64 = 0; + let mut x149: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x148, &mut x149, x147, x136, 0xc7634d81f4372ddf); + let mut x150: u64 = 0; + let mut x151: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x150, &mut x151, x149, x138, 0xffffffffffffffff); + let mut x152: u64 = 0; + let mut x153: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x152, &mut x153, x151, x140, 0xffffffffffffffff); + let mut x154: u64 = 0; + let mut x155: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x154, &mut x155, x153, x142, 0xffffffffffffffff); + let mut x156: u64 = 0; + let mut x157: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_subborrowx_u64(&mut x156, &mut x157, x155, (x143 as u64), (0x0 as u64)); + let mut x158: u64 = 0; + let mut x159: fiat_p384_scalar_u1 = 0; + fiat_p384_scalar_addcarryx_u64(&mut x158, &mut x159, 0x0, x6, (0x1 as u64)); + let x160: u64 = ((x112 >> 1) | ((x114 << 63) & 0xffffffffffffffff)); + let x161: u64 = ((x114 >> 1) | ((x116 << 63) & 0xffffffffffffffff)); + let x162: u64 = ((x116 >> 1) | ((x118 << 63) & 0xffffffffffffffff)); + let x163: u64 = ((x118 >> 1) | ((x120 << 63) & 0xffffffffffffffff)); + let x164: u64 = ((x120 >> 1) | ((x122 << 63) & 0xffffffffffffffff)); + let x165: u64 = ((x122 >> 1) | ((x124 << 63) & 0xffffffffffffffff)); + let x166: u64 = ((x124 & 0x8000000000000000) | (x124 >> 1)); + let mut x167: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x167, x66, x53, x41); + let mut x168: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x168, x66, x55, x43); + let mut x169: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x169, x66, x57, x45); + let mut x170: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x170, x66, x59, x47); + let mut x171: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x171, x66, x61, x49); + let mut x172: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x172, x66, x63, x51); + let mut x173: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x173, x157, x144, x132); + let mut x174: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x174, x157, x146, x134); + let mut x175: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x175, x157, x148, x136); + let mut x176: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x176, x157, x150, x138); + let mut x177: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x177, x157, x152, x140); + let mut x178: u64 = 0; + fiat_p384_scalar_cmovznz_u64(&mut x178, x157, x154, x142); + *out1 = x158; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out3[0] = x160; + out3[1] = x161; + out3[2] = x162; + out3[3] = x163; + out3[4] = x164; + out3[5] = x165; + out3[6] = x166; + out4[0] = x167; + out4[1] = x168; + out4[2] = x169; + out4[3] = x170; + out4[4] = x171; + out4[5] = x172; + out5[0] = x173; + out5[1] = x174; + out5[2] = x175; + out5[3] = x176; + out5[4] = x177; + out5[5] = x178; +} + +/// The function fiat_p384_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_p384_scalar_divstep_precomp(out1: &mut [u64; 6]) -> () { + out1[0] = 0x49589ae0e6045b6a; + out1[1] = 0x3c9a5352870040ed; + out1[2] = 0xdacb097e977dc242; + out1[3] = 0xb5ab30a6d1ecbe36; + out1[4] = 0x97d7a1081f959973; + out1[5] = 0x2ba012f8d27192bc; +} diff --git a/fiat-rust/src/secp256k1_scalar_32.rs b/fiat-rust/src/secp256k1_scalar_32.rs new file mode 100644 index 0000000000..bbdc1e474e --- /dev/null +++ b/fiat-rust/src/secp256k1_scalar_32.rs @@ -0,0 +1,5601 @@ +//! Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline secp256k1_scalar 32 '2^256 - 432420386565659656852420866394968145599' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +//! curve description: secp256k1_scalar +//! machine_wordsize = 32 (from "32") +//! requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +//! m = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141 (from "2^256 - 432420386565659656852420866394968145599") +//! +//! NOTE: In addition to the bounds specified above each function, all +//! functions synthesized for this Montgomery arithmetic require the +//! input to be strictly less than the prime modulus (m), and also +//! require the input to be in the unique saturated representation. +//! All functions also ensure that these two properties are true of +//! return values. +//! +//! Computed values: +//! eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) +//! bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +//! twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in +//! if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 + +#![allow(unused_parens)] +#![allow(non_camel_case_types)] + +pub type fiat_secp256k1_scalar_u1 = u8; +pub type fiat_secp256k1_scalar_i1 = i8; +pub type fiat_secp256k1_scalar_u2 = u8; +pub type fiat_secp256k1_scalar_i2 = i8; + +/* The type fiat_secp256k1_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +pub type fiat_secp256k1_scalar_montgomery_domain_field_element = [u32; 8]; + +/* The type fiat_secp256k1_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] */ +pub type fiat_secp256k1_scalar_non_montgomery_domain_field_element = [u32; 8]; + + +/// The function fiat_secp256k1_scalar_addcarryx_u32 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^32 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_secp256k1_scalar_addcarryx_u32(out1: &mut u32, out2: &mut fiat_secp256k1_scalar_u1, arg1: fiat_secp256k1_scalar_u1, arg2: u32, arg3: u32) -> () { + let x1: u64 = (((arg1 as u64) + (arg2 as u64)) + (arg3 as u64)); + let x2: u32 = ((x1 & (0xffffffff as u64)) as u32); + let x3: fiat_secp256k1_scalar_u1 = ((x1 >> 32) as fiat_secp256k1_scalar_u1); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_secp256k1_scalar_subborrowx_u32 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^32 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_secp256k1_scalar_subborrowx_u32(out1: &mut u32, out2: &mut fiat_secp256k1_scalar_u1, arg1: fiat_secp256k1_scalar_u1, arg2: u32, arg3: u32) -> () { + let x1: i64 = (((arg2 as i64) - (arg1 as i64)) - (arg3 as i64)); + let x2: fiat_secp256k1_scalar_i1 = ((x1 >> 32) as fiat_secp256k1_scalar_i1); + let x3: u32 = ((x1 & (0xffffffff as i64)) as u32); + *out1 = x3; + *out2 = (((0x0 as fiat_secp256k1_scalar_i2) - (x2 as fiat_secp256k1_scalar_i2)) as fiat_secp256k1_scalar_u1); +} + +/// The function fiat_secp256k1_scalar_mulx_u32 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^32 +/// out2 = ⌊arg1 * arg2 / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0xffffffff] +#[inline] +pub fn fiat_secp256k1_scalar_mulx_u32(out1: &mut u32, out2: &mut u32, arg1: u32, arg2: u32) -> () { + let x1: u64 = ((arg1 as u64) * (arg2 as u64)); + let x2: u32 = ((x1 & (0xffffffff as u64)) as u32); + let x3: u32 = ((x1 >> 32) as u32); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_secp256k1_scalar_cmovznz_u32 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +#[inline] +pub fn fiat_secp256k1_scalar_cmovznz_u32(out1: &mut u32, arg1: fiat_secp256k1_scalar_u1, arg2: u32, arg3: u32) -> () { + let x1: fiat_secp256k1_scalar_u1 = (!(!arg1)); + let x2: u32 = ((((((0x0 as fiat_secp256k1_scalar_i2) - (x1 as fiat_secp256k1_scalar_i2)) as fiat_secp256k1_scalar_i1) as i64) & (0xffffffff as i64)) as u32); + let x3: u32 = ((x2 & arg3) | ((!x2) & arg2)); + *out1 = x3; +} + +/// The function fiat_secp256k1_scalar_mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_mul(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_montgomery_domain_field_element, arg2: &fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[1]); + let x2: u32 = (arg1[2]); + let x3: u32 = (arg1[3]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[5]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[7]); + let x8: u32 = (arg1[0]); + let mut x9: u32 = 0; + let mut x10: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x9, &mut x10, x8, (arg2[7])); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x11, &mut x12, x8, (arg2[6])); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x13, &mut x14, x8, (arg2[5])); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x15, &mut x16, x8, (arg2[4])); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x17, &mut x18, x8, (arg2[3])); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x19, &mut x20, x8, (arg2[2])); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x21, &mut x22, x8, (arg2[1])); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x23, &mut x24, x8, (arg2[0])); + let mut x25: u32 = 0; + let mut x26: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x37, &mut x38, x36, x12, x9); + let x39: u32 = ((x38 as u32) + x10); + let mut x40: u32 = 0; + let mut x41: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x40, &mut x41, x23, 0x5588b13f); + let mut x42: u32 = 0; + let mut x43: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x42, &mut x43, x40, 0xffffffff); + let mut x44: u32 = 0; + let mut x45: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x44, &mut x45, x40, 0xffffffff); + let mut x46: u32 = 0; + let mut x47: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x46, &mut x47, x40, 0xffffffff); + let mut x48: u32 = 0; + let mut x49: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x48, &mut x49, x40, 0xfffffffe); + let mut x50: u32 = 0; + let mut x51: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x50, &mut x51, x40, 0xbaaedce6); + let mut x52: u32 = 0; + let mut x53: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x52, &mut x53, x40, 0xaf48a03b); + let mut x54: u32 = 0; + let mut x55: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x54, &mut x55, x40, 0xbfd25e8c); + let mut x56: u32 = 0; + let mut x57: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x56, &mut x57, x40, 0xd0364141); + let mut x58: u32 = 0; + let mut x59: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x58, &mut x59, 0x0, x57, x54); + let mut x60: u32 = 0; + let mut x61: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x60, &mut x61, x59, x55, x52); + let mut x62: u32 = 0; + let mut x63: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x62, &mut x63, x61, x53, x50); + let mut x64: u32 = 0; + let mut x65: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x64, &mut x65, x63, x51, x48); + let mut x66: u32 = 0; + let mut x67: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x66, &mut x67, x65, x49, x46); + let mut x68: u32 = 0; + let mut x69: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x68, &mut x69, x67, x47, x44); + let mut x70: u32 = 0; + let mut x71: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x70, &mut x71, x69, x45, x42); + let x72: u32 = ((x71 as u32) + x43); + let mut x73: u32 = 0; + let mut x74: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x73, &mut x74, 0x0, x23, x56); + let mut x75: u32 = 0; + let mut x76: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x75, &mut x76, x74, x25, x58); + let mut x77: u32 = 0; + let mut x78: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x77, &mut x78, x76, x27, x60); + let mut x79: u32 = 0; + let mut x80: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x79, &mut x80, x78, x29, x62); + let mut x81: u32 = 0; + let mut x82: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x81, &mut x82, x80, x31, x64); + let mut x83: u32 = 0; + let mut x84: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x83, &mut x84, x82, x33, x66); + let mut x85: u32 = 0; + let mut x86: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x85, &mut x86, x84, x35, x68); + let mut x87: u32 = 0; + let mut x88: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x87, &mut x88, x86, x37, x70); + let mut x89: u32 = 0; + let mut x90: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x89, &mut x90, x88, x39, x72); + let mut x91: u32 = 0; + let mut x92: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x91, &mut x92, x1, (arg2[7])); + let mut x93: u32 = 0; + let mut x94: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x93, &mut x94, x1, (arg2[6])); + let mut x95: u32 = 0; + let mut x96: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x95, &mut x96, x1, (arg2[5])); + let mut x97: u32 = 0; + let mut x98: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x97, &mut x98, x1, (arg2[4])); + let mut x99: u32 = 0; + let mut x100: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x99, &mut x100, x1, (arg2[3])); + let mut x101: u32 = 0; + let mut x102: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x101, &mut x102, x1, (arg2[2])); + let mut x103: u32 = 0; + let mut x104: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x103, &mut x104, x1, (arg2[1])); + let mut x105: u32 = 0; + let mut x106: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x105, &mut x106, x1, (arg2[0])); + let mut x107: u32 = 0; + let mut x108: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x107, &mut x108, 0x0, x106, x103); + let mut x109: u32 = 0; + let mut x110: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x109, &mut x110, x108, x104, x101); + let mut x111: u32 = 0; + let mut x112: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x102, x99); + let mut x113: u32 = 0; + let mut x114: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x113, &mut x114, x112, x100, x97); + let mut x115: u32 = 0; + let mut x116: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x115, &mut x116, x114, x98, x95); + let mut x117: u32 = 0; + let mut x118: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x117, &mut x118, x116, x96, x93); + let mut x119: u32 = 0; + let mut x120: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x119, &mut x120, x118, x94, x91); + let x121: u32 = ((x120 as u32) + x92); + let mut x122: u32 = 0; + let mut x123: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x122, &mut x123, 0x0, x75, x105); + let mut x124: u32 = 0; + let mut x125: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x77, x107); + let mut x126: u32 = 0; + let mut x127: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x126, &mut x127, x125, x79, x109); + let mut x128: u32 = 0; + let mut x129: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x128, &mut x129, x127, x81, x111); + let mut x130: u32 = 0; + let mut x131: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x130, &mut x131, x129, x83, x113); + let mut x132: u32 = 0; + let mut x133: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x132, &mut x133, x131, x85, x115); + let mut x134: u32 = 0; + let mut x135: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x134, &mut x135, x133, x87, x117); + let mut x136: u32 = 0; + let mut x137: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x136, &mut x137, x135, x89, x119); + let mut x138: u32 = 0; + let mut x139: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x138, &mut x139, x137, (x90 as u32), x121); + let mut x140: u32 = 0; + let mut x141: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x140, &mut x141, x122, 0x5588b13f); + let mut x142: u32 = 0; + let mut x143: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x142, &mut x143, x140, 0xffffffff); + let mut x144: u32 = 0; + let mut x145: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x144, &mut x145, x140, 0xffffffff); + let mut x146: u32 = 0; + let mut x147: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x146, &mut x147, x140, 0xffffffff); + let mut x148: u32 = 0; + let mut x149: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x148, &mut x149, x140, 0xfffffffe); + let mut x150: u32 = 0; + let mut x151: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x150, &mut x151, x140, 0xbaaedce6); + let mut x152: u32 = 0; + let mut x153: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x152, &mut x153, x140, 0xaf48a03b); + let mut x154: u32 = 0; + let mut x155: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x154, &mut x155, x140, 0xbfd25e8c); + let mut x156: u32 = 0; + let mut x157: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x156, &mut x157, x140, 0xd0364141); + let mut x158: u32 = 0; + let mut x159: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x158, &mut x159, 0x0, x157, x154); + let mut x160: u32 = 0; + let mut x161: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x155, x152); + let mut x162: u32 = 0; + let mut x163: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x162, &mut x163, x161, x153, x150); + let mut x164: u32 = 0; + let mut x165: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x164, &mut x165, x163, x151, x148); + let mut x166: u32 = 0; + let mut x167: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x166, &mut x167, x165, x149, x146); + let mut x168: u32 = 0; + let mut x169: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x168, &mut x169, x167, x147, x144); + let mut x170: u32 = 0; + let mut x171: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x170, &mut x171, x169, x145, x142); + let x172: u32 = ((x171 as u32) + x143); + let mut x173: u32 = 0; + let mut x174: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x173, &mut x174, 0x0, x122, x156); + let mut x175: u32 = 0; + let mut x176: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x175, &mut x176, x174, x124, x158); + let mut x177: u32 = 0; + let mut x178: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x177, &mut x178, x176, x126, x160); + let mut x179: u32 = 0; + let mut x180: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x179, &mut x180, x178, x128, x162); + let mut x181: u32 = 0; + let mut x182: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x181, &mut x182, x180, x130, x164); + let mut x183: u32 = 0; + let mut x184: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x183, &mut x184, x182, x132, x166); + let mut x185: u32 = 0; + let mut x186: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x185, &mut x186, x184, x134, x168); + let mut x187: u32 = 0; + let mut x188: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x187, &mut x188, x186, x136, x170); + let mut x189: u32 = 0; + let mut x190: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x189, &mut x190, x188, x138, x172); + let x191: u32 = ((x190 as u32) + (x139 as u32)); + let mut x192: u32 = 0; + let mut x193: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x192, &mut x193, x2, (arg2[7])); + let mut x194: u32 = 0; + let mut x195: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x194, &mut x195, x2, (arg2[6])); + let mut x196: u32 = 0; + let mut x197: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x196, &mut x197, x2, (arg2[5])); + let mut x198: u32 = 0; + let mut x199: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x198, &mut x199, x2, (arg2[4])); + let mut x200: u32 = 0; + let mut x201: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x200, &mut x201, x2, (arg2[3])); + let mut x202: u32 = 0; + let mut x203: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x202, &mut x203, x2, (arg2[2])); + let mut x204: u32 = 0; + let mut x205: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x204, &mut x205, x2, (arg2[1])); + let mut x206: u32 = 0; + let mut x207: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x206, &mut x207, x2, (arg2[0])); + let mut x208: u32 = 0; + let mut x209: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x208, &mut x209, 0x0, x207, x204); + let mut x210: u32 = 0; + let mut x211: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x210, &mut x211, x209, x205, x202); + let mut x212: u32 = 0; + let mut x213: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x212, &mut x213, x211, x203, x200); + let mut x214: u32 = 0; + let mut x215: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x214, &mut x215, x213, x201, x198); + let mut x216: u32 = 0; + let mut x217: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x216, &mut x217, x215, x199, x196); + let mut x218: u32 = 0; + let mut x219: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x218, &mut x219, x217, x197, x194); + let mut x220: u32 = 0; + let mut x221: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x220, &mut x221, x219, x195, x192); + let x222: u32 = ((x221 as u32) + x193); + let mut x223: u32 = 0; + let mut x224: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x223, &mut x224, 0x0, x175, x206); + let mut x225: u32 = 0; + let mut x226: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x225, &mut x226, x224, x177, x208); + let mut x227: u32 = 0; + let mut x228: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x227, &mut x228, x226, x179, x210); + let mut x229: u32 = 0; + let mut x230: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x229, &mut x230, x228, x181, x212); + let mut x231: u32 = 0; + let mut x232: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x231, &mut x232, x230, x183, x214); + let mut x233: u32 = 0; + let mut x234: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x233, &mut x234, x232, x185, x216); + let mut x235: u32 = 0; + let mut x236: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x235, &mut x236, x234, x187, x218); + let mut x237: u32 = 0; + let mut x238: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x237, &mut x238, x236, x189, x220); + let mut x239: u32 = 0; + let mut x240: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x239, &mut x240, x238, x191, x222); + let mut x241: u32 = 0; + let mut x242: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x241, &mut x242, x223, 0x5588b13f); + let mut x243: u32 = 0; + let mut x244: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x243, &mut x244, x241, 0xffffffff); + let mut x245: u32 = 0; + let mut x246: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x245, &mut x246, x241, 0xffffffff); + let mut x247: u32 = 0; + let mut x248: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x247, &mut x248, x241, 0xffffffff); + let mut x249: u32 = 0; + let mut x250: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x249, &mut x250, x241, 0xfffffffe); + let mut x251: u32 = 0; + let mut x252: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x251, &mut x252, x241, 0xbaaedce6); + let mut x253: u32 = 0; + let mut x254: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x253, &mut x254, x241, 0xaf48a03b); + let mut x255: u32 = 0; + let mut x256: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x255, &mut x256, x241, 0xbfd25e8c); + let mut x257: u32 = 0; + let mut x258: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x257, &mut x258, x241, 0xd0364141); + let mut x259: u32 = 0; + let mut x260: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x259, &mut x260, 0x0, x258, x255); + let mut x261: u32 = 0; + let mut x262: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x261, &mut x262, x260, x256, x253); + let mut x263: u32 = 0; + let mut x264: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x263, &mut x264, x262, x254, x251); + let mut x265: u32 = 0; + let mut x266: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x265, &mut x266, x264, x252, x249); + let mut x267: u32 = 0; + let mut x268: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x267, &mut x268, x266, x250, x247); + let mut x269: u32 = 0; + let mut x270: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x269, &mut x270, x268, x248, x245); + let mut x271: u32 = 0; + let mut x272: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x271, &mut x272, x270, x246, x243); + let x273: u32 = ((x272 as u32) + x244); + let mut x274: u32 = 0; + let mut x275: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x274, &mut x275, 0x0, x223, x257); + let mut x276: u32 = 0; + let mut x277: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x276, &mut x277, x275, x225, x259); + let mut x278: u32 = 0; + let mut x279: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x278, &mut x279, x277, x227, x261); + let mut x280: u32 = 0; + let mut x281: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x280, &mut x281, x279, x229, x263); + let mut x282: u32 = 0; + let mut x283: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x282, &mut x283, x281, x231, x265); + let mut x284: u32 = 0; + let mut x285: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x284, &mut x285, x283, x233, x267); + let mut x286: u32 = 0; + let mut x287: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x286, &mut x287, x285, x235, x269); + let mut x288: u32 = 0; + let mut x289: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x288, &mut x289, x287, x237, x271); + let mut x290: u32 = 0; + let mut x291: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x290, &mut x291, x289, x239, x273); + let x292: u32 = ((x291 as u32) + (x240 as u32)); + let mut x293: u32 = 0; + let mut x294: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x293, &mut x294, x3, (arg2[7])); + let mut x295: u32 = 0; + let mut x296: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x295, &mut x296, x3, (arg2[6])); + let mut x297: u32 = 0; + let mut x298: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x297, &mut x298, x3, (arg2[5])); + let mut x299: u32 = 0; + let mut x300: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x299, &mut x300, x3, (arg2[4])); + let mut x301: u32 = 0; + let mut x302: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x301, &mut x302, x3, (arg2[3])); + let mut x303: u32 = 0; + let mut x304: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x303, &mut x304, x3, (arg2[2])); + let mut x305: u32 = 0; + let mut x306: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x305, &mut x306, x3, (arg2[1])); + let mut x307: u32 = 0; + let mut x308: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x307, &mut x308, x3, (arg2[0])); + let mut x309: u32 = 0; + let mut x310: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x309, &mut x310, 0x0, x308, x305); + let mut x311: u32 = 0; + let mut x312: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x311, &mut x312, x310, x306, x303); + let mut x313: u32 = 0; + let mut x314: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x313, &mut x314, x312, x304, x301); + let mut x315: u32 = 0; + let mut x316: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x315, &mut x316, x314, x302, x299); + let mut x317: u32 = 0; + let mut x318: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x317, &mut x318, x316, x300, x297); + let mut x319: u32 = 0; + let mut x320: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x319, &mut x320, x318, x298, x295); + let mut x321: u32 = 0; + let mut x322: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x321, &mut x322, x320, x296, x293); + let x323: u32 = ((x322 as u32) + x294); + let mut x324: u32 = 0; + let mut x325: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x324, &mut x325, 0x0, x276, x307); + let mut x326: u32 = 0; + let mut x327: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x326, &mut x327, x325, x278, x309); + let mut x328: u32 = 0; + let mut x329: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x328, &mut x329, x327, x280, x311); + let mut x330: u32 = 0; + let mut x331: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x330, &mut x331, x329, x282, x313); + let mut x332: u32 = 0; + let mut x333: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x332, &mut x333, x331, x284, x315); + let mut x334: u32 = 0; + let mut x335: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x334, &mut x335, x333, x286, x317); + let mut x336: u32 = 0; + let mut x337: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x336, &mut x337, x335, x288, x319); + let mut x338: u32 = 0; + let mut x339: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x338, &mut x339, x337, x290, x321); + let mut x340: u32 = 0; + let mut x341: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x340, &mut x341, x339, x292, x323); + let mut x342: u32 = 0; + let mut x343: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x342, &mut x343, x324, 0x5588b13f); + let mut x344: u32 = 0; + let mut x345: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x344, &mut x345, x342, 0xffffffff); + let mut x346: u32 = 0; + let mut x347: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x346, &mut x347, x342, 0xffffffff); + let mut x348: u32 = 0; + let mut x349: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x348, &mut x349, x342, 0xffffffff); + let mut x350: u32 = 0; + let mut x351: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x350, &mut x351, x342, 0xfffffffe); + let mut x352: u32 = 0; + let mut x353: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x352, &mut x353, x342, 0xbaaedce6); + let mut x354: u32 = 0; + let mut x355: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x354, &mut x355, x342, 0xaf48a03b); + let mut x356: u32 = 0; + let mut x357: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x356, &mut x357, x342, 0xbfd25e8c); + let mut x358: u32 = 0; + let mut x359: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x358, &mut x359, x342, 0xd0364141); + let mut x360: u32 = 0; + let mut x361: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x360, &mut x361, 0x0, x359, x356); + let mut x362: u32 = 0; + let mut x363: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x362, &mut x363, x361, x357, x354); + let mut x364: u32 = 0; + let mut x365: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x364, &mut x365, x363, x355, x352); + let mut x366: u32 = 0; + let mut x367: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x366, &mut x367, x365, x353, x350); + let mut x368: u32 = 0; + let mut x369: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x368, &mut x369, x367, x351, x348); + let mut x370: u32 = 0; + let mut x371: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x370, &mut x371, x369, x349, x346); + let mut x372: u32 = 0; + let mut x373: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x372, &mut x373, x371, x347, x344); + let x374: u32 = ((x373 as u32) + x345); + let mut x375: u32 = 0; + let mut x376: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x375, &mut x376, 0x0, x324, x358); + let mut x377: u32 = 0; + let mut x378: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x377, &mut x378, x376, x326, x360); + let mut x379: u32 = 0; + let mut x380: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x379, &mut x380, x378, x328, x362); + let mut x381: u32 = 0; + let mut x382: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x381, &mut x382, x380, x330, x364); + let mut x383: u32 = 0; + let mut x384: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x383, &mut x384, x382, x332, x366); + let mut x385: u32 = 0; + let mut x386: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x385, &mut x386, x384, x334, x368); + let mut x387: u32 = 0; + let mut x388: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x387, &mut x388, x386, x336, x370); + let mut x389: u32 = 0; + let mut x390: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x389, &mut x390, x388, x338, x372); + let mut x391: u32 = 0; + let mut x392: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x391, &mut x392, x390, x340, x374); + let x393: u32 = ((x392 as u32) + (x341 as u32)); + let mut x394: u32 = 0; + let mut x395: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x394, &mut x395, x4, (arg2[7])); + let mut x396: u32 = 0; + let mut x397: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x396, &mut x397, x4, (arg2[6])); + let mut x398: u32 = 0; + let mut x399: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x398, &mut x399, x4, (arg2[5])); + let mut x400: u32 = 0; + let mut x401: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x400, &mut x401, x4, (arg2[4])); + let mut x402: u32 = 0; + let mut x403: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x402, &mut x403, x4, (arg2[3])); + let mut x404: u32 = 0; + let mut x405: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x404, &mut x405, x4, (arg2[2])); + let mut x406: u32 = 0; + let mut x407: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x406, &mut x407, x4, (arg2[1])); + let mut x408: u32 = 0; + let mut x409: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x408, &mut x409, x4, (arg2[0])); + let mut x410: u32 = 0; + let mut x411: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x410, &mut x411, 0x0, x409, x406); + let mut x412: u32 = 0; + let mut x413: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x412, &mut x413, x411, x407, x404); + let mut x414: u32 = 0; + let mut x415: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x414, &mut x415, x413, x405, x402); + let mut x416: u32 = 0; + let mut x417: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x416, &mut x417, x415, x403, x400); + let mut x418: u32 = 0; + let mut x419: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x418, &mut x419, x417, x401, x398); + let mut x420: u32 = 0; + let mut x421: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x420, &mut x421, x419, x399, x396); + let mut x422: u32 = 0; + let mut x423: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x422, &mut x423, x421, x397, x394); + let x424: u32 = ((x423 as u32) + x395); + let mut x425: u32 = 0; + let mut x426: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x425, &mut x426, 0x0, x377, x408); + let mut x427: u32 = 0; + let mut x428: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x427, &mut x428, x426, x379, x410); + let mut x429: u32 = 0; + let mut x430: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x429, &mut x430, x428, x381, x412); + let mut x431: u32 = 0; + let mut x432: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x431, &mut x432, x430, x383, x414); + let mut x433: u32 = 0; + let mut x434: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x433, &mut x434, x432, x385, x416); + let mut x435: u32 = 0; + let mut x436: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x435, &mut x436, x434, x387, x418); + let mut x437: u32 = 0; + let mut x438: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x437, &mut x438, x436, x389, x420); + let mut x439: u32 = 0; + let mut x440: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x439, &mut x440, x438, x391, x422); + let mut x441: u32 = 0; + let mut x442: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x441, &mut x442, x440, x393, x424); + let mut x443: u32 = 0; + let mut x444: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x443, &mut x444, x425, 0x5588b13f); + let mut x445: u32 = 0; + let mut x446: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x445, &mut x446, x443, 0xffffffff); + let mut x447: u32 = 0; + let mut x448: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x447, &mut x448, x443, 0xffffffff); + let mut x449: u32 = 0; + let mut x450: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x449, &mut x450, x443, 0xffffffff); + let mut x451: u32 = 0; + let mut x452: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x451, &mut x452, x443, 0xfffffffe); + let mut x453: u32 = 0; + let mut x454: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x453, &mut x454, x443, 0xbaaedce6); + let mut x455: u32 = 0; + let mut x456: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x455, &mut x456, x443, 0xaf48a03b); + let mut x457: u32 = 0; + let mut x458: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x457, &mut x458, x443, 0xbfd25e8c); + let mut x459: u32 = 0; + let mut x460: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x459, &mut x460, x443, 0xd0364141); + let mut x461: u32 = 0; + let mut x462: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x461, &mut x462, 0x0, x460, x457); + let mut x463: u32 = 0; + let mut x464: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x463, &mut x464, x462, x458, x455); + let mut x465: u32 = 0; + let mut x466: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x465, &mut x466, x464, x456, x453); + let mut x467: u32 = 0; + let mut x468: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x467, &mut x468, x466, x454, x451); + let mut x469: u32 = 0; + let mut x470: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x469, &mut x470, x468, x452, x449); + let mut x471: u32 = 0; + let mut x472: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x471, &mut x472, x470, x450, x447); + let mut x473: u32 = 0; + let mut x474: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x473, &mut x474, x472, x448, x445); + let x475: u32 = ((x474 as u32) + x446); + let mut x476: u32 = 0; + let mut x477: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x476, &mut x477, 0x0, x425, x459); + let mut x478: u32 = 0; + let mut x479: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x478, &mut x479, x477, x427, x461); + let mut x480: u32 = 0; + let mut x481: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x480, &mut x481, x479, x429, x463); + let mut x482: u32 = 0; + let mut x483: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x482, &mut x483, x481, x431, x465); + let mut x484: u32 = 0; + let mut x485: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x484, &mut x485, x483, x433, x467); + let mut x486: u32 = 0; + let mut x487: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x486, &mut x487, x485, x435, x469); + let mut x488: u32 = 0; + let mut x489: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x488, &mut x489, x487, x437, x471); + let mut x490: u32 = 0; + let mut x491: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x490, &mut x491, x489, x439, x473); + let mut x492: u32 = 0; + let mut x493: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x492, &mut x493, x491, x441, x475); + let x494: u32 = ((x493 as u32) + (x442 as u32)); + let mut x495: u32 = 0; + let mut x496: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x495, &mut x496, x5, (arg2[7])); + let mut x497: u32 = 0; + let mut x498: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x497, &mut x498, x5, (arg2[6])); + let mut x499: u32 = 0; + let mut x500: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x499, &mut x500, x5, (arg2[5])); + let mut x501: u32 = 0; + let mut x502: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x501, &mut x502, x5, (arg2[4])); + let mut x503: u32 = 0; + let mut x504: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x503, &mut x504, x5, (arg2[3])); + let mut x505: u32 = 0; + let mut x506: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x505, &mut x506, x5, (arg2[2])); + let mut x507: u32 = 0; + let mut x508: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x507, &mut x508, x5, (arg2[1])); + let mut x509: u32 = 0; + let mut x510: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x509, &mut x510, x5, (arg2[0])); + let mut x511: u32 = 0; + let mut x512: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x511, &mut x512, 0x0, x510, x507); + let mut x513: u32 = 0; + let mut x514: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x513, &mut x514, x512, x508, x505); + let mut x515: u32 = 0; + let mut x516: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x515, &mut x516, x514, x506, x503); + let mut x517: u32 = 0; + let mut x518: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x517, &mut x518, x516, x504, x501); + let mut x519: u32 = 0; + let mut x520: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x519, &mut x520, x518, x502, x499); + let mut x521: u32 = 0; + let mut x522: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x521, &mut x522, x520, x500, x497); + let mut x523: u32 = 0; + let mut x524: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x523, &mut x524, x522, x498, x495); + let x525: u32 = ((x524 as u32) + x496); + let mut x526: u32 = 0; + let mut x527: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x526, &mut x527, 0x0, x478, x509); + let mut x528: u32 = 0; + let mut x529: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x528, &mut x529, x527, x480, x511); + let mut x530: u32 = 0; + let mut x531: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x530, &mut x531, x529, x482, x513); + let mut x532: u32 = 0; + let mut x533: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x532, &mut x533, x531, x484, x515); + let mut x534: u32 = 0; + let mut x535: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x534, &mut x535, x533, x486, x517); + let mut x536: u32 = 0; + let mut x537: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x536, &mut x537, x535, x488, x519); + let mut x538: u32 = 0; + let mut x539: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x538, &mut x539, x537, x490, x521); + let mut x540: u32 = 0; + let mut x541: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x540, &mut x541, x539, x492, x523); + let mut x542: u32 = 0; + let mut x543: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x542, &mut x543, x541, x494, x525); + let mut x544: u32 = 0; + let mut x545: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x544, &mut x545, x526, 0x5588b13f); + let mut x546: u32 = 0; + let mut x547: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x546, &mut x547, x544, 0xffffffff); + let mut x548: u32 = 0; + let mut x549: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x548, &mut x549, x544, 0xffffffff); + let mut x550: u32 = 0; + let mut x551: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x550, &mut x551, x544, 0xffffffff); + let mut x552: u32 = 0; + let mut x553: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x552, &mut x553, x544, 0xfffffffe); + let mut x554: u32 = 0; + let mut x555: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x554, &mut x555, x544, 0xbaaedce6); + let mut x556: u32 = 0; + let mut x557: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x556, &mut x557, x544, 0xaf48a03b); + let mut x558: u32 = 0; + let mut x559: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x558, &mut x559, x544, 0xbfd25e8c); + let mut x560: u32 = 0; + let mut x561: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x560, &mut x561, x544, 0xd0364141); + let mut x562: u32 = 0; + let mut x563: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x562, &mut x563, 0x0, x561, x558); + let mut x564: u32 = 0; + let mut x565: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x564, &mut x565, x563, x559, x556); + let mut x566: u32 = 0; + let mut x567: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x566, &mut x567, x565, x557, x554); + let mut x568: u32 = 0; + let mut x569: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x568, &mut x569, x567, x555, x552); + let mut x570: u32 = 0; + let mut x571: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x570, &mut x571, x569, x553, x550); + let mut x572: u32 = 0; + let mut x573: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x572, &mut x573, x571, x551, x548); + let mut x574: u32 = 0; + let mut x575: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x574, &mut x575, x573, x549, x546); + let x576: u32 = ((x575 as u32) + x547); + let mut x577: u32 = 0; + let mut x578: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x577, &mut x578, 0x0, x526, x560); + let mut x579: u32 = 0; + let mut x580: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x579, &mut x580, x578, x528, x562); + let mut x581: u32 = 0; + let mut x582: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x581, &mut x582, x580, x530, x564); + let mut x583: u32 = 0; + let mut x584: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x583, &mut x584, x582, x532, x566); + let mut x585: u32 = 0; + let mut x586: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x585, &mut x586, x584, x534, x568); + let mut x587: u32 = 0; + let mut x588: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x587, &mut x588, x586, x536, x570); + let mut x589: u32 = 0; + let mut x590: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x589, &mut x590, x588, x538, x572); + let mut x591: u32 = 0; + let mut x592: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x591, &mut x592, x590, x540, x574); + let mut x593: u32 = 0; + let mut x594: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x593, &mut x594, x592, x542, x576); + let x595: u32 = ((x594 as u32) + (x543 as u32)); + let mut x596: u32 = 0; + let mut x597: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x596, &mut x597, x6, (arg2[7])); + let mut x598: u32 = 0; + let mut x599: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x598, &mut x599, x6, (arg2[6])); + let mut x600: u32 = 0; + let mut x601: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x600, &mut x601, x6, (arg2[5])); + let mut x602: u32 = 0; + let mut x603: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x602, &mut x603, x6, (arg2[4])); + let mut x604: u32 = 0; + let mut x605: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x604, &mut x605, x6, (arg2[3])); + let mut x606: u32 = 0; + let mut x607: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x606, &mut x607, x6, (arg2[2])); + let mut x608: u32 = 0; + let mut x609: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x608, &mut x609, x6, (arg2[1])); + let mut x610: u32 = 0; + let mut x611: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x610, &mut x611, x6, (arg2[0])); + let mut x612: u32 = 0; + let mut x613: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x612, &mut x613, 0x0, x611, x608); + let mut x614: u32 = 0; + let mut x615: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x614, &mut x615, x613, x609, x606); + let mut x616: u32 = 0; + let mut x617: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x616, &mut x617, x615, x607, x604); + let mut x618: u32 = 0; + let mut x619: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x618, &mut x619, x617, x605, x602); + let mut x620: u32 = 0; + let mut x621: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x620, &mut x621, x619, x603, x600); + let mut x622: u32 = 0; + let mut x623: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x622, &mut x623, x621, x601, x598); + let mut x624: u32 = 0; + let mut x625: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x624, &mut x625, x623, x599, x596); + let x626: u32 = ((x625 as u32) + x597); + let mut x627: u32 = 0; + let mut x628: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x627, &mut x628, 0x0, x579, x610); + let mut x629: u32 = 0; + let mut x630: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x629, &mut x630, x628, x581, x612); + let mut x631: u32 = 0; + let mut x632: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x631, &mut x632, x630, x583, x614); + let mut x633: u32 = 0; + let mut x634: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x633, &mut x634, x632, x585, x616); + let mut x635: u32 = 0; + let mut x636: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x635, &mut x636, x634, x587, x618); + let mut x637: u32 = 0; + let mut x638: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x637, &mut x638, x636, x589, x620); + let mut x639: u32 = 0; + let mut x640: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x639, &mut x640, x638, x591, x622); + let mut x641: u32 = 0; + let mut x642: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x641, &mut x642, x640, x593, x624); + let mut x643: u32 = 0; + let mut x644: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x643, &mut x644, x642, x595, x626); + let mut x645: u32 = 0; + let mut x646: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x645, &mut x646, x627, 0x5588b13f); + let mut x647: u32 = 0; + let mut x648: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x647, &mut x648, x645, 0xffffffff); + let mut x649: u32 = 0; + let mut x650: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x649, &mut x650, x645, 0xffffffff); + let mut x651: u32 = 0; + let mut x652: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x651, &mut x652, x645, 0xffffffff); + let mut x653: u32 = 0; + let mut x654: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x653, &mut x654, x645, 0xfffffffe); + let mut x655: u32 = 0; + let mut x656: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x655, &mut x656, x645, 0xbaaedce6); + let mut x657: u32 = 0; + let mut x658: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x657, &mut x658, x645, 0xaf48a03b); + let mut x659: u32 = 0; + let mut x660: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x659, &mut x660, x645, 0xbfd25e8c); + let mut x661: u32 = 0; + let mut x662: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x661, &mut x662, x645, 0xd0364141); + let mut x663: u32 = 0; + let mut x664: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x663, &mut x664, 0x0, x662, x659); + let mut x665: u32 = 0; + let mut x666: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x665, &mut x666, x664, x660, x657); + let mut x667: u32 = 0; + let mut x668: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x667, &mut x668, x666, x658, x655); + let mut x669: u32 = 0; + let mut x670: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x669, &mut x670, x668, x656, x653); + let mut x671: u32 = 0; + let mut x672: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x671, &mut x672, x670, x654, x651); + let mut x673: u32 = 0; + let mut x674: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x673, &mut x674, x672, x652, x649); + let mut x675: u32 = 0; + let mut x676: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x675, &mut x676, x674, x650, x647); + let x677: u32 = ((x676 as u32) + x648); + let mut x678: u32 = 0; + let mut x679: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x678, &mut x679, 0x0, x627, x661); + let mut x680: u32 = 0; + let mut x681: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x680, &mut x681, x679, x629, x663); + let mut x682: u32 = 0; + let mut x683: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x682, &mut x683, x681, x631, x665); + let mut x684: u32 = 0; + let mut x685: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x684, &mut x685, x683, x633, x667); + let mut x686: u32 = 0; + let mut x687: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x686, &mut x687, x685, x635, x669); + let mut x688: u32 = 0; + let mut x689: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x688, &mut x689, x687, x637, x671); + let mut x690: u32 = 0; + let mut x691: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x690, &mut x691, x689, x639, x673); + let mut x692: u32 = 0; + let mut x693: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x692, &mut x693, x691, x641, x675); + let mut x694: u32 = 0; + let mut x695: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x694, &mut x695, x693, x643, x677); + let x696: u32 = ((x695 as u32) + (x644 as u32)); + let mut x697: u32 = 0; + let mut x698: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x697, &mut x698, x7, (arg2[7])); + let mut x699: u32 = 0; + let mut x700: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x699, &mut x700, x7, (arg2[6])); + let mut x701: u32 = 0; + let mut x702: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x701, &mut x702, x7, (arg2[5])); + let mut x703: u32 = 0; + let mut x704: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x703, &mut x704, x7, (arg2[4])); + let mut x705: u32 = 0; + let mut x706: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x705, &mut x706, x7, (arg2[3])); + let mut x707: u32 = 0; + let mut x708: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x707, &mut x708, x7, (arg2[2])); + let mut x709: u32 = 0; + let mut x710: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x709, &mut x710, x7, (arg2[1])); + let mut x711: u32 = 0; + let mut x712: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x711, &mut x712, x7, (arg2[0])); + let mut x713: u32 = 0; + let mut x714: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x713, &mut x714, 0x0, x712, x709); + let mut x715: u32 = 0; + let mut x716: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x715, &mut x716, x714, x710, x707); + let mut x717: u32 = 0; + let mut x718: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x717, &mut x718, x716, x708, x705); + let mut x719: u32 = 0; + let mut x720: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x719, &mut x720, x718, x706, x703); + let mut x721: u32 = 0; + let mut x722: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x721, &mut x722, x720, x704, x701); + let mut x723: u32 = 0; + let mut x724: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x723, &mut x724, x722, x702, x699); + let mut x725: u32 = 0; + let mut x726: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x725, &mut x726, x724, x700, x697); + let x727: u32 = ((x726 as u32) + x698); + let mut x728: u32 = 0; + let mut x729: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x728, &mut x729, 0x0, x680, x711); + let mut x730: u32 = 0; + let mut x731: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x730, &mut x731, x729, x682, x713); + let mut x732: u32 = 0; + let mut x733: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x732, &mut x733, x731, x684, x715); + let mut x734: u32 = 0; + let mut x735: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x734, &mut x735, x733, x686, x717); + let mut x736: u32 = 0; + let mut x737: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x736, &mut x737, x735, x688, x719); + let mut x738: u32 = 0; + let mut x739: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x738, &mut x739, x737, x690, x721); + let mut x740: u32 = 0; + let mut x741: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x740, &mut x741, x739, x692, x723); + let mut x742: u32 = 0; + let mut x743: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x742, &mut x743, x741, x694, x725); + let mut x744: u32 = 0; + let mut x745: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x744, &mut x745, x743, x696, x727); + let mut x746: u32 = 0; + let mut x747: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x746, &mut x747, x728, 0x5588b13f); + let mut x748: u32 = 0; + let mut x749: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x748, &mut x749, x746, 0xffffffff); + let mut x750: u32 = 0; + let mut x751: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x750, &mut x751, x746, 0xffffffff); + let mut x752: u32 = 0; + let mut x753: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x752, &mut x753, x746, 0xffffffff); + let mut x754: u32 = 0; + let mut x755: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x754, &mut x755, x746, 0xfffffffe); + let mut x756: u32 = 0; + let mut x757: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x756, &mut x757, x746, 0xbaaedce6); + let mut x758: u32 = 0; + let mut x759: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x758, &mut x759, x746, 0xaf48a03b); + let mut x760: u32 = 0; + let mut x761: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x760, &mut x761, x746, 0xbfd25e8c); + let mut x762: u32 = 0; + let mut x763: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x762, &mut x763, x746, 0xd0364141); + let mut x764: u32 = 0; + let mut x765: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x764, &mut x765, 0x0, x763, x760); + let mut x766: u32 = 0; + let mut x767: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x766, &mut x767, x765, x761, x758); + let mut x768: u32 = 0; + let mut x769: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x768, &mut x769, x767, x759, x756); + let mut x770: u32 = 0; + let mut x771: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x770, &mut x771, x769, x757, x754); + let mut x772: u32 = 0; + let mut x773: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x772, &mut x773, x771, x755, x752); + let mut x774: u32 = 0; + let mut x775: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x774, &mut x775, x773, x753, x750); + let mut x776: u32 = 0; + let mut x777: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x776, &mut x777, x775, x751, x748); + let x778: u32 = ((x777 as u32) + x749); + let mut x779: u32 = 0; + let mut x780: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x779, &mut x780, 0x0, x728, x762); + let mut x781: u32 = 0; + let mut x782: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x781, &mut x782, x780, x730, x764); + let mut x783: u32 = 0; + let mut x784: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x783, &mut x784, x782, x732, x766); + let mut x785: u32 = 0; + let mut x786: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x785, &mut x786, x784, x734, x768); + let mut x787: u32 = 0; + let mut x788: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x787, &mut x788, x786, x736, x770); + let mut x789: u32 = 0; + let mut x790: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x789, &mut x790, x788, x738, x772); + let mut x791: u32 = 0; + let mut x792: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x791, &mut x792, x790, x740, x774); + let mut x793: u32 = 0; + let mut x794: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x793, &mut x794, x792, x742, x776); + let mut x795: u32 = 0; + let mut x796: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x795, &mut x796, x794, x744, x778); + let x797: u32 = ((x796 as u32) + (x745 as u32)); + let mut x798: u32 = 0; + let mut x799: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x798, &mut x799, 0x0, x781, 0xd0364141); + let mut x800: u32 = 0; + let mut x801: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x800, &mut x801, x799, x783, 0xbfd25e8c); + let mut x802: u32 = 0; + let mut x803: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x802, &mut x803, x801, x785, 0xaf48a03b); + let mut x804: u32 = 0; + let mut x805: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x804, &mut x805, x803, x787, 0xbaaedce6); + let mut x806: u32 = 0; + let mut x807: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x806, &mut x807, x805, x789, 0xfffffffe); + let mut x808: u32 = 0; + let mut x809: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x808, &mut x809, x807, x791, 0xffffffff); + let mut x810: u32 = 0; + let mut x811: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x810, &mut x811, x809, x793, 0xffffffff); + let mut x812: u32 = 0; + let mut x813: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x812, &mut x813, x811, x795, 0xffffffff); + let mut x814: u32 = 0; + let mut x815: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x814, &mut x815, x813, x797, (0x0 as u32)); + let mut x816: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x816, x815, x798, x781); + let mut x817: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x817, x815, x800, x783); + let mut x818: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x818, x815, x802, x785); + let mut x819: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x819, x815, x804, x787); + let mut x820: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x820, x815, x806, x789); + let mut x821: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x821, x815, x808, x791); + let mut x822: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x822, x815, x810, x793); + let mut x823: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x823, x815, x812, x795); + out1[0] = x816; + out1[1] = x817; + out1[2] = x818; + out1[3] = x819; + out1[4] = x820; + out1[5] = x821; + out1[6] = x822; + out1[7] = x823; +} + +/// The function fiat_secp256k1_scalar_square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_square(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[1]); + let x2: u32 = (arg1[2]); + let x3: u32 = (arg1[3]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[5]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[7]); + let x8: u32 = (arg1[0]); + let mut x9: u32 = 0; + let mut x10: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x9, &mut x10, x8, (arg1[7])); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x11, &mut x12, x8, (arg1[6])); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x13, &mut x14, x8, (arg1[5])); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x15, &mut x16, x8, (arg1[4])); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x17, &mut x18, x8, (arg1[3])); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x19, &mut x20, x8, (arg1[2])); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x21, &mut x22, x8, (arg1[1])); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x23, &mut x24, x8, (arg1[0])); + let mut x25: u32 = 0; + let mut x26: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x37, &mut x38, x36, x12, x9); + let x39: u32 = ((x38 as u32) + x10); + let mut x40: u32 = 0; + let mut x41: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x40, &mut x41, x23, 0x5588b13f); + let mut x42: u32 = 0; + let mut x43: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x42, &mut x43, x40, 0xffffffff); + let mut x44: u32 = 0; + let mut x45: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x44, &mut x45, x40, 0xffffffff); + let mut x46: u32 = 0; + let mut x47: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x46, &mut x47, x40, 0xffffffff); + let mut x48: u32 = 0; + let mut x49: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x48, &mut x49, x40, 0xfffffffe); + let mut x50: u32 = 0; + let mut x51: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x50, &mut x51, x40, 0xbaaedce6); + let mut x52: u32 = 0; + let mut x53: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x52, &mut x53, x40, 0xaf48a03b); + let mut x54: u32 = 0; + let mut x55: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x54, &mut x55, x40, 0xbfd25e8c); + let mut x56: u32 = 0; + let mut x57: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x56, &mut x57, x40, 0xd0364141); + let mut x58: u32 = 0; + let mut x59: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x58, &mut x59, 0x0, x57, x54); + let mut x60: u32 = 0; + let mut x61: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x60, &mut x61, x59, x55, x52); + let mut x62: u32 = 0; + let mut x63: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x62, &mut x63, x61, x53, x50); + let mut x64: u32 = 0; + let mut x65: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x64, &mut x65, x63, x51, x48); + let mut x66: u32 = 0; + let mut x67: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x66, &mut x67, x65, x49, x46); + let mut x68: u32 = 0; + let mut x69: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x68, &mut x69, x67, x47, x44); + let mut x70: u32 = 0; + let mut x71: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x70, &mut x71, x69, x45, x42); + let x72: u32 = ((x71 as u32) + x43); + let mut x73: u32 = 0; + let mut x74: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x73, &mut x74, 0x0, x23, x56); + let mut x75: u32 = 0; + let mut x76: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x75, &mut x76, x74, x25, x58); + let mut x77: u32 = 0; + let mut x78: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x77, &mut x78, x76, x27, x60); + let mut x79: u32 = 0; + let mut x80: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x79, &mut x80, x78, x29, x62); + let mut x81: u32 = 0; + let mut x82: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x81, &mut x82, x80, x31, x64); + let mut x83: u32 = 0; + let mut x84: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x83, &mut x84, x82, x33, x66); + let mut x85: u32 = 0; + let mut x86: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x85, &mut x86, x84, x35, x68); + let mut x87: u32 = 0; + let mut x88: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x87, &mut x88, x86, x37, x70); + let mut x89: u32 = 0; + let mut x90: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x89, &mut x90, x88, x39, x72); + let mut x91: u32 = 0; + let mut x92: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x91, &mut x92, x1, (arg1[7])); + let mut x93: u32 = 0; + let mut x94: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x93, &mut x94, x1, (arg1[6])); + let mut x95: u32 = 0; + let mut x96: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x95, &mut x96, x1, (arg1[5])); + let mut x97: u32 = 0; + let mut x98: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x97, &mut x98, x1, (arg1[4])); + let mut x99: u32 = 0; + let mut x100: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x99, &mut x100, x1, (arg1[3])); + let mut x101: u32 = 0; + let mut x102: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x101, &mut x102, x1, (arg1[2])); + let mut x103: u32 = 0; + let mut x104: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x103, &mut x104, x1, (arg1[1])); + let mut x105: u32 = 0; + let mut x106: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x105, &mut x106, x1, (arg1[0])); + let mut x107: u32 = 0; + let mut x108: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x107, &mut x108, 0x0, x106, x103); + let mut x109: u32 = 0; + let mut x110: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x109, &mut x110, x108, x104, x101); + let mut x111: u32 = 0; + let mut x112: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x102, x99); + let mut x113: u32 = 0; + let mut x114: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x113, &mut x114, x112, x100, x97); + let mut x115: u32 = 0; + let mut x116: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x115, &mut x116, x114, x98, x95); + let mut x117: u32 = 0; + let mut x118: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x117, &mut x118, x116, x96, x93); + let mut x119: u32 = 0; + let mut x120: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x119, &mut x120, x118, x94, x91); + let x121: u32 = ((x120 as u32) + x92); + let mut x122: u32 = 0; + let mut x123: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x122, &mut x123, 0x0, x75, x105); + let mut x124: u32 = 0; + let mut x125: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x77, x107); + let mut x126: u32 = 0; + let mut x127: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x126, &mut x127, x125, x79, x109); + let mut x128: u32 = 0; + let mut x129: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x128, &mut x129, x127, x81, x111); + let mut x130: u32 = 0; + let mut x131: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x130, &mut x131, x129, x83, x113); + let mut x132: u32 = 0; + let mut x133: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x132, &mut x133, x131, x85, x115); + let mut x134: u32 = 0; + let mut x135: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x134, &mut x135, x133, x87, x117); + let mut x136: u32 = 0; + let mut x137: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x136, &mut x137, x135, x89, x119); + let mut x138: u32 = 0; + let mut x139: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x138, &mut x139, x137, (x90 as u32), x121); + let mut x140: u32 = 0; + let mut x141: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x140, &mut x141, x122, 0x5588b13f); + let mut x142: u32 = 0; + let mut x143: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x142, &mut x143, x140, 0xffffffff); + let mut x144: u32 = 0; + let mut x145: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x144, &mut x145, x140, 0xffffffff); + let mut x146: u32 = 0; + let mut x147: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x146, &mut x147, x140, 0xffffffff); + let mut x148: u32 = 0; + let mut x149: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x148, &mut x149, x140, 0xfffffffe); + let mut x150: u32 = 0; + let mut x151: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x150, &mut x151, x140, 0xbaaedce6); + let mut x152: u32 = 0; + let mut x153: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x152, &mut x153, x140, 0xaf48a03b); + let mut x154: u32 = 0; + let mut x155: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x154, &mut x155, x140, 0xbfd25e8c); + let mut x156: u32 = 0; + let mut x157: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x156, &mut x157, x140, 0xd0364141); + let mut x158: u32 = 0; + let mut x159: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x158, &mut x159, 0x0, x157, x154); + let mut x160: u32 = 0; + let mut x161: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x155, x152); + let mut x162: u32 = 0; + let mut x163: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x162, &mut x163, x161, x153, x150); + let mut x164: u32 = 0; + let mut x165: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x164, &mut x165, x163, x151, x148); + let mut x166: u32 = 0; + let mut x167: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x166, &mut x167, x165, x149, x146); + let mut x168: u32 = 0; + let mut x169: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x168, &mut x169, x167, x147, x144); + let mut x170: u32 = 0; + let mut x171: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x170, &mut x171, x169, x145, x142); + let x172: u32 = ((x171 as u32) + x143); + let mut x173: u32 = 0; + let mut x174: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x173, &mut x174, 0x0, x122, x156); + let mut x175: u32 = 0; + let mut x176: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x175, &mut x176, x174, x124, x158); + let mut x177: u32 = 0; + let mut x178: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x177, &mut x178, x176, x126, x160); + let mut x179: u32 = 0; + let mut x180: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x179, &mut x180, x178, x128, x162); + let mut x181: u32 = 0; + let mut x182: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x181, &mut x182, x180, x130, x164); + let mut x183: u32 = 0; + let mut x184: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x183, &mut x184, x182, x132, x166); + let mut x185: u32 = 0; + let mut x186: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x185, &mut x186, x184, x134, x168); + let mut x187: u32 = 0; + let mut x188: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x187, &mut x188, x186, x136, x170); + let mut x189: u32 = 0; + let mut x190: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x189, &mut x190, x188, x138, x172); + let x191: u32 = ((x190 as u32) + (x139 as u32)); + let mut x192: u32 = 0; + let mut x193: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x192, &mut x193, x2, (arg1[7])); + let mut x194: u32 = 0; + let mut x195: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x194, &mut x195, x2, (arg1[6])); + let mut x196: u32 = 0; + let mut x197: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x196, &mut x197, x2, (arg1[5])); + let mut x198: u32 = 0; + let mut x199: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x198, &mut x199, x2, (arg1[4])); + let mut x200: u32 = 0; + let mut x201: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x200, &mut x201, x2, (arg1[3])); + let mut x202: u32 = 0; + let mut x203: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x202, &mut x203, x2, (arg1[2])); + let mut x204: u32 = 0; + let mut x205: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x204, &mut x205, x2, (arg1[1])); + let mut x206: u32 = 0; + let mut x207: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x206, &mut x207, x2, (arg1[0])); + let mut x208: u32 = 0; + let mut x209: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x208, &mut x209, 0x0, x207, x204); + let mut x210: u32 = 0; + let mut x211: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x210, &mut x211, x209, x205, x202); + let mut x212: u32 = 0; + let mut x213: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x212, &mut x213, x211, x203, x200); + let mut x214: u32 = 0; + let mut x215: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x214, &mut x215, x213, x201, x198); + let mut x216: u32 = 0; + let mut x217: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x216, &mut x217, x215, x199, x196); + let mut x218: u32 = 0; + let mut x219: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x218, &mut x219, x217, x197, x194); + let mut x220: u32 = 0; + let mut x221: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x220, &mut x221, x219, x195, x192); + let x222: u32 = ((x221 as u32) + x193); + let mut x223: u32 = 0; + let mut x224: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x223, &mut x224, 0x0, x175, x206); + let mut x225: u32 = 0; + let mut x226: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x225, &mut x226, x224, x177, x208); + let mut x227: u32 = 0; + let mut x228: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x227, &mut x228, x226, x179, x210); + let mut x229: u32 = 0; + let mut x230: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x229, &mut x230, x228, x181, x212); + let mut x231: u32 = 0; + let mut x232: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x231, &mut x232, x230, x183, x214); + let mut x233: u32 = 0; + let mut x234: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x233, &mut x234, x232, x185, x216); + let mut x235: u32 = 0; + let mut x236: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x235, &mut x236, x234, x187, x218); + let mut x237: u32 = 0; + let mut x238: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x237, &mut x238, x236, x189, x220); + let mut x239: u32 = 0; + let mut x240: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x239, &mut x240, x238, x191, x222); + let mut x241: u32 = 0; + let mut x242: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x241, &mut x242, x223, 0x5588b13f); + let mut x243: u32 = 0; + let mut x244: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x243, &mut x244, x241, 0xffffffff); + let mut x245: u32 = 0; + let mut x246: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x245, &mut x246, x241, 0xffffffff); + let mut x247: u32 = 0; + let mut x248: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x247, &mut x248, x241, 0xffffffff); + let mut x249: u32 = 0; + let mut x250: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x249, &mut x250, x241, 0xfffffffe); + let mut x251: u32 = 0; + let mut x252: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x251, &mut x252, x241, 0xbaaedce6); + let mut x253: u32 = 0; + let mut x254: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x253, &mut x254, x241, 0xaf48a03b); + let mut x255: u32 = 0; + let mut x256: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x255, &mut x256, x241, 0xbfd25e8c); + let mut x257: u32 = 0; + let mut x258: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x257, &mut x258, x241, 0xd0364141); + let mut x259: u32 = 0; + let mut x260: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x259, &mut x260, 0x0, x258, x255); + let mut x261: u32 = 0; + let mut x262: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x261, &mut x262, x260, x256, x253); + let mut x263: u32 = 0; + let mut x264: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x263, &mut x264, x262, x254, x251); + let mut x265: u32 = 0; + let mut x266: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x265, &mut x266, x264, x252, x249); + let mut x267: u32 = 0; + let mut x268: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x267, &mut x268, x266, x250, x247); + let mut x269: u32 = 0; + let mut x270: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x269, &mut x270, x268, x248, x245); + let mut x271: u32 = 0; + let mut x272: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x271, &mut x272, x270, x246, x243); + let x273: u32 = ((x272 as u32) + x244); + let mut x274: u32 = 0; + let mut x275: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x274, &mut x275, 0x0, x223, x257); + let mut x276: u32 = 0; + let mut x277: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x276, &mut x277, x275, x225, x259); + let mut x278: u32 = 0; + let mut x279: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x278, &mut x279, x277, x227, x261); + let mut x280: u32 = 0; + let mut x281: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x280, &mut x281, x279, x229, x263); + let mut x282: u32 = 0; + let mut x283: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x282, &mut x283, x281, x231, x265); + let mut x284: u32 = 0; + let mut x285: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x284, &mut x285, x283, x233, x267); + let mut x286: u32 = 0; + let mut x287: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x286, &mut x287, x285, x235, x269); + let mut x288: u32 = 0; + let mut x289: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x288, &mut x289, x287, x237, x271); + let mut x290: u32 = 0; + let mut x291: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x290, &mut x291, x289, x239, x273); + let x292: u32 = ((x291 as u32) + (x240 as u32)); + let mut x293: u32 = 0; + let mut x294: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x293, &mut x294, x3, (arg1[7])); + let mut x295: u32 = 0; + let mut x296: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x295, &mut x296, x3, (arg1[6])); + let mut x297: u32 = 0; + let mut x298: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x297, &mut x298, x3, (arg1[5])); + let mut x299: u32 = 0; + let mut x300: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x299, &mut x300, x3, (arg1[4])); + let mut x301: u32 = 0; + let mut x302: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x301, &mut x302, x3, (arg1[3])); + let mut x303: u32 = 0; + let mut x304: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x303, &mut x304, x3, (arg1[2])); + let mut x305: u32 = 0; + let mut x306: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x305, &mut x306, x3, (arg1[1])); + let mut x307: u32 = 0; + let mut x308: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x307, &mut x308, x3, (arg1[0])); + let mut x309: u32 = 0; + let mut x310: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x309, &mut x310, 0x0, x308, x305); + let mut x311: u32 = 0; + let mut x312: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x311, &mut x312, x310, x306, x303); + let mut x313: u32 = 0; + let mut x314: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x313, &mut x314, x312, x304, x301); + let mut x315: u32 = 0; + let mut x316: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x315, &mut x316, x314, x302, x299); + let mut x317: u32 = 0; + let mut x318: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x317, &mut x318, x316, x300, x297); + let mut x319: u32 = 0; + let mut x320: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x319, &mut x320, x318, x298, x295); + let mut x321: u32 = 0; + let mut x322: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x321, &mut x322, x320, x296, x293); + let x323: u32 = ((x322 as u32) + x294); + let mut x324: u32 = 0; + let mut x325: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x324, &mut x325, 0x0, x276, x307); + let mut x326: u32 = 0; + let mut x327: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x326, &mut x327, x325, x278, x309); + let mut x328: u32 = 0; + let mut x329: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x328, &mut x329, x327, x280, x311); + let mut x330: u32 = 0; + let mut x331: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x330, &mut x331, x329, x282, x313); + let mut x332: u32 = 0; + let mut x333: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x332, &mut x333, x331, x284, x315); + let mut x334: u32 = 0; + let mut x335: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x334, &mut x335, x333, x286, x317); + let mut x336: u32 = 0; + let mut x337: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x336, &mut x337, x335, x288, x319); + let mut x338: u32 = 0; + let mut x339: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x338, &mut x339, x337, x290, x321); + let mut x340: u32 = 0; + let mut x341: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x340, &mut x341, x339, x292, x323); + let mut x342: u32 = 0; + let mut x343: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x342, &mut x343, x324, 0x5588b13f); + let mut x344: u32 = 0; + let mut x345: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x344, &mut x345, x342, 0xffffffff); + let mut x346: u32 = 0; + let mut x347: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x346, &mut x347, x342, 0xffffffff); + let mut x348: u32 = 0; + let mut x349: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x348, &mut x349, x342, 0xffffffff); + let mut x350: u32 = 0; + let mut x351: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x350, &mut x351, x342, 0xfffffffe); + let mut x352: u32 = 0; + let mut x353: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x352, &mut x353, x342, 0xbaaedce6); + let mut x354: u32 = 0; + let mut x355: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x354, &mut x355, x342, 0xaf48a03b); + let mut x356: u32 = 0; + let mut x357: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x356, &mut x357, x342, 0xbfd25e8c); + let mut x358: u32 = 0; + let mut x359: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x358, &mut x359, x342, 0xd0364141); + let mut x360: u32 = 0; + let mut x361: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x360, &mut x361, 0x0, x359, x356); + let mut x362: u32 = 0; + let mut x363: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x362, &mut x363, x361, x357, x354); + let mut x364: u32 = 0; + let mut x365: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x364, &mut x365, x363, x355, x352); + let mut x366: u32 = 0; + let mut x367: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x366, &mut x367, x365, x353, x350); + let mut x368: u32 = 0; + let mut x369: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x368, &mut x369, x367, x351, x348); + let mut x370: u32 = 0; + let mut x371: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x370, &mut x371, x369, x349, x346); + let mut x372: u32 = 0; + let mut x373: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x372, &mut x373, x371, x347, x344); + let x374: u32 = ((x373 as u32) + x345); + let mut x375: u32 = 0; + let mut x376: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x375, &mut x376, 0x0, x324, x358); + let mut x377: u32 = 0; + let mut x378: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x377, &mut x378, x376, x326, x360); + let mut x379: u32 = 0; + let mut x380: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x379, &mut x380, x378, x328, x362); + let mut x381: u32 = 0; + let mut x382: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x381, &mut x382, x380, x330, x364); + let mut x383: u32 = 0; + let mut x384: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x383, &mut x384, x382, x332, x366); + let mut x385: u32 = 0; + let mut x386: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x385, &mut x386, x384, x334, x368); + let mut x387: u32 = 0; + let mut x388: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x387, &mut x388, x386, x336, x370); + let mut x389: u32 = 0; + let mut x390: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x389, &mut x390, x388, x338, x372); + let mut x391: u32 = 0; + let mut x392: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x391, &mut x392, x390, x340, x374); + let x393: u32 = ((x392 as u32) + (x341 as u32)); + let mut x394: u32 = 0; + let mut x395: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x394, &mut x395, x4, (arg1[7])); + let mut x396: u32 = 0; + let mut x397: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x396, &mut x397, x4, (arg1[6])); + let mut x398: u32 = 0; + let mut x399: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x398, &mut x399, x4, (arg1[5])); + let mut x400: u32 = 0; + let mut x401: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x400, &mut x401, x4, (arg1[4])); + let mut x402: u32 = 0; + let mut x403: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x402, &mut x403, x4, (arg1[3])); + let mut x404: u32 = 0; + let mut x405: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x404, &mut x405, x4, (arg1[2])); + let mut x406: u32 = 0; + let mut x407: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x406, &mut x407, x4, (arg1[1])); + let mut x408: u32 = 0; + let mut x409: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x408, &mut x409, x4, (arg1[0])); + let mut x410: u32 = 0; + let mut x411: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x410, &mut x411, 0x0, x409, x406); + let mut x412: u32 = 0; + let mut x413: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x412, &mut x413, x411, x407, x404); + let mut x414: u32 = 0; + let mut x415: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x414, &mut x415, x413, x405, x402); + let mut x416: u32 = 0; + let mut x417: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x416, &mut x417, x415, x403, x400); + let mut x418: u32 = 0; + let mut x419: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x418, &mut x419, x417, x401, x398); + let mut x420: u32 = 0; + let mut x421: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x420, &mut x421, x419, x399, x396); + let mut x422: u32 = 0; + let mut x423: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x422, &mut x423, x421, x397, x394); + let x424: u32 = ((x423 as u32) + x395); + let mut x425: u32 = 0; + let mut x426: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x425, &mut x426, 0x0, x377, x408); + let mut x427: u32 = 0; + let mut x428: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x427, &mut x428, x426, x379, x410); + let mut x429: u32 = 0; + let mut x430: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x429, &mut x430, x428, x381, x412); + let mut x431: u32 = 0; + let mut x432: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x431, &mut x432, x430, x383, x414); + let mut x433: u32 = 0; + let mut x434: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x433, &mut x434, x432, x385, x416); + let mut x435: u32 = 0; + let mut x436: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x435, &mut x436, x434, x387, x418); + let mut x437: u32 = 0; + let mut x438: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x437, &mut x438, x436, x389, x420); + let mut x439: u32 = 0; + let mut x440: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x439, &mut x440, x438, x391, x422); + let mut x441: u32 = 0; + let mut x442: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x441, &mut x442, x440, x393, x424); + let mut x443: u32 = 0; + let mut x444: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x443, &mut x444, x425, 0x5588b13f); + let mut x445: u32 = 0; + let mut x446: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x445, &mut x446, x443, 0xffffffff); + let mut x447: u32 = 0; + let mut x448: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x447, &mut x448, x443, 0xffffffff); + let mut x449: u32 = 0; + let mut x450: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x449, &mut x450, x443, 0xffffffff); + let mut x451: u32 = 0; + let mut x452: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x451, &mut x452, x443, 0xfffffffe); + let mut x453: u32 = 0; + let mut x454: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x453, &mut x454, x443, 0xbaaedce6); + let mut x455: u32 = 0; + let mut x456: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x455, &mut x456, x443, 0xaf48a03b); + let mut x457: u32 = 0; + let mut x458: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x457, &mut x458, x443, 0xbfd25e8c); + let mut x459: u32 = 0; + let mut x460: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x459, &mut x460, x443, 0xd0364141); + let mut x461: u32 = 0; + let mut x462: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x461, &mut x462, 0x0, x460, x457); + let mut x463: u32 = 0; + let mut x464: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x463, &mut x464, x462, x458, x455); + let mut x465: u32 = 0; + let mut x466: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x465, &mut x466, x464, x456, x453); + let mut x467: u32 = 0; + let mut x468: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x467, &mut x468, x466, x454, x451); + let mut x469: u32 = 0; + let mut x470: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x469, &mut x470, x468, x452, x449); + let mut x471: u32 = 0; + let mut x472: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x471, &mut x472, x470, x450, x447); + let mut x473: u32 = 0; + let mut x474: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x473, &mut x474, x472, x448, x445); + let x475: u32 = ((x474 as u32) + x446); + let mut x476: u32 = 0; + let mut x477: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x476, &mut x477, 0x0, x425, x459); + let mut x478: u32 = 0; + let mut x479: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x478, &mut x479, x477, x427, x461); + let mut x480: u32 = 0; + let mut x481: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x480, &mut x481, x479, x429, x463); + let mut x482: u32 = 0; + let mut x483: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x482, &mut x483, x481, x431, x465); + let mut x484: u32 = 0; + let mut x485: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x484, &mut x485, x483, x433, x467); + let mut x486: u32 = 0; + let mut x487: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x486, &mut x487, x485, x435, x469); + let mut x488: u32 = 0; + let mut x489: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x488, &mut x489, x487, x437, x471); + let mut x490: u32 = 0; + let mut x491: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x490, &mut x491, x489, x439, x473); + let mut x492: u32 = 0; + let mut x493: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x492, &mut x493, x491, x441, x475); + let x494: u32 = ((x493 as u32) + (x442 as u32)); + let mut x495: u32 = 0; + let mut x496: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x495, &mut x496, x5, (arg1[7])); + let mut x497: u32 = 0; + let mut x498: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x497, &mut x498, x5, (arg1[6])); + let mut x499: u32 = 0; + let mut x500: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x499, &mut x500, x5, (arg1[5])); + let mut x501: u32 = 0; + let mut x502: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x501, &mut x502, x5, (arg1[4])); + let mut x503: u32 = 0; + let mut x504: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x503, &mut x504, x5, (arg1[3])); + let mut x505: u32 = 0; + let mut x506: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x505, &mut x506, x5, (arg1[2])); + let mut x507: u32 = 0; + let mut x508: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x507, &mut x508, x5, (arg1[1])); + let mut x509: u32 = 0; + let mut x510: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x509, &mut x510, x5, (arg1[0])); + let mut x511: u32 = 0; + let mut x512: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x511, &mut x512, 0x0, x510, x507); + let mut x513: u32 = 0; + let mut x514: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x513, &mut x514, x512, x508, x505); + let mut x515: u32 = 0; + let mut x516: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x515, &mut x516, x514, x506, x503); + let mut x517: u32 = 0; + let mut x518: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x517, &mut x518, x516, x504, x501); + let mut x519: u32 = 0; + let mut x520: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x519, &mut x520, x518, x502, x499); + let mut x521: u32 = 0; + let mut x522: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x521, &mut x522, x520, x500, x497); + let mut x523: u32 = 0; + let mut x524: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x523, &mut x524, x522, x498, x495); + let x525: u32 = ((x524 as u32) + x496); + let mut x526: u32 = 0; + let mut x527: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x526, &mut x527, 0x0, x478, x509); + let mut x528: u32 = 0; + let mut x529: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x528, &mut x529, x527, x480, x511); + let mut x530: u32 = 0; + let mut x531: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x530, &mut x531, x529, x482, x513); + let mut x532: u32 = 0; + let mut x533: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x532, &mut x533, x531, x484, x515); + let mut x534: u32 = 0; + let mut x535: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x534, &mut x535, x533, x486, x517); + let mut x536: u32 = 0; + let mut x537: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x536, &mut x537, x535, x488, x519); + let mut x538: u32 = 0; + let mut x539: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x538, &mut x539, x537, x490, x521); + let mut x540: u32 = 0; + let mut x541: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x540, &mut x541, x539, x492, x523); + let mut x542: u32 = 0; + let mut x543: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x542, &mut x543, x541, x494, x525); + let mut x544: u32 = 0; + let mut x545: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x544, &mut x545, x526, 0x5588b13f); + let mut x546: u32 = 0; + let mut x547: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x546, &mut x547, x544, 0xffffffff); + let mut x548: u32 = 0; + let mut x549: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x548, &mut x549, x544, 0xffffffff); + let mut x550: u32 = 0; + let mut x551: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x550, &mut x551, x544, 0xffffffff); + let mut x552: u32 = 0; + let mut x553: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x552, &mut x553, x544, 0xfffffffe); + let mut x554: u32 = 0; + let mut x555: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x554, &mut x555, x544, 0xbaaedce6); + let mut x556: u32 = 0; + let mut x557: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x556, &mut x557, x544, 0xaf48a03b); + let mut x558: u32 = 0; + let mut x559: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x558, &mut x559, x544, 0xbfd25e8c); + let mut x560: u32 = 0; + let mut x561: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x560, &mut x561, x544, 0xd0364141); + let mut x562: u32 = 0; + let mut x563: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x562, &mut x563, 0x0, x561, x558); + let mut x564: u32 = 0; + let mut x565: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x564, &mut x565, x563, x559, x556); + let mut x566: u32 = 0; + let mut x567: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x566, &mut x567, x565, x557, x554); + let mut x568: u32 = 0; + let mut x569: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x568, &mut x569, x567, x555, x552); + let mut x570: u32 = 0; + let mut x571: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x570, &mut x571, x569, x553, x550); + let mut x572: u32 = 0; + let mut x573: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x572, &mut x573, x571, x551, x548); + let mut x574: u32 = 0; + let mut x575: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x574, &mut x575, x573, x549, x546); + let x576: u32 = ((x575 as u32) + x547); + let mut x577: u32 = 0; + let mut x578: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x577, &mut x578, 0x0, x526, x560); + let mut x579: u32 = 0; + let mut x580: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x579, &mut x580, x578, x528, x562); + let mut x581: u32 = 0; + let mut x582: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x581, &mut x582, x580, x530, x564); + let mut x583: u32 = 0; + let mut x584: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x583, &mut x584, x582, x532, x566); + let mut x585: u32 = 0; + let mut x586: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x585, &mut x586, x584, x534, x568); + let mut x587: u32 = 0; + let mut x588: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x587, &mut x588, x586, x536, x570); + let mut x589: u32 = 0; + let mut x590: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x589, &mut x590, x588, x538, x572); + let mut x591: u32 = 0; + let mut x592: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x591, &mut x592, x590, x540, x574); + let mut x593: u32 = 0; + let mut x594: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x593, &mut x594, x592, x542, x576); + let x595: u32 = ((x594 as u32) + (x543 as u32)); + let mut x596: u32 = 0; + let mut x597: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x596, &mut x597, x6, (arg1[7])); + let mut x598: u32 = 0; + let mut x599: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x598, &mut x599, x6, (arg1[6])); + let mut x600: u32 = 0; + let mut x601: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x600, &mut x601, x6, (arg1[5])); + let mut x602: u32 = 0; + let mut x603: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x602, &mut x603, x6, (arg1[4])); + let mut x604: u32 = 0; + let mut x605: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x604, &mut x605, x6, (arg1[3])); + let mut x606: u32 = 0; + let mut x607: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x606, &mut x607, x6, (arg1[2])); + let mut x608: u32 = 0; + let mut x609: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x608, &mut x609, x6, (arg1[1])); + let mut x610: u32 = 0; + let mut x611: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x610, &mut x611, x6, (arg1[0])); + let mut x612: u32 = 0; + let mut x613: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x612, &mut x613, 0x0, x611, x608); + let mut x614: u32 = 0; + let mut x615: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x614, &mut x615, x613, x609, x606); + let mut x616: u32 = 0; + let mut x617: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x616, &mut x617, x615, x607, x604); + let mut x618: u32 = 0; + let mut x619: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x618, &mut x619, x617, x605, x602); + let mut x620: u32 = 0; + let mut x621: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x620, &mut x621, x619, x603, x600); + let mut x622: u32 = 0; + let mut x623: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x622, &mut x623, x621, x601, x598); + let mut x624: u32 = 0; + let mut x625: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x624, &mut x625, x623, x599, x596); + let x626: u32 = ((x625 as u32) + x597); + let mut x627: u32 = 0; + let mut x628: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x627, &mut x628, 0x0, x579, x610); + let mut x629: u32 = 0; + let mut x630: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x629, &mut x630, x628, x581, x612); + let mut x631: u32 = 0; + let mut x632: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x631, &mut x632, x630, x583, x614); + let mut x633: u32 = 0; + let mut x634: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x633, &mut x634, x632, x585, x616); + let mut x635: u32 = 0; + let mut x636: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x635, &mut x636, x634, x587, x618); + let mut x637: u32 = 0; + let mut x638: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x637, &mut x638, x636, x589, x620); + let mut x639: u32 = 0; + let mut x640: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x639, &mut x640, x638, x591, x622); + let mut x641: u32 = 0; + let mut x642: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x641, &mut x642, x640, x593, x624); + let mut x643: u32 = 0; + let mut x644: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x643, &mut x644, x642, x595, x626); + let mut x645: u32 = 0; + let mut x646: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x645, &mut x646, x627, 0x5588b13f); + let mut x647: u32 = 0; + let mut x648: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x647, &mut x648, x645, 0xffffffff); + let mut x649: u32 = 0; + let mut x650: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x649, &mut x650, x645, 0xffffffff); + let mut x651: u32 = 0; + let mut x652: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x651, &mut x652, x645, 0xffffffff); + let mut x653: u32 = 0; + let mut x654: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x653, &mut x654, x645, 0xfffffffe); + let mut x655: u32 = 0; + let mut x656: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x655, &mut x656, x645, 0xbaaedce6); + let mut x657: u32 = 0; + let mut x658: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x657, &mut x658, x645, 0xaf48a03b); + let mut x659: u32 = 0; + let mut x660: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x659, &mut x660, x645, 0xbfd25e8c); + let mut x661: u32 = 0; + let mut x662: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x661, &mut x662, x645, 0xd0364141); + let mut x663: u32 = 0; + let mut x664: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x663, &mut x664, 0x0, x662, x659); + let mut x665: u32 = 0; + let mut x666: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x665, &mut x666, x664, x660, x657); + let mut x667: u32 = 0; + let mut x668: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x667, &mut x668, x666, x658, x655); + let mut x669: u32 = 0; + let mut x670: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x669, &mut x670, x668, x656, x653); + let mut x671: u32 = 0; + let mut x672: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x671, &mut x672, x670, x654, x651); + let mut x673: u32 = 0; + let mut x674: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x673, &mut x674, x672, x652, x649); + let mut x675: u32 = 0; + let mut x676: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x675, &mut x676, x674, x650, x647); + let x677: u32 = ((x676 as u32) + x648); + let mut x678: u32 = 0; + let mut x679: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x678, &mut x679, 0x0, x627, x661); + let mut x680: u32 = 0; + let mut x681: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x680, &mut x681, x679, x629, x663); + let mut x682: u32 = 0; + let mut x683: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x682, &mut x683, x681, x631, x665); + let mut x684: u32 = 0; + let mut x685: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x684, &mut x685, x683, x633, x667); + let mut x686: u32 = 0; + let mut x687: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x686, &mut x687, x685, x635, x669); + let mut x688: u32 = 0; + let mut x689: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x688, &mut x689, x687, x637, x671); + let mut x690: u32 = 0; + let mut x691: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x690, &mut x691, x689, x639, x673); + let mut x692: u32 = 0; + let mut x693: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x692, &mut x693, x691, x641, x675); + let mut x694: u32 = 0; + let mut x695: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x694, &mut x695, x693, x643, x677); + let x696: u32 = ((x695 as u32) + (x644 as u32)); + let mut x697: u32 = 0; + let mut x698: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x697, &mut x698, x7, (arg1[7])); + let mut x699: u32 = 0; + let mut x700: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x699, &mut x700, x7, (arg1[6])); + let mut x701: u32 = 0; + let mut x702: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x701, &mut x702, x7, (arg1[5])); + let mut x703: u32 = 0; + let mut x704: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x703, &mut x704, x7, (arg1[4])); + let mut x705: u32 = 0; + let mut x706: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x705, &mut x706, x7, (arg1[3])); + let mut x707: u32 = 0; + let mut x708: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x707, &mut x708, x7, (arg1[2])); + let mut x709: u32 = 0; + let mut x710: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x709, &mut x710, x7, (arg1[1])); + let mut x711: u32 = 0; + let mut x712: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x711, &mut x712, x7, (arg1[0])); + let mut x713: u32 = 0; + let mut x714: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x713, &mut x714, 0x0, x712, x709); + let mut x715: u32 = 0; + let mut x716: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x715, &mut x716, x714, x710, x707); + let mut x717: u32 = 0; + let mut x718: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x717, &mut x718, x716, x708, x705); + let mut x719: u32 = 0; + let mut x720: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x719, &mut x720, x718, x706, x703); + let mut x721: u32 = 0; + let mut x722: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x721, &mut x722, x720, x704, x701); + let mut x723: u32 = 0; + let mut x724: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x723, &mut x724, x722, x702, x699); + let mut x725: u32 = 0; + let mut x726: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x725, &mut x726, x724, x700, x697); + let x727: u32 = ((x726 as u32) + x698); + let mut x728: u32 = 0; + let mut x729: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x728, &mut x729, 0x0, x680, x711); + let mut x730: u32 = 0; + let mut x731: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x730, &mut x731, x729, x682, x713); + let mut x732: u32 = 0; + let mut x733: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x732, &mut x733, x731, x684, x715); + let mut x734: u32 = 0; + let mut x735: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x734, &mut x735, x733, x686, x717); + let mut x736: u32 = 0; + let mut x737: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x736, &mut x737, x735, x688, x719); + let mut x738: u32 = 0; + let mut x739: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x738, &mut x739, x737, x690, x721); + let mut x740: u32 = 0; + let mut x741: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x740, &mut x741, x739, x692, x723); + let mut x742: u32 = 0; + let mut x743: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x742, &mut x743, x741, x694, x725); + let mut x744: u32 = 0; + let mut x745: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x744, &mut x745, x743, x696, x727); + let mut x746: u32 = 0; + let mut x747: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x746, &mut x747, x728, 0x5588b13f); + let mut x748: u32 = 0; + let mut x749: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x748, &mut x749, x746, 0xffffffff); + let mut x750: u32 = 0; + let mut x751: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x750, &mut x751, x746, 0xffffffff); + let mut x752: u32 = 0; + let mut x753: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x752, &mut x753, x746, 0xffffffff); + let mut x754: u32 = 0; + let mut x755: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x754, &mut x755, x746, 0xfffffffe); + let mut x756: u32 = 0; + let mut x757: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x756, &mut x757, x746, 0xbaaedce6); + let mut x758: u32 = 0; + let mut x759: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x758, &mut x759, x746, 0xaf48a03b); + let mut x760: u32 = 0; + let mut x761: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x760, &mut x761, x746, 0xbfd25e8c); + let mut x762: u32 = 0; + let mut x763: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x762, &mut x763, x746, 0xd0364141); + let mut x764: u32 = 0; + let mut x765: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x764, &mut x765, 0x0, x763, x760); + let mut x766: u32 = 0; + let mut x767: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x766, &mut x767, x765, x761, x758); + let mut x768: u32 = 0; + let mut x769: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x768, &mut x769, x767, x759, x756); + let mut x770: u32 = 0; + let mut x771: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x770, &mut x771, x769, x757, x754); + let mut x772: u32 = 0; + let mut x773: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x772, &mut x773, x771, x755, x752); + let mut x774: u32 = 0; + let mut x775: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x774, &mut x775, x773, x753, x750); + let mut x776: u32 = 0; + let mut x777: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x776, &mut x777, x775, x751, x748); + let x778: u32 = ((x777 as u32) + x749); + let mut x779: u32 = 0; + let mut x780: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x779, &mut x780, 0x0, x728, x762); + let mut x781: u32 = 0; + let mut x782: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x781, &mut x782, x780, x730, x764); + let mut x783: u32 = 0; + let mut x784: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x783, &mut x784, x782, x732, x766); + let mut x785: u32 = 0; + let mut x786: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x785, &mut x786, x784, x734, x768); + let mut x787: u32 = 0; + let mut x788: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x787, &mut x788, x786, x736, x770); + let mut x789: u32 = 0; + let mut x790: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x789, &mut x790, x788, x738, x772); + let mut x791: u32 = 0; + let mut x792: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x791, &mut x792, x790, x740, x774); + let mut x793: u32 = 0; + let mut x794: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x793, &mut x794, x792, x742, x776); + let mut x795: u32 = 0; + let mut x796: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x795, &mut x796, x794, x744, x778); + let x797: u32 = ((x796 as u32) + (x745 as u32)); + let mut x798: u32 = 0; + let mut x799: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x798, &mut x799, 0x0, x781, 0xd0364141); + let mut x800: u32 = 0; + let mut x801: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x800, &mut x801, x799, x783, 0xbfd25e8c); + let mut x802: u32 = 0; + let mut x803: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x802, &mut x803, x801, x785, 0xaf48a03b); + let mut x804: u32 = 0; + let mut x805: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x804, &mut x805, x803, x787, 0xbaaedce6); + let mut x806: u32 = 0; + let mut x807: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x806, &mut x807, x805, x789, 0xfffffffe); + let mut x808: u32 = 0; + let mut x809: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x808, &mut x809, x807, x791, 0xffffffff); + let mut x810: u32 = 0; + let mut x811: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x810, &mut x811, x809, x793, 0xffffffff); + let mut x812: u32 = 0; + let mut x813: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x812, &mut x813, x811, x795, 0xffffffff); + let mut x814: u32 = 0; + let mut x815: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x814, &mut x815, x813, x797, (0x0 as u32)); + let mut x816: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x816, x815, x798, x781); + let mut x817: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x817, x815, x800, x783); + let mut x818: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x818, x815, x802, x785); + let mut x819: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x819, x815, x804, x787); + let mut x820: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x820, x815, x806, x789); + let mut x821: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x821, x815, x808, x791); + let mut x822: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x822, x815, x810, x793); + let mut x823: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x823, x815, x812, x795); + out1[0] = x816; + out1[1] = x817; + out1[2] = x818; + out1[3] = x819; + out1[4] = x820; + out1[5] = x821; + out1[6] = x822; + out1[7] = x823; +} + +/// The function fiat_secp256k1_scalar_add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_add(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_montgomery_domain_field_element, arg2: &fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u32 = 0; + let mut x4: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u32 = 0; + let mut x6: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u32 = 0; + let mut x8: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u32 = 0; + let mut x10: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u32 = 0; + let mut x12: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u32 = 0; + let mut x14: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x13, &mut x14, x12, (arg1[6]), (arg2[6])); + let mut x15: u32 = 0; + let mut x16: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x15, &mut x16, x14, (arg1[7]), (arg2[7])); + let mut x17: u32 = 0; + let mut x18: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x17, &mut x18, 0x0, x1, 0xd0364141); + let mut x19: u32 = 0; + let mut x20: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x19, &mut x20, x18, x3, 0xbfd25e8c); + let mut x21: u32 = 0; + let mut x22: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x21, &mut x22, x20, x5, 0xaf48a03b); + let mut x23: u32 = 0; + let mut x24: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x23, &mut x24, x22, x7, 0xbaaedce6); + let mut x25: u32 = 0; + let mut x26: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x25, &mut x26, x24, x9, 0xfffffffe); + let mut x27: u32 = 0; + let mut x28: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x27, &mut x28, x26, x11, 0xffffffff); + let mut x29: u32 = 0; + let mut x30: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x29, &mut x30, x28, x13, 0xffffffff); + let mut x31: u32 = 0; + let mut x32: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x31, &mut x32, x30, x15, 0xffffffff); + let mut x33: u32 = 0; + let mut x34: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x33, &mut x34, x32, (x16 as u32), (0x0 as u32)); + let mut x35: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x35, x34, x17, x1); + let mut x36: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x36, x34, x19, x3); + let mut x37: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x37, x34, x21, x5); + let mut x38: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x38, x34, x23, x7); + let mut x39: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x39, x34, x25, x9); + let mut x40: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x40, x34, x27, x11); + let mut x41: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x41, x34, x29, x13); + let mut x42: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x42, x34, x31, x15); + out1[0] = x35; + out1[1] = x36; + out1[2] = x37; + out1[3] = x38; + out1[4] = x39; + out1[5] = x40; + out1[6] = x41; + out1[7] = x42; +} + +/// The function fiat_secp256k1_scalar_sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_sub(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_montgomery_domain_field_element, arg2: &fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u32 = 0; + let mut x4: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u32 = 0; + let mut x6: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u32 = 0; + let mut x8: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u32 = 0; + let mut x10: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u32 = 0; + let mut x12: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u32 = 0; + let mut x14: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x13, &mut x14, x12, (arg1[6]), (arg2[6])); + let mut x15: u32 = 0; + let mut x16: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x15, &mut x16, x14, (arg1[7]), (arg2[7])); + let mut x17: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x17, x16, (0x0 as u32), 0xffffffff); + let mut x18: u32 = 0; + let mut x19: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x18, &mut x19, 0x0, x1, (x17 & 0xd0364141)); + let mut x20: u32 = 0; + let mut x21: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x20, &mut x21, x19, x3, (x17 & 0xbfd25e8c)); + let mut x22: u32 = 0; + let mut x23: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x22, &mut x23, x21, x5, (x17 & 0xaf48a03b)); + let mut x24: u32 = 0; + let mut x25: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x24, &mut x25, x23, x7, (x17 & 0xbaaedce6)); + let mut x26: u32 = 0; + let mut x27: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x26, &mut x27, x25, x9, (x17 & 0xfffffffe)); + let mut x28: u32 = 0; + let mut x29: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x28, &mut x29, x27, x11, x17); + let mut x30: u32 = 0; + let mut x31: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x13, x17); + let mut x32: u32 = 0; + let mut x33: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x15, x17); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/// The function fiat_secp256k1_scalar_opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_opp(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x1, &mut x2, 0x0, (0x0 as u32), (arg1[0])); + let mut x3: u32 = 0; + let mut x4: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x3, &mut x4, x2, (0x0 as u32), (arg1[1])); + let mut x5: u32 = 0; + let mut x6: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x5, &mut x6, x4, (0x0 as u32), (arg1[2])); + let mut x7: u32 = 0; + let mut x8: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x7, &mut x8, x6, (0x0 as u32), (arg1[3])); + let mut x9: u32 = 0; + let mut x10: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x9, &mut x10, x8, (0x0 as u32), (arg1[4])); + let mut x11: u32 = 0; + let mut x12: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x11, &mut x12, x10, (0x0 as u32), (arg1[5])); + let mut x13: u32 = 0; + let mut x14: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x13, &mut x14, x12, (0x0 as u32), (arg1[6])); + let mut x15: u32 = 0; + let mut x16: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x15, &mut x16, x14, (0x0 as u32), (arg1[7])); + let mut x17: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x17, x16, (0x0 as u32), 0xffffffff); + let mut x18: u32 = 0; + let mut x19: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x18, &mut x19, 0x0, x1, (x17 & 0xd0364141)); + let mut x20: u32 = 0; + let mut x21: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x20, &mut x21, x19, x3, (x17 & 0xbfd25e8c)); + let mut x22: u32 = 0; + let mut x23: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x22, &mut x23, x21, x5, (x17 & 0xaf48a03b)); + let mut x24: u32 = 0; + let mut x25: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x24, &mut x25, x23, x7, (x17 & 0xbaaedce6)); + let mut x26: u32 = 0; + let mut x27: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x26, &mut x27, x25, x9, (x17 & 0xfffffffe)); + let mut x28: u32 = 0; + let mut x29: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x28, &mut x29, x27, x11, x17); + let mut x30: u32 = 0; + let mut x31: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x13, x17); + let mut x32: u32 = 0; + let mut x33: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x15, x17); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/// The function fiat_secp256k1_scalar_from_montgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_from_montgomery(out1: &mut fiat_secp256k1_scalar_non_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[0]); + let mut x2: u32 = 0; + let mut x3: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x2, &mut x3, x1, 0x5588b13f); + let mut x4: u32 = 0; + let mut x5: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x4, &mut x5, x2, 0xffffffff); + let mut x6: u32 = 0; + let mut x7: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x6, &mut x7, x2, 0xffffffff); + let mut x8: u32 = 0; + let mut x9: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x8, &mut x9, x2, 0xffffffff); + let mut x10: u32 = 0; + let mut x11: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x10, &mut x11, x2, 0xfffffffe); + let mut x12: u32 = 0; + let mut x13: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x12, &mut x13, x2, 0xbaaedce6); + let mut x14: u32 = 0; + let mut x15: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x14, &mut x15, x2, 0xaf48a03b); + let mut x16: u32 = 0; + let mut x17: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x16, &mut x17, x2, 0xbfd25e8c); + let mut x18: u32 = 0; + let mut x19: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x18, &mut x19, x2, 0xd0364141); + let mut x20: u32 = 0; + let mut x21: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x20, &mut x21, 0x0, x19, x16); + let mut x22: u32 = 0; + let mut x23: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x22, &mut x23, x21, x17, x14); + let mut x24: u32 = 0; + let mut x25: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x24, &mut x25, x23, x15, x12); + let mut x26: u32 = 0; + let mut x27: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x26, &mut x27, x25, x13, x10); + let mut x28: u32 = 0; + let mut x29: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x28, &mut x29, x27, x11, x8); + let mut x30: u32 = 0; + let mut x31: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x9, x6); + let mut x32: u32 = 0; + let mut x33: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x7, x4); + let mut x34: u32 = 0; + let mut x35: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x34, &mut x35, 0x0, x1, x18); + let mut x36: u32 = 0; + let mut x37: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x36, &mut x37, x35, (0x0 as u32), x20); + let mut x38: u32 = 0; + let mut x39: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x38, &mut x39, x37, (0x0 as u32), x22); + let mut x40: u32 = 0; + let mut x41: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x40, &mut x41, x39, (0x0 as u32), x24); + let mut x42: u32 = 0; + let mut x43: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x42, &mut x43, x41, (0x0 as u32), x26); + let mut x44: u32 = 0; + let mut x45: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x44, &mut x45, x43, (0x0 as u32), x28); + let mut x46: u32 = 0; + let mut x47: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x46, &mut x47, x45, (0x0 as u32), x30); + let mut x48: u32 = 0; + let mut x49: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x48, &mut x49, x47, (0x0 as u32), x32); + let mut x50: u32 = 0; + let mut x51: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x50, &mut x51, x49, (0x0 as u32), ((x33 as u32) + x5)); + let mut x52: u32 = 0; + let mut x53: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x52, &mut x53, 0x0, x36, (arg1[1])); + let mut x54: u32 = 0; + let mut x55: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x54, &mut x55, x53, x38, (0x0 as u32)); + let mut x56: u32 = 0; + let mut x57: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x56, &mut x57, x55, x40, (0x0 as u32)); + let mut x58: u32 = 0; + let mut x59: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x58, &mut x59, x57, x42, (0x0 as u32)); + let mut x60: u32 = 0; + let mut x61: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x60, &mut x61, x59, x44, (0x0 as u32)); + let mut x62: u32 = 0; + let mut x63: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x62, &mut x63, x61, x46, (0x0 as u32)); + let mut x64: u32 = 0; + let mut x65: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x64, &mut x65, x63, x48, (0x0 as u32)); + let mut x66: u32 = 0; + let mut x67: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x66, &mut x67, x65, x50, (0x0 as u32)); + let mut x68: u32 = 0; + let mut x69: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x68, &mut x69, x52, 0x5588b13f); + let mut x70: u32 = 0; + let mut x71: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x70, &mut x71, x68, 0xffffffff); + let mut x72: u32 = 0; + let mut x73: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x72, &mut x73, x68, 0xffffffff); + let mut x74: u32 = 0; + let mut x75: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x74, &mut x75, x68, 0xffffffff); + let mut x76: u32 = 0; + let mut x77: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x76, &mut x77, x68, 0xfffffffe); + let mut x78: u32 = 0; + let mut x79: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x78, &mut x79, x68, 0xbaaedce6); + let mut x80: u32 = 0; + let mut x81: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x80, &mut x81, x68, 0xaf48a03b); + let mut x82: u32 = 0; + let mut x83: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x82, &mut x83, x68, 0xbfd25e8c); + let mut x84: u32 = 0; + let mut x85: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x84, &mut x85, x68, 0xd0364141); + let mut x86: u32 = 0; + let mut x87: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x86, &mut x87, 0x0, x85, x82); + let mut x88: u32 = 0; + let mut x89: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x88, &mut x89, x87, x83, x80); + let mut x90: u32 = 0; + let mut x91: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x90, &mut x91, x89, x81, x78); + let mut x92: u32 = 0; + let mut x93: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x92, &mut x93, x91, x79, x76); + let mut x94: u32 = 0; + let mut x95: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x94, &mut x95, x93, x77, x74); + let mut x96: u32 = 0; + let mut x97: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x96, &mut x97, x95, x75, x72); + let mut x98: u32 = 0; + let mut x99: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x98, &mut x99, x97, x73, x70); + let mut x100: u32 = 0; + let mut x101: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x100, &mut x101, 0x0, x52, x84); + let mut x102: u32 = 0; + let mut x103: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x102, &mut x103, x101, x54, x86); + let mut x104: u32 = 0; + let mut x105: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x104, &mut x105, x103, x56, x88); + let mut x106: u32 = 0; + let mut x107: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x106, &mut x107, x105, x58, x90); + let mut x108: u32 = 0; + let mut x109: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x108, &mut x109, x107, x60, x92); + let mut x110: u32 = 0; + let mut x111: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x110, &mut x111, x109, x62, x94); + let mut x112: u32 = 0; + let mut x113: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x112, &mut x113, x111, x64, x96); + let mut x114: u32 = 0; + let mut x115: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x114, &mut x115, x113, x66, x98); + let mut x116: u32 = 0; + let mut x117: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x116, &mut x117, x115, ((x67 as u32) + (x51 as u32)), ((x99 as u32) + x71)); + let mut x118: u32 = 0; + let mut x119: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x118, &mut x119, 0x0, x102, (arg1[2])); + let mut x120: u32 = 0; + let mut x121: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x120, &mut x121, x119, x104, (0x0 as u32)); + let mut x122: u32 = 0; + let mut x123: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x122, &mut x123, x121, x106, (0x0 as u32)); + let mut x124: u32 = 0; + let mut x125: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x108, (0x0 as u32)); + let mut x126: u32 = 0; + let mut x127: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x126, &mut x127, x125, x110, (0x0 as u32)); + let mut x128: u32 = 0; + let mut x129: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x128, &mut x129, x127, x112, (0x0 as u32)); + let mut x130: u32 = 0; + let mut x131: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x130, &mut x131, x129, x114, (0x0 as u32)); + let mut x132: u32 = 0; + let mut x133: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x132, &mut x133, x131, x116, (0x0 as u32)); + let mut x134: u32 = 0; + let mut x135: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x134, &mut x135, x118, 0x5588b13f); + let mut x136: u32 = 0; + let mut x137: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x136, &mut x137, x134, 0xffffffff); + let mut x138: u32 = 0; + let mut x139: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x138, &mut x139, x134, 0xffffffff); + let mut x140: u32 = 0; + let mut x141: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x140, &mut x141, x134, 0xffffffff); + let mut x142: u32 = 0; + let mut x143: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x142, &mut x143, x134, 0xfffffffe); + let mut x144: u32 = 0; + let mut x145: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x144, &mut x145, x134, 0xbaaedce6); + let mut x146: u32 = 0; + let mut x147: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x146, &mut x147, x134, 0xaf48a03b); + let mut x148: u32 = 0; + let mut x149: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x148, &mut x149, x134, 0xbfd25e8c); + let mut x150: u32 = 0; + let mut x151: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x150, &mut x151, x134, 0xd0364141); + let mut x152: u32 = 0; + let mut x153: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x152, &mut x153, 0x0, x151, x148); + let mut x154: u32 = 0; + let mut x155: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x154, &mut x155, x153, x149, x146); + let mut x156: u32 = 0; + let mut x157: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x156, &mut x157, x155, x147, x144); + let mut x158: u32 = 0; + let mut x159: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x158, &mut x159, x157, x145, x142); + let mut x160: u32 = 0; + let mut x161: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x143, x140); + let mut x162: u32 = 0; + let mut x163: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x162, &mut x163, x161, x141, x138); + let mut x164: u32 = 0; + let mut x165: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x164, &mut x165, x163, x139, x136); + let mut x166: u32 = 0; + let mut x167: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x166, &mut x167, 0x0, x118, x150); + let mut x168: u32 = 0; + let mut x169: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x168, &mut x169, x167, x120, x152); + let mut x170: u32 = 0; + let mut x171: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x170, &mut x171, x169, x122, x154); + let mut x172: u32 = 0; + let mut x173: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x172, &mut x173, x171, x124, x156); + let mut x174: u32 = 0; + let mut x175: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x174, &mut x175, x173, x126, x158); + let mut x176: u32 = 0; + let mut x177: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x176, &mut x177, x175, x128, x160); + let mut x178: u32 = 0; + let mut x179: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x178, &mut x179, x177, x130, x162); + let mut x180: u32 = 0; + let mut x181: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x180, &mut x181, x179, x132, x164); + let mut x182: u32 = 0; + let mut x183: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x182, &mut x183, x181, ((x133 as u32) + (x117 as u32)), ((x165 as u32) + x137)); + let mut x184: u32 = 0; + let mut x185: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x184, &mut x185, 0x0, x168, (arg1[3])); + let mut x186: u32 = 0; + let mut x187: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x186, &mut x187, x185, x170, (0x0 as u32)); + let mut x188: u32 = 0; + let mut x189: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x188, &mut x189, x187, x172, (0x0 as u32)); + let mut x190: u32 = 0; + let mut x191: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x190, &mut x191, x189, x174, (0x0 as u32)); + let mut x192: u32 = 0; + let mut x193: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x192, &mut x193, x191, x176, (0x0 as u32)); + let mut x194: u32 = 0; + let mut x195: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x194, &mut x195, x193, x178, (0x0 as u32)); + let mut x196: u32 = 0; + let mut x197: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x196, &mut x197, x195, x180, (0x0 as u32)); + let mut x198: u32 = 0; + let mut x199: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x198, &mut x199, x197, x182, (0x0 as u32)); + let mut x200: u32 = 0; + let mut x201: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x200, &mut x201, x184, 0x5588b13f); + let mut x202: u32 = 0; + let mut x203: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x202, &mut x203, x200, 0xffffffff); + let mut x204: u32 = 0; + let mut x205: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x204, &mut x205, x200, 0xffffffff); + let mut x206: u32 = 0; + let mut x207: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x206, &mut x207, x200, 0xffffffff); + let mut x208: u32 = 0; + let mut x209: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x208, &mut x209, x200, 0xfffffffe); + let mut x210: u32 = 0; + let mut x211: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x210, &mut x211, x200, 0xbaaedce6); + let mut x212: u32 = 0; + let mut x213: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x212, &mut x213, x200, 0xaf48a03b); + let mut x214: u32 = 0; + let mut x215: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x214, &mut x215, x200, 0xbfd25e8c); + let mut x216: u32 = 0; + let mut x217: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x216, &mut x217, x200, 0xd0364141); + let mut x218: u32 = 0; + let mut x219: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x218, &mut x219, 0x0, x217, x214); + let mut x220: u32 = 0; + let mut x221: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x220, &mut x221, x219, x215, x212); + let mut x222: u32 = 0; + let mut x223: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x222, &mut x223, x221, x213, x210); + let mut x224: u32 = 0; + let mut x225: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x224, &mut x225, x223, x211, x208); + let mut x226: u32 = 0; + let mut x227: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x226, &mut x227, x225, x209, x206); + let mut x228: u32 = 0; + let mut x229: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x228, &mut x229, x227, x207, x204); + let mut x230: u32 = 0; + let mut x231: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x230, &mut x231, x229, x205, x202); + let mut x232: u32 = 0; + let mut x233: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x232, &mut x233, 0x0, x184, x216); + let mut x234: u32 = 0; + let mut x235: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x234, &mut x235, x233, x186, x218); + let mut x236: u32 = 0; + let mut x237: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x236, &mut x237, x235, x188, x220); + let mut x238: u32 = 0; + let mut x239: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x238, &mut x239, x237, x190, x222); + let mut x240: u32 = 0; + let mut x241: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x240, &mut x241, x239, x192, x224); + let mut x242: u32 = 0; + let mut x243: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x242, &mut x243, x241, x194, x226); + let mut x244: u32 = 0; + let mut x245: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x244, &mut x245, x243, x196, x228); + let mut x246: u32 = 0; + let mut x247: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x246, &mut x247, x245, x198, x230); + let mut x248: u32 = 0; + let mut x249: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x248, &mut x249, x247, ((x199 as u32) + (x183 as u32)), ((x231 as u32) + x203)); + let mut x250: u32 = 0; + let mut x251: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x250, &mut x251, 0x0, x234, (arg1[4])); + let mut x252: u32 = 0; + let mut x253: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x252, &mut x253, x251, x236, (0x0 as u32)); + let mut x254: u32 = 0; + let mut x255: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x254, &mut x255, x253, x238, (0x0 as u32)); + let mut x256: u32 = 0; + let mut x257: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x256, &mut x257, x255, x240, (0x0 as u32)); + let mut x258: u32 = 0; + let mut x259: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x258, &mut x259, x257, x242, (0x0 as u32)); + let mut x260: u32 = 0; + let mut x261: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x260, &mut x261, x259, x244, (0x0 as u32)); + let mut x262: u32 = 0; + let mut x263: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x262, &mut x263, x261, x246, (0x0 as u32)); + let mut x264: u32 = 0; + let mut x265: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x264, &mut x265, x263, x248, (0x0 as u32)); + let mut x266: u32 = 0; + let mut x267: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x266, &mut x267, x250, 0x5588b13f); + let mut x268: u32 = 0; + let mut x269: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x268, &mut x269, x266, 0xffffffff); + let mut x270: u32 = 0; + let mut x271: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x270, &mut x271, x266, 0xffffffff); + let mut x272: u32 = 0; + let mut x273: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x272, &mut x273, x266, 0xffffffff); + let mut x274: u32 = 0; + let mut x275: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x274, &mut x275, x266, 0xfffffffe); + let mut x276: u32 = 0; + let mut x277: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x276, &mut x277, x266, 0xbaaedce6); + let mut x278: u32 = 0; + let mut x279: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x278, &mut x279, x266, 0xaf48a03b); + let mut x280: u32 = 0; + let mut x281: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x280, &mut x281, x266, 0xbfd25e8c); + let mut x282: u32 = 0; + let mut x283: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x282, &mut x283, x266, 0xd0364141); + let mut x284: u32 = 0; + let mut x285: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x284, &mut x285, 0x0, x283, x280); + let mut x286: u32 = 0; + let mut x287: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x286, &mut x287, x285, x281, x278); + let mut x288: u32 = 0; + let mut x289: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x288, &mut x289, x287, x279, x276); + let mut x290: u32 = 0; + let mut x291: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x290, &mut x291, x289, x277, x274); + let mut x292: u32 = 0; + let mut x293: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x292, &mut x293, x291, x275, x272); + let mut x294: u32 = 0; + let mut x295: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x294, &mut x295, x293, x273, x270); + let mut x296: u32 = 0; + let mut x297: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x296, &mut x297, x295, x271, x268); + let mut x298: u32 = 0; + let mut x299: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x298, &mut x299, 0x0, x250, x282); + let mut x300: u32 = 0; + let mut x301: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x300, &mut x301, x299, x252, x284); + let mut x302: u32 = 0; + let mut x303: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x302, &mut x303, x301, x254, x286); + let mut x304: u32 = 0; + let mut x305: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x304, &mut x305, x303, x256, x288); + let mut x306: u32 = 0; + let mut x307: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x306, &mut x307, x305, x258, x290); + let mut x308: u32 = 0; + let mut x309: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x308, &mut x309, x307, x260, x292); + let mut x310: u32 = 0; + let mut x311: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x310, &mut x311, x309, x262, x294); + let mut x312: u32 = 0; + let mut x313: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x312, &mut x313, x311, x264, x296); + let mut x314: u32 = 0; + let mut x315: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x314, &mut x315, x313, ((x265 as u32) + (x249 as u32)), ((x297 as u32) + x269)); + let mut x316: u32 = 0; + let mut x317: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x316, &mut x317, 0x0, x300, (arg1[5])); + let mut x318: u32 = 0; + let mut x319: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x318, &mut x319, x317, x302, (0x0 as u32)); + let mut x320: u32 = 0; + let mut x321: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x320, &mut x321, x319, x304, (0x0 as u32)); + let mut x322: u32 = 0; + let mut x323: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x322, &mut x323, x321, x306, (0x0 as u32)); + let mut x324: u32 = 0; + let mut x325: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x324, &mut x325, x323, x308, (0x0 as u32)); + let mut x326: u32 = 0; + let mut x327: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x326, &mut x327, x325, x310, (0x0 as u32)); + let mut x328: u32 = 0; + let mut x329: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x328, &mut x329, x327, x312, (0x0 as u32)); + let mut x330: u32 = 0; + let mut x331: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x330, &mut x331, x329, x314, (0x0 as u32)); + let mut x332: u32 = 0; + let mut x333: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x332, &mut x333, x316, 0x5588b13f); + let mut x334: u32 = 0; + let mut x335: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x334, &mut x335, x332, 0xffffffff); + let mut x336: u32 = 0; + let mut x337: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x336, &mut x337, x332, 0xffffffff); + let mut x338: u32 = 0; + let mut x339: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x338, &mut x339, x332, 0xffffffff); + let mut x340: u32 = 0; + let mut x341: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x340, &mut x341, x332, 0xfffffffe); + let mut x342: u32 = 0; + let mut x343: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x342, &mut x343, x332, 0xbaaedce6); + let mut x344: u32 = 0; + let mut x345: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x344, &mut x345, x332, 0xaf48a03b); + let mut x346: u32 = 0; + let mut x347: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x346, &mut x347, x332, 0xbfd25e8c); + let mut x348: u32 = 0; + let mut x349: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x348, &mut x349, x332, 0xd0364141); + let mut x350: u32 = 0; + let mut x351: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x350, &mut x351, 0x0, x349, x346); + let mut x352: u32 = 0; + let mut x353: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x352, &mut x353, x351, x347, x344); + let mut x354: u32 = 0; + let mut x355: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x354, &mut x355, x353, x345, x342); + let mut x356: u32 = 0; + let mut x357: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x356, &mut x357, x355, x343, x340); + let mut x358: u32 = 0; + let mut x359: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x358, &mut x359, x357, x341, x338); + let mut x360: u32 = 0; + let mut x361: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x360, &mut x361, x359, x339, x336); + let mut x362: u32 = 0; + let mut x363: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x362, &mut x363, x361, x337, x334); + let mut x364: u32 = 0; + let mut x365: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x364, &mut x365, 0x0, x316, x348); + let mut x366: u32 = 0; + let mut x367: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x366, &mut x367, x365, x318, x350); + let mut x368: u32 = 0; + let mut x369: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x368, &mut x369, x367, x320, x352); + let mut x370: u32 = 0; + let mut x371: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x370, &mut x371, x369, x322, x354); + let mut x372: u32 = 0; + let mut x373: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x372, &mut x373, x371, x324, x356); + let mut x374: u32 = 0; + let mut x375: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x374, &mut x375, x373, x326, x358); + let mut x376: u32 = 0; + let mut x377: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x376, &mut x377, x375, x328, x360); + let mut x378: u32 = 0; + let mut x379: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x378, &mut x379, x377, x330, x362); + let mut x380: u32 = 0; + let mut x381: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x380, &mut x381, x379, ((x331 as u32) + (x315 as u32)), ((x363 as u32) + x335)); + let mut x382: u32 = 0; + let mut x383: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x382, &mut x383, 0x0, x366, (arg1[6])); + let mut x384: u32 = 0; + let mut x385: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x384, &mut x385, x383, x368, (0x0 as u32)); + let mut x386: u32 = 0; + let mut x387: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x386, &mut x387, x385, x370, (0x0 as u32)); + let mut x388: u32 = 0; + let mut x389: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x388, &mut x389, x387, x372, (0x0 as u32)); + let mut x390: u32 = 0; + let mut x391: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x390, &mut x391, x389, x374, (0x0 as u32)); + let mut x392: u32 = 0; + let mut x393: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x392, &mut x393, x391, x376, (0x0 as u32)); + let mut x394: u32 = 0; + let mut x395: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x394, &mut x395, x393, x378, (0x0 as u32)); + let mut x396: u32 = 0; + let mut x397: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x396, &mut x397, x395, x380, (0x0 as u32)); + let mut x398: u32 = 0; + let mut x399: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x398, &mut x399, x382, 0x5588b13f); + let mut x400: u32 = 0; + let mut x401: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x400, &mut x401, x398, 0xffffffff); + let mut x402: u32 = 0; + let mut x403: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x402, &mut x403, x398, 0xffffffff); + let mut x404: u32 = 0; + let mut x405: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x404, &mut x405, x398, 0xffffffff); + let mut x406: u32 = 0; + let mut x407: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x406, &mut x407, x398, 0xfffffffe); + let mut x408: u32 = 0; + let mut x409: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x408, &mut x409, x398, 0xbaaedce6); + let mut x410: u32 = 0; + let mut x411: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x410, &mut x411, x398, 0xaf48a03b); + let mut x412: u32 = 0; + let mut x413: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x412, &mut x413, x398, 0xbfd25e8c); + let mut x414: u32 = 0; + let mut x415: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x414, &mut x415, x398, 0xd0364141); + let mut x416: u32 = 0; + let mut x417: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x416, &mut x417, 0x0, x415, x412); + let mut x418: u32 = 0; + let mut x419: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x418, &mut x419, x417, x413, x410); + let mut x420: u32 = 0; + let mut x421: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x420, &mut x421, x419, x411, x408); + let mut x422: u32 = 0; + let mut x423: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x422, &mut x423, x421, x409, x406); + let mut x424: u32 = 0; + let mut x425: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x424, &mut x425, x423, x407, x404); + let mut x426: u32 = 0; + let mut x427: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x426, &mut x427, x425, x405, x402); + let mut x428: u32 = 0; + let mut x429: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x428, &mut x429, x427, x403, x400); + let mut x430: u32 = 0; + let mut x431: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x430, &mut x431, 0x0, x382, x414); + let mut x432: u32 = 0; + let mut x433: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x432, &mut x433, x431, x384, x416); + let mut x434: u32 = 0; + let mut x435: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x434, &mut x435, x433, x386, x418); + let mut x436: u32 = 0; + let mut x437: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x436, &mut x437, x435, x388, x420); + let mut x438: u32 = 0; + let mut x439: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x438, &mut x439, x437, x390, x422); + let mut x440: u32 = 0; + let mut x441: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x440, &mut x441, x439, x392, x424); + let mut x442: u32 = 0; + let mut x443: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x442, &mut x443, x441, x394, x426); + let mut x444: u32 = 0; + let mut x445: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x444, &mut x445, x443, x396, x428); + let mut x446: u32 = 0; + let mut x447: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x446, &mut x447, x445, ((x397 as u32) + (x381 as u32)), ((x429 as u32) + x401)); + let mut x448: u32 = 0; + let mut x449: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x448, &mut x449, 0x0, x432, (arg1[7])); + let mut x450: u32 = 0; + let mut x451: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x450, &mut x451, x449, x434, (0x0 as u32)); + let mut x452: u32 = 0; + let mut x453: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x452, &mut x453, x451, x436, (0x0 as u32)); + let mut x454: u32 = 0; + let mut x455: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x454, &mut x455, x453, x438, (0x0 as u32)); + let mut x456: u32 = 0; + let mut x457: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x456, &mut x457, x455, x440, (0x0 as u32)); + let mut x458: u32 = 0; + let mut x459: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x458, &mut x459, x457, x442, (0x0 as u32)); + let mut x460: u32 = 0; + let mut x461: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x460, &mut x461, x459, x444, (0x0 as u32)); + let mut x462: u32 = 0; + let mut x463: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x462, &mut x463, x461, x446, (0x0 as u32)); + let mut x464: u32 = 0; + let mut x465: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x464, &mut x465, x448, 0x5588b13f); + let mut x466: u32 = 0; + let mut x467: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x466, &mut x467, x464, 0xffffffff); + let mut x468: u32 = 0; + let mut x469: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x468, &mut x469, x464, 0xffffffff); + let mut x470: u32 = 0; + let mut x471: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x470, &mut x471, x464, 0xffffffff); + let mut x472: u32 = 0; + let mut x473: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x472, &mut x473, x464, 0xfffffffe); + let mut x474: u32 = 0; + let mut x475: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x474, &mut x475, x464, 0xbaaedce6); + let mut x476: u32 = 0; + let mut x477: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x476, &mut x477, x464, 0xaf48a03b); + let mut x478: u32 = 0; + let mut x479: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x478, &mut x479, x464, 0xbfd25e8c); + let mut x480: u32 = 0; + let mut x481: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x480, &mut x481, x464, 0xd0364141); + let mut x482: u32 = 0; + let mut x483: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x482, &mut x483, 0x0, x481, x478); + let mut x484: u32 = 0; + let mut x485: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x484, &mut x485, x483, x479, x476); + let mut x486: u32 = 0; + let mut x487: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x486, &mut x487, x485, x477, x474); + let mut x488: u32 = 0; + let mut x489: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x488, &mut x489, x487, x475, x472); + let mut x490: u32 = 0; + let mut x491: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x490, &mut x491, x489, x473, x470); + let mut x492: u32 = 0; + let mut x493: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x492, &mut x493, x491, x471, x468); + let mut x494: u32 = 0; + let mut x495: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x494, &mut x495, x493, x469, x466); + let mut x496: u32 = 0; + let mut x497: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x496, &mut x497, 0x0, x448, x480); + let mut x498: u32 = 0; + let mut x499: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x498, &mut x499, x497, x450, x482); + let mut x500: u32 = 0; + let mut x501: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x500, &mut x501, x499, x452, x484); + let mut x502: u32 = 0; + let mut x503: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x502, &mut x503, x501, x454, x486); + let mut x504: u32 = 0; + let mut x505: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x504, &mut x505, x503, x456, x488); + let mut x506: u32 = 0; + let mut x507: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x506, &mut x507, x505, x458, x490); + let mut x508: u32 = 0; + let mut x509: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x508, &mut x509, x507, x460, x492); + let mut x510: u32 = 0; + let mut x511: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x510, &mut x511, x509, x462, x494); + let mut x512: u32 = 0; + let mut x513: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x512, &mut x513, x511, ((x463 as u32) + (x447 as u32)), ((x495 as u32) + x467)); + let mut x514: u32 = 0; + let mut x515: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x514, &mut x515, 0x0, x498, 0xd0364141); + let mut x516: u32 = 0; + let mut x517: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x516, &mut x517, x515, x500, 0xbfd25e8c); + let mut x518: u32 = 0; + let mut x519: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x518, &mut x519, x517, x502, 0xaf48a03b); + let mut x520: u32 = 0; + let mut x521: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x520, &mut x521, x519, x504, 0xbaaedce6); + let mut x522: u32 = 0; + let mut x523: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x522, &mut x523, x521, x506, 0xfffffffe); + let mut x524: u32 = 0; + let mut x525: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x524, &mut x525, x523, x508, 0xffffffff); + let mut x526: u32 = 0; + let mut x527: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x526, &mut x527, x525, x510, 0xffffffff); + let mut x528: u32 = 0; + let mut x529: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x528, &mut x529, x527, x512, 0xffffffff); + let mut x530: u32 = 0; + let mut x531: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x530, &mut x531, x529, (x513 as u32), (0x0 as u32)); + let mut x532: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x532, x531, x514, x498); + let mut x533: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x533, x531, x516, x500); + let mut x534: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x534, x531, x518, x502); + let mut x535: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x535, x531, x520, x504); + let mut x536: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x536, x531, x522, x506); + let mut x537: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x537, x531, x524, x508); + let mut x538: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x538, x531, x526, x510); + let mut x539: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x539, x531, x528, x512); + out1[0] = x532; + out1[1] = x533; + out1[2] = x534; + out1[3] = x535; + out1[4] = x536; + out1[5] = x537; + out1[6] = x538; + out1[7] = x539; +} + +/// The function fiat_secp256k1_scalar_to_montgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_to_montgomery(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_non_montgomery_domain_field_element) -> () { + let x1: u32 = (arg1[1]); + let x2: u32 = (arg1[2]); + let x3: u32 = (arg1[3]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[5]); + let x6: u32 = (arg1[6]); + let x7: u32 = (arg1[7]); + let x8: u32 = (arg1[0]); + let mut x9: u32 = 0; + let mut x10: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x9, &mut x10, x8, 0x9d671cd5); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x11, &mut x12, x8, 0x81c69bc5); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x13, &mut x14, x8, 0xe697f5e4); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x15, &mut x16, x8, 0x5bcd07c6); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x17, &mut x18, x8, 0x741496c2); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x19, &mut x20, x8, 0xe7cf878); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x21, &mut x22, x8, 0x896cf214); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x23, &mut x24, x8, 0x67d7d140); + let mut x25: u32 = 0; + let mut x26: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x37, &mut x38, x36, x12, x9); + let mut x39: u32 = 0; + let mut x40: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x39, &mut x40, x23, 0x5588b13f); + let mut x41: u32 = 0; + let mut x42: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x41, &mut x42, x39, 0xffffffff); + let mut x43: u32 = 0; + let mut x44: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x43, &mut x44, x39, 0xffffffff); + let mut x45: u32 = 0; + let mut x46: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x45, &mut x46, x39, 0xffffffff); + let mut x47: u32 = 0; + let mut x48: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x47, &mut x48, x39, 0xfffffffe); + let mut x49: u32 = 0; + let mut x50: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x49, &mut x50, x39, 0xbaaedce6); + let mut x51: u32 = 0; + let mut x52: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x51, &mut x52, x39, 0xaf48a03b); + let mut x53: u32 = 0; + let mut x54: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x53, &mut x54, x39, 0xbfd25e8c); + let mut x55: u32 = 0; + let mut x56: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x55, &mut x56, x39, 0xd0364141); + let mut x57: u32 = 0; + let mut x58: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x57, &mut x58, 0x0, x56, x53); + let mut x59: u32 = 0; + let mut x60: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x59, &mut x60, x58, x54, x51); + let mut x61: u32 = 0; + let mut x62: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x61, &mut x62, x60, x52, x49); + let mut x63: u32 = 0; + let mut x64: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x63, &mut x64, x62, x50, x47); + let mut x65: u32 = 0; + let mut x66: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x65, &mut x66, x64, x48, x45); + let mut x67: u32 = 0; + let mut x68: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x67, &mut x68, x66, x46, x43); + let mut x69: u32 = 0; + let mut x70: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x69, &mut x70, x68, x44, x41); + let mut x71: u32 = 0; + let mut x72: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x71, &mut x72, 0x0, x23, x55); + let mut x73: u32 = 0; + let mut x74: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x73, &mut x74, x72, x25, x57); + let mut x75: u32 = 0; + let mut x76: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x75, &mut x76, x74, x27, x59); + let mut x77: u32 = 0; + let mut x78: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x77, &mut x78, x76, x29, x61); + let mut x79: u32 = 0; + let mut x80: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x79, &mut x80, x78, x31, x63); + let mut x81: u32 = 0; + let mut x82: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x81, &mut x82, x80, x33, x65); + let mut x83: u32 = 0; + let mut x84: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x83, &mut x84, x82, x35, x67); + let mut x85: u32 = 0; + let mut x86: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x85, &mut x86, x84, x37, x69); + let mut x87: u32 = 0; + let mut x88: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x87, &mut x88, x86, ((x38 as u32) + x10), ((x70 as u32) + x42)); + let mut x89: u32 = 0; + let mut x90: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x89, &mut x90, x1, 0x9d671cd5); + let mut x91: u32 = 0; + let mut x92: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x91, &mut x92, x1, 0x81c69bc5); + let mut x93: u32 = 0; + let mut x94: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x93, &mut x94, x1, 0xe697f5e4); + let mut x95: u32 = 0; + let mut x96: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x95, &mut x96, x1, 0x5bcd07c6); + let mut x97: u32 = 0; + let mut x98: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x97, &mut x98, x1, 0x741496c2); + let mut x99: u32 = 0; + let mut x100: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x99, &mut x100, x1, 0xe7cf878); + let mut x101: u32 = 0; + let mut x102: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x101, &mut x102, x1, 0x896cf214); + let mut x103: u32 = 0; + let mut x104: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x103, &mut x104, x1, 0x67d7d140); + let mut x105: u32 = 0; + let mut x106: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x105, &mut x106, 0x0, x104, x101); + let mut x107: u32 = 0; + let mut x108: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x107, &mut x108, x106, x102, x99); + let mut x109: u32 = 0; + let mut x110: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x109, &mut x110, x108, x100, x97); + let mut x111: u32 = 0; + let mut x112: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x98, x95); + let mut x113: u32 = 0; + let mut x114: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x113, &mut x114, x112, x96, x93); + let mut x115: u32 = 0; + let mut x116: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x115, &mut x116, x114, x94, x91); + let mut x117: u32 = 0; + let mut x118: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x117, &mut x118, x116, x92, x89); + let mut x119: u32 = 0; + let mut x120: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x119, &mut x120, 0x0, x73, x103); + let mut x121: u32 = 0; + let mut x122: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x121, &mut x122, x120, x75, x105); + let mut x123: u32 = 0; + let mut x124: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x123, &mut x124, x122, x77, x107); + let mut x125: u32 = 0; + let mut x126: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x125, &mut x126, x124, x79, x109); + let mut x127: u32 = 0; + let mut x128: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x127, &mut x128, x126, x81, x111); + let mut x129: u32 = 0; + let mut x130: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x129, &mut x130, x128, x83, x113); + let mut x131: u32 = 0; + let mut x132: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x131, &mut x132, x130, x85, x115); + let mut x133: u32 = 0; + let mut x134: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x133, &mut x134, x132, x87, x117); + let mut x135: u32 = 0; + let mut x136: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x135, &mut x136, x119, 0x5588b13f); + let mut x137: u32 = 0; + let mut x138: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x137, &mut x138, x135, 0xffffffff); + let mut x139: u32 = 0; + let mut x140: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x139, &mut x140, x135, 0xffffffff); + let mut x141: u32 = 0; + let mut x142: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x141, &mut x142, x135, 0xffffffff); + let mut x143: u32 = 0; + let mut x144: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x143, &mut x144, x135, 0xfffffffe); + let mut x145: u32 = 0; + let mut x146: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x145, &mut x146, x135, 0xbaaedce6); + let mut x147: u32 = 0; + let mut x148: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x147, &mut x148, x135, 0xaf48a03b); + let mut x149: u32 = 0; + let mut x150: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x149, &mut x150, x135, 0xbfd25e8c); + let mut x151: u32 = 0; + let mut x152: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x151, &mut x152, x135, 0xd0364141); + let mut x153: u32 = 0; + let mut x154: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x153, &mut x154, 0x0, x152, x149); + let mut x155: u32 = 0; + let mut x156: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x155, &mut x156, x154, x150, x147); + let mut x157: u32 = 0; + let mut x158: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x157, &mut x158, x156, x148, x145); + let mut x159: u32 = 0; + let mut x160: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x159, &mut x160, x158, x146, x143); + let mut x161: u32 = 0; + let mut x162: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x161, &mut x162, x160, x144, x141); + let mut x163: u32 = 0; + let mut x164: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x163, &mut x164, x162, x142, x139); + let mut x165: u32 = 0; + let mut x166: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x165, &mut x166, x164, x140, x137); + let mut x167: u32 = 0; + let mut x168: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x167, &mut x168, 0x0, x119, x151); + let mut x169: u32 = 0; + let mut x170: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x169, &mut x170, x168, x121, x153); + let mut x171: u32 = 0; + let mut x172: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x171, &mut x172, x170, x123, x155); + let mut x173: u32 = 0; + let mut x174: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x173, &mut x174, x172, x125, x157); + let mut x175: u32 = 0; + let mut x176: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x175, &mut x176, x174, x127, x159); + let mut x177: u32 = 0; + let mut x178: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x177, &mut x178, x176, x129, x161); + let mut x179: u32 = 0; + let mut x180: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x179, &mut x180, x178, x131, x163); + let mut x181: u32 = 0; + let mut x182: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x181, &mut x182, x180, x133, x165); + let mut x183: u32 = 0; + let mut x184: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x183, &mut x184, x182, (((x134 as u32) + (x88 as u32)) + ((x118 as u32) + x90)), ((x166 as u32) + x138)); + let mut x185: u32 = 0; + let mut x186: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x185, &mut x186, x2, 0x9d671cd5); + let mut x187: u32 = 0; + let mut x188: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x187, &mut x188, x2, 0x81c69bc5); + let mut x189: u32 = 0; + let mut x190: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x189, &mut x190, x2, 0xe697f5e4); + let mut x191: u32 = 0; + let mut x192: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x191, &mut x192, x2, 0x5bcd07c6); + let mut x193: u32 = 0; + let mut x194: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x193, &mut x194, x2, 0x741496c2); + let mut x195: u32 = 0; + let mut x196: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x195, &mut x196, x2, 0xe7cf878); + let mut x197: u32 = 0; + let mut x198: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x197, &mut x198, x2, 0x896cf214); + let mut x199: u32 = 0; + let mut x200: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x199, &mut x200, x2, 0x67d7d140); + let mut x201: u32 = 0; + let mut x202: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x201, &mut x202, 0x0, x200, x197); + let mut x203: u32 = 0; + let mut x204: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x203, &mut x204, x202, x198, x195); + let mut x205: u32 = 0; + let mut x206: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x205, &mut x206, x204, x196, x193); + let mut x207: u32 = 0; + let mut x208: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x207, &mut x208, x206, x194, x191); + let mut x209: u32 = 0; + let mut x210: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x209, &mut x210, x208, x192, x189); + let mut x211: u32 = 0; + let mut x212: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x211, &mut x212, x210, x190, x187); + let mut x213: u32 = 0; + let mut x214: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x213, &mut x214, x212, x188, x185); + let mut x215: u32 = 0; + let mut x216: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x215, &mut x216, 0x0, x169, x199); + let mut x217: u32 = 0; + let mut x218: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x217, &mut x218, x216, x171, x201); + let mut x219: u32 = 0; + let mut x220: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x219, &mut x220, x218, x173, x203); + let mut x221: u32 = 0; + let mut x222: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x221, &mut x222, x220, x175, x205); + let mut x223: u32 = 0; + let mut x224: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x223, &mut x224, x222, x177, x207); + let mut x225: u32 = 0; + let mut x226: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x225, &mut x226, x224, x179, x209); + let mut x227: u32 = 0; + let mut x228: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x227, &mut x228, x226, x181, x211); + let mut x229: u32 = 0; + let mut x230: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x229, &mut x230, x228, x183, x213); + let mut x231: u32 = 0; + let mut x232: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x231, &mut x232, x215, 0x5588b13f); + let mut x233: u32 = 0; + let mut x234: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x233, &mut x234, x231, 0xffffffff); + let mut x235: u32 = 0; + let mut x236: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x235, &mut x236, x231, 0xffffffff); + let mut x237: u32 = 0; + let mut x238: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x237, &mut x238, x231, 0xffffffff); + let mut x239: u32 = 0; + let mut x240: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x239, &mut x240, x231, 0xfffffffe); + let mut x241: u32 = 0; + let mut x242: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x241, &mut x242, x231, 0xbaaedce6); + let mut x243: u32 = 0; + let mut x244: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x243, &mut x244, x231, 0xaf48a03b); + let mut x245: u32 = 0; + let mut x246: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x245, &mut x246, x231, 0xbfd25e8c); + let mut x247: u32 = 0; + let mut x248: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x247, &mut x248, x231, 0xd0364141); + let mut x249: u32 = 0; + let mut x250: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x249, &mut x250, 0x0, x248, x245); + let mut x251: u32 = 0; + let mut x252: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x251, &mut x252, x250, x246, x243); + let mut x253: u32 = 0; + let mut x254: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x253, &mut x254, x252, x244, x241); + let mut x255: u32 = 0; + let mut x256: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x255, &mut x256, x254, x242, x239); + let mut x257: u32 = 0; + let mut x258: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x257, &mut x258, x256, x240, x237); + let mut x259: u32 = 0; + let mut x260: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x259, &mut x260, x258, x238, x235); + let mut x261: u32 = 0; + let mut x262: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x261, &mut x262, x260, x236, x233); + let mut x263: u32 = 0; + let mut x264: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x263, &mut x264, 0x0, x215, x247); + let mut x265: u32 = 0; + let mut x266: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x265, &mut x266, x264, x217, x249); + let mut x267: u32 = 0; + let mut x268: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x267, &mut x268, x266, x219, x251); + let mut x269: u32 = 0; + let mut x270: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x269, &mut x270, x268, x221, x253); + let mut x271: u32 = 0; + let mut x272: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x271, &mut x272, x270, x223, x255); + let mut x273: u32 = 0; + let mut x274: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x273, &mut x274, x272, x225, x257); + let mut x275: u32 = 0; + let mut x276: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x275, &mut x276, x274, x227, x259); + let mut x277: u32 = 0; + let mut x278: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x277, &mut x278, x276, x229, x261); + let mut x279: u32 = 0; + let mut x280: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x279, &mut x280, x278, (((x230 as u32) + (x184 as u32)) + ((x214 as u32) + x186)), ((x262 as u32) + x234)); + let mut x281: u32 = 0; + let mut x282: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x281, &mut x282, x3, 0x9d671cd5); + let mut x283: u32 = 0; + let mut x284: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x283, &mut x284, x3, 0x81c69bc5); + let mut x285: u32 = 0; + let mut x286: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x285, &mut x286, x3, 0xe697f5e4); + let mut x287: u32 = 0; + let mut x288: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x287, &mut x288, x3, 0x5bcd07c6); + let mut x289: u32 = 0; + let mut x290: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x289, &mut x290, x3, 0x741496c2); + let mut x291: u32 = 0; + let mut x292: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x291, &mut x292, x3, 0xe7cf878); + let mut x293: u32 = 0; + let mut x294: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x293, &mut x294, x3, 0x896cf214); + let mut x295: u32 = 0; + let mut x296: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x295, &mut x296, x3, 0x67d7d140); + let mut x297: u32 = 0; + let mut x298: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x297, &mut x298, 0x0, x296, x293); + let mut x299: u32 = 0; + let mut x300: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x299, &mut x300, x298, x294, x291); + let mut x301: u32 = 0; + let mut x302: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x301, &mut x302, x300, x292, x289); + let mut x303: u32 = 0; + let mut x304: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x303, &mut x304, x302, x290, x287); + let mut x305: u32 = 0; + let mut x306: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x305, &mut x306, x304, x288, x285); + let mut x307: u32 = 0; + let mut x308: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x307, &mut x308, x306, x286, x283); + let mut x309: u32 = 0; + let mut x310: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x309, &mut x310, x308, x284, x281); + let mut x311: u32 = 0; + let mut x312: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x311, &mut x312, 0x0, x265, x295); + let mut x313: u32 = 0; + let mut x314: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x313, &mut x314, x312, x267, x297); + let mut x315: u32 = 0; + let mut x316: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x315, &mut x316, x314, x269, x299); + let mut x317: u32 = 0; + let mut x318: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x317, &mut x318, x316, x271, x301); + let mut x319: u32 = 0; + let mut x320: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x319, &mut x320, x318, x273, x303); + let mut x321: u32 = 0; + let mut x322: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x321, &mut x322, x320, x275, x305); + let mut x323: u32 = 0; + let mut x324: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x323, &mut x324, x322, x277, x307); + let mut x325: u32 = 0; + let mut x326: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x325, &mut x326, x324, x279, x309); + let mut x327: u32 = 0; + let mut x328: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x327, &mut x328, x311, 0x5588b13f); + let mut x329: u32 = 0; + let mut x330: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x329, &mut x330, x327, 0xffffffff); + let mut x331: u32 = 0; + let mut x332: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x331, &mut x332, x327, 0xffffffff); + let mut x333: u32 = 0; + let mut x334: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x333, &mut x334, x327, 0xffffffff); + let mut x335: u32 = 0; + let mut x336: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x335, &mut x336, x327, 0xfffffffe); + let mut x337: u32 = 0; + let mut x338: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x337, &mut x338, x327, 0xbaaedce6); + let mut x339: u32 = 0; + let mut x340: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x339, &mut x340, x327, 0xaf48a03b); + let mut x341: u32 = 0; + let mut x342: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x341, &mut x342, x327, 0xbfd25e8c); + let mut x343: u32 = 0; + let mut x344: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x343, &mut x344, x327, 0xd0364141); + let mut x345: u32 = 0; + let mut x346: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x345, &mut x346, 0x0, x344, x341); + let mut x347: u32 = 0; + let mut x348: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x347, &mut x348, x346, x342, x339); + let mut x349: u32 = 0; + let mut x350: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x349, &mut x350, x348, x340, x337); + let mut x351: u32 = 0; + let mut x352: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x351, &mut x352, x350, x338, x335); + let mut x353: u32 = 0; + let mut x354: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x353, &mut x354, x352, x336, x333); + let mut x355: u32 = 0; + let mut x356: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x355, &mut x356, x354, x334, x331); + let mut x357: u32 = 0; + let mut x358: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x357, &mut x358, x356, x332, x329); + let mut x359: u32 = 0; + let mut x360: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x359, &mut x360, 0x0, x311, x343); + let mut x361: u32 = 0; + let mut x362: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x361, &mut x362, x360, x313, x345); + let mut x363: u32 = 0; + let mut x364: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x363, &mut x364, x362, x315, x347); + let mut x365: u32 = 0; + let mut x366: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x365, &mut x366, x364, x317, x349); + let mut x367: u32 = 0; + let mut x368: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x367, &mut x368, x366, x319, x351); + let mut x369: u32 = 0; + let mut x370: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x369, &mut x370, x368, x321, x353); + let mut x371: u32 = 0; + let mut x372: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x371, &mut x372, x370, x323, x355); + let mut x373: u32 = 0; + let mut x374: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x373, &mut x374, x372, x325, x357); + let mut x375: u32 = 0; + let mut x376: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x375, &mut x376, x374, (((x326 as u32) + (x280 as u32)) + ((x310 as u32) + x282)), ((x358 as u32) + x330)); + let mut x377: u32 = 0; + let mut x378: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x377, &mut x378, x4, 0x9d671cd5); + let mut x379: u32 = 0; + let mut x380: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x379, &mut x380, x4, 0x81c69bc5); + let mut x381: u32 = 0; + let mut x382: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x381, &mut x382, x4, 0xe697f5e4); + let mut x383: u32 = 0; + let mut x384: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x383, &mut x384, x4, 0x5bcd07c6); + let mut x385: u32 = 0; + let mut x386: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x385, &mut x386, x4, 0x741496c2); + let mut x387: u32 = 0; + let mut x388: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x387, &mut x388, x4, 0xe7cf878); + let mut x389: u32 = 0; + let mut x390: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x389, &mut x390, x4, 0x896cf214); + let mut x391: u32 = 0; + let mut x392: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x391, &mut x392, x4, 0x67d7d140); + let mut x393: u32 = 0; + let mut x394: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x393, &mut x394, 0x0, x392, x389); + let mut x395: u32 = 0; + let mut x396: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x395, &mut x396, x394, x390, x387); + let mut x397: u32 = 0; + let mut x398: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x397, &mut x398, x396, x388, x385); + let mut x399: u32 = 0; + let mut x400: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x399, &mut x400, x398, x386, x383); + let mut x401: u32 = 0; + let mut x402: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x401, &mut x402, x400, x384, x381); + let mut x403: u32 = 0; + let mut x404: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x403, &mut x404, x402, x382, x379); + let mut x405: u32 = 0; + let mut x406: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x405, &mut x406, x404, x380, x377); + let mut x407: u32 = 0; + let mut x408: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x407, &mut x408, 0x0, x361, x391); + let mut x409: u32 = 0; + let mut x410: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x409, &mut x410, x408, x363, x393); + let mut x411: u32 = 0; + let mut x412: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x411, &mut x412, x410, x365, x395); + let mut x413: u32 = 0; + let mut x414: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x413, &mut x414, x412, x367, x397); + let mut x415: u32 = 0; + let mut x416: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x415, &mut x416, x414, x369, x399); + let mut x417: u32 = 0; + let mut x418: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x417, &mut x418, x416, x371, x401); + let mut x419: u32 = 0; + let mut x420: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x419, &mut x420, x418, x373, x403); + let mut x421: u32 = 0; + let mut x422: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x421, &mut x422, x420, x375, x405); + let mut x423: u32 = 0; + let mut x424: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x423, &mut x424, x407, 0x5588b13f); + let mut x425: u32 = 0; + let mut x426: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x425, &mut x426, x423, 0xffffffff); + let mut x427: u32 = 0; + let mut x428: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x427, &mut x428, x423, 0xffffffff); + let mut x429: u32 = 0; + let mut x430: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x429, &mut x430, x423, 0xffffffff); + let mut x431: u32 = 0; + let mut x432: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x431, &mut x432, x423, 0xfffffffe); + let mut x433: u32 = 0; + let mut x434: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x433, &mut x434, x423, 0xbaaedce6); + let mut x435: u32 = 0; + let mut x436: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x435, &mut x436, x423, 0xaf48a03b); + let mut x437: u32 = 0; + let mut x438: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x437, &mut x438, x423, 0xbfd25e8c); + let mut x439: u32 = 0; + let mut x440: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x439, &mut x440, x423, 0xd0364141); + let mut x441: u32 = 0; + let mut x442: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x441, &mut x442, 0x0, x440, x437); + let mut x443: u32 = 0; + let mut x444: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x443, &mut x444, x442, x438, x435); + let mut x445: u32 = 0; + let mut x446: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x445, &mut x446, x444, x436, x433); + let mut x447: u32 = 0; + let mut x448: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x447, &mut x448, x446, x434, x431); + let mut x449: u32 = 0; + let mut x450: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x449, &mut x450, x448, x432, x429); + let mut x451: u32 = 0; + let mut x452: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x451, &mut x452, x450, x430, x427); + let mut x453: u32 = 0; + let mut x454: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x453, &mut x454, x452, x428, x425); + let mut x455: u32 = 0; + let mut x456: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x455, &mut x456, 0x0, x407, x439); + let mut x457: u32 = 0; + let mut x458: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x457, &mut x458, x456, x409, x441); + let mut x459: u32 = 0; + let mut x460: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x459, &mut x460, x458, x411, x443); + let mut x461: u32 = 0; + let mut x462: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x461, &mut x462, x460, x413, x445); + let mut x463: u32 = 0; + let mut x464: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x463, &mut x464, x462, x415, x447); + let mut x465: u32 = 0; + let mut x466: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x465, &mut x466, x464, x417, x449); + let mut x467: u32 = 0; + let mut x468: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x467, &mut x468, x466, x419, x451); + let mut x469: u32 = 0; + let mut x470: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x469, &mut x470, x468, x421, x453); + let mut x471: u32 = 0; + let mut x472: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x471, &mut x472, x470, (((x422 as u32) + (x376 as u32)) + ((x406 as u32) + x378)), ((x454 as u32) + x426)); + let mut x473: u32 = 0; + let mut x474: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x473, &mut x474, x5, 0x9d671cd5); + let mut x475: u32 = 0; + let mut x476: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x475, &mut x476, x5, 0x81c69bc5); + let mut x477: u32 = 0; + let mut x478: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x477, &mut x478, x5, 0xe697f5e4); + let mut x479: u32 = 0; + let mut x480: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x479, &mut x480, x5, 0x5bcd07c6); + let mut x481: u32 = 0; + let mut x482: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x481, &mut x482, x5, 0x741496c2); + let mut x483: u32 = 0; + let mut x484: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x483, &mut x484, x5, 0xe7cf878); + let mut x485: u32 = 0; + let mut x486: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x485, &mut x486, x5, 0x896cf214); + let mut x487: u32 = 0; + let mut x488: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x487, &mut x488, x5, 0x67d7d140); + let mut x489: u32 = 0; + let mut x490: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x489, &mut x490, 0x0, x488, x485); + let mut x491: u32 = 0; + let mut x492: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x491, &mut x492, x490, x486, x483); + let mut x493: u32 = 0; + let mut x494: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x493, &mut x494, x492, x484, x481); + let mut x495: u32 = 0; + let mut x496: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x495, &mut x496, x494, x482, x479); + let mut x497: u32 = 0; + let mut x498: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x497, &mut x498, x496, x480, x477); + let mut x499: u32 = 0; + let mut x500: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x499, &mut x500, x498, x478, x475); + let mut x501: u32 = 0; + let mut x502: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x501, &mut x502, x500, x476, x473); + let mut x503: u32 = 0; + let mut x504: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x503, &mut x504, 0x0, x457, x487); + let mut x505: u32 = 0; + let mut x506: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x505, &mut x506, x504, x459, x489); + let mut x507: u32 = 0; + let mut x508: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x507, &mut x508, x506, x461, x491); + let mut x509: u32 = 0; + let mut x510: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x509, &mut x510, x508, x463, x493); + let mut x511: u32 = 0; + let mut x512: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x511, &mut x512, x510, x465, x495); + let mut x513: u32 = 0; + let mut x514: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x513, &mut x514, x512, x467, x497); + let mut x515: u32 = 0; + let mut x516: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x515, &mut x516, x514, x469, x499); + let mut x517: u32 = 0; + let mut x518: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x517, &mut x518, x516, x471, x501); + let mut x519: u32 = 0; + let mut x520: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x519, &mut x520, x503, 0x5588b13f); + let mut x521: u32 = 0; + let mut x522: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x521, &mut x522, x519, 0xffffffff); + let mut x523: u32 = 0; + let mut x524: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x523, &mut x524, x519, 0xffffffff); + let mut x525: u32 = 0; + let mut x526: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x525, &mut x526, x519, 0xffffffff); + let mut x527: u32 = 0; + let mut x528: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x527, &mut x528, x519, 0xfffffffe); + let mut x529: u32 = 0; + let mut x530: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x529, &mut x530, x519, 0xbaaedce6); + let mut x531: u32 = 0; + let mut x532: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x531, &mut x532, x519, 0xaf48a03b); + let mut x533: u32 = 0; + let mut x534: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x533, &mut x534, x519, 0xbfd25e8c); + let mut x535: u32 = 0; + let mut x536: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x535, &mut x536, x519, 0xd0364141); + let mut x537: u32 = 0; + let mut x538: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x537, &mut x538, 0x0, x536, x533); + let mut x539: u32 = 0; + let mut x540: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x539, &mut x540, x538, x534, x531); + let mut x541: u32 = 0; + let mut x542: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x541, &mut x542, x540, x532, x529); + let mut x543: u32 = 0; + let mut x544: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x543, &mut x544, x542, x530, x527); + let mut x545: u32 = 0; + let mut x546: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x545, &mut x546, x544, x528, x525); + let mut x547: u32 = 0; + let mut x548: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x547, &mut x548, x546, x526, x523); + let mut x549: u32 = 0; + let mut x550: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x549, &mut x550, x548, x524, x521); + let mut x551: u32 = 0; + let mut x552: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x551, &mut x552, 0x0, x503, x535); + let mut x553: u32 = 0; + let mut x554: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x553, &mut x554, x552, x505, x537); + let mut x555: u32 = 0; + let mut x556: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x555, &mut x556, x554, x507, x539); + let mut x557: u32 = 0; + let mut x558: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x557, &mut x558, x556, x509, x541); + let mut x559: u32 = 0; + let mut x560: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x559, &mut x560, x558, x511, x543); + let mut x561: u32 = 0; + let mut x562: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x561, &mut x562, x560, x513, x545); + let mut x563: u32 = 0; + let mut x564: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x563, &mut x564, x562, x515, x547); + let mut x565: u32 = 0; + let mut x566: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x565, &mut x566, x564, x517, x549); + let mut x567: u32 = 0; + let mut x568: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x567, &mut x568, x566, (((x518 as u32) + (x472 as u32)) + ((x502 as u32) + x474)), ((x550 as u32) + x522)); + let mut x569: u32 = 0; + let mut x570: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x569, &mut x570, x6, 0x9d671cd5); + let mut x571: u32 = 0; + let mut x572: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x571, &mut x572, x6, 0x81c69bc5); + let mut x573: u32 = 0; + let mut x574: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x573, &mut x574, x6, 0xe697f5e4); + let mut x575: u32 = 0; + let mut x576: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x575, &mut x576, x6, 0x5bcd07c6); + let mut x577: u32 = 0; + let mut x578: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x577, &mut x578, x6, 0x741496c2); + let mut x579: u32 = 0; + let mut x580: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x579, &mut x580, x6, 0xe7cf878); + let mut x581: u32 = 0; + let mut x582: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x581, &mut x582, x6, 0x896cf214); + let mut x583: u32 = 0; + let mut x584: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x583, &mut x584, x6, 0x67d7d140); + let mut x585: u32 = 0; + let mut x586: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x585, &mut x586, 0x0, x584, x581); + let mut x587: u32 = 0; + let mut x588: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x587, &mut x588, x586, x582, x579); + let mut x589: u32 = 0; + let mut x590: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x589, &mut x590, x588, x580, x577); + let mut x591: u32 = 0; + let mut x592: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x591, &mut x592, x590, x578, x575); + let mut x593: u32 = 0; + let mut x594: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x593, &mut x594, x592, x576, x573); + let mut x595: u32 = 0; + let mut x596: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x595, &mut x596, x594, x574, x571); + let mut x597: u32 = 0; + let mut x598: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x597, &mut x598, x596, x572, x569); + let mut x599: u32 = 0; + let mut x600: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x599, &mut x600, 0x0, x553, x583); + let mut x601: u32 = 0; + let mut x602: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x601, &mut x602, x600, x555, x585); + let mut x603: u32 = 0; + let mut x604: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x603, &mut x604, x602, x557, x587); + let mut x605: u32 = 0; + let mut x606: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x605, &mut x606, x604, x559, x589); + let mut x607: u32 = 0; + let mut x608: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x607, &mut x608, x606, x561, x591); + let mut x609: u32 = 0; + let mut x610: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x609, &mut x610, x608, x563, x593); + let mut x611: u32 = 0; + let mut x612: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x611, &mut x612, x610, x565, x595); + let mut x613: u32 = 0; + let mut x614: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x613, &mut x614, x612, x567, x597); + let mut x615: u32 = 0; + let mut x616: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x615, &mut x616, x599, 0x5588b13f); + let mut x617: u32 = 0; + let mut x618: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x617, &mut x618, x615, 0xffffffff); + let mut x619: u32 = 0; + let mut x620: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x619, &mut x620, x615, 0xffffffff); + let mut x621: u32 = 0; + let mut x622: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x621, &mut x622, x615, 0xffffffff); + let mut x623: u32 = 0; + let mut x624: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x623, &mut x624, x615, 0xfffffffe); + let mut x625: u32 = 0; + let mut x626: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x625, &mut x626, x615, 0xbaaedce6); + let mut x627: u32 = 0; + let mut x628: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x627, &mut x628, x615, 0xaf48a03b); + let mut x629: u32 = 0; + let mut x630: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x629, &mut x630, x615, 0xbfd25e8c); + let mut x631: u32 = 0; + let mut x632: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x631, &mut x632, x615, 0xd0364141); + let mut x633: u32 = 0; + let mut x634: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x633, &mut x634, 0x0, x632, x629); + let mut x635: u32 = 0; + let mut x636: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x635, &mut x636, x634, x630, x627); + let mut x637: u32 = 0; + let mut x638: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x637, &mut x638, x636, x628, x625); + let mut x639: u32 = 0; + let mut x640: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x639, &mut x640, x638, x626, x623); + let mut x641: u32 = 0; + let mut x642: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x641, &mut x642, x640, x624, x621); + let mut x643: u32 = 0; + let mut x644: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x643, &mut x644, x642, x622, x619); + let mut x645: u32 = 0; + let mut x646: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x645, &mut x646, x644, x620, x617); + let mut x647: u32 = 0; + let mut x648: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x647, &mut x648, 0x0, x599, x631); + let mut x649: u32 = 0; + let mut x650: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x649, &mut x650, x648, x601, x633); + let mut x651: u32 = 0; + let mut x652: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x651, &mut x652, x650, x603, x635); + let mut x653: u32 = 0; + let mut x654: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x653, &mut x654, x652, x605, x637); + let mut x655: u32 = 0; + let mut x656: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x655, &mut x656, x654, x607, x639); + let mut x657: u32 = 0; + let mut x658: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x657, &mut x658, x656, x609, x641); + let mut x659: u32 = 0; + let mut x660: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x659, &mut x660, x658, x611, x643); + let mut x661: u32 = 0; + let mut x662: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x661, &mut x662, x660, x613, x645); + let mut x663: u32 = 0; + let mut x664: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x663, &mut x664, x662, (((x614 as u32) + (x568 as u32)) + ((x598 as u32) + x570)), ((x646 as u32) + x618)); + let mut x665: u32 = 0; + let mut x666: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x665, &mut x666, x7, 0x9d671cd5); + let mut x667: u32 = 0; + let mut x668: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x667, &mut x668, x7, 0x81c69bc5); + let mut x669: u32 = 0; + let mut x670: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x669, &mut x670, x7, 0xe697f5e4); + let mut x671: u32 = 0; + let mut x672: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x671, &mut x672, x7, 0x5bcd07c6); + let mut x673: u32 = 0; + let mut x674: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x673, &mut x674, x7, 0x741496c2); + let mut x675: u32 = 0; + let mut x676: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x675, &mut x676, x7, 0xe7cf878); + let mut x677: u32 = 0; + let mut x678: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x677, &mut x678, x7, 0x896cf214); + let mut x679: u32 = 0; + let mut x680: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x679, &mut x680, x7, 0x67d7d140); + let mut x681: u32 = 0; + let mut x682: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x681, &mut x682, 0x0, x680, x677); + let mut x683: u32 = 0; + let mut x684: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x683, &mut x684, x682, x678, x675); + let mut x685: u32 = 0; + let mut x686: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x685, &mut x686, x684, x676, x673); + let mut x687: u32 = 0; + let mut x688: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x687, &mut x688, x686, x674, x671); + let mut x689: u32 = 0; + let mut x690: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x689, &mut x690, x688, x672, x669); + let mut x691: u32 = 0; + let mut x692: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x691, &mut x692, x690, x670, x667); + let mut x693: u32 = 0; + let mut x694: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x693, &mut x694, x692, x668, x665); + let mut x695: u32 = 0; + let mut x696: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x695, &mut x696, 0x0, x649, x679); + let mut x697: u32 = 0; + let mut x698: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x697, &mut x698, x696, x651, x681); + let mut x699: u32 = 0; + let mut x700: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x699, &mut x700, x698, x653, x683); + let mut x701: u32 = 0; + let mut x702: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x701, &mut x702, x700, x655, x685); + let mut x703: u32 = 0; + let mut x704: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x703, &mut x704, x702, x657, x687); + let mut x705: u32 = 0; + let mut x706: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x705, &mut x706, x704, x659, x689); + let mut x707: u32 = 0; + let mut x708: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x707, &mut x708, x706, x661, x691); + let mut x709: u32 = 0; + let mut x710: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x709, &mut x710, x708, x663, x693); + let mut x711: u32 = 0; + let mut x712: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x711, &mut x712, x695, 0x5588b13f); + let mut x713: u32 = 0; + let mut x714: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x713, &mut x714, x711, 0xffffffff); + let mut x715: u32 = 0; + let mut x716: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x715, &mut x716, x711, 0xffffffff); + let mut x717: u32 = 0; + let mut x718: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x717, &mut x718, x711, 0xffffffff); + let mut x719: u32 = 0; + let mut x720: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x719, &mut x720, x711, 0xfffffffe); + let mut x721: u32 = 0; + let mut x722: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x721, &mut x722, x711, 0xbaaedce6); + let mut x723: u32 = 0; + let mut x724: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x723, &mut x724, x711, 0xaf48a03b); + let mut x725: u32 = 0; + let mut x726: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x725, &mut x726, x711, 0xbfd25e8c); + let mut x727: u32 = 0; + let mut x728: u32 = 0; + fiat_secp256k1_scalar_mulx_u32(&mut x727, &mut x728, x711, 0xd0364141); + let mut x729: u32 = 0; + let mut x730: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x729, &mut x730, 0x0, x728, x725); + let mut x731: u32 = 0; + let mut x732: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x731, &mut x732, x730, x726, x723); + let mut x733: u32 = 0; + let mut x734: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x733, &mut x734, x732, x724, x721); + let mut x735: u32 = 0; + let mut x736: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x735, &mut x736, x734, x722, x719); + let mut x737: u32 = 0; + let mut x738: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x737, &mut x738, x736, x720, x717); + let mut x739: u32 = 0; + let mut x740: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x739, &mut x740, x738, x718, x715); + let mut x741: u32 = 0; + let mut x742: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x741, &mut x742, x740, x716, x713); + let mut x743: u32 = 0; + let mut x744: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x743, &mut x744, 0x0, x695, x727); + let mut x745: u32 = 0; + let mut x746: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x745, &mut x746, x744, x697, x729); + let mut x747: u32 = 0; + let mut x748: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x747, &mut x748, x746, x699, x731); + let mut x749: u32 = 0; + let mut x750: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x749, &mut x750, x748, x701, x733); + let mut x751: u32 = 0; + let mut x752: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x751, &mut x752, x750, x703, x735); + let mut x753: u32 = 0; + let mut x754: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x753, &mut x754, x752, x705, x737); + let mut x755: u32 = 0; + let mut x756: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x755, &mut x756, x754, x707, x739); + let mut x757: u32 = 0; + let mut x758: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x757, &mut x758, x756, x709, x741); + let mut x759: u32 = 0; + let mut x760: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x759, &mut x760, x758, (((x710 as u32) + (x664 as u32)) + ((x694 as u32) + x666)), ((x742 as u32) + x714)); + let mut x761: u32 = 0; + let mut x762: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x761, &mut x762, 0x0, x745, 0xd0364141); + let mut x763: u32 = 0; + let mut x764: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x763, &mut x764, x762, x747, 0xbfd25e8c); + let mut x765: u32 = 0; + let mut x766: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x765, &mut x766, x764, x749, 0xaf48a03b); + let mut x767: u32 = 0; + let mut x768: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x767, &mut x768, x766, x751, 0xbaaedce6); + let mut x769: u32 = 0; + let mut x770: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x769, &mut x770, x768, x753, 0xfffffffe); + let mut x771: u32 = 0; + let mut x772: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x771, &mut x772, x770, x755, 0xffffffff); + let mut x773: u32 = 0; + let mut x774: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x773, &mut x774, x772, x757, 0xffffffff); + let mut x775: u32 = 0; + let mut x776: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x775, &mut x776, x774, x759, 0xffffffff); + let mut x777: u32 = 0; + let mut x778: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x777, &mut x778, x776, (x760 as u32), (0x0 as u32)); + let mut x779: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x779, x778, x761, x745); + let mut x780: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x780, x778, x763, x747); + let mut x781: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x781, x778, x765, x749); + let mut x782: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x782, x778, x767, x751); + let mut x783: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x783, x778, x769, x753); + let mut x784: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x784, x778, x771, x755); + let mut x785: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x785, x778, x773, x757); + let mut x786: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x786, x778, x775, x759); + out1[0] = x779; + out1[1] = x780; + out1[2] = x781; + out1[3] = x782; + out1[4] = x783; + out1[5] = x784; + out1[6] = x785; + out1[7] = x786; +} + +/// The function fiat_secp256k1_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +#[inline] +pub fn fiat_secp256k1_scalar_nonzero(out1: &mut u32, arg1: &[u32; 8]) -> () { + let x1: u32 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | (arg1[7])))))))); + *out1 = x1; +} + +/// The function fiat_secp256k1_scalar_selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_secp256k1_scalar_selectznz(out1: &mut [u32; 8], arg1: fiat_secp256k1_scalar_u1, arg2: &[u32; 8], arg3: &[u32; 8]) -> () { + let mut x1: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x1, arg1, (arg2[0]), (arg3[0])); + let mut x2: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x2, arg1, (arg2[1]), (arg3[1])); + let mut x3: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x3, arg1, (arg2[2]), (arg3[2])); + let mut x4: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x4, arg1, (arg2[3]), (arg3[3])); + let mut x5: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x5, arg1, (arg2[4]), (arg3[4])); + let mut x6: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x6, arg1, (arg2[5]), (arg3[5])); + let mut x7: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x7, arg1, (arg2[6]), (arg3[6])); + let mut x8: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x8, arg1, (arg2[7]), (arg3[7])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; + out1[6] = x7; + out1[7] = x8; +} + +/// The function fiat_secp256k1_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +#[inline] +pub fn fiat_secp256k1_scalar_to_bytes(out1: &mut [u8; 32], arg1: &[u32; 8]) -> () { + let x1: u32 = (arg1[7]); + let x2: u32 = (arg1[6]); + let x3: u32 = (arg1[5]); + let x4: u32 = (arg1[4]); + let x5: u32 = (arg1[3]); + let x6: u32 = (arg1[2]); + let x7: u32 = (arg1[1]); + let x8: u32 = (arg1[0]); + let x9: u8 = ((x8 & (0xff as u32)) as u8); + let x10: u32 = (x8 >> 8); + let x11: u8 = ((x10 & (0xff as u32)) as u8); + let x12: u32 = (x10 >> 8); + let x13: u8 = ((x12 & (0xff as u32)) as u8); + let x14: u8 = ((x12 >> 8) as u8); + let x15: u8 = ((x7 & (0xff as u32)) as u8); + let x16: u32 = (x7 >> 8); + let x17: u8 = ((x16 & (0xff as u32)) as u8); + let x18: u32 = (x16 >> 8); + let x19: u8 = ((x18 & (0xff as u32)) as u8); + let x20: u8 = ((x18 >> 8) as u8); + let x21: u8 = ((x6 & (0xff as u32)) as u8); + let x22: u32 = (x6 >> 8); + let x23: u8 = ((x22 & (0xff as u32)) as u8); + let x24: u32 = (x22 >> 8); + let x25: u8 = ((x24 & (0xff as u32)) as u8); + let x26: u8 = ((x24 >> 8) as u8); + let x27: u8 = ((x5 & (0xff as u32)) as u8); + let x28: u32 = (x5 >> 8); + let x29: u8 = ((x28 & (0xff as u32)) as u8); + let x30: u32 = (x28 >> 8); + let x31: u8 = ((x30 & (0xff as u32)) as u8); + let x32: u8 = ((x30 >> 8) as u8); + let x33: u8 = ((x4 & (0xff as u32)) as u8); + let x34: u32 = (x4 >> 8); + let x35: u8 = ((x34 & (0xff as u32)) as u8); + let x36: u32 = (x34 >> 8); + let x37: u8 = ((x36 & (0xff as u32)) as u8); + let x38: u8 = ((x36 >> 8) as u8); + let x39: u8 = ((x3 & (0xff as u32)) as u8); + let x40: u32 = (x3 >> 8); + let x41: u8 = ((x40 & (0xff as u32)) as u8); + let x42: u32 = (x40 >> 8); + let x43: u8 = ((x42 & (0xff as u32)) as u8); + let x44: u8 = ((x42 >> 8) as u8); + let x45: u8 = ((x2 & (0xff as u32)) as u8); + let x46: u32 = (x2 >> 8); + let x47: u8 = ((x46 & (0xff as u32)) as u8); + let x48: u32 = (x46 >> 8); + let x49: u8 = ((x48 & (0xff as u32)) as u8); + let x50: u8 = ((x48 >> 8) as u8); + let x51: u8 = ((x1 & (0xff as u32)) as u8); + let x52: u32 = (x1 >> 8); + let x53: u8 = ((x52 & (0xff as u32)) as u8); + let x54: u32 = (x52 >> 8); + let x55: u8 = ((x54 & (0xff as u32)) as u8); + let x56: u8 = ((x54 >> 8) as u8); + out1[0] = x9; + out1[1] = x11; + out1[2] = x13; + out1[3] = x14; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x26; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x38; + out1[20] = x39; + out1[21] = x41; + out1[22] = x43; + out1[23] = x44; + out1[24] = x45; + out1[25] = x47; + out1[26] = x49; + out1[27] = x50; + out1[28] = x51; + out1[29] = x53; + out1[30] = x55; + out1[31] = x56; +} + +/// The function fiat_secp256k1_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_secp256k1_scalar_from_bytes(out1: &mut [u32; 8], arg1: &[u8; 32]) -> () { + let x1: u32 = (((arg1[31]) as u32) << 24); + let x2: u32 = (((arg1[30]) as u32) << 16); + let x3: u32 = (((arg1[29]) as u32) << 8); + let x4: u8 = (arg1[28]); + let x5: u32 = (((arg1[27]) as u32) << 24); + let x6: u32 = (((arg1[26]) as u32) << 16); + let x7: u32 = (((arg1[25]) as u32) << 8); + let x8: u8 = (arg1[24]); + let x9: u32 = (((arg1[23]) as u32) << 24); + let x10: u32 = (((arg1[22]) as u32) << 16); + let x11: u32 = (((arg1[21]) as u32) << 8); + let x12: u8 = (arg1[20]); + let x13: u32 = (((arg1[19]) as u32) << 24); + let x14: u32 = (((arg1[18]) as u32) << 16); + let x15: u32 = (((arg1[17]) as u32) << 8); + let x16: u8 = (arg1[16]); + let x17: u32 = (((arg1[15]) as u32) << 24); + let x18: u32 = (((arg1[14]) as u32) << 16); + let x19: u32 = (((arg1[13]) as u32) << 8); + let x20: u8 = (arg1[12]); + let x21: u32 = (((arg1[11]) as u32) << 24); + let x22: u32 = (((arg1[10]) as u32) << 16); + let x23: u32 = (((arg1[9]) as u32) << 8); + let x24: u8 = (arg1[8]); + let x25: u32 = (((arg1[7]) as u32) << 24); + let x26: u32 = (((arg1[6]) as u32) << 16); + let x27: u32 = (((arg1[5]) as u32) << 8); + let x28: u8 = (arg1[4]); + let x29: u32 = (((arg1[3]) as u32) << 24); + let x30: u32 = (((arg1[2]) as u32) << 16); + let x31: u32 = (((arg1[1]) as u32) << 8); + let x32: u8 = (arg1[0]); + let x33: u32 = (x31 + (x32 as u32)); + let x34: u32 = (x30 + x33); + let x35: u32 = (x29 + x34); + let x36: u32 = (x27 + (x28 as u32)); + let x37: u32 = (x26 + x36); + let x38: u32 = (x25 + x37); + let x39: u32 = (x23 + (x24 as u32)); + let x40: u32 = (x22 + x39); + let x41: u32 = (x21 + x40); + let x42: u32 = (x19 + (x20 as u32)); + let x43: u32 = (x18 + x42); + let x44: u32 = (x17 + x43); + let x45: u32 = (x15 + (x16 as u32)); + let x46: u32 = (x14 + x45); + let x47: u32 = (x13 + x46); + let x48: u32 = (x11 + (x12 as u32)); + let x49: u32 = (x10 + x48); + let x50: u32 = (x9 + x49); + let x51: u32 = (x7 + (x8 as u32)); + let x52: u32 = (x6 + x51); + let x53: u32 = (x5 + x52); + let x54: u32 = (x3 + (x4 as u32)); + let x55: u32 = (x2 + x54); + let x56: u32 = (x1 + x55); + out1[0] = x35; + out1[1] = x38; + out1[2] = x41; + out1[3] = x44; + out1[4] = x47; + out1[5] = x50; + out1[6] = x53; + out1[7] = x56; +} + +/// The function fiat_secp256k1_scalar_set_one returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_set_one(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + out1[0] = 0x2fc9bebf; + out1[1] = 0x402da173; + out1[2] = 0x50b75fc4; + out1[3] = 0x45512319; + out1[4] = (0x1 as u32); + out1[5] = (0x0 as u32); + out1[6] = (0x0 as u32); + out1[7] = (0x0 as u32); +} + +/// The function fiat_secp256k1_scalar_msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_secp256k1_scalar_msat(out1: &mut [u32; 9]) -> () { + out1[0] = 0xd0364141; + out1[1] = 0xbfd25e8c; + out1[2] = 0xaf48a03b; + out1[3] = 0xbaaedce6; + out1[4] = 0xfffffffe; + out1[5] = 0xffffffff; + out1[6] = 0xffffffff; + out1[7] = 0xffffffff; + out1[8] = (0x0 as u32); +} + +/// The function fiat_secp256k1_scalar_divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_secp256k1_scalar_divstep(out1: &mut u32, out2: &mut [u32; 9], out3: &mut [u32; 9], out4: &mut [u32; 8], out5: &mut [u32; 8], arg1: u32, arg2: &[u32; 9], arg3: &[u32; 9], arg4: &[u32; 8], arg5: &[u32; 8]) -> () { + let mut x1: u32 = 0; + let mut x2: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x1, &mut x2, 0x0, (!arg1), (0x1 as u32)); + let x3: fiat_secp256k1_scalar_u1 = (((x1 >> 31) as fiat_secp256k1_scalar_u1) & (((arg3[0]) & (0x1 as u32)) as fiat_secp256k1_scalar_u1)); + let mut x4: u32 = 0; + let mut x5: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x4, &mut x5, 0x0, (!arg1), (0x1 as u32)); + let mut x6: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x6, x3, arg1, x4); + let mut x7: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x7, x3, (arg2[0]), (arg3[0])); + let mut x8: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x8, x3, (arg2[1]), (arg3[1])); + let mut x9: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x9, x3, (arg2[2]), (arg3[2])); + let mut x10: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x10, x3, (arg2[3]), (arg3[3])); + let mut x11: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x11, x3, (arg2[4]), (arg3[4])); + let mut x12: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x12, x3, (arg2[5]), (arg3[5])); + let mut x13: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x13, x3, (arg2[6]), (arg3[6])); + let mut x14: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x14, x3, (arg2[7]), (arg3[7])); + let mut x15: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x15, x3, (arg2[8]), (arg3[8])); + let mut x16: u32 = 0; + let mut x17: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x16, &mut x17, 0x0, (0x1 as u32), (!(arg2[0]))); + let mut x18: u32 = 0; + let mut x19: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x18, &mut x19, x17, (0x0 as u32), (!(arg2[1]))); + let mut x20: u32 = 0; + let mut x21: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x20, &mut x21, x19, (0x0 as u32), (!(arg2[2]))); + let mut x22: u32 = 0; + let mut x23: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x22, &mut x23, x21, (0x0 as u32), (!(arg2[3]))); + let mut x24: u32 = 0; + let mut x25: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x24, &mut x25, x23, (0x0 as u32), (!(arg2[4]))); + let mut x26: u32 = 0; + let mut x27: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x26, &mut x27, x25, (0x0 as u32), (!(arg2[5]))); + let mut x28: u32 = 0; + let mut x29: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x28, &mut x29, x27, (0x0 as u32), (!(arg2[6]))); + let mut x30: u32 = 0; + let mut x31: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x30, &mut x31, x29, (0x0 as u32), (!(arg2[7]))); + let mut x32: u32 = 0; + let mut x33: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x32, &mut x33, x31, (0x0 as u32), (!(arg2[8]))); + let mut x34: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x34, x3, (arg3[0]), x16); + let mut x35: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x35, x3, (arg3[1]), x18); + let mut x36: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x36, x3, (arg3[2]), x20); + let mut x37: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x37, x3, (arg3[3]), x22); + let mut x38: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x38, x3, (arg3[4]), x24); + let mut x39: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x39, x3, (arg3[5]), x26); + let mut x40: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x40, x3, (arg3[6]), x28); + let mut x41: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x41, x3, (arg3[7]), x30); + let mut x42: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x42, x3, (arg3[8]), x32); + let mut x43: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x43, x3, (arg4[0]), (arg5[0])); + let mut x44: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x44, x3, (arg4[1]), (arg5[1])); + let mut x45: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x45, x3, (arg4[2]), (arg5[2])); + let mut x46: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x46, x3, (arg4[3]), (arg5[3])); + let mut x47: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x47, x3, (arg4[4]), (arg5[4])); + let mut x48: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x48, x3, (arg4[5]), (arg5[5])); + let mut x49: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x49, x3, (arg4[6]), (arg5[6])); + let mut x50: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x50, x3, (arg4[7]), (arg5[7])); + let mut x51: u32 = 0; + let mut x52: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x51, &mut x52, 0x0, x43, x43); + let mut x53: u32 = 0; + let mut x54: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x53, &mut x54, x52, x44, x44); + let mut x55: u32 = 0; + let mut x56: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x55, &mut x56, x54, x45, x45); + let mut x57: u32 = 0; + let mut x58: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x57, &mut x58, x56, x46, x46); + let mut x59: u32 = 0; + let mut x60: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x59, &mut x60, x58, x47, x47); + let mut x61: u32 = 0; + let mut x62: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x61, &mut x62, x60, x48, x48); + let mut x63: u32 = 0; + let mut x64: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x63, &mut x64, x62, x49, x49); + let mut x65: u32 = 0; + let mut x66: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x65, &mut x66, x64, x50, x50); + let mut x67: u32 = 0; + let mut x68: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x67, &mut x68, 0x0, x51, 0xd0364141); + let mut x69: u32 = 0; + let mut x70: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x69, &mut x70, x68, x53, 0xbfd25e8c); + let mut x71: u32 = 0; + let mut x72: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x71, &mut x72, x70, x55, 0xaf48a03b); + let mut x73: u32 = 0; + let mut x74: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x73, &mut x74, x72, x57, 0xbaaedce6); + let mut x75: u32 = 0; + let mut x76: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x75, &mut x76, x74, x59, 0xfffffffe); + let mut x77: u32 = 0; + let mut x78: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x77, &mut x78, x76, x61, 0xffffffff); + let mut x79: u32 = 0; + let mut x80: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x79, &mut x80, x78, x63, 0xffffffff); + let mut x81: u32 = 0; + let mut x82: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x81, &mut x82, x80, x65, 0xffffffff); + let mut x83: u32 = 0; + let mut x84: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x83, &mut x84, x82, (x66 as u32), (0x0 as u32)); + let x85: u32 = (arg4[7]); + let x86: u32 = (arg4[6]); + let x87: u32 = (arg4[5]); + let x88: u32 = (arg4[4]); + let x89: u32 = (arg4[3]); + let x90: u32 = (arg4[2]); + let x91: u32 = (arg4[1]); + let x92: u32 = (arg4[0]); + let mut x93: u32 = 0; + let mut x94: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x93, &mut x94, 0x0, (0x0 as u32), x92); + let mut x95: u32 = 0; + let mut x96: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x95, &mut x96, x94, (0x0 as u32), x91); + let mut x97: u32 = 0; + let mut x98: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x97, &mut x98, x96, (0x0 as u32), x90); + let mut x99: u32 = 0; + let mut x100: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x99, &mut x100, x98, (0x0 as u32), x89); + let mut x101: u32 = 0; + let mut x102: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x101, &mut x102, x100, (0x0 as u32), x88); + let mut x103: u32 = 0; + let mut x104: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x103, &mut x104, x102, (0x0 as u32), x87); + let mut x105: u32 = 0; + let mut x106: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x105, &mut x106, x104, (0x0 as u32), x86); + let mut x107: u32 = 0; + let mut x108: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x107, &mut x108, x106, (0x0 as u32), x85); + let mut x109: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x109, x108, (0x0 as u32), 0xffffffff); + let mut x110: u32 = 0; + let mut x111: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x110, &mut x111, 0x0, x93, (x109 & 0xd0364141)); + let mut x112: u32 = 0; + let mut x113: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x112, &mut x113, x111, x95, (x109 & 0xbfd25e8c)); + let mut x114: u32 = 0; + let mut x115: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x114, &mut x115, x113, x97, (x109 & 0xaf48a03b)); + let mut x116: u32 = 0; + let mut x117: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x116, &mut x117, x115, x99, (x109 & 0xbaaedce6)); + let mut x118: u32 = 0; + let mut x119: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x118, &mut x119, x117, x101, (x109 & 0xfffffffe)); + let mut x120: u32 = 0; + let mut x121: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x120, &mut x121, x119, x103, x109); + let mut x122: u32 = 0; + let mut x123: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x122, &mut x123, x121, x105, x109); + let mut x124: u32 = 0; + let mut x125: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x107, x109); + let mut x126: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x126, x3, (arg5[0]), x110); + let mut x127: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x127, x3, (arg5[1]), x112); + let mut x128: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x128, x3, (arg5[2]), x114); + let mut x129: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x129, x3, (arg5[3]), x116); + let mut x130: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x130, x3, (arg5[4]), x118); + let mut x131: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x131, x3, (arg5[5]), x120); + let mut x132: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x132, x3, (arg5[6]), x122); + let mut x133: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x133, x3, (arg5[7]), x124); + let x134: fiat_secp256k1_scalar_u1 = ((x34 & (0x1 as u32)) as fiat_secp256k1_scalar_u1); + let mut x135: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x135, x134, (0x0 as u32), x7); + let mut x136: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x136, x134, (0x0 as u32), x8); + let mut x137: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x137, x134, (0x0 as u32), x9); + let mut x138: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x138, x134, (0x0 as u32), x10); + let mut x139: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x139, x134, (0x0 as u32), x11); + let mut x140: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x140, x134, (0x0 as u32), x12); + let mut x141: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x141, x134, (0x0 as u32), x13); + let mut x142: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x142, x134, (0x0 as u32), x14); + let mut x143: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x143, x134, (0x0 as u32), x15); + let mut x144: u32 = 0; + let mut x145: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x144, &mut x145, 0x0, x34, x135); + let mut x146: u32 = 0; + let mut x147: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x146, &mut x147, x145, x35, x136); + let mut x148: u32 = 0; + let mut x149: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x148, &mut x149, x147, x36, x137); + let mut x150: u32 = 0; + let mut x151: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x150, &mut x151, x149, x37, x138); + let mut x152: u32 = 0; + let mut x153: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x152, &mut x153, x151, x38, x139); + let mut x154: u32 = 0; + let mut x155: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x154, &mut x155, x153, x39, x140); + let mut x156: u32 = 0; + let mut x157: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x156, &mut x157, x155, x40, x141); + let mut x158: u32 = 0; + let mut x159: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x158, &mut x159, x157, x41, x142); + let mut x160: u32 = 0; + let mut x161: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x42, x143); + let mut x162: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x162, x134, (0x0 as u32), x43); + let mut x163: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x163, x134, (0x0 as u32), x44); + let mut x164: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x164, x134, (0x0 as u32), x45); + let mut x165: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x165, x134, (0x0 as u32), x46); + let mut x166: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x166, x134, (0x0 as u32), x47); + let mut x167: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x167, x134, (0x0 as u32), x48); + let mut x168: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x168, x134, (0x0 as u32), x49); + let mut x169: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x169, x134, (0x0 as u32), x50); + let mut x170: u32 = 0; + let mut x171: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x170, &mut x171, 0x0, x126, x162); + let mut x172: u32 = 0; + let mut x173: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x172, &mut x173, x171, x127, x163); + let mut x174: u32 = 0; + let mut x175: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x174, &mut x175, x173, x128, x164); + let mut x176: u32 = 0; + let mut x177: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x176, &mut x177, x175, x129, x165); + let mut x178: u32 = 0; + let mut x179: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x178, &mut x179, x177, x130, x166); + let mut x180: u32 = 0; + let mut x181: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x180, &mut x181, x179, x131, x167); + let mut x182: u32 = 0; + let mut x183: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x182, &mut x183, x181, x132, x168); + let mut x184: u32 = 0; + let mut x185: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x184, &mut x185, x183, x133, x169); + let mut x186: u32 = 0; + let mut x187: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x186, &mut x187, 0x0, x170, 0xd0364141); + let mut x188: u32 = 0; + let mut x189: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x188, &mut x189, x187, x172, 0xbfd25e8c); + let mut x190: u32 = 0; + let mut x191: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x190, &mut x191, x189, x174, 0xaf48a03b); + let mut x192: u32 = 0; + let mut x193: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x192, &mut x193, x191, x176, 0xbaaedce6); + let mut x194: u32 = 0; + let mut x195: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x194, &mut x195, x193, x178, 0xfffffffe); + let mut x196: u32 = 0; + let mut x197: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x196, &mut x197, x195, x180, 0xffffffff); + let mut x198: u32 = 0; + let mut x199: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x198, &mut x199, x197, x182, 0xffffffff); + let mut x200: u32 = 0; + let mut x201: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x200, &mut x201, x199, x184, 0xffffffff); + let mut x202: u32 = 0; + let mut x203: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u32(&mut x202, &mut x203, x201, (x185 as u32), (0x0 as u32)); + let mut x204: u32 = 0; + let mut x205: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u32(&mut x204, &mut x205, 0x0, x6, (0x1 as u32)); + let x206: u32 = ((x144 >> 1) | ((x146 << 31) & 0xffffffff)); + let x207: u32 = ((x146 >> 1) | ((x148 << 31) & 0xffffffff)); + let x208: u32 = ((x148 >> 1) | ((x150 << 31) & 0xffffffff)); + let x209: u32 = ((x150 >> 1) | ((x152 << 31) & 0xffffffff)); + let x210: u32 = ((x152 >> 1) | ((x154 << 31) & 0xffffffff)); + let x211: u32 = ((x154 >> 1) | ((x156 << 31) & 0xffffffff)); + let x212: u32 = ((x156 >> 1) | ((x158 << 31) & 0xffffffff)); + let x213: u32 = ((x158 >> 1) | ((x160 << 31) & 0xffffffff)); + let x214: u32 = ((x160 & 0x80000000) | (x160 >> 1)); + let mut x215: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x215, x84, x67, x51); + let mut x216: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x216, x84, x69, x53); + let mut x217: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x217, x84, x71, x55); + let mut x218: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x218, x84, x73, x57); + let mut x219: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x219, x84, x75, x59); + let mut x220: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x220, x84, x77, x61); + let mut x221: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x221, x84, x79, x63); + let mut x222: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x222, x84, x81, x65); + let mut x223: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x223, x203, x186, x170); + let mut x224: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x224, x203, x188, x172); + let mut x225: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x225, x203, x190, x174); + let mut x226: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x226, x203, x192, x176); + let mut x227: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x227, x203, x194, x178); + let mut x228: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x228, x203, x196, x180); + let mut x229: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x229, x203, x198, x182); + let mut x230: u32 = 0; + fiat_secp256k1_scalar_cmovznz_u32(&mut x230, x203, x200, x184); + *out1 = x204; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out2[7] = x14; + out2[8] = x15; + out3[0] = x206; + out3[1] = x207; + out3[2] = x208; + out3[3] = x209; + out3[4] = x210; + out3[5] = x211; + out3[6] = x212; + out3[7] = x213; + out3[8] = x214; + out4[0] = x215; + out4[1] = x216; + out4[2] = x217; + out4[3] = x218; + out4[4] = x219; + out4[5] = x220; + out4[6] = x221; + out4[7] = x222; + out5[0] = x223; + out5[1] = x224; + out5[2] = x225; + out5[3] = x226; + out5[4] = x227; + out5[5] = x228; + out5[6] = x229; + out5[7] = x230; +} + +/// The function fiat_secp256k1_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +#[inline] +pub fn fiat_secp256k1_scalar_divstep_precomp(out1: &mut [u32; 8]) -> () { + out1[0] = 0x2b9cb4e9; + out1[1] = 0xd7431a4d; + out1[2] = 0x32d9c503; + out1[3] = 0xab67d35a; + out1[4] = 0x859ce35f; + out1[5] = 0xadf6c7e5; + out1[6] = 0x1df6c379; + out1[7] = 0x61544145; +} diff --git a/fiat-rust/src/secp256k1_scalar_64.rs b/fiat-rust/src/secp256k1_scalar_64.rs new file mode 100644 index 0000000000..5778e6d41f --- /dev/null +++ b/fiat-rust/src/secp256k1_scalar_64.rs @@ -0,0 +1,2017 @@ +//! Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline secp256k1_scalar 64 '2^256 - 432420386565659656852420866394968145599' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +//! curve description: secp256k1_scalar +//! machine_wordsize = 64 (from "64") +//! requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +//! m = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141 (from "2^256 - 432420386565659656852420866394968145599") +//! +//! NOTE: In addition to the bounds specified above each function, all +//! functions synthesized for this Montgomery arithmetic require the +//! input to be strictly less than the prime modulus (m), and also +//! require the input to be in the unique saturated representation. +//! All functions also ensure that these two properties are true of +//! return values. +//! +//! Computed values: +//! eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) +//! bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +//! twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in +//! if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 + +#![allow(unused_parens)] +#![allow(non_camel_case_types)] + +pub type fiat_secp256k1_scalar_u1 = u8; +pub type fiat_secp256k1_scalar_i1 = i8; +pub type fiat_secp256k1_scalar_u2 = u8; +pub type fiat_secp256k1_scalar_i2 = i8; + +/* The type fiat_secp256k1_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +pub type fiat_secp256k1_scalar_montgomery_domain_field_element = [u64; 4]; + +/* The type fiat_secp256k1_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +pub type fiat_secp256k1_scalar_non_montgomery_domain_field_element = [u64; 4]; + + +/// The function fiat_secp256k1_scalar_addcarryx_u64 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^64 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_secp256k1_scalar_addcarryx_u64(out1: &mut u64, out2: &mut fiat_secp256k1_scalar_u1, arg1: fiat_secp256k1_scalar_u1, arg2: u64, arg3: u64) -> () { + let x1: u128 = (((arg1 as u128) + (arg2 as u128)) + (arg3 as u128)); + let x2: u64 = ((x1 & (0xffffffffffffffff as u128)) as u64); + let x3: fiat_secp256k1_scalar_u1 = ((x1 >> 64) as fiat_secp256k1_scalar_u1); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_secp256k1_scalar_subborrowx_u64 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^64 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +#[inline] +pub fn fiat_secp256k1_scalar_subborrowx_u64(out1: &mut u64, out2: &mut fiat_secp256k1_scalar_u1, arg1: fiat_secp256k1_scalar_u1, arg2: u64, arg3: u64) -> () { + let x1: i128 = (((arg2 as i128) - (arg1 as i128)) - (arg3 as i128)); + let x2: fiat_secp256k1_scalar_i1 = ((x1 >> 64) as fiat_secp256k1_scalar_i1); + let x3: u64 = ((x1 & (0xffffffffffffffff as i128)) as u64); + *out1 = x3; + *out2 = (((0x0 as fiat_secp256k1_scalar_i2) - (x2 as fiat_secp256k1_scalar_i2)) as fiat_secp256k1_scalar_u1); +} + +/// The function fiat_secp256k1_scalar_mulx_u64 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^64 +/// out2 = ⌊arg1 * arg2 / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0xffffffffffffffff] +#[inline] +pub fn fiat_secp256k1_scalar_mulx_u64(out1: &mut u64, out2: &mut u64, arg1: u64, arg2: u64) -> () { + let x1: u128 = ((arg1 as u128) * (arg2 as u128)); + let x2: u64 = ((x1 & (0xffffffffffffffff as u128)) as u64); + let x3: u64 = ((x1 >> 64) as u64); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_secp256k1_scalar_cmovznz_u64 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +#[inline] +pub fn fiat_secp256k1_scalar_cmovznz_u64(out1: &mut u64, arg1: fiat_secp256k1_scalar_u1, arg2: u64, arg3: u64) -> () { + let x1: fiat_secp256k1_scalar_u1 = (!(!arg1)); + let x2: u64 = ((((((0x0 as fiat_secp256k1_scalar_i2) - (x1 as fiat_secp256k1_scalar_i2)) as fiat_secp256k1_scalar_i1) as i128) & (0xffffffffffffffff as i128)) as u64); + let x3: u64 = ((x2 & arg3) | ((!x2) & arg2)); + *out1 = x3; +} + +/// The function fiat_secp256k1_scalar_mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_mul(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_montgomery_domain_field_element, arg2: &fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[1]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[0]); + let mut x5: u64 = 0; + let mut x6: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x5, &mut x6, x4, (arg2[3])); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x7, &mut x8, x4, (arg2[2])); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x9, &mut x10, x4, (arg2[1])); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x11, &mut x12, x4, (arg2[0])); + let mut x13: u64 = 0; + let mut x14: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x17, &mut x18, x16, x8, x5); + let x19: u64 = ((x18 as u64) + x6); + let mut x20: u64 = 0; + let mut x21: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x20, &mut x21, x11, 0x4b0dff665588b13f); + let mut x22: u64 = 0; + let mut x23: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x22, &mut x23, x20, 0xffffffffffffffff); + let mut x24: u64 = 0; + let mut x25: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x24, &mut x25, x20, 0xfffffffffffffffe); + let mut x26: u64 = 0; + let mut x27: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x26, &mut x27, x20, 0xbaaedce6af48a03b); + let mut x28: u64 = 0; + let mut x29: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x28, &mut x29, x20, 0xbfd25e8cd0364141); + let mut x30: u64 = 0; + let mut x31: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x30, &mut x31, 0x0, x29, x26); + let mut x32: u64 = 0; + let mut x33: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x32, &mut x33, x31, x27, x24); + let mut x34: u64 = 0; + let mut x35: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x34, &mut x35, x33, x25, x22); + let x36: u64 = ((x35 as u64) + x23); + let mut x37: u64 = 0; + let mut x38: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x37, &mut x38, 0x0, x11, x28); + let mut x39: u64 = 0; + let mut x40: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x39, &mut x40, x38, x13, x30); + let mut x41: u64 = 0; + let mut x42: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x41, &mut x42, x40, x15, x32); + let mut x43: u64 = 0; + let mut x44: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x43, &mut x44, x42, x17, x34); + let mut x45: u64 = 0; + let mut x46: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x45, &mut x46, x44, x19, x36); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x47, &mut x48, x1, (arg2[3])); + let mut x49: u64 = 0; + let mut x50: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x49, &mut x50, x1, (arg2[2])); + let mut x51: u64 = 0; + let mut x52: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x51, &mut x52, x1, (arg2[1])); + let mut x53: u64 = 0; + let mut x54: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x53, &mut x54, x1, (arg2[0])); + let mut x55: u64 = 0; + let mut x56: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x55, &mut x56, 0x0, x54, x51); + let mut x57: u64 = 0; + let mut x58: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x57, &mut x58, x56, x52, x49); + let mut x59: u64 = 0; + let mut x60: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x59, &mut x60, x58, x50, x47); + let x61: u64 = ((x60 as u64) + x48); + let mut x62: u64 = 0; + let mut x63: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x62, &mut x63, 0x0, x39, x53); + let mut x64: u64 = 0; + let mut x65: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x64, &mut x65, x63, x41, x55); + let mut x66: u64 = 0; + let mut x67: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x66, &mut x67, x65, x43, x57); + let mut x68: u64 = 0; + let mut x69: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x68, &mut x69, x67, x45, x59); + let mut x70: u64 = 0; + let mut x71: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x70, &mut x71, x69, (x46 as u64), x61); + let mut x72: u64 = 0; + let mut x73: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x72, &mut x73, x62, 0x4b0dff665588b13f); + let mut x74: u64 = 0; + let mut x75: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x74, &mut x75, x72, 0xffffffffffffffff); + let mut x76: u64 = 0; + let mut x77: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x76, &mut x77, x72, 0xfffffffffffffffe); + let mut x78: u64 = 0; + let mut x79: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x78, &mut x79, x72, 0xbaaedce6af48a03b); + let mut x80: u64 = 0; + let mut x81: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x80, &mut x81, x72, 0xbfd25e8cd0364141); + let mut x82: u64 = 0; + let mut x83: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x82, &mut x83, 0x0, x81, x78); + let mut x84: u64 = 0; + let mut x85: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x84, &mut x85, x83, x79, x76); + let mut x86: u64 = 0; + let mut x87: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x86, &mut x87, x85, x77, x74); + let x88: u64 = ((x87 as u64) + x75); + let mut x89: u64 = 0; + let mut x90: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x89, &mut x90, 0x0, x62, x80); + let mut x91: u64 = 0; + let mut x92: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x91, &mut x92, x90, x64, x82); + let mut x93: u64 = 0; + let mut x94: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x93, &mut x94, x92, x66, x84); + let mut x95: u64 = 0; + let mut x96: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x95, &mut x96, x94, x68, x86); + let mut x97: u64 = 0; + let mut x98: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x97, &mut x98, x96, x70, x88); + let x99: u64 = ((x98 as u64) + (x71 as u64)); + let mut x100: u64 = 0; + let mut x101: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x100, &mut x101, x2, (arg2[3])); + let mut x102: u64 = 0; + let mut x103: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x102, &mut x103, x2, (arg2[2])); + let mut x104: u64 = 0; + let mut x105: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x104, &mut x105, x2, (arg2[1])); + let mut x106: u64 = 0; + let mut x107: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x106, &mut x107, x2, (arg2[0])); + let mut x108: u64 = 0; + let mut x109: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x108, &mut x109, 0x0, x107, x104); + let mut x110: u64 = 0; + let mut x111: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x110, &mut x111, x109, x105, x102); + let mut x112: u64 = 0; + let mut x113: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x112, &mut x113, x111, x103, x100); + let x114: u64 = ((x113 as u64) + x101); + let mut x115: u64 = 0; + let mut x116: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x115, &mut x116, 0x0, x91, x106); + let mut x117: u64 = 0; + let mut x118: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x117, &mut x118, x116, x93, x108); + let mut x119: u64 = 0; + let mut x120: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x119, &mut x120, x118, x95, x110); + let mut x121: u64 = 0; + let mut x122: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x121, &mut x122, x120, x97, x112); + let mut x123: u64 = 0; + let mut x124: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x123, &mut x124, x122, x99, x114); + let mut x125: u64 = 0; + let mut x126: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x125, &mut x126, x115, 0x4b0dff665588b13f); + let mut x127: u64 = 0; + let mut x128: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x127, &mut x128, x125, 0xffffffffffffffff); + let mut x129: u64 = 0; + let mut x130: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x129, &mut x130, x125, 0xfffffffffffffffe); + let mut x131: u64 = 0; + let mut x132: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x131, &mut x132, x125, 0xbaaedce6af48a03b); + let mut x133: u64 = 0; + let mut x134: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x133, &mut x134, x125, 0xbfd25e8cd0364141); + let mut x135: u64 = 0; + let mut x136: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x135, &mut x136, 0x0, x134, x131); + let mut x137: u64 = 0; + let mut x138: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x137, &mut x138, x136, x132, x129); + let mut x139: u64 = 0; + let mut x140: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x139, &mut x140, x138, x130, x127); + let x141: u64 = ((x140 as u64) + x128); + let mut x142: u64 = 0; + let mut x143: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x142, &mut x143, 0x0, x115, x133); + let mut x144: u64 = 0; + let mut x145: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x144, &mut x145, x143, x117, x135); + let mut x146: u64 = 0; + let mut x147: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x146, &mut x147, x145, x119, x137); + let mut x148: u64 = 0; + let mut x149: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x148, &mut x149, x147, x121, x139); + let mut x150: u64 = 0; + let mut x151: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x150, &mut x151, x149, x123, x141); + let x152: u64 = ((x151 as u64) + (x124 as u64)); + let mut x153: u64 = 0; + let mut x154: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x153, &mut x154, x3, (arg2[3])); + let mut x155: u64 = 0; + let mut x156: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x155, &mut x156, x3, (arg2[2])); + let mut x157: u64 = 0; + let mut x158: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x157, &mut x158, x3, (arg2[1])); + let mut x159: u64 = 0; + let mut x160: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x159, &mut x160, x3, (arg2[0])); + let mut x161: u64 = 0; + let mut x162: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x161, &mut x162, 0x0, x160, x157); + let mut x163: u64 = 0; + let mut x164: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x163, &mut x164, x162, x158, x155); + let mut x165: u64 = 0; + let mut x166: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x165, &mut x166, x164, x156, x153); + let x167: u64 = ((x166 as u64) + x154); + let mut x168: u64 = 0; + let mut x169: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x168, &mut x169, 0x0, x144, x159); + let mut x170: u64 = 0; + let mut x171: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x170, &mut x171, x169, x146, x161); + let mut x172: u64 = 0; + let mut x173: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x172, &mut x173, x171, x148, x163); + let mut x174: u64 = 0; + let mut x175: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x174, &mut x175, x173, x150, x165); + let mut x176: u64 = 0; + let mut x177: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x176, &mut x177, x175, x152, x167); + let mut x178: u64 = 0; + let mut x179: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x178, &mut x179, x168, 0x4b0dff665588b13f); + let mut x180: u64 = 0; + let mut x181: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x180, &mut x181, x178, 0xffffffffffffffff); + let mut x182: u64 = 0; + let mut x183: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x182, &mut x183, x178, 0xfffffffffffffffe); + let mut x184: u64 = 0; + let mut x185: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x184, &mut x185, x178, 0xbaaedce6af48a03b); + let mut x186: u64 = 0; + let mut x187: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x186, &mut x187, x178, 0xbfd25e8cd0364141); + let mut x188: u64 = 0; + let mut x189: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x188, &mut x189, 0x0, x187, x184); + let mut x190: u64 = 0; + let mut x191: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x190, &mut x191, x189, x185, x182); + let mut x192: u64 = 0; + let mut x193: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x192, &mut x193, x191, x183, x180); + let x194: u64 = ((x193 as u64) + x181); + let mut x195: u64 = 0; + let mut x196: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x195, &mut x196, 0x0, x168, x186); + let mut x197: u64 = 0; + let mut x198: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x197, &mut x198, x196, x170, x188); + let mut x199: u64 = 0; + let mut x200: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x199, &mut x200, x198, x172, x190); + let mut x201: u64 = 0; + let mut x202: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x201, &mut x202, x200, x174, x192); + let mut x203: u64 = 0; + let mut x204: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x203, &mut x204, x202, x176, x194); + let x205: u64 = ((x204 as u64) + (x177 as u64)); + let mut x206: u64 = 0; + let mut x207: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x206, &mut x207, 0x0, x197, 0xbfd25e8cd0364141); + let mut x208: u64 = 0; + let mut x209: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x208, &mut x209, x207, x199, 0xbaaedce6af48a03b); + let mut x210: u64 = 0; + let mut x211: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x210, &mut x211, x209, x201, 0xfffffffffffffffe); + let mut x212: u64 = 0; + let mut x213: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x212, &mut x213, x211, x203, 0xffffffffffffffff); + let mut x214: u64 = 0; + let mut x215: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x214, &mut x215, x213, x205, (0x0 as u64)); + let mut x216: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x216, x215, x206, x197); + let mut x217: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x217, x215, x208, x199); + let mut x218: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x218, x215, x210, x201); + let mut x219: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/// The function fiat_secp256k1_scalar_square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_square(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[1]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[0]); + let mut x5: u64 = 0; + let mut x6: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x5, &mut x6, x4, (arg1[3])); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x7, &mut x8, x4, (arg1[2])); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x9, &mut x10, x4, (arg1[1])); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x11, &mut x12, x4, (arg1[0])); + let mut x13: u64 = 0; + let mut x14: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x17, &mut x18, x16, x8, x5); + let x19: u64 = ((x18 as u64) + x6); + let mut x20: u64 = 0; + let mut x21: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x20, &mut x21, x11, 0x4b0dff665588b13f); + let mut x22: u64 = 0; + let mut x23: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x22, &mut x23, x20, 0xffffffffffffffff); + let mut x24: u64 = 0; + let mut x25: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x24, &mut x25, x20, 0xfffffffffffffffe); + let mut x26: u64 = 0; + let mut x27: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x26, &mut x27, x20, 0xbaaedce6af48a03b); + let mut x28: u64 = 0; + let mut x29: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x28, &mut x29, x20, 0xbfd25e8cd0364141); + let mut x30: u64 = 0; + let mut x31: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x30, &mut x31, 0x0, x29, x26); + let mut x32: u64 = 0; + let mut x33: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x32, &mut x33, x31, x27, x24); + let mut x34: u64 = 0; + let mut x35: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x34, &mut x35, x33, x25, x22); + let x36: u64 = ((x35 as u64) + x23); + let mut x37: u64 = 0; + let mut x38: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x37, &mut x38, 0x0, x11, x28); + let mut x39: u64 = 0; + let mut x40: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x39, &mut x40, x38, x13, x30); + let mut x41: u64 = 0; + let mut x42: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x41, &mut x42, x40, x15, x32); + let mut x43: u64 = 0; + let mut x44: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x43, &mut x44, x42, x17, x34); + let mut x45: u64 = 0; + let mut x46: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x45, &mut x46, x44, x19, x36); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x47, &mut x48, x1, (arg1[3])); + let mut x49: u64 = 0; + let mut x50: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x49, &mut x50, x1, (arg1[2])); + let mut x51: u64 = 0; + let mut x52: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x51, &mut x52, x1, (arg1[1])); + let mut x53: u64 = 0; + let mut x54: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x53, &mut x54, x1, (arg1[0])); + let mut x55: u64 = 0; + let mut x56: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x55, &mut x56, 0x0, x54, x51); + let mut x57: u64 = 0; + let mut x58: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x57, &mut x58, x56, x52, x49); + let mut x59: u64 = 0; + let mut x60: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x59, &mut x60, x58, x50, x47); + let x61: u64 = ((x60 as u64) + x48); + let mut x62: u64 = 0; + let mut x63: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x62, &mut x63, 0x0, x39, x53); + let mut x64: u64 = 0; + let mut x65: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x64, &mut x65, x63, x41, x55); + let mut x66: u64 = 0; + let mut x67: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x66, &mut x67, x65, x43, x57); + let mut x68: u64 = 0; + let mut x69: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x68, &mut x69, x67, x45, x59); + let mut x70: u64 = 0; + let mut x71: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x70, &mut x71, x69, (x46 as u64), x61); + let mut x72: u64 = 0; + let mut x73: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x72, &mut x73, x62, 0x4b0dff665588b13f); + let mut x74: u64 = 0; + let mut x75: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x74, &mut x75, x72, 0xffffffffffffffff); + let mut x76: u64 = 0; + let mut x77: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x76, &mut x77, x72, 0xfffffffffffffffe); + let mut x78: u64 = 0; + let mut x79: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x78, &mut x79, x72, 0xbaaedce6af48a03b); + let mut x80: u64 = 0; + let mut x81: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x80, &mut x81, x72, 0xbfd25e8cd0364141); + let mut x82: u64 = 0; + let mut x83: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x82, &mut x83, 0x0, x81, x78); + let mut x84: u64 = 0; + let mut x85: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x84, &mut x85, x83, x79, x76); + let mut x86: u64 = 0; + let mut x87: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x86, &mut x87, x85, x77, x74); + let x88: u64 = ((x87 as u64) + x75); + let mut x89: u64 = 0; + let mut x90: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x89, &mut x90, 0x0, x62, x80); + let mut x91: u64 = 0; + let mut x92: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x91, &mut x92, x90, x64, x82); + let mut x93: u64 = 0; + let mut x94: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x93, &mut x94, x92, x66, x84); + let mut x95: u64 = 0; + let mut x96: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x95, &mut x96, x94, x68, x86); + let mut x97: u64 = 0; + let mut x98: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x97, &mut x98, x96, x70, x88); + let x99: u64 = ((x98 as u64) + (x71 as u64)); + let mut x100: u64 = 0; + let mut x101: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x100, &mut x101, x2, (arg1[3])); + let mut x102: u64 = 0; + let mut x103: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x102, &mut x103, x2, (arg1[2])); + let mut x104: u64 = 0; + let mut x105: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x104, &mut x105, x2, (arg1[1])); + let mut x106: u64 = 0; + let mut x107: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x106, &mut x107, x2, (arg1[0])); + let mut x108: u64 = 0; + let mut x109: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x108, &mut x109, 0x0, x107, x104); + let mut x110: u64 = 0; + let mut x111: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x110, &mut x111, x109, x105, x102); + let mut x112: u64 = 0; + let mut x113: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x112, &mut x113, x111, x103, x100); + let x114: u64 = ((x113 as u64) + x101); + let mut x115: u64 = 0; + let mut x116: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x115, &mut x116, 0x0, x91, x106); + let mut x117: u64 = 0; + let mut x118: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x117, &mut x118, x116, x93, x108); + let mut x119: u64 = 0; + let mut x120: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x119, &mut x120, x118, x95, x110); + let mut x121: u64 = 0; + let mut x122: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x121, &mut x122, x120, x97, x112); + let mut x123: u64 = 0; + let mut x124: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x123, &mut x124, x122, x99, x114); + let mut x125: u64 = 0; + let mut x126: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x125, &mut x126, x115, 0x4b0dff665588b13f); + let mut x127: u64 = 0; + let mut x128: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x127, &mut x128, x125, 0xffffffffffffffff); + let mut x129: u64 = 0; + let mut x130: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x129, &mut x130, x125, 0xfffffffffffffffe); + let mut x131: u64 = 0; + let mut x132: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x131, &mut x132, x125, 0xbaaedce6af48a03b); + let mut x133: u64 = 0; + let mut x134: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x133, &mut x134, x125, 0xbfd25e8cd0364141); + let mut x135: u64 = 0; + let mut x136: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x135, &mut x136, 0x0, x134, x131); + let mut x137: u64 = 0; + let mut x138: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x137, &mut x138, x136, x132, x129); + let mut x139: u64 = 0; + let mut x140: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x139, &mut x140, x138, x130, x127); + let x141: u64 = ((x140 as u64) + x128); + let mut x142: u64 = 0; + let mut x143: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x142, &mut x143, 0x0, x115, x133); + let mut x144: u64 = 0; + let mut x145: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x144, &mut x145, x143, x117, x135); + let mut x146: u64 = 0; + let mut x147: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x146, &mut x147, x145, x119, x137); + let mut x148: u64 = 0; + let mut x149: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x148, &mut x149, x147, x121, x139); + let mut x150: u64 = 0; + let mut x151: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x150, &mut x151, x149, x123, x141); + let x152: u64 = ((x151 as u64) + (x124 as u64)); + let mut x153: u64 = 0; + let mut x154: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x153, &mut x154, x3, (arg1[3])); + let mut x155: u64 = 0; + let mut x156: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x155, &mut x156, x3, (arg1[2])); + let mut x157: u64 = 0; + let mut x158: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x157, &mut x158, x3, (arg1[1])); + let mut x159: u64 = 0; + let mut x160: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x159, &mut x160, x3, (arg1[0])); + let mut x161: u64 = 0; + let mut x162: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x161, &mut x162, 0x0, x160, x157); + let mut x163: u64 = 0; + let mut x164: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x163, &mut x164, x162, x158, x155); + let mut x165: u64 = 0; + let mut x166: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x165, &mut x166, x164, x156, x153); + let x167: u64 = ((x166 as u64) + x154); + let mut x168: u64 = 0; + let mut x169: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x168, &mut x169, 0x0, x144, x159); + let mut x170: u64 = 0; + let mut x171: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x170, &mut x171, x169, x146, x161); + let mut x172: u64 = 0; + let mut x173: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x172, &mut x173, x171, x148, x163); + let mut x174: u64 = 0; + let mut x175: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x174, &mut x175, x173, x150, x165); + let mut x176: u64 = 0; + let mut x177: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x176, &mut x177, x175, x152, x167); + let mut x178: u64 = 0; + let mut x179: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x178, &mut x179, x168, 0x4b0dff665588b13f); + let mut x180: u64 = 0; + let mut x181: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x180, &mut x181, x178, 0xffffffffffffffff); + let mut x182: u64 = 0; + let mut x183: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x182, &mut x183, x178, 0xfffffffffffffffe); + let mut x184: u64 = 0; + let mut x185: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x184, &mut x185, x178, 0xbaaedce6af48a03b); + let mut x186: u64 = 0; + let mut x187: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x186, &mut x187, x178, 0xbfd25e8cd0364141); + let mut x188: u64 = 0; + let mut x189: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x188, &mut x189, 0x0, x187, x184); + let mut x190: u64 = 0; + let mut x191: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x190, &mut x191, x189, x185, x182); + let mut x192: u64 = 0; + let mut x193: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x192, &mut x193, x191, x183, x180); + let x194: u64 = ((x193 as u64) + x181); + let mut x195: u64 = 0; + let mut x196: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x195, &mut x196, 0x0, x168, x186); + let mut x197: u64 = 0; + let mut x198: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x197, &mut x198, x196, x170, x188); + let mut x199: u64 = 0; + let mut x200: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x199, &mut x200, x198, x172, x190); + let mut x201: u64 = 0; + let mut x202: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x201, &mut x202, x200, x174, x192); + let mut x203: u64 = 0; + let mut x204: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x203, &mut x204, x202, x176, x194); + let x205: u64 = ((x204 as u64) + (x177 as u64)); + let mut x206: u64 = 0; + let mut x207: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x206, &mut x207, 0x0, x197, 0xbfd25e8cd0364141); + let mut x208: u64 = 0; + let mut x209: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x208, &mut x209, x207, x199, 0xbaaedce6af48a03b); + let mut x210: u64 = 0; + let mut x211: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x210, &mut x211, x209, x201, 0xfffffffffffffffe); + let mut x212: u64 = 0; + let mut x213: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x212, &mut x213, x211, x203, 0xffffffffffffffff); + let mut x214: u64 = 0; + let mut x215: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x214, &mut x215, x213, x205, (0x0 as u64)); + let mut x216: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x216, x215, x206, x197); + let mut x217: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x217, x215, x208, x199); + let mut x218: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x218, x215, x210, x201); + let mut x219: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/// The function fiat_secp256k1_scalar_add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_add(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_montgomery_domain_field_element, arg2: &fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u64 = 0; + let mut x4: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u64 = 0; + let mut x6: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u64 = 0; + let mut x8: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u64 = 0; + let mut x10: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x9, &mut x10, 0x0, x1, 0xbfd25e8cd0364141); + let mut x11: u64 = 0; + let mut x12: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x11, &mut x12, x10, x3, 0xbaaedce6af48a03b); + let mut x13: u64 = 0; + let mut x14: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x13, &mut x14, x12, x5, 0xfffffffffffffffe); + let mut x15: u64 = 0; + let mut x16: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x15, &mut x16, x14, x7, 0xffffffffffffffff); + let mut x17: u64 = 0; + let mut x18: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x17, &mut x18, x16, (x8 as u64), (0x0 as u64)); + let mut x19: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x19, x18, x9, x1); + let mut x20: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x20, x18, x11, x3); + let mut x21: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x21, x18, x13, x5); + let mut x22: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/// The function fiat_secp256k1_scalar_sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_sub(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_montgomery_domain_field_element, arg2: &fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u64 = 0; + let mut x4: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u64 = 0; + let mut x6: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u64 = 0; + let mut x8: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x9, x8, (0x0 as u64), 0xffffffffffffffff); + let mut x10: u64 = 0; + let mut x11: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x10, &mut x11, 0x0, x1, (x9 & 0xbfd25e8cd0364141)); + let mut x12: u64 = 0; + let mut x13: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x12, &mut x13, x11, x3, (x9 & 0xbaaedce6af48a03b)); + let mut x14: u64 = 0; + let mut x15: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x14, &mut x15, x13, x5, (x9 & 0xfffffffffffffffe)); + let mut x16: u64 = 0; + let mut x17: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x7, x9); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fiat_secp256k1_scalar_opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_opp(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x1, &mut x2, 0x0, (0x0 as u64), (arg1[0])); + let mut x3: u64 = 0; + let mut x4: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x3, &mut x4, x2, (0x0 as u64), (arg1[1])); + let mut x5: u64 = 0; + let mut x6: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x5, &mut x6, x4, (0x0 as u64), (arg1[2])); + let mut x7: u64 = 0; + let mut x8: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x7, &mut x8, x6, (0x0 as u64), (arg1[3])); + let mut x9: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x9, x8, (0x0 as u64), 0xffffffffffffffff); + let mut x10: u64 = 0; + let mut x11: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x10, &mut x11, 0x0, x1, (x9 & 0xbfd25e8cd0364141)); + let mut x12: u64 = 0; + let mut x13: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x12, &mut x13, x11, x3, (x9 & 0xbaaedce6af48a03b)); + let mut x14: u64 = 0; + let mut x15: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x14, &mut x15, x13, x5, (x9 & 0xfffffffffffffffe)); + let mut x16: u64 = 0; + let mut x17: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x7, x9); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fiat_secp256k1_scalar_from_montgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_from_montgomery(out1: &mut fiat_secp256k1_scalar_non_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[0]); + let mut x2: u64 = 0; + let mut x3: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x2, &mut x3, x1, 0x4b0dff665588b13f); + let mut x4: u64 = 0; + let mut x5: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x4, &mut x5, x2, 0xffffffffffffffff); + let mut x6: u64 = 0; + let mut x7: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x6, &mut x7, x2, 0xfffffffffffffffe); + let mut x8: u64 = 0; + let mut x9: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x8, &mut x9, x2, 0xbaaedce6af48a03b); + let mut x10: u64 = 0; + let mut x11: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x10, &mut x11, x2, 0xbfd25e8cd0364141); + let mut x12: u64 = 0; + let mut x13: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x12, &mut x13, 0x0, x11, x8); + let mut x14: u64 = 0; + let mut x15: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x14, &mut x15, x13, x9, x6); + let mut x16: u64 = 0; + let mut x17: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x7, x4); + let mut x18: u64 = 0; + let mut x19: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x18, &mut x19, 0x0, x1, x10); + let mut x20: u64 = 0; + let mut x21: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x20, &mut x21, x19, (0x0 as u64), x12); + let mut x22: u64 = 0; + let mut x23: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x22, &mut x23, x21, (0x0 as u64), x14); + let mut x24: u64 = 0; + let mut x25: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x24, &mut x25, x23, (0x0 as u64), x16); + let mut x26: u64 = 0; + let mut x27: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x26, &mut x27, x25, (0x0 as u64), ((x17 as u64) + x5)); + let mut x28: u64 = 0; + let mut x29: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x28, &mut x29, 0x0, x20, (arg1[1])); + let mut x30: u64 = 0; + let mut x31: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x30, &mut x31, x29, x22, (0x0 as u64)); + let mut x32: u64 = 0; + let mut x33: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x32, &mut x33, x31, x24, (0x0 as u64)); + let mut x34: u64 = 0; + let mut x35: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x34, &mut x35, x33, x26, (0x0 as u64)); + let mut x36: u64 = 0; + let mut x37: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x36, &mut x37, x28, 0x4b0dff665588b13f); + let mut x38: u64 = 0; + let mut x39: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x38, &mut x39, x36, 0xffffffffffffffff); + let mut x40: u64 = 0; + let mut x41: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x40, &mut x41, x36, 0xfffffffffffffffe); + let mut x42: u64 = 0; + let mut x43: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x42, &mut x43, x36, 0xbaaedce6af48a03b); + let mut x44: u64 = 0; + let mut x45: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x44, &mut x45, x36, 0xbfd25e8cd0364141); + let mut x46: u64 = 0; + let mut x47: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x46, &mut x47, 0x0, x45, x42); + let mut x48: u64 = 0; + let mut x49: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x48, &mut x49, x47, x43, x40); + let mut x50: u64 = 0; + let mut x51: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x50, &mut x51, x49, x41, x38); + let mut x52: u64 = 0; + let mut x53: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x52, &mut x53, 0x0, x28, x44); + let mut x54: u64 = 0; + let mut x55: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x54, &mut x55, x53, x30, x46); + let mut x56: u64 = 0; + let mut x57: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x56, &mut x57, x55, x32, x48); + let mut x58: u64 = 0; + let mut x59: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x58, &mut x59, x57, x34, x50); + let mut x60: u64 = 0; + let mut x61: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x60, &mut x61, x59, ((x35 as u64) + (x27 as u64)), ((x51 as u64) + x39)); + let mut x62: u64 = 0; + let mut x63: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x62, &mut x63, 0x0, x54, (arg1[2])); + let mut x64: u64 = 0; + let mut x65: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x64, &mut x65, x63, x56, (0x0 as u64)); + let mut x66: u64 = 0; + let mut x67: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x66, &mut x67, x65, x58, (0x0 as u64)); + let mut x68: u64 = 0; + let mut x69: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x68, &mut x69, x67, x60, (0x0 as u64)); + let mut x70: u64 = 0; + let mut x71: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x70, &mut x71, x62, 0x4b0dff665588b13f); + let mut x72: u64 = 0; + let mut x73: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x72, &mut x73, x70, 0xffffffffffffffff); + let mut x74: u64 = 0; + let mut x75: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x74, &mut x75, x70, 0xfffffffffffffffe); + let mut x76: u64 = 0; + let mut x77: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x76, &mut x77, x70, 0xbaaedce6af48a03b); + let mut x78: u64 = 0; + let mut x79: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x78, &mut x79, x70, 0xbfd25e8cd0364141); + let mut x80: u64 = 0; + let mut x81: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x80, &mut x81, 0x0, x79, x76); + let mut x82: u64 = 0; + let mut x83: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x82, &mut x83, x81, x77, x74); + let mut x84: u64 = 0; + let mut x85: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x84, &mut x85, x83, x75, x72); + let mut x86: u64 = 0; + let mut x87: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x86, &mut x87, 0x0, x62, x78); + let mut x88: u64 = 0; + let mut x89: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x88, &mut x89, x87, x64, x80); + let mut x90: u64 = 0; + let mut x91: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x90, &mut x91, x89, x66, x82); + let mut x92: u64 = 0; + let mut x93: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x92, &mut x93, x91, x68, x84); + let mut x94: u64 = 0; + let mut x95: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x94, &mut x95, x93, ((x69 as u64) + (x61 as u64)), ((x85 as u64) + x73)); + let mut x96: u64 = 0; + let mut x97: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x96, &mut x97, 0x0, x88, (arg1[3])); + let mut x98: u64 = 0; + let mut x99: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x98, &mut x99, x97, x90, (0x0 as u64)); + let mut x100: u64 = 0; + let mut x101: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x100, &mut x101, x99, x92, (0x0 as u64)); + let mut x102: u64 = 0; + let mut x103: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x102, &mut x103, x101, x94, (0x0 as u64)); + let mut x104: u64 = 0; + let mut x105: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x104, &mut x105, x96, 0x4b0dff665588b13f); + let mut x106: u64 = 0; + let mut x107: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x106, &mut x107, x104, 0xffffffffffffffff); + let mut x108: u64 = 0; + let mut x109: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x108, &mut x109, x104, 0xfffffffffffffffe); + let mut x110: u64 = 0; + let mut x111: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x110, &mut x111, x104, 0xbaaedce6af48a03b); + let mut x112: u64 = 0; + let mut x113: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x112, &mut x113, x104, 0xbfd25e8cd0364141); + let mut x114: u64 = 0; + let mut x115: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x114, &mut x115, 0x0, x113, x110); + let mut x116: u64 = 0; + let mut x117: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x116, &mut x117, x115, x111, x108); + let mut x118: u64 = 0; + let mut x119: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x118, &mut x119, x117, x109, x106); + let mut x120: u64 = 0; + let mut x121: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x120, &mut x121, 0x0, x96, x112); + let mut x122: u64 = 0; + let mut x123: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x122, &mut x123, x121, x98, x114); + let mut x124: u64 = 0; + let mut x125: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x124, &mut x125, x123, x100, x116); + let mut x126: u64 = 0; + let mut x127: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x126, &mut x127, x125, x102, x118); + let mut x128: u64 = 0; + let mut x129: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x128, &mut x129, x127, ((x103 as u64) + (x95 as u64)), ((x119 as u64) + x107)); + let mut x130: u64 = 0; + let mut x131: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x130, &mut x131, 0x0, x122, 0xbfd25e8cd0364141); + let mut x132: u64 = 0; + let mut x133: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x132, &mut x133, x131, x124, 0xbaaedce6af48a03b); + let mut x134: u64 = 0; + let mut x135: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x134, &mut x135, x133, x126, 0xfffffffffffffffe); + let mut x136: u64 = 0; + let mut x137: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x136, &mut x137, x135, x128, 0xffffffffffffffff); + let mut x138: u64 = 0; + let mut x139: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x138, &mut x139, x137, (x129 as u64), (0x0 as u64)); + let mut x140: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x140, x139, x130, x122); + let mut x141: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x141, x139, x132, x124); + let mut x142: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x142, x139, x134, x126); + let mut x143: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x143, x139, x136, x128); + out1[0] = x140; + out1[1] = x141; + out1[2] = x142; + out1[3] = x143; +} + +/// The function fiat_secp256k1_scalar_to_montgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_to_montgomery(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element, arg1: &fiat_secp256k1_scalar_non_montgomery_domain_field_element) -> () { + let x1: u64 = (arg1[1]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[3]); + let x4: u64 = (arg1[0]); + let mut x5: u64 = 0; + let mut x6: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x5, &mut x6, x4, 0x9d671cd581c69bc5); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x7, &mut x8, x4, 0xe697f5e45bcd07c6); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x9, &mut x10, x4, 0x741496c20e7cf878); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x11, &mut x12, x4, 0x896cf21467d7d140); + let mut x13: u64 = 0; + let mut x14: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x17, &mut x18, x16, x8, x5); + let mut x19: u64 = 0; + let mut x20: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x19, &mut x20, x11, 0x4b0dff665588b13f); + let mut x21: u64 = 0; + let mut x22: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x21, &mut x22, x19, 0xffffffffffffffff); + let mut x23: u64 = 0; + let mut x24: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x23, &mut x24, x19, 0xfffffffffffffffe); + let mut x25: u64 = 0; + let mut x26: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x25, &mut x26, x19, 0xbaaedce6af48a03b); + let mut x27: u64 = 0; + let mut x28: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x27, &mut x28, x19, 0xbfd25e8cd0364141); + let mut x29: u64 = 0; + let mut x30: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x29, &mut x30, 0x0, x28, x25); + let mut x31: u64 = 0; + let mut x32: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x31, &mut x32, x30, x26, x23); + let mut x33: u64 = 0; + let mut x34: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x33, &mut x34, x32, x24, x21); + let mut x35: u64 = 0; + let mut x36: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x35, &mut x36, 0x0, x11, x27); + let mut x37: u64 = 0; + let mut x38: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x37, &mut x38, x36, x13, x29); + let mut x39: u64 = 0; + let mut x40: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x39, &mut x40, x38, x15, x31); + let mut x41: u64 = 0; + let mut x42: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x41, &mut x42, x40, x17, x33); + let mut x43: u64 = 0; + let mut x44: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x43, &mut x44, x42, ((x18 as u64) + x6), ((x34 as u64) + x22)); + let mut x45: u64 = 0; + let mut x46: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x45, &mut x46, x1, 0x9d671cd581c69bc5); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x47, &mut x48, x1, 0xe697f5e45bcd07c6); + let mut x49: u64 = 0; + let mut x50: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x49, &mut x50, x1, 0x741496c20e7cf878); + let mut x51: u64 = 0; + let mut x52: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x51, &mut x52, x1, 0x896cf21467d7d140); + let mut x53: u64 = 0; + let mut x54: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x53, &mut x54, 0x0, x52, x49); + let mut x55: u64 = 0; + let mut x56: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x55, &mut x56, x54, x50, x47); + let mut x57: u64 = 0; + let mut x58: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x57, &mut x58, x56, x48, x45); + let mut x59: u64 = 0; + let mut x60: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x59, &mut x60, 0x0, x37, x51); + let mut x61: u64 = 0; + let mut x62: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x61, &mut x62, x60, x39, x53); + let mut x63: u64 = 0; + let mut x64: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x63, &mut x64, x62, x41, x55); + let mut x65: u64 = 0; + let mut x66: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x65, &mut x66, x64, x43, x57); + let mut x67: u64 = 0; + let mut x68: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x67, &mut x68, x59, 0x4b0dff665588b13f); + let mut x69: u64 = 0; + let mut x70: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x69, &mut x70, x67, 0xffffffffffffffff); + let mut x71: u64 = 0; + let mut x72: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x71, &mut x72, x67, 0xfffffffffffffffe); + let mut x73: u64 = 0; + let mut x74: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x73, &mut x74, x67, 0xbaaedce6af48a03b); + let mut x75: u64 = 0; + let mut x76: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x75, &mut x76, x67, 0xbfd25e8cd0364141); + let mut x77: u64 = 0; + let mut x78: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x77, &mut x78, 0x0, x76, x73); + let mut x79: u64 = 0; + let mut x80: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x79, &mut x80, x78, x74, x71); + let mut x81: u64 = 0; + let mut x82: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x81, &mut x82, x80, x72, x69); + let mut x83: u64 = 0; + let mut x84: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x83, &mut x84, 0x0, x59, x75); + let mut x85: u64 = 0; + let mut x86: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x85, &mut x86, x84, x61, x77); + let mut x87: u64 = 0; + let mut x88: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x87, &mut x88, x86, x63, x79); + let mut x89: u64 = 0; + let mut x90: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x89, &mut x90, x88, x65, x81); + let mut x91: u64 = 0; + let mut x92: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x91, &mut x92, x90, (((x66 as u64) + (x44 as u64)) + ((x58 as u64) + x46)), ((x82 as u64) + x70)); + let mut x93: u64 = 0; + let mut x94: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x93, &mut x94, x2, 0x9d671cd581c69bc5); + let mut x95: u64 = 0; + let mut x96: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x95, &mut x96, x2, 0xe697f5e45bcd07c6); + let mut x97: u64 = 0; + let mut x98: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x97, &mut x98, x2, 0x741496c20e7cf878); + let mut x99: u64 = 0; + let mut x100: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x99, &mut x100, x2, 0x896cf21467d7d140); + let mut x101: u64 = 0; + let mut x102: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x101, &mut x102, 0x0, x100, x97); + let mut x103: u64 = 0; + let mut x104: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x103, &mut x104, x102, x98, x95); + let mut x105: u64 = 0; + let mut x106: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x105, &mut x106, x104, x96, x93); + let mut x107: u64 = 0; + let mut x108: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x107, &mut x108, 0x0, x85, x99); + let mut x109: u64 = 0; + let mut x110: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x109, &mut x110, x108, x87, x101); + let mut x111: u64 = 0; + let mut x112: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x111, &mut x112, x110, x89, x103); + let mut x113: u64 = 0; + let mut x114: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x113, &mut x114, x112, x91, x105); + let mut x115: u64 = 0; + let mut x116: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x115, &mut x116, x107, 0x4b0dff665588b13f); + let mut x117: u64 = 0; + let mut x118: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x117, &mut x118, x115, 0xffffffffffffffff); + let mut x119: u64 = 0; + let mut x120: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x119, &mut x120, x115, 0xfffffffffffffffe); + let mut x121: u64 = 0; + let mut x122: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x121, &mut x122, x115, 0xbaaedce6af48a03b); + let mut x123: u64 = 0; + let mut x124: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x123, &mut x124, x115, 0xbfd25e8cd0364141); + let mut x125: u64 = 0; + let mut x126: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x125, &mut x126, 0x0, x124, x121); + let mut x127: u64 = 0; + let mut x128: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x127, &mut x128, x126, x122, x119); + let mut x129: u64 = 0; + let mut x130: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x129, &mut x130, x128, x120, x117); + let mut x131: u64 = 0; + let mut x132: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x131, &mut x132, 0x0, x107, x123); + let mut x133: u64 = 0; + let mut x134: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x133, &mut x134, x132, x109, x125); + let mut x135: u64 = 0; + let mut x136: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x135, &mut x136, x134, x111, x127); + let mut x137: u64 = 0; + let mut x138: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x137, &mut x138, x136, x113, x129); + let mut x139: u64 = 0; + let mut x140: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x139, &mut x140, x138, (((x114 as u64) + (x92 as u64)) + ((x106 as u64) + x94)), ((x130 as u64) + x118)); + let mut x141: u64 = 0; + let mut x142: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x141, &mut x142, x3, 0x9d671cd581c69bc5); + let mut x143: u64 = 0; + let mut x144: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x143, &mut x144, x3, 0xe697f5e45bcd07c6); + let mut x145: u64 = 0; + let mut x146: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x145, &mut x146, x3, 0x741496c20e7cf878); + let mut x147: u64 = 0; + let mut x148: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x147, &mut x148, x3, 0x896cf21467d7d140); + let mut x149: u64 = 0; + let mut x150: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x149, &mut x150, 0x0, x148, x145); + let mut x151: u64 = 0; + let mut x152: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x151, &mut x152, x150, x146, x143); + let mut x153: u64 = 0; + let mut x154: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x153, &mut x154, x152, x144, x141); + let mut x155: u64 = 0; + let mut x156: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x155, &mut x156, 0x0, x133, x147); + let mut x157: u64 = 0; + let mut x158: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x157, &mut x158, x156, x135, x149); + let mut x159: u64 = 0; + let mut x160: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x159, &mut x160, x158, x137, x151); + let mut x161: u64 = 0; + let mut x162: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x161, &mut x162, x160, x139, x153); + let mut x163: u64 = 0; + let mut x164: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x163, &mut x164, x155, 0x4b0dff665588b13f); + let mut x165: u64 = 0; + let mut x166: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x165, &mut x166, x163, 0xffffffffffffffff); + let mut x167: u64 = 0; + let mut x168: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x167, &mut x168, x163, 0xfffffffffffffffe); + let mut x169: u64 = 0; + let mut x170: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x169, &mut x170, x163, 0xbaaedce6af48a03b); + let mut x171: u64 = 0; + let mut x172: u64 = 0; + fiat_secp256k1_scalar_mulx_u64(&mut x171, &mut x172, x163, 0xbfd25e8cd0364141); + let mut x173: u64 = 0; + let mut x174: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x173, &mut x174, 0x0, x172, x169); + let mut x175: u64 = 0; + let mut x176: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x175, &mut x176, x174, x170, x167); + let mut x177: u64 = 0; + let mut x178: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x177, &mut x178, x176, x168, x165); + let mut x179: u64 = 0; + let mut x180: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x179, &mut x180, 0x0, x155, x171); + let mut x181: u64 = 0; + let mut x182: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x181, &mut x182, x180, x157, x173); + let mut x183: u64 = 0; + let mut x184: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x183, &mut x184, x182, x159, x175); + let mut x185: u64 = 0; + let mut x186: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x185, &mut x186, x184, x161, x177); + let mut x187: u64 = 0; + let mut x188: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x187, &mut x188, x186, (((x162 as u64) + (x140 as u64)) + ((x154 as u64) + x142)), ((x178 as u64) + x166)); + let mut x189: u64 = 0; + let mut x190: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x189, &mut x190, 0x0, x181, 0xbfd25e8cd0364141); + let mut x191: u64 = 0; + let mut x192: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x191, &mut x192, x190, x183, 0xbaaedce6af48a03b); + let mut x193: u64 = 0; + let mut x194: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x193, &mut x194, x192, x185, 0xfffffffffffffffe); + let mut x195: u64 = 0; + let mut x196: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x195, &mut x196, x194, x187, 0xffffffffffffffff); + let mut x197: u64 = 0; + let mut x198: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x197, &mut x198, x196, (x188 as u64), (0x0 as u64)); + let mut x199: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x199, x198, x189, x181); + let mut x200: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x200, x198, x191, x183); + let mut x201: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x201, x198, x193, x185); + let mut x202: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x202, x198, x195, x187); + out1[0] = x199; + out1[1] = x200; + out1[2] = x201; + out1[3] = x202; +} + +/// The function fiat_secp256k1_scalar_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +#[inline] +pub fn fiat_secp256k1_scalar_nonzero(out1: &mut u64, arg1: &[u64; 4]) -> () { + let x1: u64 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3])))); + *out1 = x1; +} + +/// The function fiat_secp256k1_scalar_selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_secp256k1_scalar_selectznz(out1: &mut [u64; 4], arg1: fiat_secp256k1_scalar_u1, arg2: &[u64; 4], arg3: &[u64; 4]) -> () { + let mut x1: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x1, arg1, (arg2[0]), (arg3[0])); + let mut x2: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x2, arg1, (arg2[1]), (arg3[1])); + let mut x3: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x3, arg1, (arg2[2]), (arg3[2])); + let mut x4: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/// The function fiat_secp256k1_scalar_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +#[inline] +pub fn fiat_secp256k1_scalar_to_bytes(out1: &mut [u8; 32], arg1: &[u64; 4]) -> () { + let x1: u64 = (arg1[3]); + let x2: u64 = (arg1[2]); + let x3: u64 = (arg1[1]); + let x4: u64 = (arg1[0]); + let x5: u8 = ((x4 & (0xff as u64)) as u8); + let x6: u64 = (x4 >> 8); + let x7: u8 = ((x6 & (0xff as u64)) as u8); + let x8: u64 = (x6 >> 8); + let x9: u8 = ((x8 & (0xff as u64)) as u8); + let x10: u64 = (x8 >> 8); + let x11: u8 = ((x10 & (0xff as u64)) as u8); + let x12: u64 = (x10 >> 8); + let x13: u8 = ((x12 & (0xff as u64)) as u8); + let x14: u64 = (x12 >> 8); + let x15: u8 = ((x14 & (0xff as u64)) as u8); + let x16: u64 = (x14 >> 8); + let x17: u8 = ((x16 & (0xff as u64)) as u8); + let x18: u8 = ((x16 >> 8) as u8); + let x19: u8 = ((x3 & (0xff as u64)) as u8); + let x20: u64 = (x3 >> 8); + let x21: u8 = ((x20 & (0xff as u64)) as u8); + let x22: u64 = (x20 >> 8); + let x23: u8 = ((x22 & (0xff as u64)) as u8); + let x24: u64 = (x22 >> 8); + let x25: u8 = ((x24 & (0xff as u64)) as u8); + let x26: u64 = (x24 >> 8); + let x27: u8 = ((x26 & (0xff as u64)) as u8); + let x28: u64 = (x26 >> 8); + let x29: u8 = ((x28 & (0xff as u64)) as u8); + let x30: u64 = (x28 >> 8); + let x31: u8 = ((x30 & (0xff as u64)) as u8); + let x32: u8 = ((x30 >> 8) as u8); + let x33: u8 = ((x2 & (0xff as u64)) as u8); + let x34: u64 = (x2 >> 8); + let x35: u8 = ((x34 & (0xff as u64)) as u8); + let x36: u64 = (x34 >> 8); + let x37: u8 = ((x36 & (0xff as u64)) as u8); + let x38: u64 = (x36 >> 8); + let x39: u8 = ((x38 & (0xff as u64)) as u8); + let x40: u64 = (x38 >> 8); + let x41: u8 = ((x40 & (0xff as u64)) as u8); + let x42: u64 = (x40 >> 8); + let x43: u8 = ((x42 & (0xff as u64)) as u8); + let x44: u64 = (x42 >> 8); + let x45: u8 = ((x44 & (0xff as u64)) as u8); + let x46: u8 = ((x44 >> 8) as u8); + let x47: u8 = ((x1 & (0xff as u64)) as u8); + let x48: u64 = (x1 >> 8); + let x49: u8 = ((x48 & (0xff as u64)) as u8); + let x50: u64 = (x48 >> 8); + let x51: u8 = ((x50 & (0xff as u64)) as u8); + let x52: u64 = (x50 >> 8); + let x53: u8 = ((x52 & (0xff as u64)) as u8); + let x54: u64 = (x52 >> 8); + let x55: u8 = ((x54 & (0xff as u64)) as u8); + let x56: u64 = (x54 >> 8); + let x57: u8 = ((x56 & (0xff as u64)) as u8); + let x58: u64 = (x56 >> 8); + let x59: u8 = ((x58 & (0xff as u64)) as u8); + let x60: u8 = ((x58 >> 8) as u8); + out1[0] = x5; + out1[1] = x7; + out1[2] = x9; + out1[3] = x11; + out1[4] = x13; + out1[5] = x15; + out1[6] = x17; + out1[7] = x18; + out1[8] = x19; + out1[9] = x21; + out1[10] = x23; + out1[11] = x25; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x39; + out1[20] = x41; + out1[21] = x43; + out1[22] = x45; + out1[23] = x46; + out1[24] = x47; + out1[25] = x49; + out1[26] = x51; + out1[27] = x53; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; +} + +/// The function fiat_secp256k1_scalar_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_secp256k1_scalar_from_bytes(out1: &mut [u64; 4], arg1: &[u8; 32]) -> () { + let x1: u64 = (((arg1[31]) as u64) << 56); + let x2: u64 = (((arg1[30]) as u64) << 48); + let x3: u64 = (((arg1[29]) as u64) << 40); + let x4: u64 = (((arg1[28]) as u64) << 32); + let x5: u64 = (((arg1[27]) as u64) << 24); + let x6: u64 = (((arg1[26]) as u64) << 16); + let x7: u64 = (((arg1[25]) as u64) << 8); + let x8: u8 = (arg1[24]); + let x9: u64 = (((arg1[23]) as u64) << 56); + let x10: u64 = (((arg1[22]) as u64) << 48); + let x11: u64 = (((arg1[21]) as u64) << 40); + let x12: u64 = (((arg1[20]) as u64) << 32); + let x13: u64 = (((arg1[19]) as u64) << 24); + let x14: u64 = (((arg1[18]) as u64) << 16); + let x15: u64 = (((arg1[17]) as u64) << 8); + let x16: u8 = (arg1[16]); + let x17: u64 = (((arg1[15]) as u64) << 56); + let x18: u64 = (((arg1[14]) as u64) << 48); + let x19: u64 = (((arg1[13]) as u64) << 40); + let x20: u64 = (((arg1[12]) as u64) << 32); + let x21: u64 = (((arg1[11]) as u64) << 24); + let x22: u64 = (((arg1[10]) as u64) << 16); + let x23: u64 = (((arg1[9]) as u64) << 8); + let x24: u8 = (arg1[8]); + let x25: u64 = (((arg1[7]) as u64) << 56); + let x26: u64 = (((arg1[6]) as u64) << 48); + let x27: u64 = (((arg1[5]) as u64) << 40); + let x28: u64 = (((arg1[4]) as u64) << 32); + let x29: u64 = (((arg1[3]) as u64) << 24); + let x30: u64 = (((arg1[2]) as u64) << 16); + let x31: u64 = (((arg1[1]) as u64) << 8); + let x32: u8 = (arg1[0]); + let x33: u64 = (x31 + (x32 as u64)); + let x34: u64 = (x30 + x33); + let x35: u64 = (x29 + x34); + let x36: u64 = (x28 + x35); + let x37: u64 = (x27 + x36); + let x38: u64 = (x26 + x37); + let x39: u64 = (x25 + x38); + let x40: u64 = (x23 + (x24 as u64)); + let x41: u64 = (x22 + x40); + let x42: u64 = (x21 + x41); + let x43: u64 = (x20 + x42); + let x44: u64 = (x19 + x43); + let x45: u64 = (x18 + x44); + let x46: u64 = (x17 + x45); + let x47: u64 = (x15 + (x16 as u64)); + let x48: u64 = (x14 + x47); + let x49: u64 = (x13 + x48); + let x50: u64 = (x12 + x49); + let x51: u64 = (x11 + x50); + let x52: u64 = (x10 + x51); + let x53: u64 = (x9 + x52); + let x54: u64 = (x7 + (x8 as u64)); + let x55: u64 = (x6 + x54); + let x56: u64 = (x5 + x55); + let x57: u64 = (x4 + x56); + let x58: u64 = (x3 + x57); + let x59: u64 = (x2 + x58); + let x60: u64 = (x1 + x59); + out1[0] = x39; + out1[1] = x46; + out1[2] = x53; + out1[3] = x60; +} + +/// The function fiat_secp256k1_scalar_set_one returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +#[inline] +pub fn fiat_secp256k1_scalar_set_one(out1: &mut fiat_secp256k1_scalar_montgomery_domain_field_element) -> () { + out1[0] = 0x402da1732fc9bebf; + out1[1] = 0x4551231950b75fc4; + out1[2] = (0x1 as u64); + out1[3] = (0x0 as u64); +} + +/// The function fiat_secp256k1_scalar_msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_secp256k1_scalar_msat(out1: &mut [u64; 5]) -> () { + out1[0] = 0xbfd25e8cd0364141; + out1[1] = 0xbaaedce6af48a03b; + out1[2] = 0xfffffffffffffffe; + out1[3] = 0xffffffffffffffff; + out1[4] = (0x0 as u64); +} + +/// The function fiat_secp256k1_scalar_divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_secp256k1_scalar_divstep(out1: &mut u64, out2: &mut [u64; 5], out3: &mut [u64; 5], out4: &mut [u64; 4], out5: &mut [u64; 4], arg1: u64, arg2: &[u64; 5], arg3: &[u64; 5], arg4: &[u64; 4], arg5: &[u64; 4]) -> () { + let mut x1: u64 = 0; + let mut x2: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x1, &mut x2, 0x0, (!arg1), (0x1 as u64)); + let x3: fiat_secp256k1_scalar_u1 = (((x1 >> 63) as fiat_secp256k1_scalar_u1) & (((arg3[0]) & (0x1 as u64)) as fiat_secp256k1_scalar_u1)); + let mut x4: u64 = 0; + let mut x5: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x4, &mut x5, 0x0, (!arg1), (0x1 as u64)); + let mut x6: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x6, x3, arg1, x4); + let mut x7: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x7, x3, (arg2[0]), (arg3[0])); + let mut x8: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x8, x3, (arg2[1]), (arg3[1])); + let mut x9: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x9, x3, (arg2[2]), (arg3[2])); + let mut x10: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x10, x3, (arg2[3]), (arg3[3])); + let mut x11: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x11, x3, (arg2[4]), (arg3[4])); + let mut x12: u64 = 0; + let mut x13: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x12, &mut x13, 0x0, (0x1 as u64), (!(arg2[0]))); + let mut x14: u64 = 0; + let mut x15: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x14, &mut x15, x13, (0x0 as u64), (!(arg2[1]))); + let mut x16: u64 = 0; + let mut x17: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x16, &mut x17, x15, (0x0 as u64), (!(arg2[2]))); + let mut x18: u64 = 0; + let mut x19: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x18, &mut x19, x17, (0x0 as u64), (!(arg2[3]))); + let mut x20: u64 = 0; + let mut x21: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x20, &mut x21, x19, (0x0 as u64), (!(arg2[4]))); + let mut x22: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x22, x3, (arg3[0]), x12); + let mut x23: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x23, x3, (arg3[1]), x14); + let mut x24: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x24, x3, (arg3[2]), x16); + let mut x25: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x25, x3, (arg3[3]), x18); + let mut x26: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x26, x3, (arg3[4]), x20); + let mut x27: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x27, x3, (arg4[0]), (arg5[0])); + let mut x28: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x28, x3, (arg4[1]), (arg5[1])); + let mut x29: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x29, x3, (arg4[2]), (arg5[2])); + let mut x30: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x30, x3, (arg4[3]), (arg5[3])); + let mut x31: u64 = 0; + let mut x32: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x31, &mut x32, 0x0, x27, x27); + let mut x33: u64 = 0; + let mut x34: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x33, &mut x34, x32, x28, x28); + let mut x35: u64 = 0; + let mut x36: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x35, &mut x36, x34, x29, x29); + let mut x37: u64 = 0; + let mut x38: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x37, &mut x38, x36, x30, x30); + let mut x39: u64 = 0; + let mut x40: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x39, &mut x40, 0x0, x31, 0xbfd25e8cd0364141); + let mut x41: u64 = 0; + let mut x42: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x41, &mut x42, x40, x33, 0xbaaedce6af48a03b); + let mut x43: u64 = 0; + let mut x44: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x43, &mut x44, x42, x35, 0xfffffffffffffffe); + let mut x45: u64 = 0; + let mut x46: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x45, &mut x46, x44, x37, 0xffffffffffffffff); + let mut x47: u64 = 0; + let mut x48: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x47, &mut x48, x46, (x38 as u64), (0x0 as u64)); + let x49: u64 = (arg4[3]); + let x50: u64 = (arg4[2]); + let x51: u64 = (arg4[1]); + let x52: u64 = (arg4[0]); + let mut x53: u64 = 0; + let mut x54: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x53, &mut x54, 0x0, (0x0 as u64), x52); + let mut x55: u64 = 0; + let mut x56: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x55, &mut x56, x54, (0x0 as u64), x51); + let mut x57: u64 = 0; + let mut x58: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x57, &mut x58, x56, (0x0 as u64), x50); + let mut x59: u64 = 0; + let mut x60: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x59, &mut x60, x58, (0x0 as u64), x49); + let mut x61: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x61, x60, (0x0 as u64), 0xffffffffffffffff); + let mut x62: u64 = 0; + let mut x63: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x62, &mut x63, 0x0, x53, (x61 & 0xbfd25e8cd0364141)); + let mut x64: u64 = 0; + let mut x65: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x64, &mut x65, x63, x55, (x61 & 0xbaaedce6af48a03b)); + let mut x66: u64 = 0; + let mut x67: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x66, &mut x67, x65, x57, (x61 & 0xfffffffffffffffe)); + let mut x68: u64 = 0; + let mut x69: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x68, &mut x69, x67, x59, x61); + let mut x70: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x70, x3, (arg5[0]), x62); + let mut x71: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x71, x3, (arg5[1]), x64); + let mut x72: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x72, x3, (arg5[2]), x66); + let mut x73: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x73, x3, (arg5[3]), x68); + let x74: fiat_secp256k1_scalar_u1 = ((x22 & (0x1 as u64)) as fiat_secp256k1_scalar_u1); + let mut x75: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x75, x74, (0x0 as u64), x7); + let mut x76: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x76, x74, (0x0 as u64), x8); + let mut x77: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x77, x74, (0x0 as u64), x9); + let mut x78: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x78, x74, (0x0 as u64), x10); + let mut x79: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x79, x74, (0x0 as u64), x11); + let mut x80: u64 = 0; + let mut x81: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x80, &mut x81, 0x0, x22, x75); + let mut x82: u64 = 0; + let mut x83: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x82, &mut x83, x81, x23, x76); + let mut x84: u64 = 0; + let mut x85: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x84, &mut x85, x83, x24, x77); + let mut x86: u64 = 0; + let mut x87: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x86, &mut x87, x85, x25, x78); + let mut x88: u64 = 0; + let mut x89: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x88, &mut x89, x87, x26, x79); + let mut x90: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x90, x74, (0x0 as u64), x27); + let mut x91: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x91, x74, (0x0 as u64), x28); + let mut x92: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x92, x74, (0x0 as u64), x29); + let mut x93: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x93, x74, (0x0 as u64), x30); + let mut x94: u64 = 0; + let mut x95: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x94, &mut x95, 0x0, x70, x90); + let mut x96: u64 = 0; + let mut x97: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x96, &mut x97, x95, x71, x91); + let mut x98: u64 = 0; + let mut x99: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x98, &mut x99, x97, x72, x92); + let mut x100: u64 = 0; + let mut x101: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x100, &mut x101, x99, x73, x93); + let mut x102: u64 = 0; + let mut x103: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x102, &mut x103, 0x0, x94, 0xbfd25e8cd0364141); + let mut x104: u64 = 0; + let mut x105: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x104, &mut x105, x103, x96, 0xbaaedce6af48a03b); + let mut x106: u64 = 0; + let mut x107: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x106, &mut x107, x105, x98, 0xfffffffffffffffe); + let mut x108: u64 = 0; + let mut x109: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x108, &mut x109, x107, x100, 0xffffffffffffffff); + let mut x110: u64 = 0; + let mut x111: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_subborrowx_u64(&mut x110, &mut x111, x109, (x101 as u64), (0x0 as u64)); + let mut x112: u64 = 0; + let mut x113: fiat_secp256k1_scalar_u1 = 0; + fiat_secp256k1_scalar_addcarryx_u64(&mut x112, &mut x113, 0x0, x6, (0x1 as u64)); + let x114: u64 = ((x80 >> 1) | ((x82 << 63) & 0xffffffffffffffff)); + let x115: u64 = ((x82 >> 1) | ((x84 << 63) & 0xffffffffffffffff)); + let x116: u64 = ((x84 >> 1) | ((x86 << 63) & 0xffffffffffffffff)); + let x117: u64 = ((x86 >> 1) | ((x88 << 63) & 0xffffffffffffffff)); + let x118: u64 = ((x88 & 0x8000000000000000) | (x88 >> 1)); + let mut x119: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x119, x48, x39, x31); + let mut x120: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x120, x48, x41, x33); + let mut x121: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x121, x48, x43, x35); + let mut x122: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x122, x48, x45, x37); + let mut x123: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x123, x111, x102, x94); + let mut x124: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x124, x111, x104, x96); + let mut x125: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x125, x111, x106, x98); + let mut x126: u64 = 0; + fiat_secp256k1_scalar_cmovznz_u64(&mut x126, x111, x108, x100); + *out1 = x112; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out3[0] = x114; + out3[1] = x115; + out3[2] = x116; + out3[3] = x117; + out3[4] = x118; + out4[0] = x119; + out4[1] = x120; + out4[2] = x121; + out4[3] = x122; + out5[0] = x123; + out5[1] = x124; + out5[2] = x125; + out5[3] = x126; +} + +/// The function fiat_secp256k1_scalar_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +#[inline] +pub fn fiat_secp256k1_scalar_divstep_precomp(out1: &mut [u64; 4]) -> () { + out1[0] = 0xd7431a4d2b9cb4e9; + out1[1] = 0xab67d35a32d9c503; + out1[2] = 0xadf6c7e5859ce35f; + out1[3] = 0x615441451df6c379; +} diff --git a/fiat-zig/src/curve25519_scalar_32.zig b/fiat-zig/src/curve25519_scalar_32.zig new file mode 100644 index 0000000000..142caef8ff --- /dev/null +++ b/fiat-zig/src/curve25519_scalar_32.zig @@ -0,0 +1,4822 @@ +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Zig --internal-static --public-function-case camelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case UpperCamelCase --no-prefix-fiat --package-name 25519_scalar '' 32 '2^252 + 27742317777372353535851937790883648493' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// curve description (via package name): 25519_scalar +// machine_wordsize = 32 (from "32") +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// m = 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed (from "2^252 + 27742317777372353535851937790883648493") +// +// NOTE: In addition to the bounds specified above each function, all +// functions synthesized for this Montgomery arithmetic require the +// input to be strictly less than the prime modulus (m), and also +// require the input to be in the unique saturated representation. +// All functions also ensure that these two properties are true of +// return values. +// +// Computed values: +// eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +// twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in +// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 + +const std = @import("std"); +const mode = @import("builtin").mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels + +inline fn cast(comptime DestType: type, target: anytype) DestType { + if (@typeInfo(@TypeOf(target)) == .Int) { + const dest = @typeInfo(DestType).Int; + const source = @typeInfo(@TypeOf(target)).Int; + if (dest.bits < source.bits) { + return @bitCast(DestType, @truncate(std.meta.Int(source.signedness, dest.bits), target)); + } else { + return @bitCast(DestType, @as(std.meta.Int(source.signedness, dest.bits), target)); + } + } + return @as(DestType, target); +} + +// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub const MontgomeryDomainFieldElement = [8]u32; + +// The type NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub const NonMontgomeryDomainFieldElement = [8]u32; + +/// The function addcarryxU32 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^32 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +inline fn addcarryxU32(out1: *u32, out2: *u1, arg1: u1, arg2: u32, arg3: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(u64, arg1) + cast(u64, arg2)) + cast(u64, arg3)); + const x2 = cast(u32, (x1 & cast(u64, 0xffffffff))); + const x3 = cast(u1, (x1 >> 32)); + out1.* = x2; + out2.* = x3; +} + +/// The function subborrowxU32 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^32 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +inline fn subborrowxU32(out1: *u32, out2: *u1, arg1: u1, arg2: u32, arg3: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(i64, arg2) - cast(i64, arg1)) - cast(i64, arg3)); + const x2 = cast(i1, (x1 >> 32)); + const x3 = cast(u32, (x1 & cast(i64, 0xffffffff))); + out1.* = x3; + out2.* = cast(u1, (cast(i2, 0x0) - cast(i2, x2))); +} + +/// The function mulxU32 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^32 +/// out2 = ⌊arg1 * arg2 / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0xffffffff] +inline fn mulxU32(out1: *u32, out2: *u32, arg1: u32, arg2: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u64, arg1) * cast(u64, arg2)); + const x2 = cast(u32, (x1 & cast(u64, 0xffffffff))); + const x3 = cast(u32, (x1 >> 32)); + out1.* = x2; + out2.* = x3; +} + +/// The function cmovznzU32 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +inline fn cmovznzU32(out1: *u32, arg1: u1, arg2: u32, arg3: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (~(~arg1)); + const x2 = cast(u32, (cast(i64, cast(i1, (cast(i2, 0x0) - cast(i2, x1)))) & cast(i64, 0xffffffff))); + const x3 = ((x2 & arg3) | ((~x2) & arg2)); + out1.* = x3; +} + +/// The function mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn mul(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[6]); + const x7 = (arg1[7]); + const x8 = (arg1[0]); + var x9: u32 = undefined; + var x10: u32 = undefined; + mulxU32(&x9, &x10, x8, (arg2[7])); + var x11: u32 = undefined; + var x12: u32 = undefined; + mulxU32(&x11, &x12, x8, (arg2[6])); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x8, (arg2[5])); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x8, (arg2[4])); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x8, (arg2[3])); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x8, (arg2[2])); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x8, (arg2[1])); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x8, (arg2[0])); + var x25: u32 = undefined; + var x26: u1 = undefined; + addcarryxU32(&x25, &x26, 0x0, x24, x21); + var x27: u32 = undefined; + var x28: u1 = undefined; + addcarryxU32(&x27, &x28, x26, x22, x19); + var x29: u32 = undefined; + var x30: u1 = undefined; + addcarryxU32(&x29, &x30, x28, x20, x17); + var x31: u32 = undefined; + var x32: u1 = undefined; + addcarryxU32(&x31, &x32, x30, x18, x15); + var x33: u32 = undefined; + var x34: u1 = undefined; + addcarryxU32(&x33, &x34, x32, x16, x13); + var x35: u32 = undefined; + var x36: u1 = undefined; + addcarryxU32(&x35, &x36, x34, x14, x11); + var x37: u32 = undefined; + var x38: u1 = undefined; + addcarryxU32(&x37, &x38, x36, x12, x9); + const x39 = (cast(u32, x38) + x10); + var x40: u32 = undefined; + var x41: u32 = undefined; + mulxU32(&x40, &x41, x23, 0x12547e1b); + var x42: u32 = undefined; + var x43: u32 = undefined; + mulxU32(&x42, &x43, x40, 0x10000000); + var x44: u32 = undefined; + var x45: u32 = undefined; + mulxU32(&x44, &x45, x40, 0x14def9de); + var x46: u32 = undefined; + var x47: u32 = undefined; + mulxU32(&x46, &x47, x40, 0xa2f79cd6); + var x48: u32 = undefined; + var x49: u32 = undefined; + mulxU32(&x48, &x49, x40, 0x5812631a); + var x50: u32 = undefined; + var x51: u32 = undefined; + mulxU32(&x50, &x51, x40, 0x5cf5d3ed); + var x52: u32 = undefined; + var x53: u1 = undefined; + addcarryxU32(&x52, &x53, 0x0, x51, x48); + var x54: u32 = undefined; + var x55: u1 = undefined; + addcarryxU32(&x54, &x55, x53, x49, x46); + var x56: u32 = undefined; + var x57: u1 = undefined; + addcarryxU32(&x56, &x57, x55, x47, x44); + const x58 = (cast(u32, x57) + x45); + var x59: u32 = undefined; + var x60: u1 = undefined; + addcarryxU32(&x59, &x60, 0x0, x23, x50); + var x61: u32 = undefined; + var x62: u1 = undefined; + addcarryxU32(&x61, &x62, x60, x25, x52); + var x63: u32 = undefined; + var x64: u1 = undefined; + addcarryxU32(&x63, &x64, x62, x27, x54); + var x65: u32 = undefined; + var x66: u1 = undefined; + addcarryxU32(&x65, &x66, x64, x29, x56); + var x67: u32 = undefined; + var x68: u1 = undefined; + addcarryxU32(&x67, &x68, x66, x31, x58); + var x69: u32 = undefined; + var x70: u1 = undefined; + addcarryxU32(&x69, &x70, x68, x33, cast(u32, 0x0)); + var x71: u32 = undefined; + var x72: u1 = undefined; + addcarryxU32(&x71, &x72, x70, x35, cast(u32, 0x0)); + var x73: u32 = undefined; + var x74: u1 = undefined; + addcarryxU32(&x73, &x74, x72, x37, x42); + var x75: u32 = undefined; + var x76: u1 = undefined; + addcarryxU32(&x75, &x76, x74, x39, x43); + var x77: u32 = undefined; + var x78: u32 = undefined; + mulxU32(&x77, &x78, x1, (arg2[7])); + var x79: u32 = undefined; + var x80: u32 = undefined; + mulxU32(&x79, &x80, x1, (arg2[6])); + var x81: u32 = undefined; + var x82: u32 = undefined; + mulxU32(&x81, &x82, x1, (arg2[5])); + var x83: u32 = undefined; + var x84: u32 = undefined; + mulxU32(&x83, &x84, x1, (arg2[4])); + var x85: u32 = undefined; + var x86: u32 = undefined; + mulxU32(&x85, &x86, x1, (arg2[3])); + var x87: u32 = undefined; + var x88: u32 = undefined; + mulxU32(&x87, &x88, x1, (arg2[2])); + var x89: u32 = undefined; + var x90: u32 = undefined; + mulxU32(&x89, &x90, x1, (arg2[1])); + var x91: u32 = undefined; + var x92: u32 = undefined; + mulxU32(&x91, &x92, x1, (arg2[0])); + var x93: u32 = undefined; + var x94: u1 = undefined; + addcarryxU32(&x93, &x94, 0x0, x92, x89); + var x95: u32 = undefined; + var x96: u1 = undefined; + addcarryxU32(&x95, &x96, x94, x90, x87); + var x97: u32 = undefined; + var x98: u1 = undefined; + addcarryxU32(&x97, &x98, x96, x88, x85); + var x99: u32 = undefined; + var x100: u1 = undefined; + addcarryxU32(&x99, &x100, x98, x86, x83); + var x101: u32 = undefined; + var x102: u1 = undefined; + addcarryxU32(&x101, &x102, x100, x84, x81); + var x103: u32 = undefined; + var x104: u1 = undefined; + addcarryxU32(&x103, &x104, x102, x82, x79); + var x105: u32 = undefined; + var x106: u1 = undefined; + addcarryxU32(&x105, &x106, x104, x80, x77); + const x107 = (cast(u32, x106) + x78); + var x108: u32 = undefined; + var x109: u1 = undefined; + addcarryxU32(&x108, &x109, 0x0, x61, x91); + var x110: u32 = undefined; + var x111: u1 = undefined; + addcarryxU32(&x110, &x111, x109, x63, x93); + var x112: u32 = undefined; + var x113: u1 = undefined; + addcarryxU32(&x112, &x113, x111, x65, x95); + var x114: u32 = undefined; + var x115: u1 = undefined; + addcarryxU32(&x114, &x115, x113, x67, x97); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, x115, x69, x99); + var x118: u32 = undefined; + var x119: u1 = undefined; + addcarryxU32(&x118, &x119, x117, x71, x101); + var x120: u32 = undefined; + var x121: u1 = undefined; + addcarryxU32(&x120, &x121, x119, x73, x103); + var x122: u32 = undefined; + var x123: u1 = undefined; + addcarryxU32(&x122, &x123, x121, x75, x105); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, cast(u32, x76), x107); + var x126: u32 = undefined; + var x127: u32 = undefined; + mulxU32(&x126, &x127, x108, 0x12547e1b); + var x128: u32 = undefined; + var x129: u32 = undefined; + mulxU32(&x128, &x129, x126, 0x10000000); + var x130: u32 = undefined; + var x131: u32 = undefined; + mulxU32(&x130, &x131, x126, 0x14def9de); + var x132: u32 = undefined; + var x133: u32 = undefined; + mulxU32(&x132, &x133, x126, 0xa2f79cd6); + var x134: u32 = undefined; + var x135: u32 = undefined; + mulxU32(&x134, &x135, x126, 0x5812631a); + var x136: u32 = undefined; + var x137: u32 = undefined; + mulxU32(&x136, &x137, x126, 0x5cf5d3ed); + var x138: u32 = undefined; + var x139: u1 = undefined; + addcarryxU32(&x138, &x139, 0x0, x137, x134); + var x140: u32 = undefined; + var x141: u1 = undefined; + addcarryxU32(&x140, &x141, x139, x135, x132); + var x142: u32 = undefined; + var x143: u1 = undefined; + addcarryxU32(&x142, &x143, x141, x133, x130); + const x144 = (cast(u32, x143) + x131); + var x145: u32 = undefined; + var x146: u1 = undefined; + addcarryxU32(&x145, &x146, 0x0, x108, x136); + var x147: u32 = undefined; + var x148: u1 = undefined; + addcarryxU32(&x147, &x148, x146, x110, x138); + var x149: u32 = undefined; + var x150: u1 = undefined; + addcarryxU32(&x149, &x150, x148, x112, x140); + var x151: u32 = undefined; + var x152: u1 = undefined; + addcarryxU32(&x151, &x152, x150, x114, x142); + var x153: u32 = undefined; + var x154: u1 = undefined; + addcarryxU32(&x153, &x154, x152, x116, x144); + var x155: u32 = undefined; + var x156: u1 = undefined; + addcarryxU32(&x155, &x156, x154, x118, cast(u32, 0x0)); + var x157: u32 = undefined; + var x158: u1 = undefined; + addcarryxU32(&x157, &x158, x156, x120, cast(u32, 0x0)); + var x159: u32 = undefined; + var x160: u1 = undefined; + addcarryxU32(&x159, &x160, x158, x122, x128); + var x161: u32 = undefined; + var x162: u1 = undefined; + addcarryxU32(&x161, &x162, x160, x124, x129); + const x163 = (cast(u32, x162) + cast(u32, x125)); + var x164: u32 = undefined; + var x165: u32 = undefined; + mulxU32(&x164, &x165, x2, (arg2[7])); + var x166: u32 = undefined; + var x167: u32 = undefined; + mulxU32(&x166, &x167, x2, (arg2[6])); + var x168: u32 = undefined; + var x169: u32 = undefined; + mulxU32(&x168, &x169, x2, (arg2[5])); + var x170: u32 = undefined; + var x171: u32 = undefined; + mulxU32(&x170, &x171, x2, (arg2[4])); + var x172: u32 = undefined; + var x173: u32 = undefined; + mulxU32(&x172, &x173, x2, (arg2[3])); + var x174: u32 = undefined; + var x175: u32 = undefined; + mulxU32(&x174, &x175, x2, (arg2[2])); + var x176: u32 = undefined; + var x177: u32 = undefined; + mulxU32(&x176, &x177, x2, (arg2[1])); + var x178: u32 = undefined; + var x179: u32 = undefined; + mulxU32(&x178, &x179, x2, (arg2[0])); + var x180: u32 = undefined; + var x181: u1 = undefined; + addcarryxU32(&x180, &x181, 0x0, x179, x176); + var x182: u32 = undefined; + var x183: u1 = undefined; + addcarryxU32(&x182, &x183, x181, x177, x174); + var x184: u32 = undefined; + var x185: u1 = undefined; + addcarryxU32(&x184, &x185, x183, x175, x172); + var x186: u32 = undefined; + var x187: u1 = undefined; + addcarryxU32(&x186, &x187, x185, x173, x170); + var x188: u32 = undefined; + var x189: u1 = undefined; + addcarryxU32(&x188, &x189, x187, x171, x168); + var x190: u32 = undefined; + var x191: u1 = undefined; + addcarryxU32(&x190, &x191, x189, x169, x166); + var x192: u32 = undefined; + var x193: u1 = undefined; + addcarryxU32(&x192, &x193, x191, x167, x164); + const x194 = (cast(u32, x193) + x165); + var x195: u32 = undefined; + var x196: u1 = undefined; + addcarryxU32(&x195, &x196, 0x0, x147, x178); + var x197: u32 = undefined; + var x198: u1 = undefined; + addcarryxU32(&x197, &x198, x196, x149, x180); + var x199: u32 = undefined; + var x200: u1 = undefined; + addcarryxU32(&x199, &x200, x198, x151, x182); + var x201: u32 = undefined; + var x202: u1 = undefined; + addcarryxU32(&x201, &x202, x200, x153, x184); + var x203: u32 = undefined; + var x204: u1 = undefined; + addcarryxU32(&x203, &x204, x202, x155, x186); + var x205: u32 = undefined; + var x206: u1 = undefined; + addcarryxU32(&x205, &x206, x204, x157, x188); + var x207: u32 = undefined; + var x208: u1 = undefined; + addcarryxU32(&x207, &x208, x206, x159, x190); + var x209: u32 = undefined; + var x210: u1 = undefined; + addcarryxU32(&x209, &x210, x208, x161, x192); + var x211: u32 = undefined; + var x212: u1 = undefined; + addcarryxU32(&x211, &x212, x210, x163, x194); + var x213: u32 = undefined; + var x214: u32 = undefined; + mulxU32(&x213, &x214, x195, 0x12547e1b); + var x215: u32 = undefined; + var x216: u32 = undefined; + mulxU32(&x215, &x216, x213, 0x10000000); + var x217: u32 = undefined; + var x218: u32 = undefined; + mulxU32(&x217, &x218, x213, 0x14def9de); + var x219: u32 = undefined; + var x220: u32 = undefined; + mulxU32(&x219, &x220, x213, 0xa2f79cd6); + var x221: u32 = undefined; + var x222: u32 = undefined; + mulxU32(&x221, &x222, x213, 0x5812631a); + var x223: u32 = undefined; + var x224: u32 = undefined; + mulxU32(&x223, &x224, x213, 0x5cf5d3ed); + var x225: u32 = undefined; + var x226: u1 = undefined; + addcarryxU32(&x225, &x226, 0x0, x224, x221); + var x227: u32 = undefined; + var x228: u1 = undefined; + addcarryxU32(&x227, &x228, x226, x222, x219); + var x229: u32 = undefined; + var x230: u1 = undefined; + addcarryxU32(&x229, &x230, x228, x220, x217); + const x231 = (cast(u32, x230) + x218); + var x232: u32 = undefined; + var x233: u1 = undefined; + addcarryxU32(&x232, &x233, 0x0, x195, x223); + var x234: u32 = undefined; + var x235: u1 = undefined; + addcarryxU32(&x234, &x235, x233, x197, x225); + var x236: u32 = undefined; + var x237: u1 = undefined; + addcarryxU32(&x236, &x237, x235, x199, x227); + var x238: u32 = undefined; + var x239: u1 = undefined; + addcarryxU32(&x238, &x239, x237, x201, x229); + var x240: u32 = undefined; + var x241: u1 = undefined; + addcarryxU32(&x240, &x241, x239, x203, x231); + var x242: u32 = undefined; + var x243: u1 = undefined; + addcarryxU32(&x242, &x243, x241, x205, cast(u32, 0x0)); + var x244: u32 = undefined; + var x245: u1 = undefined; + addcarryxU32(&x244, &x245, x243, x207, cast(u32, 0x0)); + var x246: u32 = undefined; + var x247: u1 = undefined; + addcarryxU32(&x246, &x247, x245, x209, x215); + var x248: u32 = undefined; + var x249: u1 = undefined; + addcarryxU32(&x248, &x249, x247, x211, x216); + const x250 = (cast(u32, x249) + cast(u32, x212)); + var x251: u32 = undefined; + var x252: u32 = undefined; + mulxU32(&x251, &x252, x3, (arg2[7])); + var x253: u32 = undefined; + var x254: u32 = undefined; + mulxU32(&x253, &x254, x3, (arg2[6])); + var x255: u32 = undefined; + var x256: u32 = undefined; + mulxU32(&x255, &x256, x3, (arg2[5])); + var x257: u32 = undefined; + var x258: u32 = undefined; + mulxU32(&x257, &x258, x3, (arg2[4])); + var x259: u32 = undefined; + var x260: u32 = undefined; + mulxU32(&x259, &x260, x3, (arg2[3])); + var x261: u32 = undefined; + var x262: u32 = undefined; + mulxU32(&x261, &x262, x3, (arg2[2])); + var x263: u32 = undefined; + var x264: u32 = undefined; + mulxU32(&x263, &x264, x3, (arg2[1])); + var x265: u32 = undefined; + var x266: u32 = undefined; + mulxU32(&x265, &x266, x3, (arg2[0])); + var x267: u32 = undefined; + var x268: u1 = undefined; + addcarryxU32(&x267, &x268, 0x0, x266, x263); + var x269: u32 = undefined; + var x270: u1 = undefined; + addcarryxU32(&x269, &x270, x268, x264, x261); + var x271: u32 = undefined; + var x272: u1 = undefined; + addcarryxU32(&x271, &x272, x270, x262, x259); + var x273: u32 = undefined; + var x274: u1 = undefined; + addcarryxU32(&x273, &x274, x272, x260, x257); + var x275: u32 = undefined; + var x276: u1 = undefined; + addcarryxU32(&x275, &x276, x274, x258, x255); + var x277: u32 = undefined; + var x278: u1 = undefined; + addcarryxU32(&x277, &x278, x276, x256, x253); + var x279: u32 = undefined; + var x280: u1 = undefined; + addcarryxU32(&x279, &x280, x278, x254, x251); + const x281 = (cast(u32, x280) + x252); + var x282: u32 = undefined; + var x283: u1 = undefined; + addcarryxU32(&x282, &x283, 0x0, x234, x265); + var x284: u32 = undefined; + var x285: u1 = undefined; + addcarryxU32(&x284, &x285, x283, x236, x267); + var x286: u32 = undefined; + var x287: u1 = undefined; + addcarryxU32(&x286, &x287, x285, x238, x269); + var x288: u32 = undefined; + var x289: u1 = undefined; + addcarryxU32(&x288, &x289, x287, x240, x271); + var x290: u32 = undefined; + var x291: u1 = undefined; + addcarryxU32(&x290, &x291, x289, x242, x273); + var x292: u32 = undefined; + var x293: u1 = undefined; + addcarryxU32(&x292, &x293, x291, x244, x275); + var x294: u32 = undefined; + var x295: u1 = undefined; + addcarryxU32(&x294, &x295, x293, x246, x277); + var x296: u32 = undefined; + var x297: u1 = undefined; + addcarryxU32(&x296, &x297, x295, x248, x279); + var x298: u32 = undefined; + var x299: u1 = undefined; + addcarryxU32(&x298, &x299, x297, x250, x281); + var x300: u32 = undefined; + var x301: u32 = undefined; + mulxU32(&x300, &x301, x282, 0x12547e1b); + var x302: u32 = undefined; + var x303: u32 = undefined; + mulxU32(&x302, &x303, x300, 0x10000000); + var x304: u32 = undefined; + var x305: u32 = undefined; + mulxU32(&x304, &x305, x300, 0x14def9de); + var x306: u32 = undefined; + var x307: u32 = undefined; + mulxU32(&x306, &x307, x300, 0xa2f79cd6); + var x308: u32 = undefined; + var x309: u32 = undefined; + mulxU32(&x308, &x309, x300, 0x5812631a); + var x310: u32 = undefined; + var x311: u32 = undefined; + mulxU32(&x310, &x311, x300, 0x5cf5d3ed); + var x312: u32 = undefined; + var x313: u1 = undefined; + addcarryxU32(&x312, &x313, 0x0, x311, x308); + var x314: u32 = undefined; + var x315: u1 = undefined; + addcarryxU32(&x314, &x315, x313, x309, x306); + var x316: u32 = undefined; + var x317: u1 = undefined; + addcarryxU32(&x316, &x317, x315, x307, x304); + const x318 = (cast(u32, x317) + x305); + var x319: u32 = undefined; + var x320: u1 = undefined; + addcarryxU32(&x319, &x320, 0x0, x282, x310); + var x321: u32 = undefined; + var x322: u1 = undefined; + addcarryxU32(&x321, &x322, x320, x284, x312); + var x323: u32 = undefined; + var x324: u1 = undefined; + addcarryxU32(&x323, &x324, x322, x286, x314); + var x325: u32 = undefined; + var x326: u1 = undefined; + addcarryxU32(&x325, &x326, x324, x288, x316); + var x327: u32 = undefined; + var x328: u1 = undefined; + addcarryxU32(&x327, &x328, x326, x290, x318); + var x329: u32 = undefined; + var x330: u1 = undefined; + addcarryxU32(&x329, &x330, x328, x292, cast(u32, 0x0)); + var x331: u32 = undefined; + var x332: u1 = undefined; + addcarryxU32(&x331, &x332, x330, x294, cast(u32, 0x0)); + var x333: u32 = undefined; + var x334: u1 = undefined; + addcarryxU32(&x333, &x334, x332, x296, x302); + var x335: u32 = undefined; + var x336: u1 = undefined; + addcarryxU32(&x335, &x336, x334, x298, x303); + const x337 = (cast(u32, x336) + cast(u32, x299)); + var x338: u32 = undefined; + var x339: u32 = undefined; + mulxU32(&x338, &x339, x4, (arg2[7])); + var x340: u32 = undefined; + var x341: u32 = undefined; + mulxU32(&x340, &x341, x4, (arg2[6])); + var x342: u32 = undefined; + var x343: u32 = undefined; + mulxU32(&x342, &x343, x4, (arg2[5])); + var x344: u32 = undefined; + var x345: u32 = undefined; + mulxU32(&x344, &x345, x4, (arg2[4])); + var x346: u32 = undefined; + var x347: u32 = undefined; + mulxU32(&x346, &x347, x4, (arg2[3])); + var x348: u32 = undefined; + var x349: u32 = undefined; + mulxU32(&x348, &x349, x4, (arg2[2])); + var x350: u32 = undefined; + var x351: u32 = undefined; + mulxU32(&x350, &x351, x4, (arg2[1])); + var x352: u32 = undefined; + var x353: u32 = undefined; + mulxU32(&x352, &x353, x4, (arg2[0])); + var x354: u32 = undefined; + var x355: u1 = undefined; + addcarryxU32(&x354, &x355, 0x0, x353, x350); + var x356: u32 = undefined; + var x357: u1 = undefined; + addcarryxU32(&x356, &x357, x355, x351, x348); + var x358: u32 = undefined; + var x359: u1 = undefined; + addcarryxU32(&x358, &x359, x357, x349, x346); + var x360: u32 = undefined; + var x361: u1 = undefined; + addcarryxU32(&x360, &x361, x359, x347, x344); + var x362: u32 = undefined; + var x363: u1 = undefined; + addcarryxU32(&x362, &x363, x361, x345, x342); + var x364: u32 = undefined; + var x365: u1 = undefined; + addcarryxU32(&x364, &x365, x363, x343, x340); + var x366: u32 = undefined; + var x367: u1 = undefined; + addcarryxU32(&x366, &x367, x365, x341, x338); + const x368 = (cast(u32, x367) + x339); + var x369: u32 = undefined; + var x370: u1 = undefined; + addcarryxU32(&x369, &x370, 0x0, x321, x352); + var x371: u32 = undefined; + var x372: u1 = undefined; + addcarryxU32(&x371, &x372, x370, x323, x354); + var x373: u32 = undefined; + var x374: u1 = undefined; + addcarryxU32(&x373, &x374, x372, x325, x356); + var x375: u32 = undefined; + var x376: u1 = undefined; + addcarryxU32(&x375, &x376, x374, x327, x358); + var x377: u32 = undefined; + var x378: u1 = undefined; + addcarryxU32(&x377, &x378, x376, x329, x360); + var x379: u32 = undefined; + var x380: u1 = undefined; + addcarryxU32(&x379, &x380, x378, x331, x362); + var x381: u32 = undefined; + var x382: u1 = undefined; + addcarryxU32(&x381, &x382, x380, x333, x364); + var x383: u32 = undefined; + var x384: u1 = undefined; + addcarryxU32(&x383, &x384, x382, x335, x366); + var x385: u32 = undefined; + var x386: u1 = undefined; + addcarryxU32(&x385, &x386, x384, x337, x368); + var x387: u32 = undefined; + var x388: u32 = undefined; + mulxU32(&x387, &x388, x369, 0x12547e1b); + var x389: u32 = undefined; + var x390: u32 = undefined; + mulxU32(&x389, &x390, x387, 0x10000000); + var x391: u32 = undefined; + var x392: u32 = undefined; + mulxU32(&x391, &x392, x387, 0x14def9de); + var x393: u32 = undefined; + var x394: u32 = undefined; + mulxU32(&x393, &x394, x387, 0xa2f79cd6); + var x395: u32 = undefined; + var x396: u32 = undefined; + mulxU32(&x395, &x396, x387, 0x5812631a); + var x397: u32 = undefined; + var x398: u32 = undefined; + mulxU32(&x397, &x398, x387, 0x5cf5d3ed); + var x399: u32 = undefined; + var x400: u1 = undefined; + addcarryxU32(&x399, &x400, 0x0, x398, x395); + var x401: u32 = undefined; + var x402: u1 = undefined; + addcarryxU32(&x401, &x402, x400, x396, x393); + var x403: u32 = undefined; + var x404: u1 = undefined; + addcarryxU32(&x403, &x404, x402, x394, x391); + const x405 = (cast(u32, x404) + x392); + var x406: u32 = undefined; + var x407: u1 = undefined; + addcarryxU32(&x406, &x407, 0x0, x369, x397); + var x408: u32 = undefined; + var x409: u1 = undefined; + addcarryxU32(&x408, &x409, x407, x371, x399); + var x410: u32 = undefined; + var x411: u1 = undefined; + addcarryxU32(&x410, &x411, x409, x373, x401); + var x412: u32 = undefined; + var x413: u1 = undefined; + addcarryxU32(&x412, &x413, x411, x375, x403); + var x414: u32 = undefined; + var x415: u1 = undefined; + addcarryxU32(&x414, &x415, x413, x377, x405); + var x416: u32 = undefined; + var x417: u1 = undefined; + addcarryxU32(&x416, &x417, x415, x379, cast(u32, 0x0)); + var x418: u32 = undefined; + var x419: u1 = undefined; + addcarryxU32(&x418, &x419, x417, x381, cast(u32, 0x0)); + var x420: u32 = undefined; + var x421: u1 = undefined; + addcarryxU32(&x420, &x421, x419, x383, x389); + var x422: u32 = undefined; + var x423: u1 = undefined; + addcarryxU32(&x422, &x423, x421, x385, x390); + const x424 = (cast(u32, x423) + cast(u32, x386)); + var x425: u32 = undefined; + var x426: u32 = undefined; + mulxU32(&x425, &x426, x5, (arg2[7])); + var x427: u32 = undefined; + var x428: u32 = undefined; + mulxU32(&x427, &x428, x5, (arg2[6])); + var x429: u32 = undefined; + var x430: u32 = undefined; + mulxU32(&x429, &x430, x5, (arg2[5])); + var x431: u32 = undefined; + var x432: u32 = undefined; + mulxU32(&x431, &x432, x5, (arg2[4])); + var x433: u32 = undefined; + var x434: u32 = undefined; + mulxU32(&x433, &x434, x5, (arg2[3])); + var x435: u32 = undefined; + var x436: u32 = undefined; + mulxU32(&x435, &x436, x5, (arg2[2])); + var x437: u32 = undefined; + var x438: u32 = undefined; + mulxU32(&x437, &x438, x5, (arg2[1])); + var x439: u32 = undefined; + var x440: u32 = undefined; + mulxU32(&x439, &x440, x5, (arg2[0])); + var x441: u32 = undefined; + var x442: u1 = undefined; + addcarryxU32(&x441, &x442, 0x0, x440, x437); + var x443: u32 = undefined; + var x444: u1 = undefined; + addcarryxU32(&x443, &x444, x442, x438, x435); + var x445: u32 = undefined; + var x446: u1 = undefined; + addcarryxU32(&x445, &x446, x444, x436, x433); + var x447: u32 = undefined; + var x448: u1 = undefined; + addcarryxU32(&x447, &x448, x446, x434, x431); + var x449: u32 = undefined; + var x450: u1 = undefined; + addcarryxU32(&x449, &x450, x448, x432, x429); + var x451: u32 = undefined; + var x452: u1 = undefined; + addcarryxU32(&x451, &x452, x450, x430, x427); + var x453: u32 = undefined; + var x454: u1 = undefined; + addcarryxU32(&x453, &x454, x452, x428, x425); + const x455 = (cast(u32, x454) + x426); + var x456: u32 = undefined; + var x457: u1 = undefined; + addcarryxU32(&x456, &x457, 0x0, x408, x439); + var x458: u32 = undefined; + var x459: u1 = undefined; + addcarryxU32(&x458, &x459, x457, x410, x441); + var x460: u32 = undefined; + var x461: u1 = undefined; + addcarryxU32(&x460, &x461, x459, x412, x443); + var x462: u32 = undefined; + var x463: u1 = undefined; + addcarryxU32(&x462, &x463, x461, x414, x445); + var x464: u32 = undefined; + var x465: u1 = undefined; + addcarryxU32(&x464, &x465, x463, x416, x447); + var x466: u32 = undefined; + var x467: u1 = undefined; + addcarryxU32(&x466, &x467, x465, x418, x449); + var x468: u32 = undefined; + var x469: u1 = undefined; + addcarryxU32(&x468, &x469, x467, x420, x451); + var x470: u32 = undefined; + var x471: u1 = undefined; + addcarryxU32(&x470, &x471, x469, x422, x453); + var x472: u32 = undefined; + var x473: u1 = undefined; + addcarryxU32(&x472, &x473, x471, x424, x455); + var x474: u32 = undefined; + var x475: u32 = undefined; + mulxU32(&x474, &x475, x456, 0x12547e1b); + var x476: u32 = undefined; + var x477: u32 = undefined; + mulxU32(&x476, &x477, x474, 0x10000000); + var x478: u32 = undefined; + var x479: u32 = undefined; + mulxU32(&x478, &x479, x474, 0x14def9de); + var x480: u32 = undefined; + var x481: u32 = undefined; + mulxU32(&x480, &x481, x474, 0xa2f79cd6); + var x482: u32 = undefined; + var x483: u32 = undefined; + mulxU32(&x482, &x483, x474, 0x5812631a); + var x484: u32 = undefined; + var x485: u32 = undefined; + mulxU32(&x484, &x485, x474, 0x5cf5d3ed); + var x486: u32 = undefined; + var x487: u1 = undefined; + addcarryxU32(&x486, &x487, 0x0, x485, x482); + var x488: u32 = undefined; + var x489: u1 = undefined; + addcarryxU32(&x488, &x489, x487, x483, x480); + var x490: u32 = undefined; + var x491: u1 = undefined; + addcarryxU32(&x490, &x491, x489, x481, x478); + const x492 = (cast(u32, x491) + x479); + var x493: u32 = undefined; + var x494: u1 = undefined; + addcarryxU32(&x493, &x494, 0x0, x456, x484); + var x495: u32 = undefined; + var x496: u1 = undefined; + addcarryxU32(&x495, &x496, x494, x458, x486); + var x497: u32 = undefined; + var x498: u1 = undefined; + addcarryxU32(&x497, &x498, x496, x460, x488); + var x499: u32 = undefined; + var x500: u1 = undefined; + addcarryxU32(&x499, &x500, x498, x462, x490); + var x501: u32 = undefined; + var x502: u1 = undefined; + addcarryxU32(&x501, &x502, x500, x464, x492); + var x503: u32 = undefined; + var x504: u1 = undefined; + addcarryxU32(&x503, &x504, x502, x466, cast(u32, 0x0)); + var x505: u32 = undefined; + var x506: u1 = undefined; + addcarryxU32(&x505, &x506, x504, x468, cast(u32, 0x0)); + var x507: u32 = undefined; + var x508: u1 = undefined; + addcarryxU32(&x507, &x508, x506, x470, x476); + var x509: u32 = undefined; + var x510: u1 = undefined; + addcarryxU32(&x509, &x510, x508, x472, x477); + const x511 = (cast(u32, x510) + cast(u32, x473)); + var x512: u32 = undefined; + var x513: u32 = undefined; + mulxU32(&x512, &x513, x6, (arg2[7])); + var x514: u32 = undefined; + var x515: u32 = undefined; + mulxU32(&x514, &x515, x6, (arg2[6])); + var x516: u32 = undefined; + var x517: u32 = undefined; + mulxU32(&x516, &x517, x6, (arg2[5])); + var x518: u32 = undefined; + var x519: u32 = undefined; + mulxU32(&x518, &x519, x6, (arg2[4])); + var x520: u32 = undefined; + var x521: u32 = undefined; + mulxU32(&x520, &x521, x6, (arg2[3])); + var x522: u32 = undefined; + var x523: u32 = undefined; + mulxU32(&x522, &x523, x6, (arg2[2])); + var x524: u32 = undefined; + var x525: u32 = undefined; + mulxU32(&x524, &x525, x6, (arg2[1])); + var x526: u32 = undefined; + var x527: u32 = undefined; + mulxU32(&x526, &x527, x6, (arg2[0])); + var x528: u32 = undefined; + var x529: u1 = undefined; + addcarryxU32(&x528, &x529, 0x0, x527, x524); + var x530: u32 = undefined; + var x531: u1 = undefined; + addcarryxU32(&x530, &x531, x529, x525, x522); + var x532: u32 = undefined; + var x533: u1 = undefined; + addcarryxU32(&x532, &x533, x531, x523, x520); + var x534: u32 = undefined; + var x535: u1 = undefined; + addcarryxU32(&x534, &x535, x533, x521, x518); + var x536: u32 = undefined; + var x537: u1 = undefined; + addcarryxU32(&x536, &x537, x535, x519, x516); + var x538: u32 = undefined; + var x539: u1 = undefined; + addcarryxU32(&x538, &x539, x537, x517, x514); + var x540: u32 = undefined; + var x541: u1 = undefined; + addcarryxU32(&x540, &x541, x539, x515, x512); + const x542 = (cast(u32, x541) + x513); + var x543: u32 = undefined; + var x544: u1 = undefined; + addcarryxU32(&x543, &x544, 0x0, x495, x526); + var x545: u32 = undefined; + var x546: u1 = undefined; + addcarryxU32(&x545, &x546, x544, x497, x528); + var x547: u32 = undefined; + var x548: u1 = undefined; + addcarryxU32(&x547, &x548, x546, x499, x530); + var x549: u32 = undefined; + var x550: u1 = undefined; + addcarryxU32(&x549, &x550, x548, x501, x532); + var x551: u32 = undefined; + var x552: u1 = undefined; + addcarryxU32(&x551, &x552, x550, x503, x534); + var x553: u32 = undefined; + var x554: u1 = undefined; + addcarryxU32(&x553, &x554, x552, x505, x536); + var x555: u32 = undefined; + var x556: u1 = undefined; + addcarryxU32(&x555, &x556, x554, x507, x538); + var x557: u32 = undefined; + var x558: u1 = undefined; + addcarryxU32(&x557, &x558, x556, x509, x540); + var x559: u32 = undefined; + var x560: u1 = undefined; + addcarryxU32(&x559, &x560, x558, x511, x542); + var x561: u32 = undefined; + var x562: u32 = undefined; + mulxU32(&x561, &x562, x543, 0x12547e1b); + var x563: u32 = undefined; + var x564: u32 = undefined; + mulxU32(&x563, &x564, x561, 0x10000000); + var x565: u32 = undefined; + var x566: u32 = undefined; + mulxU32(&x565, &x566, x561, 0x14def9de); + var x567: u32 = undefined; + var x568: u32 = undefined; + mulxU32(&x567, &x568, x561, 0xa2f79cd6); + var x569: u32 = undefined; + var x570: u32 = undefined; + mulxU32(&x569, &x570, x561, 0x5812631a); + var x571: u32 = undefined; + var x572: u32 = undefined; + mulxU32(&x571, &x572, x561, 0x5cf5d3ed); + var x573: u32 = undefined; + var x574: u1 = undefined; + addcarryxU32(&x573, &x574, 0x0, x572, x569); + var x575: u32 = undefined; + var x576: u1 = undefined; + addcarryxU32(&x575, &x576, x574, x570, x567); + var x577: u32 = undefined; + var x578: u1 = undefined; + addcarryxU32(&x577, &x578, x576, x568, x565); + const x579 = (cast(u32, x578) + x566); + var x580: u32 = undefined; + var x581: u1 = undefined; + addcarryxU32(&x580, &x581, 0x0, x543, x571); + var x582: u32 = undefined; + var x583: u1 = undefined; + addcarryxU32(&x582, &x583, x581, x545, x573); + var x584: u32 = undefined; + var x585: u1 = undefined; + addcarryxU32(&x584, &x585, x583, x547, x575); + var x586: u32 = undefined; + var x587: u1 = undefined; + addcarryxU32(&x586, &x587, x585, x549, x577); + var x588: u32 = undefined; + var x589: u1 = undefined; + addcarryxU32(&x588, &x589, x587, x551, x579); + var x590: u32 = undefined; + var x591: u1 = undefined; + addcarryxU32(&x590, &x591, x589, x553, cast(u32, 0x0)); + var x592: u32 = undefined; + var x593: u1 = undefined; + addcarryxU32(&x592, &x593, x591, x555, cast(u32, 0x0)); + var x594: u32 = undefined; + var x595: u1 = undefined; + addcarryxU32(&x594, &x595, x593, x557, x563); + var x596: u32 = undefined; + var x597: u1 = undefined; + addcarryxU32(&x596, &x597, x595, x559, x564); + const x598 = (cast(u32, x597) + cast(u32, x560)); + var x599: u32 = undefined; + var x600: u32 = undefined; + mulxU32(&x599, &x600, x7, (arg2[7])); + var x601: u32 = undefined; + var x602: u32 = undefined; + mulxU32(&x601, &x602, x7, (arg2[6])); + var x603: u32 = undefined; + var x604: u32 = undefined; + mulxU32(&x603, &x604, x7, (arg2[5])); + var x605: u32 = undefined; + var x606: u32 = undefined; + mulxU32(&x605, &x606, x7, (arg2[4])); + var x607: u32 = undefined; + var x608: u32 = undefined; + mulxU32(&x607, &x608, x7, (arg2[3])); + var x609: u32 = undefined; + var x610: u32 = undefined; + mulxU32(&x609, &x610, x7, (arg2[2])); + var x611: u32 = undefined; + var x612: u32 = undefined; + mulxU32(&x611, &x612, x7, (arg2[1])); + var x613: u32 = undefined; + var x614: u32 = undefined; + mulxU32(&x613, &x614, x7, (arg2[0])); + var x615: u32 = undefined; + var x616: u1 = undefined; + addcarryxU32(&x615, &x616, 0x0, x614, x611); + var x617: u32 = undefined; + var x618: u1 = undefined; + addcarryxU32(&x617, &x618, x616, x612, x609); + var x619: u32 = undefined; + var x620: u1 = undefined; + addcarryxU32(&x619, &x620, x618, x610, x607); + var x621: u32 = undefined; + var x622: u1 = undefined; + addcarryxU32(&x621, &x622, x620, x608, x605); + var x623: u32 = undefined; + var x624: u1 = undefined; + addcarryxU32(&x623, &x624, x622, x606, x603); + var x625: u32 = undefined; + var x626: u1 = undefined; + addcarryxU32(&x625, &x626, x624, x604, x601); + var x627: u32 = undefined; + var x628: u1 = undefined; + addcarryxU32(&x627, &x628, x626, x602, x599); + const x629 = (cast(u32, x628) + x600); + var x630: u32 = undefined; + var x631: u1 = undefined; + addcarryxU32(&x630, &x631, 0x0, x582, x613); + var x632: u32 = undefined; + var x633: u1 = undefined; + addcarryxU32(&x632, &x633, x631, x584, x615); + var x634: u32 = undefined; + var x635: u1 = undefined; + addcarryxU32(&x634, &x635, x633, x586, x617); + var x636: u32 = undefined; + var x637: u1 = undefined; + addcarryxU32(&x636, &x637, x635, x588, x619); + var x638: u32 = undefined; + var x639: u1 = undefined; + addcarryxU32(&x638, &x639, x637, x590, x621); + var x640: u32 = undefined; + var x641: u1 = undefined; + addcarryxU32(&x640, &x641, x639, x592, x623); + var x642: u32 = undefined; + var x643: u1 = undefined; + addcarryxU32(&x642, &x643, x641, x594, x625); + var x644: u32 = undefined; + var x645: u1 = undefined; + addcarryxU32(&x644, &x645, x643, x596, x627); + var x646: u32 = undefined; + var x647: u1 = undefined; + addcarryxU32(&x646, &x647, x645, x598, x629); + var x648: u32 = undefined; + var x649: u32 = undefined; + mulxU32(&x648, &x649, x630, 0x12547e1b); + var x650: u32 = undefined; + var x651: u32 = undefined; + mulxU32(&x650, &x651, x648, 0x10000000); + var x652: u32 = undefined; + var x653: u32 = undefined; + mulxU32(&x652, &x653, x648, 0x14def9de); + var x654: u32 = undefined; + var x655: u32 = undefined; + mulxU32(&x654, &x655, x648, 0xa2f79cd6); + var x656: u32 = undefined; + var x657: u32 = undefined; + mulxU32(&x656, &x657, x648, 0x5812631a); + var x658: u32 = undefined; + var x659: u32 = undefined; + mulxU32(&x658, &x659, x648, 0x5cf5d3ed); + var x660: u32 = undefined; + var x661: u1 = undefined; + addcarryxU32(&x660, &x661, 0x0, x659, x656); + var x662: u32 = undefined; + var x663: u1 = undefined; + addcarryxU32(&x662, &x663, x661, x657, x654); + var x664: u32 = undefined; + var x665: u1 = undefined; + addcarryxU32(&x664, &x665, x663, x655, x652); + const x666 = (cast(u32, x665) + x653); + var x667: u32 = undefined; + var x668: u1 = undefined; + addcarryxU32(&x667, &x668, 0x0, x630, x658); + var x669: u32 = undefined; + var x670: u1 = undefined; + addcarryxU32(&x669, &x670, x668, x632, x660); + var x671: u32 = undefined; + var x672: u1 = undefined; + addcarryxU32(&x671, &x672, x670, x634, x662); + var x673: u32 = undefined; + var x674: u1 = undefined; + addcarryxU32(&x673, &x674, x672, x636, x664); + var x675: u32 = undefined; + var x676: u1 = undefined; + addcarryxU32(&x675, &x676, x674, x638, x666); + var x677: u32 = undefined; + var x678: u1 = undefined; + addcarryxU32(&x677, &x678, x676, x640, cast(u32, 0x0)); + var x679: u32 = undefined; + var x680: u1 = undefined; + addcarryxU32(&x679, &x680, x678, x642, cast(u32, 0x0)); + var x681: u32 = undefined; + var x682: u1 = undefined; + addcarryxU32(&x681, &x682, x680, x644, x650); + var x683: u32 = undefined; + var x684: u1 = undefined; + addcarryxU32(&x683, &x684, x682, x646, x651); + const x685 = (cast(u32, x684) + cast(u32, x647)); + var x686: u32 = undefined; + var x687: u1 = undefined; + subborrowxU32(&x686, &x687, 0x0, x669, 0x5cf5d3ed); + var x688: u32 = undefined; + var x689: u1 = undefined; + subborrowxU32(&x688, &x689, x687, x671, 0x5812631a); + var x690: u32 = undefined; + var x691: u1 = undefined; + subborrowxU32(&x690, &x691, x689, x673, 0xa2f79cd6); + var x692: u32 = undefined; + var x693: u1 = undefined; + subborrowxU32(&x692, &x693, x691, x675, 0x14def9de); + var x694: u32 = undefined; + var x695: u1 = undefined; + subborrowxU32(&x694, &x695, x693, x677, cast(u32, 0x0)); + var x696: u32 = undefined; + var x697: u1 = undefined; + subborrowxU32(&x696, &x697, x695, x679, cast(u32, 0x0)); + var x698: u32 = undefined; + var x699: u1 = undefined; + subborrowxU32(&x698, &x699, x697, x681, cast(u32, 0x0)); + var x700: u32 = undefined; + var x701: u1 = undefined; + subborrowxU32(&x700, &x701, x699, x683, 0x10000000); + var x702: u32 = undefined; + var x703: u1 = undefined; + subborrowxU32(&x702, &x703, x701, x685, cast(u32, 0x0)); + var x704: u32 = undefined; + cmovznzU32(&x704, x703, x686, x669); + var x705: u32 = undefined; + cmovznzU32(&x705, x703, x688, x671); + var x706: u32 = undefined; + cmovznzU32(&x706, x703, x690, x673); + var x707: u32 = undefined; + cmovznzU32(&x707, x703, x692, x675); + var x708: u32 = undefined; + cmovznzU32(&x708, x703, x694, x677); + var x709: u32 = undefined; + cmovznzU32(&x709, x703, x696, x679); + var x710: u32 = undefined; + cmovznzU32(&x710, x703, x698, x681); + var x711: u32 = undefined; + cmovznzU32(&x711, x703, x700, x683); + out1[0] = x704; + out1[1] = x705; + out1[2] = x706; + out1[3] = x707; + out1[4] = x708; + out1[5] = x709; + out1[6] = x710; + out1[7] = x711; +} + +/// The function square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn square(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[6]); + const x7 = (arg1[7]); + const x8 = (arg1[0]); + var x9: u32 = undefined; + var x10: u32 = undefined; + mulxU32(&x9, &x10, x8, (arg1[7])); + var x11: u32 = undefined; + var x12: u32 = undefined; + mulxU32(&x11, &x12, x8, (arg1[6])); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x8, (arg1[5])); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x8, (arg1[4])); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x8, (arg1[3])); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x8, (arg1[2])); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x8, (arg1[1])); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x8, (arg1[0])); + var x25: u32 = undefined; + var x26: u1 = undefined; + addcarryxU32(&x25, &x26, 0x0, x24, x21); + var x27: u32 = undefined; + var x28: u1 = undefined; + addcarryxU32(&x27, &x28, x26, x22, x19); + var x29: u32 = undefined; + var x30: u1 = undefined; + addcarryxU32(&x29, &x30, x28, x20, x17); + var x31: u32 = undefined; + var x32: u1 = undefined; + addcarryxU32(&x31, &x32, x30, x18, x15); + var x33: u32 = undefined; + var x34: u1 = undefined; + addcarryxU32(&x33, &x34, x32, x16, x13); + var x35: u32 = undefined; + var x36: u1 = undefined; + addcarryxU32(&x35, &x36, x34, x14, x11); + var x37: u32 = undefined; + var x38: u1 = undefined; + addcarryxU32(&x37, &x38, x36, x12, x9); + const x39 = (cast(u32, x38) + x10); + var x40: u32 = undefined; + var x41: u32 = undefined; + mulxU32(&x40, &x41, x23, 0x12547e1b); + var x42: u32 = undefined; + var x43: u32 = undefined; + mulxU32(&x42, &x43, x40, 0x10000000); + var x44: u32 = undefined; + var x45: u32 = undefined; + mulxU32(&x44, &x45, x40, 0x14def9de); + var x46: u32 = undefined; + var x47: u32 = undefined; + mulxU32(&x46, &x47, x40, 0xa2f79cd6); + var x48: u32 = undefined; + var x49: u32 = undefined; + mulxU32(&x48, &x49, x40, 0x5812631a); + var x50: u32 = undefined; + var x51: u32 = undefined; + mulxU32(&x50, &x51, x40, 0x5cf5d3ed); + var x52: u32 = undefined; + var x53: u1 = undefined; + addcarryxU32(&x52, &x53, 0x0, x51, x48); + var x54: u32 = undefined; + var x55: u1 = undefined; + addcarryxU32(&x54, &x55, x53, x49, x46); + var x56: u32 = undefined; + var x57: u1 = undefined; + addcarryxU32(&x56, &x57, x55, x47, x44); + const x58 = (cast(u32, x57) + x45); + var x59: u32 = undefined; + var x60: u1 = undefined; + addcarryxU32(&x59, &x60, 0x0, x23, x50); + var x61: u32 = undefined; + var x62: u1 = undefined; + addcarryxU32(&x61, &x62, x60, x25, x52); + var x63: u32 = undefined; + var x64: u1 = undefined; + addcarryxU32(&x63, &x64, x62, x27, x54); + var x65: u32 = undefined; + var x66: u1 = undefined; + addcarryxU32(&x65, &x66, x64, x29, x56); + var x67: u32 = undefined; + var x68: u1 = undefined; + addcarryxU32(&x67, &x68, x66, x31, x58); + var x69: u32 = undefined; + var x70: u1 = undefined; + addcarryxU32(&x69, &x70, x68, x33, cast(u32, 0x0)); + var x71: u32 = undefined; + var x72: u1 = undefined; + addcarryxU32(&x71, &x72, x70, x35, cast(u32, 0x0)); + var x73: u32 = undefined; + var x74: u1 = undefined; + addcarryxU32(&x73, &x74, x72, x37, x42); + var x75: u32 = undefined; + var x76: u1 = undefined; + addcarryxU32(&x75, &x76, x74, x39, x43); + var x77: u32 = undefined; + var x78: u32 = undefined; + mulxU32(&x77, &x78, x1, (arg1[7])); + var x79: u32 = undefined; + var x80: u32 = undefined; + mulxU32(&x79, &x80, x1, (arg1[6])); + var x81: u32 = undefined; + var x82: u32 = undefined; + mulxU32(&x81, &x82, x1, (arg1[5])); + var x83: u32 = undefined; + var x84: u32 = undefined; + mulxU32(&x83, &x84, x1, (arg1[4])); + var x85: u32 = undefined; + var x86: u32 = undefined; + mulxU32(&x85, &x86, x1, (arg1[3])); + var x87: u32 = undefined; + var x88: u32 = undefined; + mulxU32(&x87, &x88, x1, (arg1[2])); + var x89: u32 = undefined; + var x90: u32 = undefined; + mulxU32(&x89, &x90, x1, (arg1[1])); + var x91: u32 = undefined; + var x92: u32 = undefined; + mulxU32(&x91, &x92, x1, (arg1[0])); + var x93: u32 = undefined; + var x94: u1 = undefined; + addcarryxU32(&x93, &x94, 0x0, x92, x89); + var x95: u32 = undefined; + var x96: u1 = undefined; + addcarryxU32(&x95, &x96, x94, x90, x87); + var x97: u32 = undefined; + var x98: u1 = undefined; + addcarryxU32(&x97, &x98, x96, x88, x85); + var x99: u32 = undefined; + var x100: u1 = undefined; + addcarryxU32(&x99, &x100, x98, x86, x83); + var x101: u32 = undefined; + var x102: u1 = undefined; + addcarryxU32(&x101, &x102, x100, x84, x81); + var x103: u32 = undefined; + var x104: u1 = undefined; + addcarryxU32(&x103, &x104, x102, x82, x79); + var x105: u32 = undefined; + var x106: u1 = undefined; + addcarryxU32(&x105, &x106, x104, x80, x77); + const x107 = (cast(u32, x106) + x78); + var x108: u32 = undefined; + var x109: u1 = undefined; + addcarryxU32(&x108, &x109, 0x0, x61, x91); + var x110: u32 = undefined; + var x111: u1 = undefined; + addcarryxU32(&x110, &x111, x109, x63, x93); + var x112: u32 = undefined; + var x113: u1 = undefined; + addcarryxU32(&x112, &x113, x111, x65, x95); + var x114: u32 = undefined; + var x115: u1 = undefined; + addcarryxU32(&x114, &x115, x113, x67, x97); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, x115, x69, x99); + var x118: u32 = undefined; + var x119: u1 = undefined; + addcarryxU32(&x118, &x119, x117, x71, x101); + var x120: u32 = undefined; + var x121: u1 = undefined; + addcarryxU32(&x120, &x121, x119, x73, x103); + var x122: u32 = undefined; + var x123: u1 = undefined; + addcarryxU32(&x122, &x123, x121, x75, x105); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, cast(u32, x76), x107); + var x126: u32 = undefined; + var x127: u32 = undefined; + mulxU32(&x126, &x127, x108, 0x12547e1b); + var x128: u32 = undefined; + var x129: u32 = undefined; + mulxU32(&x128, &x129, x126, 0x10000000); + var x130: u32 = undefined; + var x131: u32 = undefined; + mulxU32(&x130, &x131, x126, 0x14def9de); + var x132: u32 = undefined; + var x133: u32 = undefined; + mulxU32(&x132, &x133, x126, 0xa2f79cd6); + var x134: u32 = undefined; + var x135: u32 = undefined; + mulxU32(&x134, &x135, x126, 0x5812631a); + var x136: u32 = undefined; + var x137: u32 = undefined; + mulxU32(&x136, &x137, x126, 0x5cf5d3ed); + var x138: u32 = undefined; + var x139: u1 = undefined; + addcarryxU32(&x138, &x139, 0x0, x137, x134); + var x140: u32 = undefined; + var x141: u1 = undefined; + addcarryxU32(&x140, &x141, x139, x135, x132); + var x142: u32 = undefined; + var x143: u1 = undefined; + addcarryxU32(&x142, &x143, x141, x133, x130); + const x144 = (cast(u32, x143) + x131); + var x145: u32 = undefined; + var x146: u1 = undefined; + addcarryxU32(&x145, &x146, 0x0, x108, x136); + var x147: u32 = undefined; + var x148: u1 = undefined; + addcarryxU32(&x147, &x148, x146, x110, x138); + var x149: u32 = undefined; + var x150: u1 = undefined; + addcarryxU32(&x149, &x150, x148, x112, x140); + var x151: u32 = undefined; + var x152: u1 = undefined; + addcarryxU32(&x151, &x152, x150, x114, x142); + var x153: u32 = undefined; + var x154: u1 = undefined; + addcarryxU32(&x153, &x154, x152, x116, x144); + var x155: u32 = undefined; + var x156: u1 = undefined; + addcarryxU32(&x155, &x156, x154, x118, cast(u32, 0x0)); + var x157: u32 = undefined; + var x158: u1 = undefined; + addcarryxU32(&x157, &x158, x156, x120, cast(u32, 0x0)); + var x159: u32 = undefined; + var x160: u1 = undefined; + addcarryxU32(&x159, &x160, x158, x122, x128); + var x161: u32 = undefined; + var x162: u1 = undefined; + addcarryxU32(&x161, &x162, x160, x124, x129); + const x163 = (cast(u32, x162) + cast(u32, x125)); + var x164: u32 = undefined; + var x165: u32 = undefined; + mulxU32(&x164, &x165, x2, (arg1[7])); + var x166: u32 = undefined; + var x167: u32 = undefined; + mulxU32(&x166, &x167, x2, (arg1[6])); + var x168: u32 = undefined; + var x169: u32 = undefined; + mulxU32(&x168, &x169, x2, (arg1[5])); + var x170: u32 = undefined; + var x171: u32 = undefined; + mulxU32(&x170, &x171, x2, (arg1[4])); + var x172: u32 = undefined; + var x173: u32 = undefined; + mulxU32(&x172, &x173, x2, (arg1[3])); + var x174: u32 = undefined; + var x175: u32 = undefined; + mulxU32(&x174, &x175, x2, (arg1[2])); + var x176: u32 = undefined; + var x177: u32 = undefined; + mulxU32(&x176, &x177, x2, (arg1[1])); + var x178: u32 = undefined; + var x179: u32 = undefined; + mulxU32(&x178, &x179, x2, (arg1[0])); + var x180: u32 = undefined; + var x181: u1 = undefined; + addcarryxU32(&x180, &x181, 0x0, x179, x176); + var x182: u32 = undefined; + var x183: u1 = undefined; + addcarryxU32(&x182, &x183, x181, x177, x174); + var x184: u32 = undefined; + var x185: u1 = undefined; + addcarryxU32(&x184, &x185, x183, x175, x172); + var x186: u32 = undefined; + var x187: u1 = undefined; + addcarryxU32(&x186, &x187, x185, x173, x170); + var x188: u32 = undefined; + var x189: u1 = undefined; + addcarryxU32(&x188, &x189, x187, x171, x168); + var x190: u32 = undefined; + var x191: u1 = undefined; + addcarryxU32(&x190, &x191, x189, x169, x166); + var x192: u32 = undefined; + var x193: u1 = undefined; + addcarryxU32(&x192, &x193, x191, x167, x164); + const x194 = (cast(u32, x193) + x165); + var x195: u32 = undefined; + var x196: u1 = undefined; + addcarryxU32(&x195, &x196, 0x0, x147, x178); + var x197: u32 = undefined; + var x198: u1 = undefined; + addcarryxU32(&x197, &x198, x196, x149, x180); + var x199: u32 = undefined; + var x200: u1 = undefined; + addcarryxU32(&x199, &x200, x198, x151, x182); + var x201: u32 = undefined; + var x202: u1 = undefined; + addcarryxU32(&x201, &x202, x200, x153, x184); + var x203: u32 = undefined; + var x204: u1 = undefined; + addcarryxU32(&x203, &x204, x202, x155, x186); + var x205: u32 = undefined; + var x206: u1 = undefined; + addcarryxU32(&x205, &x206, x204, x157, x188); + var x207: u32 = undefined; + var x208: u1 = undefined; + addcarryxU32(&x207, &x208, x206, x159, x190); + var x209: u32 = undefined; + var x210: u1 = undefined; + addcarryxU32(&x209, &x210, x208, x161, x192); + var x211: u32 = undefined; + var x212: u1 = undefined; + addcarryxU32(&x211, &x212, x210, x163, x194); + var x213: u32 = undefined; + var x214: u32 = undefined; + mulxU32(&x213, &x214, x195, 0x12547e1b); + var x215: u32 = undefined; + var x216: u32 = undefined; + mulxU32(&x215, &x216, x213, 0x10000000); + var x217: u32 = undefined; + var x218: u32 = undefined; + mulxU32(&x217, &x218, x213, 0x14def9de); + var x219: u32 = undefined; + var x220: u32 = undefined; + mulxU32(&x219, &x220, x213, 0xa2f79cd6); + var x221: u32 = undefined; + var x222: u32 = undefined; + mulxU32(&x221, &x222, x213, 0x5812631a); + var x223: u32 = undefined; + var x224: u32 = undefined; + mulxU32(&x223, &x224, x213, 0x5cf5d3ed); + var x225: u32 = undefined; + var x226: u1 = undefined; + addcarryxU32(&x225, &x226, 0x0, x224, x221); + var x227: u32 = undefined; + var x228: u1 = undefined; + addcarryxU32(&x227, &x228, x226, x222, x219); + var x229: u32 = undefined; + var x230: u1 = undefined; + addcarryxU32(&x229, &x230, x228, x220, x217); + const x231 = (cast(u32, x230) + x218); + var x232: u32 = undefined; + var x233: u1 = undefined; + addcarryxU32(&x232, &x233, 0x0, x195, x223); + var x234: u32 = undefined; + var x235: u1 = undefined; + addcarryxU32(&x234, &x235, x233, x197, x225); + var x236: u32 = undefined; + var x237: u1 = undefined; + addcarryxU32(&x236, &x237, x235, x199, x227); + var x238: u32 = undefined; + var x239: u1 = undefined; + addcarryxU32(&x238, &x239, x237, x201, x229); + var x240: u32 = undefined; + var x241: u1 = undefined; + addcarryxU32(&x240, &x241, x239, x203, x231); + var x242: u32 = undefined; + var x243: u1 = undefined; + addcarryxU32(&x242, &x243, x241, x205, cast(u32, 0x0)); + var x244: u32 = undefined; + var x245: u1 = undefined; + addcarryxU32(&x244, &x245, x243, x207, cast(u32, 0x0)); + var x246: u32 = undefined; + var x247: u1 = undefined; + addcarryxU32(&x246, &x247, x245, x209, x215); + var x248: u32 = undefined; + var x249: u1 = undefined; + addcarryxU32(&x248, &x249, x247, x211, x216); + const x250 = (cast(u32, x249) + cast(u32, x212)); + var x251: u32 = undefined; + var x252: u32 = undefined; + mulxU32(&x251, &x252, x3, (arg1[7])); + var x253: u32 = undefined; + var x254: u32 = undefined; + mulxU32(&x253, &x254, x3, (arg1[6])); + var x255: u32 = undefined; + var x256: u32 = undefined; + mulxU32(&x255, &x256, x3, (arg1[5])); + var x257: u32 = undefined; + var x258: u32 = undefined; + mulxU32(&x257, &x258, x3, (arg1[4])); + var x259: u32 = undefined; + var x260: u32 = undefined; + mulxU32(&x259, &x260, x3, (arg1[3])); + var x261: u32 = undefined; + var x262: u32 = undefined; + mulxU32(&x261, &x262, x3, (arg1[2])); + var x263: u32 = undefined; + var x264: u32 = undefined; + mulxU32(&x263, &x264, x3, (arg1[1])); + var x265: u32 = undefined; + var x266: u32 = undefined; + mulxU32(&x265, &x266, x3, (arg1[0])); + var x267: u32 = undefined; + var x268: u1 = undefined; + addcarryxU32(&x267, &x268, 0x0, x266, x263); + var x269: u32 = undefined; + var x270: u1 = undefined; + addcarryxU32(&x269, &x270, x268, x264, x261); + var x271: u32 = undefined; + var x272: u1 = undefined; + addcarryxU32(&x271, &x272, x270, x262, x259); + var x273: u32 = undefined; + var x274: u1 = undefined; + addcarryxU32(&x273, &x274, x272, x260, x257); + var x275: u32 = undefined; + var x276: u1 = undefined; + addcarryxU32(&x275, &x276, x274, x258, x255); + var x277: u32 = undefined; + var x278: u1 = undefined; + addcarryxU32(&x277, &x278, x276, x256, x253); + var x279: u32 = undefined; + var x280: u1 = undefined; + addcarryxU32(&x279, &x280, x278, x254, x251); + const x281 = (cast(u32, x280) + x252); + var x282: u32 = undefined; + var x283: u1 = undefined; + addcarryxU32(&x282, &x283, 0x0, x234, x265); + var x284: u32 = undefined; + var x285: u1 = undefined; + addcarryxU32(&x284, &x285, x283, x236, x267); + var x286: u32 = undefined; + var x287: u1 = undefined; + addcarryxU32(&x286, &x287, x285, x238, x269); + var x288: u32 = undefined; + var x289: u1 = undefined; + addcarryxU32(&x288, &x289, x287, x240, x271); + var x290: u32 = undefined; + var x291: u1 = undefined; + addcarryxU32(&x290, &x291, x289, x242, x273); + var x292: u32 = undefined; + var x293: u1 = undefined; + addcarryxU32(&x292, &x293, x291, x244, x275); + var x294: u32 = undefined; + var x295: u1 = undefined; + addcarryxU32(&x294, &x295, x293, x246, x277); + var x296: u32 = undefined; + var x297: u1 = undefined; + addcarryxU32(&x296, &x297, x295, x248, x279); + var x298: u32 = undefined; + var x299: u1 = undefined; + addcarryxU32(&x298, &x299, x297, x250, x281); + var x300: u32 = undefined; + var x301: u32 = undefined; + mulxU32(&x300, &x301, x282, 0x12547e1b); + var x302: u32 = undefined; + var x303: u32 = undefined; + mulxU32(&x302, &x303, x300, 0x10000000); + var x304: u32 = undefined; + var x305: u32 = undefined; + mulxU32(&x304, &x305, x300, 0x14def9de); + var x306: u32 = undefined; + var x307: u32 = undefined; + mulxU32(&x306, &x307, x300, 0xa2f79cd6); + var x308: u32 = undefined; + var x309: u32 = undefined; + mulxU32(&x308, &x309, x300, 0x5812631a); + var x310: u32 = undefined; + var x311: u32 = undefined; + mulxU32(&x310, &x311, x300, 0x5cf5d3ed); + var x312: u32 = undefined; + var x313: u1 = undefined; + addcarryxU32(&x312, &x313, 0x0, x311, x308); + var x314: u32 = undefined; + var x315: u1 = undefined; + addcarryxU32(&x314, &x315, x313, x309, x306); + var x316: u32 = undefined; + var x317: u1 = undefined; + addcarryxU32(&x316, &x317, x315, x307, x304); + const x318 = (cast(u32, x317) + x305); + var x319: u32 = undefined; + var x320: u1 = undefined; + addcarryxU32(&x319, &x320, 0x0, x282, x310); + var x321: u32 = undefined; + var x322: u1 = undefined; + addcarryxU32(&x321, &x322, x320, x284, x312); + var x323: u32 = undefined; + var x324: u1 = undefined; + addcarryxU32(&x323, &x324, x322, x286, x314); + var x325: u32 = undefined; + var x326: u1 = undefined; + addcarryxU32(&x325, &x326, x324, x288, x316); + var x327: u32 = undefined; + var x328: u1 = undefined; + addcarryxU32(&x327, &x328, x326, x290, x318); + var x329: u32 = undefined; + var x330: u1 = undefined; + addcarryxU32(&x329, &x330, x328, x292, cast(u32, 0x0)); + var x331: u32 = undefined; + var x332: u1 = undefined; + addcarryxU32(&x331, &x332, x330, x294, cast(u32, 0x0)); + var x333: u32 = undefined; + var x334: u1 = undefined; + addcarryxU32(&x333, &x334, x332, x296, x302); + var x335: u32 = undefined; + var x336: u1 = undefined; + addcarryxU32(&x335, &x336, x334, x298, x303); + const x337 = (cast(u32, x336) + cast(u32, x299)); + var x338: u32 = undefined; + var x339: u32 = undefined; + mulxU32(&x338, &x339, x4, (arg1[7])); + var x340: u32 = undefined; + var x341: u32 = undefined; + mulxU32(&x340, &x341, x4, (arg1[6])); + var x342: u32 = undefined; + var x343: u32 = undefined; + mulxU32(&x342, &x343, x4, (arg1[5])); + var x344: u32 = undefined; + var x345: u32 = undefined; + mulxU32(&x344, &x345, x4, (arg1[4])); + var x346: u32 = undefined; + var x347: u32 = undefined; + mulxU32(&x346, &x347, x4, (arg1[3])); + var x348: u32 = undefined; + var x349: u32 = undefined; + mulxU32(&x348, &x349, x4, (arg1[2])); + var x350: u32 = undefined; + var x351: u32 = undefined; + mulxU32(&x350, &x351, x4, (arg1[1])); + var x352: u32 = undefined; + var x353: u32 = undefined; + mulxU32(&x352, &x353, x4, (arg1[0])); + var x354: u32 = undefined; + var x355: u1 = undefined; + addcarryxU32(&x354, &x355, 0x0, x353, x350); + var x356: u32 = undefined; + var x357: u1 = undefined; + addcarryxU32(&x356, &x357, x355, x351, x348); + var x358: u32 = undefined; + var x359: u1 = undefined; + addcarryxU32(&x358, &x359, x357, x349, x346); + var x360: u32 = undefined; + var x361: u1 = undefined; + addcarryxU32(&x360, &x361, x359, x347, x344); + var x362: u32 = undefined; + var x363: u1 = undefined; + addcarryxU32(&x362, &x363, x361, x345, x342); + var x364: u32 = undefined; + var x365: u1 = undefined; + addcarryxU32(&x364, &x365, x363, x343, x340); + var x366: u32 = undefined; + var x367: u1 = undefined; + addcarryxU32(&x366, &x367, x365, x341, x338); + const x368 = (cast(u32, x367) + x339); + var x369: u32 = undefined; + var x370: u1 = undefined; + addcarryxU32(&x369, &x370, 0x0, x321, x352); + var x371: u32 = undefined; + var x372: u1 = undefined; + addcarryxU32(&x371, &x372, x370, x323, x354); + var x373: u32 = undefined; + var x374: u1 = undefined; + addcarryxU32(&x373, &x374, x372, x325, x356); + var x375: u32 = undefined; + var x376: u1 = undefined; + addcarryxU32(&x375, &x376, x374, x327, x358); + var x377: u32 = undefined; + var x378: u1 = undefined; + addcarryxU32(&x377, &x378, x376, x329, x360); + var x379: u32 = undefined; + var x380: u1 = undefined; + addcarryxU32(&x379, &x380, x378, x331, x362); + var x381: u32 = undefined; + var x382: u1 = undefined; + addcarryxU32(&x381, &x382, x380, x333, x364); + var x383: u32 = undefined; + var x384: u1 = undefined; + addcarryxU32(&x383, &x384, x382, x335, x366); + var x385: u32 = undefined; + var x386: u1 = undefined; + addcarryxU32(&x385, &x386, x384, x337, x368); + var x387: u32 = undefined; + var x388: u32 = undefined; + mulxU32(&x387, &x388, x369, 0x12547e1b); + var x389: u32 = undefined; + var x390: u32 = undefined; + mulxU32(&x389, &x390, x387, 0x10000000); + var x391: u32 = undefined; + var x392: u32 = undefined; + mulxU32(&x391, &x392, x387, 0x14def9de); + var x393: u32 = undefined; + var x394: u32 = undefined; + mulxU32(&x393, &x394, x387, 0xa2f79cd6); + var x395: u32 = undefined; + var x396: u32 = undefined; + mulxU32(&x395, &x396, x387, 0x5812631a); + var x397: u32 = undefined; + var x398: u32 = undefined; + mulxU32(&x397, &x398, x387, 0x5cf5d3ed); + var x399: u32 = undefined; + var x400: u1 = undefined; + addcarryxU32(&x399, &x400, 0x0, x398, x395); + var x401: u32 = undefined; + var x402: u1 = undefined; + addcarryxU32(&x401, &x402, x400, x396, x393); + var x403: u32 = undefined; + var x404: u1 = undefined; + addcarryxU32(&x403, &x404, x402, x394, x391); + const x405 = (cast(u32, x404) + x392); + var x406: u32 = undefined; + var x407: u1 = undefined; + addcarryxU32(&x406, &x407, 0x0, x369, x397); + var x408: u32 = undefined; + var x409: u1 = undefined; + addcarryxU32(&x408, &x409, x407, x371, x399); + var x410: u32 = undefined; + var x411: u1 = undefined; + addcarryxU32(&x410, &x411, x409, x373, x401); + var x412: u32 = undefined; + var x413: u1 = undefined; + addcarryxU32(&x412, &x413, x411, x375, x403); + var x414: u32 = undefined; + var x415: u1 = undefined; + addcarryxU32(&x414, &x415, x413, x377, x405); + var x416: u32 = undefined; + var x417: u1 = undefined; + addcarryxU32(&x416, &x417, x415, x379, cast(u32, 0x0)); + var x418: u32 = undefined; + var x419: u1 = undefined; + addcarryxU32(&x418, &x419, x417, x381, cast(u32, 0x0)); + var x420: u32 = undefined; + var x421: u1 = undefined; + addcarryxU32(&x420, &x421, x419, x383, x389); + var x422: u32 = undefined; + var x423: u1 = undefined; + addcarryxU32(&x422, &x423, x421, x385, x390); + const x424 = (cast(u32, x423) + cast(u32, x386)); + var x425: u32 = undefined; + var x426: u32 = undefined; + mulxU32(&x425, &x426, x5, (arg1[7])); + var x427: u32 = undefined; + var x428: u32 = undefined; + mulxU32(&x427, &x428, x5, (arg1[6])); + var x429: u32 = undefined; + var x430: u32 = undefined; + mulxU32(&x429, &x430, x5, (arg1[5])); + var x431: u32 = undefined; + var x432: u32 = undefined; + mulxU32(&x431, &x432, x5, (arg1[4])); + var x433: u32 = undefined; + var x434: u32 = undefined; + mulxU32(&x433, &x434, x5, (arg1[3])); + var x435: u32 = undefined; + var x436: u32 = undefined; + mulxU32(&x435, &x436, x5, (arg1[2])); + var x437: u32 = undefined; + var x438: u32 = undefined; + mulxU32(&x437, &x438, x5, (arg1[1])); + var x439: u32 = undefined; + var x440: u32 = undefined; + mulxU32(&x439, &x440, x5, (arg1[0])); + var x441: u32 = undefined; + var x442: u1 = undefined; + addcarryxU32(&x441, &x442, 0x0, x440, x437); + var x443: u32 = undefined; + var x444: u1 = undefined; + addcarryxU32(&x443, &x444, x442, x438, x435); + var x445: u32 = undefined; + var x446: u1 = undefined; + addcarryxU32(&x445, &x446, x444, x436, x433); + var x447: u32 = undefined; + var x448: u1 = undefined; + addcarryxU32(&x447, &x448, x446, x434, x431); + var x449: u32 = undefined; + var x450: u1 = undefined; + addcarryxU32(&x449, &x450, x448, x432, x429); + var x451: u32 = undefined; + var x452: u1 = undefined; + addcarryxU32(&x451, &x452, x450, x430, x427); + var x453: u32 = undefined; + var x454: u1 = undefined; + addcarryxU32(&x453, &x454, x452, x428, x425); + const x455 = (cast(u32, x454) + x426); + var x456: u32 = undefined; + var x457: u1 = undefined; + addcarryxU32(&x456, &x457, 0x0, x408, x439); + var x458: u32 = undefined; + var x459: u1 = undefined; + addcarryxU32(&x458, &x459, x457, x410, x441); + var x460: u32 = undefined; + var x461: u1 = undefined; + addcarryxU32(&x460, &x461, x459, x412, x443); + var x462: u32 = undefined; + var x463: u1 = undefined; + addcarryxU32(&x462, &x463, x461, x414, x445); + var x464: u32 = undefined; + var x465: u1 = undefined; + addcarryxU32(&x464, &x465, x463, x416, x447); + var x466: u32 = undefined; + var x467: u1 = undefined; + addcarryxU32(&x466, &x467, x465, x418, x449); + var x468: u32 = undefined; + var x469: u1 = undefined; + addcarryxU32(&x468, &x469, x467, x420, x451); + var x470: u32 = undefined; + var x471: u1 = undefined; + addcarryxU32(&x470, &x471, x469, x422, x453); + var x472: u32 = undefined; + var x473: u1 = undefined; + addcarryxU32(&x472, &x473, x471, x424, x455); + var x474: u32 = undefined; + var x475: u32 = undefined; + mulxU32(&x474, &x475, x456, 0x12547e1b); + var x476: u32 = undefined; + var x477: u32 = undefined; + mulxU32(&x476, &x477, x474, 0x10000000); + var x478: u32 = undefined; + var x479: u32 = undefined; + mulxU32(&x478, &x479, x474, 0x14def9de); + var x480: u32 = undefined; + var x481: u32 = undefined; + mulxU32(&x480, &x481, x474, 0xa2f79cd6); + var x482: u32 = undefined; + var x483: u32 = undefined; + mulxU32(&x482, &x483, x474, 0x5812631a); + var x484: u32 = undefined; + var x485: u32 = undefined; + mulxU32(&x484, &x485, x474, 0x5cf5d3ed); + var x486: u32 = undefined; + var x487: u1 = undefined; + addcarryxU32(&x486, &x487, 0x0, x485, x482); + var x488: u32 = undefined; + var x489: u1 = undefined; + addcarryxU32(&x488, &x489, x487, x483, x480); + var x490: u32 = undefined; + var x491: u1 = undefined; + addcarryxU32(&x490, &x491, x489, x481, x478); + const x492 = (cast(u32, x491) + x479); + var x493: u32 = undefined; + var x494: u1 = undefined; + addcarryxU32(&x493, &x494, 0x0, x456, x484); + var x495: u32 = undefined; + var x496: u1 = undefined; + addcarryxU32(&x495, &x496, x494, x458, x486); + var x497: u32 = undefined; + var x498: u1 = undefined; + addcarryxU32(&x497, &x498, x496, x460, x488); + var x499: u32 = undefined; + var x500: u1 = undefined; + addcarryxU32(&x499, &x500, x498, x462, x490); + var x501: u32 = undefined; + var x502: u1 = undefined; + addcarryxU32(&x501, &x502, x500, x464, x492); + var x503: u32 = undefined; + var x504: u1 = undefined; + addcarryxU32(&x503, &x504, x502, x466, cast(u32, 0x0)); + var x505: u32 = undefined; + var x506: u1 = undefined; + addcarryxU32(&x505, &x506, x504, x468, cast(u32, 0x0)); + var x507: u32 = undefined; + var x508: u1 = undefined; + addcarryxU32(&x507, &x508, x506, x470, x476); + var x509: u32 = undefined; + var x510: u1 = undefined; + addcarryxU32(&x509, &x510, x508, x472, x477); + const x511 = (cast(u32, x510) + cast(u32, x473)); + var x512: u32 = undefined; + var x513: u32 = undefined; + mulxU32(&x512, &x513, x6, (arg1[7])); + var x514: u32 = undefined; + var x515: u32 = undefined; + mulxU32(&x514, &x515, x6, (arg1[6])); + var x516: u32 = undefined; + var x517: u32 = undefined; + mulxU32(&x516, &x517, x6, (arg1[5])); + var x518: u32 = undefined; + var x519: u32 = undefined; + mulxU32(&x518, &x519, x6, (arg1[4])); + var x520: u32 = undefined; + var x521: u32 = undefined; + mulxU32(&x520, &x521, x6, (arg1[3])); + var x522: u32 = undefined; + var x523: u32 = undefined; + mulxU32(&x522, &x523, x6, (arg1[2])); + var x524: u32 = undefined; + var x525: u32 = undefined; + mulxU32(&x524, &x525, x6, (arg1[1])); + var x526: u32 = undefined; + var x527: u32 = undefined; + mulxU32(&x526, &x527, x6, (arg1[0])); + var x528: u32 = undefined; + var x529: u1 = undefined; + addcarryxU32(&x528, &x529, 0x0, x527, x524); + var x530: u32 = undefined; + var x531: u1 = undefined; + addcarryxU32(&x530, &x531, x529, x525, x522); + var x532: u32 = undefined; + var x533: u1 = undefined; + addcarryxU32(&x532, &x533, x531, x523, x520); + var x534: u32 = undefined; + var x535: u1 = undefined; + addcarryxU32(&x534, &x535, x533, x521, x518); + var x536: u32 = undefined; + var x537: u1 = undefined; + addcarryxU32(&x536, &x537, x535, x519, x516); + var x538: u32 = undefined; + var x539: u1 = undefined; + addcarryxU32(&x538, &x539, x537, x517, x514); + var x540: u32 = undefined; + var x541: u1 = undefined; + addcarryxU32(&x540, &x541, x539, x515, x512); + const x542 = (cast(u32, x541) + x513); + var x543: u32 = undefined; + var x544: u1 = undefined; + addcarryxU32(&x543, &x544, 0x0, x495, x526); + var x545: u32 = undefined; + var x546: u1 = undefined; + addcarryxU32(&x545, &x546, x544, x497, x528); + var x547: u32 = undefined; + var x548: u1 = undefined; + addcarryxU32(&x547, &x548, x546, x499, x530); + var x549: u32 = undefined; + var x550: u1 = undefined; + addcarryxU32(&x549, &x550, x548, x501, x532); + var x551: u32 = undefined; + var x552: u1 = undefined; + addcarryxU32(&x551, &x552, x550, x503, x534); + var x553: u32 = undefined; + var x554: u1 = undefined; + addcarryxU32(&x553, &x554, x552, x505, x536); + var x555: u32 = undefined; + var x556: u1 = undefined; + addcarryxU32(&x555, &x556, x554, x507, x538); + var x557: u32 = undefined; + var x558: u1 = undefined; + addcarryxU32(&x557, &x558, x556, x509, x540); + var x559: u32 = undefined; + var x560: u1 = undefined; + addcarryxU32(&x559, &x560, x558, x511, x542); + var x561: u32 = undefined; + var x562: u32 = undefined; + mulxU32(&x561, &x562, x543, 0x12547e1b); + var x563: u32 = undefined; + var x564: u32 = undefined; + mulxU32(&x563, &x564, x561, 0x10000000); + var x565: u32 = undefined; + var x566: u32 = undefined; + mulxU32(&x565, &x566, x561, 0x14def9de); + var x567: u32 = undefined; + var x568: u32 = undefined; + mulxU32(&x567, &x568, x561, 0xa2f79cd6); + var x569: u32 = undefined; + var x570: u32 = undefined; + mulxU32(&x569, &x570, x561, 0x5812631a); + var x571: u32 = undefined; + var x572: u32 = undefined; + mulxU32(&x571, &x572, x561, 0x5cf5d3ed); + var x573: u32 = undefined; + var x574: u1 = undefined; + addcarryxU32(&x573, &x574, 0x0, x572, x569); + var x575: u32 = undefined; + var x576: u1 = undefined; + addcarryxU32(&x575, &x576, x574, x570, x567); + var x577: u32 = undefined; + var x578: u1 = undefined; + addcarryxU32(&x577, &x578, x576, x568, x565); + const x579 = (cast(u32, x578) + x566); + var x580: u32 = undefined; + var x581: u1 = undefined; + addcarryxU32(&x580, &x581, 0x0, x543, x571); + var x582: u32 = undefined; + var x583: u1 = undefined; + addcarryxU32(&x582, &x583, x581, x545, x573); + var x584: u32 = undefined; + var x585: u1 = undefined; + addcarryxU32(&x584, &x585, x583, x547, x575); + var x586: u32 = undefined; + var x587: u1 = undefined; + addcarryxU32(&x586, &x587, x585, x549, x577); + var x588: u32 = undefined; + var x589: u1 = undefined; + addcarryxU32(&x588, &x589, x587, x551, x579); + var x590: u32 = undefined; + var x591: u1 = undefined; + addcarryxU32(&x590, &x591, x589, x553, cast(u32, 0x0)); + var x592: u32 = undefined; + var x593: u1 = undefined; + addcarryxU32(&x592, &x593, x591, x555, cast(u32, 0x0)); + var x594: u32 = undefined; + var x595: u1 = undefined; + addcarryxU32(&x594, &x595, x593, x557, x563); + var x596: u32 = undefined; + var x597: u1 = undefined; + addcarryxU32(&x596, &x597, x595, x559, x564); + const x598 = (cast(u32, x597) + cast(u32, x560)); + var x599: u32 = undefined; + var x600: u32 = undefined; + mulxU32(&x599, &x600, x7, (arg1[7])); + var x601: u32 = undefined; + var x602: u32 = undefined; + mulxU32(&x601, &x602, x7, (arg1[6])); + var x603: u32 = undefined; + var x604: u32 = undefined; + mulxU32(&x603, &x604, x7, (arg1[5])); + var x605: u32 = undefined; + var x606: u32 = undefined; + mulxU32(&x605, &x606, x7, (arg1[4])); + var x607: u32 = undefined; + var x608: u32 = undefined; + mulxU32(&x607, &x608, x7, (arg1[3])); + var x609: u32 = undefined; + var x610: u32 = undefined; + mulxU32(&x609, &x610, x7, (arg1[2])); + var x611: u32 = undefined; + var x612: u32 = undefined; + mulxU32(&x611, &x612, x7, (arg1[1])); + var x613: u32 = undefined; + var x614: u32 = undefined; + mulxU32(&x613, &x614, x7, (arg1[0])); + var x615: u32 = undefined; + var x616: u1 = undefined; + addcarryxU32(&x615, &x616, 0x0, x614, x611); + var x617: u32 = undefined; + var x618: u1 = undefined; + addcarryxU32(&x617, &x618, x616, x612, x609); + var x619: u32 = undefined; + var x620: u1 = undefined; + addcarryxU32(&x619, &x620, x618, x610, x607); + var x621: u32 = undefined; + var x622: u1 = undefined; + addcarryxU32(&x621, &x622, x620, x608, x605); + var x623: u32 = undefined; + var x624: u1 = undefined; + addcarryxU32(&x623, &x624, x622, x606, x603); + var x625: u32 = undefined; + var x626: u1 = undefined; + addcarryxU32(&x625, &x626, x624, x604, x601); + var x627: u32 = undefined; + var x628: u1 = undefined; + addcarryxU32(&x627, &x628, x626, x602, x599); + const x629 = (cast(u32, x628) + x600); + var x630: u32 = undefined; + var x631: u1 = undefined; + addcarryxU32(&x630, &x631, 0x0, x582, x613); + var x632: u32 = undefined; + var x633: u1 = undefined; + addcarryxU32(&x632, &x633, x631, x584, x615); + var x634: u32 = undefined; + var x635: u1 = undefined; + addcarryxU32(&x634, &x635, x633, x586, x617); + var x636: u32 = undefined; + var x637: u1 = undefined; + addcarryxU32(&x636, &x637, x635, x588, x619); + var x638: u32 = undefined; + var x639: u1 = undefined; + addcarryxU32(&x638, &x639, x637, x590, x621); + var x640: u32 = undefined; + var x641: u1 = undefined; + addcarryxU32(&x640, &x641, x639, x592, x623); + var x642: u32 = undefined; + var x643: u1 = undefined; + addcarryxU32(&x642, &x643, x641, x594, x625); + var x644: u32 = undefined; + var x645: u1 = undefined; + addcarryxU32(&x644, &x645, x643, x596, x627); + var x646: u32 = undefined; + var x647: u1 = undefined; + addcarryxU32(&x646, &x647, x645, x598, x629); + var x648: u32 = undefined; + var x649: u32 = undefined; + mulxU32(&x648, &x649, x630, 0x12547e1b); + var x650: u32 = undefined; + var x651: u32 = undefined; + mulxU32(&x650, &x651, x648, 0x10000000); + var x652: u32 = undefined; + var x653: u32 = undefined; + mulxU32(&x652, &x653, x648, 0x14def9de); + var x654: u32 = undefined; + var x655: u32 = undefined; + mulxU32(&x654, &x655, x648, 0xa2f79cd6); + var x656: u32 = undefined; + var x657: u32 = undefined; + mulxU32(&x656, &x657, x648, 0x5812631a); + var x658: u32 = undefined; + var x659: u32 = undefined; + mulxU32(&x658, &x659, x648, 0x5cf5d3ed); + var x660: u32 = undefined; + var x661: u1 = undefined; + addcarryxU32(&x660, &x661, 0x0, x659, x656); + var x662: u32 = undefined; + var x663: u1 = undefined; + addcarryxU32(&x662, &x663, x661, x657, x654); + var x664: u32 = undefined; + var x665: u1 = undefined; + addcarryxU32(&x664, &x665, x663, x655, x652); + const x666 = (cast(u32, x665) + x653); + var x667: u32 = undefined; + var x668: u1 = undefined; + addcarryxU32(&x667, &x668, 0x0, x630, x658); + var x669: u32 = undefined; + var x670: u1 = undefined; + addcarryxU32(&x669, &x670, x668, x632, x660); + var x671: u32 = undefined; + var x672: u1 = undefined; + addcarryxU32(&x671, &x672, x670, x634, x662); + var x673: u32 = undefined; + var x674: u1 = undefined; + addcarryxU32(&x673, &x674, x672, x636, x664); + var x675: u32 = undefined; + var x676: u1 = undefined; + addcarryxU32(&x675, &x676, x674, x638, x666); + var x677: u32 = undefined; + var x678: u1 = undefined; + addcarryxU32(&x677, &x678, x676, x640, cast(u32, 0x0)); + var x679: u32 = undefined; + var x680: u1 = undefined; + addcarryxU32(&x679, &x680, x678, x642, cast(u32, 0x0)); + var x681: u32 = undefined; + var x682: u1 = undefined; + addcarryxU32(&x681, &x682, x680, x644, x650); + var x683: u32 = undefined; + var x684: u1 = undefined; + addcarryxU32(&x683, &x684, x682, x646, x651); + const x685 = (cast(u32, x684) + cast(u32, x647)); + var x686: u32 = undefined; + var x687: u1 = undefined; + subborrowxU32(&x686, &x687, 0x0, x669, 0x5cf5d3ed); + var x688: u32 = undefined; + var x689: u1 = undefined; + subborrowxU32(&x688, &x689, x687, x671, 0x5812631a); + var x690: u32 = undefined; + var x691: u1 = undefined; + subborrowxU32(&x690, &x691, x689, x673, 0xa2f79cd6); + var x692: u32 = undefined; + var x693: u1 = undefined; + subborrowxU32(&x692, &x693, x691, x675, 0x14def9de); + var x694: u32 = undefined; + var x695: u1 = undefined; + subborrowxU32(&x694, &x695, x693, x677, cast(u32, 0x0)); + var x696: u32 = undefined; + var x697: u1 = undefined; + subborrowxU32(&x696, &x697, x695, x679, cast(u32, 0x0)); + var x698: u32 = undefined; + var x699: u1 = undefined; + subborrowxU32(&x698, &x699, x697, x681, cast(u32, 0x0)); + var x700: u32 = undefined; + var x701: u1 = undefined; + subborrowxU32(&x700, &x701, x699, x683, 0x10000000); + var x702: u32 = undefined; + var x703: u1 = undefined; + subborrowxU32(&x702, &x703, x701, x685, cast(u32, 0x0)); + var x704: u32 = undefined; + cmovznzU32(&x704, x703, x686, x669); + var x705: u32 = undefined; + cmovznzU32(&x705, x703, x688, x671); + var x706: u32 = undefined; + cmovznzU32(&x706, x703, x690, x673); + var x707: u32 = undefined; + cmovznzU32(&x707, x703, x692, x675); + var x708: u32 = undefined; + cmovznzU32(&x708, x703, x694, x677); + var x709: u32 = undefined; + cmovznzU32(&x709, x703, x696, x679); + var x710: u32 = undefined; + cmovznzU32(&x710, x703, x698, x681); + var x711: u32 = undefined; + cmovznzU32(&x711, x703, x700, x683); + out1[0] = x704; + out1[1] = x705; + out1[2] = x706; + out1[3] = x707; + out1[4] = x708; + out1[5] = x709; + out1[6] = x710; + out1[7] = x711; +} + +/// The function add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn add(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + addcarryxU32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u32 = undefined; + var x4: u1 = undefined; + addcarryxU32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u32 = undefined; + var x6: u1 = undefined; + addcarryxU32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u32 = undefined; + var x8: u1 = undefined; + addcarryxU32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u32 = undefined; + var x10: u1 = undefined; + addcarryxU32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + var x11: u32 = undefined; + var x12: u1 = undefined; + addcarryxU32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + var x13: u32 = undefined; + var x14: u1 = undefined; + addcarryxU32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + var x15: u32 = undefined; + var x16: u1 = undefined; + addcarryxU32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + var x17: u32 = undefined; + var x18: u1 = undefined; + subborrowxU32(&x17, &x18, 0x0, x1, 0x5cf5d3ed); + var x19: u32 = undefined; + var x20: u1 = undefined; + subborrowxU32(&x19, &x20, x18, x3, 0x5812631a); + var x21: u32 = undefined; + var x22: u1 = undefined; + subborrowxU32(&x21, &x22, x20, x5, 0xa2f79cd6); + var x23: u32 = undefined; + var x24: u1 = undefined; + subborrowxU32(&x23, &x24, x22, x7, 0x14def9de); + var x25: u32 = undefined; + var x26: u1 = undefined; + subborrowxU32(&x25, &x26, x24, x9, cast(u32, 0x0)); + var x27: u32 = undefined; + var x28: u1 = undefined; + subborrowxU32(&x27, &x28, x26, x11, cast(u32, 0x0)); + var x29: u32 = undefined; + var x30: u1 = undefined; + subborrowxU32(&x29, &x30, x28, x13, cast(u32, 0x0)); + var x31: u32 = undefined; + var x32: u1 = undefined; + subborrowxU32(&x31, &x32, x30, x15, 0x10000000); + var x33: u32 = undefined; + var x34: u1 = undefined; + subborrowxU32(&x33, &x34, x32, cast(u32, x16), cast(u32, 0x0)); + var x35: u32 = undefined; + cmovznzU32(&x35, x34, x17, x1); + var x36: u32 = undefined; + cmovznzU32(&x36, x34, x19, x3); + var x37: u32 = undefined; + cmovznzU32(&x37, x34, x21, x5); + var x38: u32 = undefined; + cmovznzU32(&x38, x34, x23, x7); + var x39: u32 = undefined; + cmovznzU32(&x39, x34, x25, x9); + var x40: u32 = undefined; + cmovznzU32(&x40, x34, x27, x11); + var x41: u32 = undefined; + cmovznzU32(&x41, x34, x29, x13); + var x42: u32 = undefined; + cmovznzU32(&x42, x34, x31, x15); + out1[0] = x35; + out1[1] = x36; + out1[2] = x37; + out1[3] = x38; + out1[4] = x39; + out1[5] = x40; + out1[6] = x41; + out1[7] = x42; +} + +/// The function sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn sub(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + subborrowxU32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u32 = undefined; + var x4: u1 = undefined; + subborrowxU32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u32 = undefined; + var x6: u1 = undefined; + subborrowxU32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u32 = undefined; + var x8: u1 = undefined; + subborrowxU32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u32 = undefined; + var x10: u1 = undefined; + subborrowxU32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + var x11: u32 = undefined; + var x12: u1 = undefined; + subborrowxU32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + var x13: u32 = undefined; + var x14: u1 = undefined; + subborrowxU32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + var x15: u32 = undefined; + var x16: u1 = undefined; + subborrowxU32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + var x17: u32 = undefined; + cmovznzU32(&x17, x16, cast(u32, 0x0), 0xffffffff); + var x18: u32 = undefined; + var x19: u1 = undefined; + addcarryxU32(&x18, &x19, 0x0, x1, (x17 & 0x5cf5d3ed)); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, x3, (x17 & 0x5812631a)); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x5, (x17 & 0xa2f79cd6)); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x7, (x17 & 0x14def9de)); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, x9, cast(u32, 0x0)); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, x11, cast(u32, 0x0)); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, x13, cast(u32, 0x0)); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x15, (x17 & 0x10000000)); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/// The function opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +pub fn opp(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + subborrowxU32(&x1, &x2, 0x0, cast(u32, 0x0), (arg1[0])); + var x3: u32 = undefined; + var x4: u1 = undefined; + subborrowxU32(&x3, &x4, x2, cast(u32, 0x0), (arg1[1])); + var x5: u32 = undefined; + var x6: u1 = undefined; + subborrowxU32(&x5, &x6, x4, cast(u32, 0x0), (arg1[2])); + var x7: u32 = undefined; + var x8: u1 = undefined; + subborrowxU32(&x7, &x8, x6, cast(u32, 0x0), (arg1[3])); + var x9: u32 = undefined; + var x10: u1 = undefined; + subborrowxU32(&x9, &x10, x8, cast(u32, 0x0), (arg1[4])); + var x11: u32 = undefined; + var x12: u1 = undefined; + subborrowxU32(&x11, &x12, x10, cast(u32, 0x0), (arg1[5])); + var x13: u32 = undefined; + var x14: u1 = undefined; + subborrowxU32(&x13, &x14, x12, cast(u32, 0x0), (arg1[6])); + var x15: u32 = undefined; + var x16: u1 = undefined; + subborrowxU32(&x15, &x16, x14, cast(u32, 0x0), (arg1[7])); + var x17: u32 = undefined; + cmovznzU32(&x17, x16, cast(u32, 0x0), 0xffffffff); + var x18: u32 = undefined; + var x19: u1 = undefined; + addcarryxU32(&x18, &x19, 0x0, x1, (x17 & 0x5cf5d3ed)); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, x3, (x17 & 0x5812631a)); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x5, (x17 & 0xa2f79cd6)); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x7, (x17 & 0x14def9de)); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, x9, cast(u32, 0x0)); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, x11, cast(u32, 0x0)); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, x13, cast(u32, 0x0)); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x15, (x17 & 0x10000000)); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/// The function fromMontgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m +/// 0 ≤ eval out1 < m +/// +pub fn fromMontgomery(out1: *NonMontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[0]); + var x2: u32 = undefined; + var x3: u32 = undefined; + mulxU32(&x2, &x3, x1, 0x12547e1b); + var x4: u32 = undefined; + var x5: u32 = undefined; + mulxU32(&x4, &x5, x2, 0x10000000); + var x6: u32 = undefined; + var x7: u32 = undefined; + mulxU32(&x6, &x7, x2, 0x14def9de); + var x8: u32 = undefined; + var x9: u32 = undefined; + mulxU32(&x8, &x9, x2, 0xa2f79cd6); + var x10: u32 = undefined; + var x11: u32 = undefined; + mulxU32(&x10, &x11, x2, 0x5812631a); + var x12: u32 = undefined; + var x13: u32 = undefined; + mulxU32(&x12, &x13, x2, 0x5cf5d3ed); + var x14: u32 = undefined; + var x15: u1 = undefined; + addcarryxU32(&x14, &x15, 0x0, x13, x10); + var x16: u32 = undefined; + var x17: u1 = undefined; + addcarryxU32(&x16, &x17, x15, x11, x8); + var x18: u32 = undefined; + var x19: u1 = undefined; + addcarryxU32(&x18, &x19, x17, x9, x6); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, 0x0, x1, x12); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, cast(u32, 0x0), x14); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, cast(u32, 0x0), x16); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, cast(u32, 0x0), x18); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, 0x0, x22, (arg1[1])); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, x24, cast(u32, 0x0)); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x26, cast(u32, 0x0)); + var x34: u32 = undefined; + var x35: u32 = undefined; + mulxU32(&x34, &x35, x28, 0x12547e1b); + var x36: u32 = undefined; + var x37: u32 = undefined; + mulxU32(&x36, &x37, x34, 0x10000000); + var x38: u32 = undefined; + var x39: u32 = undefined; + mulxU32(&x38, &x39, x34, 0x14def9de); + var x40: u32 = undefined; + var x41: u32 = undefined; + mulxU32(&x40, &x41, x34, 0xa2f79cd6); + var x42: u32 = undefined; + var x43: u32 = undefined; + mulxU32(&x42, &x43, x34, 0x5812631a); + var x44: u32 = undefined; + var x45: u32 = undefined; + mulxU32(&x44, &x45, x34, 0x5cf5d3ed); + var x46: u32 = undefined; + var x47: u1 = undefined; + addcarryxU32(&x46, &x47, 0x0, x45, x42); + var x48: u32 = undefined; + var x49: u1 = undefined; + addcarryxU32(&x48, &x49, x47, x43, x40); + var x50: u32 = undefined; + var x51: u1 = undefined; + addcarryxU32(&x50, &x51, x49, x41, x38); + var x52: u32 = undefined; + var x53: u1 = undefined; + addcarryxU32(&x52, &x53, 0x0, x28, x44); + var x54: u32 = undefined; + var x55: u1 = undefined; + addcarryxU32(&x54, &x55, x53, x30, x46); + var x56: u32 = undefined; + var x57: u1 = undefined; + addcarryxU32(&x56, &x57, x55, x32, x48); + var x58: u32 = undefined; + var x59: u1 = undefined; + addcarryxU32(&x58, &x59, x57, (cast(u32, x33) + (cast(u32, x27) + (cast(u32, x19) + x7))), x50); + var x60: u32 = undefined; + var x61: u1 = undefined; + addcarryxU32(&x60, &x61, 0x0, x5, x36); + var x62: u32 = undefined; + var x63: u1 = undefined; + addcarryxU32(&x62, &x63, 0x0, x54, (arg1[2])); + var x64: u32 = undefined; + var x65: u1 = undefined; + addcarryxU32(&x64, &x65, x63, x56, cast(u32, 0x0)); + var x66: u32 = undefined; + var x67: u1 = undefined; + addcarryxU32(&x66, &x67, x65, x58, cast(u32, 0x0)); + var x68: u32 = undefined; + var x69: u32 = undefined; + mulxU32(&x68, &x69, x62, 0x12547e1b); + var x70: u32 = undefined; + var x71: u32 = undefined; + mulxU32(&x70, &x71, x68, 0x10000000); + var x72: u32 = undefined; + var x73: u32 = undefined; + mulxU32(&x72, &x73, x68, 0x14def9de); + var x74: u32 = undefined; + var x75: u32 = undefined; + mulxU32(&x74, &x75, x68, 0xa2f79cd6); + var x76: u32 = undefined; + var x77: u32 = undefined; + mulxU32(&x76, &x77, x68, 0x5812631a); + var x78: u32 = undefined; + var x79: u32 = undefined; + mulxU32(&x78, &x79, x68, 0x5cf5d3ed); + var x80: u32 = undefined; + var x81: u1 = undefined; + addcarryxU32(&x80, &x81, 0x0, x79, x76); + var x82: u32 = undefined; + var x83: u1 = undefined; + addcarryxU32(&x82, &x83, x81, x77, x74); + var x84: u32 = undefined; + var x85: u1 = undefined; + addcarryxU32(&x84, &x85, x83, x75, x72); + var x86: u32 = undefined; + var x87: u1 = undefined; + addcarryxU32(&x86, &x87, 0x0, x62, x78); + var x88: u32 = undefined; + var x89: u1 = undefined; + addcarryxU32(&x88, &x89, x87, x64, x80); + var x90: u32 = undefined; + var x91: u1 = undefined; + addcarryxU32(&x90, &x91, x89, x66, x82); + var x92: u32 = undefined; + var x93: u1 = undefined; + addcarryxU32(&x92, &x93, x91, (cast(u32, x67) + (cast(u32, x59) + (cast(u32, x51) + x39))), x84); + var x94: u32 = undefined; + var x95: u1 = undefined; + addcarryxU32(&x94, &x95, 0x0, (cast(u32, x61) + x37), x70); + var x96: u32 = undefined; + var x97: u1 = undefined; + addcarryxU32(&x96, &x97, 0x0, x88, (arg1[3])); + var x98: u32 = undefined; + var x99: u1 = undefined; + addcarryxU32(&x98, &x99, x97, x90, cast(u32, 0x0)); + var x100: u32 = undefined; + var x101: u1 = undefined; + addcarryxU32(&x100, &x101, x99, x92, cast(u32, 0x0)); + var x102: u32 = undefined; + var x103: u32 = undefined; + mulxU32(&x102, &x103, x96, 0x12547e1b); + var x104: u32 = undefined; + var x105: u32 = undefined; + mulxU32(&x104, &x105, x102, 0x10000000); + var x106: u32 = undefined; + var x107: u32 = undefined; + mulxU32(&x106, &x107, x102, 0x14def9de); + var x108: u32 = undefined; + var x109: u32 = undefined; + mulxU32(&x108, &x109, x102, 0xa2f79cd6); + var x110: u32 = undefined; + var x111: u32 = undefined; + mulxU32(&x110, &x111, x102, 0x5812631a); + var x112: u32 = undefined; + var x113: u32 = undefined; + mulxU32(&x112, &x113, x102, 0x5cf5d3ed); + var x114: u32 = undefined; + var x115: u1 = undefined; + addcarryxU32(&x114, &x115, 0x0, x113, x110); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, x115, x111, x108); + var x118: u32 = undefined; + var x119: u1 = undefined; + addcarryxU32(&x118, &x119, x117, x109, x106); + var x120: u32 = undefined; + var x121: u1 = undefined; + addcarryxU32(&x120, &x121, 0x0, x96, x112); + var x122: u32 = undefined; + var x123: u1 = undefined; + addcarryxU32(&x122, &x123, x121, x98, x114); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, x100, x116); + var x126: u32 = undefined; + var x127: u1 = undefined; + addcarryxU32(&x126, &x127, x125, (cast(u32, x101) + (cast(u32, x93) + (cast(u32, x85) + x73))), x118); + var x128: u32 = undefined; + var x129: u1 = undefined; + addcarryxU32(&x128, &x129, x127, x4, (cast(u32, x119) + x107)); + var x130: u32 = undefined; + var x131: u1 = undefined; + addcarryxU32(&x130, &x131, x129, x60, cast(u32, 0x0)); + var x132: u32 = undefined; + var x133: u1 = undefined; + addcarryxU32(&x132, &x133, x131, x94, cast(u32, 0x0)); + var x134: u32 = undefined; + var x135: u1 = undefined; + addcarryxU32(&x134, &x135, x133, (cast(u32, x95) + x71), x104); + var x136: u32 = undefined; + var x137: u1 = undefined; + addcarryxU32(&x136, &x137, 0x0, x122, (arg1[4])); + var x138: u32 = undefined; + var x139: u1 = undefined; + addcarryxU32(&x138, &x139, x137, x124, cast(u32, 0x0)); + var x140: u32 = undefined; + var x141: u1 = undefined; + addcarryxU32(&x140, &x141, x139, x126, cast(u32, 0x0)); + var x142: u32 = undefined; + var x143: u1 = undefined; + addcarryxU32(&x142, &x143, x141, x128, cast(u32, 0x0)); + var x144: u32 = undefined; + var x145: u1 = undefined; + addcarryxU32(&x144, &x145, x143, x130, cast(u32, 0x0)); + var x146: u32 = undefined; + var x147: u1 = undefined; + addcarryxU32(&x146, &x147, x145, x132, cast(u32, 0x0)); + var x148: u32 = undefined; + var x149: u1 = undefined; + addcarryxU32(&x148, &x149, x147, x134, cast(u32, 0x0)); + var x150: u32 = undefined; + var x151: u32 = undefined; + mulxU32(&x150, &x151, x136, 0x12547e1b); + var x152: u32 = undefined; + var x153: u32 = undefined; + mulxU32(&x152, &x153, x150, 0x10000000); + var x154: u32 = undefined; + var x155: u32 = undefined; + mulxU32(&x154, &x155, x150, 0x14def9de); + var x156: u32 = undefined; + var x157: u32 = undefined; + mulxU32(&x156, &x157, x150, 0xa2f79cd6); + var x158: u32 = undefined; + var x159: u32 = undefined; + mulxU32(&x158, &x159, x150, 0x5812631a); + var x160: u32 = undefined; + var x161: u32 = undefined; + mulxU32(&x160, &x161, x150, 0x5cf5d3ed); + var x162: u32 = undefined; + var x163: u1 = undefined; + addcarryxU32(&x162, &x163, 0x0, x161, x158); + var x164: u32 = undefined; + var x165: u1 = undefined; + addcarryxU32(&x164, &x165, x163, x159, x156); + var x166: u32 = undefined; + var x167: u1 = undefined; + addcarryxU32(&x166, &x167, x165, x157, x154); + var x168: u32 = undefined; + var x169: u1 = undefined; + addcarryxU32(&x168, &x169, 0x0, x136, x160); + var x170: u32 = undefined; + var x171: u1 = undefined; + addcarryxU32(&x170, &x171, x169, x138, x162); + var x172: u32 = undefined; + var x173: u1 = undefined; + addcarryxU32(&x172, &x173, x171, x140, x164); + var x174: u32 = undefined; + var x175: u1 = undefined; + addcarryxU32(&x174, &x175, x173, x142, x166); + var x176: u32 = undefined; + var x177: u1 = undefined; + addcarryxU32(&x176, &x177, x175, x144, (cast(u32, x167) + x155)); + var x178: u32 = undefined; + var x179: u1 = undefined; + addcarryxU32(&x178, &x179, x177, x146, cast(u32, 0x0)); + var x180: u32 = undefined; + var x181: u1 = undefined; + addcarryxU32(&x180, &x181, x179, x148, cast(u32, 0x0)); + var x182: u32 = undefined; + var x183: u1 = undefined; + addcarryxU32(&x182, &x183, x181, (cast(u32, x149) + (cast(u32, x135) + x105)), x152); + var x184: u32 = undefined; + var x185: u1 = undefined; + addcarryxU32(&x184, &x185, 0x0, x170, (arg1[5])); + var x186: u32 = undefined; + var x187: u1 = undefined; + addcarryxU32(&x186, &x187, x185, x172, cast(u32, 0x0)); + var x188: u32 = undefined; + var x189: u1 = undefined; + addcarryxU32(&x188, &x189, x187, x174, cast(u32, 0x0)); + var x190: u32 = undefined; + var x191: u1 = undefined; + addcarryxU32(&x190, &x191, x189, x176, cast(u32, 0x0)); + var x192: u32 = undefined; + var x193: u1 = undefined; + addcarryxU32(&x192, &x193, x191, x178, cast(u32, 0x0)); + var x194: u32 = undefined; + var x195: u1 = undefined; + addcarryxU32(&x194, &x195, x193, x180, cast(u32, 0x0)); + var x196: u32 = undefined; + var x197: u1 = undefined; + addcarryxU32(&x196, &x197, x195, x182, cast(u32, 0x0)); + var x198: u32 = undefined; + var x199: u32 = undefined; + mulxU32(&x198, &x199, x184, 0x12547e1b); + var x200: u32 = undefined; + var x201: u32 = undefined; + mulxU32(&x200, &x201, x198, 0x10000000); + var x202: u32 = undefined; + var x203: u32 = undefined; + mulxU32(&x202, &x203, x198, 0x14def9de); + var x204: u32 = undefined; + var x205: u32 = undefined; + mulxU32(&x204, &x205, x198, 0xa2f79cd6); + var x206: u32 = undefined; + var x207: u32 = undefined; + mulxU32(&x206, &x207, x198, 0x5812631a); + var x208: u32 = undefined; + var x209: u32 = undefined; + mulxU32(&x208, &x209, x198, 0x5cf5d3ed); + var x210: u32 = undefined; + var x211: u1 = undefined; + addcarryxU32(&x210, &x211, 0x0, x209, x206); + var x212: u32 = undefined; + var x213: u1 = undefined; + addcarryxU32(&x212, &x213, x211, x207, x204); + var x214: u32 = undefined; + var x215: u1 = undefined; + addcarryxU32(&x214, &x215, x213, x205, x202); + var x216: u32 = undefined; + var x217: u1 = undefined; + addcarryxU32(&x216, &x217, 0x0, x184, x208); + var x218: u32 = undefined; + var x219: u1 = undefined; + addcarryxU32(&x218, &x219, x217, x186, x210); + var x220: u32 = undefined; + var x221: u1 = undefined; + addcarryxU32(&x220, &x221, x219, x188, x212); + var x222: u32 = undefined; + var x223: u1 = undefined; + addcarryxU32(&x222, &x223, x221, x190, x214); + var x224: u32 = undefined; + var x225: u1 = undefined; + addcarryxU32(&x224, &x225, x223, x192, (cast(u32, x215) + x203)); + var x226: u32 = undefined; + var x227: u1 = undefined; + addcarryxU32(&x226, &x227, x225, x194, cast(u32, 0x0)); + var x228: u32 = undefined; + var x229: u1 = undefined; + addcarryxU32(&x228, &x229, x227, x196, cast(u32, 0x0)); + var x230: u32 = undefined; + var x231: u1 = undefined; + addcarryxU32(&x230, &x231, x229, (cast(u32, x197) + (cast(u32, x183) + x153)), x200); + var x232: u32 = undefined; + var x233: u1 = undefined; + addcarryxU32(&x232, &x233, 0x0, x218, (arg1[6])); + var x234: u32 = undefined; + var x235: u1 = undefined; + addcarryxU32(&x234, &x235, x233, x220, cast(u32, 0x0)); + var x236: u32 = undefined; + var x237: u1 = undefined; + addcarryxU32(&x236, &x237, x235, x222, cast(u32, 0x0)); + var x238: u32 = undefined; + var x239: u1 = undefined; + addcarryxU32(&x238, &x239, x237, x224, cast(u32, 0x0)); + var x240: u32 = undefined; + var x241: u1 = undefined; + addcarryxU32(&x240, &x241, x239, x226, cast(u32, 0x0)); + var x242: u32 = undefined; + var x243: u1 = undefined; + addcarryxU32(&x242, &x243, x241, x228, cast(u32, 0x0)); + var x244: u32 = undefined; + var x245: u1 = undefined; + addcarryxU32(&x244, &x245, x243, x230, cast(u32, 0x0)); + var x246: u32 = undefined; + var x247: u32 = undefined; + mulxU32(&x246, &x247, x232, 0x12547e1b); + var x248: u32 = undefined; + var x249: u32 = undefined; + mulxU32(&x248, &x249, x246, 0x10000000); + var x250: u32 = undefined; + var x251: u32 = undefined; + mulxU32(&x250, &x251, x246, 0x14def9de); + var x252: u32 = undefined; + var x253: u32 = undefined; + mulxU32(&x252, &x253, x246, 0xa2f79cd6); + var x254: u32 = undefined; + var x255: u32 = undefined; + mulxU32(&x254, &x255, x246, 0x5812631a); + var x256: u32 = undefined; + var x257: u32 = undefined; + mulxU32(&x256, &x257, x246, 0x5cf5d3ed); + var x258: u32 = undefined; + var x259: u1 = undefined; + addcarryxU32(&x258, &x259, 0x0, x257, x254); + var x260: u32 = undefined; + var x261: u1 = undefined; + addcarryxU32(&x260, &x261, x259, x255, x252); + var x262: u32 = undefined; + var x263: u1 = undefined; + addcarryxU32(&x262, &x263, x261, x253, x250); + var x264: u32 = undefined; + var x265: u1 = undefined; + addcarryxU32(&x264, &x265, 0x0, x232, x256); + var x266: u32 = undefined; + var x267: u1 = undefined; + addcarryxU32(&x266, &x267, x265, x234, x258); + var x268: u32 = undefined; + var x269: u1 = undefined; + addcarryxU32(&x268, &x269, x267, x236, x260); + var x270: u32 = undefined; + var x271: u1 = undefined; + addcarryxU32(&x270, &x271, x269, x238, x262); + var x272: u32 = undefined; + var x273: u1 = undefined; + addcarryxU32(&x272, &x273, x271, x240, (cast(u32, x263) + x251)); + var x274: u32 = undefined; + var x275: u1 = undefined; + addcarryxU32(&x274, &x275, x273, x242, cast(u32, 0x0)); + var x276: u32 = undefined; + var x277: u1 = undefined; + addcarryxU32(&x276, &x277, x275, x244, cast(u32, 0x0)); + var x278: u32 = undefined; + var x279: u1 = undefined; + addcarryxU32(&x278, &x279, x277, (cast(u32, x245) + (cast(u32, x231) + x201)), x248); + var x280: u32 = undefined; + var x281: u1 = undefined; + addcarryxU32(&x280, &x281, 0x0, x266, (arg1[7])); + var x282: u32 = undefined; + var x283: u1 = undefined; + addcarryxU32(&x282, &x283, x281, x268, cast(u32, 0x0)); + var x284: u32 = undefined; + var x285: u1 = undefined; + addcarryxU32(&x284, &x285, x283, x270, cast(u32, 0x0)); + var x286: u32 = undefined; + var x287: u1 = undefined; + addcarryxU32(&x286, &x287, x285, x272, cast(u32, 0x0)); + var x288: u32 = undefined; + var x289: u1 = undefined; + addcarryxU32(&x288, &x289, x287, x274, cast(u32, 0x0)); + var x290: u32 = undefined; + var x291: u1 = undefined; + addcarryxU32(&x290, &x291, x289, x276, cast(u32, 0x0)); + var x292: u32 = undefined; + var x293: u1 = undefined; + addcarryxU32(&x292, &x293, x291, x278, cast(u32, 0x0)); + var x294: u32 = undefined; + var x295: u32 = undefined; + mulxU32(&x294, &x295, x280, 0x12547e1b); + var x296: u32 = undefined; + var x297: u32 = undefined; + mulxU32(&x296, &x297, x294, 0x10000000); + var x298: u32 = undefined; + var x299: u32 = undefined; + mulxU32(&x298, &x299, x294, 0x14def9de); + var x300: u32 = undefined; + var x301: u32 = undefined; + mulxU32(&x300, &x301, x294, 0xa2f79cd6); + var x302: u32 = undefined; + var x303: u32 = undefined; + mulxU32(&x302, &x303, x294, 0x5812631a); + var x304: u32 = undefined; + var x305: u32 = undefined; + mulxU32(&x304, &x305, x294, 0x5cf5d3ed); + var x306: u32 = undefined; + var x307: u1 = undefined; + addcarryxU32(&x306, &x307, 0x0, x305, x302); + var x308: u32 = undefined; + var x309: u1 = undefined; + addcarryxU32(&x308, &x309, x307, x303, x300); + var x310: u32 = undefined; + var x311: u1 = undefined; + addcarryxU32(&x310, &x311, x309, x301, x298); + var x312: u32 = undefined; + var x313: u1 = undefined; + addcarryxU32(&x312, &x313, 0x0, x280, x304); + var x314: u32 = undefined; + var x315: u1 = undefined; + addcarryxU32(&x314, &x315, x313, x282, x306); + var x316: u32 = undefined; + var x317: u1 = undefined; + addcarryxU32(&x316, &x317, x315, x284, x308); + var x318: u32 = undefined; + var x319: u1 = undefined; + addcarryxU32(&x318, &x319, x317, x286, x310); + var x320: u32 = undefined; + var x321: u1 = undefined; + addcarryxU32(&x320, &x321, x319, x288, (cast(u32, x311) + x299)); + var x322: u32 = undefined; + var x323: u1 = undefined; + addcarryxU32(&x322, &x323, x321, x290, cast(u32, 0x0)); + var x324: u32 = undefined; + var x325: u1 = undefined; + addcarryxU32(&x324, &x325, x323, x292, cast(u32, 0x0)); + var x326: u32 = undefined; + var x327: u1 = undefined; + addcarryxU32(&x326, &x327, x325, (cast(u32, x293) + (cast(u32, x279) + x249)), x296); + const x328 = (cast(u32, x327) + x297); + var x329: u32 = undefined; + var x330: u1 = undefined; + subborrowxU32(&x329, &x330, 0x0, x314, 0x5cf5d3ed); + var x331: u32 = undefined; + var x332: u1 = undefined; + subborrowxU32(&x331, &x332, x330, x316, 0x5812631a); + var x333: u32 = undefined; + var x334: u1 = undefined; + subborrowxU32(&x333, &x334, x332, x318, 0xa2f79cd6); + var x335: u32 = undefined; + var x336: u1 = undefined; + subborrowxU32(&x335, &x336, x334, x320, 0x14def9de); + var x337: u32 = undefined; + var x338: u1 = undefined; + subborrowxU32(&x337, &x338, x336, x322, cast(u32, 0x0)); + var x339: u32 = undefined; + var x340: u1 = undefined; + subborrowxU32(&x339, &x340, x338, x324, cast(u32, 0x0)); + var x341: u32 = undefined; + var x342: u1 = undefined; + subborrowxU32(&x341, &x342, x340, x326, cast(u32, 0x0)); + var x343: u32 = undefined; + var x344: u1 = undefined; + subborrowxU32(&x343, &x344, x342, x328, 0x10000000); + var x345: u32 = undefined; + var x346: u1 = undefined; + subborrowxU32(&x345, &x346, x344, cast(u32, 0x0), cast(u32, 0x0)); + var x347: u32 = undefined; + cmovznzU32(&x347, x346, x329, x314); + var x348: u32 = undefined; + cmovznzU32(&x348, x346, x331, x316); + var x349: u32 = undefined; + cmovznzU32(&x349, x346, x333, x318); + var x350: u32 = undefined; + cmovznzU32(&x350, x346, x335, x320); + var x351: u32 = undefined; + cmovznzU32(&x351, x346, x337, x322); + var x352: u32 = undefined; + cmovznzU32(&x352, x346, x339, x324); + var x353: u32 = undefined; + cmovznzU32(&x353, x346, x341, x326); + var x354: u32 = undefined; + cmovznzU32(&x354, x346, x343, x328); + out1[0] = x347; + out1[1] = x348; + out1[2] = x349; + out1[3] = x350; + out1[4] = x351; + out1[5] = x352; + out1[6] = x353; + out1[7] = x354; +} + +/// The function toMontgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn toMontgomery(out1: *MontgomeryDomainFieldElement, arg1: NonMontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[6]); + const x7 = (arg1[7]); + const x8 = (arg1[0]); + var x9: u32 = undefined; + var x10: u32 = undefined; + mulxU32(&x9, &x10, x8, 0x399411b); + var x11: u32 = undefined; + var x12: u32 = undefined; + mulxU32(&x11, &x12, x8, 0x7c309a3d); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x8, 0xceec73d2); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x8, 0x17f5be65); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x8, 0xd00e1ba7); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x8, 0x68859347); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x8, 0xa40611e3); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x8, 0x449c0f01); + var x25: u32 = undefined; + var x26: u1 = undefined; + addcarryxU32(&x25, &x26, 0x0, x24, x21); + var x27: u32 = undefined; + var x28: u1 = undefined; + addcarryxU32(&x27, &x28, x26, x22, x19); + var x29: u32 = undefined; + var x30: u1 = undefined; + addcarryxU32(&x29, &x30, x28, x20, x17); + var x31: u32 = undefined; + var x32: u1 = undefined; + addcarryxU32(&x31, &x32, x30, x18, x15); + var x33: u32 = undefined; + var x34: u1 = undefined; + addcarryxU32(&x33, &x34, x32, x16, x13); + var x35: u32 = undefined; + var x36: u1 = undefined; + addcarryxU32(&x35, &x36, x34, x14, x11); + var x37: u32 = undefined; + var x38: u1 = undefined; + addcarryxU32(&x37, &x38, x36, x12, x9); + var x39: u32 = undefined; + var x40: u32 = undefined; + mulxU32(&x39, &x40, x23, 0x12547e1b); + var x41: u32 = undefined; + var x42: u32 = undefined; + mulxU32(&x41, &x42, x39, 0x10000000); + var x43: u32 = undefined; + var x44: u32 = undefined; + mulxU32(&x43, &x44, x39, 0x14def9de); + var x45: u32 = undefined; + var x46: u32 = undefined; + mulxU32(&x45, &x46, x39, 0xa2f79cd6); + var x47: u32 = undefined; + var x48: u32 = undefined; + mulxU32(&x47, &x48, x39, 0x5812631a); + var x49: u32 = undefined; + var x50: u32 = undefined; + mulxU32(&x49, &x50, x39, 0x5cf5d3ed); + var x51: u32 = undefined; + var x52: u1 = undefined; + addcarryxU32(&x51, &x52, 0x0, x50, x47); + var x53: u32 = undefined; + var x54: u1 = undefined; + addcarryxU32(&x53, &x54, x52, x48, x45); + var x55: u32 = undefined; + var x56: u1 = undefined; + addcarryxU32(&x55, &x56, x54, x46, x43); + var x57: u32 = undefined; + var x58: u1 = undefined; + addcarryxU32(&x57, &x58, 0x0, x23, x49); + var x59: u32 = undefined; + var x60: u1 = undefined; + addcarryxU32(&x59, &x60, x58, x25, x51); + var x61: u32 = undefined; + var x62: u1 = undefined; + addcarryxU32(&x61, &x62, x60, x27, x53); + var x63: u32 = undefined; + var x64: u1 = undefined; + addcarryxU32(&x63, &x64, x62, x29, x55); + var x65: u32 = undefined; + var x66: u1 = undefined; + addcarryxU32(&x65, &x66, x64, x31, (cast(u32, x56) + x44)); + var x67: u32 = undefined; + var x68: u1 = undefined; + addcarryxU32(&x67, &x68, x66, x33, cast(u32, 0x0)); + var x69: u32 = undefined; + var x70: u1 = undefined; + addcarryxU32(&x69, &x70, x68, x35, cast(u32, 0x0)); + var x71: u32 = undefined; + var x72: u1 = undefined; + addcarryxU32(&x71, &x72, x70, x37, x41); + var x73: u32 = undefined; + var x74: u32 = undefined; + mulxU32(&x73, &x74, x1, 0x399411b); + var x75: u32 = undefined; + var x76: u32 = undefined; + mulxU32(&x75, &x76, x1, 0x7c309a3d); + var x77: u32 = undefined; + var x78: u32 = undefined; + mulxU32(&x77, &x78, x1, 0xceec73d2); + var x79: u32 = undefined; + var x80: u32 = undefined; + mulxU32(&x79, &x80, x1, 0x17f5be65); + var x81: u32 = undefined; + var x82: u32 = undefined; + mulxU32(&x81, &x82, x1, 0xd00e1ba7); + var x83: u32 = undefined; + var x84: u32 = undefined; + mulxU32(&x83, &x84, x1, 0x68859347); + var x85: u32 = undefined; + var x86: u32 = undefined; + mulxU32(&x85, &x86, x1, 0xa40611e3); + var x87: u32 = undefined; + var x88: u32 = undefined; + mulxU32(&x87, &x88, x1, 0x449c0f01); + var x89: u32 = undefined; + var x90: u1 = undefined; + addcarryxU32(&x89, &x90, 0x0, x88, x85); + var x91: u32 = undefined; + var x92: u1 = undefined; + addcarryxU32(&x91, &x92, x90, x86, x83); + var x93: u32 = undefined; + var x94: u1 = undefined; + addcarryxU32(&x93, &x94, x92, x84, x81); + var x95: u32 = undefined; + var x96: u1 = undefined; + addcarryxU32(&x95, &x96, x94, x82, x79); + var x97: u32 = undefined; + var x98: u1 = undefined; + addcarryxU32(&x97, &x98, x96, x80, x77); + var x99: u32 = undefined; + var x100: u1 = undefined; + addcarryxU32(&x99, &x100, x98, x78, x75); + var x101: u32 = undefined; + var x102: u1 = undefined; + addcarryxU32(&x101, &x102, x100, x76, x73); + var x103: u32 = undefined; + var x104: u1 = undefined; + addcarryxU32(&x103, &x104, 0x0, x59, x87); + var x105: u32 = undefined; + var x106: u1 = undefined; + addcarryxU32(&x105, &x106, x104, x61, x89); + var x107: u32 = undefined; + var x108: u1 = undefined; + addcarryxU32(&x107, &x108, x106, x63, x91); + var x109: u32 = undefined; + var x110: u1 = undefined; + addcarryxU32(&x109, &x110, x108, x65, x93); + var x111: u32 = undefined; + var x112: u1 = undefined; + addcarryxU32(&x111, &x112, x110, x67, x95); + var x113: u32 = undefined; + var x114: u1 = undefined; + addcarryxU32(&x113, &x114, x112, x69, x97); + var x115: u32 = undefined; + var x116: u1 = undefined; + addcarryxU32(&x115, &x116, x114, x71, x99); + var x117: u32 = undefined; + var x118: u1 = undefined; + addcarryxU32(&x117, &x118, x116, ((cast(u32, x72) + (cast(u32, x38) + x10)) + x42), x101); + var x119: u32 = undefined; + var x120: u32 = undefined; + mulxU32(&x119, &x120, x103, 0x12547e1b); + var x121: u32 = undefined; + var x122: u32 = undefined; + mulxU32(&x121, &x122, x119, 0x10000000); + var x123: u32 = undefined; + var x124: u32 = undefined; + mulxU32(&x123, &x124, x119, 0x14def9de); + var x125: u32 = undefined; + var x126: u32 = undefined; + mulxU32(&x125, &x126, x119, 0xa2f79cd6); + var x127: u32 = undefined; + var x128: u32 = undefined; + mulxU32(&x127, &x128, x119, 0x5812631a); + var x129: u32 = undefined; + var x130: u32 = undefined; + mulxU32(&x129, &x130, x119, 0x5cf5d3ed); + var x131: u32 = undefined; + var x132: u1 = undefined; + addcarryxU32(&x131, &x132, 0x0, x130, x127); + var x133: u32 = undefined; + var x134: u1 = undefined; + addcarryxU32(&x133, &x134, x132, x128, x125); + var x135: u32 = undefined; + var x136: u1 = undefined; + addcarryxU32(&x135, &x136, x134, x126, x123); + var x137: u32 = undefined; + var x138: u1 = undefined; + addcarryxU32(&x137, &x138, 0x0, x103, x129); + var x139: u32 = undefined; + var x140: u1 = undefined; + addcarryxU32(&x139, &x140, x138, x105, x131); + var x141: u32 = undefined; + var x142: u1 = undefined; + addcarryxU32(&x141, &x142, x140, x107, x133); + var x143: u32 = undefined; + var x144: u1 = undefined; + addcarryxU32(&x143, &x144, x142, x109, x135); + var x145: u32 = undefined; + var x146: u1 = undefined; + addcarryxU32(&x145, &x146, x144, x111, (cast(u32, x136) + x124)); + var x147: u32 = undefined; + var x148: u1 = undefined; + addcarryxU32(&x147, &x148, x146, x113, cast(u32, 0x0)); + var x149: u32 = undefined; + var x150: u1 = undefined; + addcarryxU32(&x149, &x150, x148, x115, cast(u32, 0x0)); + var x151: u32 = undefined; + var x152: u1 = undefined; + addcarryxU32(&x151, &x152, x150, x117, x121); + var x153: u32 = undefined; + var x154: u32 = undefined; + mulxU32(&x153, &x154, x2, 0x399411b); + var x155: u32 = undefined; + var x156: u32 = undefined; + mulxU32(&x155, &x156, x2, 0x7c309a3d); + var x157: u32 = undefined; + var x158: u32 = undefined; + mulxU32(&x157, &x158, x2, 0xceec73d2); + var x159: u32 = undefined; + var x160: u32 = undefined; + mulxU32(&x159, &x160, x2, 0x17f5be65); + var x161: u32 = undefined; + var x162: u32 = undefined; + mulxU32(&x161, &x162, x2, 0xd00e1ba7); + var x163: u32 = undefined; + var x164: u32 = undefined; + mulxU32(&x163, &x164, x2, 0x68859347); + var x165: u32 = undefined; + var x166: u32 = undefined; + mulxU32(&x165, &x166, x2, 0xa40611e3); + var x167: u32 = undefined; + var x168: u32 = undefined; + mulxU32(&x167, &x168, x2, 0x449c0f01); + var x169: u32 = undefined; + var x170: u1 = undefined; + addcarryxU32(&x169, &x170, 0x0, x168, x165); + var x171: u32 = undefined; + var x172: u1 = undefined; + addcarryxU32(&x171, &x172, x170, x166, x163); + var x173: u32 = undefined; + var x174: u1 = undefined; + addcarryxU32(&x173, &x174, x172, x164, x161); + var x175: u32 = undefined; + var x176: u1 = undefined; + addcarryxU32(&x175, &x176, x174, x162, x159); + var x177: u32 = undefined; + var x178: u1 = undefined; + addcarryxU32(&x177, &x178, x176, x160, x157); + var x179: u32 = undefined; + var x180: u1 = undefined; + addcarryxU32(&x179, &x180, x178, x158, x155); + var x181: u32 = undefined; + var x182: u1 = undefined; + addcarryxU32(&x181, &x182, x180, x156, x153); + var x183: u32 = undefined; + var x184: u1 = undefined; + addcarryxU32(&x183, &x184, 0x0, x139, x167); + var x185: u32 = undefined; + var x186: u1 = undefined; + addcarryxU32(&x185, &x186, x184, x141, x169); + var x187: u32 = undefined; + var x188: u1 = undefined; + addcarryxU32(&x187, &x188, x186, x143, x171); + var x189: u32 = undefined; + var x190: u1 = undefined; + addcarryxU32(&x189, &x190, x188, x145, x173); + var x191: u32 = undefined; + var x192: u1 = undefined; + addcarryxU32(&x191, &x192, x190, x147, x175); + var x193: u32 = undefined; + var x194: u1 = undefined; + addcarryxU32(&x193, &x194, x192, x149, x177); + var x195: u32 = undefined; + var x196: u1 = undefined; + addcarryxU32(&x195, &x196, x194, x151, x179); + var x197: u32 = undefined; + var x198: u1 = undefined; + addcarryxU32(&x197, &x198, x196, ((cast(u32, x152) + (cast(u32, x118) + (cast(u32, x102) + x74))) + x122), x181); + var x199: u32 = undefined; + var x200: u32 = undefined; + mulxU32(&x199, &x200, x183, 0x12547e1b); + var x201: u32 = undefined; + var x202: u32 = undefined; + mulxU32(&x201, &x202, x199, 0x10000000); + var x203: u32 = undefined; + var x204: u32 = undefined; + mulxU32(&x203, &x204, x199, 0x14def9de); + var x205: u32 = undefined; + var x206: u32 = undefined; + mulxU32(&x205, &x206, x199, 0xa2f79cd6); + var x207: u32 = undefined; + var x208: u32 = undefined; + mulxU32(&x207, &x208, x199, 0x5812631a); + var x209: u32 = undefined; + var x210: u32 = undefined; + mulxU32(&x209, &x210, x199, 0x5cf5d3ed); + var x211: u32 = undefined; + var x212: u1 = undefined; + addcarryxU32(&x211, &x212, 0x0, x210, x207); + var x213: u32 = undefined; + var x214: u1 = undefined; + addcarryxU32(&x213, &x214, x212, x208, x205); + var x215: u32 = undefined; + var x216: u1 = undefined; + addcarryxU32(&x215, &x216, x214, x206, x203); + var x217: u32 = undefined; + var x218: u1 = undefined; + addcarryxU32(&x217, &x218, 0x0, x183, x209); + var x219: u32 = undefined; + var x220: u1 = undefined; + addcarryxU32(&x219, &x220, x218, x185, x211); + var x221: u32 = undefined; + var x222: u1 = undefined; + addcarryxU32(&x221, &x222, x220, x187, x213); + var x223: u32 = undefined; + var x224: u1 = undefined; + addcarryxU32(&x223, &x224, x222, x189, x215); + var x225: u32 = undefined; + var x226: u1 = undefined; + addcarryxU32(&x225, &x226, x224, x191, (cast(u32, x216) + x204)); + var x227: u32 = undefined; + var x228: u1 = undefined; + addcarryxU32(&x227, &x228, x226, x193, cast(u32, 0x0)); + var x229: u32 = undefined; + var x230: u1 = undefined; + addcarryxU32(&x229, &x230, x228, x195, cast(u32, 0x0)); + var x231: u32 = undefined; + var x232: u1 = undefined; + addcarryxU32(&x231, &x232, x230, x197, x201); + var x233: u32 = undefined; + var x234: u32 = undefined; + mulxU32(&x233, &x234, x3, 0x399411b); + var x235: u32 = undefined; + var x236: u32 = undefined; + mulxU32(&x235, &x236, x3, 0x7c309a3d); + var x237: u32 = undefined; + var x238: u32 = undefined; + mulxU32(&x237, &x238, x3, 0xceec73d2); + var x239: u32 = undefined; + var x240: u32 = undefined; + mulxU32(&x239, &x240, x3, 0x17f5be65); + var x241: u32 = undefined; + var x242: u32 = undefined; + mulxU32(&x241, &x242, x3, 0xd00e1ba7); + var x243: u32 = undefined; + var x244: u32 = undefined; + mulxU32(&x243, &x244, x3, 0x68859347); + var x245: u32 = undefined; + var x246: u32 = undefined; + mulxU32(&x245, &x246, x3, 0xa40611e3); + var x247: u32 = undefined; + var x248: u32 = undefined; + mulxU32(&x247, &x248, x3, 0x449c0f01); + var x249: u32 = undefined; + var x250: u1 = undefined; + addcarryxU32(&x249, &x250, 0x0, x248, x245); + var x251: u32 = undefined; + var x252: u1 = undefined; + addcarryxU32(&x251, &x252, x250, x246, x243); + var x253: u32 = undefined; + var x254: u1 = undefined; + addcarryxU32(&x253, &x254, x252, x244, x241); + var x255: u32 = undefined; + var x256: u1 = undefined; + addcarryxU32(&x255, &x256, x254, x242, x239); + var x257: u32 = undefined; + var x258: u1 = undefined; + addcarryxU32(&x257, &x258, x256, x240, x237); + var x259: u32 = undefined; + var x260: u1 = undefined; + addcarryxU32(&x259, &x260, x258, x238, x235); + var x261: u32 = undefined; + var x262: u1 = undefined; + addcarryxU32(&x261, &x262, x260, x236, x233); + var x263: u32 = undefined; + var x264: u1 = undefined; + addcarryxU32(&x263, &x264, 0x0, x219, x247); + var x265: u32 = undefined; + var x266: u1 = undefined; + addcarryxU32(&x265, &x266, x264, x221, x249); + var x267: u32 = undefined; + var x268: u1 = undefined; + addcarryxU32(&x267, &x268, x266, x223, x251); + var x269: u32 = undefined; + var x270: u1 = undefined; + addcarryxU32(&x269, &x270, x268, x225, x253); + var x271: u32 = undefined; + var x272: u1 = undefined; + addcarryxU32(&x271, &x272, x270, x227, x255); + var x273: u32 = undefined; + var x274: u1 = undefined; + addcarryxU32(&x273, &x274, x272, x229, x257); + var x275: u32 = undefined; + var x276: u1 = undefined; + addcarryxU32(&x275, &x276, x274, x231, x259); + var x277: u32 = undefined; + var x278: u1 = undefined; + addcarryxU32(&x277, &x278, x276, ((cast(u32, x232) + (cast(u32, x198) + (cast(u32, x182) + x154))) + x202), x261); + var x279: u32 = undefined; + var x280: u32 = undefined; + mulxU32(&x279, &x280, x263, 0x12547e1b); + var x281: u32 = undefined; + var x282: u32 = undefined; + mulxU32(&x281, &x282, x279, 0x10000000); + var x283: u32 = undefined; + var x284: u32 = undefined; + mulxU32(&x283, &x284, x279, 0x14def9de); + var x285: u32 = undefined; + var x286: u32 = undefined; + mulxU32(&x285, &x286, x279, 0xa2f79cd6); + var x287: u32 = undefined; + var x288: u32 = undefined; + mulxU32(&x287, &x288, x279, 0x5812631a); + var x289: u32 = undefined; + var x290: u32 = undefined; + mulxU32(&x289, &x290, x279, 0x5cf5d3ed); + var x291: u32 = undefined; + var x292: u1 = undefined; + addcarryxU32(&x291, &x292, 0x0, x290, x287); + var x293: u32 = undefined; + var x294: u1 = undefined; + addcarryxU32(&x293, &x294, x292, x288, x285); + var x295: u32 = undefined; + var x296: u1 = undefined; + addcarryxU32(&x295, &x296, x294, x286, x283); + var x297: u32 = undefined; + var x298: u1 = undefined; + addcarryxU32(&x297, &x298, 0x0, x263, x289); + var x299: u32 = undefined; + var x300: u1 = undefined; + addcarryxU32(&x299, &x300, x298, x265, x291); + var x301: u32 = undefined; + var x302: u1 = undefined; + addcarryxU32(&x301, &x302, x300, x267, x293); + var x303: u32 = undefined; + var x304: u1 = undefined; + addcarryxU32(&x303, &x304, x302, x269, x295); + var x305: u32 = undefined; + var x306: u1 = undefined; + addcarryxU32(&x305, &x306, x304, x271, (cast(u32, x296) + x284)); + var x307: u32 = undefined; + var x308: u1 = undefined; + addcarryxU32(&x307, &x308, x306, x273, cast(u32, 0x0)); + var x309: u32 = undefined; + var x310: u1 = undefined; + addcarryxU32(&x309, &x310, x308, x275, cast(u32, 0x0)); + var x311: u32 = undefined; + var x312: u1 = undefined; + addcarryxU32(&x311, &x312, x310, x277, x281); + var x313: u32 = undefined; + var x314: u32 = undefined; + mulxU32(&x313, &x314, x4, 0x399411b); + var x315: u32 = undefined; + var x316: u32 = undefined; + mulxU32(&x315, &x316, x4, 0x7c309a3d); + var x317: u32 = undefined; + var x318: u32 = undefined; + mulxU32(&x317, &x318, x4, 0xceec73d2); + var x319: u32 = undefined; + var x320: u32 = undefined; + mulxU32(&x319, &x320, x4, 0x17f5be65); + var x321: u32 = undefined; + var x322: u32 = undefined; + mulxU32(&x321, &x322, x4, 0xd00e1ba7); + var x323: u32 = undefined; + var x324: u32 = undefined; + mulxU32(&x323, &x324, x4, 0x68859347); + var x325: u32 = undefined; + var x326: u32 = undefined; + mulxU32(&x325, &x326, x4, 0xa40611e3); + var x327: u32 = undefined; + var x328: u32 = undefined; + mulxU32(&x327, &x328, x4, 0x449c0f01); + var x329: u32 = undefined; + var x330: u1 = undefined; + addcarryxU32(&x329, &x330, 0x0, x328, x325); + var x331: u32 = undefined; + var x332: u1 = undefined; + addcarryxU32(&x331, &x332, x330, x326, x323); + var x333: u32 = undefined; + var x334: u1 = undefined; + addcarryxU32(&x333, &x334, x332, x324, x321); + var x335: u32 = undefined; + var x336: u1 = undefined; + addcarryxU32(&x335, &x336, x334, x322, x319); + var x337: u32 = undefined; + var x338: u1 = undefined; + addcarryxU32(&x337, &x338, x336, x320, x317); + var x339: u32 = undefined; + var x340: u1 = undefined; + addcarryxU32(&x339, &x340, x338, x318, x315); + var x341: u32 = undefined; + var x342: u1 = undefined; + addcarryxU32(&x341, &x342, x340, x316, x313); + var x343: u32 = undefined; + var x344: u1 = undefined; + addcarryxU32(&x343, &x344, 0x0, x299, x327); + var x345: u32 = undefined; + var x346: u1 = undefined; + addcarryxU32(&x345, &x346, x344, x301, x329); + var x347: u32 = undefined; + var x348: u1 = undefined; + addcarryxU32(&x347, &x348, x346, x303, x331); + var x349: u32 = undefined; + var x350: u1 = undefined; + addcarryxU32(&x349, &x350, x348, x305, x333); + var x351: u32 = undefined; + var x352: u1 = undefined; + addcarryxU32(&x351, &x352, x350, x307, x335); + var x353: u32 = undefined; + var x354: u1 = undefined; + addcarryxU32(&x353, &x354, x352, x309, x337); + var x355: u32 = undefined; + var x356: u1 = undefined; + addcarryxU32(&x355, &x356, x354, x311, x339); + var x357: u32 = undefined; + var x358: u1 = undefined; + addcarryxU32(&x357, &x358, x356, ((cast(u32, x312) + (cast(u32, x278) + (cast(u32, x262) + x234))) + x282), x341); + var x359: u32 = undefined; + var x360: u32 = undefined; + mulxU32(&x359, &x360, x343, 0x12547e1b); + var x361: u32 = undefined; + var x362: u32 = undefined; + mulxU32(&x361, &x362, x359, 0x10000000); + var x363: u32 = undefined; + var x364: u32 = undefined; + mulxU32(&x363, &x364, x359, 0x14def9de); + var x365: u32 = undefined; + var x366: u32 = undefined; + mulxU32(&x365, &x366, x359, 0xa2f79cd6); + var x367: u32 = undefined; + var x368: u32 = undefined; + mulxU32(&x367, &x368, x359, 0x5812631a); + var x369: u32 = undefined; + var x370: u32 = undefined; + mulxU32(&x369, &x370, x359, 0x5cf5d3ed); + var x371: u32 = undefined; + var x372: u1 = undefined; + addcarryxU32(&x371, &x372, 0x0, x370, x367); + var x373: u32 = undefined; + var x374: u1 = undefined; + addcarryxU32(&x373, &x374, x372, x368, x365); + var x375: u32 = undefined; + var x376: u1 = undefined; + addcarryxU32(&x375, &x376, x374, x366, x363); + var x377: u32 = undefined; + var x378: u1 = undefined; + addcarryxU32(&x377, &x378, 0x0, x343, x369); + var x379: u32 = undefined; + var x380: u1 = undefined; + addcarryxU32(&x379, &x380, x378, x345, x371); + var x381: u32 = undefined; + var x382: u1 = undefined; + addcarryxU32(&x381, &x382, x380, x347, x373); + var x383: u32 = undefined; + var x384: u1 = undefined; + addcarryxU32(&x383, &x384, x382, x349, x375); + var x385: u32 = undefined; + var x386: u1 = undefined; + addcarryxU32(&x385, &x386, x384, x351, (cast(u32, x376) + x364)); + var x387: u32 = undefined; + var x388: u1 = undefined; + addcarryxU32(&x387, &x388, x386, x353, cast(u32, 0x0)); + var x389: u32 = undefined; + var x390: u1 = undefined; + addcarryxU32(&x389, &x390, x388, x355, cast(u32, 0x0)); + var x391: u32 = undefined; + var x392: u1 = undefined; + addcarryxU32(&x391, &x392, x390, x357, x361); + var x393: u32 = undefined; + var x394: u32 = undefined; + mulxU32(&x393, &x394, x5, 0x399411b); + var x395: u32 = undefined; + var x396: u32 = undefined; + mulxU32(&x395, &x396, x5, 0x7c309a3d); + var x397: u32 = undefined; + var x398: u32 = undefined; + mulxU32(&x397, &x398, x5, 0xceec73d2); + var x399: u32 = undefined; + var x400: u32 = undefined; + mulxU32(&x399, &x400, x5, 0x17f5be65); + var x401: u32 = undefined; + var x402: u32 = undefined; + mulxU32(&x401, &x402, x5, 0xd00e1ba7); + var x403: u32 = undefined; + var x404: u32 = undefined; + mulxU32(&x403, &x404, x5, 0x68859347); + var x405: u32 = undefined; + var x406: u32 = undefined; + mulxU32(&x405, &x406, x5, 0xa40611e3); + var x407: u32 = undefined; + var x408: u32 = undefined; + mulxU32(&x407, &x408, x5, 0x449c0f01); + var x409: u32 = undefined; + var x410: u1 = undefined; + addcarryxU32(&x409, &x410, 0x0, x408, x405); + var x411: u32 = undefined; + var x412: u1 = undefined; + addcarryxU32(&x411, &x412, x410, x406, x403); + var x413: u32 = undefined; + var x414: u1 = undefined; + addcarryxU32(&x413, &x414, x412, x404, x401); + var x415: u32 = undefined; + var x416: u1 = undefined; + addcarryxU32(&x415, &x416, x414, x402, x399); + var x417: u32 = undefined; + var x418: u1 = undefined; + addcarryxU32(&x417, &x418, x416, x400, x397); + var x419: u32 = undefined; + var x420: u1 = undefined; + addcarryxU32(&x419, &x420, x418, x398, x395); + var x421: u32 = undefined; + var x422: u1 = undefined; + addcarryxU32(&x421, &x422, x420, x396, x393); + var x423: u32 = undefined; + var x424: u1 = undefined; + addcarryxU32(&x423, &x424, 0x0, x379, x407); + var x425: u32 = undefined; + var x426: u1 = undefined; + addcarryxU32(&x425, &x426, x424, x381, x409); + var x427: u32 = undefined; + var x428: u1 = undefined; + addcarryxU32(&x427, &x428, x426, x383, x411); + var x429: u32 = undefined; + var x430: u1 = undefined; + addcarryxU32(&x429, &x430, x428, x385, x413); + var x431: u32 = undefined; + var x432: u1 = undefined; + addcarryxU32(&x431, &x432, x430, x387, x415); + var x433: u32 = undefined; + var x434: u1 = undefined; + addcarryxU32(&x433, &x434, x432, x389, x417); + var x435: u32 = undefined; + var x436: u1 = undefined; + addcarryxU32(&x435, &x436, x434, x391, x419); + var x437: u32 = undefined; + var x438: u1 = undefined; + addcarryxU32(&x437, &x438, x436, ((cast(u32, x392) + (cast(u32, x358) + (cast(u32, x342) + x314))) + x362), x421); + var x439: u32 = undefined; + var x440: u32 = undefined; + mulxU32(&x439, &x440, x423, 0x12547e1b); + var x441: u32 = undefined; + var x442: u32 = undefined; + mulxU32(&x441, &x442, x439, 0x10000000); + var x443: u32 = undefined; + var x444: u32 = undefined; + mulxU32(&x443, &x444, x439, 0x14def9de); + var x445: u32 = undefined; + var x446: u32 = undefined; + mulxU32(&x445, &x446, x439, 0xa2f79cd6); + var x447: u32 = undefined; + var x448: u32 = undefined; + mulxU32(&x447, &x448, x439, 0x5812631a); + var x449: u32 = undefined; + var x450: u32 = undefined; + mulxU32(&x449, &x450, x439, 0x5cf5d3ed); + var x451: u32 = undefined; + var x452: u1 = undefined; + addcarryxU32(&x451, &x452, 0x0, x450, x447); + var x453: u32 = undefined; + var x454: u1 = undefined; + addcarryxU32(&x453, &x454, x452, x448, x445); + var x455: u32 = undefined; + var x456: u1 = undefined; + addcarryxU32(&x455, &x456, x454, x446, x443); + var x457: u32 = undefined; + var x458: u1 = undefined; + addcarryxU32(&x457, &x458, 0x0, x423, x449); + var x459: u32 = undefined; + var x460: u1 = undefined; + addcarryxU32(&x459, &x460, x458, x425, x451); + var x461: u32 = undefined; + var x462: u1 = undefined; + addcarryxU32(&x461, &x462, x460, x427, x453); + var x463: u32 = undefined; + var x464: u1 = undefined; + addcarryxU32(&x463, &x464, x462, x429, x455); + var x465: u32 = undefined; + var x466: u1 = undefined; + addcarryxU32(&x465, &x466, x464, x431, (cast(u32, x456) + x444)); + var x467: u32 = undefined; + var x468: u1 = undefined; + addcarryxU32(&x467, &x468, x466, x433, cast(u32, 0x0)); + var x469: u32 = undefined; + var x470: u1 = undefined; + addcarryxU32(&x469, &x470, x468, x435, cast(u32, 0x0)); + var x471: u32 = undefined; + var x472: u1 = undefined; + addcarryxU32(&x471, &x472, x470, x437, x441); + var x473: u32 = undefined; + var x474: u32 = undefined; + mulxU32(&x473, &x474, x6, 0x399411b); + var x475: u32 = undefined; + var x476: u32 = undefined; + mulxU32(&x475, &x476, x6, 0x7c309a3d); + var x477: u32 = undefined; + var x478: u32 = undefined; + mulxU32(&x477, &x478, x6, 0xceec73d2); + var x479: u32 = undefined; + var x480: u32 = undefined; + mulxU32(&x479, &x480, x6, 0x17f5be65); + var x481: u32 = undefined; + var x482: u32 = undefined; + mulxU32(&x481, &x482, x6, 0xd00e1ba7); + var x483: u32 = undefined; + var x484: u32 = undefined; + mulxU32(&x483, &x484, x6, 0x68859347); + var x485: u32 = undefined; + var x486: u32 = undefined; + mulxU32(&x485, &x486, x6, 0xa40611e3); + var x487: u32 = undefined; + var x488: u32 = undefined; + mulxU32(&x487, &x488, x6, 0x449c0f01); + var x489: u32 = undefined; + var x490: u1 = undefined; + addcarryxU32(&x489, &x490, 0x0, x488, x485); + var x491: u32 = undefined; + var x492: u1 = undefined; + addcarryxU32(&x491, &x492, x490, x486, x483); + var x493: u32 = undefined; + var x494: u1 = undefined; + addcarryxU32(&x493, &x494, x492, x484, x481); + var x495: u32 = undefined; + var x496: u1 = undefined; + addcarryxU32(&x495, &x496, x494, x482, x479); + var x497: u32 = undefined; + var x498: u1 = undefined; + addcarryxU32(&x497, &x498, x496, x480, x477); + var x499: u32 = undefined; + var x500: u1 = undefined; + addcarryxU32(&x499, &x500, x498, x478, x475); + var x501: u32 = undefined; + var x502: u1 = undefined; + addcarryxU32(&x501, &x502, x500, x476, x473); + var x503: u32 = undefined; + var x504: u1 = undefined; + addcarryxU32(&x503, &x504, 0x0, x459, x487); + var x505: u32 = undefined; + var x506: u1 = undefined; + addcarryxU32(&x505, &x506, x504, x461, x489); + var x507: u32 = undefined; + var x508: u1 = undefined; + addcarryxU32(&x507, &x508, x506, x463, x491); + var x509: u32 = undefined; + var x510: u1 = undefined; + addcarryxU32(&x509, &x510, x508, x465, x493); + var x511: u32 = undefined; + var x512: u1 = undefined; + addcarryxU32(&x511, &x512, x510, x467, x495); + var x513: u32 = undefined; + var x514: u1 = undefined; + addcarryxU32(&x513, &x514, x512, x469, x497); + var x515: u32 = undefined; + var x516: u1 = undefined; + addcarryxU32(&x515, &x516, x514, x471, x499); + var x517: u32 = undefined; + var x518: u1 = undefined; + addcarryxU32(&x517, &x518, x516, ((cast(u32, x472) + (cast(u32, x438) + (cast(u32, x422) + x394))) + x442), x501); + var x519: u32 = undefined; + var x520: u32 = undefined; + mulxU32(&x519, &x520, x503, 0x12547e1b); + var x521: u32 = undefined; + var x522: u32 = undefined; + mulxU32(&x521, &x522, x519, 0x10000000); + var x523: u32 = undefined; + var x524: u32 = undefined; + mulxU32(&x523, &x524, x519, 0x14def9de); + var x525: u32 = undefined; + var x526: u32 = undefined; + mulxU32(&x525, &x526, x519, 0xa2f79cd6); + var x527: u32 = undefined; + var x528: u32 = undefined; + mulxU32(&x527, &x528, x519, 0x5812631a); + var x529: u32 = undefined; + var x530: u32 = undefined; + mulxU32(&x529, &x530, x519, 0x5cf5d3ed); + var x531: u32 = undefined; + var x532: u1 = undefined; + addcarryxU32(&x531, &x532, 0x0, x530, x527); + var x533: u32 = undefined; + var x534: u1 = undefined; + addcarryxU32(&x533, &x534, x532, x528, x525); + var x535: u32 = undefined; + var x536: u1 = undefined; + addcarryxU32(&x535, &x536, x534, x526, x523); + var x537: u32 = undefined; + var x538: u1 = undefined; + addcarryxU32(&x537, &x538, 0x0, x503, x529); + var x539: u32 = undefined; + var x540: u1 = undefined; + addcarryxU32(&x539, &x540, x538, x505, x531); + var x541: u32 = undefined; + var x542: u1 = undefined; + addcarryxU32(&x541, &x542, x540, x507, x533); + var x543: u32 = undefined; + var x544: u1 = undefined; + addcarryxU32(&x543, &x544, x542, x509, x535); + var x545: u32 = undefined; + var x546: u1 = undefined; + addcarryxU32(&x545, &x546, x544, x511, (cast(u32, x536) + x524)); + var x547: u32 = undefined; + var x548: u1 = undefined; + addcarryxU32(&x547, &x548, x546, x513, cast(u32, 0x0)); + var x549: u32 = undefined; + var x550: u1 = undefined; + addcarryxU32(&x549, &x550, x548, x515, cast(u32, 0x0)); + var x551: u32 = undefined; + var x552: u1 = undefined; + addcarryxU32(&x551, &x552, x550, x517, x521); + var x553: u32 = undefined; + var x554: u32 = undefined; + mulxU32(&x553, &x554, x7, 0x399411b); + var x555: u32 = undefined; + var x556: u32 = undefined; + mulxU32(&x555, &x556, x7, 0x7c309a3d); + var x557: u32 = undefined; + var x558: u32 = undefined; + mulxU32(&x557, &x558, x7, 0xceec73d2); + var x559: u32 = undefined; + var x560: u32 = undefined; + mulxU32(&x559, &x560, x7, 0x17f5be65); + var x561: u32 = undefined; + var x562: u32 = undefined; + mulxU32(&x561, &x562, x7, 0xd00e1ba7); + var x563: u32 = undefined; + var x564: u32 = undefined; + mulxU32(&x563, &x564, x7, 0x68859347); + var x565: u32 = undefined; + var x566: u32 = undefined; + mulxU32(&x565, &x566, x7, 0xa40611e3); + var x567: u32 = undefined; + var x568: u32 = undefined; + mulxU32(&x567, &x568, x7, 0x449c0f01); + var x569: u32 = undefined; + var x570: u1 = undefined; + addcarryxU32(&x569, &x570, 0x0, x568, x565); + var x571: u32 = undefined; + var x572: u1 = undefined; + addcarryxU32(&x571, &x572, x570, x566, x563); + var x573: u32 = undefined; + var x574: u1 = undefined; + addcarryxU32(&x573, &x574, x572, x564, x561); + var x575: u32 = undefined; + var x576: u1 = undefined; + addcarryxU32(&x575, &x576, x574, x562, x559); + var x577: u32 = undefined; + var x578: u1 = undefined; + addcarryxU32(&x577, &x578, x576, x560, x557); + var x579: u32 = undefined; + var x580: u1 = undefined; + addcarryxU32(&x579, &x580, x578, x558, x555); + var x581: u32 = undefined; + var x582: u1 = undefined; + addcarryxU32(&x581, &x582, x580, x556, x553); + var x583: u32 = undefined; + var x584: u1 = undefined; + addcarryxU32(&x583, &x584, 0x0, x539, x567); + var x585: u32 = undefined; + var x586: u1 = undefined; + addcarryxU32(&x585, &x586, x584, x541, x569); + var x587: u32 = undefined; + var x588: u1 = undefined; + addcarryxU32(&x587, &x588, x586, x543, x571); + var x589: u32 = undefined; + var x590: u1 = undefined; + addcarryxU32(&x589, &x590, x588, x545, x573); + var x591: u32 = undefined; + var x592: u1 = undefined; + addcarryxU32(&x591, &x592, x590, x547, x575); + var x593: u32 = undefined; + var x594: u1 = undefined; + addcarryxU32(&x593, &x594, x592, x549, x577); + var x595: u32 = undefined; + var x596: u1 = undefined; + addcarryxU32(&x595, &x596, x594, x551, x579); + var x597: u32 = undefined; + var x598: u1 = undefined; + addcarryxU32(&x597, &x598, x596, ((cast(u32, x552) + (cast(u32, x518) + (cast(u32, x502) + x474))) + x522), x581); + var x599: u32 = undefined; + var x600: u32 = undefined; + mulxU32(&x599, &x600, x583, 0x12547e1b); + var x601: u32 = undefined; + var x602: u32 = undefined; + mulxU32(&x601, &x602, x599, 0x10000000); + var x603: u32 = undefined; + var x604: u32 = undefined; + mulxU32(&x603, &x604, x599, 0x14def9de); + var x605: u32 = undefined; + var x606: u32 = undefined; + mulxU32(&x605, &x606, x599, 0xa2f79cd6); + var x607: u32 = undefined; + var x608: u32 = undefined; + mulxU32(&x607, &x608, x599, 0x5812631a); + var x609: u32 = undefined; + var x610: u32 = undefined; + mulxU32(&x609, &x610, x599, 0x5cf5d3ed); + var x611: u32 = undefined; + var x612: u1 = undefined; + addcarryxU32(&x611, &x612, 0x0, x610, x607); + var x613: u32 = undefined; + var x614: u1 = undefined; + addcarryxU32(&x613, &x614, x612, x608, x605); + var x615: u32 = undefined; + var x616: u1 = undefined; + addcarryxU32(&x615, &x616, x614, x606, x603); + var x617: u32 = undefined; + var x618: u1 = undefined; + addcarryxU32(&x617, &x618, 0x0, x583, x609); + var x619: u32 = undefined; + var x620: u1 = undefined; + addcarryxU32(&x619, &x620, x618, x585, x611); + var x621: u32 = undefined; + var x622: u1 = undefined; + addcarryxU32(&x621, &x622, x620, x587, x613); + var x623: u32 = undefined; + var x624: u1 = undefined; + addcarryxU32(&x623, &x624, x622, x589, x615); + var x625: u32 = undefined; + var x626: u1 = undefined; + addcarryxU32(&x625, &x626, x624, x591, (cast(u32, x616) + x604)); + var x627: u32 = undefined; + var x628: u1 = undefined; + addcarryxU32(&x627, &x628, x626, x593, cast(u32, 0x0)); + var x629: u32 = undefined; + var x630: u1 = undefined; + addcarryxU32(&x629, &x630, x628, x595, cast(u32, 0x0)); + var x631: u32 = undefined; + var x632: u1 = undefined; + addcarryxU32(&x631, &x632, x630, x597, x601); + const x633 = ((cast(u32, x632) + (cast(u32, x598) + (cast(u32, x582) + x554))) + x602); + var x634: u32 = undefined; + var x635: u1 = undefined; + subborrowxU32(&x634, &x635, 0x0, x619, 0x5cf5d3ed); + var x636: u32 = undefined; + var x637: u1 = undefined; + subborrowxU32(&x636, &x637, x635, x621, 0x5812631a); + var x638: u32 = undefined; + var x639: u1 = undefined; + subborrowxU32(&x638, &x639, x637, x623, 0xa2f79cd6); + var x640: u32 = undefined; + var x641: u1 = undefined; + subborrowxU32(&x640, &x641, x639, x625, 0x14def9de); + var x642: u32 = undefined; + var x643: u1 = undefined; + subborrowxU32(&x642, &x643, x641, x627, cast(u32, 0x0)); + var x644: u32 = undefined; + var x645: u1 = undefined; + subborrowxU32(&x644, &x645, x643, x629, cast(u32, 0x0)); + var x646: u32 = undefined; + var x647: u1 = undefined; + subborrowxU32(&x646, &x647, x645, x631, cast(u32, 0x0)); + var x648: u32 = undefined; + var x649: u1 = undefined; + subborrowxU32(&x648, &x649, x647, x633, 0x10000000); + var x650: u32 = undefined; + var x651: u1 = undefined; + subborrowxU32(&x650, &x651, x649, cast(u32, 0x0), cast(u32, 0x0)); + var x652: u32 = undefined; + cmovznzU32(&x652, x651, x634, x619); + var x653: u32 = undefined; + cmovznzU32(&x653, x651, x636, x621); + var x654: u32 = undefined; + cmovznzU32(&x654, x651, x638, x623); + var x655: u32 = undefined; + cmovznzU32(&x655, x651, x640, x625); + var x656: u32 = undefined; + cmovznzU32(&x656, x651, x642, x627); + var x657: u32 = undefined; + cmovznzU32(&x657, x651, x644, x629); + var x658: u32 = undefined; + cmovznzU32(&x658, x651, x646, x631); + var x659: u32 = undefined; + cmovznzU32(&x659, x651, x648, x633); + out1[0] = x652; + out1[1] = x653; + out1[2] = x654; + out1[3] = x655; + out1[4] = x656; + out1[5] = x657; + out1[6] = x658; + out1[7] = x659; +} + +/// The function nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +pub fn nonzero(out1: *u32, arg1: [8]u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | (arg1[7])))))))); + out1.* = x1; +} + +/// The function selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn selectznz(out1: *[8]u32, arg1: u1, arg2: [8]u32, arg3: [8]u32) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + cmovznzU32(&x1, arg1, (arg2[0]), (arg3[0])); + var x2: u32 = undefined; + cmovznzU32(&x2, arg1, (arg2[1]), (arg3[1])); + var x3: u32 = undefined; + cmovznzU32(&x3, arg1, (arg2[2]), (arg3[2])); + var x4: u32 = undefined; + cmovznzU32(&x4, arg1, (arg2[3]), (arg3[3])); + var x5: u32 = undefined; + cmovznzU32(&x5, arg1, (arg2[4]), (arg3[4])); + var x6: u32 = undefined; + cmovznzU32(&x6, arg1, (arg2[5]), (arg3[5])); + var x7: u32 = undefined; + cmovznzU32(&x7, arg1, (arg2[6]), (arg3[6])); + var x8: u32 = undefined; + cmovznzU32(&x8, arg1, (arg2[7]), (arg3[7])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; + out1[6] = x7; + out1[7] = x8; +} + +/// The function toBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0x1fffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] +pub fn toBytes(out1: *[32]u8, arg1: [8]u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[7]); + const x2 = (arg1[6]); + const x3 = (arg1[5]); + const x4 = (arg1[4]); + const x5 = (arg1[3]); + const x6 = (arg1[2]); + const x7 = (arg1[1]); + const x8 = (arg1[0]); + const x9 = cast(u8, (x8 & cast(u32, 0xff))); + const x10 = (x8 >> 8); + const x11 = cast(u8, (x10 & cast(u32, 0xff))); + const x12 = (x10 >> 8); + const x13 = cast(u8, (x12 & cast(u32, 0xff))); + const x14 = cast(u8, (x12 >> 8)); + const x15 = cast(u8, (x7 & cast(u32, 0xff))); + const x16 = (x7 >> 8); + const x17 = cast(u8, (x16 & cast(u32, 0xff))); + const x18 = (x16 >> 8); + const x19 = cast(u8, (x18 & cast(u32, 0xff))); + const x20 = cast(u8, (x18 >> 8)); + const x21 = cast(u8, (x6 & cast(u32, 0xff))); + const x22 = (x6 >> 8); + const x23 = cast(u8, (x22 & cast(u32, 0xff))); + const x24 = (x22 >> 8); + const x25 = cast(u8, (x24 & cast(u32, 0xff))); + const x26 = cast(u8, (x24 >> 8)); + const x27 = cast(u8, (x5 & cast(u32, 0xff))); + const x28 = (x5 >> 8); + const x29 = cast(u8, (x28 & cast(u32, 0xff))); + const x30 = (x28 >> 8); + const x31 = cast(u8, (x30 & cast(u32, 0xff))); + const x32 = cast(u8, (x30 >> 8)); + const x33 = cast(u8, (x4 & cast(u32, 0xff))); + const x34 = (x4 >> 8); + const x35 = cast(u8, (x34 & cast(u32, 0xff))); + const x36 = (x34 >> 8); + const x37 = cast(u8, (x36 & cast(u32, 0xff))); + const x38 = cast(u8, (x36 >> 8)); + const x39 = cast(u8, (x3 & cast(u32, 0xff))); + const x40 = (x3 >> 8); + const x41 = cast(u8, (x40 & cast(u32, 0xff))); + const x42 = (x40 >> 8); + const x43 = cast(u8, (x42 & cast(u32, 0xff))); + const x44 = cast(u8, (x42 >> 8)); + const x45 = cast(u8, (x2 & cast(u32, 0xff))); + const x46 = (x2 >> 8); + const x47 = cast(u8, (x46 & cast(u32, 0xff))); + const x48 = (x46 >> 8); + const x49 = cast(u8, (x48 & cast(u32, 0xff))); + const x50 = cast(u8, (x48 >> 8)); + const x51 = cast(u8, (x1 & cast(u32, 0xff))); + const x52 = (x1 >> 8); + const x53 = cast(u8, (x52 & cast(u32, 0xff))); + const x54 = (x52 >> 8); + const x55 = cast(u8, (x54 & cast(u32, 0xff))); + const x56 = cast(u8, (x54 >> 8)); + out1[0] = x9; + out1[1] = x11; + out1[2] = x13; + out1[3] = x14; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x26; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x38; + out1[20] = x39; + out1[21] = x41; + out1[22] = x43; + out1[23] = x44; + out1[24] = x45; + out1[25] = x47; + out1[26] = x49; + out1[27] = x50; + out1[28] = x51; + out1[29] = x53; + out1[30] = x55; + out1[31] = x56; +} + +/// The function fromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0x1fffffff]] +pub fn fromBytes(out1: *[8]u32, arg1: [32]u8) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u32, (arg1[31])) << 24); + const x2 = (cast(u32, (arg1[30])) << 16); + const x3 = (cast(u32, (arg1[29])) << 8); + const x4 = (arg1[28]); + const x5 = (cast(u32, (arg1[27])) << 24); + const x6 = (cast(u32, (arg1[26])) << 16); + const x7 = (cast(u32, (arg1[25])) << 8); + const x8 = (arg1[24]); + const x9 = (cast(u32, (arg1[23])) << 24); + const x10 = (cast(u32, (arg1[22])) << 16); + const x11 = (cast(u32, (arg1[21])) << 8); + const x12 = (arg1[20]); + const x13 = (cast(u32, (arg1[19])) << 24); + const x14 = (cast(u32, (arg1[18])) << 16); + const x15 = (cast(u32, (arg1[17])) << 8); + const x16 = (arg1[16]); + const x17 = (cast(u32, (arg1[15])) << 24); + const x18 = (cast(u32, (arg1[14])) << 16); + const x19 = (cast(u32, (arg1[13])) << 8); + const x20 = (arg1[12]); + const x21 = (cast(u32, (arg1[11])) << 24); + const x22 = (cast(u32, (arg1[10])) << 16); + const x23 = (cast(u32, (arg1[9])) << 8); + const x24 = (arg1[8]); + const x25 = (cast(u32, (arg1[7])) << 24); + const x26 = (cast(u32, (arg1[6])) << 16); + const x27 = (cast(u32, (arg1[5])) << 8); + const x28 = (arg1[4]); + const x29 = (cast(u32, (arg1[3])) << 24); + const x30 = (cast(u32, (arg1[2])) << 16); + const x31 = (cast(u32, (arg1[1])) << 8); + const x32 = (arg1[0]); + const x33 = (x31 + cast(u32, x32)); + const x34 = (x30 + x33); + const x35 = (x29 + x34); + const x36 = (x27 + cast(u32, x28)); + const x37 = (x26 + x36); + const x38 = (x25 + x37); + const x39 = (x23 + cast(u32, x24)); + const x40 = (x22 + x39); + const x41 = (x21 + x40); + const x42 = (x19 + cast(u32, x20)); + const x43 = (x18 + x42); + const x44 = (x17 + x43); + const x45 = (x15 + cast(u32, x16)); + const x46 = (x14 + x45); + const x47 = (x13 + x46); + const x48 = (x11 + cast(u32, x12)); + const x49 = (x10 + x48); + const x50 = (x9 + x49); + const x51 = (x7 + cast(u32, x8)); + const x52 = (x6 + x51); + const x53 = (x5 + x52); + const x54 = (x3 + cast(u32, x4)); + const x55 = (x2 + x54); + const x56 = (x1 + x55); + out1[0] = x35; + out1[1] = x38; + out1[2] = x41; + out1[3] = x44; + out1[4] = x47; + out1[5] = x50; + out1[6] = x53; + out1[7] = x56; +} + +/// The function setOne returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn setOne(out1: *MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0x8d98951d; + out1[1] = 0xd6ec3174; + out1[2] = 0x737dcf70; + out1[3] = 0xc6ef5bf4; + out1[4] = 0xfffffffe; + out1[5] = 0xffffffff; + out1[6] = 0xffffffff; + out1[7] = 0xfffffff; +} + +/// The function msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn msat(out1: *[9]u32) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0x5cf5d3ed; + out1[1] = 0x5812631a; + out1[2] = 0xa2f79cd6; + out1[3] = 0x14def9de; + out1[4] = cast(u32, 0x0); + out1[5] = cast(u32, 0x0); + out1[6] = cast(u32, 0x0); + out1[7] = 0x10000000; + out1[8] = cast(u32, 0x0); +} + +/// The function divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn divstep(out1: *u32, out2: *[9]u32, out3: *[9]u32, out4: *[8]u32, out5: *[8]u32, arg1: u32, arg2: [9]u32, arg3: [9]u32, arg4: [8]u32, arg5: [8]u32) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + addcarryxU32(&x1, &x2, 0x0, (~arg1), cast(u32, 0x1)); + const x3 = (cast(u1, (x1 >> 31)) & cast(u1, ((arg3[0]) & cast(u32, 0x1)))); + var x4: u32 = undefined; + var x5: u1 = undefined; + addcarryxU32(&x4, &x5, 0x0, (~arg1), cast(u32, 0x1)); + var x6: u32 = undefined; + cmovznzU32(&x6, x3, arg1, x4); + var x7: u32 = undefined; + cmovznzU32(&x7, x3, (arg2[0]), (arg3[0])); + var x8: u32 = undefined; + cmovznzU32(&x8, x3, (arg2[1]), (arg3[1])); + var x9: u32 = undefined; + cmovznzU32(&x9, x3, (arg2[2]), (arg3[2])); + var x10: u32 = undefined; + cmovznzU32(&x10, x3, (arg2[3]), (arg3[3])); + var x11: u32 = undefined; + cmovznzU32(&x11, x3, (arg2[4]), (arg3[4])); + var x12: u32 = undefined; + cmovznzU32(&x12, x3, (arg2[5]), (arg3[5])); + var x13: u32 = undefined; + cmovznzU32(&x13, x3, (arg2[6]), (arg3[6])); + var x14: u32 = undefined; + cmovznzU32(&x14, x3, (arg2[7]), (arg3[7])); + var x15: u32 = undefined; + cmovznzU32(&x15, x3, (arg2[8]), (arg3[8])); + var x16: u32 = undefined; + var x17: u1 = undefined; + addcarryxU32(&x16, &x17, 0x0, cast(u32, 0x1), (~(arg2[0]))); + var x18: u32 = undefined; + var x19: u1 = undefined; + addcarryxU32(&x18, &x19, x17, cast(u32, 0x0), (~(arg2[1]))); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, cast(u32, 0x0), (~(arg2[2]))); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, cast(u32, 0x0), (~(arg2[3]))); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, cast(u32, 0x0), (~(arg2[4]))); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, cast(u32, 0x0), (~(arg2[5]))); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, cast(u32, 0x0), (~(arg2[6]))); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, cast(u32, 0x0), (~(arg2[7]))); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, cast(u32, 0x0), (~(arg2[8]))); + var x34: u32 = undefined; + cmovznzU32(&x34, x3, (arg3[0]), x16); + var x35: u32 = undefined; + cmovznzU32(&x35, x3, (arg3[1]), x18); + var x36: u32 = undefined; + cmovznzU32(&x36, x3, (arg3[2]), x20); + var x37: u32 = undefined; + cmovznzU32(&x37, x3, (arg3[3]), x22); + var x38: u32 = undefined; + cmovznzU32(&x38, x3, (arg3[4]), x24); + var x39: u32 = undefined; + cmovznzU32(&x39, x3, (arg3[5]), x26); + var x40: u32 = undefined; + cmovznzU32(&x40, x3, (arg3[6]), x28); + var x41: u32 = undefined; + cmovznzU32(&x41, x3, (arg3[7]), x30); + var x42: u32 = undefined; + cmovznzU32(&x42, x3, (arg3[8]), x32); + var x43: u32 = undefined; + cmovznzU32(&x43, x3, (arg4[0]), (arg5[0])); + var x44: u32 = undefined; + cmovznzU32(&x44, x3, (arg4[1]), (arg5[1])); + var x45: u32 = undefined; + cmovznzU32(&x45, x3, (arg4[2]), (arg5[2])); + var x46: u32 = undefined; + cmovznzU32(&x46, x3, (arg4[3]), (arg5[3])); + var x47: u32 = undefined; + cmovznzU32(&x47, x3, (arg4[4]), (arg5[4])); + var x48: u32 = undefined; + cmovznzU32(&x48, x3, (arg4[5]), (arg5[5])); + var x49: u32 = undefined; + cmovznzU32(&x49, x3, (arg4[6]), (arg5[6])); + var x50: u32 = undefined; + cmovznzU32(&x50, x3, (arg4[7]), (arg5[7])); + var x51: u32 = undefined; + var x52: u1 = undefined; + addcarryxU32(&x51, &x52, 0x0, x43, x43); + var x53: u32 = undefined; + var x54: u1 = undefined; + addcarryxU32(&x53, &x54, x52, x44, x44); + var x55: u32 = undefined; + var x56: u1 = undefined; + addcarryxU32(&x55, &x56, x54, x45, x45); + var x57: u32 = undefined; + var x58: u1 = undefined; + addcarryxU32(&x57, &x58, x56, x46, x46); + var x59: u32 = undefined; + var x60: u1 = undefined; + addcarryxU32(&x59, &x60, x58, x47, x47); + var x61: u32 = undefined; + var x62: u1 = undefined; + addcarryxU32(&x61, &x62, x60, x48, x48); + var x63: u32 = undefined; + var x64: u1 = undefined; + addcarryxU32(&x63, &x64, x62, x49, x49); + var x65: u32 = undefined; + var x66: u1 = undefined; + addcarryxU32(&x65, &x66, x64, x50, x50); + var x67: u32 = undefined; + var x68: u1 = undefined; + subborrowxU32(&x67, &x68, 0x0, x51, 0x5cf5d3ed); + var x69: u32 = undefined; + var x70: u1 = undefined; + subborrowxU32(&x69, &x70, x68, x53, 0x5812631a); + var x71: u32 = undefined; + var x72: u1 = undefined; + subborrowxU32(&x71, &x72, x70, x55, 0xa2f79cd6); + var x73: u32 = undefined; + var x74: u1 = undefined; + subborrowxU32(&x73, &x74, x72, x57, 0x14def9de); + var x75: u32 = undefined; + var x76: u1 = undefined; + subborrowxU32(&x75, &x76, x74, x59, cast(u32, 0x0)); + var x77: u32 = undefined; + var x78: u1 = undefined; + subborrowxU32(&x77, &x78, x76, x61, cast(u32, 0x0)); + var x79: u32 = undefined; + var x80: u1 = undefined; + subborrowxU32(&x79, &x80, x78, x63, cast(u32, 0x0)); + var x81: u32 = undefined; + var x82: u1 = undefined; + subborrowxU32(&x81, &x82, x80, x65, 0x10000000); + var x83: u32 = undefined; + var x84: u1 = undefined; + subborrowxU32(&x83, &x84, x82, cast(u32, x66), cast(u32, 0x0)); + const x85 = (arg4[7]); + const x86 = (arg4[6]); + const x87 = (arg4[5]); + const x88 = (arg4[4]); + const x89 = (arg4[3]); + const x90 = (arg4[2]); + const x91 = (arg4[1]); + const x92 = (arg4[0]); + var x93: u32 = undefined; + var x94: u1 = undefined; + subborrowxU32(&x93, &x94, 0x0, cast(u32, 0x0), x92); + var x95: u32 = undefined; + var x96: u1 = undefined; + subborrowxU32(&x95, &x96, x94, cast(u32, 0x0), x91); + var x97: u32 = undefined; + var x98: u1 = undefined; + subborrowxU32(&x97, &x98, x96, cast(u32, 0x0), x90); + var x99: u32 = undefined; + var x100: u1 = undefined; + subborrowxU32(&x99, &x100, x98, cast(u32, 0x0), x89); + var x101: u32 = undefined; + var x102: u1 = undefined; + subborrowxU32(&x101, &x102, x100, cast(u32, 0x0), x88); + var x103: u32 = undefined; + var x104: u1 = undefined; + subborrowxU32(&x103, &x104, x102, cast(u32, 0x0), x87); + var x105: u32 = undefined; + var x106: u1 = undefined; + subborrowxU32(&x105, &x106, x104, cast(u32, 0x0), x86); + var x107: u32 = undefined; + var x108: u1 = undefined; + subborrowxU32(&x107, &x108, x106, cast(u32, 0x0), x85); + var x109: u32 = undefined; + cmovznzU32(&x109, x108, cast(u32, 0x0), 0xffffffff); + var x110: u32 = undefined; + var x111: u1 = undefined; + addcarryxU32(&x110, &x111, 0x0, x93, (x109 & 0x5cf5d3ed)); + var x112: u32 = undefined; + var x113: u1 = undefined; + addcarryxU32(&x112, &x113, x111, x95, (x109 & 0x5812631a)); + var x114: u32 = undefined; + var x115: u1 = undefined; + addcarryxU32(&x114, &x115, x113, x97, (x109 & 0xa2f79cd6)); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, x115, x99, (x109 & 0x14def9de)); + var x118: u32 = undefined; + var x119: u1 = undefined; + addcarryxU32(&x118, &x119, x117, x101, cast(u32, 0x0)); + var x120: u32 = undefined; + var x121: u1 = undefined; + addcarryxU32(&x120, &x121, x119, x103, cast(u32, 0x0)); + var x122: u32 = undefined; + var x123: u1 = undefined; + addcarryxU32(&x122, &x123, x121, x105, cast(u32, 0x0)); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, x107, (x109 & 0x10000000)); + var x126: u32 = undefined; + cmovznzU32(&x126, x3, (arg5[0]), x110); + var x127: u32 = undefined; + cmovznzU32(&x127, x3, (arg5[1]), x112); + var x128: u32 = undefined; + cmovznzU32(&x128, x3, (arg5[2]), x114); + var x129: u32 = undefined; + cmovznzU32(&x129, x3, (arg5[3]), x116); + var x130: u32 = undefined; + cmovznzU32(&x130, x3, (arg5[4]), x118); + var x131: u32 = undefined; + cmovznzU32(&x131, x3, (arg5[5]), x120); + var x132: u32 = undefined; + cmovznzU32(&x132, x3, (arg5[6]), x122); + var x133: u32 = undefined; + cmovznzU32(&x133, x3, (arg5[7]), x124); + const x134 = cast(u1, (x34 & cast(u32, 0x1))); + var x135: u32 = undefined; + cmovznzU32(&x135, x134, cast(u32, 0x0), x7); + var x136: u32 = undefined; + cmovznzU32(&x136, x134, cast(u32, 0x0), x8); + var x137: u32 = undefined; + cmovznzU32(&x137, x134, cast(u32, 0x0), x9); + var x138: u32 = undefined; + cmovznzU32(&x138, x134, cast(u32, 0x0), x10); + var x139: u32 = undefined; + cmovznzU32(&x139, x134, cast(u32, 0x0), x11); + var x140: u32 = undefined; + cmovznzU32(&x140, x134, cast(u32, 0x0), x12); + var x141: u32 = undefined; + cmovznzU32(&x141, x134, cast(u32, 0x0), x13); + var x142: u32 = undefined; + cmovznzU32(&x142, x134, cast(u32, 0x0), x14); + var x143: u32 = undefined; + cmovznzU32(&x143, x134, cast(u32, 0x0), x15); + var x144: u32 = undefined; + var x145: u1 = undefined; + addcarryxU32(&x144, &x145, 0x0, x34, x135); + var x146: u32 = undefined; + var x147: u1 = undefined; + addcarryxU32(&x146, &x147, x145, x35, x136); + var x148: u32 = undefined; + var x149: u1 = undefined; + addcarryxU32(&x148, &x149, x147, x36, x137); + var x150: u32 = undefined; + var x151: u1 = undefined; + addcarryxU32(&x150, &x151, x149, x37, x138); + var x152: u32 = undefined; + var x153: u1 = undefined; + addcarryxU32(&x152, &x153, x151, x38, x139); + var x154: u32 = undefined; + var x155: u1 = undefined; + addcarryxU32(&x154, &x155, x153, x39, x140); + var x156: u32 = undefined; + var x157: u1 = undefined; + addcarryxU32(&x156, &x157, x155, x40, x141); + var x158: u32 = undefined; + var x159: u1 = undefined; + addcarryxU32(&x158, &x159, x157, x41, x142); + var x160: u32 = undefined; + var x161: u1 = undefined; + addcarryxU32(&x160, &x161, x159, x42, x143); + var x162: u32 = undefined; + cmovznzU32(&x162, x134, cast(u32, 0x0), x43); + var x163: u32 = undefined; + cmovznzU32(&x163, x134, cast(u32, 0x0), x44); + var x164: u32 = undefined; + cmovznzU32(&x164, x134, cast(u32, 0x0), x45); + var x165: u32 = undefined; + cmovznzU32(&x165, x134, cast(u32, 0x0), x46); + var x166: u32 = undefined; + cmovznzU32(&x166, x134, cast(u32, 0x0), x47); + var x167: u32 = undefined; + cmovznzU32(&x167, x134, cast(u32, 0x0), x48); + var x168: u32 = undefined; + cmovznzU32(&x168, x134, cast(u32, 0x0), x49); + var x169: u32 = undefined; + cmovznzU32(&x169, x134, cast(u32, 0x0), x50); + var x170: u32 = undefined; + var x171: u1 = undefined; + addcarryxU32(&x170, &x171, 0x0, x126, x162); + var x172: u32 = undefined; + var x173: u1 = undefined; + addcarryxU32(&x172, &x173, x171, x127, x163); + var x174: u32 = undefined; + var x175: u1 = undefined; + addcarryxU32(&x174, &x175, x173, x128, x164); + var x176: u32 = undefined; + var x177: u1 = undefined; + addcarryxU32(&x176, &x177, x175, x129, x165); + var x178: u32 = undefined; + var x179: u1 = undefined; + addcarryxU32(&x178, &x179, x177, x130, x166); + var x180: u32 = undefined; + var x181: u1 = undefined; + addcarryxU32(&x180, &x181, x179, x131, x167); + var x182: u32 = undefined; + var x183: u1 = undefined; + addcarryxU32(&x182, &x183, x181, x132, x168); + var x184: u32 = undefined; + var x185: u1 = undefined; + addcarryxU32(&x184, &x185, x183, x133, x169); + var x186: u32 = undefined; + var x187: u1 = undefined; + subborrowxU32(&x186, &x187, 0x0, x170, 0x5cf5d3ed); + var x188: u32 = undefined; + var x189: u1 = undefined; + subborrowxU32(&x188, &x189, x187, x172, 0x5812631a); + var x190: u32 = undefined; + var x191: u1 = undefined; + subborrowxU32(&x190, &x191, x189, x174, 0xa2f79cd6); + var x192: u32 = undefined; + var x193: u1 = undefined; + subborrowxU32(&x192, &x193, x191, x176, 0x14def9de); + var x194: u32 = undefined; + var x195: u1 = undefined; + subborrowxU32(&x194, &x195, x193, x178, cast(u32, 0x0)); + var x196: u32 = undefined; + var x197: u1 = undefined; + subborrowxU32(&x196, &x197, x195, x180, cast(u32, 0x0)); + var x198: u32 = undefined; + var x199: u1 = undefined; + subborrowxU32(&x198, &x199, x197, x182, cast(u32, 0x0)); + var x200: u32 = undefined; + var x201: u1 = undefined; + subborrowxU32(&x200, &x201, x199, x184, 0x10000000); + var x202: u32 = undefined; + var x203: u1 = undefined; + subborrowxU32(&x202, &x203, x201, cast(u32, x185), cast(u32, 0x0)); + var x204: u32 = undefined; + var x205: u1 = undefined; + addcarryxU32(&x204, &x205, 0x0, x6, cast(u32, 0x1)); + const x206 = ((x144 >> 1) | ((x146 << 31) & 0xffffffff)); + const x207 = ((x146 >> 1) | ((x148 << 31) & 0xffffffff)); + const x208 = ((x148 >> 1) | ((x150 << 31) & 0xffffffff)); + const x209 = ((x150 >> 1) | ((x152 << 31) & 0xffffffff)); + const x210 = ((x152 >> 1) | ((x154 << 31) & 0xffffffff)); + const x211 = ((x154 >> 1) | ((x156 << 31) & 0xffffffff)); + const x212 = ((x156 >> 1) | ((x158 << 31) & 0xffffffff)); + const x213 = ((x158 >> 1) | ((x160 << 31) & 0xffffffff)); + const x214 = ((x160 & 0x80000000) | (x160 >> 1)); + var x215: u32 = undefined; + cmovznzU32(&x215, x84, x67, x51); + var x216: u32 = undefined; + cmovznzU32(&x216, x84, x69, x53); + var x217: u32 = undefined; + cmovznzU32(&x217, x84, x71, x55); + var x218: u32 = undefined; + cmovznzU32(&x218, x84, x73, x57); + var x219: u32 = undefined; + cmovznzU32(&x219, x84, x75, x59); + var x220: u32 = undefined; + cmovznzU32(&x220, x84, x77, x61); + var x221: u32 = undefined; + cmovznzU32(&x221, x84, x79, x63); + var x222: u32 = undefined; + cmovznzU32(&x222, x84, x81, x65); + var x223: u32 = undefined; + cmovznzU32(&x223, x203, x186, x170); + var x224: u32 = undefined; + cmovznzU32(&x224, x203, x188, x172); + var x225: u32 = undefined; + cmovznzU32(&x225, x203, x190, x174); + var x226: u32 = undefined; + cmovznzU32(&x226, x203, x192, x176); + var x227: u32 = undefined; + cmovznzU32(&x227, x203, x194, x178); + var x228: u32 = undefined; + cmovznzU32(&x228, x203, x196, x180); + var x229: u32 = undefined; + cmovznzU32(&x229, x203, x198, x182); + var x230: u32 = undefined; + cmovznzU32(&x230, x203, x200, x184); + out1.* = x204; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out2[7] = x14; + out2[8] = x15; + out3[0] = x206; + out3[1] = x207; + out3[2] = x208; + out3[3] = x209; + out3[4] = x210; + out3[5] = x211; + out3[6] = x212; + out3[7] = x213; + out3[8] = x214; + out4[0] = x215; + out4[1] = x216; + out4[2] = x217; + out4[3] = x218; + out4[4] = x219; + out4[5] = x220; + out4[6] = x221; + out4[7] = x222; + out5[0] = x223; + out5[1] = x224; + out5[2] = x225; + out5[3] = x226; + out5[4] = x227; + out5[5] = x228; + out5[6] = x229; + out5[7] = x230; +} + +/// The function divstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn divstepPrecomp(out1: *[8]u32) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0x36a7cb92; + out1[1] = 0xd70af844; + out1[2] = 0xb0b8b159; + out1[3] = 0x5f71c978; + out1[4] = 0x74947f1a; + out1[5] = 0xe76d8169; + out1[6] = 0xf193e4ff; + out1[7] = 0x19a2d36; +} diff --git a/fiat-zig/src/curve25519_scalar_64.zig b/fiat-zig/src/curve25519_scalar_64.zig new file mode 100644 index 0000000000..8d27a72fcd --- /dev/null +++ b/fiat-zig/src/curve25519_scalar_64.zig @@ -0,0 +1,1856 @@ +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Zig --internal-static --public-function-case camelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case UpperCamelCase --no-prefix-fiat --package-name 25519_scalar '' 64 '2^252 + 27742317777372353535851937790883648493' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// curve description (via package name): 25519_scalar +// machine_wordsize = 64 (from "64") +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// m = 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed (from "2^252 + 27742317777372353535851937790883648493") +// +// NOTE: In addition to the bounds specified above each function, all +// functions synthesized for this Montgomery arithmetic require the +// input to be strictly less than the prime modulus (m), and also +// require the input to be in the unique saturated representation. +// All functions also ensure that these two properties are true of +// return values. +// +// Computed values: +// eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +// twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in +// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 + +const std = @import("std"); +const mode = @import("builtin").mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels + +inline fn cast(comptime DestType: type, target: anytype) DestType { + if (@typeInfo(@TypeOf(target)) == .Int) { + const dest = @typeInfo(DestType).Int; + const source = @typeInfo(@TypeOf(target)).Int; + if (dest.bits < source.bits) { + return @bitCast(DestType, @truncate(std.meta.Int(source.signedness, dest.bits), target)); + } else { + return @bitCast(DestType, @as(std.meta.Int(source.signedness, dest.bits), target)); + } + } + return @as(DestType, target); +} + +// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub const MontgomeryDomainFieldElement = [4]u64; + +// The type NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub const NonMontgomeryDomainFieldElement = [4]u64; + +/// The function addcarryxU64 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^64 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +inline fn addcarryxU64(out1: *u64, out2: *u1, arg1: u1, arg2: u64, arg3: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(u128, arg1) + cast(u128, arg2)) + cast(u128, arg3)); + const x2 = cast(u64, (x1 & cast(u128, 0xffffffffffffffff))); + const x3 = cast(u1, (x1 >> 64)); + out1.* = x2; + out2.* = x3; +} + +/// The function subborrowxU64 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^64 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +inline fn subborrowxU64(out1: *u64, out2: *u1, arg1: u1, arg2: u64, arg3: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(i128, arg2) - cast(i128, arg1)) - cast(i128, arg3)); + const x2 = cast(i1, (x1 >> 64)); + const x3 = cast(u64, (x1 & cast(i128, 0xffffffffffffffff))); + out1.* = x3; + out2.* = cast(u1, (cast(i2, 0x0) - cast(i2, x2))); +} + +/// The function mulxU64 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^64 +/// out2 = ⌊arg1 * arg2 / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0xffffffffffffffff] +inline fn mulxU64(out1: *u64, out2: *u64, arg1: u64, arg2: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u128, arg1) * cast(u128, arg2)); + const x2 = cast(u64, (x1 & cast(u128, 0xffffffffffffffff))); + const x3 = cast(u64, (x1 >> 64)); + out1.* = x2; + out2.* = x3; +} + +/// The function cmovznzU64 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +inline fn cmovznzU64(out1: *u64, arg1: u1, arg2: u64, arg3: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (~(~arg1)); + const x2 = cast(u64, (cast(i128, cast(i1, (cast(i2, 0x0) - cast(i2, x1)))) & cast(i128, 0xffffffffffffffff))); + const x3 = ((x2 & arg3) | ((~x2) & arg2)); + out1.* = x3; +} + +/// The function mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn mul(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[0]); + var x5: u64 = undefined; + var x6: u64 = undefined; + mulxU64(&x5, &x6, x4, (arg2[3])); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x4, (arg2[2])); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x4, (arg2[1])); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x4, (arg2[0])); + var x13: u64 = undefined; + var x14: u1 = undefined; + addcarryxU64(&x13, &x14, 0x0, x12, x9); + var x15: u64 = undefined; + var x16: u1 = undefined; + addcarryxU64(&x15, &x16, x14, x10, x7); + var x17: u64 = undefined; + var x18: u1 = undefined; + addcarryxU64(&x17, &x18, x16, x8, x5); + const x19 = (cast(u64, x18) + x6); + var x20: u64 = undefined; + var x21: u64 = undefined; + mulxU64(&x20, &x21, x11, 0xd2b51da312547e1b); + var x22: u64 = undefined; + var x23: u64 = undefined; + mulxU64(&x22, &x23, x20, 0x1000000000000000); + var x24: u64 = undefined; + var x25: u64 = undefined; + mulxU64(&x24, &x25, x20, 0x14def9dea2f79cd6); + var x26: u64 = undefined; + var x27: u64 = undefined; + mulxU64(&x26, &x27, x20, 0x5812631a5cf5d3ed); + var x28: u64 = undefined; + var x29: u1 = undefined; + addcarryxU64(&x28, &x29, 0x0, x27, x24); + const x30 = (cast(u64, x29) + x25); + var x31: u64 = undefined; + var x32: u1 = undefined; + addcarryxU64(&x31, &x32, 0x0, x11, x26); + var x33: u64 = undefined; + var x34: u1 = undefined; + addcarryxU64(&x33, &x34, x32, x13, x28); + var x35: u64 = undefined; + var x36: u1 = undefined; + addcarryxU64(&x35, &x36, x34, x15, x30); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, x36, x17, x22); + var x39: u64 = undefined; + var x40: u1 = undefined; + addcarryxU64(&x39, &x40, x38, x19, x23); + var x41: u64 = undefined; + var x42: u64 = undefined; + mulxU64(&x41, &x42, x1, (arg2[3])); + var x43: u64 = undefined; + var x44: u64 = undefined; + mulxU64(&x43, &x44, x1, (arg2[2])); + var x45: u64 = undefined; + var x46: u64 = undefined; + mulxU64(&x45, &x46, x1, (arg2[1])); + var x47: u64 = undefined; + var x48: u64 = undefined; + mulxU64(&x47, &x48, x1, (arg2[0])); + var x49: u64 = undefined; + var x50: u1 = undefined; + addcarryxU64(&x49, &x50, 0x0, x48, x45); + var x51: u64 = undefined; + var x52: u1 = undefined; + addcarryxU64(&x51, &x52, x50, x46, x43); + var x53: u64 = undefined; + var x54: u1 = undefined; + addcarryxU64(&x53, &x54, x52, x44, x41); + const x55 = (cast(u64, x54) + x42); + var x56: u64 = undefined; + var x57: u1 = undefined; + addcarryxU64(&x56, &x57, 0x0, x33, x47); + var x58: u64 = undefined; + var x59: u1 = undefined; + addcarryxU64(&x58, &x59, x57, x35, x49); + var x60: u64 = undefined; + var x61: u1 = undefined; + addcarryxU64(&x60, &x61, x59, x37, x51); + var x62: u64 = undefined; + var x63: u1 = undefined; + addcarryxU64(&x62, &x63, x61, x39, x53); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, cast(u64, x40), x55); + var x66: u64 = undefined; + var x67: u64 = undefined; + mulxU64(&x66, &x67, x56, 0xd2b51da312547e1b); + var x68: u64 = undefined; + var x69: u64 = undefined; + mulxU64(&x68, &x69, x66, 0x1000000000000000); + var x70: u64 = undefined; + var x71: u64 = undefined; + mulxU64(&x70, &x71, x66, 0x14def9dea2f79cd6); + var x72: u64 = undefined; + var x73: u64 = undefined; + mulxU64(&x72, &x73, x66, 0x5812631a5cf5d3ed); + var x74: u64 = undefined; + var x75: u1 = undefined; + addcarryxU64(&x74, &x75, 0x0, x73, x70); + const x76 = (cast(u64, x75) + x71); + var x77: u64 = undefined; + var x78: u1 = undefined; + addcarryxU64(&x77, &x78, 0x0, x56, x72); + var x79: u64 = undefined; + var x80: u1 = undefined; + addcarryxU64(&x79, &x80, x78, x58, x74); + var x81: u64 = undefined; + var x82: u1 = undefined; + addcarryxU64(&x81, &x82, x80, x60, x76); + var x83: u64 = undefined; + var x84: u1 = undefined; + addcarryxU64(&x83, &x84, x82, x62, x68); + var x85: u64 = undefined; + var x86: u1 = undefined; + addcarryxU64(&x85, &x86, x84, x64, x69); + const x87 = (cast(u64, x86) + cast(u64, x65)); + var x88: u64 = undefined; + var x89: u64 = undefined; + mulxU64(&x88, &x89, x2, (arg2[3])); + var x90: u64 = undefined; + var x91: u64 = undefined; + mulxU64(&x90, &x91, x2, (arg2[2])); + var x92: u64 = undefined; + var x93: u64 = undefined; + mulxU64(&x92, &x93, x2, (arg2[1])); + var x94: u64 = undefined; + var x95: u64 = undefined; + mulxU64(&x94, &x95, x2, (arg2[0])); + var x96: u64 = undefined; + var x97: u1 = undefined; + addcarryxU64(&x96, &x97, 0x0, x95, x92); + var x98: u64 = undefined; + var x99: u1 = undefined; + addcarryxU64(&x98, &x99, x97, x93, x90); + var x100: u64 = undefined; + var x101: u1 = undefined; + addcarryxU64(&x100, &x101, x99, x91, x88); + const x102 = (cast(u64, x101) + x89); + var x103: u64 = undefined; + var x104: u1 = undefined; + addcarryxU64(&x103, &x104, 0x0, x79, x94); + var x105: u64 = undefined; + var x106: u1 = undefined; + addcarryxU64(&x105, &x106, x104, x81, x96); + var x107: u64 = undefined; + var x108: u1 = undefined; + addcarryxU64(&x107, &x108, x106, x83, x98); + var x109: u64 = undefined; + var x110: u1 = undefined; + addcarryxU64(&x109, &x110, x108, x85, x100); + var x111: u64 = undefined; + var x112: u1 = undefined; + addcarryxU64(&x111, &x112, x110, x87, x102); + var x113: u64 = undefined; + var x114: u64 = undefined; + mulxU64(&x113, &x114, x103, 0xd2b51da312547e1b); + var x115: u64 = undefined; + var x116: u64 = undefined; + mulxU64(&x115, &x116, x113, 0x1000000000000000); + var x117: u64 = undefined; + var x118: u64 = undefined; + mulxU64(&x117, &x118, x113, 0x14def9dea2f79cd6); + var x119: u64 = undefined; + var x120: u64 = undefined; + mulxU64(&x119, &x120, x113, 0x5812631a5cf5d3ed); + var x121: u64 = undefined; + var x122: u1 = undefined; + addcarryxU64(&x121, &x122, 0x0, x120, x117); + const x123 = (cast(u64, x122) + x118); + var x124: u64 = undefined; + var x125: u1 = undefined; + addcarryxU64(&x124, &x125, 0x0, x103, x119); + var x126: u64 = undefined; + var x127: u1 = undefined; + addcarryxU64(&x126, &x127, x125, x105, x121); + var x128: u64 = undefined; + var x129: u1 = undefined; + addcarryxU64(&x128, &x129, x127, x107, x123); + var x130: u64 = undefined; + var x131: u1 = undefined; + addcarryxU64(&x130, &x131, x129, x109, x115); + var x132: u64 = undefined; + var x133: u1 = undefined; + addcarryxU64(&x132, &x133, x131, x111, x116); + const x134 = (cast(u64, x133) + cast(u64, x112)); + var x135: u64 = undefined; + var x136: u64 = undefined; + mulxU64(&x135, &x136, x3, (arg2[3])); + var x137: u64 = undefined; + var x138: u64 = undefined; + mulxU64(&x137, &x138, x3, (arg2[2])); + var x139: u64 = undefined; + var x140: u64 = undefined; + mulxU64(&x139, &x140, x3, (arg2[1])); + var x141: u64 = undefined; + var x142: u64 = undefined; + mulxU64(&x141, &x142, x3, (arg2[0])); + var x143: u64 = undefined; + var x144: u1 = undefined; + addcarryxU64(&x143, &x144, 0x0, x142, x139); + var x145: u64 = undefined; + var x146: u1 = undefined; + addcarryxU64(&x145, &x146, x144, x140, x137); + var x147: u64 = undefined; + var x148: u1 = undefined; + addcarryxU64(&x147, &x148, x146, x138, x135); + const x149 = (cast(u64, x148) + x136); + var x150: u64 = undefined; + var x151: u1 = undefined; + addcarryxU64(&x150, &x151, 0x0, x126, x141); + var x152: u64 = undefined; + var x153: u1 = undefined; + addcarryxU64(&x152, &x153, x151, x128, x143); + var x154: u64 = undefined; + var x155: u1 = undefined; + addcarryxU64(&x154, &x155, x153, x130, x145); + var x156: u64 = undefined; + var x157: u1 = undefined; + addcarryxU64(&x156, &x157, x155, x132, x147); + var x158: u64 = undefined; + var x159: u1 = undefined; + addcarryxU64(&x158, &x159, x157, x134, x149); + var x160: u64 = undefined; + var x161: u64 = undefined; + mulxU64(&x160, &x161, x150, 0xd2b51da312547e1b); + var x162: u64 = undefined; + var x163: u64 = undefined; + mulxU64(&x162, &x163, x160, 0x1000000000000000); + var x164: u64 = undefined; + var x165: u64 = undefined; + mulxU64(&x164, &x165, x160, 0x14def9dea2f79cd6); + var x166: u64 = undefined; + var x167: u64 = undefined; + mulxU64(&x166, &x167, x160, 0x5812631a5cf5d3ed); + var x168: u64 = undefined; + var x169: u1 = undefined; + addcarryxU64(&x168, &x169, 0x0, x167, x164); + const x170 = (cast(u64, x169) + x165); + var x171: u64 = undefined; + var x172: u1 = undefined; + addcarryxU64(&x171, &x172, 0x0, x150, x166); + var x173: u64 = undefined; + var x174: u1 = undefined; + addcarryxU64(&x173, &x174, x172, x152, x168); + var x175: u64 = undefined; + var x176: u1 = undefined; + addcarryxU64(&x175, &x176, x174, x154, x170); + var x177: u64 = undefined; + var x178: u1 = undefined; + addcarryxU64(&x177, &x178, x176, x156, x162); + var x179: u64 = undefined; + var x180: u1 = undefined; + addcarryxU64(&x179, &x180, x178, x158, x163); + const x181 = (cast(u64, x180) + cast(u64, x159)); + var x182: u64 = undefined; + var x183: u1 = undefined; + subborrowxU64(&x182, &x183, 0x0, x173, 0x5812631a5cf5d3ed); + var x184: u64 = undefined; + var x185: u1 = undefined; + subborrowxU64(&x184, &x185, x183, x175, 0x14def9dea2f79cd6); + var x186: u64 = undefined; + var x187: u1 = undefined; + subborrowxU64(&x186, &x187, x185, x177, cast(u64, 0x0)); + var x188: u64 = undefined; + var x189: u1 = undefined; + subborrowxU64(&x188, &x189, x187, x179, 0x1000000000000000); + var x190: u64 = undefined; + var x191: u1 = undefined; + subborrowxU64(&x190, &x191, x189, x181, cast(u64, 0x0)); + var x192: u64 = undefined; + cmovznzU64(&x192, x191, x182, x173); + var x193: u64 = undefined; + cmovznzU64(&x193, x191, x184, x175); + var x194: u64 = undefined; + cmovznzU64(&x194, x191, x186, x177); + var x195: u64 = undefined; + cmovznzU64(&x195, x191, x188, x179); + out1[0] = x192; + out1[1] = x193; + out1[2] = x194; + out1[3] = x195; +} + +/// The function square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn square(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[0]); + var x5: u64 = undefined; + var x6: u64 = undefined; + mulxU64(&x5, &x6, x4, (arg1[3])); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x4, (arg1[2])); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x4, (arg1[1])); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x4, (arg1[0])); + var x13: u64 = undefined; + var x14: u1 = undefined; + addcarryxU64(&x13, &x14, 0x0, x12, x9); + var x15: u64 = undefined; + var x16: u1 = undefined; + addcarryxU64(&x15, &x16, x14, x10, x7); + var x17: u64 = undefined; + var x18: u1 = undefined; + addcarryxU64(&x17, &x18, x16, x8, x5); + const x19 = (cast(u64, x18) + x6); + var x20: u64 = undefined; + var x21: u64 = undefined; + mulxU64(&x20, &x21, x11, 0xd2b51da312547e1b); + var x22: u64 = undefined; + var x23: u64 = undefined; + mulxU64(&x22, &x23, x20, 0x1000000000000000); + var x24: u64 = undefined; + var x25: u64 = undefined; + mulxU64(&x24, &x25, x20, 0x14def9dea2f79cd6); + var x26: u64 = undefined; + var x27: u64 = undefined; + mulxU64(&x26, &x27, x20, 0x5812631a5cf5d3ed); + var x28: u64 = undefined; + var x29: u1 = undefined; + addcarryxU64(&x28, &x29, 0x0, x27, x24); + const x30 = (cast(u64, x29) + x25); + var x31: u64 = undefined; + var x32: u1 = undefined; + addcarryxU64(&x31, &x32, 0x0, x11, x26); + var x33: u64 = undefined; + var x34: u1 = undefined; + addcarryxU64(&x33, &x34, x32, x13, x28); + var x35: u64 = undefined; + var x36: u1 = undefined; + addcarryxU64(&x35, &x36, x34, x15, x30); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, x36, x17, x22); + var x39: u64 = undefined; + var x40: u1 = undefined; + addcarryxU64(&x39, &x40, x38, x19, x23); + var x41: u64 = undefined; + var x42: u64 = undefined; + mulxU64(&x41, &x42, x1, (arg1[3])); + var x43: u64 = undefined; + var x44: u64 = undefined; + mulxU64(&x43, &x44, x1, (arg1[2])); + var x45: u64 = undefined; + var x46: u64 = undefined; + mulxU64(&x45, &x46, x1, (arg1[1])); + var x47: u64 = undefined; + var x48: u64 = undefined; + mulxU64(&x47, &x48, x1, (arg1[0])); + var x49: u64 = undefined; + var x50: u1 = undefined; + addcarryxU64(&x49, &x50, 0x0, x48, x45); + var x51: u64 = undefined; + var x52: u1 = undefined; + addcarryxU64(&x51, &x52, x50, x46, x43); + var x53: u64 = undefined; + var x54: u1 = undefined; + addcarryxU64(&x53, &x54, x52, x44, x41); + const x55 = (cast(u64, x54) + x42); + var x56: u64 = undefined; + var x57: u1 = undefined; + addcarryxU64(&x56, &x57, 0x0, x33, x47); + var x58: u64 = undefined; + var x59: u1 = undefined; + addcarryxU64(&x58, &x59, x57, x35, x49); + var x60: u64 = undefined; + var x61: u1 = undefined; + addcarryxU64(&x60, &x61, x59, x37, x51); + var x62: u64 = undefined; + var x63: u1 = undefined; + addcarryxU64(&x62, &x63, x61, x39, x53); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, cast(u64, x40), x55); + var x66: u64 = undefined; + var x67: u64 = undefined; + mulxU64(&x66, &x67, x56, 0xd2b51da312547e1b); + var x68: u64 = undefined; + var x69: u64 = undefined; + mulxU64(&x68, &x69, x66, 0x1000000000000000); + var x70: u64 = undefined; + var x71: u64 = undefined; + mulxU64(&x70, &x71, x66, 0x14def9dea2f79cd6); + var x72: u64 = undefined; + var x73: u64 = undefined; + mulxU64(&x72, &x73, x66, 0x5812631a5cf5d3ed); + var x74: u64 = undefined; + var x75: u1 = undefined; + addcarryxU64(&x74, &x75, 0x0, x73, x70); + const x76 = (cast(u64, x75) + x71); + var x77: u64 = undefined; + var x78: u1 = undefined; + addcarryxU64(&x77, &x78, 0x0, x56, x72); + var x79: u64 = undefined; + var x80: u1 = undefined; + addcarryxU64(&x79, &x80, x78, x58, x74); + var x81: u64 = undefined; + var x82: u1 = undefined; + addcarryxU64(&x81, &x82, x80, x60, x76); + var x83: u64 = undefined; + var x84: u1 = undefined; + addcarryxU64(&x83, &x84, x82, x62, x68); + var x85: u64 = undefined; + var x86: u1 = undefined; + addcarryxU64(&x85, &x86, x84, x64, x69); + const x87 = (cast(u64, x86) + cast(u64, x65)); + var x88: u64 = undefined; + var x89: u64 = undefined; + mulxU64(&x88, &x89, x2, (arg1[3])); + var x90: u64 = undefined; + var x91: u64 = undefined; + mulxU64(&x90, &x91, x2, (arg1[2])); + var x92: u64 = undefined; + var x93: u64 = undefined; + mulxU64(&x92, &x93, x2, (arg1[1])); + var x94: u64 = undefined; + var x95: u64 = undefined; + mulxU64(&x94, &x95, x2, (arg1[0])); + var x96: u64 = undefined; + var x97: u1 = undefined; + addcarryxU64(&x96, &x97, 0x0, x95, x92); + var x98: u64 = undefined; + var x99: u1 = undefined; + addcarryxU64(&x98, &x99, x97, x93, x90); + var x100: u64 = undefined; + var x101: u1 = undefined; + addcarryxU64(&x100, &x101, x99, x91, x88); + const x102 = (cast(u64, x101) + x89); + var x103: u64 = undefined; + var x104: u1 = undefined; + addcarryxU64(&x103, &x104, 0x0, x79, x94); + var x105: u64 = undefined; + var x106: u1 = undefined; + addcarryxU64(&x105, &x106, x104, x81, x96); + var x107: u64 = undefined; + var x108: u1 = undefined; + addcarryxU64(&x107, &x108, x106, x83, x98); + var x109: u64 = undefined; + var x110: u1 = undefined; + addcarryxU64(&x109, &x110, x108, x85, x100); + var x111: u64 = undefined; + var x112: u1 = undefined; + addcarryxU64(&x111, &x112, x110, x87, x102); + var x113: u64 = undefined; + var x114: u64 = undefined; + mulxU64(&x113, &x114, x103, 0xd2b51da312547e1b); + var x115: u64 = undefined; + var x116: u64 = undefined; + mulxU64(&x115, &x116, x113, 0x1000000000000000); + var x117: u64 = undefined; + var x118: u64 = undefined; + mulxU64(&x117, &x118, x113, 0x14def9dea2f79cd6); + var x119: u64 = undefined; + var x120: u64 = undefined; + mulxU64(&x119, &x120, x113, 0x5812631a5cf5d3ed); + var x121: u64 = undefined; + var x122: u1 = undefined; + addcarryxU64(&x121, &x122, 0x0, x120, x117); + const x123 = (cast(u64, x122) + x118); + var x124: u64 = undefined; + var x125: u1 = undefined; + addcarryxU64(&x124, &x125, 0x0, x103, x119); + var x126: u64 = undefined; + var x127: u1 = undefined; + addcarryxU64(&x126, &x127, x125, x105, x121); + var x128: u64 = undefined; + var x129: u1 = undefined; + addcarryxU64(&x128, &x129, x127, x107, x123); + var x130: u64 = undefined; + var x131: u1 = undefined; + addcarryxU64(&x130, &x131, x129, x109, x115); + var x132: u64 = undefined; + var x133: u1 = undefined; + addcarryxU64(&x132, &x133, x131, x111, x116); + const x134 = (cast(u64, x133) + cast(u64, x112)); + var x135: u64 = undefined; + var x136: u64 = undefined; + mulxU64(&x135, &x136, x3, (arg1[3])); + var x137: u64 = undefined; + var x138: u64 = undefined; + mulxU64(&x137, &x138, x3, (arg1[2])); + var x139: u64 = undefined; + var x140: u64 = undefined; + mulxU64(&x139, &x140, x3, (arg1[1])); + var x141: u64 = undefined; + var x142: u64 = undefined; + mulxU64(&x141, &x142, x3, (arg1[0])); + var x143: u64 = undefined; + var x144: u1 = undefined; + addcarryxU64(&x143, &x144, 0x0, x142, x139); + var x145: u64 = undefined; + var x146: u1 = undefined; + addcarryxU64(&x145, &x146, x144, x140, x137); + var x147: u64 = undefined; + var x148: u1 = undefined; + addcarryxU64(&x147, &x148, x146, x138, x135); + const x149 = (cast(u64, x148) + x136); + var x150: u64 = undefined; + var x151: u1 = undefined; + addcarryxU64(&x150, &x151, 0x0, x126, x141); + var x152: u64 = undefined; + var x153: u1 = undefined; + addcarryxU64(&x152, &x153, x151, x128, x143); + var x154: u64 = undefined; + var x155: u1 = undefined; + addcarryxU64(&x154, &x155, x153, x130, x145); + var x156: u64 = undefined; + var x157: u1 = undefined; + addcarryxU64(&x156, &x157, x155, x132, x147); + var x158: u64 = undefined; + var x159: u1 = undefined; + addcarryxU64(&x158, &x159, x157, x134, x149); + var x160: u64 = undefined; + var x161: u64 = undefined; + mulxU64(&x160, &x161, x150, 0xd2b51da312547e1b); + var x162: u64 = undefined; + var x163: u64 = undefined; + mulxU64(&x162, &x163, x160, 0x1000000000000000); + var x164: u64 = undefined; + var x165: u64 = undefined; + mulxU64(&x164, &x165, x160, 0x14def9dea2f79cd6); + var x166: u64 = undefined; + var x167: u64 = undefined; + mulxU64(&x166, &x167, x160, 0x5812631a5cf5d3ed); + var x168: u64 = undefined; + var x169: u1 = undefined; + addcarryxU64(&x168, &x169, 0x0, x167, x164); + const x170 = (cast(u64, x169) + x165); + var x171: u64 = undefined; + var x172: u1 = undefined; + addcarryxU64(&x171, &x172, 0x0, x150, x166); + var x173: u64 = undefined; + var x174: u1 = undefined; + addcarryxU64(&x173, &x174, x172, x152, x168); + var x175: u64 = undefined; + var x176: u1 = undefined; + addcarryxU64(&x175, &x176, x174, x154, x170); + var x177: u64 = undefined; + var x178: u1 = undefined; + addcarryxU64(&x177, &x178, x176, x156, x162); + var x179: u64 = undefined; + var x180: u1 = undefined; + addcarryxU64(&x179, &x180, x178, x158, x163); + const x181 = (cast(u64, x180) + cast(u64, x159)); + var x182: u64 = undefined; + var x183: u1 = undefined; + subborrowxU64(&x182, &x183, 0x0, x173, 0x5812631a5cf5d3ed); + var x184: u64 = undefined; + var x185: u1 = undefined; + subborrowxU64(&x184, &x185, x183, x175, 0x14def9dea2f79cd6); + var x186: u64 = undefined; + var x187: u1 = undefined; + subborrowxU64(&x186, &x187, x185, x177, cast(u64, 0x0)); + var x188: u64 = undefined; + var x189: u1 = undefined; + subborrowxU64(&x188, &x189, x187, x179, 0x1000000000000000); + var x190: u64 = undefined; + var x191: u1 = undefined; + subborrowxU64(&x190, &x191, x189, x181, cast(u64, 0x0)); + var x192: u64 = undefined; + cmovznzU64(&x192, x191, x182, x173); + var x193: u64 = undefined; + cmovznzU64(&x193, x191, x184, x175); + var x194: u64 = undefined; + cmovznzU64(&x194, x191, x186, x177); + var x195: u64 = undefined; + cmovznzU64(&x195, x191, x188, x179); + out1[0] = x192; + out1[1] = x193; + out1[2] = x194; + out1[3] = x195; +} + +/// The function add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn add(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + addcarryxU64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u64 = undefined; + var x4: u1 = undefined; + addcarryxU64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u64 = undefined; + var x6: u1 = undefined; + addcarryxU64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u64 = undefined; + var x8: u1 = undefined; + addcarryxU64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u64 = undefined; + var x10: u1 = undefined; + subborrowxU64(&x9, &x10, 0x0, x1, 0x5812631a5cf5d3ed); + var x11: u64 = undefined; + var x12: u1 = undefined; + subborrowxU64(&x11, &x12, x10, x3, 0x14def9dea2f79cd6); + var x13: u64 = undefined; + var x14: u1 = undefined; + subborrowxU64(&x13, &x14, x12, x5, cast(u64, 0x0)); + var x15: u64 = undefined; + var x16: u1 = undefined; + subborrowxU64(&x15, &x16, x14, x7, 0x1000000000000000); + var x17: u64 = undefined; + var x18: u1 = undefined; + subborrowxU64(&x17, &x18, x16, cast(u64, x8), cast(u64, 0x0)); + var x19: u64 = undefined; + cmovznzU64(&x19, x18, x9, x1); + var x20: u64 = undefined; + cmovznzU64(&x20, x18, x11, x3); + var x21: u64 = undefined; + cmovznzU64(&x21, x18, x13, x5); + var x22: u64 = undefined; + cmovznzU64(&x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/// The function sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn sub(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + subborrowxU64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u64 = undefined; + var x4: u1 = undefined; + subborrowxU64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u64 = undefined; + var x6: u1 = undefined; + subborrowxU64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u64 = undefined; + var x8: u1 = undefined; + subborrowxU64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u64 = undefined; + cmovznzU64(&x9, x8, cast(u64, 0x0), 0xffffffffffffffff); + var x10: u64 = undefined; + var x11: u1 = undefined; + addcarryxU64(&x10, &x11, 0x0, x1, (x9 & 0x5812631a5cf5d3ed)); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, x11, x3, (x9 & 0x14def9dea2f79cd6)); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, x5, cast(u64, 0x0)); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, x7, (x9 & 0x1000000000000000)); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +pub fn opp(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + subborrowxU64(&x1, &x2, 0x0, cast(u64, 0x0), (arg1[0])); + var x3: u64 = undefined; + var x4: u1 = undefined; + subborrowxU64(&x3, &x4, x2, cast(u64, 0x0), (arg1[1])); + var x5: u64 = undefined; + var x6: u1 = undefined; + subborrowxU64(&x5, &x6, x4, cast(u64, 0x0), (arg1[2])); + var x7: u64 = undefined; + var x8: u1 = undefined; + subborrowxU64(&x7, &x8, x6, cast(u64, 0x0), (arg1[3])); + var x9: u64 = undefined; + cmovznzU64(&x9, x8, cast(u64, 0x0), 0xffffffffffffffff); + var x10: u64 = undefined; + var x11: u1 = undefined; + addcarryxU64(&x10, &x11, 0x0, x1, (x9 & 0x5812631a5cf5d3ed)); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, x11, x3, (x9 & 0x14def9dea2f79cd6)); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, x5, cast(u64, 0x0)); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, x7, (x9 & 0x1000000000000000)); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fromMontgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m +/// 0 ≤ eval out1 < m +/// +pub fn fromMontgomery(out1: *NonMontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[0]); + var x2: u64 = undefined; + var x3: u64 = undefined; + mulxU64(&x2, &x3, x1, 0xd2b51da312547e1b); + var x4: u64 = undefined; + var x5: u64 = undefined; + mulxU64(&x4, &x5, x2, 0x1000000000000000); + var x6: u64 = undefined; + var x7: u64 = undefined; + mulxU64(&x6, &x7, x2, 0x14def9dea2f79cd6); + var x8: u64 = undefined; + var x9: u64 = undefined; + mulxU64(&x8, &x9, x2, 0x5812631a5cf5d3ed); + var x10: u64 = undefined; + var x11: u1 = undefined; + addcarryxU64(&x10, &x11, 0x0, x9, x6); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, 0x0, x1, x8); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, cast(u64, 0x0), x10); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, 0x0, x14, (arg1[1])); + var x18: u64 = undefined; + var x19: u64 = undefined; + mulxU64(&x18, &x19, x16, 0xd2b51da312547e1b); + var x20: u64 = undefined; + var x21: u64 = undefined; + mulxU64(&x20, &x21, x18, 0x1000000000000000); + var x22: u64 = undefined; + var x23: u64 = undefined; + mulxU64(&x22, &x23, x18, 0x14def9dea2f79cd6); + var x24: u64 = undefined; + var x25: u64 = undefined; + mulxU64(&x24, &x25, x18, 0x5812631a5cf5d3ed); + var x26: u64 = undefined; + var x27: u1 = undefined; + addcarryxU64(&x26, &x27, 0x0, x25, x22); + var x28: u64 = undefined; + var x29: u1 = undefined; + addcarryxU64(&x28, &x29, 0x0, x16, x24); + var x30: u64 = undefined; + var x31: u1 = undefined; + addcarryxU64(&x30, &x31, x29, (cast(u64, x17) + (cast(u64, x15) + (cast(u64, x11) + x7))), x26); + var x32: u64 = undefined; + var x33: u1 = undefined; + addcarryxU64(&x32, &x33, x31, x4, (cast(u64, x27) + x23)); + var x34: u64 = undefined; + var x35: u1 = undefined; + addcarryxU64(&x34, &x35, x33, x5, x20); + var x36: u64 = undefined; + var x37: u1 = undefined; + addcarryxU64(&x36, &x37, 0x0, x30, (arg1[2])); + var x38: u64 = undefined; + var x39: u1 = undefined; + addcarryxU64(&x38, &x39, x37, x32, cast(u64, 0x0)); + var x40: u64 = undefined; + var x41: u1 = undefined; + addcarryxU64(&x40, &x41, x39, x34, cast(u64, 0x0)); + var x42: u64 = undefined; + var x43: u64 = undefined; + mulxU64(&x42, &x43, x36, 0xd2b51da312547e1b); + var x44: u64 = undefined; + var x45: u64 = undefined; + mulxU64(&x44, &x45, x42, 0x1000000000000000); + var x46: u64 = undefined; + var x47: u64 = undefined; + mulxU64(&x46, &x47, x42, 0x14def9dea2f79cd6); + var x48: u64 = undefined; + var x49: u64 = undefined; + mulxU64(&x48, &x49, x42, 0x5812631a5cf5d3ed); + var x50: u64 = undefined; + var x51: u1 = undefined; + addcarryxU64(&x50, &x51, 0x0, x49, x46); + var x52: u64 = undefined; + var x53: u1 = undefined; + addcarryxU64(&x52, &x53, 0x0, x36, x48); + var x54: u64 = undefined; + var x55: u1 = undefined; + addcarryxU64(&x54, &x55, x53, x38, x50); + var x56: u64 = undefined; + var x57: u1 = undefined; + addcarryxU64(&x56, &x57, x55, x40, (cast(u64, x51) + x47)); + var x58: u64 = undefined; + var x59: u1 = undefined; + addcarryxU64(&x58, &x59, x57, (cast(u64, x41) + (cast(u64, x35) + x21)), x44); + var x60: u64 = undefined; + var x61: u1 = undefined; + addcarryxU64(&x60, &x61, 0x0, x54, (arg1[3])); + var x62: u64 = undefined; + var x63: u1 = undefined; + addcarryxU64(&x62, &x63, x61, x56, cast(u64, 0x0)); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, x58, cast(u64, 0x0)); + var x66: u64 = undefined; + var x67: u64 = undefined; + mulxU64(&x66, &x67, x60, 0xd2b51da312547e1b); + var x68: u64 = undefined; + var x69: u64 = undefined; + mulxU64(&x68, &x69, x66, 0x1000000000000000); + var x70: u64 = undefined; + var x71: u64 = undefined; + mulxU64(&x70, &x71, x66, 0x14def9dea2f79cd6); + var x72: u64 = undefined; + var x73: u64 = undefined; + mulxU64(&x72, &x73, x66, 0x5812631a5cf5d3ed); + var x74: u64 = undefined; + var x75: u1 = undefined; + addcarryxU64(&x74, &x75, 0x0, x73, x70); + var x76: u64 = undefined; + var x77: u1 = undefined; + addcarryxU64(&x76, &x77, 0x0, x60, x72); + var x78: u64 = undefined; + var x79: u1 = undefined; + addcarryxU64(&x78, &x79, x77, x62, x74); + var x80: u64 = undefined; + var x81: u1 = undefined; + addcarryxU64(&x80, &x81, x79, x64, (cast(u64, x75) + x71)); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, x81, (cast(u64, x65) + (cast(u64, x59) + x45)), x68); + const x84 = (cast(u64, x83) + x69); + var x85: u64 = undefined; + var x86: u1 = undefined; + subborrowxU64(&x85, &x86, 0x0, x78, 0x5812631a5cf5d3ed); + var x87: u64 = undefined; + var x88: u1 = undefined; + subborrowxU64(&x87, &x88, x86, x80, 0x14def9dea2f79cd6); + var x89: u64 = undefined; + var x90: u1 = undefined; + subborrowxU64(&x89, &x90, x88, x82, cast(u64, 0x0)); + var x91: u64 = undefined; + var x92: u1 = undefined; + subborrowxU64(&x91, &x92, x90, x84, 0x1000000000000000); + var x93: u64 = undefined; + var x94: u1 = undefined; + subborrowxU64(&x93, &x94, x92, cast(u64, 0x0), cast(u64, 0x0)); + var x95: u64 = undefined; + cmovznzU64(&x95, x94, x85, x78); + var x96: u64 = undefined; + cmovznzU64(&x96, x94, x87, x80); + var x97: u64 = undefined; + cmovznzU64(&x97, x94, x89, x82); + var x98: u64 = undefined; + cmovznzU64(&x98, x94, x91, x84); + out1[0] = x95; + out1[1] = x96; + out1[2] = x97; + out1[3] = x98; +} + +/// The function toMontgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn toMontgomery(out1: *MontgomeryDomainFieldElement, arg1: NonMontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[0]); + var x5: u64 = undefined; + var x6: u64 = undefined; + mulxU64(&x5, &x6, x4, 0x399411b7c309a3d); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x4, 0xceec73d217f5be65); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x4, 0xd00e1ba768859347); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x4, 0xa40611e3449c0f01); + var x13: u64 = undefined; + var x14: u1 = undefined; + addcarryxU64(&x13, &x14, 0x0, x12, x9); + var x15: u64 = undefined; + var x16: u1 = undefined; + addcarryxU64(&x15, &x16, x14, x10, x7); + var x17: u64 = undefined; + var x18: u1 = undefined; + addcarryxU64(&x17, &x18, x16, x8, x5); + var x19: u64 = undefined; + var x20: u64 = undefined; + mulxU64(&x19, &x20, x11, 0xd2b51da312547e1b); + var x21: u64 = undefined; + var x22: u64 = undefined; + mulxU64(&x21, &x22, x19, 0x1000000000000000); + var x23: u64 = undefined; + var x24: u64 = undefined; + mulxU64(&x23, &x24, x19, 0x14def9dea2f79cd6); + var x25: u64 = undefined; + var x26: u64 = undefined; + mulxU64(&x25, &x26, x19, 0x5812631a5cf5d3ed); + var x27: u64 = undefined; + var x28: u1 = undefined; + addcarryxU64(&x27, &x28, 0x0, x26, x23); + var x29: u64 = undefined; + var x30: u1 = undefined; + addcarryxU64(&x29, &x30, 0x0, x11, x25); + var x31: u64 = undefined; + var x32: u1 = undefined; + addcarryxU64(&x31, &x32, x30, x13, x27); + var x33: u64 = undefined; + var x34: u1 = undefined; + addcarryxU64(&x33, &x34, x32, x15, (cast(u64, x28) + x24)); + var x35: u64 = undefined; + var x36: u1 = undefined; + addcarryxU64(&x35, &x36, x34, x17, x21); + var x37: u64 = undefined; + var x38: u64 = undefined; + mulxU64(&x37, &x38, x1, 0x399411b7c309a3d); + var x39: u64 = undefined; + var x40: u64 = undefined; + mulxU64(&x39, &x40, x1, 0xceec73d217f5be65); + var x41: u64 = undefined; + var x42: u64 = undefined; + mulxU64(&x41, &x42, x1, 0xd00e1ba768859347); + var x43: u64 = undefined; + var x44: u64 = undefined; + mulxU64(&x43, &x44, x1, 0xa40611e3449c0f01); + var x45: u64 = undefined; + var x46: u1 = undefined; + addcarryxU64(&x45, &x46, 0x0, x44, x41); + var x47: u64 = undefined; + var x48: u1 = undefined; + addcarryxU64(&x47, &x48, x46, x42, x39); + var x49: u64 = undefined; + var x50: u1 = undefined; + addcarryxU64(&x49, &x50, x48, x40, x37); + var x51: u64 = undefined; + var x52: u1 = undefined; + addcarryxU64(&x51, &x52, 0x0, x31, x43); + var x53: u64 = undefined; + var x54: u1 = undefined; + addcarryxU64(&x53, &x54, x52, x33, x45); + var x55: u64 = undefined; + var x56: u1 = undefined; + addcarryxU64(&x55, &x56, x54, x35, x47); + var x57: u64 = undefined; + var x58: u1 = undefined; + addcarryxU64(&x57, &x58, x56, ((cast(u64, x36) + (cast(u64, x18) + x6)) + x22), x49); + var x59: u64 = undefined; + var x60: u64 = undefined; + mulxU64(&x59, &x60, x51, 0xd2b51da312547e1b); + var x61: u64 = undefined; + var x62: u64 = undefined; + mulxU64(&x61, &x62, x59, 0x1000000000000000); + var x63: u64 = undefined; + var x64: u64 = undefined; + mulxU64(&x63, &x64, x59, 0x14def9dea2f79cd6); + var x65: u64 = undefined; + var x66: u64 = undefined; + mulxU64(&x65, &x66, x59, 0x5812631a5cf5d3ed); + var x67: u64 = undefined; + var x68: u1 = undefined; + addcarryxU64(&x67, &x68, 0x0, x66, x63); + var x69: u64 = undefined; + var x70: u1 = undefined; + addcarryxU64(&x69, &x70, 0x0, x51, x65); + var x71: u64 = undefined; + var x72: u1 = undefined; + addcarryxU64(&x71, &x72, x70, x53, x67); + var x73: u64 = undefined; + var x74: u1 = undefined; + addcarryxU64(&x73, &x74, x72, x55, (cast(u64, x68) + x64)); + var x75: u64 = undefined; + var x76: u1 = undefined; + addcarryxU64(&x75, &x76, x74, x57, x61); + var x77: u64 = undefined; + var x78: u64 = undefined; + mulxU64(&x77, &x78, x2, 0x399411b7c309a3d); + var x79: u64 = undefined; + var x80: u64 = undefined; + mulxU64(&x79, &x80, x2, 0xceec73d217f5be65); + var x81: u64 = undefined; + var x82: u64 = undefined; + mulxU64(&x81, &x82, x2, 0xd00e1ba768859347); + var x83: u64 = undefined; + var x84: u64 = undefined; + mulxU64(&x83, &x84, x2, 0xa40611e3449c0f01); + var x85: u64 = undefined; + var x86: u1 = undefined; + addcarryxU64(&x85, &x86, 0x0, x84, x81); + var x87: u64 = undefined; + var x88: u1 = undefined; + addcarryxU64(&x87, &x88, x86, x82, x79); + var x89: u64 = undefined; + var x90: u1 = undefined; + addcarryxU64(&x89, &x90, x88, x80, x77); + var x91: u64 = undefined; + var x92: u1 = undefined; + addcarryxU64(&x91, &x92, 0x0, x71, x83); + var x93: u64 = undefined; + var x94: u1 = undefined; + addcarryxU64(&x93, &x94, x92, x73, x85); + var x95: u64 = undefined; + var x96: u1 = undefined; + addcarryxU64(&x95, &x96, x94, x75, x87); + var x97: u64 = undefined; + var x98: u1 = undefined; + addcarryxU64(&x97, &x98, x96, ((cast(u64, x76) + (cast(u64, x58) + (cast(u64, x50) + x38))) + x62), x89); + var x99: u64 = undefined; + var x100: u64 = undefined; + mulxU64(&x99, &x100, x91, 0xd2b51da312547e1b); + var x101: u64 = undefined; + var x102: u64 = undefined; + mulxU64(&x101, &x102, x99, 0x1000000000000000); + var x103: u64 = undefined; + var x104: u64 = undefined; + mulxU64(&x103, &x104, x99, 0x14def9dea2f79cd6); + var x105: u64 = undefined; + var x106: u64 = undefined; + mulxU64(&x105, &x106, x99, 0x5812631a5cf5d3ed); + var x107: u64 = undefined; + var x108: u1 = undefined; + addcarryxU64(&x107, &x108, 0x0, x106, x103); + var x109: u64 = undefined; + var x110: u1 = undefined; + addcarryxU64(&x109, &x110, 0x0, x91, x105); + var x111: u64 = undefined; + var x112: u1 = undefined; + addcarryxU64(&x111, &x112, x110, x93, x107); + var x113: u64 = undefined; + var x114: u1 = undefined; + addcarryxU64(&x113, &x114, x112, x95, (cast(u64, x108) + x104)); + var x115: u64 = undefined; + var x116: u1 = undefined; + addcarryxU64(&x115, &x116, x114, x97, x101); + var x117: u64 = undefined; + var x118: u64 = undefined; + mulxU64(&x117, &x118, x3, 0x399411b7c309a3d); + var x119: u64 = undefined; + var x120: u64 = undefined; + mulxU64(&x119, &x120, x3, 0xceec73d217f5be65); + var x121: u64 = undefined; + var x122: u64 = undefined; + mulxU64(&x121, &x122, x3, 0xd00e1ba768859347); + var x123: u64 = undefined; + var x124: u64 = undefined; + mulxU64(&x123, &x124, x3, 0xa40611e3449c0f01); + var x125: u64 = undefined; + var x126: u1 = undefined; + addcarryxU64(&x125, &x126, 0x0, x124, x121); + var x127: u64 = undefined; + var x128: u1 = undefined; + addcarryxU64(&x127, &x128, x126, x122, x119); + var x129: u64 = undefined; + var x130: u1 = undefined; + addcarryxU64(&x129, &x130, x128, x120, x117); + var x131: u64 = undefined; + var x132: u1 = undefined; + addcarryxU64(&x131, &x132, 0x0, x111, x123); + var x133: u64 = undefined; + var x134: u1 = undefined; + addcarryxU64(&x133, &x134, x132, x113, x125); + var x135: u64 = undefined; + var x136: u1 = undefined; + addcarryxU64(&x135, &x136, x134, x115, x127); + var x137: u64 = undefined; + var x138: u1 = undefined; + addcarryxU64(&x137, &x138, x136, ((cast(u64, x116) + (cast(u64, x98) + (cast(u64, x90) + x78))) + x102), x129); + var x139: u64 = undefined; + var x140: u64 = undefined; + mulxU64(&x139, &x140, x131, 0xd2b51da312547e1b); + var x141: u64 = undefined; + var x142: u64 = undefined; + mulxU64(&x141, &x142, x139, 0x1000000000000000); + var x143: u64 = undefined; + var x144: u64 = undefined; + mulxU64(&x143, &x144, x139, 0x14def9dea2f79cd6); + var x145: u64 = undefined; + var x146: u64 = undefined; + mulxU64(&x145, &x146, x139, 0x5812631a5cf5d3ed); + var x147: u64 = undefined; + var x148: u1 = undefined; + addcarryxU64(&x147, &x148, 0x0, x146, x143); + var x149: u64 = undefined; + var x150: u1 = undefined; + addcarryxU64(&x149, &x150, 0x0, x131, x145); + var x151: u64 = undefined; + var x152: u1 = undefined; + addcarryxU64(&x151, &x152, x150, x133, x147); + var x153: u64 = undefined; + var x154: u1 = undefined; + addcarryxU64(&x153, &x154, x152, x135, (cast(u64, x148) + x144)); + var x155: u64 = undefined; + var x156: u1 = undefined; + addcarryxU64(&x155, &x156, x154, x137, x141); + const x157 = ((cast(u64, x156) + (cast(u64, x138) + (cast(u64, x130) + x118))) + x142); + var x158: u64 = undefined; + var x159: u1 = undefined; + subborrowxU64(&x158, &x159, 0x0, x151, 0x5812631a5cf5d3ed); + var x160: u64 = undefined; + var x161: u1 = undefined; + subborrowxU64(&x160, &x161, x159, x153, 0x14def9dea2f79cd6); + var x162: u64 = undefined; + var x163: u1 = undefined; + subborrowxU64(&x162, &x163, x161, x155, cast(u64, 0x0)); + var x164: u64 = undefined; + var x165: u1 = undefined; + subborrowxU64(&x164, &x165, x163, x157, 0x1000000000000000); + var x166: u64 = undefined; + var x167: u1 = undefined; + subborrowxU64(&x166, &x167, x165, cast(u64, 0x0), cast(u64, 0x0)); + var x168: u64 = undefined; + cmovznzU64(&x168, x167, x158, x151); + var x169: u64 = undefined; + cmovznzU64(&x169, x167, x160, x153); + var x170: u64 = undefined; + cmovznzU64(&x170, x167, x162, x155); + var x171: u64 = undefined; + cmovznzU64(&x171, x167, x164, x157); + out1[0] = x168; + out1[1] = x169; + out1[2] = x170; + out1[3] = x171; +} + +/// The function nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +pub fn nonzero(out1: *u64, arg1: [4]u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3])))); + out1.* = x1; +} + +/// The function selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn selectznz(out1: *[4]u64, arg1: u1, arg2: [4]u64, arg3: [4]u64) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + cmovznzU64(&x1, arg1, (arg2[0]), (arg3[0])); + var x2: u64 = undefined; + cmovznzU64(&x2, arg1, (arg2[1]), (arg3[1])); + var x3: u64 = undefined; + cmovznzU64(&x3, arg1, (arg2[2]), (arg3[2])); + var x4: u64 = undefined; + cmovznzU64(&x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/// The function toBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1fffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] +pub fn toBytes(out1: *[32]u8, arg1: [4]u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[3]); + const x2 = (arg1[2]); + const x3 = (arg1[1]); + const x4 = (arg1[0]); + const x5 = cast(u8, (x4 & cast(u64, 0xff))); + const x6 = (x4 >> 8); + const x7 = cast(u8, (x6 & cast(u64, 0xff))); + const x8 = (x6 >> 8); + const x9 = cast(u8, (x8 & cast(u64, 0xff))); + const x10 = (x8 >> 8); + const x11 = cast(u8, (x10 & cast(u64, 0xff))); + const x12 = (x10 >> 8); + const x13 = cast(u8, (x12 & cast(u64, 0xff))); + const x14 = (x12 >> 8); + const x15 = cast(u8, (x14 & cast(u64, 0xff))); + const x16 = (x14 >> 8); + const x17 = cast(u8, (x16 & cast(u64, 0xff))); + const x18 = cast(u8, (x16 >> 8)); + const x19 = cast(u8, (x3 & cast(u64, 0xff))); + const x20 = (x3 >> 8); + const x21 = cast(u8, (x20 & cast(u64, 0xff))); + const x22 = (x20 >> 8); + const x23 = cast(u8, (x22 & cast(u64, 0xff))); + const x24 = (x22 >> 8); + const x25 = cast(u8, (x24 & cast(u64, 0xff))); + const x26 = (x24 >> 8); + const x27 = cast(u8, (x26 & cast(u64, 0xff))); + const x28 = (x26 >> 8); + const x29 = cast(u8, (x28 & cast(u64, 0xff))); + const x30 = (x28 >> 8); + const x31 = cast(u8, (x30 & cast(u64, 0xff))); + const x32 = cast(u8, (x30 >> 8)); + const x33 = cast(u8, (x2 & cast(u64, 0xff))); + const x34 = (x2 >> 8); + const x35 = cast(u8, (x34 & cast(u64, 0xff))); + const x36 = (x34 >> 8); + const x37 = cast(u8, (x36 & cast(u64, 0xff))); + const x38 = (x36 >> 8); + const x39 = cast(u8, (x38 & cast(u64, 0xff))); + const x40 = (x38 >> 8); + const x41 = cast(u8, (x40 & cast(u64, 0xff))); + const x42 = (x40 >> 8); + const x43 = cast(u8, (x42 & cast(u64, 0xff))); + const x44 = (x42 >> 8); + const x45 = cast(u8, (x44 & cast(u64, 0xff))); + const x46 = cast(u8, (x44 >> 8)); + const x47 = cast(u8, (x1 & cast(u64, 0xff))); + const x48 = (x1 >> 8); + const x49 = cast(u8, (x48 & cast(u64, 0xff))); + const x50 = (x48 >> 8); + const x51 = cast(u8, (x50 & cast(u64, 0xff))); + const x52 = (x50 >> 8); + const x53 = cast(u8, (x52 & cast(u64, 0xff))); + const x54 = (x52 >> 8); + const x55 = cast(u8, (x54 & cast(u64, 0xff))); + const x56 = (x54 >> 8); + const x57 = cast(u8, (x56 & cast(u64, 0xff))); + const x58 = (x56 >> 8); + const x59 = cast(u8, (x58 & cast(u64, 0xff))); + const x60 = cast(u8, (x58 >> 8)); + out1[0] = x5; + out1[1] = x7; + out1[2] = x9; + out1[3] = x11; + out1[4] = x13; + out1[5] = x15; + out1[6] = x17; + out1[7] = x18; + out1[8] = x19; + out1[9] = x21; + out1[10] = x23; + out1[11] = x25; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x39; + out1[20] = x41; + out1[21] = x43; + out1[22] = x45; + out1[23] = x46; + out1[24] = x47; + out1[25] = x49; + out1[26] = x51; + out1[27] = x53; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; +} + +/// The function fromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1fffffffffffffff]] +pub fn fromBytes(out1: *[4]u64, arg1: [32]u8) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u64, (arg1[31])) << 56); + const x2 = (cast(u64, (arg1[30])) << 48); + const x3 = (cast(u64, (arg1[29])) << 40); + const x4 = (cast(u64, (arg1[28])) << 32); + const x5 = (cast(u64, (arg1[27])) << 24); + const x6 = (cast(u64, (arg1[26])) << 16); + const x7 = (cast(u64, (arg1[25])) << 8); + const x8 = (arg1[24]); + const x9 = (cast(u64, (arg1[23])) << 56); + const x10 = (cast(u64, (arg1[22])) << 48); + const x11 = (cast(u64, (arg1[21])) << 40); + const x12 = (cast(u64, (arg1[20])) << 32); + const x13 = (cast(u64, (arg1[19])) << 24); + const x14 = (cast(u64, (arg1[18])) << 16); + const x15 = (cast(u64, (arg1[17])) << 8); + const x16 = (arg1[16]); + const x17 = (cast(u64, (arg1[15])) << 56); + const x18 = (cast(u64, (arg1[14])) << 48); + const x19 = (cast(u64, (arg1[13])) << 40); + const x20 = (cast(u64, (arg1[12])) << 32); + const x21 = (cast(u64, (arg1[11])) << 24); + const x22 = (cast(u64, (arg1[10])) << 16); + const x23 = (cast(u64, (arg1[9])) << 8); + const x24 = (arg1[8]); + const x25 = (cast(u64, (arg1[7])) << 56); + const x26 = (cast(u64, (arg1[6])) << 48); + const x27 = (cast(u64, (arg1[5])) << 40); + const x28 = (cast(u64, (arg1[4])) << 32); + const x29 = (cast(u64, (arg1[3])) << 24); + const x30 = (cast(u64, (arg1[2])) << 16); + const x31 = (cast(u64, (arg1[1])) << 8); + const x32 = (arg1[0]); + const x33 = (x31 + cast(u64, x32)); + const x34 = (x30 + x33); + const x35 = (x29 + x34); + const x36 = (x28 + x35); + const x37 = (x27 + x36); + const x38 = (x26 + x37); + const x39 = (x25 + x38); + const x40 = (x23 + cast(u64, x24)); + const x41 = (x22 + x40); + const x42 = (x21 + x41); + const x43 = (x20 + x42); + const x44 = (x19 + x43); + const x45 = (x18 + x44); + const x46 = (x17 + x45); + const x47 = (x15 + cast(u64, x16)); + const x48 = (x14 + x47); + const x49 = (x13 + x48); + const x50 = (x12 + x49); + const x51 = (x11 + x50); + const x52 = (x10 + x51); + const x53 = (x9 + x52); + const x54 = (x7 + cast(u64, x8)); + const x55 = (x6 + x54); + const x56 = (x5 + x55); + const x57 = (x4 + x56); + const x58 = (x3 + x57); + const x59 = (x2 + x58); + const x60 = (x1 + x59); + out1[0] = x39; + out1[1] = x46; + out1[2] = x53; + out1[3] = x60; +} + +/// The function setOne returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn setOne(out1: *MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xd6ec31748d98951d; + out1[1] = 0xc6ef5bf4737dcf70; + out1[2] = 0xfffffffffffffffe; + out1[3] = 0xfffffffffffffff; +} + +/// The function msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn msat(out1: *[5]u64) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0x5812631a5cf5d3ed; + out1[1] = 0x14def9dea2f79cd6; + out1[2] = cast(u64, 0x0); + out1[3] = 0x1000000000000000; + out1[4] = cast(u64, 0x0); +} + +/// The function divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn divstep(out1: *u64, out2: *[5]u64, out3: *[5]u64, out4: *[4]u64, out5: *[4]u64, arg1: u64, arg2: [5]u64, arg3: [5]u64, arg4: [4]u64, arg5: [4]u64) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + addcarryxU64(&x1, &x2, 0x0, (~arg1), cast(u64, 0x1)); + const x3 = (cast(u1, (x1 >> 63)) & cast(u1, ((arg3[0]) & cast(u64, 0x1)))); + var x4: u64 = undefined; + var x5: u1 = undefined; + addcarryxU64(&x4, &x5, 0x0, (~arg1), cast(u64, 0x1)); + var x6: u64 = undefined; + cmovznzU64(&x6, x3, arg1, x4); + var x7: u64 = undefined; + cmovznzU64(&x7, x3, (arg2[0]), (arg3[0])); + var x8: u64 = undefined; + cmovznzU64(&x8, x3, (arg2[1]), (arg3[1])); + var x9: u64 = undefined; + cmovznzU64(&x9, x3, (arg2[2]), (arg3[2])); + var x10: u64 = undefined; + cmovznzU64(&x10, x3, (arg2[3]), (arg3[3])); + var x11: u64 = undefined; + cmovznzU64(&x11, x3, (arg2[4]), (arg3[4])); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, 0x0, cast(u64, 0x1), (~(arg2[0]))); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, cast(u64, 0x0), (~(arg2[1]))); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, cast(u64, 0x0), (~(arg2[2]))); + var x18: u64 = undefined; + var x19: u1 = undefined; + addcarryxU64(&x18, &x19, x17, cast(u64, 0x0), (~(arg2[3]))); + var x20: u64 = undefined; + var x21: u1 = undefined; + addcarryxU64(&x20, &x21, x19, cast(u64, 0x0), (~(arg2[4]))); + var x22: u64 = undefined; + cmovznzU64(&x22, x3, (arg3[0]), x12); + var x23: u64 = undefined; + cmovznzU64(&x23, x3, (arg3[1]), x14); + var x24: u64 = undefined; + cmovznzU64(&x24, x3, (arg3[2]), x16); + var x25: u64 = undefined; + cmovznzU64(&x25, x3, (arg3[3]), x18); + var x26: u64 = undefined; + cmovznzU64(&x26, x3, (arg3[4]), x20); + var x27: u64 = undefined; + cmovznzU64(&x27, x3, (arg4[0]), (arg5[0])); + var x28: u64 = undefined; + cmovznzU64(&x28, x3, (arg4[1]), (arg5[1])); + var x29: u64 = undefined; + cmovznzU64(&x29, x3, (arg4[2]), (arg5[2])); + var x30: u64 = undefined; + cmovznzU64(&x30, x3, (arg4[3]), (arg5[3])); + var x31: u64 = undefined; + var x32: u1 = undefined; + addcarryxU64(&x31, &x32, 0x0, x27, x27); + var x33: u64 = undefined; + var x34: u1 = undefined; + addcarryxU64(&x33, &x34, x32, x28, x28); + var x35: u64 = undefined; + var x36: u1 = undefined; + addcarryxU64(&x35, &x36, x34, x29, x29); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, x36, x30, x30); + var x39: u64 = undefined; + var x40: u1 = undefined; + subborrowxU64(&x39, &x40, 0x0, x31, 0x5812631a5cf5d3ed); + var x41: u64 = undefined; + var x42: u1 = undefined; + subborrowxU64(&x41, &x42, x40, x33, 0x14def9dea2f79cd6); + var x43: u64 = undefined; + var x44: u1 = undefined; + subborrowxU64(&x43, &x44, x42, x35, cast(u64, 0x0)); + var x45: u64 = undefined; + var x46: u1 = undefined; + subborrowxU64(&x45, &x46, x44, x37, 0x1000000000000000); + var x47: u64 = undefined; + var x48: u1 = undefined; + subborrowxU64(&x47, &x48, x46, cast(u64, x38), cast(u64, 0x0)); + const x49 = (arg4[3]); + const x50 = (arg4[2]); + const x51 = (arg4[1]); + const x52 = (arg4[0]); + var x53: u64 = undefined; + var x54: u1 = undefined; + subborrowxU64(&x53, &x54, 0x0, cast(u64, 0x0), x52); + var x55: u64 = undefined; + var x56: u1 = undefined; + subborrowxU64(&x55, &x56, x54, cast(u64, 0x0), x51); + var x57: u64 = undefined; + var x58: u1 = undefined; + subborrowxU64(&x57, &x58, x56, cast(u64, 0x0), x50); + var x59: u64 = undefined; + var x60: u1 = undefined; + subborrowxU64(&x59, &x60, x58, cast(u64, 0x0), x49); + var x61: u64 = undefined; + cmovznzU64(&x61, x60, cast(u64, 0x0), 0xffffffffffffffff); + var x62: u64 = undefined; + var x63: u1 = undefined; + addcarryxU64(&x62, &x63, 0x0, x53, (x61 & 0x5812631a5cf5d3ed)); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, x55, (x61 & 0x14def9dea2f79cd6)); + var x66: u64 = undefined; + var x67: u1 = undefined; + addcarryxU64(&x66, &x67, x65, x57, cast(u64, 0x0)); + var x68: u64 = undefined; + var x69: u1 = undefined; + addcarryxU64(&x68, &x69, x67, x59, (x61 & 0x1000000000000000)); + var x70: u64 = undefined; + cmovznzU64(&x70, x3, (arg5[0]), x62); + var x71: u64 = undefined; + cmovznzU64(&x71, x3, (arg5[1]), x64); + var x72: u64 = undefined; + cmovznzU64(&x72, x3, (arg5[2]), x66); + var x73: u64 = undefined; + cmovznzU64(&x73, x3, (arg5[3]), x68); + const x74 = cast(u1, (x22 & cast(u64, 0x1))); + var x75: u64 = undefined; + cmovznzU64(&x75, x74, cast(u64, 0x0), x7); + var x76: u64 = undefined; + cmovznzU64(&x76, x74, cast(u64, 0x0), x8); + var x77: u64 = undefined; + cmovznzU64(&x77, x74, cast(u64, 0x0), x9); + var x78: u64 = undefined; + cmovznzU64(&x78, x74, cast(u64, 0x0), x10); + var x79: u64 = undefined; + cmovznzU64(&x79, x74, cast(u64, 0x0), x11); + var x80: u64 = undefined; + var x81: u1 = undefined; + addcarryxU64(&x80, &x81, 0x0, x22, x75); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, x81, x23, x76); + var x84: u64 = undefined; + var x85: u1 = undefined; + addcarryxU64(&x84, &x85, x83, x24, x77); + var x86: u64 = undefined; + var x87: u1 = undefined; + addcarryxU64(&x86, &x87, x85, x25, x78); + var x88: u64 = undefined; + var x89: u1 = undefined; + addcarryxU64(&x88, &x89, x87, x26, x79); + var x90: u64 = undefined; + cmovznzU64(&x90, x74, cast(u64, 0x0), x27); + var x91: u64 = undefined; + cmovznzU64(&x91, x74, cast(u64, 0x0), x28); + var x92: u64 = undefined; + cmovznzU64(&x92, x74, cast(u64, 0x0), x29); + var x93: u64 = undefined; + cmovznzU64(&x93, x74, cast(u64, 0x0), x30); + var x94: u64 = undefined; + var x95: u1 = undefined; + addcarryxU64(&x94, &x95, 0x0, x70, x90); + var x96: u64 = undefined; + var x97: u1 = undefined; + addcarryxU64(&x96, &x97, x95, x71, x91); + var x98: u64 = undefined; + var x99: u1 = undefined; + addcarryxU64(&x98, &x99, x97, x72, x92); + var x100: u64 = undefined; + var x101: u1 = undefined; + addcarryxU64(&x100, &x101, x99, x73, x93); + var x102: u64 = undefined; + var x103: u1 = undefined; + subborrowxU64(&x102, &x103, 0x0, x94, 0x5812631a5cf5d3ed); + var x104: u64 = undefined; + var x105: u1 = undefined; + subborrowxU64(&x104, &x105, x103, x96, 0x14def9dea2f79cd6); + var x106: u64 = undefined; + var x107: u1 = undefined; + subborrowxU64(&x106, &x107, x105, x98, cast(u64, 0x0)); + var x108: u64 = undefined; + var x109: u1 = undefined; + subborrowxU64(&x108, &x109, x107, x100, 0x1000000000000000); + var x110: u64 = undefined; + var x111: u1 = undefined; + subborrowxU64(&x110, &x111, x109, cast(u64, x101), cast(u64, 0x0)); + var x112: u64 = undefined; + var x113: u1 = undefined; + addcarryxU64(&x112, &x113, 0x0, x6, cast(u64, 0x1)); + const x114 = ((x80 >> 1) | ((x82 << 63) & 0xffffffffffffffff)); + const x115 = ((x82 >> 1) | ((x84 << 63) & 0xffffffffffffffff)); + const x116 = ((x84 >> 1) | ((x86 << 63) & 0xffffffffffffffff)); + const x117 = ((x86 >> 1) | ((x88 << 63) & 0xffffffffffffffff)); + const x118 = ((x88 & 0x8000000000000000) | (x88 >> 1)); + var x119: u64 = undefined; + cmovznzU64(&x119, x48, x39, x31); + var x120: u64 = undefined; + cmovznzU64(&x120, x48, x41, x33); + var x121: u64 = undefined; + cmovznzU64(&x121, x48, x43, x35); + var x122: u64 = undefined; + cmovznzU64(&x122, x48, x45, x37); + var x123: u64 = undefined; + cmovznzU64(&x123, x111, x102, x94); + var x124: u64 = undefined; + cmovznzU64(&x124, x111, x104, x96); + var x125: u64 = undefined; + cmovznzU64(&x125, x111, x106, x98); + var x126: u64 = undefined; + cmovznzU64(&x126, x111, x108, x100); + out1.* = x112; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out3[0] = x114; + out3[1] = x115; + out3[2] = x116; + out3[3] = x117; + out3[4] = x118; + out4[0] = x119; + out4[1] = x120; + out4[2] = x121; + out4[3] = x122; + out5[0] = x123; + out5[1] = x124; + out5[2] = x125; + out5[3] = x126; +} + +/// The function divstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn divstepPrecomp(out1: *[4]u64) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xd70af84436a7cb92; + out1[1] = 0x5f71c978b0b8b159; + out1[2] = 0xe76d816974947f1a; + out1[3] = 0x19a2d36f193e4ff; +} diff --git a/fiat-zig/src/p256_scalar_32.zig b/fiat-zig/src/p256_scalar_32.zig new file mode 100644 index 0000000000..b12bf3e1c0 --- /dev/null +++ b/fiat-zig/src/p256_scalar_32.zig @@ -0,0 +1,5336 @@ +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Zig --internal-static --public-function-case camelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case UpperCamelCase --no-prefix-fiat --package-name p256_scalar '' 32 '2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// curve description (via package name): p256_scalar +// machine_wordsize = 32 (from "32") +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// m = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 (from "2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247") +// +// NOTE: In addition to the bounds specified above each function, all +// functions synthesized for this Montgomery arithmetic require the +// input to be strictly less than the prime modulus (m), and also +// require the input to be in the unique saturated representation. +// All functions also ensure that these two properties are true of +// return values. +// +// Computed values: +// eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +// twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in +// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 + +const std = @import("std"); +const mode = @import("builtin").mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels + +inline fn cast(comptime DestType: type, target: anytype) DestType { + if (@typeInfo(@TypeOf(target)) == .Int) { + const dest = @typeInfo(DestType).Int; + const source = @typeInfo(@TypeOf(target)).Int; + if (dest.bits < source.bits) { + return @bitCast(DestType, @truncate(std.meta.Int(source.signedness, dest.bits), target)); + } else { + return @bitCast(DestType, @as(std.meta.Int(source.signedness, dest.bits), target)); + } + } + return @as(DestType, target); +} + +// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub const MontgomeryDomainFieldElement = [8]u32; + +// The type NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub const NonMontgomeryDomainFieldElement = [8]u32; + +/// The function addcarryxU32 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^32 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +inline fn addcarryxU32(out1: *u32, out2: *u1, arg1: u1, arg2: u32, arg3: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(u64, arg1) + cast(u64, arg2)) + cast(u64, arg3)); + const x2 = cast(u32, (x1 & cast(u64, 0xffffffff))); + const x3 = cast(u1, (x1 >> 32)); + out1.* = x2; + out2.* = x3; +} + +/// The function subborrowxU32 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^32 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +inline fn subborrowxU32(out1: *u32, out2: *u1, arg1: u1, arg2: u32, arg3: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(i64, arg2) - cast(i64, arg1)) - cast(i64, arg3)); + const x2 = cast(i1, (x1 >> 32)); + const x3 = cast(u32, (x1 & cast(i64, 0xffffffff))); + out1.* = x3; + out2.* = cast(u1, (cast(i2, 0x0) - cast(i2, x2))); +} + +/// The function mulxU32 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^32 +/// out2 = ⌊arg1 * arg2 / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0xffffffff] +inline fn mulxU32(out1: *u32, out2: *u32, arg1: u32, arg2: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u64, arg1) * cast(u64, arg2)); + const x2 = cast(u32, (x1 & cast(u64, 0xffffffff))); + const x3 = cast(u32, (x1 >> 32)); + out1.* = x2; + out2.* = x3; +} + +/// The function cmovznzU32 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +inline fn cmovznzU32(out1: *u32, arg1: u1, arg2: u32, arg3: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (~(~arg1)); + const x2 = cast(u32, (cast(i64, cast(i1, (cast(i2, 0x0) - cast(i2, x1)))) & cast(i64, 0xffffffff))); + const x3 = ((x2 & arg3) | ((~x2) & arg2)); + out1.* = x3; +} + +/// The function mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn mul(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[6]); + const x7 = (arg1[7]); + const x8 = (arg1[0]); + var x9: u32 = undefined; + var x10: u32 = undefined; + mulxU32(&x9, &x10, x8, (arg2[7])); + var x11: u32 = undefined; + var x12: u32 = undefined; + mulxU32(&x11, &x12, x8, (arg2[6])); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x8, (arg2[5])); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x8, (arg2[4])); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x8, (arg2[3])); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x8, (arg2[2])); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x8, (arg2[1])); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x8, (arg2[0])); + var x25: u32 = undefined; + var x26: u1 = undefined; + addcarryxU32(&x25, &x26, 0x0, x24, x21); + var x27: u32 = undefined; + var x28: u1 = undefined; + addcarryxU32(&x27, &x28, x26, x22, x19); + var x29: u32 = undefined; + var x30: u1 = undefined; + addcarryxU32(&x29, &x30, x28, x20, x17); + var x31: u32 = undefined; + var x32: u1 = undefined; + addcarryxU32(&x31, &x32, x30, x18, x15); + var x33: u32 = undefined; + var x34: u1 = undefined; + addcarryxU32(&x33, &x34, x32, x16, x13); + var x35: u32 = undefined; + var x36: u1 = undefined; + addcarryxU32(&x35, &x36, x34, x14, x11); + var x37: u32 = undefined; + var x38: u1 = undefined; + addcarryxU32(&x37, &x38, x36, x12, x9); + const x39 = (cast(u32, x38) + x10); + var x40: u32 = undefined; + var x41: u32 = undefined; + mulxU32(&x40, &x41, x23, 0xee00bc4f); + var x42: u32 = undefined; + var x43: u32 = undefined; + mulxU32(&x42, &x43, x40, 0xffffffff); + var x44: u32 = undefined; + var x45: u32 = undefined; + mulxU32(&x44, &x45, x40, 0xffffffff); + var x46: u32 = undefined; + var x47: u32 = undefined; + mulxU32(&x46, &x47, x40, 0xffffffff); + var x48: u32 = undefined; + var x49: u32 = undefined; + mulxU32(&x48, &x49, x40, 0xbce6faad); + var x50: u32 = undefined; + var x51: u32 = undefined; + mulxU32(&x50, &x51, x40, 0xa7179e84); + var x52: u32 = undefined; + var x53: u32 = undefined; + mulxU32(&x52, &x53, x40, 0xf3b9cac2); + var x54: u32 = undefined; + var x55: u32 = undefined; + mulxU32(&x54, &x55, x40, 0xfc632551); + var x56: u32 = undefined; + var x57: u1 = undefined; + addcarryxU32(&x56, &x57, 0x0, x55, x52); + var x58: u32 = undefined; + var x59: u1 = undefined; + addcarryxU32(&x58, &x59, x57, x53, x50); + var x60: u32 = undefined; + var x61: u1 = undefined; + addcarryxU32(&x60, &x61, x59, x51, x48); + var x62: u32 = undefined; + var x63: u1 = undefined; + addcarryxU32(&x62, &x63, x61, x49, x46); + var x64: u32 = undefined; + var x65: u1 = undefined; + addcarryxU32(&x64, &x65, x63, x47, x44); + const x66 = (cast(u32, x65) + x45); + var x67: u32 = undefined; + var x68: u1 = undefined; + addcarryxU32(&x67, &x68, 0x0, x23, x54); + var x69: u32 = undefined; + var x70: u1 = undefined; + addcarryxU32(&x69, &x70, x68, x25, x56); + var x71: u32 = undefined; + var x72: u1 = undefined; + addcarryxU32(&x71, &x72, x70, x27, x58); + var x73: u32 = undefined; + var x74: u1 = undefined; + addcarryxU32(&x73, &x74, x72, x29, x60); + var x75: u32 = undefined; + var x76: u1 = undefined; + addcarryxU32(&x75, &x76, x74, x31, x62); + var x77: u32 = undefined; + var x78: u1 = undefined; + addcarryxU32(&x77, &x78, x76, x33, x64); + var x79: u32 = undefined; + var x80: u1 = undefined; + addcarryxU32(&x79, &x80, x78, x35, x66); + var x81: u32 = undefined; + var x82: u1 = undefined; + addcarryxU32(&x81, &x82, x80, x37, x42); + var x83: u32 = undefined; + var x84: u1 = undefined; + addcarryxU32(&x83, &x84, x82, x39, x43); + var x85: u32 = undefined; + var x86: u32 = undefined; + mulxU32(&x85, &x86, x1, (arg2[7])); + var x87: u32 = undefined; + var x88: u32 = undefined; + mulxU32(&x87, &x88, x1, (arg2[6])); + var x89: u32 = undefined; + var x90: u32 = undefined; + mulxU32(&x89, &x90, x1, (arg2[5])); + var x91: u32 = undefined; + var x92: u32 = undefined; + mulxU32(&x91, &x92, x1, (arg2[4])); + var x93: u32 = undefined; + var x94: u32 = undefined; + mulxU32(&x93, &x94, x1, (arg2[3])); + var x95: u32 = undefined; + var x96: u32 = undefined; + mulxU32(&x95, &x96, x1, (arg2[2])); + var x97: u32 = undefined; + var x98: u32 = undefined; + mulxU32(&x97, &x98, x1, (arg2[1])); + var x99: u32 = undefined; + var x100: u32 = undefined; + mulxU32(&x99, &x100, x1, (arg2[0])); + var x101: u32 = undefined; + var x102: u1 = undefined; + addcarryxU32(&x101, &x102, 0x0, x100, x97); + var x103: u32 = undefined; + var x104: u1 = undefined; + addcarryxU32(&x103, &x104, x102, x98, x95); + var x105: u32 = undefined; + var x106: u1 = undefined; + addcarryxU32(&x105, &x106, x104, x96, x93); + var x107: u32 = undefined; + var x108: u1 = undefined; + addcarryxU32(&x107, &x108, x106, x94, x91); + var x109: u32 = undefined; + var x110: u1 = undefined; + addcarryxU32(&x109, &x110, x108, x92, x89); + var x111: u32 = undefined; + var x112: u1 = undefined; + addcarryxU32(&x111, &x112, x110, x90, x87); + var x113: u32 = undefined; + var x114: u1 = undefined; + addcarryxU32(&x113, &x114, x112, x88, x85); + const x115 = (cast(u32, x114) + x86); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, 0x0, x69, x99); + var x118: u32 = undefined; + var x119: u1 = undefined; + addcarryxU32(&x118, &x119, x117, x71, x101); + var x120: u32 = undefined; + var x121: u1 = undefined; + addcarryxU32(&x120, &x121, x119, x73, x103); + var x122: u32 = undefined; + var x123: u1 = undefined; + addcarryxU32(&x122, &x123, x121, x75, x105); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, x77, x107); + var x126: u32 = undefined; + var x127: u1 = undefined; + addcarryxU32(&x126, &x127, x125, x79, x109); + var x128: u32 = undefined; + var x129: u1 = undefined; + addcarryxU32(&x128, &x129, x127, x81, x111); + var x130: u32 = undefined; + var x131: u1 = undefined; + addcarryxU32(&x130, &x131, x129, x83, x113); + var x132: u32 = undefined; + var x133: u1 = undefined; + addcarryxU32(&x132, &x133, x131, cast(u32, x84), x115); + var x134: u32 = undefined; + var x135: u32 = undefined; + mulxU32(&x134, &x135, x116, 0xee00bc4f); + var x136: u32 = undefined; + var x137: u32 = undefined; + mulxU32(&x136, &x137, x134, 0xffffffff); + var x138: u32 = undefined; + var x139: u32 = undefined; + mulxU32(&x138, &x139, x134, 0xffffffff); + var x140: u32 = undefined; + var x141: u32 = undefined; + mulxU32(&x140, &x141, x134, 0xffffffff); + var x142: u32 = undefined; + var x143: u32 = undefined; + mulxU32(&x142, &x143, x134, 0xbce6faad); + var x144: u32 = undefined; + var x145: u32 = undefined; + mulxU32(&x144, &x145, x134, 0xa7179e84); + var x146: u32 = undefined; + var x147: u32 = undefined; + mulxU32(&x146, &x147, x134, 0xf3b9cac2); + var x148: u32 = undefined; + var x149: u32 = undefined; + mulxU32(&x148, &x149, x134, 0xfc632551); + var x150: u32 = undefined; + var x151: u1 = undefined; + addcarryxU32(&x150, &x151, 0x0, x149, x146); + var x152: u32 = undefined; + var x153: u1 = undefined; + addcarryxU32(&x152, &x153, x151, x147, x144); + var x154: u32 = undefined; + var x155: u1 = undefined; + addcarryxU32(&x154, &x155, x153, x145, x142); + var x156: u32 = undefined; + var x157: u1 = undefined; + addcarryxU32(&x156, &x157, x155, x143, x140); + var x158: u32 = undefined; + var x159: u1 = undefined; + addcarryxU32(&x158, &x159, x157, x141, x138); + const x160 = (cast(u32, x159) + x139); + var x161: u32 = undefined; + var x162: u1 = undefined; + addcarryxU32(&x161, &x162, 0x0, x116, x148); + var x163: u32 = undefined; + var x164: u1 = undefined; + addcarryxU32(&x163, &x164, x162, x118, x150); + var x165: u32 = undefined; + var x166: u1 = undefined; + addcarryxU32(&x165, &x166, x164, x120, x152); + var x167: u32 = undefined; + var x168: u1 = undefined; + addcarryxU32(&x167, &x168, x166, x122, x154); + var x169: u32 = undefined; + var x170: u1 = undefined; + addcarryxU32(&x169, &x170, x168, x124, x156); + var x171: u32 = undefined; + var x172: u1 = undefined; + addcarryxU32(&x171, &x172, x170, x126, x158); + var x173: u32 = undefined; + var x174: u1 = undefined; + addcarryxU32(&x173, &x174, x172, x128, x160); + var x175: u32 = undefined; + var x176: u1 = undefined; + addcarryxU32(&x175, &x176, x174, x130, x136); + var x177: u32 = undefined; + var x178: u1 = undefined; + addcarryxU32(&x177, &x178, x176, x132, x137); + const x179 = (cast(u32, x178) + cast(u32, x133)); + var x180: u32 = undefined; + var x181: u32 = undefined; + mulxU32(&x180, &x181, x2, (arg2[7])); + var x182: u32 = undefined; + var x183: u32 = undefined; + mulxU32(&x182, &x183, x2, (arg2[6])); + var x184: u32 = undefined; + var x185: u32 = undefined; + mulxU32(&x184, &x185, x2, (arg2[5])); + var x186: u32 = undefined; + var x187: u32 = undefined; + mulxU32(&x186, &x187, x2, (arg2[4])); + var x188: u32 = undefined; + var x189: u32 = undefined; + mulxU32(&x188, &x189, x2, (arg2[3])); + var x190: u32 = undefined; + var x191: u32 = undefined; + mulxU32(&x190, &x191, x2, (arg2[2])); + var x192: u32 = undefined; + var x193: u32 = undefined; + mulxU32(&x192, &x193, x2, (arg2[1])); + var x194: u32 = undefined; + var x195: u32 = undefined; + mulxU32(&x194, &x195, x2, (arg2[0])); + var x196: u32 = undefined; + var x197: u1 = undefined; + addcarryxU32(&x196, &x197, 0x0, x195, x192); + var x198: u32 = undefined; + var x199: u1 = undefined; + addcarryxU32(&x198, &x199, x197, x193, x190); + var x200: u32 = undefined; + var x201: u1 = undefined; + addcarryxU32(&x200, &x201, x199, x191, x188); + var x202: u32 = undefined; + var x203: u1 = undefined; + addcarryxU32(&x202, &x203, x201, x189, x186); + var x204: u32 = undefined; + var x205: u1 = undefined; + addcarryxU32(&x204, &x205, x203, x187, x184); + var x206: u32 = undefined; + var x207: u1 = undefined; + addcarryxU32(&x206, &x207, x205, x185, x182); + var x208: u32 = undefined; + var x209: u1 = undefined; + addcarryxU32(&x208, &x209, x207, x183, x180); + const x210 = (cast(u32, x209) + x181); + var x211: u32 = undefined; + var x212: u1 = undefined; + addcarryxU32(&x211, &x212, 0x0, x163, x194); + var x213: u32 = undefined; + var x214: u1 = undefined; + addcarryxU32(&x213, &x214, x212, x165, x196); + var x215: u32 = undefined; + var x216: u1 = undefined; + addcarryxU32(&x215, &x216, x214, x167, x198); + var x217: u32 = undefined; + var x218: u1 = undefined; + addcarryxU32(&x217, &x218, x216, x169, x200); + var x219: u32 = undefined; + var x220: u1 = undefined; + addcarryxU32(&x219, &x220, x218, x171, x202); + var x221: u32 = undefined; + var x222: u1 = undefined; + addcarryxU32(&x221, &x222, x220, x173, x204); + var x223: u32 = undefined; + var x224: u1 = undefined; + addcarryxU32(&x223, &x224, x222, x175, x206); + var x225: u32 = undefined; + var x226: u1 = undefined; + addcarryxU32(&x225, &x226, x224, x177, x208); + var x227: u32 = undefined; + var x228: u1 = undefined; + addcarryxU32(&x227, &x228, x226, x179, x210); + var x229: u32 = undefined; + var x230: u32 = undefined; + mulxU32(&x229, &x230, x211, 0xee00bc4f); + var x231: u32 = undefined; + var x232: u32 = undefined; + mulxU32(&x231, &x232, x229, 0xffffffff); + var x233: u32 = undefined; + var x234: u32 = undefined; + mulxU32(&x233, &x234, x229, 0xffffffff); + var x235: u32 = undefined; + var x236: u32 = undefined; + mulxU32(&x235, &x236, x229, 0xffffffff); + var x237: u32 = undefined; + var x238: u32 = undefined; + mulxU32(&x237, &x238, x229, 0xbce6faad); + var x239: u32 = undefined; + var x240: u32 = undefined; + mulxU32(&x239, &x240, x229, 0xa7179e84); + var x241: u32 = undefined; + var x242: u32 = undefined; + mulxU32(&x241, &x242, x229, 0xf3b9cac2); + var x243: u32 = undefined; + var x244: u32 = undefined; + mulxU32(&x243, &x244, x229, 0xfc632551); + var x245: u32 = undefined; + var x246: u1 = undefined; + addcarryxU32(&x245, &x246, 0x0, x244, x241); + var x247: u32 = undefined; + var x248: u1 = undefined; + addcarryxU32(&x247, &x248, x246, x242, x239); + var x249: u32 = undefined; + var x250: u1 = undefined; + addcarryxU32(&x249, &x250, x248, x240, x237); + var x251: u32 = undefined; + var x252: u1 = undefined; + addcarryxU32(&x251, &x252, x250, x238, x235); + var x253: u32 = undefined; + var x254: u1 = undefined; + addcarryxU32(&x253, &x254, x252, x236, x233); + const x255 = (cast(u32, x254) + x234); + var x256: u32 = undefined; + var x257: u1 = undefined; + addcarryxU32(&x256, &x257, 0x0, x211, x243); + var x258: u32 = undefined; + var x259: u1 = undefined; + addcarryxU32(&x258, &x259, x257, x213, x245); + var x260: u32 = undefined; + var x261: u1 = undefined; + addcarryxU32(&x260, &x261, x259, x215, x247); + var x262: u32 = undefined; + var x263: u1 = undefined; + addcarryxU32(&x262, &x263, x261, x217, x249); + var x264: u32 = undefined; + var x265: u1 = undefined; + addcarryxU32(&x264, &x265, x263, x219, x251); + var x266: u32 = undefined; + var x267: u1 = undefined; + addcarryxU32(&x266, &x267, x265, x221, x253); + var x268: u32 = undefined; + var x269: u1 = undefined; + addcarryxU32(&x268, &x269, x267, x223, x255); + var x270: u32 = undefined; + var x271: u1 = undefined; + addcarryxU32(&x270, &x271, x269, x225, x231); + var x272: u32 = undefined; + var x273: u1 = undefined; + addcarryxU32(&x272, &x273, x271, x227, x232); + const x274 = (cast(u32, x273) + cast(u32, x228)); + var x275: u32 = undefined; + var x276: u32 = undefined; + mulxU32(&x275, &x276, x3, (arg2[7])); + var x277: u32 = undefined; + var x278: u32 = undefined; + mulxU32(&x277, &x278, x3, (arg2[6])); + var x279: u32 = undefined; + var x280: u32 = undefined; + mulxU32(&x279, &x280, x3, (arg2[5])); + var x281: u32 = undefined; + var x282: u32 = undefined; + mulxU32(&x281, &x282, x3, (arg2[4])); + var x283: u32 = undefined; + var x284: u32 = undefined; + mulxU32(&x283, &x284, x3, (arg2[3])); + var x285: u32 = undefined; + var x286: u32 = undefined; + mulxU32(&x285, &x286, x3, (arg2[2])); + var x287: u32 = undefined; + var x288: u32 = undefined; + mulxU32(&x287, &x288, x3, (arg2[1])); + var x289: u32 = undefined; + var x290: u32 = undefined; + mulxU32(&x289, &x290, x3, (arg2[0])); + var x291: u32 = undefined; + var x292: u1 = undefined; + addcarryxU32(&x291, &x292, 0x0, x290, x287); + var x293: u32 = undefined; + var x294: u1 = undefined; + addcarryxU32(&x293, &x294, x292, x288, x285); + var x295: u32 = undefined; + var x296: u1 = undefined; + addcarryxU32(&x295, &x296, x294, x286, x283); + var x297: u32 = undefined; + var x298: u1 = undefined; + addcarryxU32(&x297, &x298, x296, x284, x281); + var x299: u32 = undefined; + var x300: u1 = undefined; + addcarryxU32(&x299, &x300, x298, x282, x279); + var x301: u32 = undefined; + var x302: u1 = undefined; + addcarryxU32(&x301, &x302, x300, x280, x277); + var x303: u32 = undefined; + var x304: u1 = undefined; + addcarryxU32(&x303, &x304, x302, x278, x275); + const x305 = (cast(u32, x304) + x276); + var x306: u32 = undefined; + var x307: u1 = undefined; + addcarryxU32(&x306, &x307, 0x0, x258, x289); + var x308: u32 = undefined; + var x309: u1 = undefined; + addcarryxU32(&x308, &x309, x307, x260, x291); + var x310: u32 = undefined; + var x311: u1 = undefined; + addcarryxU32(&x310, &x311, x309, x262, x293); + var x312: u32 = undefined; + var x313: u1 = undefined; + addcarryxU32(&x312, &x313, x311, x264, x295); + var x314: u32 = undefined; + var x315: u1 = undefined; + addcarryxU32(&x314, &x315, x313, x266, x297); + var x316: u32 = undefined; + var x317: u1 = undefined; + addcarryxU32(&x316, &x317, x315, x268, x299); + var x318: u32 = undefined; + var x319: u1 = undefined; + addcarryxU32(&x318, &x319, x317, x270, x301); + var x320: u32 = undefined; + var x321: u1 = undefined; + addcarryxU32(&x320, &x321, x319, x272, x303); + var x322: u32 = undefined; + var x323: u1 = undefined; + addcarryxU32(&x322, &x323, x321, x274, x305); + var x324: u32 = undefined; + var x325: u32 = undefined; + mulxU32(&x324, &x325, x306, 0xee00bc4f); + var x326: u32 = undefined; + var x327: u32 = undefined; + mulxU32(&x326, &x327, x324, 0xffffffff); + var x328: u32 = undefined; + var x329: u32 = undefined; + mulxU32(&x328, &x329, x324, 0xffffffff); + var x330: u32 = undefined; + var x331: u32 = undefined; + mulxU32(&x330, &x331, x324, 0xffffffff); + var x332: u32 = undefined; + var x333: u32 = undefined; + mulxU32(&x332, &x333, x324, 0xbce6faad); + var x334: u32 = undefined; + var x335: u32 = undefined; + mulxU32(&x334, &x335, x324, 0xa7179e84); + var x336: u32 = undefined; + var x337: u32 = undefined; + mulxU32(&x336, &x337, x324, 0xf3b9cac2); + var x338: u32 = undefined; + var x339: u32 = undefined; + mulxU32(&x338, &x339, x324, 0xfc632551); + var x340: u32 = undefined; + var x341: u1 = undefined; + addcarryxU32(&x340, &x341, 0x0, x339, x336); + var x342: u32 = undefined; + var x343: u1 = undefined; + addcarryxU32(&x342, &x343, x341, x337, x334); + var x344: u32 = undefined; + var x345: u1 = undefined; + addcarryxU32(&x344, &x345, x343, x335, x332); + var x346: u32 = undefined; + var x347: u1 = undefined; + addcarryxU32(&x346, &x347, x345, x333, x330); + var x348: u32 = undefined; + var x349: u1 = undefined; + addcarryxU32(&x348, &x349, x347, x331, x328); + const x350 = (cast(u32, x349) + x329); + var x351: u32 = undefined; + var x352: u1 = undefined; + addcarryxU32(&x351, &x352, 0x0, x306, x338); + var x353: u32 = undefined; + var x354: u1 = undefined; + addcarryxU32(&x353, &x354, x352, x308, x340); + var x355: u32 = undefined; + var x356: u1 = undefined; + addcarryxU32(&x355, &x356, x354, x310, x342); + var x357: u32 = undefined; + var x358: u1 = undefined; + addcarryxU32(&x357, &x358, x356, x312, x344); + var x359: u32 = undefined; + var x360: u1 = undefined; + addcarryxU32(&x359, &x360, x358, x314, x346); + var x361: u32 = undefined; + var x362: u1 = undefined; + addcarryxU32(&x361, &x362, x360, x316, x348); + var x363: u32 = undefined; + var x364: u1 = undefined; + addcarryxU32(&x363, &x364, x362, x318, x350); + var x365: u32 = undefined; + var x366: u1 = undefined; + addcarryxU32(&x365, &x366, x364, x320, x326); + var x367: u32 = undefined; + var x368: u1 = undefined; + addcarryxU32(&x367, &x368, x366, x322, x327); + const x369 = (cast(u32, x368) + cast(u32, x323)); + var x370: u32 = undefined; + var x371: u32 = undefined; + mulxU32(&x370, &x371, x4, (arg2[7])); + var x372: u32 = undefined; + var x373: u32 = undefined; + mulxU32(&x372, &x373, x4, (arg2[6])); + var x374: u32 = undefined; + var x375: u32 = undefined; + mulxU32(&x374, &x375, x4, (arg2[5])); + var x376: u32 = undefined; + var x377: u32 = undefined; + mulxU32(&x376, &x377, x4, (arg2[4])); + var x378: u32 = undefined; + var x379: u32 = undefined; + mulxU32(&x378, &x379, x4, (arg2[3])); + var x380: u32 = undefined; + var x381: u32 = undefined; + mulxU32(&x380, &x381, x4, (arg2[2])); + var x382: u32 = undefined; + var x383: u32 = undefined; + mulxU32(&x382, &x383, x4, (arg2[1])); + var x384: u32 = undefined; + var x385: u32 = undefined; + mulxU32(&x384, &x385, x4, (arg2[0])); + var x386: u32 = undefined; + var x387: u1 = undefined; + addcarryxU32(&x386, &x387, 0x0, x385, x382); + var x388: u32 = undefined; + var x389: u1 = undefined; + addcarryxU32(&x388, &x389, x387, x383, x380); + var x390: u32 = undefined; + var x391: u1 = undefined; + addcarryxU32(&x390, &x391, x389, x381, x378); + var x392: u32 = undefined; + var x393: u1 = undefined; + addcarryxU32(&x392, &x393, x391, x379, x376); + var x394: u32 = undefined; + var x395: u1 = undefined; + addcarryxU32(&x394, &x395, x393, x377, x374); + var x396: u32 = undefined; + var x397: u1 = undefined; + addcarryxU32(&x396, &x397, x395, x375, x372); + var x398: u32 = undefined; + var x399: u1 = undefined; + addcarryxU32(&x398, &x399, x397, x373, x370); + const x400 = (cast(u32, x399) + x371); + var x401: u32 = undefined; + var x402: u1 = undefined; + addcarryxU32(&x401, &x402, 0x0, x353, x384); + var x403: u32 = undefined; + var x404: u1 = undefined; + addcarryxU32(&x403, &x404, x402, x355, x386); + var x405: u32 = undefined; + var x406: u1 = undefined; + addcarryxU32(&x405, &x406, x404, x357, x388); + var x407: u32 = undefined; + var x408: u1 = undefined; + addcarryxU32(&x407, &x408, x406, x359, x390); + var x409: u32 = undefined; + var x410: u1 = undefined; + addcarryxU32(&x409, &x410, x408, x361, x392); + var x411: u32 = undefined; + var x412: u1 = undefined; + addcarryxU32(&x411, &x412, x410, x363, x394); + var x413: u32 = undefined; + var x414: u1 = undefined; + addcarryxU32(&x413, &x414, x412, x365, x396); + var x415: u32 = undefined; + var x416: u1 = undefined; + addcarryxU32(&x415, &x416, x414, x367, x398); + var x417: u32 = undefined; + var x418: u1 = undefined; + addcarryxU32(&x417, &x418, x416, x369, x400); + var x419: u32 = undefined; + var x420: u32 = undefined; + mulxU32(&x419, &x420, x401, 0xee00bc4f); + var x421: u32 = undefined; + var x422: u32 = undefined; + mulxU32(&x421, &x422, x419, 0xffffffff); + var x423: u32 = undefined; + var x424: u32 = undefined; + mulxU32(&x423, &x424, x419, 0xffffffff); + var x425: u32 = undefined; + var x426: u32 = undefined; + mulxU32(&x425, &x426, x419, 0xffffffff); + var x427: u32 = undefined; + var x428: u32 = undefined; + mulxU32(&x427, &x428, x419, 0xbce6faad); + var x429: u32 = undefined; + var x430: u32 = undefined; + mulxU32(&x429, &x430, x419, 0xa7179e84); + var x431: u32 = undefined; + var x432: u32 = undefined; + mulxU32(&x431, &x432, x419, 0xf3b9cac2); + var x433: u32 = undefined; + var x434: u32 = undefined; + mulxU32(&x433, &x434, x419, 0xfc632551); + var x435: u32 = undefined; + var x436: u1 = undefined; + addcarryxU32(&x435, &x436, 0x0, x434, x431); + var x437: u32 = undefined; + var x438: u1 = undefined; + addcarryxU32(&x437, &x438, x436, x432, x429); + var x439: u32 = undefined; + var x440: u1 = undefined; + addcarryxU32(&x439, &x440, x438, x430, x427); + var x441: u32 = undefined; + var x442: u1 = undefined; + addcarryxU32(&x441, &x442, x440, x428, x425); + var x443: u32 = undefined; + var x444: u1 = undefined; + addcarryxU32(&x443, &x444, x442, x426, x423); + const x445 = (cast(u32, x444) + x424); + var x446: u32 = undefined; + var x447: u1 = undefined; + addcarryxU32(&x446, &x447, 0x0, x401, x433); + var x448: u32 = undefined; + var x449: u1 = undefined; + addcarryxU32(&x448, &x449, x447, x403, x435); + var x450: u32 = undefined; + var x451: u1 = undefined; + addcarryxU32(&x450, &x451, x449, x405, x437); + var x452: u32 = undefined; + var x453: u1 = undefined; + addcarryxU32(&x452, &x453, x451, x407, x439); + var x454: u32 = undefined; + var x455: u1 = undefined; + addcarryxU32(&x454, &x455, x453, x409, x441); + var x456: u32 = undefined; + var x457: u1 = undefined; + addcarryxU32(&x456, &x457, x455, x411, x443); + var x458: u32 = undefined; + var x459: u1 = undefined; + addcarryxU32(&x458, &x459, x457, x413, x445); + var x460: u32 = undefined; + var x461: u1 = undefined; + addcarryxU32(&x460, &x461, x459, x415, x421); + var x462: u32 = undefined; + var x463: u1 = undefined; + addcarryxU32(&x462, &x463, x461, x417, x422); + const x464 = (cast(u32, x463) + cast(u32, x418)); + var x465: u32 = undefined; + var x466: u32 = undefined; + mulxU32(&x465, &x466, x5, (arg2[7])); + var x467: u32 = undefined; + var x468: u32 = undefined; + mulxU32(&x467, &x468, x5, (arg2[6])); + var x469: u32 = undefined; + var x470: u32 = undefined; + mulxU32(&x469, &x470, x5, (arg2[5])); + var x471: u32 = undefined; + var x472: u32 = undefined; + mulxU32(&x471, &x472, x5, (arg2[4])); + var x473: u32 = undefined; + var x474: u32 = undefined; + mulxU32(&x473, &x474, x5, (arg2[3])); + var x475: u32 = undefined; + var x476: u32 = undefined; + mulxU32(&x475, &x476, x5, (arg2[2])); + var x477: u32 = undefined; + var x478: u32 = undefined; + mulxU32(&x477, &x478, x5, (arg2[1])); + var x479: u32 = undefined; + var x480: u32 = undefined; + mulxU32(&x479, &x480, x5, (arg2[0])); + var x481: u32 = undefined; + var x482: u1 = undefined; + addcarryxU32(&x481, &x482, 0x0, x480, x477); + var x483: u32 = undefined; + var x484: u1 = undefined; + addcarryxU32(&x483, &x484, x482, x478, x475); + var x485: u32 = undefined; + var x486: u1 = undefined; + addcarryxU32(&x485, &x486, x484, x476, x473); + var x487: u32 = undefined; + var x488: u1 = undefined; + addcarryxU32(&x487, &x488, x486, x474, x471); + var x489: u32 = undefined; + var x490: u1 = undefined; + addcarryxU32(&x489, &x490, x488, x472, x469); + var x491: u32 = undefined; + var x492: u1 = undefined; + addcarryxU32(&x491, &x492, x490, x470, x467); + var x493: u32 = undefined; + var x494: u1 = undefined; + addcarryxU32(&x493, &x494, x492, x468, x465); + const x495 = (cast(u32, x494) + x466); + var x496: u32 = undefined; + var x497: u1 = undefined; + addcarryxU32(&x496, &x497, 0x0, x448, x479); + var x498: u32 = undefined; + var x499: u1 = undefined; + addcarryxU32(&x498, &x499, x497, x450, x481); + var x500: u32 = undefined; + var x501: u1 = undefined; + addcarryxU32(&x500, &x501, x499, x452, x483); + var x502: u32 = undefined; + var x503: u1 = undefined; + addcarryxU32(&x502, &x503, x501, x454, x485); + var x504: u32 = undefined; + var x505: u1 = undefined; + addcarryxU32(&x504, &x505, x503, x456, x487); + var x506: u32 = undefined; + var x507: u1 = undefined; + addcarryxU32(&x506, &x507, x505, x458, x489); + var x508: u32 = undefined; + var x509: u1 = undefined; + addcarryxU32(&x508, &x509, x507, x460, x491); + var x510: u32 = undefined; + var x511: u1 = undefined; + addcarryxU32(&x510, &x511, x509, x462, x493); + var x512: u32 = undefined; + var x513: u1 = undefined; + addcarryxU32(&x512, &x513, x511, x464, x495); + var x514: u32 = undefined; + var x515: u32 = undefined; + mulxU32(&x514, &x515, x496, 0xee00bc4f); + var x516: u32 = undefined; + var x517: u32 = undefined; + mulxU32(&x516, &x517, x514, 0xffffffff); + var x518: u32 = undefined; + var x519: u32 = undefined; + mulxU32(&x518, &x519, x514, 0xffffffff); + var x520: u32 = undefined; + var x521: u32 = undefined; + mulxU32(&x520, &x521, x514, 0xffffffff); + var x522: u32 = undefined; + var x523: u32 = undefined; + mulxU32(&x522, &x523, x514, 0xbce6faad); + var x524: u32 = undefined; + var x525: u32 = undefined; + mulxU32(&x524, &x525, x514, 0xa7179e84); + var x526: u32 = undefined; + var x527: u32 = undefined; + mulxU32(&x526, &x527, x514, 0xf3b9cac2); + var x528: u32 = undefined; + var x529: u32 = undefined; + mulxU32(&x528, &x529, x514, 0xfc632551); + var x530: u32 = undefined; + var x531: u1 = undefined; + addcarryxU32(&x530, &x531, 0x0, x529, x526); + var x532: u32 = undefined; + var x533: u1 = undefined; + addcarryxU32(&x532, &x533, x531, x527, x524); + var x534: u32 = undefined; + var x535: u1 = undefined; + addcarryxU32(&x534, &x535, x533, x525, x522); + var x536: u32 = undefined; + var x537: u1 = undefined; + addcarryxU32(&x536, &x537, x535, x523, x520); + var x538: u32 = undefined; + var x539: u1 = undefined; + addcarryxU32(&x538, &x539, x537, x521, x518); + const x540 = (cast(u32, x539) + x519); + var x541: u32 = undefined; + var x542: u1 = undefined; + addcarryxU32(&x541, &x542, 0x0, x496, x528); + var x543: u32 = undefined; + var x544: u1 = undefined; + addcarryxU32(&x543, &x544, x542, x498, x530); + var x545: u32 = undefined; + var x546: u1 = undefined; + addcarryxU32(&x545, &x546, x544, x500, x532); + var x547: u32 = undefined; + var x548: u1 = undefined; + addcarryxU32(&x547, &x548, x546, x502, x534); + var x549: u32 = undefined; + var x550: u1 = undefined; + addcarryxU32(&x549, &x550, x548, x504, x536); + var x551: u32 = undefined; + var x552: u1 = undefined; + addcarryxU32(&x551, &x552, x550, x506, x538); + var x553: u32 = undefined; + var x554: u1 = undefined; + addcarryxU32(&x553, &x554, x552, x508, x540); + var x555: u32 = undefined; + var x556: u1 = undefined; + addcarryxU32(&x555, &x556, x554, x510, x516); + var x557: u32 = undefined; + var x558: u1 = undefined; + addcarryxU32(&x557, &x558, x556, x512, x517); + const x559 = (cast(u32, x558) + cast(u32, x513)); + var x560: u32 = undefined; + var x561: u32 = undefined; + mulxU32(&x560, &x561, x6, (arg2[7])); + var x562: u32 = undefined; + var x563: u32 = undefined; + mulxU32(&x562, &x563, x6, (arg2[6])); + var x564: u32 = undefined; + var x565: u32 = undefined; + mulxU32(&x564, &x565, x6, (arg2[5])); + var x566: u32 = undefined; + var x567: u32 = undefined; + mulxU32(&x566, &x567, x6, (arg2[4])); + var x568: u32 = undefined; + var x569: u32 = undefined; + mulxU32(&x568, &x569, x6, (arg2[3])); + var x570: u32 = undefined; + var x571: u32 = undefined; + mulxU32(&x570, &x571, x6, (arg2[2])); + var x572: u32 = undefined; + var x573: u32 = undefined; + mulxU32(&x572, &x573, x6, (arg2[1])); + var x574: u32 = undefined; + var x575: u32 = undefined; + mulxU32(&x574, &x575, x6, (arg2[0])); + var x576: u32 = undefined; + var x577: u1 = undefined; + addcarryxU32(&x576, &x577, 0x0, x575, x572); + var x578: u32 = undefined; + var x579: u1 = undefined; + addcarryxU32(&x578, &x579, x577, x573, x570); + var x580: u32 = undefined; + var x581: u1 = undefined; + addcarryxU32(&x580, &x581, x579, x571, x568); + var x582: u32 = undefined; + var x583: u1 = undefined; + addcarryxU32(&x582, &x583, x581, x569, x566); + var x584: u32 = undefined; + var x585: u1 = undefined; + addcarryxU32(&x584, &x585, x583, x567, x564); + var x586: u32 = undefined; + var x587: u1 = undefined; + addcarryxU32(&x586, &x587, x585, x565, x562); + var x588: u32 = undefined; + var x589: u1 = undefined; + addcarryxU32(&x588, &x589, x587, x563, x560); + const x590 = (cast(u32, x589) + x561); + var x591: u32 = undefined; + var x592: u1 = undefined; + addcarryxU32(&x591, &x592, 0x0, x543, x574); + var x593: u32 = undefined; + var x594: u1 = undefined; + addcarryxU32(&x593, &x594, x592, x545, x576); + var x595: u32 = undefined; + var x596: u1 = undefined; + addcarryxU32(&x595, &x596, x594, x547, x578); + var x597: u32 = undefined; + var x598: u1 = undefined; + addcarryxU32(&x597, &x598, x596, x549, x580); + var x599: u32 = undefined; + var x600: u1 = undefined; + addcarryxU32(&x599, &x600, x598, x551, x582); + var x601: u32 = undefined; + var x602: u1 = undefined; + addcarryxU32(&x601, &x602, x600, x553, x584); + var x603: u32 = undefined; + var x604: u1 = undefined; + addcarryxU32(&x603, &x604, x602, x555, x586); + var x605: u32 = undefined; + var x606: u1 = undefined; + addcarryxU32(&x605, &x606, x604, x557, x588); + var x607: u32 = undefined; + var x608: u1 = undefined; + addcarryxU32(&x607, &x608, x606, x559, x590); + var x609: u32 = undefined; + var x610: u32 = undefined; + mulxU32(&x609, &x610, x591, 0xee00bc4f); + var x611: u32 = undefined; + var x612: u32 = undefined; + mulxU32(&x611, &x612, x609, 0xffffffff); + var x613: u32 = undefined; + var x614: u32 = undefined; + mulxU32(&x613, &x614, x609, 0xffffffff); + var x615: u32 = undefined; + var x616: u32 = undefined; + mulxU32(&x615, &x616, x609, 0xffffffff); + var x617: u32 = undefined; + var x618: u32 = undefined; + mulxU32(&x617, &x618, x609, 0xbce6faad); + var x619: u32 = undefined; + var x620: u32 = undefined; + mulxU32(&x619, &x620, x609, 0xa7179e84); + var x621: u32 = undefined; + var x622: u32 = undefined; + mulxU32(&x621, &x622, x609, 0xf3b9cac2); + var x623: u32 = undefined; + var x624: u32 = undefined; + mulxU32(&x623, &x624, x609, 0xfc632551); + var x625: u32 = undefined; + var x626: u1 = undefined; + addcarryxU32(&x625, &x626, 0x0, x624, x621); + var x627: u32 = undefined; + var x628: u1 = undefined; + addcarryxU32(&x627, &x628, x626, x622, x619); + var x629: u32 = undefined; + var x630: u1 = undefined; + addcarryxU32(&x629, &x630, x628, x620, x617); + var x631: u32 = undefined; + var x632: u1 = undefined; + addcarryxU32(&x631, &x632, x630, x618, x615); + var x633: u32 = undefined; + var x634: u1 = undefined; + addcarryxU32(&x633, &x634, x632, x616, x613); + const x635 = (cast(u32, x634) + x614); + var x636: u32 = undefined; + var x637: u1 = undefined; + addcarryxU32(&x636, &x637, 0x0, x591, x623); + var x638: u32 = undefined; + var x639: u1 = undefined; + addcarryxU32(&x638, &x639, x637, x593, x625); + var x640: u32 = undefined; + var x641: u1 = undefined; + addcarryxU32(&x640, &x641, x639, x595, x627); + var x642: u32 = undefined; + var x643: u1 = undefined; + addcarryxU32(&x642, &x643, x641, x597, x629); + var x644: u32 = undefined; + var x645: u1 = undefined; + addcarryxU32(&x644, &x645, x643, x599, x631); + var x646: u32 = undefined; + var x647: u1 = undefined; + addcarryxU32(&x646, &x647, x645, x601, x633); + var x648: u32 = undefined; + var x649: u1 = undefined; + addcarryxU32(&x648, &x649, x647, x603, x635); + var x650: u32 = undefined; + var x651: u1 = undefined; + addcarryxU32(&x650, &x651, x649, x605, x611); + var x652: u32 = undefined; + var x653: u1 = undefined; + addcarryxU32(&x652, &x653, x651, x607, x612); + const x654 = (cast(u32, x653) + cast(u32, x608)); + var x655: u32 = undefined; + var x656: u32 = undefined; + mulxU32(&x655, &x656, x7, (arg2[7])); + var x657: u32 = undefined; + var x658: u32 = undefined; + mulxU32(&x657, &x658, x7, (arg2[6])); + var x659: u32 = undefined; + var x660: u32 = undefined; + mulxU32(&x659, &x660, x7, (arg2[5])); + var x661: u32 = undefined; + var x662: u32 = undefined; + mulxU32(&x661, &x662, x7, (arg2[4])); + var x663: u32 = undefined; + var x664: u32 = undefined; + mulxU32(&x663, &x664, x7, (arg2[3])); + var x665: u32 = undefined; + var x666: u32 = undefined; + mulxU32(&x665, &x666, x7, (arg2[2])); + var x667: u32 = undefined; + var x668: u32 = undefined; + mulxU32(&x667, &x668, x7, (arg2[1])); + var x669: u32 = undefined; + var x670: u32 = undefined; + mulxU32(&x669, &x670, x7, (arg2[0])); + var x671: u32 = undefined; + var x672: u1 = undefined; + addcarryxU32(&x671, &x672, 0x0, x670, x667); + var x673: u32 = undefined; + var x674: u1 = undefined; + addcarryxU32(&x673, &x674, x672, x668, x665); + var x675: u32 = undefined; + var x676: u1 = undefined; + addcarryxU32(&x675, &x676, x674, x666, x663); + var x677: u32 = undefined; + var x678: u1 = undefined; + addcarryxU32(&x677, &x678, x676, x664, x661); + var x679: u32 = undefined; + var x680: u1 = undefined; + addcarryxU32(&x679, &x680, x678, x662, x659); + var x681: u32 = undefined; + var x682: u1 = undefined; + addcarryxU32(&x681, &x682, x680, x660, x657); + var x683: u32 = undefined; + var x684: u1 = undefined; + addcarryxU32(&x683, &x684, x682, x658, x655); + const x685 = (cast(u32, x684) + x656); + var x686: u32 = undefined; + var x687: u1 = undefined; + addcarryxU32(&x686, &x687, 0x0, x638, x669); + var x688: u32 = undefined; + var x689: u1 = undefined; + addcarryxU32(&x688, &x689, x687, x640, x671); + var x690: u32 = undefined; + var x691: u1 = undefined; + addcarryxU32(&x690, &x691, x689, x642, x673); + var x692: u32 = undefined; + var x693: u1 = undefined; + addcarryxU32(&x692, &x693, x691, x644, x675); + var x694: u32 = undefined; + var x695: u1 = undefined; + addcarryxU32(&x694, &x695, x693, x646, x677); + var x696: u32 = undefined; + var x697: u1 = undefined; + addcarryxU32(&x696, &x697, x695, x648, x679); + var x698: u32 = undefined; + var x699: u1 = undefined; + addcarryxU32(&x698, &x699, x697, x650, x681); + var x700: u32 = undefined; + var x701: u1 = undefined; + addcarryxU32(&x700, &x701, x699, x652, x683); + var x702: u32 = undefined; + var x703: u1 = undefined; + addcarryxU32(&x702, &x703, x701, x654, x685); + var x704: u32 = undefined; + var x705: u32 = undefined; + mulxU32(&x704, &x705, x686, 0xee00bc4f); + var x706: u32 = undefined; + var x707: u32 = undefined; + mulxU32(&x706, &x707, x704, 0xffffffff); + var x708: u32 = undefined; + var x709: u32 = undefined; + mulxU32(&x708, &x709, x704, 0xffffffff); + var x710: u32 = undefined; + var x711: u32 = undefined; + mulxU32(&x710, &x711, x704, 0xffffffff); + var x712: u32 = undefined; + var x713: u32 = undefined; + mulxU32(&x712, &x713, x704, 0xbce6faad); + var x714: u32 = undefined; + var x715: u32 = undefined; + mulxU32(&x714, &x715, x704, 0xa7179e84); + var x716: u32 = undefined; + var x717: u32 = undefined; + mulxU32(&x716, &x717, x704, 0xf3b9cac2); + var x718: u32 = undefined; + var x719: u32 = undefined; + mulxU32(&x718, &x719, x704, 0xfc632551); + var x720: u32 = undefined; + var x721: u1 = undefined; + addcarryxU32(&x720, &x721, 0x0, x719, x716); + var x722: u32 = undefined; + var x723: u1 = undefined; + addcarryxU32(&x722, &x723, x721, x717, x714); + var x724: u32 = undefined; + var x725: u1 = undefined; + addcarryxU32(&x724, &x725, x723, x715, x712); + var x726: u32 = undefined; + var x727: u1 = undefined; + addcarryxU32(&x726, &x727, x725, x713, x710); + var x728: u32 = undefined; + var x729: u1 = undefined; + addcarryxU32(&x728, &x729, x727, x711, x708); + const x730 = (cast(u32, x729) + x709); + var x731: u32 = undefined; + var x732: u1 = undefined; + addcarryxU32(&x731, &x732, 0x0, x686, x718); + var x733: u32 = undefined; + var x734: u1 = undefined; + addcarryxU32(&x733, &x734, x732, x688, x720); + var x735: u32 = undefined; + var x736: u1 = undefined; + addcarryxU32(&x735, &x736, x734, x690, x722); + var x737: u32 = undefined; + var x738: u1 = undefined; + addcarryxU32(&x737, &x738, x736, x692, x724); + var x739: u32 = undefined; + var x740: u1 = undefined; + addcarryxU32(&x739, &x740, x738, x694, x726); + var x741: u32 = undefined; + var x742: u1 = undefined; + addcarryxU32(&x741, &x742, x740, x696, x728); + var x743: u32 = undefined; + var x744: u1 = undefined; + addcarryxU32(&x743, &x744, x742, x698, x730); + var x745: u32 = undefined; + var x746: u1 = undefined; + addcarryxU32(&x745, &x746, x744, x700, x706); + var x747: u32 = undefined; + var x748: u1 = undefined; + addcarryxU32(&x747, &x748, x746, x702, x707); + const x749 = (cast(u32, x748) + cast(u32, x703)); + var x750: u32 = undefined; + var x751: u1 = undefined; + subborrowxU32(&x750, &x751, 0x0, x733, 0xfc632551); + var x752: u32 = undefined; + var x753: u1 = undefined; + subborrowxU32(&x752, &x753, x751, x735, 0xf3b9cac2); + var x754: u32 = undefined; + var x755: u1 = undefined; + subborrowxU32(&x754, &x755, x753, x737, 0xa7179e84); + var x756: u32 = undefined; + var x757: u1 = undefined; + subborrowxU32(&x756, &x757, x755, x739, 0xbce6faad); + var x758: u32 = undefined; + var x759: u1 = undefined; + subborrowxU32(&x758, &x759, x757, x741, 0xffffffff); + var x760: u32 = undefined; + var x761: u1 = undefined; + subborrowxU32(&x760, &x761, x759, x743, 0xffffffff); + var x762: u32 = undefined; + var x763: u1 = undefined; + subborrowxU32(&x762, &x763, x761, x745, cast(u32, 0x0)); + var x764: u32 = undefined; + var x765: u1 = undefined; + subborrowxU32(&x764, &x765, x763, x747, 0xffffffff); + var x766: u32 = undefined; + var x767: u1 = undefined; + subborrowxU32(&x766, &x767, x765, x749, cast(u32, 0x0)); + var x768: u32 = undefined; + cmovznzU32(&x768, x767, x750, x733); + var x769: u32 = undefined; + cmovznzU32(&x769, x767, x752, x735); + var x770: u32 = undefined; + cmovznzU32(&x770, x767, x754, x737); + var x771: u32 = undefined; + cmovznzU32(&x771, x767, x756, x739); + var x772: u32 = undefined; + cmovznzU32(&x772, x767, x758, x741); + var x773: u32 = undefined; + cmovznzU32(&x773, x767, x760, x743); + var x774: u32 = undefined; + cmovznzU32(&x774, x767, x762, x745); + var x775: u32 = undefined; + cmovznzU32(&x775, x767, x764, x747); + out1[0] = x768; + out1[1] = x769; + out1[2] = x770; + out1[3] = x771; + out1[4] = x772; + out1[5] = x773; + out1[6] = x774; + out1[7] = x775; +} + +/// The function square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn square(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[6]); + const x7 = (arg1[7]); + const x8 = (arg1[0]); + var x9: u32 = undefined; + var x10: u32 = undefined; + mulxU32(&x9, &x10, x8, (arg1[7])); + var x11: u32 = undefined; + var x12: u32 = undefined; + mulxU32(&x11, &x12, x8, (arg1[6])); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x8, (arg1[5])); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x8, (arg1[4])); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x8, (arg1[3])); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x8, (arg1[2])); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x8, (arg1[1])); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x8, (arg1[0])); + var x25: u32 = undefined; + var x26: u1 = undefined; + addcarryxU32(&x25, &x26, 0x0, x24, x21); + var x27: u32 = undefined; + var x28: u1 = undefined; + addcarryxU32(&x27, &x28, x26, x22, x19); + var x29: u32 = undefined; + var x30: u1 = undefined; + addcarryxU32(&x29, &x30, x28, x20, x17); + var x31: u32 = undefined; + var x32: u1 = undefined; + addcarryxU32(&x31, &x32, x30, x18, x15); + var x33: u32 = undefined; + var x34: u1 = undefined; + addcarryxU32(&x33, &x34, x32, x16, x13); + var x35: u32 = undefined; + var x36: u1 = undefined; + addcarryxU32(&x35, &x36, x34, x14, x11); + var x37: u32 = undefined; + var x38: u1 = undefined; + addcarryxU32(&x37, &x38, x36, x12, x9); + const x39 = (cast(u32, x38) + x10); + var x40: u32 = undefined; + var x41: u32 = undefined; + mulxU32(&x40, &x41, x23, 0xee00bc4f); + var x42: u32 = undefined; + var x43: u32 = undefined; + mulxU32(&x42, &x43, x40, 0xffffffff); + var x44: u32 = undefined; + var x45: u32 = undefined; + mulxU32(&x44, &x45, x40, 0xffffffff); + var x46: u32 = undefined; + var x47: u32 = undefined; + mulxU32(&x46, &x47, x40, 0xffffffff); + var x48: u32 = undefined; + var x49: u32 = undefined; + mulxU32(&x48, &x49, x40, 0xbce6faad); + var x50: u32 = undefined; + var x51: u32 = undefined; + mulxU32(&x50, &x51, x40, 0xa7179e84); + var x52: u32 = undefined; + var x53: u32 = undefined; + mulxU32(&x52, &x53, x40, 0xf3b9cac2); + var x54: u32 = undefined; + var x55: u32 = undefined; + mulxU32(&x54, &x55, x40, 0xfc632551); + var x56: u32 = undefined; + var x57: u1 = undefined; + addcarryxU32(&x56, &x57, 0x0, x55, x52); + var x58: u32 = undefined; + var x59: u1 = undefined; + addcarryxU32(&x58, &x59, x57, x53, x50); + var x60: u32 = undefined; + var x61: u1 = undefined; + addcarryxU32(&x60, &x61, x59, x51, x48); + var x62: u32 = undefined; + var x63: u1 = undefined; + addcarryxU32(&x62, &x63, x61, x49, x46); + var x64: u32 = undefined; + var x65: u1 = undefined; + addcarryxU32(&x64, &x65, x63, x47, x44); + const x66 = (cast(u32, x65) + x45); + var x67: u32 = undefined; + var x68: u1 = undefined; + addcarryxU32(&x67, &x68, 0x0, x23, x54); + var x69: u32 = undefined; + var x70: u1 = undefined; + addcarryxU32(&x69, &x70, x68, x25, x56); + var x71: u32 = undefined; + var x72: u1 = undefined; + addcarryxU32(&x71, &x72, x70, x27, x58); + var x73: u32 = undefined; + var x74: u1 = undefined; + addcarryxU32(&x73, &x74, x72, x29, x60); + var x75: u32 = undefined; + var x76: u1 = undefined; + addcarryxU32(&x75, &x76, x74, x31, x62); + var x77: u32 = undefined; + var x78: u1 = undefined; + addcarryxU32(&x77, &x78, x76, x33, x64); + var x79: u32 = undefined; + var x80: u1 = undefined; + addcarryxU32(&x79, &x80, x78, x35, x66); + var x81: u32 = undefined; + var x82: u1 = undefined; + addcarryxU32(&x81, &x82, x80, x37, x42); + var x83: u32 = undefined; + var x84: u1 = undefined; + addcarryxU32(&x83, &x84, x82, x39, x43); + var x85: u32 = undefined; + var x86: u32 = undefined; + mulxU32(&x85, &x86, x1, (arg1[7])); + var x87: u32 = undefined; + var x88: u32 = undefined; + mulxU32(&x87, &x88, x1, (arg1[6])); + var x89: u32 = undefined; + var x90: u32 = undefined; + mulxU32(&x89, &x90, x1, (arg1[5])); + var x91: u32 = undefined; + var x92: u32 = undefined; + mulxU32(&x91, &x92, x1, (arg1[4])); + var x93: u32 = undefined; + var x94: u32 = undefined; + mulxU32(&x93, &x94, x1, (arg1[3])); + var x95: u32 = undefined; + var x96: u32 = undefined; + mulxU32(&x95, &x96, x1, (arg1[2])); + var x97: u32 = undefined; + var x98: u32 = undefined; + mulxU32(&x97, &x98, x1, (arg1[1])); + var x99: u32 = undefined; + var x100: u32 = undefined; + mulxU32(&x99, &x100, x1, (arg1[0])); + var x101: u32 = undefined; + var x102: u1 = undefined; + addcarryxU32(&x101, &x102, 0x0, x100, x97); + var x103: u32 = undefined; + var x104: u1 = undefined; + addcarryxU32(&x103, &x104, x102, x98, x95); + var x105: u32 = undefined; + var x106: u1 = undefined; + addcarryxU32(&x105, &x106, x104, x96, x93); + var x107: u32 = undefined; + var x108: u1 = undefined; + addcarryxU32(&x107, &x108, x106, x94, x91); + var x109: u32 = undefined; + var x110: u1 = undefined; + addcarryxU32(&x109, &x110, x108, x92, x89); + var x111: u32 = undefined; + var x112: u1 = undefined; + addcarryxU32(&x111, &x112, x110, x90, x87); + var x113: u32 = undefined; + var x114: u1 = undefined; + addcarryxU32(&x113, &x114, x112, x88, x85); + const x115 = (cast(u32, x114) + x86); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, 0x0, x69, x99); + var x118: u32 = undefined; + var x119: u1 = undefined; + addcarryxU32(&x118, &x119, x117, x71, x101); + var x120: u32 = undefined; + var x121: u1 = undefined; + addcarryxU32(&x120, &x121, x119, x73, x103); + var x122: u32 = undefined; + var x123: u1 = undefined; + addcarryxU32(&x122, &x123, x121, x75, x105); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, x77, x107); + var x126: u32 = undefined; + var x127: u1 = undefined; + addcarryxU32(&x126, &x127, x125, x79, x109); + var x128: u32 = undefined; + var x129: u1 = undefined; + addcarryxU32(&x128, &x129, x127, x81, x111); + var x130: u32 = undefined; + var x131: u1 = undefined; + addcarryxU32(&x130, &x131, x129, x83, x113); + var x132: u32 = undefined; + var x133: u1 = undefined; + addcarryxU32(&x132, &x133, x131, cast(u32, x84), x115); + var x134: u32 = undefined; + var x135: u32 = undefined; + mulxU32(&x134, &x135, x116, 0xee00bc4f); + var x136: u32 = undefined; + var x137: u32 = undefined; + mulxU32(&x136, &x137, x134, 0xffffffff); + var x138: u32 = undefined; + var x139: u32 = undefined; + mulxU32(&x138, &x139, x134, 0xffffffff); + var x140: u32 = undefined; + var x141: u32 = undefined; + mulxU32(&x140, &x141, x134, 0xffffffff); + var x142: u32 = undefined; + var x143: u32 = undefined; + mulxU32(&x142, &x143, x134, 0xbce6faad); + var x144: u32 = undefined; + var x145: u32 = undefined; + mulxU32(&x144, &x145, x134, 0xa7179e84); + var x146: u32 = undefined; + var x147: u32 = undefined; + mulxU32(&x146, &x147, x134, 0xf3b9cac2); + var x148: u32 = undefined; + var x149: u32 = undefined; + mulxU32(&x148, &x149, x134, 0xfc632551); + var x150: u32 = undefined; + var x151: u1 = undefined; + addcarryxU32(&x150, &x151, 0x0, x149, x146); + var x152: u32 = undefined; + var x153: u1 = undefined; + addcarryxU32(&x152, &x153, x151, x147, x144); + var x154: u32 = undefined; + var x155: u1 = undefined; + addcarryxU32(&x154, &x155, x153, x145, x142); + var x156: u32 = undefined; + var x157: u1 = undefined; + addcarryxU32(&x156, &x157, x155, x143, x140); + var x158: u32 = undefined; + var x159: u1 = undefined; + addcarryxU32(&x158, &x159, x157, x141, x138); + const x160 = (cast(u32, x159) + x139); + var x161: u32 = undefined; + var x162: u1 = undefined; + addcarryxU32(&x161, &x162, 0x0, x116, x148); + var x163: u32 = undefined; + var x164: u1 = undefined; + addcarryxU32(&x163, &x164, x162, x118, x150); + var x165: u32 = undefined; + var x166: u1 = undefined; + addcarryxU32(&x165, &x166, x164, x120, x152); + var x167: u32 = undefined; + var x168: u1 = undefined; + addcarryxU32(&x167, &x168, x166, x122, x154); + var x169: u32 = undefined; + var x170: u1 = undefined; + addcarryxU32(&x169, &x170, x168, x124, x156); + var x171: u32 = undefined; + var x172: u1 = undefined; + addcarryxU32(&x171, &x172, x170, x126, x158); + var x173: u32 = undefined; + var x174: u1 = undefined; + addcarryxU32(&x173, &x174, x172, x128, x160); + var x175: u32 = undefined; + var x176: u1 = undefined; + addcarryxU32(&x175, &x176, x174, x130, x136); + var x177: u32 = undefined; + var x178: u1 = undefined; + addcarryxU32(&x177, &x178, x176, x132, x137); + const x179 = (cast(u32, x178) + cast(u32, x133)); + var x180: u32 = undefined; + var x181: u32 = undefined; + mulxU32(&x180, &x181, x2, (arg1[7])); + var x182: u32 = undefined; + var x183: u32 = undefined; + mulxU32(&x182, &x183, x2, (arg1[6])); + var x184: u32 = undefined; + var x185: u32 = undefined; + mulxU32(&x184, &x185, x2, (arg1[5])); + var x186: u32 = undefined; + var x187: u32 = undefined; + mulxU32(&x186, &x187, x2, (arg1[4])); + var x188: u32 = undefined; + var x189: u32 = undefined; + mulxU32(&x188, &x189, x2, (arg1[3])); + var x190: u32 = undefined; + var x191: u32 = undefined; + mulxU32(&x190, &x191, x2, (arg1[2])); + var x192: u32 = undefined; + var x193: u32 = undefined; + mulxU32(&x192, &x193, x2, (arg1[1])); + var x194: u32 = undefined; + var x195: u32 = undefined; + mulxU32(&x194, &x195, x2, (arg1[0])); + var x196: u32 = undefined; + var x197: u1 = undefined; + addcarryxU32(&x196, &x197, 0x0, x195, x192); + var x198: u32 = undefined; + var x199: u1 = undefined; + addcarryxU32(&x198, &x199, x197, x193, x190); + var x200: u32 = undefined; + var x201: u1 = undefined; + addcarryxU32(&x200, &x201, x199, x191, x188); + var x202: u32 = undefined; + var x203: u1 = undefined; + addcarryxU32(&x202, &x203, x201, x189, x186); + var x204: u32 = undefined; + var x205: u1 = undefined; + addcarryxU32(&x204, &x205, x203, x187, x184); + var x206: u32 = undefined; + var x207: u1 = undefined; + addcarryxU32(&x206, &x207, x205, x185, x182); + var x208: u32 = undefined; + var x209: u1 = undefined; + addcarryxU32(&x208, &x209, x207, x183, x180); + const x210 = (cast(u32, x209) + x181); + var x211: u32 = undefined; + var x212: u1 = undefined; + addcarryxU32(&x211, &x212, 0x0, x163, x194); + var x213: u32 = undefined; + var x214: u1 = undefined; + addcarryxU32(&x213, &x214, x212, x165, x196); + var x215: u32 = undefined; + var x216: u1 = undefined; + addcarryxU32(&x215, &x216, x214, x167, x198); + var x217: u32 = undefined; + var x218: u1 = undefined; + addcarryxU32(&x217, &x218, x216, x169, x200); + var x219: u32 = undefined; + var x220: u1 = undefined; + addcarryxU32(&x219, &x220, x218, x171, x202); + var x221: u32 = undefined; + var x222: u1 = undefined; + addcarryxU32(&x221, &x222, x220, x173, x204); + var x223: u32 = undefined; + var x224: u1 = undefined; + addcarryxU32(&x223, &x224, x222, x175, x206); + var x225: u32 = undefined; + var x226: u1 = undefined; + addcarryxU32(&x225, &x226, x224, x177, x208); + var x227: u32 = undefined; + var x228: u1 = undefined; + addcarryxU32(&x227, &x228, x226, x179, x210); + var x229: u32 = undefined; + var x230: u32 = undefined; + mulxU32(&x229, &x230, x211, 0xee00bc4f); + var x231: u32 = undefined; + var x232: u32 = undefined; + mulxU32(&x231, &x232, x229, 0xffffffff); + var x233: u32 = undefined; + var x234: u32 = undefined; + mulxU32(&x233, &x234, x229, 0xffffffff); + var x235: u32 = undefined; + var x236: u32 = undefined; + mulxU32(&x235, &x236, x229, 0xffffffff); + var x237: u32 = undefined; + var x238: u32 = undefined; + mulxU32(&x237, &x238, x229, 0xbce6faad); + var x239: u32 = undefined; + var x240: u32 = undefined; + mulxU32(&x239, &x240, x229, 0xa7179e84); + var x241: u32 = undefined; + var x242: u32 = undefined; + mulxU32(&x241, &x242, x229, 0xf3b9cac2); + var x243: u32 = undefined; + var x244: u32 = undefined; + mulxU32(&x243, &x244, x229, 0xfc632551); + var x245: u32 = undefined; + var x246: u1 = undefined; + addcarryxU32(&x245, &x246, 0x0, x244, x241); + var x247: u32 = undefined; + var x248: u1 = undefined; + addcarryxU32(&x247, &x248, x246, x242, x239); + var x249: u32 = undefined; + var x250: u1 = undefined; + addcarryxU32(&x249, &x250, x248, x240, x237); + var x251: u32 = undefined; + var x252: u1 = undefined; + addcarryxU32(&x251, &x252, x250, x238, x235); + var x253: u32 = undefined; + var x254: u1 = undefined; + addcarryxU32(&x253, &x254, x252, x236, x233); + const x255 = (cast(u32, x254) + x234); + var x256: u32 = undefined; + var x257: u1 = undefined; + addcarryxU32(&x256, &x257, 0x0, x211, x243); + var x258: u32 = undefined; + var x259: u1 = undefined; + addcarryxU32(&x258, &x259, x257, x213, x245); + var x260: u32 = undefined; + var x261: u1 = undefined; + addcarryxU32(&x260, &x261, x259, x215, x247); + var x262: u32 = undefined; + var x263: u1 = undefined; + addcarryxU32(&x262, &x263, x261, x217, x249); + var x264: u32 = undefined; + var x265: u1 = undefined; + addcarryxU32(&x264, &x265, x263, x219, x251); + var x266: u32 = undefined; + var x267: u1 = undefined; + addcarryxU32(&x266, &x267, x265, x221, x253); + var x268: u32 = undefined; + var x269: u1 = undefined; + addcarryxU32(&x268, &x269, x267, x223, x255); + var x270: u32 = undefined; + var x271: u1 = undefined; + addcarryxU32(&x270, &x271, x269, x225, x231); + var x272: u32 = undefined; + var x273: u1 = undefined; + addcarryxU32(&x272, &x273, x271, x227, x232); + const x274 = (cast(u32, x273) + cast(u32, x228)); + var x275: u32 = undefined; + var x276: u32 = undefined; + mulxU32(&x275, &x276, x3, (arg1[7])); + var x277: u32 = undefined; + var x278: u32 = undefined; + mulxU32(&x277, &x278, x3, (arg1[6])); + var x279: u32 = undefined; + var x280: u32 = undefined; + mulxU32(&x279, &x280, x3, (arg1[5])); + var x281: u32 = undefined; + var x282: u32 = undefined; + mulxU32(&x281, &x282, x3, (arg1[4])); + var x283: u32 = undefined; + var x284: u32 = undefined; + mulxU32(&x283, &x284, x3, (arg1[3])); + var x285: u32 = undefined; + var x286: u32 = undefined; + mulxU32(&x285, &x286, x3, (arg1[2])); + var x287: u32 = undefined; + var x288: u32 = undefined; + mulxU32(&x287, &x288, x3, (arg1[1])); + var x289: u32 = undefined; + var x290: u32 = undefined; + mulxU32(&x289, &x290, x3, (arg1[0])); + var x291: u32 = undefined; + var x292: u1 = undefined; + addcarryxU32(&x291, &x292, 0x0, x290, x287); + var x293: u32 = undefined; + var x294: u1 = undefined; + addcarryxU32(&x293, &x294, x292, x288, x285); + var x295: u32 = undefined; + var x296: u1 = undefined; + addcarryxU32(&x295, &x296, x294, x286, x283); + var x297: u32 = undefined; + var x298: u1 = undefined; + addcarryxU32(&x297, &x298, x296, x284, x281); + var x299: u32 = undefined; + var x300: u1 = undefined; + addcarryxU32(&x299, &x300, x298, x282, x279); + var x301: u32 = undefined; + var x302: u1 = undefined; + addcarryxU32(&x301, &x302, x300, x280, x277); + var x303: u32 = undefined; + var x304: u1 = undefined; + addcarryxU32(&x303, &x304, x302, x278, x275); + const x305 = (cast(u32, x304) + x276); + var x306: u32 = undefined; + var x307: u1 = undefined; + addcarryxU32(&x306, &x307, 0x0, x258, x289); + var x308: u32 = undefined; + var x309: u1 = undefined; + addcarryxU32(&x308, &x309, x307, x260, x291); + var x310: u32 = undefined; + var x311: u1 = undefined; + addcarryxU32(&x310, &x311, x309, x262, x293); + var x312: u32 = undefined; + var x313: u1 = undefined; + addcarryxU32(&x312, &x313, x311, x264, x295); + var x314: u32 = undefined; + var x315: u1 = undefined; + addcarryxU32(&x314, &x315, x313, x266, x297); + var x316: u32 = undefined; + var x317: u1 = undefined; + addcarryxU32(&x316, &x317, x315, x268, x299); + var x318: u32 = undefined; + var x319: u1 = undefined; + addcarryxU32(&x318, &x319, x317, x270, x301); + var x320: u32 = undefined; + var x321: u1 = undefined; + addcarryxU32(&x320, &x321, x319, x272, x303); + var x322: u32 = undefined; + var x323: u1 = undefined; + addcarryxU32(&x322, &x323, x321, x274, x305); + var x324: u32 = undefined; + var x325: u32 = undefined; + mulxU32(&x324, &x325, x306, 0xee00bc4f); + var x326: u32 = undefined; + var x327: u32 = undefined; + mulxU32(&x326, &x327, x324, 0xffffffff); + var x328: u32 = undefined; + var x329: u32 = undefined; + mulxU32(&x328, &x329, x324, 0xffffffff); + var x330: u32 = undefined; + var x331: u32 = undefined; + mulxU32(&x330, &x331, x324, 0xffffffff); + var x332: u32 = undefined; + var x333: u32 = undefined; + mulxU32(&x332, &x333, x324, 0xbce6faad); + var x334: u32 = undefined; + var x335: u32 = undefined; + mulxU32(&x334, &x335, x324, 0xa7179e84); + var x336: u32 = undefined; + var x337: u32 = undefined; + mulxU32(&x336, &x337, x324, 0xf3b9cac2); + var x338: u32 = undefined; + var x339: u32 = undefined; + mulxU32(&x338, &x339, x324, 0xfc632551); + var x340: u32 = undefined; + var x341: u1 = undefined; + addcarryxU32(&x340, &x341, 0x0, x339, x336); + var x342: u32 = undefined; + var x343: u1 = undefined; + addcarryxU32(&x342, &x343, x341, x337, x334); + var x344: u32 = undefined; + var x345: u1 = undefined; + addcarryxU32(&x344, &x345, x343, x335, x332); + var x346: u32 = undefined; + var x347: u1 = undefined; + addcarryxU32(&x346, &x347, x345, x333, x330); + var x348: u32 = undefined; + var x349: u1 = undefined; + addcarryxU32(&x348, &x349, x347, x331, x328); + const x350 = (cast(u32, x349) + x329); + var x351: u32 = undefined; + var x352: u1 = undefined; + addcarryxU32(&x351, &x352, 0x0, x306, x338); + var x353: u32 = undefined; + var x354: u1 = undefined; + addcarryxU32(&x353, &x354, x352, x308, x340); + var x355: u32 = undefined; + var x356: u1 = undefined; + addcarryxU32(&x355, &x356, x354, x310, x342); + var x357: u32 = undefined; + var x358: u1 = undefined; + addcarryxU32(&x357, &x358, x356, x312, x344); + var x359: u32 = undefined; + var x360: u1 = undefined; + addcarryxU32(&x359, &x360, x358, x314, x346); + var x361: u32 = undefined; + var x362: u1 = undefined; + addcarryxU32(&x361, &x362, x360, x316, x348); + var x363: u32 = undefined; + var x364: u1 = undefined; + addcarryxU32(&x363, &x364, x362, x318, x350); + var x365: u32 = undefined; + var x366: u1 = undefined; + addcarryxU32(&x365, &x366, x364, x320, x326); + var x367: u32 = undefined; + var x368: u1 = undefined; + addcarryxU32(&x367, &x368, x366, x322, x327); + const x369 = (cast(u32, x368) + cast(u32, x323)); + var x370: u32 = undefined; + var x371: u32 = undefined; + mulxU32(&x370, &x371, x4, (arg1[7])); + var x372: u32 = undefined; + var x373: u32 = undefined; + mulxU32(&x372, &x373, x4, (arg1[6])); + var x374: u32 = undefined; + var x375: u32 = undefined; + mulxU32(&x374, &x375, x4, (arg1[5])); + var x376: u32 = undefined; + var x377: u32 = undefined; + mulxU32(&x376, &x377, x4, (arg1[4])); + var x378: u32 = undefined; + var x379: u32 = undefined; + mulxU32(&x378, &x379, x4, (arg1[3])); + var x380: u32 = undefined; + var x381: u32 = undefined; + mulxU32(&x380, &x381, x4, (arg1[2])); + var x382: u32 = undefined; + var x383: u32 = undefined; + mulxU32(&x382, &x383, x4, (arg1[1])); + var x384: u32 = undefined; + var x385: u32 = undefined; + mulxU32(&x384, &x385, x4, (arg1[0])); + var x386: u32 = undefined; + var x387: u1 = undefined; + addcarryxU32(&x386, &x387, 0x0, x385, x382); + var x388: u32 = undefined; + var x389: u1 = undefined; + addcarryxU32(&x388, &x389, x387, x383, x380); + var x390: u32 = undefined; + var x391: u1 = undefined; + addcarryxU32(&x390, &x391, x389, x381, x378); + var x392: u32 = undefined; + var x393: u1 = undefined; + addcarryxU32(&x392, &x393, x391, x379, x376); + var x394: u32 = undefined; + var x395: u1 = undefined; + addcarryxU32(&x394, &x395, x393, x377, x374); + var x396: u32 = undefined; + var x397: u1 = undefined; + addcarryxU32(&x396, &x397, x395, x375, x372); + var x398: u32 = undefined; + var x399: u1 = undefined; + addcarryxU32(&x398, &x399, x397, x373, x370); + const x400 = (cast(u32, x399) + x371); + var x401: u32 = undefined; + var x402: u1 = undefined; + addcarryxU32(&x401, &x402, 0x0, x353, x384); + var x403: u32 = undefined; + var x404: u1 = undefined; + addcarryxU32(&x403, &x404, x402, x355, x386); + var x405: u32 = undefined; + var x406: u1 = undefined; + addcarryxU32(&x405, &x406, x404, x357, x388); + var x407: u32 = undefined; + var x408: u1 = undefined; + addcarryxU32(&x407, &x408, x406, x359, x390); + var x409: u32 = undefined; + var x410: u1 = undefined; + addcarryxU32(&x409, &x410, x408, x361, x392); + var x411: u32 = undefined; + var x412: u1 = undefined; + addcarryxU32(&x411, &x412, x410, x363, x394); + var x413: u32 = undefined; + var x414: u1 = undefined; + addcarryxU32(&x413, &x414, x412, x365, x396); + var x415: u32 = undefined; + var x416: u1 = undefined; + addcarryxU32(&x415, &x416, x414, x367, x398); + var x417: u32 = undefined; + var x418: u1 = undefined; + addcarryxU32(&x417, &x418, x416, x369, x400); + var x419: u32 = undefined; + var x420: u32 = undefined; + mulxU32(&x419, &x420, x401, 0xee00bc4f); + var x421: u32 = undefined; + var x422: u32 = undefined; + mulxU32(&x421, &x422, x419, 0xffffffff); + var x423: u32 = undefined; + var x424: u32 = undefined; + mulxU32(&x423, &x424, x419, 0xffffffff); + var x425: u32 = undefined; + var x426: u32 = undefined; + mulxU32(&x425, &x426, x419, 0xffffffff); + var x427: u32 = undefined; + var x428: u32 = undefined; + mulxU32(&x427, &x428, x419, 0xbce6faad); + var x429: u32 = undefined; + var x430: u32 = undefined; + mulxU32(&x429, &x430, x419, 0xa7179e84); + var x431: u32 = undefined; + var x432: u32 = undefined; + mulxU32(&x431, &x432, x419, 0xf3b9cac2); + var x433: u32 = undefined; + var x434: u32 = undefined; + mulxU32(&x433, &x434, x419, 0xfc632551); + var x435: u32 = undefined; + var x436: u1 = undefined; + addcarryxU32(&x435, &x436, 0x0, x434, x431); + var x437: u32 = undefined; + var x438: u1 = undefined; + addcarryxU32(&x437, &x438, x436, x432, x429); + var x439: u32 = undefined; + var x440: u1 = undefined; + addcarryxU32(&x439, &x440, x438, x430, x427); + var x441: u32 = undefined; + var x442: u1 = undefined; + addcarryxU32(&x441, &x442, x440, x428, x425); + var x443: u32 = undefined; + var x444: u1 = undefined; + addcarryxU32(&x443, &x444, x442, x426, x423); + const x445 = (cast(u32, x444) + x424); + var x446: u32 = undefined; + var x447: u1 = undefined; + addcarryxU32(&x446, &x447, 0x0, x401, x433); + var x448: u32 = undefined; + var x449: u1 = undefined; + addcarryxU32(&x448, &x449, x447, x403, x435); + var x450: u32 = undefined; + var x451: u1 = undefined; + addcarryxU32(&x450, &x451, x449, x405, x437); + var x452: u32 = undefined; + var x453: u1 = undefined; + addcarryxU32(&x452, &x453, x451, x407, x439); + var x454: u32 = undefined; + var x455: u1 = undefined; + addcarryxU32(&x454, &x455, x453, x409, x441); + var x456: u32 = undefined; + var x457: u1 = undefined; + addcarryxU32(&x456, &x457, x455, x411, x443); + var x458: u32 = undefined; + var x459: u1 = undefined; + addcarryxU32(&x458, &x459, x457, x413, x445); + var x460: u32 = undefined; + var x461: u1 = undefined; + addcarryxU32(&x460, &x461, x459, x415, x421); + var x462: u32 = undefined; + var x463: u1 = undefined; + addcarryxU32(&x462, &x463, x461, x417, x422); + const x464 = (cast(u32, x463) + cast(u32, x418)); + var x465: u32 = undefined; + var x466: u32 = undefined; + mulxU32(&x465, &x466, x5, (arg1[7])); + var x467: u32 = undefined; + var x468: u32 = undefined; + mulxU32(&x467, &x468, x5, (arg1[6])); + var x469: u32 = undefined; + var x470: u32 = undefined; + mulxU32(&x469, &x470, x5, (arg1[5])); + var x471: u32 = undefined; + var x472: u32 = undefined; + mulxU32(&x471, &x472, x5, (arg1[4])); + var x473: u32 = undefined; + var x474: u32 = undefined; + mulxU32(&x473, &x474, x5, (arg1[3])); + var x475: u32 = undefined; + var x476: u32 = undefined; + mulxU32(&x475, &x476, x5, (arg1[2])); + var x477: u32 = undefined; + var x478: u32 = undefined; + mulxU32(&x477, &x478, x5, (arg1[1])); + var x479: u32 = undefined; + var x480: u32 = undefined; + mulxU32(&x479, &x480, x5, (arg1[0])); + var x481: u32 = undefined; + var x482: u1 = undefined; + addcarryxU32(&x481, &x482, 0x0, x480, x477); + var x483: u32 = undefined; + var x484: u1 = undefined; + addcarryxU32(&x483, &x484, x482, x478, x475); + var x485: u32 = undefined; + var x486: u1 = undefined; + addcarryxU32(&x485, &x486, x484, x476, x473); + var x487: u32 = undefined; + var x488: u1 = undefined; + addcarryxU32(&x487, &x488, x486, x474, x471); + var x489: u32 = undefined; + var x490: u1 = undefined; + addcarryxU32(&x489, &x490, x488, x472, x469); + var x491: u32 = undefined; + var x492: u1 = undefined; + addcarryxU32(&x491, &x492, x490, x470, x467); + var x493: u32 = undefined; + var x494: u1 = undefined; + addcarryxU32(&x493, &x494, x492, x468, x465); + const x495 = (cast(u32, x494) + x466); + var x496: u32 = undefined; + var x497: u1 = undefined; + addcarryxU32(&x496, &x497, 0x0, x448, x479); + var x498: u32 = undefined; + var x499: u1 = undefined; + addcarryxU32(&x498, &x499, x497, x450, x481); + var x500: u32 = undefined; + var x501: u1 = undefined; + addcarryxU32(&x500, &x501, x499, x452, x483); + var x502: u32 = undefined; + var x503: u1 = undefined; + addcarryxU32(&x502, &x503, x501, x454, x485); + var x504: u32 = undefined; + var x505: u1 = undefined; + addcarryxU32(&x504, &x505, x503, x456, x487); + var x506: u32 = undefined; + var x507: u1 = undefined; + addcarryxU32(&x506, &x507, x505, x458, x489); + var x508: u32 = undefined; + var x509: u1 = undefined; + addcarryxU32(&x508, &x509, x507, x460, x491); + var x510: u32 = undefined; + var x511: u1 = undefined; + addcarryxU32(&x510, &x511, x509, x462, x493); + var x512: u32 = undefined; + var x513: u1 = undefined; + addcarryxU32(&x512, &x513, x511, x464, x495); + var x514: u32 = undefined; + var x515: u32 = undefined; + mulxU32(&x514, &x515, x496, 0xee00bc4f); + var x516: u32 = undefined; + var x517: u32 = undefined; + mulxU32(&x516, &x517, x514, 0xffffffff); + var x518: u32 = undefined; + var x519: u32 = undefined; + mulxU32(&x518, &x519, x514, 0xffffffff); + var x520: u32 = undefined; + var x521: u32 = undefined; + mulxU32(&x520, &x521, x514, 0xffffffff); + var x522: u32 = undefined; + var x523: u32 = undefined; + mulxU32(&x522, &x523, x514, 0xbce6faad); + var x524: u32 = undefined; + var x525: u32 = undefined; + mulxU32(&x524, &x525, x514, 0xa7179e84); + var x526: u32 = undefined; + var x527: u32 = undefined; + mulxU32(&x526, &x527, x514, 0xf3b9cac2); + var x528: u32 = undefined; + var x529: u32 = undefined; + mulxU32(&x528, &x529, x514, 0xfc632551); + var x530: u32 = undefined; + var x531: u1 = undefined; + addcarryxU32(&x530, &x531, 0x0, x529, x526); + var x532: u32 = undefined; + var x533: u1 = undefined; + addcarryxU32(&x532, &x533, x531, x527, x524); + var x534: u32 = undefined; + var x535: u1 = undefined; + addcarryxU32(&x534, &x535, x533, x525, x522); + var x536: u32 = undefined; + var x537: u1 = undefined; + addcarryxU32(&x536, &x537, x535, x523, x520); + var x538: u32 = undefined; + var x539: u1 = undefined; + addcarryxU32(&x538, &x539, x537, x521, x518); + const x540 = (cast(u32, x539) + x519); + var x541: u32 = undefined; + var x542: u1 = undefined; + addcarryxU32(&x541, &x542, 0x0, x496, x528); + var x543: u32 = undefined; + var x544: u1 = undefined; + addcarryxU32(&x543, &x544, x542, x498, x530); + var x545: u32 = undefined; + var x546: u1 = undefined; + addcarryxU32(&x545, &x546, x544, x500, x532); + var x547: u32 = undefined; + var x548: u1 = undefined; + addcarryxU32(&x547, &x548, x546, x502, x534); + var x549: u32 = undefined; + var x550: u1 = undefined; + addcarryxU32(&x549, &x550, x548, x504, x536); + var x551: u32 = undefined; + var x552: u1 = undefined; + addcarryxU32(&x551, &x552, x550, x506, x538); + var x553: u32 = undefined; + var x554: u1 = undefined; + addcarryxU32(&x553, &x554, x552, x508, x540); + var x555: u32 = undefined; + var x556: u1 = undefined; + addcarryxU32(&x555, &x556, x554, x510, x516); + var x557: u32 = undefined; + var x558: u1 = undefined; + addcarryxU32(&x557, &x558, x556, x512, x517); + const x559 = (cast(u32, x558) + cast(u32, x513)); + var x560: u32 = undefined; + var x561: u32 = undefined; + mulxU32(&x560, &x561, x6, (arg1[7])); + var x562: u32 = undefined; + var x563: u32 = undefined; + mulxU32(&x562, &x563, x6, (arg1[6])); + var x564: u32 = undefined; + var x565: u32 = undefined; + mulxU32(&x564, &x565, x6, (arg1[5])); + var x566: u32 = undefined; + var x567: u32 = undefined; + mulxU32(&x566, &x567, x6, (arg1[4])); + var x568: u32 = undefined; + var x569: u32 = undefined; + mulxU32(&x568, &x569, x6, (arg1[3])); + var x570: u32 = undefined; + var x571: u32 = undefined; + mulxU32(&x570, &x571, x6, (arg1[2])); + var x572: u32 = undefined; + var x573: u32 = undefined; + mulxU32(&x572, &x573, x6, (arg1[1])); + var x574: u32 = undefined; + var x575: u32 = undefined; + mulxU32(&x574, &x575, x6, (arg1[0])); + var x576: u32 = undefined; + var x577: u1 = undefined; + addcarryxU32(&x576, &x577, 0x0, x575, x572); + var x578: u32 = undefined; + var x579: u1 = undefined; + addcarryxU32(&x578, &x579, x577, x573, x570); + var x580: u32 = undefined; + var x581: u1 = undefined; + addcarryxU32(&x580, &x581, x579, x571, x568); + var x582: u32 = undefined; + var x583: u1 = undefined; + addcarryxU32(&x582, &x583, x581, x569, x566); + var x584: u32 = undefined; + var x585: u1 = undefined; + addcarryxU32(&x584, &x585, x583, x567, x564); + var x586: u32 = undefined; + var x587: u1 = undefined; + addcarryxU32(&x586, &x587, x585, x565, x562); + var x588: u32 = undefined; + var x589: u1 = undefined; + addcarryxU32(&x588, &x589, x587, x563, x560); + const x590 = (cast(u32, x589) + x561); + var x591: u32 = undefined; + var x592: u1 = undefined; + addcarryxU32(&x591, &x592, 0x0, x543, x574); + var x593: u32 = undefined; + var x594: u1 = undefined; + addcarryxU32(&x593, &x594, x592, x545, x576); + var x595: u32 = undefined; + var x596: u1 = undefined; + addcarryxU32(&x595, &x596, x594, x547, x578); + var x597: u32 = undefined; + var x598: u1 = undefined; + addcarryxU32(&x597, &x598, x596, x549, x580); + var x599: u32 = undefined; + var x600: u1 = undefined; + addcarryxU32(&x599, &x600, x598, x551, x582); + var x601: u32 = undefined; + var x602: u1 = undefined; + addcarryxU32(&x601, &x602, x600, x553, x584); + var x603: u32 = undefined; + var x604: u1 = undefined; + addcarryxU32(&x603, &x604, x602, x555, x586); + var x605: u32 = undefined; + var x606: u1 = undefined; + addcarryxU32(&x605, &x606, x604, x557, x588); + var x607: u32 = undefined; + var x608: u1 = undefined; + addcarryxU32(&x607, &x608, x606, x559, x590); + var x609: u32 = undefined; + var x610: u32 = undefined; + mulxU32(&x609, &x610, x591, 0xee00bc4f); + var x611: u32 = undefined; + var x612: u32 = undefined; + mulxU32(&x611, &x612, x609, 0xffffffff); + var x613: u32 = undefined; + var x614: u32 = undefined; + mulxU32(&x613, &x614, x609, 0xffffffff); + var x615: u32 = undefined; + var x616: u32 = undefined; + mulxU32(&x615, &x616, x609, 0xffffffff); + var x617: u32 = undefined; + var x618: u32 = undefined; + mulxU32(&x617, &x618, x609, 0xbce6faad); + var x619: u32 = undefined; + var x620: u32 = undefined; + mulxU32(&x619, &x620, x609, 0xa7179e84); + var x621: u32 = undefined; + var x622: u32 = undefined; + mulxU32(&x621, &x622, x609, 0xf3b9cac2); + var x623: u32 = undefined; + var x624: u32 = undefined; + mulxU32(&x623, &x624, x609, 0xfc632551); + var x625: u32 = undefined; + var x626: u1 = undefined; + addcarryxU32(&x625, &x626, 0x0, x624, x621); + var x627: u32 = undefined; + var x628: u1 = undefined; + addcarryxU32(&x627, &x628, x626, x622, x619); + var x629: u32 = undefined; + var x630: u1 = undefined; + addcarryxU32(&x629, &x630, x628, x620, x617); + var x631: u32 = undefined; + var x632: u1 = undefined; + addcarryxU32(&x631, &x632, x630, x618, x615); + var x633: u32 = undefined; + var x634: u1 = undefined; + addcarryxU32(&x633, &x634, x632, x616, x613); + const x635 = (cast(u32, x634) + x614); + var x636: u32 = undefined; + var x637: u1 = undefined; + addcarryxU32(&x636, &x637, 0x0, x591, x623); + var x638: u32 = undefined; + var x639: u1 = undefined; + addcarryxU32(&x638, &x639, x637, x593, x625); + var x640: u32 = undefined; + var x641: u1 = undefined; + addcarryxU32(&x640, &x641, x639, x595, x627); + var x642: u32 = undefined; + var x643: u1 = undefined; + addcarryxU32(&x642, &x643, x641, x597, x629); + var x644: u32 = undefined; + var x645: u1 = undefined; + addcarryxU32(&x644, &x645, x643, x599, x631); + var x646: u32 = undefined; + var x647: u1 = undefined; + addcarryxU32(&x646, &x647, x645, x601, x633); + var x648: u32 = undefined; + var x649: u1 = undefined; + addcarryxU32(&x648, &x649, x647, x603, x635); + var x650: u32 = undefined; + var x651: u1 = undefined; + addcarryxU32(&x650, &x651, x649, x605, x611); + var x652: u32 = undefined; + var x653: u1 = undefined; + addcarryxU32(&x652, &x653, x651, x607, x612); + const x654 = (cast(u32, x653) + cast(u32, x608)); + var x655: u32 = undefined; + var x656: u32 = undefined; + mulxU32(&x655, &x656, x7, (arg1[7])); + var x657: u32 = undefined; + var x658: u32 = undefined; + mulxU32(&x657, &x658, x7, (arg1[6])); + var x659: u32 = undefined; + var x660: u32 = undefined; + mulxU32(&x659, &x660, x7, (arg1[5])); + var x661: u32 = undefined; + var x662: u32 = undefined; + mulxU32(&x661, &x662, x7, (arg1[4])); + var x663: u32 = undefined; + var x664: u32 = undefined; + mulxU32(&x663, &x664, x7, (arg1[3])); + var x665: u32 = undefined; + var x666: u32 = undefined; + mulxU32(&x665, &x666, x7, (arg1[2])); + var x667: u32 = undefined; + var x668: u32 = undefined; + mulxU32(&x667, &x668, x7, (arg1[1])); + var x669: u32 = undefined; + var x670: u32 = undefined; + mulxU32(&x669, &x670, x7, (arg1[0])); + var x671: u32 = undefined; + var x672: u1 = undefined; + addcarryxU32(&x671, &x672, 0x0, x670, x667); + var x673: u32 = undefined; + var x674: u1 = undefined; + addcarryxU32(&x673, &x674, x672, x668, x665); + var x675: u32 = undefined; + var x676: u1 = undefined; + addcarryxU32(&x675, &x676, x674, x666, x663); + var x677: u32 = undefined; + var x678: u1 = undefined; + addcarryxU32(&x677, &x678, x676, x664, x661); + var x679: u32 = undefined; + var x680: u1 = undefined; + addcarryxU32(&x679, &x680, x678, x662, x659); + var x681: u32 = undefined; + var x682: u1 = undefined; + addcarryxU32(&x681, &x682, x680, x660, x657); + var x683: u32 = undefined; + var x684: u1 = undefined; + addcarryxU32(&x683, &x684, x682, x658, x655); + const x685 = (cast(u32, x684) + x656); + var x686: u32 = undefined; + var x687: u1 = undefined; + addcarryxU32(&x686, &x687, 0x0, x638, x669); + var x688: u32 = undefined; + var x689: u1 = undefined; + addcarryxU32(&x688, &x689, x687, x640, x671); + var x690: u32 = undefined; + var x691: u1 = undefined; + addcarryxU32(&x690, &x691, x689, x642, x673); + var x692: u32 = undefined; + var x693: u1 = undefined; + addcarryxU32(&x692, &x693, x691, x644, x675); + var x694: u32 = undefined; + var x695: u1 = undefined; + addcarryxU32(&x694, &x695, x693, x646, x677); + var x696: u32 = undefined; + var x697: u1 = undefined; + addcarryxU32(&x696, &x697, x695, x648, x679); + var x698: u32 = undefined; + var x699: u1 = undefined; + addcarryxU32(&x698, &x699, x697, x650, x681); + var x700: u32 = undefined; + var x701: u1 = undefined; + addcarryxU32(&x700, &x701, x699, x652, x683); + var x702: u32 = undefined; + var x703: u1 = undefined; + addcarryxU32(&x702, &x703, x701, x654, x685); + var x704: u32 = undefined; + var x705: u32 = undefined; + mulxU32(&x704, &x705, x686, 0xee00bc4f); + var x706: u32 = undefined; + var x707: u32 = undefined; + mulxU32(&x706, &x707, x704, 0xffffffff); + var x708: u32 = undefined; + var x709: u32 = undefined; + mulxU32(&x708, &x709, x704, 0xffffffff); + var x710: u32 = undefined; + var x711: u32 = undefined; + mulxU32(&x710, &x711, x704, 0xffffffff); + var x712: u32 = undefined; + var x713: u32 = undefined; + mulxU32(&x712, &x713, x704, 0xbce6faad); + var x714: u32 = undefined; + var x715: u32 = undefined; + mulxU32(&x714, &x715, x704, 0xa7179e84); + var x716: u32 = undefined; + var x717: u32 = undefined; + mulxU32(&x716, &x717, x704, 0xf3b9cac2); + var x718: u32 = undefined; + var x719: u32 = undefined; + mulxU32(&x718, &x719, x704, 0xfc632551); + var x720: u32 = undefined; + var x721: u1 = undefined; + addcarryxU32(&x720, &x721, 0x0, x719, x716); + var x722: u32 = undefined; + var x723: u1 = undefined; + addcarryxU32(&x722, &x723, x721, x717, x714); + var x724: u32 = undefined; + var x725: u1 = undefined; + addcarryxU32(&x724, &x725, x723, x715, x712); + var x726: u32 = undefined; + var x727: u1 = undefined; + addcarryxU32(&x726, &x727, x725, x713, x710); + var x728: u32 = undefined; + var x729: u1 = undefined; + addcarryxU32(&x728, &x729, x727, x711, x708); + const x730 = (cast(u32, x729) + x709); + var x731: u32 = undefined; + var x732: u1 = undefined; + addcarryxU32(&x731, &x732, 0x0, x686, x718); + var x733: u32 = undefined; + var x734: u1 = undefined; + addcarryxU32(&x733, &x734, x732, x688, x720); + var x735: u32 = undefined; + var x736: u1 = undefined; + addcarryxU32(&x735, &x736, x734, x690, x722); + var x737: u32 = undefined; + var x738: u1 = undefined; + addcarryxU32(&x737, &x738, x736, x692, x724); + var x739: u32 = undefined; + var x740: u1 = undefined; + addcarryxU32(&x739, &x740, x738, x694, x726); + var x741: u32 = undefined; + var x742: u1 = undefined; + addcarryxU32(&x741, &x742, x740, x696, x728); + var x743: u32 = undefined; + var x744: u1 = undefined; + addcarryxU32(&x743, &x744, x742, x698, x730); + var x745: u32 = undefined; + var x746: u1 = undefined; + addcarryxU32(&x745, &x746, x744, x700, x706); + var x747: u32 = undefined; + var x748: u1 = undefined; + addcarryxU32(&x747, &x748, x746, x702, x707); + const x749 = (cast(u32, x748) + cast(u32, x703)); + var x750: u32 = undefined; + var x751: u1 = undefined; + subborrowxU32(&x750, &x751, 0x0, x733, 0xfc632551); + var x752: u32 = undefined; + var x753: u1 = undefined; + subborrowxU32(&x752, &x753, x751, x735, 0xf3b9cac2); + var x754: u32 = undefined; + var x755: u1 = undefined; + subborrowxU32(&x754, &x755, x753, x737, 0xa7179e84); + var x756: u32 = undefined; + var x757: u1 = undefined; + subborrowxU32(&x756, &x757, x755, x739, 0xbce6faad); + var x758: u32 = undefined; + var x759: u1 = undefined; + subborrowxU32(&x758, &x759, x757, x741, 0xffffffff); + var x760: u32 = undefined; + var x761: u1 = undefined; + subborrowxU32(&x760, &x761, x759, x743, 0xffffffff); + var x762: u32 = undefined; + var x763: u1 = undefined; + subborrowxU32(&x762, &x763, x761, x745, cast(u32, 0x0)); + var x764: u32 = undefined; + var x765: u1 = undefined; + subborrowxU32(&x764, &x765, x763, x747, 0xffffffff); + var x766: u32 = undefined; + var x767: u1 = undefined; + subborrowxU32(&x766, &x767, x765, x749, cast(u32, 0x0)); + var x768: u32 = undefined; + cmovznzU32(&x768, x767, x750, x733); + var x769: u32 = undefined; + cmovznzU32(&x769, x767, x752, x735); + var x770: u32 = undefined; + cmovznzU32(&x770, x767, x754, x737); + var x771: u32 = undefined; + cmovznzU32(&x771, x767, x756, x739); + var x772: u32 = undefined; + cmovznzU32(&x772, x767, x758, x741); + var x773: u32 = undefined; + cmovznzU32(&x773, x767, x760, x743); + var x774: u32 = undefined; + cmovznzU32(&x774, x767, x762, x745); + var x775: u32 = undefined; + cmovznzU32(&x775, x767, x764, x747); + out1[0] = x768; + out1[1] = x769; + out1[2] = x770; + out1[3] = x771; + out1[4] = x772; + out1[5] = x773; + out1[6] = x774; + out1[7] = x775; +} + +/// The function add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn add(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + addcarryxU32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u32 = undefined; + var x4: u1 = undefined; + addcarryxU32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u32 = undefined; + var x6: u1 = undefined; + addcarryxU32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u32 = undefined; + var x8: u1 = undefined; + addcarryxU32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u32 = undefined; + var x10: u1 = undefined; + addcarryxU32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + var x11: u32 = undefined; + var x12: u1 = undefined; + addcarryxU32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + var x13: u32 = undefined; + var x14: u1 = undefined; + addcarryxU32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + var x15: u32 = undefined; + var x16: u1 = undefined; + addcarryxU32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + var x17: u32 = undefined; + var x18: u1 = undefined; + subborrowxU32(&x17, &x18, 0x0, x1, 0xfc632551); + var x19: u32 = undefined; + var x20: u1 = undefined; + subborrowxU32(&x19, &x20, x18, x3, 0xf3b9cac2); + var x21: u32 = undefined; + var x22: u1 = undefined; + subborrowxU32(&x21, &x22, x20, x5, 0xa7179e84); + var x23: u32 = undefined; + var x24: u1 = undefined; + subborrowxU32(&x23, &x24, x22, x7, 0xbce6faad); + var x25: u32 = undefined; + var x26: u1 = undefined; + subborrowxU32(&x25, &x26, x24, x9, 0xffffffff); + var x27: u32 = undefined; + var x28: u1 = undefined; + subborrowxU32(&x27, &x28, x26, x11, 0xffffffff); + var x29: u32 = undefined; + var x30: u1 = undefined; + subborrowxU32(&x29, &x30, x28, x13, cast(u32, 0x0)); + var x31: u32 = undefined; + var x32: u1 = undefined; + subborrowxU32(&x31, &x32, x30, x15, 0xffffffff); + var x33: u32 = undefined; + var x34: u1 = undefined; + subborrowxU32(&x33, &x34, x32, cast(u32, x16), cast(u32, 0x0)); + var x35: u32 = undefined; + cmovznzU32(&x35, x34, x17, x1); + var x36: u32 = undefined; + cmovznzU32(&x36, x34, x19, x3); + var x37: u32 = undefined; + cmovznzU32(&x37, x34, x21, x5); + var x38: u32 = undefined; + cmovznzU32(&x38, x34, x23, x7); + var x39: u32 = undefined; + cmovznzU32(&x39, x34, x25, x9); + var x40: u32 = undefined; + cmovznzU32(&x40, x34, x27, x11); + var x41: u32 = undefined; + cmovznzU32(&x41, x34, x29, x13); + var x42: u32 = undefined; + cmovznzU32(&x42, x34, x31, x15); + out1[0] = x35; + out1[1] = x36; + out1[2] = x37; + out1[3] = x38; + out1[4] = x39; + out1[5] = x40; + out1[6] = x41; + out1[7] = x42; +} + +/// The function sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn sub(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + subborrowxU32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u32 = undefined; + var x4: u1 = undefined; + subborrowxU32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u32 = undefined; + var x6: u1 = undefined; + subborrowxU32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u32 = undefined; + var x8: u1 = undefined; + subborrowxU32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u32 = undefined; + var x10: u1 = undefined; + subborrowxU32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + var x11: u32 = undefined; + var x12: u1 = undefined; + subborrowxU32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + var x13: u32 = undefined; + var x14: u1 = undefined; + subborrowxU32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + var x15: u32 = undefined; + var x16: u1 = undefined; + subborrowxU32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + var x17: u32 = undefined; + cmovznzU32(&x17, x16, cast(u32, 0x0), 0xffffffff); + var x18: u32 = undefined; + var x19: u1 = undefined; + addcarryxU32(&x18, &x19, 0x0, x1, (x17 & 0xfc632551)); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, x3, (x17 & 0xf3b9cac2)); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x5, (x17 & 0xa7179e84)); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x7, (x17 & 0xbce6faad)); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, x9, x17); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, x11, x17); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, x13, cast(u32, 0x0)); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x15, x17); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/// The function opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +pub fn opp(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + subborrowxU32(&x1, &x2, 0x0, cast(u32, 0x0), (arg1[0])); + var x3: u32 = undefined; + var x4: u1 = undefined; + subborrowxU32(&x3, &x4, x2, cast(u32, 0x0), (arg1[1])); + var x5: u32 = undefined; + var x6: u1 = undefined; + subborrowxU32(&x5, &x6, x4, cast(u32, 0x0), (arg1[2])); + var x7: u32 = undefined; + var x8: u1 = undefined; + subborrowxU32(&x7, &x8, x6, cast(u32, 0x0), (arg1[3])); + var x9: u32 = undefined; + var x10: u1 = undefined; + subborrowxU32(&x9, &x10, x8, cast(u32, 0x0), (arg1[4])); + var x11: u32 = undefined; + var x12: u1 = undefined; + subborrowxU32(&x11, &x12, x10, cast(u32, 0x0), (arg1[5])); + var x13: u32 = undefined; + var x14: u1 = undefined; + subborrowxU32(&x13, &x14, x12, cast(u32, 0x0), (arg1[6])); + var x15: u32 = undefined; + var x16: u1 = undefined; + subborrowxU32(&x15, &x16, x14, cast(u32, 0x0), (arg1[7])); + var x17: u32 = undefined; + cmovznzU32(&x17, x16, cast(u32, 0x0), 0xffffffff); + var x18: u32 = undefined; + var x19: u1 = undefined; + addcarryxU32(&x18, &x19, 0x0, x1, (x17 & 0xfc632551)); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, x3, (x17 & 0xf3b9cac2)); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x5, (x17 & 0xa7179e84)); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x7, (x17 & 0xbce6faad)); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, x9, x17); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, x11, x17); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, x13, cast(u32, 0x0)); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x15, x17); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/// The function fromMontgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m +/// 0 ≤ eval out1 < m +/// +pub fn fromMontgomery(out1: *NonMontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[0]); + var x2: u32 = undefined; + var x3: u32 = undefined; + mulxU32(&x2, &x3, x1, 0xee00bc4f); + var x4: u32 = undefined; + var x5: u32 = undefined; + mulxU32(&x4, &x5, x2, 0xffffffff); + var x6: u32 = undefined; + var x7: u32 = undefined; + mulxU32(&x6, &x7, x2, 0xffffffff); + var x8: u32 = undefined; + var x9: u32 = undefined; + mulxU32(&x8, &x9, x2, 0xffffffff); + var x10: u32 = undefined; + var x11: u32 = undefined; + mulxU32(&x10, &x11, x2, 0xbce6faad); + var x12: u32 = undefined; + var x13: u32 = undefined; + mulxU32(&x12, &x13, x2, 0xa7179e84); + var x14: u32 = undefined; + var x15: u32 = undefined; + mulxU32(&x14, &x15, x2, 0xf3b9cac2); + var x16: u32 = undefined; + var x17: u32 = undefined; + mulxU32(&x16, &x17, x2, 0xfc632551); + var x18: u32 = undefined; + var x19: u1 = undefined; + addcarryxU32(&x18, &x19, 0x0, x17, x14); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, x15, x12); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x13, x10); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x11, x8); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, x9, x6); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, 0x0, x1, x16); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, cast(u32, 0x0), x18); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, cast(u32, 0x0), x20); + var x34: u32 = undefined; + var x35: u1 = undefined; + addcarryxU32(&x34, &x35, x33, cast(u32, 0x0), x22); + var x36: u32 = undefined; + var x37: u1 = undefined; + addcarryxU32(&x36, &x37, x35, cast(u32, 0x0), x24); + var x38: u32 = undefined; + var x39: u1 = undefined; + addcarryxU32(&x38, &x39, x37, cast(u32, 0x0), x26); + var x40: u32 = undefined; + var x41: u1 = undefined; + addcarryxU32(&x40, &x41, x39, cast(u32, 0x0), (cast(u32, x27) + x7)); + var x42: u32 = undefined; + var x43: u1 = undefined; + addcarryxU32(&x42, &x43, x41, cast(u32, 0x0), x4); + var x44: u32 = undefined; + var x45: u1 = undefined; + addcarryxU32(&x44, &x45, 0x0, x30, (arg1[1])); + var x46: u32 = undefined; + var x47: u1 = undefined; + addcarryxU32(&x46, &x47, x45, x32, cast(u32, 0x0)); + var x48: u32 = undefined; + var x49: u1 = undefined; + addcarryxU32(&x48, &x49, x47, x34, cast(u32, 0x0)); + var x50: u32 = undefined; + var x51: u1 = undefined; + addcarryxU32(&x50, &x51, x49, x36, cast(u32, 0x0)); + var x52: u32 = undefined; + var x53: u1 = undefined; + addcarryxU32(&x52, &x53, x51, x38, cast(u32, 0x0)); + var x54: u32 = undefined; + var x55: u1 = undefined; + addcarryxU32(&x54, &x55, x53, x40, cast(u32, 0x0)); + var x56: u32 = undefined; + var x57: u1 = undefined; + addcarryxU32(&x56, &x57, x55, x42, cast(u32, 0x0)); + var x58: u32 = undefined; + var x59: u1 = undefined; + addcarryxU32(&x58, &x59, x57, (cast(u32, x43) + x5), cast(u32, 0x0)); + var x60: u32 = undefined; + var x61: u32 = undefined; + mulxU32(&x60, &x61, x44, 0xee00bc4f); + var x62: u32 = undefined; + var x63: u32 = undefined; + mulxU32(&x62, &x63, x60, 0xffffffff); + var x64: u32 = undefined; + var x65: u32 = undefined; + mulxU32(&x64, &x65, x60, 0xffffffff); + var x66: u32 = undefined; + var x67: u32 = undefined; + mulxU32(&x66, &x67, x60, 0xffffffff); + var x68: u32 = undefined; + var x69: u32 = undefined; + mulxU32(&x68, &x69, x60, 0xbce6faad); + var x70: u32 = undefined; + var x71: u32 = undefined; + mulxU32(&x70, &x71, x60, 0xa7179e84); + var x72: u32 = undefined; + var x73: u32 = undefined; + mulxU32(&x72, &x73, x60, 0xf3b9cac2); + var x74: u32 = undefined; + var x75: u32 = undefined; + mulxU32(&x74, &x75, x60, 0xfc632551); + var x76: u32 = undefined; + var x77: u1 = undefined; + addcarryxU32(&x76, &x77, 0x0, x75, x72); + var x78: u32 = undefined; + var x79: u1 = undefined; + addcarryxU32(&x78, &x79, x77, x73, x70); + var x80: u32 = undefined; + var x81: u1 = undefined; + addcarryxU32(&x80, &x81, x79, x71, x68); + var x82: u32 = undefined; + var x83: u1 = undefined; + addcarryxU32(&x82, &x83, x81, x69, x66); + var x84: u32 = undefined; + var x85: u1 = undefined; + addcarryxU32(&x84, &x85, x83, x67, x64); + var x86: u32 = undefined; + var x87: u1 = undefined; + addcarryxU32(&x86, &x87, 0x0, x44, x74); + var x88: u32 = undefined; + var x89: u1 = undefined; + addcarryxU32(&x88, &x89, x87, x46, x76); + var x90: u32 = undefined; + var x91: u1 = undefined; + addcarryxU32(&x90, &x91, x89, x48, x78); + var x92: u32 = undefined; + var x93: u1 = undefined; + addcarryxU32(&x92, &x93, x91, x50, x80); + var x94: u32 = undefined; + var x95: u1 = undefined; + addcarryxU32(&x94, &x95, x93, x52, x82); + var x96: u32 = undefined; + var x97: u1 = undefined; + addcarryxU32(&x96, &x97, x95, x54, x84); + var x98: u32 = undefined; + var x99: u1 = undefined; + addcarryxU32(&x98, &x99, x97, x56, (cast(u32, x85) + x65)); + var x100: u32 = undefined; + var x101: u1 = undefined; + addcarryxU32(&x100, &x101, x99, x58, x62); + var x102: u32 = undefined; + var x103: u1 = undefined; + addcarryxU32(&x102, &x103, x101, cast(u32, x59), x63); + var x104: u32 = undefined; + var x105: u1 = undefined; + addcarryxU32(&x104, &x105, 0x0, x88, (arg1[2])); + var x106: u32 = undefined; + var x107: u1 = undefined; + addcarryxU32(&x106, &x107, x105, x90, cast(u32, 0x0)); + var x108: u32 = undefined; + var x109: u1 = undefined; + addcarryxU32(&x108, &x109, x107, x92, cast(u32, 0x0)); + var x110: u32 = undefined; + var x111: u1 = undefined; + addcarryxU32(&x110, &x111, x109, x94, cast(u32, 0x0)); + var x112: u32 = undefined; + var x113: u1 = undefined; + addcarryxU32(&x112, &x113, x111, x96, cast(u32, 0x0)); + var x114: u32 = undefined; + var x115: u1 = undefined; + addcarryxU32(&x114, &x115, x113, x98, cast(u32, 0x0)); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, x115, x100, cast(u32, 0x0)); + var x118: u32 = undefined; + var x119: u1 = undefined; + addcarryxU32(&x118, &x119, x117, x102, cast(u32, 0x0)); + var x120: u32 = undefined; + var x121: u32 = undefined; + mulxU32(&x120, &x121, x104, 0xee00bc4f); + var x122: u32 = undefined; + var x123: u32 = undefined; + mulxU32(&x122, &x123, x120, 0xffffffff); + var x124: u32 = undefined; + var x125: u32 = undefined; + mulxU32(&x124, &x125, x120, 0xffffffff); + var x126: u32 = undefined; + var x127: u32 = undefined; + mulxU32(&x126, &x127, x120, 0xffffffff); + var x128: u32 = undefined; + var x129: u32 = undefined; + mulxU32(&x128, &x129, x120, 0xbce6faad); + var x130: u32 = undefined; + var x131: u32 = undefined; + mulxU32(&x130, &x131, x120, 0xa7179e84); + var x132: u32 = undefined; + var x133: u32 = undefined; + mulxU32(&x132, &x133, x120, 0xf3b9cac2); + var x134: u32 = undefined; + var x135: u32 = undefined; + mulxU32(&x134, &x135, x120, 0xfc632551); + var x136: u32 = undefined; + var x137: u1 = undefined; + addcarryxU32(&x136, &x137, 0x0, x135, x132); + var x138: u32 = undefined; + var x139: u1 = undefined; + addcarryxU32(&x138, &x139, x137, x133, x130); + var x140: u32 = undefined; + var x141: u1 = undefined; + addcarryxU32(&x140, &x141, x139, x131, x128); + var x142: u32 = undefined; + var x143: u1 = undefined; + addcarryxU32(&x142, &x143, x141, x129, x126); + var x144: u32 = undefined; + var x145: u1 = undefined; + addcarryxU32(&x144, &x145, x143, x127, x124); + var x146: u32 = undefined; + var x147: u1 = undefined; + addcarryxU32(&x146, &x147, 0x0, x104, x134); + var x148: u32 = undefined; + var x149: u1 = undefined; + addcarryxU32(&x148, &x149, x147, x106, x136); + var x150: u32 = undefined; + var x151: u1 = undefined; + addcarryxU32(&x150, &x151, x149, x108, x138); + var x152: u32 = undefined; + var x153: u1 = undefined; + addcarryxU32(&x152, &x153, x151, x110, x140); + var x154: u32 = undefined; + var x155: u1 = undefined; + addcarryxU32(&x154, &x155, x153, x112, x142); + var x156: u32 = undefined; + var x157: u1 = undefined; + addcarryxU32(&x156, &x157, x155, x114, x144); + var x158: u32 = undefined; + var x159: u1 = undefined; + addcarryxU32(&x158, &x159, x157, x116, (cast(u32, x145) + x125)); + var x160: u32 = undefined; + var x161: u1 = undefined; + addcarryxU32(&x160, &x161, x159, x118, x122); + var x162: u32 = undefined; + var x163: u1 = undefined; + addcarryxU32(&x162, &x163, x161, (cast(u32, x119) + cast(u32, x103)), x123); + var x164: u32 = undefined; + var x165: u1 = undefined; + addcarryxU32(&x164, &x165, 0x0, x148, (arg1[3])); + var x166: u32 = undefined; + var x167: u1 = undefined; + addcarryxU32(&x166, &x167, x165, x150, cast(u32, 0x0)); + var x168: u32 = undefined; + var x169: u1 = undefined; + addcarryxU32(&x168, &x169, x167, x152, cast(u32, 0x0)); + var x170: u32 = undefined; + var x171: u1 = undefined; + addcarryxU32(&x170, &x171, x169, x154, cast(u32, 0x0)); + var x172: u32 = undefined; + var x173: u1 = undefined; + addcarryxU32(&x172, &x173, x171, x156, cast(u32, 0x0)); + var x174: u32 = undefined; + var x175: u1 = undefined; + addcarryxU32(&x174, &x175, x173, x158, cast(u32, 0x0)); + var x176: u32 = undefined; + var x177: u1 = undefined; + addcarryxU32(&x176, &x177, x175, x160, cast(u32, 0x0)); + var x178: u32 = undefined; + var x179: u1 = undefined; + addcarryxU32(&x178, &x179, x177, x162, cast(u32, 0x0)); + var x180: u32 = undefined; + var x181: u32 = undefined; + mulxU32(&x180, &x181, x164, 0xee00bc4f); + var x182: u32 = undefined; + var x183: u32 = undefined; + mulxU32(&x182, &x183, x180, 0xffffffff); + var x184: u32 = undefined; + var x185: u32 = undefined; + mulxU32(&x184, &x185, x180, 0xffffffff); + var x186: u32 = undefined; + var x187: u32 = undefined; + mulxU32(&x186, &x187, x180, 0xffffffff); + var x188: u32 = undefined; + var x189: u32 = undefined; + mulxU32(&x188, &x189, x180, 0xbce6faad); + var x190: u32 = undefined; + var x191: u32 = undefined; + mulxU32(&x190, &x191, x180, 0xa7179e84); + var x192: u32 = undefined; + var x193: u32 = undefined; + mulxU32(&x192, &x193, x180, 0xf3b9cac2); + var x194: u32 = undefined; + var x195: u32 = undefined; + mulxU32(&x194, &x195, x180, 0xfc632551); + var x196: u32 = undefined; + var x197: u1 = undefined; + addcarryxU32(&x196, &x197, 0x0, x195, x192); + var x198: u32 = undefined; + var x199: u1 = undefined; + addcarryxU32(&x198, &x199, x197, x193, x190); + var x200: u32 = undefined; + var x201: u1 = undefined; + addcarryxU32(&x200, &x201, x199, x191, x188); + var x202: u32 = undefined; + var x203: u1 = undefined; + addcarryxU32(&x202, &x203, x201, x189, x186); + var x204: u32 = undefined; + var x205: u1 = undefined; + addcarryxU32(&x204, &x205, x203, x187, x184); + var x206: u32 = undefined; + var x207: u1 = undefined; + addcarryxU32(&x206, &x207, 0x0, x164, x194); + var x208: u32 = undefined; + var x209: u1 = undefined; + addcarryxU32(&x208, &x209, x207, x166, x196); + var x210: u32 = undefined; + var x211: u1 = undefined; + addcarryxU32(&x210, &x211, x209, x168, x198); + var x212: u32 = undefined; + var x213: u1 = undefined; + addcarryxU32(&x212, &x213, x211, x170, x200); + var x214: u32 = undefined; + var x215: u1 = undefined; + addcarryxU32(&x214, &x215, x213, x172, x202); + var x216: u32 = undefined; + var x217: u1 = undefined; + addcarryxU32(&x216, &x217, x215, x174, x204); + var x218: u32 = undefined; + var x219: u1 = undefined; + addcarryxU32(&x218, &x219, x217, x176, (cast(u32, x205) + x185)); + var x220: u32 = undefined; + var x221: u1 = undefined; + addcarryxU32(&x220, &x221, x219, x178, x182); + var x222: u32 = undefined; + var x223: u1 = undefined; + addcarryxU32(&x222, &x223, x221, (cast(u32, x179) + cast(u32, x163)), x183); + var x224: u32 = undefined; + var x225: u1 = undefined; + addcarryxU32(&x224, &x225, 0x0, x208, (arg1[4])); + var x226: u32 = undefined; + var x227: u1 = undefined; + addcarryxU32(&x226, &x227, x225, x210, cast(u32, 0x0)); + var x228: u32 = undefined; + var x229: u1 = undefined; + addcarryxU32(&x228, &x229, x227, x212, cast(u32, 0x0)); + var x230: u32 = undefined; + var x231: u1 = undefined; + addcarryxU32(&x230, &x231, x229, x214, cast(u32, 0x0)); + var x232: u32 = undefined; + var x233: u1 = undefined; + addcarryxU32(&x232, &x233, x231, x216, cast(u32, 0x0)); + var x234: u32 = undefined; + var x235: u1 = undefined; + addcarryxU32(&x234, &x235, x233, x218, cast(u32, 0x0)); + var x236: u32 = undefined; + var x237: u1 = undefined; + addcarryxU32(&x236, &x237, x235, x220, cast(u32, 0x0)); + var x238: u32 = undefined; + var x239: u1 = undefined; + addcarryxU32(&x238, &x239, x237, x222, cast(u32, 0x0)); + var x240: u32 = undefined; + var x241: u32 = undefined; + mulxU32(&x240, &x241, x224, 0xee00bc4f); + var x242: u32 = undefined; + var x243: u32 = undefined; + mulxU32(&x242, &x243, x240, 0xffffffff); + var x244: u32 = undefined; + var x245: u32 = undefined; + mulxU32(&x244, &x245, x240, 0xffffffff); + var x246: u32 = undefined; + var x247: u32 = undefined; + mulxU32(&x246, &x247, x240, 0xffffffff); + var x248: u32 = undefined; + var x249: u32 = undefined; + mulxU32(&x248, &x249, x240, 0xbce6faad); + var x250: u32 = undefined; + var x251: u32 = undefined; + mulxU32(&x250, &x251, x240, 0xa7179e84); + var x252: u32 = undefined; + var x253: u32 = undefined; + mulxU32(&x252, &x253, x240, 0xf3b9cac2); + var x254: u32 = undefined; + var x255: u32 = undefined; + mulxU32(&x254, &x255, x240, 0xfc632551); + var x256: u32 = undefined; + var x257: u1 = undefined; + addcarryxU32(&x256, &x257, 0x0, x255, x252); + var x258: u32 = undefined; + var x259: u1 = undefined; + addcarryxU32(&x258, &x259, x257, x253, x250); + var x260: u32 = undefined; + var x261: u1 = undefined; + addcarryxU32(&x260, &x261, x259, x251, x248); + var x262: u32 = undefined; + var x263: u1 = undefined; + addcarryxU32(&x262, &x263, x261, x249, x246); + var x264: u32 = undefined; + var x265: u1 = undefined; + addcarryxU32(&x264, &x265, x263, x247, x244); + var x266: u32 = undefined; + var x267: u1 = undefined; + addcarryxU32(&x266, &x267, 0x0, x224, x254); + var x268: u32 = undefined; + var x269: u1 = undefined; + addcarryxU32(&x268, &x269, x267, x226, x256); + var x270: u32 = undefined; + var x271: u1 = undefined; + addcarryxU32(&x270, &x271, x269, x228, x258); + var x272: u32 = undefined; + var x273: u1 = undefined; + addcarryxU32(&x272, &x273, x271, x230, x260); + var x274: u32 = undefined; + var x275: u1 = undefined; + addcarryxU32(&x274, &x275, x273, x232, x262); + var x276: u32 = undefined; + var x277: u1 = undefined; + addcarryxU32(&x276, &x277, x275, x234, x264); + var x278: u32 = undefined; + var x279: u1 = undefined; + addcarryxU32(&x278, &x279, x277, x236, (cast(u32, x265) + x245)); + var x280: u32 = undefined; + var x281: u1 = undefined; + addcarryxU32(&x280, &x281, x279, x238, x242); + var x282: u32 = undefined; + var x283: u1 = undefined; + addcarryxU32(&x282, &x283, x281, (cast(u32, x239) + cast(u32, x223)), x243); + var x284: u32 = undefined; + var x285: u1 = undefined; + addcarryxU32(&x284, &x285, 0x0, x268, (arg1[5])); + var x286: u32 = undefined; + var x287: u1 = undefined; + addcarryxU32(&x286, &x287, x285, x270, cast(u32, 0x0)); + var x288: u32 = undefined; + var x289: u1 = undefined; + addcarryxU32(&x288, &x289, x287, x272, cast(u32, 0x0)); + var x290: u32 = undefined; + var x291: u1 = undefined; + addcarryxU32(&x290, &x291, x289, x274, cast(u32, 0x0)); + var x292: u32 = undefined; + var x293: u1 = undefined; + addcarryxU32(&x292, &x293, x291, x276, cast(u32, 0x0)); + var x294: u32 = undefined; + var x295: u1 = undefined; + addcarryxU32(&x294, &x295, x293, x278, cast(u32, 0x0)); + var x296: u32 = undefined; + var x297: u1 = undefined; + addcarryxU32(&x296, &x297, x295, x280, cast(u32, 0x0)); + var x298: u32 = undefined; + var x299: u1 = undefined; + addcarryxU32(&x298, &x299, x297, x282, cast(u32, 0x0)); + var x300: u32 = undefined; + var x301: u32 = undefined; + mulxU32(&x300, &x301, x284, 0xee00bc4f); + var x302: u32 = undefined; + var x303: u32 = undefined; + mulxU32(&x302, &x303, x300, 0xffffffff); + var x304: u32 = undefined; + var x305: u32 = undefined; + mulxU32(&x304, &x305, x300, 0xffffffff); + var x306: u32 = undefined; + var x307: u32 = undefined; + mulxU32(&x306, &x307, x300, 0xffffffff); + var x308: u32 = undefined; + var x309: u32 = undefined; + mulxU32(&x308, &x309, x300, 0xbce6faad); + var x310: u32 = undefined; + var x311: u32 = undefined; + mulxU32(&x310, &x311, x300, 0xa7179e84); + var x312: u32 = undefined; + var x313: u32 = undefined; + mulxU32(&x312, &x313, x300, 0xf3b9cac2); + var x314: u32 = undefined; + var x315: u32 = undefined; + mulxU32(&x314, &x315, x300, 0xfc632551); + var x316: u32 = undefined; + var x317: u1 = undefined; + addcarryxU32(&x316, &x317, 0x0, x315, x312); + var x318: u32 = undefined; + var x319: u1 = undefined; + addcarryxU32(&x318, &x319, x317, x313, x310); + var x320: u32 = undefined; + var x321: u1 = undefined; + addcarryxU32(&x320, &x321, x319, x311, x308); + var x322: u32 = undefined; + var x323: u1 = undefined; + addcarryxU32(&x322, &x323, x321, x309, x306); + var x324: u32 = undefined; + var x325: u1 = undefined; + addcarryxU32(&x324, &x325, x323, x307, x304); + var x326: u32 = undefined; + var x327: u1 = undefined; + addcarryxU32(&x326, &x327, 0x0, x284, x314); + var x328: u32 = undefined; + var x329: u1 = undefined; + addcarryxU32(&x328, &x329, x327, x286, x316); + var x330: u32 = undefined; + var x331: u1 = undefined; + addcarryxU32(&x330, &x331, x329, x288, x318); + var x332: u32 = undefined; + var x333: u1 = undefined; + addcarryxU32(&x332, &x333, x331, x290, x320); + var x334: u32 = undefined; + var x335: u1 = undefined; + addcarryxU32(&x334, &x335, x333, x292, x322); + var x336: u32 = undefined; + var x337: u1 = undefined; + addcarryxU32(&x336, &x337, x335, x294, x324); + var x338: u32 = undefined; + var x339: u1 = undefined; + addcarryxU32(&x338, &x339, x337, x296, (cast(u32, x325) + x305)); + var x340: u32 = undefined; + var x341: u1 = undefined; + addcarryxU32(&x340, &x341, x339, x298, x302); + var x342: u32 = undefined; + var x343: u1 = undefined; + addcarryxU32(&x342, &x343, x341, (cast(u32, x299) + cast(u32, x283)), x303); + var x344: u32 = undefined; + var x345: u1 = undefined; + addcarryxU32(&x344, &x345, 0x0, x328, (arg1[6])); + var x346: u32 = undefined; + var x347: u1 = undefined; + addcarryxU32(&x346, &x347, x345, x330, cast(u32, 0x0)); + var x348: u32 = undefined; + var x349: u1 = undefined; + addcarryxU32(&x348, &x349, x347, x332, cast(u32, 0x0)); + var x350: u32 = undefined; + var x351: u1 = undefined; + addcarryxU32(&x350, &x351, x349, x334, cast(u32, 0x0)); + var x352: u32 = undefined; + var x353: u1 = undefined; + addcarryxU32(&x352, &x353, x351, x336, cast(u32, 0x0)); + var x354: u32 = undefined; + var x355: u1 = undefined; + addcarryxU32(&x354, &x355, x353, x338, cast(u32, 0x0)); + var x356: u32 = undefined; + var x357: u1 = undefined; + addcarryxU32(&x356, &x357, x355, x340, cast(u32, 0x0)); + var x358: u32 = undefined; + var x359: u1 = undefined; + addcarryxU32(&x358, &x359, x357, x342, cast(u32, 0x0)); + var x360: u32 = undefined; + var x361: u32 = undefined; + mulxU32(&x360, &x361, x344, 0xee00bc4f); + var x362: u32 = undefined; + var x363: u32 = undefined; + mulxU32(&x362, &x363, x360, 0xffffffff); + var x364: u32 = undefined; + var x365: u32 = undefined; + mulxU32(&x364, &x365, x360, 0xffffffff); + var x366: u32 = undefined; + var x367: u32 = undefined; + mulxU32(&x366, &x367, x360, 0xffffffff); + var x368: u32 = undefined; + var x369: u32 = undefined; + mulxU32(&x368, &x369, x360, 0xbce6faad); + var x370: u32 = undefined; + var x371: u32 = undefined; + mulxU32(&x370, &x371, x360, 0xa7179e84); + var x372: u32 = undefined; + var x373: u32 = undefined; + mulxU32(&x372, &x373, x360, 0xf3b9cac2); + var x374: u32 = undefined; + var x375: u32 = undefined; + mulxU32(&x374, &x375, x360, 0xfc632551); + var x376: u32 = undefined; + var x377: u1 = undefined; + addcarryxU32(&x376, &x377, 0x0, x375, x372); + var x378: u32 = undefined; + var x379: u1 = undefined; + addcarryxU32(&x378, &x379, x377, x373, x370); + var x380: u32 = undefined; + var x381: u1 = undefined; + addcarryxU32(&x380, &x381, x379, x371, x368); + var x382: u32 = undefined; + var x383: u1 = undefined; + addcarryxU32(&x382, &x383, x381, x369, x366); + var x384: u32 = undefined; + var x385: u1 = undefined; + addcarryxU32(&x384, &x385, x383, x367, x364); + var x386: u32 = undefined; + var x387: u1 = undefined; + addcarryxU32(&x386, &x387, 0x0, x344, x374); + var x388: u32 = undefined; + var x389: u1 = undefined; + addcarryxU32(&x388, &x389, x387, x346, x376); + var x390: u32 = undefined; + var x391: u1 = undefined; + addcarryxU32(&x390, &x391, x389, x348, x378); + var x392: u32 = undefined; + var x393: u1 = undefined; + addcarryxU32(&x392, &x393, x391, x350, x380); + var x394: u32 = undefined; + var x395: u1 = undefined; + addcarryxU32(&x394, &x395, x393, x352, x382); + var x396: u32 = undefined; + var x397: u1 = undefined; + addcarryxU32(&x396, &x397, x395, x354, x384); + var x398: u32 = undefined; + var x399: u1 = undefined; + addcarryxU32(&x398, &x399, x397, x356, (cast(u32, x385) + x365)); + var x400: u32 = undefined; + var x401: u1 = undefined; + addcarryxU32(&x400, &x401, x399, x358, x362); + var x402: u32 = undefined; + var x403: u1 = undefined; + addcarryxU32(&x402, &x403, x401, (cast(u32, x359) + cast(u32, x343)), x363); + var x404: u32 = undefined; + var x405: u1 = undefined; + addcarryxU32(&x404, &x405, 0x0, x388, (arg1[7])); + var x406: u32 = undefined; + var x407: u1 = undefined; + addcarryxU32(&x406, &x407, x405, x390, cast(u32, 0x0)); + var x408: u32 = undefined; + var x409: u1 = undefined; + addcarryxU32(&x408, &x409, x407, x392, cast(u32, 0x0)); + var x410: u32 = undefined; + var x411: u1 = undefined; + addcarryxU32(&x410, &x411, x409, x394, cast(u32, 0x0)); + var x412: u32 = undefined; + var x413: u1 = undefined; + addcarryxU32(&x412, &x413, x411, x396, cast(u32, 0x0)); + var x414: u32 = undefined; + var x415: u1 = undefined; + addcarryxU32(&x414, &x415, x413, x398, cast(u32, 0x0)); + var x416: u32 = undefined; + var x417: u1 = undefined; + addcarryxU32(&x416, &x417, x415, x400, cast(u32, 0x0)); + var x418: u32 = undefined; + var x419: u1 = undefined; + addcarryxU32(&x418, &x419, x417, x402, cast(u32, 0x0)); + var x420: u32 = undefined; + var x421: u32 = undefined; + mulxU32(&x420, &x421, x404, 0xee00bc4f); + var x422: u32 = undefined; + var x423: u32 = undefined; + mulxU32(&x422, &x423, x420, 0xffffffff); + var x424: u32 = undefined; + var x425: u32 = undefined; + mulxU32(&x424, &x425, x420, 0xffffffff); + var x426: u32 = undefined; + var x427: u32 = undefined; + mulxU32(&x426, &x427, x420, 0xffffffff); + var x428: u32 = undefined; + var x429: u32 = undefined; + mulxU32(&x428, &x429, x420, 0xbce6faad); + var x430: u32 = undefined; + var x431: u32 = undefined; + mulxU32(&x430, &x431, x420, 0xa7179e84); + var x432: u32 = undefined; + var x433: u32 = undefined; + mulxU32(&x432, &x433, x420, 0xf3b9cac2); + var x434: u32 = undefined; + var x435: u32 = undefined; + mulxU32(&x434, &x435, x420, 0xfc632551); + var x436: u32 = undefined; + var x437: u1 = undefined; + addcarryxU32(&x436, &x437, 0x0, x435, x432); + var x438: u32 = undefined; + var x439: u1 = undefined; + addcarryxU32(&x438, &x439, x437, x433, x430); + var x440: u32 = undefined; + var x441: u1 = undefined; + addcarryxU32(&x440, &x441, x439, x431, x428); + var x442: u32 = undefined; + var x443: u1 = undefined; + addcarryxU32(&x442, &x443, x441, x429, x426); + var x444: u32 = undefined; + var x445: u1 = undefined; + addcarryxU32(&x444, &x445, x443, x427, x424); + var x446: u32 = undefined; + var x447: u1 = undefined; + addcarryxU32(&x446, &x447, 0x0, x404, x434); + var x448: u32 = undefined; + var x449: u1 = undefined; + addcarryxU32(&x448, &x449, x447, x406, x436); + var x450: u32 = undefined; + var x451: u1 = undefined; + addcarryxU32(&x450, &x451, x449, x408, x438); + var x452: u32 = undefined; + var x453: u1 = undefined; + addcarryxU32(&x452, &x453, x451, x410, x440); + var x454: u32 = undefined; + var x455: u1 = undefined; + addcarryxU32(&x454, &x455, x453, x412, x442); + var x456: u32 = undefined; + var x457: u1 = undefined; + addcarryxU32(&x456, &x457, x455, x414, x444); + var x458: u32 = undefined; + var x459: u1 = undefined; + addcarryxU32(&x458, &x459, x457, x416, (cast(u32, x445) + x425)); + var x460: u32 = undefined; + var x461: u1 = undefined; + addcarryxU32(&x460, &x461, x459, x418, x422); + var x462: u32 = undefined; + var x463: u1 = undefined; + addcarryxU32(&x462, &x463, x461, (cast(u32, x419) + cast(u32, x403)), x423); + var x464: u32 = undefined; + var x465: u1 = undefined; + subborrowxU32(&x464, &x465, 0x0, x448, 0xfc632551); + var x466: u32 = undefined; + var x467: u1 = undefined; + subborrowxU32(&x466, &x467, x465, x450, 0xf3b9cac2); + var x468: u32 = undefined; + var x469: u1 = undefined; + subborrowxU32(&x468, &x469, x467, x452, 0xa7179e84); + var x470: u32 = undefined; + var x471: u1 = undefined; + subborrowxU32(&x470, &x471, x469, x454, 0xbce6faad); + var x472: u32 = undefined; + var x473: u1 = undefined; + subborrowxU32(&x472, &x473, x471, x456, 0xffffffff); + var x474: u32 = undefined; + var x475: u1 = undefined; + subborrowxU32(&x474, &x475, x473, x458, 0xffffffff); + var x476: u32 = undefined; + var x477: u1 = undefined; + subborrowxU32(&x476, &x477, x475, x460, cast(u32, 0x0)); + var x478: u32 = undefined; + var x479: u1 = undefined; + subborrowxU32(&x478, &x479, x477, x462, 0xffffffff); + var x480: u32 = undefined; + var x481: u1 = undefined; + subborrowxU32(&x480, &x481, x479, cast(u32, x463), cast(u32, 0x0)); + var x482: u32 = undefined; + cmovznzU32(&x482, x481, x464, x448); + var x483: u32 = undefined; + cmovznzU32(&x483, x481, x466, x450); + var x484: u32 = undefined; + cmovznzU32(&x484, x481, x468, x452); + var x485: u32 = undefined; + cmovznzU32(&x485, x481, x470, x454); + var x486: u32 = undefined; + cmovznzU32(&x486, x481, x472, x456); + var x487: u32 = undefined; + cmovznzU32(&x487, x481, x474, x458); + var x488: u32 = undefined; + cmovznzU32(&x488, x481, x476, x460); + var x489: u32 = undefined; + cmovznzU32(&x489, x481, x478, x462); + out1[0] = x482; + out1[1] = x483; + out1[2] = x484; + out1[3] = x485; + out1[4] = x486; + out1[5] = x487; + out1[6] = x488; + out1[7] = x489; +} + +/// The function toMontgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn toMontgomery(out1: *MontgomeryDomainFieldElement, arg1: NonMontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[6]); + const x7 = (arg1[7]); + const x8 = (arg1[0]); + var x9: u32 = undefined; + var x10: u32 = undefined; + mulxU32(&x9, &x10, x8, 0x66e12d94); + var x11: u32 = undefined; + var x12: u32 = undefined; + mulxU32(&x11, &x12, x8, 0xf3d95620); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x8, 0x2845b239); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x8, 0x2b6bec59); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x8, 0x4699799c); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x8, 0x49bd6fa6); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x8, 0x83244c95); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x8, 0xbe79eea2); + var x25: u32 = undefined; + var x26: u1 = undefined; + addcarryxU32(&x25, &x26, 0x0, x24, x21); + var x27: u32 = undefined; + var x28: u1 = undefined; + addcarryxU32(&x27, &x28, x26, x22, x19); + var x29: u32 = undefined; + var x30: u1 = undefined; + addcarryxU32(&x29, &x30, x28, x20, x17); + var x31: u32 = undefined; + var x32: u1 = undefined; + addcarryxU32(&x31, &x32, x30, x18, x15); + var x33: u32 = undefined; + var x34: u1 = undefined; + addcarryxU32(&x33, &x34, x32, x16, x13); + var x35: u32 = undefined; + var x36: u1 = undefined; + addcarryxU32(&x35, &x36, x34, x14, x11); + var x37: u32 = undefined; + var x38: u1 = undefined; + addcarryxU32(&x37, &x38, x36, x12, x9); + var x39: u32 = undefined; + var x40: u32 = undefined; + mulxU32(&x39, &x40, x23, 0xee00bc4f); + var x41: u32 = undefined; + var x42: u32 = undefined; + mulxU32(&x41, &x42, x39, 0xffffffff); + var x43: u32 = undefined; + var x44: u32 = undefined; + mulxU32(&x43, &x44, x39, 0xffffffff); + var x45: u32 = undefined; + var x46: u32 = undefined; + mulxU32(&x45, &x46, x39, 0xffffffff); + var x47: u32 = undefined; + var x48: u32 = undefined; + mulxU32(&x47, &x48, x39, 0xbce6faad); + var x49: u32 = undefined; + var x50: u32 = undefined; + mulxU32(&x49, &x50, x39, 0xa7179e84); + var x51: u32 = undefined; + var x52: u32 = undefined; + mulxU32(&x51, &x52, x39, 0xf3b9cac2); + var x53: u32 = undefined; + var x54: u32 = undefined; + mulxU32(&x53, &x54, x39, 0xfc632551); + var x55: u32 = undefined; + var x56: u1 = undefined; + addcarryxU32(&x55, &x56, 0x0, x54, x51); + var x57: u32 = undefined; + var x58: u1 = undefined; + addcarryxU32(&x57, &x58, x56, x52, x49); + var x59: u32 = undefined; + var x60: u1 = undefined; + addcarryxU32(&x59, &x60, x58, x50, x47); + var x61: u32 = undefined; + var x62: u1 = undefined; + addcarryxU32(&x61, &x62, x60, x48, x45); + var x63: u32 = undefined; + var x64: u1 = undefined; + addcarryxU32(&x63, &x64, x62, x46, x43); + var x65: u32 = undefined; + var x66: u1 = undefined; + addcarryxU32(&x65, &x66, 0x0, x23, x53); + var x67: u32 = undefined; + var x68: u1 = undefined; + addcarryxU32(&x67, &x68, x66, x25, x55); + var x69: u32 = undefined; + var x70: u1 = undefined; + addcarryxU32(&x69, &x70, x68, x27, x57); + var x71: u32 = undefined; + var x72: u1 = undefined; + addcarryxU32(&x71, &x72, x70, x29, x59); + var x73: u32 = undefined; + var x74: u1 = undefined; + addcarryxU32(&x73, &x74, x72, x31, x61); + var x75: u32 = undefined; + var x76: u1 = undefined; + addcarryxU32(&x75, &x76, x74, x33, x63); + var x77: u32 = undefined; + var x78: u1 = undefined; + addcarryxU32(&x77, &x78, x76, x35, (cast(u32, x64) + x44)); + var x79: u32 = undefined; + var x80: u1 = undefined; + addcarryxU32(&x79, &x80, x78, x37, x41); + var x81: u32 = undefined; + var x82: u1 = undefined; + addcarryxU32(&x81, &x82, x80, (cast(u32, x38) + x10), x42); + var x83: u32 = undefined; + var x84: u32 = undefined; + mulxU32(&x83, &x84, x1, 0x66e12d94); + var x85: u32 = undefined; + var x86: u32 = undefined; + mulxU32(&x85, &x86, x1, 0xf3d95620); + var x87: u32 = undefined; + var x88: u32 = undefined; + mulxU32(&x87, &x88, x1, 0x2845b239); + var x89: u32 = undefined; + var x90: u32 = undefined; + mulxU32(&x89, &x90, x1, 0x2b6bec59); + var x91: u32 = undefined; + var x92: u32 = undefined; + mulxU32(&x91, &x92, x1, 0x4699799c); + var x93: u32 = undefined; + var x94: u32 = undefined; + mulxU32(&x93, &x94, x1, 0x49bd6fa6); + var x95: u32 = undefined; + var x96: u32 = undefined; + mulxU32(&x95, &x96, x1, 0x83244c95); + var x97: u32 = undefined; + var x98: u32 = undefined; + mulxU32(&x97, &x98, x1, 0xbe79eea2); + var x99: u32 = undefined; + var x100: u1 = undefined; + addcarryxU32(&x99, &x100, 0x0, x98, x95); + var x101: u32 = undefined; + var x102: u1 = undefined; + addcarryxU32(&x101, &x102, x100, x96, x93); + var x103: u32 = undefined; + var x104: u1 = undefined; + addcarryxU32(&x103, &x104, x102, x94, x91); + var x105: u32 = undefined; + var x106: u1 = undefined; + addcarryxU32(&x105, &x106, x104, x92, x89); + var x107: u32 = undefined; + var x108: u1 = undefined; + addcarryxU32(&x107, &x108, x106, x90, x87); + var x109: u32 = undefined; + var x110: u1 = undefined; + addcarryxU32(&x109, &x110, x108, x88, x85); + var x111: u32 = undefined; + var x112: u1 = undefined; + addcarryxU32(&x111, &x112, x110, x86, x83); + var x113: u32 = undefined; + var x114: u1 = undefined; + addcarryxU32(&x113, &x114, 0x0, x67, x97); + var x115: u32 = undefined; + var x116: u1 = undefined; + addcarryxU32(&x115, &x116, x114, x69, x99); + var x117: u32 = undefined; + var x118: u1 = undefined; + addcarryxU32(&x117, &x118, x116, x71, x101); + var x119: u32 = undefined; + var x120: u1 = undefined; + addcarryxU32(&x119, &x120, x118, x73, x103); + var x121: u32 = undefined; + var x122: u1 = undefined; + addcarryxU32(&x121, &x122, x120, x75, x105); + var x123: u32 = undefined; + var x124: u1 = undefined; + addcarryxU32(&x123, &x124, x122, x77, x107); + var x125: u32 = undefined; + var x126: u1 = undefined; + addcarryxU32(&x125, &x126, x124, x79, x109); + var x127: u32 = undefined; + var x128: u1 = undefined; + addcarryxU32(&x127, &x128, x126, x81, x111); + var x129: u32 = undefined; + var x130: u32 = undefined; + mulxU32(&x129, &x130, x113, 0xee00bc4f); + var x131: u32 = undefined; + var x132: u32 = undefined; + mulxU32(&x131, &x132, x129, 0xffffffff); + var x133: u32 = undefined; + var x134: u32 = undefined; + mulxU32(&x133, &x134, x129, 0xffffffff); + var x135: u32 = undefined; + var x136: u32 = undefined; + mulxU32(&x135, &x136, x129, 0xffffffff); + var x137: u32 = undefined; + var x138: u32 = undefined; + mulxU32(&x137, &x138, x129, 0xbce6faad); + var x139: u32 = undefined; + var x140: u32 = undefined; + mulxU32(&x139, &x140, x129, 0xa7179e84); + var x141: u32 = undefined; + var x142: u32 = undefined; + mulxU32(&x141, &x142, x129, 0xf3b9cac2); + var x143: u32 = undefined; + var x144: u32 = undefined; + mulxU32(&x143, &x144, x129, 0xfc632551); + var x145: u32 = undefined; + var x146: u1 = undefined; + addcarryxU32(&x145, &x146, 0x0, x144, x141); + var x147: u32 = undefined; + var x148: u1 = undefined; + addcarryxU32(&x147, &x148, x146, x142, x139); + var x149: u32 = undefined; + var x150: u1 = undefined; + addcarryxU32(&x149, &x150, x148, x140, x137); + var x151: u32 = undefined; + var x152: u1 = undefined; + addcarryxU32(&x151, &x152, x150, x138, x135); + var x153: u32 = undefined; + var x154: u1 = undefined; + addcarryxU32(&x153, &x154, x152, x136, x133); + var x155: u32 = undefined; + var x156: u1 = undefined; + addcarryxU32(&x155, &x156, 0x0, x113, x143); + var x157: u32 = undefined; + var x158: u1 = undefined; + addcarryxU32(&x157, &x158, x156, x115, x145); + var x159: u32 = undefined; + var x160: u1 = undefined; + addcarryxU32(&x159, &x160, x158, x117, x147); + var x161: u32 = undefined; + var x162: u1 = undefined; + addcarryxU32(&x161, &x162, x160, x119, x149); + var x163: u32 = undefined; + var x164: u1 = undefined; + addcarryxU32(&x163, &x164, x162, x121, x151); + var x165: u32 = undefined; + var x166: u1 = undefined; + addcarryxU32(&x165, &x166, x164, x123, x153); + var x167: u32 = undefined; + var x168: u1 = undefined; + addcarryxU32(&x167, &x168, x166, x125, (cast(u32, x154) + x134)); + var x169: u32 = undefined; + var x170: u1 = undefined; + addcarryxU32(&x169, &x170, x168, x127, x131); + var x171: u32 = undefined; + var x172: u1 = undefined; + addcarryxU32(&x171, &x172, x170, ((cast(u32, x128) + cast(u32, x82)) + (cast(u32, x112) + x84)), x132); + var x173: u32 = undefined; + var x174: u32 = undefined; + mulxU32(&x173, &x174, x2, 0x66e12d94); + var x175: u32 = undefined; + var x176: u32 = undefined; + mulxU32(&x175, &x176, x2, 0xf3d95620); + var x177: u32 = undefined; + var x178: u32 = undefined; + mulxU32(&x177, &x178, x2, 0x2845b239); + var x179: u32 = undefined; + var x180: u32 = undefined; + mulxU32(&x179, &x180, x2, 0x2b6bec59); + var x181: u32 = undefined; + var x182: u32 = undefined; + mulxU32(&x181, &x182, x2, 0x4699799c); + var x183: u32 = undefined; + var x184: u32 = undefined; + mulxU32(&x183, &x184, x2, 0x49bd6fa6); + var x185: u32 = undefined; + var x186: u32 = undefined; + mulxU32(&x185, &x186, x2, 0x83244c95); + var x187: u32 = undefined; + var x188: u32 = undefined; + mulxU32(&x187, &x188, x2, 0xbe79eea2); + var x189: u32 = undefined; + var x190: u1 = undefined; + addcarryxU32(&x189, &x190, 0x0, x188, x185); + var x191: u32 = undefined; + var x192: u1 = undefined; + addcarryxU32(&x191, &x192, x190, x186, x183); + var x193: u32 = undefined; + var x194: u1 = undefined; + addcarryxU32(&x193, &x194, x192, x184, x181); + var x195: u32 = undefined; + var x196: u1 = undefined; + addcarryxU32(&x195, &x196, x194, x182, x179); + var x197: u32 = undefined; + var x198: u1 = undefined; + addcarryxU32(&x197, &x198, x196, x180, x177); + var x199: u32 = undefined; + var x200: u1 = undefined; + addcarryxU32(&x199, &x200, x198, x178, x175); + var x201: u32 = undefined; + var x202: u1 = undefined; + addcarryxU32(&x201, &x202, x200, x176, x173); + var x203: u32 = undefined; + var x204: u1 = undefined; + addcarryxU32(&x203, &x204, 0x0, x157, x187); + var x205: u32 = undefined; + var x206: u1 = undefined; + addcarryxU32(&x205, &x206, x204, x159, x189); + var x207: u32 = undefined; + var x208: u1 = undefined; + addcarryxU32(&x207, &x208, x206, x161, x191); + var x209: u32 = undefined; + var x210: u1 = undefined; + addcarryxU32(&x209, &x210, x208, x163, x193); + var x211: u32 = undefined; + var x212: u1 = undefined; + addcarryxU32(&x211, &x212, x210, x165, x195); + var x213: u32 = undefined; + var x214: u1 = undefined; + addcarryxU32(&x213, &x214, x212, x167, x197); + var x215: u32 = undefined; + var x216: u1 = undefined; + addcarryxU32(&x215, &x216, x214, x169, x199); + var x217: u32 = undefined; + var x218: u1 = undefined; + addcarryxU32(&x217, &x218, x216, x171, x201); + var x219: u32 = undefined; + var x220: u32 = undefined; + mulxU32(&x219, &x220, x203, 0xee00bc4f); + var x221: u32 = undefined; + var x222: u32 = undefined; + mulxU32(&x221, &x222, x219, 0xffffffff); + var x223: u32 = undefined; + var x224: u32 = undefined; + mulxU32(&x223, &x224, x219, 0xffffffff); + var x225: u32 = undefined; + var x226: u32 = undefined; + mulxU32(&x225, &x226, x219, 0xffffffff); + var x227: u32 = undefined; + var x228: u32 = undefined; + mulxU32(&x227, &x228, x219, 0xbce6faad); + var x229: u32 = undefined; + var x230: u32 = undefined; + mulxU32(&x229, &x230, x219, 0xa7179e84); + var x231: u32 = undefined; + var x232: u32 = undefined; + mulxU32(&x231, &x232, x219, 0xf3b9cac2); + var x233: u32 = undefined; + var x234: u32 = undefined; + mulxU32(&x233, &x234, x219, 0xfc632551); + var x235: u32 = undefined; + var x236: u1 = undefined; + addcarryxU32(&x235, &x236, 0x0, x234, x231); + var x237: u32 = undefined; + var x238: u1 = undefined; + addcarryxU32(&x237, &x238, x236, x232, x229); + var x239: u32 = undefined; + var x240: u1 = undefined; + addcarryxU32(&x239, &x240, x238, x230, x227); + var x241: u32 = undefined; + var x242: u1 = undefined; + addcarryxU32(&x241, &x242, x240, x228, x225); + var x243: u32 = undefined; + var x244: u1 = undefined; + addcarryxU32(&x243, &x244, x242, x226, x223); + var x245: u32 = undefined; + var x246: u1 = undefined; + addcarryxU32(&x245, &x246, 0x0, x203, x233); + var x247: u32 = undefined; + var x248: u1 = undefined; + addcarryxU32(&x247, &x248, x246, x205, x235); + var x249: u32 = undefined; + var x250: u1 = undefined; + addcarryxU32(&x249, &x250, x248, x207, x237); + var x251: u32 = undefined; + var x252: u1 = undefined; + addcarryxU32(&x251, &x252, x250, x209, x239); + var x253: u32 = undefined; + var x254: u1 = undefined; + addcarryxU32(&x253, &x254, x252, x211, x241); + var x255: u32 = undefined; + var x256: u1 = undefined; + addcarryxU32(&x255, &x256, x254, x213, x243); + var x257: u32 = undefined; + var x258: u1 = undefined; + addcarryxU32(&x257, &x258, x256, x215, (cast(u32, x244) + x224)); + var x259: u32 = undefined; + var x260: u1 = undefined; + addcarryxU32(&x259, &x260, x258, x217, x221); + var x261: u32 = undefined; + var x262: u1 = undefined; + addcarryxU32(&x261, &x262, x260, ((cast(u32, x218) + cast(u32, x172)) + (cast(u32, x202) + x174)), x222); + var x263: u32 = undefined; + var x264: u32 = undefined; + mulxU32(&x263, &x264, x3, 0x66e12d94); + var x265: u32 = undefined; + var x266: u32 = undefined; + mulxU32(&x265, &x266, x3, 0xf3d95620); + var x267: u32 = undefined; + var x268: u32 = undefined; + mulxU32(&x267, &x268, x3, 0x2845b239); + var x269: u32 = undefined; + var x270: u32 = undefined; + mulxU32(&x269, &x270, x3, 0x2b6bec59); + var x271: u32 = undefined; + var x272: u32 = undefined; + mulxU32(&x271, &x272, x3, 0x4699799c); + var x273: u32 = undefined; + var x274: u32 = undefined; + mulxU32(&x273, &x274, x3, 0x49bd6fa6); + var x275: u32 = undefined; + var x276: u32 = undefined; + mulxU32(&x275, &x276, x3, 0x83244c95); + var x277: u32 = undefined; + var x278: u32 = undefined; + mulxU32(&x277, &x278, x3, 0xbe79eea2); + var x279: u32 = undefined; + var x280: u1 = undefined; + addcarryxU32(&x279, &x280, 0x0, x278, x275); + var x281: u32 = undefined; + var x282: u1 = undefined; + addcarryxU32(&x281, &x282, x280, x276, x273); + var x283: u32 = undefined; + var x284: u1 = undefined; + addcarryxU32(&x283, &x284, x282, x274, x271); + var x285: u32 = undefined; + var x286: u1 = undefined; + addcarryxU32(&x285, &x286, x284, x272, x269); + var x287: u32 = undefined; + var x288: u1 = undefined; + addcarryxU32(&x287, &x288, x286, x270, x267); + var x289: u32 = undefined; + var x290: u1 = undefined; + addcarryxU32(&x289, &x290, x288, x268, x265); + var x291: u32 = undefined; + var x292: u1 = undefined; + addcarryxU32(&x291, &x292, x290, x266, x263); + var x293: u32 = undefined; + var x294: u1 = undefined; + addcarryxU32(&x293, &x294, 0x0, x247, x277); + var x295: u32 = undefined; + var x296: u1 = undefined; + addcarryxU32(&x295, &x296, x294, x249, x279); + var x297: u32 = undefined; + var x298: u1 = undefined; + addcarryxU32(&x297, &x298, x296, x251, x281); + var x299: u32 = undefined; + var x300: u1 = undefined; + addcarryxU32(&x299, &x300, x298, x253, x283); + var x301: u32 = undefined; + var x302: u1 = undefined; + addcarryxU32(&x301, &x302, x300, x255, x285); + var x303: u32 = undefined; + var x304: u1 = undefined; + addcarryxU32(&x303, &x304, x302, x257, x287); + var x305: u32 = undefined; + var x306: u1 = undefined; + addcarryxU32(&x305, &x306, x304, x259, x289); + var x307: u32 = undefined; + var x308: u1 = undefined; + addcarryxU32(&x307, &x308, x306, x261, x291); + var x309: u32 = undefined; + var x310: u32 = undefined; + mulxU32(&x309, &x310, x293, 0xee00bc4f); + var x311: u32 = undefined; + var x312: u32 = undefined; + mulxU32(&x311, &x312, x309, 0xffffffff); + var x313: u32 = undefined; + var x314: u32 = undefined; + mulxU32(&x313, &x314, x309, 0xffffffff); + var x315: u32 = undefined; + var x316: u32 = undefined; + mulxU32(&x315, &x316, x309, 0xffffffff); + var x317: u32 = undefined; + var x318: u32 = undefined; + mulxU32(&x317, &x318, x309, 0xbce6faad); + var x319: u32 = undefined; + var x320: u32 = undefined; + mulxU32(&x319, &x320, x309, 0xa7179e84); + var x321: u32 = undefined; + var x322: u32 = undefined; + mulxU32(&x321, &x322, x309, 0xf3b9cac2); + var x323: u32 = undefined; + var x324: u32 = undefined; + mulxU32(&x323, &x324, x309, 0xfc632551); + var x325: u32 = undefined; + var x326: u1 = undefined; + addcarryxU32(&x325, &x326, 0x0, x324, x321); + var x327: u32 = undefined; + var x328: u1 = undefined; + addcarryxU32(&x327, &x328, x326, x322, x319); + var x329: u32 = undefined; + var x330: u1 = undefined; + addcarryxU32(&x329, &x330, x328, x320, x317); + var x331: u32 = undefined; + var x332: u1 = undefined; + addcarryxU32(&x331, &x332, x330, x318, x315); + var x333: u32 = undefined; + var x334: u1 = undefined; + addcarryxU32(&x333, &x334, x332, x316, x313); + var x335: u32 = undefined; + var x336: u1 = undefined; + addcarryxU32(&x335, &x336, 0x0, x293, x323); + var x337: u32 = undefined; + var x338: u1 = undefined; + addcarryxU32(&x337, &x338, x336, x295, x325); + var x339: u32 = undefined; + var x340: u1 = undefined; + addcarryxU32(&x339, &x340, x338, x297, x327); + var x341: u32 = undefined; + var x342: u1 = undefined; + addcarryxU32(&x341, &x342, x340, x299, x329); + var x343: u32 = undefined; + var x344: u1 = undefined; + addcarryxU32(&x343, &x344, x342, x301, x331); + var x345: u32 = undefined; + var x346: u1 = undefined; + addcarryxU32(&x345, &x346, x344, x303, x333); + var x347: u32 = undefined; + var x348: u1 = undefined; + addcarryxU32(&x347, &x348, x346, x305, (cast(u32, x334) + x314)); + var x349: u32 = undefined; + var x350: u1 = undefined; + addcarryxU32(&x349, &x350, x348, x307, x311); + var x351: u32 = undefined; + var x352: u1 = undefined; + addcarryxU32(&x351, &x352, x350, ((cast(u32, x308) + cast(u32, x262)) + (cast(u32, x292) + x264)), x312); + var x353: u32 = undefined; + var x354: u32 = undefined; + mulxU32(&x353, &x354, x4, 0x66e12d94); + var x355: u32 = undefined; + var x356: u32 = undefined; + mulxU32(&x355, &x356, x4, 0xf3d95620); + var x357: u32 = undefined; + var x358: u32 = undefined; + mulxU32(&x357, &x358, x4, 0x2845b239); + var x359: u32 = undefined; + var x360: u32 = undefined; + mulxU32(&x359, &x360, x4, 0x2b6bec59); + var x361: u32 = undefined; + var x362: u32 = undefined; + mulxU32(&x361, &x362, x4, 0x4699799c); + var x363: u32 = undefined; + var x364: u32 = undefined; + mulxU32(&x363, &x364, x4, 0x49bd6fa6); + var x365: u32 = undefined; + var x366: u32 = undefined; + mulxU32(&x365, &x366, x4, 0x83244c95); + var x367: u32 = undefined; + var x368: u32 = undefined; + mulxU32(&x367, &x368, x4, 0xbe79eea2); + var x369: u32 = undefined; + var x370: u1 = undefined; + addcarryxU32(&x369, &x370, 0x0, x368, x365); + var x371: u32 = undefined; + var x372: u1 = undefined; + addcarryxU32(&x371, &x372, x370, x366, x363); + var x373: u32 = undefined; + var x374: u1 = undefined; + addcarryxU32(&x373, &x374, x372, x364, x361); + var x375: u32 = undefined; + var x376: u1 = undefined; + addcarryxU32(&x375, &x376, x374, x362, x359); + var x377: u32 = undefined; + var x378: u1 = undefined; + addcarryxU32(&x377, &x378, x376, x360, x357); + var x379: u32 = undefined; + var x380: u1 = undefined; + addcarryxU32(&x379, &x380, x378, x358, x355); + var x381: u32 = undefined; + var x382: u1 = undefined; + addcarryxU32(&x381, &x382, x380, x356, x353); + var x383: u32 = undefined; + var x384: u1 = undefined; + addcarryxU32(&x383, &x384, 0x0, x337, x367); + var x385: u32 = undefined; + var x386: u1 = undefined; + addcarryxU32(&x385, &x386, x384, x339, x369); + var x387: u32 = undefined; + var x388: u1 = undefined; + addcarryxU32(&x387, &x388, x386, x341, x371); + var x389: u32 = undefined; + var x390: u1 = undefined; + addcarryxU32(&x389, &x390, x388, x343, x373); + var x391: u32 = undefined; + var x392: u1 = undefined; + addcarryxU32(&x391, &x392, x390, x345, x375); + var x393: u32 = undefined; + var x394: u1 = undefined; + addcarryxU32(&x393, &x394, x392, x347, x377); + var x395: u32 = undefined; + var x396: u1 = undefined; + addcarryxU32(&x395, &x396, x394, x349, x379); + var x397: u32 = undefined; + var x398: u1 = undefined; + addcarryxU32(&x397, &x398, x396, x351, x381); + var x399: u32 = undefined; + var x400: u32 = undefined; + mulxU32(&x399, &x400, x383, 0xee00bc4f); + var x401: u32 = undefined; + var x402: u32 = undefined; + mulxU32(&x401, &x402, x399, 0xffffffff); + var x403: u32 = undefined; + var x404: u32 = undefined; + mulxU32(&x403, &x404, x399, 0xffffffff); + var x405: u32 = undefined; + var x406: u32 = undefined; + mulxU32(&x405, &x406, x399, 0xffffffff); + var x407: u32 = undefined; + var x408: u32 = undefined; + mulxU32(&x407, &x408, x399, 0xbce6faad); + var x409: u32 = undefined; + var x410: u32 = undefined; + mulxU32(&x409, &x410, x399, 0xa7179e84); + var x411: u32 = undefined; + var x412: u32 = undefined; + mulxU32(&x411, &x412, x399, 0xf3b9cac2); + var x413: u32 = undefined; + var x414: u32 = undefined; + mulxU32(&x413, &x414, x399, 0xfc632551); + var x415: u32 = undefined; + var x416: u1 = undefined; + addcarryxU32(&x415, &x416, 0x0, x414, x411); + var x417: u32 = undefined; + var x418: u1 = undefined; + addcarryxU32(&x417, &x418, x416, x412, x409); + var x419: u32 = undefined; + var x420: u1 = undefined; + addcarryxU32(&x419, &x420, x418, x410, x407); + var x421: u32 = undefined; + var x422: u1 = undefined; + addcarryxU32(&x421, &x422, x420, x408, x405); + var x423: u32 = undefined; + var x424: u1 = undefined; + addcarryxU32(&x423, &x424, x422, x406, x403); + var x425: u32 = undefined; + var x426: u1 = undefined; + addcarryxU32(&x425, &x426, 0x0, x383, x413); + var x427: u32 = undefined; + var x428: u1 = undefined; + addcarryxU32(&x427, &x428, x426, x385, x415); + var x429: u32 = undefined; + var x430: u1 = undefined; + addcarryxU32(&x429, &x430, x428, x387, x417); + var x431: u32 = undefined; + var x432: u1 = undefined; + addcarryxU32(&x431, &x432, x430, x389, x419); + var x433: u32 = undefined; + var x434: u1 = undefined; + addcarryxU32(&x433, &x434, x432, x391, x421); + var x435: u32 = undefined; + var x436: u1 = undefined; + addcarryxU32(&x435, &x436, x434, x393, x423); + var x437: u32 = undefined; + var x438: u1 = undefined; + addcarryxU32(&x437, &x438, x436, x395, (cast(u32, x424) + x404)); + var x439: u32 = undefined; + var x440: u1 = undefined; + addcarryxU32(&x439, &x440, x438, x397, x401); + var x441: u32 = undefined; + var x442: u1 = undefined; + addcarryxU32(&x441, &x442, x440, ((cast(u32, x398) + cast(u32, x352)) + (cast(u32, x382) + x354)), x402); + var x443: u32 = undefined; + var x444: u32 = undefined; + mulxU32(&x443, &x444, x5, 0x66e12d94); + var x445: u32 = undefined; + var x446: u32 = undefined; + mulxU32(&x445, &x446, x5, 0xf3d95620); + var x447: u32 = undefined; + var x448: u32 = undefined; + mulxU32(&x447, &x448, x5, 0x2845b239); + var x449: u32 = undefined; + var x450: u32 = undefined; + mulxU32(&x449, &x450, x5, 0x2b6bec59); + var x451: u32 = undefined; + var x452: u32 = undefined; + mulxU32(&x451, &x452, x5, 0x4699799c); + var x453: u32 = undefined; + var x454: u32 = undefined; + mulxU32(&x453, &x454, x5, 0x49bd6fa6); + var x455: u32 = undefined; + var x456: u32 = undefined; + mulxU32(&x455, &x456, x5, 0x83244c95); + var x457: u32 = undefined; + var x458: u32 = undefined; + mulxU32(&x457, &x458, x5, 0xbe79eea2); + var x459: u32 = undefined; + var x460: u1 = undefined; + addcarryxU32(&x459, &x460, 0x0, x458, x455); + var x461: u32 = undefined; + var x462: u1 = undefined; + addcarryxU32(&x461, &x462, x460, x456, x453); + var x463: u32 = undefined; + var x464: u1 = undefined; + addcarryxU32(&x463, &x464, x462, x454, x451); + var x465: u32 = undefined; + var x466: u1 = undefined; + addcarryxU32(&x465, &x466, x464, x452, x449); + var x467: u32 = undefined; + var x468: u1 = undefined; + addcarryxU32(&x467, &x468, x466, x450, x447); + var x469: u32 = undefined; + var x470: u1 = undefined; + addcarryxU32(&x469, &x470, x468, x448, x445); + var x471: u32 = undefined; + var x472: u1 = undefined; + addcarryxU32(&x471, &x472, x470, x446, x443); + var x473: u32 = undefined; + var x474: u1 = undefined; + addcarryxU32(&x473, &x474, 0x0, x427, x457); + var x475: u32 = undefined; + var x476: u1 = undefined; + addcarryxU32(&x475, &x476, x474, x429, x459); + var x477: u32 = undefined; + var x478: u1 = undefined; + addcarryxU32(&x477, &x478, x476, x431, x461); + var x479: u32 = undefined; + var x480: u1 = undefined; + addcarryxU32(&x479, &x480, x478, x433, x463); + var x481: u32 = undefined; + var x482: u1 = undefined; + addcarryxU32(&x481, &x482, x480, x435, x465); + var x483: u32 = undefined; + var x484: u1 = undefined; + addcarryxU32(&x483, &x484, x482, x437, x467); + var x485: u32 = undefined; + var x486: u1 = undefined; + addcarryxU32(&x485, &x486, x484, x439, x469); + var x487: u32 = undefined; + var x488: u1 = undefined; + addcarryxU32(&x487, &x488, x486, x441, x471); + var x489: u32 = undefined; + var x490: u32 = undefined; + mulxU32(&x489, &x490, x473, 0xee00bc4f); + var x491: u32 = undefined; + var x492: u32 = undefined; + mulxU32(&x491, &x492, x489, 0xffffffff); + var x493: u32 = undefined; + var x494: u32 = undefined; + mulxU32(&x493, &x494, x489, 0xffffffff); + var x495: u32 = undefined; + var x496: u32 = undefined; + mulxU32(&x495, &x496, x489, 0xffffffff); + var x497: u32 = undefined; + var x498: u32 = undefined; + mulxU32(&x497, &x498, x489, 0xbce6faad); + var x499: u32 = undefined; + var x500: u32 = undefined; + mulxU32(&x499, &x500, x489, 0xa7179e84); + var x501: u32 = undefined; + var x502: u32 = undefined; + mulxU32(&x501, &x502, x489, 0xf3b9cac2); + var x503: u32 = undefined; + var x504: u32 = undefined; + mulxU32(&x503, &x504, x489, 0xfc632551); + var x505: u32 = undefined; + var x506: u1 = undefined; + addcarryxU32(&x505, &x506, 0x0, x504, x501); + var x507: u32 = undefined; + var x508: u1 = undefined; + addcarryxU32(&x507, &x508, x506, x502, x499); + var x509: u32 = undefined; + var x510: u1 = undefined; + addcarryxU32(&x509, &x510, x508, x500, x497); + var x511: u32 = undefined; + var x512: u1 = undefined; + addcarryxU32(&x511, &x512, x510, x498, x495); + var x513: u32 = undefined; + var x514: u1 = undefined; + addcarryxU32(&x513, &x514, x512, x496, x493); + var x515: u32 = undefined; + var x516: u1 = undefined; + addcarryxU32(&x515, &x516, 0x0, x473, x503); + var x517: u32 = undefined; + var x518: u1 = undefined; + addcarryxU32(&x517, &x518, x516, x475, x505); + var x519: u32 = undefined; + var x520: u1 = undefined; + addcarryxU32(&x519, &x520, x518, x477, x507); + var x521: u32 = undefined; + var x522: u1 = undefined; + addcarryxU32(&x521, &x522, x520, x479, x509); + var x523: u32 = undefined; + var x524: u1 = undefined; + addcarryxU32(&x523, &x524, x522, x481, x511); + var x525: u32 = undefined; + var x526: u1 = undefined; + addcarryxU32(&x525, &x526, x524, x483, x513); + var x527: u32 = undefined; + var x528: u1 = undefined; + addcarryxU32(&x527, &x528, x526, x485, (cast(u32, x514) + x494)); + var x529: u32 = undefined; + var x530: u1 = undefined; + addcarryxU32(&x529, &x530, x528, x487, x491); + var x531: u32 = undefined; + var x532: u1 = undefined; + addcarryxU32(&x531, &x532, x530, ((cast(u32, x488) + cast(u32, x442)) + (cast(u32, x472) + x444)), x492); + var x533: u32 = undefined; + var x534: u32 = undefined; + mulxU32(&x533, &x534, x6, 0x66e12d94); + var x535: u32 = undefined; + var x536: u32 = undefined; + mulxU32(&x535, &x536, x6, 0xf3d95620); + var x537: u32 = undefined; + var x538: u32 = undefined; + mulxU32(&x537, &x538, x6, 0x2845b239); + var x539: u32 = undefined; + var x540: u32 = undefined; + mulxU32(&x539, &x540, x6, 0x2b6bec59); + var x541: u32 = undefined; + var x542: u32 = undefined; + mulxU32(&x541, &x542, x6, 0x4699799c); + var x543: u32 = undefined; + var x544: u32 = undefined; + mulxU32(&x543, &x544, x6, 0x49bd6fa6); + var x545: u32 = undefined; + var x546: u32 = undefined; + mulxU32(&x545, &x546, x6, 0x83244c95); + var x547: u32 = undefined; + var x548: u32 = undefined; + mulxU32(&x547, &x548, x6, 0xbe79eea2); + var x549: u32 = undefined; + var x550: u1 = undefined; + addcarryxU32(&x549, &x550, 0x0, x548, x545); + var x551: u32 = undefined; + var x552: u1 = undefined; + addcarryxU32(&x551, &x552, x550, x546, x543); + var x553: u32 = undefined; + var x554: u1 = undefined; + addcarryxU32(&x553, &x554, x552, x544, x541); + var x555: u32 = undefined; + var x556: u1 = undefined; + addcarryxU32(&x555, &x556, x554, x542, x539); + var x557: u32 = undefined; + var x558: u1 = undefined; + addcarryxU32(&x557, &x558, x556, x540, x537); + var x559: u32 = undefined; + var x560: u1 = undefined; + addcarryxU32(&x559, &x560, x558, x538, x535); + var x561: u32 = undefined; + var x562: u1 = undefined; + addcarryxU32(&x561, &x562, x560, x536, x533); + var x563: u32 = undefined; + var x564: u1 = undefined; + addcarryxU32(&x563, &x564, 0x0, x517, x547); + var x565: u32 = undefined; + var x566: u1 = undefined; + addcarryxU32(&x565, &x566, x564, x519, x549); + var x567: u32 = undefined; + var x568: u1 = undefined; + addcarryxU32(&x567, &x568, x566, x521, x551); + var x569: u32 = undefined; + var x570: u1 = undefined; + addcarryxU32(&x569, &x570, x568, x523, x553); + var x571: u32 = undefined; + var x572: u1 = undefined; + addcarryxU32(&x571, &x572, x570, x525, x555); + var x573: u32 = undefined; + var x574: u1 = undefined; + addcarryxU32(&x573, &x574, x572, x527, x557); + var x575: u32 = undefined; + var x576: u1 = undefined; + addcarryxU32(&x575, &x576, x574, x529, x559); + var x577: u32 = undefined; + var x578: u1 = undefined; + addcarryxU32(&x577, &x578, x576, x531, x561); + var x579: u32 = undefined; + var x580: u32 = undefined; + mulxU32(&x579, &x580, x563, 0xee00bc4f); + var x581: u32 = undefined; + var x582: u32 = undefined; + mulxU32(&x581, &x582, x579, 0xffffffff); + var x583: u32 = undefined; + var x584: u32 = undefined; + mulxU32(&x583, &x584, x579, 0xffffffff); + var x585: u32 = undefined; + var x586: u32 = undefined; + mulxU32(&x585, &x586, x579, 0xffffffff); + var x587: u32 = undefined; + var x588: u32 = undefined; + mulxU32(&x587, &x588, x579, 0xbce6faad); + var x589: u32 = undefined; + var x590: u32 = undefined; + mulxU32(&x589, &x590, x579, 0xa7179e84); + var x591: u32 = undefined; + var x592: u32 = undefined; + mulxU32(&x591, &x592, x579, 0xf3b9cac2); + var x593: u32 = undefined; + var x594: u32 = undefined; + mulxU32(&x593, &x594, x579, 0xfc632551); + var x595: u32 = undefined; + var x596: u1 = undefined; + addcarryxU32(&x595, &x596, 0x0, x594, x591); + var x597: u32 = undefined; + var x598: u1 = undefined; + addcarryxU32(&x597, &x598, x596, x592, x589); + var x599: u32 = undefined; + var x600: u1 = undefined; + addcarryxU32(&x599, &x600, x598, x590, x587); + var x601: u32 = undefined; + var x602: u1 = undefined; + addcarryxU32(&x601, &x602, x600, x588, x585); + var x603: u32 = undefined; + var x604: u1 = undefined; + addcarryxU32(&x603, &x604, x602, x586, x583); + var x605: u32 = undefined; + var x606: u1 = undefined; + addcarryxU32(&x605, &x606, 0x0, x563, x593); + var x607: u32 = undefined; + var x608: u1 = undefined; + addcarryxU32(&x607, &x608, x606, x565, x595); + var x609: u32 = undefined; + var x610: u1 = undefined; + addcarryxU32(&x609, &x610, x608, x567, x597); + var x611: u32 = undefined; + var x612: u1 = undefined; + addcarryxU32(&x611, &x612, x610, x569, x599); + var x613: u32 = undefined; + var x614: u1 = undefined; + addcarryxU32(&x613, &x614, x612, x571, x601); + var x615: u32 = undefined; + var x616: u1 = undefined; + addcarryxU32(&x615, &x616, x614, x573, x603); + var x617: u32 = undefined; + var x618: u1 = undefined; + addcarryxU32(&x617, &x618, x616, x575, (cast(u32, x604) + x584)); + var x619: u32 = undefined; + var x620: u1 = undefined; + addcarryxU32(&x619, &x620, x618, x577, x581); + var x621: u32 = undefined; + var x622: u1 = undefined; + addcarryxU32(&x621, &x622, x620, ((cast(u32, x578) + cast(u32, x532)) + (cast(u32, x562) + x534)), x582); + var x623: u32 = undefined; + var x624: u32 = undefined; + mulxU32(&x623, &x624, x7, 0x66e12d94); + var x625: u32 = undefined; + var x626: u32 = undefined; + mulxU32(&x625, &x626, x7, 0xf3d95620); + var x627: u32 = undefined; + var x628: u32 = undefined; + mulxU32(&x627, &x628, x7, 0x2845b239); + var x629: u32 = undefined; + var x630: u32 = undefined; + mulxU32(&x629, &x630, x7, 0x2b6bec59); + var x631: u32 = undefined; + var x632: u32 = undefined; + mulxU32(&x631, &x632, x7, 0x4699799c); + var x633: u32 = undefined; + var x634: u32 = undefined; + mulxU32(&x633, &x634, x7, 0x49bd6fa6); + var x635: u32 = undefined; + var x636: u32 = undefined; + mulxU32(&x635, &x636, x7, 0x83244c95); + var x637: u32 = undefined; + var x638: u32 = undefined; + mulxU32(&x637, &x638, x7, 0xbe79eea2); + var x639: u32 = undefined; + var x640: u1 = undefined; + addcarryxU32(&x639, &x640, 0x0, x638, x635); + var x641: u32 = undefined; + var x642: u1 = undefined; + addcarryxU32(&x641, &x642, x640, x636, x633); + var x643: u32 = undefined; + var x644: u1 = undefined; + addcarryxU32(&x643, &x644, x642, x634, x631); + var x645: u32 = undefined; + var x646: u1 = undefined; + addcarryxU32(&x645, &x646, x644, x632, x629); + var x647: u32 = undefined; + var x648: u1 = undefined; + addcarryxU32(&x647, &x648, x646, x630, x627); + var x649: u32 = undefined; + var x650: u1 = undefined; + addcarryxU32(&x649, &x650, x648, x628, x625); + var x651: u32 = undefined; + var x652: u1 = undefined; + addcarryxU32(&x651, &x652, x650, x626, x623); + var x653: u32 = undefined; + var x654: u1 = undefined; + addcarryxU32(&x653, &x654, 0x0, x607, x637); + var x655: u32 = undefined; + var x656: u1 = undefined; + addcarryxU32(&x655, &x656, x654, x609, x639); + var x657: u32 = undefined; + var x658: u1 = undefined; + addcarryxU32(&x657, &x658, x656, x611, x641); + var x659: u32 = undefined; + var x660: u1 = undefined; + addcarryxU32(&x659, &x660, x658, x613, x643); + var x661: u32 = undefined; + var x662: u1 = undefined; + addcarryxU32(&x661, &x662, x660, x615, x645); + var x663: u32 = undefined; + var x664: u1 = undefined; + addcarryxU32(&x663, &x664, x662, x617, x647); + var x665: u32 = undefined; + var x666: u1 = undefined; + addcarryxU32(&x665, &x666, x664, x619, x649); + var x667: u32 = undefined; + var x668: u1 = undefined; + addcarryxU32(&x667, &x668, x666, x621, x651); + var x669: u32 = undefined; + var x670: u32 = undefined; + mulxU32(&x669, &x670, x653, 0xee00bc4f); + var x671: u32 = undefined; + var x672: u32 = undefined; + mulxU32(&x671, &x672, x669, 0xffffffff); + var x673: u32 = undefined; + var x674: u32 = undefined; + mulxU32(&x673, &x674, x669, 0xffffffff); + var x675: u32 = undefined; + var x676: u32 = undefined; + mulxU32(&x675, &x676, x669, 0xffffffff); + var x677: u32 = undefined; + var x678: u32 = undefined; + mulxU32(&x677, &x678, x669, 0xbce6faad); + var x679: u32 = undefined; + var x680: u32 = undefined; + mulxU32(&x679, &x680, x669, 0xa7179e84); + var x681: u32 = undefined; + var x682: u32 = undefined; + mulxU32(&x681, &x682, x669, 0xf3b9cac2); + var x683: u32 = undefined; + var x684: u32 = undefined; + mulxU32(&x683, &x684, x669, 0xfc632551); + var x685: u32 = undefined; + var x686: u1 = undefined; + addcarryxU32(&x685, &x686, 0x0, x684, x681); + var x687: u32 = undefined; + var x688: u1 = undefined; + addcarryxU32(&x687, &x688, x686, x682, x679); + var x689: u32 = undefined; + var x690: u1 = undefined; + addcarryxU32(&x689, &x690, x688, x680, x677); + var x691: u32 = undefined; + var x692: u1 = undefined; + addcarryxU32(&x691, &x692, x690, x678, x675); + var x693: u32 = undefined; + var x694: u1 = undefined; + addcarryxU32(&x693, &x694, x692, x676, x673); + var x695: u32 = undefined; + var x696: u1 = undefined; + addcarryxU32(&x695, &x696, 0x0, x653, x683); + var x697: u32 = undefined; + var x698: u1 = undefined; + addcarryxU32(&x697, &x698, x696, x655, x685); + var x699: u32 = undefined; + var x700: u1 = undefined; + addcarryxU32(&x699, &x700, x698, x657, x687); + var x701: u32 = undefined; + var x702: u1 = undefined; + addcarryxU32(&x701, &x702, x700, x659, x689); + var x703: u32 = undefined; + var x704: u1 = undefined; + addcarryxU32(&x703, &x704, x702, x661, x691); + var x705: u32 = undefined; + var x706: u1 = undefined; + addcarryxU32(&x705, &x706, x704, x663, x693); + var x707: u32 = undefined; + var x708: u1 = undefined; + addcarryxU32(&x707, &x708, x706, x665, (cast(u32, x694) + x674)); + var x709: u32 = undefined; + var x710: u1 = undefined; + addcarryxU32(&x709, &x710, x708, x667, x671); + var x711: u32 = undefined; + var x712: u1 = undefined; + addcarryxU32(&x711, &x712, x710, ((cast(u32, x668) + cast(u32, x622)) + (cast(u32, x652) + x624)), x672); + var x713: u32 = undefined; + var x714: u1 = undefined; + subborrowxU32(&x713, &x714, 0x0, x697, 0xfc632551); + var x715: u32 = undefined; + var x716: u1 = undefined; + subborrowxU32(&x715, &x716, x714, x699, 0xf3b9cac2); + var x717: u32 = undefined; + var x718: u1 = undefined; + subborrowxU32(&x717, &x718, x716, x701, 0xa7179e84); + var x719: u32 = undefined; + var x720: u1 = undefined; + subborrowxU32(&x719, &x720, x718, x703, 0xbce6faad); + var x721: u32 = undefined; + var x722: u1 = undefined; + subborrowxU32(&x721, &x722, x720, x705, 0xffffffff); + var x723: u32 = undefined; + var x724: u1 = undefined; + subborrowxU32(&x723, &x724, x722, x707, 0xffffffff); + var x725: u32 = undefined; + var x726: u1 = undefined; + subborrowxU32(&x725, &x726, x724, x709, cast(u32, 0x0)); + var x727: u32 = undefined; + var x728: u1 = undefined; + subborrowxU32(&x727, &x728, x726, x711, 0xffffffff); + var x729: u32 = undefined; + var x730: u1 = undefined; + subborrowxU32(&x729, &x730, x728, cast(u32, x712), cast(u32, 0x0)); + var x731: u32 = undefined; + cmovznzU32(&x731, x730, x713, x697); + var x732: u32 = undefined; + cmovznzU32(&x732, x730, x715, x699); + var x733: u32 = undefined; + cmovznzU32(&x733, x730, x717, x701); + var x734: u32 = undefined; + cmovznzU32(&x734, x730, x719, x703); + var x735: u32 = undefined; + cmovznzU32(&x735, x730, x721, x705); + var x736: u32 = undefined; + cmovznzU32(&x736, x730, x723, x707); + var x737: u32 = undefined; + cmovznzU32(&x737, x730, x725, x709); + var x738: u32 = undefined; + cmovznzU32(&x738, x730, x727, x711); + out1[0] = x731; + out1[1] = x732; + out1[2] = x733; + out1[3] = x734; + out1[4] = x735; + out1[5] = x736; + out1[6] = x737; + out1[7] = x738; +} + +/// The function nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +pub fn nonzero(out1: *u32, arg1: [8]u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | (arg1[7])))))))); + out1.* = x1; +} + +/// The function selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn selectznz(out1: *[8]u32, arg1: u1, arg2: [8]u32, arg3: [8]u32) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + cmovznzU32(&x1, arg1, (arg2[0]), (arg3[0])); + var x2: u32 = undefined; + cmovznzU32(&x2, arg1, (arg2[1]), (arg3[1])); + var x3: u32 = undefined; + cmovznzU32(&x3, arg1, (arg2[2]), (arg3[2])); + var x4: u32 = undefined; + cmovznzU32(&x4, arg1, (arg2[3]), (arg3[3])); + var x5: u32 = undefined; + cmovznzU32(&x5, arg1, (arg2[4]), (arg3[4])); + var x6: u32 = undefined; + cmovznzU32(&x6, arg1, (arg2[5]), (arg3[5])); + var x7: u32 = undefined; + cmovznzU32(&x7, arg1, (arg2[6]), (arg3[6])); + var x8: u32 = undefined; + cmovznzU32(&x8, arg1, (arg2[7]), (arg3[7])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; + out1[6] = x7; + out1[7] = x8; +} + +/// The function toBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +pub fn toBytes(out1: *[32]u8, arg1: [8]u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[7]); + const x2 = (arg1[6]); + const x3 = (arg1[5]); + const x4 = (arg1[4]); + const x5 = (arg1[3]); + const x6 = (arg1[2]); + const x7 = (arg1[1]); + const x8 = (arg1[0]); + const x9 = cast(u8, (x8 & cast(u32, 0xff))); + const x10 = (x8 >> 8); + const x11 = cast(u8, (x10 & cast(u32, 0xff))); + const x12 = (x10 >> 8); + const x13 = cast(u8, (x12 & cast(u32, 0xff))); + const x14 = cast(u8, (x12 >> 8)); + const x15 = cast(u8, (x7 & cast(u32, 0xff))); + const x16 = (x7 >> 8); + const x17 = cast(u8, (x16 & cast(u32, 0xff))); + const x18 = (x16 >> 8); + const x19 = cast(u8, (x18 & cast(u32, 0xff))); + const x20 = cast(u8, (x18 >> 8)); + const x21 = cast(u8, (x6 & cast(u32, 0xff))); + const x22 = (x6 >> 8); + const x23 = cast(u8, (x22 & cast(u32, 0xff))); + const x24 = (x22 >> 8); + const x25 = cast(u8, (x24 & cast(u32, 0xff))); + const x26 = cast(u8, (x24 >> 8)); + const x27 = cast(u8, (x5 & cast(u32, 0xff))); + const x28 = (x5 >> 8); + const x29 = cast(u8, (x28 & cast(u32, 0xff))); + const x30 = (x28 >> 8); + const x31 = cast(u8, (x30 & cast(u32, 0xff))); + const x32 = cast(u8, (x30 >> 8)); + const x33 = cast(u8, (x4 & cast(u32, 0xff))); + const x34 = (x4 >> 8); + const x35 = cast(u8, (x34 & cast(u32, 0xff))); + const x36 = (x34 >> 8); + const x37 = cast(u8, (x36 & cast(u32, 0xff))); + const x38 = cast(u8, (x36 >> 8)); + const x39 = cast(u8, (x3 & cast(u32, 0xff))); + const x40 = (x3 >> 8); + const x41 = cast(u8, (x40 & cast(u32, 0xff))); + const x42 = (x40 >> 8); + const x43 = cast(u8, (x42 & cast(u32, 0xff))); + const x44 = cast(u8, (x42 >> 8)); + const x45 = cast(u8, (x2 & cast(u32, 0xff))); + const x46 = (x2 >> 8); + const x47 = cast(u8, (x46 & cast(u32, 0xff))); + const x48 = (x46 >> 8); + const x49 = cast(u8, (x48 & cast(u32, 0xff))); + const x50 = cast(u8, (x48 >> 8)); + const x51 = cast(u8, (x1 & cast(u32, 0xff))); + const x52 = (x1 >> 8); + const x53 = cast(u8, (x52 & cast(u32, 0xff))); + const x54 = (x52 >> 8); + const x55 = cast(u8, (x54 & cast(u32, 0xff))); + const x56 = cast(u8, (x54 >> 8)); + out1[0] = x9; + out1[1] = x11; + out1[2] = x13; + out1[3] = x14; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x26; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x38; + out1[20] = x39; + out1[21] = x41; + out1[22] = x43; + out1[23] = x44; + out1[24] = x45; + out1[25] = x47; + out1[26] = x49; + out1[27] = x50; + out1[28] = x51; + out1[29] = x53; + out1[30] = x55; + out1[31] = x56; +} + +/// The function fromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn fromBytes(out1: *[8]u32, arg1: [32]u8) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u32, (arg1[31])) << 24); + const x2 = (cast(u32, (arg1[30])) << 16); + const x3 = (cast(u32, (arg1[29])) << 8); + const x4 = (arg1[28]); + const x5 = (cast(u32, (arg1[27])) << 24); + const x6 = (cast(u32, (arg1[26])) << 16); + const x7 = (cast(u32, (arg1[25])) << 8); + const x8 = (arg1[24]); + const x9 = (cast(u32, (arg1[23])) << 24); + const x10 = (cast(u32, (arg1[22])) << 16); + const x11 = (cast(u32, (arg1[21])) << 8); + const x12 = (arg1[20]); + const x13 = (cast(u32, (arg1[19])) << 24); + const x14 = (cast(u32, (arg1[18])) << 16); + const x15 = (cast(u32, (arg1[17])) << 8); + const x16 = (arg1[16]); + const x17 = (cast(u32, (arg1[15])) << 24); + const x18 = (cast(u32, (arg1[14])) << 16); + const x19 = (cast(u32, (arg1[13])) << 8); + const x20 = (arg1[12]); + const x21 = (cast(u32, (arg1[11])) << 24); + const x22 = (cast(u32, (arg1[10])) << 16); + const x23 = (cast(u32, (arg1[9])) << 8); + const x24 = (arg1[8]); + const x25 = (cast(u32, (arg1[7])) << 24); + const x26 = (cast(u32, (arg1[6])) << 16); + const x27 = (cast(u32, (arg1[5])) << 8); + const x28 = (arg1[4]); + const x29 = (cast(u32, (arg1[3])) << 24); + const x30 = (cast(u32, (arg1[2])) << 16); + const x31 = (cast(u32, (arg1[1])) << 8); + const x32 = (arg1[0]); + const x33 = (x31 + cast(u32, x32)); + const x34 = (x30 + x33); + const x35 = (x29 + x34); + const x36 = (x27 + cast(u32, x28)); + const x37 = (x26 + x36); + const x38 = (x25 + x37); + const x39 = (x23 + cast(u32, x24)); + const x40 = (x22 + x39); + const x41 = (x21 + x40); + const x42 = (x19 + cast(u32, x20)); + const x43 = (x18 + x42); + const x44 = (x17 + x43); + const x45 = (x15 + cast(u32, x16)); + const x46 = (x14 + x45); + const x47 = (x13 + x46); + const x48 = (x11 + cast(u32, x12)); + const x49 = (x10 + x48); + const x50 = (x9 + x49); + const x51 = (x7 + cast(u32, x8)); + const x52 = (x6 + x51); + const x53 = (x5 + x52); + const x54 = (x3 + cast(u32, x4)); + const x55 = (x2 + x54); + const x56 = (x1 + x55); + out1[0] = x35; + out1[1] = x38; + out1[2] = x41; + out1[3] = x44; + out1[4] = x47; + out1[5] = x50; + out1[6] = x53; + out1[7] = x56; +} + +/// The function setOne returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn setOne(out1: *MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0x39cdaaf; + out1[1] = 0xc46353d; + out1[2] = 0x58e8617b; + out1[3] = 0x43190552; + out1[4] = cast(u32, 0x0); + out1[5] = cast(u32, 0x0); + out1[6] = 0xffffffff; + out1[7] = cast(u32, 0x0); +} + +/// The function msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn msat(out1: *[9]u32) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xfc632551; + out1[1] = 0xf3b9cac2; + out1[2] = 0xa7179e84; + out1[3] = 0xbce6faad; + out1[4] = 0xffffffff; + out1[5] = 0xffffffff; + out1[6] = cast(u32, 0x0); + out1[7] = 0xffffffff; + out1[8] = cast(u32, 0x0); +} + +/// The function divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn divstep(out1: *u32, out2: *[9]u32, out3: *[9]u32, out4: *[8]u32, out5: *[8]u32, arg1: u32, arg2: [9]u32, arg3: [9]u32, arg4: [8]u32, arg5: [8]u32) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + addcarryxU32(&x1, &x2, 0x0, (~arg1), cast(u32, 0x1)); + const x3 = (cast(u1, (x1 >> 31)) & cast(u1, ((arg3[0]) & cast(u32, 0x1)))); + var x4: u32 = undefined; + var x5: u1 = undefined; + addcarryxU32(&x4, &x5, 0x0, (~arg1), cast(u32, 0x1)); + var x6: u32 = undefined; + cmovznzU32(&x6, x3, arg1, x4); + var x7: u32 = undefined; + cmovznzU32(&x7, x3, (arg2[0]), (arg3[0])); + var x8: u32 = undefined; + cmovznzU32(&x8, x3, (arg2[1]), (arg3[1])); + var x9: u32 = undefined; + cmovznzU32(&x9, x3, (arg2[2]), (arg3[2])); + var x10: u32 = undefined; + cmovznzU32(&x10, x3, (arg2[3]), (arg3[3])); + var x11: u32 = undefined; + cmovznzU32(&x11, x3, (arg2[4]), (arg3[4])); + var x12: u32 = undefined; + cmovznzU32(&x12, x3, (arg2[5]), (arg3[5])); + var x13: u32 = undefined; + cmovznzU32(&x13, x3, (arg2[6]), (arg3[6])); + var x14: u32 = undefined; + cmovznzU32(&x14, x3, (arg2[7]), (arg3[7])); + var x15: u32 = undefined; + cmovznzU32(&x15, x3, (arg2[8]), (arg3[8])); + var x16: u32 = undefined; + var x17: u1 = undefined; + addcarryxU32(&x16, &x17, 0x0, cast(u32, 0x1), (~(arg2[0]))); + var x18: u32 = undefined; + var x19: u1 = undefined; + addcarryxU32(&x18, &x19, x17, cast(u32, 0x0), (~(arg2[1]))); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, cast(u32, 0x0), (~(arg2[2]))); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, cast(u32, 0x0), (~(arg2[3]))); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, cast(u32, 0x0), (~(arg2[4]))); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, cast(u32, 0x0), (~(arg2[5]))); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, cast(u32, 0x0), (~(arg2[6]))); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, cast(u32, 0x0), (~(arg2[7]))); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, cast(u32, 0x0), (~(arg2[8]))); + var x34: u32 = undefined; + cmovznzU32(&x34, x3, (arg3[0]), x16); + var x35: u32 = undefined; + cmovznzU32(&x35, x3, (arg3[1]), x18); + var x36: u32 = undefined; + cmovznzU32(&x36, x3, (arg3[2]), x20); + var x37: u32 = undefined; + cmovznzU32(&x37, x3, (arg3[3]), x22); + var x38: u32 = undefined; + cmovznzU32(&x38, x3, (arg3[4]), x24); + var x39: u32 = undefined; + cmovznzU32(&x39, x3, (arg3[5]), x26); + var x40: u32 = undefined; + cmovznzU32(&x40, x3, (arg3[6]), x28); + var x41: u32 = undefined; + cmovznzU32(&x41, x3, (arg3[7]), x30); + var x42: u32 = undefined; + cmovznzU32(&x42, x3, (arg3[8]), x32); + var x43: u32 = undefined; + cmovznzU32(&x43, x3, (arg4[0]), (arg5[0])); + var x44: u32 = undefined; + cmovznzU32(&x44, x3, (arg4[1]), (arg5[1])); + var x45: u32 = undefined; + cmovznzU32(&x45, x3, (arg4[2]), (arg5[2])); + var x46: u32 = undefined; + cmovznzU32(&x46, x3, (arg4[3]), (arg5[3])); + var x47: u32 = undefined; + cmovznzU32(&x47, x3, (arg4[4]), (arg5[4])); + var x48: u32 = undefined; + cmovznzU32(&x48, x3, (arg4[5]), (arg5[5])); + var x49: u32 = undefined; + cmovznzU32(&x49, x3, (arg4[6]), (arg5[6])); + var x50: u32 = undefined; + cmovznzU32(&x50, x3, (arg4[7]), (arg5[7])); + var x51: u32 = undefined; + var x52: u1 = undefined; + addcarryxU32(&x51, &x52, 0x0, x43, x43); + var x53: u32 = undefined; + var x54: u1 = undefined; + addcarryxU32(&x53, &x54, x52, x44, x44); + var x55: u32 = undefined; + var x56: u1 = undefined; + addcarryxU32(&x55, &x56, x54, x45, x45); + var x57: u32 = undefined; + var x58: u1 = undefined; + addcarryxU32(&x57, &x58, x56, x46, x46); + var x59: u32 = undefined; + var x60: u1 = undefined; + addcarryxU32(&x59, &x60, x58, x47, x47); + var x61: u32 = undefined; + var x62: u1 = undefined; + addcarryxU32(&x61, &x62, x60, x48, x48); + var x63: u32 = undefined; + var x64: u1 = undefined; + addcarryxU32(&x63, &x64, x62, x49, x49); + var x65: u32 = undefined; + var x66: u1 = undefined; + addcarryxU32(&x65, &x66, x64, x50, x50); + var x67: u32 = undefined; + var x68: u1 = undefined; + subborrowxU32(&x67, &x68, 0x0, x51, 0xfc632551); + var x69: u32 = undefined; + var x70: u1 = undefined; + subborrowxU32(&x69, &x70, x68, x53, 0xf3b9cac2); + var x71: u32 = undefined; + var x72: u1 = undefined; + subborrowxU32(&x71, &x72, x70, x55, 0xa7179e84); + var x73: u32 = undefined; + var x74: u1 = undefined; + subborrowxU32(&x73, &x74, x72, x57, 0xbce6faad); + var x75: u32 = undefined; + var x76: u1 = undefined; + subborrowxU32(&x75, &x76, x74, x59, 0xffffffff); + var x77: u32 = undefined; + var x78: u1 = undefined; + subborrowxU32(&x77, &x78, x76, x61, 0xffffffff); + var x79: u32 = undefined; + var x80: u1 = undefined; + subborrowxU32(&x79, &x80, x78, x63, cast(u32, 0x0)); + var x81: u32 = undefined; + var x82: u1 = undefined; + subborrowxU32(&x81, &x82, x80, x65, 0xffffffff); + var x83: u32 = undefined; + var x84: u1 = undefined; + subborrowxU32(&x83, &x84, x82, cast(u32, x66), cast(u32, 0x0)); + const x85 = (arg4[7]); + const x86 = (arg4[6]); + const x87 = (arg4[5]); + const x88 = (arg4[4]); + const x89 = (arg4[3]); + const x90 = (arg4[2]); + const x91 = (arg4[1]); + const x92 = (arg4[0]); + var x93: u32 = undefined; + var x94: u1 = undefined; + subborrowxU32(&x93, &x94, 0x0, cast(u32, 0x0), x92); + var x95: u32 = undefined; + var x96: u1 = undefined; + subborrowxU32(&x95, &x96, x94, cast(u32, 0x0), x91); + var x97: u32 = undefined; + var x98: u1 = undefined; + subborrowxU32(&x97, &x98, x96, cast(u32, 0x0), x90); + var x99: u32 = undefined; + var x100: u1 = undefined; + subborrowxU32(&x99, &x100, x98, cast(u32, 0x0), x89); + var x101: u32 = undefined; + var x102: u1 = undefined; + subborrowxU32(&x101, &x102, x100, cast(u32, 0x0), x88); + var x103: u32 = undefined; + var x104: u1 = undefined; + subborrowxU32(&x103, &x104, x102, cast(u32, 0x0), x87); + var x105: u32 = undefined; + var x106: u1 = undefined; + subborrowxU32(&x105, &x106, x104, cast(u32, 0x0), x86); + var x107: u32 = undefined; + var x108: u1 = undefined; + subborrowxU32(&x107, &x108, x106, cast(u32, 0x0), x85); + var x109: u32 = undefined; + cmovznzU32(&x109, x108, cast(u32, 0x0), 0xffffffff); + var x110: u32 = undefined; + var x111: u1 = undefined; + addcarryxU32(&x110, &x111, 0x0, x93, (x109 & 0xfc632551)); + var x112: u32 = undefined; + var x113: u1 = undefined; + addcarryxU32(&x112, &x113, x111, x95, (x109 & 0xf3b9cac2)); + var x114: u32 = undefined; + var x115: u1 = undefined; + addcarryxU32(&x114, &x115, x113, x97, (x109 & 0xa7179e84)); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, x115, x99, (x109 & 0xbce6faad)); + var x118: u32 = undefined; + var x119: u1 = undefined; + addcarryxU32(&x118, &x119, x117, x101, x109); + var x120: u32 = undefined; + var x121: u1 = undefined; + addcarryxU32(&x120, &x121, x119, x103, x109); + var x122: u32 = undefined; + var x123: u1 = undefined; + addcarryxU32(&x122, &x123, x121, x105, cast(u32, 0x0)); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, x107, x109); + var x126: u32 = undefined; + cmovznzU32(&x126, x3, (arg5[0]), x110); + var x127: u32 = undefined; + cmovznzU32(&x127, x3, (arg5[1]), x112); + var x128: u32 = undefined; + cmovznzU32(&x128, x3, (arg5[2]), x114); + var x129: u32 = undefined; + cmovznzU32(&x129, x3, (arg5[3]), x116); + var x130: u32 = undefined; + cmovznzU32(&x130, x3, (arg5[4]), x118); + var x131: u32 = undefined; + cmovznzU32(&x131, x3, (arg5[5]), x120); + var x132: u32 = undefined; + cmovznzU32(&x132, x3, (arg5[6]), x122); + var x133: u32 = undefined; + cmovznzU32(&x133, x3, (arg5[7]), x124); + const x134 = cast(u1, (x34 & cast(u32, 0x1))); + var x135: u32 = undefined; + cmovznzU32(&x135, x134, cast(u32, 0x0), x7); + var x136: u32 = undefined; + cmovznzU32(&x136, x134, cast(u32, 0x0), x8); + var x137: u32 = undefined; + cmovznzU32(&x137, x134, cast(u32, 0x0), x9); + var x138: u32 = undefined; + cmovznzU32(&x138, x134, cast(u32, 0x0), x10); + var x139: u32 = undefined; + cmovznzU32(&x139, x134, cast(u32, 0x0), x11); + var x140: u32 = undefined; + cmovznzU32(&x140, x134, cast(u32, 0x0), x12); + var x141: u32 = undefined; + cmovznzU32(&x141, x134, cast(u32, 0x0), x13); + var x142: u32 = undefined; + cmovznzU32(&x142, x134, cast(u32, 0x0), x14); + var x143: u32 = undefined; + cmovznzU32(&x143, x134, cast(u32, 0x0), x15); + var x144: u32 = undefined; + var x145: u1 = undefined; + addcarryxU32(&x144, &x145, 0x0, x34, x135); + var x146: u32 = undefined; + var x147: u1 = undefined; + addcarryxU32(&x146, &x147, x145, x35, x136); + var x148: u32 = undefined; + var x149: u1 = undefined; + addcarryxU32(&x148, &x149, x147, x36, x137); + var x150: u32 = undefined; + var x151: u1 = undefined; + addcarryxU32(&x150, &x151, x149, x37, x138); + var x152: u32 = undefined; + var x153: u1 = undefined; + addcarryxU32(&x152, &x153, x151, x38, x139); + var x154: u32 = undefined; + var x155: u1 = undefined; + addcarryxU32(&x154, &x155, x153, x39, x140); + var x156: u32 = undefined; + var x157: u1 = undefined; + addcarryxU32(&x156, &x157, x155, x40, x141); + var x158: u32 = undefined; + var x159: u1 = undefined; + addcarryxU32(&x158, &x159, x157, x41, x142); + var x160: u32 = undefined; + var x161: u1 = undefined; + addcarryxU32(&x160, &x161, x159, x42, x143); + var x162: u32 = undefined; + cmovznzU32(&x162, x134, cast(u32, 0x0), x43); + var x163: u32 = undefined; + cmovznzU32(&x163, x134, cast(u32, 0x0), x44); + var x164: u32 = undefined; + cmovznzU32(&x164, x134, cast(u32, 0x0), x45); + var x165: u32 = undefined; + cmovznzU32(&x165, x134, cast(u32, 0x0), x46); + var x166: u32 = undefined; + cmovznzU32(&x166, x134, cast(u32, 0x0), x47); + var x167: u32 = undefined; + cmovznzU32(&x167, x134, cast(u32, 0x0), x48); + var x168: u32 = undefined; + cmovznzU32(&x168, x134, cast(u32, 0x0), x49); + var x169: u32 = undefined; + cmovznzU32(&x169, x134, cast(u32, 0x0), x50); + var x170: u32 = undefined; + var x171: u1 = undefined; + addcarryxU32(&x170, &x171, 0x0, x126, x162); + var x172: u32 = undefined; + var x173: u1 = undefined; + addcarryxU32(&x172, &x173, x171, x127, x163); + var x174: u32 = undefined; + var x175: u1 = undefined; + addcarryxU32(&x174, &x175, x173, x128, x164); + var x176: u32 = undefined; + var x177: u1 = undefined; + addcarryxU32(&x176, &x177, x175, x129, x165); + var x178: u32 = undefined; + var x179: u1 = undefined; + addcarryxU32(&x178, &x179, x177, x130, x166); + var x180: u32 = undefined; + var x181: u1 = undefined; + addcarryxU32(&x180, &x181, x179, x131, x167); + var x182: u32 = undefined; + var x183: u1 = undefined; + addcarryxU32(&x182, &x183, x181, x132, x168); + var x184: u32 = undefined; + var x185: u1 = undefined; + addcarryxU32(&x184, &x185, x183, x133, x169); + var x186: u32 = undefined; + var x187: u1 = undefined; + subborrowxU32(&x186, &x187, 0x0, x170, 0xfc632551); + var x188: u32 = undefined; + var x189: u1 = undefined; + subborrowxU32(&x188, &x189, x187, x172, 0xf3b9cac2); + var x190: u32 = undefined; + var x191: u1 = undefined; + subborrowxU32(&x190, &x191, x189, x174, 0xa7179e84); + var x192: u32 = undefined; + var x193: u1 = undefined; + subborrowxU32(&x192, &x193, x191, x176, 0xbce6faad); + var x194: u32 = undefined; + var x195: u1 = undefined; + subborrowxU32(&x194, &x195, x193, x178, 0xffffffff); + var x196: u32 = undefined; + var x197: u1 = undefined; + subborrowxU32(&x196, &x197, x195, x180, 0xffffffff); + var x198: u32 = undefined; + var x199: u1 = undefined; + subborrowxU32(&x198, &x199, x197, x182, cast(u32, 0x0)); + var x200: u32 = undefined; + var x201: u1 = undefined; + subborrowxU32(&x200, &x201, x199, x184, 0xffffffff); + var x202: u32 = undefined; + var x203: u1 = undefined; + subborrowxU32(&x202, &x203, x201, cast(u32, x185), cast(u32, 0x0)); + var x204: u32 = undefined; + var x205: u1 = undefined; + addcarryxU32(&x204, &x205, 0x0, x6, cast(u32, 0x1)); + const x206 = ((x144 >> 1) | ((x146 << 31) & 0xffffffff)); + const x207 = ((x146 >> 1) | ((x148 << 31) & 0xffffffff)); + const x208 = ((x148 >> 1) | ((x150 << 31) & 0xffffffff)); + const x209 = ((x150 >> 1) | ((x152 << 31) & 0xffffffff)); + const x210 = ((x152 >> 1) | ((x154 << 31) & 0xffffffff)); + const x211 = ((x154 >> 1) | ((x156 << 31) & 0xffffffff)); + const x212 = ((x156 >> 1) | ((x158 << 31) & 0xffffffff)); + const x213 = ((x158 >> 1) | ((x160 << 31) & 0xffffffff)); + const x214 = ((x160 & 0x80000000) | (x160 >> 1)); + var x215: u32 = undefined; + cmovznzU32(&x215, x84, x67, x51); + var x216: u32 = undefined; + cmovznzU32(&x216, x84, x69, x53); + var x217: u32 = undefined; + cmovznzU32(&x217, x84, x71, x55); + var x218: u32 = undefined; + cmovznzU32(&x218, x84, x73, x57); + var x219: u32 = undefined; + cmovznzU32(&x219, x84, x75, x59); + var x220: u32 = undefined; + cmovznzU32(&x220, x84, x77, x61); + var x221: u32 = undefined; + cmovznzU32(&x221, x84, x79, x63); + var x222: u32 = undefined; + cmovznzU32(&x222, x84, x81, x65); + var x223: u32 = undefined; + cmovznzU32(&x223, x203, x186, x170); + var x224: u32 = undefined; + cmovznzU32(&x224, x203, x188, x172); + var x225: u32 = undefined; + cmovznzU32(&x225, x203, x190, x174); + var x226: u32 = undefined; + cmovznzU32(&x226, x203, x192, x176); + var x227: u32 = undefined; + cmovznzU32(&x227, x203, x194, x178); + var x228: u32 = undefined; + cmovznzU32(&x228, x203, x196, x180); + var x229: u32 = undefined; + cmovznzU32(&x229, x203, x198, x182); + var x230: u32 = undefined; + cmovznzU32(&x230, x203, x200, x184); + out1.* = x204; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out2[7] = x14; + out2[8] = x15; + out3[0] = x206; + out3[1] = x207; + out3[2] = x208; + out3[3] = x209; + out3[4] = x210; + out3[5] = x211; + out3[6] = x212; + out3[7] = x213; + out3[8] = x214; + out4[0] = x215; + out4[1] = x216; + out4[2] = x217; + out4[3] = x218; + out4[4] = x219; + out4[5] = x220; + out4[6] = x221; + out4[7] = x222; + out5[0] = x223; + out5[1] = x224; + out5[2] = x225; + out5[3] = x226; + out5[4] = x227; + out5[5] = x228; + out5[6] = x229; + out5[7] = x230; +} + +/// The function divstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn divstepPrecomp(out1: *[8]u32) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xb7fcfbb5; + out1[1] = 0xd739262f; + out1[2] = 0x20074414; + out1[3] = 0x8ac6f75d; + out1[4] = 0xb5e3c256; + out1[5] = 0xc67428bf; + out1[6] = 0xeda7aedf; + out1[7] = 0x444962f2; +} diff --git a/fiat-zig/src/p256_scalar_64.zig b/fiat-zig/src/p256_scalar_64.zig new file mode 100644 index 0000000000..a265759617 --- /dev/null +++ b/fiat-zig/src/p256_scalar_64.zig @@ -0,0 +1,2023 @@ +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Zig --internal-static --public-function-case camelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case UpperCamelCase --no-prefix-fiat --package-name p256_scalar '' 64 '2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// curve description (via package name): p256_scalar +// machine_wordsize = 64 (from "64") +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// m = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 (from "2^256 - 2^224 + 2^192 - 89188191075325690597107910205041859247") +// +// NOTE: In addition to the bounds specified above each function, all +// functions synthesized for this Montgomery arithmetic require the +// input to be strictly less than the prime modulus (m), and also +// require the input to be in the unique saturated representation. +// All functions also ensure that these two properties are true of +// return values. +// +// Computed values: +// eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +// twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in +// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 + +const std = @import("std"); +const mode = @import("builtin").mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels + +inline fn cast(comptime DestType: type, target: anytype) DestType { + if (@typeInfo(@TypeOf(target)) == .Int) { + const dest = @typeInfo(DestType).Int; + const source = @typeInfo(@TypeOf(target)).Int; + if (dest.bits < source.bits) { + return @bitCast(DestType, @truncate(std.meta.Int(source.signedness, dest.bits), target)); + } else { + return @bitCast(DestType, @as(std.meta.Int(source.signedness, dest.bits), target)); + } + } + return @as(DestType, target); +} + +// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub const MontgomeryDomainFieldElement = [4]u64; + +// The type NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub const NonMontgomeryDomainFieldElement = [4]u64; + +/// The function addcarryxU64 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^64 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +inline fn addcarryxU64(out1: *u64, out2: *u1, arg1: u1, arg2: u64, arg3: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(u128, arg1) + cast(u128, arg2)) + cast(u128, arg3)); + const x2 = cast(u64, (x1 & cast(u128, 0xffffffffffffffff))); + const x3 = cast(u1, (x1 >> 64)); + out1.* = x2; + out2.* = x3; +} + +/// The function subborrowxU64 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^64 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +inline fn subborrowxU64(out1: *u64, out2: *u1, arg1: u1, arg2: u64, arg3: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(i128, arg2) - cast(i128, arg1)) - cast(i128, arg3)); + const x2 = cast(i1, (x1 >> 64)); + const x3 = cast(u64, (x1 & cast(i128, 0xffffffffffffffff))); + out1.* = x3; + out2.* = cast(u1, (cast(i2, 0x0) - cast(i2, x2))); +} + +/// The function mulxU64 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^64 +/// out2 = ⌊arg1 * arg2 / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0xffffffffffffffff] +inline fn mulxU64(out1: *u64, out2: *u64, arg1: u64, arg2: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u128, arg1) * cast(u128, arg2)); + const x2 = cast(u64, (x1 & cast(u128, 0xffffffffffffffff))); + const x3 = cast(u64, (x1 >> 64)); + out1.* = x2; + out2.* = x3; +} + +/// The function cmovznzU64 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +inline fn cmovznzU64(out1: *u64, arg1: u1, arg2: u64, arg3: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (~(~arg1)); + const x2 = cast(u64, (cast(i128, cast(i1, (cast(i2, 0x0) - cast(i2, x1)))) & cast(i128, 0xffffffffffffffff))); + const x3 = ((x2 & arg3) | ((~x2) & arg2)); + out1.* = x3; +} + +/// The function mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn mul(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[0]); + var x5: u64 = undefined; + var x6: u64 = undefined; + mulxU64(&x5, &x6, x4, (arg2[3])); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x4, (arg2[2])); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x4, (arg2[1])); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x4, (arg2[0])); + var x13: u64 = undefined; + var x14: u1 = undefined; + addcarryxU64(&x13, &x14, 0x0, x12, x9); + var x15: u64 = undefined; + var x16: u1 = undefined; + addcarryxU64(&x15, &x16, x14, x10, x7); + var x17: u64 = undefined; + var x18: u1 = undefined; + addcarryxU64(&x17, &x18, x16, x8, x5); + const x19 = (cast(u64, x18) + x6); + var x20: u64 = undefined; + var x21: u64 = undefined; + mulxU64(&x20, &x21, x11, 0xccd1c8aaee00bc4f); + var x22: u64 = undefined; + var x23: u64 = undefined; + mulxU64(&x22, &x23, x20, 0xffffffff00000000); + var x24: u64 = undefined; + var x25: u64 = undefined; + mulxU64(&x24, &x25, x20, 0xffffffffffffffff); + var x26: u64 = undefined; + var x27: u64 = undefined; + mulxU64(&x26, &x27, x20, 0xbce6faada7179e84); + var x28: u64 = undefined; + var x29: u64 = undefined; + mulxU64(&x28, &x29, x20, 0xf3b9cac2fc632551); + var x30: u64 = undefined; + var x31: u1 = undefined; + addcarryxU64(&x30, &x31, 0x0, x29, x26); + var x32: u64 = undefined; + var x33: u1 = undefined; + addcarryxU64(&x32, &x33, x31, x27, x24); + var x34: u64 = undefined; + var x35: u1 = undefined; + addcarryxU64(&x34, &x35, x33, x25, x22); + const x36 = (cast(u64, x35) + x23); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, 0x0, x11, x28); + var x39: u64 = undefined; + var x40: u1 = undefined; + addcarryxU64(&x39, &x40, x38, x13, x30); + var x41: u64 = undefined; + var x42: u1 = undefined; + addcarryxU64(&x41, &x42, x40, x15, x32); + var x43: u64 = undefined; + var x44: u1 = undefined; + addcarryxU64(&x43, &x44, x42, x17, x34); + var x45: u64 = undefined; + var x46: u1 = undefined; + addcarryxU64(&x45, &x46, x44, x19, x36); + var x47: u64 = undefined; + var x48: u64 = undefined; + mulxU64(&x47, &x48, x1, (arg2[3])); + var x49: u64 = undefined; + var x50: u64 = undefined; + mulxU64(&x49, &x50, x1, (arg2[2])); + var x51: u64 = undefined; + var x52: u64 = undefined; + mulxU64(&x51, &x52, x1, (arg2[1])); + var x53: u64 = undefined; + var x54: u64 = undefined; + mulxU64(&x53, &x54, x1, (arg2[0])); + var x55: u64 = undefined; + var x56: u1 = undefined; + addcarryxU64(&x55, &x56, 0x0, x54, x51); + var x57: u64 = undefined; + var x58: u1 = undefined; + addcarryxU64(&x57, &x58, x56, x52, x49); + var x59: u64 = undefined; + var x60: u1 = undefined; + addcarryxU64(&x59, &x60, x58, x50, x47); + const x61 = (cast(u64, x60) + x48); + var x62: u64 = undefined; + var x63: u1 = undefined; + addcarryxU64(&x62, &x63, 0x0, x39, x53); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, x41, x55); + var x66: u64 = undefined; + var x67: u1 = undefined; + addcarryxU64(&x66, &x67, x65, x43, x57); + var x68: u64 = undefined; + var x69: u1 = undefined; + addcarryxU64(&x68, &x69, x67, x45, x59); + var x70: u64 = undefined; + var x71: u1 = undefined; + addcarryxU64(&x70, &x71, x69, cast(u64, x46), x61); + var x72: u64 = undefined; + var x73: u64 = undefined; + mulxU64(&x72, &x73, x62, 0xccd1c8aaee00bc4f); + var x74: u64 = undefined; + var x75: u64 = undefined; + mulxU64(&x74, &x75, x72, 0xffffffff00000000); + var x76: u64 = undefined; + var x77: u64 = undefined; + mulxU64(&x76, &x77, x72, 0xffffffffffffffff); + var x78: u64 = undefined; + var x79: u64 = undefined; + mulxU64(&x78, &x79, x72, 0xbce6faada7179e84); + var x80: u64 = undefined; + var x81: u64 = undefined; + mulxU64(&x80, &x81, x72, 0xf3b9cac2fc632551); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, 0x0, x81, x78); + var x84: u64 = undefined; + var x85: u1 = undefined; + addcarryxU64(&x84, &x85, x83, x79, x76); + var x86: u64 = undefined; + var x87: u1 = undefined; + addcarryxU64(&x86, &x87, x85, x77, x74); + const x88 = (cast(u64, x87) + x75); + var x89: u64 = undefined; + var x90: u1 = undefined; + addcarryxU64(&x89, &x90, 0x0, x62, x80); + var x91: u64 = undefined; + var x92: u1 = undefined; + addcarryxU64(&x91, &x92, x90, x64, x82); + var x93: u64 = undefined; + var x94: u1 = undefined; + addcarryxU64(&x93, &x94, x92, x66, x84); + var x95: u64 = undefined; + var x96: u1 = undefined; + addcarryxU64(&x95, &x96, x94, x68, x86); + var x97: u64 = undefined; + var x98: u1 = undefined; + addcarryxU64(&x97, &x98, x96, x70, x88); + const x99 = (cast(u64, x98) + cast(u64, x71)); + var x100: u64 = undefined; + var x101: u64 = undefined; + mulxU64(&x100, &x101, x2, (arg2[3])); + var x102: u64 = undefined; + var x103: u64 = undefined; + mulxU64(&x102, &x103, x2, (arg2[2])); + var x104: u64 = undefined; + var x105: u64 = undefined; + mulxU64(&x104, &x105, x2, (arg2[1])); + var x106: u64 = undefined; + var x107: u64 = undefined; + mulxU64(&x106, &x107, x2, (arg2[0])); + var x108: u64 = undefined; + var x109: u1 = undefined; + addcarryxU64(&x108, &x109, 0x0, x107, x104); + var x110: u64 = undefined; + var x111: u1 = undefined; + addcarryxU64(&x110, &x111, x109, x105, x102); + var x112: u64 = undefined; + var x113: u1 = undefined; + addcarryxU64(&x112, &x113, x111, x103, x100); + const x114 = (cast(u64, x113) + x101); + var x115: u64 = undefined; + var x116: u1 = undefined; + addcarryxU64(&x115, &x116, 0x0, x91, x106); + var x117: u64 = undefined; + var x118: u1 = undefined; + addcarryxU64(&x117, &x118, x116, x93, x108); + var x119: u64 = undefined; + var x120: u1 = undefined; + addcarryxU64(&x119, &x120, x118, x95, x110); + var x121: u64 = undefined; + var x122: u1 = undefined; + addcarryxU64(&x121, &x122, x120, x97, x112); + var x123: u64 = undefined; + var x124: u1 = undefined; + addcarryxU64(&x123, &x124, x122, x99, x114); + var x125: u64 = undefined; + var x126: u64 = undefined; + mulxU64(&x125, &x126, x115, 0xccd1c8aaee00bc4f); + var x127: u64 = undefined; + var x128: u64 = undefined; + mulxU64(&x127, &x128, x125, 0xffffffff00000000); + var x129: u64 = undefined; + var x130: u64 = undefined; + mulxU64(&x129, &x130, x125, 0xffffffffffffffff); + var x131: u64 = undefined; + var x132: u64 = undefined; + mulxU64(&x131, &x132, x125, 0xbce6faada7179e84); + var x133: u64 = undefined; + var x134: u64 = undefined; + mulxU64(&x133, &x134, x125, 0xf3b9cac2fc632551); + var x135: u64 = undefined; + var x136: u1 = undefined; + addcarryxU64(&x135, &x136, 0x0, x134, x131); + var x137: u64 = undefined; + var x138: u1 = undefined; + addcarryxU64(&x137, &x138, x136, x132, x129); + var x139: u64 = undefined; + var x140: u1 = undefined; + addcarryxU64(&x139, &x140, x138, x130, x127); + const x141 = (cast(u64, x140) + x128); + var x142: u64 = undefined; + var x143: u1 = undefined; + addcarryxU64(&x142, &x143, 0x0, x115, x133); + var x144: u64 = undefined; + var x145: u1 = undefined; + addcarryxU64(&x144, &x145, x143, x117, x135); + var x146: u64 = undefined; + var x147: u1 = undefined; + addcarryxU64(&x146, &x147, x145, x119, x137); + var x148: u64 = undefined; + var x149: u1 = undefined; + addcarryxU64(&x148, &x149, x147, x121, x139); + var x150: u64 = undefined; + var x151: u1 = undefined; + addcarryxU64(&x150, &x151, x149, x123, x141); + const x152 = (cast(u64, x151) + cast(u64, x124)); + var x153: u64 = undefined; + var x154: u64 = undefined; + mulxU64(&x153, &x154, x3, (arg2[3])); + var x155: u64 = undefined; + var x156: u64 = undefined; + mulxU64(&x155, &x156, x3, (arg2[2])); + var x157: u64 = undefined; + var x158: u64 = undefined; + mulxU64(&x157, &x158, x3, (arg2[1])); + var x159: u64 = undefined; + var x160: u64 = undefined; + mulxU64(&x159, &x160, x3, (arg2[0])); + var x161: u64 = undefined; + var x162: u1 = undefined; + addcarryxU64(&x161, &x162, 0x0, x160, x157); + var x163: u64 = undefined; + var x164: u1 = undefined; + addcarryxU64(&x163, &x164, x162, x158, x155); + var x165: u64 = undefined; + var x166: u1 = undefined; + addcarryxU64(&x165, &x166, x164, x156, x153); + const x167 = (cast(u64, x166) + x154); + var x168: u64 = undefined; + var x169: u1 = undefined; + addcarryxU64(&x168, &x169, 0x0, x144, x159); + var x170: u64 = undefined; + var x171: u1 = undefined; + addcarryxU64(&x170, &x171, x169, x146, x161); + var x172: u64 = undefined; + var x173: u1 = undefined; + addcarryxU64(&x172, &x173, x171, x148, x163); + var x174: u64 = undefined; + var x175: u1 = undefined; + addcarryxU64(&x174, &x175, x173, x150, x165); + var x176: u64 = undefined; + var x177: u1 = undefined; + addcarryxU64(&x176, &x177, x175, x152, x167); + var x178: u64 = undefined; + var x179: u64 = undefined; + mulxU64(&x178, &x179, x168, 0xccd1c8aaee00bc4f); + var x180: u64 = undefined; + var x181: u64 = undefined; + mulxU64(&x180, &x181, x178, 0xffffffff00000000); + var x182: u64 = undefined; + var x183: u64 = undefined; + mulxU64(&x182, &x183, x178, 0xffffffffffffffff); + var x184: u64 = undefined; + var x185: u64 = undefined; + mulxU64(&x184, &x185, x178, 0xbce6faada7179e84); + var x186: u64 = undefined; + var x187: u64 = undefined; + mulxU64(&x186, &x187, x178, 0xf3b9cac2fc632551); + var x188: u64 = undefined; + var x189: u1 = undefined; + addcarryxU64(&x188, &x189, 0x0, x187, x184); + var x190: u64 = undefined; + var x191: u1 = undefined; + addcarryxU64(&x190, &x191, x189, x185, x182); + var x192: u64 = undefined; + var x193: u1 = undefined; + addcarryxU64(&x192, &x193, x191, x183, x180); + const x194 = (cast(u64, x193) + x181); + var x195: u64 = undefined; + var x196: u1 = undefined; + addcarryxU64(&x195, &x196, 0x0, x168, x186); + var x197: u64 = undefined; + var x198: u1 = undefined; + addcarryxU64(&x197, &x198, x196, x170, x188); + var x199: u64 = undefined; + var x200: u1 = undefined; + addcarryxU64(&x199, &x200, x198, x172, x190); + var x201: u64 = undefined; + var x202: u1 = undefined; + addcarryxU64(&x201, &x202, x200, x174, x192); + var x203: u64 = undefined; + var x204: u1 = undefined; + addcarryxU64(&x203, &x204, x202, x176, x194); + const x205 = (cast(u64, x204) + cast(u64, x177)); + var x206: u64 = undefined; + var x207: u1 = undefined; + subborrowxU64(&x206, &x207, 0x0, x197, 0xf3b9cac2fc632551); + var x208: u64 = undefined; + var x209: u1 = undefined; + subborrowxU64(&x208, &x209, x207, x199, 0xbce6faada7179e84); + var x210: u64 = undefined; + var x211: u1 = undefined; + subborrowxU64(&x210, &x211, x209, x201, 0xffffffffffffffff); + var x212: u64 = undefined; + var x213: u1 = undefined; + subborrowxU64(&x212, &x213, x211, x203, 0xffffffff00000000); + var x214: u64 = undefined; + var x215: u1 = undefined; + subborrowxU64(&x214, &x215, x213, x205, cast(u64, 0x0)); + var x216: u64 = undefined; + cmovznzU64(&x216, x215, x206, x197); + var x217: u64 = undefined; + cmovznzU64(&x217, x215, x208, x199); + var x218: u64 = undefined; + cmovznzU64(&x218, x215, x210, x201); + var x219: u64 = undefined; + cmovznzU64(&x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/// The function square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn square(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[0]); + var x5: u64 = undefined; + var x6: u64 = undefined; + mulxU64(&x5, &x6, x4, (arg1[3])); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x4, (arg1[2])); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x4, (arg1[1])); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x4, (arg1[0])); + var x13: u64 = undefined; + var x14: u1 = undefined; + addcarryxU64(&x13, &x14, 0x0, x12, x9); + var x15: u64 = undefined; + var x16: u1 = undefined; + addcarryxU64(&x15, &x16, x14, x10, x7); + var x17: u64 = undefined; + var x18: u1 = undefined; + addcarryxU64(&x17, &x18, x16, x8, x5); + const x19 = (cast(u64, x18) + x6); + var x20: u64 = undefined; + var x21: u64 = undefined; + mulxU64(&x20, &x21, x11, 0xccd1c8aaee00bc4f); + var x22: u64 = undefined; + var x23: u64 = undefined; + mulxU64(&x22, &x23, x20, 0xffffffff00000000); + var x24: u64 = undefined; + var x25: u64 = undefined; + mulxU64(&x24, &x25, x20, 0xffffffffffffffff); + var x26: u64 = undefined; + var x27: u64 = undefined; + mulxU64(&x26, &x27, x20, 0xbce6faada7179e84); + var x28: u64 = undefined; + var x29: u64 = undefined; + mulxU64(&x28, &x29, x20, 0xf3b9cac2fc632551); + var x30: u64 = undefined; + var x31: u1 = undefined; + addcarryxU64(&x30, &x31, 0x0, x29, x26); + var x32: u64 = undefined; + var x33: u1 = undefined; + addcarryxU64(&x32, &x33, x31, x27, x24); + var x34: u64 = undefined; + var x35: u1 = undefined; + addcarryxU64(&x34, &x35, x33, x25, x22); + const x36 = (cast(u64, x35) + x23); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, 0x0, x11, x28); + var x39: u64 = undefined; + var x40: u1 = undefined; + addcarryxU64(&x39, &x40, x38, x13, x30); + var x41: u64 = undefined; + var x42: u1 = undefined; + addcarryxU64(&x41, &x42, x40, x15, x32); + var x43: u64 = undefined; + var x44: u1 = undefined; + addcarryxU64(&x43, &x44, x42, x17, x34); + var x45: u64 = undefined; + var x46: u1 = undefined; + addcarryxU64(&x45, &x46, x44, x19, x36); + var x47: u64 = undefined; + var x48: u64 = undefined; + mulxU64(&x47, &x48, x1, (arg1[3])); + var x49: u64 = undefined; + var x50: u64 = undefined; + mulxU64(&x49, &x50, x1, (arg1[2])); + var x51: u64 = undefined; + var x52: u64 = undefined; + mulxU64(&x51, &x52, x1, (arg1[1])); + var x53: u64 = undefined; + var x54: u64 = undefined; + mulxU64(&x53, &x54, x1, (arg1[0])); + var x55: u64 = undefined; + var x56: u1 = undefined; + addcarryxU64(&x55, &x56, 0x0, x54, x51); + var x57: u64 = undefined; + var x58: u1 = undefined; + addcarryxU64(&x57, &x58, x56, x52, x49); + var x59: u64 = undefined; + var x60: u1 = undefined; + addcarryxU64(&x59, &x60, x58, x50, x47); + const x61 = (cast(u64, x60) + x48); + var x62: u64 = undefined; + var x63: u1 = undefined; + addcarryxU64(&x62, &x63, 0x0, x39, x53); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, x41, x55); + var x66: u64 = undefined; + var x67: u1 = undefined; + addcarryxU64(&x66, &x67, x65, x43, x57); + var x68: u64 = undefined; + var x69: u1 = undefined; + addcarryxU64(&x68, &x69, x67, x45, x59); + var x70: u64 = undefined; + var x71: u1 = undefined; + addcarryxU64(&x70, &x71, x69, cast(u64, x46), x61); + var x72: u64 = undefined; + var x73: u64 = undefined; + mulxU64(&x72, &x73, x62, 0xccd1c8aaee00bc4f); + var x74: u64 = undefined; + var x75: u64 = undefined; + mulxU64(&x74, &x75, x72, 0xffffffff00000000); + var x76: u64 = undefined; + var x77: u64 = undefined; + mulxU64(&x76, &x77, x72, 0xffffffffffffffff); + var x78: u64 = undefined; + var x79: u64 = undefined; + mulxU64(&x78, &x79, x72, 0xbce6faada7179e84); + var x80: u64 = undefined; + var x81: u64 = undefined; + mulxU64(&x80, &x81, x72, 0xf3b9cac2fc632551); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, 0x0, x81, x78); + var x84: u64 = undefined; + var x85: u1 = undefined; + addcarryxU64(&x84, &x85, x83, x79, x76); + var x86: u64 = undefined; + var x87: u1 = undefined; + addcarryxU64(&x86, &x87, x85, x77, x74); + const x88 = (cast(u64, x87) + x75); + var x89: u64 = undefined; + var x90: u1 = undefined; + addcarryxU64(&x89, &x90, 0x0, x62, x80); + var x91: u64 = undefined; + var x92: u1 = undefined; + addcarryxU64(&x91, &x92, x90, x64, x82); + var x93: u64 = undefined; + var x94: u1 = undefined; + addcarryxU64(&x93, &x94, x92, x66, x84); + var x95: u64 = undefined; + var x96: u1 = undefined; + addcarryxU64(&x95, &x96, x94, x68, x86); + var x97: u64 = undefined; + var x98: u1 = undefined; + addcarryxU64(&x97, &x98, x96, x70, x88); + const x99 = (cast(u64, x98) + cast(u64, x71)); + var x100: u64 = undefined; + var x101: u64 = undefined; + mulxU64(&x100, &x101, x2, (arg1[3])); + var x102: u64 = undefined; + var x103: u64 = undefined; + mulxU64(&x102, &x103, x2, (arg1[2])); + var x104: u64 = undefined; + var x105: u64 = undefined; + mulxU64(&x104, &x105, x2, (arg1[1])); + var x106: u64 = undefined; + var x107: u64 = undefined; + mulxU64(&x106, &x107, x2, (arg1[0])); + var x108: u64 = undefined; + var x109: u1 = undefined; + addcarryxU64(&x108, &x109, 0x0, x107, x104); + var x110: u64 = undefined; + var x111: u1 = undefined; + addcarryxU64(&x110, &x111, x109, x105, x102); + var x112: u64 = undefined; + var x113: u1 = undefined; + addcarryxU64(&x112, &x113, x111, x103, x100); + const x114 = (cast(u64, x113) + x101); + var x115: u64 = undefined; + var x116: u1 = undefined; + addcarryxU64(&x115, &x116, 0x0, x91, x106); + var x117: u64 = undefined; + var x118: u1 = undefined; + addcarryxU64(&x117, &x118, x116, x93, x108); + var x119: u64 = undefined; + var x120: u1 = undefined; + addcarryxU64(&x119, &x120, x118, x95, x110); + var x121: u64 = undefined; + var x122: u1 = undefined; + addcarryxU64(&x121, &x122, x120, x97, x112); + var x123: u64 = undefined; + var x124: u1 = undefined; + addcarryxU64(&x123, &x124, x122, x99, x114); + var x125: u64 = undefined; + var x126: u64 = undefined; + mulxU64(&x125, &x126, x115, 0xccd1c8aaee00bc4f); + var x127: u64 = undefined; + var x128: u64 = undefined; + mulxU64(&x127, &x128, x125, 0xffffffff00000000); + var x129: u64 = undefined; + var x130: u64 = undefined; + mulxU64(&x129, &x130, x125, 0xffffffffffffffff); + var x131: u64 = undefined; + var x132: u64 = undefined; + mulxU64(&x131, &x132, x125, 0xbce6faada7179e84); + var x133: u64 = undefined; + var x134: u64 = undefined; + mulxU64(&x133, &x134, x125, 0xf3b9cac2fc632551); + var x135: u64 = undefined; + var x136: u1 = undefined; + addcarryxU64(&x135, &x136, 0x0, x134, x131); + var x137: u64 = undefined; + var x138: u1 = undefined; + addcarryxU64(&x137, &x138, x136, x132, x129); + var x139: u64 = undefined; + var x140: u1 = undefined; + addcarryxU64(&x139, &x140, x138, x130, x127); + const x141 = (cast(u64, x140) + x128); + var x142: u64 = undefined; + var x143: u1 = undefined; + addcarryxU64(&x142, &x143, 0x0, x115, x133); + var x144: u64 = undefined; + var x145: u1 = undefined; + addcarryxU64(&x144, &x145, x143, x117, x135); + var x146: u64 = undefined; + var x147: u1 = undefined; + addcarryxU64(&x146, &x147, x145, x119, x137); + var x148: u64 = undefined; + var x149: u1 = undefined; + addcarryxU64(&x148, &x149, x147, x121, x139); + var x150: u64 = undefined; + var x151: u1 = undefined; + addcarryxU64(&x150, &x151, x149, x123, x141); + const x152 = (cast(u64, x151) + cast(u64, x124)); + var x153: u64 = undefined; + var x154: u64 = undefined; + mulxU64(&x153, &x154, x3, (arg1[3])); + var x155: u64 = undefined; + var x156: u64 = undefined; + mulxU64(&x155, &x156, x3, (arg1[2])); + var x157: u64 = undefined; + var x158: u64 = undefined; + mulxU64(&x157, &x158, x3, (arg1[1])); + var x159: u64 = undefined; + var x160: u64 = undefined; + mulxU64(&x159, &x160, x3, (arg1[0])); + var x161: u64 = undefined; + var x162: u1 = undefined; + addcarryxU64(&x161, &x162, 0x0, x160, x157); + var x163: u64 = undefined; + var x164: u1 = undefined; + addcarryxU64(&x163, &x164, x162, x158, x155); + var x165: u64 = undefined; + var x166: u1 = undefined; + addcarryxU64(&x165, &x166, x164, x156, x153); + const x167 = (cast(u64, x166) + x154); + var x168: u64 = undefined; + var x169: u1 = undefined; + addcarryxU64(&x168, &x169, 0x0, x144, x159); + var x170: u64 = undefined; + var x171: u1 = undefined; + addcarryxU64(&x170, &x171, x169, x146, x161); + var x172: u64 = undefined; + var x173: u1 = undefined; + addcarryxU64(&x172, &x173, x171, x148, x163); + var x174: u64 = undefined; + var x175: u1 = undefined; + addcarryxU64(&x174, &x175, x173, x150, x165); + var x176: u64 = undefined; + var x177: u1 = undefined; + addcarryxU64(&x176, &x177, x175, x152, x167); + var x178: u64 = undefined; + var x179: u64 = undefined; + mulxU64(&x178, &x179, x168, 0xccd1c8aaee00bc4f); + var x180: u64 = undefined; + var x181: u64 = undefined; + mulxU64(&x180, &x181, x178, 0xffffffff00000000); + var x182: u64 = undefined; + var x183: u64 = undefined; + mulxU64(&x182, &x183, x178, 0xffffffffffffffff); + var x184: u64 = undefined; + var x185: u64 = undefined; + mulxU64(&x184, &x185, x178, 0xbce6faada7179e84); + var x186: u64 = undefined; + var x187: u64 = undefined; + mulxU64(&x186, &x187, x178, 0xf3b9cac2fc632551); + var x188: u64 = undefined; + var x189: u1 = undefined; + addcarryxU64(&x188, &x189, 0x0, x187, x184); + var x190: u64 = undefined; + var x191: u1 = undefined; + addcarryxU64(&x190, &x191, x189, x185, x182); + var x192: u64 = undefined; + var x193: u1 = undefined; + addcarryxU64(&x192, &x193, x191, x183, x180); + const x194 = (cast(u64, x193) + x181); + var x195: u64 = undefined; + var x196: u1 = undefined; + addcarryxU64(&x195, &x196, 0x0, x168, x186); + var x197: u64 = undefined; + var x198: u1 = undefined; + addcarryxU64(&x197, &x198, x196, x170, x188); + var x199: u64 = undefined; + var x200: u1 = undefined; + addcarryxU64(&x199, &x200, x198, x172, x190); + var x201: u64 = undefined; + var x202: u1 = undefined; + addcarryxU64(&x201, &x202, x200, x174, x192); + var x203: u64 = undefined; + var x204: u1 = undefined; + addcarryxU64(&x203, &x204, x202, x176, x194); + const x205 = (cast(u64, x204) + cast(u64, x177)); + var x206: u64 = undefined; + var x207: u1 = undefined; + subborrowxU64(&x206, &x207, 0x0, x197, 0xf3b9cac2fc632551); + var x208: u64 = undefined; + var x209: u1 = undefined; + subborrowxU64(&x208, &x209, x207, x199, 0xbce6faada7179e84); + var x210: u64 = undefined; + var x211: u1 = undefined; + subborrowxU64(&x210, &x211, x209, x201, 0xffffffffffffffff); + var x212: u64 = undefined; + var x213: u1 = undefined; + subborrowxU64(&x212, &x213, x211, x203, 0xffffffff00000000); + var x214: u64 = undefined; + var x215: u1 = undefined; + subborrowxU64(&x214, &x215, x213, x205, cast(u64, 0x0)); + var x216: u64 = undefined; + cmovznzU64(&x216, x215, x206, x197); + var x217: u64 = undefined; + cmovznzU64(&x217, x215, x208, x199); + var x218: u64 = undefined; + cmovznzU64(&x218, x215, x210, x201); + var x219: u64 = undefined; + cmovznzU64(&x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/// The function add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn add(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + addcarryxU64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u64 = undefined; + var x4: u1 = undefined; + addcarryxU64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u64 = undefined; + var x6: u1 = undefined; + addcarryxU64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u64 = undefined; + var x8: u1 = undefined; + addcarryxU64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u64 = undefined; + var x10: u1 = undefined; + subborrowxU64(&x9, &x10, 0x0, x1, 0xf3b9cac2fc632551); + var x11: u64 = undefined; + var x12: u1 = undefined; + subborrowxU64(&x11, &x12, x10, x3, 0xbce6faada7179e84); + var x13: u64 = undefined; + var x14: u1 = undefined; + subborrowxU64(&x13, &x14, x12, x5, 0xffffffffffffffff); + var x15: u64 = undefined; + var x16: u1 = undefined; + subborrowxU64(&x15, &x16, x14, x7, 0xffffffff00000000); + var x17: u64 = undefined; + var x18: u1 = undefined; + subborrowxU64(&x17, &x18, x16, cast(u64, x8), cast(u64, 0x0)); + var x19: u64 = undefined; + cmovznzU64(&x19, x18, x9, x1); + var x20: u64 = undefined; + cmovznzU64(&x20, x18, x11, x3); + var x21: u64 = undefined; + cmovznzU64(&x21, x18, x13, x5); + var x22: u64 = undefined; + cmovznzU64(&x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/// The function sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn sub(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + subborrowxU64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u64 = undefined; + var x4: u1 = undefined; + subborrowxU64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u64 = undefined; + var x6: u1 = undefined; + subborrowxU64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u64 = undefined; + var x8: u1 = undefined; + subborrowxU64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u64 = undefined; + cmovznzU64(&x9, x8, cast(u64, 0x0), 0xffffffffffffffff); + var x10: u64 = undefined; + var x11: u1 = undefined; + addcarryxU64(&x10, &x11, 0x0, x1, (x9 & 0xf3b9cac2fc632551)); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, x11, x3, (x9 & 0xbce6faada7179e84)); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, x5, x9); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, x7, (x9 & 0xffffffff00000000)); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +pub fn opp(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + subborrowxU64(&x1, &x2, 0x0, cast(u64, 0x0), (arg1[0])); + var x3: u64 = undefined; + var x4: u1 = undefined; + subborrowxU64(&x3, &x4, x2, cast(u64, 0x0), (arg1[1])); + var x5: u64 = undefined; + var x6: u1 = undefined; + subborrowxU64(&x5, &x6, x4, cast(u64, 0x0), (arg1[2])); + var x7: u64 = undefined; + var x8: u1 = undefined; + subborrowxU64(&x7, &x8, x6, cast(u64, 0x0), (arg1[3])); + var x9: u64 = undefined; + cmovznzU64(&x9, x8, cast(u64, 0x0), 0xffffffffffffffff); + var x10: u64 = undefined; + var x11: u1 = undefined; + addcarryxU64(&x10, &x11, 0x0, x1, (x9 & 0xf3b9cac2fc632551)); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, x11, x3, (x9 & 0xbce6faada7179e84)); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, x5, x9); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, x7, (x9 & 0xffffffff00000000)); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fromMontgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m +/// 0 ≤ eval out1 < m +/// +pub fn fromMontgomery(out1: *NonMontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[0]); + var x2: u64 = undefined; + var x3: u64 = undefined; + mulxU64(&x2, &x3, x1, 0xccd1c8aaee00bc4f); + var x4: u64 = undefined; + var x5: u64 = undefined; + mulxU64(&x4, &x5, x2, 0xffffffff00000000); + var x6: u64 = undefined; + var x7: u64 = undefined; + mulxU64(&x6, &x7, x2, 0xffffffffffffffff); + var x8: u64 = undefined; + var x9: u64 = undefined; + mulxU64(&x8, &x9, x2, 0xbce6faada7179e84); + var x10: u64 = undefined; + var x11: u64 = undefined; + mulxU64(&x10, &x11, x2, 0xf3b9cac2fc632551); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, 0x0, x11, x8); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, x9, x6); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, x7, x4); + var x18: u64 = undefined; + var x19: u1 = undefined; + addcarryxU64(&x18, &x19, 0x0, x1, x10); + var x20: u64 = undefined; + var x21: u1 = undefined; + addcarryxU64(&x20, &x21, x19, cast(u64, 0x0), x12); + var x22: u64 = undefined; + var x23: u1 = undefined; + addcarryxU64(&x22, &x23, x21, cast(u64, 0x0), x14); + var x24: u64 = undefined; + var x25: u1 = undefined; + addcarryxU64(&x24, &x25, x23, cast(u64, 0x0), x16); + var x26: u64 = undefined; + var x27: u1 = undefined; + addcarryxU64(&x26, &x27, 0x0, x20, (arg1[1])); + var x28: u64 = undefined; + var x29: u1 = undefined; + addcarryxU64(&x28, &x29, x27, x22, cast(u64, 0x0)); + var x30: u64 = undefined; + var x31: u1 = undefined; + addcarryxU64(&x30, &x31, x29, x24, cast(u64, 0x0)); + var x32: u64 = undefined; + var x33: u64 = undefined; + mulxU64(&x32, &x33, x26, 0xccd1c8aaee00bc4f); + var x34: u64 = undefined; + var x35: u64 = undefined; + mulxU64(&x34, &x35, x32, 0xffffffff00000000); + var x36: u64 = undefined; + var x37: u64 = undefined; + mulxU64(&x36, &x37, x32, 0xffffffffffffffff); + var x38: u64 = undefined; + var x39: u64 = undefined; + mulxU64(&x38, &x39, x32, 0xbce6faada7179e84); + var x40: u64 = undefined; + var x41: u64 = undefined; + mulxU64(&x40, &x41, x32, 0xf3b9cac2fc632551); + var x42: u64 = undefined; + var x43: u1 = undefined; + addcarryxU64(&x42, &x43, 0x0, x41, x38); + var x44: u64 = undefined; + var x45: u1 = undefined; + addcarryxU64(&x44, &x45, x43, x39, x36); + var x46: u64 = undefined; + var x47: u1 = undefined; + addcarryxU64(&x46, &x47, x45, x37, x34); + var x48: u64 = undefined; + var x49: u1 = undefined; + addcarryxU64(&x48, &x49, 0x0, x26, x40); + var x50: u64 = undefined; + var x51: u1 = undefined; + addcarryxU64(&x50, &x51, x49, x28, x42); + var x52: u64 = undefined; + var x53: u1 = undefined; + addcarryxU64(&x52, &x53, x51, x30, x44); + var x54: u64 = undefined; + var x55: u1 = undefined; + addcarryxU64(&x54, &x55, x53, (cast(u64, x31) + (cast(u64, x25) + (cast(u64, x17) + x5))), x46); + var x56: u64 = undefined; + var x57: u1 = undefined; + addcarryxU64(&x56, &x57, 0x0, x50, (arg1[2])); + var x58: u64 = undefined; + var x59: u1 = undefined; + addcarryxU64(&x58, &x59, x57, x52, cast(u64, 0x0)); + var x60: u64 = undefined; + var x61: u1 = undefined; + addcarryxU64(&x60, &x61, x59, x54, cast(u64, 0x0)); + var x62: u64 = undefined; + var x63: u64 = undefined; + mulxU64(&x62, &x63, x56, 0xccd1c8aaee00bc4f); + var x64: u64 = undefined; + var x65: u64 = undefined; + mulxU64(&x64, &x65, x62, 0xffffffff00000000); + var x66: u64 = undefined; + var x67: u64 = undefined; + mulxU64(&x66, &x67, x62, 0xffffffffffffffff); + var x68: u64 = undefined; + var x69: u64 = undefined; + mulxU64(&x68, &x69, x62, 0xbce6faada7179e84); + var x70: u64 = undefined; + var x71: u64 = undefined; + mulxU64(&x70, &x71, x62, 0xf3b9cac2fc632551); + var x72: u64 = undefined; + var x73: u1 = undefined; + addcarryxU64(&x72, &x73, 0x0, x71, x68); + var x74: u64 = undefined; + var x75: u1 = undefined; + addcarryxU64(&x74, &x75, x73, x69, x66); + var x76: u64 = undefined; + var x77: u1 = undefined; + addcarryxU64(&x76, &x77, x75, x67, x64); + var x78: u64 = undefined; + var x79: u1 = undefined; + addcarryxU64(&x78, &x79, 0x0, x56, x70); + var x80: u64 = undefined; + var x81: u1 = undefined; + addcarryxU64(&x80, &x81, x79, x58, x72); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, x81, x60, x74); + var x84: u64 = undefined; + var x85: u1 = undefined; + addcarryxU64(&x84, &x85, x83, (cast(u64, x61) + (cast(u64, x55) + (cast(u64, x47) + x35))), x76); + var x86: u64 = undefined; + var x87: u1 = undefined; + addcarryxU64(&x86, &x87, 0x0, x80, (arg1[3])); + var x88: u64 = undefined; + var x89: u1 = undefined; + addcarryxU64(&x88, &x89, x87, x82, cast(u64, 0x0)); + var x90: u64 = undefined; + var x91: u1 = undefined; + addcarryxU64(&x90, &x91, x89, x84, cast(u64, 0x0)); + var x92: u64 = undefined; + var x93: u64 = undefined; + mulxU64(&x92, &x93, x86, 0xccd1c8aaee00bc4f); + var x94: u64 = undefined; + var x95: u64 = undefined; + mulxU64(&x94, &x95, x92, 0xffffffff00000000); + var x96: u64 = undefined; + var x97: u64 = undefined; + mulxU64(&x96, &x97, x92, 0xffffffffffffffff); + var x98: u64 = undefined; + var x99: u64 = undefined; + mulxU64(&x98, &x99, x92, 0xbce6faada7179e84); + var x100: u64 = undefined; + var x101: u64 = undefined; + mulxU64(&x100, &x101, x92, 0xf3b9cac2fc632551); + var x102: u64 = undefined; + var x103: u1 = undefined; + addcarryxU64(&x102, &x103, 0x0, x101, x98); + var x104: u64 = undefined; + var x105: u1 = undefined; + addcarryxU64(&x104, &x105, x103, x99, x96); + var x106: u64 = undefined; + var x107: u1 = undefined; + addcarryxU64(&x106, &x107, x105, x97, x94); + var x108: u64 = undefined; + var x109: u1 = undefined; + addcarryxU64(&x108, &x109, 0x0, x86, x100); + var x110: u64 = undefined; + var x111: u1 = undefined; + addcarryxU64(&x110, &x111, x109, x88, x102); + var x112: u64 = undefined; + var x113: u1 = undefined; + addcarryxU64(&x112, &x113, x111, x90, x104); + var x114: u64 = undefined; + var x115: u1 = undefined; + addcarryxU64(&x114, &x115, x113, (cast(u64, x91) + (cast(u64, x85) + (cast(u64, x77) + x65))), x106); + const x116 = (cast(u64, x115) + (cast(u64, x107) + x95)); + var x117: u64 = undefined; + var x118: u1 = undefined; + subborrowxU64(&x117, &x118, 0x0, x110, 0xf3b9cac2fc632551); + var x119: u64 = undefined; + var x120: u1 = undefined; + subborrowxU64(&x119, &x120, x118, x112, 0xbce6faada7179e84); + var x121: u64 = undefined; + var x122: u1 = undefined; + subborrowxU64(&x121, &x122, x120, x114, 0xffffffffffffffff); + var x123: u64 = undefined; + var x124: u1 = undefined; + subborrowxU64(&x123, &x124, x122, x116, 0xffffffff00000000); + var x125: u64 = undefined; + var x126: u1 = undefined; + subborrowxU64(&x125, &x126, x124, cast(u64, 0x0), cast(u64, 0x0)); + var x127: u64 = undefined; + cmovznzU64(&x127, x126, x117, x110); + var x128: u64 = undefined; + cmovznzU64(&x128, x126, x119, x112); + var x129: u64 = undefined; + cmovznzU64(&x129, x126, x121, x114); + var x130: u64 = undefined; + cmovznzU64(&x130, x126, x123, x116); + out1[0] = x127; + out1[1] = x128; + out1[2] = x129; + out1[3] = x130; +} + +/// The function toMontgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn toMontgomery(out1: *MontgomeryDomainFieldElement, arg1: NonMontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[0]); + var x5: u64 = undefined; + var x6: u64 = undefined; + mulxU64(&x5, &x6, x4, 0x66e12d94f3d95620); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x4, 0x2845b2392b6bec59); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x4, 0x4699799c49bd6fa6); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x4, 0x83244c95be79eea2); + var x13: u64 = undefined; + var x14: u1 = undefined; + addcarryxU64(&x13, &x14, 0x0, x12, x9); + var x15: u64 = undefined; + var x16: u1 = undefined; + addcarryxU64(&x15, &x16, x14, x10, x7); + var x17: u64 = undefined; + var x18: u1 = undefined; + addcarryxU64(&x17, &x18, x16, x8, x5); + var x19: u64 = undefined; + var x20: u64 = undefined; + mulxU64(&x19, &x20, x11, 0xccd1c8aaee00bc4f); + var x21: u64 = undefined; + var x22: u64 = undefined; + mulxU64(&x21, &x22, x19, 0xffffffff00000000); + var x23: u64 = undefined; + var x24: u64 = undefined; + mulxU64(&x23, &x24, x19, 0xffffffffffffffff); + var x25: u64 = undefined; + var x26: u64 = undefined; + mulxU64(&x25, &x26, x19, 0xbce6faada7179e84); + var x27: u64 = undefined; + var x28: u64 = undefined; + mulxU64(&x27, &x28, x19, 0xf3b9cac2fc632551); + var x29: u64 = undefined; + var x30: u1 = undefined; + addcarryxU64(&x29, &x30, 0x0, x28, x25); + var x31: u64 = undefined; + var x32: u1 = undefined; + addcarryxU64(&x31, &x32, x30, x26, x23); + var x33: u64 = undefined; + var x34: u1 = undefined; + addcarryxU64(&x33, &x34, x32, x24, x21); + var x35: u64 = undefined; + var x36: u1 = undefined; + addcarryxU64(&x35, &x36, 0x0, x11, x27); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, x36, x13, x29); + var x39: u64 = undefined; + var x40: u1 = undefined; + addcarryxU64(&x39, &x40, x38, x15, x31); + var x41: u64 = undefined; + var x42: u1 = undefined; + addcarryxU64(&x41, &x42, x40, x17, x33); + var x43: u64 = undefined; + var x44: u1 = undefined; + addcarryxU64(&x43, &x44, x42, (cast(u64, x18) + x6), (cast(u64, x34) + x22)); + var x45: u64 = undefined; + var x46: u64 = undefined; + mulxU64(&x45, &x46, x1, 0x66e12d94f3d95620); + var x47: u64 = undefined; + var x48: u64 = undefined; + mulxU64(&x47, &x48, x1, 0x2845b2392b6bec59); + var x49: u64 = undefined; + var x50: u64 = undefined; + mulxU64(&x49, &x50, x1, 0x4699799c49bd6fa6); + var x51: u64 = undefined; + var x52: u64 = undefined; + mulxU64(&x51, &x52, x1, 0x83244c95be79eea2); + var x53: u64 = undefined; + var x54: u1 = undefined; + addcarryxU64(&x53, &x54, 0x0, x52, x49); + var x55: u64 = undefined; + var x56: u1 = undefined; + addcarryxU64(&x55, &x56, x54, x50, x47); + var x57: u64 = undefined; + var x58: u1 = undefined; + addcarryxU64(&x57, &x58, x56, x48, x45); + var x59: u64 = undefined; + var x60: u1 = undefined; + addcarryxU64(&x59, &x60, 0x0, x37, x51); + var x61: u64 = undefined; + var x62: u1 = undefined; + addcarryxU64(&x61, &x62, x60, x39, x53); + var x63: u64 = undefined; + var x64: u1 = undefined; + addcarryxU64(&x63, &x64, x62, x41, x55); + var x65: u64 = undefined; + var x66: u1 = undefined; + addcarryxU64(&x65, &x66, x64, x43, x57); + var x67: u64 = undefined; + var x68: u64 = undefined; + mulxU64(&x67, &x68, x59, 0xccd1c8aaee00bc4f); + var x69: u64 = undefined; + var x70: u64 = undefined; + mulxU64(&x69, &x70, x67, 0xffffffff00000000); + var x71: u64 = undefined; + var x72: u64 = undefined; + mulxU64(&x71, &x72, x67, 0xffffffffffffffff); + var x73: u64 = undefined; + var x74: u64 = undefined; + mulxU64(&x73, &x74, x67, 0xbce6faada7179e84); + var x75: u64 = undefined; + var x76: u64 = undefined; + mulxU64(&x75, &x76, x67, 0xf3b9cac2fc632551); + var x77: u64 = undefined; + var x78: u1 = undefined; + addcarryxU64(&x77, &x78, 0x0, x76, x73); + var x79: u64 = undefined; + var x80: u1 = undefined; + addcarryxU64(&x79, &x80, x78, x74, x71); + var x81: u64 = undefined; + var x82: u1 = undefined; + addcarryxU64(&x81, &x82, x80, x72, x69); + var x83: u64 = undefined; + var x84: u1 = undefined; + addcarryxU64(&x83, &x84, 0x0, x59, x75); + var x85: u64 = undefined; + var x86: u1 = undefined; + addcarryxU64(&x85, &x86, x84, x61, x77); + var x87: u64 = undefined; + var x88: u1 = undefined; + addcarryxU64(&x87, &x88, x86, x63, x79); + var x89: u64 = undefined; + var x90: u1 = undefined; + addcarryxU64(&x89, &x90, x88, x65, x81); + var x91: u64 = undefined; + var x92: u1 = undefined; + addcarryxU64(&x91, &x92, x90, ((cast(u64, x66) + cast(u64, x44)) + (cast(u64, x58) + x46)), (cast(u64, x82) + x70)); + var x93: u64 = undefined; + var x94: u64 = undefined; + mulxU64(&x93, &x94, x2, 0x66e12d94f3d95620); + var x95: u64 = undefined; + var x96: u64 = undefined; + mulxU64(&x95, &x96, x2, 0x2845b2392b6bec59); + var x97: u64 = undefined; + var x98: u64 = undefined; + mulxU64(&x97, &x98, x2, 0x4699799c49bd6fa6); + var x99: u64 = undefined; + var x100: u64 = undefined; + mulxU64(&x99, &x100, x2, 0x83244c95be79eea2); + var x101: u64 = undefined; + var x102: u1 = undefined; + addcarryxU64(&x101, &x102, 0x0, x100, x97); + var x103: u64 = undefined; + var x104: u1 = undefined; + addcarryxU64(&x103, &x104, x102, x98, x95); + var x105: u64 = undefined; + var x106: u1 = undefined; + addcarryxU64(&x105, &x106, x104, x96, x93); + var x107: u64 = undefined; + var x108: u1 = undefined; + addcarryxU64(&x107, &x108, 0x0, x85, x99); + var x109: u64 = undefined; + var x110: u1 = undefined; + addcarryxU64(&x109, &x110, x108, x87, x101); + var x111: u64 = undefined; + var x112: u1 = undefined; + addcarryxU64(&x111, &x112, x110, x89, x103); + var x113: u64 = undefined; + var x114: u1 = undefined; + addcarryxU64(&x113, &x114, x112, x91, x105); + var x115: u64 = undefined; + var x116: u64 = undefined; + mulxU64(&x115, &x116, x107, 0xccd1c8aaee00bc4f); + var x117: u64 = undefined; + var x118: u64 = undefined; + mulxU64(&x117, &x118, x115, 0xffffffff00000000); + var x119: u64 = undefined; + var x120: u64 = undefined; + mulxU64(&x119, &x120, x115, 0xffffffffffffffff); + var x121: u64 = undefined; + var x122: u64 = undefined; + mulxU64(&x121, &x122, x115, 0xbce6faada7179e84); + var x123: u64 = undefined; + var x124: u64 = undefined; + mulxU64(&x123, &x124, x115, 0xf3b9cac2fc632551); + var x125: u64 = undefined; + var x126: u1 = undefined; + addcarryxU64(&x125, &x126, 0x0, x124, x121); + var x127: u64 = undefined; + var x128: u1 = undefined; + addcarryxU64(&x127, &x128, x126, x122, x119); + var x129: u64 = undefined; + var x130: u1 = undefined; + addcarryxU64(&x129, &x130, x128, x120, x117); + var x131: u64 = undefined; + var x132: u1 = undefined; + addcarryxU64(&x131, &x132, 0x0, x107, x123); + var x133: u64 = undefined; + var x134: u1 = undefined; + addcarryxU64(&x133, &x134, x132, x109, x125); + var x135: u64 = undefined; + var x136: u1 = undefined; + addcarryxU64(&x135, &x136, x134, x111, x127); + var x137: u64 = undefined; + var x138: u1 = undefined; + addcarryxU64(&x137, &x138, x136, x113, x129); + var x139: u64 = undefined; + var x140: u1 = undefined; + addcarryxU64(&x139, &x140, x138, ((cast(u64, x114) + cast(u64, x92)) + (cast(u64, x106) + x94)), (cast(u64, x130) + x118)); + var x141: u64 = undefined; + var x142: u64 = undefined; + mulxU64(&x141, &x142, x3, 0x66e12d94f3d95620); + var x143: u64 = undefined; + var x144: u64 = undefined; + mulxU64(&x143, &x144, x3, 0x2845b2392b6bec59); + var x145: u64 = undefined; + var x146: u64 = undefined; + mulxU64(&x145, &x146, x3, 0x4699799c49bd6fa6); + var x147: u64 = undefined; + var x148: u64 = undefined; + mulxU64(&x147, &x148, x3, 0x83244c95be79eea2); + var x149: u64 = undefined; + var x150: u1 = undefined; + addcarryxU64(&x149, &x150, 0x0, x148, x145); + var x151: u64 = undefined; + var x152: u1 = undefined; + addcarryxU64(&x151, &x152, x150, x146, x143); + var x153: u64 = undefined; + var x154: u1 = undefined; + addcarryxU64(&x153, &x154, x152, x144, x141); + var x155: u64 = undefined; + var x156: u1 = undefined; + addcarryxU64(&x155, &x156, 0x0, x133, x147); + var x157: u64 = undefined; + var x158: u1 = undefined; + addcarryxU64(&x157, &x158, x156, x135, x149); + var x159: u64 = undefined; + var x160: u1 = undefined; + addcarryxU64(&x159, &x160, x158, x137, x151); + var x161: u64 = undefined; + var x162: u1 = undefined; + addcarryxU64(&x161, &x162, x160, x139, x153); + var x163: u64 = undefined; + var x164: u64 = undefined; + mulxU64(&x163, &x164, x155, 0xccd1c8aaee00bc4f); + var x165: u64 = undefined; + var x166: u64 = undefined; + mulxU64(&x165, &x166, x163, 0xffffffff00000000); + var x167: u64 = undefined; + var x168: u64 = undefined; + mulxU64(&x167, &x168, x163, 0xffffffffffffffff); + var x169: u64 = undefined; + var x170: u64 = undefined; + mulxU64(&x169, &x170, x163, 0xbce6faada7179e84); + var x171: u64 = undefined; + var x172: u64 = undefined; + mulxU64(&x171, &x172, x163, 0xf3b9cac2fc632551); + var x173: u64 = undefined; + var x174: u1 = undefined; + addcarryxU64(&x173, &x174, 0x0, x172, x169); + var x175: u64 = undefined; + var x176: u1 = undefined; + addcarryxU64(&x175, &x176, x174, x170, x167); + var x177: u64 = undefined; + var x178: u1 = undefined; + addcarryxU64(&x177, &x178, x176, x168, x165); + var x179: u64 = undefined; + var x180: u1 = undefined; + addcarryxU64(&x179, &x180, 0x0, x155, x171); + var x181: u64 = undefined; + var x182: u1 = undefined; + addcarryxU64(&x181, &x182, x180, x157, x173); + var x183: u64 = undefined; + var x184: u1 = undefined; + addcarryxU64(&x183, &x184, x182, x159, x175); + var x185: u64 = undefined; + var x186: u1 = undefined; + addcarryxU64(&x185, &x186, x184, x161, x177); + var x187: u64 = undefined; + var x188: u1 = undefined; + addcarryxU64(&x187, &x188, x186, ((cast(u64, x162) + cast(u64, x140)) + (cast(u64, x154) + x142)), (cast(u64, x178) + x166)); + var x189: u64 = undefined; + var x190: u1 = undefined; + subborrowxU64(&x189, &x190, 0x0, x181, 0xf3b9cac2fc632551); + var x191: u64 = undefined; + var x192: u1 = undefined; + subborrowxU64(&x191, &x192, x190, x183, 0xbce6faada7179e84); + var x193: u64 = undefined; + var x194: u1 = undefined; + subborrowxU64(&x193, &x194, x192, x185, 0xffffffffffffffff); + var x195: u64 = undefined; + var x196: u1 = undefined; + subborrowxU64(&x195, &x196, x194, x187, 0xffffffff00000000); + var x197: u64 = undefined; + var x198: u1 = undefined; + subborrowxU64(&x197, &x198, x196, cast(u64, x188), cast(u64, 0x0)); + var x199: u64 = undefined; + cmovznzU64(&x199, x198, x189, x181); + var x200: u64 = undefined; + cmovznzU64(&x200, x198, x191, x183); + var x201: u64 = undefined; + cmovznzU64(&x201, x198, x193, x185); + var x202: u64 = undefined; + cmovznzU64(&x202, x198, x195, x187); + out1[0] = x199; + out1[1] = x200; + out1[2] = x201; + out1[3] = x202; +} + +/// The function nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +pub fn nonzero(out1: *u64, arg1: [4]u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3])))); + out1.* = x1; +} + +/// The function selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn selectznz(out1: *[4]u64, arg1: u1, arg2: [4]u64, arg3: [4]u64) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + cmovznzU64(&x1, arg1, (arg2[0]), (arg3[0])); + var x2: u64 = undefined; + cmovznzU64(&x2, arg1, (arg2[1]), (arg3[1])); + var x3: u64 = undefined; + cmovznzU64(&x3, arg1, (arg2[2]), (arg3[2])); + var x4: u64 = undefined; + cmovznzU64(&x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/// The function toBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +pub fn toBytes(out1: *[32]u8, arg1: [4]u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[3]); + const x2 = (arg1[2]); + const x3 = (arg1[1]); + const x4 = (arg1[0]); + const x5 = cast(u8, (x4 & cast(u64, 0xff))); + const x6 = (x4 >> 8); + const x7 = cast(u8, (x6 & cast(u64, 0xff))); + const x8 = (x6 >> 8); + const x9 = cast(u8, (x8 & cast(u64, 0xff))); + const x10 = (x8 >> 8); + const x11 = cast(u8, (x10 & cast(u64, 0xff))); + const x12 = (x10 >> 8); + const x13 = cast(u8, (x12 & cast(u64, 0xff))); + const x14 = (x12 >> 8); + const x15 = cast(u8, (x14 & cast(u64, 0xff))); + const x16 = (x14 >> 8); + const x17 = cast(u8, (x16 & cast(u64, 0xff))); + const x18 = cast(u8, (x16 >> 8)); + const x19 = cast(u8, (x3 & cast(u64, 0xff))); + const x20 = (x3 >> 8); + const x21 = cast(u8, (x20 & cast(u64, 0xff))); + const x22 = (x20 >> 8); + const x23 = cast(u8, (x22 & cast(u64, 0xff))); + const x24 = (x22 >> 8); + const x25 = cast(u8, (x24 & cast(u64, 0xff))); + const x26 = (x24 >> 8); + const x27 = cast(u8, (x26 & cast(u64, 0xff))); + const x28 = (x26 >> 8); + const x29 = cast(u8, (x28 & cast(u64, 0xff))); + const x30 = (x28 >> 8); + const x31 = cast(u8, (x30 & cast(u64, 0xff))); + const x32 = cast(u8, (x30 >> 8)); + const x33 = cast(u8, (x2 & cast(u64, 0xff))); + const x34 = (x2 >> 8); + const x35 = cast(u8, (x34 & cast(u64, 0xff))); + const x36 = (x34 >> 8); + const x37 = cast(u8, (x36 & cast(u64, 0xff))); + const x38 = (x36 >> 8); + const x39 = cast(u8, (x38 & cast(u64, 0xff))); + const x40 = (x38 >> 8); + const x41 = cast(u8, (x40 & cast(u64, 0xff))); + const x42 = (x40 >> 8); + const x43 = cast(u8, (x42 & cast(u64, 0xff))); + const x44 = (x42 >> 8); + const x45 = cast(u8, (x44 & cast(u64, 0xff))); + const x46 = cast(u8, (x44 >> 8)); + const x47 = cast(u8, (x1 & cast(u64, 0xff))); + const x48 = (x1 >> 8); + const x49 = cast(u8, (x48 & cast(u64, 0xff))); + const x50 = (x48 >> 8); + const x51 = cast(u8, (x50 & cast(u64, 0xff))); + const x52 = (x50 >> 8); + const x53 = cast(u8, (x52 & cast(u64, 0xff))); + const x54 = (x52 >> 8); + const x55 = cast(u8, (x54 & cast(u64, 0xff))); + const x56 = (x54 >> 8); + const x57 = cast(u8, (x56 & cast(u64, 0xff))); + const x58 = (x56 >> 8); + const x59 = cast(u8, (x58 & cast(u64, 0xff))); + const x60 = cast(u8, (x58 >> 8)); + out1[0] = x5; + out1[1] = x7; + out1[2] = x9; + out1[3] = x11; + out1[4] = x13; + out1[5] = x15; + out1[6] = x17; + out1[7] = x18; + out1[8] = x19; + out1[9] = x21; + out1[10] = x23; + out1[11] = x25; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x39; + out1[20] = x41; + out1[21] = x43; + out1[22] = x45; + out1[23] = x46; + out1[24] = x47; + out1[25] = x49; + out1[26] = x51; + out1[27] = x53; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; +} + +/// The function fromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn fromBytes(out1: *[4]u64, arg1: [32]u8) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u64, (arg1[31])) << 56); + const x2 = (cast(u64, (arg1[30])) << 48); + const x3 = (cast(u64, (arg1[29])) << 40); + const x4 = (cast(u64, (arg1[28])) << 32); + const x5 = (cast(u64, (arg1[27])) << 24); + const x6 = (cast(u64, (arg1[26])) << 16); + const x7 = (cast(u64, (arg1[25])) << 8); + const x8 = (arg1[24]); + const x9 = (cast(u64, (arg1[23])) << 56); + const x10 = (cast(u64, (arg1[22])) << 48); + const x11 = (cast(u64, (arg1[21])) << 40); + const x12 = (cast(u64, (arg1[20])) << 32); + const x13 = (cast(u64, (arg1[19])) << 24); + const x14 = (cast(u64, (arg1[18])) << 16); + const x15 = (cast(u64, (arg1[17])) << 8); + const x16 = (arg1[16]); + const x17 = (cast(u64, (arg1[15])) << 56); + const x18 = (cast(u64, (arg1[14])) << 48); + const x19 = (cast(u64, (arg1[13])) << 40); + const x20 = (cast(u64, (arg1[12])) << 32); + const x21 = (cast(u64, (arg1[11])) << 24); + const x22 = (cast(u64, (arg1[10])) << 16); + const x23 = (cast(u64, (arg1[9])) << 8); + const x24 = (arg1[8]); + const x25 = (cast(u64, (arg1[7])) << 56); + const x26 = (cast(u64, (arg1[6])) << 48); + const x27 = (cast(u64, (arg1[5])) << 40); + const x28 = (cast(u64, (arg1[4])) << 32); + const x29 = (cast(u64, (arg1[3])) << 24); + const x30 = (cast(u64, (arg1[2])) << 16); + const x31 = (cast(u64, (arg1[1])) << 8); + const x32 = (arg1[0]); + const x33 = (x31 + cast(u64, x32)); + const x34 = (x30 + x33); + const x35 = (x29 + x34); + const x36 = (x28 + x35); + const x37 = (x27 + x36); + const x38 = (x26 + x37); + const x39 = (x25 + x38); + const x40 = (x23 + cast(u64, x24)); + const x41 = (x22 + x40); + const x42 = (x21 + x41); + const x43 = (x20 + x42); + const x44 = (x19 + x43); + const x45 = (x18 + x44); + const x46 = (x17 + x45); + const x47 = (x15 + cast(u64, x16)); + const x48 = (x14 + x47); + const x49 = (x13 + x48); + const x50 = (x12 + x49); + const x51 = (x11 + x50); + const x52 = (x10 + x51); + const x53 = (x9 + x52); + const x54 = (x7 + cast(u64, x8)); + const x55 = (x6 + x54); + const x56 = (x5 + x55); + const x57 = (x4 + x56); + const x58 = (x3 + x57); + const x59 = (x2 + x58); + const x60 = (x1 + x59); + out1[0] = x39; + out1[1] = x46; + out1[2] = x53; + out1[3] = x60; +} + +/// The function setOne returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn setOne(out1: *MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xc46353d039cdaaf; + out1[1] = 0x4319055258e8617b; + out1[2] = cast(u64, 0x0); + out1[3] = 0xffffffff; +} + +/// The function msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn msat(out1: *[5]u64) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xf3b9cac2fc632551; + out1[1] = 0xbce6faada7179e84; + out1[2] = 0xffffffffffffffff; + out1[3] = 0xffffffff00000000; + out1[4] = cast(u64, 0x0); +} + +/// The function divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn divstep(out1: *u64, out2: *[5]u64, out3: *[5]u64, out4: *[4]u64, out5: *[4]u64, arg1: u64, arg2: [5]u64, arg3: [5]u64, arg4: [4]u64, arg5: [4]u64) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + addcarryxU64(&x1, &x2, 0x0, (~arg1), cast(u64, 0x1)); + const x3 = (cast(u1, (x1 >> 63)) & cast(u1, ((arg3[0]) & cast(u64, 0x1)))); + var x4: u64 = undefined; + var x5: u1 = undefined; + addcarryxU64(&x4, &x5, 0x0, (~arg1), cast(u64, 0x1)); + var x6: u64 = undefined; + cmovznzU64(&x6, x3, arg1, x4); + var x7: u64 = undefined; + cmovznzU64(&x7, x3, (arg2[0]), (arg3[0])); + var x8: u64 = undefined; + cmovznzU64(&x8, x3, (arg2[1]), (arg3[1])); + var x9: u64 = undefined; + cmovznzU64(&x9, x3, (arg2[2]), (arg3[2])); + var x10: u64 = undefined; + cmovznzU64(&x10, x3, (arg2[3]), (arg3[3])); + var x11: u64 = undefined; + cmovznzU64(&x11, x3, (arg2[4]), (arg3[4])); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, 0x0, cast(u64, 0x1), (~(arg2[0]))); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, cast(u64, 0x0), (~(arg2[1]))); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, cast(u64, 0x0), (~(arg2[2]))); + var x18: u64 = undefined; + var x19: u1 = undefined; + addcarryxU64(&x18, &x19, x17, cast(u64, 0x0), (~(arg2[3]))); + var x20: u64 = undefined; + var x21: u1 = undefined; + addcarryxU64(&x20, &x21, x19, cast(u64, 0x0), (~(arg2[4]))); + var x22: u64 = undefined; + cmovznzU64(&x22, x3, (arg3[0]), x12); + var x23: u64 = undefined; + cmovznzU64(&x23, x3, (arg3[1]), x14); + var x24: u64 = undefined; + cmovznzU64(&x24, x3, (arg3[2]), x16); + var x25: u64 = undefined; + cmovznzU64(&x25, x3, (arg3[3]), x18); + var x26: u64 = undefined; + cmovznzU64(&x26, x3, (arg3[4]), x20); + var x27: u64 = undefined; + cmovznzU64(&x27, x3, (arg4[0]), (arg5[0])); + var x28: u64 = undefined; + cmovznzU64(&x28, x3, (arg4[1]), (arg5[1])); + var x29: u64 = undefined; + cmovznzU64(&x29, x3, (arg4[2]), (arg5[2])); + var x30: u64 = undefined; + cmovznzU64(&x30, x3, (arg4[3]), (arg5[3])); + var x31: u64 = undefined; + var x32: u1 = undefined; + addcarryxU64(&x31, &x32, 0x0, x27, x27); + var x33: u64 = undefined; + var x34: u1 = undefined; + addcarryxU64(&x33, &x34, x32, x28, x28); + var x35: u64 = undefined; + var x36: u1 = undefined; + addcarryxU64(&x35, &x36, x34, x29, x29); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, x36, x30, x30); + var x39: u64 = undefined; + var x40: u1 = undefined; + subborrowxU64(&x39, &x40, 0x0, x31, 0xf3b9cac2fc632551); + var x41: u64 = undefined; + var x42: u1 = undefined; + subborrowxU64(&x41, &x42, x40, x33, 0xbce6faada7179e84); + var x43: u64 = undefined; + var x44: u1 = undefined; + subborrowxU64(&x43, &x44, x42, x35, 0xffffffffffffffff); + var x45: u64 = undefined; + var x46: u1 = undefined; + subborrowxU64(&x45, &x46, x44, x37, 0xffffffff00000000); + var x47: u64 = undefined; + var x48: u1 = undefined; + subborrowxU64(&x47, &x48, x46, cast(u64, x38), cast(u64, 0x0)); + const x49 = (arg4[3]); + const x50 = (arg4[2]); + const x51 = (arg4[1]); + const x52 = (arg4[0]); + var x53: u64 = undefined; + var x54: u1 = undefined; + subborrowxU64(&x53, &x54, 0x0, cast(u64, 0x0), x52); + var x55: u64 = undefined; + var x56: u1 = undefined; + subborrowxU64(&x55, &x56, x54, cast(u64, 0x0), x51); + var x57: u64 = undefined; + var x58: u1 = undefined; + subborrowxU64(&x57, &x58, x56, cast(u64, 0x0), x50); + var x59: u64 = undefined; + var x60: u1 = undefined; + subborrowxU64(&x59, &x60, x58, cast(u64, 0x0), x49); + var x61: u64 = undefined; + cmovznzU64(&x61, x60, cast(u64, 0x0), 0xffffffffffffffff); + var x62: u64 = undefined; + var x63: u1 = undefined; + addcarryxU64(&x62, &x63, 0x0, x53, (x61 & 0xf3b9cac2fc632551)); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, x55, (x61 & 0xbce6faada7179e84)); + var x66: u64 = undefined; + var x67: u1 = undefined; + addcarryxU64(&x66, &x67, x65, x57, x61); + var x68: u64 = undefined; + var x69: u1 = undefined; + addcarryxU64(&x68, &x69, x67, x59, (x61 & 0xffffffff00000000)); + var x70: u64 = undefined; + cmovznzU64(&x70, x3, (arg5[0]), x62); + var x71: u64 = undefined; + cmovznzU64(&x71, x3, (arg5[1]), x64); + var x72: u64 = undefined; + cmovznzU64(&x72, x3, (arg5[2]), x66); + var x73: u64 = undefined; + cmovznzU64(&x73, x3, (arg5[3]), x68); + const x74 = cast(u1, (x22 & cast(u64, 0x1))); + var x75: u64 = undefined; + cmovznzU64(&x75, x74, cast(u64, 0x0), x7); + var x76: u64 = undefined; + cmovznzU64(&x76, x74, cast(u64, 0x0), x8); + var x77: u64 = undefined; + cmovznzU64(&x77, x74, cast(u64, 0x0), x9); + var x78: u64 = undefined; + cmovznzU64(&x78, x74, cast(u64, 0x0), x10); + var x79: u64 = undefined; + cmovznzU64(&x79, x74, cast(u64, 0x0), x11); + var x80: u64 = undefined; + var x81: u1 = undefined; + addcarryxU64(&x80, &x81, 0x0, x22, x75); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, x81, x23, x76); + var x84: u64 = undefined; + var x85: u1 = undefined; + addcarryxU64(&x84, &x85, x83, x24, x77); + var x86: u64 = undefined; + var x87: u1 = undefined; + addcarryxU64(&x86, &x87, x85, x25, x78); + var x88: u64 = undefined; + var x89: u1 = undefined; + addcarryxU64(&x88, &x89, x87, x26, x79); + var x90: u64 = undefined; + cmovznzU64(&x90, x74, cast(u64, 0x0), x27); + var x91: u64 = undefined; + cmovznzU64(&x91, x74, cast(u64, 0x0), x28); + var x92: u64 = undefined; + cmovznzU64(&x92, x74, cast(u64, 0x0), x29); + var x93: u64 = undefined; + cmovznzU64(&x93, x74, cast(u64, 0x0), x30); + var x94: u64 = undefined; + var x95: u1 = undefined; + addcarryxU64(&x94, &x95, 0x0, x70, x90); + var x96: u64 = undefined; + var x97: u1 = undefined; + addcarryxU64(&x96, &x97, x95, x71, x91); + var x98: u64 = undefined; + var x99: u1 = undefined; + addcarryxU64(&x98, &x99, x97, x72, x92); + var x100: u64 = undefined; + var x101: u1 = undefined; + addcarryxU64(&x100, &x101, x99, x73, x93); + var x102: u64 = undefined; + var x103: u1 = undefined; + subborrowxU64(&x102, &x103, 0x0, x94, 0xf3b9cac2fc632551); + var x104: u64 = undefined; + var x105: u1 = undefined; + subborrowxU64(&x104, &x105, x103, x96, 0xbce6faada7179e84); + var x106: u64 = undefined; + var x107: u1 = undefined; + subborrowxU64(&x106, &x107, x105, x98, 0xffffffffffffffff); + var x108: u64 = undefined; + var x109: u1 = undefined; + subborrowxU64(&x108, &x109, x107, x100, 0xffffffff00000000); + var x110: u64 = undefined; + var x111: u1 = undefined; + subborrowxU64(&x110, &x111, x109, cast(u64, x101), cast(u64, 0x0)); + var x112: u64 = undefined; + var x113: u1 = undefined; + addcarryxU64(&x112, &x113, 0x0, x6, cast(u64, 0x1)); + const x114 = ((x80 >> 1) | ((x82 << 63) & 0xffffffffffffffff)); + const x115 = ((x82 >> 1) | ((x84 << 63) & 0xffffffffffffffff)); + const x116 = ((x84 >> 1) | ((x86 << 63) & 0xffffffffffffffff)); + const x117 = ((x86 >> 1) | ((x88 << 63) & 0xffffffffffffffff)); + const x118 = ((x88 & 0x8000000000000000) | (x88 >> 1)); + var x119: u64 = undefined; + cmovznzU64(&x119, x48, x39, x31); + var x120: u64 = undefined; + cmovznzU64(&x120, x48, x41, x33); + var x121: u64 = undefined; + cmovznzU64(&x121, x48, x43, x35); + var x122: u64 = undefined; + cmovznzU64(&x122, x48, x45, x37); + var x123: u64 = undefined; + cmovznzU64(&x123, x111, x102, x94); + var x124: u64 = undefined; + cmovznzU64(&x124, x111, x104, x96); + var x125: u64 = undefined; + cmovznzU64(&x125, x111, x106, x98); + var x126: u64 = undefined; + cmovznzU64(&x126, x111, x108, x100); + out1.* = x112; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out3[0] = x114; + out3[1] = x115; + out3[2] = x116; + out3[3] = x117; + out3[4] = x118; + out4[0] = x119; + out4[1] = x120; + out4[2] = x121; + out4[3] = x122; + out5[0] = x123; + out5[1] = x124; + out5[2] = x125; + out5[3] = x126; +} + +/// The function divstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn divstepPrecomp(out1: *[4]u64) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xd739262fb7fcfbb5; + out1[1] = 0x8ac6f75d20074414; + out1[2] = 0xc67428bfb5e3c256; + out1[3] = 0x444962f2eda7aedf; +} diff --git a/fiat-zig/src/p384_scalar_32.zig b/fiat-zig/src/p384_scalar_32.zig new file mode 100644 index 0000000000..ae7c7be877 --- /dev/null +++ b/fiat-zig/src/p384_scalar_32.zig @@ -0,0 +1,11403 @@ +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Zig --internal-static --public-function-case camelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case UpperCamelCase --no-prefix-fiat --package-name p384_scalar '' 32 '2^384 - 1388124618062372383947042015309946732620727252194336364173' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// curve description (via package name): p384_scalar +// machine_wordsize = 32 (from "32") +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from "2^384 - 1388124618062372383947042015309946732620727252194336364173") +// +// NOTE: In addition to the bounds specified above each function, all +// functions synthesized for this Montgomery arithmetic require the +// input to be strictly less than the prime modulus (m), and also +// require the input to be in the unique saturated representation. +// All functions also ensure that these two properties are true of +// return values. +// +// Computed values: +// eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) +// twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) in +// if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384 + +const std = @import("std"); +const mode = @import("builtin").mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels + +inline fn cast(comptime DestType: type, target: anytype) DestType { + if (@typeInfo(@TypeOf(target)) == .Int) { + const dest = @typeInfo(DestType).Int; + const source = @typeInfo(@TypeOf(target)).Int; + if (dest.bits < source.bits) { + return @bitCast(DestType, @truncate(std.meta.Int(source.signedness, dest.bits), target)); + } else { + return @bitCast(DestType, @as(std.meta.Int(source.signedness, dest.bits), target)); + } + } + return @as(DestType, target); +} + +// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub const MontgomeryDomainFieldElement = [12]u32; + +// The type NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub const NonMontgomeryDomainFieldElement = [12]u32; + +/// The function addcarryxU32 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^32 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +inline fn addcarryxU32(out1: *u32, out2: *u1, arg1: u1, arg2: u32, arg3: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(u64, arg1) + cast(u64, arg2)) + cast(u64, arg3)); + const x2 = cast(u32, (x1 & cast(u64, 0xffffffff))); + const x3 = cast(u1, (x1 >> 32)); + out1.* = x2; + out2.* = x3; +} + +/// The function subborrowxU32 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^32 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +inline fn subborrowxU32(out1: *u32, out2: *u1, arg1: u1, arg2: u32, arg3: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(i64, arg2) - cast(i64, arg1)) - cast(i64, arg3)); + const x2 = cast(i1, (x1 >> 32)); + const x3 = cast(u32, (x1 & cast(i64, 0xffffffff))); + out1.* = x3; + out2.* = cast(u1, (cast(i2, 0x0) - cast(i2, x2))); +} + +/// The function mulxU32 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^32 +/// out2 = ⌊arg1 * arg2 / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0xffffffff] +inline fn mulxU32(out1: *u32, out2: *u32, arg1: u32, arg2: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u64, arg1) * cast(u64, arg2)); + const x2 = cast(u32, (x1 & cast(u64, 0xffffffff))); + const x3 = cast(u32, (x1 >> 32)); + out1.* = x2; + out2.* = x3; +} + +/// The function cmovznzU32 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +inline fn cmovznzU32(out1: *u32, arg1: u1, arg2: u32, arg3: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (~(~arg1)); + const x2 = cast(u32, (cast(i64, cast(i1, (cast(i2, 0x0) - cast(i2, x1)))) & cast(i64, 0xffffffff))); + const x3 = ((x2 & arg3) | ((~x2) & arg2)); + out1.* = x3; +} + +/// The function mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn mul(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[6]); + const x7 = (arg1[7]); + const x8 = (arg1[8]); + const x9 = (arg1[9]); + const x10 = (arg1[10]); + const x11 = (arg1[11]); + const x12 = (arg1[0]); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x12, (arg2[11])); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x12, (arg2[10])); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x12, (arg2[9])); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x12, (arg2[8])); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x12, (arg2[7])); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x12, (arg2[6])); + var x25: u32 = undefined; + var x26: u32 = undefined; + mulxU32(&x25, &x26, x12, (arg2[5])); + var x27: u32 = undefined; + var x28: u32 = undefined; + mulxU32(&x27, &x28, x12, (arg2[4])); + var x29: u32 = undefined; + var x30: u32 = undefined; + mulxU32(&x29, &x30, x12, (arg2[3])); + var x31: u32 = undefined; + var x32: u32 = undefined; + mulxU32(&x31, &x32, x12, (arg2[2])); + var x33: u32 = undefined; + var x34: u32 = undefined; + mulxU32(&x33, &x34, x12, (arg2[1])); + var x35: u32 = undefined; + var x36: u32 = undefined; + mulxU32(&x35, &x36, x12, (arg2[0])); + var x37: u32 = undefined; + var x38: u1 = undefined; + addcarryxU32(&x37, &x38, 0x0, x36, x33); + var x39: u32 = undefined; + var x40: u1 = undefined; + addcarryxU32(&x39, &x40, x38, x34, x31); + var x41: u32 = undefined; + var x42: u1 = undefined; + addcarryxU32(&x41, &x42, x40, x32, x29); + var x43: u32 = undefined; + var x44: u1 = undefined; + addcarryxU32(&x43, &x44, x42, x30, x27); + var x45: u32 = undefined; + var x46: u1 = undefined; + addcarryxU32(&x45, &x46, x44, x28, x25); + var x47: u32 = undefined; + var x48: u1 = undefined; + addcarryxU32(&x47, &x48, x46, x26, x23); + var x49: u32 = undefined; + var x50: u1 = undefined; + addcarryxU32(&x49, &x50, x48, x24, x21); + var x51: u32 = undefined; + var x52: u1 = undefined; + addcarryxU32(&x51, &x52, x50, x22, x19); + var x53: u32 = undefined; + var x54: u1 = undefined; + addcarryxU32(&x53, &x54, x52, x20, x17); + var x55: u32 = undefined; + var x56: u1 = undefined; + addcarryxU32(&x55, &x56, x54, x18, x15); + var x57: u32 = undefined; + var x58: u1 = undefined; + addcarryxU32(&x57, &x58, x56, x16, x13); + const x59 = (cast(u32, x58) + x14); + var x60: u32 = undefined; + var x61: u32 = undefined; + mulxU32(&x60, &x61, x35, 0xe88fdc45); + var x62: u32 = undefined; + var x63: u32 = undefined; + mulxU32(&x62, &x63, x60, 0xffffffff); + var x64: u32 = undefined; + var x65: u32 = undefined; + mulxU32(&x64, &x65, x60, 0xffffffff); + var x66: u32 = undefined; + var x67: u32 = undefined; + mulxU32(&x66, &x67, x60, 0xffffffff); + var x68: u32 = undefined; + var x69: u32 = undefined; + mulxU32(&x68, &x69, x60, 0xffffffff); + var x70: u32 = undefined; + var x71: u32 = undefined; + mulxU32(&x70, &x71, x60, 0xffffffff); + var x72: u32 = undefined; + var x73: u32 = undefined; + mulxU32(&x72, &x73, x60, 0xffffffff); + var x74: u32 = undefined; + var x75: u32 = undefined; + mulxU32(&x74, &x75, x60, 0xc7634d81); + var x76: u32 = undefined; + var x77: u32 = undefined; + mulxU32(&x76, &x77, x60, 0xf4372ddf); + var x78: u32 = undefined; + var x79: u32 = undefined; + mulxU32(&x78, &x79, x60, 0x581a0db2); + var x80: u32 = undefined; + var x81: u32 = undefined; + mulxU32(&x80, &x81, x60, 0x48b0a77a); + var x82: u32 = undefined; + var x83: u32 = undefined; + mulxU32(&x82, &x83, x60, 0xecec196a); + var x84: u32 = undefined; + var x85: u32 = undefined; + mulxU32(&x84, &x85, x60, 0xccc52973); + var x86: u32 = undefined; + var x87: u1 = undefined; + addcarryxU32(&x86, &x87, 0x0, x85, x82); + var x88: u32 = undefined; + var x89: u1 = undefined; + addcarryxU32(&x88, &x89, x87, x83, x80); + var x90: u32 = undefined; + var x91: u1 = undefined; + addcarryxU32(&x90, &x91, x89, x81, x78); + var x92: u32 = undefined; + var x93: u1 = undefined; + addcarryxU32(&x92, &x93, x91, x79, x76); + var x94: u32 = undefined; + var x95: u1 = undefined; + addcarryxU32(&x94, &x95, x93, x77, x74); + var x96: u32 = undefined; + var x97: u1 = undefined; + addcarryxU32(&x96, &x97, x95, x75, x72); + var x98: u32 = undefined; + var x99: u1 = undefined; + addcarryxU32(&x98, &x99, x97, x73, x70); + var x100: u32 = undefined; + var x101: u1 = undefined; + addcarryxU32(&x100, &x101, x99, x71, x68); + var x102: u32 = undefined; + var x103: u1 = undefined; + addcarryxU32(&x102, &x103, x101, x69, x66); + var x104: u32 = undefined; + var x105: u1 = undefined; + addcarryxU32(&x104, &x105, x103, x67, x64); + var x106: u32 = undefined; + var x107: u1 = undefined; + addcarryxU32(&x106, &x107, x105, x65, x62); + const x108 = (cast(u32, x107) + x63); + var x109: u32 = undefined; + var x110: u1 = undefined; + addcarryxU32(&x109, &x110, 0x0, x35, x84); + var x111: u32 = undefined; + var x112: u1 = undefined; + addcarryxU32(&x111, &x112, x110, x37, x86); + var x113: u32 = undefined; + var x114: u1 = undefined; + addcarryxU32(&x113, &x114, x112, x39, x88); + var x115: u32 = undefined; + var x116: u1 = undefined; + addcarryxU32(&x115, &x116, x114, x41, x90); + var x117: u32 = undefined; + var x118: u1 = undefined; + addcarryxU32(&x117, &x118, x116, x43, x92); + var x119: u32 = undefined; + var x120: u1 = undefined; + addcarryxU32(&x119, &x120, x118, x45, x94); + var x121: u32 = undefined; + var x122: u1 = undefined; + addcarryxU32(&x121, &x122, x120, x47, x96); + var x123: u32 = undefined; + var x124: u1 = undefined; + addcarryxU32(&x123, &x124, x122, x49, x98); + var x125: u32 = undefined; + var x126: u1 = undefined; + addcarryxU32(&x125, &x126, x124, x51, x100); + var x127: u32 = undefined; + var x128: u1 = undefined; + addcarryxU32(&x127, &x128, x126, x53, x102); + var x129: u32 = undefined; + var x130: u1 = undefined; + addcarryxU32(&x129, &x130, x128, x55, x104); + var x131: u32 = undefined; + var x132: u1 = undefined; + addcarryxU32(&x131, &x132, x130, x57, x106); + var x133: u32 = undefined; + var x134: u1 = undefined; + addcarryxU32(&x133, &x134, x132, x59, x108); + var x135: u32 = undefined; + var x136: u32 = undefined; + mulxU32(&x135, &x136, x1, (arg2[11])); + var x137: u32 = undefined; + var x138: u32 = undefined; + mulxU32(&x137, &x138, x1, (arg2[10])); + var x139: u32 = undefined; + var x140: u32 = undefined; + mulxU32(&x139, &x140, x1, (arg2[9])); + var x141: u32 = undefined; + var x142: u32 = undefined; + mulxU32(&x141, &x142, x1, (arg2[8])); + var x143: u32 = undefined; + var x144: u32 = undefined; + mulxU32(&x143, &x144, x1, (arg2[7])); + var x145: u32 = undefined; + var x146: u32 = undefined; + mulxU32(&x145, &x146, x1, (arg2[6])); + var x147: u32 = undefined; + var x148: u32 = undefined; + mulxU32(&x147, &x148, x1, (arg2[5])); + var x149: u32 = undefined; + var x150: u32 = undefined; + mulxU32(&x149, &x150, x1, (arg2[4])); + var x151: u32 = undefined; + var x152: u32 = undefined; + mulxU32(&x151, &x152, x1, (arg2[3])); + var x153: u32 = undefined; + var x154: u32 = undefined; + mulxU32(&x153, &x154, x1, (arg2[2])); + var x155: u32 = undefined; + var x156: u32 = undefined; + mulxU32(&x155, &x156, x1, (arg2[1])); + var x157: u32 = undefined; + var x158: u32 = undefined; + mulxU32(&x157, &x158, x1, (arg2[0])); + var x159: u32 = undefined; + var x160: u1 = undefined; + addcarryxU32(&x159, &x160, 0x0, x158, x155); + var x161: u32 = undefined; + var x162: u1 = undefined; + addcarryxU32(&x161, &x162, x160, x156, x153); + var x163: u32 = undefined; + var x164: u1 = undefined; + addcarryxU32(&x163, &x164, x162, x154, x151); + var x165: u32 = undefined; + var x166: u1 = undefined; + addcarryxU32(&x165, &x166, x164, x152, x149); + var x167: u32 = undefined; + var x168: u1 = undefined; + addcarryxU32(&x167, &x168, x166, x150, x147); + var x169: u32 = undefined; + var x170: u1 = undefined; + addcarryxU32(&x169, &x170, x168, x148, x145); + var x171: u32 = undefined; + var x172: u1 = undefined; + addcarryxU32(&x171, &x172, x170, x146, x143); + var x173: u32 = undefined; + var x174: u1 = undefined; + addcarryxU32(&x173, &x174, x172, x144, x141); + var x175: u32 = undefined; + var x176: u1 = undefined; + addcarryxU32(&x175, &x176, x174, x142, x139); + var x177: u32 = undefined; + var x178: u1 = undefined; + addcarryxU32(&x177, &x178, x176, x140, x137); + var x179: u32 = undefined; + var x180: u1 = undefined; + addcarryxU32(&x179, &x180, x178, x138, x135); + const x181 = (cast(u32, x180) + x136); + var x182: u32 = undefined; + var x183: u1 = undefined; + addcarryxU32(&x182, &x183, 0x0, x111, x157); + var x184: u32 = undefined; + var x185: u1 = undefined; + addcarryxU32(&x184, &x185, x183, x113, x159); + var x186: u32 = undefined; + var x187: u1 = undefined; + addcarryxU32(&x186, &x187, x185, x115, x161); + var x188: u32 = undefined; + var x189: u1 = undefined; + addcarryxU32(&x188, &x189, x187, x117, x163); + var x190: u32 = undefined; + var x191: u1 = undefined; + addcarryxU32(&x190, &x191, x189, x119, x165); + var x192: u32 = undefined; + var x193: u1 = undefined; + addcarryxU32(&x192, &x193, x191, x121, x167); + var x194: u32 = undefined; + var x195: u1 = undefined; + addcarryxU32(&x194, &x195, x193, x123, x169); + var x196: u32 = undefined; + var x197: u1 = undefined; + addcarryxU32(&x196, &x197, x195, x125, x171); + var x198: u32 = undefined; + var x199: u1 = undefined; + addcarryxU32(&x198, &x199, x197, x127, x173); + var x200: u32 = undefined; + var x201: u1 = undefined; + addcarryxU32(&x200, &x201, x199, x129, x175); + var x202: u32 = undefined; + var x203: u1 = undefined; + addcarryxU32(&x202, &x203, x201, x131, x177); + var x204: u32 = undefined; + var x205: u1 = undefined; + addcarryxU32(&x204, &x205, x203, x133, x179); + var x206: u32 = undefined; + var x207: u1 = undefined; + addcarryxU32(&x206, &x207, x205, cast(u32, x134), x181); + var x208: u32 = undefined; + var x209: u32 = undefined; + mulxU32(&x208, &x209, x182, 0xe88fdc45); + var x210: u32 = undefined; + var x211: u32 = undefined; + mulxU32(&x210, &x211, x208, 0xffffffff); + var x212: u32 = undefined; + var x213: u32 = undefined; + mulxU32(&x212, &x213, x208, 0xffffffff); + var x214: u32 = undefined; + var x215: u32 = undefined; + mulxU32(&x214, &x215, x208, 0xffffffff); + var x216: u32 = undefined; + var x217: u32 = undefined; + mulxU32(&x216, &x217, x208, 0xffffffff); + var x218: u32 = undefined; + var x219: u32 = undefined; + mulxU32(&x218, &x219, x208, 0xffffffff); + var x220: u32 = undefined; + var x221: u32 = undefined; + mulxU32(&x220, &x221, x208, 0xffffffff); + var x222: u32 = undefined; + var x223: u32 = undefined; + mulxU32(&x222, &x223, x208, 0xc7634d81); + var x224: u32 = undefined; + var x225: u32 = undefined; + mulxU32(&x224, &x225, x208, 0xf4372ddf); + var x226: u32 = undefined; + var x227: u32 = undefined; + mulxU32(&x226, &x227, x208, 0x581a0db2); + var x228: u32 = undefined; + var x229: u32 = undefined; + mulxU32(&x228, &x229, x208, 0x48b0a77a); + var x230: u32 = undefined; + var x231: u32 = undefined; + mulxU32(&x230, &x231, x208, 0xecec196a); + var x232: u32 = undefined; + var x233: u32 = undefined; + mulxU32(&x232, &x233, x208, 0xccc52973); + var x234: u32 = undefined; + var x235: u1 = undefined; + addcarryxU32(&x234, &x235, 0x0, x233, x230); + var x236: u32 = undefined; + var x237: u1 = undefined; + addcarryxU32(&x236, &x237, x235, x231, x228); + var x238: u32 = undefined; + var x239: u1 = undefined; + addcarryxU32(&x238, &x239, x237, x229, x226); + var x240: u32 = undefined; + var x241: u1 = undefined; + addcarryxU32(&x240, &x241, x239, x227, x224); + var x242: u32 = undefined; + var x243: u1 = undefined; + addcarryxU32(&x242, &x243, x241, x225, x222); + var x244: u32 = undefined; + var x245: u1 = undefined; + addcarryxU32(&x244, &x245, x243, x223, x220); + var x246: u32 = undefined; + var x247: u1 = undefined; + addcarryxU32(&x246, &x247, x245, x221, x218); + var x248: u32 = undefined; + var x249: u1 = undefined; + addcarryxU32(&x248, &x249, x247, x219, x216); + var x250: u32 = undefined; + var x251: u1 = undefined; + addcarryxU32(&x250, &x251, x249, x217, x214); + var x252: u32 = undefined; + var x253: u1 = undefined; + addcarryxU32(&x252, &x253, x251, x215, x212); + var x254: u32 = undefined; + var x255: u1 = undefined; + addcarryxU32(&x254, &x255, x253, x213, x210); + const x256 = (cast(u32, x255) + x211); + var x257: u32 = undefined; + var x258: u1 = undefined; + addcarryxU32(&x257, &x258, 0x0, x182, x232); + var x259: u32 = undefined; + var x260: u1 = undefined; + addcarryxU32(&x259, &x260, x258, x184, x234); + var x261: u32 = undefined; + var x262: u1 = undefined; + addcarryxU32(&x261, &x262, x260, x186, x236); + var x263: u32 = undefined; + var x264: u1 = undefined; + addcarryxU32(&x263, &x264, x262, x188, x238); + var x265: u32 = undefined; + var x266: u1 = undefined; + addcarryxU32(&x265, &x266, x264, x190, x240); + var x267: u32 = undefined; + var x268: u1 = undefined; + addcarryxU32(&x267, &x268, x266, x192, x242); + var x269: u32 = undefined; + var x270: u1 = undefined; + addcarryxU32(&x269, &x270, x268, x194, x244); + var x271: u32 = undefined; + var x272: u1 = undefined; + addcarryxU32(&x271, &x272, x270, x196, x246); + var x273: u32 = undefined; + var x274: u1 = undefined; + addcarryxU32(&x273, &x274, x272, x198, x248); + var x275: u32 = undefined; + var x276: u1 = undefined; + addcarryxU32(&x275, &x276, x274, x200, x250); + var x277: u32 = undefined; + var x278: u1 = undefined; + addcarryxU32(&x277, &x278, x276, x202, x252); + var x279: u32 = undefined; + var x280: u1 = undefined; + addcarryxU32(&x279, &x280, x278, x204, x254); + var x281: u32 = undefined; + var x282: u1 = undefined; + addcarryxU32(&x281, &x282, x280, x206, x256); + const x283 = (cast(u32, x282) + cast(u32, x207)); + var x284: u32 = undefined; + var x285: u32 = undefined; + mulxU32(&x284, &x285, x2, (arg2[11])); + var x286: u32 = undefined; + var x287: u32 = undefined; + mulxU32(&x286, &x287, x2, (arg2[10])); + var x288: u32 = undefined; + var x289: u32 = undefined; + mulxU32(&x288, &x289, x2, (arg2[9])); + var x290: u32 = undefined; + var x291: u32 = undefined; + mulxU32(&x290, &x291, x2, (arg2[8])); + var x292: u32 = undefined; + var x293: u32 = undefined; + mulxU32(&x292, &x293, x2, (arg2[7])); + var x294: u32 = undefined; + var x295: u32 = undefined; + mulxU32(&x294, &x295, x2, (arg2[6])); + var x296: u32 = undefined; + var x297: u32 = undefined; + mulxU32(&x296, &x297, x2, (arg2[5])); + var x298: u32 = undefined; + var x299: u32 = undefined; + mulxU32(&x298, &x299, x2, (arg2[4])); + var x300: u32 = undefined; + var x301: u32 = undefined; + mulxU32(&x300, &x301, x2, (arg2[3])); + var x302: u32 = undefined; + var x303: u32 = undefined; + mulxU32(&x302, &x303, x2, (arg2[2])); + var x304: u32 = undefined; + var x305: u32 = undefined; + mulxU32(&x304, &x305, x2, (arg2[1])); + var x306: u32 = undefined; + var x307: u32 = undefined; + mulxU32(&x306, &x307, x2, (arg2[0])); + var x308: u32 = undefined; + var x309: u1 = undefined; + addcarryxU32(&x308, &x309, 0x0, x307, x304); + var x310: u32 = undefined; + var x311: u1 = undefined; + addcarryxU32(&x310, &x311, x309, x305, x302); + var x312: u32 = undefined; + var x313: u1 = undefined; + addcarryxU32(&x312, &x313, x311, x303, x300); + var x314: u32 = undefined; + var x315: u1 = undefined; + addcarryxU32(&x314, &x315, x313, x301, x298); + var x316: u32 = undefined; + var x317: u1 = undefined; + addcarryxU32(&x316, &x317, x315, x299, x296); + var x318: u32 = undefined; + var x319: u1 = undefined; + addcarryxU32(&x318, &x319, x317, x297, x294); + var x320: u32 = undefined; + var x321: u1 = undefined; + addcarryxU32(&x320, &x321, x319, x295, x292); + var x322: u32 = undefined; + var x323: u1 = undefined; + addcarryxU32(&x322, &x323, x321, x293, x290); + var x324: u32 = undefined; + var x325: u1 = undefined; + addcarryxU32(&x324, &x325, x323, x291, x288); + var x326: u32 = undefined; + var x327: u1 = undefined; + addcarryxU32(&x326, &x327, x325, x289, x286); + var x328: u32 = undefined; + var x329: u1 = undefined; + addcarryxU32(&x328, &x329, x327, x287, x284); + const x330 = (cast(u32, x329) + x285); + var x331: u32 = undefined; + var x332: u1 = undefined; + addcarryxU32(&x331, &x332, 0x0, x259, x306); + var x333: u32 = undefined; + var x334: u1 = undefined; + addcarryxU32(&x333, &x334, x332, x261, x308); + var x335: u32 = undefined; + var x336: u1 = undefined; + addcarryxU32(&x335, &x336, x334, x263, x310); + var x337: u32 = undefined; + var x338: u1 = undefined; + addcarryxU32(&x337, &x338, x336, x265, x312); + var x339: u32 = undefined; + var x340: u1 = undefined; + addcarryxU32(&x339, &x340, x338, x267, x314); + var x341: u32 = undefined; + var x342: u1 = undefined; + addcarryxU32(&x341, &x342, x340, x269, x316); + var x343: u32 = undefined; + var x344: u1 = undefined; + addcarryxU32(&x343, &x344, x342, x271, x318); + var x345: u32 = undefined; + var x346: u1 = undefined; + addcarryxU32(&x345, &x346, x344, x273, x320); + var x347: u32 = undefined; + var x348: u1 = undefined; + addcarryxU32(&x347, &x348, x346, x275, x322); + var x349: u32 = undefined; + var x350: u1 = undefined; + addcarryxU32(&x349, &x350, x348, x277, x324); + var x351: u32 = undefined; + var x352: u1 = undefined; + addcarryxU32(&x351, &x352, x350, x279, x326); + var x353: u32 = undefined; + var x354: u1 = undefined; + addcarryxU32(&x353, &x354, x352, x281, x328); + var x355: u32 = undefined; + var x356: u1 = undefined; + addcarryxU32(&x355, &x356, x354, x283, x330); + var x357: u32 = undefined; + var x358: u32 = undefined; + mulxU32(&x357, &x358, x331, 0xe88fdc45); + var x359: u32 = undefined; + var x360: u32 = undefined; + mulxU32(&x359, &x360, x357, 0xffffffff); + var x361: u32 = undefined; + var x362: u32 = undefined; + mulxU32(&x361, &x362, x357, 0xffffffff); + var x363: u32 = undefined; + var x364: u32 = undefined; + mulxU32(&x363, &x364, x357, 0xffffffff); + var x365: u32 = undefined; + var x366: u32 = undefined; + mulxU32(&x365, &x366, x357, 0xffffffff); + var x367: u32 = undefined; + var x368: u32 = undefined; + mulxU32(&x367, &x368, x357, 0xffffffff); + var x369: u32 = undefined; + var x370: u32 = undefined; + mulxU32(&x369, &x370, x357, 0xffffffff); + var x371: u32 = undefined; + var x372: u32 = undefined; + mulxU32(&x371, &x372, x357, 0xc7634d81); + var x373: u32 = undefined; + var x374: u32 = undefined; + mulxU32(&x373, &x374, x357, 0xf4372ddf); + var x375: u32 = undefined; + var x376: u32 = undefined; + mulxU32(&x375, &x376, x357, 0x581a0db2); + var x377: u32 = undefined; + var x378: u32 = undefined; + mulxU32(&x377, &x378, x357, 0x48b0a77a); + var x379: u32 = undefined; + var x380: u32 = undefined; + mulxU32(&x379, &x380, x357, 0xecec196a); + var x381: u32 = undefined; + var x382: u32 = undefined; + mulxU32(&x381, &x382, x357, 0xccc52973); + var x383: u32 = undefined; + var x384: u1 = undefined; + addcarryxU32(&x383, &x384, 0x0, x382, x379); + var x385: u32 = undefined; + var x386: u1 = undefined; + addcarryxU32(&x385, &x386, x384, x380, x377); + var x387: u32 = undefined; + var x388: u1 = undefined; + addcarryxU32(&x387, &x388, x386, x378, x375); + var x389: u32 = undefined; + var x390: u1 = undefined; + addcarryxU32(&x389, &x390, x388, x376, x373); + var x391: u32 = undefined; + var x392: u1 = undefined; + addcarryxU32(&x391, &x392, x390, x374, x371); + var x393: u32 = undefined; + var x394: u1 = undefined; + addcarryxU32(&x393, &x394, x392, x372, x369); + var x395: u32 = undefined; + var x396: u1 = undefined; + addcarryxU32(&x395, &x396, x394, x370, x367); + var x397: u32 = undefined; + var x398: u1 = undefined; + addcarryxU32(&x397, &x398, x396, x368, x365); + var x399: u32 = undefined; + var x400: u1 = undefined; + addcarryxU32(&x399, &x400, x398, x366, x363); + var x401: u32 = undefined; + var x402: u1 = undefined; + addcarryxU32(&x401, &x402, x400, x364, x361); + var x403: u32 = undefined; + var x404: u1 = undefined; + addcarryxU32(&x403, &x404, x402, x362, x359); + const x405 = (cast(u32, x404) + x360); + var x406: u32 = undefined; + var x407: u1 = undefined; + addcarryxU32(&x406, &x407, 0x0, x331, x381); + var x408: u32 = undefined; + var x409: u1 = undefined; + addcarryxU32(&x408, &x409, x407, x333, x383); + var x410: u32 = undefined; + var x411: u1 = undefined; + addcarryxU32(&x410, &x411, x409, x335, x385); + var x412: u32 = undefined; + var x413: u1 = undefined; + addcarryxU32(&x412, &x413, x411, x337, x387); + var x414: u32 = undefined; + var x415: u1 = undefined; + addcarryxU32(&x414, &x415, x413, x339, x389); + var x416: u32 = undefined; + var x417: u1 = undefined; + addcarryxU32(&x416, &x417, x415, x341, x391); + var x418: u32 = undefined; + var x419: u1 = undefined; + addcarryxU32(&x418, &x419, x417, x343, x393); + var x420: u32 = undefined; + var x421: u1 = undefined; + addcarryxU32(&x420, &x421, x419, x345, x395); + var x422: u32 = undefined; + var x423: u1 = undefined; + addcarryxU32(&x422, &x423, x421, x347, x397); + var x424: u32 = undefined; + var x425: u1 = undefined; + addcarryxU32(&x424, &x425, x423, x349, x399); + var x426: u32 = undefined; + var x427: u1 = undefined; + addcarryxU32(&x426, &x427, x425, x351, x401); + var x428: u32 = undefined; + var x429: u1 = undefined; + addcarryxU32(&x428, &x429, x427, x353, x403); + var x430: u32 = undefined; + var x431: u1 = undefined; + addcarryxU32(&x430, &x431, x429, x355, x405); + const x432 = (cast(u32, x431) + cast(u32, x356)); + var x433: u32 = undefined; + var x434: u32 = undefined; + mulxU32(&x433, &x434, x3, (arg2[11])); + var x435: u32 = undefined; + var x436: u32 = undefined; + mulxU32(&x435, &x436, x3, (arg2[10])); + var x437: u32 = undefined; + var x438: u32 = undefined; + mulxU32(&x437, &x438, x3, (arg2[9])); + var x439: u32 = undefined; + var x440: u32 = undefined; + mulxU32(&x439, &x440, x3, (arg2[8])); + var x441: u32 = undefined; + var x442: u32 = undefined; + mulxU32(&x441, &x442, x3, (arg2[7])); + var x443: u32 = undefined; + var x444: u32 = undefined; + mulxU32(&x443, &x444, x3, (arg2[6])); + var x445: u32 = undefined; + var x446: u32 = undefined; + mulxU32(&x445, &x446, x3, (arg2[5])); + var x447: u32 = undefined; + var x448: u32 = undefined; + mulxU32(&x447, &x448, x3, (arg2[4])); + var x449: u32 = undefined; + var x450: u32 = undefined; + mulxU32(&x449, &x450, x3, (arg2[3])); + var x451: u32 = undefined; + var x452: u32 = undefined; + mulxU32(&x451, &x452, x3, (arg2[2])); + var x453: u32 = undefined; + var x454: u32 = undefined; + mulxU32(&x453, &x454, x3, (arg2[1])); + var x455: u32 = undefined; + var x456: u32 = undefined; + mulxU32(&x455, &x456, x3, (arg2[0])); + var x457: u32 = undefined; + var x458: u1 = undefined; + addcarryxU32(&x457, &x458, 0x0, x456, x453); + var x459: u32 = undefined; + var x460: u1 = undefined; + addcarryxU32(&x459, &x460, x458, x454, x451); + var x461: u32 = undefined; + var x462: u1 = undefined; + addcarryxU32(&x461, &x462, x460, x452, x449); + var x463: u32 = undefined; + var x464: u1 = undefined; + addcarryxU32(&x463, &x464, x462, x450, x447); + var x465: u32 = undefined; + var x466: u1 = undefined; + addcarryxU32(&x465, &x466, x464, x448, x445); + var x467: u32 = undefined; + var x468: u1 = undefined; + addcarryxU32(&x467, &x468, x466, x446, x443); + var x469: u32 = undefined; + var x470: u1 = undefined; + addcarryxU32(&x469, &x470, x468, x444, x441); + var x471: u32 = undefined; + var x472: u1 = undefined; + addcarryxU32(&x471, &x472, x470, x442, x439); + var x473: u32 = undefined; + var x474: u1 = undefined; + addcarryxU32(&x473, &x474, x472, x440, x437); + var x475: u32 = undefined; + var x476: u1 = undefined; + addcarryxU32(&x475, &x476, x474, x438, x435); + var x477: u32 = undefined; + var x478: u1 = undefined; + addcarryxU32(&x477, &x478, x476, x436, x433); + const x479 = (cast(u32, x478) + x434); + var x480: u32 = undefined; + var x481: u1 = undefined; + addcarryxU32(&x480, &x481, 0x0, x408, x455); + var x482: u32 = undefined; + var x483: u1 = undefined; + addcarryxU32(&x482, &x483, x481, x410, x457); + var x484: u32 = undefined; + var x485: u1 = undefined; + addcarryxU32(&x484, &x485, x483, x412, x459); + var x486: u32 = undefined; + var x487: u1 = undefined; + addcarryxU32(&x486, &x487, x485, x414, x461); + var x488: u32 = undefined; + var x489: u1 = undefined; + addcarryxU32(&x488, &x489, x487, x416, x463); + var x490: u32 = undefined; + var x491: u1 = undefined; + addcarryxU32(&x490, &x491, x489, x418, x465); + var x492: u32 = undefined; + var x493: u1 = undefined; + addcarryxU32(&x492, &x493, x491, x420, x467); + var x494: u32 = undefined; + var x495: u1 = undefined; + addcarryxU32(&x494, &x495, x493, x422, x469); + var x496: u32 = undefined; + var x497: u1 = undefined; + addcarryxU32(&x496, &x497, x495, x424, x471); + var x498: u32 = undefined; + var x499: u1 = undefined; + addcarryxU32(&x498, &x499, x497, x426, x473); + var x500: u32 = undefined; + var x501: u1 = undefined; + addcarryxU32(&x500, &x501, x499, x428, x475); + var x502: u32 = undefined; + var x503: u1 = undefined; + addcarryxU32(&x502, &x503, x501, x430, x477); + var x504: u32 = undefined; + var x505: u1 = undefined; + addcarryxU32(&x504, &x505, x503, x432, x479); + var x506: u32 = undefined; + var x507: u32 = undefined; + mulxU32(&x506, &x507, x480, 0xe88fdc45); + var x508: u32 = undefined; + var x509: u32 = undefined; + mulxU32(&x508, &x509, x506, 0xffffffff); + var x510: u32 = undefined; + var x511: u32 = undefined; + mulxU32(&x510, &x511, x506, 0xffffffff); + var x512: u32 = undefined; + var x513: u32 = undefined; + mulxU32(&x512, &x513, x506, 0xffffffff); + var x514: u32 = undefined; + var x515: u32 = undefined; + mulxU32(&x514, &x515, x506, 0xffffffff); + var x516: u32 = undefined; + var x517: u32 = undefined; + mulxU32(&x516, &x517, x506, 0xffffffff); + var x518: u32 = undefined; + var x519: u32 = undefined; + mulxU32(&x518, &x519, x506, 0xffffffff); + var x520: u32 = undefined; + var x521: u32 = undefined; + mulxU32(&x520, &x521, x506, 0xc7634d81); + var x522: u32 = undefined; + var x523: u32 = undefined; + mulxU32(&x522, &x523, x506, 0xf4372ddf); + var x524: u32 = undefined; + var x525: u32 = undefined; + mulxU32(&x524, &x525, x506, 0x581a0db2); + var x526: u32 = undefined; + var x527: u32 = undefined; + mulxU32(&x526, &x527, x506, 0x48b0a77a); + var x528: u32 = undefined; + var x529: u32 = undefined; + mulxU32(&x528, &x529, x506, 0xecec196a); + var x530: u32 = undefined; + var x531: u32 = undefined; + mulxU32(&x530, &x531, x506, 0xccc52973); + var x532: u32 = undefined; + var x533: u1 = undefined; + addcarryxU32(&x532, &x533, 0x0, x531, x528); + var x534: u32 = undefined; + var x535: u1 = undefined; + addcarryxU32(&x534, &x535, x533, x529, x526); + var x536: u32 = undefined; + var x537: u1 = undefined; + addcarryxU32(&x536, &x537, x535, x527, x524); + var x538: u32 = undefined; + var x539: u1 = undefined; + addcarryxU32(&x538, &x539, x537, x525, x522); + var x540: u32 = undefined; + var x541: u1 = undefined; + addcarryxU32(&x540, &x541, x539, x523, x520); + var x542: u32 = undefined; + var x543: u1 = undefined; + addcarryxU32(&x542, &x543, x541, x521, x518); + var x544: u32 = undefined; + var x545: u1 = undefined; + addcarryxU32(&x544, &x545, x543, x519, x516); + var x546: u32 = undefined; + var x547: u1 = undefined; + addcarryxU32(&x546, &x547, x545, x517, x514); + var x548: u32 = undefined; + var x549: u1 = undefined; + addcarryxU32(&x548, &x549, x547, x515, x512); + var x550: u32 = undefined; + var x551: u1 = undefined; + addcarryxU32(&x550, &x551, x549, x513, x510); + var x552: u32 = undefined; + var x553: u1 = undefined; + addcarryxU32(&x552, &x553, x551, x511, x508); + const x554 = (cast(u32, x553) + x509); + var x555: u32 = undefined; + var x556: u1 = undefined; + addcarryxU32(&x555, &x556, 0x0, x480, x530); + var x557: u32 = undefined; + var x558: u1 = undefined; + addcarryxU32(&x557, &x558, x556, x482, x532); + var x559: u32 = undefined; + var x560: u1 = undefined; + addcarryxU32(&x559, &x560, x558, x484, x534); + var x561: u32 = undefined; + var x562: u1 = undefined; + addcarryxU32(&x561, &x562, x560, x486, x536); + var x563: u32 = undefined; + var x564: u1 = undefined; + addcarryxU32(&x563, &x564, x562, x488, x538); + var x565: u32 = undefined; + var x566: u1 = undefined; + addcarryxU32(&x565, &x566, x564, x490, x540); + var x567: u32 = undefined; + var x568: u1 = undefined; + addcarryxU32(&x567, &x568, x566, x492, x542); + var x569: u32 = undefined; + var x570: u1 = undefined; + addcarryxU32(&x569, &x570, x568, x494, x544); + var x571: u32 = undefined; + var x572: u1 = undefined; + addcarryxU32(&x571, &x572, x570, x496, x546); + var x573: u32 = undefined; + var x574: u1 = undefined; + addcarryxU32(&x573, &x574, x572, x498, x548); + var x575: u32 = undefined; + var x576: u1 = undefined; + addcarryxU32(&x575, &x576, x574, x500, x550); + var x577: u32 = undefined; + var x578: u1 = undefined; + addcarryxU32(&x577, &x578, x576, x502, x552); + var x579: u32 = undefined; + var x580: u1 = undefined; + addcarryxU32(&x579, &x580, x578, x504, x554); + const x581 = (cast(u32, x580) + cast(u32, x505)); + var x582: u32 = undefined; + var x583: u32 = undefined; + mulxU32(&x582, &x583, x4, (arg2[11])); + var x584: u32 = undefined; + var x585: u32 = undefined; + mulxU32(&x584, &x585, x4, (arg2[10])); + var x586: u32 = undefined; + var x587: u32 = undefined; + mulxU32(&x586, &x587, x4, (arg2[9])); + var x588: u32 = undefined; + var x589: u32 = undefined; + mulxU32(&x588, &x589, x4, (arg2[8])); + var x590: u32 = undefined; + var x591: u32 = undefined; + mulxU32(&x590, &x591, x4, (arg2[7])); + var x592: u32 = undefined; + var x593: u32 = undefined; + mulxU32(&x592, &x593, x4, (arg2[6])); + var x594: u32 = undefined; + var x595: u32 = undefined; + mulxU32(&x594, &x595, x4, (arg2[5])); + var x596: u32 = undefined; + var x597: u32 = undefined; + mulxU32(&x596, &x597, x4, (arg2[4])); + var x598: u32 = undefined; + var x599: u32 = undefined; + mulxU32(&x598, &x599, x4, (arg2[3])); + var x600: u32 = undefined; + var x601: u32 = undefined; + mulxU32(&x600, &x601, x4, (arg2[2])); + var x602: u32 = undefined; + var x603: u32 = undefined; + mulxU32(&x602, &x603, x4, (arg2[1])); + var x604: u32 = undefined; + var x605: u32 = undefined; + mulxU32(&x604, &x605, x4, (arg2[0])); + var x606: u32 = undefined; + var x607: u1 = undefined; + addcarryxU32(&x606, &x607, 0x0, x605, x602); + var x608: u32 = undefined; + var x609: u1 = undefined; + addcarryxU32(&x608, &x609, x607, x603, x600); + var x610: u32 = undefined; + var x611: u1 = undefined; + addcarryxU32(&x610, &x611, x609, x601, x598); + var x612: u32 = undefined; + var x613: u1 = undefined; + addcarryxU32(&x612, &x613, x611, x599, x596); + var x614: u32 = undefined; + var x615: u1 = undefined; + addcarryxU32(&x614, &x615, x613, x597, x594); + var x616: u32 = undefined; + var x617: u1 = undefined; + addcarryxU32(&x616, &x617, x615, x595, x592); + var x618: u32 = undefined; + var x619: u1 = undefined; + addcarryxU32(&x618, &x619, x617, x593, x590); + var x620: u32 = undefined; + var x621: u1 = undefined; + addcarryxU32(&x620, &x621, x619, x591, x588); + var x622: u32 = undefined; + var x623: u1 = undefined; + addcarryxU32(&x622, &x623, x621, x589, x586); + var x624: u32 = undefined; + var x625: u1 = undefined; + addcarryxU32(&x624, &x625, x623, x587, x584); + var x626: u32 = undefined; + var x627: u1 = undefined; + addcarryxU32(&x626, &x627, x625, x585, x582); + const x628 = (cast(u32, x627) + x583); + var x629: u32 = undefined; + var x630: u1 = undefined; + addcarryxU32(&x629, &x630, 0x0, x557, x604); + var x631: u32 = undefined; + var x632: u1 = undefined; + addcarryxU32(&x631, &x632, x630, x559, x606); + var x633: u32 = undefined; + var x634: u1 = undefined; + addcarryxU32(&x633, &x634, x632, x561, x608); + var x635: u32 = undefined; + var x636: u1 = undefined; + addcarryxU32(&x635, &x636, x634, x563, x610); + var x637: u32 = undefined; + var x638: u1 = undefined; + addcarryxU32(&x637, &x638, x636, x565, x612); + var x639: u32 = undefined; + var x640: u1 = undefined; + addcarryxU32(&x639, &x640, x638, x567, x614); + var x641: u32 = undefined; + var x642: u1 = undefined; + addcarryxU32(&x641, &x642, x640, x569, x616); + var x643: u32 = undefined; + var x644: u1 = undefined; + addcarryxU32(&x643, &x644, x642, x571, x618); + var x645: u32 = undefined; + var x646: u1 = undefined; + addcarryxU32(&x645, &x646, x644, x573, x620); + var x647: u32 = undefined; + var x648: u1 = undefined; + addcarryxU32(&x647, &x648, x646, x575, x622); + var x649: u32 = undefined; + var x650: u1 = undefined; + addcarryxU32(&x649, &x650, x648, x577, x624); + var x651: u32 = undefined; + var x652: u1 = undefined; + addcarryxU32(&x651, &x652, x650, x579, x626); + var x653: u32 = undefined; + var x654: u1 = undefined; + addcarryxU32(&x653, &x654, x652, x581, x628); + var x655: u32 = undefined; + var x656: u32 = undefined; + mulxU32(&x655, &x656, x629, 0xe88fdc45); + var x657: u32 = undefined; + var x658: u32 = undefined; + mulxU32(&x657, &x658, x655, 0xffffffff); + var x659: u32 = undefined; + var x660: u32 = undefined; + mulxU32(&x659, &x660, x655, 0xffffffff); + var x661: u32 = undefined; + var x662: u32 = undefined; + mulxU32(&x661, &x662, x655, 0xffffffff); + var x663: u32 = undefined; + var x664: u32 = undefined; + mulxU32(&x663, &x664, x655, 0xffffffff); + var x665: u32 = undefined; + var x666: u32 = undefined; + mulxU32(&x665, &x666, x655, 0xffffffff); + var x667: u32 = undefined; + var x668: u32 = undefined; + mulxU32(&x667, &x668, x655, 0xffffffff); + var x669: u32 = undefined; + var x670: u32 = undefined; + mulxU32(&x669, &x670, x655, 0xc7634d81); + var x671: u32 = undefined; + var x672: u32 = undefined; + mulxU32(&x671, &x672, x655, 0xf4372ddf); + var x673: u32 = undefined; + var x674: u32 = undefined; + mulxU32(&x673, &x674, x655, 0x581a0db2); + var x675: u32 = undefined; + var x676: u32 = undefined; + mulxU32(&x675, &x676, x655, 0x48b0a77a); + var x677: u32 = undefined; + var x678: u32 = undefined; + mulxU32(&x677, &x678, x655, 0xecec196a); + var x679: u32 = undefined; + var x680: u32 = undefined; + mulxU32(&x679, &x680, x655, 0xccc52973); + var x681: u32 = undefined; + var x682: u1 = undefined; + addcarryxU32(&x681, &x682, 0x0, x680, x677); + var x683: u32 = undefined; + var x684: u1 = undefined; + addcarryxU32(&x683, &x684, x682, x678, x675); + var x685: u32 = undefined; + var x686: u1 = undefined; + addcarryxU32(&x685, &x686, x684, x676, x673); + var x687: u32 = undefined; + var x688: u1 = undefined; + addcarryxU32(&x687, &x688, x686, x674, x671); + var x689: u32 = undefined; + var x690: u1 = undefined; + addcarryxU32(&x689, &x690, x688, x672, x669); + var x691: u32 = undefined; + var x692: u1 = undefined; + addcarryxU32(&x691, &x692, x690, x670, x667); + var x693: u32 = undefined; + var x694: u1 = undefined; + addcarryxU32(&x693, &x694, x692, x668, x665); + var x695: u32 = undefined; + var x696: u1 = undefined; + addcarryxU32(&x695, &x696, x694, x666, x663); + var x697: u32 = undefined; + var x698: u1 = undefined; + addcarryxU32(&x697, &x698, x696, x664, x661); + var x699: u32 = undefined; + var x700: u1 = undefined; + addcarryxU32(&x699, &x700, x698, x662, x659); + var x701: u32 = undefined; + var x702: u1 = undefined; + addcarryxU32(&x701, &x702, x700, x660, x657); + const x703 = (cast(u32, x702) + x658); + var x704: u32 = undefined; + var x705: u1 = undefined; + addcarryxU32(&x704, &x705, 0x0, x629, x679); + var x706: u32 = undefined; + var x707: u1 = undefined; + addcarryxU32(&x706, &x707, x705, x631, x681); + var x708: u32 = undefined; + var x709: u1 = undefined; + addcarryxU32(&x708, &x709, x707, x633, x683); + var x710: u32 = undefined; + var x711: u1 = undefined; + addcarryxU32(&x710, &x711, x709, x635, x685); + var x712: u32 = undefined; + var x713: u1 = undefined; + addcarryxU32(&x712, &x713, x711, x637, x687); + var x714: u32 = undefined; + var x715: u1 = undefined; + addcarryxU32(&x714, &x715, x713, x639, x689); + var x716: u32 = undefined; + var x717: u1 = undefined; + addcarryxU32(&x716, &x717, x715, x641, x691); + var x718: u32 = undefined; + var x719: u1 = undefined; + addcarryxU32(&x718, &x719, x717, x643, x693); + var x720: u32 = undefined; + var x721: u1 = undefined; + addcarryxU32(&x720, &x721, x719, x645, x695); + var x722: u32 = undefined; + var x723: u1 = undefined; + addcarryxU32(&x722, &x723, x721, x647, x697); + var x724: u32 = undefined; + var x725: u1 = undefined; + addcarryxU32(&x724, &x725, x723, x649, x699); + var x726: u32 = undefined; + var x727: u1 = undefined; + addcarryxU32(&x726, &x727, x725, x651, x701); + var x728: u32 = undefined; + var x729: u1 = undefined; + addcarryxU32(&x728, &x729, x727, x653, x703); + const x730 = (cast(u32, x729) + cast(u32, x654)); + var x731: u32 = undefined; + var x732: u32 = undefined; + mulxU32(&x731, &x732, x5, (arg2[11])); + var x733: u32 = undefined; + var x734: u32 = undefined; + mulxU32(&x733, &x734, x5, (arg2[10])); + var x735: u32 = undefined; + var x736: u32 = undefined; + mulxU32(&x735, &x736, x5, (arg2[9])); + var x737: u32 = undefined; + var x738: u32 = undefined; + mulxU32(&x737, &x738, x5, (arg2[8])); + var x739: u32 = undefined; + var x740: u32 = undefined; + mulxU32(&x739, &x740, x5, (arg2[7])); + var x741: u32 = undefined; + var x742: u32 = undefined; + mulxU32(&x741, &x742, x5, (arg2[6])); + var x743: u32 = undefined; + var x744: u32 = undefined; + mulxU32(&x743, &x744, x5, (arg2[5])); + var x745: u32 = undefined; + var x746: u32 = undefined; + mulxU32(&x745, &x746, x5, (arg2[4])); + var x747: u32 = undefined; + var x748: u32 = undefined; + mulxU32(&x747, &x748, x5, (arg2[3])); + var x749: u32 = undefined; + var x750: u32 = undefined; + mulxU32(&x749, &x750, x5, (arg2[2])); + var x751: u32 = undefined; + var x752: u32 = undefined; + mulxU32(&x751, &x752, x5, (arg2[1])); + var x753: u32 = undefined; + var x754: u32 = undefined; + mulxU32(&x753, &x754, x5, (arg2[0])); + var x755: u32 = undefined; + var x756: u1 = undefined; + addcarryxU32(&x755, &x756, 0x0, x754, x751); + var x757: u32 = undefined; + var x758: u1 = undefined; + addcarryxU32(&x757, &x758, x756, x752, x749); + var x759: u32 = undefined; + var x760: u1 = undefined; + addcarryxU32(&x759, &x760, x758, x750, x747); + var x761: u32 = undefined; + var x762: u1 = undefined; + addcarryxU32(&x761, &x762, x760, x748, x745); + var x763: u32 = undefined; + var x764: u1 = undefined; + addcarryxU32(&x763, &x764, x762, x746, x743); + var x765: u32 = undefined; + var x766: u1 = undefined; + addcarryxU32(&x765, &x766, x764, x744, x741); + var x767: u32 = undefined; + var x768: u1 = undefined; + addcarryxU32(&x767, &x768, x766, x742, x739); + var x769: u32 = undefined; + var x770: u1 = undefined; + addcarryxU32(&x769, &x770, x768, x740, x737); + var x771: u32 = undefined; + var x772: u1 = undefined; + addcarryxU32(&x771, &x772, x770, x738, x735); + var x773: u32 = undefined; + var x774: u1 = undefined; + addcarryxU32(&x773, &x774, x772, x736, x733); + var x775: u32 = undefined; + var x776: u1 = undefined; + addcarryxU32(&x775, &x776, x774, x734, x731); + const x777 = (cast(u32, x776) + x732); + var x778: u32 = undefined; + var x779: u1 = undefined; + addcarryxU32(&x778, &x779, 0x0, x706, x753); + var x780: u32 = undefined; + var x781: u1 = undefined; + addcarryxU32(&x780, &x781, x779, x708, x755); + var x782: u32 = undefined; + var x783: u1 = undefined; + addcarryxU32(&x782, &x783, x781, x710, x757); + var x784: u32 = undefined; + var x785: u1 = undefined; + addcarryxU32(&x784, &x785, x783, x712, x759); + var x786: u32 = undefined; + var x787: u1 = undefined; + addcarryxU32(&x786, &x787, x785, x714, x761); + var x788: u32 = undefined; + var x789: u1 = undefined; + addcarryxU32(&x788, &x789, x787, x716, x763); + var x790: u32 = undefined; + var x791: u1 = undefined; + addcarryxU32(&x790, &x791, x789, x718, x765); + var x792: u32 = undefined; + var x793: u1 = undefined; + addcarryxU32(&x792, &x793, x791, x720, x767); + var x794: u32 = undefined; + var x795: u1 = undefined; + addcarryxU32(&x794, &x795, x793, x722, x769); + var x796: u32 = undefined; + var x797: u1 = undefined; + addcarryxU32(&x796, &x797, x795, x724, x771); + var x798: u32 = undefined; + var x799: u1 = undefined; + addcarryxU32(&x798, &x799, x797, x726, x773); + var x800: u32 = undefined; + var x801: u1 = undefined; + addcarryxU32(&x800, &x801, x799, x728, x775); + var x802: u32 = undefined; + var x803: u1 = undefined; + addcarryxU32(&x802, &x803, x801, x730, x777); + var x804: u32 = undefined; + var x805: u32 = undefined; + mulxU32(&x804, &x805, x778, 0xe88fdc45); + var x806: u32 = undefined; + var x807: u32 = undefined; + mulxU32(&x806, &x807, x804, 0xffffffff); + var x808: u32 = undefined; + var x809: u32 = undefined; + mulxU32(&x808, &x809, x804, 0xffffffff); + var x810: u32 = undefined; + var x811: u32 = undefined; + mulxU32(&x810, &x811, x804, 0xffffffff); + var x812: u32 = undefined; + var x813: u32 = undefined; + mulxU32(&x812, &x813, x804, 0xffffffff); + var x814: u32 = undefined; + var x815: u32 = undefined; + mulxU32(&x814, &x815, x804, 0xffffffff); + var x816: u32 = undefined; + var x817: u32 = undefined; + mulxU32(&x816, &x817, x804, 0xffffffff); + var x818: u32 = undefined; + var x819: u32 = undefined; + mulxU32(&x818, &x819, x804, 0xc7634d81); + var x820: u32 = undefined; + var x821: u32 = undefined; + mulxU32(&x820, &x821, x804, 0xf4372ddf); + var x822: u32 = undefined; + var x823: u32 = undefined; + mulxU32(&x822, &x823, x804, 0x581a0db2); + var x824: u32 = undefined; + var x825: u32 = undefined; + mulxU32(&x824, &x825, x804, 0x48b0a77a); + var x826: u32 = undefined; + var x827: u32 = undefined; + mulxU32(&x826, &x827, x804, 0xecec196a); + var x828: u32 = undefined; + var x829: u32 = undefined; + mulxU32(&x828, &x829, x804, 0xccc52973); + var x830: u32 = undefined; + var x831: u1 = undefined; + addcarryxU32(&x830, &x831, 0x0, x829, x826); + var x832: u32 = undefined; + var x833: u1 = undefined; + addcarryxU32(&x832, &x833, x831, x827, x824); + var x834: u32 = undefined; + var x835: u1 = undefined; + addcarryxU32(&x834, &x835, x833, x825, x822); + var x836: u32 = undefined; + var x837: u1 = undefined; + addcarryxU32(&x836, &x837, x835, x823, x820); + var x838: u32 = undefined; + var x839: u1 = undefined; + addcarryxU32(&x838, &x839, x837, x821, x818); + var x840: u32 = undefined; + var x841: u1 = undefined; + addcarryxU32(&x840, &x841, x839, x819, x816); + var x842: u32 = undefined; + var x843: u1 = undefined; + addcarryxU32(&x842, &x843, x841, x817, x814); + var x844: u32 = undefined; + var x845: u1 = undefined; + addcarryxU32(&x844, &x845, x843, x815, x812); + var x846: u32 = undefined; + var x847: u1 = undefined; + addcarryxU32(&x846, &x847, x845, x813, x810); + var x848: u32 = undefined; + var x849: u1 = undefined; + addcarryxU32(&x848, &x849, x847, x811, x808); + var x850: u32 = undefined; + var x851: u1 = undefined; + addcarryxU32(&x850, &x851, x849, x809, x806); + const x852 = (cast(u32, x851) + x807); + var x853: u32 = undefined; + var x854: u1 = undefined; + addcarryxU32(&x853, &x854, 0x0, x778, x828); + var x855: u32 = undefined; + var x856: u1 = undefined; + addcarryxU32(&x855, &x856, x854, x780, x830); + var x857: u32 = undefined; + var x858: u1 = undefined; + addcarryxU32(&x857, &x858, x856, x782, x832); + var x859: u32 = undefined; + var x860: u1 = undefined; + addcarryxU32(&x859, &x860, x858, x784, x834); + var x861: u32 = undefined; + var x862: u1 = undefined; + addcarryxU32(&x861, &x862, x860, x786, x836); + var x863: u32 = undefined; + var x864: u1 = undefined; + addcarryxU32(&x863, &x864, x862, x788, x838); + var x865: u32 = undefined; + var x866: u1 = undefined; + addcarryxU32(&x865, &x866, x864, x790, x840); + var x867: u32 = undefined; + var x868: u1 = undefined; + addcarryxU32(&x867, &x868, x866, x792, x842); + var x869: u32 = undefined; + var x870: u1 = undefined; + addcarryxU32(&x869, &x870, x868, x794, x844); + var x871: u32 = undefined; + var x872: u1 = undefined; + addcarryxU32(&x871, &x872, x870, x796, x846); + var x873: u32 = undefined; + var x874: u1 = undefined; + addcarryxU32(&x873, &x874, x872, x798, x848); + var x875: u32 = undefined; + var x876: u1 = undefined; + addcarryxU32(&x875, &x876, x874, x800, x850); + var x877: u32 = undefined; + var x878: u1 = undefined; + addcarryxU32(&x877, &x878, x876, x802, x852); + const x879 = (cast(u32, x878) + cast(u32, x803)); + var x880: u32 = undefined; + var x881: u32 = undefined; + mulxU32(&x880, &x881, x6, (arg2[11])); + var x882: u32 = undefined; + var x883: u32 = undefined; + mulxU32(&x882, &x883, x6, (arg2[10])); + var x884: u32 = undefined; + var x885: u32 = undefined; + mulxU32(&x884, &x885, x6, (arg2[9])); + var x886: u32 = undefined; + var x887: u32 = undefined; + mulxU32(&x886, &x887, x6, (arg2[8])); + var x888: u32 = undefined; + var x889: u32 = undefined; + mulxU32(&x888, &x889, x6, (arg2[7])); + var x890: u32 = undefined; + var x891: u32 = undefined; + mulxU32(&x890, &x891, x6, (arg2[6])); + var x892: u32 = undefined; + var x893: u32 = undefined; + mulxU32(&x892, &x893, x6, (arg2[5])); + var x894: u32 = undefined; + var x895: u32 = undefined; + mulxU32(&x894, &x895, x6, (arg2[4])); + var x896: u32 = undefined; + var x897: u32 = undefined; + mulxU32(&x896, &x897, x6, (arg2[3])); + var x898: u32 = undefined; + var x899: u32 = undefined; + mulxU32(&x898, &x899, x6, (arg2[2])); + var x900: u32 = undefined; + var x901: u32 = undefined; + mulxU32(&x900, &x901, x6, (arg2[1])); + var x902: u32 = undefined; + var x903: u32 = undefined; + mulxU32(&x902, &x903, x6, (arg2[0])); + var x904: u32 = undefined; + var x905: u1 = undefined; + addcarryxU32(&x904, &x905, 0x0, x903, x900); + var x906: u32 = undefined; + var x907: u1 = undefined; + addcarryxU32(&x906, &x907, x905, x901, x898); + var x908: u32 = undefined; + var x909: u1 = undefined; + addcarryxU32(&x908, &x909, x907, x899, x896); + var x910: u32 = undefined; + var x911: u1 = undefined; + addcarryxU32(&x910, &x911, x909, x897, x894); + var x912: u32 = undefined; + var x913: u1 = undefined; + addcarryxU32(&x912, &x913, x911, x895, x892); + var x914: u32 = undefined; + var x915: u1 = undefined; + addcarryxU32(&x914, &x915, x913, x893, x890); + var x916: u32 = undefined; + var x917: u1 = undefined; + addcarryxU32(&x916, &x917, x915, x891, x888); + var x918: u32 = undefined; + var x919: u1 = undefined; + addcarryxU32(&x918, &x919, x917, x889, x886); + var x920: u32 = undefined; + var x921: u1 = undefined; + addcarryxU32(&x920, &x921, x919, x887, x884); + var x922: u32 = undefined; + var x923: u1 = undefined; + addcarryxU32(&x922, &x923, x921, x885, x882); + var x924: u32 = undefined; + var x925: u1 = undefined; + addcarryxU32(&x924, &x925, x923, x883, x880); + const x926 = (cast(u32, x925) + x881); + var x927: u32 = undefined; + var x928: u1 = undefined; + addcarryxU32(&x927, &x928, 0x0, x855, x902); + var x929: u32 = undefined; + var x930: u1 = undefined; + addcarryxU32(&x929, &x930, x928, x857, x904); + var x931: u32 = undefined; + var x932: u1 = undefined; + addcarryxU32(&x931, &x932, x930, x859, x906); + var x933: u32 = undefined; + var x934: u1 = undefined; + addcarryxU32(&x933, &x934, x932, x861, x908); + var x935: u32 = undefined; + var x936: u1 = undefined; + addcarryxU32(&x935, &x936, x934, x863, x910); + var x937: u32 = undefined; + var x938: u1 = undefined; + addcarryxU32(&x937, &x938, x936, x865, x912); + var x939: u32 = undefined; + var x940: u1 = undefined; + addcarryxU32(&x939, &x940, x938, x867, x914); + var x941: u32 = undefined; + var x942: u1 = undefined; + addcarryxU32(&x941, &x942, x940, x869, x916); + var x943: u32 = undefined; + var x944: u1 = undefined; + addcarryxU32(&x943, &x944, x942, x871, x918); + var x945: u32 = undefined; + var x946: u1 = undefined; + addcarryxU32(&x945, &x946, x944, x873, x920); + var x947: u32 = undefined; + var x948: u1 = undefined; + addcarryxU32(&x947, &x948, x946, x875, x922); + var x949: u32 = undefined; + var x950: u1 = undefined; + addcarryxU32(&x949, &x950, x948, x877, x924); + var x951: u32 = undefined; + var x952: u1 = undefined; + addcarryxU32(&x951, &x952, x950, x879, x926); + var x953: u32 = undefined; + var x954: u32 = undefined; + mulxU32(&x953, &x954, x927, 0xe88fdc45); + var x955: u32 = undefined; + var x956: u32 = undefined; + mulxU32(&x955, &x956, x953, 0xffffffff); + var x957: u32 = undefined; + var x958: u32 = undefined; + mulxU32(&x957, &x958, x953, 0xffffffff); + var x959: u32 = undefined; + var x960: u32 = undefined; + mulxU32(&x959, &x960, x953, 0xffffffff); + var x961: u32 = undefined; + var x962: u32 = undefined; + mulxU32(&x961, &x962, x953, 0xffffffff); + var x963: u32 = undefined; + var x964: u32 = undefined; + mulxU32(&x963, &x964, x953, 0xffffffff); + var x965: u32 = undefined; + var x966: u32 = undefined; + mulxU32(&x965, &x966, x953, 0xffffffff); + var x967: u32 = undefined; + var x968: u32 = undefined; + mulxU32(&x967, &x968, x953, 0xc7634d81); + var x969: u32 = undefined; + var x970: u32 = undefined; + mulxU32(&x969, &x970, x953, 0xf4372ddf); + var x971: u32 = undefined; + var x972: u32 = undefined; + mulxU32(&x971, &x972, x953, 0x581a0db2); + var x973: u32 = undefined; + var x974: u32 = undefined; + mulxU32(&x973, &x974, x953, 0x48b0a77a); + var x975: u32 = undefined; + var x976: u32 = undefined; + mulxU32(&x975, &x976, x953, 0xecec196a); + var x977: u32 = undefined; + var x978: u32 = undefined; + mulxU32(&x977, &x978, x953, 0xccc52973); + var x979: u32 = undefined; + var x980: u1 = undefined; + addcarryxU32(&x979, &x980, 0x0, x978, x975); + var x981: u32 = undefined; + var x982: u1 = undefined; + addcarryxU32(&x981, &x982, x980, x976, x973); + var x983: u32 = undefined; + var x984: u1 = undefined; + addcarryxU32(&x983, &x984, x982, x974, x971); + var x985: u32 = undefined; + var x986: u1 = undefined; + addcarryxU32(&x985, &x986, x984, x972, x969); + var x987: u32 = undefined; + var x988: u1 = undefined; + addcarryxU32(&x987, &x988, x986, x970, x967); + var x989: u32 = undefined; + var x990: u1 = undefined; + addcarryxU32(&x989, &x990, x988, x968, x965); + var x991: u32 = undefined; + var x992: u1 = undefined; + addcarryxU32(&x991, &x992, x990, x966, x963); + var x993: u32 = undefined; + var x994: u1 = undefined; + addcarryxU32(&x993, &x994, x992, x964, x961); + var x995: u32 = undefined; + var x996: u1 = undefined; + addcarryxU32(&x995, &x996, x994, x962, x959); + var x997: u32 = undefined; + var x998: u1 = undefined; + addcarryxU32(&x997, &x998, x996, x960, x957); + var x999: u32 = undefined; + var x1000: u1 = undefined; + addcarryxU32(&x999, &x1000, x998, x958, x955); + const x1001 = (cast(u32, x1000) + x956); + var x1002: u32 = undefined; + var x1003: u1 = undefined; + addcarryxU32(&x1002, &x1003, 0x0, x927, x977); + var x1004: u32 = undefined; + var x1005: u1 = undefined; + addcarryxU32(&x1004, &x1005, x1003, x929, x979); + var x1006: u32 = undefined; + var x1007: u1 = undefined; + addcarryxU32(&x1006, &x1007, x1005, x931, x981); + var x1008: u32 = undefined; + var x1009: u1 = undefined; + addcarryxU32(&x1008, &x1009, x1007, x933, x983); + var x1010: u32 = undefined; + var x1011: u1 = undefined; + addcarryxU32(&x1010, &x1011, x1009, x935, x985); + var x1012: u32 = undefined; + var x1013: u1 = undefined; + addcarryxU32(&x1012, &x1013, x1011, x937, x987); + var x1014: u32 = undefined; + var x1015: u1 = undefined; + addcarryxU32(&x1014, &x1015, x1013, x939, x989); + var x1016: u32 = undefined; + var x1017: u1 = undefined; + addcarryxU32(&x1016, &x1017, x1015, x941, x991); + var x1018: u32 = undefined; + var x1019: u1 = undefined; + addcarryxU32(&x1018, &x1019, x1017, x943, x993); + var x1020: u32 = undefined; + var x1021: u1 = undefined; + addcarryxU32(&x1020, &x1021, x1019, x945, x995); + var x1022: u32 = undefined; + var x1023: u1 = undefined; + addcarryxU32(&x1022, &x1023, x1021, x947, x997); + var x1024: u32 = undefined; + var x1025: u1 = undefined; + addcarryxU32(&x1024, &x1025, x1023, x949, x999); + var x1026: u32 = undefined; + var x1027: u1 = undefined; + addcarryxU32(&x1026, &x1027, x1025, x951, x1001); + const x1028 = (cast(u32, x1027) + cast(u32, x952)); + var x1029: u32 = undefined; + var x1030: u32 = undefined; + mulxU32(&x1029, &x1030, x7, (arg2[11])); + var x1031: u32 = undefined; + var x1032: u32 = undefined; + mulxU32(&x1031, &x1032, x7, (arg2[10])); + var x1033: u32 = undefined; + var x1034: u32 = undefined; + mulxU32(&x1033, &x1034, x7, (arg2[9])); + var x1035: u32 = undefined; + var x1036: u32 = undefined; + mulxU32(&x1035, &x1036, x7, (arg2[8])); + var x1037: u32 = undefined; + var x1038: u32 = undefined; + mulxU32(&x1037, &x1038, x7, (arg2[7])); + var x1039: u32 = undefined; + var x1040: u32 = undefined; + mulxU32(&x1039, &x1040, x7, (arg2[6])); + var x1041: u32 = undefined; + var x1042: u32 = undefined; + mulxU32(&x1041, &x1042, x7, (arg2[5])); + var x1043: u32 = undefined; + var x1044: u32 = undefined; + mulxU32(&x1043, &x1044, x7, (arg2[4])); + var x1045: u32 = undefined; + var x1046: u32 = undefined; + mulxU32(&x1045, &x1046, x7, (arg2[3])); + var x1047: u32 = undefined; + var x1048: u32 = undefined; + mulxU32(&x1047, &x1048, x7, (arg2[2])); + var x1049: u32 = undefined; + var x1050: u32 = undefined; + mulxU32(&x1049, &x1050, x7, (arg2[1])); + var x1051: u32 = undefined; + var x1052: u32 = undefined; + mulxU32(&x1051, &x1052, x7, (arg2[0])); + var x1053: u32 = undefined; + var x1054: u1 = undefined; + addcarryxU32(&x1053, &x1054, 0x0, x1052, x1049); + var x1055: u32 = undefined; + var x1056: u1 = undefined; + addcarryxU32(&x1055, &x1056, x1054, x1050, x1047); + var x1057: u32 = undefined; + var x1058: u1 = undefined; + addcarryxU32(&x1057, &x1058, x1056, x1048, x1045); + var x1059: u32 = undefined; + var x1060: u1 = undefined; + addcarryxU32(&x1059, &x1060, x1058, x1046, x1043); + var x1061: u32 = undefined; + var x1062: u1 = undefined; + addcarryxU32(&x1061, &x1062, x1060, x1044, x1041); + var x1063: u32 = undefined; + var x1064: u1 = undefined; + addcarryxU32(&x1063, &x1064, x1062, x1042, x1039); + var x1065: u32 = undefined; + var x1066: u1 = undefined; + addcarryxU32(&x1065, &x1066, x1064, x1040, x1037); + var x1067: u32 = undefined; + var x1068: u1 = undefined; + addcarryxU32(&x1067, &x1068, x1066, x1038, x1035); + var x1069: u32 = undefined; + var x1070: u1 = undefined; + addcarryxU32(&x1069, &x1070, x1068, x1036, x1033); + var x1071: u32 = undefined; + var x1072: u1 = undefined; + addcarryxU32(&x1071, &x1072, x1070, x1034, x1031); + var x1073: u32 = undefined; + var x1074: u1 = undefined; + addcarryxU32(&x1073, &x1074, x1072, x1032, x1029); + const x1075 = (cast(u32, x1074) + x1030); + var x1076: u32 = undefined; + var x1077: u1 = undefined; + addcarryxU32(&x1076, &x1077, 0x0, x1004, x1051); + var x1078: u32 = undefined; + var x1079: u1 = undefined; + addcarryxU32(&x1078, &x1079, x1077, x1006, x1053); + var x1080: u32 = undefined; + var x1081: u1 = undefined; + addcarryxU32(&x1080, &x1081, x1079, x1008, x1055); + var x1082: u32 = undefined; + var x1083: u1 = undefined; + addcarryxU32(&x1082, &x1083, x1081, x1010, x1057); + var x1084: u32 = undefined; + var x1085: u1 = undefined; + addcarryxU32(&x1084, &x1085, x1083, x1012, x1059); + var x1086: u32 = undefined; + var x1087: u1 = undefined; + addcarryxU32(&x1086, &x1087, x1085, x1014, x1061); + var x1088: u32 = undefined; + var x1089: u1 = undefined; + addcarryxU32(&x1088, &x1089, x1087, x1016, x1063); + var x1090: u32 = undefined; + var x1091: u1 = undefined; + addcarryxU32(&x1090, &x1091, x1089, x1018, x1065); + var x1092: u32 = undefined; + var x1093: u1 = undefined; + addcarryxU32(&x1092, &x1093, x1091, x1020, x1067); + var x1094: u32 = undefined; + var x1095: u1 = undefined; + addcarryxU32(&x1094, &x1095, x1093, x1022, x1069); + var x1096: u32 = undefined; + var x1097: u1 = undefined; + addcarryxU32(&x1096, &x1097, x1095, x1024, x1071); + var x1098: u32 = undefined; + var x1099: u1 = undefined; + addcarryxU32(&x1098, &x1099, x1097, x1026, x1073); + var x1100: u32 = undefined; + var x1101: u1 = undefined; + addcarryxU32(&x1100, &x1101, x1099, x1028, x1075); + var x1102: u32 = undefined; + var x1103: u32 = undefined; + mulxU32(&x1102, &x1103, x1076, 0xe88fdc45); + var x1104: u32 = undefined; + var x1105: u32 = undefined; + mulxU32(&x1104, &x1105, x1102, 0xffffffff); + var x1106: u32 = undefined; + var x1107: u32 = undefined; + mulxU32(&x1106, &x1107, x1102, 0xffffffff); + var x1108: u32 = undefined; + var x1109: u32 = undefined; + mulxU32(&x1108, &x1109, x1102, 0xffffffff); + var x1110: u32 = undefined; + var x1111: u32 = undefined; + mulxU32(&x1110, &x1111, x1102, 0xffffffff); + var x1112: u32 = undefined; + var x1113: u32 = undefined; + mulxU32(&x1112, &x1113, x1102, 0xffffffff); + var x1114: u32 = undefined; + var x1115: u32 = undefined; + mulxU32(&x1114, &x1115, x1102, 0xffffffff); + var x1116: u32 = undefined; + var x1117: u32 = undefined; + mulxU32(&x1116, &x1117, x1102, 0xc7634d81); + var x1118: u32 = undefined; + var x1119: u32 = undefined; + mulxU32(&x1118, &x1119, x1102, 0xf4372ddf); + var x1120: u32 = undefined; + var x1121: u32 = undefined; + mulxU32(&x1120, &x1121, x1102, 0x581a0db2); + var x1122: u32 = undefined; + var x1123: u32 = undefined; + mulxU32(&x1122, &x1123, x1102, 0x48b0a77a); + var x1124: u32 = undefined; + var x1125: u32 = undefined; + mulxU32(&x1124, &x1125, x1102, 0xecec196a); + var x1126: u32 = undefined; + var x1127: u32 = undefined; + mulxU32(&x1126, &x1127, x1102, 0xccc52973); + var x1128: u32 = undefined; + var x1129: u1 = undefined; + addcarryxU32(&x1128, &x1129, 0x0, x1127, x1124); + var x1130: u32 = undefined; + var x1131: u1 = undefined; + addcarryxU32(&x1130, &x1131, x1129, x1125, x1122); + var x1132: u32 = undefined; + var x1133: u1 = undefined; + addcarryxU32(&x1132, &x1133, x1131, x1123, x1120); + var x1134: u32 = undefined; + var x1135: u1 = undefined; + addcarryxU32(&x1134, &x1135, x1133, x1121, x1118); + var x1136: u32 = undefined; + var x1137: u1 = undefined; + addcarryxU32(&x1136, &x1137, x1135, x1119, x1116); + var x1138: u32 = undefined; + var x1139: u1 = undefined; + addcarryxU32(&x1138, &x1139, x1137, x1117, x1114); + var x1140: u32 = undefined; + var x1141: u1 = undefined; + addcarryxU32(&x1140, &x1141, x1139, x1115, x1112); + var x1142: u32 = undefined; + var x1143: u1 = undefined; + addcarryxU32(&x1142, &x1143, x1141, x1113, x1110); + var x1144: u32 = undefined; + var x1145: u1 = undefined; + addcarryxU32(&x1144, &x1145, x1143, x1111, x1108); + var x1146: u32 = undefined; + var x1147: u1 = undefined; + addcarryxU32(&x1146, &x1147, x1145, x1109, x1106); + var x1148: u32 = undefined; + var x1149: u1 = undefined; + addcarryxU32(&x1148, &x1149, x1147, x1107, x1104); + const x1150 = (cast(u32, x1149) + x1105); + var x1151: u32 = undefined; + var x1152: u1 = undefined; + addcarryxU32(&x1151, &x1152, 0x0, x1076, x1126); + var x1153: u32 = undefined; + var x1154: u1 = undefined; + addcarryxU32(&x1153, &x1154, x1152, x1078, x1128); + var x1155: u32 = undefined; + var x1156: u1 = undefined; + addcarryxU32(&x1155, &x1156, x1154, x1080, x1130); + var x1157: u32 = undefined; + var x1158: u1 = undefined; + addcarryxU32(&x1157, &x1158, x1156, x1082, x1132); + var x1159: u32 = undefined; + var x1160: u1 = undefined; + addcarryxU32(&x1159, &x1160, x1158, x1084, x1134); + var x1161: u32 = undefined; + var x1162: u1 = undefined; + addcarryxU32(&x1161, &x1162, x1160, x1086, x1136); + var x1163: u32 = undefined; + var x1164: u1 = undefined; + addcarryxU32(&x1163, &x1164, x1162, x1088, x1138); + var x1165: u32 = undefined; + var x1166: u1 = undefined; + addcarryxU32(&x1165, &x1166, x1164, x1090, x1140); + var x1167: u32 = undefined; + var x1168: u1 = undefined; + addcarryxU32(&x1167, &x1168, x1166, x1092, x1142); + var x1169: u32 = undefined; + var x1170: u1 = undefined; + addcarryxU32(&x1169, &x1170, x1168, x1094, x1144); + var x1171: u32 = undefined; + var x1172: u1 = undefined; + addcarryxU32(&x1171, &x1172, x1170, x1096, x1146); + var x1173: u32 = undefined; + var x1174: u1 = undefined; + addcarryxU32(&x1173, &x1174, x1172, x1098, x1148); + var x1175: u32 = undefined; + var x1176: u1 = undefined; + addcarryxU32(&x1175, &x1176, x1174, x1100, x1150); + const x1177 = (cast(u32, x1176) + cast(u32, x1101)); + var x1178: u32 = undefined; + var x1179: u32 = undefined; + mulxU32(&x1178, &x1179, x8, (arg2[11])); + var x1180: u32 = undefined; + var x1181: u32 = undefined; + mulxU32(&x1180, &x1181, x8, (arg2[10])); + var x1182: u32 = undefined; + var x1183: u32 = undefined; + mulxU32(&x1182, &x1183, x8, (arg2[9])); + var x1184: u32 = undefined; + var x1185: u32 = undefined; + mulxU32(&x1184, &x1185, x8, (arg2[8])); + var x1186: u32 = undefined; + var x1187: u32 = undefined; + mulxU32(&x1186, &x1187, x8, (arg2[7])); + var x1188: u32 = undefined; + var x1189: u32 = undefined; + mulxU32(&x1188, &x1189, x8, (arg2[6])); + var x1190: u32 = undefined; + var x1191: u32 = undefined; + mulxU32(&x1190, &x1191, x8, (arg2[5])); + var x1192: u32 = undefined; + var x1193: u32 = undefined; + mulxU32(&x1192, &x1193, x8, (arg2[4])); + var x1194: u32 = undefined; + var x1195: u32 = undefined; + mulxU32(&x1194, &x1195, x8, (arg2[3])); + var x1196: u32 = undefined; + var x1197: u32 = undefined; + mulxU32(&x1196, &x1197, x8, (arg2[2])); + var x1198: u32 = undefined; + var x1199: u32 = undefined; + mulxU32(&x1198, &x1199, x8, (arg2[1])); + var x1200: u32 = undefined; + var x1201: u32 = undefined; + mulxU32(&x1200, &x1201, x8, (arg2[0])); + var x1202: u32 = undefined; + var x1203: u1 = undefined; + addcarryxU32(&x1202, &x1203, 0x0, x1201, x1198); + var x1204: u32 = undefined; + var x1205: u1 = undefined; + addcarryxU32(&x1204, &x1205, x1203, x1199, x1196); + var x1206: u32 = undefined; + var x1207: u1 = undefined; + addcarryxU32(&x1206, &x1207, x1205, x1197, x1194); + var x1208: u32 = undefined; + var x1209: u1 = undefined; + addcarryxU32(&x1208, &x1209, x1207, x1195, x1192); + var x1210: u32 = undefined; + var x1211: u1 = undefined; + addcarryxU32(&x1210, &x1211, x1209, x1193, x1190); + var x1212: u32 = undefined; + var x1213: u1 = undefined; + addcarryxU32(&x1212, &x1213, x1211, x1191, x1188); + var x1214: u32 = undefined; + var x1215: u1 = undefined; + addcarryxU32(&x1214, &x1215, x1213, x1189, x1186); + var x1216: u32 = undefined; + var x1217: u1 = undefined; + addcarryxU32(&x1216, &x1217, x1215, x1187, x1184); + var x1218: u32 = undefined; + var x1219: u1 = undefined; + addcarryxU32(&x1218, &x1219, x1217, x1185, x1182); + var x1220: u32 = undefined; + var x1221: u1 = undefined; + addcarryxU32(&x1220, &x1221, x1219, x1183, x1180); + var x1222: u32 = undefined; + var x1223: u1 = undefined; + addcarryxU32(&x1222, &x1223, x1221, x1181, x1178); + const x1224 = (cast(u32, x1223) + x1179); + var x1225: u32 = undefined; + var x1226: u1 = undefined; + addcarryxU32(&x1225, &x1226, 0x0, x1153, x1200); + var x1227: u32 = undefined; + var x1228: u1 = undefined; + addcarryxU32(&x1227, &x1228, x1226, x1155, x1202); + var x1229: u32 = undefined; + var x1230: u1 = undefined; + addcarryxU32(&x1229, &x1230, x1228, x1157, x1204); + var x1231: u32 = undefined; + var x1232: u1 = undefined; + addcarryxU32(&x1231, &x1232, x1230, x1159, x1206); + var x1233: u32 = undefined; + var x1234: u1 = undefined; + addcarryxU32(&x1233, &x1234, x1232, x1161, x1208); + var x1235: u32 = undefined; + var x1236: u1 = undefined; + addcarryxU32(&x1235, &x1236, x1234, x1163, x1210); + var x1237: u32 = undefined; + var x1238: u1 = undefined; + addcarryxU32(&x1237, &x1238, x1236, x1165, x1212); + var x1239: u32 = undefined; + var x1240: u1 = undefined; + addcarryxU32(&x1239, &x1240, x1238, x1167, x1214); + var x1241: u32 = undefined; + var x1242: u1 = undefined; + addcarryxU32(&x1241, &x1242, x1240, x1169, x1216); + var x1243: u32 = undefined; + var x1244: u1 = undefined; + addcarryxU32(&x1243, &x1244, x1242, x1171, x1218); + var x1245: u32 = undefined; + var x1246: u1 = undefined; + addcarryxU32(&x1245, &x1246, x1244, x1173, x1220); + var x1247: u32 = undefined; + var x1248: u1 = undefined; + addcarryxU32(&x1247, &x1248, x1246, x1175, x1222); + var x1249: u32 = undefined; + var x1250: u1 = undefined; + addcarryxU32(&x1249, &x1250, x1248, x1177, x1224); + var x1251: u32 = undefined; + var x1252: u32 = undefined; + mulxU32(&x1251, &x1252, x1225, 0xe88fdc45); + var x1253: u32 = undefined; + var x1254: u32 = undefined; + mulxU32(&x1253, &x1254, x1251, 0xffffffff); + var x1255: u32 = undefined; + var x1256: u32 = undefined; + mulxU32(&x1255, &x1256, x1251, 0xffffffff); + var x1257: u32 = undefined; + var x1258: u32 = undefined; + mulxU32(&x1257, &x1258, x1251, 0xffffffff); + var x1259: u32 = undefined; + var x1260: u32 = undefined; + mulxU32(&x1259, &x1260, x1251, 0xffffffff); + var x1261: u32 = undefined; + var x1262: u32 = undefined; + mulxU32(&x1261, &x1262, x1251, 0xffffffff); + var x1263: u32 = undefined; + var x1264: u32 = undefined; + mulxU32(&x1263, &x1264, x1251, 0xffffffff); + var x1265: u32 = undefined; + var x1266: u32 = undefined; + mulxU32(&x1265, &x1266, x1251, 0xc7634d81); + var x1267: u32 = undefined; + var x1268: u32 = undefined; + mulxU32(&x1267, &x1268, x1251, 0xf4372ddf); + var x1269: u32 = undefined; + var x1270: u32 = undefined; + mulxU32(&x1269, &x1270, x1251, 0x581a0db2); + var x1271: u32 = undefined; + var x1272: u32 = undefined; + mulxU32(&x1271, &x1272, x1251, 0x48b0a77a); + var x1273: u32 = undefined; + var x1274: u32 = undefined; + mulxU32(&x1273, &x1274, x1251, 0xecec196a); + var x1275: u32 = undefined; + var x1276: u32 = undefined; + mulxU32(&x1275, &x1276, x1251, 0xccc52973); + var x1277: u32 = undefined; + var x1278: u1 = undefined; + addcarryxU32(&x1277, &x1278, 0x0, x1276, x1273); + var x1279: u32 = undefined; + var x1280: u1 = undefined; + addcarryxU32(&x1279, &x1280, x1278, x1274, x1271); + var x1281: u32 = undefined; + var x1282: u1 = undefined; + addcarryxU32(&x1281, &x1282, x1280, x1272, x1269); + var x1283: u32 = undefined; + var x1284: u1 = undefined; + addcarryxU32(&x1283, &x1284, x1282, x1270, x1267); + var x1285: u32 = undefined; + var x1286: u1 = undefined; + addcarryxU32(&x1285, &x1286, x1284, x1268, x1265); + var x1287: u32 = undefined; + var x1288: u1 = undefined; + addcarryxU32(&x1287, &x1288, x1286, x1266, x1263); + var x1289: u32 = undefined; + var x1290: u1 = undefined; + addcarryxU32(&x1289, &x1290, x1288, x1264, x1261); + var x1291: u32 = undefined; + var x1292: u1 = undefined; + addcarryxU32(&x1291, &x1292, x1290, x1262, x1259); + var x1293: u32 = undefined; + var x1294: u1 = undefined; + addcarryxU32(&x1293, &x1294, x1292, x1260, x1257); + var x1295: u32 = undefined; + var x1296: u1 = undefined; + addcarryxU32(&x1295, &x1296, x1294, x1258, x1255); + var x1297: u32 = undefined; + var x1298: u1 = undefined; + addcarryxU32(&x1297, &x1298, x1296, x1256, x1253); + const x1299 = (cast(u32, x1298) + x1254); + var x1300: u32 = undefined; + var x1301: u1 = undefined; + addcarryxU32(&x1300, &x1301, 0x0, x1225, x1275); + var x1302: u32 = undefined; + var x1303: u1 = undefined; + addcarryxU32(&x1302, &x1303, x1301, x1227, x1277); + var x1304: u32 = undefined; + var x1305: u1 = undefined; + addcarryxU32(&x1304, &x1305, x1303, x1229, x1279); + var x1306: u32 = undefined; + var x1307: u1 = undefined; + addcarryxU32(&x1306, &x1307, x1305, x1231, x1281); + var x1308: u32 = undefined; + var x1309: u1 = undefined; + addcarryxU32(&x1308, &x1309, x1307, x1233, x1283); + var x1310: u32 = undefined; + var x1311: u1 = undefined; + addcarryxU32(&x1310, &x1311, x1309, x1235, x1285); + var x1312: u32 = undefined; + var x1313: u1 = undefined; + addcarryxU32(&x1312, &x1313, x1311, x1237, x1287); + var x1314: u32 = undefined; + var x1315: u1 = undefined; + addcarryxU32(&x1314, &x1315, x1313, x1239, x1289); + var x1316: u32 = undefined; + var x1317: u1 = undefined; + addcarryxU32(&x1316, &x1317, x1315, x1241, x1291); + var x1318: u32 = undefined; + var x1319: u1 = undefined; + addcarryxU32(&x1318, &x1319, x1317, x1243, x1293); + var x1320: u32 = undefined; + var x1321: u1 = undefined; + addcarryxU32(&x1320, &x1321, x1319, x1245, x1295); + var x1322: u32 = undefined; + var x1323: u1 = undefined; + addcarryxU32(&x1322, &x1323, x1321, x1247, x1297); + var x1324: u32 = undefined; + var x1325: u1 = undefined; + addcarryxU32(&x1324, &x1325, x1323, x1249, x1299); + const x1326 = (cast(u32, x1325) + cast(u32, x1250)); + var x1327: u32 = undefined; + var x1328: u32 = undefined; + mulxU32(&x1327, &x1328, x9, (arg2[11])); + var x1329: u32 = undefined; + var x1330: u32 = undefined; + mulxU32(&x1329, &x1330, x9, (arg2[10])); + var x1331: u32 = undefined; + var x1332: u32 = undefined; + mulxU32(&x1331, &x1332, x9, (arg2[9])); + var x1333: u32 = undefined; + var x1334: u32 = undefined; + mulxU32(&x1333, &x1334, x9, (arg2[8])); + var x1335: u32 = undefined; + var x1336: u32 = undefined; + mulxU32(&x1335, &x1336, x9, (arg2[7])); + var x1337: u32 = undefined; + var x1338: u32 = undefined; + mulxU32(&x1337, &x1338, x9, (arg2[6])); + var x1339: u32 = undefined; + var x1340: u32 = undefined; + mulxU32(&x1339, &x1340, x9, (arg2[5])); + var x1341: u32 = undefined; + var x1342: u32 = undefined; + mulxU32(&x1341, &x1342, x9, (arg2[4])); + var x1343: u32 = undefined; + var x1344: u32 = undefined; + mulxU32(&x1343, &x1344, x9, (arg2[3])); + var x1345: u32 = undefined; + var x1346: u32 = undefined; + mulxU32(&x1345, &x1346, x9, (arg2[2])); + var x1347: u32 = undefined; + var x1348: u32 = undefined; + mulxU32(&x1347, &x1348, x9, (arg2[1])); + var x1349: u32 = undefined; + var x1350: u32 = undefined; + mulxU32(&x1349, &x1350, x9, (arg2[0])); + var x1351: u32 = undefined; + var x1352: u1 = undefined; + addcarryxU32(&x1351, &x1352, 0x0, x1350, x1347); + var x1353: u32 = undefined; + var x1354: u1 = undefined; + addcarryxU32(&x1353, &x1354, x1352, x1348, x1345); + var x1355: u32 = undefined; + var x1356: u1 = undefined; + addcarryxU32(&x1355, &x1356, x1354, x1346, x1343); + var x1357: u32 = undefined; + var x1358: u1 = undefined; + addcarryxU32(&x1357, &x1358, x1356, x1344, x1341); + var x1359: u32 = undefined; + var x1360: u1 = undefined; + addcarryxU32(&x1359, &x1360, x1358, x1342, x1339); + var x1361: u32 = undefined; + var x1362: u1 = undefined; + addcarryxU32(&x1361, &x1362, x1360, x1340, x1337); + var x1363: u32 = undefined; + var x1364: u1 = undefined; + addcarryxU32(&x1363, &x1364, x1362, x1338, x1335); + var x1365: u32 = undefined; + var x1366: u1 = undefined; + addcarryxU32(&x1365, &x1366, x1364, x1336, x1333); + var x1367: u32 = undefined; + var x1368: u1 = undefined; + addcarryxU32(&x1367, &x1368, x1366, x1334, x1331); + var x1369: u32 = undefined; + var x1370: u1 = undefined; + addcarryxU32(&x1369, &x1370, x1368, x1332, x1329); + var x1371: u32 = undefined; + var x1372: u1 = undefined; + addcarryxU32(&x1371, &x1372, x1370, x1330, x1327); + const x1373 = (cast(u32, x1372) + x1328); + var x1374: u32 = undefined; + var x1375: u1 = undefined; + addcarryxU32(&x1374, &x1375, 0x0, x1302, x1349); + var x1376: u32 = undefined; + var x1377: u1 = undefined; + addcarryxU32(&x1376, &x1377, x1375, x1304, x1351); + var x1378: u32 = undefined; + var x1379: u1 = undefined; + addcarryxU32(&x1378, &x1379, x1377, x1306, x1353); + var x1380: u32 = undefined; + var x1381: u1 = undefined; + addcarryxU32(&x1380, &x1381, x1379, x1308, x1355); + var x1382: u32 = undefined; + var x1383: u1 = undefined; + addcarryxU32(&x1382, &x1383, x1381, x1310, x1357); + var x1384: u32 = undefined; + var x1385: u1 = undefined; + addcarryxU32(&x1384, &x1385, x1383, x1312, x1359); + var x1386: u32 = undefined; + var x1387: u1 = undefined; + addcarryxU32(&x1386, &x1387, x1385, x1314, x1361); + var x1388: u32 = undefined; + var x1389: u1 = undefined; + addcarryxU32(&x1388, &x1389, x1387, x1316, x1363); + var x1390: u32 = undefined; + var x1391: u1 = undefined; + addcarryxU32(&x1390, &x1391, x1389, x1318, x1365); + var x1392: u32 = undefined; + var x1393: u1 = undefined; + addcarryxU32(&x1392, &x1393, x1391, x1320, x1367); + var x1394: u32 = undefined; + var x1395: u1 = undefined; + addcarryxU32(&x1394, &x1395, x1393, x1322, x1369); + var x1396: u32 = undefined; + var x1397: u1 = undefined; + addcarryxU32(&x1396, &x1397, x1395, x1324, x1371); + var x1398: u32 = undefined; + var x1399: u1 = undefined; + addcarryxU32(&x1398, &x1399, x1397, x1326, x1373); + var x1400: u32 = undefined; + var x1401: u32 = undefined; + mulxU32(&x1400, &x1401, x1374, 0xe88fdc45); + var x1402: u32 = undefined; + var x1403: u32 = undefined; + mulxU32(&x1402, &x1403, x1400, 0xffffffff); + var x1404: u32 = undefined; + var x1405: u32 = undefined; + mulxU32(&x1404, &x1405, x1400, 0xffffffff); + var x1406: u32 = undefined; + var x1407: u32 = undefined; + mulxU32(&x1406, &x1407, x1400, 0xffffffff); + var x1408: u32 = undefined; + var x1409: u32 = undefined; + mulxU32(&x1408, &x1409, x1400, 0xffffffff); + var x1410: u32 = undefined; + var x1411: u32 = undefined; + mulxU32(&x1410, &x1411, x1400, 0xffffffff); + var x1412: u32 = undefined; + var x1413: u32 = undefined; + mulxU32(&x1412, &x1413, x1400, 0xffffffff); + var x1414: u32 = undefined; + var x1415: u32 = undefined; + mulxU32(&x1414, &x1415, x1400, 0xc7634d81); + var x1416: u32 = undefined; + var x1417: u32 = undefined; + mulxU32(&x1416, &x1417, x1400, 0xf4372ddf); + var x1418: u32 = undefined; + var x1419: u32 = undefined; + mulxU32(&x1418, &x1419, x1400, 0x581a0db2); + var x1420: u32 = undefined; + var x1421: u32 = undefined; + mulxU32(&x1420, &x1421, x1400, 0x48b0a77a); + var x1422: u32 = undefined; + var x1423: u32 = undefined; + mulxU32(&x1422, &x1423, x1400, 0xecec196a); + var x1424: u32 = undefined; + var x1425: u32 = undefined; + mulxU32(&x1424, &x1425, x1400, 0xccc52973); + var x1426: u32 = undefined; + var x1427: u1 = undefined; + addcarryxU32(&x1426, &x1427, 0x0, x1425, x1422); + var x1428: u32 = undefined; + var x1429: u1 = undefined; + addcarryxU32(&x1428, &x1429, x1427, x1423, x1420); + var x1430: u32 = undefined; + var x1431: u1 = undefined; + addcarryxU32(&x1430, &x1431, x1429, x1421, x1418); + var x1432: u32 = undefined; + var x1433: u1 = undefined; + addcarryxU32(&x1432, &x1433, x1431, x1419, x1416); + var x1434: u32 = undefined; + var x1435: u1 = undefined; + addcarryxU32(&x1434, &x1435, x1433, x1417, x1414); + var x1436: u32 = undefined; + var x1437: u1 = undefined; + addcarryxU32(&x1436, &x1437, x1435, x1415, x1412); + var x1438: u32 = undefined; + var x1439: u1 = undefined; + addcarryxU32(&x1438, &x1439, x1437, x1413, x1410); + var x1440: u32 = undefined; + var x1441: u1 = undefined; + addcarryxU32(&x1440, &x1441, x1439, x1411, x1408); + var x1442: u32 = undefined; + var x1443: u1 = undefined; + addcarryxU32(&x1442, &x1443, x1441, x1409, x1406); + var x1444: u32 = undefined; + var x1445: u1 = undefined; + addcarryxU32(&x1444, &x1445, x1443, x1407, x1404); + var x1446: u32 = undefined; + var x1447: u1 = undefined; + addcarryxU32(&x1446, &x1447, x1445, x1405, x1402); + const x1448 = (cast(u32, x1447) + x1403); + var x1449: u32 = undefined; + var x1450: u1 = undefined; + addcarryxU32(&x1449, &x1450, 0x0, x1374, x1424); + var x1451: u32 = undefined; + var x1452: u1 = undefined; + addcarryxU32(&x1451, &x1452, x1450, x1376, x1426); + var x1453: u32 = undefined; + var x1454: u1 = undefined; + addcarryxU32(&x1453, &x1454, x1452, x1378, x1428); + var x1455: u32 = undefined; + var x1456: u1 = undefined; + addcarryxU32(&x1455, &x1456, x1454, x1380, x1430); + var x1457: u32 = undefined; + var x1458: u1 = undefined; + addcarryxU32(&x1457, &x1458, x1456, x1382, x1432); + var x1459: u32 = undefined; + var x1460: u1 = undefined; + addcarryxU32(&x1459, &x1460, x1458, x1384, x1434); + var x1461: u32 = undefined; + var x1462: u1 = undefined; + addcarryxU32(&x1461, &x1462, x1460, x1386, x1436); + var x1463: u32 = undefined; + var x1464: u1 = undefined; + addcarryxU32(&x1463, &x1464, x1462, x1388, x1438); + var x1465: u32 = undefined; + var x1466: u1 = undefined; + addcarryxU32(&x1465, &x1466, x1464, x1390, x1440); + var x1467: u32 = undefined; + var x1468: u1 = undefined; + addcarryxU32(&x1467, &x1468, x1466, x1392, x1442); + var x1469: u32 = undefined; + var x1470: u1 = undefined; + addcarryxU32(&x1469, &x1470, x1468, x1394, x1444); + var x1471: u32 = undefined; + var x1472: u1 = undefined; + addcarryxU32(&x1471, &x1472, x1470, x1396, x1446); + var x1473: u32 = undefined; + var x1474: u1 = undefined; + addcarryxU32(&x1473, &x1474, x1472, x1398, x1448); + const x1475 = (cast(u32, x1474) + cast(u32, x1399)); + var x1476: u32 = undefined; + var x1477: u32 = undefined; + mulxU32(&x1476, &x1477, x10, (arg2[11])); + var x1478: u32 = undefined; + var x1479: u32 = undefined; + mulxU32(&x1478, &x1479, x10, (arg2[10])); + var x1480: u32 = undefined; + var x1481: u32 = undefined; + mulxU32(&x1480, &x1481, x10, (arg2[9])); + var x1482: u32 = undefined; + var x1483: u32 = undefined; + mulxU32(&x1482, &x1483, x10, (arg2[8])); + var x1484: u32 = undefined; + var x1485: u32 = undefined; + mulxU32(&x1484, &x1485, x10, (arg2[7])); + var x1486: u32 = undefined; + var x1487: u32 = undefined; + mulxU32(&x1486, &x1487, x10, (arg2[6])); + var x1488: u32 = undefined; + var x1489: u32 = undefined; + mulxU32(&x1488, &x1489, x10, (arg2[5])); + var x1490: u32 = undefined; + var x1491: u32 = undefined; + mulxU32(&x1490, &x1491, x10, (arg2[4])); + var x1492: u32 = undefined; + var x1493: u32 = undefined; + mulxU32(&x1492, &x1493, x10, (arg2[3])); + var x1494: u32 = undefined; + var x1495: u32 = undefined; + mulxU32(&x1494, &x1495, x10, (arg2[2])); + var x1496: u32 = undefined; + var x1497: u32 = undefined; + mulxU32(&x1496, &x1497, x10, (arg2[1])); + var x1498: u32 = undefined; + var x1499: u32 = undefined; + mulxU32(&x1498, &x1499, x10, (arg2[0])); + var x1500: u32 = undefined; + var x1501: u1 = undefined; + addcarryxU32(&x1500, &x1501, 0x0, x1499, x1496); + var x1502: u32 = undefined; + var x1503: u1 = undefined; + addcarryxU32(&x1502, &x1503, x1501, x1497, x1494); + var x1504: u32 = undefined; + var x1505: u1 = undefined; + addcarryxU32(&x1504, &x1505, x1503, x1495, x1492); + var x1506: u32 = undefined; + var x1507: u1 = undefined; + addcarryxU32(&x1506, &x1507, x1505, x1493, x1490); + var x1508: u32 = undefined; + var x1509: u1 = undefined; + addcarryxU32(&x1508, &x1509, x1507, x1491, x1488); + var x1510: u32 = undefined; + var x1511: u1 = undefined; + addcarryxU32(&x1510, &x1511, x1509, x1489, x1486); + var x1512: u32 = undefined; + var x1513: u1 = undefined; + addcarryxU32(&x1512, &x1513, x1511, x1487, x1484); + var x1514: u32 = undefined; + var x1515: u1 = undefined; + addcarryxU32(&x1514, &x1515, x1513, x1485, x1482); + var x1516: u32 = undefined; + var x1517: u1 = undefined; + addcarryxU32(&x1516, &x1517, x1515, x1483, x1480); + var x1518: u32 = undefined; + var x1519: u1 = undefined; + addcarryxU32(&x1518, &x1519, x1517, x1481, x1478); + var x1520: u32 = undefined; + var x1521: u1 = undefined; + addcarryxU32(&x1520, &x1521, x1519, x1479, x1476); + const x1522 = (cast(u32, x1521) + x1477); + var x1523: u32 = undefined; + var x1524: u1 = undefined; + addcarryxU32(&x1523, &x1524, 0x0, x1451, x1498); + var x1525: u32 = undefined; + var x1526: u1 = undefined; + addcarryxU32(&x1525, &x1526, x1524, x1453, x1500); + var x1527: u32 = undefined; + var x1528: u1 = undefined; + addcarryxU32(&x1527, &x1528, x1526, x1455, x1502); + var x1529: u32 = undefined; + var x1530: u1 = undefined; + addcarryxU32(&x1529, &x1530, x1528, x1457, x1504); + var x1531: u32 = undefined; + var x1532: u1 = undefined; + addcarryxU32(&x1531, &x1532, x1530, x1459, x1506); + var x1533: u32 = undefined; + var x1534: u1 = undefined; + addcarryxU32(&x1533, &x1534, x1532, x1461, x1508); + var x1535: u32 = undefined; + var x1536: u1 = undefined; + addcarryxU32(&x1535, &x1536, x1534, x1463, x1510); + var x1537: u32 = undefined; + var x1538: u1 = undefined; + addcarryxU32(&x1537, &x1538, x1536, x1465, x1512); + var x1539: u32 = undefined; + var x1540: u1 = undefined; + addcarryxU32(&x1539, &x1540, x1538, x1467, x1514); + var x1541: u32 = undefined; + var x1542: u1 = undefined; + addcarryxU32(&x1541, &x1542, x1540, x1469, x1516); + var x1543: u32 = undefined; + var x1544: u1 = undefined; + addcarryxU32(&x1543, &x1544, x1542, x1471, x1518); + var x1545: u32 = undefined; + var x1546: u1 = undefined; + addcarryxU32(&x1545, &x1546, x1544, x1473, x1520); + var x1547: u32 = undefined; + var x1548: u1 = undefined; + addcarryxU32(&x1547, &x1548, x1546, x1475, x1522); + var x1549: u32 = undefined; + var x1550: u32 = undefined; + mulxU32(&x1549, &x1550, x1523, 0xe88fdc45); + var x1551: u32 = undefined; + var x1552: u32 = undefined; + mulxU32(&x1551, &x1552, x1549, 0xffffffff); + var x1553: u32 = undefined; + var x1554: u32 = undefined; + mulxU32(&x1553, &x1554, x1549, 0xffffffff); + var x1555: u32 = undefined; + var x1556: u32 = undefined; + mulxU32(&x1555, &x1556, x1549, 0xffffffff); + var x1557: u32 = undefined; + var x1558: u32 = undefined; + mulxU32(&x1557, &x1558, x1549, 0xffffffff); + var x1559: u32 = undefined; + var x1560: u32 = undefined; + mulxU32(&x1559, &x1560, x1549, 0xffffffff); + var x1561: u32 = undefined; + var x1562: u32 = undefined; + mulxU32(&x1561, &x1562, x1549, 0xffffffff); + var x1563: u32 = undefined; + var x1564: u32 = undefined; + mulxU32(&x1563, &x1564, x1549, 0xc7634d81); + var x1565: u32 = undefined; + var x1566: u32 = undefined; + mulxU32(&x1565, &x1566, x1549, 0xf4372ddf); + var x1567: u32 = undefined; + var x1568: u32 = undefined; + mulxU32(&x1567, &x1568, x1549, 0x581a0db2); + var x1569: u32 = undefined; + var x1570: u32 = undefined; + mulxU32(&x1569, &x1570, x1549, 0x48b0a77a); + var x1571: u32 = undefined; + var x1572: u32 = undefined; + mulxU32(&x1571, &x1572, x1549, 0xecec196a); + var x1573: u32 = undefined; + var x1574: u32 = undefined; + mulxU32(&x1573, &x1574, x1549, 0xccc52973); + var x1575: u32 = undefined; + var x1576: u1 = undefined; + addcarryxU32(&x1575, &x1576, 0x0, x1574, x1571); + var x1577: u32 = undefined; + var x1578: u1 = undefined; + addcarryxU32(&x1577, &x1578, x1576, x1572, x1569); + var x1579: u32 = undefined; + var x1580: u1 = undefined; + addcarryxU32(&x1579, &x1580, x1578, x1570, x1567); + var x1581: u32 = undefined; + var x1582: u1 = undefined; + addcarryxU32(&x1581, &x1582, x1580, x1568, x1565); + var x1583: u32 = undefined; + var x1584: u1 = undefined; + addcarryxU32(&x1583, &x1584, x1582, x1566, x1563); + var x1585: u32 = undefined; + var x1586: u1 = undefined; + addcarryxU32(&x1585, &x1586, x1584, x1564, x1561); + var x1587: u32 = undefined; + var x1588: u1 = undefined; + addcarryxU32(&x1587, &x1588, x1586, x1562, x1559); + var x1589: u32 = undefined; + var x1590: u1 = undefined; + addcarryxU32(&x1589, &x1590, x1588, x1560, x1557); + var x1591: u32 = undefined; + var x1592: u1 = undefined; + addcarryxU32(&x1591, &x1592, x1590, x1558, x1555); + var x1593: u32 = undefined; + var x1594: u1 = undefined; + addcarryxU32(&x1593, &x1594, x1592, x1556, x1553); + var x1595: u32 = undefined; + var x1596: u1 = undefined; + addcarryxU32(&x1595, &x1596, x1594, x1554, x1551); + const x1597 = (cast(u32, x1596) + x1552); + var x1598: u32 = undefined; + var x1599: u1 = undefined; + addcarryxU32(&x1598, &x1599, 0x0, x1523, x1573); + var x1600: u32 = undefined; + var x1601: u1 = undefined; + addcarryxU32(&x1600, &x1601, x1599, x1525, x1575); + var x1602: u32 = undefined; + var x1603: u1 = undefined; + addcarryxU32(&x1602, &x1603, x1601, x1527, x1577); + var x1604: u32 = undefined; + var x1605: u1 = undefined; + addcarryxU32(&x1604, &x1605, x1603, x1529, x1579); + var x1606: u32 = undefined; + var x1607: u1 = undefined; + addcarryxU32(&x1606, &x1607, x1605, x1531, x1581); + var x1608: u32 = undefined; + var x1609: u1 = undefined; + addcarryxU32(&x1608, &x1609, x1607, x1533, x1583); + var x1610: u32 = undefined; + var x1611: u1 = undefined; + addcarryxU32(&x1610, &x1611, x1609, x1535, x1585); + var x1612: u32 = undefined; + var x1613: u1 = undefined; + addcarryxU32(&x1612, &x1613, x1611, x1537, x1587); + var x1614: u32 = undefined; + var x1615: u1 = undefined; + addcarryxU32(&x1614, &x1615, x1613, x1539, x1589); + var x1616: u32 = undefined; + var x1617: u1 = undefined; + addcarryxU32(&x1616, &x1617, x1615, x1541, x1591); + var x1618: u32 = undefined; + var x1619: u1 = undefined; + addcarryxU32(&x1618, &x1619, x1617, x1543, x1593); + var x1620: u32 = undefined; + var x1621: u1 = undefined; + addcarryxU32(&x1620, &x1621, x1619, x1545, x1595); + var x1622: u32 = undefined; + var x1623: u1 = undefined; + addcarryxU32(&x1622, &x1623, x1621, x1547, x1597); + const x1624 = (cast(u32, x1623) + cast(u32, x1548)); + var x1625: u32 = undefined; + var x1626: u32 = undefined; + mulxU32(&x1625, &x1626, x11, (arg2[11])); + var x1627: u32 = undefined; + var x1628: u32 = undefined; + mulxU32(&x1627, &x1628, x11, (arg2[10])); + var x1629: u32 = undefined; + var x1630: u32 = undefined; + mulxU32(&x1629, &x1630, x11, (arg2[9])); + var x1631: u32 = undefined; + var x1632: u32 = undefined; + mulxU32(&x1631, &x1632, x11, (arg2[8])); + var x1633: u32 = undefined; + var x1634: u32 = undefined; + mulxU32(&x1633, &x1634, x11, (arg2[7])); + var x1635: u32 = undefined; + var x1636: u32 = undefined; + mulxU32(&x1635, &x1636, x11, (arg2[6])); + var x1637: u32 = undefined; + var x1638: u32 = undefined; + mulxU32(&x1637, &x1638, x11, (arg2[5])); + var x1639: u32 = undefined; + var x1640: u32 = undefined; + mulxU32(&x1639, &x1640, x11, (arg2[4])); + var x1641: u32 = undefined; + var x1642: u32 = undefined; + mulxU32(&x1641, &x1642, x11, (arg2[3])); + var x1643: u32 = undefined; + var x1644: u32 = undefined; + mulxU32(&x1643, &x1644, x11, (arg2[2])); + var x1645: u32 = undefined; + var x1646: u32 = undefined; + mulxU32(&x1645, &x1646, x11, (arg2[1])); + var x1647: u32 = undefined; + var x1648: u32 = undefined; + mulxU32(&x1647, &x1648, x11, (arg2[0])); + var x1649: u32 = undefined; + var x1650: u1 = undefined; + addcarryxU32(&x1649, &x1650, 0x0, x1648, x1645); + var x1651: u32 = undefined; + var x1652: u1 = undefined; + addcarryxU32(&x1651, &x1652, x1650, x1646, x1643); + var x1653: u32 = undefined; + var x1654: u1 = undefined; + addcarryxU32(&x1653, &x1654, x1652, x1644, x1641); + var x1655: u32 = undefined; + var x1656: u1 = undefined; + addcarryxU32(&x1655, &x1656, x1654, x1642, x1639); + var x1657: u32 = undefined; + var x1658: u1 = undefined; + addcarryxU32(&x1657, &x1658, x1656, x1640, x1637); + var x1659: u32 = undefined; + var x1660: u1 = undefined; + addcarryxU32(&x1659, &x1660, x1658, x1638, x1635); + var x1661: u32 = undefined; + var x1662: u1 = undefined; + addcarryxU32(&x1661, &x1662, x1660, x1636, x1633); + var x1663: u32 = undefined; + var x1664: u1 = undefined; + addcarryxU32(&x1663, &x1664, x1662, x1634, x1631); + var x1665: u32 = undefined; + var x1666: u1 = undefined; + addcarryxU32(&x1665, &x1666, x1664, x1632, x1629); + var x1667: u32 = undefined; + var x1668: u1 = undefined; + addcarryxU32(&x1667, &x1668, x1666, x1630, x1627); + var x1669: u32 = undefined; + var x1670: u1 = undefined; + addcarryxU32(&x1669, &x1670, x1668, x1628, x1625); + const x1671 = (cast(u32, x1670) + x1626); + var x1672: u32 = undefined; + var x1673: u1 = undefined; + addcarryxU32(&x1672, &x1673, 0x0, x1600, x1647); + var x1674: u32 = undefined; + var x1675: u1 = undefined; + addcarryxU32(&x1674, &x1675, x1673, x1602, x1649); + var x1676: u32 = undefined; + var x1677: u1 = undefined; + addcarryxU32(&x1676, &x1677, x1675, x1604, x1651); + var x1678: u32 = undefined; + var x1679: u1 = undefined; + addcarryxU32(&x1678, &x1679, x1677, x1606, x1653); + var x1680: u32 = undefined; + var x1681: u1 = undefined; + addcarryxU32(&x1680, &x1681, x1679, x1608, x1655); + var x1682: u32 = undefined; + var x1683: u1 = undefined; + addcarryxU32(&x1682, &x1683, x1681, x1610, x1657); + var x1684: u32 = undefined; + var x1685: u1 = undefined; + addcarryxU32(&x1684, &x1685, x1683, x1612, x1659); + var x1686: u32 = undefined; + var x1687: u1 = undefined; + addcarryxU32(&x1686, &x1687, x1685, x1614, x1661); + var x1688: u32 = undefined; + var x1689: u1 = undefined; + addcarryxU32(&x1688, &x1689, x1687, x1616, x1663); + var x1690: u32 = undefined; + var x1691: u1 = undefined; + addcarryxU32(&x1690, &x1691, x1689, x1618, x1665); + var x1692: u32 = undefined; + var x1693: u1 = undefined; + addcarryxU32(&x1692, &x1693, x1691, x1620, x1667); + var x1694: u32 = undefined; + var x1695: u1 = undefined; + addcarryxU32(&x1694, &x1695, x1693, x1622, x1669); + var x1696: u32 = undefined; + var x1697: u1 = undefined; + addcarryxU32(&x1696, &x1697, x1695, x1624, x1671); + var x1698: u32 = undefined; + var x1699: u32 = undefined; + mulxU32(&x1698, &x1699, x1672, 0xe88fdc45); + var x1700: u32 = undefined; + var x1701: u32 = undefined; + mulxU32(&x1700, &x1701, x1698, 0xffffffff); + var x1702: u32 = undefined; + var x1703: u32 = undefined; + mulxU32(&x1702, &x1703, x1698, 0xffffffff); + var x1704: u32 = undefined; + var x1705: u32 = undefined; + mulxU32(&x1704, &x1705, x1698, 0xffffffff); + var x1706: u32 = undefined; + var x1707: u32 = undefined; + mulxU32(&x1706, &x1707, x1698, 0xffffffff); + var x1708: u32 = undefined; + var x1709: u32 = undefined; + mulxU32(&x1708, &x1709, x1698, 0xffffffff); + var x1710: u32 = undefined; + var x1711: u32 = undefined; + mulxU32(&x1710, &x1711, x1698, 0xffffffff); + var x1712: u32 = undefined; + var x1713: u32 = undefined; + mulxU32(&x1712, &x1713, x1698, 0xc7634d81); + var x1714: u32 = undefined; + var x1715: u32 = undefined; + mulxU32(&x1714, &x1715, x1698, 0xf4372ddf); + var x1716: u32 = undefined; + var x1717: u32 = undefined; + mulxU32(&x1716, &x1717, x1698, 0x581a0db2); + var x1718: u32 = undefined; + var x1719: u32 = undefined; + mulxU32(&x1718, &x1719, x1698, 0x48b0a77a); + var x1720: u32 = undefined; + var x1721: u32 = undefined; + mulxU32(&x1720, &x1721, x1698, 0xecec196a); + var x1722: u32 = undefined; + var x1723: u32 = undefined; + mulxU32(&x1722, &x1723, x1698, 0xccc52973); + var x1724: u32 = undefined; + var x1725: u1 = undefined; + addcarryxU32(&x1724, &x1725, 0x0, x1723, x1720); + var x1726: u32 = undefined; + var x1727: u1 = undefined; + addcarryxU32(&x1726, &x1727, x1725, x1721, x1718); + var x1728: u32 = undefined; + var x1729: u1 = undefined; + addcarryxU32(&x1728, &x1729, x1727, x1719, x1716); + var x1730: u32 = undefined; + var x1731: u1 = undefined; + addcarryxU32(&x1730, &x1731, x1729, x1717, x1714); + var x1732: u32 = undefined; + var x1733: u1 = undefined; + addcarryxU32(&x1732, &x1733, x1731, x1715, x1712); + var x1734: u32 = undefined; + var x1735: u1 = undefined; + addcarryxU32(&x1734, &x1735, x1733, x1713, x1710); + var x1736: u32 = undefined; + var x1737: u1 = undefined; + addcarryxU32(&x1736, &x1737, x1735, x1711, x1708); + var x1738: u32 = undefined; + var x1739: u1 = undefined; + addcarryxU32(&x1738, &x1739, x1737, x1709, x1706); + var x1740: u32 = undefined; + var x1741: u1 = undefined; + addcarryxU32(&x1740, &x1741, x1739, x1707, x1704); + var x1742: u32 = undefined; + var x1743: u1 = undefined; + addcarryxU32(&x1742, &x1743, x1741, x1705, x1702); + var x1744: u32 = undefined; + var x1745: u1 = undefined; + addcarryxU32(&x1744, &x1745, x1743, x1703, x1700); + const x1746 = (cast(u32, x1745) + x1701); + var x1747: u32 = undefined; + var x1748: u1 = undefined; + addcarryxU32(&x1747, &x1748, 0x0, x1672, x1722); + var x1749: u32 = undefined; + var x1750: u1 = undefined; + addcarryxU32(&x1749, &x1750, x1748, x1674, x1724); + var x1751: u32 = undefined; + var x1752: u1 = undefined; + addcarryxU32(&x1751, &x1752, x1750, x1676, x1726); + var x1753: u32 = undefined; + var x1754: u1 = undefined; + addcarryxU32(&x1753, &x1754, x1752, x1678, x1728); + var x1755: u32 = undefined; + var x1756: u1 = undefined; + addcarryxU32(&x1755, &x1756, x1754, x1680, x1730); + var x1757: u32 = undefined; + var x1758: u1 = undefined; + addcarryxU32(&x1757, &x1758, x1756, x1682, x1732); + var x1759: u32 = undefined; + var x1760: u1 = undefined; + addcarryxU32(&x1759, &x1760, x1758, x1684, x1734); + var x1761: u32 = undefined; + var x1762: u1 = undefined; + addcarryxU32(&x1761, &x1762, x1760, x1686, x1736); + var x1763: u32 = undefined; + var x1764: u1 = undefined; + addcarryxU32(&x1763, &x1764, x1762, x1688, x1738); + var x1765: u32 = undefined; + var x1766: u1 = undefined; + addcarryxU32(&x1765, &x1766, x1764, x1690, x1740); + var x1767: u32 = undefined; + var x1768: u1 = undefined; + addcarryxU32(&x1767, &x1768, x1766, x1692, x1742); + var x1769: u32 = undefined; + var x1770: u1 = undefined; + addcarryxU32(&x1769, &x1770, x1768, x1694, x1744); + var x1771: u32 = undefined; + var x1772: u1 = undefined; + addcarryxU32(&x1771, &x1772, x1770, x1696, x1746); + const x1773 = (cast(u32, x1772) + cast(u32, x1697)); + var x1774: u32 = undefined; + var x1775: u1 = undefined; + subborrowxU32(&x1774, &x1775, 0x0, x1749, 0xccc52973); + var x1776: u32 = undefined; + var x1777: u1 = undefined; + subborrowxU32(&x1776, &x1777, x1775, x1751, 0xecec196a); + var x1778: u32 = undefined; + var x1779: u1 = undefined; + subborrowxU32(&x1778, &x1779, x1777, x1753, 0x48b0a77a); + var x1780: u32 = undefined; + var x1781: u1 = undefined; + subborrowxU32(&x1780, &x1781, x1779, x1755, 0x581a0db2); + var x1782: u32 = undefined; + var x1783: u1 = undefined; + subborrowxU32(&x1782, &x1783, x1781, x1757, 0xf4372ddf); + var x1784: u32 = undefined; + var x1785: u1 = undefined; + subborrowxU32(&x1784, &x1785, x1783, x1759, 0xc7634d81); + var x1786: u32 = undefined; + var x1787: u1 = undefined; + subborrowxU32(&x1786, &x1787, x1785, x1761, 0xffffffff); + var x1788: u32 = undefined; + var x1789: u1 = undefined; + subborrowxU32(&x1788, &x1789, x1787, x1763, 0xffffffff); + var x1790: u32 = undefined; + var x1791: u1 = undefined; + subborrowxU32(&x1790, &x1791, x1789, x1765, 0xffffffff); + var x1792: u32 = undefined; + var x1793: u1 = undefined; + subborrowxU32(&x1792, &x1793, x1791, x1767, 0xffffffff); + var x1794: u32 = undefined; + var x1795: u1 = undefined; + subborrowxU32(&x1794, &x1795, x1793, x1769, 0xffffffff); + var x1796: u32 = undefined; + var x1797: u1 = undefined; + subborrowxU32(&x1796, &x1797, x1795, x1771, 0xffffffff); + var x1798: u32 = undefined; + var x1799: u1 = undefined; + subborrowxU32(&x1798, &x1799, x1797, x1773, cast(u32, 0x0)); + var x1800: u32 = undefined; + cmovznzU32(&x1800, x1799, x1774, x1749); + var x1801: u32 = undefined; + cmovznzU32(&x1801, x1799, x1776, x1751); + var x1802: u32 = undefined; + cmovznzU32(&x1802, x1799, x1778, x1753); + var x1803: u32 = undefined; + cmovznzU32(&x1803, x1799, x1780, x1755); + var x1804: u32 = undefined; + cmovznzU32(&x1804, x1799, x1782, x1757); + var x1805: u32 = undefined; + cmovznzU32(&x1805, x1799, x1784, x1759); + var x1806: u32 = undefined; + cmovznzU32(&x1806, x1799, x1786, x1761); + var x1807: u32 = undefined; + cmovznzU32(&x1807, x1799, x1788, x1763); + var x1808: u32 = undefined; + cmovznzU32(&x1808, x1799, x1790, x1765); + var x1809: u32 = undefined; + cmovznzU32(&x1809, x1799, x1792, x1767); + var x1810: u32 = undefined; + cmovznzU32(&x1810, x1799, x1794, x1769); + var x1811: u32 = undefined; + cmovznzU32(&x1811, x1799, x1796, x1771); + out1[0] = x1800; + out1[1] = x1801; + out1[2] = x1802; + out1[3] = x1803; + out1[4] = x1804; + out1[5] = x1805; + out1[6] = x1806; + out1[7] = x1807; + out1[8] = x1808; + out1[9] = x1809; + out1[10] = x1810; + out1[11] = x1811; +} + +/// The function square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn square(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[6]); + const x7 = (arg1[7]); + const x8 = (arg1[8]); + const x9 = (arg1[9]); + const x10 = (arg1[10]); + const x11 = (arg1[11]); + const x12 = (arg1[0]); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x12, (arg1[11])); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x12, (arg1[10])); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x12, (arg1[9])); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x12, (arg1[8])); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x12, (arg1[7])); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x12, (arg1[6])); + var x25: u32 = undefined; + var x26: u32 = undefined; + mulxU32(&x25, &x26, x12, (arg1[5])); + var x27: u32 = undefined; + var x28: u32 = undefined; + mulxU32(&x27, &x28, x12, (arg1[4])); + var x29: u32 = undefined; + var x30: u32 = undefined; + mulxU32(&x29, &x30, x12, (arg1[3])); + var x31: u32 = undefined; + var x32: u32 = undefined; + mulxU32(&x31, &x32, x12, (arg1[2])); + var x33: u32 = undefined; + var x34: u32 = undefined; + mulxU32(&x33, &x34, x12, (arg1[1])); + var x35: u32 = undefined; + var x36: u32 = undefined; + mulxU32(&x35, &x36, x12, (arg1[0])); + var x37: u32 = undefined; + var x38: u1 = undefined; + addcarryxU32(&x37, &x38, 0x0, x36, x33); + var x39: u32 = undefined; + var x40: u1 = undefined; + addcarryxU32(&x39, &x40, x38, x34, x31); + var x41: u32 = undefined; + var x42: u1 = undefined; + addcarryxU32(&x41, &x42, x40, x32, x29); + var x43: u32 = undefined; + var x44: u1 = undefined; + addcarryxU32(&x43, &x44, x42, x30, x27); + var x45: u32 = undefined; + var x46: u1 = undefined; + addcarryxU32(&x45, &x46, x44, x28, x25); + var x47: u32 = undefined; + var x48: u1 = undefined; + addcarryxU32(&x47, &x48, x46, x26, x23); + var x49: u32 = undefined; + var x50: u1 = undefined; + addcarryxU32(&x49, &x50, x48, x24, x21); + var x51: u32 = undefined; + var x52: u1 = undefined; + addcarryxU32(&x51, &x52, x50, x22, x19); + var x53: u32 = undefined; + var x54: u1 = undefined; + addcarryxU32(&x53, &x54, x52, x20, x17); + var x55: u32 = undefined; + var x56: u1 = undefined; + addcarryxU32(&x55, &x56, x54, x18, x15); + var x57: u32 = undefined; + var x58: u1 = undefined; + addcarryxU32(&x57, &x58, x56, x16, x13); + const x59 = (cast(u32, x58) + x14); + var x60: u32 = undefined; + var x61: u32 = undefined; + mulxU32(&x60, &x61, x35, 0xe88fdc45); + var x62: u32 = undefined; + var x63: u32 = undefined; + mulxU32(&x62, &x63, x60, 0xffffffff); + var x64: u32 = undefined; + var x65: u32 = undefined; + mulxU32(&x64, &x65, x60, 0xffffffff); + var x66: u32 = undefined; + var x67: u32 = undefined; + mulxU32(&x66, &x67, x60, 0xffffffff); + var x68: u32 = undefined; + var x69: u32 = undefined; + mulxU32(&x68, &x69, x60, 0xffffffff); + var x70: u32 = undefined; + var x71: u32 = undefined; + mulxU32(&x70, &x71, x60, 0xffffffff); + var x72: u32 = undefined; + var x73: u32 = undefined; + mulxU32(&x72, &x73, x60, 0xffffffff); + var x74: u32 = undefined; + var x75: u32 = undefined; + mulxU32(&x74, &x75, x60, 0xc7634d81); + var x76: u32 = undefined; + var x77: u32 = undefined; + mulxU32(&x76, &x77, x60, 0xf4372ddf); + var x78: u32 = undefined; + var x79: u32 = undefined; + mulxU32(&x78, &x79, x60, 0x581a0db2); + var x80: u32 = undefined; + var x81: u32 = undefined; + mulxU32(&x80, &x81, x60, 0x48b0a77a); + var x82: u32 = undefined; + var x83: u32 = undefined; + mulxU32(&x82, &x83, x60, 0xecec196a); + var x84: u32 = undefined; + var x85: u32 = undefined; + mulxU32(&x84, &x85, x60, 0xccc52973); + var x86: u32 = undefined; + var x87: u1 = undefined; + addcarryxU32(&x86, &x87, 0x0, x85, x82); + var x88: u32 = undefined; + var x89: u1 = undefined; + addcarryxU32(&x88, &x89, x87, x83, x80); + var x90: u32 = undefined; + var x91: u1 = undefined; + addcarryxU32(&x90, &x91, x89, x81, x78); + var x92: u32 = undefined; + var x93: u1 = undefined; + addcarryxU32(&x92, &x93, x91, x79, x76); + var x94: u32 = undefined; + var x95: u1 = undefined; + addcarryxU32(&x94, &x95, x93, x77, x74); + var x96: u32 = undefined; + var x97: u1 = undefined; + addcarryxU32(&x96, &x97, x95, x75, x72); + var x98: u32 = undefined; + var x99: u1 = undefined; + addcarryxU32(&x98, &x99, x97, x73, x70); + var x100: u32 = undefined; + var x101: u1 = undefined; + addcarryxU32(&x100, &x101, x99, x71, x68); + var x102: u32 = undefined; + var x103: u1 = undefined; + addcarryxU32(&x102, &x103, x101, x69, x66); + var x104: u32 = undefined; + var x105: u1 = undefined; + addcarryxU32(&x104, &x105, x103, x67, x64); + var x106: u32 = undefined; + var x107: u1 = undefined; + addcarryxU32(&x106, &x107, x105, x65, x62); + const x108 = (cast(u32, x107) + x63); + var x109: u32 = undefined; + var x110: u1 = undefined; + addcarryxU32(&x109, &x110, 0x0, x35, x84); + var x111: u32 = undefined; + var x112: u1 = undefined; + addcarryxU32(&x111, &x112, x110, x37, x86); + var x113: u32 = undefined; + var x114: u1 = undefined; + addcarryxU32(&x113, &x114, x112, x39, x88); + var x115: u32 = undefined; + var x116: u1 = undefined; + addcarryxU32(&x115, &x116, x114, x41, x90); + var x117: u32 = undefined; + var x118: u1 = undefined; + addcarryxU32(&x117, &x118, x116, x43, x92); + var x119: u32 = undefined; + var x120: u1 = undefined; + addcarryxU32(&x119, &x120, x118, x45, x94); + var x121: u32 = undefined; + var x122: u1 = undefined; + addcarryxU32(&x121, &x122, x120, x47, x96); + var x123: u32 = undefined; + var x124: u1 = undefined; + addcarryxU32(&x123, &x124, x122, x49, x98); + var x125: u32 = undefined; + var x126: u1 = undefined; + addcarryxU32(&x125, &x126, x124, x51, x100); + var x127: u32 = undefined; + var x128: u1 = undefined; + addcarryxU32(&x127, &x128, x126, x53, x102); + var x129: u32 = undefined; + var x130: u1 = undefined; + addcarryxU32(&x129, &x130, x128, x55, x104); + var x131: u32 = undefined; + var x132: u1 = undefined; + addcarryxU32(&x131, &x132, x130, x57, x106); + var x133: u32 = undefined; + var x134: u1 = undefined; + addcarryxU32(&x133, &x134, x132, x59, x108); + var x135: u32 = undefined; + var x136: u32 = undefined; + mulxU32(&x135, &x136, x1, (arg1[11])); + var x137: u32 = undefined; + var x138: u32 = undefined; + mulxU32(&x137, &x138, x1, (arg1[10])); + var x139: u32 = undefined; + var x140: u32 = undefined; + mulxU32(&x139, &x140, x1, (arg1[9])); + var x141: u32 = undefined; + var x142: u32 = undefined; + mulxU32(&x141, &x142, x1, (arg1[8])); + var x143: u32 = undefined; + var x144: u32 = undefined; + mulxU32(&x143, &x144, x1, (arg1[7])); + var x145: u32 = undefined; + var x146: u32 = undefined; + mulxU32(&x145, &x146, x1, (arg1[6])); + var x147: u32 = undefined; + var x148: u32 = undefined; + mulxU32(&x147, &x148, x1, (arg1[5])); + var x149: u32 = undefined; + var x150: u32 = undefined; + mulxU32(&x149, &x150, x1, (arg1[4])); + var x151: u32 = undefined; + var x152: u32 = undefined; + mulxU32(&x151, &x152, x1, (arg1[3])); + var x153: u32 = undefined; + var x154: u32 = undefined; + mulxU32(&x153, &x154, x1, (arg1[2])); + var x155: u32 = undefined; + var x156: u32 = undefined; + mulxU32(&x155, &x156, x1, (arg1[1])); + var x157: u32 = undefined; + var x158: u32 = undefined; + mulxU32(&x157, &x158, x1, (arg1[0])); + var x159: u32 = undefined; + var x160: u1 = undefined; + addcarryxU32(&x159, &x160, 0x0, x158, x155); + var x161: u32 = undefined; + var x162: u1 = undefined; + addcarryxU32(&x161, &x162, x160, x156, x153); + var x163: u32 = undefined; + var x164: u1 = undefined; + addcarryxU32(&x163, &x164, x162, x154, x151); + var x165: u32 = undefined; + var x166: u1 = undefined; + addcarryxU32(&x165, &x166, x164, x152, x149); + var x167: u32 = undefined; + var x168: u1 = undefined; + addcarryxU32(&x167, &x168, x166, x150, x147); + var x169: u32 = undefined; + var x170: u1 = undefined; + addcarryxU32(&x169, &x170, x168, x148, x145); + var x171: u32 = undefined; + var x172: u1 = undefined; + addcarryxU32(&x171, &x172, x170, x146, x143); + var x173: u32 = undefined; + var x174: u1 = undefined; + addcarryxU32(&x173, &x174, x172, x144, x141); + var x175: u32 = undefined; + var x176: u1 = undefined; + addcarryxU32(&x175, &x176, x174, x142, x139); + var x177: u32 = undefined; + var x178: u1 = undefined; + addcarryxU32(&x177, &x178, x176, x140, x137); + var x179: u32 = undefined; + var x180: u1 = undefined; + addcarryxU32(&x179, &x180, x178, x138, x135); + const x181 = (cast(u32, x180) + x136); + var x182: u32 = undefined; + var x183: u1 = undefined; + addcarryxU32(&x182, &x183, 0x0, x111, x157); + var x184: u32 = undefined; + var x185: u1 = undefined; + addcarryxU32(&x184, &x185, x183, x113, x159); + var x186: u32 = undefined; + var x187: u1 = undefined; + addcarryxU32(&x186, &x187, x185, x115, x161); + var x188: u32 = undefined; + var x189: u1 = undefined; + addcarryxU32(&x188, &x189, x187, x117, x163); + var x190: u32 = undefined; + var x191: u1 = undefined; + addcarryxU32(&x190, &x191, x189, x119, x165); + var x192: u32 = undefined; + var x193: u1 = undefined; + addcarryxU32(&x192, &x193, x191, x121, x167); + var x194: u32 = undefined; + var x195: u1 = undefined; + addcarryxU32(&x194, &x195, x193, x123, x169); + var x196: u32 = undefined; + var x197: u1 = undefined; + addcarryxU32(&x196, &x197, x195, x125, x171); + var x198: u32 = undefined; + var x199: u1 = undefined; + addcarryxU32(&x198, &x199, x197, x127, x173); + var x200: u32 = undefined; + var x201: u1 = undefined; + addcarryxU32(&x200, &x201, x199, x129, x175); + var x202: u32 = undefined; + var x203: u1 = undefined; + addcarryxU32(&x202, &x203, x201, x131, x177); + var x204: u32 = undefined; + var x205: u1 = undefined; + addcarryxU32(&x204, &x205, x203, x133, x179); + var x206: u32 = undefined; + var x207: u1 = undefined; + addcarryxU32(&x206, &x207, x205, cast(u32, x134), x181); + var x208: u32 = undefined; + var x209: u32 = undefined; + mulxU32(&x208, &x209, x182, 0xe88fdc45); + var x210: u32 = undefined; + var x211: u32 = undefined; + mulxU32(&x210, &x211, x208, 0xffffffff); + var x212: u32 = undefined; + var x213: u32 = undefined; + mulxU32(&x212, &x213, x208, 0xffffffff); + var x214: u32 = undefined; + var x215: u32 = undefined; + mulxU32(&x214, &x215, x208, 0xffffffff); + var x216: u32 = undefined; + var x217: u32 = undefined; + mulxU32(&x216, &x217, x208, 0xffffffff); + var x218: u32 = undefined; + var x219: u32 = undefined; + mulxU32(&x218, &x219, x208, 0xffffffff); + var x220: u32 = undefined; + var x221: u32 = undefined; + mulxU32(&x220, &x221, x208, 0xffffffff); + var x222: u32 = undefined; + var x223: u32 = undefined; + mulxU32(&x222, &x223, x208, 0xc7634d81); + var x224: u32 = undefined; + var x225: u32 = undefined; + mulxU32(&x224, &x225, x208, 0xf4372ddf); + var x226: u32 = undefined; + var x227: u32 = undefined; + mulxU32(&x226, &x227, x208, 0x581a0db2); + var x228: u32 = undefined; + var x229: u32 = undefined; + mulxU32(&x228, &x229, x208, 0x48b0a77a); + var x230: u32 = undefined; + var x231: u32 = undefined; + mulxU32(&x230, &x231, x208, 0xecec196a); + var x232: u32 = undefined; + var x233: u32 = undefined; + mulxU32(&x232, &x233, x208, 0xccc52973); + var x234: u32 = undefined; + var x235: u1 = undefined; + addcarryxU32(&x234, &x235, 0x0, x233, x230); + var x236: u32 = undefined; + var x237: u1 = undefined; + addcarryxU32(&x236, &x237, x235, x231, x228); + var x238: u32 = undefined; + var x239: u1 = undefined; + addcarryxU32(&x238, &x239, x237, x229, x226); + var x240: u32 = undefined; + var x241: u1 = undefined; + addcarryxU32(&x240, &x241, x239, x227, x224); + var x242: u32 = undefined; + var x243: u1 = undefined; + addcarryxU32(&x242, &x243, x241, x225, x222); + var x244: u32 = undefined; + var x245: u1 = undefined; + addcarryxU32(&x244, &x245, x243, x223, x220); + var x246: u32 = undefined; + var x247: u1 = undefined; + addcarryxU32(&x246, &x247, x245, x221, x218); + var x248: u32 = undefined; + var x249: u1 = undefined; + addcarryxU32(&x248, &x249, x247, x219, x216); + var x250: u32 = undefined; + var x251: u1 = undefined; + addcarryxU32(&x250, &x251, x249, x217, x214); + var x252: u32 = undefined; + var x253: u1 = undefined; + addcarryxU32(&x252, &x253, x251, x215, x212); + var x254: u32 = undefined; + var x255: u1 = undefined; + addcarryxU32(&x254, &x255, x253, x213, x210); + const x256 = (cast(u32, x255) + x211); + var x257: u32 = undefined; + var x258: u1 = undefined; + addcarryxU32(&x257, &x258, 0x0, x182, x232); + var x259: u32 = undefined; + var x260: u1 = undefined; + addcarryxU32(&x259, &x260, x258, x184, x234); + var x261: u32 = undefined; + var x262: u1 = undefined; + addcarryxU32(&x261, &x262, x260, x186, x236); + var x263: u32 = undefined; + var x264: u1 = undefined; + addcarryxU32(&x263, &x264, x262, x188, x238); + var x265: u32 = undefined; + var x266: u1 = undefined; + addcarryxU32(&x265, &x266, x264, x190, x240); + var x267: u32 = undefined; + var x268: u1 = undefined; + addcarryxU32(&x267, &x268, x266, x192, x242); + var x269: u32 = undefined; + var x270: u1 = undefined; + addcarryxU32(&x269, &x270, x268, x194, x244); + var x271: u32 = undefined; + var x272: u1 = undefined; + addcarryxU32(&x271, &x272, x270, x196, x246); + var x273: u32 = undefined; + var x274: u1 = undefined; + addcarryxU32(&x273, &x274, x272, x198, x248); + var x275: u32 = undefined; + var x276: u1 = undefined; + addcarryxU32(&x275, &x276, x274, x200, x250); + var x277: u32 = undefined; + var x278: u1 = undefined; + addcarryxU32(&x277, &x278, x276, x202, x252); + var x279: u32 = undefined; + var x280: u1 = undefined; + addcarryxU32(&x279, &x280, x278, x204, x254); + var x281: u32 = undefined; + var x282: u1 = undefined; + addcarryxU32(&x281, &x282, x280, x206, x256); + const x283 = (cast(u32, x282) + cast(u32, x207)); + var x284: u32 = undefined; + var x285: u32 = undefined; + mulxU32(&x284, &x285, x2, (arg1[11])); + var x286: u32 = undefined; + var x287: u32 = undefined; + mulxU32(&x286, &x287, x2, (arg1[10])); + var x288: u32 = undefined; + var x289: u32 = undefined; + mulxU32(&x288, &x289, x2, (arg1[9])); + var x290: u32 = undefined; + var x291: u32 = undefined; + mulxU32(&x290, &x291, x2, (arg1[8])); + var x292: u32 = undefined; + var x293: u32 = undefined; + mulxU32(&x292, &x293, x2, (arg1[7])); + var x294: u32 = undefined; + var x295: u32 = undefined; + mulxU32(&x294, &x295, x2, (arg1[6])); + var x296: u32 = undefined; + var x297: u32 = undefined; + mulxU32(&x296, &x297, x2, (arg1[5])); + var x298: u32 = undefined; + var x299: u32 = undefined; + mulxU32(&x298, &x299, x2, (arg1[4])); + var x300: u32 = undefined; + var x301: u32 = undefined; + mulxU32(&x300, &x301, x2, (arg1[3])); + var x302: u32 = undefined; + var x303: u32 = undefined; + mulxU32(&x302, &x303, x2, (arg1[2])); + var x304: u32 = undefined; + var x305: u32 = undefined; + mulxU32(&x304, &x305, x2, (arg1[1])); + var x306: u32 = undefined; + var x307: u32 = undefined; + mulxU32(&x306, &x307, x2, (arg1[0])); + var x308: u32 = undefined; + var x309: u1 = undefined; + addcarryxU32(&x308, &x309, 0x0, x307, x304); + var x310: u32 = undefined; + var x311: u1 = undefined; + addcarryxU32(&x310, &x311, x309, x305, x302); + var x312: u32 = undefined; + var x313: u1 = undefined; + addcarryxU32(&x312, &x313, x311, x303, x300); + var x314: u32 = undefined; + var x315: u1 = undefined; + addcarryxU32(&x314, &x315, x313, x301, x298); + var x316: u32 = undefined; + var x317: u1 = undefined; + addcarryxU32(&x316, &x317, x315, x299, x296); + var x318: u32 = undefined; + var x319: u1 = undefined; + addcarryxU32(&x318, &x319, x317, x297, x294); + var x320: u32 = undefined; + var x321: u1 = undefined; + addcarryxU32(&x320, &x321, x319, x295, x292); + var x322: u32 = undefined; + var x323: u1 = undefined; + addcarryxU32(&x322, &x323, x321, x293, x290); + var x324: u32 = undefined; + var x325: u1 = undefined; + addcarryxU32(&x324, &x325, x323, x291, x288); + var x326: u32 = undefined; + var x327: u1 = undefined; + addcarryxU32(&x326, &x327, x325, x289, x286); + var x328: u32 = undefined; + var x329: u1 = undefined; + addcarryxU32(&x328, &x329, x327, x287, x284); + const x330 = (cast(u32, x329) + x285); + var x331: u32 = undefined; + var x332: u1 = undefined; + addcarryxU32(&x331, &x332, 0x0, x259, x306); + var x333: u32 = undefined; + var x334: u1 = undefined; + addcarryxU32(&x333, &x334, x332, x261, x308); + var x335: u32 = undefined; + var x336: u1 = undefined; + addcarryxU32(&x335, &x336, x334, x263, x310); + var x337: u32 = undefined; + var x338: u1 = undefined; + addcarryxU32(&x337, &x338, x336, x265, x312); + var x339: u32 = undefined; + var x340: u1 = undefined; + addcarryxU32(&x339, &x340, x338, x267, x314); + var x341: u32 = undefined; + var x342: u1 = undefined; + addcarryxU32(&x341, &x342, x340, x269, x316); + var x343: u32 = undefined; + var x344: u1 = undefined; + addcarryxU32(&x343, &x344, x342, x271, x318); + var x345: u32 = undefined; + var x346: u1 = undefined; + addcarryxU32(&x345, &x346, x344, x273, x320); + var x347: u32 = undefined; + var x348: u1 = undefined; + addcarryxU32(&x347, &x348, x346, x275, x322); + var x349: u32 = undefined; + var x350: u1 = undefined; + addcarryxU32(&x349, &x350, x348, x277, x324); + var x351: u32 = undefined; + var x352: u1 = undefined; + addcarryxU32(&x351, &x352, x350, x279, x326); + var x353: u32 = undefined; + var x354: u1 = undefined; + addcarryxU32(&x353, &x354, x352, x281, x328); + var x355: u32 = undefined; + var x356: u1 = undefined; + addcarryxU32(&x355, &x356, x354, x283, x330); + var x357: u32 = undefined; + var x358: u32 = undefined; + mulxU32(&x357, &x358, x331, 0xe88fdc45); + var x359: u32 = undefined; + var x360: u32 = undefined; + mulxU32(&x359, &x360, x357, 0xffffffff); + var x361: u32 = undefined; + var x362: u32 = undefined; + mulxU32(&x361, &x362, x357, 0xffffffff); + var x363: u32 = undefined; + var x364: u32 = undefined; + mulxU32(&x363, &x364, x357, 0xffffffff); + var x365: u32 = undefined; + var x366: u32 = undefined; + mulxU32(&x365, &x366, x357, 0xffffffff); + var x367: u32 = undefined; + var x368: u32 = undefined; + mulxU32(&x367, &x368, x357, 0xffffffff); + var x369: u32 = undefined; + var x370: u32 = undefined; + mulxU32(&x369, &x370, x357, 0xffffffff); + var x371: u32 = undefined; + var x372: u32 = undefined; + mulxU32(&x371, &x372, x357, 0xc7634d81); + var x373: u32 = undefined; + var x374: u32 = undefined; + mulxU32(&x373, &x374, x357, 0xf4372ddf); + var x375: u32 = undefined; + var x376: u32 = undefined; + mulxU32(&x375, &x376, x357, 0x581a0db2); + var x377: u32 = undefined; + var x378: u32 = undefined; + mulxU32(&x377, &x378, x357, 0x48b0a77a); + var x379: u32 = undefined; + var x380: u32 = undefined; + mulxU32(&x379, &x380, x357, 0xecec196a); + var x381: u32 = undefined; + var x382: u32 = undefined; + mulxU32(&x381, &x382, x357, 0xccc52973); + var x383: u32 = undefined; + var x384: u1 = undefined; + addcarryxU32(&x383, &x384, 0x0, x382, x379); + var x385: u32 = undefined; + var x386: u1 = undefined; + addcarryxU32(&x385, &x386, x384, x380, x377); + var x387: u32 = undefined; + var x388: u1 = undefined; + addcarryxU32(&x387, &x388, x386, x378, x375); + var x389: u32 = undefined; + var x390: u1 = undefined; + addcarryxU32(&x389, &x390, x388, x376, x373); + var x391: u32 = undefined; + var x392: u1 = undefined; + addcarryxU32(&x391, &x392, x390, x374, x371); + var x393: u32 = undefined; + var x394: u1 = undefined; + addcarryxU32(&x393, &x394, x392, x372, x369); + var x395: u32 = undefined; + var x396: u1 = undefined; + addcarryxU32(&x395, &x396, x394, x370, x367); + var x397: u32 = undefined; + var x398: u1 = undefined; + addcarryxU32(&x397, &x398, x396, x368, x365); + var x399: u32 = undefined; + var x400: u1 = undefined; + addcarryxU32(&x399, &x400, x398, x366, x363); + var x401: u32 = undefined; + var x402: u1 = undefined; + addcarryxU32(&x401, &x402, x400, x364, x361); + var x403: u32 = undefined; + var x404: u1 = undefined; + addcarryxU32(&x403, &x404, x402, x362, x359); + const x405 = (cast(u32, x404) + x360); + var x406: u32 = undefined; + var x407: u1 = undefined; + addcarryxU32(&x406, &x407, 0x0, x331, x381); + var x408: u32 = undefined; + var x409: u1 = undefined; + addcarryxU32(&x408, &x409, x407, x333, x383); + var x410: u32 = undefined; + var x411: u1 = undefined; + addcarryxU32(&x410, &x411, x409, x335, x385); + var x412: u32 = undefined; + var x413: u1 = undefined; + addcarryxU32(&x412, &x413, x411, x337, x387); + var x414: u32 = undefined; + var x415: u1 = undefined; + addcarryxU32(&x414, &x415, x413, x339, x389); + var x416: u32 = undefined; + var x417: u1 = undefined; + addcarryxU32(&x416, &x417, x415, x341, x391); + var x418: u32 = undefined; + var x419: u1 = undefined; + addcarryxU32(&x418, &x419, x417, x343, x393); + var x420: u32 = undefined; + var x421: u1 = undefined; + addcarryxU32(&x420, &x421, x419, x345, x395); + var x422: u32 = undefined; + var x423: u1 = undefined; + addcarryxU32(&x422, &x423, x421, x347, x397); + var x424: u32 = undefined; + var x425: u1 = undefined; + addcarryxU32(&x424, &x425, x423, x349, x399); + var x426: u32 = undefined; + var x427: u1 = undefined; + addcarryxU32(&x426, &x427, x425, x351, x401); + var x428: u32 = undefined; + var x429: u1 = undefined; + addcarryxU32(&x428, &x429, x427, x353, x403); + var x430: u32 = undefined; + var x431: u1 = undefined; + addcarryxU32(&x430, &x431, x429, x355, x405); + const x432 = (cast(u32, x431) + cast(u32, x356)); + var x433: u32 = undefined; + var x434: u32 = undefined; + mulxU32(&x433, &x434, x3, (arg1[11])); + var x435: u32 = undefined; + var x436: u32 = undefined; + mulxU32(&x435, &x436, x3, (arg1[10])); + var x437: u32 = undefined; + var x438: u32 = undefined; + mulxU32(&x437, &x438, x3, (arg1[9])); + var x439: u32 = undefined; + var x440: u32 = undefined; + mulxU32(&x439, &x440, x3, (arg1[8])); + var x441: u32 = undefined; + var x442: u32 = undefined; + mulxU32(&x441, &x442, x3, (arg1[7])); + var x443: u32 = undefined; + var x444: u32 = undefined; + mulxU32(&x443, &x444, x3, (arg1[6])); + var x445: u32 = undefined; + var x446: u32 = undefined; + mulxU32(&x445, &x446, x3, (arg1[5])); + var x447: u32 = undefined; + var x448: u32 = undefined; + mulxU32(&x447, &x448, x3, (arg1[4])); + var x449: u32 = undefined; + var x450: u32 = undefined; + mulxU32(&x449, &x450, x3, (arg1[3])); + var x451: u32 = undefined; + var x452: u32 = undefined; + mulxU32(&x451, &x452, x3, (arg1[2])); + var x453: u32 = undefined; + var x454: u32 = undefined; + mulxU32(&x453, &x454, x3, (arg1[1])); + var x455: u32 = undefined; + var x456: u32 = undefined; + mulxU32(&x455, &x456, x3, (arg1[0])); + var x457: u32 = undefined; + var x458: u1 = undefined; + addcarryxU32(&x457, &x458, 0x0, x456, x453); + var x459: u32 = undefined; + var x460: u1 = undefined; + addcarryxU32(&x459, &x460, x458, x454, x451); + var x461: u32 = undefined; + var x462: u1 = undefined; + addcarryxU32(&x461, &x462, x460, x452, x449); + var x463: u32 = undefined; + var x464: u1 = undefined; + addcarryxU32(&x463, &x464, x462, x450, x447); + var x465: u32 = undefined; + var x466: u1 = undefined; + addcarryxU32(&x465, &x466, x464, x448, x445); + var x467: u32 = undefined; + var x468: u1 = undefined; + addcarryxU32(&x467, &x468, x466, x446, x443); + var x469: u32 = undefined; + var x470: u1 = undefined; + addcarryxU32(&x469, &x470, x468, x444, x441); + var x471: u32 = undefined; + var x472: u1 = undefined; + addcarryxU32(&x471, &x472, x470, x442, x439); + var x473: u32 = undefined; + var x474: u1 = undefined; + addcarryxU32(&x473, &x474, x472, x440, x437); + var x475: u32 = undefined; + var x476: u1 = undefined; + addcarryxU32(&x475, &x476, x474, x438, x435); + var x477: u32 = undefined; + var x478: u1 = undefined; + addcarryxU32(&x477, &x478, x476, x436, x433); + const x479 = (cast(u32, x478) + x434); + var x480: u32 = undefined; + var x481: u1 = undefined; + addcarryxU32(&x480, &x481, 0x0, x408, x455); + var x482: u32 = undefined; + var x483: u1 = undefined; + addcarryxU32(&x482, &x483, x481, x410, x457); + var x484: u32 = undefined; + var x485: u1 = undefined; + addcarryxU32(&x484, &x485, x483, x412, x459); + var x486: u32 = undefined; + var x487: u1 = undefined; + addcarryxU32(&x486, &x487, x485, x414, x461); + var x488: u32 = undefined; + var x489: u1 = undefined; + addcarryxU32(&x488, &x489, x487, x416, x463); + var x490: u32 = undefined; + var x491: u1 = undefined; + addcarryxU32(&x490, &x491, x489, x418, x465); + var x492: u32 = undefined; + var x493: u1 = undefined; + addcarryxU32(&x492, &x493, x491, x420, x467); + var x494: u32 = undefined; + var x495: u1 = undefined; + addcarryxU32(&x494, &x495, x493, x422, x469); + var x496: u32 = undefined; + var x497: u1 = undefined; + addcarryxU32(&x496, &x497, x495, x424, x471); + var x498: u32 = undefined; + var x499: u1 = undefined; + addcarryxU32(&x498, &x499, x497, x426, x473); + var x500: u32 = undefined; + var x501: u1 = undefined; + addcarryxU32(&x500, &x501, x499, x428, x475); + var x502: u32 = undefined; + var x503: u1 = undefined; + addcarryxU32(&x502, &x503, x501, x430, x477); + var x504: u32 = undefined; + var x505: u1 = undefined; + addcarryxU32(&x504, &x505, x503, x432, x479); + var x506: u32 = undefined; + var x507: u32 = undefined; + mulxU32(&x506, &x507, x480, 0xe88fdc45); + var x508: u32 = undefined; + var x509: u32 = undefined; + mulxU32(&x508, &x509, x506, 0xffffffff); + var x510: u32 = undefined; + var x511: u32 = undefined; + mulxU32(&x510, &x511, x506, 0xffffffff); + var x512: u32 = undefined; + var x513: u32 = undefined; + mulxU32(&x512, &x513, x506, 0xffffffff); + var x514: u32 = undefined; + var x515: u32 = undefined; + mulxU32(&x514, &x515, x506, 0xffffffff); + var x516: u32 = undefined; + var x517: u32 = undefined; + mulxU32(&x516, &x517, x506, 0xffffffff); + var x518: u32 = undefined; + var x519: u32 = undefined; + mulxU32(&x518, &x519, x506, 0xffffffff); + var x520: u32 = undefined; + var x521: u32 = undefined; + mulxU32(&x520, &x521, x506, 0xc7634d81); + var x522: u32 = undefined; + var x523: u32 = undefined; + mulxU32(&x522, &x523, x506, 0xf4372ddf); + var x524: u32 = undefined; + var x525: u32 = undefined; + mulxU32(&x524, &x525, x506, 0x581a0db2); + var x526: u32 = undefined; + var x527: u32 = undefined; + mulxU32(&x526, &x527, x506, 0x48b0a77a); + var x528: u32 = undefined; + var x529: u32 = undefined; + mulxU32(&x528, &x529, x506, 0xecec196a); + var x530: u32 = undefined; + var x531: u32 = undefined; + mulxU32(&x530, &x531, x506, 0xccc52973); + var x532: u32 = undefined; + var x533: u1 = undefined; + addcarryxU32(&x532, &x533, 0x0, x531, x528); + var x534: u32 = undefined; + var x535: u1 = undefined; + addcarryxU32(&x534, &x535, x533, x529, x526); + var x536: u32 = undefined; + var x537: u1 = undefined; + addcarryxU32(&x536, &x537, x535, x527, x524); + var x538: u32 = undefined; + var x539: u1 = undefined; + addcarryxU32(&x538, &x539, x537, x525, x522); + var x540: u32 = undefined; + var x541: u1 = undefined; + addcarryxU32(&x540, &x541, x539, x523, x520); + var x542: u32 = undefined; + var x543: u1 = undefined; + addcarryxU32(&x542, &x543, x541, x521, x518); + var x544: u32 = undefined; + var x545: u1 = undefined; + addcarryxU32(&x544, &x545, x543, x519, x516); + var x546: u32 = undefined; + var x547: u1 = undefined; + addcarryxU32(&x546, &x547, x545, x517, x514); + var x548: u32 = undefined; + var x549: u1 = undefined; + addcarryxU32(&x548, &x549, x547, x515, x512); + var x550: u32 = undefined; + var x551: u1 = undefined; + addcarryxU32(&x550, &x551, x549, x513, x510); + var x552: u32 = undefined; + var x553: u1 = undefined; + addcarryxU32(&x552, &x553, x551, x511, x508); + const x554 = (cast(u32, x553) + x509); + var x555: u32 = undefined; + var x556: u1 = undefined; + addcarryxU32(&x555, &x556, 0x0, x480, x530); + var x557: u32 = undefined; + var x558: u1 = undefined; + addcarryxU32(&x557, &x558, x556, x482, x532); + var x559: u32 = undefined; + var x560: u1 = undefined; + addcarryxU32(&x559, &x560, x558, x484, x534); + var x561: u32 = undefined; + var x562: u1 = undefined; + addcarryxU32(&x561, &x562, x560, x486, x536); + var x563: u32 = undefined; + var x564: u1 = undefined; + addcarryxU32(&x563, &x564, x562, x488, x538); + var x565: u32 = undefined; + var x566: u1 = undefined; + addcarryxU32(&x565, &x566, x564, x490, x540); + var x567: u32 = undefined; + var x568: u1 = undefined; + addcarryxU32(&x567, &x568, x566, x492, x542); + var x569: u32 = undefined; + var x570: u1 = undefined; + addcarryxU32(&x569, &x570, x568, x494, x544); + var x571: u32 = undefined; + var x572: u1 = undefined; + addcarryxU32(&x571, &x572, x570, x496, x546); + var x573: u32 = undefined; + var x574: u1 = undefined; + addcarryxU32(&x573, &x574, x572, x498, x548); + var x575: u32 = undefined; + var x576: u1 = undefined; + addcarryxU32(&x575, &x576, x574, x500, x550); + var x577: u32 = undefined; + var x578: u1 = undefined; + addcarryxU32(&x577, &x578, x576, x502, x552); + var x579: u32 = undefined; + var x580: u1 = undefined; + addcarryxU32(&x579, &x580, x578, x504, x554); + const x581 = (cast(u32, x580) + cast(u32, x505)); + var x582: u32 = undefined; + var x583: u32 = undefined; + mulxU32(&x582, &x583, x4, (arg1[11])); + var x584: u32 = undefined; + var x585: u32 = undefined; + mulxU32(&x584, &x585, x4, (arg1[10])); + var x586: u32 = undefined; + var x587: u32 = undefined; + mulxU32(&x586, &x587, x4, (arg1[9])); + var x588: u32 = undefined; + var x589: u32 = undefined; + mulxU32(&x588, &x589, x4, (arg1[8])); + var x590: u32 = undefined; + var x591: u32 = undefined; + mulxU32(&x590, &x591, x4, (arg1[7])); + var x592: u32 = undefined; + var x593: u32 = undefined; + mulxU32(&x592, &x593, x4, (arg1[6])); + var x594: u32 = undefined; + var x595: u32 = undefined; + mulxU32(&x594, &x595, x4, (arg1[5])); + var x596: u32 = undefined; + var x597: u32 = undefined; + mulxU32(&x596, &x597, x4, (arg1[4])); + var x598: u32 = undefined; + var x599: u32 = undefined; + mulxU32(&x598, &x599, x4, (arg1[3])); + var x600: u32 = undefined; + var x601: u32 = undefined; + mulxU32(&x600, &x601, x4, (arg1[2])); + var x602: u32 = undefined; + var x603: u32 = undefined; + mulxU32(&x602, &x603, x4, (arg1[1])); + var x604: u32 = undefined; + var x605: u32 = undefined; + mulxU32(&x604, &x605, x4, (arg1[0])); + var x606: u32 = undefined; + var x607: u1 = undefined; + addcarryxU32(&x606, &x607, 0x0, x605, x602); + var x608: u32 = undefined; + var x609: u1 = undefined; + addcarryxU32(&x608, &x609, x607, x603, x600); + var x610: u32 = undefined; + var x611: u1 = undefined; + addcarryxU32(&x610, &x611, x609, x601, x598); + var x612: u32 = undefined; + var x613: u1 = undefined; + addcarryxU32(&x612, &x613, x611, x599, x596); + var x614: u32 = undefined; + var x615: u1 = undefined; + addcarryxU32(&x614, &x615, x613, x597, x594); + var x616: u32 = undefined; + var x617: u1 = undefined; + addcarryxU32(&x616, &x617, x615, x595, x592); + var x618: u32 = undefined; + var x619: u1 = undefined; + addcarryxU32(&x618, &x619, x617, x593, x590); + var x620: u32 = undefined; + var x621: u1 = undefined; + addcarryxU32(&x620, &x621, x619, x591, x588); + var x622: u32 = undefined; + var x623: u1 = undefined; + addcarryxU32(&x622, &x623, x621, x589, x586); + var x624: u32 = undefined; + var x625: u1 = undefined; + addcarryxU32(&x624, &x625, x623, x587, x584); + var x626: u32 = undefined; + var x627: u1 = undefined; + addcarryxU32(&x626, &x627, x625, x585, x582); + const x628 = (cast(u32, x627) + x583); + var x629: u32 = undefined; + var x630: u1 = undefined; + addcarryxU32(&x629, &x630, 0x0, x557, x604); + var x631: u32 = undefined; + var x632: u1 = undefined; + addcarryxU32(&x631, &x632, x630, x559, x606); + var x633: u32 = undefined; + var x634: u1 = undefined; + addcarryxU32(&x633, &x634, x632, x561, x608); + var x635: u32 = undefined; + var x636: u1 = undefined; + addcarryxU32(&x635, &x636, x634, x563, x610); + var x637: u32 = undefined; + var x638: u1 = undefined; + addcarryxU32(&x637, &x638, x636, x565, x612); + var x639: u32 = undefined; + var x640: u1 = undefined; + addcarryxU32(&x639, &x640, x638, x567, x614); + var x641: u32 = undefined; + var x642: u1 = undefined; + addcarryxU32(&x641, &x642, x640, x569, x616); + var x643: u32 = undefined; + var x644: u1 = undefined; + addcarryxU32(&x643, &x644, x642, x571, x618); + var x645: u32 = undefined; + var x646: u1 = undefined; + addcarryxU32(&x645, &x646, x644, x573, x620); + var x647: u32 = undefined; + var x648: u1 = undefined; + addcarryxU32(&x647, &x648, x646, x575, x622); + var x649: u32 = undefined; + var x650: u1 = undefined; + addcarryxU32(&x649, &x650, x648, x577, x624); + var x651: u32 = undefined; + var x652: u1 = undefined; + addcarryxU32(&x651, &x652, x650, x579, x626); + var x653: u32 = undefined; + var x654: u1 = undefined; + addcarryxU32(&x653, &x654, x652, x581, x628); + var x655: u32 = undefined; + var x656: u32 = undefined; + mulxU32(&x655, &x656, x629, 0xe88fdc45); + var x657: u32 = undefined; + var x658: u32 = undefined; + mulxU32(&x657, &x658, x655, 0xffffffff); + var x659: u32 = undefined; + var x660: u32 = undefined; + mulxU32(&x659, &x660, x655, 0xffffffff); + var x661: u32 = undefined; + var x662: u32 = undefined; + mulxU32(&x661, &x662, x655, 0xffffffff); + var x663: u32 = undefined; + var x664: u32 = undefined; + mulxU32(&x663, &x664, x655, 0xffffffff); + var x665: u32 = undefined; + var x666: u32 = undefined; + mulxU32(&x665, &x666, x655, 0xffffffff); + var x667: u32 = undefined; + var x668: u32 = undefined; + mulxU32(&x667, &x668, x655, 0xffffffff); + var x669: u32 = undefined; + var x670: u32 = undefined; + mulxU32(&x669, &x670, x655, 0xc7634d81); + var x671: u32 = undefined; + var x672: u32 = undefined; + mulxU32(&x671, &x672, x655, 0xf4372ddf); + var x673: u32 = undefined; + var x674: u32 = undefined; + mulxU32(&x673, &x674, x655, 0x581a0db2); + var x675: u32 = undefined; + var x676: u32 = undefined; + mulxU32(&x675, &x676, x655, 0x48b0a77a); + var x677: u32 = undefined; + var x678: u32 = undefined; + mulxU32(&x677, &x678, x655, 0xecec196a); + var x679: u32 = undefined; + var x680: u32 = undefined; + mulxU32(&x679, &x680, x655, 0xccc52973); + var x681: u32 = undefined; + var x682: u1 = undefined; + addcarryxU32(&x681, &x682, 0x0, x680, x677); + var x683: u32 = undefined; + var x684: u1 = undefined; + addcarryxU32(&x683, &x684, x682, x678, x675); + var x685: u32 = undefined; + var x686: u1 = undefined; + addcarryxU32(&x685, &x686, x684, x676, x673); + var x687: u32 = undefined; + var x688: u1 = undefined; + addcarryxU32(&x687, &x688, x686, x674, x671); + var x689: u32 = undefined; + var x690: u1 = undefined; + addcarryxU32(&x689, &x690, x688, x672, x669); + var x691: u32 = undefined; + var x692: u1 = undefined; + addcarryxU32(&x691, &x692, x690, x670, x667); + var x693: u32 = undefined; + var x694: u1 = undefined; + addcarryxU32(&x693, &x694, x692, x668, x665); + var x695: u32 = undefined; + var x696: u1 = undefined; + addcarryxU32(&x695, &x696, x694, x666, x663); + var x697: u32 = undefined; + var x698: u1 = undefined; + addcarryxU32(&x697, &x698, x696, x664, x661); + var x699: u32 = undefined; + var x700: u1 = undefined; + addcarryxU32(&x699, &x700, x698, x662, x659); + var x701: u32 = undefined; + var x702: u1 = undefined; + addcarryxU32(&x701, &x702, x700, x660, x657); + const x703 = (cast(u32, x702) + x658); + var x704: u32 = undefined; + var x705: u1 = undefined; + addcarryxU32(&x704, &x705, 0x0, x629, x679); + var x706: u32 = undefined; + var x707: u1 = undefined; + addcarryxU32(&x706, &x707, x705, x631, x681); + var x708: u32 = undefined; + var x709: u1 = undefined; + addcarryxU32(&x708, &x709, x707, x633, x683); + var x710: u32 = undefined; + var x711: u1 = undefined; + addcarryxU32(&x710, &x711, x709, x635, x685); + var x712: u32 = undefined; + var x713: u1 = undefined; + addcarryxU32(&x712, &x713, x711, x637, x687); + var x714: u32 = undefined; + var x715: u1 = undefined; + addcarryxU32(&x714, &x715, x713, x639, x689); + var x716: u32 = undefined; + var x717: u1 = undefined; + addcarryxU32(&x716, &x717, x715, x641, x691); + var x718: u32 = undefined; + var x719: u1 = undefined; + addcarryxU32(&x718, &x719, x717, x643, x693); + var x720: u32 = undefined; + var x721: u1 = undefined; + addcarryxU32(&x720, &x721, x719, x645, x695); + var x722: u32 = undefined; + var x723: u1 = undefined; + addcarryxU32(&x722, &x723, x721, x647, x697); + var x724: u32 = undefined; + var x725: u1 = undefined; + addcarryxU32(&x724, &x725, x723, x649, x699); + var x726: u32 = undefined; + var x727: u1 = undefined; + addcarryxU32(&x726, &x727, x725, x651, x701); + var x728: u32 = undefined; + var x729: u1 = undefined; + addcarryxU32(&x728, &x729, x727, x653, x703); + const x730 = (cast(u32, x729) + cast(u32, x654)); + var x731: u32 = undefined; + var x732: u32 = undefined; + mulxU32(&x731, &x732, x5, (arg1[11])); + var x733: u32 = undefined; + var x734: u32 = undefined; + mulxU32(&x733, &x734, x5, (arg1[10])); + var x735: u32 = undefined; + var x736: u32 = undefined; + mulxU32(&x735, &x736, x5, (arg1[9])); + var x737: u32 = undefined; + var x738: u32 = undefined; + mulxU32(&x737, &x738, x5, (arg1[8])); + var x739: u32 = undefined; + var x740: u32 = undefined; + mulxU32(&x739, &x740, x5, (arg1[7])); + var x741: u32 = undefined; + var x742: u32 = undefined; + mulxU32(&x741, &x742, x5, (arg1[6])); + var x743: u32 = undefined; + var x744: u32 = undefined; + mulxU32(&x743, &x744, x5, (arg1[5])); + var x745: u32 = undefined; + var x746: u32 = undefined; + mulxU32(&x745, &x746, x5, (arg1[4])); + var x747: u32 = undefined; + var x748: u32 = undefined; + mulxU32(&x747, &x748, x5, (arg1[3])); + var x749: u32 = undefined; + var x750: u32 = undefined; + mulxU32(&x749, &x750, x5, (arg1[2])); + var x751: u32 = undefined; + var x752: u32 = undefined; + mulxU32(&x751, &x752, x5, (arg1[1])); + var x753: u32 = undefined; + var x754: u32 = undefined; + mulxU32(&x753, &x754, x5, (arg1[0])); + var x755: u32 = undefined; + var x756: u1 = undefined; + addcarryxU32(&x755, &x756, 0x0, x754, x751); + var x757: u32 = undefined; + var x758: u1 = undefined; + addcarryxU32(&x757, &x758, x756, x752, x749); + var x759: u32 = undefined; + var x760: u1 = undefined; + addcarryxU32(&x759, &x760, x758, x750, x747); + var x761: u32 = undefined; + var x762: u1 = undefined; + addcarryxU32(&x761, &x762, x760, x748, x745); + var x763: u32 = undefined; + var x764: u1 = undefined; + addcarryxU32(&x763, &x764, x762, x746, x743); + var x765: u32 = undefined; + var x766: u1 = undefined; + addcarryxU32(&x765, &x766, x764, x744, x741); + var x767: u32 = undefined; + var x768: u1 = undefined; + addcarryxU32(&x767, &x768, x766, x742, x739); + var x769: u32 = undefined; + var x770: u1 = undefined; + addcarryxU32(&x769, &x770, x768, x740, x737); + var x771: u32 = undefined; + var x772: u1 = undefined; + addcarryxU32(&x771, &x772, x770, x738, x735); + var x773: u32 = undefined; + var x774: u1 = undefined; + addcarryxU32(&x773, &x774, x772, x736, x733); + var x775: u32 = undefined; + var x776: u1 = undefined; + addcarryxU32(&x775, &x776, x774, x734, x731); + const x777 = (cast(u32, x776) + x732); + var x778: u32 = undefined; + var x779: u1 = undefined; + addcarryxU32(&x778, &x779, 0x0, x706, x753); + var x780: u32 = undefined; + var x781: u1 = undefined; + addcarryxU32(&x780, &x781, x779, x708, x755); + var x782: u32 = undefined; + var x783: u1 = undefined; + addcarryxU32(&x782, &x783, x781, x710, x757); + var x784: u32 = undefined; + var x785: u1 = undefined; + addcarryxU32(&x784, &x785, x783, x712, x759); + var x786: u32 = undefined; + var x787: u1 = undefined; + addcarryxU32(&x786, &x787, x785, x714, x761); + var x788: u32 = undefined; + var x789: u1 = undefined; + addcarryxU32(&x788, &x789, x787, x716, x763); + var x790: u32 = undefined; + var x791: u1 = undefined; + addcarryxU32(&x790, &x791, x789, x718, x765); + var x792: u32 = undefined; + var x793: u1 = undefined; + addcarryxU32(&x792, &x793, x791, x720, x767); + var x794: u32 = undefined; + var x795: u1 = undefined; + addcarryxU32(&x794, &x795, x793, x722, x769); + var x796: u32 = undefined; + var x797: u1 = undefined; + addcarryxU32(&x796, &x797, x795, x724, x771); + var x798: u32 = undefined; + var x799: u1 = undefined; + addcarryxU32(&x798, &x799, x797, x726, x773); + var x800: u32 = undefined; + var x801: u1 = undefined; + addcarryxU32(&x800, &x801, x799, x728, x775); + var x802: u32 = undefined; + var x803: u1 = undefined; + addcarryxU32(&x802, &x803, x801, x730, x777); + var x804: u32 = undefined; + var x805: u32 = undefined; + mulxU32(&x804, &x805, x778, 0xe88fdc45); + var x806: u32 = undefined; + var x807: u32 = undefined; + mulxU32(&x806, &x807, x804, 0xffffffff); + var x808: u32 = undefined; + var x809: u32 = undefined; + mulxU32(&x808, &x809, x804, 0xffffffff); + var x810: u32 = undefined; + var x811: u32 = undefined; + mulxU32(&x810, &x811, x804, 0xffffffff); + var x812: u32 = undefined; + var x813: u32 = undefined; + mulxU32(&x812, &x813, x804, 0xffffffff); + var x814: u32 = undefined; + var x815: u32 = undefined; + mulxU32(&x814, &x815, x804, 0xffffffff); + var x816: u32 = undefined; + var x817: u32 = undefined; + mulxU32(&x816, &x817, x804, 0xffffffff); + var x818: u32 = undefined; + var x819: u32 = undefined; + mulxU32(&x818, &x819, x804, 0xc7634d81); + var x820: u32 = undefined; + var x821: u32 = undefined; + mulxU32(&x820, &x821, x804, 0xf4372ddf); + var x822: u32 = undefined; + var x823: u32 = undefined; + mulxU32(&x822, &x823, x804, 0x581a0db2); + var x824: u32 = undefined; + var x825: u32 = undefined; + mulxU32(&x824, &x825, x804, 0x48b0a77a); + var x826: u32 = undefined; + var x827: u32 = undefined; + mulxU32(&x826, &x827, x804, 0xecec196a); + var x828: u32 = undefined; + var x829: u32 = undefined; + mulxU32(&x828, &x829, x804, 0xccc52973); + var x830: u32 = undefined; + var x831: u1 = undefined; + addcarryxU32(&x830, &x831, 0x0, x829, x826); + var x832: u32 = undefined; + var x833: u1 = undefined; + addcarryxU32(&x832, &x833, x831, x827, x824); + var x834: u32 = undefined; + var x835: u1 = undefined; + addcarryxU32(&x834, &x835, x833, x825, x822); + var x836: u32 = undefined; + var x837: u1 = undefined; + addcarryxU32(&x836, &x837, x835, x823, x820); + var x838: u32 = undefined; + var x839: u1 = undefined; + addcarryxU32(&x838, &x839, x837, x821, x818); + var x840: u32 = undefined; + var x841: u1 = undefined; + addcarryxU32(&x840, &x841, x839, x819, x816); + var x842: u32 = undefined; + var x843: u1 = undefined; + addcarryxU32(&x842, &x843, x841, x817, x814); + var x844: u32 = undefined; + var x845: u1 = undefined; + addcarryxU32(&x844, &x845, x843, x815, x812); + var x846: u32 = undefined; + var x847: u1 = undefined; + addcarryxU32(&x846, &x847, x845, x813, x810); + var x848: u32 = undefined; + var x849: u1 = undefined; + addcarryxU32(&x848, &x849, x847, x811, x808); + var x850: u32 = undefined; + var x851: u1 = undefined; + addcarryxU32(&x850, &x851, x849, x809, x806); + const x852 = (cast(u32, x851) + x807); + var x853: u32 = undefined; + var x854: u1 = undefined; + addcarryxU32(&x853, &x854, 0x0, x778, x828); + var x855: u32 = undefined; + var x856: u1 = undefined; + addcarryxU32(&x855, &x856, x854, x780, x830); + var x857: u32 = undefined; + var x858: u1 = undefined; + addcarryxU32(&x857, &x858, x856, x782, x832); + var x859: u32 = undefined; + var x860: u1 = undefined; + addcarryxU32(&x859, &x860, x858, x784, x834); + var x861: u32 = undefined; + var x862: u1 = undefined; + addcarryxU32(&x861, &x862, x860, x786, x836); + var x863: u32 = undefined; + var x864: u1 = undefined; + addcarryxU32(&x863, &x864, x862, x788, x838); + var x865: u32 = undefined; + var x866: u1 = undefined; + addcarryxU32(&x865, &x866, x864, x790, x840); + var x867: u32 = undefined; + var x868: u1 = undefined; + addcarryxU32(&x867, &x868, x866, x792, x842); + var x869: u32 = undefined; + var x870: u1 = undefined; + addcarryxU32(&x869, &x870, x868, x794, x844); + var x871: u32 = undefined; + var x872: u1 = undefined; + addcarryxU32(&x871, &x872, x870, x796, x846); + var x873: u32 = undefined; + var x874: u1 = undefined; + addcarryxU32(&x873, &x874, x872, x798, x848); + var x875: u32 = undefined; + var x876: u1 = undefined; + addcarryxU32(&x875, &x876, x874, x800, x850); + var x877: u32 = undefined; + var x878: u1 = undefined; + addcarryxU32(&x877, &x878, x876, x802, x852); + const x879 = (cast(u32, x878) + cast(u32, x803)); + var x880: u32 = undefined; + var x881: u32 = undefined; + mulxU32(&x880, &x881, x6, (arg1[11])); + var x882: u32 = undefined; + var x883: u32 = undefined; + mulxU32(&x882, &x883, x6, (arg1[10])); + var x884: u32 = undefined; + var x885: u32 = undefined; + mulxU32(&x884, &x885, x6, (arg1[9])); + var x886: u32 = undefined; + var x887: u32 = undefined; + mulxU32(&x886, &x887, x6, (arg1[8])); + var x888: u32 = undefined; + var x889: u32 = undefined; + mulxU32(&x888, &x889, x6, (arg1[7])); + var x890: u32 = undefined; + var x891: u32 = undefined; + mulxU32(&x890, &x891, x6, (arg1[6])); + var x892: u32 = undefined; + var x893: u32 = undefined; + mulxU32(&x892, &x893, x6, (arg1[5])); + var x894: u32 = undefined; + var x895: u32 = undefined; + mulxU32(&x894, &x895, x6, (arg1[4])); + var x896: u32 = undefined; + var x897: u32 = undefined; + mulxU32(&x896, &x897, x6, (arg1[3])); + var x898: u32 = undefined; + var x899: u32 = undefined; + mulxU32(&x898, &x899, x6, (arg1[2])); + var x900: u32 = undefined; + var x901: u32 = undefined; + mulxU32(&x900, &x901, x6, (arg1[1])); + var x902: u32 = undefined; + var x903: u32 = undefined; + mulxU32(&x902, &x903, x6, (arg1[0])); + var x904: u32 = undefined; + var x905: u1 = undefined; + addcarryxU32(&x904, &x905, 0x0, x903, x900); + var x906: u32 = undefined; + var x907: u1 = undefined; + addcarryxU32(&x906, &x907, x905, x901, x898); + var x908: u32 = undefined; + var x909: u1 = undefined; + addcarryxU32(&x908, &x909, x907, x899, x896); + var x910: u32 = undefined; + var x911: u1 = undefined; + addcarryxU32(&x910, &x911, x909, x897, x894); + var x912: u32 = undefined; + var x913: u1 = undefined; + addcarryxU32(&x912, &x913, x911, x895, x892); + var x914: u32 = undefined; + var x915: u1 = undefined; + addcarryxU32(&x914, &x915, x913, x893, x890); + var x916: u32 = undefined; + var x917: u1 = undefined; + addcarryxU32(&x916, &x917, x915, x891, x888); + var x918: u32 = undefined; + var x919: u1 = undefined; + addcarryxU32(&x918, &x919, x917, x889, x886); + var x920: u32 = undefined; + var x921: u1 = undefined; + addcarryxU32(&x920, &x921, x919, x887, x884); + var x922: u32 = undefined; + var x923: u1 = undefined; + addcarryxU32(&x922, &x923, x921, x885, x882); + var x924: u32 = undefined; + var x925: u1 = undefined; + addcarryxU32(&x924, &x925, x923, x883, x880); + const x926 = (cast(u32, x925) + x881); + var x927: u32 = undefined; + var x928: u1 = undefined; + addcarryxU32(&x927, &x928, 0x0, x855, x902); + var x929: u32 = undefined; + var x930: u1 = undefined; + addcarryxU32(&x929, &x930, x928, x857, x904); + var x931: u32 = undefined; + var x932: u1 = undefined; + addcarryxU32(&x931, &x932, x930, x859, x906); + var x933: u32 = undefined; + var x934: u1 = undefined; + addcarryxU32(&x933, &x934, x932, x861, x908); + var x935: u32 = undefined; + var x936: u1 = undefined; + addcarryxU32(&x935, &x936, x934, x863, x910); + var x937: u32 = undefined; + var x938: u1 = undefined; + addcarryxU32(&x937, &x938, x936, x865, x912); + var x939: u32 = undefined; + var x940: u1 = undefined; + addcarryxU32(&x939, &x940, x938, x867, x914); + var x941: u32 = undefined; + var x942: u1 = undefined; + addcarryxU32(&x941, &x942, x940, x869, x916); + var x943: u32 = undefined; + var x944: u1 = undefined; + addcarryxU32(&x943, &x944, x942, x871, x918); + var x945: u32 = undefined; + var x946: u1 = undefined; + addcarryxU32(&x945, &x946, x944, x873, x920); + var x947: u32 = undefined; + var x948: u1 = undefined; + addcarryxU32(&x947, &x948, x946, x875, x922); + var x949: u32 = undefined; + var x950: u1 = undefined; + addcarryxU32(&x949, &x950, x948, x877, x924); + var x951: u32 = undefined; + var x952: u1 = undefined; + addcarryxU32(&x951, &x952, x950, x879, x926); + var x953: u32 = undefined; + var x954: u32 = undefined; + mulxU32(&x953, &x954, x927, 0xe88fdc45); + var x955: u32 = undefined; + var x956: u32 = undefined; + mulxU32(&x955, &x956, x953, 0xffffffff); + var x957: u32 = undefined; + var x958: u32 = undefined; + mulxU32(&x957, &x958, x953, 0xffffffff); + var x959: u32 = undefined; + var x960: u32 = undefined; + mulxU32(&x959, &x960, x953, 0xffffffff); + var x961: u32 = undefined; + var x962: u32 = undefined; + mulxU32(&x961, &x962, x953, 0xffffffff); + var x963: u32 = undefined; + var x964: u32 = undefined; + mulxU32(&x963, &x964, x953, 0xffffffff); + var x965: u32 = undefined; + var x966: u32 = undefined; + mulxU32(&x965, &x966, x953, 0xffffffff); + var x967: u32 = undefined; + var x968: u32 = undefined; + mulxU32(&x967, &x968, x953, 0xc7634d81); + var x969: u32 = undefined; + var x970: u32 = undefined; + mulxU32(&x969, &x970, x953, 0xf4372ddf); + var x971: u32 = undefined; + var x972: u32 = undefined; + mulxU32(&x971, &x972, x953, 0x581a0db2); + var x973: u32 = undefined; + var x974: u32 = undefined; + mulxU32(&x973, &x974, x953, 0x48b0a77a); + var x975: u32 = undefined; + var x976: u32 = undefined; + mulxU32(&x975, &x976, x953, 0xecec196a); + var x977: u32 = undefined; + var x978: u32 = undefined; + mulxU32(&x977, &x978, x953, 0xccc52973); + var x979: u32 = undefined; + var x980: u1 = undefined; + addcarryxU32(&x979, &x980, 0x0, x978, x975); + var x981: u32 = undefined; + var x982: u1 = undefined; + addcarryxU32(&x981, &x982, x980, x976, x973); + var x983: u32 = undefined; + var x984: u1 = undefined; + addcarryxU32(&x983, &x984, x982, x974, x971); + var x985: u32 = undefined; + var x986: u1 = undefined; + addcarryxU32(&x985, &x986, x984, x972, x969); + var x987: u32 = undefined; + var x988: u1 = undefined; + addcarryxU32(&x987, &x988, x986, x970, x967); + var x989: u32 = undefined; + var x990: u1 = undefined; + addcarryxU32(&x989, &x990, x988, x968, x965); + var x991: u32 = undefined; + var x992: u1 = undefined; + addcarryxU32(&x991, &x992, x990, x966, x963); + var x993: u32 = undefined; + var x994: u1 = undefined; + addcarryxU32(&x993, &x994, x992, x964, x961); + var x995: u32 = undefined; + var x996: u1 = undefined; + addcarryxU32(&x995, &x996, x994, x962, x959); + var x997: u32 = undefined; + var x998: u1 = undefined; + addcarryxU32(&x997, &x998, x996, x960, x957); + var x999: u32 = undefined; + var x1000: u1 = undefined; + addcarryxU32(&x999, &x1000, x998, x958, x955); + const x1001 = (cast(u32, x1000) + x956); + var x1002: u32 = undefined; + var x1003: u1 = undefined; + addcarryxU32(&x1002, &x1003, 0x0, x927, x977); + var x1004: u32 = undefined; + var x1005: u1 = undefined; + addcarryxU32(&x1004, &x1005, x1003, x929, x979); + var x1006: u32 = undefined; + var x1007: u1 = undefined; + addcarryxU32(&x1006, &x1007, x1005, x931, x981); + var x1008: u32 = undefined; + var x1009: u1 = undefined; + addcarryxU32(&x1008, &x1009, x1007, x933, x983); + var x1010: u32 = undefined; + var x1011: u1 = undefined; + addcarryxU32(&x1010, &x1011, x1009, x935, x985); + var x1012: u32 = undefined; + var x1013: u1 = undefined; + addcarryxU32(&x1012, &x1013, x1011, x937, x987); + var x1014: u32 = undefined; + var x1015: u1 = undefined; + addcarryxU32(&x1014, &x1015, x1013, x939, x989); + var x1016: u32 = undefined; + var x1017: u1 = undefined; + addcarryxU32(&x1016, &x1017, x1015, x941, x991); + var x1018: u32 = undefined; + var x1019: u1 = undefined; + addcarryxU32(&x1018, &x1019, x1017, x943, x993); + var x1020: u32 = undefined; + var x1021: u1 = undefined; + addcarryxU32(&x1020, &x1021, x1019, x945, x995); + var x1022: u32 = undefined; + var x1023: u1 = undefined; + addcarryxU32(&x1022, &x1023, x1021, x947, x997); + var x1024: u32 = undefined; + var x1025: u1 = undefined; + addcarryxU32(&x1024, &x1025, x1023, x949, x999); + var x1026: u32 = undefined; + var x1027: u1 = undefined; + addcarryxU32(&x1026, &x1027, x1025, x951, x1001); + const x1028 = (cast(u32, x1027) + cast(u32, x952)); + var x1029: u32 = undefined; + var x1030: u32 = undefined; + mulxU32(&x1029, &x1030, x7, (arg1[11])); + var x1031: u32 = undefined; + var x1032: u32 = undefined; + mulxU32(&x1031, &x1032, x7, (arg1[10])); + var x1033: u32 = undefined; + var x1034: u32 = undefined; + mulxU32(&x1033, &x1034, x7, (arg1[9])); + var x1035: u32 = undefined; + var x1036: u32 = undefined; + mulxU32(&x1035, &x1036, x7, (arg1[8])); + var x1037: u32 = undefined; + var x1038: u32 = undefined; + mulxU32(&x1037, &x1038, x7, (arg1[7])); + var x1039: u32 = undefined; + var x1040: u32 = undefined; + mulxU32(&x1039, &x1040, x7, (arg1[6])); + var x1041: u32 = undefined; + var x1042: u32 = undefined; + mulxU32(&x1041, &x1042, x7, (arg1[5])); + var x1043: u32 = undefined; + var x1044: u32 = undefined; + mulxU32(&x1043, &x1044, x7, (arg1[4])); + var x1045: u32 = undefined; + var x1046: u32 = undefined; + mulxU32(&x1045, &x1046, x7, (arg1[3])); + var x1047: u32 = undefined; + var x1048: u32 = undefined; + mulxU32(&x1047, &x1048, x7, (arg1[2])); + var x1049: u32 = undefined; + var x1050: u32 = undefined; + mulxU32(&x1049, &x1050, x7, (arg1[1])); + var x1051: u32 = undefined; + var x1052: u32 = undefined; + mulxU32(&x1051, &x1052, x7, (arg1[0])); + var x1053: u32 = undefined; + var x1054: u1 = undefined; + addcarryxU32(&x1053, &x1054, 0x0, x1052, x1049); + var x1055: u32 = undefined; + var x1056: u1 = undefined; + addcarryxU32(&x1055, &x1056, x1054, x1050, x1047); + var x1057: u32 = undefined; + var x1058: u1 = undefined; + addcarryxU32(&x1057, &x1058, x1056, x1048, x1045); + var x1059: u32 = undefined; + var x1060: u1 = undefined; + addcarryxU32(&x1059, &x1060, x1058, x1046, x1043); + var x1061: u32 = undefined; + var x1062: u1 = undefined; + addcarryxU32(&x1061, &x1062, x1060, x1044, x1041); + var x1063: u32 = undefined; + var x1064: u1 = undefined; + addcarryxU32(&x1063, &x1064, x1062, x1042, x1039); + var x1065: u32 = undefined; + var x1066: u1 = undefined; + addcarryxU32(&x1065, &x1066, x1064, x1040, x1037); + var x1067: u32 = undefined; + var x1068: u1 = undefined; + addcarryxU32(&x1067, &x1068, x1066, x1038, x1035); + var x1069: u32 = undefined; + var x1070: u1 = undefined; + addcarryxU32(&x1069, &x1070, x1068, x1036, x1033); + var x1071: u32 = undefined; + var x1072: u1 = undefined; + addcarryxU32(&x1071, &x1072, x1070, x1034, x1031); + var x1073: u32 = undefined; + var x1074: u1 = undefined; + addcarryxU32(&x1073, &x1074, x1072, x1032, x1029); + const x1075 = (cast(u32, x1074) + x1030); + var x1076: u32 = undefined; + var x1077: u1 = undefined; + addcarryxU32(&x1076, &x1077, 0x0, x1004, x1051); + var x1078: u32 = undefined; + var x1079: u1 = undefined; + addcarryxU32(&x1078, &x1079, x1077, x1006, x1053); + var x1080: u32 = undefined; + var x1081: u1 = undefined; + addcarryxU32(&x1080, &x1081, x1079, x1008, x1055); + var x1082: u32 = undefined; + var x1083: u1 = undefined; + addcarryxU32(&x1082, &x1083, x1081, x1010, x1057); + var x1084: u32 = undefined; + var x1085: u1 = undefined; + addcarryxU32(&x1084, &x1085, x1083, x1012, x1059); + var x1086: u32 = undefined; + var x1087: u1 = undefined; + addcarryxU32(&x1086, &x1087, x1085, x1014, x1061); + var x1088: u32 = undefined; + var x1089: u1 = undefined; + addcarryxU32(&x1088, &x1089, x1087, x1016, x1063); + var x1090: u32 = undefined; + var x1091: u1 = undefined; + addcarryxU32(&x1090, &x1091, x1089, x1018, x1065); + var x1092: u32 = undefined; + var x1093: u1 = undefined; + addcarryxU32(&x1092, &x1093, x1091, x1020, x1067); + var x1094: u32 = undefined; + var x1095: u1 = undefined; + addcarryxU32(&x1094, &x1095, x1093, x1022, x1069); + var x1096: u32 = undefined; + var x1097: u1 = undefined; + addcarryxU32(&x1096, &x1097, x1095, x1024, x1071); + var x1098: u32 = undefined; + var x1099: u1 = undefined; + addcarryxU32(&x1098, &x1099, x1097, x1026, x1073); + var x1100: u32 = undefined; + var x1101: u1 = undefined; + addcarryxU32(&x1100, &x1101, x1099, x1028, x1075); + var x1102: u32 = undefined; + var x1103: u32 = undefined; + mulxU32(&x1102, &x1103, x1076, 0xe88fdc45); + var x1104: u32 = undefined; + var x1105: u32 = undefined; + mulxU32(&x1104, &x1105, x1102, 0xffffffff); + var x1106: u32 = undefined; + var x1107: u32 = undefined; + mulxU32(&x1106, &x1107, x1102, 0xffffffff); + var x1108: u32 = undefined; + var x1109: u32 = undefined; + mulxU32(&x1108, &x1109, x1102, 0xffffffff); + var x1110: u32 = undefined; + var x1111: u32 = undefined; + mulxU32(&x1110, &x1111, x1102, 0xffffffff); + var x1112: u32 = undefined; + var x1113: u32 = undefined; + mulxU32(&x1112, &x1113, x1102, 0xffffffff); + var x1114: u32 = undefined; + var x1115: u32 = undefined; + mulxU32(&x1114, &x1115, x1102, 0xffffffff); + var x1116: u32 = undefined; + var x1117: u32 = undefined; + mulxU32(&x1116, &x1117, x1102, 0xc7634d81); + var x1118: u32 = undefined; + var x1119: u32 = undefined; + mulxU32(&x1118, &x1119, x1102, 0xf4372ddf); + var x1120: u32 = undefined; + var x1121: u32 = undefined; + mulxU32(&x1120, &x1121, x1102, 0x581a0db2); + var x1122: u32 = undefined; + var x1123: u32 = undefined; + mulxU32(&x1122, &x1123, x1102, 0x48b0a77a); + var x1124: u32 = undefined; + var x1125: u32 = undefined; + mulxU32(&x1124, &x1125, x1102, 0xecec196a); + var x1126: u32 = undefined; + var x1127: u32 = undefined; + mulxU32(&x1126, &x1127, x1102, 0xccc52973); + var x1128: u32 = undefined; + var x1129: u1 = undefined; + addcarryxU32(&x1128, &x1129, 0x0, x1127, x1124); + var x1130: u32 = undefined; + var x1131: u1 = undefined; + addcarryxU32(&x1130, &x1131, x1129, x1125, x1122); + var x1132: u32 = undefined; + var x1133: u1 = undefined; + addcarryxU32(&x1132, &x1133, x1131, x1123, x1120); + var x1134: u32 = undefined; + var x1135: u1 = undefined; + addcarryxU32(&x1134, &x1135, x1133, x1121, x1118); + var x1136: u32 = undefined; + var x1137: u1 = undefined; + addcarryxU32(&x1136, &x1137, x1135, x1119, x1116); + var x1138: u32 = undefined; + var x1139: u1 = undefined; + addcarryxU32(&x1138, &x1139, x1137, x1117, x1114); + var x1140: u32 = undefined; + var x1141: u1 = undefined; + addcarryxU32(&x1140, &x1141, x1139, x1115, x1112); + var x1142: u32 = undefined; + var x1143: u1 = undefined; + addcarryxU32(&x1142, &x1143, x1141, x1113, x1110); + var x1144: u32 = undefined; + var x1145: u1 = undefined; + addcarryxU32(&x1144, &x1145, x1143, x1111, x1108); + var x1146: u32 = undefined; + var x1147: u1 = undefined; + addcarryxU32(&x1146, &x1147, x1145, x1109, x1106); + var x1148: u32 = undefined; + var x1149: u1 = undefined; + addcarryxU32(&x1148, &x1149, x1147, x1107, x1104); + const x1150 = (cast(u32, x1149) + x1105); + var x1151: u32 = undefined; + var x1152: u1 = undefined; + addcarryxU32(&x1151, &x1152, 0x0, x1076, x1126); + var x1153: u32 = undefined; + var x1154: u1 = undefined; + addcarryxU32(&x1153, &x1154, x1152, x1078, x1128); + var x1155: u32 = undefined; + var x1156: u1 = undefined; + addcarryxU32(&x1155, &x1156, x1154, x1080, x1130); + var x1157: u32 = undefined; + var x1158: u1 = undefined; + addcarryxU32(&x1157, &x1158, x1156, x1082, x1132); + var x1159: u32 = undefined; + var x1160: u1 = undefined; + addcarryxU32(&x1159, &x1160, x1158, x1084, x1134); + var x1161: u32 = undefined; + var x1162: u1 = undefined; + addcarryxU32(&x1161, &x1162, x1160, x1086, x1136); + var x1163: u32 = undefined; + var x1164: u1 = undefined; + addcarryxU32(&x1163, &x1164, x1162, x1088, x1138); + var x1165: u32 = undefined; + var x1166: u1 = undefined; + addcarryxU32(&x1165, &x1166, x1164, x1090, x1140); + var x1167: u32 = undefined; + var x1168: u1 = undefined; + addcarryxU32(&x1167, &x1168, x1166, x1092, x1142); + var x1169: u32 = undefined; + var x1170: u1 = undefined; + addcarryxU32(&x1169, &x1170, x1168, x1094, x1144); + var x1171: u32 = undefined; + var x1172: u1 = undefined; + addcarryxU32(&x1171, &x1172, x1170, x1096, x1146); + var x1173: u32 = undefined; + var x1174: u1 = undefined; + addcarryxU32(&x1173, &x1174, x1172, x1098, x1148); + var x1175: u32 = undefined; + var x1176: u1 = undefined; + addcarryxU32(&x1175, &x1176, x1174, x1100, x1150); + const x1177 = (cast(u32, x1176) + cast(u32, x1101)); + var x1178: u32 = undefined; + var x1179: u32 = undefined; + mulxU32(&x1178, &x1179, x8, (arg1[11])); + var x1180: u32 = undefined; + var x1181: u32 = undefined; + mulxU32(&x1180, &x1181, x8, (arg1[10])); + var x1182: u32 = undefined; + var x1183: u32 = undefined; + mulxU32(&x1182, &x1183, x8, (arg1[9])); + var x1184: u32 = undefined; + var x1185: u32 = undefined; + mulxU32(&x1184, &x1185, x8, (arg1[8])); + var x1186: u32 = undefined; + var x1187: u32 = undefined; + mulxU32(&x1186, &x1187, x8, (arg1[7])); + var x1188: u32 = undefined; + var x1189: u32 = undefined; + mulxU32(&x1188, &x1189, x8, (arg1[6])); + var x1190: u32 = undefined; + var x1191: u32 = undefined; + mulxU32(&x1190, &x1191, x8, (arg1[5])); + var x1192: u32 = undefined; + var x1193: u32 = undefined; + mulxU32(&x1192, &x1193, x8, (arg1[4])); + var x1194: u32 = undefined; + var x1195: u32 = undefined; + mulxU32(&x1194, &x1195, x8, (arg1[3])); + var x1196: u32 = undefined; + var x1197: u32 = undefined; + mulxU32(&x1196, &x1197, x8, (arg1[2])); + var x1198: u32 = undefined; + var x1199: u32 = undefined; + mulxU32(&x1198, &x1199, x8, (arg1[1])); + var x1200: u32 = undefined; + var x1201: u32 = undefined; + mulxU32(&x1200, &x1201, x8, (arg1[0])); + var x1202: u32 = undefined; + var x1203: u1 = undefined; + addcarryxU32(&x1202, &x1203, 0x0, x1201, x1198); + var x1204: u32 = undefined; + var x1205: u1 = undefined; + addcarryxU32(&x1204, &x1205, x1203, x1199, x1196); + var x1206: u32 = undefined; + var x1207: u1 = undefined; + addcarryxU32(&x1206, &x1207, x1205, x1197, x1194); + var x1208: u32 = undefined; + var x1209: u1 = undefined; + addcarryxU32(&x1208, &x1209, x1207, x1195, x1192); + var x1210: u32 = undefined; + var x1211: u1 = undefined; + addcarryxU32(&x1210, &x1211, x1209, x1193, x1190); + var x1212: u32 = undefined; + var x1213: u1 = undefined; + addcarryxU32(&x1212, &x1213, x1211, x1191, x1188); + var x1214: u32 = undefined; + var x1215: u1 = undefined; + addcarryxU32(&x1214, &x1215, x1213, x1189, x1186); + var x1216: u32 = undefined; + var x1217: u1 = undefined; + addcarryxU32(&x1216, &x1217, x1215, x1187, x1184); + var x1218: u32 = undefined; + var x1219: u1 = undefined; + addcarryxU32(&x1218, &x1219, x1217, x1185, x1182); + var x1220: u32 = undefined; + var x1221: u1 = undefined; + addcarryxU32(&x1220, &x1221, x1219, x1183, x1180); + var x1222: u32 = undefined; + var x1223: u1 = undefined; + addcarryxU32(&x1222, &x1223, x1221, x1181, x1178); + const x1224 = (cast(u32, x1223) + x1179); + var x1225: u32 = undefined; + var x1226: u1 = undefined; + addcarryxU32(&x1225, &x1226, 0x0, x1153, x1200); + var x1227: u32 = undefined; + var x1228: u1 = undefined; + addcarryxU32(&x1227, &x1228, x1226, x1155, x1202); + var x1229: u32 = undefined; + var x1230: u1 = undefined; + addcarryxU32(&x1229, &x1230, x1228, x1157, x1204); + var x1231: u32 = undefined; + var x1232: u1 = undefined; + addcarryxU32(&x1231, &x1232, x1230, x1159, x1206); + var x1233: u32 = undefined; + var x1234: u1 = undefined; + addcarryxU32(&x1233, &x1234, x1232, x1161, x1208); + var x1235: u32 = undefined; + var x1236: u1 = undefined; + addcarryxU32(&x1235, &x1236, x1234, x1163, x1210); + var x1237: u32 = undefined; + var x1238: u1 = undefined; + addcarryxU32(&x1237, &x1238, x1236, x1165, x1212); + var x1239: u32 = undefined; + var x1240: u1 = undefined; + addcarryxU32(&x1239, &x1240, x1238, x1167, x1214); + var x1241: u32 = undefined; + var x1242: u1 = undefined; + addcarryxU32(&x1241, &x1242, x1240, x1169, x1216); + var x1243: u32 = undefined; + var x1244: u1 = undefined; + addcarryxU32(&x1243, &x1244, x1242, x1171, x1218); + var x1245: u32 = undefined; + var x1246: u1 = undefined; + addcarryxU32(&x1245, &x1246, x1244, x1173, x1220); + var x1247: u32 = undefined; + var x1248: u1 = undefined; + addcarryxU32(&x1247, &x1248, x1246, x1175, x1222); + var x1249: u32 = undefined; + var x1250: u1 = undefined; + addcarryxU32(&x1249, &x1250, x1248, x1177, x1224); + var x1251: u32 = undefined; + var x1252: u32 = undefined; + mulxU32(&x1251, &x1252, x1225, 0xe88fdc45); + var x1253: u32 = undefined; + var x1254: u32 = undefined; + mulxU32(&x1253, &x1254, x1251, 0xffffffff); + var x1255: u32 = undefined; + var x1256: u32 = undefined; + mulxU32(&x1255, &x1256, x1251, 0xffffffff); + var x1257: u32 = undefined; + var x1258: u32 = undefined; + mulxU32(&x1257, &x1258, x1251, 0xffffffff); + var x1259: u32 = undefined; + var x1260: u32 = undefined; + mulxU32(&x1259, &x1260, x1251, 0xffffffff); + var x1261: u32 = undefined; + var x1262: u32 = undefined; + mulxU32(&x1261, &x1262, x1251, 0xffffffff); + var x1263: u32 = undefined; + var x1264: u32 = undefined; + mulxU32(&x1263, &x1264, x1251, 0xffffffff); + var x1265: u32 = undefined; + var x1266: u32 = undefined; + mulxU32(&x1265, &x1266, x1251, 0xc7634d81); + var x1267: u32 = undefined; + var x1268: u32 = undefined; + mulxU32(&x1267, &x1268, x1251, 0xf4372ddf); + var x1269: u32 = undefined; + var x1270: u32 = undefined; + mulxU32(&x1269, &x1270, x1251, 0x581a0db2); + var x1271: u32 = undefined; + var x1272: u32 = undefined; + mulxU32(&x1271, &x1272, x1251, 0x48b0a77a); + var x1273: u32 = undefined; + var x1274: u32 = undefined; + mulxU32(&x1273, &x1274, x1251, 0xecec196a); + var x1275: u32 = undefined; + var x1276: u32 = undefined; + mulxU32(&x1275, &x1276, x1251, 0xccc52973); + var x1277: u32 = undefined; + var x1278: u1 = undefined; + addcarryxU32(&x1277, &x1278, 0x0, x1276, x1273); + var x1279: u32 = undefined; + var x1280: u1 = undefined; + addcarryxU32(&x1279, &x1280, x1278, x1274, x1271); + var x1281: u32 = undefined; + var x1282: u1 = undefined; + addcarryxU32(&x1281, &x1282, x1280, x1272, x1269); + var x1283: u32 = undefined; + var x1284: u1 = undefined; + addcarryxU32(&x1283, &x1284, x1282, x1270, x1267); + var x1285: u32 = undefined; + var x1286: u1 = undefined; + addcarryxU32(&x1285, &x1286, x1284, x1268, x1265); + var x1287: u32 = undefined; + var x1288: u1 = undefined; + addcarryxU32(&x1287, &x1288, x1286, x1266, x1263); + var x1289: u32 = undefined; + var x1290: u1 = undefined; + addcarryxU32(&x1289, &x1290, x1288, x1264, x1261); + var x1291: u32 = undefined; + var x1292: u1 = undefined; + addcarryxU32(&x1291, &x1292, x1290, x1262, x1259); + var x1293: u32 = undefined; + var x1294: u1 = undefined; + addcarryxU32(&x1293, &x1294, x1292, x1260, x1257); + var x1295: u32 = undefined; + var x1296: u1 = undefined; + addcarryxU32(&x1295, &x1296, x1294, x1258, x1255); + var x1297: u32 = undefined; + var x1298: u1 = undefined; + addcarryxU32(&x1297, &x1298, x1296, x1256, x1253); + const x1299 = (cast(u32, x1298) + x1254); + var x1300: u32 = undefined; + var x1301: u1 = undefined; + addcarryxU32(&x1300, &x1301, 0x0, x1225, x1275); + var x1302: u32 = undefined; + var x1303: u1 = undefined; + addcarryxU32(&x1302, &x1303, x1301, x1227, x1277); + var x1304: u32 = undefined; + var x1305: u1 = undefined; + addcarryxU32(&x1304, &x1305, x1303, x1229, x1279); + var x1306: u32 = undefined; + var x1307: u1 = undefined; + addcarryxU32(&x1306, &x1307, x1305, x1231, x1281); + var x1308: u32 = undefined; + var x1309: u1 = undefined; + addcarryxU32(&x1308, &x1309, x1307, x1233, x1283); + var x1310: u32 = undefined; + var x1311: u1 = undefined; + addcarryxU32(&x1310, &x1311, x1309, x1235, x1285); + var x1312: u32 = undefined; + var x1313: u1 = undefined; + addcarryxU32(&x1312, &x1313, x1311, x1237, x1287); + var x1314: u32 = undefined; + var x1315: u1 = undefined; + addcarryxU32(&x1314, &x1315, x1313, x1239, x1289); + var x1316: u32 = undefined; + var x1317: u1 = undefined; + addcarryxU32(&x1316, &x1317, x1315, x1241, x1291); + var x1318: u32 = undefined; + var x1319: u1 = undefined; + addcarryxU32(&x1318, &x1319, x1317, x1243, x1293); + var x1320: u32 = undefined; + var x1321: u1 = undefined; + addcarryxU32(&x1320, &x1321, x1319, x1245, x1295); + var x1322: u32 = undefined; + var x1323: u1 = undefined; + addcarryxU32(&x1322, &x1323, x1321, x1247, x1297); + var x1324: u32 = undefined; + var x1325: u1 = undefined; + addcarryxU32(&x1324, &x1325, x1323, x1249, x1299); + const x1326 = (cast(u32, x1325) + cast(u32, x1250)); + var x1327: u32 = undefined; + var x1328: u32 = undefined; + mulxU32(&x1327, &x1328, x9, (arg1[11])); + var x1329: u32 = undefined; + var x1330: u32 = undefined; + mulxU32(&x1329, &x1330, x9, (arg1[10])); + var x1331: u32 = undefined; + var x1332: u32 = undefined; + mulxU32(&x1331, &x1332, x9, (arg1[9])); + var x1333: u32 = undefined; + var x1334: u32 = undefined; + mulxU32(&x1333, &x1334, x9, (arg1[8])); + var x1335: u32 = undefined; + var x1336: u32 = undefined; + mulxU32(&x1335, &x1336, x9, (arg1[7])); + var x1337: u32 = undefined; + var x1338: u32 = undefined; + mulxU32(&x1337, &x1338, x9, (arg1[6])); + var x1339: u32 = undefined; + var x1340: u32 = undefined; + mulxU32(&x1339, &x1340, x9, (arg1[5])); + var x1341: u32 = undefined; + var x1342: u32 = undefined; + mulxU32(&x1341, &x1342, x9, (arg1[4])); + var x1343: u32 = undefined; + var x1344: u32 = undefined; + mulxU32(&x1343, &x1344, x9, (arg1[3])); + var x1345: u32 = undefined; + var x1346: u32 = undefined; + mulxU32(&x1345, &x1346, x9, (arg1[2])); + var x1347: u32 = undefined; + var x1348: u32 = undefined; + mulxU32(&x1347, &x1348, x9, (arg1[1])); + var x1349: u32 = undefined; + var x1350: u32 = undefined; + mulxU32(&x1349, &x1350, x9, (arg1[0])); + var x1351: u32 = undefined; + var x1352: u1 = undefined; + addcarryxU32(&x1351, &x1352, 0x0, x1350, x1347); + var x1353: u32 = undefined; + var x1354: u1 = undefined; + addcarryxU32(&x1353, &x1354, x1352, x1348, x1345); + var x1355: u32 = undefined; + var x1356: u1 = undefined; + addcarryxU32(&x1355, &x1356, x1354, x1346, x1343); + var x1357: u32 = undefined; + var x1358: u1 = undefined; + addcarryxU32(&x1357, &x1358, x1356, x1344, x1341); + var x1359: u32 = undefined; + var x1360: u1 = undefined; + addcarryxU32(&x1359, &x1360, x1358, x1342, x1339); + var x1361: u32 = undefined; + var x1362: u1 = undefined; + addcarryxU32(&x1361, &x1362, x1360, x1340, x1337); + var x1363: u32 = undefined; + var x1364: u1 = undefined; + addcarryxU32(&x1363, &x1364, x1362, x1338, x1335); + var x1365: u32 = undefined; + var x1366: u1 = undefined; + addcarryxU32(&x1365, &x1366, x1364, x1336, x1333); + var x1367: u32 = undefined; + var x1368: u1 = undefined; + addcarryxU32(&x1367, &x1368, x1366, x1334, x1331); + var x1369: u32 = undefined; + var x1370: u1 = undefined; + addcarryxU32(&x1369, &x1370, x1368, x1332, x1329); + var x1371: u32 = undefined; + var x1372: u1 = undefined; + addcarryxU32(&x1371, &x1372, x1370, x1330, x1327); + const x1373 = (cast(u32, x1372) + x1328); + var x1374: u32 = undefined; + var x1375: u1 = undefined; + addcarryxU32(&x1374, &x1375, 0x0, x1302, x1349); + var x1376: u32 = undefined; + var x1377: u1 = undefined; + addcarryxU32(&x1376, &x1377, x1375, x1304, x1351); + var x1378: u32 = undefined; + var x1379: u1 = undefined; + addcarryxU32(&x1378, &x1379, x1377, x1306, x1353); + var x1380: u32 = undefined; + var x1381: u1 = undefined; + addcarryxU32(&x1380, &x1381, x1379, x1308, x1355); + var x1382: u32 = undefined; + var x1383: u1 = undefined; + addcarryxU32(&x1382, &x1383, x1381, x1310, x1357); + var x1384: u32 = undefined; + var x1385: u1 = undefined; + addcarryxU32(&x1384, &x1385, x1383, x1312, x1359); + var x1386: u32 = undefined; + var x1387: u1 = undefined; + addcarryxU32(&x1386, &x1387, x1385, x1314, x1361); + var x1388: u32 = undefined; + var x1389: u1 = undefined; + addcarryxU32(&x1388, &x1389, x1387, x1316, x1363); + var x1390: u32 = undefined; + var x1391: u1 = undefined; + addcarryxU32(&x1390, &x1391, x1389, x1318, x1365); + var x1392: u32 = undefined; + var x1393: u1 = undefined; + addcarryxU32(&x1392, &x1393, x1391, x1320, x1367); + var x1394: u32 = undefined; + var x1395: u1 = undefined; + addcarryxU32(&x1394, &x1395, x1393, x1322, x1369); + var x1396: u32 = undefined; + var x1397: u1 = undefined; + addcarryxU32(&x1396, &x1397, x1395, x1324, x1371); + var x1398: u32 = undefined; + var x1399: u1 = undefined; + addcarryxU32(&x1398, &x1399, x1397, x1326, x1373); + var x1400: u32 = undefined; + var x1401: u32 = undefined; + mulxU32(&x1400, &x1401, x1374, 0xe88fdc45); + var x1402: u32 = undefined; + var x1403: u32 = undefined; + mulxU32(&x1402, &x1403, x1400, 0xffffffff); + var x1404: u32 = undefined; + var x1405: u32 = undefined; + mulxU32(&x1404, &x1405, x1400, 0xffffffff); + var x1406: u32 = undefined; + var x1407: u32 = undefined; + mulxU32(&x1406, &x1407, x1400, 0xffffffff); + var x1408: u32 = undefined; + var x1409: u32 = undefined; + mulxU32(&x1408, &x1409, x1400, 0xffffffff); + var x1410: u32 = undefined; + var x1411: u32 = undefined; + mulxU32(&x1410, &x1411, x1400, 0xffffffff); + var x1412: u32 = undefined; + var x1413: u32 = undefined; + mulxU32(&x1412, &x1413, x1400, 0xffffffff); + var x1414: u32 = undefined; + var x1415: u32 = undefined; + mulxU32(&x1414, &x1415, x1400, 0xc7634d81); + var x1416: u32 = undefined; + var x1417: u32 = undefined; + mulxU32(&x1416, &x1417, x1400, 0xf4372ddf); + var x1418: u32 = undefined; + var x1419: u32 = undefined; + mulxU32(&x1418, &x1419, x1400, 0x581a0db2); + var x1420: u32 = undefined; + var x1421: u32 = undefined; + mulxU32(&x1420, &x1421, x1400, 0x48b0a77a); + var x1422: u32 = undefined; + var x1423: u32 = undefined; + mulxU32(&x1422, &x1423, x1400, 0xecec196a); + var x1424: u32 = undefined; + var x1425: u32 = undefined; + mulxU32(&x1424, &x1425, x1400, 0xccc52973); + var x1426: u32 = undefined; + var x1427: u1 = undefined; + addcarryxU32(&x1426, &x1427, 0x0, x1425, x1422); + var x1428: u32 = undefined; + var x1429: u1 = undefined; + addcarryxU32(&x1428, &x1429, x1427, x1423, x1420); + var x1430: u32 = undefined; + var x1431: u1 = undefined; + addcarryxU32(&x1430, &x1431, x1429, x1421, x1418); + var x1432: u32 = undefined; + var x1433: u1 = undefined; + addcarryxU32(&x1432, &x1433, x1431, x1419, x1416); + var x1434: u32 = undefined; + var x1435: u1 = undefined; + addcarryxU32(&x1434, &x1435, x1433, x1417, x1414); + var x1436: u32 = undefined; + var x1437: u1 = undefined; + addcarryxU32(&x1436, &x1437, x1435, x1415, x1412); + var x1438: u32 = undefined; + var x1439: u1 = undefined; + addcarryxU32(&x1438, &x1439, x1437, x1413, x1410); + var x1440: u32 = undefined; + var x1441: u1 = undefined; + addcarryxU32(&x1440, &x1441, x1439, x1411, x1408); + var x1442: u32 = undefined; + var x1443: u1 = undefined; + addcarryxU32(&x1442, &x1443, x1441, x1409, x1406); + var x1444: u32 = undefined; + var x1445: u1 = undefined; + addcarryxU32(&x1444, &x1445, x1443, x1407, x1404); + var x1446: u32 = undefined; + var x1447: u1 = undefined; + addcarryxU32(&x1446, &x1447, x1445, x1405, x1402); + const x1448 = (cast(u32, x1447) + x1403); + var x1449: u32 = undefined; + var x1450: u1 = undefined; + addcarryxU32(&x1449, &x1450, 0x0, x1374, x1424); + var x1451: u32 = undefined; + var x1452: u1 = undefined; + addcarryxU32(&x1451, &x1452, x1450, x1376, x1426); + var x1453: u32 = undefined; + var x1454: u1 = undefined; + addcarryxU32(&x1453, &x1454, x1452, x1378, x1428); + var x1455: u32 = undefined; + var x1456: u1 = undefined; + addcarryxU32(&x1455, &x1456, x1454, x1380, x1430); + var x1457: u32 = undefined; + var x1458: u1 = undefined; + addcarryxU32(&x1457, &x1458, x1456, x1382, x1432); + var x1459: u32 = undefined; + var x1460: u1 = undefined; + addcarryxU32(&x1459, &x1460, x1458, x1384, x1434); + var x1461: u32 = undefined; + var x1462: u1 = undefined; + addcarryxU32(&x1461, &x1462, x1460, x1386, x1436); + var x1463: u32 = undefined; + var x1464: u1 = undefined; + addcarryxU32(&x1463, &x1464, x1462, x1388, x1438); + var x1465: u32 = undefined; + var x1466: u1 = undefined; + addcarryxU32(&x1465, &x1466, x1464, x1390, x1440); + var x1467: u32 = undefined; + var x1468: u1 = undefined; + addcarryxU32(&x1467, &x1468, x1466, x1392, x1442); + var x1469: u32 = undefined; + var x1470: u1 = undefined; + addcarryxU32(&x1469, &x1470, x1468, x1394, x1444); + var x1471: u32 = undefined; + var x1472: u1 = undefined; + addcarryxU32(&x1471, &x1472, x1470, x1396, x1446); + var x1473: u32 = undefined; + var x1474: u1 = undefined; + addcarryxU32(&x1473, &x1474, x1472, x1398, x1448); + const x1475 = (cast(u32, x1474) + cast(u32, x1399)); + var x1476: u32 = undefined; + var x1477: u32 = undefined; + mulxU32(&x1476, &x1477, x10, (arg1[11])); + var x1478: u32 = undefined; + var x1479: u32 = undefined; + mulxU32(&x1478, &x1479, x10, (arg1[10])); + var x1480: u32 = undefined; + var x1481: u32 = undefined; + mulxU32(&x1480, &x1481, x10, (arg1[9])); + var x1482: u32 = undefined; + var x1483: u32 = undefined; + mulxU32(&x1482, &x1483, x10, (arg1[8])); + var x1484: u32 = undefined; + var x1485: u32 = undefined; + mulxU32(&x1484, &x1485, x10, (arg1[7])); + var x1486: u32 = undefined; + var x1487: u32 = undefined; + mulxU32(&x1486, &x1487, x10, (arg1[6])); + var x1488: u32 = undefined; + var x1489: u32 = undefined; + mulxU32(&x1488, &x1489, x10, (arg1[5])); + var x1490: u32 = undefined; + var x1491: u32 = undefined; + mulxU32(&x1490, &x1491, x10, (arg1[4])); + var x1492: u32 = undefined; + var x1493: u32 = undefined; + mulxU32(&x1492, &x1493, x10, (arg1[3])); + var x1494: u32 = undefined; + var x1495: u32 = undefined; + mulxU32(&x1494, &x1495, x10, (arg1[2])); + var x1496: u32 = undefined; + var x1497: u32 = undefined; + mulxU32(&x1496, &x1497, x10, (arg1[1])); + var x1498: u32 = undefined; + var x1499: u32 = undefined; + mulxU32(&x1498, &x1499, x10, (arg1[0])); + var x1500: u32 = undefined; + var x1501: u1 = undefined; + addcarryxU32(&x1500, &x1501, 0x0, x1499, x1496); + var x1502: u32 = undefined; + var x1503: u1 = undefined; + addcarryxU32(&x1502, &x1503, x1501, x1497, x1494); + var x1504: u32 = undefined; + var x1505: u1 = undefined; + addcarryxU32(&x1504, &x1505, x1503, x1495, x1492); + var x1506: u32 = undefined; + var x1507: u1 = undefined; + addcarryxU32(&x1506, &x1507, x1505, x1493, x1490); + var x1508: u32 = undefined; + var x1509: u1 = undefined; + addcarryxU32(&x1508, &x1509, x1507, x1491, x1488); + var x1510: u32 = undefined; + var x1511: u1 = undefined; + addcarryxU32(&x1510, &x1511, x1509, x1489, x1486); + var x1512: u32 = undefined; + var x1513: u1 = undefined; + addcarryxU32(&x1512, &x1513, x1511, x1487, x1484); + var x1514: u32 = undefined; + var x1515: u1 = undefined; + addcarryxU32(&x1514, &x1515, x1513, x1485, x1482); + var x1516: u32 = undefined; + var x1517: u1 = undefined; + addcarryxU32(&x1516, &x1517, x1515, x1483, x1480); + var x1518: u32 = undefined; + var x1519: u1 = undefined; + addcarryxU32(&x1518, &x1519, x1517, x1481, x1478); + var x1520: u32 = undefined; + var x1521: u1 = undefined; + addcarryxU32(&x1520, &x1521, x1519, x1479, x1476); + const x1522 = (cast(u32, x1521) + x1477); + var x1523: u32 = undefined; + var x1524: u1 = undefined; + addcarryxU32(&x1523, &x1524, 0x0, x1451, x1498); + var x1525: u32 = undefined; + var x1526: u1 = undefined; + addcarryxU32(&x1525, &x1526, x1524, x1453, x1500); + var x1527: u32 = undefined; + var x1528: u1 = undefined; + addcarryxU32(&x1527, &x1528, x1526, x1455, x1502); + var x1529: u32 = undefined; + var x1530: u1 = undefined; + addcarryxU32(&x1529, &x1530, x1528, x1457, x1504); + var x1531: u32 = undefined; + var x1532: u1 = undefined; + addcarryxU32(&x1531, &x1532, x1530, x1459, x1506); + var x1533: u32 = undefined; + var x1534: u1 = undefined; + addcarryxU32(&x1533, &x1534, x1532, x1461, x1508); + var x1535: u32 = undefined; + var x1536: u1 = undefined; + addcarryxU32(&x1535, &x1536, x1534, x1463, x1510); + var x1537: u32 = undefined; + var x1538: u1 = undefined; + addcarryxU32(&x1537, &x1538, x1536, x1465, x1512); + var x1539: u32 = undefined; + var x1540: u1 = undefined; + addcarryxU32(&x1539, &x1540, x1538, x1467, x1514); + var x1541: u32 = undefined; + var x1542: u1 = undefined; + addcarryxU32(&x1541, &x1542, x1540, x1469, x1516); + var x1543: u32 = undefined; + var x1544: u1 = undefined; + addcarryxU32(&x1543, &x1544, x1542, x1471, x1518); + var x1545: u32 = undefined; + var x1546: u1 = undefined; + addcarryxU32(&x1545, &x1546, x1544, x1473, x1520); + var x1547: u32 = undefined; + var x1548: u1 = undefined; + addcarryxU32(&x1547, &x1548, x1546, x1475, x1522); + var x1549: u32 = undefined; + var x1550: u32 = undefined; + mulxU32(&x1549, &x1550, x1523, 0xe88fdc45); + var x1551: u32 = undefined; + var x1552: u32 = undefined; + mulxU32(&x1551, &x1552, x1549, 0xffffffff); + var x1553: u32 = undefined; + var x1554: u32 = undefined; + mulxU32(&x1553, &x1554, x1549, 0xffffffff); + var x1555: u32 = undefined; + var x1556: u32 = undefined; + mulxU32(&x1555, &x1556, x1549, 0xffffffff); + var x1557: u32 = undefined; + var x1558: u32 = undefined; + mulxU32(&x1557, &x1558, x1549, 0xffffffff); + var x1559: u32 = undefined; + var x1560: u32 = undefined; + mulxU32(&x1559, &x1560, x1549, 0xffffffff); + var x1561: u32 = undefined; + var x1562: u32 = undefined; + mulxU32(&x1561, &x1562, x1549, 0xffffffff); + var x1563: u32 = undefined; + var x1564: u32 = undefined; + mulxU32(&x1563, &x1564, x1549, 0xc7634d81); + var x1565: u32 = undefined; + var x1566: u32 = undefined; + mulxU32(&x1565, &x1566, x1549, 0xf4372ddf); + var x1567: u32 = undefined; + var x1568: u32 = undefined; + mulxU32(&x1567, &x1568, x1549, 0x581a0db2); + var x1569: u32 = undefined; + var x1570: u32 = undefined; + mulxU32(&x1569, &x1570, x1549, 0x48b0a77a); + var x1571: u32 = undefined; + var x1572: u32 = undefined; + mulxU32(&x1571, &x1572, x1549, 0xecec196a); + var x1573: u32 = undefined; + var x1574: u32 = undefined; + mulxU32(&x1573, &x1574, x1549, 0xccc52973); + var x1575: u32 = undefined; + var x1576: u1 = undefined; + addcarryxU32(&x1575, &x1576, 0x0, x1574, x1571); + var x1577: u32 = undefined; + var x1578: u1 = undefined; + addcarryxU32(&x1577, &x1578, x1576, x1572, x1569); + var x1579: u32 = undefined; + var x1580: u1 = undefined; + addcarryxU32(&x1579, &x1580, x1578, x1570, x1567); + var x1581: u32 = undefined; + var x1582: u1 = undefined; + addcarryxU32(&x1581, &x1582, x1580, x1568, x1565); + var x1583: u32 = undefined; + var x1584: u1 = undefined; + addcarryxU32(&x1583, &x1584, x1582, x1566, x1563); + var x1585: u32 = undefined; + var x1586: u1 = undefined; + addcarryxU32(&x1585, &x1586, x1584, x1564, x1561); + var x1587: u32 = undefined; + var x1588: u1 = undefined; + addcarryxU32(&x1587, &x1588, x1586, x1562, x1559); + var x1589: u32 = undefined; + var x1590: u1 = undefined; + addcarryxU32(&x1589, &x1590, x1588, x1560, x1557); + var x1591: u32 = undefined; + var x1592: u1 = undefined; + addcarryxU32(&x1591, &x1592, x1590, x1558, x1555); + var x1593: u32 = undefined; + var x1594: u1 = undefined; + addcarryxU32(&x1593, &x1594, x1592, x1556, x1553); + var x1595: u32 = undefined; + var x1596: u1 = undefined; + addcarryxU32(&x1595, &x1596, x1594, x1554, x1551); + const x1597 = (cast(u32, x1596) + x1552); + var x1598: u32 = undefined; + var x1599: u1 = undefined; + addcarryxU32(&x1598, &x1599, 0x0, x1523, x1573); + var x1600: u32 = undefined; + var x1601: u1 = undefined; + addcarryxU32(&x1600, &x1601, x1599, x1525, x1575); + var x1602: u32 = undefined; + var x1603: u1 = undefined; + addcarryxU32(&x1602, &x1603, x1601, x1527, x1577); + var x1604: u32 = undefined; + var x1605: u1 = undefined; + addcarryxU32(&x1604, &x1605, x1603, x1529, x1579); + var x1606: u32 = undefined; + var x1607: u1 = undefined; + addcarryxU32(&x1606, &x1607, x1605, x1531, x1581); + var x1608: u32 = undefined; + var x1609: u1 = undefined; + addcarryxU32(&x1608, &x1609, x1607, x1533, x1583); + var x1610: u32 = undefined; + var x1611: u1 = undefined; + addcarryxU32(&x1610, &x1611, x1609, x1535, x1585); + var x1612: u32 = undefined; + var x1613: u1 = undefined; + addcarryxU32(&x1612, &x1613, x1611, x1537, x1587); + var x1614: u32 = undefined; + var x1615: u1 = undefined; + addcarryxU32(&x1614, &x1615, x1613, x1539, x1589); + var x1616: u32 = undefined; + var x1617: u1 = undefined; + addcarryxU32(&x1616, &x1617, x1615, x1541, x1591); + var x1618: u32 = undefined; + var x1619: u1 = undefined; + addcarryxU32(&x1618, &x1619, x1617, x1543, x1593); + var x1620: u32 = undefined; + var x1621: u1 = undefined; + addcarryxU32(&x1620, &x1621, x1619, x1545, x1595); + var x1622: u32 = undefined; + var x1623: u1 = undefined; + addcarryxU32(&x1622, &x1623, x1621, x1547, x1597); + const x1624 = (cast(u32, x1623) + cast(u32, x1548)); + var x1625: u32 = undefined; + var x1626: u32 = undefined; + mulxU32(&x1625, &x1626, x11, (arg1[11])); + var x1627: u32 = undefined; + var x1628: u32 = undefined; + mulxU32(&x1627, &x1628, x11, (arg1[10])); + var x1629: u32 = undefined; + var x1630: u32 = undefined; + mulxU32(&x1629, &x1630, x11, (arg1[9])); + var x1631: u32 = undefined; + var x1632: u32 = undefined; + mulxU32(&x1631, &x1632, x11, (arg1[8])); + var x1633: u32 = undefined; + var x1634: u32 = undefined; + mulxU32(&x1633, &x1634, x11, (arg1[7])); + var x1635: u32 = undefined; + var x1636: u32 = undefined; + mulxU32(&x1635, &x1636, x11, (arg1[6])); + var x1637: u32 = undefined; + var x1638: u32 = undefined; + mulxU32(&x1637, &x1638, x11, (arg1[5])); + var x1639: u32 = undefined; + var x1640: u32 = undefined; + mulxU32(&x1639, &x1640, x11, (arg1[4])); + var x1641: u32 = undefined; + var x1642: u32 = undefined; + mulxU32(&x1641, &x1642, x11, (arg1[3])); + var x1643: u32 = undefined; + var x1644: u32 = undefined; + mulxU32(&x1643, &x1644, x11, (arg1[2])); + var x1645: u32 = undefined; + var x1646: u32 = undefined; + mulxU32(&x1645, &x1646, x11, (arg1[1])); + var x1647: u32 = undefined; + var x1648: u32 = undefined; + mulxU32(&x1647, &x1648, x11, (arg1[0])); + var x1649: u32 = undefined; + var x1650: u1 = undefined; + addcarryxU32(&x1649, &x1650, 0x0, x1648, x1645); + var x1651: u32 = undefined; + var x1652: u1 = undefined; + addcarryxU32(&x1651, &x1652, x1650, x1646, x1643); + var x1653: u32 = undefined; + var x1654: u1 = undefined; + addcarryxU32(&x1653, &x1654, x1652, x1644, x1641); + var x1655: u32 = undefined; + var x1656: u1 = undefined; + addcarryxU32(&x1655, &x1656, x1654, x1642, x1639); + var x1657: u32 = undefined; + var x1658: u1 = undefined; + addcarryxU32(&x1657, &x1658, x1656, x1640, x1637); + var x1659: u32 = undefined; + var x1660: u1 = undefined; + addcarryxU32(&x1659, &x1660, x1658, x1638, x1635); + var x1661: u32 = undefined; + var x1662: u1 = undefined; + addcarryxU32(&x1661, &x1662, x1660, x1636, x1633); + var x1663: u32 = undefined; + var x1664: u1 = undefined; + addcarryxU32(&x1663, &x1664, x1662, x1634, x1631); + var x1665: u32 = undefined; + var x1666: u1 = undefined; + addcarryxU32(&x1665, &x1666, x1664, x1632, x1629); + var x1667: u32 = undefined; + var x1668: u1 = undefined; + addcarryxU32(&x1667, &x1668, x1666, x1630, x1627); + var x1669: u32 = undefined; + var x1670: u1 = undefined; + addcarryxU32(&x1669, &x1670, x1668, x1628, x1625); + const x1671 = (cast(u32, x1670) + x1626); + var x1672: u32 = undefined; + var x1673: u1 = undefined; + addcarryxU32(&x1672, &x1673, 0x0, x1600, x1647); + var x1674: u32 = undefined; + var x1675: u1 = undefined; + addcarryxU32(&x1674, &x1675, x1673, x1602, x1649); + var x1676: u32 = undefined; + var x1677: u1 = undefined; + addcarryxU32(&x1676, &x1677, x1675, x1604, x1651); + var x1678: u32 = undefined; + var x1679: u1 = undefined; + addcarryxU32(&x1678, &x1679, x1677, x1606, x1653); + var x1680: u32 = undefined; + var x1681: u1 = undefined; + addcarryxU32(&x1680, &x1681, x1679, x1608, x1655); + var x1682: u32 = undefined; + var x1683: u1 = undefined; + addcarryxU32(&x1682, &x1683, x1681, x1610, x1657); + var x1684: u32 = undefined; + var x1685: u1 = undefined; + addcarryxU32(&x1684, &x1685, x1683, x1612, x1659); + var x1686: u32 = undefined; + var x1687: u1 = undefined; + addcarryxU32(&x1686, &x1687, x1685, x1614, x1661); + var x1688: u32 = undefined; + var x1689: u1 = undefined; + addcarryxU32(&x1688, &x1689, x1687, x1616, x1663); + var x1690: u32 = undefined; + var x1691: u1 = undefined; + addcarryxU32(&x1690, &x1691, x1689, x1618, x1665); + var x1692: u32 = undefined; + var x1693: u1 = undefined; + addcarryxU32(&x1692, &x1693, x1691, x1620, x1667); + var x1694: u32 = undefined; + var x1695: u1 = undefined; + addcarryxU32(&x1694, &x1695, x1693, x1622, x1669); + var x1696: u32 = undefined; + var x1697: u1 = undefined; + addcarryxU32(&x1696, &x1697, x1695, x1624, x1671); + var x1698: u32 = undefined; + var x1699: u32 = undefined; + mulxU32(&x1698, &x1699, x1672, 0xe88fdc45); + var x1700: u32 = undefined; + var x1701: u32 = undefined; + mulxU32(&x1700, &x1701, x1698, 0xffffffff); + var x1702: u32 = undefined; + var x1703: u32 = undefined; + mulxU32(&x1702, &x1703, x1698, 0xffffffff); + var x1704: u32 = undefined; + var x1705: u32 = undefined; + mulxU32(&x1704, &x1705, x1698, 0xffffffff); + var x1706: u32 = undefined; + var x1707: u32 = undefined; + mulxU32(&x1706, &x1707, x1698, 0xffffffff); + var x1708: u32 = undefined; + var x1709: u32 = undefined; + mulxU32(&x1708, &x1709, x1698, 0xffffffff); + var x1710: u32 = undefined; + var x1711: u32 = undefined; + mulxU32(&x1710, &x1711, x1698, 0xffffffff); + var x1712: u32 = undefined; + var x1713: u32 = undefined; + mulxU32(&x1712, &x1713, x1698, 0xc7634d81); + var x1714: u32 = undefined; + var x1715: u32 = undefined; + mulxU32(&x1714, &x1715, x1698, 0xf4372ddf); + var x1716: u32 = undefined; + var x1717: u32 = undefined; + mulxU32(&x1716, &x1717, x1698, 0x581a0db2); + var x1718: u32 = undefined; + var x1719: u32 = undefined; + mulxU32(&x1718, &x1719, x1698, 0x48b0a77a); + var x1720: u32 = undefined; + var x1721: u32 = undefined; + mulxU32(&x1720, &x1721, x1698, 0xecec196a); + var x1722: u32 = undefined; + var x1723: u32 = undefined; + mulxU32(&x1722, &x1723, x1698, 0xccc52973); + var x1724: u32 = undefined; + var x1725: u1 = undefined; + addcarryxU32(&x1724, &x1725, 0x0, x1723, x1720); + var x1726: u32 = undefined; + var x1727: u1 = undefined; + addcarryxU32(&x1726, &x1727, x1725, x1721, x1718); + var x1728: u32 = undefined; + var x1729: u1 = undefined; + addcarryxU32(&x1728, &x1729, x1727, x1719, x1716); + var x1730: u32 = undefined; + var x1731: u1 = undefined; + addcarryxU32(&x1730, &x1731, x1729, x1717, x1714); + var x1732: u32 = undefined; + var x1733: u1 = undefined; + addcarryxU32(&x1732, &x1733, x1731, x1715, x1712); + var x1734: u32 = undefined; + var x1735: u1 = undefined; + addcarryxU32(&x1734, &x1735, x1733, x1713, x1710); + var x1736: u32 = undefined; + var x1737: u1 = undefined; + addcarryxU32(&x1736, &x1737, x1735, x1711, x1708); + var x1738: u32 = undefined; + var x1739: u1 = undefined; + addcarryxU32(&x1738, &x1739, x1737, x1709, x1706); + var x1740: u32 = undefined; + var x1741: u1 = undefined; + addcarryxU32(&x1740, &x1741, x1739, x1707, x1704); + var x1742: u32 = undefined; + var x1743: u1 = undefined; + addcarryxU32(&x1742, &x1743, x1741, x1705, x1702); + var x1744: u32 = undefined; + var x1745: u1 = undefined; + addcarryxU32(&x1744, &x1745, x1743, x1703, x1700); + const x1746 = (cast(u32, x1745) + x1701); + var x1747: u32 = undefined; + var x1748: u1 = undefined; + addcarryxU32(&x1747, &x1748, 0x0, x1672, x1722); + var x1749: u32 = undefined; + var x1750: u1 = undefined; + addcarryxU32(&x1749, &x1750, x1748, x1674, x1724); + var x1751: u32 = undefined; + var x1752: u1 = undefined; + addcarryxU32(&x1751, &x1752, x1750, x1676, x1726); + var x1753: u32 = undefined; + var x1754: u1 = undefined; + addcarryxU32(&x1753, &x1754, x1752, x1678, x1728); + var x1755: u32 = undefined; + var x1756: u1 = undefined; + addcarryxU32(&x1755, &x1756, x1754, x1680, x1730); + var x1757: u32 = undefined; + var x1758: u1 = undefined; + addcarryxU32(&x1757, &x1758, x1756, x1682, x1732); + var x1759: u32 = undefined; + var x1760: u1 = undefined; + addcarryxU32(&x1759, &x1760, x1758, x1684, x1734); + var x1761: u32 = undefined; + var x1762: u1 = undefined; + addcarryxU32(&x1761, &x1762, x1760, x1686, x1736); + var x1763: u32 = undefined; + var x1764: u1 = undefined; + addcarryxU32(&x1763, &x1764, x1762, x1688, x1738); + var x1765: u32 = undefined; + var x1766: u1 = undefined; + addcarryxU32(&x1765, &x1766, x1764, x1690, x1740); + var x1767: u32 = undefined; + var x1768: u1 = undefined; + addcarryxU32(&x1767, &x1768, x1766, x1692, x1742); + var x1769: u32 = undefined; + var x1770: u1 = undefined; + addcarryxU32(&x1769, &x1770, x1768, x1694, x1744); + var x1771: u32 = undefined; + var x1772: u1 = undefined; + addcarryxU32(&x1771, &x1772, x1770, x1696, x1746); + const x1773 = (cast(u32, x1772) + cast(u32, x1697)); + var x1774: u32 = undefined; + var x1775: u1 = undefined; + subborrowxU32(&x1774, &x1775, 0x0, x1749, 0xccc52973); + var x1776: u32 = undefined; + var x1777: u1 = undefined; + subborrowxU32(&x1776, &x1777, x1775, x1751, 0xecec196a); + var x1778: u32 = undefined; + var x1779: u1 = undefined; + subborrowxU32(&x1778, &x1779, x1777, x1753, 0x48b0a77a); + var x1780: u32 = undefined; + var x1781: u1 = undefined; + subborrowxU32(&x1780, &x1781, x1779, x1755, 0x581a0db2); + var x1782: u32 = undefined; + var x1783: u1 = undefined; + subborrowxU32(&x1782, &x1783, x1781, x1757, 0xf4372ddf); + var x1784: u32 = undefined; + var x1785: u1 = undefined; + subborrowxU32(&x1784, &x1785, x1783, x1759, 0xc7634d81); + var x1786: u32 = undefined; + var x1787: u1 = undefined; + subborrowxU32(&x1786, &x1787, x1785, x1761, 0xffffffff); + var x1788: u32 = undefined; + var x1789: u1 = undefined; + subborrowxU32(&x1788, &x1789, x1787, x1763, 0xffffffff); + var x1790: u32 = undefined; + var x1791: u1 = undefined; + subborrowxU32(&x1790, &x1791, x1789, x1765, 0xffffffff); + var x1792: u32 = undefined; + var x1793: u1 = undefined; + subborrowxU32(&x1792, &x1793, x1791, x1767, 0xffffffff); + var x1794: u32 = undefined; + var x1795: u1 = undefined; + subborrowxU32(&x1794, &x1795, x1793, x1769, 0xffffffff); + var x1796: u32 = undefined; + var x1797: u1 = undefined; + subborrowxU32(&x1796, &x1797, x1795, x1771, 0xffffffff); + var x1798: u32 = undefined; + var x1799: u1 = undefined; + subborrowxU32(&x1798, &x1799, x1797, x1773, cast(u32, 0x0)); + var x1800: u32 = undefined; + cmovznzU32(&x1800, x1799, x1774, x1749); + var x1801: u32 = undefined; + cmovznzU32(&x1801, x1799, x1776, x1751); + var x1802: u32 = undefined; + cmovznzU32(&x1802, x1799, x1778, x1753); + var x1803: u32 = undefined; + cmovznzU32(&x1803, x1799, x1780, x1755); + var x1804: u32 = undefined; + cmovznzU32(&x1804, x1799, x1782, x1757); + var x1805: u32 = undefined; + cmovznzU32(&x1805, x1799, x1784, x1759); + var x1806: u32 = undefined; + cmovznzU32(&x1806, x1799, x1786, x1761); + var x1807: u32 = undefined; + cmovznzU32(&x1807, x1799, x1788, x1763); + var x1808: u32 = undefined; + cmovznzU32(&x1808, x1799, x1790, x1765); + var x1809: u32 = undefined; + cmovznzU32(&x1809, x1799, x1792, x1767); + var x1810: u32 = undefined; + cmovznzU32(&x1810, x1799, x1794, x1769); + var x1811: u32 = undefined; + cmovznzU32(&x1811, x1799, x1796, x1771); + out1[0] = x1800; + out1[1] = x1801; + out1[2] = x1802; + out1[3] = x1803; + out1[4] = x1804; + out1[5] = x1805; + out1[6] = x1806; + out1[7] = x1807; + out1[8] = x1808; + out1[9] = x1809; + out1[10] = x1810; + out1[11] = x1811; +} + +/// The function add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn add(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + addcarryxU32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u32 = undefined; + var x4: u1 = undefined; + addcarryxU32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u32 = undefined; + var x6: u1 = undefined; + addcarryxU32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u32 = undefined; + var x8: u1 = undefined; + addcarryxU32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u32 = undefined; + var x10: u1 = undefined; + addcarryxU32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + var x11: u32 = undefined; + var x12: u1 = undefined; + addcarryxU32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + var x13: u32 = undefined; + var x14: u1 = undefined; + addcarryxU32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + var x15: u32 = undefined; + var x16: u1 = undefined; + addcarryxU32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + var x17: u32 = undefined; + var x18: u1 = undefined; + addcarryxU32(&x17, &x18, x16, (arg1[8]), (arg2[8])); + var x19: u32 = undefined; + var x20: u1 = undefined; + addcarryxU32(&x19, &x20, x18, (arg1[9]), (arg2[9])); + var x21: u32 = undefined; + var x22: u1 = undefined; + addcarryxU32(&x21, &x22, x20, (arg1[10]), (arg2[10])); + var x23: u32 = undefined; + var x24: u1 = undefined; + addcarryxU32(&x23, &x24, x22, (arg1[11]), (arg2[11])); + var x25: u32 = undefined; + var x26: u1 = undefined; + subborrowxU32(&x25, &x26, 0x0, x1, 0xccc52973); + var x27: u32 = undefined; + var x28: u1 = undefined; + subborrowxU32(&x27, &x28, x26, x3, 0xecec196a); + var x29: u32 = undefined; + var x30: u1 = undefined; + subborrowxU32(&x29, &x30, x28, x5, 0x48b0a77a); + var x31: u32 = undefined; + var x32: u1 = undefined; + subborrowxU32(&x31, &x32, x30, x7, 0x581a0db2); + var x33: u32 = undefined; + var x34: u1 = undefined; + subborrowxU32(&x33, &x34, x32, x9, 0xf4372ddf); + var x35: u32 = undefined; + var x36: u1 = undefined; + subborrowxU32(&x35, &x36, x34, x11, 0xc7634d81); + var x37: u32 = undefined; + var x38: u1 = undefined; + subborrowxU32(&x37, &x38, x36, x13, 0xffffffff); + var x39: u32 = undefined; + var x40: u1 = undefined; + subborrowxU32(&x39, &x40, x38, x15, 0xffffffff); + var x41: u32 = undefined; + var x42: u1 = undefined; + subborrowxU32(&x41, &x42, x40, x17, 0xffffffff); + var x43: u32 = undefined; + var x44: u1 = undefined; + subborrowxU32(&x43, &x44, x42, x19, 0xffffffff); + var x45: u32 = undefined; + var x46: u1 = undefined; + subborrowxU32(&x45, &x46, x44, x21, 0xffffffff); + var x47: u32 = undefined; + var x48: u1 = undefined; + subborrowxU32(&x47, &x48, x46, x23, 0xffffffff); + var x49: u32 = undefined; + var x50: u1 = undefined; + subborrowxU32(&x49, &x50, x48, cast(u32, x24), cast(u32, 0x0)); + var x51: u32 = undefined; + cmovznzU32(&x51, x50, x25, x1); + var x52: u32 = undefined; + cmovznzU32(&x52, x50, x27, x3); + var x53: u32 = undefined; + cmovznzU32(&x53, x50, x29, x5); + var x54: u32 = undefined; + cmovznzU32(&x54, x50, x31, x7); + var x55: u32 = undefined; + cmovznzU32(&x55, x50, x33, x9); + var x56: u32 = undefined; + cmovznzU32(&x56, x50, x35, x11); + var x57: u32 = undefined; + cmovznzU32(&x57, x50, x37, x13); + var x58: u32 = undefined; + cmovznzU32(&x58, x50, x39, x15); + var x59: u32 = undefined; + cmovznzU32(&x59, x50, x41, x17); + var x60: u32 = undefined; + cmovznzU32(&x60, x50, x43, x19); + var x61: u32 = undefined; + cmovznzU32(&x61, x50, x45, x21); + var x62: u32 = undefined; + cmovznzU32(&x62, x50, x47, x23); + out1[0] = x51; + out1[1] = x52; + out1[2] = x53; + out1[3] = x54; + out1[4] = x55; + out1[5] = x56; + out1[6] = x57; + out1[7] = x58; + out1[8] = x59; + out1[9] = x60; + out1[10] = x61; + out1[11] = x62; +} + +/// The function sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn sub(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + subborrowxU32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u32 = undefined; + var x4: u1 = undefined; + subborrowxU32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u32 = undefined; + var x6: u1 = undefined; + subborrowxU32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u32 = undefined; + var x8: u1 = undefined; + subborrowxU32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u32 = undefined; + var x10: u1 = undefined; + subborrowxU32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + var x11: u32 = undefined; + var x12: u1 = undefined; + subborrowxU32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + var x13: u32 = undefined; + var x14: u1 = undefined; + subborrowxU32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + var x15: u32 = undefined; + var x16: u1 = undefined; + subborrowxU32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + var x17: u32 = undefined; + var x18: u1 = undefined; + subborrowxU32(&x17, &x18, x16, (arg1[8]), (arg2[8])); + var x19: u32 = undefined; + var x20: u1 = undefined; + subborrowxU32(&x19, &x20, x18, (arg1[9]), (arg2[9])); + var x21: u32 = undefined; + var x22: u1 = undefined; + subborrowxU32(&x21, &x22, x20, (arg1[10]), (arg2[10])); + var x23: u32 = undefined; + var x24: u1 = undefined; + subborrowxU32(&x23, &x24, x22, (arg1[11]), (arg2[11])); + var x25: u32 = undefined; + cmovznzU32(&x25, x24, cast(u32, 0x0), 0xffffffff); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, 0x0, x1, (x25 & 0xccc52973)); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, x3, (x25 & 0xecec196a)); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, x5, (x25 & 0x48b0a77a)); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x7, (x25 & 0x581a0db2)); + var x34: u32 = undefined; + var x35: u1 = undefined; + addcarryxU32(&x34, &x35, x33, x9, (x25 & 0xf4372ddf)); + var x36: u32 = undefined; + var x37: u1 = undefined; + addcarryxU32(&x36, &x37, x35, x11, (x25 & 0xc7634d81)); + var x38: u32 = undefined; + var x39: u1 = undefined; + addcarryxU32(&x38, &x39, x37, x13, x25); + var x40: u32 = undefined; + var x41: u1 = undefined; + addcarryxU32(&x40, &x41, x39, x15, x25); + var x42: u32 = undefined; + var x43: u1 = undefined; + addcarryxU32(&x42, &x43, x41, x17, x25); + var x44: u32 = undefined; + var x45: u1 = undefined; + addcarryxU32(&x44, &x45, x43, x19, x25); + var x46: u32 = undefined; + var x47: u1 = undefined; + addcarryxU32(&x46, &x47, x45, x21, x25); + var x48: u32 = undefined; + var x49: u1 = undefined; + addcarryxU32(&x48, &x49, x47, x23, x25); + out1[0] = x26; + out1[1] = x28; + out1[2] = x30; + out1[3] = x32; + out1[4] = x34; + out1[5] = x36; + out1[6] = x38; + out1[7] = x40; + out1[8] = x42; + out1[9] = x44; + out1[10] = x46; + out1[11] = x48; +} + +/// The function opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +pub fn opp(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + subborrowxU32(&x1, &x2, 0x0, cast(u32, 0x0), (arg1[0])); + var x3: u32 = undefined; + var x4: u1 = undefined; + subborrowxU32(&x3, &x4, x2, cast(u32, 0x0), (arg1[1])); + var x5: u32 = undefined; + var x6: u1 = undefined; + subborrowxU32(&x5, &x6, x4, cast(u32, 0x0), (arg1[2])); + var x7: u32 = undefined; + var x8: u1 = undefined; + subborrowxU32(&x7, &x8, x6, cast(u32, 0x0), (arg1[3])); + var x9: u32 = undefined; + var x10: u1 = undefined; + subborrowxU32(&x9, &x10, x8, cast(u32, 0x0), (arg1[4])); + var x11: u32 = undefined; + var x12: u1 = undefined; + subborrowxU32(&x11, &x12, x10, cast(u32, 0x0), (arg1[5])); + var x13: u32 = undefined; + var x14: u1 = undefined; + subborrowxU32(&x13, &x14, x12, cast(u32, 0x0), (arg1[6])); + var x15: u32 = undefined; + var x16: u1 = undefined; + subborrowxU32(&x15, &x16, x14, cast(u32, 0x0), (arg1[7])); + var x17: u32 = undefined; + var x18: u1 = undefined; + subborrowxU32(&x17, &x18, x16, cast(u32, 0x0), (arg1[8])); + var x19: u32 = undefined; + var x20: u1 = undefined; + subborrowxU32(&x19, &x20, x18, cast(u32, 0x0), (arg1[9])); + var x21: u32 = undefined; + var x22: u1 = undefined; + subborrowxU32(&x21, &x22, x20, cast(u32, 0x0), (arg1[10])); + var x23: u32 = undefined; + var x24: u1 = undefined; + subborrowxU32(&x23, &x24, x22, cast(u32, 0x0), (arg1[11])); + var x25: u32 = undefined; + cmovznzU32(&x25, x24, cast(u32, 0x0), 0xffffffff); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, 0x0, x1, (x25 & 0xccc52973)); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, x3, (x25 & 0xecec196a)); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, x5, (x25 & 0x48b0a77a)); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x7, (x25 & 0x581a0db2)); + var x34: u32 = undefined; + var x35: u1 = undefined; + addcarryxU32(&x34, &x35, x33, x9, (x25 & 0xf4372ddf)); + var x36: u32 = undefined; + var x37: u1 = undefined; + addcarryxU32(&x36, &x37, x35, x11, (x25 & 0xc7634d81)); + var x38: u32 = undefined; + var x39: u1 = undefined; + addcarryxU32(&x38, &x39, x37, x13, x25); + var x40: u32 = undefined; + var x41: u1 = undefined; + addcarryxU32(&x40, &x41, x39, x15, x25); + var x42: u32 = undefined; + var x43: u1 = undefined; + addcarryxU32(&x42, &x43, x41, x17, x25); + var x44: u32 = undefined; + var x45: u1 = undefined; + addcarryxU32(&x44, &x45, x43, x19, x25); + var x46: u32 = undefined; + var x47: u1 = undefined; + addcarryxU32(&x46, &x47, x45, x21, x25); + var x48: u32 = undefined; + var x49: u1 = undefined; + addcarryxU32(&x48, &x49, x47, x23, x25); + out1[0] = x26; + out1[1] = x28; + out1[2] = x30; + out1[3] = x32; + out1[4] = x34; + out1[5] = x36; + out1[6] = x38; + out1[7] = x40; + out1[8] = x42; + out1[9] = x44; + out1[10] = x46; + out1[11] = x48; +} + +/// The function fromMontgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^12) mod m +/// 0 ≤ eval out1 < m +/// +pub fn fromMontgomery(out1: *NonMontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[0]); + var x2: u32 = undefined; + var x3: u32 = undefined; + mulxU32(&x2, &x3, x1, 0xe88fdc45); + var x4: u32 = undefined; + var x5: u32 = undefined; + mulxU32(&x4, &x5, x2, 0xffffffff); + var x6: u32 = undefined; + var x7: u32 = undefined; + mulxU32(&x6, &x7, x2, 0xffffffff); + var x8: u32 = undefined; + var x9: u32 = undefined; + mulxU32(&x8, &x9, x2, 0xffffffff); + var x10: u32 = undefined; + var x11: u32 = undefined; + mulxU32(&x10, &x11, x2, 0xffffffff); + var x12: u32 = undefined; + var x13: u32 = undefined; + mulxU32(&x12, &x13, x2, 0xffffffff); + var x14: u32 = undefined; + var x15: u32 = undefined; + mulxU32(&x14, &x15, x2, 0xffffffff); + var x16: u32 = undefined; + var x17: u32 = undefined; + mulxU32(&x16, &x17, x2, 0xc7634d81); + var x18: u32 = undefined; + var x19: u32 = undefined; + mulxU32(&x18, &x19, x2, 0xf4372ddf); + var x20: u32 = undefined; + var x21: u32 = undefined; + mulxU32(&x20, &x21, x2, 0x581a0db2); + var x22: u32 = undefined; + var x23: u32 = undefined; + mulxU32(&x22, &x23, x2, 0x48b0a77a); + var x24: u32 = undefined; + var x25: u32 = undefined; + mulxU32(&x24, &x25, x2, 0xecec196a); + var x26: u32 = undefined; + var x27: u32 = undefined; + mulxU32(&x26, &x27, x2, 0xccc52973); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, 0x0, x27, x24); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, x25, x22); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x23, x20); + var x34: u32 = undefined; + var x35: u1 = undefined; + addcarryxU32(&x34, &x35, x33, x21, x18); + var x36: u32 = undefined; + var x37: u1 = undefined; + addcarryxU32(&x36, &x37, x35, x19, x16); + var x38: u32 = undefined; + var x39: u1 = undefined; + addcarryxU32(&x38, &x39, x37, x17, x14); + var x40: u32 = undefined; + var x41: u1 = undefined; + addcarryxU32(&x40, &x41, x39, x15, x12); + var x42: u32 = undefined; + var x43: u1 = undefined; + addcarryxU32(&x42, &x43, x41, x13, x10); + var x44: u32 = undefined; + var x45: u1 = undefined; + addcarryxU32(&x44, &x45, x43, x11, x8); + var x46: u32 = undefined; + var x47: u1 = undefined; + addcarryxU32(&x46, &x47, x45, x9, x6); + var x48: u32 = undefined; + var x49: u1 = undefined; + addcarryxU32(&x48, &x49, x47, x7, x4); + var x50: u32 = undefined; + var x51: u1 = undefined; + addcarryxU32(&x50, &x51, 0x0, x1, x26); + var x52: u32 = undefined; + var x53: u1 = undefined; + addcarryxU32(&x52, &x53, x51, cast(u32, 0x0), x28); + var x54: u32 = undefined; + var x55: u1 = undefined; + addcarryxU32(&x54, &x55, x53, cast(u32, 0x0), x30); + var x56: u32 = undefined; + var x57: u1 = undefined; + addcarryxU32(&x56, &x57, x55, cast(u32, 0x0), x32); + var x58: u32 = undefined; + var x59: u1 = undefined; + addcarryxU32(&x58, &x59, x57, cast(u32, 0x0), x34); + var x60: u32 = undefined; + var x61: u1 = undefined; + addcarryxU32(&x60, &x61, x59, cast(u32, 0x0), x36); + var x62: u32 = undefined; + var x63: u1 = undefined; + addcarryxU32(&x62, &x63, x61, cast(u32, 0x0), x38); + var x64: u32 = undefined; + var x65: u1 = undefined; + addcarryxU32(&x64, &x65, x63, cast(u32, 0x0), x40); + var x66: u32 = undefined; + var x67: u1 = undefined; + addcarryxU32(&x66, &x67, x65, cast(u32, 0x0), x42); + var x68: u32 = undefined; + var x69: u1 = undefined; + addcarryxU32(&x68, &x69, x67, cast(u32, 0x0), x44); + var x70: u32 = undefined; + var x71: u1 = undefined; + addcarryxU32(&x70, &x71, x69, cast(u32, 0x0), x46); + var x72: u32 = undefined; + var x73: u1 = undefined; + addcarryxU32(&x72, &x73, x71, cast(u32, 0x0), x48); + var x74: u32 = undefined; + var x75: u1 = undefined; + addcarryxU32(&x74, &x75, x73, cast(u32, 0x0), (cast(u32, x49) + x5)); + var x76: u32 = undefined; + var x77: u1 = undefined; + addcarryxU32(&x76, &x77, 0x0, x52, (arg1[1])); + var x78: u32 = undefined; + var x79: u1 = undefined; + addcarryxU32(&x78, &x79, x77, x54, cast(u32, 0x0)); + var x80: u32 = undefined; + var x81: u1 = undefined; + addcarryxU32(&x80, &x81, x79, x56, cast(u32, 0x0)); + var x82: u32 = undefined; + var x83: u1 = undefined; + addcarryxU32(&x82, &x83, x81, x58, cast(u32, 0x0)); + var x84: u32 = undefined; + var x85: u1 = undefined; + addcarryxU32(&x84, &x85, x83, x60, cast(u32, 0x0)); + var x86: u32 = undefined; + var x87: u1 = undefined; + addcarryxU32(&x86, &x87, x85, x62, cast(u32, 0x0)); + var x88: u32 = undefined; + var x89: u1 = undefined; + addcarryxU32(&x88, &x89, x87, x64, cast(u32, 0x0)); + var x90: u32 = undefined; + var x91: u1 = undefined; + addcarryxU32(&x90, &x91, x89, x66, cast(u32, 0x0)); + var x92: u32 = undefined; + var x93: u1 = undefined; + addcarryxU32(&x92, &x93, x91, x68, cast(u32, 0x0)); + var x94: u32 = undefined; + var x95: u1 = undefined; + addcarryxU32(&x94, &x95, x93, x70, cast(u32, 0x0)); + var x96: u32 = undefined; + var x97: u1 = undefined; + addcarryxU32(&x96, &x97, x95, x72, cast(u32, 0x0)); + var x98: u32 = undefined; + var x99: u1 = undefined; + addcarryxU32(&x98, &x99, x97, x74, cast(u32, 0x0)); + var x100: u32 = undefined; + var x101: u32 = undefined; + mulxU32(&x100, &x101, x76, 0xe88fdc45); + var x102: u32 = undefined; + var x103: u32 = undefined; + mulxU32(&x102, &x103, x100, 0xffffffff); + var x104: u32 = undefined; + var x105: u32 = undefined; + mulxU32(&x104, &x105, x100, 0xffffffff); + var x106: u32 = undefined; + var x107: u32 = undefined; + mulxU32(&x106, &x107, x100, 0xffffffff); + var x108: u32 = undefined; + var x109: u32 = undefined; + mulxU32(&x108, &x109, x100, 0xffffffff); + var x110: u32 = undefined; + var x111: u32 = undefined; + mulxU32(&x110, &x111, x100, 0xffffffff); + var x112: u32 = undefined; + var x113: u32 = undefined; + mulxU32(&x112, &x113, x100, 0xffffffff); + var x114: u32 = undefined; + var x115: u32 = undefined; + mulxU32(&x114, &x115, x100, 0xc7634d81); + var x116: u32 = undefined; + var x117: u32 = undefined; + mulxU32(&x116, &x117, x100, 0xf4372ddf); + var x118: u32 = undefined; + var x119: u32 = undefined; + mulxU32(&x118, &x119, x100, 0x581a0db2); + var x120: u32 = undefined; + var x121: u32 = undefined; + mulxU32(&x120, &x121, x100, 0x48b0a77a); + var x122: u32 = undefined; + var x123: u32 = undefined; + mulxU32(&x122, &x123, x100, 0xecec196a); + var x124: u32 = undefined; + var x125: u32 = undefined; + mulxU32(&x124, &x125, x100, 0xccc52973); + var x126: u32 = undefined; + var x127: u1 = undefined; + addcarryxU32(&x126, &x127, 0x0, x125, x122); + var x128: u32 = undefined; + var x129: u1 = undefined; + addcarryxU32(&x128, &x129, x127, x123, x120); + var x130: u32 = undefined; + var x131: u1 = undefined; + addcarryxU32(&x130, &x131, x129, x121, x118); + var x132: u32 = undefined; + var x133: u1 = undefined; + addcarryxU32(&x132, &x133, x131, x119, x116); + var x134: u32 = undefined; + var x135: u1 = undefined; + addcarryxU32(&x134, &x135, x133, x117, x114); + var x136: u32 = undefined; + var x137: u1 = undefined; + addcarryxU32(&x136, &x137, x135, x115, x112); + var x138: u32 = undefined; + var x139: u1 = undefined; + addcarryxU32(&x138, &x139, x137, x113, x110); + var x140: u32 = undefined; + var x141: u1 = undefined; + addcarryxU32(&x140, &x141, x139, x111, x108); + var x142: u32 = undefined; + var x143: u1 = undefined; + addcarryxU32(&x142, &x143, x141, x109, x106); + var x144: u32 = undefined; + var x145: u1 = undefined; + addcarryxU32(&x144, &x145, x143, x107, x104); + var x146: u32 = undefined; + var x147: u1 = undefined; + addcarryxU32(&x146, &x147, x145, x105, x102); + var x148: u32 = undefined; + var x149: u1 = undefined; + addcarryxU32(&x148, &x149, 0x0, x76, x124); + var x150: u32 = undefined; + var x151: u1 = undefined; + addcarryxU32(&x150, &x151, x149, x78, x126); + var x152: u32 = undefined; + var x153: u1 = undefined; + addcarryxU32(&x152, &x153, x151, x80, x128); + var x154: u32 = undefined; + var x155: u1 = undefined; + addcarryxU32(&x154, &x155, x153, x82, x130); + var x156: u32 = undefined; + var x157: u1 = undefined; + addcarryxU32(&x156, &x157, x155, x84, x132); + var x158: u32 = undefined; + var x159: u1 = undefined; + addcarryxU32(&x158, &x159, x157, x86, x134); + var x160: u32 = undefined; + var x161: u1 = undefined; + addcarryxU32(&x160, &x161, x159, x88, x136); + var x162: u32 = undefined; + var x163: u1 = undefined; + addcarryxU32(&x162, &x163, x161, x90, x138); + var x164: u32 = undefined; + var x165: u1 = undefined; + addcarryxU32(&x164, &x165, x163, x92, x140); + var x166: u32 = undefined; + var x167: u1 = undefined; + addcarryxU32(&x166, &x167, x165, x94, x142); + var x168: u32 = undefined; + var x169: u1 = undefined; + addcarryxU32(&x168, &x169, x167, x96, x144); + var x170: u32 = undefined; + var x171: u1 = undefined; + addcarryxU32(&x170, &x171, x169, x98, x146); + var x172: u32 = undefined; + var x173: u1 = undefined; + addcarryxU32(&x172, &x173, x171, (cast(u32, x99) + cast(u32, x75)), (cast(u32, x147) + x103)); + var x174: u32 = undefined; + var x175: u1 = undefined; + addcarryxU32(&x174, &x175, 0x0, x150, (arg1[2])); + var x176: u32 = undefined; + var x177: u1 = undefined; + addcarryxU32(&x176, &x177, x175, x152, cast(u32, 0x0)); + var x178: u32 = undefined; + var x179: u1 = undefined; + addcarryxU32(&x178, &x179, x177, x154, cast(u32, 0x0)); + var x180: u32 = undefined; + var x181: u1 = undefined; + addcarryxU32(&x180, &x181, x179, x156, cast(u32, 0x0)); + var x182: u32 = undefined; + var x183: u1 = undefined; + addcarryxU32(&x182, &x183, x181, x158, cast(u32, 0x0)); + var x184: u32 = undefined; + var x185: u1 = undefined; + addcarryxU32(&x184, &x185, x183, x160, cast(u32, 0x0)); + var x186: u32 = undefined; + var x187: u1 = undefined; + addcarryxU32(&x186, &x187, x185, x162, cast(u32, 0x0)); + var x188: u32 = undefined; + var x189: u1 = undefined; + addcarryxU32(&x188, &x189, x187, x164, cast(u32, 0x0)); + var x190: u32 = undefined; + var x191: u1 = undefined; + addcarryxU32(&x190, &x191, x189, x166, cast(u32, 0x0)); + var x192: u32 = undefined; + var x193: u1 = undefined; + addcarryxU32(&x192, &x193, x191, x168, cast(u32, 0x0)); + var x194: u32 = undefined; + var x195: u1 = undefined; + addcarryxU32(&x194, &x195, x193, x170, cast(u32, 0x0)); + var x196: u32 = undefined; + var x197: u1 = undefined; + addcarryxU32(&x196, &x197, x195, x172, cast(u32, 0x0)); + var x198: u32 = undefined; + var x199: u32 = undefined; + mulxU32(&x198, &x199, x174, 0xe88fdc45); + var x200: u32 = undefined; + var x201: u32 = undefined; + mulxU32(&x200, &x201, x198, 0xffffffff); + var x202: u32 = undefined; + var x203: u32 = undefined; + mulxU32(&x202, &x203, x198, 0xffffffff); + var x204: u32 = undefined; + var x205: u32 = undefined; + mulxU32(&x204, &x205, x198, 0xffffffff); + var x206: u32 = undefined; + var x207: u32 = undefined; + mulxU32(&x206, &x207, x198, 0xffffffff); + var x208: u32 = undefined; + var x209: u32 = undefined; + mulxU32(&x208, &x209, x198, 0xffffffff); + var x210: u32 = undefined; + var x211: u32 = undefined; + mulxU32(&x210, &x211, x198, 0xffffffff); + var x212: u32 = undefined; + var x213: u32 = undefined; + mulxU32(&x212, &x213, x198, 0xc7634d81); + var x214: u32 = undefined; + var x215: u32 = undefined; + mulxU32(&x214, &x215, x198, 0xf4372ddf); + var x216: u32 = undefined; + var x217: u32 = undefined; + mulxU32(&x216, &x217, x198, 0x581a0db2); + var x218: u32 = undefined; + var x219: u32 = undefined; + mulxU32(&x218, &x219, x198, 0x48b0a77a); + var x220: u32 = undefined; + var x221: u32 = undefined; + mulxU32(&x220, &x221, x198, 0xecec196a); + var x222: u32 = undefined; + var x223: u32 = undefined; + mulxU32(&x222, &x223, x198, 0xccc52973); + var x224: u32 = undefined; + var x225: u1 = undefined; + addcarryxU32(&x224, &x225, 0x0, x223, x220); + var x226: u32 = undefined; + var x227: u1 = undefined; + addcarryxU32(&x226, &x227, x225, x221, x218); + var x228: u32 = undefined; + var x229: u1 = undefined; + addcarryxU32(&x228, &x229, x227, x219, x216); + var x230: u32 = undefined; + var x231: u1 = undefined; + addcarryxU32(&x230, &x231, x229, x217, x214); + var x232: u32 = undefined; + var x233: u1 = undefined; + addcarryxU32(&x232, &x233, x231, x215, x212); + var x234: u32 = undefined; + var x235: u1 = undefined; + addcarryxU32(&x234, &x235, x233, x213, x210); + var x236: u32 = undefined; + var x237: u1 = undefined; + addcarryxU32(&x236, &x237, x235, x211, x208); + var x238: u32 = undefined; + var x239: u1 = undefined; + addcarryxU32(&x238, &x239, x237, x209, x206); + var x240: u32 = undefined; + var x241: u1 = undefined; + addcarryxU32(&x240, &x241, x239, x207, x204); + var x242: u32 = undefined; + var x243: u1 = undefined; + addcarryxU32(&x242, &x243, x241, x205, x202); + var x244: u32 = undefined; + var x245: u1 = undefined; + addcarryxU32(&x244, &x245, x243, x203, x200); + var x246: u32 = undefined; + var x247: u1 = undefined; + addcarryxU32(&x246, &x247, 0x0, x174, x222); + var x248: u32 = undefined; + var x249: u1 = undefined; + addcarryxU32(&x248, &x249, x247, x176, x224); + var x250: u32 = undefined; + var x251: u1 = undefined; + addcarryxU32(&x250, &x251, x249, x178, x226); + var x252: u32 = undefined; + var x253: u1 = undefined; + addcarryxU32(&x252, &x253, x251, x180, x228); + var x254: u32 = undefined; + var x255: u1 = undefined; + addcarryxU32(&x254, &x255, x253, x182, x230); + var x256: u32 = undefined; + var x257: u1 = undefined; + addcarryxU32(&x256, &x257, x255, x184, x232); + var x258: u32 = undefined; + var x259: u1 = undefined; + addcarryxU32(&x258, &x259, x257, x186, x234); + var x260: u32 = undefined; + var x261: u1 = undefined; + addcarryxU32(&x260, &x261, x259, x188, x236); + var x262: u32 = undefined; + var x263: u1 = undefined; + addcarryxU32(&x262, &x263, x261, x190, x238); + var x264: u32 = undefined; + var x265: u1 = undefined; + addcarryxU32(&x264, &x265, x263, x192, x240); + var x266: u32 = undefined; + var x267: u1 = undefined; + addcarryxU32(&x266, &x267, x265, x194, x242); + var x268: u32 = undefined; + var x269: u1 = undefined; + addcarryxU32(&x268, &x269, x267, x196, x244); + var x270: u32 = undefined; + var x271: u1 = undefined; + addcarryxU32(&x270, &x271, x269, (cast(u32, x197) + cast(u32, x173)), (cast(u32, x245) + x201)); + var x272: u32 = undefined; + var x273: u1 = undefined; + addcarryxU32(&x272, &x273, 0x0, x248, (arg1[3])); + var x274: u32 = undefined; + var x275: u1 = undefined; + addcarryxU32(&x274, &x275, x273, x250, cast(u32, 0x0)); + var x276: u32 = undefined; + var x277: u1 = undefined; + addcarryxU32(&x276, &x277, x275, x252, cast(u32, 0x0)); + var x278: u32 = undefined; + var x279: u1 = undefined; + addcarryxU32(&x278, &x279, x277, x254, cast(u32, 0x0)); + var x280: u32 = undefined; + var x281: u1 = undefined; + addcarryxU32(&x280, &x281, x279, x256, cast(u32, 0x0)); + var x282: u32 = undefined; + var x283: u1 = undefined; + addcarryxU32(&x282, &x283, x281, x258, cast(u32, 0x0)); + var x284: u32 = undefined; + var x285: u1 = undefined; + addcarryxU32(&x284, &x285, x283, x260, cast(u32, 0x0)); + var x286: u32 = undefined; + var x287: u1 = undefined; + addcarryxU32(&x286, &x287, x285, x262, cast(u32, 0x0)); + var x288: u32 = undefined; + var x289: u1 = undefined; + addcarryxU32(&x288, &x289, x287, x264, cast(u32, 0x0)); + var x290: u32 = undefined; + var x291: u1 = undefined; + addcarryxU32(&x290, &x291, x289, x266, cast(u32, 0x0)); + var x292: u32 = undefined; + var x293: u1 = undefined; + addcarryxU32(&x292, &x293, x291, x268, cast(u32, 0x0)); + var x294: u32 = undefined; + var x295: u1 = undefined; + addcarryxU32(&x294, &x295, x293, x270, cast(u32, 0x0)); + var x296: u32 = undefined; + var x297: u32 = undefined; + mulxU32(&x296, &x297, x272, 0xe88fdc45); + var x298: u32 = undefined; + var x299: u32 = undefined; + mulxU32(&x298, &x299, x296, 0xffffffff); + var x300: u32 = undefined; + var x301: u32 = undefined; + mulxU32(&x300, &x301, x296, 0xffffffff); + var x302: u32 = undefined; + var x303: u32 = undefined; + mulxU32(&x302, &x303, x296, 0xffffffff); + var x304: u32 = undefined; + var x305: u32 = undefined; + mulxU32(&x304, &x305, x296, 0xffffffff); + var x306: u32 = undefined; + var x307: u32 = undefined; + mulxU32(&x306, &x307, x296, 0xffffffff); + var x308: u32 = undefined; + var x309: u32 = undefined; + mulxU32(&x308, &x309, x296, 0xffffffff); + var x310: u32 = undefined; + var x311: u32 = undefined; + mulxU32(&x310, &x311, x296, 0xc7634d81); + var x312: u32 = undefined; + var x313: u32 = undefined; + mulxU32(&x312, &x313, x296, 0xf4372ddf); + var x314: u32 = undefined; + var x315: u32 = undefined; + mulxU32(&x314, &x315, x296, 0x581a0db2); + var x316: u32 = undefined; + var x317: u32 = undefined; + mulxU32(&x316, &x317, x296, 0x48b0a77a); + var x318: u32 = undefined; + var x319: u32 = undefined; + mulxU32(&x318, &x319, x296, 0xecec196a); + var x320: u32 = undefined; + var x321: u32 = undefined; + mulxU32(&x320, &x321, x296, 0xccc52973); + var x322: u32 = undefined; + var x323: u1 = undefined; + addcarryxU32(&x322, &x323, 0x0, x321, x318); + var x324: u32 = undefined; + var x325: u1 = undefined; + addcarryxU32(&x324, &x325, x323, x319, x316); + var x326: u32 = undefined; + var x327: u1 = undefined; + addcarryxU32(&x326, &x327, x325, x317, x314); + var x328: u32 = undefined; + var x329: u1 = undefined; + addcarryxU32(&x328, &x329, x327, x315, x312); + var x330: u32 = undefined; + var x331: u1 = undefined; + addcarryxU32(&x330, &x331, x329, x313, x310); + var x332: u32 = undefined; + var x333: u1 = undefined; + addcarryxU32(&x332, &x333, x331, x311, x308); + var x334: u32 = undefined; + var x335: u1 = undefined; + addcarryxU32(&x334, &x335, x333, x309, x306); + var x336: u32 = undefined; + var x337: u1 = undefined; + addcarryxU32(&x336, &x337, x335, x307, x304); + var x338: u32 = undefined; + var x339: u1 = undefined; + addcarryxU32(&x338, &x339, x337, x305, x302); + var x340: u32 = undefined; + var x341: u1 = undefined; + addcarryxU32(&x340, &x341, x339, x303, x300); + var x342: u32 = undefined; + var x343: u1 = undefined; + addcarryxU32(&x342, &x343, x341, x301, x298); + var x344: u32 = undefined; + var x345: u1 = undefined; + addcarryxU32(&x344, &x345, 0x0, x272, x320); + var x346: u32 = undefined; + var x347: u1 = undefined; + addcarryxU32(&x346, &x347, x345, x274, x322); + var x348: u32 = undefined; + var x349: u1 = undefined; + addcarryxU32(&x348, &x349, x347, x276, x324); + var x350: u32 = undefined; + var x351: u1 = undefined; + addcarryxU32(&x350, &x351, x349, x278, x326); + var x352: u32 = undefined; + var x353: u1 = undefined; + addcarryxU32(&x352, &x353, x351, x280, x328); + var x354: u32 = undefined; + var x355: u1 = undefined; + addcarryxU32(&x354, &x355, x353, x282, x330); + var x356: u32 = undefined; + var x357: u1 = undefined; + addcarryxU32(&x356, &x357, x355, x284, x332); + var x358: u32 = undefined; + var x359: u1 = undefined; + addcarryxU32(&x358, &x359, x357, x286, x334); + var x360: u32 = undefined; + var x361: u1 = undefined; + addcarryxU32(&x360, &x361, x359, x288, x336); + var x362: u32 = undefined; + var x363: u1 = undefined; + addcarryxU32(&x362, &x363, x361, x290, x338); + var x364: u32 = undefined; + var x365: u1 = undefined; + addcarryxU32(&x364, &x365, x363, x292, x340); + var x366: u32 = undefined; + var x367: u1 = undefined; + addcarryxU32(&x366, &x367, x365, x294, x342); + var x368: u32 = undefined; + var x369: u1 = undefined; + addcarryxU32(&x368, &x369, x367, (cast(u32, x295) + cast(u32, x271)), (cast(u32, x343) + x299)); + var x370: u32 = undefined; + var x371: u1 = undefined; + addcarryxU32(&x370, &x371, 0x0, x346, (arg1[4])); + var x372: u32 = undefined; + var x373: u1 = undefined; + addcarryxU32(&x372, &x373, x371, x348, cast(u32, 0x0)); + var x374: u32 = undefined; + var x375: u1 = undefined; + addcarryxU32(&x374, &x375, x373, x350, cast(u32, 0x0)); + var x376: u32 = undefined; + var x377: u1 = undefined; + addcarryxU32(&x376, &x377, x375, x352, cast(u32, 0x0)); + var x378: u32 = undefined; + var x379: u1 = undefined; + addcarryxU32(&x378, &x379, x377, x354, cast(u32, 0x0)); + var x380: u32 = undefined; + var x381: u1 = undefined; + addcarryxU32(&x380, &x381, x379, x356, cast(u32, 0x0)); + var x382: u32 = undefined; + var x383: u1 = undefined; + addcarryxU32(&x382, &x383, x381, x358, cast(u32, 0x0)); + var x384: u32 = undefined; + var x385: u1 = undefined; + addcarryxU32(&x384, &x385, x383, x360, cast(u32, 0x0)); + var x386: u32 = undefined; + var x387: u1 = undefined; + addcarryxU32(&x386, &x387, x385, x362, cast(u32, 0x0)); + var x388: u32 = undefined; + var x389: u1 = undefined; + addcarryxU32(&x388, &x389, x387, x364, cast(u32, 0x0)); + var x390: u32 = undefined; + var x391: u1 = undefined; + addcarryxU32(&x390, &x391, x389, x366, cast(u32, 0x0)); + var x392: u32 = undefined; + var x393: u1 = undefined; + addcarryxU32(&x392, &x393, x391, x368, cast(u32, 0x0)); + var x394: u32 = undefined; + var x395: u32 = undefined; + mulxU32(&x394, &x395, x370, 0xe88fdc45); + var x396: u32 = undefined; + var x397: u32 = undefined; + mulxU32(&x396, &x397, x394, 0xffffffff); + var x398: u32 = undefined; + var x399: u32 = undefined; + mulxU32(&x398, &x399, x394, 0xffffffff); + var x400: u32 = undefined; + var x401: u32 = undefined; + mulxU32(&x400, &x401, x394, 0xffffffff); + var x402: u32 = undefined; + var x403: u32 = undefined; + mulxU32(&x402, &x403, x394, 0xffffffff); + var x404: u32 = undefined; + var x405: u32 = undefined; + mulxU32(&x404, &x405, x394, 0xffffffff); + var x406: u32 = undefined; + var x407: u32 = undefined; + mulxU32(&x406, &x407, x394, 0xffffffff); + var x408: u32 = undefined; + var x409: u32 = undefined; + mulxU32(&x408, &x409, x394, 0xc7634d81); + var x410: u32 = undefined; + var x411: u32 = undefined; + mulxU32(&x410, &x411, x394, 0xf4372ddf); + var x412: u32 = undefined; + var x413: u32 = undefined; + mulxU32(&x412, &x413, x394, 0x581a0db2); + var x414: u32 = undefined; + var x415: u32 = undefined; + mulxU32(&x414, &x415, x394, 0x48b0a77a); + var x416: u32 = undefined; + var x417: u32 = undefined; + mulxU32(&x416, &x417, x394, 0xecec196a); + var x418: u32 = undefined; + var x419: u32 = undefined; + mulxU32(&x418, &x419, x394, 0xccc52973); + var x420: u32 = undefined; + var x421: u1 = undefined; + addcarryxU32(&x420, &x421, 0x0, x419, x416); + var x422: u32 = undefined; + var x423: u1 = undefined; + addcarryxU32(&x422, &x423, x421, x417, x414); + var x424: u32 = undefined; + var x425: u1 = undefined; + addcarryxU32(&x424, &x425, x423, x415, x412); + var x426: u32 = undefined; + var x427: u1 = undefined; + addcarryxU32(&x426, &x427, x425, x413, x410); + var x428: u32 = undefined; + var x429: u1 = undefined; + addcarryxU32(&x428, &x429, x427, x411, x408); + var x430: u32 = undefined; + var x431: u1 = undefined; + addcarryxU32(&x430, &x431, x429, x409, x406); + var x432: u32 = undefined; + var x433: u1 = undefined; + addcarryxU32(&x432, &x433, x431, x407, x404); + var x434: u32 = undefined; + var x435: u1 = undefined; + addcarryxU32(&x434, &x435, x433, x405, x402); + var x436: u32 = undefined; + var x437: u1 = undefined; + addcarryxU32(&x436, &x437, x435, x403, x400); + var x438: u32 = undefined; + var x439: u1 = undefined; + addcarryxU32(&x438, &x439, x437, x401, x398); + var x440: u32 = undefined; + var x441: u1 = undefined; + addcarryxU32(&x440, &x441, x439, x399, x396); + var x442: u32 = undefined; + var x443: u1 = undefined; + addcarryxU32(&x442, &x443, 0x0, x370, x418); + var x444: u32 = undefined; + var x445: u1 = undefined; + addcarryxU32(&x444, &x445, x443, x372, x420); + var x446: u32 = undefined; + var x447: u1 = undefined; + addcarryxU32(&x446, &x447, x445, x374, x422); + var x448: u32 = undefined; + var x449: u1 = undefined; + addcarryxU32(&x448, &x449, x447, x376, x424); + var x450: u32 = undefined; + var x451: u1 = undefined; + addcarryxU32(&x450, &x451, x449, x378, x426); + var x452: u32 = undefined; + var x453: u1 = undefined; + addcarryxU32(&x452, &x453, x451, x380, x428); + var x454: u32 = undefined; + var x455: u1 = undefined; + addcarryxU32(&x454, &x455, x453, x382, x430); + var x456: u32 = undefined; + var x457: u1 = undefined; + addcarryxU32(&x456, &x457, x455, x384, x432); + var x458: u32 = undefined; + var x459: u1 = undefined; + addcarryxU32(&x458, &x459, x457, x386, x434); + var x460: u32 = undefined; + var x461: u1 = undefined; + addcarryxU32(&x460, &x461, x459, x388, x436); + var x462: u32 = undefined; + var x463: u1 = undefined; + addcarryxU32(&x462, &x463, x461, x390, x438); + var x464: u32 = undefined; + var x465: u1 = undefined; + addcarryxU32(&x464, &x465, x463, x392, x440); + var x466: u32 = undefined; + var x467: u1 = undefined; + addcarryxU32(&x466, &x467, x465, (cast(u32, x393) + cast(u32, x369)), (cast(u32, x441) + x397)); + var x468: u32 = undefined; + var x469: u1 = undefined; + addcarryxU32(&x468, &x469, 0x0, x444, (arg1[5])); + var x470: u32 = undefined; + var x471: u1 = undefined; + addcarryxU32(&x470, &x471, x469, x446, cast(u32, 0x0)); + var x472: u32 = undefined; + var x473: u1 = undefined; + addcarryxU32(&x472, &x473, x471, x448, cast(u32, 0x0)); + var x474: u32 = undefined; + var x475: u1 = undefined; + addcarryxU32(&x474, &x475, x473, x450, cast(u32, 0x0)); + var x476: u32 = undefined; + var x477: u1 = undefined; + addcarryxU32(&x476, &x477, x475, x452, cast(u32, 0x0)); + var x478: u32 = undefined; + var x479: u1 = undefined; + addcarryxU32(&x478, &x479, x477, x454, cast(u32, 0x0)); + var x480: u32 = undefined; + var x481: u1 = undefined; + addcarryxU32(&x480, &x481, x479, x456, cast(u32, 0x0)); + var x482: u32 = undefined; + var x483: u1 = undefined; + addcarryxU32(&x482, &x483, x481, x458, cast(u32, 0x0)); + var x484: u32 = undefined; + var x485: u1 = undefined; + addcarryxU32(&x484, &x485, x483, x460, cast(u32, 0x0)); + var x486: u32 = undefined; + var x487: u1 = undefined; + addcarryxU32(&x486, &x487, x485, x462, cast(u32, 0x0)); + var x488: u32 = undefined; + var x489: u1 = undefined; + addcarryxU32(&x488, &x489, x487, x464, cast(u32, 0x0)); + var x490: u32 = undefined; + var x491: u1 = undefined; + addcarryxU32(&x490, &x491, x489, x466, cast(u32, 0x0)); + var x492: u32 = undefined; + var x493: u32 = undefined; + mulxU32(&x492, &x493, x468, 0xe88fdc45); + var x494: u32 = undefined; + var x495: u32 = undefined; + mulxU32(&x494, &x495, x492, 0xffffffff); + var x496: u32 = undefined; + var x497: u32 = undefined; + mulxU32(&x496, &x497, x492, 0xffffffff); + var x498: u32 = undefined; + var x499: u32 = undefined; + mulxU32(&x498, &x499, x492, 0xffffffff); + var x500: u32 = undefined; + var x501: u32 = undefined; + mulxU32(&x500, &x501, x492, 0xffffffff); + var x502: u32 = undefined; + var x503: u32 = undefined; + mulxU32(&x502, &x503, x492, 0xffffffff); + var x504: u32 = undefined; + var x505: u32 = undefined; + mulxU32(&x504, &x505, x492, 0xffffffff); + var x506: u32 = undefined; + var x507: u32 = undefined; + mulxU32(&x506, &x507, x492, 0xc7634d81); + var x508: u32 = undefined; + var x509: u32 = undefined; + mulxU32(&x508, &x509, x492, 0xf4372ddf); + var x510: u32 = undefined; + var x511: u32 = undefined; + mulxU32(&x510, &x511, x492, 0x581a0db2); + var x512: u32 = undefined; + var x513: u32 = undefined; + mulxU32(&x512, &x513, x492, 0x48b0a77a); + var x514: u32 = undefined; + var x515: u32 = undefined; + mulxU32(&x514, &x515, x492, 0xecec196a); + var x516: u32 = undefined; + var x517: u32 = undefined; + mulxU32(&x516, &x517, x492, 0xccc52973); + var x518: u32 = undefined; + var x519: u1 = undefined; + addcarryxU32(&x518, &x519, 0x0, x517, x514); + var x520: u32 = undefined; + var x521: u1 = undefined; + addcarryxU32(&x520, &x521, x519, x515, x512); + var x522: u32 = undefined; + var x523: u1 = undefined; + addcarryxU32(&x522, &x523, x521, x513, x510); + var x524: u32 = undefined; + var x525: u1 = undefined; + addcarryxU32(&x524, &x525, x523, x511, x508); + var x526: u32 = undefined; + var x527: u1 = undefined; + addcarryxU32(&x526, &x527, x525, x509, x506); + var x528: u32 = undefined; + var x529: u1 = undefined; + addcarryxU32(&x528, &x529, x527, x507, x504); + var x530: u32 = undefined; + var x531: u1 = undefined; + addcarryxU32(&x530, &x531, x529, x505, x502); + var x532: u32 = undefined; + var x533: u1 = undefined; + addcarryxU32(&x532, &x533, x531, x503, x500); + var x534: u32 = undefined; + var x535: u1 = undefined; + addcarryxU32(&x534, &x535, x533, x501, x498); + var x536: u32 = undefined; + var x537: u1 = undefined; + addcarryxU32(&x536, &x537, x535, x499, x496); + var x538: u32 = undefined; + var x539: u1 = undefined; + addcarryxU32(&x538, &x539, x537, x497, x494); + var x540: u32 = undefined; + var x541: u1 = undefined; + addcarryxU32(&x540, &x541, 0x0, x468, x516); + var x542: u32 = undefined; + var x543: u1 = undefined; + addcarryxU32(&x542, &x543, x541, x470, x518); + var x544: u32 = undefined; + var x545: u1 = undefined; + addcarryxU32(&x544, &x545, x543, x472, x520); + var x546: u32 = undefined; + var x547: u1 = undefined; + addcarryxU32(&x546, &x547, x545, x474, x522); + var x548: u32 = undefined; + var x549: u1 = undefined; + addcarryxU32(&x548, &x549, x547, x476, x524); + var x550: u32 = undefined; + var x551: u1 = undefined; + addcarryxU32(&x550, &x551, x549, x478, x526); + var x552: u32 = undefined; + var x553: u1 = undefined; + addcarryxU32(&x552, &x553, x551, x480, x528); + var x554: u32 = undefined; + var x555: u1 = undefined; + addcarryxU32(&x554, &x555, x553, x482, x530); + var x556: u32 = undefined; + var x557: u1 = undefined; + addcarryxU32(&x556, &x557, x555, x484, x532); + var x558: u32 = undefined; + var x559: u1 = undefined; + addcarryxU32(&x558, &x559, x557, x486, x534); + var x560: u32 = undefined; + var x561: u1 = undefined; + addcarryxU32(&x560, &x561, x559, x488, x536); + var x562: u32 = undefined; + var x563: u1 = undefined; + addcarryxU32(&x562, &x563, x561, x490, x538); + var x564: u32 = undefined; + var x565: u1 = undefined; + addcarryxU32(&x564, &x565, x563, (cast(u32, x491) + cast(u32, x467)), (cast(u32, x539) + x495)); + var x566: u32 = undefined; + var x567: u1 = undefined; + addcarryxU32(&x566, &x567, 0x0, x542, (arg1[6])); + var x568: u32 = undefined; + var x569: u1 = undefined; + addcarryxU32(&x568, &x569, x567, x544, cast(u32, 0x0)); + var x570: u32 = undefined; + var x571: u1 = undefined; + addcarryxU32(&x570, &x571, x569, x546, cast(u32, 0x0)); + var x572: u32 = undefined; + var x573: u1 = undefined; + addcarryxU32(&x572, &x573, x571, x548, cast(u32, 0x0)); + var x574: u32 = undefined; + var x575: u1 = undefined; + addcarryxU32(&x574, &x575, x573, x550, cast(u32, 0x0)); + var x576: u32 = undefined; + var x577: u1 = undefined; + addcarryxU32(&x576, &x577, x575, x552, cast(u32, 0x0)); + var x578: u32 = undefined; + var x579: u1 = undefined; + addcarryxU32(&x578, &x579, x577, x554, cast(u32, 0x0)); + var x580: u32 = undefined; + var x581: u1 = undefined; + addcarryxU32(&x580, &x581, x579, x556, cast(u32, 0x0)); + var x582: u32 = undefined; + var x583: u1 = undefined; + addcarryxU32(&x582, &x583, x581, x558, cast(u32, 0x0)); + var x584: u32 = undefined; + var x585: u1 = undefined; + addcarryxU32(&x584, &x585, x583, x560, cast(u32, 0x0)); + var x586: u32 = undefined; + var x587: u1 = undefined; + addcarryxU32(&x586, &x587, x585, x562, cast(u32, 0x0)); + var x588: u32 = undefined; + var x589: u1 = undefined; + addcarryxU32(&x588, &x589, x587, x564, cast(u32, 0x0)); + var x590: u32 = undefined; + var x591: u32 = undefined; + mulxU32(&x590, &x591, x566, 0xe88fdc45); + var x592: u32 = undefined; + var x593: u32 = undefined; + mulxU32(&x592, &x593, x590, 0xffffffff); + var x594: u32 = undefined; + var x595: u32 = undefined; + mulxU32(&x594, &x595, x590, 0xffffffff); + var x596: u32 = undefined; + var x597: u32 = undefined; + mulxU32(&x596, &x597, x590, 0xffffffff); + var x598: u32 = undefined; + var x599: u32 = undefined; + mulxU32(&x598, &x599, x590, 0xffffffff); + var x600: u32 = undefined; + var x601: u32 = undefined; + mulxU32(&x600, &x601, x590, 0xffffffff); + var x602: u32 = undefined; + var x603: u32 = undefined; + mulxU32(&x602, &x603, x590, 0xffffffff); + var x604: u32 = undefined; + var x605: u32 = undefined; + mulxU32(&x604, &x605, x590, 0xc7634d81); + var x606: u32 = undefined; + var x607: u32 = undefined; + mulxU32(&x606, &x607, x590, 0xf4372ddf); + var x608: u32 = undefined; + var x609: u32 = undefined; + mulxU32(&x608, &x609, x590, 0x581a0db2); + var x610: u32 = undefined; + var x611: u32 = undefined; + mulxU32(&x610, &x611, x590, 0x48b0a77a); + var x612: u32 = undefined; + var x613: u32 = undefined; + mulxU32(&x612, &x613, x590, 0xecec196a); + var x614: u32 = undefined; + var x615: u32 = undefined; + mulxU32(&x614, &x615, x590, 0xccc52973); + var x616: u32 = undefined; + var x617: u1 = undefined; + addcarryxU32(&x616, &x617, 0x0, x615, x612); + var x618: u32 = undefined; + var x619: u1 = undefined; + addcarryxU32(&x618, &x619, x617, x613, x610); + var x620: u32 = undefined; + var x621: u1 = undefined; + addcarryxU32(&x620, &x621, x619, x611, x608); + var x622: u32 = undefined; + var x623: u1 = undefined; + addcarryxU32(&x622, &x623, x621, x609, x606); + var x624: u32 = undefined; + var x625: u1 = undefined; + addcarryxU32(&x624, &x625, x623, x607, x604); + var x626: u32 = undefined; + var x627: u1 = undefined; + addcarryxU32(&x626, &x627, x625, x605, x602); + var x628: u32 = undefined; + var x629: u1 = undefined; + addcarryxU32(&x628, &x629, x627, x603, x600); + var x630: u32 = undefined; + var x631: u1 = undefined; + addcarryxU32(&x630, &x631, x629, x601, x598); + var x632: u32 = undefined; + var x633: u1 = undefined; + addcarryxU32(&x632, &x633, x631, x599, x596); + var x634: u32 = undefined; + var x635: u1 = undefined; + addcarryxU32(&x634, &x635, x633, x597, x594); + var x636: u32 = undefined; + var x637: u1 = undefined; + addcarryxU32(&x636, &x637, x635, x595, x592); + var x638: u32 = undefined; + var x639: u1 = undefined; + addcarryxU32(&x638, &x639, 0x0, x566, x614); + var x640: u32 = undefined; + var x641: u1 = undefined; + addcarryxU32(&x640, &x641, x639, x568, x616); + var x642: u32 = undefined; + var x643: u1 = undefined; + addcarryxU32(&x642, &x643, x641, x570, x618); + var x644: u32 = undefined; + var x645: u1 = undefined; + addcarryxU32(&x644, &x645, x643, x572, x620); + var x646: u32 = undefined; + var x647: u1 = undefined; + addcarryxU32(&x646, &x647, x645, x574, x622); + var x648: u32 = undefined; + var x649: u1 = undefined; + addcarryxU32(&x648, &x649, x647, x576, x624); + var x650: u32 = undefined; + var x651: u1 = undefined; + addcarryxU32(&x650, &x651, x649, x578, x626); + var x652: u32 = undefined; + var x653: u1 = undefined; + addcarryxU32(&x652, &x653, x651, x580, x628); + var x654: u32 = undefined; + var x655: u1 = undefined; + addcarryxU32(&x654, &x655, x653, x582, x630); + var x656: u32 = undefined; + var x657: u1 = undefined; + addcarryxU32(&x656, &x657, x655, x584, x632); + var x658: u32 = undefined; + var x659: u1 = undefined; + addcarryxU32(&x658, &x659, x657, x586, x634); + var x660: u32 = undefined; + var x661: u1 = undefined; + addcarryxU32(&x660, &x661, x659, x588, x636); + var x662: u32 = undefined; + var x663: u1 = undefined; + addcarryxU32(&x662, &x663, x661, (cast(u32, x589) + cast(u32, x565)), (cast(u32, x637) + x593)); + var x664: u32 = undefined; + var x665: u1 = undefined; + addcarryxU32(&x664, &x665, 0x0, x640, (arg1[7])); + var x666: u32 = undefined; + var x667: u1 = undefined; + addcarryxU32(&x666, &x667, x665, x642, cast(u32, 0x0)); + var x668: u32 = undefined; + var x669: u1 = undefined; + addcarryxU32(&x668, &x669, x667, x644, cast(u32, 0x0)); + var x670: u32 = undefined; + var x671: u1 = undefined; + addcarryxU32(&x670, &x671, x669, x646, cast(u32, 0x0)); + var x672: u32 = undefined; + var x673: u1 = undefined; + addcarryxU32(&x672, &x673, x671, x648, cast(u32, 0x0)); + var x674: u32 = undefined; + var x675: u1 = undefined; + addcarryxU32(&x674, &x675, x673, x650, cast(u32, 0x0)); + var x676: u32 = undefined; + var x677: u1 = undefined; + addcarryxU32(&x676, &x677, x675, x652, cast(u32, 0x0)); + var x678: u32 = undefined; + var x679: u1 = undefined; + addcarryxU32(&x678, &x679, x677, x654, cast(u32, 0x0)); + var x680: u32 = undefined; + var x681: u1 = undefined; + addcarryxU32(&x680, &x681, x679, x656, cast(u32, 0x0)); + var x682: u32 = undefined; + var x683: u1 = undefined; + addcarryxU32(&x682, &x683, x681, x658, cast(u32, 0x0)); + var x684: u32 = undefined; + var x685: u1 = undefined; + addcarryxU32(&x684, &x685, x683, x660, cast(u32, 0x0)); + var x686: u32 = undefined; + var x687: u1 = undefined; + addcarryxU32(&x686, &x687, x685, x662, cast(u32, 0x0)); + var x688: u32 = undefined; + var x689: u32 = undefined; + mulxU32(&x688, &x689, x664, 0xe88fdc45); + var x690: u32 = undefined; + var x691: u32 = undefined; + mulxU32(&x690, &x691, x688, 0xffffffff); + var x692: u32 = undefined; + var x693: u32 = undefined; + mulxU32(&x692, &x693, x688, 0xffffffff); + var x694: u32 = undefined; + var x695: u32 = undefined; + mulxU32(&x694, &x695, x688, 0xffffffff); + var x696: u32 = undefined; + var x697: u32 = undefined; + mulxU32(&x696, &x697, x688, 0xffffffff); + var x698: u32 = undefined; + var x699: u32 = undefined; + mulxU32(&x698, &x699, x688, 0xffffffff); + var x700: u32 = undefined; + var x701: u32 = undefined; + mulxU32(&x700, &x701, x688, 0xffffffff); + var x702: u32 = undefined; + var x703: u32 = undefined; + mulxU32(&x702, &x703, x688, 0xc7634d81); + var x704: u32 = undefined; + var x705: u32 = undefined; + mulxU32(&x704, &x705, x688, 0xf4372ddf); + var x706: u32 = undefined; + var x707: u32 = undefined; + mulxU32(&x706, &x707, x688, 0x581a0db2); + var x708: u32 = undefined; + var x709: u32 = undefined; + mulxU32(&x708, &x709, x688, 0x48b0a77a); + var x710: u32 = undefined; + var x711: u32 = undefined; + mulxU32(&x710, &x711, x688, 0xecec196a); + var x712: u32 = undefined; + var x713: u32 = undefined; + mulxU32(&x712, &x713, x688, 0xccc52973); + var x714: u32 = undefined; + var x715: u1 = undefined; + addcarryxU32(&x714, &x715, 0x0, x713, x710); + var x716: u32 = undefined; + var x717: u1 = undefined; + addcarryxU32(&x716, &x717, x715, x711, x708); + var x718: u32 = undefined; + var x719: u1 = undefined; + addcarryxU32(&x718, &x719, x717, x709, x706); + var x720: u32 = undefined; + var x721: u1 = undefined; + addcarryxU32(&x720, &x721, x719, x707, x704); + var x722: u32 = undefined; + var x723: u1 = undefined; + addcarryxU32(&x722, &x723, x721, x705, x702); + var x724: u32 = undefined; + var x725: u1 = undefined; + addcarryxU32(&x724, &x725, x723, x703, x700); + var x726: u32 = undefined; + var x727: u1 = undefined; + addcarryxU32(&x726, &x727, x725, x701, x698); + var x728: u32 = undefined; + var x729: u1 = undefined; + addcarryxU32(&x728, &x729, x727, x699, x696); + var x730: u32 = undefined; + var x731: u1 = undefined; + addcarryxU32(&x730, &x731, x729, x697, x694); + var x732: u32 = undefined; + var x733: u1 = undefined; + addcarryxU32(&x732, &x733, x731, x695, x692); + var x734: u32 = undefined; + var x735: u1 = undefined; + addcarryxU32(&x734, &x735, x733, x693, x690); + var x736: u32 = undefined; + var x737: u1 = undefined; + addcarryxU32(&x736, &x737, 0x0, x664, x712); + var x738: u32 = undefined; + var x739: u1 = undefined; + addcarryxU32(&x738, &x739, x737, x666, x714); + var x740: u32 = undefined; + var x741: u1 = undefined; + addcarryxU32(&x740, &x741, x739, x668, x716); + var x742: u32 = undefined; + var x743: u1 = undefined; + addcarryxU32(&x742, &x743, x741, x670, x718); + var x744: u32 = undefined; + var x745: u1 = undefined; + addcarryxU32(&x744, &x745, x743, x672, x720); + var x746: u32 = undefined; + var x747: u1 = undefined; + addcarryxU32(&x746, &x747, x745, x674, x722); + var x748: u32 = undefined; + var x749: u1 = undefined; + addcarryxU32(&x748, &x749, x747, x676, x724); + var x750: u32 = undefined; + var x751: u1 = undefined; + addcarryxU32(&x750, &x751, x749, x678, x726); + var x752: u32 = undefined; + var x753: u1 = undefined; + addcarryxU32(&x752, &x753, x751, x680, x728); + var x754: u32 = undefined; + var x755: u1 = undefined; + addcarryxU32(&x754, &x755, x753, x682, x730); + var x756: u32 = undefined; + var x757: u1 = undefined; + addcarryxU32(&x756, &x757, x755, x684, x732); + var x758: u32 = undefined; + var x759: u1 = undefined; + addcarryxU32(&x758, &x759, x757, x686, x734); + var x760: u32 = undefined; + var x761: u1 = undefined; + addcarryxU32(&x760, &x761, x759, (cast(u32, x687) + cast(u32, x663)), (cast(u32, x735) + x691)); + var x762: u32 = undefined; + var x763: u1 = undefined; + addcarryxU32(&x762, &x763, 0x0, x738, (arg1[8])); + var x764: u32 = undefined; + var x765: u1 = undefined; + addcarryxU32(&x764, &x765, x763, x740, cast(u32, 0x0)); + var x766: u32 = undefined; + var x767: u1 = undefined; + addcarryxU32(&x766, &x767, x765, x742, cast(u32, 0x0)); + var x768: u32 = undefined; + var x769: u1 = undefined; + addcarryxU32(&x768, &x769, x767, x744, cast(u32, 0x0)); + var x770: u32 = undefined; + var x771: u1 = undefined; + addcarryxU32(&x770, &x771, x769, x746, cast(u32, 0x0)); + var x772: u32 = undefined; + var x773: u1 = undefined; + addcarryxU32(&x772, &x773, x771, x748, cast(u32, 0x0)); + var x774: u32 = undefined; + var x775: u1 = undefined; + addcarryxU32(&x774, &x775, x773, x750, cast(u32, 0x0)); + var x776: u32 = undefined; + var x777: u1 = undefined; + addcarryxU32(&x776, &x777, x775, x752, cast(u32, 0x0)); + var x778: u32 = undefined; + var x779: u1 = undefined; + addcarryxU32(&x778, &x779, x777, x754, cast(u32, 0x0)); + var x780: u32 = undefined; + var x781: u1 = undefined; + addcarryxU32(&x780, &x781, x779, x756, cast(u32, 0x0)); + var x782: u32 = undefined; + var x783: u1 = undefined; + addcarryxU32(&x782, &x783, x781, x758, cast(u32, 0x0)); + var x784: u32 = undefined; + var x785: u1 = undefined; + addcarryxU32(&x784, &x785, x783, x760, cast(u32, 0x0)); + var x786: u32 = undefined; + var x787: u32 = undefined; + mulxU32(&x786, &x787, x762, 0xe88fdc45); + var x788: u32 = undefined; + var x789: u32 = undefined; + mulxU32(&x788, &x789, x786, 0xffffffff); + var x790: u32 = undefined; + var x791: u32 = undefined; + mulxU32(&x790, &x791, x786, 0xffffffff); + var x792: u32 = undefined; + var x793: u32 = undefined; + mulxU32(&x792, &x793, x786, 0xffffffff); + var x794: u32 = undefined; + var x795: u32 = undefined; + mulxU32(&x794, &x795, x786, 0xffffffff); + var x796: u32 = undefined; + var x797: u32 = undefined; + mulxU32(&x796, &x797, x786, 0xffffffff); + var x798: u32 = undefined; + var x799: u32 = undefined; + mulxU32(&x798, &x799, x786, 0xffffffff); + var x800: u32 = undefined; + var x801: u32 = undefined; + mulxU32(&x800, &x801, x786, 0xc7634d81); + var x802: u32 = undefined; + var x803: u32 = undefined; + mulxU32(&x802, &x803, x786, 0xf4372ddf); + var x804: u32 = undefined; + var x805: u32 = undefined; + mulxU32(&x804, &x805, x786, 0x581a0db2); + var x806: u32 = undefined; + var x807: u32 = undefined; + mulxU32(&x806, &x807, x786, 0x48b0a77a); + var x808: u32 = undefined; + var x809: u32 = undefined; + mulxU32(&x808, &x809, x786, 0xecec196a); + var x810: u32 = undefined; + var x811: u32 = undefined; + mulxU32(&x810, &x811, x786, 0xccc52973); + var x812: u32 = undefined; + var x813: u1 = undefined; + addcarryxU32(&x812, &x813, 0x0, x811, x808); + var x814: u32 = undefined; + var x815: u1 = undefined; + addcarryxU32(&x814, &x815, x813, x809, x806); + var x816: u32 = undefined; + var x817: u1 = undefined; + addcarryxU32(&x816, &x817, x815, x807, x804); + var x818: u32 = undefined; + var x819: u1 = undefined; + addcarryxU32(&x818, &x819, x817, x805, x802); + var x820: u32 = undefined; + var x821: u1 = undefined; + addcarryxU32(&x820, &x821, x819, x803, x800); + var x822: u32 = undefined; + var x823: u1 = undefined; + addcarryxU32(&x822, &x823, x821, x801, x798); + var x824: u32 = undefined; + var x825: u1 = undefined; + addcarryxU32(&x824, &x825, x823, x799, x796); + var x826: u32 = undefined; + var x827: u1 = undefined; + addcarryxU32(&x826, &x827, x825, x797, x794); + var x828: u32 = undefined; + var x829: u1 = undefined; + addcarryxU32(&x828, &x829, x827, x795, x792); + var x830: u32 = undefined; + var x831: u1 = undefined; + addcarryxU32(&x830, &x831, x829, x793, x790); + var x832: u32 = undefined; + var x833: u1 = undefined; + addcarryxU32(&x832, &x833, x831, x791, x788); + var x834: u32 = undefined; + var x835: u1 = undefined; + addcarryxU32(&x834, &x835, 0x0, x762, x810); + var x836: u32 = undefined; + var x837: u1 = undefined; + addcarryxU32(&x836, &x837, x835, x764, x812); + var x838: u32 = undefined; + var x839: u1 = undefined; + addcarryxU32(&x838, &x839, x837, x766, x814); + var x840: u32 = undefined; + var x841: u1 = undefined; + addcarryxU32(&x840, &x841, x839, x768, x816); + var x842: u32 = undefined; + var x843: u1 = undefined; + addcarryxU32(&x842, &x843, x841, x770, x818); + var x844: u32 = undefined; + var x845: u1 = undefined; + addcarryxU32(&x844, &x845, x843, x772, x820); + var x846: u32 = undefined; + var x847: u1 = undefined; + addcarryxU32(&x846, &x847, x845, x774, x822); + var x848: u32 = undefined; + var x849: u1 = undefined; + addcarryxU32(&x848, &x849, x847, x776, x824); + var x850: u32 = undefined; + var x851: u1 = undefined; + addcarryxU32(&x850, &x851, x849, x778, x826); + var x852: u32 = undefined; + var x853: u1 = undefined; + addcarryxU32(&x852, &x853, x851, x780, x828); + var x854: u32 = undefined; + var x855: u1 = undefined; + addcarryxU32(&x854, &x855, x853, x782, x830); + var x856: u32 = undefined; + var x857: u1 = undefined; + addcarryxU32(&x856, &x857, x855, x784, x832); + var x858: u32 = undefined; + var x859: u1 = undefined; + addcarryxU32(&x858, &x859, x857, (cast(u32, x785) + cast(u32, x761)), (cast(u32, x833) + x789)); + var x860: u32 = undefined; + var x861: u1 = undefined; + addcarryxU32(&x860, &x861, 0x0, x836, (arg1[9])); + var x862: u32 = undefined; + var x863: u1 = undefined; + addcarryxU32(&x862, &x863, x861, x838, cast(u32, 0x0)); + var x864: u32 = undefined; + var x865: u1 = undefined; + addcarryxU32(&x864, &x865, x863, x840, cast(u32, 0x0)); + var x866: u32 = undefined; + var x867: u1 = undefined; + addcarryxU32(&x866, &x867, x865, x842, cast(u32, 0x0)); + var x868: u32 = undefined; + var x869: u1 = undefined; + addcarryxU32(&x868, &x869, x867, x844, cast(u32, 0x0)); + var x870: u32 = undefined; + var x871: u1 = undefined; + addcarryxU32(&x870, &x871, x869, x846, cast(u32, 0x0)); + var x872: u32 = undefined; + var x873: u1 = undefined; + addcarryxU32(&x872, &x873, x871, x848, cast(u32, 0x0)); + var x874: u32 = undefined; + var x875: u1 = undefined; + addcarryxU32(&x874, &x875, x873, x850, cast(u32, 0x0)); + var x876: u32 = undefined; + var x877: u1 = undefined; + addcarryxU32(&x876, &x877, x875, x852, cast(u32, 0x0)); + var x878: u32 = undefined; + var x879: u1 = undefined; + addcarryxU32(&x878, &x879, x877, x854, cast(u32, 0x0)); + var x880: u32 = undefined; + var x881: u1 = undefined; + addcarryxU32(&x880, &x881, x879, x856, cast(u32, 0x0)); + var x882: u32 = undefined; + var x883: u1 = undefined; + addcarryxU32(&x882, &x883, x881, x858, cast(u32, 0x0)); + var x884: u32 = undefined; + var x885: u32 = undefined; + mulxU32(&x884, &x885, x860, 0xe88fdc45); + var x886: u32 = undefined; + var x887: u32 = undefined; + mulxU32(&x886, &x887, x884, 0xffffffff); + var x888: u32 = undefined; + var x889: u32 = undefined; + mulxU32(&x888, &x889, x884, 0xffffffff); + var x890: u32 = undefined; + var x891: u32 = undefined; + mulxU32(&x890, &x891, x884, 0xffffffff); + var x892: u32 = undefined; + var x893: u32 = undefined; + mulxU32(&x892, &x893, x884, 0xffffffff); + var x894: u32 = undefined; + var x895: u32 = undefined; + mulxU32(&x894, &x895, x884, 0xffffffff); + var x896: u32 = undefined; + var x897: u32 = undefined; + mulxU32(&x896, &x897, x884, 0xffffffff); + var x898: u32 = undefined; + var x899: u32 = undefined; + mulxU32(&x898, &x899, x884, 0xc7634d81); + var x900: u32 = undefined; + var x901: u32 = undefined; + mulxU32(&x900, &x901, x884, 0xf4372ddf); + var x902: u32 = undefined; + var x903: u32 = undefined; + mulxU32(&x902, &x903, x884, 0x581a0db2); + var x904: u32 = undefined; + var x905: u32 = undefined; + mulxU32(&x904, &x905, x884, 0x48b0a77a); + var x906: u32 = undefined; + var x907: u32 = undefined; + mulxU32(&x906, &x907, x884, 0xecec196a); + var x908: u32 = undefined; + var x909: u32 = undefined; + mulxU32(&x908, &x909, x884, 0xccc52973); + var x910: u32 = undefined; + var x911: u1 = undefined; + addcarryxU32(&x910, &x911, 0x0, x909, x906); + var x912: u32 = undefined; + var x913: u1 = undefined; + addcarryxU32(&x912, &x913, x911, x907, x904); + var x914: u32 = undefined; + var x915: u1 = undefined; + addcarryxU32(&x914, &x915, x913, x905, x902); + var x916: u32 = undefined; + var x917: u1 = undefined; + addcarryxU32(&x916, &x917, x915, x903, x900); + var x918: u32 = undefined; + var x919: u1 = undefined; + addcarryxU32(&x918, &x919, x917, x901, x898); + var x920: u32 = undefined; + var x921: u1 = undefined; + addcarryxU32(&x920, &x921, x919, x899, x896); + var x922: u32 = undefined; + var x923: u1 = undefined; + addcarryxU32(&x922, &x923, x921, x897, x894); + var x924: u32 = undefined; + var x925: u1 = undefined; + addcarryxU32(&x924, &x925, x923, x895, x892); + var x926: u32 = undefined; + var x927: u1 = undefined; + addcarryxU32(&x926, &x927, x925, x893, x890); + var x928: u32 = undefined; + var x929: u1 = undefined; + addcarryxU32(&x928, &x929, x927, x891, x888); + var x930: u32 = undefined; + var x931: u1 = undefined; + addcarryxU32(&x930, &x931, x929, x889, x886); + var x932: u32 = undefined; + var x933: u1 = undefined; + addcarryxU32(&x932, &x933, 0x0, x860, x908); + var x934: u32 = undefined; + var x935: u1 = undefined; + addcarryxU32(&x934, &x935, x933, x862, x910); + var x936: u32 = undefined; + var x937: u1 = undefined; + addcarryxU32(&x936, &x937, x935, x864, x912); + var x938: u32 = undefined; + var x939: u1 = undefined; + addcarryxU32(&x938, &x939, x937, x866, x914); + var x940: u32 = undefined; + var x941: u1 = undefined; + addcarryxU32(&x940, &x941, x939, x868, x916); + var x942: u32 = undefined; + var x943: u1 = undefined; + addcarryxU32(&x942, &x943, x941, x870, x918); + var x944: u32 = undefined; + var x945: u1 = undefined; + addcarryxU32(&x944, &x945, x943, x872, x920); + var x946: u32 = undefined; + var x947: u1 = undefined; + addcarryxU32(&x946, &x947, x945, x874, x922); + var x948: u32 = undefined; + var x949: u1 = undefined; + addcarryxU32(&x948, &x949, x947, x876, x924); + var x950: u32 = undefined; + var x951: u1 = undefined; + addcarryxU32(&x950, &x951, x949, x878, x926); + var x952: u32 = undefined; + var x953: u1 = undefined; + addcarryxU32(&x952, &x953, x951, x880, x928); + var x954: u32 = undefined; + var x955: u1 = undefined; + addcarryxU32(&x954, &x955, x953, x882, x930); + var x956: u32 = undefined; + var x957: u1 = undefined; + addcarryxU32(&x956, &x957, x955, (cast(u32, x883) + cast(u32, x859)), (cast(u32, x931) + x887)); + var x958: u32 = undefined; + var x959: u1 = undefined; + addcarryxU32(&x958, &x959, 0x0, x934, (arg1[10])); + var x960: u32 = undefined; + var x961: u1 = undefined; + addcarryxU32(&x960, &x961, x959, x936, cast(u32, 0x0)); + var x962: u32 = undefined; + var x963: u1 = undefined; + addcarryxU32(&x962, &x963, x961, x938, cast(u32, 0x0)); + var x964: u32 = undefined; + var x965: u1 = undefined; + addcarryxU32(&x964, &x965, x963, x940, cast(u32, 0x0)); + var x966: u32 = undefined; + var x967: u1 = undefined; + addcarryxU32(&x966, &x967, x965, x942, cast(u32, 0x0)); + var x968: u32 = undefined; + var x969: u1 = undefined; + addcarryxU32(&x968, &x969, x967, x944, cast(u32, 0x0)); + var x970: u32 = undefined; + var x971: u1 = undefined; + addcarryxU32(&x970, &x971, x969, x946, cast(u32, 0x0)); + var x972: u32 = undefined; + var x973: u1 = undefined; + addcarryxU32(&x972, &x973, x971, x948, cast(u32, 0x0)); + var x974: u32 = undefined; + var x975: u1 = undefined; + addcarryxU32(&x974, &x975, x973, x950, cast(u32, 0x0)); + var x976: u32 = undefined; + var x977: u1 = undefined; + addcarryxU32(&x976, &x977, x975, x952, cast(u32, 0x0)); + var x978: u32 = undefined; + var x979: u1 = undefined; + addcarryxU32(&x978, &x979, x977, x954, cast(u32, 0x0)); + var x980: u32 = undefined; + var x981: u1 = undefined; + addcarryxU32(&x980, &x981, x979, x956, cast(u32, 0x0)); + var x982: u32 = undefined; + var x983: u32 = undefined; + mulxU32(&x982, &x983, x958, 0xe88fdc45); + var x984: u32 = undefined; + var x985: u32 = undefined; + mulxU32(&x984, &x985, x982, 0xffffffff); + var x986: u32 = undefined; + var x987: u32 = undefined; + mulxU32(&x986, &x987, x982, 0xffffffff); + var x988: u32 = undefined; + var x989: u32 = undefined; + mulxU32(&x988, &x989, x982, 0xffffffff); + var x990: u32 = undefined; + var x991: u32 = undefined; + mulxU32(&x990, &x991, x982, 0xffffffff); + var x992: u32 = undefined; + var x993: u32 = undefined; + mulxU32(&x992, &x993, x982, 0xffffffff); + var x994: u32 = undefined; + var x995: u32 = undefined; + mulxU32(&x994, &x995, x982, 0xffffffff); + var x996: u32 = undefined; + var x997: u32 = undefined; + mulxU32(&x996, &x997, x982, 0xc7634d81); + var x998: u32 = undefined; + var x999: u32 = undefined; + mulxU32(&x998, &x999, x982, 0xf4372ddf); + var x1000: u32 = undefined; + var x1001: u32 = undefined; + mulxU32(&x1000, &x1001, x982, 0x581a0db2); + var x1002: u32 = undefined; + var x1003: u32 = undefined; + mulxU32(&x1002, &x1003, x982, 0x48b0a77a); + var x1004: u32 = undefined; + var x1005: u32 = undefined; + mulxU32(&x1004, &x1005, x982, 0xecec196a); + var x1006: u32 = undefined; + var x1007: u32 = undefined; + mulxU32(&x1006, &x1007, x982, 0xccc52973); + var x1008: u32 = undefined; + var x1009: u1 = undefined; + addcarryxU32(&x1008, &x1009, 0x0, x1007, x1004); + var x1010: u32 = undefined; + var x1011: u1 = undefined; + addcarryxU32(&x1010, &x1011, x1009, x1005, x1002); + var x1012: u32 = undefined; + var x1013: u1 = undefined; + addcarryxU32(&x1012, &x1013, x1011, x1003, x1000); + var x1014: u32 = undefined; + var x1015: u1 = undefined; + addcarryxU32(&x1014, &x1015, x1013, x1001, x998); + var x1016: u32 = undefined; + var x1017: u1 = undefined; + addcarryxU32(&x1016, &x1017, x1015, x999, x996); + var x1018: u32 = undefined; + var x1019: u1 = undefined; + addcarryxU32(&x1018, &x1019, x1017, x997, x994); + var x1020: u32 = undefined; + var x1021: u1 = undefined; + addcarryxU32(&x1020, &x1021, x1019, x995, x992); + var x1022: u32 = undefined; + var x1023: u1 = undefined; + addcarryxU32(&x1022, &x1023, x1021, x993, x990); + var x1024: u32 = undefined; + var x1025: u1 = undefined; + addcarryxU32(&x1024, &x1025, x1023, x991, x988); + var x1026: u32 = undefined; + var x1027: u1 = undefined; + addcarryxU32(&x1026, &x1027, x1025, x989, x986); + var x1028: u32 = undefined; + var x1029: u1 = undefined; + addcarryxU32(&x1028, &x1029, x1027, x987, x984); + var x1030: u32 = undefined; + var x1031: u1 = undefined; + addcarryxU32(&x1030, &x1031, 0x0, x958, x1006); + var x1032: u32 = undefined; + var x1033: u1 = undefined; + addcarryxU32(&x1032, &x1033, x1031, x960, x1008); + var x1034: u32 = undefined; + var x1035: u1 = undefined; + addcarryxU32(&x1034, &x1035, x1033, x962, x1010); + var x1036: u32 = undefined; + var x1037: u1 = undefined; + addcarryxU32(&x1036, &x1037, x1035, x964, x1012); + var x1038: u32 = undefined; + var x1039: u1 = undefined; + addcarryxU32(&x1038, &x1039, x1037, x966, x1014); + var x1040: u32 = undefined; + var x1041: u1 = undefined; + addcarryxU32(&x1040, &x1041, x1039, x968, x1016); + var x1042: u32 = undefined; + var x1043: u1 = undefined; + addcarryxU32(&x1042, &x1043, x1041, x970, x1018); + var x1044: u32 = undefined; + var x1045: u1 = undefined; + addcarryxU32(&x1044, &x1045, x1043, x972, x1020); + var x1046: u32 = undefined; + var x1047: u1 = undefined; + addcarryxU32(&x1046, &x1047, x1045, x974, x1022); + var x1048: u32 = undefined; + var x1049: u1 = undefined; + addcarryxU32(&x1048, &x1049, x1047, x976, x1024); + var x1050: u32 = undefined; + var x1051: u1 = undefined; + addcarryxU32(&x1050, &x1051, x1049, x978, x1026); + var x1052: u32 = undefined; + var x1053: u1 = undefined; + addcarryxU32(&x1052, &x1053, x1051, x980, x1028); + var x1054: u32 = undefined; + var x1055: u1 = undefined; + addcarryxU32(&x1054, &x1055, x1053, (cast(u32, x981) + cast(u32, x957)), (cast(u32, x1029) + x985)); + var x1056: u32 = undefined; + var x1057: u1 = undefined; + addcarryxU32(&x1056, &x1057, 0x0, x1032, (arg1[11])); + var x1058: u32 = undefined; + var x1059: u1 = undefined; + addcarryxU32(&x1058, &x1059, x1057, x1034, cast(u32, 0x0)); + var x1060: u32 = undefined; + var x1061: u1 = undefined; + addcarryxU32(&x1060, &x1061, x1059, x1036, cast(u32, 0x0)); + var x1062: u32 = undefined; + var x1063: u1 = undefined; + addcarryxU32(&x1062, &x1063, x1061, x1038, cast(u32, 0x0)); + var x1064: u32 = undefined; + var x1065: u1 = undefined; + addcarryxU32(&x1064, &x1065, x1063, x1040, cast(u32, 0x0)); + var x1066: u32 = undefined; + var x1067: u1 = undefined; + addcarryxU32(&x1066, &x1067, x1065, x1042, cast(u32, 0x0)); + var x1068: u32 = undefined; + var x1069: u1 = undefined; + addcarryxU32(&x1068, &x1069, x1067, x1044, cast(u32, 0x0)); + var x1070: u32 = undefined; + var x1071: u1 = undefined; + addcarryxU32(&x1070, &x1071, x1069, x1046, cast(u32, 0x0)); + var x1072: u32 = undefined; + var x1073: u1 = undefined; + addcarryxU32(&x1072, &x1073, x1071, x1048, cast(u32, 0x0)); + var x1074: u32 = undefined; + var x1075: u1 = undefined; + addcarryxU32(&x1074, &x1075, x1073, x1050, cast(u32, 0x0)); + var x1076: u32 = undefined; + var x1077: u1 = undefined; + addcarryxU32(&x1076, &x1077, x1075, x1052, cast(u32, 0x0)); + var x1078: u32 = undefined; + var x1079: u1 = undefined; + addcarryxU32(&x1078, &x1079, x1077, x1054, cast(u32, 0x0)); + var x1080: u32 = undefined; + var x1081: u32 = undefined; + mulxU32(&x1080, &x1081, x1056, 0xe88fdc45); + var x1082: u32 = undefined; + var x1083: u32 = undefined; + mulxU32(&x1082, &x1083, x1080, 0xffffffff); + var x1084: u32 = undefined; + var x1085: u32 = undefined; + mulxU32(&x1084, &x1085, x1080, 0xffffffff); + var x1086: u32 = undefined; + var x1087: u32 = undefined; + mulxU32(&x1086, &x1087, x1080, 0xffffffff); + var x1088: u32 = undefined; + var x1089: u32 = undefined; + mulxU32(&x1088, &x1089, x1080, 0xffffffff); + var x1090: u32 = undefined; + var x1091: u32 = undefined; + mulxU32(&x1090, &x1091, x1080, 0xffffffff); + var x1092: u32 = undefined; + var x1093: u32 = undefined; + mulxU32(&x1092, &x1093, x1080, 0xffffffff); + var x1094: u32 = undefined; + var x1095: u32 = undefined; + mulxU32(&x1094, &x1095, x1080, 0xc7634d81); + var x1096: u32 = undefined; + var x1097: u32 = undefined; + mulxU32(&x1096, &x1097, x1080, 0xf4372ddf); + var x1098: u32 = undefined; + var x1099: u32 = undefined; + mulxU32(&x1098, &x1099, x1080, 0x581a0db2); + var x1100: u32 = undefined; + var x1101: u32 = undefined; + mulxU32(&x1100, &x1101, x1080, 0x48b0a77a); + var x1102: u32 = undefined; + var x1103: u32 = undefined; + mulxU32(&x1102, &x1103, x1080, 0xecec196a); + var x1104: u32 = undefined; + var x1105: u32 = undefined; + mulxU32(&x1104, &x1105, x1080, 0xccc52973); + var x1106: u32 = undefined; + var x1107: u1 = undefined; + addcarryxU32(&x1106, &x1107, 0x0, x1105, x1102); + var x1108: u32 = undefined; + var x1109: u1 = undefined; + addcarryxU32(&x1108, &x1109, x1107, x1103, x1100); + var x1110: u32 = undefined; + var x1111: u1 = undefined; + addcarryxU32(&x1110, &x1111, x1109, x1101, x1098); + var x1112: u32 = undefined; + var x1113: u1 = undefined; + addcarryxU32(&x1112, &x1113, x1111, x1099, x1096); + var x1114: u32 = undefined; + var x1115: u1 = undefined; + addcarryxU32(&x1114, &x1115, x1113, x1097, x1094); + var x1116: u32 = undefined; + var x1117: u1 = undefined; + addcarryxU32(&x1116, &x1117, x1115, x1095, x1092); + var x1118: u32 = undefined; + var x1119: u1 = undefined; + addcarryxU32(&x1118, &x1119, x1117, x1093, x1090); + var x1120: u32 = undefined; + var x1121: u1 = undefined; + addcarryxU32(&x1120, &x1121, x1119, x1091, x1088); + var x1122: u32 = undefined; + var x1123: u1 = undefined; + addcarryxU32(&x1122, &x1123, x1121, x1089, x1086); + var x1124: u32 = undefined; + var x1125: u1 = undefined; + addcarryxU32(&x1124, &x1125, x1123, x1087, x1084); + var x1126: u32 = undefined; + var x1127: u1 = undefined; + addcarryxU32(&x1126, &x1127, x1125, x1085, x1082); + var x1128: u32 = undefined; + var x1129: u1 = undefined; + addcarryxU32(&x1128, &x1129, 0x0, x1056, x1104); + var x1130: u32 = undefined; + var x1131: u1 = undefined; + addcarryxU32(&x1130, &x1131, x1129, x1058, x1106); + var x1132: u32 = undefined; + var x1133: u1 = undefined; + addcarryxU32(&x1132, &x1133, x1131, x1060, x1108); + var x1134: u32 = undefined; + var x1135: u1 = undefined; + addcarryxU32(&x1134, &x1135, x1133, x1062, x1110); + var x1136: u32 = undefined; + var x1137: u1 = undefined; + addcarryxU32(&x1136, &x1137, x1135, x1064, x1112); + var x1138: u32 = undefined; + var x1139: u1 = undefined; + addcarryxU32(&x1138, &x1139, x1137, x1066, x1114); + var x1140: u32 = undefined; + var x1141: u1 = undefined; + addcarryxU32(&x1140, &x1141, x1139, x1068, x1116); + var x1142: u32 = undefined; + var x1143: u1 = undefined; + addcarryxU32(&x1142, &x1143, x1141, x1070, x1118); + var x1144: u32 = undefined; + var x1145: u1 = undefined; + addcarryxU32(&x1144, &x1145, x1143, x1072, x1120); + var x1146: u32 = undefined; + var x1147: u1 = undefined; + addcarryxU32(&x1146, &x1147, x1145, x1074, x1122); + var x1148: u32 = undefined; + var x1149: u1 = undefined; + addcarryxU32(&x1148, &x1149, x1147, x1076, x1124); + var x1150: u32 = undefined; + var x1151: u1 = undefined; + addcarryxU32(&x1150, &x1151, x1149, x1078, x1126); + var x1152: u32 = undefined; + var x1153: u1 = undefined; + addcarryxU32(&x1152, &x1153, x1151, (cast(u32, x1079) + cast(u32, x1055)), (cast(u32, x1127) + x1083)); + var x1154: u32 = undefined; + var x1155: u1 = undefined; + subborrowxU32(&x1154, &x1155, 0x0, x1130, 0xccc52973); + var x1156: u32 = undefined; + var x1157: u1 = undefined; + subborrowxU32(&x1156, &x1157, x1155, x1132, 0xecec196a); + var x1158: u32 = undefined; + var x1159: u1 = undefined; + subborrowxU32(&x1158, &x1159, x1157, x1134, 0x48b0a77a); + var x1160: u32 = undefined; + var x1161: u1 = undefined; + subborrowxU32(&x1160, &x1161, x1159, x1136, 0x581a0db2); + var x1162: u32 = undefined; + var x1163: u1 = undefined; + subborrowxU32(&x1162, &x1163, x1161, x1138, 0xf4372ddf); + var x1164: u32 = undefined; + var x1165: u1 = undefined; + subborrowxU32(&x1164, &x1165, x1163, x1140, 0xc7634d81); + var x1166: u32 = undefined; + var x1167: u1 = undefined; + subborrowxU32(&x1166, &x1167, x1165, x1142, 0xffffffff); + var x1168: u32 = undefined; + var x1169: u1 = undefined; + subborrowxU32(&x1168, &x1169, x1167, x1144, 0xffffffff); + var x1170: u32 = undefined; + var x1171: u1 = undefined; + subborrowxU32(&x1170, &x1171, x1169, x1146, 0xffffffff); + var x1172: u32 = undefined; + var x1173: u1 = undefined; + subborrowxU32(&x1172, &x1173, x1171, x1148, 0xffffffff); + var x1174: u32 = undefined; + var x1175: u1 = undefined; + subborrowxU32(&x1174, &x1175, x1173, x1150, 0xffffffff); + var x1176: u32 = undefined; + var x1177: u1 = undefined; + subborrowxU32(&x1176, &x1177, x1175, x1152, 0xffffffff); + var x1178: u32 = undefined; + var x1179: u1 = undefined; + subborrowxU32(&x1178, &x1179, x1177, cast(u32, x1153), cast(u32, 0x0)); + var x1180: u32 = undefined; + cmovznzU32(&x1180, x1179, x1154, x1130); + var x1181: u32 = undefined; + cmovznzU32(&x1181, x1179, x1156, x1132); + var x1182: u32 = undefined; + cmovznzU32(&x1182, x1179, x1158, x1134); + var x1183: u32 = undefined; + cmovznzU32(&x1183, x1179, x1160, x1136); + var x1184: u32 = undefined; + cmovznzU32(&x1184, x1179, x1162, x1138); + var x1185: u32 = undefined; + cmovznzU32(&x1185, x1179, x1164, x1140); + var x1186: u32 = undefined; + cmovznzU32(&x1186, x1179, x1166, x1142); + var x1187: u32 = undefined; + cmovznzU32(&x1187, x1179, x1168, x1144); + var x1188: u32 = undefined; + cmovznzU32(&x1188, x1179, x1170, x1146); + var x1189: u32 = undefined; + cmovznzU32(&x1189, x1179, x1172, x1148); + var x1190: u32 = undefined; + cmovznzU32(&x1190, x1179, x1174, x1150); + var x1191: u32 = undefined; + cmovznzU32(&x1191, x1179, x1176, x1152); + out1[0] = x1180; + out1[1] = x1181; + out1[2] = x1182; + out1[3] = x1183; + out1[4] = x1184; + out1[5] = x1185; + out1[6] = x1186; + out1[7] = x1187; + out1[8] = x1188; + out1[9] = x1189; + out1[10] = x1190; + out1[11] = x1191; +} + +/// The function toMontgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn toMontgomery(out1: *MontgomeryDomainFieldElement, arg1: NonMontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[6]); + const x7 = (arg1[7]); + const x8 = (arg1[8]); + const x9 = (arg1[9]); + const x10 = (arg1[10]); + const x11 = (arg1[11]); + const x12 = (arg1[0]); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x12, 0xc84ee01); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x12, 0x2b39bf21); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x12, 0x3fb05b7a); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x12, 0x28266895); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x12, 0xd40d4917); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x12, 0x4aab1cc5); + var x25: u32 = undefined; + var x26: u32 = undefined; + mulxU32(&x25, &x26, x12, 0xbc3e483a); + var x27: u32 = undefined; + var x28: u32 = undefined; + mulxU32(&x27, &x28, x12, 0xfcb82947); + var x29: u32 = undefined; + var x30: u32 = undefined; + mulxU32(&x29, &x30, x12, 0xff3d81e5); + var x31: u32 = undefined; + var x32: u32 = undefined; + mulxU32(&x31, &x32, x12, 0xdf1aa419); + var x33: u32 = undefined; + var x34: u32 = undefined; + mulxU32(&x33, &x34, x12, 0x2d319b24); + var x35: u32 = undefined; + var x36: u32 = undefined; + mulxU32(&x35, &x36, x12, 0x19b409a9); + var x37: u32 = undefined; + var x38: u1 = undefined; + addcarryxU32(&x37, &x38, 0x0, x36, x33); + var x39: u32 = undefined; + var x40: u1 = undefined; + addcarryxU32(&x39, &x40, x38, x34, x31); + var x41: u32 = undefined; + var x42: u1 = undefined; + addcarryxU32(&x41, &x42, x40, x32, x29); + var x43: u32 = undefined; + var x44: u1 = undefined; + addcarryxU32(&x43, &x44, x42, x30, x27); + var x45: u32 = undefined; + var x46: u1 = undefined; + addcarryxU32(&x45, &x46, x44, x28, x25); + var x47: u32 = undefined; + var x48: u1 = undefined; + addcarryxU32(&x47, &x48, x46, x26, x23); + var x49: u32 = undefined; + var x50: u1 = undefined; + addcarryxU32(&x49, &x50, x48, x24, x21); + var x51: u32 = undefined; + var x52: u1 = undefined; + addcarryxU32(&x51, &x52, x50, x22, x19); + var x53: u32 = undefined; + var x54: u1 = undefined; + addcarryxU32(&x53, &x54, x52, x20, x17); + var x55: u32 = undefined; + var x56: u1 = undefined; + addcarryxU32(&x55, &x56, x54, x18, x15); + var x57: u32 = undefined; + var x58: u1 = undefined; + addcarryxU32(&x57, &x58, x56, x16, x13); + var x59: u32 = undefined; + var x60: u32 = undefined; + mulxU32(&x59, &x60, x35, 0xe88fdc45); + var x61: u32 = undefined; + var x62: u32 = undefined; + mulxU32(&x61, &x62, x59, 0xffffffff); + var x63: u32 = undefined; + var x64: u32 = undefined; + mulxU32(&x63, &x64, x59, 0xffffffff); + var x65: u32 = undefined; + var x66: u32 = undefined; + mulxU32(&x65, &x66, x59, 0xffffffff); + var x67: u32 = undefined; + var x68: u32 = undefined; + mulxU32(&x67, &x68, x59, 0xffffffff); + var x69: u32 = undefined; + var x70: u32 = undefined; + mulxU32(&x69, &x70, x59, 0xffffffff); + var x71: u32 = undefined; + var x72: u32 = undefined; + mulxU32(&x71, &x72, x59, 0xffffffff); + var x73: u32 = undefined; + var x74: u32 = undefined; + mulxU32(&x73, &x74, x59, 0xc7634d81); + var x75: u32 = undefined; + var x76: u32 = undefined; + mulxU32(&x75, &x76, x59, 0xf4372ddf); + var x77: u32 = undefined; + var x78: u32 = undefined; + mulxU32(&x77, &x78, x59, 0x581a0db2); + var x79: u32 = undefined; + var x80: u32 = undefined; + mulxU32(&x79, &x80, x59, 0x48b0a77a); + var x81: u32 = undefined; + var x82: u32 = undefined; + mulxU32(&x81, &x82, x59, 0xecec196a); + var x83: u32 = undefined; + var x84: u32 = undefined; + mulxU32(&x83, &x84, x59, 0xccc52973); + var x85: u32 = undefined; + var x86: u1 = undefined; + addcarryxU32(&x85, &x86, 0x0, x84, x81); + var x87: u32 = undefined; + var x88: u1 = undefined; + addcarryxU32(&x87, &x88, x86, x82, x79); + var x89: u32 = undefined; + var x90: u1 = undefined; + addcarryxU32(&x89, &x90, x88, x80, x77); + var x91: u32 = undefined; + var x92: u1 = undefined; + addcarryxU32(&x91, &x92, x90, x78, x75); + var x93: u32 = undefined; + var x94: u1 = undefined; + addcarryxU32(&x93, &x94, x92, x76, x73); + var x95: u32 = undefined; + var x96: u1 = undefined; + addcarryxU32(&x95, &x96, x94, x74, x71); + var x97: u32 = undefined; + var x98: u1 = undefined; + addcarryxU32(&x97, &x98, x96, x72, x69); + var x99: u32 = undefined; + var x100: u1 = undefined; + addcarryxU32(&x99, &x100, x98, x70, x67); + var x101: u32 = undefined; + var x102: u1 = undefined; + addcarryxU32(&x101, &x102, x100, x68, x65); + var x103: u32 = undefined; + var x104: u1 = undefined; + addcarryxU32(&x103, &x104, x102, x66, x63); + var x105: u32 = undefined; + var x106: u1 = undefined; + addcarryxU32(&x105, &x106, x104, x64, x61); + var x107: u32 = undefined; + var x108: u1 = undefined; + addcarryxU32(&x107, &x108, 0x0, x35, x83); + var x109: u32 = undefined; + var x110: u1 = undefined; + addcarryxU32(&x109, &x110, x108, x37, x85); + var x111: u32 = undefined; + var x112: u1 = undefined; + addcarryxU32(&x111, &x112, x110, x39, x87); + var x113: u32 = undefined; + var x114: u1 = undefined; + addcarryxU32(&x113, &x114, x112, x41, x89); + var x115: u32 = undefined; + var x116: u1 = undefined; + addcarryxU32(&x115, &x116, x114, x43, x91); + var x117: u32 = undefined; + var x118: u1 = undefined; + addcarryxU32(&x117, &x118, x116, x45, x93); + var x119: u32 = undefined; + var x120: u1 = undefined; + addcarryxU32(&x119, &x120, x118, x47, x95); + var x121: u32 = undefined; + var x122: u1 = undefined; + addcarryxU32(&x121, &x122, x120, x49, x97); + var x123: u32 = undefined; + var x124: u1 = undefined; + addcarryxU32(&x123, &x124, x122, x51, x99); + var x125: u32 = undefined; + var x126: u1 = undefined; + addcarryxU32(&x125, &x126, x124, x53, x101); + var x127: u32 = undefined; + var x128: u1 = undefined; + addcarryxU32(&x127, &x128, x126, x55, x103); + var x129: u32 = undefined; + var x130: u1 = undefined; + addcarryxU32(&x129, &x130, x128, x57, x105); + var x131: u32 = undefined; + var x132: u1 = undefined; + addcarryxU32(&x131, &x132, x130, (cast(u32, x58) + x14), (cast(u32, x106) + x62)); + var x133: u32 = undefined; + var x134: u32 = undefined; + mulxU32(&x133, &x134, x1, 0xc84ee01); + var x135: u32 = undefined; + var x136: u32 = undefined; + mulxU32(&x135, &x136, x1, 0x2b39bf21); + var x137: u32 = undefined; + var x138: u32 = undefined; + mulxU32(&x137, &x138, x1, 0x3fb05b7a); + var x139: u32 = undefined; + var x140: u32 = undefined; + mulxU32(&x139, &x140, x1, 0x28266895); + var x141: u32 = undefined; + var x142: u32 = undefined; + mulxU32(&x141, &x142, x1, 0xd40d4917); + var x143: u32 = undefined; + var x144: u32 = undefined; + mulxU32(&x143, &x144, x1, 0x4aab1cc5); + var x145: u32 = undefined; + var x146: u32 = undefined; + mulxU32(&x145, &x146, x1, 0xbc3e483a); + var x147: u32 = undefined; + var x148: u32 = undefined; + mulxU32(&x147, &x148, x1, 0xfcb82947); + var x149: u32 = undefined; + var x150: u32 = undefined; + mulxU32(&x149, &x150, x1, 0xff3d81e5); + var x151: u32 = undefined; + var x152: u32 = undefined; + mulxU32(&x151, &x152, x1, 0xdf1aa419); + var x153: u32 = undefined; + var x154: u32 = undefined; + mulxU32(&x153, &x154, x1, 0x2d319b24); + var x155: u32 = undefined; + var x156: u32 = undefined; + mulxU32(&x155, &x156, x1, 0x19b409a9); + var x157: u32 = undefined; + var x158: u1 = undefined; + addcarryxU32(&x157, &x158, 0x0, x156, x153); + var x159: u32 = undefined; + var x160: u1 = undefined; + addcarryxU32(&x159, &x160, x158, x154, x151); + var x161: u32 = undefined; + var x162: u1 = undefined; + addcarryxU32(&x161, &x162, x160, x152, x149); + var x163: u32 = undefined; + var x164: u1 = undefined; + addcarryxU32(&x163, &x164, x162, x150, x147); + var x165: u32 = undefined; + var x166: u1 = undefined; + addcarryxU32(&x165, &x166, x164, x148, x145); + var x167: u32 = undefined; + var x168: u1 = undefined; + addcarryxU32(&x167, &x168, x166, x146, x143); + var x169: u32 = undefined; + var x170: u1 = undefined; + addcarryxU32(&x169, &x170, x168, x144, x141); + var x171: u32 = undefined; + var x172: u1 = undefined; + addcarryxU32(&x171, &x172, x170, x142, x139); + var x173: u32 = undefined; + var x174: u1 = undefined; + addcarryxU32(&x173, &x174, x172, x140, x137); + var x175: u32 = undefined; + var x176: u1 = undefined; + addcarryxU32(&x175, &x176, x174, x138, x135); + var x177: u32 = undefined; + var x178: u1 = undefined; + addcarryxU32(&x177, &x178, x176, x136, x133); + var x179: u32 = undefined; + var x180: u1 = undefined; + addcarryxU32(&x179, &x180, 0x0, x109, x155); + var x181: u32 = undefined; + var x182: u1 = undefined; + addcarryxU32(&x181, &x182, x180, x111, x157); + var x183: u32 = undefined; + var x184: u1 = undefined; + addcarryxU32(&x183, &x184, x182, x113, x159); + var x185: u32 = undefined; + var x186: u1 = undefined; + addcarryxU32(&x185, &x186, x184, x115, x161); + var x187: u32 = undefined; + var x188: u1 = undefined; + addcarryxU32(&x187, &x188, x186, x117, x163); + var x189: u32 = undefined; + var x190: u1 = undefined; + addcarryxU32(&x189, &x190, x188, x119, x165); + var x191: u32 = undefined; + var x192: u1 = undefined; + addcarryxU32(&x191, &x192, x190, x121, x167); + var x193: u32 = undefined; + var x194: u1 = undefined; + addcarryxU32(&x193, &x194, x192, x123, x169); + var x195: u32 = undefined; + var x196: u1 = undefined; + addcarryxU32(&x195, &x196, x194, x125, x171); + var x197: u32 = undefined; + var x198: u1 = undefined; + addcarryxU32(&x197, &x198, x196, x127, x173); + var x199: u32 = undefined; + var x200: u1 = undefined; + addcarryxU32(&x199, &x200, x198, x129, x175); + var x201: u32 = undefined; + var x202: u1 = undefined; + addcarryxU32(&x201, &x202, x200, x131, x177); + var x203: u32 = undefined; + var x204: u32 = undefined; + mulxU32(&x203, &x204, x179, 0xe88fdc45); + var x205: u32 = undefined; + var x206: u32 = undefined; + mulxU32(&x205, &x206, x203, 0xffffffff); + var x207: u32 = undefined; + var x208: u32 = undefined; + mulxU32(&x207, &x208, x203, 0xffffffff); + var x209: u32 = undefined; + var x210: u32 = undefined; + mulxU32(&x209, &x210, x203, 0xffffffff); + var x211: u32 = undefined; + var x212: u32 = undefined; + mulxU32(&x211, &x212, x203, 0xffffffff); + var x213: u32 = undefined; + var x214: u32 = undefined; + mulxU32(&x213, &x214, x203, 0xffffffff); + var x215: u32 = undefined; + var x216: u32 = undefined; + mulxU32(&x215, &x216, x203, 0xffffffff); + var x217: u32 = undefined; + var x218: u32 = undefined; + mulxU32(&x217, &x218, x203, 0xc7634d81); + var x219: u32 = undefined; + var x220: u32 = undefined; + mulxU32(&x219, &x220, x203, 0xf4372ddf); + var x221: u32 = undefined; + var x222: u32 = undefined; + mulxU32(&x221, &x222, x203, 0x581a0db2); + var x223: u32 = undefined; + var x224: u32 = undefined; + mulxU32(&x223, &x224, x203, 0x48b0a77a); + var x225: u32 = undefined; + var x226: u32 = undefined; + mulxU32(&x225, &x226, x203, 0xecec196a); + var x227: u32 = undefined; + var x228: u32 = undefined; + mulxU32(&x227, &x228, x203, 0xccc52973); + var x229: u32 = undefined; + var x230: u1 = undefined; + addcarryxU32(&x229, &x230, 0x0, x228, x225); + var x231: u32 = undefined; + var x232: u1 = undefined; + addcarryxU32(&x231, &x232, x230, x226, x223); + var x233: u32 = undefined; + var x234: u1 = undefined; + addcarryxU32(&x233, &x234, x232, x224, x221); + var x235: u32 = undefined; + var x236: u1 = undefined; + addcarryxU32(&x235, &x236, x234, x222, x219); + var x237: u32 = undefined; + var x238: u1 = undefined; + addcarryxU32(&x237, &x238, x236, x220, x217); + var x239: u32 = undefined; + var x240: u1 = undefined; + addcarryxU32(&x239, &x240, x238, x218, x215); + var x241: u32 = undefined; + var x242: u1 = undefined; + addcarryxU32(&x241, &x242, x240, x216, x213); + var x243: u32 = undefined; + var x244: u1 = undefined; + addcarryxU32(&x243, &x244, x242, x214, x211); + var x245: u32 = undefined; + var x246: u1 = undefined; + addcarryxU32(&x245, &x246, x244, x212, x209); + var x247: u32 = undefined; + var x248: u1 = undefined; + addcarryxU32(&x247, &x248, x246, x210, x207); + var x249: u32 = undefined; + var x250: u1 = undefined; + addcarryxU32(&x249, &x250, x248, x208, x205); + var x251: u32 = undefined; + var x252: u1 = undefined; + addcarryxU32(&x251, &x252, 0x0, x179, x227); + var x253: u32 = undefined; + var x254: u1 = undefined; + addcarryxU32(&x253, &x254, x252, x181, x229); + var x255: u32 = undefined; + var x256: u1 = undefined; + addcarryxU32(&x255, &x256, x254, x183, x231); + var x257: u32 = undefined; + var x258: u1 = undefined; + addcarryxU32(&x257, &x258, x256, x185, x233); + var x259: u32 = undefined; + var x260: u1 = undefined; + addcarryxU32(&x259, &x260, x258, x187, x235); + var x261: u32 = undefined; + var x262: u1 = undefined; + addcarryxU32(&x261, &x262, x260, x189, x237); + var x263: u32 = undefined; + var x264: u1 = undefined; + addcarryxU32(&x263, &x264, x262, x191, x239); + var x265: u32 = undefined; + var x266: u1 = undefined; + addcarryxU32(&x265, &x266, x264, x193, x241); + var x267: u32 = undefined; + var x268: u1 = undefined; + addcarryxU32(&x267, &x268, x266, x195, x243); + var x269: u32 = undefined; + var x270: u1 = undefined; + addcarryxU32(&x269, &x270, x268, x197, x245); + var x271: u32 = undefined; + var x272: u1 = undefined; + addcarryxU32(&x271, &x272, x270, x199, x247); + var x273: u32 = undefined; + var x274: u1 = undefined; + addcarryxU32(&x273, &x274, x272, x201, x249); + var x275: u32 = undefined; + var x276: u1 = undefined; + addcarryxU32(&x275, &x276, x274, ((cast(u32, x202) + cast(u32, x132)) + (cast(u32, x178) + x134)), (cast(u32, x250) + x206)); + var x277: u32 = undefined; + var x278: u32 = undefined; + mulxU32(&x277, &x278, x2, 0xc84ee01); + var x279: u32 = undefined; + var x280: u32 = undefined; + mulxU32(&x279, &x280, x2, 0x2b39bf21); + var x281: u32 = undefined; + var x282: u32 = undefined; + mulxU32(&x281, &x282, x2, 0x3fb05b7a); + var x283: u32 = undefined; + var x284: u32 = undefined; + mulxU32(&x283, &x284, x2, 0x28266895); + var x285: u32 = undefined; + var x286: u32 = undefined; + mulxU32(&x285, &x286, x2, 0xd40d4917); + var x287: u32 = undefined; + var x288: u32 = undefined; + mulxU32(&x287, &x288, x2, 0x4aab1cc5); + var x289: u32 = undefined; + var x290: u32 = undefined; + mulxU32(&x289, &x290, x2, 0xbc3e483a); + var x291: u32 = undefined; + var x292: u32 = undefined; + mulxU32(&x291, &x292, x2, 0xfcb82947); + var x293: u32 = undefined; + var x294: u32 = undefined; + mulxU32(&x293, &x294, x2, 0xff3d81e5); + var x295: u32 = undefined; + var x296: u32 = undefined; + mulxU32(&x295, &x296, x2, 0xdf1aa419); + var x297: u32 = undefined; + var x298: u32 = undefined; + mulxU32(&x297, &x298, x2, 0x2d319b24); + var x299: u32 = undefined; + var x300: u32 = undefined; + mulxU32(&x299, &x300, x2, 0x19b409a9); + var x301: u32 = undefined; + var x302: u1 = undefined; + addcarryxU32(&x301, &x302, 0x0, x300, x297); + var x303: u32 = undefined; + var x304: u1 = undefined; + addcarryxU32(&x303, &x304, x302, x298, x295); + var x305: u32 = undefined; + var x306: u1 = undefined; + addcarryxU32(&x305, &x306, x304, x296, x293); + var x307: u32 = undefined; + var x308: u1 = undefined; + addcarryxU32(&x307, &x308, x306, x294, x291); + var x309: u32 = undefined; + var x310: u1 = undefined; + addcarryxU32(&x309, &x310, x308, x292, x289); + var x311: u32 = undefined; + var x312: u1 = undefined; + addcarryxU32(&x311, &x312, x310, x290, x287); + var x313: u32 = undefined; + var x314: u1 = undefined; + addcarryxU32(&x313, &x314, x312, x288, x285); + var x315: u32 = undefined; + var x316: u1 = undefined; + addcarryxU32(&x315, &x316, x314, x286, x283); + var x317: u32 = undefined; + var x318: u1 = undefined; + addcarryxU32(&x317, &x318, x316, x284, x281); + var x319: u32 = undefined; + var x320: u1 = undefined; + addcarryxU32(&x319, &x320, x318, x282, x279); + var x321: u32 = undefined; + var x322: u1 = undefined; + addcarryxU32(&x321, &x322, x320, x280, x277); + var x323: u32 = undefined; + var x324: u1 = undefined; + addcarryxU32(&x323, &x324, 0x0, x253, x299); + var x325: u32 = undefined; + var x326: u1 = undefined; + addcarryxU32(&x325, &x326, x324, x255, x301); + var x327: u32 = undefined; + var x328: u1 = undefined; + addcarryxU32(&x327, &x328, x326, x257, x303); + var x329: u32 = undefined; + var x330: u1 = undefined; + addcarryxU32(&x329, &x330, x328, x259, x305); + var x331: u32 = undefined; + var x332: u1 = undefined; + addcarryxU32(&x331, &x332, x330, x261, x307); + var x333: u32 = undefined; + var x334: u1 = undefined; + addcarryxU32(&x333, &x334, x332, x263, x309); + var x335: u32 = undefined; + var x336: u1 = undefined; + addcarryxU32(&x335, &x336, x334, x265, x311); + var x337: u32 = undefined; + var x338: u1 = undefined; + addcarryxU32(&x337, &x338, x336, x267, x313); + var x339: u32 = undefined; + var x340: u1 = undefined; + addcarryxU32(&x339, &x340, x338, x269, x315); + var x341: u32 = undefined; + var x342: u1 = undefined; + addcarryxU32(&x341, &x342, x340, x271, x317); + var x343: u32 = undefined; + var x344: u1 = undefined; + addcarryxU32(&x343, &x344, x342, x273, x319); + var x345: u32 = undefined; + var x346: u1 = undefined; + addcarryxU32(&x345, &x346, x344, x275, x321); + var x347: u32 = undefined; + var x348: u32 = undefined; + mulxU32(&x347, &x348, x323, 0xe88fdc45); + var x349: u32 = undefined; + var x350: u32 = undefined; + mulxU32(&x349, &x350, x347, 0xffffffff); + var x351: u32 = undefined; + var x352: u32 = undefined; + mulxU32(&x351, &x352, x347, 0xffffffff); + var x353: u32 = undefined; + var x354: u32 = undefined; + mulxU32(&x353, &x354, x347, 0xffffffff); + var x355: u32 = undefined; + var x356: u32 = undefined; + mulxU32(&x355, &x356, x347, 0xffffffff); + var x357: u32 = undefined; + var x358: u32 = undefined; + mulxU32(&x357, &x358, x347, 0xffffffff); + var x359: u32 = undefined; + var x360: u32 = undefined; + mulxU32(&x359, &x360, x347, 0xffffffff); + var x361: u32 = undefined; + var x362: u32 = undefined; + mulxU32(&x361, &x362, x347, 0xc7634d81); + var x363: u32 = undefined; + var x364: u32 = undefined; + mulxU32(&x363, &x364, x347, 0xf4372ddf); + var x365: u32 = undefined; + var x366: u32 = undefined; + mulxU32(&x365, &x366, x347, 0x581a0db2); + var x367: u32 = undefined; + var x368: u32 = undefined; + mulxU32(&x367, &x368, x347, 0x48b0a77a); + var x369: u32 = undefined; + var x370: u32 = undefined; + mulxU32(&x369, &x370, x347, 0xecec196a); + var x371: u32 = undefined; + var x372: u32 = undefined; + mulxU32(&x371, &x372, x347, 0xccc52973); + var x373: u32 = undefined; + var x374: u1 = undefined; + addcarryxU32(&x373, &x374, 0x0, x372, x369); + var x375: u32 = undefined; + var x376: u1 = undefined; + addcarryxU32(&x375, &x376, x374, x370, x367); + var x377: u32 = undefined; + var x378: u1 = undefined; + addcarryxU32(&x377, &x378, x376, x368, x365); + var x379: u32 = undefined; + var x380: u1 = undefined; + addcarryxU32(&x379, &x380, x378, x366, x363); + var x381: u32 = undefined; + var x382: u1 = undefined; + addcarryxU32(&x381, &x382, x380, x364, x361); + var x383: u32 = undefined; + var x384: u1 = undefined; + addcarryxU32(&x383, &x384, x382, x362, x359); + var x385: u32 = undefined; + var x386: u1 = undefined; + addcarryxU32(&x385, &x386, x384, x360, x357); + var x387: u32 = undefined; + var x388: u1 = undefined; + addcarryxU32(&x387, &x388, x386, x358, x355); + var x389: u32 = undefined; + var x390: u1 = undefined; + addcarryxU32(&x389, &x390, x388, x356, x353); + var x391: u32 = undefined; + var x392: u1 = undefined; + addcarryxU32(&x391, &x392, x390, x354, x351); + var x393: u32 = undefined; + var x394: u1 = undefined; + addcarryxU32(&x393, &x394, x392, x352, x349); + var x395: u32 = undefined; + var x396: u1 = undefined; + addcarryxU32(&x395, &x396, 0x0, x323, x371); + var x397: u32 = undefined; + var x398: u1 = undefined; + addcarryxU32(&x397, &x398, x396, x325, x373); + var x399: u32 = undefined; + var x400: u1 = undefined; + addcarryxU32(&x399, &x400, x398, x327, x375); + var x401: u32 = undefined; + var x402: u1 = undefined; + addcarryxU32(&x401, &x402, x400, x329, x377); + var x403: u32 = undefined; + var x404: u1 = undefined; + addcarryxU32(&x403, &x404, x402, x331, x379); + var x405: u32 = undefined; + var x406: u1 = undefined; + addcarryxU32(&x405, &x406, x404, x333, x381); + var x407: u32 = undefined; + var x408: u1 = undefined; + addcarryxU32(&x407, &x408, x406, x335, x383); + var x409: u32 = undefined; + var x410: u1 = undefined; + addcarryxU32(&x409, &x410, x408, x337, x385); + var x411: u32 = undefined; + var x412: u1 = undefined; + addcarryxU32(&x411, &x412, x410, x339, x387); + var x413: u32 = undefined; + var x414: u1 = undefined; + addcarryxU32(&x413, &x414, x412, x341, x389); + var x415: u32 = undefined; + var x416: u1 = undefined; + addcarryxU32(&x415, &x416, x414, x343, x391); + var x417: u32 = undefined; + var x418: u1 = undefined; + addcarryxU32(&x417, &x418, x416, x345, x393); + var x419: u32 = undefined; + var x420: u1 = undefined; + addcarryxU32(&x419, &x420, x418, ((cast(u32, x346) + cast(u32, x276)) + (cast(u32, x322) + x278)), (cast(u32, x394) + x350)); + var x421: u32 = undefined; + var x422: u32 = undefined; + mulxU32(&x421, &x422, x3, 0xc84ee01); + var x423: u32 = undefined; + var x424: u32 = undefined; + mulxU32(&x423, &x424, x3, 0x2b39bf21); + var x425: u32 = undefined; + var x426: u32 = undefined; + mulxU32(&x425, &x426, x3, 0x3fb05b7a); + var x427: u32 = undefined; + var x428: u32 = undefined; + mulxU32(&x427, &x428, x3, 0x28266895); + var x429: u32 = undefined; + var x430: u32 = undefined; + mulxU32(&x429, &x430, x3, 0xd40d4917); + var x431: u32 = undefined; + var x432: u32 = undefined; + mulxU32(&x431, &x432, x3, 0x4aab1cc5); + var x433: u32 = undefined; + var x434: u32 = undefined; + mulxU32(&x433, &x434, x3, 0xbc3e483a); + var x435: u32 = undefined; + var x436: u32 = undefined; + mulxU32(&x435, &x436, x3, 0xfcb82947); + var x437: u32 = undefined; + var x438: u32 = undefined; + mulxU32(&x437, &x438, x3, 0xff3d81e5); + var x439: u32 = undefined; + var x440: u32 = undefined; + mulxU32(&x439, &x440, x3, 0xdf1aa419); + var x441: u32 = undefined; + var x442: u32 = undefined; + mulxU32(&x441, &x442, x3, 0x2d319b24); + var x443: u32 = undefined; + var x444: u32 = undefined; + mulxU32(&x443, &x444, x3, 0x19b409a9); + var x445: u32 = undefined; + var x446: u1 = undefined; + addcarryxU32(&x445, &x446, 0x0, x444, x441); + var x447: u32 = undefined; + var x448: u1 = undefined; + addcarryxU32(&x447, &x448, x446, x442, x439); + var x449: u32 = undefined; + var x450: u1 = undefined; + addcarryxU32(&x449, &x450, x448, x440, x437); + var x451: u32 = undefined; + var x452: u1 = undefined; + addcarryxU32(&x451, &x452, x450, x438, x435); + var x453: u32 = undefined; + var x454: u1 = undefined; + addcarryxU32(&x453, &x454, x452, x436, x433); + var x455: u32 = undefined; + var x456: u1 = undefined; + addcarryxU32(&x455, &x456, x454, x434, x431); + var x457: u32 = undefined; + var x458: u1 = undefined; + addcarryxU32(&x457, &x458, x456, x432, x429); + var x459: u32 = undefined; + var x460: u1 = undefined; + addcarryxU32(&x459, &x460, x458, x430, x427); + var x461: u32 = undefined; + var x462: u1 = undefined; + addcarryxU32(&x461, &x462, x460, x428, x425); + var x463: u32 = undefined; + var x464: u1 = undefined; + addcarryxU32(&x463, &x464, x462, x426, x423); + var x465: u32 = undefined; + var x466: u1 = undefined; + addcarryxU32(&x465, &x466, x464, x424, x421); + var x467: u32 = undefined; + var x468: u1 = undefined; + addcarryxU32(&x467, &x468, 0x0, x397, x443); + var x469: u32 = undefined; + var x470: u1 = undefined; + addcarryxU32(&x469, &x470, x468, x399, x445); + var x471: u32 = undefined; + var x472: u1 = undefined; + addcarryxU32(&x471, &x472, x470, x401, x447); + var x473: u32 = undefined; + var x474: u1 = undefined; + addcarryxU32(&x473, &x474, x472, x403, x449); + var x475: u32 = undefined; + var x476: u1 = undefined; + addcarryxU32(&x475, &x476, x474, x405, x451); + var x477: u32 = undefined; + var x478: u1 = undefined; + addcarryxU32(&x477, &x478, x476, x407, x453); + var x479: u32 = undefined; + var x480: u1 = undefined; + addcarryxU32(&x479, &x480, x478, x409, x455); + var x481: u32 = undefined; + var x482: u1 = undefined; + addcarryxU32(&x481, &x482, x480, x411, x457); + var x483: u32 = undefined; + var x484: u1 = undefined; + addcarryxU32(&x483, &x484, x482, x413, x459); + var x485: u32 = undefined; + var x486: u1 = undefined; + addcarryxU32(&x485, &x486, x484, x415, x461); + var x487: u32 = undefined; + var x488: u1 = undefined; + addcarryxU32(&x487, &x488, x486, x417, x463); + var x489: u32 = undefined; + var x490: u1 = undefined; + addcarryxU32(&x489, &x490, x488, x419, x465); + var x491: u32 = undefined; + var x492: u32 = undefined; + mulxU32(&x491, &x492, x467, 0xe88fdc45); + var x493: u32 = undefined; + var x494: u32 = undefined; + mulxU32(&x493, &x494, x491, 0xffffffff); + var x495: u32 = undefined; + var x496: u32 = undefined; + mulxU32(&x495, &x496, x491, 0xffffffff); + var x497: u32 = undefined; + var x498: u32 = undefined; + mulxU32(&x497, &x498, x491, 0xffffffff); + var x499: u32 = undefined; + var x500: u32 = undefined; + mulxU32(&x499, &x500, x491, 0xffffffff); + var x501: u32 = undefined; + var x502: u32 = undefined; + mulxU32(&x501, &x502, x491, 0xffffffff); + var x503: u32 = undefined; + var x504: u32 = undefined; + mulxU32(&x503, &x504, x491, 0xffffffff); + var x505: u32 = undefined; + var x506: u32 = undefined; + mulxU32(&x505, &x506, x491, 0xc7634d81); + var x507: u32 = undefined; + var x508: u32 = undefined; + mulxU32(&x507, &x508, x491, 0xf4372ddf); + var x509: u32 = undefined; + var x510: u32 = undefined; + mulxU32(&x509, &x510, x491, 0x581a0db2); + var x511: u32 = undefined; + var x512: u32 = undefined; + mulxU32(&x511, &x512, x491, 0x48b0a77a); + var x513: u32 = undefined; + var x514: u32 = undefined; + mulxU32(&x513, &x514, x491, 0xecec196a); + var x515: u32 = undefined; + var x516: u32 = undefined; + mulxU32(&x515, &x516, x491, 0xccc52973); + var x517: u32 = undefined; + var x518: u1 = undefined; + addcarryxU32(&x517, &x518, 0x0, x516, x513); + var x519: u32 = undefined; + var x520: u1 = undefined; + addcarryxU32(&x519, &x520, x518, x514, x511); + var x521: u32 = undefined; + var x522: u1 = undefined; + addcarryxU32(&x521, &x522, x520, x512, x509); + var x523: u32 = undefined; + var x524: u1 = undefined; + addcarryxU32(&x523, &x524, x522, x510, x507); + var x525: u32 = undefined; + var x526: u1 = undefined; + addcarryxU32(&x525, &x526, x524, x508, x505); + var x527: u32 = undefined; + var x528: u1 = undefined; + addcarryxU32(&x527, &x528, x526, x506, x503); + var x529: u32 = undefined; + var x530: u1 = undefined; + addcarryxU32(&x529, &x530, x528, x504, x501); + var x531: u32 = undefined; + var x532: u1 = undefined; + addcarryxU32(&x531, &x532, x530, x502, x499); + var x533: u32 = undefined; + var x534: u1 = undefined; + addcarryxU32(&x533, &x534, x532, x500, x497); + var x535: u32 = undefined; + var x536: u1 = undefined; + addcarryxU32(&x535, &x536, x534, x498, x495); + var x537: u32 = undefined; + var x538: u1 = undefined; + addcarryxU32(&x537, &x538, x536, x496, x493); + var x539: u32 = undefined; + var x540: u1 = undefined; + addcarryxU32(&x539, &x540, 0x0, x467, x515); + var x541: u32 = undefined; + var x542: u1 = undefined; + addcarryxU32(&x541, &x542, x540, x469, x517); + var x543: u32 = undefined; + var x544: u1 = undefined; + addcarryxU32(&x543, &x544, x542, x471, x519); + var x545: u32 = undefined; + var x546: u1 = undefined; + addcarryxU32(&x545, &x546, x544, x473, x521); + var x547: u32 = undefined; + var x548: u1 = undefined; + addcarryxU32(&x547, &x548, x546, x475, x523); + var x549: u32 = undefined; + var x550: u1 = undefined; + addcarryxU32(&x549, &x550, x548, x477, x525); + var x551: u32 = undefined; + var x552: u1 = undefined; + addcarryxU32(&x551, &x552, x550, x479, x527); + var x553: u32 = undefined; + var x554: u1 = undefined; + addcarryxU32(&x553, &x554, x552, x481, x529); + var x555: u32 = undefined; + var x556: u1 = undefined; + addcarryxU32(&x555, &x556, x554, x483, x531); + var x557: u32 = undefined; + var x558: u1 = undefined; + addcarryxU32(&x557, &x558, x556, x485, x533); + var x559: u32 = undefined; + var x560: u1 = undefined; + addcarryxU32(&x559, &x560, x558, x487, x535); + var x561: u32 = undefined; + var x562: u1 = undefined; + addcarryxU32(&x561, &x562, x560, x489, x537); + var x563: u32 = undefined; + var x564: u1 = undefined; + addcarryxU32(&x563, &x564, x562, ((cast(u32, x490) + cast(u32, x420)) + (cast(u32, x466) + x422)), (cast(u32, x538) + x494)); + var x565: u32 = undefined; + var x566: u32 = undefined; + mulxU32(&x565, &x566, x4, 0xc84ee01); + var x567: u32 = undefined; + var x568: u32 = undefined; + mulxU32(&x567, &x568, x4, 0x2b39bf21); + var x569: u32 = undefined; + var x570: u32 = undefined; + mulxU32(&x569, &x570, x4, 0x3fb05b7a); + var x571: u32 = undefined; + var x572: u32 = undefined; + mulxU32(&x571, &x572, x4, 0x28266895); + var x573: u32 = undefined; + var x574: u32 = undefined; + mulxU32(&x573, &x574, x4, 0xd40d4917); + var x575: u32 = undefined; + var x576: u32 = undefined; + mulxU32(&x575, &x576, x4, 0x4aab1cc5); + var x577: u32 = undefined; + var x578: u32 = undefined; + mulxU32(&x577, &x578, x4, 0xbc3e483a); + var x579: u32 = undefined; + var x580: u32 = undefined; + mulxU32(&x579, &x580, x4, 0xfcb82947); + var x581: u32 = undefined; + var x582: u32 = undefined; + mulxU32(&x581, &x582, x4, 0xff3d81e5); + var x583: u32 = undefined; + var x584: u32 = undefined; + mulxU32(&x583, &x584, x4, 0xdf1aa419); + var x585: u32 = undefined; + var x586: u32 = undefined; + mulxU32(&x585, &x586, x4, 0x2d319b24); + var x587: u32 = undefined; + var x588: u32 = undefined; + mulxU32(&x587, &x588, x4, 0x19b409a9); + var x589: u32 = undefined; + var x590: u1 = undefined; + addcarryxU32(&x589, &x590, 0x0, x588, x585); + var x591: u32 = undefined; + var x592: u1 = undefined; + addcarryxU32(&x591, &x592, x590, x586, x583); + var x593: u32 = undefined; + var x594: u1 = undefined; + addcarryxU32(&x593, &x594, x592, x584, x581); + var x595: u32 = undefined; + var x596: u1 = undefined; + addcarryxU32(&x595, &x596, x594, x582, x579); + var x597: u32 = undefined; + var x598: u1 = undefined; + addcarryxU32(&x597, &x598, x596, x580, x577); + var x599: u32 = undefined; + var x600: u1 = undefined; + addcarryxU32(&x599, &x600, x598, x578, x575); + var x601: u32 = undefined; + var x602: u1 = undefined; + addcarryxU32(&x601, &x602, x600, x576, x573); + var x603: u32 = undefined; + var x604: u1 = undefined; + addcarryxU32(&x603, &x604, x602, x574, x571); + var x605: u32 = undefined; + var x606: u1 = undefined; + addcarryxU32(&x605, &x606, x604, x572, x569); + var x607: u32 = undefined; + var x608: u1 = undefined; + addcarryxU32(&x607, &x608, x606, x570, x567); + var x609: u32 = undefined; + var x610: u1 = undefined; + addcarryxU32(&x609, &x610, x608, x568, x565); + var x611: u32 = undefined; + var x612: u1 = undefined; + addcarryxU32(&x611, &x612, 0x0, x541, x587); + var x613: u32 = undefined; + var x614: u1 = undefined; + addcarryxU32(&x613, &x614, x612, x543, x589); + var x615: u32 = undefined; + var x616: u1 = undefined; + addcarryxU32(&x615, &x616, x614, x545, x591); + var x617: u32 = undefined; + var x618: u1 = undefined; + addcarryxU32(&x617, &x618, x616, x547, x593); + var x619: u32 = undefined; + var x620: u1 = undefined; + addcarryxU32(&x619, &x620, x618, x549, x595); + var x621: u32 = undefined; + var x622: u1 = undefined; + addcarryxU32(&x621, &x622, x620, x551, x597); + var x623: u32 = undefined; + var x624: u1 = undefined; + addcarryxU32(&x623, &x624, x622, x553, x599); + var x625: u32 = undefined; + var x626: u1 = undefined; + addcarryxU32(&x625, &x626, x624, x555, x601); + var x627: u32 = undefined; + var x628: u1 = undefined; + addcarryxU32(&x627, &x628, x626, x557, x603); + var x629: u32 = undefined; + var x630: u1 = undefined; + addcarryxU32(&x629, &x630, x628, x559, x605); + var x631: u32 = undefined; + var x632: u1 = undefined; + addcarryxU32(&x631, &x632, x630, x561, x607); + var x633: u32 = undefined; + var x634: u1 = undefined; + addcarryxU32(&x633, &x634, x632, x563, x609); + var x635: u32 = undefined; + var x636: u32 = undefined; + mulxU32(&x635, &x636, x611, 0xe88fdc45); + var x637: u32 = undefined; + var x638: u32 = undefined; + mulxU32(&x637, &x638, x635, 0xffffffff); + var x639: u32 = undefined; + var x640: u32 = undefined; + mulxU32(&x639, &x640, x635, 0xffffffff); + var x641: u32 = undefined; + var x642: u32 = undefined; + mulxU32(&x641, &x642, x635, 0xffffffff); + var x643: u32 = undefined; + var x644: u32 = undefined; + mulxU32(&x643, &x644, x635, 0xffffffff); + var x645: u32 = undefined; + var x646: u32 = undefined; + mulxU32(&x645, &x646, x635, 0xffffffff); + var x647: u32 = undefined; + var x648: u32 = undefined; + mulxU32(&x647, &x648, x635, 0xffffffff); + var x649: u32 = undefined; + var x650: u32 = undefined; + mulxU32(&x649, &x650, x635, 0xc7634d81); + var x651: u32 = undefined; + var x652: u32 = undefined; + mulxU32(&x651, &x652, x635, 0xf4372ddf); + var x653: u32 = undefined; + var x654: u32 = undefined; + mulxU32(&x653, &x654, x635, 0x581a0db2); + var x655: u32 = undefined; + var x656: u32 = undefined; + mulxU32(&x655, &x656, x635, 0x48b0a77a); + var x657: u32 = undefined; + var x658: u32 = undefined; + mulxU32(&x657, &x658, x635, 0xecec196a); + var x659: u32 = undefined; + var x660: u32 = undefined; + mulxU32(&x659, &x660, x635, 0xccc52973); + var x661: u32 = undefined; + var x662: u1 = undefined; + addcarryxU32(&x661, &x662, 0x0, x660, x657); + var x663: u32 = undefined; + var x664: u1 = undefined; + addcarryxU32(&x663, &x664, x662, x658, x655); + var x665: u32 = undefined; + var x666: u1 = undefined; + addcarryxU32(&x665, &x666, x664, x656, x653); + var x667: u32 = undefined; + var x668: u1 = undefined; + addcarryxU32(&x667, &x668, x666, x654, x651); + var x669: u32 = undefined; + var x670: u1 = undefined; + addcarryxU32(&x669, &x670, x668, x652, x649); + var x671: u32 = undefined; + var x672: u1 = undefined; + addcarryxU32(&x671, &x672, x670, x650, x647); + var x673: u32 = undefined; + var x674: u1 = undefined; + addcarryxU32(&x673, &x674, x672, x648, x645); + var x675: u32 = undefined; + var x676: u1 = undefined; + addcarryxU32(&x675, &x676, x674, x646, x643); + var x677: u32 = undefined; + var x678: u1 = undefined; + addcarryxU32(&x677, &x678, x676, x644, x641); + var x679: u32 = undefined; + var x680: u1 = undefined; + addcarryxU32(&x679, &x680, x678, x642, x639); + var x681: u32 = undefined; + var x682: u1 = undefined; + addcarryxU32(&x681, &x682, x680, x640, x637); + var x683: u32 = undefined; + var x684: u1 = undefined; + addcarryxU32(&x683, &x684, 0x0, x611, x659); + var x685: u32 = undefined; + var x686: u1 = undefined; + addcarryxU32(&x685, &x686, x684, x613, x661); + var x687: u32 = undefined; + var x688: u1 = undefined; + addcarryxU32(&x687, &x688, x686, x615, x663); + var x689: u32 = undefined; + var x690: u1 = undefined; + addcarryxU32(&x689, &x690, x688, x617, x665); + var x691: u32 = undefined; + var x692: u1 = undefined; + addcarryxU32(&x691, &x692, x690, x619, x667); + var x693: u32 = undefined; + var x694: u1 = undefined; + addcarryxU32(&x693, &x694, x692, x621, x669); + var x695: u32 = undefined; + var x696: u1 = undefined; + addcarryxU32(&x695, &x696, x694, x623, x671); + var x697: u32 = undefined; + var x698: u1 = undefined; + addcarryxU32(&x697, &x698, x696, x625, x673); + var x699: u32 = undefined; + var x700: u1 = undefined; + addcarryxU32(&x699, &x700, x698, x627, x675); + var x701: u32 = undefined; + var x702: u1 = undefined; + addcarryxU32(&x701, &x702, x700, x629, x677); + var x703: u32 = undefined; + var x704: u1 = undefined; + addcarryxU32(&x703, &x704, x702, x631, x679); + var x705: u32 = undefined; + var x706: u1 = undefined; + addcarryxU32(&x705, &x706, x704, x633, x681); + var x707: u32 = undefined; + var x708: u1 = undefined; + addcarryxU32(&x707, &x708, x706, ((cast(u32, x634) + cast(u32, x564)) + (cast(u32, x610) + x566)), (cast(u32, x682) + x638)); + var x709: u32 = undefined; + var x710: u32 = undefined; + mulxU32(&x709, &x710, x5, 0xc84ee01); + var x711: u32 = undefined; + var x712: u32 = undefined; + mulxU32(&x711, &x712, x5, 0x2b39bf21); + var x713: u32 = undefined; + var x714: u32 = undefined; + mulxU32(&x713, &x714, x5, 0x3fb05b7a); + var x715: u32 = undefined; + var x716: u32 = undefined; + mulxU32(&x715, &x716, x5, 0x28266895); + var x717: u32 = undefined; + var x718: u32 = undefined; + mulxU32(&x717, &x718, x5, 0xd40d4917); + var x719: u32 = undefined; + var x720: u32 = undefined; + mulxU32(&x719, &x720, x5, 0x4aab1cc5); + var x721: u32 = undefined; + var x722: u32 = undefined; + mulxU32(&x721, &x722, x5, 0xbc3e483a); + var x723: u32 = undefined; + var x724: u32 = undefined; + mulxU32(&x723, &x724, x5, 0xfcb82947); + var x725: u32 = undefined; + var x726: u32 = undefined; + mulxU32(&x725, &x726, x5, 0xff3d81e5); + var x727: u32 = undefined; + var x728: u32 = undefined; + mulxU32(&x727, &x728, x5, 0xdf1aa419); + var x729: u32 = undefined; + var x730: u32 = undefined; + mulxU32(&x729, &x730, x5, 0x2d319b24); + var x731: u32 = undefined; + var x732: u32 = undefined; + mulxU32(&x731, &x732, x5, 0x19b409a9); + var x733: u32 = undefined; + var x734: u1 = undefined; + addcarryxU32(&x733, &x734, 0x0, x732, x729); + var x735: u32 = undefined; + var x736: u1 = undefined; + addcarryxU32(&x735, &x736, x734, x730, x727); + var x737: u32 = undefined; + var x738: u1 = undefined; + addcarryxU32(&x737, &x738, x736, x728, x725); + var x739: u32 = undefined; + var x740: u1 = undefined; + addcarryxU32(&x739, &x740, x738, x726, x723); + var x741: u32 = undefined; + var x742: u1 = undefined; + addcarryxU32(&x741, &x742, x740, x724, x721); + var x743: u32 = undefined; + var x744: u1 = undefined; + addcarryxU32(&x743, &x744, x742, x722, x719); + var x745: u32 = undefined; + var x746: u1 = undefined; + addcarryxU32(&x745, &x746, x744, x720, x717); + var x747: u32 = undefined; + var x748: u1 = undefined; + addcarryxU32(&x747, &x748, x746, x718, x715); + var x749: u32 = undefined; + var x750: u1 = undefined; + addcarryxU32(&x749, &x750, x748, x716, x713); + var x751: u32 = undefined; + var x752: u1 = undefined; + addcarryxU32(&x751, &x752, x750, x714, x711); + var x753: u32 = undefined; + var x754: u1 = undefined; + addcarryxU32(&x753, &x754, x752, x712, x709); + var x755: u32 = undefined; + var x756: u1 = undefined; + addcarryxU32(&x755, &x756, 0x0, x685, x731); + var x757: u32 = undefined; + var x758: u1 = undefined; + addcarryxU32(&x757, &x758, x756, x687, x733); + var x759: u32 = undefined; + var x760: u1 = undefined; + addcarryxU32(&x759, &x760, x758, x689, x735); + var x761: u32 = undefined; + var x762: u1 = undefined; + addcarryxU32(&x761, &x762, x760, x691, x737); + var x763: u32 = undefined; + var x764: u1 = undefined; + addcarryxU32(&x763, &x764, x762, x693, x739); + var x765: u32 = undefined; + var x766: u1 = undefined; + addcarryxU32(&x765, &x766, x764, x695, x741); + var x767: u32 = undefined; + var x768: u1 = undefined; + addcarryxU32(&x767, &x768, x766, x697, x743); + var x769: u32 = undefined; + var x770: u1 = undefined; + addcarryxU32(&x769, &x770, x768, x699, x745); + var x771: u32 = undefined; + var x772: u1 = undefined; + addcarryxU32(&x771, &x772, x770, x701, x747); + var x773: u32 = undefined; + var x774: u1 = undefined; + addcarryxU32(&x773, &x774, x772, x703, x749); + var x775: u32 = undefined; + var x776: u1 = undefined; + addcarryxU32(&x775, &x776, x774, x705, x751); + var x777: u32 = undefined; + var x778: u1 = undefined; + addcarryxU32(&x777, &x778, x776, x707, x753); + var x779: u32 = undefined; + var x780: u32 = undefined; + mulxU32(&x779, &x780, x755, 0xe88fdc45); + var x781: u32 = undefined; + var x782: u32 = undefined; + mulxU32(&x781, &x782, x779, 0xffffffff); + var x783: u32 = undefined; + var x784: u32 = undefined; + mulxU32(&x783, &x784, x779, 0xffffffff); + var x785: u32 = undefined; + var x786: u32 = undefined; + mulxU32(&x785, &x786, x779, 0xffffffff); + var x787: u32 = undefined; + var x788: u32 = undefined; + mulxU32(&x787, &x788, x779, 0xffffffff); + var x789: u32 = undefined; + var x790: u32 = undefined; + mulxU32(&x789, &x790, x779, 0xffffffff); + var x791: u32 = undefined; + var x792: u32 = undefined; + mulxU32(&x791, &x792, x779, 0xffffffff); + var x793: u32 = undefined; + var x794: u32 = undefined; + mulxU32(&x793, &x794, x779, 0xc7634d81); + var x795: u32 = undefined; + var x796: u32 = undefined; + mulxU32(&x795, &x796, x779, 0xf4372ddf); + var x797: u32 = undefined; + var x798: u32 = undefined; + mulxU32(&x797, &x798, x779, 0x581a0db2); + var x799: u32 = undefined; + var x800: u32 = undefined; + mulxU32(&x799, &x800, x779, 0x48b0a77a); + var x801: u32 = undefined; + var x802: u32 = undefined; + mulxU32(&x801, &x802, x779, 0xecec196a); + var x803: u32 = undefined; + var x804: u32 = undefined; + mulxU32(&x803, &x804, x779, 0xccc52973); + var x805: u32 = undefined; + var x806: u1 = undefined; + addcarryxU32(&x805, &x806, 0x0, x804, x801); + var x807: u32 = undefined; + var x808: u1 = undefined; + addcarryxU32(&x807, &x808, x806, x802, x799); + var x809: u32 = undefined; + var x810: u1 = undefined; + addcarryxU32(&x809, &x810, x808, x800, x797); + var x811: u32 = undefined; + var x812: u1 = undefined; + addcarryxU32(&x811, &x812, x810, x798, x795); + var x813: u32 = undefined; + var x814: u1 = undefined; + addcarryxU32(&x813, &x814, x812, x796, x793); + var x815: u32 = undefined; + var x816: u1 = undefined; + addcarryxU32(&x815, &x816, x814, x794, x791); + var x817: u32 = undefined; + var x818: u1 = undefined; + addcarryxU32(&x817, &x818, x816, x792, x789); + var x819: u32 = undefined; + var x820: u1 = undefined; + addcarryxU32(&x819, &x820, x818, x790, x787); + var x821: u32 = undefined; + var x822: u1 = undefined; + addcarryxU32(&x821, &x822, x820, x788, x785); + var x823: u32 = undefined; + var x824: u1 = undefined; + addcarryxU32(&x823, &x824, x822, x786, x783); + var x825: u32 = undefined; + var x826: u1 = undefined; + addcarryxU32(&x825, &x826, x824, x784, x781); + var x827: u32 = undefined; + var x828: u1 = undefined; + addcarryxU32(&x827, &x828, 0x0, x755, x803); + var x829: u32 = undefined; + var x830: u1 = undefined; + addcarryxU32(&x829, &x830, x828, x757, x805); + var x831: u32 = undefined; + var x832: u1 = undefined; + addcarryxU32(&x831, &x832, x830, x759, x807); + var x833: u32 = undefined; + var x834: u1 = undefined; + addcarryxU32(&x833, &x834, x832, x761, x809); + var x835: u32 = undefined; + var x836: u1 = undefined; + addcarryxU32(&x835, &x836, x834, x763, x811); + var x837: u32 = undefined; + var x838: u1 = undefined; + addcarryxU32(&x837, &x838, x836, x765, x813); + var x839: u32 = undefined; + var x840: u1 = undefined; + addcarryxU32(&x839, &x840, x838, x767, x815); + var x841: u32 = undefined; + var x842: u1 = undefined; + addcarryxU32(&x841, &x842, x840, x769, x817); + var x843: u32 = undefined; + var x844: u1 = undefined; + addcarryxU32(&x843, &x844, x842, x771, x819); + var x845: u32 = undefined; + var x846: u1 = undefined; + addcarryxU32(&x845, &x846, x844, x773, x821); + var x847: u32 = undefined; + var x848: u1 = undefined; + addcarryxU32(&x847, &x848, x846, x775, x823); + var x849: u32 = undefined; + var x850: u1 = undefined; + addcarryxU32(&x849, &x850, x848, x777, x825); + var x851: u32 = undefined; + var x852: u1 = undefined; + addcarryxU32(&x851, &x852, x850, ((cast(u32, x778) + cast(u32, x708)) + (cast(u32, x754) + x710)), (cast(u32, x826) + x782)); + var x853: u32 = undefined; + var x854: u32 = undefined; + mulxU32(&x853, &x854, x6, 0xc84ee01); + var x855: u32 = undefined; + var x856: u32 = undefined; + mulxU32(&x855, &x856, x6, 0x2b39bf21); + var x857: u32 = undefined; + var x858: u32 = undefined; + mulxU32(&x857, &x858, x6, 0x3fb05b7a); + var x859: u32 = undefined; + var x860: u32 = undefined; + mulxU32(&x859, &x860, x6, 0x28266895); + var x861: u32 = undefined; + var x862: u32 = undefined; + mulxU32(&x861, &x862, x6, 0xd40d4917); + var x863: u32 = undefined; + var x864: u32 = undefined; + mulxU32(&x863, &x864, x6, 0x4aab1cc5); + var x865: u32 = undefined; + var x866: u32 = undefined; + mulxU32(&x865, &x866, x6, 0xbc3e483a); + var x867: u32 = undefined; + var x868: u32 = undefined; + mulxU32(&x867, &x868, x6, 0xfcb82947); + var x869: u32 = undefined; + var x870: u32 = undefined; + mulxU32(&x869, &x870, x6, 0xff3d81e5); + var x871: u32 = undefined; + var x872: u32 = undefined; + mulxU32(&x871, &x872, x6, 0xdf1aa419); + var x873: u32 = undefined; + var x874: u32 = undefined; + mulxU32(&x873, &x874, x6, 0x2d319b24); + var x875: u32 = undefined; + var x876: u32 = undefined; + mulxU32(&x875, &x876, x6, 0x19b409a9); + var x877: u32 = undefined; + var x878: u1 = undefined; + addcarryxU32(&x877, &x878, 0x0, x876, x873); + var x879: u32 = undefined; + var x880: u1 = undefined; + addcarryxU32(&x879, &x880, x878, x874, x871); + var x881: u32 = undefined; + var x882: u1 = undefined; + addcarryxU32(&x881, &x882, x880, x872, x869); + var x883: u32 = undefined; + var x884: u1 = undefined; + addcarryxU32(&x883, &x884, x882, x870, x867); + var x885: u32 = undefined; + var x886: u1 = undefined; + addcarryxU32(&x885, &x886, x884, x868, x865); + var x887: u32 = undefined; + var x888: u1 = undefined; + addcarryxU32(&x887, &x888, x886, x866, x863); + var x889: u32 = undefined; + var x890: u1 = undefined; + addcarryxU32(&x889, &x890, x888, x864, x861); + var x891: u32 = undefined; + var x892: u1 = undefined; + addcarryxU32(&x891, &x892, x890, x862, x859); + var x893: u32 = undefined; + var x894: u1 = undefined; + addcarryxU32(&x893, &x894, x892, x860, x857); + var x895: u32 = undefined; + var x896: u1 = undefined; + addcarryxU32(&x895, &x896, x894, x858, x855); + var x897: u32 = undefined; + var x898: u1 = undefined; + addcarryxU32(&x897, &x898, x896, x856, x853); + var x899: u32 = undefined; + var x900: u1 = undefined; + addcarryxU32(&x899, &x900, 0x0, x829, x875); + var x901: u32 = undefined; + var x902: u1 = undefined; + addcarryxU32(&x901, &x902, x900, x831, x877); + var x903: u32 = undefined; + var x904: u1 = undefined; + addcarryxU32(&x903, &x904, x902, x833, x879); + var x905: u32 = undefined; + var x906: u1 = undefined; + addcarryxU32(&x905, &x906, x904, x835, x881); + var x907: u32 = undefined; + var x908: u1 = undefined; + addcarryxU32(&x907, &x908, x906, x837, x883); + var x909: u32 = undefined; + var x910: u1 = undefined; + addcarryxU32(&x909, &x910, x908, x839, x885); + var x911: u32 = undefined; + var x912: u1 = undefined; + addcarryxU32(&x911, &x912, x910, x841, x887); + var x913: u32 = undefined; + var x914: u1 = undefined; + addcarryxU32(&x913, &x914, x912, x843, x889); + var x915: u32 = undefined; + var x916: u1 = undefined; + addcarryxU32(&x915, &x916, x914, x845, x891); + var x917: u32 = undefined; + var x918: u1 = undefined; + addcarryxU32(&x917, &x918, x916, x847, x893); + var x919: u32 = undefined; + var x920: u1 = undefined; + addcarryxU32(&x919, &x920, x918, x849, x895); + var x921: u32 = undefined; + var x922: u1 = undefined; + addcarryxU32(&x921, &x922, x920, x851, x897); + var x923: u32 = undefined; + var x924: u32 = undefined; + mulxU32(&x923, &x924, x899, 0xe88fdc45); + var x925: u32 = undefined; + var x926: u32 = undefined; + mulxU32(&x925, &x926, x923, 0xffffffff); + var x927: u32 = undefined; + var x928: u32 = undefined; + mulxU32(&x927, &x928, x923, 0xffffffff); + var x929: u32 = undefined; + var x930: u32 = undefined; + mulxU32(&x929, &x930, x923, 0xffffffff); + var x931: u32 = undefined; + var x932: u32 = undefined; + mulxU32(&x931, &x932, x923, 0xffffffff); + var x933: u32 = undefined; + var x934: u32 = undefined; + mulxU32(&x933, &x934, x923, 0xffffffff); + var x935: u32 = undefined; + var x936: u32 = undefined; + mulxU32(&x935, &x936, x923, 0xffffffff); + var x937: u32 = undefined; + var x938: u32 = undefined; + mulxU32(&x937, &x938, x923, 0xc7634d81); + var x939: u32 = undefined; + var x940: u32 = undefined; + mulxU32(&x939, &x940, x923, 0xf4372ddf); + var x941: u32 = undefined; + var x942: u32 = undefined; + mulxU32(&x941, &x942, x923, 0x581a0db2); + var x943: u32 = undefined; + var x944: u32 = undefined; + mulxU32(&x943, &x944, x923, 0x48b0a77a); + var x945: u32 = undefined; + var x946: u32 = undefined; + mulxU32(&x945, &x946, x923, 0xecec196a); + var x947: u32 = undefined; + var x948: u32 = undefined; + mulxU32(&x947, &x948, x923, 0xccc52973); + var x949: u32 = undefined; + var x950: u1 = undefined; + addcarryxU32(&x949, &x950, 0x0, x948, x945); + var x951: u32 = undefined; + var x952: u1 = undefined; + addcarryxU32(&x951, &x952, x950, x946, x943); + var x953: u32 = undefined; + var x954: u1 = undefined; + addcarryxU32(&x953, &x954, x952, x944, x941); + var x955: u32 = undefined; + var x956: u1 = undefined; + addcarryxU32(&x955, &x956, x954, x942, x939); + var x957: u32 = undefined; + var x958: u1 = undefined; + addcarryxU32(&x957, &x958, x956, x940, x937); + var x959: u32 = undefined; + var x960: u1 = undefined; + addcarryxU32(&x959, &x960, x958, x938, x935); + var x961: u32 = undefined; + var x962: u1 = undefined; + addcarryxU32(&x961, &x962, x960, x936, x933); + var x963: u32 = undefined; + var x964: u1 = undefined; + addcarryxU32(&x963, &x964, x962, x934, x931); + var x965: u32 = undefined; + var x966: u1 = undefined; + addcarryxU32(&x965, &x966, x964, x932, x929); + var x967: u32 = undefined; + var x968: u1 = undefined; + addcarryxU32(&x967, &x968, x966, x930, x927); + var x969: u32 = undefined; + var x970: u1 = undefined; + addcarryxU32(&x969, &x970, x968, x928, x925); + var x971: u32 = undefined; + var x972: u1 = undefined; + addcarryxU32(&x971, &x972, 0x0, x899, x947); + var x973: u32 = undefined; + var x974: u1 = undefined; + addcarryxU32(&x973, &x974, x972, x901, x949); + var x975: u32 = undefined; + var x976: u1 = undefined; + addcarryxU32(&x975, &x976, x974, x903, x951); + var x977: u32 = undefined; + var x978: u1 = undefined; + addcarryxU32(&x977, &x978, x976, x905, x953); + var x979: u32 = undefined; + var x980: u1 = undefined; + addcarryxU32(&x979, &x980, x978, x907, x955); + var x981: u32 = undefined; + var x982: u1 = undefined; + addcarryxU32(&x981, &x982, x980, x909, x957); + var x983: u32 = undefined; + var x984: u1 = undefined; + addcarryxU32(&x983, &x984, x982, x911, x959); + var x985: u32 = undefined; + var x986: u1 = undefined; + addcarryxU32(&x985, &x986, x984, x913, x961); + var x987: u32 = undefined; + var x988: u1 = undefined; + addcarryxU32(&x987, &x988, x986, x915, x963); + var x989: u32 = undefined; + var x990: u1 = undefined; + addcarryxU32(&x989, &x990, x988, x917, x965); + var x991: u32 = undefined; + var x992: u1 = undefined; + addcarryxU32(&x991, &x992, x990, x919, x967); + var x993: u32 = undefined; + var x994: u1 = undefined; + addcarryxU32(&x993, &x994, x992, x921, x969); + var x995: u32 = undefined; + var x996: u1 = undefined; + addcarryxU32(&x995, &x996, x994, ((cast(u32, x922) + cast(u32, x852)) + (cast(u32, x898) + x854)), (cast(u32, x970) + x926)); + var x997: u32 = undefined; + var x998: u32 = undefined; + mulxU32(&x997, &x998, x7, 0xc84ee01); + var x999: u32 = undefined; + var x1000: u32 = undefined; + mulxU32(&x999, &x1000, x7, 0x2b39bf21); + var x1001: u32 = undefined; + var x1002: u32 = undefined; + mulxU32(&x1001, &x1002, x7, 0x3fb05b7a); + var x1003: u32 = undefined; + var x1004: u32 = undefined; + mulxU32(&x1003, &x1004, x7, 0x28266895); + var x1005: u32 = undefined; + var x1006: u32 = undefined; + mulxU32(&x1005, &x1006, x7, 0xd40d4917); + var x1007: u32 = undefined; + var x1008: u32 = undefined; + mulxU32(&x1007, &x1008, x7, 0x4aab1cc5); + var x1009: u32 = undefined; + var x1010: u32 = undefined; + mulxU32(&x1009, &x1010, x7, 0xbc3e483a); + var x1011: u32 = undefined; + var x1012: u32 = undefined; + mulxU32(&x1011, &x1012, x7, 0xfcb82947); + var x1013: u32 = undefined; + var x1014: u32 = undefined; + mulxU32(&x1013, &x1014, x7, 0xff3d81e5); + var x1015: u32 = undefined; + var x1016: u32 = undefined; + mulxU32(&x1015, &x1016, x7, 0xdf1aa419); + var x1017: u32 = undefined; + var x1018: u32 = undefined; + mulxU32(&x1017, &x1018, x7, 0x2d319b24); + var x1019: u32 = undefined; + var x1020: u32 = undefined; + mulxU32(&x1019, &x1020, x7, 0x19b409a9); + var x1021: u32 = undefined; + var x1022: u1 = undefined; + addcarryxU32(&x1021, &x1022, 0x0, x1020, x1017); + var x1023: u32 = undefined; + var x1024: u1 = undefined; + addcarryxU32(&x1023, &x1024, x1022, x1018, x1015); + var x1025: u32 = undefined; + var x1026: u1 = undefined; + addcarryxU32(&x1025, &x1026, x1024, x1016, x1013); + var x1027: u32 = undefined; + var x1028: u1 = undefined; + addcarryxU32(&x1027, &x1028, x1026, x1014, x1011); + var x1029: u32 = undefined; + var x1030: u1 = undefined; + addcarryxU32(&x1029, &x1030, x1028, x1012, x1009); + var x1031: u32 = undefined; + var x1032: u1 = undefined; + addcarryxU32(&x1031, &x1032, x1030, x1010, x1007); + var x1033: u32 = undefined; + var x1034: u1 = undefined; + addcarryxU32(&x1033, &x1034, x1032, x1008, x1005); + var x1035: u32 = undefined; + var x1036: u1 = undefined; + addcarryxU32(&x1035, &x1036, x1034, x1006, x1003); + var x1037: u32 = undefined; + var x1038: u1 = undefined; + addcarryxU32(&x1037, &x1038, x1036, x1004, x1001); + var x1039: u32 = undefined; + var x1040: u1 = undefined; + addcarryxU32(&x1039, &x1040, x1038, x1002, x999); + var x1041: u32 = undefined; + var x1042: u1 = undefined; + addcarryxU32(&x1041, &x1042, x1040, x1000, x997); + var x1043: u32 = undefined; + var x1044: u1 = undefined; + addcarryxU32(&x1043, &x1044, 0x0, x973, x1019); + var x1045: u32 = undefined; + var x1046: u1 = undefined; + addcarryxU32(&x1045, &x1046, x1044, x975, x1021); + var x1047: u32 = undefined; + var x1048: u1 = undefined; + addcarryxU32(&x1047, &x1048, x1046, x977, x1023); + var x1049: u32 = undefined; + var x1050: u1 = undefined; + addcarryxU32(&x1049, &x1050, x1048, x979, x1025); + var x1051: u32 = undefined; + var x1052: u1 = undefined; + addcarryxU32(&x1051, &x1052, x1050, x981, x1027); + var x1053: u32 = undefined; + var x1054: u1 = undefined; + addcarryxU32(&x1053, &x1054, x1052, x983, x1029); + var x1055: u32 = undefined; + var x1056: u1 = undefined; + addcarryxU32(&x1055, &x1056, x1054, x985, x1031); + var x1057: u32 = undefined; + var x1058: u1 = undefined; + addcarryxU32(&x1057, &x1058, x1056, x987, x1033); + var x1059: u32 = undefined; + var x1060: u1 = undefined; + addcarryxU32(&x1059, &x1060, x1058, x989, x1035); + var x1061: u32 = undefined; + var x1062: u1 = undefined; + addcarryxU32(&x1061, &x1062, x1060, x991, x1037); + var x1063: u32 = undefined; + var x1064: u1 = undefined; + addcarryxU32(&x1063, &x1064, x1062, x993, x1039); + var x1065: u32 = undefined; + var x1066: u1 = undefined; + addcarryxU32(&x1065, &x1066, x1064, x995, x1041); + var x1067: u32 = undefined; + var x1068: u32 = undefined; + mulxU32(&x1067, &x1068, x1043, 0xe88fdc45); + var x1069: u32 = undefined; + var x1070: u32 = undefined; + mulxU32(&x1069, &x1070, x1067, 0xffffffff); + var x1071: u32 = undefined; + var x1072: u32 = undefined; + mulxU32(&x1071, &x1072, x1067, 0xffffffff); + var x1073: u32 = undefined; + var x1074: u32 = undefined; + mulxU32(&x1073, &x1074, x1067, 0xffffffff); + var x1075: u32 = undefined; + var x1076: u32 = undefined; + mulxU32(&x1075, &x1076, x1067, 0xffffffff); + var x1077: u32 = undefined; + var x1078: u32 = undefined; + mulxU32(&x1077, &x1078, x1067, 0xffffffff); + var x1079: u32 = undefined; + var x1080: u32 = undefined; + mulxU32(&x1079, &x1080, x1067, 0xffffffff); + var x1081: u32 = undefined; + var x1082: u32 = undefined; + mulxU32(&x1081, &x1082, x1067, 0xc7634d81); + var x1083: u32 = undefined; + var x1084: u32 = undefined; + mulxU32(&x1083, &x1084, x1067, 0xf4372ddf); + var x1085: u32 = undefined; + var x1086: u32 = undefined; + mulxU32(&x1085, &x1086, x1067, 0x581a0db2); + var x1087: u32 = undefined; + var x1088: u32 = undefined; + mulxU32(&x1087, &x1088, x1067, 0x48b0a77a); + var x1089: u32 = undefined; + var x1090: u32 = undefined; + mulxU32(&x1089, &x1090, x1067, 0xecec196a); + var x1091: u32 = undefined; + var x1092: u32 = undefined; + mulxU32(&x1091, &x1092, x1067, 0xccc52973); + var x1093: u32 = undefined; + var x1094: u1 = undefined; + addcarryxU32(&x1093, &x1094, 0x0, x1092, x1089); + var x1095: u32 = undefined; + var x1096: u1 = undefined; + addcarryxU32(&x1095, &x1096, x1094, x1090, x1087); + var x1097: u32 = undefined; + var x1098: u1 = undefined; + addcarryxU32(&x1097, &x1098, x1096, x1088, x1085); + var x1099: u32 = undefined; + var x1100: u1 = undefined; + addcarryxU32(&x1099, &x1100, x1098, x1086, x1083); + var x1101: u32 = undefined; + var x1102: u1 = undefined; + addcarryxU32(&x1101, &x1102, x1100, x1084, x1081); + var x1103: u32 = undefined; + var x1104: u1 = undefined; + addcarryxU32(&x1103, &x1104, x1102, x1082, x1079); + var x1105: u32 = undefined; + var x1106: u1 = undefined; + addcarryxU32(&x1105, &x1106, x1104, x1080, x1077); + var x1107: u32 = undefined; + var x1108: u1 = undefined; + addcarryxU32(&x1107, &x1108, x1106, x1078, x1075); + var x1109: u32 = undefined; + var x1110: u1 = undefined; + addcarryxU32(&x1109, &x1110, x1108, x1076, x1073); + var x1111: u32 = undefined; + var x1112: u1 = undefined; + addcarryxU32(&x1111, &x1112, x1110, x1074, x1071); + var x1113: u32 = undefined; + var x1114: u1 = undefined; + addcarryxU32(&x1113, &x1114, x1112, x1072, x1069); + var x1115: u32 = undefined; + var x1116: u1 = undefined; + addcarryxU32(&x1115, &x1116, 0x0, x1043, x1091); + var x1117: u32 = undefined; + var x1118: u1 = undefined; + addcarryxU32(&x1117, &x1118, x1116, x1045, x1093); + var x1119: u32 = undefined; + var x1120: u1 = undefined; + addcarryxU32(&x1119, &x1120, x1118, x1047, x1095); + var x1121: u32 = undefined; + var x1122: u1 = undefined; + addcarryxU32(&x1121, &x1122, x1120, x1049, x1097); + var x1123: u32 = undefined; + var x1124: u1 = undefined; + addcarryxU32(&x1123, &x1124, x1122, x1051, x1099); + var x1125: u32 = undefined; + var x1126: u1 = undefined; + addcarryxU32(&x1125, &x1126, x1124, x1053, x1101); + var x1127: u32 = undefined; + var x1128: u1 = undefined; + addcarryxU32(&x1127, &x1128, x1126, x1055, x1103); + var x1129: u32 = undefined; + var x1130: u1 = undefined; + addcarryxU32(&x1129, &x1130, x1128, x1057, x1105); + var x1131: u32 = undefined; + var x1132: u1 = undefined; + addcarryxU32(&x1131, &x1132, x1130, x1059, x1107); + var x1133: u32 = undefined; + var x1134: u1 = undefined; + addcarryxU32(&x1133, &x1134, x1132, x1061, x1109); + var x1135: u32 = undefined; + var x1136: u1 = undefined; + addcarryxU32(&x1135, &x1136, x1134, x1063, x1111); + var x1137: u32 = undefined; + var x1138: u1 = undefined; + addcarryxU32(&x1137, &x1138, x1136, x1065, x1113); + var x1139: u32 = undefined; + var x1140: u1 = undefined; + addcarryxU32(&x1139, &x1140, x1138, ((cast(u32, x1066) + cast(u32, x996)) + (cast(u32, x1042) + x998)), (cast(u32, x1114) + x1070)); + var x1141: u32 = undefined; + var x1142: u32 = undefined; + mulxU32(&x1141, &x1142, x8, 0xc84ee01); + var x1143: u32 = undefined; + var x1144: u32 = undefined; + mulxU32(&x1143, &x1144, x8, 0x2b39bf21); + var x1145: u32 = undefined; + var x1146: u32 = undefined; + mulxU32(&x1145, &x1146, x8, 0x3fb05b7a); + var x1147: u32 = undefined; + var x1148: u32 = undefined; + mulxU32(&x1147, &x1148, x8, 0x28266895); + var x1149: u32 = undefined; + var x1150: u32 = undefined; + mulxU32(&x1149, &x1150, x8, 0xd40d4917); + var x1151: u32 = undefined; + var x1152: u32 = undefined; + mulxU32(&x1151, &x1152, x8, 0x4aab1cc5); + var x1153: u32 = undefined; + var x1154: u32 = undefined; + mulxU32(&x1153, &x1154, x8, 0xbc3e483a); + var x1155: u32 = undefined; + var x1156: u32 = undefined; + mulxU32(&x1155, &x1156, x8, 0xfcb82947); + var x1157: u32 = undefined; + var x1158: u32 = undefined; + mulxU32(&x1157, &x1158, x8, 0xff3d81e5); + var x1159: u32 = undefined; + var x1160: u32 = undefined; + mulxU32(&x1159, &x1160, x8, 0xdf1aa419); + var x1161: u32 = undefined; + var x1162: u32 = undefined; + mulxU32(&x1161, &x1162, x8, 0x2d319b24); + var x1163: u32 = undefined; + var x1164: u32 = undefined; + mulxU32(&x1163, &x1164, x8, 0x19b409a9); + var x1165: u32 = undefined; + var x1166: u1 = undefined; + addcarryxU32(&x1165, &x1166, 0x0, x1164, x1161); + var x1167: u32 = undefined; + var x1168: u1 = undefined; + addcarryxU32(&x1167, &x1168, x1166, x1162, x1159); + var x1169: u32 = undefined; + var x1170: u1 = undefined; + addcarryxU32(&x1169, &x1170, x1168, x1160, x1157); + var x1171: u32 = undefined; + var x1172: u1 = undefined; + addcarryxU32(&x1171, &x1172, x1170, x1158, x1155); + var x1173: u32 = undefined; + var x1174: u1 = undefined; + addcarryxU32(&x1173, &x1174, x1172, x1156, x1153); + var x1175: u32 = undefined; + var x1176: u1 = undefined; + addcarryxU32(&x1175, &x1176, x1174, x1154, x1151); + var x1177: u32 = undefined; + var x1178: u1 = undefined; + addcarryxU32(&x1177, &x1178, x1176, x1152, x1149); + var x1179: u32 = undefined; + var x1180: u1 = undefined; + addcarryxU32(&x1179, &x1180, x1178, x1150, x1147); + var x1181: u32 = undefined; + var x1182: u1 = undefined; + addcarryxU32(&x1181, &x1182, x1180, x1148, x1145); + var x1183: u32 = undefined; + var x1184: u1 = undefined; + addcarryxU32(&x1183, &x1184, x1182, x1146, x1143); + var x1185: u32 = undefined; + var x1186: u1 = undefined; + addcarryxU32(&x1185, &x1186, x1184, x1144, x1141); + var x1187: u32 = undefined; + var x1188: u1 = undefined; + addcarryxU32(&x1187, &x1188, 0x0, x1117, x1163); + var x1189: u32 = undefined; + var x1190: u1 = undefined; + addcarryxU32(&x1189, &x1190, x1188, x1119, x1165); + var x1191: u32 = undefined; + var x1192: u1 = undefined; + addcarryxU32(&x1191, &x1192, x1190, x1121, x1167); + var x1193: u32 = undefined; + var x1194: u1 = undefined; + addcarryxU32(&x1193, &x1194, x1192, x1123, x1169); + var x1195: u32 = undefined; + var x1196: u1 = undefined; + addcarryxU32(&x1195, &x1196, x1194, x1125, x1171); + var x1197: u32 = undefined; + var x1198: u1 = undefined; + addcarryxU32(&x1197, &x1198, x1196, x1127, x1173); + var x1199: u32 = undefined; + var x1200: u1 = undefined; + addcarryxU32(&x1199, &x1200, x1198, x1129, x1175); + var x1201: u32 = undefined; + var x1202: u1 = undefined; + addcarryxU32(&x1201, &x1202, x1200, x1131, x1177); + var x1203: u32 = undefined; + var x1204: u1 = undefined; + addcarryxU32(&x1203, &x1204, x1202, x1133, x1179); + var x1205: u32 = undefined; + var x1206: u1 = undefined; + addcarryxU32(&x1205, &x1206, x1204, x1135, x1181); + var x1207: u32 = undefined; + var x1208: u1 = undefined; + addcarryxU32(&x1207, &x1208, x1206, x1137, x1183); + var x1209: u32 = undefined; + var x1210: u1 = undefined; + addcarryxU32(&x1209, &x1210, x1208, x1139, x1185); + var x1211: u32 = undefined; + var x1212: u32 = undefined; + mulxU32(&x1211, &x1212, x1187, 0xe88fdc45); + var x1213: u32 = undefined; + var x1214: u32 = undefined; + mulxU32(&x1213, &x1214, x1211, 0xffffffff); + var x1215: u32 = undefined; + var x1216: u32 = undefined; + mulxU32(&x1215, &x1216, x1211, 0xffffffff); + var x1217: u32 = undefined; + var x1218: u32 = undefined; + mulxU32(&x1217, &x1218, x1211, 0xffffffff); + var x1219: u32 = undefined; + var x1220: u32 = undefined; + mulxU32(&x1219, &x1220, x1211, 0xffffffff); + var x1221: u32 = undefined; + var x1222: u32 = undefined; + mulxU32(&x1221, &x1222, x1211, 0xffffffff); + var x1223: u32 = undefined; + var x1224: u32 = undefined; + mulxU32(&x1223, &x1224, x1211, 0xffffffff); + var x1225: u32 = undefined; + var x1226: u32 = undefined; + mulxU32(&x1225, &x1226, x1211, 0xc7634d81); + var x1227: u32 = undefined; + var x1228: u32 = undefined; + mulxU32(&x1227, &x1228, x1211, 0xf4372ddf); + var x1229: u32 = undefined; + var x1230: u32 = undefined; + mulxU32(&x1229, &x1230, x1211, 0x581a0db2); + var x1231: u32 = undefined; + var x1232: u32 = undefined; + mulxU32(&x1231, &x1232, x1211, 0x48b0a77a); + var x1233: u32 = undefined; + var x1234: u32 = undefined; + mulxU32(&x1233, &x1234, x1211, 0xecec196a); + var x1235: u32 = undefined; + var x1236: u32 = undefined; + mulxU32(&x1235, &x1236, x1211, 0xccc52973); + var x1237: u32 = undefined; + var x1238: u1 = undefined; + addcarryxU32(&x1237, &x1238, 0x0, x1236, x1233); + var x1239: u32 = undefined; + var x1240: u1 = undefined; + addcarryxU32(&x1239, &x1240, x1238, x1234, x1231); + var x1241: u32 = undefined; + var x1242: u1 = undefined; + addcarryxU32(&x1241, &x1242, x1240, x1232, x1229); + var x1243: u32 = undefined; + var x1244: u1 = undefined; + addcarryxU32(&x1243, &x1244, x1242, x1230, x1227); + var x1245: u32 = undefined; + var x1246: u1 = undefined; + addcarryxU32(&x1245, &x1246, x1244, x1228, x1225); + var x1247: u32 = undefined; + var x1248: u1 = undefined; + addcarryxU32(&x1247, &x1248, x1246, x1226, x1223); + var x1249: u32 = undefined; + var x1250: u1 = undefined; + addcarryxU32(&x1249, &x1250, x1248, x1224, x1221); + var x1251: u32 = undefined; + var x1252: u1 = undefined; + addcarryxU32(&x1251, &x1252, x1250, x1222, x1219); + var x1253: u32 = undefined; + var x1254: u1 = undefined; + addcarryxU32(&x1253, &x1254, x1252, x1220, x1217); + var x1255: u32 = undefined; + var x1256: u1 = undefined; + addcarryxU32(&x1255, &x1256, x1254, x1218, x1215); + var x1257: u32 = undefined; + var x1258: u1 = undefined; + addcarryxU32(&x1257, &x1258, x1256, x1216, x1213); + var x1259: u32 = undefined; + var x1260: u1 = undefined; + addcarryxU32(&x1259, &x1260, 0x0, x1187, x1235); + var x1261: u32 = undefined; + var x1262: u1 = undefined; + addcarryxU32(&x1261, &x1262, x1260, x1189, x1237); + var x1263: u32 = undefined; + var x1264: u1 = undefined; + addcarryxU32(&x1263, &x1264, x1262, x1191, x1239); + var x1265: u32 = undefined; + var x1266: u1 = undefined; + addcarryxU32(&x1265, &x1266, x1264, x1193, x1241); + var x1267: u32 = undefined; + var x1268: u1 = undefined; + addcarryxU32(&x1267, &x1268, x1266, x1195, x1243); + var x1269: u32 = undefined; + var x1270: u1 = undefined; + addcarryxU32(&x1269, &x1270, x1268, x1197, x1245); + var x1271: u32 = undefined; + var x1272: u1 = undefined; + addcarryxU32(&x1271, &x1272, x1270, x1199, x1247); + var x1273: u32 = undefined; + var x1274: u1 = undefined; + addcarryxU32(&x1273, &x1274, x1272, x1201, x1249); + var x1275: u32 = undefined; + var x1276: u1 = undefined; + addcarryxU32(&x1275, &x1276, x1274, x1203, x1251); + var x1277: u32 = undefined; + var x1278: u1 = undefined; + addcarryxU32(&x1277, &x1278, x1276, x1205, x1253); + var x1279: u32 = undefined; + var x1280: u1 = undefined; + addcarryxU32(&x1279, &x1280, x1278, x1207, x1255); + var x1281: u32 = undefined; + var x1282: u1 = undefined; + addcarryxU32(&x1281, &x1282, x1280, x1209, x1257); + var x1283: u32 = undefined; + var x1284: u1 = undefined; + addcarryxU32(&x1283, &x1284, x1282, ((cast(u32, x1210) + cast(u32, x1140)) + (cast(u32, x1186) + x1142)), (cast(u32, x1258) + x1214)); + var x1285: u32 = undefined; + var x1286: u32 = undefined; + mulxU32(&x1285, &x1286, x9, 0xc84ee01); + var x1287: u32 = undefined; + var x1288: u32 = undefined; + mulxU32(&x1287, &x1288, x9, 0x2b39bf21); + var x1289: u32 = undefined; + var x1290: u32 = undefined; + mulxU32(&x1289, &x1290, x9, 0x3fb05b7a); + var x1291: u32 = undefined; + var x1292: u32 = undefined; + mulxU32(&x1291, &x1292, x9, 0x28266895); + var x1293: u32 = undefined; + var x1294: u32 = undefined; + mulxU32(&x1293, &x1294, x9, 0xd40d4917); + var x1295: u32 = undefined; + var x1296: u32 = undefined; + mulxU32(&x1295, &x1296, x9, 0x4aab1cc5); + var x1297: u32 = undefined; + var x1298: u32 = undefined; + mulxU32(&x1297, &x1298, x9, 0xbc3e483a); + var x1299: u32 = undefined; + var x1300: u32 = undefined; + mulxU32(&x1299, &x1300, x9, 0xfcb82947); + var x1301: u32 = undefined; + var x1302: u32 = undefined; + mulxU32(&x1301, &x1302, x9, 0xff3d81e5); + var x1303: u32 = undefined; + var x1304: u32 = undefined; + mulxU32(&x1303, &x1304, x9, 0xdf1aa419); + var x1305: u32 = undefined; + var x1306: u32 = undefined; + mulxU32(&x1305, &x1306, x9, 0x2d319b24); + var x1307: u32 = undefined; + var x1308: u32 = undefined; + mulxU32(&x1307, &x1308, x9, 0x19b409a9); + var x1309: u32 = undefined; + var x1310: u1 = undefined; + addcarryxU32(&x1309, &x1310, 0x0, x1308, x1305); + var x1311: u32 = undefined; + var x1312: u1 = undefined; + addcarryxU32(&x1311, &x1312, x1310, x1306, x1303); + var x1313: u32 = undefined; + var x1314: u1 = undefined; + addcarryxU32(&x1313, &x1314, x1312, x1304, x1301); + var x1315: u32 = undefined; + var x1316: u1 = undefined; + addcarryxU32(&x1315, &x1316, x1314, x1302, x1299); + var x1317: u32 = undefined; + var x1318: u1 = undefined; + addcarryxU32(&x1317, &x1318, x1316, x1300, x1297); + var x1319: u32 = undefined; + var x1320: u1 = undefined; + addcarryxU32(&x1319, &x1320, x1318, x1298, x1295); + var x1321: u32 = undefined; + var x1322: u1 = undefined; + addcarryxU32(&x1321, &x1322, x1320, x1296, x1293); + var x1323: u32 = undefined; + var x1324: u1 = undefined; + addcarryxU32(&x1323, &x1324, x1322, x1294, x1291); + var x1325: u32 = undefined; + var x1326: u1 = undefined; + addcarryxU32(&x1325, &x1326, x1324, x1292, x1289); + var x1327: u32 = undefined; + var x1328: u1 = undefined; + addcarryxU32(&x1327, &x1328, x1326, x1290, x1287); + var x1329: u32 = undefined; + var x1330: u1 = undefined; + addcarryxU32(&x1329, &x1330, x1328, x1288, x1285); + var x1331: u32 = undefined; + var x1332: u1 = undefined; + addcarryxU32(&x1331, &x1332, 0x0, x1261, x1307); + var x1333: u32 = undefined; + var x1334: u1 = undefined; + addcarryxU32(&x1333, &x1334, x1332, x1263, x1309); + var x1335: u32 = undefined; + var x1336: u1 = undefined; + addcarryxU32(&x1335, &x1336, x1334, x1265, x1311); + var x1337: u32 = undefined; + var x1338: u1 = undefined; + addcarryxU32(&x1337, &x1338, x1336, x1267, x1313); + var x1339: u32 = undefined; + var x1340: u1 = undefined; + addcarryxU32(&x1339, &x1340, x1338, x1269, x1315); + var x1341: u32 = undefined; + var x1342: u1 = undefined; + addcarryxU32(&x1341, &x1342, x1340, x1271, x1317); + var x1343: u32 = undefined; + var x1344: u1 = undefined; + addcarryxU32(&x1343, &x1344, x1342, x1273, x1319); + var x1345: u32 = undefined; + var x1346: u1 = undefined; + addcarryxU32(&x1345, &x1346, x1344, x1275, x1321); + var x1347: u32 = undefined; + var x1348: u1 = undefined; + addcarryxU32(&x1347, &x1348, x1346, x1277, x1323); + var x1349: u32 = undefined; + var x1350: u1 = undefined; + addcarryxU32(&x1349, &x1350, x1348, x1279, x1325); + var x1351: u32 = undefined; + var x1352: u1 = undefined; + addcarryxU32(&x1351, &x1352, x1350, x1281, x1327); + var x1353: u32 = undefined; + var x1354: u1 = undefined; + addcarryxU32(&x1353, &x1354, x1352, x1283, x1329); + var x1355: u32 = undefined; + var x1356: u32 = undefined; + mulxU32(&x1355, &x1356, x1331, 0xe88fdc45); + var x1357: u32 = undefined; + var x1358: u32 = undefined; + mulxU32(&x1357, &x1358, x1355, 0xffffffff); + var x1359: u32 = undefined; + var x1360: u32 = undefined; + mulxU32(&x1359, &x1360, x1355, 0xffffffff); + var x1361: u32 = undefined; + var x1362: u32 = undefined; + mulxU32(&x1361, &x1362, x1355, 0xffffffff); + var x1363: u32 = undefined; + var x1364: u32 = undefined; + mulxU32(&x1363, &x1364, x1355, 0xffffffff); + var x1365: u32 = undefined; + var x1366: u32 = undefined; + mulxU32(&x1365, &x1366, x1355, 0xffffffff); + var x1367: u32 = undefined; + var x1368: u32 = undefined; + mulxU32(&x1367, &x1368, x1355, 0xffffffff); + var x1369: u32 = undefined; + var x1370: u32 = undefined; + mulxU32(&x1369, &x1370, x1355, 0xc7634d81); + var x1371: u32 = undefined; + var x1372: u32 = undefined; + mulxU32(&x1371, &x1372, x1355, 0xf4372ddf); + var x1373: u32 = undefined; + var x1374: u32 = undefined; + mulxU32(&x1373, &x1374, x1355, 0x581a0db2); + var x1375: u32 = undefined; + var x1376: u32 = undefined; + mulxU32(&x1375, &x1376, x1355, 0x48b0a77a); + var x1377: u32 = undefined; + var x1378: u32 = undefined; + mulxU32(&x1377, &x1378, x1355, 0xecec196a); + var x1379: u32 = undefined; + var x1380: u32 = undefined; + mulxU32(&x1379, &x1380, x1355, 0xccc52973); + var x1381: u32 = undefined; + var x1382: u1 = undefined; + addcarryxU32(&x1381, &x1382, 0x0, x1380, x1377); + var x1383: u32 = undefined; + var x1384: u1 = undefined; + addcarryxU32(&x1383, &x1384, x1382, x1378, x1375); + var x1385: u32 = undefined; + var x1386: u1 = undefined; + addcarryxU32(&x1385, &x1386, x1384, x1376, x1373); + var x1387: u32 = undefined; + var x1388: u1 = undefined; + addcarryxU32(&x1387, &x1388, x1386, x1374, x1371); + var x1389: u32 = undefined; + var x1390: u1 = undefined; + addcarryxU32(&x1389, &x1390, x1388, x1372, x1369); + var x1391: u32 = undefined; + var x1392: u1 = undefined; + addcarryxU32(&x1391, &x1392, x1390, x1370, x1367); + var x1393: u32 = undefined; + var x1394: u1 = undefined; + addcarryxU32(&x1393, &x1394, x1392, x1368, x1365); + var x1395: u32 = undefined; + var x1396: u1 = undefined; + addcarryxU32(&x1395, &x1396, x1394, x1366, x1363); + var x1397: u32 = undefined; + var x1398: u1 = undefined; + addcarryxU32(&x1397, &x1398, x1396, x1364, x1361); + var x1399: u32 = undefined; + var x1400: u1 = undefined; + addcarryxU32(&x1399, &x1400, x1398, x1362, x1359); + var x1401: u32 = undefined; + var x1402: u1 = undefined; + addcarryxU32(&x1401, &x1402, x1400, x1360, x1357); + var x1403: u32 = undefined; + var x1404: u1 = undefined; + addcarryxU32(&x1403, &x1404, 0x0, x1331, x1379); + var x1405: u32 = undefined; + var x1406: u1 = undefined; + addcarryxU32(&x1405, &x1406, x1404, x1333, x1381); + var x1407: u32 = undefined; + var x1408: u1 = undefined; + addcarryxU32(&x1407, &x1408, x1406, x1335, x1383); + var x1409: u32 = undefined; + var x1410: u1 = undefined; + addcarryxU32(&x1409, &x1410, x1408, x1337, x1385); + var x1411: u32 = undefined; + var x1412: u1 = undefined; + addcarryxU32(&x1411, &x1412, x1410, x1339, x1387); + var x1413: u32 = undefined; + var x1414: u1 = undefined; + addcarryxU32(&x1413, &x1414, x1412, x1341, x1389); + var x1415: u32 = undefined; + var x1416: u1 = undefined; + addcarryxU32(&x1415, &x1416, x1414, x1343, x1391); + var x1417: u32 = undefined; + var x1418: u1 = undefined; + addcarryxU32(&x1417, &x1418, x1416, x1345, x1393); + var x1419: u32 = undefined; + var x1420: u1 = undefined; + addcarryxU32(&x1419, &x1420, x1418, x1347, x1395); + var x1421: u32 = undefined; + var x1422: u1 = undefined; + addcarryxU32(&x1421, &x1422, x1420, x1349, x1397); + var x1423: u32 = undefined; + var x1424: u1 = undefined; + addcarryxU32(&x1423, &x1424, x1422, x1351, x1399); + var x1425: u32 = undefined; + var x1426: u1 = undefined; + addcarryxU32(&x1425, &x1426, x1424, x1353, x1401); + var x1427: u32 = undefined; + var x1428: u1 = undefined; + addcarryxU32(&x1427, &x1428, x1426, ((cast(u32, x1354) + cast(u32, x1284)) + (cast(u32, x1330) + x1286)), (cast(u32, x1402) + x1358)); + var x1429: u32 = undefined; + var x1430: u32 = undefined; + mulxU32(&x1429, &x1430, x10, 0xc84ee01); + var x1431: u32 = undefined; + var x1432: u32 = undefined; + mulxU32(&x1431, &x1432, x10, 0x2b39bf21); + var x1433: u32 = undefined; + var x1434: u32 = undefined; + mulxU32(&x1433, &x1434, x10, 0x3fb05b7a); + var x1435: u32 = undefined; + var x1436: u32 = undefined; + mulxU32(&x1435, &x1436, x10, 0x28266895); + var x1437: u32 = undefined; + var x1438: u32 = undefined; + mulxU32(&x1437, &x1438, x10, 0xd40d4917); + var x1439: u32 = undefined; + var x1440: u32 = undefined; + mulxU32(&x1439, &x1440, x10, 0x4aab1cc5); + var x1441: u32 = undefined; + var x1442: u32 = undefined; + mulxU32(&x1441, &x1442, x10, 0xbc3e483a); + var x1443: u32 = undefined; + var x1444: u32 = undefined; + mulxU32(&x1443, &x1444, x10, 0xfcb82947); + var x1445: u32 = undefined; + var x1446: u32 = undefined; + mulxU32(&x1445, &x1446, x10, 0xff3d81e5); + var x1447: u32 = undefined; + var x1448: u32 = undefined; + mulxU32(&x1447, &x1448, x10, 0xdf1aa419); + var x1449: u32 = undefined; + var x1450: u32 = undefined; + mulxU32(&x1449, &x1450, x10, 0x2d319b24); + var x1451: u32 = undefined; + var x1452: u32 = undefined; + mulxU32(&x1451, &x1452, x10, 0x19b409a9); + var x1453: u32 = undefined; + var x1454: u1 = undefined; + addcarryxU32(&x1453, &x1454, 0x0, x1452, x1449); + var x1455: u32 = undefined; + var x1456: u1 = undefined; + addcarryxU32(&x1455, &x1456, x1454, x1450, x1447); + var x1457: u32 = undefined; + var x1458: u1 = undefined; + addcarryxU32(&x1457, &x1458, x1456, x1448, x1445); + var x1459: u32 = undefined; + var x1460: u1 = undefined; + addcarryxU32(&x1459, &x1460, x1458, x1446, x1443); + var x1461: u32 = undefined; + var x1462: u1 = undefined; + addcarryxU32(&x1461, &x1462, x1460, x1444, x1441); + var x1463: u32 = undefined; + var x1464: u1 = undefined; + addcarryxU32(&x1463, &x1464, x1462, x1442, x1439); + var x1465: u32 = undefined; + var x1466: u1 = undefined; + addcarryxU32(&x1465, &x1466, x1464, x1440, x1437); + var x1467: u32 = undefined; + var x1468: u1 = undefined; + addcarryxU32(&x1467, &x1468, x1466, x1438, x1435); + var x1469: u32 = undefined; + var x1470: u1 = undefined; + addcarryxU32(&x1469, &x1470, x1468, x1436, x1433); + var x1471: u32 = undefined; + var x1472: u1 = undefined; + addcarryxU32(&x1471, &x1472, x1470, x1434, x1431); + var x1473: u32 = undefined; + var x1474: u1 = undefined; + addcarryxU32(&x1473, &x1474, x1472, x1432, x1429); + var x1475: u32 = undefined; + var x1476: u1 = undefined; + addcarryxU32(&x1475, &x1476, 0x0, x1405, x1451); + var x1477: u32 = undefined; + var x1478: u1 = undefined; + addcarryxU32(&x1477, &x1478, x1476, x1407, x1453); + var x1479: u32 = undefined; + var x1480: u1 = undefined; + addcarryxU32(&x1479, &x1480, x1478, x1409, x1455); + var x1481: u32 = undefined; + var x1482: u1 = undefined; + addcarryxU32(&x1481, &x1482, x1480, x1411, x1457); + var x1483: u32 = undefined; + var x1484: u1 = undefined; + addcarryxU32(&x1483, &x1484, x1482, x1413, x1459); + var x1485: u32 = undefined; + var x1486: u1 = undefined; + addcarryxU32(&x1485, &x1486, x1484, x1415, x1461); + var x1487: u32 = undefined; + var x1488: u1 = undefined; + addcarryxU32(&x1487, &x1488, x1486, x1417, x1463); + var x1489: u32 = undefined; + var x1490: u1 = undefined; + addcarryxU32(&x1489, &x1490, x1488, x1419, x1465); + var x1491: u32 = undefined; + var x1492: u1 = undefined; + addcarryxU32(&x1491, &x1492, x1490, x1421, x1467); + var x1493: u32 = undefined; + var x1494: u1 = undefined; + addcarryxU32(&x1493, &x1494, x1492, x1423, x1469); + var x1495: u32 = undefined; + var x1496: u1 = undefined; + addcarryxU32(&x1495, &x1496, x1494, x1425, x1471); + var x1497: u32 = undefined; + var x1498: u1 = undefined; + addcarryxU32(&x1497, &x1498, x1496, x1427, x1473); + var x1499: u32 = undefined; + var x1500: u32 = undefined; + mulxU32(&x1499, &x1500, x1475, 0xe88fdc45); + var x1501: u32 = undefined; + var x1502: u32 = undefined; + mulxU32(&x1501, &x1502, x1499, 0xffffffff); + var x1503: u32 = undefined; + var x1504: u32 = undefined; + mulxU32(&x1503, &x1504, x1499, 0xffffffff); + var x1505: u32 = undefined; + var x1506: u32 = undefined; + mulxU32(&x1505, &x1506, x1499, 0xffffffff); + var x1507: u32 = undefined; + var x1508: u32 = undefined; + mulxU32(&x1507, &x1508, x1499, 0xffffffff); + var x1509: u32 = undefined; + var x1510: u32 = undefined; + mulxU32(&x1509, &x1510, x1499, 0xffffffff); + var x1511: u32 = undefined; + var x1512: u32 = undefined; + mulxU32(&x1511, &x1512, x1499, 0xffffffff); + var x1513: u32 = undefined; + var x1514: u32 = undefined; + mulxU32(&x1513, &x1514, x1499, 0xc7634d81); + var x1515: u32 = undefined; + var x1516: u32 = undefined; + mulxU32(&x1515, &x1516, x1499, 0xf4372ddf); + var x1517: u32 = undefined; + var x1518: u32 = undefined; + mulxU32(&x1517, &x1518, x1499, 0x581a0db2); + var x1519: u32 = undefined; + var x1520: u32 = undefined; + mulxU32(&x1519, &x1520, x1499, 0x48b0a77a); + var x1521: u32 = undefined; + var x1522: u32 = undefined; + mulxU32(&x1521, &x1522, x1499, 0xecec196a); + var x1523: u32 = undefined; + var x1524: u32 = undefined; + mulxU32(&x1523, &x1524, x1499, 0xccc52973); + var x1525: u32 = undefined; + var x1526: u1 = undefined; + addcarryxU32(&x1525, &x1526, 0x0, x1524, x1521); + var x1527: u32 = undefined; + var x1528: u1 = undefined; + addcarryxU32(&x1527, &x1528, x1526, x1522, x1519); + var x1529: u32 = undefined; + var x1530: u1 = undefined; + addcarryxU32(&x1529, &x1530, x1528, x1520, x1517); + var x1531: u32 = undefined; + var x1532: u1 = undefined; + addcarryxU32(&x1531, &x1532, x1530, x1518, x1515); + var x1533: u32 = undefined; + var x1534: u1 = undefined; + addcarryxU32(&x1533, &x1534, x1532, x1516, x1513); + var x1535: u32 = undefined; + var x1536: u1 = undefined; + addcarryxU32(&x1535, &x1536, x1534, x1514, x1511); + var x1537: u32 = undefined; + var x1538: u1 = undefined; + addcarryxU32(&x1537, &x1538, x1536, x1512, x1509); + var x1539: u32 = undefined; + var x1540: u1 = undefined; + addcarryxU32(&x1539, &x1540, x1538, x1510, x1507); + var x1541: u32 = undefined; + var x1542: u1 = undefined; + addcarryxU32(&x1541, &x1542, x1540, x1508, x1505); + var x1543: u32 = undefined; + var x1544: u1 = undefined; + addcarryxU32(&x1543, &x1544, x1542, x1506, x1503); + var x1545: u32 = undefined; + var x1546: u1 = undefined; + addcarryxU32(&x1545, &x1546, x1544, x1504, x1501); + var x1547: u32 = undefined; + var x1548: u1 = undefined; + addcarryxU32(&x1547, &x1548, 0x0, x1475, x1523); + var x1549: u32 = undefined; + var x1550: u1 = undefined; + addcarryxU32(&x1549, &x1550, x1548, x1477, x1525); + var x1551: u32 = undefined; + var x1552: u1 = undefined; + addcarryxU32(&x1551, &x1552, x1550, x1479, x1527); + var x1553: u32 = undefined; + var x1554: u1 = undefined; + addcarryxU32(&x1553, &x1554, x1552, x1481, x1529); + var x1555: u32 = undefined; + var x1556: u1 = undefined; + addcarryxU32(&x1555, &x1556, x1554, x1483, x1531); + var x1557: u32 = undefined; + var x1558: u1 = undefined; + addcarryxU32(&x1557, &x1558, x1556, x1485, x1533); + var x1559: u32 = undefined; + var x1560: u1 = undefined; + addcarryxU32(&x1559, &x1560, x1558, x1487, x1535); + var x1561: u32 = undefined; + var x1562: u1 = undefined; + addcarryxU32(&x1561, &x1562, x1560, x1489, x1537); + var x1563: u32 = undefined; + var x1564: u1 = undefined; + addcarryxU32(&x1563, &x1564, x1562, x1491, x1539); + var x1565: u32 = undefined; + var x1566: u1 = undefined; + addcarryxU32(&x1565, &x1566, x1564, x1493, x1541); + var x1567: u32 = undefined; + var x1568: u1 = undefined; + addcarryxU32(&x1567, &x1568, x1566, x1495, x1543); + var x1569: u32 = undefined; + var x1570: u1 = undefined; + addcarryxU32(&x1569, &x1570, x1568, x1497, x1545); + var x1571: u32 = undefined; + var x1572: u1 = undefined; + addcarryxU32(&x1571, &x1572, x1570, ((cast(u32, x1498) + cast(u32, x1428)) + (cast(u32, x1474) + x1430)), (cast(u32, x1546) + x1502)); + var x1573: u32 = undefined; + var x1574: u32 = undefined; + mulxU32(&x1573, &x1574, x11, 0xc84ee01); + var x1575: u32 = undefined; + var x1576: u32 = undefined; + mulxU32(&x1575, &x1576, x11, 0x2b39bf21); + var x1577: u32 = undefined; + var x1578: u32 = undefined; + mulxU32(&x1577, &x1578, x11, 0x3fb05b7a); + var x1579: u32 = undefined; + var x1580: u32 = undefined; + mulxU32(&x1579, &x1580, x11, 0x28266895); + var x1581: u32 = undefined; + var x1582: u32 = undefined; + mulxU32(&x1581, &x1582, x11, 0xd40d4917); + var x1583: u32 = undefined; + var x1584: u32 = undefined; + mulxU32(&x1583, &x1584, x11, 0x4aab1cc5); + var x1585: u32 = undefined; + var x1586: u32 = undefined; + mulxU32(&x1585, &x1586, x11, 0xbc3e483a); + var x1587: u32 = undefined; + var x1588: u32 = undefined; + mulxU32(&x1587, &x1588, x11, 0xfcb82947); + var x1589: u32 = undefined; + var x1590: u32 = undefined; + mulxU32(&x1589, &x1590, x11, 0xff3d81e5); + var x1591: u32 = undefined; + var x1592: u32 = undefined; + mulxU32(&x1591, &x1592, x11, 0xdf1aa419); + var x1593: u32 = undefined; + var x1594: u32 = undefined; + mulxU32(&x1593, &x1594, x11, 0x2d319b24); + var x1595: u32 = undefined; + var x1596: u32 = undefined; + mulxU32(&x1595, &x1596, x11, 0x19b409a9); + var x1597: u32 = undefined; + var x1598: u1 = undefined; + addcarryxU32(&x1597, &x1598, 0x0, x1596, x1593); + var x1599: u32 = undefined; + var x1600: u1 = undefined; + addcarryxU32(&x1599, &x1600, x1598, x1594, x1591); + var x1601: u32 = undefined; + var x1602: u1 = undefined; + addcarryxU32(&x1601, &x1602, x1600, x1592, x1589); + var x1603: u32 = undefined; + var x1604: u1 = undefined; + addcarryxU32(&x1603, &x1604, x1602, x1590, x1587); + var x1605: u32 = undefined; + var x1606: u1 = undefined; + addcarryxU32(&x1605, &x1606, x1604, x1588, x1585); + var x1607: u32 = undefined; + var x1608: u1 = undefined; + addcarryxU32(&x1607, &x1608, x1606, x1586, x1583); + var x1609: u32 = undefined; + var x1610: u1 = undefined; + addcarryxU32(&x1609, &x1610, x1608, x1584, x1581); + var x1611: u32 = undefined; + var x1612: u1 = undefined; + addcarryxU32(&x1611, &x1612, x1610, x1582, x1579); + var x1613: u32 = undefined; + var x1614: u1 = undefined; + addcarryxU32(&x1613, &x1614, x1612, x1580, x1577); + var x1615: u32 = undefined; + var x1616: u1 = undefined; + addcarryxU32(&x1615, &x1616, x1614, x1578, x1575); + var x1617: u32 = undefined; + var x1618: u1 = undefined; + addcarryxU32(&x1617, &x1618, x1616, x1576, x1573); + var x1619: u32 = undefined; + var x1620: u1 = undefined; + addcarryxU32(&x1619, &x1620, 0x0, x1549, x1595); + var x1621: u32 = undefined; + var x1622: u1 = undefined; + addcarryxU32(&x1621, &x1622, x1620, x1551, x1597); + var x1623: u32 = undefined; + var x1624: u1 = undefined; + addcarryxU32(&x1623, &x1624, x1622, x1553, x1599); + var x1625: u32 = undefined; + var x1626: u1 = undefined; + addcarryxU32(&x1625, &x1626, x1624, x1555, x1601); + var x1627: u32 = undefined; + var x1628: u1 = undefined; + addcarryxU32(&x1627, &x1628, x1626, x1557, x1603); + var x1629: u32 = undefined; + var x1630: u1 = undefined; + addcarryxU32(&x1629, &x1630, x1628, x1559, x1605); + var x1631: u32 = undefined; + var x1632: u1 = undefined; + addcarryxU32(&x1631, &x1632, x1630, x1561, x1607); + var x1633: u32 = undefined; + var x1634: u1 = undefined; + addcarryxU32(&x1633, &x1634, x1632, x1563, x1609); + var x1635: u32 = undefined; + var x1636: u1 = undefined; + addcarryxU32(&x1635, &x1636, x1634, x1565, x1611); + var x1637: u32 = undefined; + var x1638: u1 = undefined; + addcarryxU32(&x1637, &x1638, x1636, x1567, x1613); + var x1639: u32 = undefined; + var x1640: u1 = undefined; + addcarryxU32(&x1639, &x1640, x1638, x1569, x1615); + var x1641: u32 = undefined; + var x1642: u1 = undefined; + addcarryxU32(&x1641, &x1642, x1640, x1571, x1617); + var x1643: u32 = undefined; + var x1644: u32 = undefined; + mulxU32(&x1643, &x1644, x1619, 0xe88fdc45); + var x1645: u32 = undefined; + var x1646: u32 = undefined; + mulxU32(&x1645, &x1646, x1643, 0xffffffff); + var x1647: u32 = undefined; + var x1648: u32 = undefined; + mulxU32(&x1647, &x1648, x1643, 0xffffffff); + var x1649: u32 = undefined; + var x1650: u32 = undefined; + mulxU32(&x1649, &x1650, x1643, 0xffffffff); + var x1651: u32 = undefined; + var x1652: u32 = undefined; + mulxU32(&x1651, &x1652, x1643, 0xffffffff); + var x1653: u32 = undefined; + var x1654: u32 = undefined; + mulxU32(&x1653, &x1654, x1643, 0xffffffff); + var x1655: u32 = undefined; + var x1656: u32 = undefined; + mulxU32(&x1655, &x1656, x1643, 0xffffffff); + var x1657: u32 = undefined; + var x1658: u32 = undefined; + mulxU32(&x1657, &x1658, x1643, 0xc7634d81); + var x1659: u32 = undefined; + var x1660: u32 = undefined; + mulxU32(&x1659, &x1660, x1643, 0xf4372ddf); + var x1661: u32 = undefined; + var x1662: u32 = undefined; + mulxU32(&x1661, &x1662, x1643, 0x581a0db2); + var x1663: u32 = undefined; + var x1664: u32 = undefined; + mulxU32(&x1663, &x1664, x1643, 0x48b0a77a); + var x1665: u32 = undefined; + var x1666: u32 = undefined; + mulxU32(&x1665, &x1666, x1643, 0xecec196a); + var x1667: u32 = undefined; + var x1668: u32 = undefined; + mulxU32(&x1667, &x1668, x1643, 0xccc52973); + var x1669: u32 = undefined; + var x1670: u1 = undefined; + addcarryxU32(&x1669, &x1670, 0x0, x1668, x1665); + var x1671: u32 = undefined; + var x1672: u1 = undefined; + addcarryxU32(&x1671, &x1672, x1670, x1666, x1663); + var x1673: u32 = undefined; + var x1674: u1 = undefined; + addcarryxU32(&x1673, &x1674, x1672, x1664, x1661); + var x1675: u32 = undefined; + var x1676: u1 = undefined; + addcarryxU32(&x1675, &x1676, x1674, x1662, x1659); + var x1677: u32 = undefined; + var x1678: u1 = undefined; + addcarryxU32(&x1677, &x1678, x1676, x1660, x1657); + var x1679: u32 = undefined; + var x1680: u1 = undefined; + addcarryxU32(&x1679, &x1680, x1678, x1658, x1655); + var x1681: u32 = undefined; + var x1682: u1 = undefined; + addcarryxU32(&x1681, &x1682, x1680, x1656, x1653); + var x1683: u32 = undefined; + var x1684: u1 = undefined; + addcarryxU32(&x1683, &x1684, x1682, x1654, x1651); + var x1685: u32 = undefined; + var x1686: u1 = undefined; + addcarryxU32(&x1685, &x1686, x1684, x1652, x1649); + var x1687: u32 = undefined; + var x1688: u1 = undefined; + addcarryxU32(&x1687, &x1688, x1686, x1650, x1647); + var x1689: u32 = undefined; + var x1690: u1 = undefined; + addcarryxU32(&x1689, &x1690, x1688, x1648, x1645); + var x1691: u32 = undefined; + var x1692: u1 = undefined; + addcarryxU32(&x1691, &x1692, 0x0, x1619, x1667); + var x1693: u32 = undefined; + var x1694: u1 = undefined; + addcarryxU32(&x1693, &x1694, x1692, x1621, x1669); + var x1695: u32 = undefined; + var x1696: u1 = undefined; + addcarryxU32(&x1695, &x1696, x1694, x1623, x1671); + var x1697: u32 = undefined; + var x1698: u1 = undefined; + addcarryxU32(&x1697, &x1698, x1696, x1625, x1673); + var x1699: u32 = undefined; + var x1700: u1 = undefined; + addcarryxU32(&x1699, &x1700, x1698, x1627, x1675); + var x1701: u32 = undefined; + var x1702: u1 = undefined; + addcarryxU32(&x1701, &x1702, x1700, x1629, x1677); + var x1703: u32 = undefined; + var x1704: u1 = undefined; + addcarryxU32(&x1703, &x1704, x1702, x1631, x1679); + var x1705: u32 = undefined; + var x1706: u1 = undefined; + addcarryxU32(&x1705, &x1706, x1704, x1633, x1681); + var x1707: u32 = undefined; + var x1708: u1 = undefined; + addcarryxU32(&x1707, &x1708, x1706, x1635, x1683); + var x1709: u32 = undefined; + var x1710: u1 = undefined; + addcarryxU32(&x1709, &x1710, x1708, x1637, x1685); + var x1711: u32 = undefined; + var x1712: u1 = undefined; + addcarryxU32(&x1711, &x1712, x1710, x1639, x1687); + var x1713: u32 = undefined; + var x1714: u1 = undefined; + addcarryxU32(&x1713, &x1714, x1712, x1641, x1689); + var x1715: u32 = undefined; + var x1716: u1 = undefined; + addcarryxU32(&x1715, &x1716, x1714, ((cast(u32, x1642) + cast(u32, x1572)) + (cast(u32, x1618) + x1574)), (cast(u32, x1690) + x1646)); + var x1717: u32 = undefined; + var x1718: u1 = undefined; + subborrowxU32(&x1717, &x1718, 0x0, x1693, 0xccc52973); + var x1719: u32 = undefined; + var x1720: u1 = undefined; + subborrowxU32(&x1719, &x1720, x1718, x1695, 0xecec196a); + var x1721: u32 = undefined; + var x1722: u1 = undefined; + subborrowxU32(&x1721, &x1722, x1720, x1697, 0x48b0a77a); + var x1723: u32 = undefined; + var x1724: u1 = undefined; + subborrowxU32(&x1723, &x1724, x1722, x1699, 0x581a0db2); + var x1725: u32 = undefined; + var x1726: u1 = undefined; + subborrowxU32(&x1725, &x1726, x1724, x1701, 0xf4372ddf); + var x1727: u32 = undefined; + var x1728: u1 = undefined; + subborrowxU32(&x1727, &x1728, x1726, x1703, 0xc7634d81); + var x1729: u32 = undefined; + var x1730: u1 = undefined; + subborrowxU32(&x1729, &x1730, x1728, x1705, 0xffffffff); + var x1731: u32 = undefined; + var x1732: u1 = undefined; + subborrowxU32(&x1731, &x1732, x1730, x1707, 0xffffffff); + var x1733: u32 = undefined; + var x1734: u1 = undefined; + subborrowxU32(&x1733, &x1734, x1732, x1709, 0xffffffff); + var x1735: u32 = undefined; + var x1736: u1 = undefined; + subborrowxU32(&x1735, &x1736, x1734, x1711, 0xffffffff); + var x1737: u32 = undefined; + var x1738: u1 = undefined; + subborrowxU32(&x1737, &x1738, x1736, x1713, 0xffffffff); + var x1739: u32 = undefined; + var x1740: u1 = undefined; + subborrowxU32(&x1739, &x1740, x1738, x1715, 0xffffffff); + var x1741: u32 = undefined; + var x1742: u1 = undefined; + subborrowxU32(&x1741, &x1742, x1740, cast(u32, x1716), cast(u32, 0x0)); + var x1743: u32 = undefined; + cmovznzU32(&x1743, x1742, x1717, x1693); + var x1744: u32 = undefined; + cmovznzU32(&x1744, x1742, x1719, x1695); + var x1745: u32 = undefined; + cmovznzU32(&x1745, x1742, x1721, x1697); + var x1746: u32 = undefined; + cmovznzU32(&x1746, x1742, x1723, x1699); + var x1747: u32 = undefined; + cmovznzU32(&x1747, x1742, x1725, x1701); + var x1748: u32 = undefined; + cmovznzU32(&x1748, x1742, x1727, x1703); + var x1749: u32 = undefined; + cmovznzU32(&x1749, x1742, x1729, x1705); + var x1750: u32 = undefined; + cmovznzU32(&x1750, x1742, x1731, x1707); + var x1751: u32 = undefined; + cmovznzU32(&x1751, x1742, x1733, x1709); + var x1752: u32 = undefined; + cmovznzU32(&x1752, x1742, x1735, x1711); + var x1753: u32 = undefined; + cmovznzU32(&x1753, x1742, x1737, x1713); + var x1754: u32 = undefined; + cmovznzU32(&x1754, x1742, x1739, x1715); + out1[0] = x1743; + out1[1] = x1744; + out1[2] = x1745; + out1[3] = x1746; + out1[4] = x1747; + out1[5] = x1748; + out1[6] = x1749; + out1[7] = x1750; + out1[8] = x1751; + out1[9] = x1752; + out1[10] = x1753; + out1[11] = x1754; +} + +/// The function nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +pub fn nonzero(out1: *u32, arg1: [12]u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | ((arg1[7]) | ((arg1[8]) | ((arg1[9]) | ((arg1[10]) | (arg1[11])))))))))))); + out1.* = x1; +} + +/// The function selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn selectznz(out1: *[12]u32, arg1: u1, arg2: [12]u32, arg3: [12]u32) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + cmovznzU32(&x1, arg1, (arg2[0]), (arg3[0])); + var x2: u32 = undefined; + cmovznzU32(&x2, arg1, (arg2[1]), (arg3[1])); + var x3: u32 = undefined; + cmovznzU32(&x3, arg1, (arg2[2]), (arg3[2])); + var x4: u32 = undefined; + cmovznzU32(&x4, arg1, (arg2[3]), (arg3[3])); + var x5: u32 = undefined; + cmovznzU32(&x5, arg1, (arg2[4]), (arg3[4])); + var x6: u32 = undefined; + cmovznzU32(&x6, arg1, (arg2[5]), (arg3[5])); + var x7: u32 = undefined; + cmovznzU32(&x7, arg1, (arg2[6]), (arg3[6])); + var x8: u32 = undefined; + cmovznzU32(&x8, arg1, (arg2[7]), (arg3[7])); + var x9: u32 = undefined; + cmovznzU32(&x9, arg1, (arg2[8]), (arg3[8])); + var x10: u32 = undefined; + cmovznzU32(&x10, arg1, (arg2[9]), (arg3[9])); + var x11: u32 = undefined; + cmovznzU32(&x11, arg1, (arg2[10]), (arg3[10])); + var x12: u32 = undefined; + cmovznzU32(&x12, arg1, (arg2[11]), (arg3[11])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; + out1[6] = x7; + out1[7] = x8; + out1[8] = x9; + out1[9] = x10; + out1[10] = x11; + out1[11] = x12; +} + +/// The function toBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +pub fn toBytes(out1: *[48]u8, arg1: [12]u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[11]); + const x2 = (arg1[10]); + const x3 = (arg1[9]); + const x4 = (arg1[8]); + const x5 = (arg1[7]); + const x6 = (arg1[6]); + const x7 = (arg1[5]); + const x8 = (arg1[4]); + const x9 = (arg1[3]); + const x10 = (arg1[2]); + const x11 = (arg1[1]); + const x12 = (arg1[0]); + const x13 = cast(u8, (x12 & cast(u32, 0xff))); + const x14 = (x12 >> 8); + const x15 = cast(u8, (x14 & cast(u32, 0xff))); + const x16 = (x14 >> 8); + const x17 = cast(u8, (x16 & cast(u32, 0xff))); + const x18 = cast(u8, (x16 >> 8)); + const x19 = cast(u8, (x11 & cast(u32, 0xff))); + const x20 = (x11 >> 8); + const x21 = cast(u8, (x20 & cast(u32, 0xff))); + const x22 = (x20 >> 8); + const x23 = cast(u8, (x22 & cast(u32, 0xff))); + const x24 = cast(u8, (x22 >> 8)); + const x25 = cast(u8, (x10 & cast(u32, 0xff))); + const x26 = (x10 >> 8); + const x27 = cast(u8, (x26 & cast(u32, 0xff))); + const x28 = (x26 >> 8); + const x29 = cast(u8, (x28 & cast(u32, 0xff))); + const x30 = cast(u8, (x28 >> 8)); + const x31 = cast(u8, (x9 & cast(u32, 0xff))); + const x32 = (x9 >> 8); + const x33 = cast(u8, (x32 & cast(u32, 0xff))); + const x34 = (x32 >> 8); + const x35 = cast(u8, (x34 & cast(u32, 0xff))); + const x36 = cast(u8, (x34 >> 8)); + const x37 = cast(u8, (x8 & cast(u32, 0xff))); + const x38 = (x8 >> 8); + const x39 = cast(u8, (x38 & cast(u32, 0xff))); + const x40 = (x38 >> 8); + const x41 = cast(u8, (x40 & cast(u32, 0xff))); + const x42 = cast(u8, (x40 >> 8)); + const x43 = cast(u8, (x7 & cast(u32, 0xff))); + const x44 = (x7 >> 8); + const x45 = cast(u8, (x44 & cast(u32, 0xff))); + const x46 = (x44 >> 8); + const x47 = cast(u8, (x46 & cast(u32, 0xff))); + const x48 = cast(u8, (x46 >> 8)); + const x49 = cast(u8, (x6 & cast(u32, 0xff))); + const x50 = (x6 >> 8); + const x51 = cast(u8, (x50 & cast(u32, 0xff))); + const x52 = (x50 >> 8); + const x53 = cast(u8, (x52 & cast(u32, 0xff))); + const x54 = cast(u8, (x52 >> 8)); + const x55 = cast(u8, (x5 & cast(u32, 0xff))); + const x56 = (x5 >> 8); + const x57 = cast(u8, (x56 & cast(u32, 0xff))); + const x58 = (x56 >> 8); + const x59 = cast(u8, (x58 & cast(u32, 0xff))); + const x60 = cast(u8, (x58 >> 8)); + const x61 = cast(u8, (x4 & cast(u32, 0xff))); + const x62 = (x4 >> 8); + const x63 = cast(u8, (x62 & cast(u32, 0xff))); + const x64 = (x62 >> 8); + const x65 = cast(u8, (x64 & cast(u32, 0xff))); + const x66 = cast(u8, (x64 >> 8)); + const x67 = cast(u8, (x3 & cast(u32, 0xff))); + const x68 = (x3 >> 8); + const x69 = cast(u8, (x68 & cast(u32, 0xff))); + const x70 = (x68 >> 8); + const x71 = cast(u8, (x70 & cast(u32, 0xff))); + const x72 = cast(u8, (x70 >> 8)); + const x73 = cast(u8, (x2 & cast(u32, 0xff))); + const x74 = (x2 >> 8); + const x75 = cast(u8, (x74 & cast(u32, 0xff))); + const x76 = (x74 >> 8); + const x77 = cast(u8, (x76 & cast(u32, 0xff))); + const x78 = cast(u8, (x76 >> 8)); + const x79 = cast(u8, (x1 & cast(u32, 0xff))); + const x80 = (x1 >> 8); + const x81 = cast(u8, (x80 & cast(u32, 0xff))); + const x82 = (x80 >> 8); + const x83 = cast(u8, (x82 & cast(u32, 0xff))); + const x84 = cast(u8, (x82 >> 8)); + out1[0] = x13; + out1[1] = x15; + out1[2] = x17; + out1[3] = x18; + out1[4] = x19; + out1[5] = x21; + out1[6] = x23; + out1[7] = x24; + out1[8] = x25; + out1[9] = x27; + out1[10] = x29; + out1[11] = x30; + out1[12] = x31; + out1[13] = x33; + out1[14] = x35; + out1[15] = x36; + out1[16] = x37; + out1[17] = x39; + out1[18] = x41; + out1[19] = x42; + out1[20] = x43; + out1[21] = x45; + out1[22] = x47; + out1[23] = x48; + out1[24] = x49; + out1[25] = x51; + out1[26] = x53; + out1[27] = x54; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; + out1[32] = x61; + out1[33] = x63; + out1[34] = x65; + out1[35] = x66; + out1[36] = x67; + out1[37] = x69; + out1[38] = x71; + out1[39] = x72; + out1[40] = x73; + out1[41] = x75; + out1[42] = x77; + out1[43] = x78; + out1[44] = x79; + out1[45] = x81; + out1[46] = x83; + out1[47] = x84; +} + +/// The function fromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn fromBytes(out1: *[12]u32, arg1: [48]u8) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u32, (arg1[47])) << 24); + const x2 = (cast(u32, (arg1[46])) << 16); + const x3 = (cast(u32, (arg1[45])) << 8); + const x4 = (arg1[44]); + const x5 = (cast(u32, (arg1[43])) << 24); + const x6 = (cast(u32, (arg1[42])) << 16); + const x7 = (cast(u32, (arg1[41])) << 8); + const x8 = (arg1[40]); + const x9 = (cast(u32, (arg1[39])) << 24); + const x10 = (cast(u32, (arg1[38])) << 16); + const x11 = (cast(u32, (arg1[37])) << 8); + const x12 = (arg1[36]); + const x13 = (cast(u32, (arg1[35])) << 24); + const x14 = (cast(u32, (arg1[34])) << 16); + const x15 = (cast(u32, (arg1[33])) << 8); + const x16 = (arg1[32]); + const x17 = (cast(u32, (arg1[31])) << 24); + const x18 = (cast(u32, (arg1[30])) << 16); + const x19 = (cast(u32, (arg1[29])) << 8); + const x20 = (arg1[28]); + const x21 = (cast(u32, (arg1[27])) << 24); + const x22 = (cast(u32, (arg1[26])) << 16); + const x23 = (cast(u32, (arg1[25])) << 8); + const x24 = (arg1[24]); + const x25 = (cast(u32, (arg1[23])) << 24); + const x26 = (cast(u32, (arg1[22])) << 16); + const x27 = (cast(u32, (arg1[21])) << 8); + const x28 = (arg1[20]); + const x29 = (cast(u32, (arg1[19])) << 24); + const x30 = (cast(u32, (arg1[18])) << 16); + const x31 = (cast(u32, (arg1[17])) << 8); + const x32 = (arg1[16]); + const x33 = (cast(u32, (arg1[15])) << 24); + const x34 = (cast(u32, (arg1[14])) << 16); + const x35 = (cast(u32, (arg1[13])) << 8); + const x36 = (arg1[12]); + const x37 = (cast(u32, (arg1[11])) << 24); + const x38 = (cast(u32, (arg1[10])) << 16); + const x39 = (cast(u32, (arg1[9])) << 8); + const x40 = (arg1[8]); + const x41 = (cast(u32, (arg1[7])) << 24); + const x42 = (cast(u32, (arg1[6])) << 16); + const x43 = (cast(u32, (arg1[5])) << 8); + const x44 = (arg1[4]); + const x45 = (cast(u32, (arg1[3])) << 24); + const x46 = (cast(u32, (arg1[2])) << 16); + const x47 = (cast(u32, (arg1[1])) << 8); + const x48 = (arg1[0]); + const x49 = (x47 + cast(u32, x48)); + const x50 = (x46 + x49); + const x51 = (x45 + x50); + const x52 = (x43 + cast(u32, x44)); + const x53 = (x42 + x52); + const x54 = (x41 + x53); + const x55 = (x39 + cast(u32, x40)); + const x56 = (x38 + x55); + const x57 = (x37 + x56); + const x58 = (x35 + cast(u32, x36)); + const x59 = (x34 + x58); + const x60 = (x33 + x59); + const x61 = (x31 + cast(u32, x32)); + const x62 = (x30 + x61); + const x63 = (x29 + x62); + const x64 = (x27 + cast(u32, x28)); + const x65 = (x26 + x64); + const x66 = (x25 + x65); + const x67 = (x23 + cast(u32, x24)); + const x68 = (x22 + x67); + const x69 = (x21 + x68); + const x70 = (x19 + cast(u32, x20)); + const x71 = (x18 + x70); + const x72 = (x17 + x71); + const x73 = (x15 + cast(u32, x16)); + const x74 = (x14 + x73); + const x75 = (x13 + x74); + const x76 = (x11 + cast(u32, x12)); + const x77 = (x10 + x76); + const x78 = (x9 + x77); + const x79 = (x7 + cast(u32, x8)); + const x80 = (x6 + x79); + const x81 = (x5 + x80); + const x82 = (x3 + cast(u32, x4)); + const x83 = (x2 + x82); + const x84 = (x1 + x83); + out1[0] = x51; + out1[1] = x54; + out1[2] = x57; + out1[3] = x60; + out1[4] = x63; + out1[5] = x66; + out1[6] = x69; + out1[7] = x72; + out1[8] = x75; + out1[9] = x78; + out1[10] = x81; + out1[11] = x84; +} + +/// The function setOne returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn setOne(out1: *MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0x333ad68d; + out1[1] = 0x1313e695; + out1[2] = 0xb74f5885; + out1[3] = 0xa7e5f24d; + out1[4] = 0xbc8d220; + out1[5] = 0x389cb27e; + out1[6] = cast(u32, 0x0); + out1[7] = cast(u32, 0x0); + out1[8] = cast(u32, 0x0); + out1[9] = cast(u32, 0x0); + out1[10] = cast(u32, 0x0); + out1[11] = cast(u32, 0x0); +} + +/// The function msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn msat(out1: *[13]u32) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xccc52973; + out1[1] = 0xecec196a; + out1[2] = 0x48b0a77a; + out1[3] = 0x581a0db2; + out1[4] = 0xf4372ddf; + out1[5] = 0xc7634d81; + out1[6] = 0xffffffff; + out1[7] = 0xffffffff; + out1[8] = 0xffffffff; + out1[9] = 0xffffffff; + out1[10] = 0xffffffff; + out1[11] = 0xffffffff; + out1[12] = cast(u32, 0x0); +} + +/// The function divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn divstep(out1: *u32, out2: *[13]u32, out3: *[13]u32, out4: *[12]u32, out5: *[12]u32, arg1: u32, arg2: [13]u32, arg3: [13]u32, arg4: [12]u32, arg5: [12]u32) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + addcarryxU32(&x1, &x2, 0x0, (~arg1), cast(u32, 0x1)); + const x3 = (cast(u1, (x1 >> 31)) & cast(u1, ((arg3[0]) & cast(u32, 0x1)))); + var x4: u32 = undefined; + var x5: u1 = undefined; + addcarryxU32(&x4, &x5, 0x0, (~arg1), cast(u32, 0x1)); + var x6: u32 = undefined; + cmovznzU32(&x6, x3, arg1, x4); + var x7: u32 = undefined; + cmovznzU32(&x7, x3, (arg2[0]), (arg3[0])); + var x8: u32 = undefined; + cmovznzU32(&x8, x3, (arg2[1]), (arg3[1])); + var x9: u32 = undefined; + cmovznzU32(&x9, x3, (arg2[2]), (arg3[2])); + var x10: u32 = undefined; + cmovznzU32(&x10, x3, (arg2[3]), (arg3[3])); + var x11: u32 = undefined; + cmovznzU32(&x11, x3, (arg2[4]), (arg3[4])); + var x12: u32 = undefined; + cmovznzU32(&x12, x3, (arg2[5]), (arg3[5])); + var x13: u32 = undefined; + cmovznzU32(&x13, x3, (arg2[6]), (arg3[6])); + var x14: u32 = undefined; + cmovznzU32(&x14, x3, (arg2[7]), (arg3[7])); + var x15: u32 = undefined; + cmovznzU32(&x15, x3, (arg2[8]), (arg3[8])); + var x16: u32 = undefined; + cmovznzU32(&x16, x3, (arg2[9]), (arg3[9])); + var x17: u32 = undefined; + cmovznzU32(&x17, x3, (arg2[10]), (arg3[10])); + var x18: u32 = undefined; + cmovznzU32(&x18, x3, (arg2[11]), (arg3[11])); + var x19: u32 = undefined; + cmovznzU32(&x19, x3, (arg2[12]), (arg3[12])); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, 0x0, cast(u32, 0x1), (~(arg2[0]))); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, cast(u32, 0x0), (~(arg2[1]))); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, cast(u32, 0x0), (~(arg2[2]))); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, cast(u32, 0x0), (~(arg2[3]))); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, cast(u32, 0x0), (~(arg2[4]))); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, cast(u32, 0x0), (~(arg2[5]))); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, cast(u32, 0x0), (~(arg2[6]))); + var x34: u32 = undefined; + var x35: u1 = undefined; + addcarryxU32(&x34, &x35, x33, cast(u32, 0x0), (~(arg2[7]))); + var x36: u32 = undefined; + var x37: u1 = undefined; + addcarryxU32(&x36, &x37, x35, cast(u32, 0x0), (~(arg2[8]))); + var x38: u32 = undefined; + var x39: u1 = undefined; + addcarryxU32(&x38, &x39, x37, cast(u32, 0x0), (~(arg2[9]))); + var x40: u32 = undefined; + var x41: u1 = undefined; + addcarryxU32(&x40, &x41, x39, cast(u32, 0x0), (~(arg2[10]))); + var x42: u32 = undefined; + var x43: u1 = undefined; + addcarryxU32(&x42, &x43, x41, cast(u32, 0x0), (~(arg2[11]))); + var x44: u32 = undefined; + var x45: u1 = undefined; + addcarryxU32(&x44, &x45, x43, cast(u32, 0x0), (~(arg2[12]))); + var x46: u32 = undefined; + cmovznzU32(&x46, x3, (arg3[0]), x20); + var x47: u32 = undefined; + cmovznzU32(&x47, x3, (arg3[1]), x22); + var x48: u32 = undefined; + cmovznzU32(&x48, x3, (arg3[2]), x24); + var x49: u32 = undefined; + cmovznzU32(&x49, x3, (arg3[3]), x26); + var x50: u32 = undefined; + cmovznzU32(&x50, x3, (arg3[4]), x28); + var x51: u32 = undefined; + cmovznzU32(&x51, x3, (arg3[5]), x30); + var x52: u32 = undefined; + cmovznzU32(&x52, x3, (arg3[6]), x32); + var x53: u32 = undefined; + cmovznzU32(&x53, x3, (arg3[7]), x34); + var x54: u32 = undefined; + cmovznzU32(&x54, x3, (arg3[8]), x36); + var x55: u32 = undefined; + cmovznzU32(&x55, x3, (arg3[9]), x38); + var x56: u32 = undefined; + cmovznzU32(&x56, x3, (arg3[10]), x40); + var x57: u32 = undefined; + cmovznzU32(&x57, x3, (arg3[11]), x42); + var x58: u32 = undefined; + cmovznzU32(&x58, x3, (arg3[12]), x44); + var x59: u32 = undefined; + cmovznzU32(&x59, x3, (arg4[0]), (arg5[0])); + var x60: u32 = undefined; + cmovznzU32(&x60, x3, (arg4[1]), (arg5[1])); + var x61: u32 = undefined; + cmovznzU32(&x61, x3, (arg4[2]), (arg5[2])); + var x62: u32 = undefined; + cmovznzU32(&x62, x3, (arg4[3]), (arg5[3])); + var x63: u32 = undefined; + cmovznzU32(&x63, x3, (arg4[4]), (arg5[4])); + var x64: u32 = undefined; + cmovznzU32(&x64, x3, (arg4[5]), (arg5[5])); + var x65: u32 = undefined; + cmovznzU32(&x65, x3, (arg4[6]), (arg5[6])); + var x66: u32 = undefined; + cmovznzU32(&x66, x3, (arg4[7]), (arg5[7])); + var x67: u32 = undefined; + cmovznzU32(&x67, x3, (arg4[8]), (arg5[8])); + var x68: u32 = undefined; + cmovznzU32(&x68, x3, (arg4[9]), (arg5[9])); + var x69: u32 = undefined; + cmovznzU32(&x69, x3, (arg4[10]), (arg5[10])); + var x70: u32 = undefined; + cmovznzU32(&x70, x3, (arg4[11]), (arg5[11])); + var x71: u32 = undefined; + var x72: u1 = undefined; + addcarryxU32(&x71, &x72, 0x0, x59, x59); + var x73: u32 = undefined; + var x74: u1 = undefined; + addcarryxU32(&x73, &x74, x72, x60, x60); + var x75: u32 = undefined; + var x76: u1 = undefined; + addcarryxU32(&x75, &x76, x74, x61, x61); + var x77: u32 = undefined; + var x78: u1 = undefined; + addcarryxU32(&x77, &x78, x76, x62, x62); + var x79: u32 = undefined; + var x80: u1 = undefined; + addcarryxU32(&x79, &x80, x78, x63, x63); + var x81: u32 = undefined; + var x82: u1 = undefined; + addcarryxU32(&x81, &x82, x80, x64, x64); + var x83: u32 = undefined; + var x84: u1 = undefined; + addcarryxU32(&x83, &x84, x82, x65, x65); + var x85: u32 = undefined; + var x86: u1 = undefined; + addcarryxU32(&x85, &x86, x84, x66, x66); + var x87: u32 = undefined; + var x88: u1 = undefined; + addcarryxU32(&x87, &x88, x86, x67, x67); + var x89: u32 = undefined; + var x90: u1 = undefined; + addcarryxU32(&x89, &x90, x88, x68, x68); + var x91: u32 = undefined; + var x92: u1 = undefined; + addcarryxU32(&x91, &x92, x90, x69, x69); + var x93: u32 = undefined; + var x94: u1 = undefined; + addcarryxU32(&x93, &x94, x92, x70, x70); + var x95: u32 = undefined; + var x96: u1 = undefined; + subborrowxU32(&x95, &x96, 0x0, x71, 0xccc52973); + var x97: u32 = undefined; + var x98: u1 = undefined; + subborrowxU32(&x97, &x98, x96, x73, 0xecec196a); + var x99: u32 = undefined; + var x100: u1 = undefined; + subborrowxU32(&x99, &x100, x98, x75, 0x48b0a77a); + var x101: u32 = undefined; + var x102: u1 = undefined; + subborrowxU32(&x101, &x102, x100, x77, 0x581a0db2); + var x103: u32 = undefined; + var x104: u1 = undefined; + subborrowxU32(&x103, &x104, x102, x79, 0xf4372ddf); + var x105: u32 = undefined; + var x106: u1 = undefined; + subborrowxU32(&x105, &x106, x104, x81, 0xc7634d81); + var x107: u32 = undefined; + var x108: u1 = undefined; + subborrowxU32(&x107, &x108, x106, x83, 0xffffffff); + var x109: u32 = undefined; + var x110: u1 = undefined; + subborrowxU32(&x109, &x110, x108, x85, 0xffffffff); + var x111: u32 = undefined; + var x112: u1 = undefined; + subborrowxU32(&x111, &x112, x110, x87, 0xffffffff); + var x113: u32 = undefined; + var x114: u1 = undefined; + subborrowxU32(&x113, &x114, x112, x89, 0xffffffff); + var x115: u32 = undefined; + var x116: u1 = undefined; + subborrowxU32(&x115, &x116, x114, x91, 0xffffffff); + var x117: u32 = undefined; + var x118: u1 = undefined; + subborrowxU32(&x117, &x118, x116, x93, 0xffffffff); + var x119: u32 = undefined; + var x120: u1 = undefined; + subborrowxU32(&x119, &x120, x118, cast(u32, x94), cast(u32, 0x0)); + const x121 = (arg4[11]); + const x122 = (arg4[10]); + const x123 = (arg4[9]); + const x124 = (arg4[8]); + const x125 = (arg4[7]); + const x126 = (arg4[6]); + const x127 = (arg4[5]); + const x128 = (arg4[4]); + const x129 = (arg4[3]); + const x130 = (arg4[2]); + const x131 = (arg4[1]); + const x132 = (arg4[0]); + var x133: u32 = undefined; + var x134: u1 = undefined; + subborrowxU32(&x133, &x134, 0x0, cast(u32, 0x0), x132); + var x135: u32 = undefined; + var x136: u1 = undefined; + subborrowxU32(&x135, &x136, x134, cast(u32, 0x0), x131); + var x137: u32 = undefined; + var x138: u1 = undefined; + subborrowxU32(&x137, &x138, x136, cast(u32, 0x0), x130); + var x139: u32 = undefined; + var x140: u1 = undefined; + subborrowxU32(&x139, &x140, x138, cast(u32, 0x0), x129); + var x141: u32 = undefined; + var x142: u1 = undefined; + subborrowxU32(&x141, &x142, x140, cast(u32, 0x0), x128); + var x143: u32 = undefined; + var x144: u1 = undefined; + subborrowxU32(&x143, &x144, x142, cast(u32, 0x0), x127); + var x145: u32 = undefined; + var x146: u1 = undefined; + subborrowxU32(&x145, &x146, x144, cast(u32, 0x0), x126); + var x147: u32 = undefined; + var x148: u1 = undefined; + subborrowxU32(&x147, &x148, x146, cast(u32, 0x0), x125); + var x149: u32 = undefined; + var x150: u1 = undefined; + subborrowxU32(&x149, &x150, x148, cast(u32, 0x0), x124); + var x151: u32 = undefined; + var x152: u1 = undefined; + subborrowxU32(&x151, &x152, x150, cast(u32, 0x0), x123); + var x153: u32 = undefined; + var x154: u1 = undefined; + subborrowxU32(&x153, &x154, x152, cast(u32, 0x0), x122); + var x155: u32 = undefined; + var x156: u1 = undefined; + subborrowxU32(&x155, &x156, x154, cast(u32, 0x0), x121); + var x157: u32 = undefined; + cmovznzU32(&x157, x156, cast(u32, 0x0), 0xffffffff); + var x158: u32 = undefined; + var x159: u1 = undefined; + addcarryxU32(&x158, &x159, 0x0, x133, (x157 & 0xccc52973)); + var x160: u32 = undefined; + var x161: u1 = undefined; + addcarryxU32(&x160, &x161, x159, x135, (x157 & 0xecec196a)); + var x162: u32 = undefined; + var x163: u1 = undefined; + addcarryxU32(&x162, &x163, x161, x137, (x157 & 0x48b0a77a)); + var x164: u32 = undefined; + var x165: u1 = undefined; + addcarryxU32(&x164, &x165, x163, x139, (x157 & 0x581a0db2)); + var x166: u32 = undefined; + var x167: u1 = undefined; + addcarryxU32(&x166, &x167, x165, x141, (x157 & 0xf4372ddf)); + var x168: u32 = undefined; + var x169: u1 = undefined; + addcarryxU32(&x168, &x169, x167, x143, (x157 & 0xc7634d81)); + var x170: u32 = undefined; + var x171: u1 = undefined; + addcarryxU32(&x170, &x171, x169, x145, x157); + var x172: u32 = undefined; + var x173: u1 = undefined; + addcarryxU32(&x172, &x173, x171, x147, x157); + var x174: u32 = undefined; + var x175: u1 = undefined; + addcarryxU32(&x174, &x175, x173, x149, x157); + var x176: u32 = undefined; + var x177: u1 = undefined; + addcarryxU32(&x176, &x177, x175, x151, x157); + var x178: u32 = undefined; + var x179: u1 = undefined; + addcarryxU32(&x178, &x179, x177, x153, x157); + var x180: u32 = undefined; + var x181: u1 = undefined; + addcarryxU32(&x180, &x181, x179, x155, x157); + var x182: u32 = undefined; + cmovznzU32(&x182, x3, (arg5[0]), x158); + var x183: u32 = undefined; + cmovznzU32(&x183, x3, (arg5[1]), x160); + var x184: u32 = undefined; + cmovznzU32(&x184, x3, (arg5[2]), x162); + var x185: u32 = undefined; + cmovznzU32(&x185, x3, (arg5[3]), x164); + var x186: u32 = undefined; + cmovznzU32(&x186, x3, (arg5[4]), x166); + var x187: u32 = undefined; + cmovznzU32(&x187, x3, (arg5[5]), x168); + var x188: u32 = undefined; + cmovznzU32(&x188, x3, (arg5[6]), x170); + var x189: u32 = undefined; + cmovznzU32(&x189, x3, (arg5[7]), x172); + var x190: u32 = undefined; + cmovznzU32(&x190, x3, (arg5[8]), x174); + var x191: u32 = undefined; + cmovznzU32(&x191, x3, (arg5[9]), x176); + var x192: u32 = undefined; + cmovznzU32(&x192, x3, (arg5[10]), x178); + var x193: u32 = undefined; + cmovznzU32(&x193, x3, (arg5[11]), x180); + const x194 = cast(u1, (x46 & cast(u32, 0x1))); + var x195: u32 = undefined; + cmovznzU32(&x195, x194, cast(u32, 0x0), x7); + var x196: u32 = undefined; + cmovznzU32(&x196, x194, cast(u32, 0x0), x8); + var x197: u32 = undefined; + cmovznzU32(&x197, x194, cast(u32, 0x0), x9); + var x198: u32 = undefined; + cmovznzU32(&x198, x194, cast(u32, 0x0), x10); + var x199: u32 = undefined; + cmovznzU32(&x199, x194, cast(u32, 0x0), x11); + var x200: u32 = undefined; + cmovznzU32(&x200, x194, cast(u32, 0x0), x12); + var x201: u32 = undefined; + cmovznzU32(&x201, x194, cast(u32, 0x0), x13); + var x202: u32 = undefined; + cmovznzU32(&x202, x194, cast(u32, 0x0), x14); + var x203: u32 = undefined; + cmovznzU32(&x203, x194, cast(u32, 0x0), x15); + var x204: u32 = undefined; + cmovznzU32(&x204, x194, cast(u32, 0x0), x16); + var x205: u32 = undefined; + cmovznzU32(&x205, x194, cast(u32, 0x0), x17); + var x206: u32 = undefined; + cmovznzU32(&x206, x194, cast(u32, 0x0), x18); + var x207: u32 = undefined; + cmovznzU32(&x207, x194, cast(u32, 0x0), x19); + var x208: u32 = undefined; + var x209: u1 = undefined; + addcarryxU32(&x208, &x209, 0x0, x46, x195); + var x210: u32 = undefined; + var x211: u1 = undefined; + addcarryxU32(&x210, &x211, x209, x47, x196); + var x212: u32 = undefined; + var x213: u1 = undefined; + addcarryxU32(&x212, &x213, x211, x48, x197); + var x214: u32 = undefined; + var x215: u1 = undefined; + addcarryxU32(&x214, &x215, x213, x49, x198); + var x216: u32 = undefined; + var x217: u1 = undefined; + addcarryxU32(&x216, &x217, x215, x50, x199); + var x218: u32 = undefined; + var x219: u1 = undefined; + addcarryxU32(&x218, &x219, x217, x51, x200); + var x220: u32 = undefined; + var x221: u1 = undefined; + addcarryxU32(&x220, &x221, x219, x52, x201); + var x222: u32 = undefined; + var x223: u1 = undefined; + addcarryxU32(&x222, &x223, x221, x53, x202); + var x224: u32 = undefined; + var x225: u1 = undefined; + addcarryxU32(&x224, &x225, x223, x54, x203); + var x226: u32 = undefined; + var x227: u1 = undefined; + addcarryxU32(&x226, &x227, x225, x55, x204); + var x228: u32 = undefined; + var x229: u1 = undefined; + addcarryxU32(&x228, &x229, x227, x56, x205); + var x230: u32 = undefined; + var x231: u1 = undefined; + addcarryxU32(&x230, &x231, x229, x57, x206); + var x232: u32 = undefined; + var x233: u1 = undefined; + addcarryxU32(&x232, &x233, x231, x58, x207); + var x234: u32 = undefined; + cmovznzU32(&x234, x194, cast(u32, 0x0), x59); + var x235: u32 = undefined; + cmovznzU32(&x235, x194, cast(u32, 0x0), x60); + var x236: u32 = undefined; + cmovznzU32(&x236, x194, cast(u32, 0x0), x61); + var x237: u32 = undefined; + cmovznzU32(&x237, x194, cast(u32, 0x0), x62); + var x238: u32 = undefined; + cmovznzU32(&x238, x194, cast(u32, 0x0), x63); + var x239: u32 = undefined; + cmovznzU32(&x239, x194, cast(u32, 0x0), x64); + var x240: u32 = undefined; + cmovznzU32(&x240, x194, cast(u32, 0x0), x65); + var x241: u32 = undefined; + cmovznzU32(&x241, x194, cast(u32, 0x0), x66); + var x242: u32 = undefined; + cmovznzU32(&x242, x194, cast(u32, 0x0), x67); + var x243: u32 = undefined; + cmovznzU32(&x243, x194, cast(u32, 0x0), x68); + var x244: u32 = undefined; + cmovznzU32(&x244, x194, cast(u32, 0x0), x69); + var x245: u32 = undefined; + cmovznzU32(&x245, x194, cast(u32, 0x0), x70); + var x246: u32 = undefined; + var x247: u1 = undefined; + addcarryxU32(&x246, &x247, 0x0, x182, x234); + var x248: u32 = undefined; + var x249: u1 = undefined; + addcarryxU32(&x248, &x249, x247, x183, x235); + var x250: u32 = undefined; + var x251: u1 = undefined; + addcarryxU32(&x250, &x251, x249, x184, x236); + var x252: u32 = undefined; + var x253: u1 = undefined; + addcarryxU32(&x252, &x253, x251, x185, x237); + var x254: u32 = undefined; + var x255: u1 = undefined; + addcarryxU32(&x254, &x255, x253, x186, x238); + var x256: u32 = undefined; + var x257: u1 = undefined; + addcarryxU32(&x256, &x257, x255, x187, x239); + var x258: u32 = undefined; + var x259: u1 = undefined; + addcarryxU32(&x258, &x259, x257, x188, x240); + var x260: u32 = undefined; + var x261: u1 = undefined; + addcarryxU32(&x260, &x261, x259, x189, x241); + var x262: u32 = undefined; + var x263: u1 = undefined; + addcarryxU32(&x262, &x263, x261, x190, x242); + var x264: u32 = undefined; + var x265: u1 = undefined; + addcarryxU32(&x264, &x265, x263, x191, x243); + var x266: u32 = undefined; + var x267: u1 = undefined; + addcarryxU32(&x266, &x267, x265, x192, x244); + var x268: u32 = undefined; + var x269: u1 = undefined; + addcarryxU32(&x268, &x269, x267, x193, x245); + var x270: u32 = undefined; + var x271: u1 = undefined; + subborrowxU32(&x270, &x271, 0x0, x246, 0xccc52973); + var x272: u32 = undefined; + var x273: u1 = undefined; + subborrowxU32(&x272, &x273, x271, x248, 0xecec196a); + var x274: u32 = undefined; + var x275: u1 = undefined; + subborrowxU32(&x274, &x275, x273, x250, 0x48b0a77a); + var x276: u32 = undefined; + var x277: u1 = undefined; + subborrowxU32(&x276, &x277, x275, x252, 0x581a0db2); + var x278: u32 = undefined; + var x279: u1 = undefined; + subborrowxU32(&x278, &x279, x277, x254, 0xf4372ddf); + var x280: u32 = undefined; + var x281: u1 = undefined; + subborrowxU32(&x280, &x281, x279, x256, 0xc7634d81); + var x282: u32 = undefined; + var x283: u1 = undefined; + subborrowxU32(&x282, &x283, x281, x258, 0xffffffff); + var x284: u32 = undefined; + var x285: u1 = undefined; + subborrowxU32(&x284, &x285, x283, x260, 0xffffffff); + var x286: u32 = undefined; + var x287: u1 = undefined; + subborrowxU32(&x286, &x287, x285, x262, 0xffffffff); + var x288: u32 = undefined; + var x289: u1 = undefined; + subborrowxU32(&x288, &x289, x287, x264, 0xffffffff); + var x290: u32 = undefined; + var x291: u1 = undefined; + subborrowxU32(&x290, &x291, x289, x266, 0xffffffff); + var x292: u32 = undefined; + var x293: u1 = undefined; + subborrowxU32(&x292, &x293, x291, x268, 0xffffffff); + var x294: u32 = undefined; + var x295: u1 = undefined; + subborrowxU32(&x294, &x295, x293, cast(u32, x269), cast(u32, 0x0)); + var x296: u32 = undefined; + var x297: u1 = undefined; + addcarryxU32(&x296, &x297, 0x0, x6, cast(u32, 0x1)); + const x298 = ((x208 >> 1) | ((x210 << 31) & 0xffffffff)); + const x299 = ((x210 >> 1) | ((x212 << 31) & 0xffffffff)); + const x300 = ((x212 >> 1) | ((x214 << 31) & 0xffffffff)); + const x301 = ((x214 >> 1) | ((x216 << 31) & 0xffffffff)); + const x302 = ((x216 >> 1) | ((x218 << 31) & 0xffffffff)); + const x303 = ((x218 >> 1) | ((x220 << 31) & 0xffffffff)); + const x304 = ((x220 >> 1) | ((x222 << 31) & 0xffffffff)); + const x305 = ((x222 >> 1) | ((x224 << 31) & 0xffffffff)); + const x306 = ((x224 >> 1) | ((x226 << 31) & 0xffffffff)); + const x307 = ((x226 >> 1) | ((x228 << 31) & 0xffffffff)); + const x308 = ((x228 >> 1) | ((x230 << 31) & 0xffffffff)); + const x309 = ((x230 >> 1) | ((x232 << 31) & 0xffffffff)); + const x310 = ((x232 & 0x80000000) | (x232 >> 1)); + var x311: u32 = undefined; + cmovznzU32(&x311, x120, x95, x71); + var x312: u32 = undefined; + cmovznzU32(&x312, x120, x97, x73); + var x313: u32 = undefined; + cmovznzU32(&x313, x120, x99, x75); + var x314: u32 = undefined; + cmovznzU32(&x314, x120, x101, x77); + var x315: u32 = undefined; + cmovznzU32(&x315, x120, x103, x79); + var x316: u32 = undefined; + cmovznzU32(&x316, x120, x105, x81); + var x317: u32 = undefined; + cmovznzU32(&x317, x120, x107, x83); + var x318: u32 = undefined; + cmovznzU32(&x318, x120, x109, x85); + var x319: u32 = undefined; + cmovznzU32(&x319, x120, x111, x87); + var x320: u32 = undefined; + cmovznzU32(&x320, x120, x113, x89); + var x321: u32 = undefined; + cmovznzU32(&x321, x120, x115, x91); + var x322: u32 = undefined; + cmovznzU32(&x322, x120, x117, x93); + var x323: u32 = undefined; + cmovznzU32(&x323, x295, x270, x246); + var x324: u32 = undefined; + cmovznzU32(&x324, x295, x272, x248); + var x325: u32 = undefined; + cmovznzU32(&x325, x295, x274, x250); + var x326: u32 = undefined; + cmovznzU32(&x326, x295, x276, x252); + var x327: u32 = undefined; + cmovznzU32(&x327, x295, x278, x254); + var x328: u32 = undefined; + cmovznzU32(&x328, x295, x280, x256); + var x329: u32 = undefined; + cmovznzU32(&x329, x295, x282, x258); + var x330: u32 = undefined; + cmovznzU32(&x330, x295, x284, x260); + var x331: u32 = undefined; + cmovznzU32(&x331, x295, x286, x262); + var x332: u32 = undefined; + cmovznzU32(&x332, x295, x288, x264); + var x333: u32 = undefined; + cmovznzU32(&x333, x295, x290, x266); + var x334: u32 = undefined; + cmovznzU32(&x334, x295, x292, x268); + out1.* = x296; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out2[7] = x14; + out2[8] = x15; + out2[9] = x16; + out2[10] = x17; + out2[11] = x18; + out2[12] = x19; + out3[0] = x298; + out3[1] = x299; + out3[2] = x300; + out3[3] = x301; + out3[4] = x302; + out3[5] = x303; + out3[6] = x304; + out3[7] = x305; + out3[8] = x306; + out3[9] = x307; + out3[10] = x308; + out3[11] = x309; + out3[12] = x310; + out4[0] = x311; + out4[1] = x312; + out4[2] = x313; + out4[3] = x314; + out4[4] = x315; + out4[5] = x316; + out4[6] = x317; + out4[7] = x318; + out4[8] = x319; + out4[9] = x320; + out4[10] = x321; + out4[11] = x322; + out5[0] = x323; + out5[1] = x324; + out5[2] = x325; + out5[3] = x326; + out5[4] = x327; + out5[5] = x328; + out5[6] = x329; + out5[7] = x330; + out5[8] = x331; + out5[9] = x332; + out5[10] = x333; + out5[11] = x334; +} + +/// The function divstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn divstepPrecomp(out1: *[12]u32) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xe6045b6a; + out1[1] = 0x49589ae0; + out1[2] = 0x870040ed; + out1[3] = 0x3c9a5352; + out1[4] = 0x977dc242; + out1[5] = 0xdacb097e; + out1[6] = 0xd1ecbe36; + out1[7] = 0xb5ab30a6; + out1[8] = 0x1f959973; + out1[9] = 0x97d7a108; + out1[10] = 0xd27192bc; + out1[11] = 0x2ba012f8; +} diff --git a/fiat-zig/src/p384_scalar_64.zig b/fiat-zig/src/p384_scalar_64.zig new file mode 100644 index 0000000000..b3c0a4d5bb --- /dev/null +++ b/fiat-zig/src/p384_scalar_64.zig @@ -0,0 +1,3651 @@ +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Zig --internal-static --public-function-case camelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case UpperCamelCase --no-prefix-fiat --package-name p384_scalar '' 64 '2^384 - 1388124618062372383947042015309946732620727252194336364173' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// curve description (via package name): p384_scalar +// machine_wordsize = 64 (from "64") +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// m = 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973 (from "2^384 - 1388124618062372383947042015309946732620727252194336364173") +// +// NOTE: In addition to the bounds specified above each function, all +// functions synthesized for this Montgomery arithmetic require the +// input to be strictly less than the prime modulus (m), and also +// require the input to be in the unique saturated representation. +// All functions also ensure that these two properties are true of +// return values. +// +// Computed values: +// eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) +// twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) in +// if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384 + +const std = @import("std"); +const mode = @import("builtin").mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels + +inline fn cast(comptime DestType: type, target: anytype) DestType { + if (@typeInfo(@TypeOf(target)) == .Int) { + const dest = @typeInfo(DestType).Int; + const source = @typeInfo(@TypeOf(target)).Int; + if (dest.bits < source.bits) { + return @bitCast(DestType, @truncate(std.meta.Int(source.signedness, dest.bits), target)); + } else { + return @bitCast(DestType, @as(std.meta.Int(source.signedness, dest.bits), target)); + } + } + return @as(DestType, target); +} + +// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub const MontgomeryDomainFieldElement = [6]u64; + +// The type NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub const NonMontgomeryDomainFieldElement = [6]u64; + +/// The function addcarryxU64 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^64 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +inline fn addcarryxU64(out1: *u64, out2: *u1, arg1: u1, arg2: u64, arg3: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(u128, arg1) + cast(u128, arg2)) + cast(u128, arg3)); + const x2 = cast(u64, (x1 & cast(u128, 0xffffffffffffffff))); + const x3 = cast(u1, (x1 >> 64)); + out1.* = x2; + out2.* = x3; +} + +/// The function subborrowxU64 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^64 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +inline fn subborrowxU64(out1: *u64, out2: *u1, arg1: u1, arg2: u64, arg3: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(i128, arg2) - cast(i128, arg1)) - cast(i128, arg3)); + const x2 = cast(i1, (x1 >> 64)); + const x3 = cast(u64, (x1 & cast(i128, 0xffffffffffffffff))); + out1.* = x3; + out2.* = cast(u1, (cast(i2, 0x0) - cast(i2, x2))); +} + +/// The function mulxU64 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^64 +/// out2 = ⌊arg1 * arg2 / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0xffffffffffffffff] +inline fn mulxU64(out1: *u64, out2: *u64, arg1: u64, arg2: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u128, arg1) * cast(u128, arg2)); + const x2 = cast(u64, (x1 & cast(u128, 0xffffffffffffffff))); + const x3 = cast(u64, (x1 >> 64)); + out1.* = x2; + out2.* = x3; +} + +/// The function cmovznzU64 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +inline fn cmovznzU64(out1: *u64, arg1: u1, arg2: u64, arg3: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (~(~arg1)); + const x2 = cast(u64, (cast(i128, cast(i1, (cast(i2, 0x0) - cast(i2, x1)))) & cast(i128, 0xffffffffffffffff))); + const x3 = ((x2 & arg3) | ((~x2) & arg2)); + out1.* = x3; +} + +/// The function mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn mul(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[0]); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x6, (arg2[5])); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x6, (arg2[4])); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x6, (arg2[3])); + var x13: u64 = undefined; + var x14: u64 = undefined; + mulxU64(&x13, &x14, x6, (arg2[2])); + var x15: u64 = undefined; + var x16: u64 = undefined; + mulxU64(&x15, &x16, x6, (arg2[1])); + var x17: u64 = undefined; + var x18: u64 = undefined; + mulxU64(&x17, &x18, x6, (arg2[0])); + var x19: u64 = undefined; + var x20: u1 = undefined; + addcarryxU64(&x19, &x20, 0x0, x18, x15); + var x21: u64 = undefined; + var x22: u1 = undefined; + addcarryxU64(&x21, &x22, x20, x16, x13); + var x23: u64 = undefined; + var x24: u1 = undefined; + addcarryxU64(&x23, &x24, x22, x14, x11); + var x25: u64 = undefined; + var x26: u1 = undefined; + addcarryxU64(&x25, &x26, x24, x12, x9); + var x27: u64 = undefined; + var x28: u1 = undefined; + addcarryxU64(&x27, &x28, x26, x10, x7); + const x29 = (cast(u64, x28) + x8); + var x30: u64 = undefined; + var x31: u64 = undefined; + mulxU64(&x30, &x31, x17, 0x6ed46089e88fdc45); + var x32: u64 = undefined; + var x33: u64 = undefined; + mulxU64(&x32, &x33, x30, 0xffffffffffffffff); + var x34: u64 = undefined; + var x35: u64 = undefined; + mulxU64(&x34, &x35, x30, 0xffffffffffffffff); + var x36: u64 = undefined; + var x37: u64 = undefined; + mulxU64(&x36, &x37, x30, 0xffffffffffffffff); + var x38: u64 = undefined; + var x39: u64 = undefined; + mulxU64(&x38, &x39, x30, 0xc7634d81f4372ddf); + var x40: u64 = undefined; + var x41: u64 = undefined; + mulxU64(&x40, &x41, x30, 0x581a0db248b0a77a); + var x42: u64 = undefined; + var x43: u64 = undefined; + mulxU64(&x42, &x43, x30, 0xecec196accc52973); + var x44: u64 = undefined; + var x45: u1 = undefined; + addcarryxU64(&x44, &x45, 0x0, x43, x40); + var x46: u64 = undefined; + var x47: u1 = undefined; + addcarryxU64(&x46, &x47, x45, x41, x38); + var x48: u64 = undefined; + var x49: u1 = undefined; + addcarryxU64(&x48, &x49, x47, x39, x36); + var x50: u64 = undefined; + var x51: u1 = undefined; + addcarryxU64(&x50, &x51, x49, x37, x34); + var x52: u64 = undefined; + var x53: u1 = undefined; + addcarryxU64(&x52, &x53, x51, x35, x32); + const x54 = (cast(u64, x53) + x33); + var x55: u64 = undefined; + var x56: u1 = undefined; + addcarryxU64(&x55, &x56, 0x0, x17, x42); + var x57: u64 = undefined; + var x58: u1 = undefined; + addcarryxU64(&x57, &x58, x56, x19, x44); + var x59: u64 = undefined; + var x60: u1 = undefined; + addcarryxU64(&x59, &x60, x58, x21, x46); + var x61: u64 = undefined; + var x62: u1 = undefined; + addcarryxU64(&x61, &x62, x60, x23, x48); + var x63: u64 = undefined; + var x64: u1 = undefined; + addcarryxU64(&x63, &x64, x62, x25, x50); + var x65: u64 = undefined; + var x66: u1 = undefined; + addcarryxU64(&x65, &x66, x64, x27, x52); + var x67: u64 = undefined; + var x68: u1 = undefined; + addcarryxU64(&x67, &x68, x66, x29, x54); + var x69: u64 = undefined; + var x70: u64 = undefined; + mulxU64(&x69, &x70, x1, (arg2[5])); + var x71: u64 = undefined; + var x72: u64 = undefined; + mulxU64(&x71, &x72, x1, (arg2[4])); + var x73: u64 = undefined; + var x74: u64 = undefined; + mulxU64(&x73, &x74, x1, (arg2[3])); + var x75: u64 = undefined; + var x76: u64 = undefined; + mulxU64(&x75, &x76, x1, (arg2[2])); + var x77: u64 = undefined; + var x78: u64 = undefined; + mulxU64(&x77, &x78, x1, (arg2[1])); + var x79: u64 = undefined; + var x80: u64 = undefined; + mulxU64(&x79, &x80, x1, (arg2[0])); + var x81: u64 = undefined; + var x82: u1 = undefined; + addcarryxU64(&x81, &x82, 0x0, x80, x77); + var x83: u64 = undefined; + var x84: u1 = undefined; + addcarryxU64(&x83, &x84, x82, x78, x75); + var x85: u64 = undefined; + var x86: u1 = undefined; + addcarryxU64(&x85, &x86, x84, x76, x73); + var x87: u64 = undefined; + var x88: u1 = undefined; + addcarryxU64(&x87, &x88, x86, x74, x71); + var x89: u64 = undefined; + var x90: u1 = undefined; + addcarryxU64(&x89, &x90, x88, x72, x69); + const x91 = (cast(u64, x90) + x70); + var x92: u64 = undefined; + var x93: u1 = undefined; + addcarryxU64(&x92, &x93, 0x0, x57, x79); + var x94: u64 = undefined; + var x95: u1 = undefined; + addcarryxU64(&x94, &x95, x93, x59, x81); + var x96: u64 = undefined; + var x97: u1 = undefined; + addcarryxU64(&x96, &x97, x95, x61, x83); + var x98: u64 = undefined; + var x99: u1 = undefined; + addcarryxU64(&x98, &x99, x97, x63, x85); + var x100: u64 = undefined; + var x101: u1 = undefined; + addcarryxU64(&x100, &x101, x99, x65, x87); + var x102: u64 = undefined; + var x103: u1 = undefined; + addcarryxU64(&x102, &x103, x101, x67, x89); + var x104: u64 = undefined; + var x105: u1 = undefined; + addcarryxU64(&x104, &x105, x103, cast(u64, x68), x91); + var x106: u64 = undefined; + var x107: u64 = undefined; + mulxU64(&x106, &x107, x92, 0x6ed46089e88fdc45); + var x108: u64 = undefined; + var x109: u64 = undefined; + mulxU64(&x108, &x109, x106, 0xffffffffffffffff); + var x110: u64 = undefined; + var x111: u64 = undefined; + mulxU64(&x110, &x111, x106, 0xffffffffffffffff); + var x112: u64 = undefined; + var x113: u64 = undefined; + mulxU64(&x112, &x113, x106, 0xffffffffffffffff); + var x114: u64 = undefined; + var x115: u64 = undefined; + mulxU64(&x114, &x115, x106, 0xc7634d81f4372ddf); + var x116: u64 = undefined; + var x117: u64 = undefined; + mulxU64(&x116, &x117, x106, 0x581a0db248b0a77a); + var x118: u64 = undefined; + var x119: u64 = undefined; + mulxU64(&x118, &x119, x106, 0xecec196accc52973); + var x120: u64 = undefined; + var x121: u1 = undefined; + addcarryxU64(&x120, &x121, 0x0, x119, x116); + var x122: u64 = undefined; + var x123: u1 = undefined; + addcarryxU64(&x122, &x123, x121, x117, x114); + var x124: u64 = undefined; + var x125: u1 = undefined; + addcarryxU64(&x124, &x125, x123, x115, x112); + var x126: u64 = undefined; + var x127: u1 = undefined; + addcarryxU64(&x126, &x127, x125, x113, x110); + var x128: u64 = undefined; + var x129: u1 = undefined; + addcarryxU64(&x128, &x129, x127, x111, x108); + const x130 = (cast(u64, x129) + x109); + var x131: u64 = undefined; + var x132: u1 = undefined; + addcarryxU64(&x131, &x132, 0x0, x92, x118); + var x133: u64 = undefined; + var x134: u1 = undefined; + addcarryxU64(&x133, &x134, x132, x94, x120); + var x135: u64 = undefined; + var x136: u1 = undefined; + addcarryxU64(&x135, &x136, x134, x96, x122); + var x137: u64 = undefined; + var x138: u1 = undefined; + addcarryxU64(&x137, &x138, x136, x98, x124); + var x139: u64 = undefined; + var x140: u1 = undefined; + addcarryxU64(&x139, &x140, x138, x100, x126); + var x141: u64 = undefined; + var x142: u1 = undefined; + addcarryxU64(&x141, &x142, x140, x102, x128); + var x143: u64 = undefined; + var x144: u1 = undefined; + addcarryxU64(&x143, &x144, x142, x104, x130); + const x145 = (cast(u64, x144) + cast(u64, x105)); + var x146: u64 = undefined; + var x147: u64 = undefined; + mulxU64(&x146, &x147, x2, (arg2[5])); + var x148: u64 = undefined; + var x149: u64 = undefined; + mulxU64(&x148, &x149, x2, (arg2[4])); + var x150: u64 = undefined; + var x151: u64 = undefined; + mulxU64(&x150, &x151, x2, (arg2[3])); + var x152: u64 = undefined; + var x153: u64 = undefined; + mulxU64(&x152, &x153, x2, (arg2[2])); + var x154: u64 = undefined; + var x155: u64 = undefined; + mulxU64(&x154, &x155, x2, (arg2[1])); + var x156: u64 = undefined; + var x157: u64 = undefined; + mulxU64(&x156, &x157, x2, (arg2[0])); + var x158: u64 = undefined; + var x159: u1 = undefined; + addcarryxU64(&x158, &x159, 0x0, x157, x154); + var x160: u64 = undefined; + var x161: u1 = undefined; + addcarryxU64(&x160, &x161, x159, x155, x152); + var x162: u64 = undefined; + var x163: u1 = undefined; + addcarryxU64(&x162, &x163, x161, x153, x150); + var x164: u64 = undefined; + var x165: u1 = undefined; + addcarryxU64(&x164, &x165, x163, x151, x148); + var x166: u64 = undefined; + var x167: u1 = undefined; + addcarryxU64(&x166, &x167, x165, x149, x146); + const x168 = (cast(u64, x167) + x147); + var x169: u64 = undefined; + var x170: u1 = undefined; + addcarryxU64(&x169, &x170, 0x0, x133, x156); + var x171: u64 = undefined; + var x172: u1 = undefined; + addcarryxU64(&x171, &x172, x170, x135, x158); + var x173: u64 = undefined; + var x174: u1 = undefined; + addcarryxU64(&x173, &x174, x172, x137, x160); + var x175: u64 = undefined; + var x176: u1 = undefined; + addcarryxU64(&x175, &x176, x174, x139, x162); + var x177: u64 = undefined; + var x178: u1 = undefined; + addcarryxU64(&x177, &x178, x176, x141, x164); + var x179: u64 = undefined; + var x180: u1 = undefined; + addcarryxU64(&x179, &x180, x178, x143, x166); + var x181: u64 = undefined; + var x182: u1 = undefined; + addcarryxU64(&x181, &x182, x180, x145, x168); + var x183: u64 = undefined; + var x184: u64 = undefined; + mulxU64(&x183, &x184, x169, 0x6ed46089e88fdc45); + var x185: u64 = undefined; + var x186: u64 = undefined; + mulxU64(&x185, &x186, x183, 0xffffffffffffffff); + var x187: u64 = undefined; + var x188: u64 = undefined; + mulxU64(&x187, &x188, x183, 0xffffffffffffffff); + var x189: u64 = undefined; + var x190: u64 = undefined; + mulxU64(&x189, &x190, x183, 0xffffffffffffffff); + var x191: u64 = undefined; + var x192: u64 = undefined; + mulxU64(&x191, &x192, x183, 0xc7634d81f4372ddf); + var x193: u64 = undefined; + var x194: u64 = undefined; + mulxU64(&x193, &x194, x183, 0x581a0db248b0a77a); + var x195: u64 = undefined; + var x196: u64 = undefined; + mulxU64(&x195, &x196, x183, 0xecec196accc52973); + var x197: u64 = undefined; + var x198: u1 = undefined; + addcarryxU64(&x197, &x198, 0x0, x196, x193); + var x199: u64 = undefined; + var x200: u1 = undefined; + addcarryxU64(&x199, &x200, x198, x194, x191); + var x201: u64 = undefined; + var x202: u1 = undefined; + addcarryxU64(&x201, &x202, x200, x192, x189); + var x203: u64 = undefined; + var x204: u1 = undefined; + addcarryxU64(&x203, &x204, x202, x190, x187); + var x205: u64 = undefined; + var x206: u1 = undefined; + addcarryxU64(&x205, &x206, x204, x188, x185); + const x207 = (cast(u64, x206) + x186); + var x208: u64 = undefined; + var x209: u1 = undefined; + addcarryxU64(&x208, &x209, 0x0, x169, x195); + var x210: u64 = undefined; + var x211: u1 = undefined; + addcarryxU64(&x210, &x211, x209, x171, x197); + var x212: u64 = undefined; + var x213: u1 = undefined; + addcarryxU64(&x212, &x213, x211, x173, x199); + var x214: u64 = undefined; + var x215: u1 = undefined; + addcarryxU64(&x214, &x215, x213, x175, x201); + var x216: u64 = undefined; + var x217: u1 = undefined; + addcarryxU64(&x216, &x217, x215, x177, x203); + var x218: u64 = undefined; + var x219: u1 = undefined; + addcarryxU64(&x218, &x219, x217, x179, x205); + var x220: u64 = undefined; + var x221: u1 = undefined; + addcarryxU64(&x220, &x221, x219, x181, x207); + const x222 = (cast(u64, x221) + cast(u64, x182)); + var x223: u64 = undefined; + var x224: u64 = undefined; + mulxU64(&x223, &x224, x3, (arg2[5])); + var x225: u64 = undefined; + var x226: u64 = undefined; + mulxU64(&x225, &x226, x3, (arg2[4])); + var x227: u64 = undefined; + var x228: u64 = undefined; + mulxU64(&x227, &x228, x3, (arg2[3])); + var x229: u64 = undefined; + var x230: u64 = undefined; + mulxU64(&x229, &x230, x3, (arg2[2])); + var x231: u64 = undefined; + var x232: u64 = undefined; + mulxU64(&x231, &x232, x3, (arg2[1])); + var x233: u64 = undefined; + var x234: u64 = undefined; + mulxU64(&x233, &x234, x3, (arg2[0])); + var x235: u64 = undefined; + var x236: u1 = undefined; + addcarryxU64(&x235, &x236, 0x0, x234, x231); + var x237: u64 = undefined; + var x238: u1 = undefined; + addcarryxU64(&x237, &x238, x236, x232, x229); + var x239: u64 = undefined; + var x240: u1 = undefined; + addcarryxU64(&x239, &x240, x238, x230, x227); + var x241: u64 = undefined; + var x242: u1 = undefined; + addcarryxU64(&x241, &x242, x240, x228, x225); + var x243: u64 = undefined; + var x244: u1 = undefined; + addcarryxU64(&x243, &x244, x242, x226, x223); + const x245 = (cast(u64, x244) + x224); + var x246: u64 = undefined; + var x247: u1 = undefined; + addcarryxU64(&x246, &x247, 0x0, x210, x233); + var x248: u64 = undefined; + var x249: u1 = undefined; + addcarryxU64(&x248, &x249, x247, x212, x235); + var x250: u64 = undefined; + var x251: u1 = undefined; + addcarryxU64(&x250, &x251, x249, x214, x237); + var x252: u64 = undefined; + var x253: u1 = undefined; + addcarryxU64(&x252, &x253, x251, x216, x239); + var x254: u64 = undefined; + var x255: u1 = undefined; + addcarryxU64(&x254, &x255, x253, x218, x241); + var x256: u64 = undefined; + var x257: u1 = undefined; + addcarryxU64(&x256, &x257, x255, x220, x243); + var x258: u64 = undefined; + var x259: u1 = undefined; + addcarryxU64(&x258, &x259, x257, x222, x245); + var x260: u64 = undefined; + var x261: u64 = undefined; + mulxU64(&x260, &x261, x246, 0x6ed46089e88fdc45); + var x262: u64 = undefined; + var x263: u64 = undefined; + mulxU64(&x262, &x263, x260, 0xffffffffffffffff); + var x264: u64 = undefined; + var x265: u64 = undefined; + mulxU64(&x264, &x265, x260, 0xffffffffffffffff); + var x266: u64 = undefined; + var x267: u64 = undefined; + mulxU64(&x266, &x267, x260, 0xffffffffffffffff); + var x268: u64 = undefined; + var x269: u64 = undefined; + mulxU64(&x268, &x269, x260, 0xc7634d81f4372ddf); + var x270: u64 = undefined; + var x271: u64 = undefined; + mulxU64(&x270, &x271, x260, 0x581a0db248b0a77a); + var x272: u64 = undefined; + var x273: u64 = undefined; + mulxU64(&x272, &x273, x260, 0xecec196accc52973); + var x274: u64 = undefined; + var x275: u1 = undefined; + addcarryxU64(&x274, &x275, 0x0, x273, x270); + var x276: u64 = undefined; + var x277: u1 = undefined; + addcarryxU64(&x276, &x277, x275, x271, x268); + var x278: u64 = undefined; + var x279: u1 = undefined; + addcarryxU64(&x278, &x279, x277, x269, x266); + var x280: u64 = undefined; + var x281: u1 = undefined; + addcarryxU64(&x280, &x281, x279, x267, x264); + var x282: u64 = undefined; + var x283: u1 = undefined; + addcarryxU64(&x282, &x283, x281, x265, x262); + const x284 = (cast(u64, x283) + x263); + var x285: u64 = undefined; + var x286: u1 = undefined; + addcarryxU64(&x285, &x286, 0x0, x246, x272); + var x287: u64 = undefined; + var x288: u1 = undefined; + addcarryxU64(&x287, &x288, x286, x248, x274); + var x289: u64 = undefined; + var x290: u1 = undefined; + addcarryxU64(&x289, &x290, x288, x250, x276); + var x291: u64 = undefined; + var x292: u1 = undefined; + addcarryxU64(&x291, &x292, x290, x252, x278); + var x293: u64 = undefined; + var x294: u1 = undefined; + addcarryxU64(&x293, &x294, x292, x254, x280); + var x295: u64 = undefined; + var x296: u1 = undefined; + addcarryxU64(&x295, &x296, x294, x256, x282); + var x297: u64 = undefined; + var x298: u1 = undefined; + addcarryxU64(&x297, &x298, x296, x258, x284); + const x299 = (cast(u64, x298) + cast(u64, x259)); + var x300: u64 = undefined; + var x301: u64 = undefined; + mulxU64(&x300, &x301, x4, (arg2[5])); + var x302: u64 = undefined; + var x303: u64 = undefined; + mulxU64(&x302, &x303, x4, (arg2[4])); + var x304: u64 = undefined; + var x305: u64 = undefined; + mulxU64(&x304, &x305, x4, (arg2[3])); + var x306: u64 = undefined; + var x307: u64 = undefined; + mulxU64(&x306, &x307, x4, (arg2[2])); + var x308: u64 = undefined; + var x309: u64 = undefined; + mulxU64(&x308, &x309, x4, (arg2[1])); + var x310: u64 = undefined; + var x311: u64 = undefined; + mulxU64(&x310, &x311, x4, (arg2[0])); + var x312: u64 = undefined; + var x313: u1 = undefined; + addcarryxU64(&x312, &x313, 0x0, x311, x308); + var x314: u64 = undefined; + var x315: u1 = undefined; + addcarryxU64(&x314, &x315, x313, x309, x306); + var x316: u64 = undefined; + var x317: u1 = undefined; + addcarryxU64(&x316, &x317, x315, x307, x304); + var x318: u64 = undefined; + var x319: u1 = undefined; + addcarryxU64(&x318, &x319, x317, x305, x302); + var x320: u64 = undefined; + var x321: u1 = undefined; + addcarryxU64(&x320, &x321, x319, x303, x300); + const x322 = (cast(u64, x321) + x301); + var x323: u64 = undefined; + var x324: u1 = undefined; + addcarryxU64(&x323, &x324, 0x0, x287, x310); + var x325: u64 = undefined; + var x326: u1 = undefined; + addcarryxU64(&x325, &x326, x324, x289, x312); + var x327: u64 = undefined; + var x328: u1 = undefined; + addcarryxU64(&x327, &x328, x326, x291, x314); + var x329: u64 = undefined; + var x330: u1 = undefined; + addcarryxU64(&x329, &x330, x328, x293, x316); + var x331: u64 = undefined; + var x332: u1 = undefined; + addcarryxU64(&x331, &x332, x330, x295, x318); + var x333: u64 = undefined; + var x334: u1 = undefined; + addcarryxU64(&x333, &x334, x332, x297, x320); + var x335: u64 = undefined; + var x336: u1 = undefined; + addcarryxU64(&x335, &x336, x334, x299, x322); + var x337: u64 = undefined; + var x338: u64 = undefined; + mulxU64(&x337, &x338, x323, 0x6ed46089e88fdc45); + var x339: u64 = undefined; + var x340: u64 = undefined; + mulxU64(&x339, &x340, x337, 0xffffffffffffffff); + var x341: u64 = undefined; + var x342: u64 = undefined; + mulxU64(&x341, &x342, x337, 0xffffffffffffffff); + var x343: u64 = undefined; + var x344: u64 = undefined; + mulxU64(&x343, &x344, x337, 0xffffffffffffffff); + var x345: u64 = undefined; + var x346: u64 = undefined; + mulxU64(&x345, &x346, x337, 0xc7634d81f4372ddf); + var x347: u64 = undefined; + var x348: u64 = undefined; + mulxU64(&x347, &x348, x337, 0x581a0db248b0a77a); + var x349: u64 = undefined; + var x350: u64 = undefined; + mulxU64(&x349, &x350, x337, 0xecec196accc52973); + var x351: u64 = undefined; + var x352: u1 = undefined; + addcarryxU64(&x351, &x352, 0x0, x350, x347); + var x353: u64 = undefined; + var x354: u1 = undefined; + addcarryxU64(&x353, &x354, x352, x348, x345); + var x355: u64 = undefined; + var x356: u1 = undefined; + addcarryxU64(&x355, &x356, x354, x346, x343); + var x357: u64 = undefined; + var x358: u1 = undefined; + addcarryxU64(&x357, &x358, x356, x344, x341); + var x359: u64 = undefined; + var x360: u1 = undefined; + addcarryxU64(&x359, &x360, x358, x342, x339); + const x361 = (cast(u64, x360) + x340); + var x362: u64 = undefined; + var x363: u1 = undefined; + addcarryxU64(&x362, &x363, 0x0, x323, x349); + var x364: u64 = undefined; + var x365: u1 = undefined; + addcarryxU64(&x364, &x365, x363, x325, x351); + var x366: u64 = undefined; + var x367: u1 = undefined; + addcarryxU64(&x366, &x367, x365, x327, x353); + var x368: u64 = undefined; + var x369: u1 = undefined; + addcarryxU64(&x368, &x369, x367, x329, x355); + var x370: u64 = undefined; + var x371: u1 = undefined; + addcarryxU64(&x370, &x371, x369, x331, x357); + var x372: u64 = undefined; + var x373: u1 = undefined; + addcarryxU64(&x372, &x373, x371, x333, x359); + var x374: u64 = undefined; + var x375: u1 = undefined; + addcarryxU64(&x374, &x375, x373, x335, x361); + const x376 = (cast(u64, x375) + cast(u64, x336)); + var x377: u64 = undefined; + var x378: u64 = undefined; + mulxU64(&x377, &x378, x5, (arg2[5])); + var x379: u64 = undefined; + var x380: u64 = undefined; + mulxU64(&x379, &x380, x5, (arg2[4])); + var x381: u64 = undefined; + var x382: u64 = undefined; + mulxU64(&x381, &x382, x5, (arg2[3])); + var x383: u64 = undefined; + var x384: u64 = undefined; + mulxU64(&x383, &x384, x5, (arg2[2])); + var x385: u64 = undefined; + var x386: u64 = undefined; + mulxU64(&x385, &x386, x5, (arg2[1])); + var x387: u64 = undefined; + var x388: u64 = undefined; + mulxU64(&x387, &x388, x5, (arg2[0])); + var x389: u64 = undefined; + var x390: u1 = undefined; + addcarryxU64(&x389, &x390, 0x0, x388, x385); + var x391: u64 = undefined; + var x392: u1 = undefined; + addcarryxU64(&x391, &x392, x390, x386, x383); + var x393: u64 = undefined; + var x394: u1 = undefined; + addcarryxU64(&x393, &x394, x392, x384, x381); + var x395: u64 = undefined; + var x396: u1 = undefined; + addcarryxU64(&x395, &x396, x394, x382, x379); + var x397: u64 = undefined; + var x398: u1 = undefined; + addcarryxU64(&x397, &x398, x396, x380, x377); + const x399 = (cast(u64, x398) + x378); + var x400: u64 = undefined; + var x401: u1 = undefined; + addcarryxU64(&x400, &x401, 0x0, x364, x387); + var x402: u64 = undefined; + var x403: u1 = undefined; + addcarryxU64(&x402, &x403, x401, x366, x389); + var x404: u64 = undefined; + var x405: u1 = undefined; + addcarryxU64(&x404, &x405, x403, x368, x391); + var x406: u64 = undefined; + var x407: u1 = undefined; + addcarryxU64(&x406, &x407, x405, x370, x393); + var x408: u64 = undefined; + var x409: u1 = undefined; + addcarryxU64(&x408, &x409, x407, x372, x395); + var x410: u64 = undefined; + var x411: u1 = undefined; + addcarryxU64(&x410, &x411, x409, x374, x397); + var x412: u64 = undefined; + var x413: u1 = undefined; + addcarryxU64(&x412, &x413, x411, x376, x399); + var x414: u64 = undefined; + var x415: u64 = undefined; + mulxU64(&x414, &x415, x400, 0x6ed46089e88fdc45); + var x416: u64 = undefined; + var x417: u64 = undefined; + mulxU64(&x416, &x417, x414, 0xffffffffffffffff); + var x418: u64 = undefined; + var x419: u64 = undefined; + mulxU64(&x418, &x419, x414, 0xffffffffffffffff); + var x420: u64 = undefined; + var x421: u64 = undefined; + mulxU64(&x420, &x421, x414, 0xffffffffffffffff); + var x422: u64 = undefined; + var x423: u64 = undefined; + mulxU64(&x422, &x423, x414, 0xc7634d81f4372ddf); + var x424: u64 = undefined; + var x425: u64 = undefined; + mulxU64(&x424, &x425, x414, 0x581a0db248b0a77a); + var x426: u64 = undefined; + var x427: u64 = undefined; + mulxU64(&x426, &x427, x414, 0xecec196accc52973); + var x428: u64 = undefined; + var x429: u1 = undefined; + addcarryxU64(&x428, &x429, 0x0, x427, x424); + var x430: u64 = undefined; + var x431: u1 = undefined; + addcarryxU64(&x430, &x431, x429, x425, x422); + var x432: u64 = undefined; + var x433: u1 = undefined; + addcarryxU64(&x432, &x433, x431, x423, x420); + var x434: u64 = undefined; + var x435: u1 = undefined; + addcarryxU64(&x434, &x435, x433, x421, x418); + var x436: u64 = undefined; + var x437: u1 = undefined; + addcarryxU64(&x436, &x437, x435, x419, x416); + const x438 = (cast(u64, x437) + x417); + var x439: u64 = undefined; + var x440: u1 = undefined; + addcarryxU64(&x439, &x440, 0x0, x400, x426); + var x441: u64 = undefined; + var x442: u1 = undefined; + addcarryxU64(&x441, &x442, x440, x402, x428); + var x443: u64 = undefined; + var x444: u1 = undefined; + addcarryxU64(&x443, &x444, x442, x404, x430); + var x445: u64 = undefined; + var x446: u1 = undefined; + addcarryxU64(&x445, &x446, x444, x406, x432); + var x447: u64 = undefined; + var x448: u1 = undefined; + addcarryxU64(&x447, &x448, x446, x408, x434); + var x449: u64 = undefined; + var x450: u1 = undefined; + addcarryxU64(&x449, &x450, x448, x410, x436); + var x451: u64 = undefined; + var x452: u1 = undefined; + addcarryxU64(&x451, &x452, x450, x412, x438); + const x453 = (cast(u64, x452) + cast(u64, x413)); + var x454: u64 = undefined; + var x455: u1 = undefined; + subborrowxU64(&x454, &x455, 0x0, x441, 0xecec196accc52973); + var x456: u64 = undefined; + var x457: u1 = undefined; + subborrowxU64(&x456, &x457, x455, x443, 0x581a0db248b0a77a); + var x458: u64 = undefined; + var x459: u1 = undefined; + subborrowxU64(&x458, &x459, x457, x445, 0xc7634d81f4372ddf); + var x460: u64 = undefined; + var x461: u1 = undefined; + subborrowxU64(&x460, &x461, x459, x447, 0xffffffffffffffff); + var x462: u64 = undefined; + var x463: u1 = undefined; + subborrowxU64(&x462, &x463, x461, x449, 0xffffffffffffffff); + var x464: u64 = undefined; + var x465: u1 = undefined; + subborrowxU64(&x464, &x465, x463, x451, 0xffffffffffffffff); + var x466: u64 = undefined; + var x467: u1 = undefined; + subborrowxU64(&x466, &x467, x465, x453, cast(u64, 0x0)); + var x468: u64 = undefined; + cmovznzU64(&x468, x467, x454, x441); + var x469: u64 = undefined; + cmovznzU64(&x469, x467, x456, x443); + var x470: u64 = undefined; + cmovznzU64(&x470, x467, x458, x445); + var x471: u64 = undefined; + cmovznzU64(&x471, x467, x460, x447); + var x472: u64 = undefined; + cmovznzU64(&x472, x467, x462, x449); + var x473: u64 = undefined; + cmovznzU64(&x473, x467, x464, x451); + out1[0] = x468; + out1[1] = x469; + out1[2] = x470; + out1[3] = x471; + out1[4] = x472; + out1[5] = x473; +} + +/// The function square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn square(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[0]); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x6, (arg1[5])); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x6, (arg1[4])); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x6, (arg1[3])); + var x13: u64 = undefined; + var x14: u64 = undefined; + mulxU64(&x13, &x14, x6, (arg1[2])); + var x15: u64 = undefined; + var x16: u64 = undefined; + mulxU64(&x15, &x16, x6, (arg1[1])); + var x17: u64 = undefined; + var x18: u64 = undefined; + mulxU64(&x17, &x18, x6, (arg1[0])); + var x19: u64 = undefined; + var x20: u1 = undefined; + addcarryxU64(&x19, &x20, 0x0, x18, x15); + var x21: u64 = undefined; + var x22: u1 = undefined; + addcarryxU64(&x21, &x22, x20, x16, x13); + var x23: u64 = undefined; + var x24: u1 = undefined; + addcarryxU64(&x23, &x24, x22, x14, x11); + var x25: u64 = undefined; + var x26: u1 = undefined; + addcarryxU64(&x25, &x26, x24, x12, x9); + var x27: u64 = undefined; + var x28: u1 = undefined; + addcarryxU64(&x27, &x28, x26, x10, x7); + const x29 = (cast(u64, x28) + x8); + var x30: u64 = undefined; + var x31: u64 = undefined; + mulxU64(&x30, &x31, x17, 0x6ed46089e88fdc45); + var x32: u64 = undefined; + var x33: u64 = undefined; + mulxU64(&x32, &x33, x30, 0xffffffffffffffff); + var x34: u64 = undefined; + var x35: u64 = undefined; + mulxU64(&x34, &x35, x30, 0xffffffffffffffff); + var x36: u64 = undefined; + var x37: u64 = undefined; + mulxU64(&x36, &x37, x30, 0xffffffffffffffff); + var x38: u64 = undefined; + var x39: u64 = undefined; + mulxU64(&x38, &x39, x30, 0xc7634d81f4372ddf); + var x40: u64 = undefined; + var x41: u64 = undefined; + mulxU64(&x40, &x41, x30, 0x581a0db248b0a77a); + var x42: u64 = undefined; + var x43: u64 = undefined; + mulxU64(&x42, &x43, x30, 0xecec196accc52973); + var x44: u64 = undefined; + var x45: u1 = undefined; + addcarryxU64(&x44, &x45, 0x0, x43, x40); + var x46: u64 = undefined; + var x47: u1 = undefined; + addcarryxU64(&x46, &x47, x45, x41, x38); + var x48: u64 = undefined; + var x49: u1 = undefined; + addcarryxU64(&x48, &x49, x47, x39, x36); + var x50: u64 = undefined; + var x51: u1 = undefined; + addcarryxU64(&x50, &x51, x49, x37, x34); + var x52: u64 = undefined; + var x53: u1 = undefined; + addcarryxU64(&x52, &x53, x51, x35, x32); + const x54 = (cast(u64, x53) + x33); + var x55: u64 = undefined; + var x56: u1 = undefined; + addcarryxU64(&x55, &x56, 0x0, x17, x42); + var x57: u64 = undefined; + var x58: u1 = undefined; + addcarryxU64(&x57, &x58, x56, x19, x44); + var x59: u64 = undefined; + var x60: u1 = undefined; + addcarryxU64(&x59, &x60, x58, x21, x46); + var x61: u64 = undefined; + var x62: u1 = undefined; + addcarryxU64(&x61, &x62, x60, x23, x48); + var x63: u64 = undefined; + var x64: u1 = undefined; + addcarryxU64(&x63, &x64, x62, x25, x50); + var x65: u64 = undefined; + var x66: u1 = undefined; + addcarryxU64(&x65, &x66, x64, x27, x52); + var x67: u64 = undefined; + var x68: u1 = undefined; + addcarryxU64(&x67, &x68, x66, x29, x54); + var x69: u64 = undefined; + var x70: u64 = undefined; + mulxU64(&x69, &x70, x1, (arg1[5])); + var x71: u64 = undefined; + var x72: u64 = undefined; + mulxU64(&x71, &x72, x1, (arg1[4])); + var x73: u64 = undefined; + var x74: u64 = undefined; + mulxU64(&x73, &x74, x1, (arg1[3])); + var x75: u64 = undefined; + var x76: u64 = undefined; + mulxU64(&x75, &x76, x1, (arg1[2])); + var x77: u64 = undefined; + var x78: u64 = undefined; + mulxU64(&x77, &x78, x1, (arg1[1])); + var x79: u64 = undefined; + var x80: u64 = undefined; + mulxU64(&x79, &x80, x1, (arg1[0])); + var x81: u64 = undefined; + var x82: u1 = undefined; + addcarryxU64(&x81, &x82, 0x0, x80, x77); + var x83: u64 = undefined; + var x84: u1 = undefined; + addcarryxU64(&x83, &x84, x82, x78, x75); + var x85: u64 = undefined; + var x86: u1 = undefined; + addcarryxU64(&x85, &x86, x84, x76, x73); + var x87: u64 = undefined; + var x88: u1 = undefined; + addcarryxU64(&x87, &x88, x86, x74, x71); + var x89: u64 = undefined; + var x90: u1 = undefined; + addcarryxU64(&x89, &x90, x88, x72, x69); + const x91 = (cast(u64, x90) + x70); + var x92: u64 = undefined; + var x93: u1 = undefined; + addcarryxU64(&x92, &x93, 0x0, x57, x79); + var x94: u64 = undefined; + var x95: u1 = undefined; + addcarryxU64(&x94, &x95, x93, x59, x81); + var x96: u64 = undefined; + var x97: u1 = undefined; + addcarryxU64(&x96, &x97, x95, x61, x83); + var x98: u64 = undefined; + var x99: u1 = undefined; + addcarryxU64(&x98, &x99, x97, x63, x85); + var x100: u64 = undefined; + var x101: u1 = undefined; + addcarryxU64(&x100, &x101, x99, x65, x87); + var x102: u64 = undefined; + var x103: u1 = undefined; + addcarryxU64(&x102, &x103, x101, x67, x89); + var x104: u64 = undefined; + var x105: u1 = undefined; + addcarryxU64(&x104, &x105, x103, cast(u64, x68), x91); + var x106: u64 = undefined; + var x107: u64 = undefined; + mulxU64(&x106, &x107, x92, 0x6ed46089e88fdc45); + var x108: u64 = undefined; + var x109: u64 = undefined; + mulxU64(&x108, &x109, x106, 0xffffffffffffffff); + var x110: u64 = undefined; + var x111: u64 = undefined; + mulxU64(&x110, &x111, x106, 0xffffffffffffffff); + var x112: u64 = undefined; + var x113: u64 = undefined; + mulxU64(&x112, &x113, x106, 0xffffffffffffffff); + var x114: u64 = undefined; + var x115: u64 = undefined; + mulxU64(&x114, &x115, x106, 0xc7634d81f4372ddf); + var x116: u64 = undefined; + var x117: u64 = undefined; + mulxU64(&x116, &x117, x106, 0x581a0db248b0a77a); + var x118: u64 = undefined; + var x119: u64 = undefined; + mulxU64(&x118, &x119, x106, 0xecec196accc52973); + var x120: u64 = undefined; + var x121: u1 = undefined; + addcarryxU64(&x120, &x121, 0x0, x119, x116); + var x122: u64 = undefined; + var x123: u1 = undefined; + addcarryxU64(&x122, &x123, x121, x117, x114); + var x124: u64 = undefined; + var x125: u1 = undefined; + addcarryxU64(&x124, &x125, x123, x115, x112); + var x126: u64 = undefined; + var x127: u1 = undefined; + addcarryxU64(&x126, &x127, x125, x113, x110); + var x128: u64 = undefined; + var x129: u1 = undefined; + addcarryxU64(&x128, &x129, x127, x111, x108); + const x130 = (cast(u64, x129) + x109); + var x131: u64 = undefined; + var x132: u1 = undefined; + addcarryxU64(&x131, &x132, 0x0, x92, x118); + var x133: u64 = undefined; + var x134: u1 = undefined; + addcarryxU64(&x133, &x134, x132, x94, x120); + var x135: u64 = undefined; + var x136: u1 = undefined; + addcarryxU64(&x135, &x136, x134, x96, x122); + var x137: u64 = undefined; + var x138: u1 = undefined; + addcarryxU64(&x137, &x138, x136, x98, x124); + var x139: u64 = undefined; + var x140: u1 = undefined; + addcarryxU64(&x139, &x140, x138, x100, x126); + var x141: u64 = undefined; + var x142: u1 = undefined; + addcarryxU64(&x141, &x142, x140, x102, x128); + var x143: u64 = undefined; + var x144: u1 = undefined; + addcarryxU64(&x143, &x144, x142, x104, x130); + const x145 = (cast(u64, x144) + cast(u64, x105)); + var x146: u64 = undefined; + var x147: u64 = undefined; + mulxU64(&x146, &x147, x2, (arg1[5])); + var x148: u64 = undefined; + var x149: u64 = undefined; + mulxU64(&x148, &x149, x2, (arg1[4])); + var x150: u64 = undefined; + var x151: u64 = undefined; + mulxU64(&x150, &x151, x2, (arg1[3])); + var x152: u64 = undefined; + var x153: u64 = undefined; + mulxU64(&x152, &x153, x2, (arg1[2])); + var x154: u64 = undefined; + var x155: u64 = undefined; + mulxU64(&x154, &x155, x2, (arg1[1])); + var x156: u64 = undefined; + var x157: u64 = undefined; + mulxU64(&x156, &x157, x2, (arg1[0])); + var x158: u64 = undefined; + var x159: u1 = undefined; + addcarryxU64(&x158, &x159, 0x0, x157, x154); + var x160: u64 = undefined; + var x161: u1 = undefined; + addcarryxU64(&x160, &x161, x159, x155, x152); + var x162: u64 = undefined; + var x163: u1 = undefined; + addcarryxU64(&x162, &x163, x161, x153, x150); + var x164: u64 = undefined; + var x165: u1 = undefined; + addcarryxU64(&x164, &x165, x163, x151, x148); + var x166: u64 = undefined; + var x167: u1 = undefined; + addcarryxU64(&x166, &x167, x165, x149, x146); + const x168 = (cast(u64, x167) + x147); + var x169: u64 = undefined; + var x170: u1 = undefined; + addcarryxU64(&x169, &x170, 0x0, x133, x156); + var x171: u64 = undefined; + var x172: u1 = undefined; + addcarryxU64(&x171, &x172, x170, x135, x158); + var x173: u64 = undefined; + var x174: u1 = undefined; + addcarryxU64(&x173, &x174, x172, x137, x160); + var x175: u64 = undefined; + var x176: u1 = undefined; + addcarryxU64(&x175, &x176, x174, x139, x162); + var x177: u64 = undefined; + var x178: u1 = undefined; + addcarryxU64(&x177, &x178, x176, x141, x164); + var x179: u64 = undefined; + var x180: u1 = undefined; + addcarryxU64(&x179, &x180, x178, x143, x166); + var x181: u64 = undefined; + var x182: u1 = undefined; + addcarryxU64(&x181, &x182, x180, x145, x168); + var x183: u64 = undefined; + var x184: u64 = undefined; + mulxU64(&x183, &x184, x169, 0x6ed46089e88fdc45); + var x185: u64 = undefined; + var x186: u64 = undefined; + mulxU64(&x185, &x186, x183, 0xffffffffffffffff); + var x187: u64 = undefined; + var x188: u64 = undefined; + mulxU64(&x187, &x188, x183, 0xffffffffffffffff); + var x189: u64 = undefined; + var x190: u64 = undefined; + mulxU64(&x189, &x190, x183, 0xffffffffffffffff); + var x191: u64 = undefined; + var x192: u64 = undefined; + mulxU64(&x191, &x192, x183, 0xc7634d81f4372ddf); + var x193: u64 = undefined; + var x194: u64 = undefined; + mulxU64(&x193, &x194, x183, 0x581a0db248b0a77a); + var x195: u64 = undefined; + var x196: u64 = undefined; + mulxU64(&x195, &x196, x183, 0xecec196accc52973); + var x197: u64 = undefined; + var x198: u1 = undefined; + addcarryxU64(&x197, &x198, 0x0, x196, x193); + var x199: u64 = undefined; + var x200: u1 = undefined; + addcarryxU64(&x199, &x200, x198, x194, x191); + var x201: u64 = undefined; + var x202: u1 = undefined; + addcarryxU64(&x201, &x202, x200, x192, x189); + var x203: u64 = undefined; + var x204: u1 = undefined; + addcarryxU64(&x203, &x204, x202, x190, x187); + var x205: u64 = undefined; + var x206: u1 = undefined; + addcarryxU64(&x205, &x206, x204, x188, x185); + const x207 = (cast(u64, x206) + x186); + var x208: u64 = undefined; + var x209: u1 = undefined; + addcarryxU64(&x208, &x209, 0x0, x169, x195); + var x210: u64 = undefined; + var x211: u1 = undefined; + addcarryxU64(&x210, &x211, x209, x171, x197); + var x212: u64 = undefined; + var x213: u1 = undefined; + addcarryxU64(&x212, &x213, x211, x173, x199); + var x214: u64 = undefined; + var x215: u1 = undefined; + addcarryxU64(&x214, &x215, x213, x175, x201); + var x216: u64 = undefined; + var x217: u1 = undefined; + addcarryxU64(&x216, &x217, x215, x177, x203); + var x218: u64 = undefined; + var x219: u1 = undefined; + addcarryxU64(&x218, &x219, x217, x179, x205); + var x220: u64 = undefined; + var x221: u1 = undefined; + addcarryxU64(&x220, &x221, x219, x181, x207); + const x222 = (cast(u64, x221) + cast(u64, x182)); + var x223: u64 = undefined; + var x224: u64 = undefined; + mulxU64(&x223, &x224, x3, (arg1[5])); + var x225: u64 = undefined; + var x226: u64 = undefined; + mulxU64(&x225, &x226, x3, (arg1[4])); + var x227: u64 = undefined; + var x228: u64 = undefined; + mulxU64(&x227, &x228, x3, (arg1[3])); + var x229: u64 = undefined; + var x230: u64 = undefined; + mulxU64(&x229, &x230, x3, (arg1[2])); + var x231: u64 = undefined; + var x232: u64 = undefined; + mulxU64(&x231, &x232, x3, (arg1[1])); + var x233: u64 = undefined; + var x234: u64 = undefined; + mulxU64(&x233, &x234, x3, (arg1[0])); + var x235: u64 = undefined; + var x236: u1 = undefined; + addcarryxU64(&x235, &x236, 0x0, x234, x231); + var x237: u64 = undefined; + var x238: u1 = undefined; + addcarryxU64(&x237, &x238, x236, x232, x229); + var x239: u64 = undefined; + var x240: u1 = undefined; + addcarryxU64(&x239, &x240, x238, x230, x227); + var x241: u64 = undefined; + var x242: u1 = undefined; + addcarryxU64(&x241, &x242, x240, x228, x225); + var x243: u64 = undefined; + var x244: u1 = undefined; + addcarryxU64(&x243, &x244, x242, x226, x223); + const x245 = (cast(u64, x244) + x224); + var x246: u64 = undefined; + var x247: u1 = undefined; + addcarryxU64(&x246, &x247, 0x0, x210, x233); + var x248: u64 = undefined; + var x249: u1 = undefined; + addcarryxU64(&x248, &x249, x247, x212, x235); + var x250: u64 = undefined; + var x251: u1 = undefined; + addcarryxU64(&x250, &x251, x249, x214, x237); + var x252: u64 = undefined; + var x253: u1 = undefined; + addcarryxU64(&x252, &x253, x251, x216, x239); + var x254: u64 = undefined; + var x255: u1 = undefined; + addcarryxU64(&x254, &x255, x253, x218, x241); + var x256: u64 = undefined; + var x257: u1 = undefined; + addcarryxU64(&x256, &x257, x255, x220, x243); + var x258: u64 = undefined; + var x259: u1 = undefined; + addcarryxU64(&x258, &x259, x257, x222, x245); + var x260: u64 = undefined; + var x261: u64 = undefined; + mulxU64(&x260, &x261, x246, 0x6ed46089e88fdc45); + var x262: u64 = undefined; + var x263: u64 = undefined; + mulxU64(&x262, &x263, x260, 0xffffffffffffffff); + var x264: u64 = undefined; + var x265: u64 = undefined; + mulxU64(&x264, &x265, x260, 0xffffffffffffffff); + var x266: u64 = undefined; + var x267: u64 = undefined; + mulxU64(&x266, &x267, x260, 0xffffffffffffffff); + var x268: u64 = undefined; + var x269: u64 = undefined; + mulxU64(&x268, &x269, x260, 0xc7634d81f4372ddf); + var x270: u64 = undefined; + var x271: u64 = undefined; + mulxU64(&x270, &x271, x260, 0x581a0db248b0a77a); + var x272: u64 = undefined; + var x273: u64 = undefined; + mulxU64(&x272, &x273, x260, 0xecec196accc52973); + var x274: u64 = undefined; + var x275: u1 = undefined; + addcarryxU64(&x274, &x275, 0x0, x273, x270); + var x276: u64 = undefined; + var x277: u1 = undefined; + addcarryxU64(&x276, &x277, x275, x271, x268); + var x278: u64 = undefined; + var x279: u1 = undefined; + addcarryxU64(&x278, &x279, x277, x269, x266); + var x280: u64 = undefined; + var x281: u1 = undefined; + addcarryxU64(&x280, &x281, x279, x267, x264); + var x282: u64 = undefined; + var x283: u1 = undefined; + addcarryxU64(&x282, &x283, x281, x265, x262); + const x284 = (cast(u64, x283) + x263); + var x285: u64 = undefined; + var x286: u1 = undefined; + addcarryxU64(&x285, &x286, 0x0, x246, x272); + var x287: u64 = undefined; + var x288: u1 = undefined; + addcarryxU64(&x287, &x288, x286, x248, x274); + var x289: u64 = undefined; + var x290: u1 = undefined; + addcarryxU64(&x289, &x290, x288, x250, x276); + var x291: u64 = undefined; + var x292: u1 = undefined; + addcarryxU64(&x291, &x292, x290, x252, x278); + var x293: u64 = undefined; + var x294: u1 = undefined; + addcarryxU64(&x293, &x294, x292, x254, x280); + var x295: u64 = undefined; + var x296: u1 = undefined; + addcarryxU64(&x295, &x296, x294, x256, x282); + var x297: u64 = undefined; + var x298: u1 = undefined; + addcarryxU64(&x297, &x298, x296, x258, x284); + const x299 = (cast(u64, x298) + cast(u64, x259)); + var x300: u64 = undefined; + var x301: u64 = undefined; + mulxU64(&x300, &x301, x4, (arg1[5])); + var x302: u64 = undefined; + var x303: u64 = undefined; + mulxU64(&x302, &x303, x4, (arg1[4])); + var x304: u64 = undefined; + var x305: u64 = undefined; + mulxU64(&x304, &x305, x4, (arg1[3])); + var x306: u64 = undefined; + var x307: u64 = undefined; + mulxU64(&x306, &x307, x4, (arg1[2])); + var x308: u64 = undefined; + var x309: u64 = undefined; + mulxU64(&x308, &x309, x4, (arg1[1])); + var x310: u64 = undefined; + var x311: u64 = undefined; + mulxU64(&x310, &x311, x4, (arg1[0])); + var x312: u64 = undefined; + var x313: u1 = undefined; + addcarryxU64(&x312, &x313, 0x0, x311, x308); + var x314: u64 = undefined; + var x315: u1 = undefined; + addcarryxU64(&x314, &x315, x313, x309, x306); + var x316: u64 = undefined; + var x317: u1 = undefined; + addcarryxU64(&x316, &x317, x315, x307, x304); + var x318: u64 = undefined; + var x319: u1 = undefined; + addcarryxU64(&x318, &x319, x317, x305, x302); + var x320: u64 = undefined; + var x321: u1 = undefined; + addcarryxU64(&x320, &x321, x319, x303, x300); + const x322 = (cast(u64, x321) + x301); + var x323: u64 = undefined; + var x324: u1 = undefined; + addcarryxU64(&x323, &x324, 0x0, x287, x310); + var x325: u64 = undefined; + var x326: u1 = undefined; + addcarryxU64(&x325, &x326, x324, x289, x312); + var x327: u64 = undefined; + var x328: u1 = undefined; + addcarryxU64(&x327, &x328, x326, x291, x314); + var x329: u64 = undefined; + var x330: u1 = undefined; + addcarryxU64(&x329, &x330, x328, x293, x316); + var x331: u64 = undefined; + var x332: u1 = undefined; + addcarryxU64(&x331, &x332, x330, x295, x318); + var x333: u64 = undefined; + var x334: u1 = undefined; + addcarryxU64(&x333, &x334, x332, x297, x320); + var x335: u64 = undefined; + var x336: u1 = undefined; + addcarryxU64(&x335, &x336, x334, x299, x322); + var x337: u64 = undefined; + var x338: u64 = undefined; + mulxU64(&x337, &x338, x323, 0x6ed46089e88fdc45); + var x339: u64 = undefined; + var x340: u64 = undefined; + mulxU64(&x339, &x340, x337, 0xffffffffffffffff); + var x341: u64 = undefined; + var x342: u64 = undefined; + mulxU64(&x341, &x342, x337, 0xffffffffffffffff); + var x343: u64 = undefined; + var x344: u64 = undefined; + mulxU64(&x343, &x344, x337, 0xffffffffffffffff); + var x345: u64 = undefined; + var x346: u64 = undefined; + mulxU64(&x345, &x346, x337, 0xc7634d81f4372ddf); + var x347: u64 = undefined; + var x348: u64 = undefined; + mulxU64(&x347, &x348, x337, 0x581a0db248b0a77a); + var x349: u64 = undefined; + var x350: u64 = undefined; + mulxU64(&x349, &x350, x337, 0xecec196accc52973); + var x351: u64 = undefined; + var x352: u1 = undefined; + addcarryxU64(&x351, &x352, 0x0, x350, x347); + var x353: u64 = undefined; + var x354: u1 = undefined; + addcarryxU64(&x353, &x354, x352, x348, x345); + var x355: u64 = undefined; + var x356: u1 = undefined; + addcarryxU64(&x355, &x356, x354, x346, x343); + var x357: u64 = undefined; + var x358: u1 = undefined; + addcarryxU64(&x357, &x358, x356, x344, x341); + var x359: u64 = undefined; + var x360: u1 = undefined; + addcarryxU64(&x359, &x360, x358, x342, x339); + const x361 = (cast(u64, x360) + x340); + var x362: u64 = undefined; + var x363: u1 = undefined; + addcarryxU64(&x362, &x363, 0x0, x323, x349); + var x364: u64 = undefined; + var x365: u1 = undefined; + addcarryxU64(&x364, &x365, x363, x325, x351); + var x366: u64 = undefined; + var x367: u1 = undefined; + addcarryxU64(&x366, &x367, x365, x327, x353); + var x368: u64 = undefined; + var x369: u1 = undefined; + addcarryxU64(&x368, &x369, x367, x329, x355); + var x370: u64 = undefined; + var x371: u1 = undefined; + addcarryxU64(&x370, &x371, x369, x331, x357); + var x372: u64 = undefined; + var x373: u1 = undefined; + addcarryxU64(&x372, &x373, x371, x333, x359); + var x374: u64 = undefined; + var x375: u1 = undefined; + addcarryxU64(&x374, &x375, x373, x335, x361); + const x376 = (cast(u64, x375) + cast(u64, x336)); + var x377: u64 = undefined; + var x378: u64 = undefined; + mulxU64(&x377, &x378, x5, (arg1[5])); + var x379: u64 = undefined; + var x380: u64 = undefined; + mulxU64(&x379, &x380, x5, (arg1[4])); + var x381: u64 = undefined; + var x382: u64 = undefined; + mulxU64(&x381, &x382, x5, (arg1[3])); + var x383: u64 = undefined; + var x384: u64 = undefined; + mulxU64(&x383, &x384, x5, (arg1[2])); + var x385: u64 = undefined; + var x386: u64 = undefined; + mulxU64(&x385, &x386, x5, (arg1[1])); + var x387: u64 = undefined; + var x388: u64 = undefined; + mulxU64(&x387, &x388, x5, (arg1[0])); + var x389: u64 = undefined; + var x390: u1 = undefined; + addcarryxU64(&x389, &x390, 0x0, x388, x385); + var x391: u64 = undefined; + var x392: u1 = undefined; + addcarryxU64(&x391, &x392, x390, x386, x383); + var x393: u64 = undefined; + var x394: u1 = undefined; + addcarryxU64(&x393, &x394, x392, x384, x381); + var x395: u64 = undefined; + var x396: u1 = undefined; + addcarryxU64(&x395, &x396, x394, x382, x379); + var x397: u64 = undefined; + var x398: u1 = undefined; + addcarryxU64(&x397, &x398, x396, x380, x377); + const x399 = (cast(u64, x398) + x378); + var x400: u64 = undefined; + var x401: u1 = undefined; + addcarryxU64(&x400, &x401, 0x0, x364, x387); + var x402: u64 = undefined; + var x403: u1 = undefined; + addcarryxU64(&x402, &x403, x401, x366, x389); + var x404: u64 = undefined; + var x405: u1 = undefined; + addcarryxU64(&x404, &x405, x403, x368, x391); + var x406: u64 = undefined; + var x407: u1 = undefined; + addcarryxU64(&x406, &x407, x405, x370, x393); + var x408: u64 = undefined; + var x409: u1 = undefined; + addcarryxU64(&x408, &x409, x407, x372, x395); + var x410: u64 = undefined; + var x411: u1 = undefined; + addcarryxU64(&x410, &x411, x409, x374, x397); + var x412: u64 = undefined; + var x413: u1 = undefined; + addcarryxU64(&x412, &x413, x411, x376, x399); + var x414: u64 = undefined; + var x415: u64 = undefined; + mulxU64(&x414, &x415, x400, 0x6ed46089e88fdc45); + var x416: u64 = undefined; + var x417: u64 = undefined; + mulxU64(&x416, &x417, x414, 0xffffffffffffffff); + var x418: u64 = undefined; + var x419: u64 = undefined; + mulxU64(&x418, &x419, x414, 0xffffffffffffffff); + var x420: u64 = undefined; + var x421: u64 = undefined; + mulxU64(&x420, &x421, x414, 0xffffffffffffffff); + var x422: u64 = undefined; + var x423: u64 = undefined; + mulxU64(&x422, &x423, x414, 0xc7634d81f4372ddf); + var x424: u64 = undefined; + var x425: u64 = undefined; + mulxU64(&x424, &x425, x414, 0x581a0db248b0a77a); + var x426: u64 = undefined; + var x427: u64 = undefined; + mulxU64(&x426, &x427, x414, 0xecec196accc52973); + var x428: u64 = undefined; + var x429: u1 = undefined; + addcarryxU64(&x428, &x429, 0x0, x427, x424); + var x430: u64 = undefined; + var x431: u1 = undefined; + addcarryxU64(&x430, &x431, x429, x425, x422); + var x432: u64 = undefined; + var x433: u1 = undefined; + addcarryxU64(&x432, &x433, x431, x423, x420); + var x434: u64 = undefined; + var x435: u1 = undefined; + addcarryxU64(&x434, &x435, x433, x421, x418); + var x436: u64 = undefined; + var x437: u1 = undefined; + addcarryxU64(&x436, &x437, x435, x419, x416); + const x438 = (cast(u64, x437) + x417); + var x439: u64 = undefined; + var x440: u1 = undefined; + addcarryxU64(&x439, &x440, 0x0, x400, x426); + var x441: u64 = undefined; + var x442: u1 = undefined; + addcarryxU64(&x441, &x442, x440, x402, x428); + var x443: u64 = undefined; + var x444: u1 = undefined; + addcarryxU64(&x443, &x444, x442, x404, x430); + var x445: u64 = undefined; + var x446: u1 = undefined; + addcarryxU64(&x445, &x446, x444, x406, x432); + var x447: u64 = undefined; + var x448: u1 = undefined; + addcarryxU64(&x447, &x448, x446, x408, x434); + var x449: u64 = undefined; + var x450: u1 = undefined; + addcarryxU64(&x449, &x450, x448, x410, x436); + var x451: u64 = undefined; + var x452: u1 = undefined; + addcarryxU64(&x451, &x452, x450, x412, x438); + const x453 = (cast(u64, x452) + cast(u64, x413)); + var x454: u64 = undefined; + var x455: u1 = undefined; + subborrowxU64(&x454, &x455, 0x0, x441, 0xecec196accc52973); + var x456: u64 = undefined; + var x457: u1 = undefined; + subborrowxU64(&x456, &x457, x455, x443, 0x581a0db248b0a77a); + var x458: u64 = undefined; + var x459: u1 = undefined; + subborrowxU64(&x458, &x459, x457, x445, 0xc7634d81f4372ddf); + var x460: u64 = undefined; + var x461: u1 = undefined; + subborrowxU64(&x460, &x461, x459, x447, 0xffffffffffffffff); + var x462: u64 = undefined; + var x463: u1 = undefined; + subborrowxU64(&x462, &x463, x461, x449, 0xffffffffffffffff); + var x464: u64 = undefined; + var x465: u1 = undefined; + subborrowxU64(&x464, &x465, x463, x451, 0xffffffffffffffff); + var x466: u64 = undefined; + var x467: u1 = undefined; + subborrowxU64(&x466, &x467, x465, x453, cast(u64, 0x0)); + var x468: u64 = undefined; + cmovznzU64(&x468, x467, x454, x441); + var x469: u64 = undefined; + cmovznzU64(&x469, x467, x456, x443); + var x470: u64 = undefined; + cmovznzU64(&x470, x467, x458, x445); + var x471: u64 = undefined; + cmovznzU64(&x471, x467, x460, x447); + var x472: u64 = undefined; + cmovznzU64(&x472, x467, x462, x449); + var x473: u64 = undefined; + cmovznzU64(&x473, x467, x464, x451); + out1[0] = x468; + out1[1] = x469; + out1[2] = x470; + out1[3] = x471; + out1[4] = x472; + out1[5] = x473; +} + +/// The function add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn add(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + addcarryxU64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u64 = undefined; + var x4: u1 = undefined; + addcarryxU64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u64 = undefined; + var x6: u1 = undefined; + addcarryxU64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u64 = undefined; + var x8: u1 = undefined; + addcarryxU64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u64 = undefined; + var x10: u1 = undefined; + addcarryxU64(&x9, &x10, x8, (arg1[4]), (arg2[4])); + var x11: u64 = undefined; + var x12: u1 = undefined; + addcarryxU64(&x11, &x12, x10, (arg1[5]), (arg2[5])); + var x13: u64 = undefined; + var x14: u1 = undefined; + subborrowxU64(&x13, &x14, 0x0, x1, 0xecec196accc52973); + var x15: u64 = undefined; + var x16: u1 = undefined; + subborrowxU64(&x15, &x16, x14, x3, 0x581a0db248b0a77a); + var x17: u64 = undefined; + var x18: u1 = undefined; + subborrowxU64(&x17, &x18, x16, x5, 0xc7634d81f4372ddf); + var x19: u64 = undefined; + var x20: u1 = undefined; + subborrowxU64(&x19, &x20, x18, x7, 0xffffffffffffffff); + var x21: u64 = undefined; + var x22: u1 = undefined; + subborrowxU64(&x21, &x22, x20, x9, 0xffffffffffffffff); + var x23: u64 = undefined; + var x24: u1 = undefined; + subborrowxU64(&x23, &x24, x22, x11, 0xffffffffffffffff); + var x25: u64 = undefined; + var x26: u1 = undefined; + subborrowxU64(&x25, &x26, x24, cast(u64, x12), cast(u64, 0x0)); + var x27: u64 = undefined; + cmovznzU64(&x27, x26, x13, x1); + var x28: u64 = undefined; + cmovznzU64(&x28, x26, x15, x3); + var x29: u64 = undefined; + cmovznzU64(&x29, x26, x17, x5); + var x30: u64 = undefined; + cmovznzU64(&x30, x26, x19, x7); + var x31: u64 = undefined; + cmovznzU64(&x31, x26, x21, x9); + var x32: u64 = undefined; + cmovznzU64(&x32, x26, x23, x11); + out1[0] = x27; + out1[1] = x28; + out1[2] = x29; + out1[3] = x30; + out1[4] = x31; + out1[5] = x32; +} + +/// The function sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn sub(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + subborrowxU64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u64 = undefined; + var x4: u1 = undefined; + subborrowxU64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u64 = undefined; + var x6: u1 = undefined; + subborrowxU64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u64 = undefined; + var x8: u1 = undefined; + subborrowxU64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u64 = undefined; + var x10: u1 = undefined; + subborrowxU64(&x9, &x10, x8, (arg1[4]), (arg2[4])); + var x11: u64 = undefined; + var x12: u1 = undefined; + subborrowxU64(&x11, &x12, x10, (arg1[5]), (arg2[5])); + var x13: u64 = undefined; + cmovznzU64(&x13, x12, cast(u64, 0x0), 0xffffffffffffffff); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, 0x0, x1, (x13 & 0xecec196accc52973)); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, x3, (x13 & 0x581a0db248b0a77a)); + var x18: u64 = undefined; + var x19: u1 = undefined; + addcarryxU64(&x18, &x19, x17, x5, (x13 & 0xc7634d81f4372ddf)); + var x20: u64 = undefined; + var x21: u1 = undefined; + addcarryxU64(&x20, &x21, x19, x7, x13); + var x22: u64 = undefined; + var x23: u1 = undefined; + addcarryxU64(&x22, &x23, x21, x9, x13); + var x24: u64 = undefined; + var x25: u1 = undefined; + addcarryxU64(&x24, &x25, x23, x11, x13); + out1[0] = x14; + out1[1] = x16; + out1[2] = x18; + out1[3] = x20; + out1[4] = x22; + out1[5] = x24; +} + +/// The function opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +pub fn opp(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + subborrowxU64(&x1, &x2, 0x0, cast(u64, 0x0), (arg1[0])); + var x3: u64 = undefined; + var x4: u1 = undefined; + subborrowxU64(&x3, &x4, x2, cast(u64, 0x0), (arg1[1])); + var x5: u64 = undefined; + var x6: u1 = undefined; + subborrowxU64(&x5, &x6, x4, cast(u64, 0x0), (arg1[2])); + var x7: u64 = undefined; + var x8: u1 = undefined; + subborrowxU64(&x7, &x8, x6, cast(u64, 0x0), (arg1[3])); + var x9: u64 = undefined; + var x10: u1 = undefined; + subborrowxU64(&x9, &x10, x8, cast(u64, 0x0), (arg1[4])); + var x11: u64 = undefined; + var x12: u1 = undefined; + subborrowxU64(&x11, &x12, x10, cast(u64, 0x0), (arg1[5])); + var x13: u64 = undefined; + cmovznzU64(&x13, x12, cast(u64, 0x0), 0xffffffffffffffff); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, 0x0, x1, (x13 & 0xecec196accc52973)); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, x3, (x13 & 0x581a0db248b0a77a)); + var x18: u64 = undefined; + var x19: u1 = undefined; + addcarryxU64(&x18, &x19, x17, x5, (x13 & 0xc7634d81f4372ddf)); + var x20: u64 = undefined; + var x21: u1 = undefined; + addcarryxU64(&x20, &x21, x19, x7, x13); + var x22: u64 = undefined; + var x23: u1 = undefined; + addcarryxU64(&x22, &x23, x21, x9, x13); + var x24: u64 = undefined; + var x25: u1 = undefined; + addcarryxU64(&x24, &x25, x23, x11, x13); + out1[0] = x14; + out1[1] = x16; + out1[2] = x18; + out1[3] = x20; + out1[4] = x22; + out1[5] = x24; +} + +/// The function fromMontgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^6) mod m +/// 0 ≤ eval out1 < m +/// +pub fn fromMontgomery(out1: *NonMontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[0]); + var x2: u64 = undefined; + var x3: u64 = undefined; + mulxU64(&x2, &x3, x1, 0x6ed46089e88fdc45); + var x4: u64 = undefined; + var x5: u64 = undefined; + mulxU64(&x4, &x5, x2, 0xffffffffffffffff); + var x6: u64 = undefined; + var x7: u64 = undefined; + mulxU64(&x6, &x7, x2, 0xffffffffffffffff); + var x8: u64 = undefined; + var x9: u64 = undefined; + mulxU64(&x8, &x9, x2, 0xffffffffffffffff); + var x10: u64 = undefined; + var x11: u64 = undefined; + mulxU64(&x10, &x11, x2, 0xc7634d81f4372ddf); + var x12: u64 = undefined; + var x13: u64 = undefined; + mulxU64(&x12, &x13, x2, 0x581a0db248b0a77a); + var x14: u64 = undefined; + var x15: u64 = undefined; + mulxU64(&x14, &x15, x2, 0xecec196accc52973); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, 0x0, x15, x12); + var x18: u64 = undefined; + var x19: u1 = undefined; + addcarryxU64(&x18, &x19, x17, x13, x10); + var x20: u64 = undefined; + var x21: u1 = undefined; + addcarryxU64(&x20, &x21, x19, x11, x8); + var x22: u64 = undefined; + var x23: u1 = undefined; + addcarryxU64(&x22, &x23, x21, x9, x6); + var x24: u64 = undefined; + var x25: u1 = undefined; + addcarryxU64(&x24, &x25, x23, x7, x4); + var x26: u64 = undefined; + var x27: u1 = undefined; + addcarryxU64(&x26, &x27, 0x0, x1, x14); + var x28: u64 = undefined; + var x29: u1 = undefined; + addcarryxU64(&x28, &x29, x27, cast(u64, 0x0), x16); + var x30: u64 = undefined; + var x31: u1 = undefined; + addcarryxU64(&x30, &x31, x29, cast(u64, 0x0), x18); + var x32: u64 = undefined; + var x33: u1 = undefined; + addcarryxU64(&x32, &x33, x31, cast(u64, 0x0), x20); + var x34: u64 = undefined; + var x35: u1 = undefined; + addcarryxU64(&x34, &x35, x33, cast(u64, 0x0), x22); + var x36: u64 = undefined; + var x37: u1 = undefined; + addcarryxU64(&x36, &x37, x35, cast(u64, 0x0), x24); + var x38: u64 = undefined; + var x39: u1 = undefined; + addcarryxU64(&x38, &x39, x37, cast(u64, 0x0), (cast(u64, x25) + x5)); + var x40: u64 = undefined; + var x41: u1 = undefined; + addcarryxU64(&x40, &x41, 0x0, x28, (arg1[1])); + var x42: u64 = undefined; + var x43: u1 = undefined; + addcarryxU64(&x42, &x43, x41, x30, cast(u64, 0x0)); + var x44: u64 = undefined; + var x45: u1 = undefined; + addcarryxU64(&x44, &x45, x43, x32, cast(u64, 0x0)); + var x46: u64 = undefined; + var x47: u1 = undefined; + addcarryxU64(&x46, &x47, x45, x34, cast(u64, 0x0)); + var x48: u64 = undefined; + var x49: u1 = undefined; + addcarryxU64(&x48, &x49, x47, x36, cast(u64, 0x0)); + var x50: u64 = undefined; + var x51: u1 = undefined; + addcarryxU64(&x50, &x51, x49, x38, cast(u64, 0x0)); + var x52: u64 = undefined; + var x53: u64 = undefined; + mulxU64(&x52, &x53, x40, 0x6ed46089e88fdc45); + var x54: u64 = undefined; + var x55: u64 = undefined; + mulxU64(&x54, &x55, x52, 0xffffffffffffffff); + var x56: u64 = undefined; + var x57: u64 = undefined; + mulxU64(&x56, &x57, x52, 0xffffffffffffffff); + var x58: u64 = undefined; + var x59: u64 = undefined; + mulxU64(&x58, &x59, x52, 0xffffffffffffffff); + var x60: u64 = undefined; + var x61: u64 = undefined; + mulxU64(&x60, &x61, x52, 0xc7634d81f4372ddf); + var x62: u64 = undefined; + var x63: u64 = undefined; + mulxU64(&x62, &x63, x52, 0x581a0db248b0a77a); + var x64: u64 = undefined; + var x65: u64 = undefined; + mulxU64(&x64, &x65, x52, 0xecec196accc52973); + var x66: u64 = undefined; + var x67: u1 = undefined; + addcarryxU64(&x66, &x67, 0x0, x65, x62); + var x68: u64 = undefined; + var x69: u1 = undefined; + addcarryxU64(&x68, &x69, x67, x63, x60); + var x70: u64 = undefined; + var x71: u1 = undefined; + addcarryxU64(&x70, &x71, x69, x61, x58); + var x72: u64 = undefined; + var x73: u1 = undefined; + addcarryxU64(&x72, &x73, x71, x59, x56); + var x74: u64 = undefined; + var x75: u1 = undefined; + addcarryxU64(&x74, &x75, x73, x57, x54); + var x76: u64 = undefined; + var x77: u1 = undefined; + addcarryxU64(&x76, &x77, 0x0, x40, x64); + var x78: u64 = undefined; + var x79: u1 = undefined; + addcarryxU64(&x78, &x79, x77, x42, x66); + var x80: u64 = undefined; + var x81: u1 = undefined; + addcarryxU64(&x80, &x81, x79, x44, x68); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, x81, x46, x70); + var x84: u64 = undefined; + var x85: u1 = undefined; + addcarryxU64(&x84, &x85, x83, x48, x72); + var x86: u64 = undefined; + var x87: u1 = undefined; + addcarryxU64(&x86, &x87, x85, x50, x74); + var x88: u64 = undefined; + var x89: u1 = undefined; + addcarryxU64(&x88, &x89, x87, (cast(u64, x51) + cast(u64, x39)), (cast(u64, x75) + x55)); + var x90: u64 = undefined; + var x91: u1 = undefined; + addcarryxU64(&x90, &x91, 0x0, x78, (arg1[2])); + var x92: u64 = undefined; + var x93: u1 = undefined; + addcarryxU64(&x92, &x93, x91, x80, cast(u64, 0x0)); + var x94: u64 = undefined; + var x95: u1 = undefined; + addcarryxU64(&x94, &x95, x93, x82, cast(u64, 0x0)); + var x96: u64 = undefined; + var x97: u1 = undefined; + addcarryxU64(&x96, &x97, x95, x84, cast(u64, 0x0)); + var x98: u64 = undefined; + var x99: u1 = undefined; + addcarryxU64(&x98, &x99, x97, x86, cast(u64, 0x0)); + var x100: u64 = undefined; + var x101: u1 = undefined; + addcarryxU64(&x100, &x101, x99, x88, cast(u64, 0x0)); + var x102: u64 = undefined; + var x103: u64 = undefined; + mulxU64(&x102, &x103, x90, 0x6ed46089e88fdc45); + var x104: u64 = undefined; + var x105: u64 = undefined; + mulxU64(&x104, &x105, x102, 0xffffffffffffffff); + var x106: u64 = undefined; + var x107: u64 = undefined; + mulxU64(&x106, &x107, x102, 0xffffffffffffffff); + var x108: u64 = undefined; + var x109: u64 = undefined; + mulxU64(&x108, &x109, x102, 0xffffffffffffffff); + var x110: u64 = undefined; + var x111: u64 = undefined; + mulxU64(&x110, &x111, x102, 0xc7634d81f4372ddf); + var x112: u64 = undefined; + var x113: u64 = undefined; + mulxU64(&x112, &x113, x102, 0x581a0db248b0a77a); + var x114: u64 = undefined; + var x115: u64 = undefined; + mulxU64(&x114, &x115, x102, 0xecec196accc52973); + var x116: u64 = undefined; + var x117: u1 = undefined; + addcarryxU64(&x116, &x117, 0x0, x115, x112); + var x118: u64 = undefined; + var x119: u1 = undefined; + addcarryxU64(&x118, &x119, x117, x113, x110); + var x120: u64 = undefined; + var x121: u1 = undefined; + addcarryxU64(&x120, &x121, x119, x111, x108); + var x122: u64 = undefined; + var x123: u1 = undefined; + addcarryxU64(&x122, &x123, x121, x109, x106); + var x124: u64 = undefined; + var x125: u1 = undefined; + addcarryxU64(&x124, &x125, x123, x107, x104); + var x126: u64 = undefined; + var x127: u1 = undefined; + addcarryxU64(&x126, &x127, 0x0, x90, x114); + var x128: u64 = undefined; + var x129: u1 = undefined; + addcarryxU64(&x128, &x129, x127, x92, x116); + var x130: u64 = undefined; + var x131: u1 = undefined; + addcarryxU64(&x130, &x131, x129, x94, x118); + var x132: u64 = undefined; + var x133: u1 = undefined; + addcarryxU64(&x132, &x133, x131, x96, x120); + var x134: u64 = undefined; + var x135: u1 = undefined; + addcarryxU64(&x134, &x135, x133, x98, x122); + var x136: u64 = undefined; + var x137: u1 = undefined; + addcarryxU64(&x136, &x137, x135, x100, x124); + var x138: u64 = undefined; + var x139: u1 = undefined; + addcarryxU64(&x138, &x139, x137, (cast(u64, x101) + cast(u64, x89)), (cast(u64, x125) + x105)); + var x140: u64 = undefined; + var x141: u1 = undefined; + addcarryxU64(&x140, &x141, 0x0, x128, (arg1[3])); + var x142: u64 = undefined; + var x143: u1 = undefined; + addcarryxU64(&x142, &x143, x141, x130, cast(u64, 0x0)); + var x144: u64 = undefined; + var x145: u1 = undefined; + addcarryxU64(&x144, &x145, x143, x132, cast(u64, 0x0)); + var x146: u64 = undefined; + var x147: u1 = undefined; + addcarryxU64(&x146, &x147, x145, x134, cast(u64, 0x0)); + var x148: u64 = undefined; + var x149: u1 = undefined; + addcarryxU64(&x148, &x149, x147, x136, cast(u64, 0x0)); + var x150: u64 = undefined; + var x151: u1 = undefined; + addcarryxU64(&x150, &x151, x149, x138, cast(u64, 0x0)); + var x152: u64 = undefined; + var x153: u64 = undefined; + mulxU64(&x152, &x153, x140, 0x6ed46089e88fdc45); + var x154: u64 = undefined; + var x155: u64 = undefined; + mulxU64(&x154, &x155, x152, 0xffffffffffffffff); + var x156: u64 = undefined; + var x157: u64 = undefined; + mulxU64(&x156, &x157, x152, 0xffffffffffffffff); + var x158: u64 = undefined; + var x159: u64 = undefined; + mulxU64(&x158, &x159, x152, 0xffffffffffffffff); + var x160: u64 = undefined; + var x161: u64 = undefined; + mulxU64(&x160, &x161, x152, 0xc7634d81f4372ddf); + var x162: u64 = undefined; + var x163: u64 = undefined; + mulxU64(&x162, &x163, x152, 0x581a0db248b0a77a); + var x164: u64 = undefined; + var x165: u64 = undefined; + mulxU64(&x164, &x165, x152, 0xecec196accc52973); + var x166: u64 = undefined; + var x167: u1 = undefined; + addcarryxU64(&x166, &x167, 0x0, x165, x162); + var x168: u64 = undefined; + var x169: u1 = undefined; + addcarryxU64(&x168, &x169, x167, x163, x160); + var x170: u64 = undefined; + var x171: u1 = undefined; + addcarryxU64(&x170, &x171, x169, x161, x158); + var x172: u64 = undefined; + var x173: u1 = undefined; + addcarryxU64(&x172, &x173, x171, x159, x156); + var x174: u64 = undefined; + var x175: u1 = undefined; + addcarryxU64(&x174, &x175, x173, x157, x154); + var x176: u64 = undefined; + var x177: u1 = undefined; + addcarryxU64(&x176, &x177, 0x0, x140, x164); + var x178: u64 = undefined; + var x179: u1 = undefined; + addcarryxU64(&x178, &x179, x177, x142, x166); + var x180: u64 = undefined; + var x181: u1 = undefined; + addcarryxU64(&x180, &x181, x179, x144, x168); + var x182: u64 = undefined; + var x183: u1 = undefined; + addcarryxU64(&x182, &x183, x181, x146, x170); + var x184: u64 = undefined; + var x185: u1 = undefined; + addcarryxU64(&x184, &x185, x183, x148, x172); + var x186: u64 = undefined; + var x187: u1 = undefined; + addcarryxU64(&x186, &x187, x185, x150, x174); + var x188: u64 = undefined; + var x189: u1 = undefined; + addcarryxU64(&x188, &x189, x187, (cast(u64, x151) + cast(u64, x139)), (cast(u64, x175) + x155)); + var x190: u64 = undefined; + var x191: u1 = undefined; + addcarryxU64(&x190, &x191, 0x0, x178, (arg1[4])); + var x192: u64 = undefined; + var x193: u1 = undefined; + addcarryxU64(&x192, &x193, x191, x180, cast(u64, 0x0)); + var x194: u64 = undefined; + var x195: u1 = undefined; + addcarryxU64(&x194, &x195, x193, x182, cast(u64, 0x0)); + var x196: u64 = undefined; + var x197: u1 = undefined; + addcarryxU64(&x196, &x197, x195, x184, cast(u64, 0x0)); + var x198: u64 = undefined; + var x199: u1 = undefined; + addcarryxU64(&x198, &x199, x197, x186, cast(u64, 0x0)); + var x200: u64 = undefined; + var x201: u1 = undefined; + addcarryxU64(&x200, &x201, x199, x188, cast(u64, 0x0)); + var x202: u64 = undefined; + var x203: u64 = undefined; + mulxU64(&x202, &x203, x190, 0x6ed46089e88fdc45); + var x204: u64 = undefined; + var x205: u64 = undefined; + mulxU64(&x204, &x205, x202, 0xffffffffffffffff); + var x206: u64 = undefined; + var x207: u64 = undefined; + mulxU64(&x206, &x207, x202, 0xffffffffffffffff); + var x208: u64 = undefined; + var x209: u64 = undefined; + mulxU64(&x208, &x209, x202, 0xffffffffffffffff); + var x210: u64 = undefined; + var x211: u64 = undefined; + mulxU64(&x210, &x211, x202, 0xc7634d81f4372ddf); + var x212: u64 = undefined; + var x213: u64 = undefined; + mulxU64(&x212, &x213, x202, 0x581a0db248b0a77a); + var x214: u64 = undefined; + var x215: u64 = undefined; + mulxU64(&x214, &x215, x202, 0xecec196accc52973); + var x216: u64 = undefined; + var x217: u1 = undefined; + addcarryxU64(&x216, &x217, 0x0, x215, x212); + var x218: u64 = undefined; + var x219: u1 = undefined; + addcarryxU64(&x218, &x219, x217, x213, x210); + var x220: u64 = undefined; + var x221: u1 = undefined; + addcarryxU64(&x220, &x221, x219, x211, x208); + var x222: u64 = undefined; + var x223: u1 = undefined; + addcarryxU64(&x222, &x223, x221, x209, x206); + var x224: u64 = undefined; + var x225: u1 = undefined; + addcarryxU64(&x224, &x225, x223, x207, x204); + var x226: u64 = undefined; + var x227: u1 = undefined; + addcarryxU64(&x226, &x227, 0x0, x190, x214); + var x228: u64 = undefined; + var x229: u1 = undefined; + addcarryxU64(&x228, &x229, x227, x192, x216); + var x230: u64 = undefined; + var x231: u1 = undefined; + addcarryxU64(&x230, &x231, x229, x194, x218); + var x232: u64 = undefined; + var x233: u1 = undefined; + addcarryxU64(&x232, &x233, x231, x196, x220); + var x234: u64 = undefined; + var x235: u1 = undefined; + addcarryxU64(&x234, &x235, x233, x198, x222); + var x236: u64 = undefined; + var x237: u1 = undefined; + addcarryxU64(&x236, &x237, x235, x200, x224); + var x238: u64 = undefined; + var x239: u1 = undefined; + addcarryxU64(&x238, &x239, x237, (cast(u64, x201) + cast(u64, x189)), (cast(u64, x225) + x205)); + var x240: u64 = undefined; + var x241: u1 = undefined; + addcarryxU64(&x240, &x241, 0x0, x228, (arg1[5])); + var x242: u64 = undefined; + var x243: u1 = undefined; + addcarryxU64(&x242, &x243, x241, x230, cast(u64, 0x0)); + var x244: u64 = undefined; + var x245: u1 = undefined; + addcarryxU64(&x244, &x245, x243, x232, cast(u64, 0x0)); + var x246: u64 = undefined; + var x247: u1 = undefined; + addcarryxU64(&x246, &x247, x245, x234, cast(u64, 0x0)); + var x248: u64 = undefined; + var x249: u1 = undefined; + addcarryxU64(&x248, &x249, x247, x236, cast(u64, 0x0)); + var x250: u64 = undefined; + var x251: u1 = undefined; + addcarryxU64(&x250, &x251, x249, x238, cast(u64, 0x0)); + var x252: u64 = undefined; + var x253: u64 = undefined; + mulxU64(&x252, &x253, x240, 0x6ed46089e88fdc45); + var x254: u64 = undefined; + var x255: u64 = undefined; + mulxU64(&x254, &x255, x252, 0xffffffffffffffff); + var x256: u64 = undefined; + var x257: u64 = undefined; + mulxU64(&x256, &x257, x252, 0xffffffffffffffff); + var x258: u64 = undefined; + var x259: u64 = undefined; + mulxU64(&x258, &x259, x252, 0xffffffffffffffff); + var x260: u64 = undefined; + var x261: u64 = undefined; + mulxU64(&x260, &x261, x252, 0xc7634d81f4372ddf); + var x262: u64 = undefined; + var x263: u64 = undefined; + mulxU64(&x262, &x263, x252, 0x581a0db248b0a77a); + var x264: u64 = undefined; + var x265: u64 = undefined; + mulxU64(&x264, &x265, x252, 0xecec196accc52973); + var x266: u64 = undefined; + var x267: u1 = undefined; + addcarryxU64(&x266, &x267, 0x0, x265, x262); + var x268: u64 = undefined; + var x269: u1 = undefined; + addcarryxU64(&x268, &x269, x267, x263, x260); + var x270: u64 = undefined; + var x271: u1 = undefined; + addcarryxU64(&x270, &x271, x269, x261, x258); + var x272: u64 = undefined; + var x273: u1 = undefined; + addcarryxU64(&x272, &x273, x271, x259, x256); + var x274: u64 = undefined; + var x275: u1 = undefined; + addcarryxU64(&x274, &x275, x273, x257, x254); + var x276: u64 = undefined; + var x277: u1 = undefined; + addcarryxU64(&x276, &x277, 0x0, x240, x264); + var x278: u64 = undefined; + var x279: u1 = undefined; + addcarryxU64(&x278, &x279, x277, x242, x266); + var x280: u64 = undefined; + var x281: u1 = undefined; + addcarryxU64(&x280, &x281, x279, x244, x268); + var x282: u64 = undefined; + var x283: u1 = undefined; + addcarryxU64(&x282, &x283, x281, x246, x270); + var x284: u64 = undefined; + var x285: u1 = undefined; + addcarryxU64(&x284, &x285, x283, x248, x272); + var x286: u64 = undefined; + var x287: u1 = undefined; + addcarryxU64(&x286, &x287, x285, x250, x274); + var x288: u64 = undefined; + var x289: u1 = undefined; + addcarryxU64(&x288, &x289, x287, (cast(u64, x251) + cast(u64, x239)), (cast(u64, x275) + x255)); + var x290: u64 = undefined; + var x291: u1 = undefined; + subborrowxU64(&x290, &x291, 0x0, x278, 0xecec196accc52973); + var x292: u64 = undefined; + var x293: u1 = undefined; + subborrowxU64(&x292, &x293, x291, x280, 0x581a0db248b0a77a); + var x294: u64 = undefined; + var x295: u1 = undefined; + subborrowxU64(&x294, &x295, x293, x282, 0xc7634d81f4372ddf); + var x296: u64 = undefined; + var x297: u1 = undefined; + subborrowxU64(&x296, &x297, x295, x284, 0xffffffffffffffff); + var x298: u64 = undefined; + var x299: u1 = undefined; + subborrowxU64(&x298, &x299, x297, x286, 0xffffffffffffffff); + var x300: u64 = undefined; + var x301: u1 = undefined; + subborrowxU64(&x300, &x301, x299, x288, 0xffffffffffffffff); + var x302: u64 = undefined; + var x303: u1 = undefined; + subborrowxU64(&x302, &x303, x301, cast(u64, x289), cast(u64, 0x0)); + var x304: u64 = undefined; + cmovznzU64(&x304, x303, x290, x278); + var x305: u64 = undefined; + cmovznzU64(&x305, x303, x292, x280); + var x306: u64 = undefined; + cmovznzU64(&x306, x303, x294, x282); + var x307: u64 = undefined; + cmovznzU64(&x307, x303, x296, x284); + var x308: u64 = undefined; + cmovznzU64(&x308, x303, x298, x286); + var x309: u64 = undefined; + cmovznzU64(&x309, x303, x300, x288); + out1[0] = x304; + out1[1] = x305; + out1[2] = x306; + out1[3] = x307; + out1[4] = x308; + out1[5] = x309; +} + +/// The function toMontgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn toMontgomery(out1: *MontgomeryDomainFieldElement, arg1: NonMontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[0]); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x6, 0xc84ee012b39bf21); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x6, 0x3fb05b7a28266895); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x6, 0xd40d49174aab1cc5); + var x13: u64 = undefined; + var x14: u64 = undefined; + mulxU64(&x13, &x14, x6, 0xbc3e483afcb82947); + var x15: u64 = undefined; + var x16: u64 = undefined; + mulxU64(&x15, &x16, x6, 0xff3d81e5df1aa419); + var x17: u64 = undefined; + var x18: u64 = undefined; + mulxU64(&x17, &x18, x6, 0x2d319b2419b409a9); + var x19: u64 = undefined; + var x20: u1 = undefined; + addcarryxU64(&x19, &x20, 0x0, x18, x15); + var x21: u64 = undefined; + var x22: u1 = undefined; + addcarryxU64(&x21, &x22, x20, x16, x13); + var x23: u64 = undefined; + var x24: u1 = undefined; + addcarryxU64(&x23, &x24, x22, x14, x11); + var x25: u64 = undefined; + var x26: u1 = undefined; + addcarryxU64(&x25, &x26, x24, x12, x9); + var x27: u64 = undefined; + var x28: u1 = undefined; + addcarryxU64(&x27, &x28, x26, x10, x7); + var x29: u64 = undefined; + var x30: u64 = undefined; + mulxU64(&x29, &x30, x17, 0x6ed46089e88fdc45); + var x31: u64 = undefined; + var x32: u64 = undefined; + mulxU64(&x31, &x32, x29, 0xffffffffffffffff); + var x33: u64 = undefined; + var x34: u64 = undefined; + mulxU64(&x33, &x34, x29, 0xffffffffffffffff); + var x35: u64 = undefined; + var x36: u64 = undefined; + mulxU64(&x35, &x36, x29, 0xffffffffffffffff); + var x37: u64 = undefined; + var x38: u64 = undefined; + mulxU64(&x37, &x38, x29, 0xc7634d81f4372ddf); + var x39: u64 = undefined; + var x40: u64 = undefined; + mulxU64(&x39, &x40, x29, 0x581a0db248b0a77a); + var x41: u64 = undefined; + var x42: u64 = undefined; + mulxU64(&x41, &x42, x29, 0xecec196accc52973); + var x43: u64 = undefined; + var x44: u1 = undefined; + addcarryxU64(&x43, &x44, 0x0, x42, x39); + var x45: u64 = undefined; + var x46: u1 = undefined; + addcarryxU64(&x45, &x46, x44, x40, x37); + var x47: u64 = undefined; + var x48: u1 = undefined; + addcarryxU64(&x47, &x48, x46, x38, x35); + var x49: u64 = undefined; + var x50: u1 = undefined; + addcarryxU64(&x49, &x50, x48, x36, x33); + var x51: u64 = undefined; + var x52: u1 = undefined; + addcarryxU64(&x51, &x52, x50, x34, x31); + var x53: u64 = undefined; + var x54: u1 = undefined; + addcarryxU64(&x53, &x54, 0x0, x17, x41); + var x55: u64 = undefined; + var x56: u1 = undefined; + addcarryxU64(&x55, &x56, x54, x19, x43); + var x57: u64 = undefined; + var x58: u1 = undefined; + addcarryxU64(&x57, &x58, x56, x21, x45); + var x59: u64 = undefined; + var x60: u1 = undefined; + addcarryxU64(&x59, &x60, x58, x23, x47); + var x61: u64 = undefined; + var x62: u1 = undefined; + addcarryxU64(&x61, &x62, x60, x25, x49); + var x63: u64 = undefined; + var x64: u1 = undefined; + addcarryxU64(&x63, &x64, x62, x27, x51); + var x65: u64 = undefined; + var x66: u1 = undefined; + addcarryxU64(&x65, &x66, x64, (cast(u64, x28) + x8), (cast(u64, x52) + x32)); + var x67: u64 = undefined; + var x68: u64 = undefined; + mulxU64(&x67, &x68, x1, 0xc84ee012b39bf21); + var x69: u64 = undefined; + var x70: u64 = undefined; + mulxU64(&x69, &x70, x1, 0x3fb05b7a28266895); + var x71: u64 = undefined; + var x72: u64 = undefined; + mulxU64(&x71, &x72, x1, 0xd40d49174aab1cc5); + var x73: u64 = undefined; + var x74: u64 = undefined; + mulxU64(&x73, &x74, x1, 0xbc3e483afcb82947); + var x75: u64 = undefined; + var x76: u64 = undefined; + mulxU64(&x75, &x76, x1, 0xff3d81e5df1aa419); + var x77: u64 = undefined; + var x78: u64 = undefined; + mulxU64(&x77, &x78, x1, 0x2d319b2419b409a9); + var x79: u64 = undefined; + var x80: u1 = undefined; + addcarryxU64(&x79, &x80, 0x0, x78, x75); + var x81: u64 = undefined; + var x82: u1 = undefined; + addcarryxU64(&x81, &x82, x80, x76, x73); + var x83: u64 = undefined; + var x84: u1 = undefined; + addcarryxU64(&x83, &x84, x82, x74, x71); + var x85: u64 = undefined; + var x86: u1 = undefined; + addcarryxU64(&x85, &x86, x84, x72, x69); + var x87: u64 = undefined; + var x88: u1 = undefined; + addcarryxU64(&x87, &x88, x86, x70, x67); + var x89: u64 = undefined; + var x90: u1 = undefined; + addcarryxU64(&x89, &x90, 0x0, x55, x77); + var x91: u64 = undefined; + var x92: u1 = undefined; + addcarryxU64(&x91, &x92, x90, x57, x79); + var x93: u64 = undefined; + var x94: u1 = undefined; + addcarryxU64(&x93, &x94, x92, x59, x81); + var x95: u64 = undefined; + var x96: u1 = undefined; + addcarryxU64(&x95, &x96, x94, x61, x83); + var x97: u64 = undefined; + var x98: u1 = undefined; + addcarryxU64(&x97, &x98, x96, x63, x85); + var x99: u64 = undefined; + var x100: u1 = undefined; + addcarryxU64(&x99, &x100, x98, x65, x87); + var x101: u64 = undefined; + var x102: u64 = undefined; + mulxU64(&x101, &x102, x89, 0x6ed46089e88fdc45); + var x103: u64 = undefined; + var x104: u64 = undefined; + mulxU64(&x103, &x104, x101, 0xffffffffffffffff); + var x105: u64 = undefined; + var x106: u64 = undefined; + mulxU64(&x105, &x106, x101, 0xffffffffffffffff); + var x107: u64 = undefined; + var x108: u64 = undefined; + mulxU64(&x107, &x108, x101, 0xffffffffffffffff); + var x109: u64 = undefined; + var x110: u64 = undefined; + mulxU64(&x109, &x110, x101, 0xc7634d81f4372ddf); + var x111: u64 = undefined; + var x112: u64 = undefined; + mulxU64(&x111, &x112, x101, 0x581a0db248b0a77a); + var x113: u64 = undefined; + var x114: u64 = undefined; + mulxU64(&x113, &x114, x101, 0xecec196accc52973); + var x115: u64 = undefined; + var x116: u1 = undefined; + addcarryxU64(&x115, &x116, 0x0, x114, x111); + var x117: u64 = undefined; + var x118: u1 = undefined; + addcarryxU64(&x117, &x118, x116, x112, x109); + var x119: u64 = undefined; + var x120: u1 = undefined; + addcarryxU64(&x119, &x120, x118, x110, x107); + var x121: u64 = undefined; + var x122: u1 = undefined; + addcarryxU64(&x121, &x122, x120, x108, x105); + var x123: u64 = undefined; + var x124: u1 = undefined; + addcarryxU64(&x123, &x124, x122, x106, x103); + var x125: u64 = undefined; + var x126: u1 = undefined; + addcarryxU64(&x125, &x126, 0x0, x89, x113); + var x127: u64 = undefined; + var x128: u1 = undefined; + addcarryxU64(&x127, &x128, x126, x91, x115); + var x129: u64 = undefined; + var x130: u1 = undefined; + addcarryxU64(&x129, &x130, x128, x93, x117); + var x131: u64 = undefined; + var x132: u1 = undefined; + addcarryxU64(&x131, &x132, x130, x95, x119); + var x133: u64 = undefined; + var x134: u1 = undefined; + addcarryxU64(&x133, &x134, x132, x97, x121); + var x135: u64 = undefined; + var x136: u1 = undefined; + addcarryxU64(&x135, &x136, x134, x99, x123); + var x137: u64 = undefined; + var x138: u1 = undefined; + addcarryxU64(&x137, &x138, x136, ((cast(u64, x100) + cast(u64, x66)) + (cast(u64, x88) + x68)), (cast(u64, x124) + x104)); + var x139: u64 = undefined; + var x140: u64 = undefined; + mulxU64(&x139, &x140, x2, 0xc84ee012b39bf21); + var x141: u64 = undefined; + var x142: u64 = undefined; + mulxU64(&x141, &x142, x2, 0x3fb05b7a28266895); + var x143: u64 = undefined; + var x144: u64 = undefined; + mulxU64(&x143, &x144, x2, 0xd40d49174aab1cc5); + var x145: u64 = undefined; + var x146: u64 = undefined; + mulxU64(&x145, &x146, x2, 0xbc3e483afcb82947); + var x147: u64 = undefined; + var x148: u64 = undefined; + mulxU64(&x147, &x148, x2, 0xff3d81e5df1aa419); + var x149: u64 = undefined; + var x150: u64 = undefined; + mulxU64(&x149, &x150, x2, 0x2d319b2419b409a9); + var x151: u64 = undefined; + var x152: u1 = undefined; + addcarryxU64(&x151, &x152, 0x0, x150, x147); + var x153: u64 = undefined; + var x154: u1 = undefined; + addcarryxU64(&x153, &x154, x152, x148, x145); + var x155: u64 = undefined; + var x156: u1 = undefined; + addcarryxU64(&x155, &x156, x154, x146, x143); + var x157: u64 = undefined; + var x158: u1 = undefined; + addcarryxU64(&x157, &x158, x156, x144, x141); + var x159: u64 = undefined; + var x160: u1 = undefined; + addcarryxU64(&x159, &x160, x158, x142, x139); + var x161: u64 = undefined; + var x162: u1 = undefined; + addcarryxU64(&x161, &x162, 0x0, x127, x149); + var x163: u64 = undefined; + var x164: u1 = undefined; + addcarryxU64(&x163, &x164, x162, x129, x151); + var x165: u64 = undefined; + var x166: u1 = undefined; + addcarryxU64(&x165, &x166, x164, x131, x153); + var x167: u64 = undefined; + var x168: u1 = undefined; + addcarryxU64(&x167, &x168, x166, x133, x155); + var x169: u64 = undefined; + var x170: u1 = undefined; + addcarryxU64(&x169, &x170, x168, x135, x157); + var x171: u64 = undefined; + var x172: u1 = undefined; + addcarryxU64(&x171, &x172, x170, x137, x159); + var x173: u64 = undefined; + var x174: u64 = undefined; + mulxU64(&x173, &x174, x161, 0x6ed46089e88fdc45); + var x175: u64 = undefined; + var x176: u64 = undefined; + mulxU64(&x175, &x176, x173, 0xffffffffffffffff); + var x177: u64 = undefined; + var x178: u64 = undefined; + mulxU64(&x177, &x178, x173, 0xffffffffffffffff); + var x179: u64 = undefined; + var x180: u64 = undefined; + mulxU64(&x179, &x180, x173, 0xffffffffffffffff); + var x181: u64 = undefined; + var x182: u64 = undefined; + mulxU64(&x181, &x182, x173, 0xc7634d81f4372ddf); + var x183: u64 = undefined; + var x184: u64 = undefined; + mulxU64(&x183, &x184, x173, 0x581a0db248b0a77a); + var x185: u64 = undefined; + var x186: u64 = undefined; + mulxU64(&x185, &x186, x173, 0xecec196accc52973); + var x187: u64 = undefined; + var x188: u1 = undefined; + addcarryxU64(&x187, &x188, 0x0, x186, x183); + var x189: u64 = undefined; + var x190: u1 = undefined; + addcarryxU64(&x189, &x190, x188, x184, x181); + var x191: u64 = undefined; + var x192: u1 = undefined; + addcarryxU64(&x191, &x192, x190, x182, x179); + var x193: u64 = undefined; + var x194: u1 = undefined; + addcarryxU64(&x193, &x194, x192, x180, x177); + var x195: u64 = undefined; + var x196: u1 = undefined; + addcarryxU64(&x195, &x196, x194, x178, x175); + var x197: u64 = undefined; + var x198: u1 = undefined; + addcarryxU64(&x197, &x198, 0x0, x161, x185); + var x199: u64 = undefined; + var x200: u1 = undefined; + addcarryxU64(&x199, &x200, x198, x163, x187); + var x201: u64 = undefined; + var x202: u1 = undefined; + addcarryxU64(&x201, &x202, x200, x165, x189); + var x203: u64 = undefined; + var x204: u1 = undefined; + addcarryxU64(&x203, &x204, x202, x167, x191); + var x205: u64 = undefined; + var x206: u1 = undefined; + addcarryxU64(&x205, &x206, x204, x169, x193); + var x207: u64 = undefined; + var x208: u1 = undefined; + addcarryxU64(&x207, &x208, x206, x171, x195); + var x209: u64 = undefined; + var x210: u1 = undefined; + addcarryxU64(&x209, &x210, x208, ((cast(u64, x172) + cast(u64, x138)) + (cast(u64, x160) + x140)), (cast(u64, x196) + x176)); + var x211: u64 = undefined; + var x212: u64 = undefined; + mulxU64(&x211, &x212, x3, 0xc84ee012b39bf21); + var x213: u64 = undefined; + var x214: u64 = undefined; + mulxU64(&x213, &x214, x3, 0x3fb05b7a28266895); + var x215: u64 = undefined; + var x216: u64 = undefined; + mulxU64(&x215, &x216, x3, 0xd40d49174aab1cc5); + var x217: u64 = undefined; + var x218: u64 = undefined; + mulxU64(&x217, &x218, x3, 0xbc3e483afcb82947); + var x219: u64 = undefined; + var x220: u64 = undefined; + mulxU64(&x219, &x220, x3, 0xff3d81e5df1aa419); + var x221: u64 = undefined; + var x222: u64 = undefined; + mulxU64(&x221, &x222, x3, 0x2d319b2419b409a9); + var x223: u64 = undefined; + var x224: u1 = undefined; + addcarryxU64(&x223, &x224, 0x0, x222, x219); + var x225: u64 = undefined; + var x226: u1 = undefined; + addcarryxU64(&x225, &x226, x224, x220, x217); + var x227: u64 = undefined; + var x228: u1 = undefined; + addcarryxU64(&x227, &x228, x226, x218, x215); + var x229: u64 = undefined; + var x230: u1 = undefined; + addcarryxU64(&x229, &x230, x228, x216, x213); + var x231: u64 = undefined; + var x232: u1 = undefined; + addcarryxU64(&x231, &x232, x230, x214, x211); + var x233: u64 = undefined; + var x234: u1 = undefined; + addcarryxU64(&x233, &x234, 0x0, x199, x221); + var x235: u64 = undefined; + var x236: u1 = undefined; + addcarryxU64(&x235, &x236, x234, x201, x223); + var x237: u64 = undefined; + var x238: u1 = undefined; + addcarryxU64(&x237, &x238, x236, x203, x225); + var x239: u64 = undefined; + var x240: u1 = undefined; + addcarryxU64(&x239, &x240, x238, x205, x227); + var x241: u64 = undefined; + var x242: u1 = undefined; + addcarryxU64(&x241, &x242, x240, x207, x229); + var x243: u64 = undefined; + var x244: u1 = undefined; + addcarryxU64(&x243, &x244, x242, x209, x231); + var x245: u64 = undefined; + var x246: u64 = undefined; + mulxU64(&x245, &x246, x233, 0x6ed46089e88fdc45); + var x247: u64 = undefined; + var x248: u64 = undefined; + mulxU64(&x247, &x248, x245, 0xffffffffffffffff); + var x249: u64 = undefined; + var x250: u64 = undefined; + mulxU64(&x249, &x250, x245, 0xffffffffffffffff); + var x251: u64 = undefined; + var x252: u64 = undefined; + mulxU64(&x251, &x252, x245, 0xffffffffffffffff); + var x253: u64 = undefined; + var x254: u64 = undefined; + mulxU64(&x253, &x254, x245, 0xc7634d81f4372ddf); + var x255: u64 = undefined; + var x256: u64 = undefined; + mulxU64(&x255, &x256, x245, 0x581a0db248b0a77a); + var x257: u64 = undefined; + var x258: u64 = undefined; + mulxU64(&x257, &x258, x245, 0xecec196accc52973); + var x259: u64 = undefined; + var x260: u1 = undefined; + addcarryxU64(&x259, &x260, 0x0, x258, x255); + var x261: u64 = undefined; + var x262: u1 = undefined; + addcarryxU64(&x261, &x262, x260, x256, x253); + var x263: u64 = undefined; + var x264: u1 = undefined; + addcarryxU64(&x263, &x264, x262, x254, x251); + var x265: u64 = undefined; + var x266: u1 = undefined; + addcarryxU64(&x265, &x266, x264, x252, x249); + var x267: u64 = undefined; + var x268: u1 = undefined; + addcarryxU64(&x267, &x268, x266, x250, x247); + var x269: u64 = undefined; + var x270: u1 = undefined; + addcarryxU64(&x269, &x270, 0x0, x233, x257); + var x271: u64 = undefined; + var x272: u1 = undefined; + addcarryxU64(&x271, &x272, x270, x235, x259); + var x273: u64 = undefined; + var x274: u1 = undefined; + addcarryxU64(&x273, &x274, x272, x237, x261); + var x275: u64 = undefined; + var x276: u1 = undefined; + addcarryxU64(&x275, &x276, x274, x239, x263); + var x277: u64 = undefined; + var x278: u1 = undefined; + addcarryxU64(&x277, &x278, x276, x241, x265); + var x279: u64 = undefined; + var x280: u1 = undefined; + addcarryxU64(&x279, &x280, x278, x243, x267); + var x281: u64 = undefined; + var x282: u1 = undefined; + addcarryxU64(&x281, &x282, x280, ((cast(u64, x244) + cast(u64, x210)) + (cast(u64, x232) + x212)), (cast(u64, x268) + x248)); + var x283: u64 = undefined; + var x284: u64 = undefined; + mulxU64(&x283, &x284, x4, 0xc84ee012b39bf21); + var x285: u64 = undefined; + var x286: u64 = undefined; + mulxU64(&x285, &x286, x4, 0x3fb05b7a28266895); + var x287: u64 = undefined; + var x288: u64 = undefined; + mulxU64(&x287, &x288, x4, 0xd40d49174aab1cc5); + var x289: u64 = undefined; + var x290: u64 = undefined; + mulxU64(&x289, &x290, x4, 0xbc3e483afcb82947); + var x291: u64 = undefined; + var x292: u64 = undefined; + mulxU64(&x291, &x292, x4, 0xff3d81e5df1aa419); + var x293: u64 = undefined; + var x294: u64 = undefined; + mulxU64(&x293, &x294, x4, 0x2d319b2419b409a9); + var x295: u64 = undefined; + var x296: u1 = undefined; + addcarryxU64(&x295, &x296, 0x0, x294, x291); + var x297: u64 = undefined; + var x298: u1 = undefined; + addcarryxU64(&x297, &x298, x296, x292, x289); + var x299: u64 = undefined; + var x300: u1 = undefined; + addcarryxU64(&x299, &x300, x298, x290, x287); + var x301: u64 = undefined; + var x302: u1 = undefined; + addcarryxU64(&x301, &x302, x300, x288, x285); + var x303: u64 = undefined; + var x304: u1 = undefined; + addcarryxU64(&x303, &x304, x302, x286, x283); + var x305: u64 = undefined; + var x306: u1 = undefined; + addcarryxU64(&x305, &x306, 0x0, x271, x293); + var x307: u64 = undefined; + var x308: u1 = undefined; + addcarryxU64(&x307, &x308, x306, x273, x295); + var x309: u64 = undefined; + var x310: u1 = undefined; + addcarryxU64(&x309, &x310, x308, x275, x297); + var x311: u64 = undefined; + var x312: u1 = undefined; + addcarryxU64(&x311, &x312, x310, x277, x299); + var x313: u64 = undefined; + var x314: u1 = undefined; + addcarryxU64(&x313, &x314, x312, x279, x301); + var x315: u64 = undefined; + var x316: u1 = undefined; + addcarryxU64(&x315, &x316, x314, x281, x303); + var x317: u64 = undefined; + var x318: u64 = undefined; + mulxU64(&x317, &x318, x305, 0x6ed46089e88fdc45); + var x319: u64 = undefined; + var x320: u64 = undefined; + mulxU64(&x319, &x320, x317, 0xffffffffffffffff); + var x321: u64 = undefined; + var x322: u64 = undefined; + mulxU64(&x321, &x322, x317, 0xffffffffffffffff); + var x323: u64 = undefined; + var x324: u64 = undefined; + mulxU64(&x323, &x324, x317, 0xffffffffffffffff); + var x325: u64 = undefined; + var x326: u64 = undefined; + mulxU64(&x325, &x326, x317, 0xc7634d81f4372ddf); + var x327: u64 = undefined; + var x328: u64 = undefined; + mulxU64(&x327, &x328, x317, 0x581a0db248b0a77a); + var x329: u64 = undefined; + var x330: u64 = undefined; + mulxU64(&x329, &x330, x317, 0xecec196accc52973); + var x331: u64 = undefined; + var x332: u1 = undefined; + addcarryxU64(&x331, &x332, 0x0, x330, x327); + var x333: u64 = undefined; + var x334: u1 = undefined; + addcarryxU64(&x333, &x334, x332, x328, x325); + var x335: u64 = undefined; + var x336: u1 = undefined; + addcarryxU64(&x335, &x336, x334, x326, x323); + var x337: u64 = undefined; + var x338: u1 = undefined; + addcarryxU64(&x337, &x338, x336, x324, x321); + var x339: u64 = undefined; + var x340: u1 = undefined; + addcarryxU64(&x339, &x340, x338, x322, x319); + var x341: u64 = undefined; + var x342: u1 = undefined; + addcarryxU64(&x341, &x342, 0x0, x305, x329); + var x343: u64 = undefined; + var x344: u1 = undefined; + addcarryxU64(&x343, &x344, x342, x307, x331); + var x345: u64 = undefined; + var x346: u1 = undefined; + addcarryxU64(&x345, &x346, x344, x309, x333); + var x347: u64 = undefined; + var x348: u1 = undefined; + addcarryxU64(&x347, &x348, x346, x311, x335); + var x349: u64 = undefined; + var x350: u1 = undefined; + addcarryxU64(&x349, &x350, x348, x313, x337); + var x351: u64 = undefined; + var x352: u1 = undefined; + addcarryxU64(&x351, &x352, x350, x315, x339); + var x353: u64 = undefined; + var x354: u1 = undefined; + addcarryxU64(&x353, &x354, x352, ((cast(u64, x316) + cast(u64, x282)) + (cast(u64, x304) + x284)), (cast(u64, x340) + x320)); + var x355: u64 = undefined; + var x356: u64 = undefined; + mulxU64(&x355, &x356, x5, 0xc84ee012b39bf21); + var x357: u64 = undefined; + var x358: u64 = undefined; + mulxU64(&x357, &x358, x5, 0x3fb05b7a28266895); + var x359: u64 = undefined; + var x360: u64 = undefined; + mulxU64(&x359, &x360, x5, 0xd40d49174aab1cc5); + var x361: u64 = undefined; + var x362: u64 = undefined; + mulxU64(&x361, &x362, x5, 0xbc3e483afcb82947); + var x363: u64 = undefined; + var x364: u64 = undefined; + mulxU64(&x363, &x364, x5, 0xff3d81e5df1aa419); + var x365: u64 = undefined; + var x366: u64 = undefined; + mulxU64(&x365, &x366, x5, 0x2d319b2419b409a9); + var x367: u64 = undefined; + var x368: u1 = undefined; + addcarryxU64(&x367, &x368, 0x0, x366, x363); + var x369: u64 = undefined; + var x370: u1 = undefined; + addcarryxU64(&x369, &x370, x368, x364, x361); + var x371: u64 = undefined; + var x372: u1 = undefined; + addcarryxU64(&x371, &x372, x370, x362, x359); + var x373: u64 = undefined; + var x374: u1 = undefined; + addcarryxU64(&x373, &x374, x372, x360, x357); + var x375: u64 = undefined; + var x376: u1 = undefined; + addcarryxU64(&x375, &x376, x374, x358, x355); + var x377: u64 = undefined; + var x378: u1 = undefined; + addcarryxU64(&x377, &x378, 0x0, x343, x365); + var x379: u64 = undefined; + var x380: u1 = undefined; + addcarryxU64(&x379, &x380, x378, x345, x367); + var x381: u64 = undefined; + var x382: u1 = undefined; + addcarryxU64(&x381, &x382, x380, x347, x369); + var x383: u64 = undefined; + var x384: u1 = undefined; + addcarryxU64(&x383, &x384, x382, x349, x371); + var x385: u64 = undefined; + var x386: u1 = undefined; + addcarryxU64(&x385, &x386, x384, x351, x373); + var x387: u64 = undefined; + var x388: u1 = undefined; + addcarryxU64(&x387, &x388, x386, x353, x375); + var x389: u64 = undefined; + var x390: u64 = undefined; + mulxU64(&x389, &x390, x377, 0x6ed46089e88fdc45); + var x391: u64 = undefined; + var x392: u64 = undefined; + mulxU64(&x391, &x392, x389, 0xffffffffffffffff); + var x393: u64 = undefined; + var x394: u64 = undefined; + mulxU64(&x393, &x394, x389, 0xffffffffffffffff); + var x395: u64 = undefined; + var x396: u64 = undefined; + mulxU64(&x395, &x396, x389, 0xffffffffffffffff); + var x397: u64 = undefined; + var x398: u64 = undefined; + mulxU64(&x397, &x398, x389, 0xc7634d81f4372ddf); + var x399: u64 = undefined; + var x400: u64 = undefined; + mulxU64(&x399, &x400, x389, 0x581a0db248b0a77a); + var x401: u64 = undefined; + var x402: u64 = undefined; + mulxU64(&x401, &x402, x389, 0xecec196accc52973); + var x403: u64 = undefined; + var x404: u1 = undefined; + addcarryxU64(&x403, &x404, 0x0, x402, x399); + var x405: u64 = undefined; + var x406: u1 = undefined; + addcarryxU64(&x405, &x406, x404, x400, x397); + var x407: u64 = undefined; + var x408: u1 = undefined; + addcarryxU64(&x407, &x408, x406, x398, x395); + var x409: u64 = undefined; + var x410: u1 = undefined; + addcarryxU64(&x409, &x410, x408, x396, x393); + var x411: u64 = undefined; + var x412: u1 = undefined; + addcarryxU64(&x411, &x412, x410, x394, x391); + var x413: u64 = undefined; + var x414: u1 = undefined; + addcarryxU64(&x413, &x414, 0x0, x377, x401); + var x415: u64 = undefined; + var x416: u1 = undefined; + addcarryxU64(&x415, &x416, x414, x379, x403); + var x417: u64 = undefined; + var x418: u1 = undefined; + addcarryxU64(&x417, &x418, x416, x381, x405); + var x419: u64 = undefined; + var x420: u1 = undefined; + addcarryxU64(&x419, &x420, x418, x383, x407); + var x421: u64 = undefined; + var x422: u1 = undefined; + addcarryxU64(&x421, &x422, x420, x385, x409); + var x423: u64 = undefined; + var x424: u1 = undefined; + addcarryxU64(&x423, &x424, x422, x387, x411); + var x425: u64 = undefined; + var x426: u1 = undefined; + addcarryxU64(&x425, &x426, x424, ((cast(u64, x388) + cast(u64, x354)) + (cast(u64, x376) + x356)), (cast(u64, x412) + x392)); + var x427: u64 = undefined; + var x428: u1 = undefined; + subborrowxU64(&x427, &x428, 0x0, x415, 0xecec196accc52973); + var x429: u64 = undefined; + var x430: u1 = undefined; + subborrowxU64(&x429, &x430, x428, x417, 0x581a0db248b0a77a); + var x431: u64 = undefined; + var x432: u1 = undefined; + subborrowxU64(&x431, &x432, x430, x419, 0xc7634d81f4372ddf); + var x433: u64 = undefined; + var x434: u1 = undefined; + subborrowxU64(&x433, &x434, x432, x421, 0xffffffffffffffff); + var x435: u64 = undefined; + var x436: u1 = undefined; + subborrowxU64(&x435, &x436, x434, x423, 0xffffffffffffffff); + var x437: u64 = undefined; + var x438: u1 = undefined; + subborrowxU64(&x437, &x438, x436, x425, 0xffffffffffffffff); + var x439: u64 = undefined; + var x440: u1 = undefined; + subborrowxU64(&x439, &x440, x438, cast(u64, x426), cast(u64, 0x0)); + var x441: u64 = undefined; + cmovznzU64(&x441, x440, x427, x415); + var x442: u64 = undefined; + cmovznzU64(&x442, x440, x429, x417); + var x443: u64 = undefined; + cmovznzU64(&x443, x440, x431, x419); + var x444: u64 = undefined; + cmovznzU64(&x444, x440, x433, x421); + var x445: u64 = undefined; + cmovznzU64(&x445, x440, x435, x423); + var x446: u64 = undefined; + cmovznzU64(&x446, x440, x437, x425); + out1[0] = x441; + out1[1] = x442; + out1[2] = x443; + out1[3] = x444; + out1[4] = x445; + out1[5] = x446; +} + +/// The function nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +pub fn nonzero(out1: *u64, arg1: [6]u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | (arg1[5])))))); + out1.* = x1; +} + +/// The function selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn selectznz(out1: *[6]u64, arg1: u1, arg2: [6]u64, arg3: [6]u64) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + cmovznzU64(&x1, arg1, (arg2[0]), (arg3[0])); + var x2: u64 = undefined; + cmovznzU64(&x2, arg1, (arg2[1]), (arg3[1])); + var x3: u64 = undefined; + cmovznzU64(&x3, arg1, (arg2[2]), (arg3[2])); + var x4: u64 = undefined; + cmovznzU64(&x4, arg1, (arg2[3]), (arg3[3])); + var x5: u64 = undefined; + cmovznzU64(&x5, arg1, (arg2[4]), (arg3[4])); + var x6: u64 = undefined; + cmovznzU64(&x6, arg1, (arg2[5]), (arg3[5])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; +} + +/// The function toBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +pub fn toBytes(out1: *[48]u8, arg1: [6]u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[5]); + const x2 = (arg1[4]); + const x3 = (arg1[3]); + const x4 = (arg1[2]); + const x5 = (arg1[1]); + const x6 = (arg1[0]); + const x7 = cast(u8, (x6 & cast(u64, 0xff))); + const x8 = (x6 >> 8); + const x9 = cast(u8, (x8 & cast(u64, 0xff))); + const x10 = (x8 >> 8); + const x11 = cast(u8, (x10 & cast(u64, 0xff))); + const x12 = (x10 >> 8); + const x13 = cast(u8, (x12 & cast(u64, 0xff))); + const x14 = (x12 >> 8); + const x15 = cast(u8, (x14 & cast(u64, 0xff))); + const x16 = (x14 >> 8); + const x17 = cast(u8, (x16 & cast(u64, 0xff))); + const x18 = (x16 >> 8); + const x19 = cast(u8, (x18 & cast(u64, 0xff))); + const x20 = cast(u8, (x18 >> 8)); + const x21 = cast(u8, (x5 & cast(u64, 0xff))); + const x22 = (x5 >> 8); + const x23 = cast(u8, (x22 & cast(u64, 0xff))); + const x24 = (x22 >> 8); + const x25 = cast(u8, (x24 & cast(u64, 0xff))); + const x26 = (x24 >> 8); + const x27 = cast(u8, (x26 & cast(u64, 0xff))); + const x28 = (x26 >> 8); + const x29 = cast(u8, (x28 & cast(u64, 0xff))); + const x30 = (x28 >> 8); + const x31 = cast(u8, (x30 & cast(u64, 0xff))); + const x32 = (x30 >> 8); + const x33 = cast(u8, (x32 & cast(u64, 0xff))); + const x34 = cast(u8, (x32 >> 8)); + const x35 = cast(u8, (x4 & cast(u64, 0xff))); + const x36 = (x4 >> 8); + const x37 = cast(u8, (x36 & cast(u64, 0xff))); + const x38 = (x36 >> 8); + const x39 = cast(u8, (x38 & cast(u64, 0xff))); + const x40 = (x38 >> 8); + const x41 = cast(u8, (x40 & cast(u64, 0xff))); + const x42 = (x40 >> 8); + const x43 = cast(u8, (x42 & cast(u64, 0xff))); + const x44 = (x42 >> 8); + const x45 = cast(u8, (x44 & cast(u64, 0xff))); + const x46 = (x44 >> 8); + const x47 = cast(u8, (x46 & cast(u64, 0xff))); + const x48 = cast(u8, (x46 >> 8)); + const x49 = cast(u8, (x3 & cast(u64, 0xff))); + const x50 = (x3 >> 8); + const x51 = cast(u8, (x50 & cast(u64, 0xff))); + const x52 = (x50 >> 8); + const x53 = cast(u8, (x52 & cast(u64, 0xff))); + const x54 = (x52 >> 8); + const x55 = cast(u8, (x54 & cast(u64, 0xff))); + const x56 = (x54 >> 8); + const x57 = cast(u8, (x56 & cast(u64, 0xff))); + const x58 = (x56 >> 8); + const x59 = cast(u8, (x58 & cast(u64, 0xff))); + const x60 = (x58 >> 8); + const x61 = cast(u8, (x60 & cast(u64, 0xff))); + const x62 = cast(u8, (x60 >> 8)); + const x63 = cast(u8, (x2 & cast(u64, 0xff))); + const x64 = (x2 >> 8); + const x65 = cast(u8, (x64 & cast(u64, 0xff))); + const x66 = (x64 >> 8); + const x67 = cast(u8, (x66 & cast(u64, 0xff))); + const x68 = (x66 >> 8); + const x69 = cast(u8, (x68 & cast(u64, 0xff))); + const x70 = (x68 >> 8); + const x71 = cast(u8, (x70 & cast(u64, 0xff))); + const x72 = (x70 >> 8); + const x73 = cast(u8, (x72 & cast(u64, 0xff))); + const x74 = (x72 >> 8); + const x75 = cast(u8, (x74 & cast(u64, 0xff))); + const x76 = cast(u8, (x74 >> 8)); + const x77 = cast(u8, (x1 & cast(u64, 0xff))); + const x78 = (x1 >> 8); + const x79 = cast(u8, (x78 & cast(u64, 0xff))); + const x80 = (x78 >> 8); + const x81 = cast(u8, (x80 & cast(u64, 0xff))); + const x82 = (x80 >> 8); + const x83 = cast(u8, (x82 & cast(u64, 0xff))); + const x84 = (x82 >> 8); + const x85 = cast(u8, (x84 & cast(u64, 0xff))); + const x86 = (x84 >> 8); + const x87 = cast(u8, (x86 & cast(u64, 0xff))); + const x88 = (x86 >> 8); + const x89 = cast(u8, (x88 & cast(u64, 0xff))); + const x90 = cast(u8, (x88 >> 8)); + out1[0] = x7; + out1[1] = x9; + out1[2] = x11; + out1[3] = x13; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x27; + out1[12] = x29; + out1[13] = x31; + out1[14] = x33; + out1[15] = x34; + out1[16] = x35; + out1[17] = x37; + out1[18] = x39; + out1[19] = x41; + out1[20] = x43; + out1[21] = x45; + out1[22] = x47; + out1[23] = x48; + out1[24] = x49; + out1[25] = x51; + out1[26] = x53; + out1[27] = x55; + out1[28] = x57; + out1[29] = x59; + out1[30] = x61; + out1[31] = x62; + out1[32] = x63; + out1[33] = x65; + out1[34] = x67; + out1[35] = x69; + out1[36] = x71; + out1[37] = x73; + out1[38] = x75; + out1[39] = x76; + out1[40] = x77; + out1[41] = x79; + out1[42] = x81; + out1[43] = x83; + out1[44] = x85; + out1[45] = x87; + out1[46] = x89; + out1[47] = x90; +} + +/// The function fromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn fromBytes(out1: *[6]u64, arg1: [48]u8) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u64, (arg1[47])) << 56); + const x2 = (cast(u64, (arg1[46])) << 48); + const x3 = (cast(u64, (arg1[45])) << 40); + const x4 = (cast(u64, (arg1[44])) << 32); + const x5 = (cast(u64, (arg1[43])) << 24); + const x6 = (cast(u64, (arg1[42])) << 16); + const x7 = (cast(u64, (arg1[41])) << 8); + const x8 = (arg1[40]); + const x9 = (cast(u64, (arg1[39])) << 56); + const x10 = (cast(u64, (arg1[38])) << 48); + const x11 = (cast(u64, (arg1[37])) << 40); + const x12 = (cast(u64, (arg1[36])) << 32); + const x13 = (cast(u64, (arg1[35])) << 24); + const x14 = (cast(u64, (arg1[34])) << 16); + const x15 = (cast(u64, (arg1[33])) << 8); + const x16 = (arg1[32]); + const x17 = (cast(u64, (arg1[31])) << 56); + const x18 = (cast(u64, (arg1[30])) << 48); + const x19 = (cast(u64, (arg1[29])) << 40); + const x20 = (cast(u64, (arg1[28])) << 32); + const x21 = (cast(u64, (arg1[27])) << 24); + const x22 = (cast(u64, (arg1[26])) << 16); + const x23 = (cast(u64, (arg1[25])) << 8); + const x24 = (arg1[24]); + const x25 = (cast(u64, (arg1[23])) << 56); + const x26 = (cast(u64, (arg1[22])) << 48); + const x27 = (cast(u64, (arg1[21])) << 40); + const x28 = (cast(u64, (arg1[20])) << 32); + const x29 = (cast(u64, (arg1[19])) << 24); + const x30 = (cast(u64, (arg1[18])) << 16); + const x31 = (cast(u64, (arg1[17])) << 8); + const x32 = (arg1[16]); + const x33 = (cast(u64, (arg1[15])) << 56); + const x34 = (cast(u64, (arg1[14])) << 48); + const x35 = (cast(u64, (arg1[13])) << 40); + const x36 = (cast(u64, (arg1[12])) << 32); + const x37 = (cast(u64, (arg1[11])) << 24); + const x38 = (cast(u64, (arg1[10])) << 16); + const x39 = (cast(u64, (arg1[9])) << 8); + const x40 = (arg1[8]); + const x41 = (cast(u64, (arg1[7])) << 56); + const x42 = (cast(u64, (arg1[6])) << 48); + const x43 = (cast(u64, (arg1[5])) << 40); + const x44 = (cast(u64, (arg1[4])) << 32); + const x45 = (cast(u64, (arg1[3])) << 24); + const x46 = (cast(u64, (arg1[2])) << 16); + const x47 = (cast(u64, (arg1[1])) << 8); + const x48 = (arg1[0]); + const x49 = (x47 + cast(u64, x48)); + const x50 = (x46 + x49); + const x51 = (x45 + x50); + const x52 = (x44 + x51); + const x53 = (x43 + x52); + const x54 = (x42 + x53); + const x55 = (x41 + x54); + const x56 = (x39 + cast(u64, x40)); + const x57 = (x38 + x56); + const x58 = (x37 + x57); + const x59 = (x36 + x58); + const x60 = (x35 + x59); + const x61 = (x34 + x60); + const x62 = (x33 + x61); + const x63 = (x31 + cast(u64, x32)); + const x64 = (x30 + x63); + const x65 = (x29 + x64); + const x66 = (x28 + x65); + const x67 = (x27 + x66); + const x68 = (x26 + x67); + const x69 = (x25 + x68); + const x70 = (x23 + cast(u64, x24)); + const x71 = (x22 + x70); + const x72 = (x21 + x71); + const x73 = (x20 + x72); + const x74 = (x19 + x73); + const x75 = (x18 + x74); + const x76 = (x17 + x75); + const x77 = (x15 + cast(u64, x16)); + const x78 = (x14 + x77); + const x79 = (x13 + x78); + const x80 = (x12 + x79); + const x81 = (x11 + x80); + const x82 = (x10 + x81); + const x83 = (x9 + x82); + const x84 = (x7 + cast(u64, x8)); + const x85 = (x6 + x84); + const x86 = (x5 + x85); + const x87 = (x4 + x86); + const x88 = (x3 + x87); + const x89 = (x2 + x88); + const x90 = (x1 + x89); + out1[0] = x55; + out1[1] = x62; + out1[2] = x69; + out1[3] = x76; + out1[4] = x83; + out1[5] = x90; +} + +/// The function setOne returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn setOne(out1: *MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0x1313e695333ad68d; + out1[1] = 0xa7e5f24db74f5885; + out1[2] = 0x389cb27e0bc8d220; + out1[3] = cast(u64, 0x0); + out1[4] = cast(u64, 0x0); + out1[5] = cast(u64, 0x0); +} + +/// The function msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn msat(out1: *[7]u64) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xecec196accc52973; + out1[1] = 0x581a0db248b0a77a; + out1[2] = 0xc7634d81f4372ddf; + out1[3] = 0xffffffffffffffff; + out1[4] = 0xffffffffffffffff; + out1[5] = 0xffffffffffffffff; + out1[6] = cast(u64, 0x0); +} + +/// The function divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn divstep(out1: *u64, out2: *[7]u64, out3: *[7]u64, out4: *[6]u64, out5: *[6]u64, arg1: u64, arg2: [7]u64, arg3: [7]u64, arg4: [6]u64, arg5: [6]u64) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + addcarryxU64(&x1, &x2, 0x0, (~arg1), cast(u64, 0x1)); + const x3 = (cast(u1, (x1 >> 63)) & cast(u1, ((arg3[0]) & cast(u64, 0x1)))); + var x4: u64 = undefined; + var x5: u1 = undefined; + addcarryxU64(&x4, &x5, 0x0, (~arg1), cast(u64, 0x1)); + var x6: u64 = undefined; + cmovznzU64(&x6, x3, arg1, x4); + var x7: u64 = undefined; + cmovznzU64(&x7, x3, (arg2[0]), (arg3[0])); + var x8: u64 = undefined; + cmovznzU64(&x8, x3, (arg2[1]), (arg3[1])); + var x9: u64 = undefined; + cmovznzU64(&x9, x3, (arg2[2]), (arg3[2])); + var x10: u64 = undefined; + cmovznzU64(&x10, x3, (arg2[3]), (arg3[3])); + var x11: u64 = undefined; + cmovznzU64(&x11, x3, (arg2[4]), (arg3[4])); + var x12: u64 = undefined; + cmovznzU64(&x12, x3, (arg2[5]), (arg3[5])); + var x13: u64 = undefined; + cmovznzU64(&x13, x3, (arg2[6]), (arg3[6])); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, 0x0, cast(u64, 0x1), (~(arg2[0]))); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, cast(u64, 0x0), (~(arg2[1]))); + var x18: u64 = undefined; + var x19: u1 = undefined; + addcarryxU64(&x18, &x19, x17, cast(u64, 0x0), (~(arg2[2]))); + var x20: u64 = undefined; + var x21: u1 = undefined; + addcarryxU64(&x20, &x21, x19, cast(u64, 0x0), (~(arg2[3]))); + var x22: u64 = undefined; + var x23: u1 = undefined; + addcarryxU64(&x22, &x23, x21, cast(u64, 0x0), (~(arg2[4]))); + var x24: u64 = undefined; + var x25: u1 = undefined; + addcarryxU64(&x24, &x25, x23, cast(u64, 0x0), (~(arg2[5]))); + var x26: u64 = undefined; + var x27: u1 = undefined; + addcarryxU64(&x26, &x27, x25, cast(u64, 0x0), (~(arg2[6]))); + var x28: u64 = undefined; + cmovznzU64(&x28, x3, (arg3[0]), x14); + var x29: u64 = undefined; + cmovznzU64(&x29, x3, (arg3[1]), x16); + var x30: u64 = undefined; + cmovznzU64(&x30, x3, (arg3[2]), x18); + var x31: u64 = undefined; + cmovznzU64(&x31, x3, (arg3[3]), x20); + var x32: u64 = undefined; + cmovznzU64(&x32, x3, (arg3[4]), x22); + var x33: u64 = undefined; + cmovznzU64(&x33, x3, (arg3[5]), x24); + var x34: u64 = undefined; + cmovznzU64(&x34, x3, (arg3[6]), x26); + var x35: u64 = undefined; + cmovznzU64(&x35, x3, (arg4[0]), (arg5[0])); + var x36: u64 = undefined; + cmovznzU64(&x36, x3, (arg4[1]), (arg5[1])); + var x37: u64 = undefined; + cmovznzU64(&x37, x3, (arg4[2]), (arg5[2])); + var x38: u64 = undefined; + cmovznzU64(&x38, x3, (arg4[3]), (arg5[3])); + var x39: u64 = undefined; + cmovznzU64(&x39, x3, (arg4[4]), (arg5[4])); + var x40: u64 = undefined; + cmovznzU64(&x40, x3, (arg4[5]), (arg5[5])); + var x41: u64 = undefined; + var x42: u1 = undefined; + addcarryxU64(&x41, &x42, 0x0, x35, x35); + var x43: u64 = undefined; + var x44: u1 = undefined; + addcarryxU64(&x43, &x44, x42, x36, x36); + var x45: u64 = undefined; + var x46: u1 = undefined; + addcarryxU64(&x45, &x46, x44, x37, x37); + var x47: u64 = undefined; + var x48: u1 = undefined; + addcarryxU64(&x47, &x48, x46, x38, x38); + var x49: u64 = undefined; + var x50: u1 = undefined; + addcarryxU64(&x49, &x50, x48, x39, x39); + var x51: u64 = undefined; + var x52: u1 = undefined; + addcarryxU64(&x51, &x52, x50, x40, x40); + var x53: u64 = undefined; + var x54: u1 = undefined; + subborrowxU64(&x53, &x54, 0x0, x41, 0xecec196accc52973); + var x55: u64 = undefined; + var x56: u1 = undefined; + subborrowxU64(&x55, &x56, x54, x43, 0x581a0db248b0a77a); + var x57: u64 = undefined; + var x58: u1 = undefined; + subborrowxU64(&x57, &x58, x56, x45, 0xc7634d81f4372ddf); + var x59: u64 = undefined; + var x60: u1 = undefined; + subborrowxU64(&x59, &x60, x58, x47, 0xffffffffffffffff); + var x61: u64 = undefined; + var x62: u1 = undefined; + subborrowxU64(&x61, &x62, x60, x49, 0xffffffffffffffff); + var x63: u64 = undefined; + var x64: u1 = undefined; + subborrowxU64(&x63, &x64, x62, x51, 0xffffffffffffffff); + var x65: u64 = undefined; + var x66: u1 = undefined; + subborrowxU64(&x65, &x66, x64, cast(u64, x52), cast(u64, 0x0)); + const x67 = (arg4[5]); + const x68 = (arg4[4]); + const x69 = (arg4[3]); + const x70 = (arg4[2]); + const x71 = (arg4[1]); + const x72 = (arg4[0]); + var x73: u64 = undefined; + var x74: u1 = undefined; + subborrowxU64(&x73, &x74, 0x0, cast(u64, 0x0), x72); + var x75: u64 = undefined; + var x76: u1 = undefined; + subborrowxU64(&x75, &x76, x74, cast(u64, 0x0), x71); + var x77: u64 = undefined; + var x78: u1 = undefined; + subborrowxU64(&x77, &x78, x76, cast(u64, 0x0), x70); + var x79: u64 = undefined; + var x80: u1 = undefined; + subborrowxU64(&x79, &x80, x78, cast(u64, 0x0), x69); + var x81: u64 = undefined; + var x82: u1 = undefined; + subborrowxU64(&x81, &x82, x80, cast(u64, 0x0), x68); + var x83: u64 = undefined; + var x84: u1 = undefined; + subborrowxU64(&x83, &x84, x82, cast(u64, 0x0), x67); + var x85: u64 = undefined; + cmovznzU64(&x85, x84, cast(u64, 0x0), 0xffffffffffffffff); + var x86: u64 = undefined; + var x87: u1 = undefined; + addcarryxU64(&x86, &x87, 0x0, x73, (x85 & 0xecec196accc52973)); + var x88: u64 = undefined; + var x89: u1 = undefined; + addcarryxU64(&x88, &x89, x87, x75, (x85 & 0x581a0db248b0a77a)); + var x90: u64 = undefined; + var x91: u1 = undefined; + addcarryxU64(&x90, &x91, x89, x77, (x85 & 0xc7634d81f4372ddf)); + var x92: u64 = undefined; + var x93: u1 = undefined; + addcarryxU64(&x92, &x93, x91, x79, x85); + var x94: u64 = undefined; + var x95: u1 = undefined; + addcarryxU64(&x94, &x95, x93, x81, x85); + var x96: u64 = undefined; + var x97: u1 = undefined; + addcarryxU64(&x96, &x97, x95, x83, x85); + var x98: u64 = undefined; + cmovznzU64(&x98, x3, (arg5[0]), x86); + var x99: u64 = undefined; + cmovznzU64(&x99, x3, (arg5[1]), x88); + var x100: u64 = undefined; + cmovznzU64(&x100, x3, (arg5[2]), x90); + var x101: u64 = undefined; + cmovznzU64(&x101, x3, (arg5[3]), x92); + var x102: u64 = undefined; + cmovznzU64(&x102, x3, (arg5[4]), x94); + var x103: u64 = undefined; + cmovznzU64(&x103, x3, (arg5[5]), x96); + const x104 = cast(u1, (x28 & cast(u64, 0x1))); + var x105: u64 = undefined; + cmovznzU64(&x105, x104, cast(u64, 0x0), x7); + var x106: u64 = undefined; + cmovznzU64(&x106, x104, cast(u64, 0x0), x8); + var x107: u64 = undefined; + cmovznzU64(&x107, x104, cast(u64, 0x0), x9); + var x108: u64 = undefined; + cmovznzU64(&x108, x104, cast(u64, 0x0), x10); + var x109: u64 = undefined; + cmovznzU64(&x109, x104, cast(u64, 0x0), x11); + var x110: u64 = undefined; + cmovznzU64(&x110, x104, cast(u64, 0x0), x12); + var x111: u64 = undefined; + cmovznzU64(&x111, x104, cast(u64, 0x0), x13); + var x112: u64 = undefined; + var x113: u1 = undefined; + addcarryxU64(&x112, &x113, 0x0, x28, x105); + var x114: u64 = undefined; + var x115: u1 = undefined; + addcarryxU64(&x114, &x115, x113, x29, x106); + var x116: u64 = undefined; + var x117: u1 = undefined; + addcarryxU64(&x116, &x117, x115, x30, x107); + var x118: u64 = undefined; + var x119: u1 = undefined; + addcarryxU64(&x118, &x119, x117, x31, x108); + var x120: u64 = undefined; + var x121: u1 = undefined; + addcarryxU64(&x120, &x121, x119, x32, x109); + var x122: u64 = undefined; + var x123: u1 = undefined; + addcarryxU64(&x122, &x123, x121, x33, x110); + var x124: u64 = undefined; + var x125: u1 = undefined; + addcarryxU64(&x124, &x125, x123, x34, x111); + var x126: u64 = undefined; + cmovznzU64(&x126, x104, cast(u64, 0x0), x35); + var x127: u64 = undefined; + cmovznzU64(&x127, x104, cast(u64, 0x0), x36); + var x128: u64 = undefined; + cmovznzU64(&x128, x104, cast(u64, 0x0), x37); + var x129: u64 = undefined; + cmovznzU64(&x129, x104, cast(u64, 0x0), x38); + var x130: u64 = undefined; + cmovznzU64(&x130, x104, cast(u64, 0x0), x39); + var x131: u64 = undefined; + cmovznzU64(&x131, x104, cast(u64, 0x0), x40); + var x132: u64 = undefined; + var x133: u1 = undefined; + addcarryxU64(&x132, &x133, 0x0, x98, x126); + var x134: u64 = undefined; + var x135: u1 = undefined; + addcarryxU64(&x134, &x135, x133, x99, x127); + var x136: u64 = undefined; + var x137: u1 = undefined; + addcarryxU64(&x136, &x137, x135, x100, x128); + var x138: u64 = undefined; + var x139: u1 = undefined; + addcarryxU64(&x138, &x139, x137, x101, x129); + var x140: u64 = undefined; + var x141: u1 = undefined; + addcarryxU64(&x140, &x141, x139, x102, x130); + var x142: u64 = undefined; + var x143: u1 = undefined; + addcarryxU64(&x142, &x143, x141, x103, x131); + var x144: u64 = undefined; + var x145: u1 = undefined; + subborrowxU64(&x144, &x145, 0x0, x132, 0xecec196accc52973); + var x146: u64 = undefined; + var x147: u1 = undefined; + subborrowxU64(&x146, &x147, x145, x134, 0x581a0db248b0a77a); + var x148: u64 = undefined; + var x149: u1 = undefined; + subborrowxU64(&x148, &x149, x147, x136, 0xc7634d81f4372ddf); + var x150: u64 = undefined; + var x151: u1 = undefined; + subborrowxU64(&x150, &x151, x149, x138, 0xffffffffffffffff); + var x152: u64 = undefined; + var x153: u1 = undefined; + subborrowxU64(&x152, &x153, x151, x140, 0xffffffffffffffff); + var x154: u64 = undefined; + var x155: u1 = undefined; + subborrowxU64(&x154, &x155, x153, x142, 0xffffffffffffffff); + var x156: u64 = undefined; + var x157: u1 = undefined; + subborrowxU64(&x156, &x157, x155, cast(u64, x143), cast(u64, 0x0)); + var x158: u64 = undefined; + var x159: u1 = undefined; + addcarryxU64(&x158, &x159, 0x0, x6, cast(u64, 0x1)); + const x160 = ((x112 >> 1) | ((x114 << 63) & 0xffffffffffffffff)); + const x161 = ((x114 >> 1) | ((x116 << 63) & 0xffffffffffffffff)); + const x162 = ((x116 >> 1) | ((x118 << 63) & 0xffffffffffffffff)); + const x163 = ((x118 >> 1) | ((x120 << 63) & 0xffffffffffffffff)); + const x164 = ((x120 >> 1) | ((x122 << 63) & 0xffffffffffffffff)); + const x165 = ((x122 >> 1) | ((x124 << 63) & 0xffffffffffffffff)); + const x166 = ((x124 & 0x8000000000000000) | (x124 >> 1)); + var x167: u64 = undefined; + cmovznzU64(&x167, x66, x53, x41); + var x168: u64 = undefined; + cmovznzU64(&x168, x66, x55, x43); + var x169: u64 = undefined; + cmovznzU64(&x169, x66, x57, x45); + var x170: u64 = undefined; + cmovznzU64(&x170, x66, x59, x47); + var x171: u64 = undefined; + cmovznzU64(&x171, x66, x61, x49); + var x172: u64 = undefined; + cmovznzU64(&x172, x66, x63, x51); + var x173: u64 = undefined; + cmovznzU64(&x173, x157, x144, x132); + var x174: u64 = undefined; + cmovznzU64(&x174, x157, x146, x134); + var x175: u64 = undefined; + cmovznzU64(&x175, x157, x148, x136); + var x176: u64 = undefined; + cmovznzU64(&x176, x157, x150, x138); + var x177: u64 = undefined; + cmovznzU64(&x177, x157, x152, x140); + var x178: u64 = undefined; + cmovznzU64(&x178, x157, x154, x142); + out1.* = x158; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out3[0] = x160; + out3[1] = x161; + out3[2] = x162; + out3[3] = x163; + out3[4] = x164; + out3[5] = x165; + out3[6] = x166; + out4[0] = x167; + out4[1] = x168; + out4[2] = x169; + out4[3] = x170; + out4[4] = x171; + out4[5] = x172; + out5[0] = x173; + out5[1] = x174; + out5[2] = x175; + out5[3] = x176; + out5[4] = x177; + out5[5] = x178; +} + +/// The function divstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn divstepPrecomp(out1: *[6]u64) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0x49589ae0e6045b6a; + out1[1] = 0x3c9a5352870040ed; + out1[2] = 0xdacb097e977dc242; + out1[3] = 0xb5ab30a6d1ecbe36; + out1[4] = 0x97d7a1081f959973; + out1[5] = 0x2ba012f8d27192bc; +} diff --git a/fiat-zig/src/secp256k1_scalar_32.zig b/fiat-zig/src/secp256k1_scalar_32.zig new file mode 100644 index 0000000000..de0da4b9e6 --- /dev/null +++ b/fiat-zig/src/secp256k1_scalar_32.zig @@ -0,0 +1,5627 @@ +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Zig --internal-static --public-function-case camelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case UpperCamelCase --no-prefix-fiat --package-name secp256k1_scalar '' 32 '2^256 - 432420386565659656852420866394968145599' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// curve description (via package name): secp256k1_scalar +// machine_wordsize = 32 (from "32") +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// m = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141 (from "2^256 - 432420386565659656852420866394968145599") +// +// NOTE: In addition to the bounds specified above each function, all +// functions synthesized for this Montgomery arithmetic require the +// input to be strictly less than the prime modulus (m), and also +// require the input to be in the unique saturated representation. +// All functions also ensure that these two properties are true of +// return values. +// +// Computed values: +// eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +// twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) in +// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 + +const std = @import("std"); +const mode = @import("builtin").mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels + +inline fn cast(comptime DestType: type, target: anytype) DestType { + if (@typeInfo(@TypeOf(target)) == .Int) { + const dest = @typeInfo(DestType).Int; + const source = @typeInfo(@TypeOf(target)).Int; + if (dest.bits < source.bits) { + return @bitCast(DestType, @truncate(std.meta.Int(source.signedness, dest.bits), target)); + } else { + return @bitCast(DestType, @as(std.meta.Int(source.signedness, dest.bits), target)); + } + } + return @as(DestType, target); +} + +// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub const MontgomeryDomainFieldElement = [8]u32; + +// The type NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub const NonMontgomeryDomainFieldElement = [8]u32; + +/// The function addcarryxU32 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^32 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +inline fn addcarryxU32(out1: *u32, out2: *u1, arg1: u1, arg2: u32, arg3: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(u64, arg1) + cast(u64, arg2)) + cast(u64, arg3)); + const x2 = cast(u32, (x1 & cast(u64, 0xffffffff))); + const x3 = cast(u1, (x1 >> 32)); + out1.* = x2; + out2.* = x3; +} + +/// The function subborrowxU32 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^32 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0x1] +inline fn subborrowxU32(out1: *u32, out2: *u1, arg1: u1, arg2: u32, arg3: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(i64, arg2) - cast(i64, arg1)) - cast(i64, arg3)); + const x2 = cast(i1, (x1 >> 32)); + const x3 = cast(u32, (x1 & cast(i64, 0xffffffff))); + out1.* = x3; + out2.* = cast(u1, (cast(i2, 0x0) - cast(i2, x2))); +} + +/// The function mulxU32 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^32 +/// out2 = ⌊arg1 * arg2 / 2^32⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [0x0 ~> 0xffffffff] +inline fn mulxU32(out1: *u32, out2: *u32, arg1: u32, arg2: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u64, arg1) * cast(u64, arg2)); + const x2 = cast(u32, (x1 & cast(u64, 0xffffffff))); + const x3 = cast(u32, (x1 >> 32)); + out1.* = x2; + out2.* = x3; +} + +/// The function cmovznzU32 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffff] +/// arg3: [0x0 ~> 0xffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +inline fn cmovznzU32(out1: *u32, arg1: u1, arg2: u32, arg3: u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (~(~arg1)); + const x2 = cast(u32, (cast(i64, cast(i1, (cast(i2, 0x0) - cast(i2, x1)))) & cast(i64, 0xffffffff))); + const x3 = ((x2 & arg3) | ((~x2) & arg2)); + out1.* = x3; +} + +/// The function mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn mul(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[6]); + const x7 = (arg1[7]); + const x8 = (arg1[0]); + var x9: u32 = undefined; + var x10: u32 = undefined; + mulxU32(&x9, &x10, x8, (arg2[7])); + var x11: u32 = undefined; + var x12: u32 = undefined; + mulxU32(&x11, &x12, x8, (arg2[6])); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x8, (arg2[5])); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x8, (arg2[4])); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x8, (arg2[3])); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x8, (arg2[2])); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x8, (arg2[1])); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x8, (arg2[0])); + var x25: u32 = undefined; + var x26: u1 = undefined; + addcarryxU32(&x25, &x26, 0x0, x24, x21); + var x27: u32 = undefined; + var x28: u1 = undefined; + addcarryxU32(&x27, &x28, x26, x22, x19); + var x29: u32 = undefined; + var x30: u1 = undefined; + addcarryxU32(&x29, &x30, x28, x20, x17); + var x31: u32 = undefined; + var x32: u1 = undefined; + addcarryxU32(&x31, &x32, x30, x18, x15); + var x33: u32 = undefined; + var x34: u1 = undefined; + addcarryxU32(&x33, &x34, x32, x16, x13); + var x35: u32 = undefined; + var x36: u1 = undefined; + addcarryxU32(&x35, &x36, x34, x14, x11); + var x37: u32 = undefined; + var x38: u1 = undefined; + addcarryxU32(&x37, &x38, x36, x12, x9); + const x39 = (cast(u32, x38) + x10); + var x40: u32 = undefined; + var x41: u32 = undefined; + mulxU32(&x40, &x41, x23, 0x5588b13f); + var x42: u32 = undefined; + var x43: u32 = undefined; + mulxU32(&x42, &x43, x40, 0xffffffff); + var x44: u32 = undefined; + var x45: u32 = undefined; + mulxU32(&x44, &x45, x40, 0xffffffff); + var x46: u32 = undefined; + var x47: u32 = undefined; + mulxU32(&x46, &x47, x40, 0xffffffff); + var x48: u32 = undefined; + var x49: u32 = undefined; + mulxU32(&x48, &x49, x40, 0xfffffffe); + var x50: u32 = undefined; + var x51: u32 = undefined; + mulxU32(&x50, &x51, x40, 0xbaaedce6); + var x52: u32 = undefined; + var x53: u32 = undefined; + mulxU32(&x52, &x53, x40, 0xaf48a03b); + var x54: u32 = undefined; + var x55: u32 = undefined; + mulxU32(&x54, &x55, x40, 0xbfd25e8c); + var x56: u32 = undefined; + var x57: u32 = undefined; + mulxU32(&x56, &x57, x40, 0xd0364141); + var x58: u32 = undefined; + var x59: u1 = undefined; + addcarryxU32(&x58, &x59, 0x0, x57, x54); + var x60: u32 = undefined; + var x61: u1 = undefined; + addcarryxU32(&x60, &x61, x59, x55, x52); + var x62: u32 = undefined; + var x63: u1 = undefined; + addcarryxU32(&x62, &x63, x61, x53, x50); + var x64: u32 = undefined; + var x65: u1 = undefined; + addcarryxU32(&x64, &x65, x63, x51, x48); + var x66: u32 = undefined; + var x67: u1 = undefined; + addcarryxU32(&x66, &x67, x65, x49, x46); + var x68: u32 = undefined; + var x69: u1 = undefined; + addcarryxU32(&x68, &x69, x67, x47, x44); + var x70: u32 = undefined; + var x71: u1 = undefined; + addcarryxU32(&x70, &x71, x69, x45, x42); + const x72 = (cast(u32, x71) + x43); + var x73: u32 = undefined; + var x74: u1 = undefined; + addcarryxU32(&x73, &x74, 0x0, x23, x56); + var x75: u32 = undefined; + var x76: u1 = undefined; + addcarryxU32(&x75, &x76, x74, x25, x58); + var x77: u32 = undefined; + var x78: u1 = undefined; + addcarryxU32(&x77, &x78, x76, x27, x60); + var x79: u32 = undefined; + var x80: u1 = undefined; + addcarryxU32(&x79, &x80, x78, x29, x62); + var x81: u32 = undefined; + var x82: u1 = undefined; + addcarryxU32(&x81, &x82, x80, x31, x64); + var x83: u32 = undefined; + var x84: u1 = undefined; + addcarryxU32(&x83, &x84, x82, x33, x66); + var x85: u32 = undefined; + var x86: u1 = undefined; + addcarryxU32(&x85, &x86, x84, x35, x68); + var x87: u32 = undefined; + var x88: u1 = undefined; + addcarryxU32(&x87, &x88, x86, x37, x70); + var x89: u32 = undefined; + var x90: u1 = undefined; + addcarryxU32(&x89, &x90, x88, x39, x72); + var x91: u32 = undefined; + var x92: u32 = undefined; + mulxU32(&x91, &x92, x1, (arg2[7])); + var x93: u32 = undefined; + var x94: u32 = undefined; + mulxU32(&x93, &x94, x1, (arg2[6])); + var x95: u32 = undefined; + var x96: u32 = undefined; + mulxU32(&x95, &x96, x1, (arg2[5])); + var x97: u32 = undefined; + var x98: u32 = undefined; + mulxU32(&x97, &x98, x1, (arg2[4])); + var x99: u32 = undefined; + var x100: u32 = undefined; + mulxU32(&x99, &x100, x1, (arg2[3])); + var x101: u32 = undefined; + var x102: u32 = undefined; + mulxU32(&x101, &x102, x1, (arg2[2])); + var x103: u32 = undefined; + var x104: u32 = undefined; + mulxU32(&x103, &x104, x1, (arg2[1])); + var x105: u32 = undefined; + var x106: u32 = undefined; + mulxU32(&x105, &x106, x1, (arg2[0])); + var x107: u32 = undefined; + var x108: u1 = undefined; + addcarryxU32(&x107, &x108, 0x0, x106, x103); + var x109: u32 = undefined; + var x110: u1 = undefined; + addcarryxU32(&x109, &x110, x108, x104, x101); + var x111: u32 = undefined; + var x112: u1 = undefined; + addcarryxU32(&x111, &x112, x110, x102, x99); + var x113: u32 = undefined; + var x114: u1 = undefined; + addcarryxU32(&x113, &x114, x112, x100, x97); + var x115: u32 = undefined; + var x116: u1 = undefined; + addcarryxU32(&x115, &x116, x114, x98, x95); + var x117: u32 = undefined; + var x118: u1 = undefined; + addcarryxU32(&x117, &x118, x116, x96, x93); + var x119: u32 = undefined; + var x120: u1 = undefined; + addcarryxU32(&x119, &x120, x118, x94, x91); + const x121 = (cast(u32, x120) + x92); + var x122: u32 = undefined; + var x123: u1 = undefined; + addcarryxU32(&x122, &x123, 0x0, x75, x105); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, x77, x107); + var x126: u32 = undefined; + var x127: u1 = undefined; + addcarryxU32(&x126, &x127, x125, x79, x109); + var x128: u32 = undefined; + var x129: u1 = undefined; + addcarryxU32(&x128, &x129, x127, x81, x111); + var x130: u32 = undefined; + var x131: u1 = undefined; + addcarryxU32(&x130, &x131, x129, x83, x113); + var x132: u32 = undefined; + var x133: u1 = undefined; + addcarryxU32(&x132, &x133, x131, x85, x115); + var x134: u32 = undefined; + var x135: u1 = undefined; + addcarryxU32(&x134, &x135, x133, x87, x117); + var x136: u32 = undefined; + var x137: u1 = undefined; + addcarryxU32(&x136, &x137, x135, x89, x119); + var x138: u32 = undefined; + var x139: u1 = undefined; + addcarryxU32(&x138, &x139, x137, cast(u32, x90), x121); + var x140: u32 = undefined; + var x141: u32 = undefined; + mulxU32(&x140, &x141, x122, 0x5588b13f); + var x142: u32 = undefined; + var x143: u32 = undefined; + mulxU32(&x142, &x143, x140, 0xffffffff); + var x144: u32 = undefined; + var x145: u32 = undefined; + mulxU32(&x144, &x145, x140, 0xffffffff); + var x146: u32 = undefined; + var x147: u32 = undefined; + mulxU32(&x146, &x147, x140, 0xffffffff); + var x148: u32 = undefined; + var x149: u32 = undefined; + mulxU32(&x148, &x149, x140, 0xfffffffe); + var x150: u32 = undefined; + var x151: u32 = undefined; + mulxU32(&x150, &x151, x140, 0xbaaedce6); + var x152: u32 = undefined; + var x153: u32 = undefined; + mulxU32(&x152, &x153, x140, 0xaf48a03b); + var x154: u32 = undefined; + var x155: u32 = undefined; + mulxU32(&x154, &x155, x140, 0xbfd25e8c); + var x156: u32 = undefined; + var x157: u32 = undefined; + mulxU32(&x156, &x157, x140, 0xd0364141); + var x158: u32 = undefined; + var x159: u1 = undefined; + addcarryxU32(&x158, &x159, 0x0, x157, x154); + var x160: u32 = undefined; + var x161: u1 = undefined; + addcarryxU32(&x160, &x161, x159, x155, x152); + var x162: u32 = undefined; + var x163: u1 = undefined; + addcarryxU32(&x162, &x163, x161, x153, x150); + var x164: u32 = undefined; + var x165: u1 = undefined; + addcarryxU32(&x164, &x165, x163, x151, x148); + var x166: u32 = undefined; + var x167: u1 = undefined; + addcarryxU32(&x166, &x167, x165, x149, x146); + var x168: u32 = undefined; + var x169: u1 = undefined; + addcarryxU32(&x168, &x169, x167, x147, x144); + var x170: u32 = undefined; + var x171: u1 = undefined; + addcarryxU32(&x170, &x171, x169, x145, x142); + const x172 = (cast(u32, x171) + x143); + var x173: u32 = undefined; + var x174: u1 = undefined; + addcarryxU32(&x173, &x174, 0x0, x122, x156); + var x175: u32 = undefined; + var x176: u1 = undefined; + addcarryxU32(&x175, &x176, x174, x124, x158); + var x177: u32 = undefined; + var x178: u1 = undefined; + addcarryxU32(&x177, &x178, x176, x126, x160); + var x179: u32 = undefined; + var x180: u1 = undefined; + addcarryxU32(&x179, &x180, x178, x128, x162); + var x181: u32 = undefined; + var x182: u1 = undefined; + addcarryxU32(&x181, &x182, x180, x130, x164); + var x183: u32 = undefined; + var x184: u1 = undefined; + addcarryxU32(&x183, &x184, x182, x132, x166); + var x185: u32 = undefined; + var x186: u1 = undefined; + addcarryxU32(&x185, &x186, x184, x134, x168); + var x187: u32 = undefined; + var x188: u1 = undefined; + addcarryxU32(&x187, &x188, x186, x136, x170); + var x189: u32 = undefined; + var x190: u1 = undefined; + addcarryxU32(&x189, &x190, x188, x138, x172); + const x191 = (cast(u32, x190) + cast(u32, x139)); + var x192: u32 = undefined; + var x193: u32 = undefined; + mulxU32(&x192, &x193, x2, (arg2[7])); + var x194: u32 = undefined; + var x195: u32 = undefined; + mulxU32(&x194, &x195, x2, (arg2[6])); + var x196: u32 = undefined; + var x197: u32 = undefined; + mulxU32(&x196, &x197, x2, (arg2[5])); + var x198: u32 = undefined; + var x199: u32 = undefined; + mulxU32(&x198, &x199, x2, (arg2[4])); + var x200: u32 = undefined; + var x201: u32 = undefined; + mulxU32(&x200, &x201, x2, (arg2[3])); + var x202: u32 = undefined; + var x203: u32 = undefined; + mulxU32(&x202, &x203, x2, (arg2[2])); + var x204: u32 = undefined; + var x205: u32 = undefined; + mulxU32(&x204, &x205, x2, (arg2[1])); + var x206: u32 = undefined; + var x207: u32 = undefined; + mulxU32(&x206, &x207, x2, (arg2[0])); + var x208: u32 = undefined; + var x209: u1 = undefined; + addcarryxU32(&x208, &x209, 0x0, x207, x204); + var x210: u32 = undefined; + var x211: u1 = undefined; + addcarryxU32(&x210, &x211, x209, x205, x202); + var x212: u32 = undefined; + var x213: u1 = undefined; + addcarryxU32(&x212, &x213, x211, x203, x200); + var x214: u32 = undefined; + var x215: u1 = undefined; + addcarryxU32(&x214, &x215, x213, x201, x198); + var x216: u32 = undefined; + var x217: u1 = undefined; + addcarryxU32(&x216, &x217, x215, x199, x196); + var x218: u32 = undefined; + var x219: u1 = undefined; + addcarryxU32(&x218, &x219, x217, x197, x194); + var x220: u32 = undefined; + var x221: u1 = undefined; + addcarryxU32(&x220, &x221, x219, x195, x192); + const x222 = (cast(u32, x221) + x193); + var x223: u32 = undefined; + var x224: u1 = undefined; + addcarryxU32(&x223, &x224, 0x0, x175, x206); + var x225: u32 = undefined; + var x226: u1 = undefined; + addcarryxU32(&x225, &x226, x224, x177, x208); + var x227: u32 = undefined; + var x228: u1 = undefined; + addcarryxU32(&x227, &x228, x226, x179, x210); + var x229: u32 = undefined; + var x230: u1 = undefined; + addcarryxU32(&x229, &x230, x228, x181, x212); + var x231: u32 = undefined; + var x232: u1 = undefined; + addcarryxU32(&x231, &x232, x230, x183, x214); + var x233: u32 = undefined; + var x234: u1 = undefined; + addcarryxU32(&x233, &x234, x232, x185, x216); + var x235: u32 = undefined; + var x236: u1 = undefined; + addcarryxU32(&x235, &x236, x234, x187, x218); + var x237: u32 = undefined; + var x238: u1 = undefined; + addcarryxU32(&x237, &x238, x236, x189, x220); + var x239: u32 = undefined; + var x240: u1 = undefined; + addcarryxU32(&x239, &x240, x238, x191, x222); + var x241: u32 = undefined; + var x242: u32 = undefined; + mulxU32(&x241, &x242, x223, 0x5588b13f); + var x243: u32 = undefined; + var x244: u32 = undefined; + mulxU32(&x243, &x244, x241, 0xffffffff); + var x245: u32 = undefined; + var x246: u32 = undefined; + mulxU32(&x245, &x246, x241, 0xffffffff); + var x247: u32 = undefined; + var x248: u32 = undefined; + mulxU32(&x247, &x248, x241, 0xffffffff); + var x249: u32 = undefined; + var x250: u32 = undefined; + mulxU32(&x249, &x250, x241, 0xfffffffe); + var x251: u32 = undefined; + var x252: u32 = undefined; + mulxU32(&x251, &x252, x241, 0xbaaedce6); + var x253: u32 = undefined; + var x254: u32 = undefined; + mulxU32(&x253, &x254, x241, 0xaf48a03b); + var x255: u32 = undefined; + var x256: u32 = undefined; + mulxU32(&x255, &x256, x241, 0xbfd25e8c); + var x257: u32 = undefined; + var x258: u32 = undefined; + mulxU32(&x257, &x258, x241, 0xd0364141); + var x259: u32 = undefined; + var x260: u1 = undefined; + addcarryxU32(&x259, &x260, 0x0, x258, x255); + var x261: u32 = undefined; + var x262: u1 = undefined; + addcarryxU32(&x261, &x262, x260, x256, x253); + var x263: u32 = undefined; + var x264: u1 = undefined; + addcarryxU32(&x263, &x264, x262, x254, x251); + var x265: u32 = undefined; + var x266: u1 = undefined; + addcarryxU32(&x265, &x266, x264, x252, x249); + var x267: u32 = undefined; + var x268: u1 = undefined; + addcarryxU32(&x267, &x268, x266, x250, x247); + var x269: u32 = undefined; + var x270: u1 = undefined; + addcarryxU32(&x269, &x270, x268, x248, x245); + var x271: u32 = undefined; + var x272: u1 = undefined; + addcarryxU32(&x271, &x272, x270, x246, x243); + const x273 = (cast(u32, x272) + x244); + var x274: u32 = undefined; + var x275: u1 = undefined; + addcarryxU32(&x274, &x275, 0x0, x223, x257); + var x276: u32 = undefined; + var x277: u1 = undefined; + addcarryxU32(&x276, &x277, x275, x225, x259); + var x278: u32 = undefined; + var x279: u1 = undefined; + addcarryxU32(&x278, &x279, x277, x227, x261); + var x280: u32 = undefined; + var x281: u1 = undefined; + addcarryxU32(&x280, &x281, x279, x229, x263); + var x282: u32 = undefined; + var x283: u1 = undefined; + addcarryxU32(&x282, &x283, x281, x231, x265); + var x284: u32 = undefined; + var x285: u1 = undefined; + addcarryxU32(&x284, &x285, x283, x233, x267); + var x286: u32 = undefined; + var x287: u1 = undefined; + addcarryxU32(&x286, &x287, x285, x235, x269); + var x288: u32 = undefined; + var x289: u1 = undefined; + addcarryxU32(&x288, &x289, x287, x237, x271); + var x290: u32 = undefined; + var x291: u1 = undefined; + addcarryxU32(&x290, &x291, x289, x239, x273); + const x292 = (cast(u32, x291) + cast(u32, x240)); + var x293: u32 = undefined; + var x294: u32 = undefined; + mulxU32(&x293, &x294, x3, (arg2[7])); + var x295: u32 = undefined; + var x296: u32 = undefined; + mulxU32(&x295, &x296, x3, (arg2[6])); + var x297: u32 = undefined; + var x298: u32 = undefined; + mulxU32(&x297, &x298, x3, (arg2[5])); + var x299: u32 = undefined; + var x300: u32 = undefined; + mulxU32(&x299, &x300, x3, (arg2[4])); + var x301: u32 = undefined; + var x302: u32 = undefined; + mulxU32(&x301, &x302, x3, (arg2[3])); + var x303: u32 = undefined; + var x304: u32 = undefined; + mulxU32(&x303, &x304, x3, (arg2[2])); + var x305: u32 = undefined; + var x306: u32 = undefined; + mulxU32(&x305, &x306, x3, (arg2[1])); + var x307: u32 = undefined; + var x308: u32 = undefined; + mulxU32(&x307, &x308, x3, (arg2[0])); + var x309: u32 = undefined; + var x310: u1 = undefined; + addcarryxU32(&x309, &x310, 0x0, x308, x305); + var x311: u32 = undefined; + var x312: u1 = undefined; + addcarryxU32(&x311, &x312, x310, x306, x303); + var x313: u32 = undefined; + var x314: u1 = undefined; + addcarryxU32(&x313, &x314, x312, x304, x301); + var x315: u32 = undefined; + var x316: u1 = undefined; + addcarryxU32(&x315, &x316, x314, x302, x299); + var x317: u32 = undefined; + var x318: u1 = undefined; + addcarryxU32(&x317, &x318, x316, x300, x297); + var x319: u32 = undefined; + var x320: u1 = undefined; + addcarryxU32(&x319, &x320, x318, x298, x295); + var x321: u32 = undefined; + var x322: u1 = undefined; + addcarryxU32(&x321, &x322, x320, x296, x293); + const x323 = (cast(u32, x322) + x294); + var x324: u32 = undefined; + var x325: u1 = undefined; + addcarryxU32(&x324, &x325, 0x0, x276, x307); + var x326: u32 = undefined; + var x327: u1 = undefined; + addcarryxU32(&x326, &x327, x325, x278, x309); + var x328: u32 = undefined; + var x329: u1 = undefined; + addcarryxU32(&x328, &x329, x327, x280, x311); + var x330: u32 = undefined; + var x331: u1 = undefined; + addcarryxU32(&x330, &x331, x329, x282, x313); + var x332: u32 = undefined; + var x333: u1 = undefined; + addcarryxU32(&x332, &x333, x331, x284, x315); + var x334: u32 = undefined; + var x335: u1 = undefined; + addcarryxU32(&x334, &x335, x333, x286, x317); + var x336: u32 = undefined; + var x337: u1 = undefined; + addcarryxU32(&x336, &x337, x335, x288, x319); + var x338: u32 = undefined; + var x339: u1 = undefined; + addcarryxU32(&x338, &x339, x337, x290, x321); + var x340: u32 = undefined; + var x341: u1 = undefined; + addcarryxU32(&x340, &x341, x339, x292, x323); + var x342: u32 = undefined; + var x343: u32 = undefined; + mulxU32(&x342, &x343, x324, 0x5588b13f); + var x344: u32 = undefined; + var x345: u32 = undefined; + mulxU32(&x344, &x345, x342, 0xffffffff); + var x346: u32 = undefined; + var x347: u32 = undefined; + mulxU32(&x346, &x347, x342, 0xffffffff); + var x348: u32 = undefined; + var x349: u32 = undefined; + mulxU32(&x348, &x349, x342, 0xffffffff); + var x350: u32 = undefined; + var x351: u32 = undefined; + mulxU32(&x350, &x351, x342, 0xfffffffe); + var x352: u32 = undefined; + var x353: u32 = undefined; + mulxU32(&x352, &x353, x342, 0xbaaedce6); + var x354: u32 = undefined; + var x355: u32 = undefined; + mulxU32(&x354, &x355, x342, 0xaf48a03b); + var x356: u32 = undefined; + var x357: u32 = undefined; + mulxU32(&x356, &x357, x342, 0xbfd25e8c); + var x358: u32 = undefined; + var x359: u32 = undefined; + mulxU32(&x358, &x359, x342, 0xd0364141); + var x360: u32 = undefined; + var x361: u1 = undefined; + addcarryxU32(&x360, &x361, 0x0, x359, x356); + var x362: u32 = undefined; + var x363: u1 = undefined; + addcarryxU32(&x362, &x363, x361, x357, x354); + var x364: u32 = undefined; + var x365: u1 = undefined; + addcarryxU32(&x364, &x365, x363, x355, x352); + var x366: u32 = undefined; + var x367: u1 = undefined; + addcarryxU32(&x366, &x367, x365, x353, x350); + var x368: u32 = undefined; + var x369: u1 = undefined; + addcarryxU32(&x368, &x369, x367, x351, x348); + var x370: u32 = undefined; + var x371: u1 = undefined; + addcarryxU32(&x370, &x371, x369, x349, x346); + var x372: u32 = undefined; + var x373: u1 = undefined; + addcarryxU32(&x372, &x373, x371, x347, x344); + const x374 = (cast(u32, x373) + x345); + var x375: u32 = undefined; + var x376: u1 = undefined; + addcarryxU32(&x375, &x376, 0x0, x324, x358); + var x377: u32 = undefined; + var x378: u1 = undefined; + addcarryxU32(&x377, &x378, x376, x326, x360); + var x379: u32 = undefined; + var x380: u1 = undefined; + addcarryxU32(&x379, &x380, x378, x328, x362); + var x381: u32 = undefined; + var x382: u1 = undefined; + addcarryxU32(&x381, &x382, x380, x330, x364); + var x383: u32 = undefined; + var x384: u1 = undefined; + addcarryxU32(&x383, &x384, x382, x332, x366); + var x385: u32 = undefined; + var x386: u1 = undefined; + addcarryxU32(&x385, &x386, x384, x334, x368); + var x387: u32 = undefined; + var x388: u1 = undefined; + addcarryxU32(&x387, &x388, x386, x336, x370); + var x389: u32 = undefined; + var x390: u1 = undefined; + addcarryxU32(&x389, &x390, x388, x338, x372); + var x391: u32 = undefined; + var x392: u1 = undefined; + addcarryxU32(&x391, &x392, x390, x340, x374); + const x393 = (cast(u32, x392) + cast(u32, x341)); + var x394: u32 = undefined; + var x395: u32 = undefined; + mulxU32(&x394, &x395, x4, (arg2[7])); + var x396: u32 = undefined; + var x397: u32 = undefined; + mulxU32(&x396, &x397, x4, (arg2[6])); + var x398: u32 = undefined; + var x399: u32 = undefined; + mulxU32(&x398, &x399, x4, (arg2[5])); + var x400: u32 = undefined; + var x401: u32 = undefined; + mulxU32(&x400, &x401, x4, (arg2[4])); + var x402: u32 = undefined; + var x403: u32 = undefined; + mulxU32(&x402, &x403, x4, (arg2[3])); + var x404: u32 = undefined; + var x405: u32 = undefined; + mulxU32(&x404, &x405, x4, (arg2[2])); + var x406: u32 = undefined; + var x407: u32 = undefined; + mulxU32(&x406, &x407, x4, (arg2[1])); + var x408: u32 = undefined; + var x409: u32 = undefined; + mulxU32(&x408, &x409, x4, (arg2[0])); + var x410: u32 = undefined; + var x411: u1 = undefined; + addcarryxU32(&x410, &x411, 0x0, x409, x406); + var x412: u32 = undefined; + var x413: u1 = undefined; + addcarryxU32(&x412, &x413, x411, x407, x404); + var x414: u32 = undefined; + var x415: u1 = undefined; + addcarryxU32(&x414, &x415, x413, x405, x402); + var x416: u32 = undefined; + var x417: u1 = undefined; + addcarryxU32(&x416, &x417, x415, x403, x400); + var x418: u32 = undefined; + var x419: u1 = undefined; + addcarryxU32(&x418, &x419, x417, x401, x398); + var x420: u32 = undefined; + var x421: u1 = undefined; + addcarryxU32(&x420, &x421, x419, x399, x396); + var x422: u32 = undefined; + var x423: u1 = undefined; + addcarryxU32(&x422, &x423, x421, x397, x394); + const x424 = (cast(u32, x423) + x395); + var x425: u32 = undefined; + var x426: u1 = undefined; + addcarryxU32(&x425, &x426, 0x0, x377, x408); + var x427: u32 = undefined; + var x428: u1 = undefined; + addcarryxU32(&x427, &x428, x426, x379, x410); + var x429: u32 = undefined; + var x430: u1 = undefined; + addcarryxU32(&x429, &x430, x428, x381, x412); + var x431: u32 = undefined; + var x432: u1 = undefined; + addcarryxU32(&x431, &x432, x430, x383, x414); + var x433: u32 = undefined; + var x434: u1 = undefined; + addcarryxU32(&x433, &x434, x432, x385, x416); + var x435: u32 = undefined; + var x436: u1 = undefined; + addcarryxU32(&x435, &x436, x434, x387, x418); + var x437: u32 = undefined; + var x438: u1 = undefined; + addcarryxU32(&x437, &x438, x436, x389, x420); + var x439: u32 = undefined; + var x440: u1 = undefined; + addcarryxU32(&x439, &x440, x438, x391, x422); + var x441: u32 = undefined; + var x442: u1 = undefined; + addcarryxU32(&x441, &x442, x440, x393, x424); + var x443: u32 = undefined; + var x444: u32 = undefined; + mulxU32(&x443, &x444, x425, 0x5588b13f); + var x445: u32 = undefined; + var x446: u32 = undefined; + mulxU32(&x445, &x446, x443, 0xffffffff); + var x447: u32 = undefined; + var x448: u32 = undefined; + mulxU32(&x447, &x448, x443, 0xffffffff); + var x449: u32 = undefined; + var x450: u32 = undefined; + mulxU32(&x449, &x450, x443, 0xffffffff); + var x451: u32 = undefined; + var x452: u32 = undefined; + mulxU32(&x451, &x452, x443, 0xfffffffe); + var x453: u32 = undefined; + var x454: u32 = undefined; + mulxU32(&x453, &x454, x443, 0xbaaedce6); + var x455: u32 = undefined; + var x456: u32 = undefined; + mulxU32(&x455, &x456, x443, 0xaf48a03b); + var x457: u32 = undefined; + var x458: u32 = undefined; + mulxU32(&x457, &x458, x443, 0xbfd25e8c); + var x459: u32 = undefined; + var x460: u32 = undefined; + mulxU32(&x459, &x460, x443, 0xd0364141); + var x461: u32 = undefined; + var x462: u1 = undefined; + addcarryxU32(&x461, &x462, 0x0, x460, x457); + var x463: u32 = undefined; + var x464: u1 = undefined; + addcarryxU32(&x463, &x464, x462, x458, x455); + var x465: u32 = undefined; + var x466: u1 = undefined; + addcarryxU32(&x465, &x466, x464, x456, x453); + var x467: u32 = undefined; + var x468: u1 = undefined; + addcarryxU32(&x467, &x468, x466, x454, x451); + var x469: u32 = undefined; + var x470: u1 = undefined; + addcarryxU32(&x469, &x470, x468, x452, x449); + var x471: u32 = undefined; + var x472: u1 = undefined; + addcarryxU32(&x471, &x472, x470, x450, x447); + var x473: u32 = undefined; + var x474: u1 = undefined; + addcarryxU32(&x473, &x474, x472, x448, x445); + const x475 = (cast(u32, x474) + x446); + var x476: u32 = undefined; + var x477: u1 = undefined; + addcarryxU32(&x476, &x477, 0x0, x425, x459); + var x478: u32 = undefined; + var x479: u1 = undefined; + addcarryxU32(&x478, &x479, x477, x427, x461); + var x480: u32 = undefined; + var x481: u1 = undefined; + addcarryxU32(&x480, &x481, x479, x429, x463); + var x482: u32 = undefined; + var x483: u1 = undefined; + addcarryxU32(&x482, &x483, x481, x431, x465); + var x484: u32 = undefined; + var x485: u1 = undefined; + addcarryxU32(&x484, &x485, x483, x433, x467); + var x486: u32 = undefined; + var x487: u1 = undefined; + addcarryxU32(&x486, &x487, x485, x435, x469); + var x488: u32 = undefined; + var x489: u1 = undefined; + addcarryxU32(&x488, &x489, x487, x437, x471); + var x490: u32 = undefined; + var x491: u1 = undefined; + addcarryxU32(&x490, &x491, x489, x439, x473); + var x492: u32 = undefined; + var x493: u1 = undefined; + addcarryxU32(&x492, &x493, x491, x441, x475); + const x494 = (cast(u32, x493) + cast(u32, x442)); + var x495: u32 = undefined; + var x496: u32 = undefined; + mulxU32(&x495, &x496, x5, (arg2[7])); + var x497: u32 = undefined; + var x498: u32 = undefined; + mulxU32(&x497, &x498, x5, (arg2[6])); + var x499: u32 = undefined; + var x500: u32 = undefined; + mulxU32(&x499, &x500, x5, (arg2[5])); + var x501: u32 = undefined; + var x502: u32 = undefined; + mulxU32(&x501, &x502, x5, (arg2[4])); + var x503: u32 = undefined; + var x504: u32 = undefined; + mulxU32(&x503, &x504, x5, (arg2[3])); + var x505: u32 = undefined; + var x506: u32 = undefined; + mulxU32(&x505, &x506, x5, (arg2[2])); + var x507: u32 = undefined; + var x508: u32 = undefined; + mulxU32(&x507, &x508, x5, (arg2[1])); + var x509: u32 = undefined; + var x510: u32 = undefined; + mulxU32(&x509, &x510, x5, (arg2[0])); + var x511: u32 = undefined; + var x512: u1 = undefined; + addcarryxU32(&x511, &x512, 0x0, x510, x507); + var x513: u32 = undefined; + var x514: u1 = undefined; + addcarryxU32(&x513, &x514, x512, x508, x505); + var x515: u32 = undefined; + var x516: u1 = undefined; + addcarryxU32(&x515, &x516, x514, x506, x503); + var x517: u32 = undefined; + var x518: u1 = undefined; + addcarryxU32(&x517, &x518, x516, x504, x501); + var x519: u32 = undefined; + var x520: u1 = undefined; + addcarryxU32(&x519, &x520, x518, x502, x499); + var x521: u32 = undefined; + var x522: u1 = undefined; + addcarryxU32(&x521, &x522, x520, x500, x497); + var x523: u32 = undefined; + var x524: u1 = undefined; + addcarryxU32(&x523, &x524, x522, x498, x495); + const x525 = (cast(u32, x524) + x496); + var x526: u32 = undefined; + var x527: u1 = undefined; + addcarryxU32(&x526, &x527, 0x0, x478, x509); + var x528: u32 = undefined; + var x529: u1 = undefined; + addcarryxU32(&x528, &x529, x527, x480, x511); + var x530: u32 = undefined; + var x531: u1 = undefined; + addcarryxU32(&x530, &x531, x529, x482, x513); + var x532: u32 = undefined; + var x533: u1 = undefined; + addcarryxU32(&x532, &x533, x531, x484, x515); + var x534: u32 = undefined; + var x535: u1 = undefined; + addcarryxU32(&x534, &x535, x533, x486, x517); + var x536: u32 = undefined; + var x537: u1 = undefined; + addcarryxU32(&x536, &x537, x535, x488, x519); + var x538: u32 = undefined; + var x539: u1 = undefined; + addcarryxU32(&x538, &x539, x537, x490, x521); + var x540: u32 = undefined; + var x541: u1 = undefined; + addcarryxU32(&x540, &x541, x539, x492, x523); + var x542: u32 = undefined; + var x543: u1 = undefined; + addcarryxU32(&x542, &x543, x541, x494, x525); + var x544: u32 = undefined; + var x545: u32 = undefined; + mulxU32(&x544, &x545, x526, 0x5588b13f); + var x546: u32 = undefined; + var x547: u32 = undefined; + mulxU32(&x546, &x547, x544, 0xffffffff); + var x548: u32 = undefined; + var x549: u32 = undefined; + mulxU32(&x548, &x549, x544, 0xffffffff); + var x550: u32 = undefined; + var x551: u32 = undefined; + mulxU32(&x550, &x551, x544, 0xffffffff); + var x552: u32 = undefined; + var x553: u32 = undefined; + mulxU32(&x552, &x553, x544, 0xfffffffe); + var x554: u32 = undefined; + var x555: u32 = undefined; + mulxU32(&x554, &x555, x544, 0xbaaedce6); + var x556: u32 = undefined; + var x557: u32 = undefined; + mulxU32(&x556, &x557, x544, 0xaf48a03b); + var x558: u32 = undefined; + var x559: u32 = undefined; + mulxU32(&x558, &x559, x544, 0xbfd25e8c); + var x560: u32 = undefined; + var x561: u32 = undefined; + mulxU32(&x560, &x561, x544, 0xd0364141); + var x562: u32 = undefined; + var x563: u1 = undefined; + addcarryxU32(&x562, &x563, 0x0, x561, x558); + var x564: u32 = undefined; + var x565: u1 = undefined; + addcarryxU32(&x564, &x565, x563, x559, x556); + var x566: u32 = undefined; + var x567: u1 = undefined; + addcarryxU32(&x566, &x567, x565, x557, x554); + var x568: u32 = undefined; + var x569: u1 = undefined; + addcarryxU32(&x568, &x569, x567, x555, x552); + var x570: u32 = undefined; + var x571: u1 = undefined; + addcarryxU32(&x570, &x571, x569, x553, x550); + var x572: u32 = undefined; + var x573: u1 = undefined; + addcarryxU32(&x572, &x573, x571, x551, x548); + var x574: u32 = undefined; + var x575: u1 = undefined; + addcarryxU32(&x574, &x575, x573, x549, x546); + const x576 = (cast(u32, x575) + x547); + var x577: u32 = undefined; + var x578: u1 = undefined; + addcarryxU32(&x577, &x578, 0x0, x526, x560); + var x579: u32 = undefined; + var x580: u1 = undefined; + addcarryxU32(&x579, &x580, x578, x528, x562); + var x581: u32 = undefined; + var x582: u1 = undefined; + addcarryxU32(&x581, &x582, x580, x530, x564); + var x583: u32 = undefined; + var x584: u1 = undefined; + addcarryxU32(&x583, &x584, x582, x532, x566); + var x585: u32 = undefined; + var x586: u1 = undefined; + addcarryxU32(&x585, &x586, x584, x534, x568); + var x587: u32 = undefined; + var x588: u1 = undefined; + addcarryxU32(&x587, &x588, x586, x536, x570); + var x589: u32 = undefined; + var x590: u1 = undefined; + addcarryxU32(&x589, &x590, x588, x538, x572); + var x591: u32 = undefined; + var x592: u1 = undefined; + addcarryxU32(&x591, &x592, x590, x540, x574); + var x593: u32 = undefined; + var x594: u1 = undefined; + addcarryxU32(&x593, &x594, x592, x542, x576); + const x595 = (cast(u32, x594) + cast(u32, x543)); + var x596: u32 = undefined; + var x597: u32 = undefined; + mulxU32(&x596, &x597, x6, (arg2[7])); + var x598: u32 = undefined; + var x599: u32 = undefined; + mulxU32(&x598, &x599, x6, (arg2[6])); + var x600: u32 = undefined; + var x601: u32 = undefined; + mulxU32(&x600, &x601, x6, (arg2[5])); + var x602: u32 = undefined; + var x603: u32 = undefined; + mulxU32(&x602, &x603, x6, (arg2[4])); + var x604: u32 = undefined; + var x605: u32 = undefined; + mulxU32(&x604, &x605, x6, (arg2[3])); + var x606: u32 = undefined; + var x607: u32 = undefined; + mulxU32(&x606, &x607, x6, (arg2[2])); + var x608: u32 = undefined; + var x609: u32 = undefined; + mulxU32(&x608, &x609, x6, (arg2[1])); + var x610: u32 = undefined; + var x611: u32 = undefined; + mulxU32(&x610, &x611, x6, (arg2[0])); + var x612: u32 = undefined; + var x613: u1 = undefined; + addcarryxU32(&x612, &x613, 0x0, x611, x608); + var x614: u32 = undefined; + var x615: u1 = undefined; + addcarryxU32(&x614, &x615, x613, x609, x606); + var x616: u32 = undefined; + var x617: u1 = undefined; + addcarryxU32(&x616, &x617, x615, x607, x604); + var x618: u32 = undefined; + var x619: u1 = undefined; + addcarryxU32(&x618, &x619, x617, x605, x602); + var x620: u32 = undefined; + var x621: u1 = undefined; + addcarryxU32(&x620, &x621, x619, x603, x600); + var x622: u32 = undefined; + var x623: u1 = undefined; + addcarryxU32(&x622, &x623, x621, x601, x598); + var x624: u32 = undefined; + var x625: u1 = undefined; + addcarryxU32(&x624, &x625, x623, x599, x596); + const x626 = (cast(u32, x625) + x597); + var x627: u32 = undefined; + var x628: u1 = undefined; + addcarryxU32(&x627, &x628, 0x0, x579, x610); + var x629: u32 = undefined; + var x630: u1 = undefined; + addcarryxU32(&x629, &x630, x628, x581, x612); + var x631: u32 = undefined; + var x632: u1 = undefined; + addcarryxU32(&x631, &x632, x630, x583, x614); + var x633: u32 = undefined; + var x634: u1 = undefined; + addcarryxU32(&x633, &x634, x632, x585, x616); + var x635: u32 = undefined; + var x636: u1 = undefined; + addcarryxU32(&x635, &x636, x634, x587, x618); + var x637: u32 = undefined; + var x638: u1 = undefined; + addcarryxU32(&x637, &x638, x636, x589, x620); + var x639: u32 = undefined; + var x640: u1 = undefined; + addcarryxU32(&x639, &x640, x638, x591, x622); + var x641: u32 = undefined; + var x642: u1 = undefined; + addcarryxU32(&x641, &x642, x640, x593, x624); + var x643: u32 = undefined; + var x644: u1 = undefined; + addcarryxU32(&x643, &x644, x642, x595, x626); + var x645: u32 = undefined; + var x646: u32 = undefined; + mulxU32(&x645, &x646, x627, 0x5588b13f); + var x647: u32 = undefined; + var x648: u32 = undefined; + mulxU32(&x647, &x648, x645, 0xffffffff); + var x649: u32 = undefined; + var x650: u32 = undefined; + mulxU32(&x649, &x650, x645, 0xffffffff); + var x651: u32 = undefined; + var x652: u32 = undefined; + mulxU32(&x651, &x652, x645, 0xffffffff); + var x653: u32 = undefined; + var x654: u32 = undefined; + mulxU32(&x653, &x654, x645, 0xfffffffe); + var x655: u32 = undefined; + var x656: u32 = undefined; + mulxU32(&x655, &x656, x645, 0xbaaedce6); + var x657: u32 = undefined; + var x658: u32 = undefined; + mulxU32(&x657, &x658, x645, 0xaf48a03b); + var x659: u32 = undefined; + var x660: u32 = undefined; + mulxU32(&x659, &x660, x645, 0xbfd25e8c); + var x661: u32 = undefined; + var x662: u32 = undefined; + mulxU32(&x661, &x662, x645, 0xd0364141); + var x663: u32 = undefined; + var x664: u1 = undefined; + addcarryxU32(&x663, &x664, 0x0, x662, x659); + var x665: u32 = undefined; + var x666: u1 = undefined; + addcarryxU32(&x665, &x666, x664, x660, x657); + var x667: u32 = undefined; + var x668: u1 = undefined; + addcarryxU32(&x667, &x668, x666, x658, x655); + var x669: u32 = undefined; + var x670: u1 = undefined; + addcarryxU32(&x669, &x670, x668, x656, x653); + var x671: u32 = undefined; + var x672: u1 = undefined; + addcarryxU32(&x671, &x672, x670, x654, x651); + var x673: u32 = undefined; + var x674: u1 = undefined; + addcarryxU32(&x673, &x674, x672, x652, x649); + var x675: u32 = undefined; + var x676: u1 = undefined; + addcarryxU32(&x675, &x676, x674, x650, x647); + const x677 = (cast(u32, x676) + x648); + var x678: u32 = undefined; + var x679: u1 = undefined; + addcarryxU32(&x678, &x679, 0x0, x627, x661); + var x680: u32 = undefined; + var x681: u1 = undefined; + addcarryxU32(&x680, &x681, x679, x629, x663); + var x682: u32 = undefined; + var x683: u1 = undefined; + addcarryxU32(&x682, &x683, x681, x631, x665); + var x684: u32 = undefined; + var x685: u1 = undefined; + addcarryxU32(&x684, &x685, x683, x633, x667); + var x686: u32 = undefined; + var x687: u1 = undefined; + addcarryxU32(&x686, &x687, x685, x635, x669); + var x688: u32 = undefined; + var x689: u1 = undefined; + addcarryxU32(&x688, &x689, x687, x637, x671); + var x690: u32 = undefined; + var x691: u1 = undefined; + addcarryxU32(&x690, &x691, x689, x639, x673); + var x692: u32 = undefined; + var x693: u1 = undefined; + addcarryxU32(&x692, &x693, x691, x641, x675); + var x694: u32 = undefined; + var x695: u1 = undefined; + addcarryxU32(&x694, &x695, x693, x643, x677); + const x696 = (cast(u32, x695) + cast(u32, x644)); + var x697: u32 = undefined; + var x698: u32 = undefined; + mulxU32(&x697, &x698, x7, (arg2[7])); + var x699: u32 = undefined; + var x700: u32 = undefined; + mulxU32(&x699, &x700, x7, (arg2[6])); + var x701: u32 = undefined; + var x702: u32 = undefined; + mulxU32(&x701, &x702, x7, (arg2[5])); + var x703: u32 = undefined; + var x704: u32 = undefined; + mulxU32(&x703, &x704, x7, (arg2[4])); + var x705: u32 = undefined; + var x706: u32 = undefined; + mulxU32(&x705, &x706, x7, (arg2[3])); + var x707: u32 = undefined; + var x708: u32 = undefined; + mulxU32(&x707, &x708, x7, (arg2[2])); + var x709: u32 = undefined; + var x710: u32 = undefined; + mulxU32(&x709, &x710, x7, (arg2[1])); + var x711: u32 = undefined; + var x712: u32 = undefined; + mulxU32(&x711, &x712, x7, (arg2[0])); + var x713: u32 = undefined; + var x714: u1 = undefined; + addcarryxU32(&x713, &x714, 0x0, x712, x709); + var x715: u32 = undefined; + var x716: u1 = undefined; + addcarryxU32(&x715, &x716, x714, x710, x707); + var x717: u32 = undefined; + var x718: u1 = undefined; + addcarryxU32(&x717, &x718, x716, x708, x705); + var x719: u32 = undefined; + var x720: u1 = undefined; + addcarryxU32(&x719, &x720, x718, x706, x703); + var x721: u32 = undefined; + var x722: u1 = undefined; + addcarryxU32(&x721, &x722, x720, x704, x701); + var x723: u32 = undefined; + var x724: u1 = undefined; + addcarryxU32(&x723, &x724, x722, x702, x699); + var x725: u32 = undefined; + var x726: u1 = undefined; + addcarryxU32(&x725, &x726, x724, x700, x697); + const x727 = (cast(u32, x726) + x698); + var x728: u32 = undefined; + var x729: u1 = undefined; + addcarryxU32(&x728, &x729, 0x0, x680, x711); + var x730: u32 = undefined; + var x731: u1 = undefined; + addcarryxU32(&x730, &x731, x729, x682, x713); + var x732: u32 = undefined; + var x733: u1 = undefined; + addcarryxU32(&x732, &x733, x731, x684, x715); + var x734: u32 = undefined; + var x735: u1 = undefined; + addcarryxU32(&x734, &x735, x733, x686, x717); + var x736: u32 = undefined; + var x737: u1 = undefined; + addcarryxU32(&x736, &x737, x735, x688, x719); + var x738: u32 = undefined; + var x739: u1 = undefined; + addcarryxU32(&x738, &x739, x737, x690, x721); + var x740: u32 = undefined; + var x741: u1 = undefined; + addcarryxU32(&x740, &x741, x739, x692, x723); + var x742: u32 = undefined; + var x743: u1 = undefined; + addcarryxU32(&x742, &x743, x741, x694, x725); + var x744: u32 = undefined; + var x745: u1 = undefined; + addcarryxU32(&x744, &x745, x743, x696, x727); + var x746: u32 = undefined; + var x747: u32 = undefined; + mulxU32(&x746, &x747, x728, 0x5588b13f); + var x748: u32 = undefined; + var x749: u32 = undefined; + mulxU32(&x748, &x749, x746, 0xffffffff); + var x750: u32 = undefined; + var x751: u32 = undefined; + mulxU32(&x750, &x751, x746, 0xffffffff); + var x752: u32 = undefined; + var x753: u32 = undefined; + mulxU32(&x752, &x753, x746, 0xffffffff); + var x754: u32 = undefined; + var x755: u32 = undefined; + mulxU32(&x754, &x755, x746, 0xfffffffe); + var x756: u32 = undefined; + var x757: u32 = undefined; + mulxU32(&x756, &x757, x746, 0xbaaedce6); + var x758: u32 = undefined; + var x759: u32 = undefined; + mulxU32(&x758, &x759, x746, 0xaf48a03b); + var x760: u32 = undefined; + var x761: u32 = undefined; + mulxU32(&x760, &x761, x746, 0xbfd25e8c); + var x762: u32 = undefined; + var x763: u32 = undefined; + mulxU32(&x762, &x763, x746, 0xd0364141); + var x764: u32 = undefined; + var x765: u1 = undefined; + addcarryxU32(&x764, &x765, 0x0, x763, x760); + var x766: u32 = undefined; + var x767: u1 = undefined; + addcarryxU32(&x766, &x767, x765, x761, x758); + var x768: u32 = undefined; + var x769: u1 = undefined; + addcarryxU32(&x768, &x769, x767, x759, x756); + var x770: u32 = undefined; + var x771: u1 = undefined; + addcarryxU32(&x770, &x771, x769, x757, x754); + var x772: u32 = undefined; + var x773: u1 = undefined; + addcarryxU32(&x772, &x773, x771, x755, x752); + var x774: u32 = undefined; + var x775: u1 = undefined; + addcarryxU32(&x774, &x775, x773, x753, x750); + var x776: u32 = undefined; + var x777: u1 = undefined; + addcarryxU32(&x776, &x777, x775, x751, x748); + const x778 = (cast(u32, x777) + x749); + var x779: u32 = undefined; + var x780: u1 = undefined; + addcarryxU32(&x779, &x780, 0x0, x728, x762); + var x781: u32 = undefined; + var x782: u1 = undefined; + addcarryxU32(&x781, &x782, x780, x730, x764); + var x783: u32 = undefined; + var x784: u1 = undefined; + addcarryxU32(&x783, &x784, x782, x732, x766); + var x785: u32 = undefined; + var x786: u1 = undefined; + addcarryxU32(&x785, &x786, x784, x734, x768); + var x787: u32 = undefined; + var x788: u1 = undefined; + addcarryxU32(&x787, &x788, x786, x736, x770); + var x789: u32 = undefined; + var x790: u1 = undefined; + addcarryxU32(&x789, &x790, x788, x738, x772); + var x791: u32 = undefined; + var x792: u1 = undefined; + addcarryxU32(&x791, &x792, x790, x740, x774); + var x793: u32 = undefined; + var x794: u1 = undefined; + addcarryxU32(&x793, &x794, x792, x742, x776); + var x795: u32 = undefined; + var x796: u1 = undefined; + addcarryxU32(&x795, &x796, x794, x744, x778); + const x797 = (cast(u32, x796) + cast(u32, x745)); + var x798: u32 = undefined; + var x799: u1 = undefined; + subborrowxU32(&x798, &x799, 0x0, x781, 0xd0364141); + var x800: u32 = undefined; + var x801: u1 = undefined; + subborrowxU32(&x800, &x801, x799, x783, 0xbfd25e8c); + var x802: u32 = undefined; + var x803: u1 = undefined; + subborrowxU32(&x802, &x803, x801, x785, 0xaf48a03b); + var x804: u32 = undefined; + var x805: u1 = undefined; + subborrowxU32(&x804, &x805, x803, x787, 0xbaaedce6); + var x806: u32 = undefined; + var x807: u1 = undefined; + subborrowxU32(&x806, &x807, x805, x789, 0xfffffffe); + var x808: u32 = undefined; + var x809: u1 = undefined; + subborrowxU32(&x808, &x809, x807, x791, 0xffffffff); + var x810: u32 = undefined; + var x811: u1 = undefined; + subborrowxU32(&x810, &x811, x809, x793, 0xffffffff); + var x812: u32 = undefined; + var x813: u1 = undefined; + subborrowxU32(&x812, &x813, x811, x795, 0xffffffff); + var x814: u32 = undefined; + var x815: u1 = undefined; + subborrowxU32(&x814, &x815, x813, x797, cast(u32, 0x0)); + var x816: u32 = undefined; + cmovznzU32(&x816, x815, x798, x781); + var x817: u32 = undefined; + cmovznzU32(&x817, x815, x800, x783); + var x818: u32 = undefined; + cmovznzU32(&x818, x815, x802, x785); + var x819: u32 = undefined; + cmovznzU32(&x819, x815, x804, x787); + var x820: u32 = undefined; + cmovznzU32(&x820, x815, x806, x789); + var x821: u32 = undefined; + cmovznzU32(&x821, x815, x808, x791); + var x822: u32 = undefined; + cmovznzU32(&x822, x815, x810, x793); + var x823: u32 = undefined; + cmovznzU32(&x823, x815, x812, x795); + out1[0] = x816; + out1[1] = x817; + out1[2] = x818; + out1[3] = x819; + out1[4] = x820; + out1[5] = x821; + out1[6] = x822; + out1[7] = x823; +} + +/// The function square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn square(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[6]); + const x7 = (arg1[7]); + const x8 = (arg1[0]); + var x9: u32 = undefined; + var x10: u32 = undefined; + mulxU32(&x9, &x10, x8, (arg1[7])); + var x11: u32 = undefined; + var x12: u32 = undefined; + mulxU32(&x11, &x12, x8, (arg1[6])); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x8, (arg1[5])); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x8, (arg1[4])); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x8, (arg1[3])); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x8, (arg1[2])); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x8, (arg1[1])); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x8, (arg1[0])); + var x25: u32 = undefined; + var x26: u1 = undefined; + addcarryxU32(&x25, &x26, 0x0, x24, x21); + var x27: u32 = undefined; + var x28: u1 = undefined; + addcarryxU32(&x27, &x28, x26, x22, x19); + var x29: u32 = undefined; + var x30: u1 = undefined; + addcarryxU32(&x29, &x30, x28, x20, x17); + var x31: u32 = undefined; + var x32: u1 = undefined; + addcarryxU32(&x31, &x32, x30, x18, x15); + var x33: u32 = undefined; + var x34: u1 = undefined; + addcarryxU32(&x33, &x34, x32, x16, x13); + var x35: u32 = undefined; + var x36: u1 = undefined; + addcarryxU32(&x35, &x36, x34, x14, x11); + var x37: u32 = undefined; + var x38: u1 = undefined; + addcarryxU32(&x37, &x38, x36, x12, x9); + const x39 = (cast(u32, x38) + x10); + var x40: u32 = undefined; + var x41: u32 = undefined; + mulxU32(&x40, &x41, x23, 0x5588b13f); + var x42: u32 = undefined; + var x43: u32 = undefined; + mulxU32(&x42, &x43, x40, 0xffffffff); + var x44: u32 = undefined; + var x45: u32 = undefined; + mulxU32(&x44, &x45, x40, 0xffffffff); + var x46: u32 = undefined; + var x47: u32 = undefined; + mulxU32(&x46, &x47, x40, 0xffffffff); + var x48: u32 = undefined; + var x49: u32 = undefined; + mulxU32(&x48, &x49, x40, 0xfffffffe); + var x50: u32 = undefined; + var x51: u32 = undefined; + mulxU32(&x50, &x51, x40, 0xbaaedce6); + var x52: u32 = undefined; + var x53: u32 = undefined; + mulxU32(&x52, &x53, x40, 0xaf48a03b); + var x54: u32 = undefined; + var x55: u32 = undefined; + mulxU32(&x54, &x55, x40, 0xbfd25e8c); + var x56: u32 = undefined; + var x57: u32 = undefined; + mulxU32(&x56, &x57, x40, 0xd0364141); + var x58: u32 = undefined; + var x59: u1 = undefined; + addcarryxU32(&x58, &x59, 0x0, x57, x54); + var x60: u32 = undefined; + var x61: u1 = undefined; + addcarryxU32(&x60, &x61, x59, x55, x52); + var x62: u32 = undefined; + var x63: u1 = undefined; + addcarryxU32(&x62, &x63, x61, x53, x50); + var x64: u32 = undefined; + var x65: u1 = undefined; + addcarryxU32(&x64, &x65, x63, x51, x48); + var x66: u32 = undefined; + var x67: u1 = undefined; + addcarryxU32(&x66, &x67, x65, x49, x46); + var x68: u32 = undefined; + var x69: u1 = undefined; + addcarryxU32(&x68, &x69, x67, x47, x44); + var x70: u32 = undefined; + var x71: u1 = undefined; + addcarryxU32(&x70, &x71, x69, x45, x42); + const x72 = (cast(u32, x71) + x43); + var x73: u32 = undefined; + var x74: u1 = undefined; + addcarryxU32(&x73, &x74, 0x0, x23, x56); + var x75: u32 = undefined; + var x76: u1 = undefined; + addcarryxU32(&x75, &x76, x74, x25, x58); + var x77: u32 = undefined; + var x78: u1 = undefined; + addcarryxU32(&x77, &x78, x76, x27, x60); + var x79: u32 = undefined; + var x80: u1 = undefined; + addcarryxU32(&x79, &x80, x78, x29, x62); + var x81: u32 = undefined; + var x82: u1 = undefined; + addcarryxU32(&x81, &x82, x80, x31, x64); + var x83: u32 = undefined; + var x84: u1 = undefined; + addcarryxU32(&x83, &x84, x82, x33, x66); + var x85: u32 = undefined; + var x86: u1 = undefined; + addcarryxU32(&x85, &x86, x84, x35, x68); + var x87: u32 = undefined; + var x88: u1 = undefined; + addcarryxU32(&x87, &x88, x86, x37, x70); + var x89: u32 = undefined; + var x90: u1 = undefined; + addcarryxU32(&x89, &x90, x88, x39, x72); + var x91: u32 = undefined; + var x92: u32 = undefined; + mulxU32(&x91, &x92, x1, (arg1[7])); + var x93: u32 = undefined; + var x94: u32 = undefined; + mulxU32(&x93, &x94, x1, (arg1[6])); + var x95: u32 = undefined; + var x96: u32 = undefined; + mulxU32(&x95, &x96, x1, (arg1[5])); + var x97: u32 = undefined; + var x98: u32 = undefined; + mulxU32(&x97, &x98, x1, (arg1[4])); + var x99: u32 = undefined; + var x100: u32 = undefined; + mulxU32(&x99, &x100, x1, (arg1[3])); + var x101: u32 = undefined; + var x102: u32 = undefined; + mulxU32(&x101, &x102, x1, (arg1[2])); + var x103: u32 = undefined; + var x104: u32 = undefined; + mulxU32(&x103, &x104, x1, (arg1[1])); + var x105: u32 = undefined; + var x106: u32 = undefined; + mulxU32(&x105, &x106, x1, (arg1[0])); + var x107: u32 = undefined; + var x108: u1 = undefined; + addcarryxU32(&x107, &x108, 0x0, x106, x103); + var x109: u32 = undefined; + var x110: u1 = undefined; + addcarryxU32(&x109, &x110, x108, x104, x101); + var x111: u32 = undefined; + var x112: u1 = undefined; + addcarryxU32(&x111, &x112, x110, x102, x99); + var x113: u32 = undefined; + var x114: u1 = undefined; + addcarryxU32(&x113, &x114, x112, x100, x97); + var x115: u32 = undefined; + var x116: u1 = undefined; + addcarryxU32(&x115, &x116, x114, x98, x95); + var x117: u32 = undefined; + var x118: u1 = undefined; + addcarryxU32(&x117, &x118, x116, x96, x93); + var x119: u32 = undefined; + var x120: u1 = undefined; + addcarryxU32(&x119, &x120, x118, x94, x91); + const x121 = (cast(u32, x120) + x92); + var x122: u32 = undefined; + var x123: u1 = undefined; + addcarryxU32(&x122, &x123, 0x0, x75, x105); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, x77, x107); + var x126: u32 = undefined; + var x127: u1 = undefined; + addcarryxU32(&x126, &x127, x125, x79, x109); + var x128: u32 = undefined; + var x129: u1 = undefined; + addcarryxU32(&x128, &x129, x127, x81, x111); + var x130: u32 = undefined; + var x131: u1 = undefined; + addcarryxU32(&x130, &x131, x129, x83, x113); + var x132: u32 = undefined; + var x133: u1 = undefined; + addcarryxU32(&x132, &x133, x131, x85, x115); + var x134: u32 = undefined; + var x135: u1 = undefined; + addcarryxU32(&x134, &x135, x133, x87, x117); + var x136: u32 = undefined; + var x137: u1 = undefined; + addcarryxU32(&x136, &x137, x135, x89, x119); + var x138: u32 = undefined; + var x139: u1 = undefined; + addcarryxU32(&x138, &x139, x137, cast(u32, x90), x121); + var x140: u32 = undefined; + var x141: u32 = undefined; + mulxU32(&x140, &x141, x122, 0x5588b13f); + var x142: u32 = undefined; + var x143: u32 = undefined; + mulxU32(&x142, &x143, x140, 0xffffffff); + var x144: u32 = undefined; + var x145: u32 = undefined; + mulxU32(&x144, &x145, x140, 0xffffffff); + var x146: u32 = undefined; + var x147: u32 = undefined; + mulxU32(&x146, &x147, x140, 0xffffffff); + var x148: u32 = undefined; + var x149: u32 = undefined; + mulxU32(&x148, &x149, x140, 0xfffffffe); + var x150: u32 = undefined; + var x151: u32 = undefined; + mulxU32(&x150, &x151, x140, 0xbaaedce6); + var x152: u32 = undefined; + var x153: u32 = undefined; + mulxU32(&x152, &x153, x140, 0xaf48a03b); + var x154: u32 = undefined; + var x155: u32 = undefined; + mulxU32(&x154, &x155, x140, 0xbfd25e8c); + var x156: u32 = undefined; + var x157: u32 = undefined; + mulxU32(&x156, &x157, x140, 0xd0364141); + var x158: u32 = undefined; + var x159: u1 = undefined; + addcarryxU32(&x158, &x159, 0x0, x157, x154); + var x160: u32 = undefined; + var x161: u1 = undefined; + addcarryxU32(&x160, &x161, x159, x155, x152); + var x162: u32 = undefined; + var x163: u1 = undefined; + addcarryxU32(&x162, &x163, x161, x153, x150); + var x164: u32 = undefined; + var x165: u1 = undefined; + addcarryxU32(&x164, &x165, x163, x151, x148); + var x166: u32 = undefined; + var x167: u1 = undefined; + addcarryxU32(&x166, &x167, x165, x149, x146); + var x168: u32 = undefined; + var x169: u1 = undefined; + addcarryxU32(&x168, &x169, x167, x147, x144); + var x170: u32 = undefined; + var x171: u1 = undefined; + addcarryxU32(&x170, &x171, x169, x145, x142); + const x172 = (cast(u32, x171) + x143); + var x173: u32 = undefined; + var x174: u1 = undefined; + addcarryxU32(&x173, &x174, 0x0, x122, x156); + var x175: u32 = undefined; + var x176: u1 = undefined; + addcarryxU32(&x175, &x176, x174, x124, x158); + var x177: u32 = undefined; + var x178: u1 = undefined; + addcarryxU32(&x177, &x178, x176, x126, x160); + var x179: u32 = undefined; + var x180: u1 = undefined; + addcarryxU32(&x179, &x180, x178, x128, x162); + var x181: u32 = undefined; + var x182: u1 = undefined; + addcarryxU32(&x181, &x182, x180, x130, x164); + var x183: u32 = undefined; + var x184: u1 = undefined; + addcarryxU32(&x183, &x184, x182, x132, x166); + var x185: u32 = undefined; + var x186: u1 = undefined; + addcarryxU32(&x185, &x186, x184, x134, x168); + var x187: u32 = undefined; + var x188: u1 = undefined; + addcarryxU32(&x187, &x188, x186, x136, x170); + var x189: u32 = undefined; + var x190: u1 = undefined; + addcarryxU32(&x189, &x190, x188, x138, x172); + const x191 = (cast(u32, x190) + cast(u32, x139)); + var x192: u32 = undefined; + var x193: u32 = undefined; + mulxU32(&x192, &x193, x2, (arg1[7])); + var x194: u32 = undefined; + var x195: u32 = undefined; + mulxU32(&x194, &x195, x2, (arg1[6])); + var x196: u32 = undefined; + var x197: u32 = undefined; + mulxU32(&x196, &x197, x2, (arg1[5])); + var x198: u32 = undefined; + var x199: u32 = undefined; + mulxU32(&x198, &x199, x2, (arg1[4])); + var x200: u32 = undefined; + var x201: u32 = undefined; + mulxU32(&x200, &x201, x2, (arg1[3])); + var x202: u32 = undefined; + var x203: u32 = undefined; + mulxU32(&x202, &x203, x2, (arg1[2])); + var x204: u32 = undefined; + var x205: u32 = undefined; + mulxU32(&x204, &x205, x2, (arg1[1])); + var x206: u32 = undefined; + var x207: u32 = undefined; + mulxU32(&x206, &x207, x2, (arg1[0])); + var x208: u32 = undefined; + var x209: u1 = undefined; + addcarryxU32(&x208, &x209, 0x0, x207, x204); + var x210: u32 = undefined; + var x211: u1 = undefined; + addcarryxU32(&x210, &x211, x209, x205, x202); + var x212: u32 = undefined; + var x213: u1 = undefined; + addcarryxU32(&x212, &x213, x211, x203, x200); + var x214: u32 = undefined; + var x215: u1 = undefined; + addcarryxU32(&x214, &x215, x213, x201, x198); + var x216: u32 = undefined; + var x217: u1 = undefined; + addcarryxU32(&x216, &x217, x215, x199, x196); + var x218: u32 = undefined; + var x219: u1 = undefined; + addcarryxU32(&x218, &x219, x217, x197, x194); + var x220: u32 = undefined; + var x221: u1 = undefined; + addcarryxU32(&x220, &x221, x219, x195, x192); + const x222 = (cast(u32, x221) + x193); + var x223: u32 = undefined; + var x224: u1 = undefined; + addcarryxU32(&x223, &x224, 0x0, x175, x206); + var x225: u32 = undefined; + var x226: u1 = undefined; + addcarryxU32(&x225, &x226, x224, x177, x208); + var x227: u32 = undefined; + var x228: u1 = undefined; + addcarryxU32(&x227, &x228, x226, x179, x210); + var x229: u32 = undefined; + var x230: u1 = undefined; + addcarryxU32(&x229, &x230, x228, x181, x212); + var x231: u32 = undefined; + var x232: u1 = undefined; + addcarryxU32(&x231, &x232, x230, x183, x214); + var x233: u32 = undefined; + var x234: u1 = undefined; + addcarryxU32(&x233, &x234, x232, x185, x216); + var x235: u32 = undefined; + var x236: u1 = undefined; + addcarryxU32(&x235, &x236, x234, x187, x218); + var x237: u32 = undefined; + var x238: u1 = undefined; + addcarryxU32(&x237, &x238, x236, x189, x220); + var x239: u32 = undefined; + var x240: u1 = undefined; + addcarryxU32(&x239, &x240, x238, x191, x222); + var x241: u32 = undefined; + var x242: u32 = undefined; + mulxU32(&x241, &x242, x223, 0x5588b13f); + var x243: u32 = undefined; + var x244: u32 = undefined; + mulxU32(&x243, &x244, x241, 0xffffffff); + var x245: u32 = undefined; + var x246: u32 = undefined; + mulxU32(&x245, &x246, x241, 0xffffffff); + var x247: u32 = undefined; + var x248: u32 = undefined; + mulxU32(&x247, &x248, x241, 0xffffffff); + var x249: u32 = undefined; + var x250: u32 = undefined; + mulxU32(&x249, &x250, x241, 0xfffffffe); + var x251: u32 = undefined; + var x252: u32 = undefined; + mulxU32(&x251, &x252, x241, 0xbaaedce6); + var x253: u32 = undefined; + var x254: u32 = undefined; + mulxU32(&x253, &x254, x241, 0xaf48a03b); + var x255: u32 = undefined; + var x256: u32 = undefined; + mulxU32(&x255, &x256, x241, 0xbfd25e8c); + var x257: u32 = undefined; + var x258: u32 = undefined; + mulxU32(&x257, &x258, x241, 0xd0364141); + var x259: u32 = undefined; + var x260: u1 = undefined; + addcarryxU32(&x259, &x260, 0x0, x258, x255); + var x261: u32 = undefined; + var x262: u1 = undefined; + addcarryxU32(&x261, &x262, x260, x256, x253); + var x263: u32 = undefined; + var x264: u1 = undefined; + addcarryxU32(&x263, &x264, x262, x254, x251); + var x265: u32 = undefined; + var x266: u1 = undefined; + addcarryxU32(&x265, &x266, x264, x252, x249); + var x267: u32 = undefined; + var x268: u1 = undefined; + addcarryxU32(&x267, &x268, x266, x250, x247); + var x269: u32 = undefined; + var x270: u1 = undefined; + addcarryxU32(&x269, &x270, x268, x248, x245); + var x271: u32 = undefined; + var x272: u1 = undefined; + addcarryxU32(&x271, &x272, x270, x246, x243); + const x273 = (cast(u32, x272) + x244); + var x274: u32 = undefined; + var x275: u1 = undefined; + addcarryxU32(&x274, &x275, 0x0, x223, x257); + var x276: u32 = undefined; + var x277: u1 = undefined; + addcarryxU32(&x276, &x277, x275, x225, x259); + var x278: u32 = undefined; + var x279: u1 = undefined; + addcarryxU32(&x278, &x279, x277, x227, x261); + var x280: u32 = undefined; + var x281: u1 = undefined; + addcarryxU32(&x280, &x281, x279, x229, x263); + var x282: u32 = undefined; + var x283: u1 = undefined; + addcarryxU32(&x282, &x283, x281, x231, x265); + var x284: u32 = undefined; + var x285: u1 = undefined; + addcarryxU32(&x284, &x285, x283, x233, x267); + var x286: u32 = undefined; + var x287: u1 = undefined; + addcarryxU32(&x286, &x287, x285, x235, x269); + var x288: u32 = undefined; + var x289: u1 = undefined; + addcarryxU32(&x288, &x289, x287, x237, x271); + var x290: u32 = undefined; + var x291: u1 = undefined; + addcarryxU32(&x290, &x291, x289, x239, x273); + const x292 = (cast(u32, x291) + cast(u32, x240)); + var x293: u32 = undefined; + var x294: u32 = undefined; + mulxU32(&x293, &x294, x3, (arg1[7])); + var x295: u32 = undefined; + var x296: u32 = undefined; + mulxU32(&x295, &x296, x3, (arg1[6])); + var x297: u32 = undefined; + var x298: u32 = undefined; + mulxU32(&x297, &x298, x3, (arg1[5])); + var x299: u32 = undefined; + var x300: u32 = undefined; + mulxU32(&x299, &x300, x3, (arg1[4])); + var x301: u32 = undefined; + var x302: u32 = undefined; + mulxU32(&x301, &x302, x3, (arg1[3])); + var x303: u32 = undefined; + var x304: u32 = undefined; + mulxU32(&x303, &x304, x3, (arg1[2])); + var x305: u32 = undefined; + var x306: u32 = undefined; + mulxU32(&x305, &x306, x3, (arg1[1])); + var x307: u32 = undefined; + var x308: u32 = undefined; + mulxU32(&x307, &x308, x3, (arg1[0])); + var x309: u32 = undefined; + var x310: u1 = undefined; + addcarryxU32(&x309, &x310, 0x0, x308, x305); + var x311: u32 = undefined; + var x312: u1 = undefined; + addcarryxU32(&x311, &x312, x310, x306, x303); + var x313: u32 = undefined; + var x314: u1 = undefined; + addcarryxU32(&x313, &x314, x312, x304, x301); + var x315: u32 = undefined; + var x316: u1 = undefined; + addcarryxU32(&x315, &x316, x314, x302, x299); + var x317: u32 = undefined; + var x318: u1 = undefined; + addcarryxU32(&x317, &x318, x316, x300, x297); + var x319: u32 = undefined; + var x320: u1 = undefined; + addcarryxU32(&x319, &x320, x318, x298, x295); + var x321: u32 = undefined; + var x322: u1 = undefined; + addcarryxU32(&x321, &x322, x320, x296, x293); + const x323 = (cast(u32, x322) + x294); + var x324: u32 = undefined; + var x325: u1 = undefined; + addcarryxU32(&x324, &x325, 0x0, x276, x307); + var x326: u32 = undefined; + var x327: u1 = undefined; + addcarryxU32(&x326, &x327, x325, x278, x309); + var x328: u32 = undefined; + var x329: u1 = undefined; + addcarryxU32(&x328, &x329, x327, x280, x311); + var x330: u32 = undefined; + var x331: u1 = undefined; + addcarryxU32(&x330, &x331, x329, x282, x313); + var x332: u32 = undefined; + var x333: u1 = undefined; + addcarryxU32(&x332, &x333, x331, x284, x315); + var x334: u32 = undefined; + var x335: u1 = undefined; + addcarryxU32(&x334, &x335, x333, x286, x317); + var x336: u32 = undefined; + var x337: u1 = undefined; + addcarryxU32(&x336, &x337, x335, x288, x319); + var x338: u32 = undefined; + var x339: u1 = undefined; + addcarryxU32(&x338, &x339, x337, x290, x321); + var x340: u32 = undefined; + var x341: u1 = undefined; + addcarryxU32(&x340, &x341, x339, x292, x323); + var x342: u32 = undefined; + var x343: u32 = undefined; + mulxU32(&x342, &x343, x324, 0x5588b13f); + var x344: u32 = undefined; + var x345: u32 = undefined; + mulxU32(&x344, &x345, x342, 0xffffffff); + var x346: u32 = undefined; + var x347: u32 = undefined; + mulxU32(&x346, &x347, x342, 0xffffffff); + var x348: u32 = undefined; + var x349: u32 = undefined; + mulxU32(&x348, &x349, x342, 0xffffffff); + var x350: u32 = undefined; + var x351: u32 = undefined; + mulxU32(&x350, &x351, x342, 0xfffffffe); + var x352: u32 = undefined; + var x353: u32 = undefined; + mulxU32(&x352, &x353, x342, 0xbaaedce6); + var x354: u32 = undefined; + var x355: u32 = undefined; + mulxU32(&x354, &x355, x342, 0xaf48a03b); + var x356: u32 = undefined; + var x357: u32 = undefined; + mulxU32(&x356, &x357, x342, 0xbfd25e8c); + var x358: u32 = undefined; + var x359: u32 = undefined; + mulxU32(&x358, &x359, x342, 0xd0364141); + var x360: u32 = undefined; + var x361: u1 = undefined; + addcarryxU32(&x360, &x361, 0x0, x359, x356); + var x362: u32 = undefined; + var x363: u1 = undefined; + addcarryxU32(&x362, &x363, x361, x357, x354); + var x364: u32 = undefined; + var x365: u1 = undefined; + addcarryxU32(&x364, &x365, x363, x355, x352); + var x366: u32 = undefined; + var x367: u1 = undefined; + addcarryxU32(&x366, &x367, x365, x353, x350); + var x368: u32 = undefined; + var x369: u1 = undefined; + addcarryxU32(&x368, &x369, x367, x351, x348); + var x370: u32 = undefined; + var x371: u1 = undefined; + addcarryxU32(&x370, &x371, x369, x349, x346); + var x372: u32 = undefined; + var x373: u1 = undefined; + addcarryxU32(&x372, &x373, x371, x347, x344); + const x374 = (cast(u32, x373) + x345); + var x375: u32 = undefined; + var x376: u1 = undefined; + addcarryxU32(&x375, &x376, 0x0, x324, x358); + var x377: u32 = undefined; + var x378: u1 = undefined; + addcarryxU32(&x377, &x378, x376, x326, x360); + var x379: u32 = undefined; + var x380: u1 = undefined; + addcarryxU32(&x379, &x380, x378, x328, x362); + var x381: u32 = undefined; + var x382: u1 = undefined; + addcarryxU32(&x381, &x382, x380, x330, x364); + var x383: u32 = undefined; + var x384: u1 = undefined; + addcarryxU32(&x383, &x384, x382, x332, x366); + var x385: u32 = undefined; + var x386: u1 = undefined; + addcarryxU32(&x385, &x386, x384, x334, x368); + var x387: u32 = undefined; + var x388: u1 = undefined; + addcarryxU32(&x387, &x388, x386, x336, x370); + var x389: u32 = undefined; + var x390: u1 = undefined; + addcarryxU32(&x389, &x390, x388, x338, x372); + var x391: u32 = undefined; + var x392: u1 = undefined; + addcarryxU32(&x391, &x392, x390, x340, x374); + const x393 = (cast(u32, x392) + cast(u32, x341)); + var x394: u32 = undefined; + var x395: u32 = undefined; + mulxU32(&x394, &x395, x4, (arg1[7])); + var x396: u32 = undefined; + var x397: u32 = undefined; + mulxU32(&x396, &x397, x4, (arg1[6])); + var x398: u32 = undefined; + var x399: u32 = undefined; + mulxU32(&x398, &x399, x4, (arg1[5])); + var x400: u32 = undefined; + var x401: u32 = undefined; + mulxU32(&x400, &x401, x4, (arg1[4])); + var x402: u32 = undefined; + var x403: u32 = undefined; + mulxU32(&x402, &x403, x4, (arg1[3])); + var x404: u32 = undefined; + var x405: u32 = undefined; + mulxU32(&x404, &x405, x4, (arg1[2])); + var x406: u32 = undefined; + var x407: u32 = undefined; + mulxU32(&x406, &x407, x4, (arg1[1])); + var x408: u32 = undefined; + var x409: u32 = undefined; + mulxU32(&x408, &x409, x4, (arg1[0])); + var x410: u32 = undefined; + var x411: u1 = undefined; + addcarryxU32(&x410, &x411, 0x0, x409, x406); + var x412: u32 = undefined; + var x413: u1 = undefined; + addcarryxU32(&x412, &x413, x411, x407, x404); + var x414: u32 = undefined; + var x415: u1 = undefined; + addcarryxU32(&x414, &x415, x413, x405, x402); + var x416: u32 = undefined; + var x417: u1 = undefined; + addcarryxU32(&x416, &x417, x415, x403, x400); + var x418: u32 = undefined; + var x419: u1 = undefined; + addcarryxU32(&x418, &x419, x417, x401, x398); + var x420: u32 = undefined; + var x421: u1 = undefined; + addcarryxU32(&x420, &x421, x419, x399, x396); + var x422: u32 = undefined; + var x423: u1 = undefined; + addcarryxU32(&x422, &x423, x421, x397, x394); + const x424 = (cast(u32, x423) + x395); + var x425: u32 = undefined; + var x426: u1 = undefined; + addcarryxU32(&x425, &x426, 0x0, x377, x408); + var x427: u32 = undefined; + var x428: u1 = undefined; + addcarryxU32(&x427, &x428, x426, x379, x410); + var x429: u32 = undefined; + var x430: u1 = undefined; + addcarryxU32(&x429, &x430, x428, x381, x412); + var x431: u32 = undefined; + var x432: u1 = undefined; + addcarryxU32(&x431, &x432, x430, x383, x414); + var x433: u32 = undefined; + var x434: u1 = undefined; + addcarryxU32(&x433, &x434, x432, x385, x416); + var x435: u32 = undefined; + var x436: u1 = undefined; + addcarryxU32(&x435, &x436, x434, x387, x418); + var x437: u32 = undefined; + var x438: u1 = undefined; + addcarryxU32(&x437, &x438, x436, x389, x420); + var x439: u32 = undefined; + var x440: u1 = undefined; + addcarryxU32(&x439, &x440, x438, x391, x422); + var x441: u32 = undefined; + var x442: u1 = undefined; + addcarryxU32(&x441, &x442, x440, x393, x424); + var x443: u32 = undefined; + var x444: u32 = undefined; + mulxU32(&x443, &x444, x425, 0x5588b13f); + var x445: u32 = undefined; + var x446: u32 = undefined; + mulxU32(&x445, &x446, x443, 0xffffffff); + var x447: u32 = undefined; + var x448: u32 = undefined; + mulxU32(&x447, &x448, x443, 0xffffffff); + var x449: u32 = undefined; + var x450: u32 = undefined; + mulxU32(&x449, &x450, x443, 0xffffffff); + var x451: u32 = undefined; + var x452: u32 = undefined; + mulxU32(&x451, &x452, x443, 0xfffffffe); + var x453: u32 = undefined; + var x454: u32 = undefined; + mulxU32(&x453, &x454, x443, 0xbaaedce6); + var x455: u32 = undefined; + var x456: u32 = undefined; + mulxU32(&x455, &x456, x443, 0xaf48a03b); + var x457: u32 = undefined; + var x458: u32 = undefined; + mulxU32(&x457, &x458, x443, 0xbfd25e8c); + var x459: u32 = undefined; + var x460: u32 = undefined; + mulxU32(&x459, &x460, x443, 0xd0364141); + var x461: u32 = undefined; + var x462: u1 = undefined; + addcarryxU32(&x461, &x462, 0x0, x460, x457); + var x463: u32 = undefined; + var x464: u1 = undefined; + addcarryxU32(&x463, &x464, x462, x458, x455); + var x465: u32 = undefined; + var x466: u1 = undefined; + addcarryxU32(&x465, &x466, x464, x456, x453); + var x467: u32 = undefined; + var x468: u1 = undefined; + addcarryxU32(&x467, &x468, x466, x454, x451); + var x469: u32 = undefined; + var x470: u1 = undefined; + addcarryxU32(&x469, &x470, x468, x452, x449); + var x471: u32 = undefined; + var x472: u1 = undefined; + addcarryxU32(&x471, &x472, x470, x450, x447); + var x473: u32 = undefined; + var x474: u1 = undefined; + addcarryxU32(&x473, &x474, x472, x448, x445); + const x475 = (cast(u32, x474) + x446); + var x476: u32 = undefined; + var x477: u1 = undefined; + addcarryxU32(&x476, &x477, 0x0, x425, x459); + var x478: u32 = undefined; + var x479: u1 = undefined; + addcarryxU32(&x478, &x479, x477, x427, x461); + var x480: u32 = undefined; + var x481: u1 = undefined; + addcarryxU32(&x480, &x481, x479, x429, x463); + var x482: u32 = undefined; + var x483: u1 = undefined; + addcarryxU32(&x482, &x483, x481, x431, x465); + var x484: u32 = undefined; + var x485: u1 = undefined; + addcarryxU32(&x484, &x485, x483, x433, x467); + var x486: u32 = undefined; + var x487: u1 = undefined; + addcarryxU32(&x486, &x487, x485, x435, x469); + var x488: u32 = undefined; + var x489: u1 = undefined; + addcarryxU32(&x488, &x489, x487, x437, x471); + var x490: u32 = undefined; + var x491: u1 = undefined; + addcarryxU32(&x490, &x491, x489, x439, x473); + var x492: u32 = undefined; + var x493: u1 = undefined; + addcarryxU32(&x492, &x493, x491, x441, x475); + const x494 = (cast(u32, x493) + cast(u32, x442)); + var x495: u32 = undefined; + var x496: u32 = undefined; + mulxU32(&x495, &x496, x5, (arg1[7])); + var x497: u32 = undefined; + var x498: u32 = undefined; + mulxU32(&x497, &x498, x5, (arg1[6])); + var x499: u32 = undefined; + var x500: u32 = undefined; + mulxU32(&x499, &x500, x5, (arg1[5])); + var x501: u32 = undefined; + var x502: u32 = undefined; + mulxU32(&x501, &x502, x5, (arg1[4])); + var x503: u32 = undefined; + var x504: u32 = undefined; + mulxU32(&x503, &x504, x5, (arg1[3])); + var x505: u32 = undefined; + var x506: u32 = undefined; + mulxU32(&x505, &x506, x5, (arg1[2])); + var x507: u32 = undefined; + var x508: u32 = undefined; + mulxU32(&x507, &x508, x5, (arg1[1])); + var x509: u32 = undefined; + var x510: u32 = undefined; + mulxU32(&x509, &x510, x5, (arg1[0])); + var x511: u32 = undefined; + var x512: u1 = undefined; + addcarryxU32(&x511, &x512, 0x0, x510, x507); + var x513: u32 = undefined; + var x514: u1 = undefined; + addcarryxU32(&x513, &x514, x512, x508, x505); + var x515: u32 = undefined; + var x516: u1 = undefined; + addcarryxU32(&x515, &x516, x514, x506, x503); + var x517: u32 = undefined; + var x518: u1 = undefined; + addcarryxU32(&x517, &x518, x516, x504, x501); + var x519: u32 = undefined; + var x520: u1 = undefined; + addcarryxU32(&x519, &x520, x518, x502, x499); + var x521: u32 = undefined; + var x522: u1 = undefined; + addcarryxU32(&x521, &x522, x520, x500, x497); + var x523: u32 = undefined; + var x524: u1 = undefined; + addcarryxU32(&x523, &x524, x522, x498, x495); + const x525 = (cast(u32, x524) + x496); + var x526: u32 = undefined; + var x527: u1 = undefined; + addcarryxU32(&x526, &x527, 0x0, x478, x509); + var x528: u32 = undefined; + var x529: u1 = undefined; + addcarryxU32(&x528, &x529, x527, x480, x511); + var x530: u32 = undefined; + var x531: u1 = undefined; + addcarryxU32(&x530, &x531, x529, x482, x513); + var x532: u32 = undefined; + var x533: u1 = undefined; + addcarryxU32(&x532, &x533, x531, x484, x515); + var x534: u32 = undefined; + var x535: u1 = undefined; + addcarryxU32(&x534, &x535, x533, x486, x517); + var x536: u32 = undefined; + var x537: u1 = undefined; + addcarryxU32(&x536, &x537, x535, x488, x519); + var x538: u32 = undefined; + var x539: u1 = undefined; + addcarryxU32(&x538, &x539, x537, x490, x521); + var x540: u32 = undefined; + var x541: u1 = undefined; + addcarryxU32(&x540, &x541, x539, x492, x523); + var x542: u32 = undefined; + var x543: u1 = undefined; + addcarryxU32(&x542, &x543, x541, x494, x525); + var x544: u32 = undefined; + var x545: u32 = undefined; + mulxU32(&x544, &x545, x526, 0x5588b13f); + var x546: u32 = undefined; + var x547: u32 = undefined; + mulxU32(&x546, &x547, x544, 0xffffffff); + var x548: u32 = undefined; + var x549: u32 = undefined; + mulxU32(&x548, &x549, x544, 0xffffffff); + var x550: u32 = undefined; + var x551: u32 = undefined; + mulxU32(&x550, &x551, x544, 0xffffffff); + var x552: u32 = undefined; + var x553: u32 = undefined; + mulxU32(&x552, &x553, x544, 0xfffffffe); + var x554: u32 = undefined; + var x555: u32 = undefined; + mulxU32(&x554, &x555, x544, 0xbaaedce6); + var x556: u32 = undefined; + var x557: u32 = undefined; + mulxU32(&x556, &x557, x544, 0xaf48a03b); + var x558: u32 = undefined; + var x559: u32 = undefined; + mulxU32(&x558, &x559, x544, 0xbfd25e8c); + var x560: u32 = undefined; + var x561: u32 = undefined; + mulxU32(&x560, &x561, x544, 0xd0364141); + var x562: u32 = undefined; + var x563: u1 = undefined; + addcarryxU32(&x562, &x563, 0x0, x561, x558); + var x564: u32 = undefined; + var x565: u1 = undefined; + addcarryxU32(&x564, &x565, x563, x559, x556); + var x566: u32 = undefined; + var x567: u1 = undefined; + addcarryxU32(&x566, &x567, x565, x557, x554); + var x568: u32 = undefined; + var x569: u1 = undefined; + addcarryxU32(&x568, &x569, x567, x555, x552); + var x570: u32 = undefined; + var x571: u1 = undefined; + addcarryxU32(&x570, &x571, x569, x553, x550); + var x572: u32 = undefined; + var x573: u1 = undefined; + addcarryxU32(&x572, &x573, x571, x551, x548); + var x574: u32 = undefined; + var x575: u1 = undefined; + addcarryxU32(&x574, &x575, x573, x549, x546); + const x576 = (cast(u32, x575) + x547); + var x577: u32 = undefined; + var x578: u1 = undefined; + addcarryxU32(&x577, &x578, 0x0, x526, x560); + var x579: u32 = undefined; + var x580: u1 = undefined; + addcarryxU32(&x579, &x580, x578, x528, x562); + var x581: u32 = undefined; + var x582: u1 = undefined; + addcarryxU32(&x581, &x582, x580, x530, x564); + var x583: u32 = undefined; + var x584: u1 = undefined; + addcarryxU32(&x583, &x584, x582, x532, x566); + var x585: u32 = undefined; + var x586: u1 = undefined; + addcarryxU32(&x585, &x586, x584, x534, x568); + var x587: u32 = undefined; + var x588: u1 = undefined; + addcarryxU32(&x587, &x588, x586, x536, x570); + var x589: u32 = undefined; + var x590: u1 = undefined; + addcarryxU32(&x589, &x590, x588, x538, x572); + var x591: u32 = undefined; + var x592: u1 = undefined; + addcarryxU32(&x591, &x592, x590, x540, x574); + var x593: u32 = undefined; + var x594: u1 = undefined; + addcarryxU32(&x593, &x594, x592, x542, x576); + const x595 = (cast(u32, x594) + cast(u32, x543)); + var x596: u32 = undefined; + var x597: u32 = undefined; + mulxU32(&x596, &x597, x6, (arg1[7])); + var x598: u32 = undefined; + var x599: u32 = undefined; + mulxU32(&x598, &x599, x6, (arg1[6])); + var x600: u32 = undefined; + var x601: u32 = undefined; + mulxU32(&x600, &x601, x6, (arg1[5])); + var x602: u32 = undefined; + var x603: u32 = undefined; + mulxU32(&x602, &x603, x6, (arg1[4])); + var x604: u32 = undefined; + var x605: u32 = undefined; + mulxU32(&x604, &x605, x6, (arg1[3])); + var x606: u32 = undefined; + var x607: u32 = undefined; + mulxU32(&x606, &x607, x6, (arg1[2])); + var x608: u32 = undefined; + var x609: u32 = undefined; + mulxU32(&x608, &x609, x6, (arg1[1])); + var x610: u32 = undefined; + var x611: u32 = undefined; + mulxU32(&x610, &x611, x6, (arg1[0])); + var x612: u32 = undefined; + var x613: u1 = undefined; + addcarryxU32(&x612, &x613, 0x0, x611, x608); + var x614: u32 = undefined; + var x615: u1 = undefined; + addcarryxU32(&x614, &x615, x613, x609, x606); + var x616: u32 = undefined; + var x617: u1 = undefined; + addcarryxU32(&x616, &x617, x615, x607, x604); + var x618: u32 = undefined; + var x619: u1 = undefined; + addcarryxU32(&x618, &x619, x617, x605, x602); + var x620: u32 = undefined; + var x621: u1 = undefined; + addcarryxU32(&x620, &x621, x619, x603, x600); + var x622: u32 = undefined; + var x623: u1 = undefined; + addcarryxU32(&x622, &x623, x621, x601, x598); + var x624: u32 = undefined; + var x625: u1 = undefined; + addcarryxU32(&x624, &x625, x623, x599, x596); + const x626 = (cast(u32, x625) + x597); + var x627: u32 = undefined; + var x628: u1 = undefined; + addcarryxU32(&x627, &x628, 0x0, x579, x610); + var x629: u32 = undefined; + var x630: u1 = undefined; + addcarryxU32(&x629, &x630, x628, x581, x612); + var x631: u32 = undefined; + var x632: u1 = undefined; + addcarryxU32(&x631, &x632, x630, x583, x614); + var x633: u32 = undefined; + var x634: u1 = undefined; + addcarryxU32(&x633, &x634, x632, x585, x616); + var x635: u32 = undefined; + var x636: u1 = undefined; + addcarryxU32(&x635, &x636, x634, x587, x618); + var x637: u32 = undefined; + var x638: u1 = undefined; + addcarryxU32(&x637, &x638, x636, x589, x620); + var x639: u32 = undefined; + var x640: u1 = undefined; + addcarryxU32(&x639, &x640, x638, x591, x622); + var x641: u32 = undefined; + var x642: u1 = undefined; + addcarryxU32(&x641, &x642, x640, x593, x624); + var x643: u32 = undefined; + var x644: u1 = undefined; + addcarryxU32(&x643, &x644, x642, x595, x626); + var x645: u32 = undefined; + var x646: u32 = undefined; + mulxU32(&x645, &x646, x627, 0x5588b13f); + var x647: u32 = undefined; + var x648: u32 = undefined; + mulxU32(&x647, &x648, x645, 0xffffffff); + var x649: u32 = undefined; + var x650: u32 = undefined; + mulxU32(&x649, &x650, x645, 0xffffffff); + var x651: u32 = undefined; + var x652: u32 = undefined; + mulxU32(&x651, &x652, x645, 0xffffffff); + var x653: u32 = undefined; + var x654: u32 = undefined; + mulxU32(&x653, &x654, x645, 0xfffffffe); + var x655: u32 = undefined; + var x656: u32 = undefined; + mulxU32(&x655, &x656, x645, 0xbaaedce6); + var x657: u32 = undefined; + var x658: u32 = undefined; + mulxU32(&x657, &x658, x645, 0xaf48a03b); + var x659: u32 = undefined; + var x660: u32 = undefined; + mulxU32(&x659, &x660, x645, 0xbfd25e8c); + var x661: u32 = undefined; + var x662: u32 = undefined; + mulxU32(&x661, &x662, x645, 0xd0364141); + var x663: u32 = undefined; + var x664: u1 = undefined; + addcarryxU32(&x663, &x664, 0x0, x662, x659); + var x665: u32 = undefined; + var x666: u1 = undefined; + addcarryxU32(&x665, &x666, x664, x660, x657); + var x667: u32 = undefined; + var x668: u1 = undefined; + addcarryxU32(&x667, &x668, x666, x658, x655); + var x669: u32 = undefined; + var x670: u1 = undefined; + addcarryxU32(&x669, &x670, x668, x656, x653); + var x671: u32 = undefined; + var x672: u1 = undefined; + addcarryxU32(&x671, &x672, x670, x654, x651); + var x673: u32 = undefined; + var x674: u1 = undefined; + addcarryxU32(&x673, &x674, x672, x652, x649); + var x675: u32 = undefined; + var x676: u1 = undefined; + addcarryxU32(&x675, &x676, x674, x650, x647); + const x677 = (cast(u32, x676) + x648); + var x678: u32 = undefined; + var x679: u1 = undefined; + addcarryxU32(&x678, &x679, 0x0, x627, x661); + var x680: u32 = undefined; + var x681: u1 = undefined; + addcarryxU32(&x680, &x681, x679, x629, x663); + var x682: u32 = undefined; + var x683: u1 = undefined; + addcarryxU32(&x682, &x683, x681, x631, x665); + var x684: u32 = undefined; + var x685: u1 = undefined; + addcarryxU32(&x684, &x685, x683, x633, x667); + var x686: u32 = undefined; + var x687: u1 = undefined; + addcarryxU32(&x686, &x687, x685, x635, x669); + var x688: u32 = undefined; + var x689: u1 = undefined; + addcarryxU32(&x688, &x689, x687, x637, x671); + var x690: u32 = undefined; + var x691: u1 = undefined; + addcarryxU32(&x690, &x691, x689, x639, x673); + var x692: u32 = undefined; + var x693: u1 = undefined; + addcarryxU32(&x692, &x693, x691, x641, x675); + var x694: u32 = undefined; + var x695: u1 = undefined; + addcarryxU32(&x694, &x695, x693, x643, x677); + const x696 = (cast(u32, x695) + cast(u32, x644)); + var x697: u32 = undefined; + var x698: u32 = undefined; + mulxU32(&x697, &x698, x7, (arg1[7])); + var x699: u32 = undefined; + var x700: u32 = undefined; + mulxU32(&x699, &x700, x7, (arg1[6])); + var x701: u32 = undefined; + var x702: u32 = undefined; + mulxU32(&x701, &x702, x7, (arg1[5])); + var x703: u32 = undefined; + var x704: u32 = undefined; + mulxU32(&x703, &x704, x7, (arg1[4])); + var x705: u32 = undefined; + var x706: u32 = undefined; + mulxU32(&x705, &x706, x7, (arg1[3])); + var x707: u32 = undefined; + var x708: u32 = undefined; + mulxU32(&x707, &x708, x7, (arg1[2])); + var x709: u32 = undefined; + var x710: u32 = undefined; + mulxU32(&x709, &x710, x7, (arg1[1])); + var x711: u32 = undefined; + var x712: u32 = undefined; + mulxU32(&x711, &x712, x7, (arg1[0])); + var x713: u32 = undefined; + var x714: u1 = undefined; + addcarryxU32(&x713, &x714, 0x0, x712, x709); + var x715: u32 = undefined; + var x716: u1 = undefined; + addcarryxU32(&x715, &x716, x714, x710, x707); + var x717: u32 = undefined; + var x718: u1 = undefined; + addcarryxU32(&x717, &x718, x716, x708, x705); + var x719: u32 = undefined; + var x720: u1 = undefined; + addcarryxU32(&x719, &x720, x718, x706, x703); + var x721: u32 = undefined; + var x722: u1 = undefined; + addcarryxU32(&x721, &x722, x720, x704, x701); + var x723: u32 = undefined; + var x724: u1 = undefined; + addcarryxU32(&x723, &x724, x722, x702, x699); + var x725: u32 = undefined; + var x726: u1 = undefined; + addcarryxU32(&x725, &x726, x724, x700, x697); + const x727 = (cast(u32, x726) + x698); + var x728: u32 = undefined; + var x729: u1 = undefined; + addcarryxU32(&x728, &x729, 0x0, x680, x711); + var x730: u32 = undefined; + var x731: u1 = undefined; + addcarryxU32(&x730, &x731, x729, x682, x713); + var x732: u32 = undefined; + var x733: u1 = undefined; + addcarryxU32(&x732, &x733, x731, x684, x715); + var x734: u32 = undefined; + var x735: u1 = undefined; + addcarryxU32(&x734, &x735, x733, x686, x717); + var x736: u32 = undefined; + var x737: u1 = undefined; + addcarryxU32(&x736, &x737, x735, x688, x719); + var x738: u32 = undefined; + var x739: u1 = undefined; + addcarryxU32(&x738, &x739, x737, x690, x721); + var x740: u32 = undefined; + var x741: u1 = undefined; + addcarryxU32(&x740, &x741, x739, x692, x723); + var x742: u32 = undefined; + var x743: u1 = undefined; + addcarryxU32(&x742, &x743, x741, x694, x725); + var x744: u32 = undefined; + var x745: u1 = undefined; + addcarryxU32(&x744, &x745, x743, x696, x727); + var x746: u32 = undefined; + var x747: u32 = undefined; + mulxU32(&x746, &x747, x728, 0x5588b13f); + var x748: u32 = undefined; + var x749: u32 = undefined; + mulxU32(&x748, &x749, x746, 0xffffffff); + var x750: u32 = undefined; + var x751: u32 = undefined; + mulxU32(&x750, &x751, x746, 0xffffffff); + var x752: u32 = undefined; + var x753: u32 = undefined; + mulxU32(&x752, &x753, x746, 0xffffffff); + var x754: u32 = undefined; + var x755: u32 = undefined; + mulxU32(&x754, &x755, x746, 0xfffffffe); + var x756: u32 = undefined; + var x757: u32 = undefined; + mulxU32(&x756, &x757, x746, 0xbaaedce6); + var x758: u32 = undefined; + var x759: u32 = undefined; + mulxU32(&x758, &x759, x746, 0xaf48a03b); + var x760: u32 = undefined; + var x761: u32 = undefined; + mulxU32(&x760, &x761, x746, 0xbfd25e8c); + var x762: u32 = undefined; + var x763: u32 = undefined; + mulxU32(&x762, &x763, x746, 0xd0364141); + var x764: u32 = undefined; + var x765: u1 = undefined; + addcarryxU32(&x764, &x765, 0x0, x763, x760); + var x766: u32 = undefined; + var x767: u1 = undefined; + addcarryxU32(&x766, &x767, x765, x761, x758); + var x768: u32 = undefined; + var x769: u1 = undefined; + addcarryxU32(&x768, &x769, x767, x759, x756); + var x770: u32 = undefined; + var x771: u1 = undefined; + addcarryxU32(&x770, &x771, x769, x757, x754); + var x772: u32 = undefined; + var x773: u1 = undefined; + addcarryxU32(&x772, &x773, x771, x755, x752); + var x774: u32 = undefined; + var x775: u1 = undefined; + addcarryxU32(&x774, &x775, x773, x753, x750); + var x776: u32 = undefined; + var x777: u1 = undefined; + addcarryxU32(&x776, &x777, x775, x751, x748); + const x778 = (cast(u32, x777) + x749); + var x779: u32 = undefined; + var x780: u1 = undefined; + addcarryxU32(&x779, &x780, 0x0, x728, x762); + var x781: u32 = undefined; + var x782: u1 = undefined; + addcarryxU32(&x781, &x782, x780, x730, x764); + var x783: u32 = undefined; + var x784: u1 = undefined; + addcarryxU32(&x783, &x784, x782, x732, x766); + var x785: u32 = undefined; + var x786: u1 = undefined; + addcarryxU32(&x785, &x786, x784, x734, x768); + var x787: u32 = undefined; + var x788: u1 = undefined; + addcarryxU32(&x787, &x788, x786, x736, x770); + var x789: u32 = undefined; + var x790: u1 = undefined; + addcarryxU32(&x789, &x790, x788, x738, x772); + var x791: u32 = undefined; + var x792: u1 = undefined; + addcarryxU32(&x791, &x792, x790, x740, x774); + var x793: u32 = undefined; + var x794: u1 = undefined; + addcarryxU32(&x793, &x794, x792, x742, x776); + var x795: u32 = undefined; + var x796: u1 = undefined; + addcarryxU32(&x795, &x796, x794, x744, x778); + const x797 = (cast(u32, x796) + cast(u32, x745)); + var x798: u32 = undefined; + var x799: u1 = undefined; + subborrowxU32(&x798, &x799, 0x0, x781, 0xd0364141); + var x800: u32 = undefined; + var x801: u1 = undefined; + subborrowxU32(&x800, &x801, x799, x783, 0xbfd25e8c); + var x802: u32 = undefined; + var x803: u1 = undefined; + subborrowxU32(&x802, &x803, x801, x785, 0xaf48a03b); + var x804: u32 = undefined; + var x805: u1 = undefined; + subborrowxU32(&x804, &x805, x803, x787, 0xbaaedce6); + var x806: u32 = undefined; + var x807: u1 = undefined; + subborrowxU32(&x806, &x807, x805, x789, 0xfffffffe); + var x808: u32 = undefined; + var x809: u1 = undefined; + subborrowxU32(&x808, &x809, x807, x791, 0xffffffff); + var x810: u32 = undefined; + var x811: u1 = undefined; + subborrowxU32(&x810, &x811, x809, x793, 0xffffffff); + var x812: u32 = undefined; + var x813: u1 = undefined; + subborrowxU32(&x812, &x813, x811, x795, 0xffffffff); + var x814: u32 = undefined; + var x815: u1 = undefined; + subborrowxU32(&x814, &x815, x813, x797, cast(u32, 0x0)); + var x816: u32 = undefined; + cmovznzU32(&x816, x815, x798, x781); + var x817: u32 = undefined; + cmovznzU32(&x817, x815, x800, x783); + var x818: u32 = undefined; + cmovznzU32(&x818, x815, x802, x785); + var x819: u32 = undefined; + cmovznzU32(&x819, x815, x804, x787); + var x820: u32 = undefined; + cmovznzU32(&x820, x815, x806, x789); + var x821: u32 = undefined; + cmovznzU32(&x821, x815, x808, x791); + var x822: u32 = undefined; + cmovznzU32(&x822, x815, x810, x793); + var x823: u32 = undefined; + cmovznzU32(&x823, x815, x812, x795); + out1[0] = x816; + out1[1] = x817; + out1[2] = x818; + out1[3] = x819; + out1[4] = x820; + out1[5] = x821; + out1[6] = x822; + out1[7] = x823; +} + +/// The function add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn add(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + addcarryxU32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u32 = undefined; + var x4: u1 = undefined; + addcarryxU32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u32 = undefined; + var x6: u1 = undefined; + addcarryxU32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u32 = undefined; + var x8: u1 = undefined; + addcarryxU32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u32 = undefined; + var x10: u1 = undefined; + addcarryxU32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + var x11: u32 = undefined; + var x12: u1 = undefined; + addcarryxU32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + var x13: u32 = undefined; + var x14: u1 = undefined; + addcarryxU32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + var x15: u32 = undefined; + var x16: u1 = undefined; + addcarryxU32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + var x17: u32 = undefined; + var x18: u1 = undefined; + subborrowxU32(&x17, &x18, 0x0, x1, 0xd0364141); + var x19: u32 = undefined; + var x20: u1 = undefined; + subborrowxU32(&x19, &x20, x18, x3, 0xbfd25e8c); + var x21: u32 = undefined; + var x22: u1 = undefined; + subborrowxU32(&x21, &x22, x20, x5, 0xaf48a03b); + var x23: u32 = undefined; + var x24: u1 = undefined; + subborrowxU32(&x23, &x24, x22, x7, 0xbaaedce6); + var x25: u32 = undefined; + var x26: u1 = undefined; + subborrowxU32(&x25, &x26, x24, x9, 0xfffffffe); + var x27: u32 = undefined; + var x28: u1 = undefined; + subborrowxU32(&x27, &x28, x26, x11, 0xffffffff); + var x29: u32 = undefined; + var x30: u1 = undefined; + subborrowxU32(&x29, &x30, x28, x13, 0xffffffff); + var x31: u32 = undefined; + var x32: u1 = undefined; + subborrowxU32(&x31, &x32, x30, x15, 0xffffffff); + var x33: u32 = undefined; + var x34: u1 = undefined; + subborrowxU32(&x33, &x34, x32, cast(u32, x16), cast(u32, 0x0)); + var x35: u32 = undefined; + cmovznzU32(&x35, x34, x17, x1); + var x36: u32 = undefined; + cmovznzU32(&x36, x34, x19, x3); + var x37: u32 = undefined; + cmovznzU32(&x37, x34, x21, x5); + var x38: u32 = undefined; + cmovznzU32(&x38, x34, x23, x7); + var x39: u32 = undefined; + cmovznzU32(&x39, x34, x25, x9); + var x40: u32 = undefined; + cmovznzU32(&x40, x34, x27, x11); + var x41: u32 = undefined; + cmovznzU32(&x41, x34, x29, x13); + var x42: u32 = undefined; + cmovznzU32(&x42, x34, x31, x15); + out1[0] = x35; + out1[1] = x36; + out1[2] = x37; + out1[3] = x38; + out1[4] = x39; + out1[5] = x40; + out1[6] = x41; + out1[7] = x42; +} + +/// The function sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn sub(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + subborrowxU32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u32 = undefined; + var x4: u1 = undefined; + subborrowxU32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u32 = undefined; + var x6: u1 = undefined; + subborrowxU32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u32 = undefined; + var x8: u1 = undefined; + subborrowxU32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u32 = undefined; + var x10: u1 = undefined; + subborrowxU32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + var x11: u32 = undefined; + var x12: u1 = undefined; + subborrowxU32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + var x13: u32 = undefined; + var x14: u1 = undefined; + subborrowxU32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + var x15: u32 = undefined; + var x16: u1 = undefined; + subborrowxU32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + var x17: u32 = undefined; + cmovznzU32(&x17, x16, cast(u32, 0x0), 0xffffffff); + var x18: u32 = undefined; + var x19: u1 = undefined; + addcarryxU32(&x18, &x19, 0x0, x1, (x17 & 0xd0364141)); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, x3, (x17 & 0xbfd25e8c)); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x5, (x17 & 0xaf48a03b)); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x7, (x17 & 0xbaaedce6)); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, x9, (x17 & 0xfffffffe)); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, x11, x17); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, x13, x17); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x15, x17); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/// The function opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +pub fn opp(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + subborrowxU32(&x1, &x2, 0x0, cast(u32, 0x0), (arg1[0])); + var x3: u32 = undefined; + var x4: u1 = undefined; + subborrowxU32(&x3, &x4, x2, cast(u32, 0x0), (arg1[1])); + var x5: u32 = undefined; + var x6: u1 = undefined; + subborrowxU32(&x5, &x6, x4, cast(u32, 0x0), (arg1[2])); + var x7: u32 = undefined; + var x8: u1 = undefined; + subborrowxU32(&x7, &x8, x6, cast(u32, 0x0), (arg1[3])); + var x9: u32 = undefined; + var x10: u1 = undefined; + subborrowxU32(&x9, &x10, x8, cast(u32, 0x0), (arg1[4])); + var x11: u32 = undefined; + var x12: u1 = undefined; + subborrowxU32(&x11, &x12, x10, cast(u32, 0x0), (arg1[5])); + var x13: u32 = undefined; + var x14: u1 = undefined; + subborrowxU32(&x13, &x14, x12, cast(u32, 0x0), (arg1[6])); + var x15: u32 = undefined; + var x16: u1 = undefined; + subborrowxU32(&x15, &x16, x14, cast(u32, 0x0), (arg1[7])); + var x17: u32 = undefined; + cmovznzU32(&x17, x16, cast(u32, 0x0), 0xffffffff); + var x18: u32 = undefined; + var x19: u1 = undefined; + addcarryxU32(&x18, &x19, 0x0, x1, (x17 & 0xd0364141)); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, x3, (x17 & 0xbfd25e8c)); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x5, (x17 & 0xaf48a03b)); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x7, (x17 & 0xbaaedce6)); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, x9, (x17 & 0xfffffffe)); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, x11, x17); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, x13, x17); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x15, x17); + out1[0] = x18; + out1[1] = x20; + out1[2] = x22; + out1[3] = x24; + out1[4] = x26; + out1[5] = x28; + out1[6] = x30; + out1[7] = x32; +} + +/// The function fromMontgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^8) mod m +/// 0 ≤ eval out1 < m +/// +pub fn fromMontgomery(out1: *NonMontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[0]); + var x2: u32 = undefined; + var x3: u32 = undefined; + mulxU32(&x2, &x3, x1, 0x5588b13f); + var x4: u32 = undefined; + var x5: u32 = undefined; + mulxU32(&x4, &x5, x2, 0xffffffff); + var x6: u32 = undefined; + var x7: u32 = undefined; + mulxU32(&x6, &x7, x2, 0xffffffff); + var x8: u32 = undefined; + var x9: u32 = undefined; + mulxU32(&x8, &x9, x2, 0xffffffff); + var x10: u32 = undefined; + var x11: u32 = undefined; + mulxU32(&x10, &x11, x2, 0xfffffffe); + var x12: u32 = undefined; + var x13: u32 = undefined; + mulxU32(&x12, &x13, x2, 0xbaaedce6); + var x14: u32 = undefined; + var x15: u32 = undefined; + mulxU32(&x14, &x15, x2, 0xaf48a03b); + var x16: u32 = undefined; + var x17: u32 = undefined; + mulxU32(&x16, &x17, x2, 0xbfd25e8c); + var x18: u32 = undefined; + var x19: u32 = undefined; + mulxU32(&x18, &x19, x2, 0xd0364141); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, 0x0, x19, x16); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x17, x14); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x15, x12); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, x13, x10); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, x11, x8); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, x9, x6); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x7, x4); + var x34: u32 = undefined; + var x35: u1 = undefined; + addcarryxU32(&x34, &x35, 0x0, x1, x18); + var x36: u32 = undefined; + var x37: u1 = undefined; + addcarryxU32(&x36, &x37, x35, cast(u32, 0x0), x20); + var x38: u32 = undefined; + var x39: u1 = undefined; + addcarryxU32(&x38, &x39, x37, cast(u32, 0x0), x22); + var x40: u32 = undefined; + var x41: u1 = undefined; + addcarryxU32(&x40, &x41, x39, cast(u32, 0x0), x24); + var x42: u32 = undefined; + var x43: u1 = undefined; + addcarryxU32(&x42, &x43, x41, cast(u32, 0x0), x26); + var x44: u32 = undefined; + var x45: u1 = undefined; + addcarryxU32(&x44, &x45, x43, cast(u32, 0x0), x28); + var x46: u32 = undefined; + var x47: u1 = undefined; + addcarryxU32(&x46, &x47, x45, cast(u32, 0x0), x30); + var x48: u32 = undefined; + var x49: u1 = undefined; + addcarryxU32(&x48, &x49, x47, cast(u32, 0x0), x32); + var x50: u32 = undefined; + var x51: u1 = undefined; + addcarryxU32(&x50, &x51, x49, cast(u32, 0x0), (cast(u32, x33) + x5)); + var x52: u32 = undefined; + var x53: u1 = undefined; + addcarryxU32(&x52, &x53, 0x0, x36, (arg1[1])); + var x54: u32 = undefined; + var x55: u1 = undefined; + addcarryxU32(&x54, &x55, x53, x38, cast(u32, 0x0)); + var x56: u32 = undefined; + var x57: u1 = undefined; + addcarryxU32(&x56, &x57, x55, x40, cast(u32, 0x0)); + var x58: u32 = undefined; + var x59: u1 = undefined; + addcarryxU32(&x58, &x59, x57, x42, cast(u32, 0x0)); + var x60: u32 = undefined; + var x61: u1 = undefined; + addcarryxU32(&x60, &x61, x59, x44, cast(u32, 0x0)); + var x62: u32 = undefined; + var x63: u1 = undefined; + addcarryxU32(&x62, &x63, x61, x46, cast(u32, 0x0)); + var x64: u32 = undefined; + var x65: u1 = undefined; + addcarryxU32(&x64, &x65, x63, x48, cast(u32, 0x0)); + var x66: u32 = undefined; + var x67: u1 = undefined; + addcarryxU32(&x66, &x67, x65, x50, cast(u32, 0x0)); + var x68: u32 = undefined; + var x69: u32 = undefined; + mulxU32(&x68, &x69, x52, 0x5588b13f); + var x70: u32 = undefined; + var x71: u32 = undefined; + mulxU32(&x70, &x71, x68, 0xffffffff); + var x72: u32 = undefined; + var x73: u32 = undefined; + mulxU32(&x72, &x73, x68, 0xffffffff); + var x74: u32 = undefined; + var x75: u32 = undefined; + mulxU32(&x74, &x75, x68, 0xffffffff); + var x76: u32 = undefined; + var x77: u32 = undefined; + mulxU32(&x76, &x77, x68, 0xfffffffe); + var x78: u32 = undefined; + var x79: u32 = undefined; + mulxU32(&x78, &x79, x68, 0xbaaedce6); + var x80: u32 = undefined; + var x81: u32 = undefined; + mulxU32(&x80, &x81, x68, 0xaf48a03b); + var x82: u32 = undefined; + var x83: u32 = undefined; + mulxU32(&x82, &x83, x68, 0xbfd25e8c); + var x84: u32 = undefined; + var x85: u32 = undefined; + mulxU32(&x84, &x85, x68, 0xd0364141); + var x86: u32 = undefined; + var x87: u1 = undefined; + addcarryxU32(&x86, &x87, 0x0, x85, x82); + var x88: u32 = undefined; + var x89: u1 = undefined; + addcarryxU32(&x88, &x89, x87, x83, x80); + var x90: u32 = undefined; + var x91: u1 = undefined; + addcarryxU32(&x90, &x91, x89, x81, x78); + var x92: u32 = undefined; + var x93: u1 = undefined; + addcarryxU32(&x92, &x93, x91, x79, x76); + var x94: u32 = undefined; + var x95: u1 = undefined; + addcarryxU32(&x94, &x95, x93, x77, x74); + var x96: u32 = undefined; + var x97: u1 = undefined; + addcarryxU32(&x96, &x97, x95, x75, x72); + var x98: u32 = undefined; + var x99: u1 = undefined; + addcarryxU32(&x98, &x99, x97, x73, x70); + var x100: u32 = undefined; + var x101: u1 = undefined; + addcarryxU32(&x100, &x101, 0x0, x52, x84); + var x102: u32 = undefined; + var x103: u1 = undefined; + addcarryxU32(&x102, &x103, x101, x54, x86); + var x104: u32 = undefined; + var x105: u1 = undefined; + addcarryxU32(&x104, &x105, x103, x56, x88); + var x106: u32 = undefined; + var x107: u1 = undefined; + addcarryxU32(&x106, &x107, x105, x58, x90); + var x108: u32 = undefined; + var x109: u1 = undefined; + addcarryxU32(&x108, &x109, x107, x60, x92); + var x110: u32 = undefined; + var x111: u1 = undefined; + addcarryxU32(&x110, &x111, x109, x62, x94); + var x112: u32 = undefined; + var x113: u1 = undefined; + addcarryxU32(&x112, &x113, x111, x64, x96); + var x114: u32 = undefined; + var x115: u1 = undefined; + addcarryxU32(&x114, &x115, x113, x66, x98); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, x115, (cast(u32, x67) + cast(u32, x51)), (cast(u32, x99) + x71)); + var x118: u32 = undefined; + var x119: u1 = undefined; + addcarryxU32(&x118, &x119, 0x0, x102, (arg1[2])); + var x120: u32 = undefined; + var x121: u1 = undefined; + addcarryxU32(&x120, &x121, x119, x104, cast(u32, 0x0)); + var x122: u32 = undefined; + var x123: u1 = undefined; + addcarryxU32(&x122, &x123, x121, x106, cast(u32, 0x0)); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, x108, cast(u32, 0x0)); + var x126: u32 = undefined; + var x127: u1 = undefined; + addcarryxU32(&x126, &x127, x125, x110, cast(u32, 0x0)); + var x128: u32 = undefined; + var x129: u1 = undefined; + addcarryxU32(&x128, &x129, x127, x112, cast(u32, 0x0)); + var x130: u32 = undefined; + var x131: u1 = undefined; + addcarryxU32(&x130, &x131, x129, x114, cast(u32, 0x0)); + var x132: u32 = undefined; + var x133: u1 = undefined; + addcarryxU32(&x132, &x133, x131, x116, cast(u32, 0x0)); + var x134: u32 = undefined; + var x135: u32 = undefined; + mulxU32(&x134, &x135, x118, 0x5588b13f); + var x136: u32 = undefined; + var x137: u32 = undefined; + mulxU32(&x136, &x137, x134, 0xffffffff); + var x138: u32 = undefined; + var x139: u32 = undefined; + mulxU32(&x138, &x139, x134, 0xffffffff); + var x140: u32 = undefined; + var x141: u32 = undefined; + mulxU32(&x140, &x141, x134, 0xffffffff); + var x142: u32 = undefined; + var x143: u32 = undefined; + mulxU32(&x142, &x143, x134, 0xfffffffe); + var x144: u32 = undefined; + var x145: u32 = undefined; + mulxU32(&x144, &x145, x134, 0xbaaedce6); + var x146: u32 = undefined; + var x147: u32 = undefined; + mulxU32(&x146, &x147, x134, 0xaf48a03b); + var x148: u32 = undefined; + var x149: u32 = undefined; + mulxU32(&x148, &x149, x134, 0xbfd25e8c); + var x150: u32 = undefined; + var x151: u32 = undefined; + mulxU32(&x150, &x151, x134, 0xd0364141); + var x152: u32 = undefined; + var x153: u1 = undefined; + addcarryxU32(&x152, &x153, 0x0, x151, x148); + var x154: u32 = undefined; + var x155: u1 = undefined; + addcarryxU32(&x154, &x155, x153, x149, x146); + var x156: u32 = undefined; + var x157: u1 = undefined; + addcarryxU32(&x156, &x157, x155, x147, x144); + var x158: u32 = undefined; + var x159: u1 = undefined; + addcarryxU32(&x158, &x159, x157, x145, x142); + var x160: u32 = undefined; + var x161: u1 = undefined; + addcarryxU32(&x160, &x161, x159, x143, x140); + var x162: u32 = undefined; + var x163: u1 = undefined; + addcarryxU32(&x162, &x163, x161, x141, x138); + var x164: u32 = undefined; + var x165: u1 = undefined; + addcarryxU32(&x164, &x165, x163, x139, x136); + var x166: u32 = undefined; + var x167: u1 = undefined; + addcarryxU32(&x166, &x167, 0x0, x118, x150); + var x168: u32 = undefined; + var x169: u1 = undefined; + addcarryxU32(&x168, &x169, x167, x120, x152); + var x170: u32 = undefined; + var x171: u1 = undefined; + addcarryxU32(&x170, &x171, x169, x122, x154); + var x172: u32 = undefined; + var x173: u1 = undefined; + addcarryxU32(&x172, &x173, x171, x124, x156); + var x174: u32 = undefined; + var x175: u1 = undefined; + addcarryxU32(&x174, &x175, x173, x126, x158); + var x176: u32 = undefined; + var x177: u1 = undefined; + addcarryxU32(&x176, &x177, x175, x128, x160); + var x178: u32 = undefined; + var x179: u1 = undefined; + addcarryxU32(&x178, &x179, x177, x130, x162); + var x180: u32 = undefined; + var x181: u1 = undefined; + addcarryxU32(&x180, &x181, x179, x132, x164); + var x182: u32 = undefined; + var x183: u1 = undefined; + addcarryxU32(&x182, &x183, x181, (cast(u32, x133) + cast(u32, x117)), (cast(u32, x165) + x137)); + var x184: u32 = undefined; + var x185: u1 = undefined; + addcarryxU32(&x184, &x185, 0x0, x168, (arg1[3])); + var x186: u32 = undefined; + var x187: u1 = undefined; + addcarryxU32(&x186, &x187, x185, x170, cast(u32, 0x0)); + var x188: u32 = undefined; + var x189: u1 = undefined; + addcarryxU32(&x188, &x189, x187, x172, cast(u32, 0x0)); + var x190: u32 = undefined; + var x191: u1 = undefined; + addcarryxU32(&x190, &x191, x189, x174, cast(u32, 0x0)); + var x192: u32 = undefined; + var x193: u1 = undefined; + addcarryxU32(&x192, &x193, x191, x176, cast(u32, 0x0)); + var x194: u32 = undefined; + var x195: u1 = undefined; + addcarryxU32(&x194, &x195, x193, x178, cast(u32, 0x0)); + var x196: u32 = undefined; + var x197: u1 = undefined; + addcarryxU32(&x196, &x197, x195, x180, cast(u32, 0x0)); + var x198: u32 = undefined; + var x199: u1 = undefined; + addcarryxU32(&x198, &x199, x197, x182, cast(u32, 0x0)); + var x200: u32 = undefined; + var x201: u32 = undefined; + mulxU32(&x200, &x201, x184, 0x5588b13f); + var x202: u32 = undefined; + var x203: u32 = undefined; + mulxU32(&x202, &x203, x200, 0xffffffff); + var x204: u32 = undefined; + var x205: u32 = undefined; + mulxU32(&x204, &x205, x200, 0xffffffff); + var x206: u32 = undefined; + var x207: u32 = undefined; + mulxU32(&x206, &x207, x200, 0xffffffff); + var x208: u32 = undefined; + var x209: u32 = undefined; + mulxU32(&x208, &x209, x200, 0xfffffffe); + var x210: u32 = undefined; + var x211: u32 = undefined; + mulxU32(&x210, &x211, x200, 0xbaaedce6); + var x212: u32 = undefined; + var x213: u32 = undefined; + mulxU32(&x212, &x213, x200, 0xaf48a03b); + var x214: u32 = undefined; + var x215: u32 = undefined; + mulxU32(&x214, &x215, x200, 0xbfd25e8c); + var x216: u32 = undefined; + var x217: u32 = undefined; + mulxU32(&x216, &x217, x200, 0xd0364141); + var x218: u32 = undefined; + var x219: u1 = undefined; + addcarryxU32(&x218, &x219, 0x0, x217, x214); + var x220: u32 = undefined; + var x221: u1 = undefined; + addcarryxU32(&x220, &x221, x219, x215, x212); + var x222: u32 = undefined; + var x223: u1 = undefined; + addcarryxU32(&x222, &x223, x221, x213, x210); + var x224: u32 = undefined; + var x225: u1 = undefined; + addcarryxU32(&x224, &x225, x223, x211, x208); + var x226: u32 = undefined; + var x227: u1 = undefined; + addcarryxU32(&x226, &x227, x225, x209, x206); + var x228: u32 = undefined; + var x229: u1 = undefined; + addcarryxU32(&x228, &x229, x227, x207, x204); + var x230: u32 = undefined; + var x231: u1 = undefined; + addcarryxU32(&x230, &x231, x229, x205, x202); + var x232: u32 = undefined; + var x233: u1 = undefined; + addcarryxU32(&x232, &x233, 0x0, x184, x216); + var x234: u32 = undefined; + var x235: u1 = undefined; + addcarryxU32(&x234, &x235, x233, x186, x218); + var x236: u32 = undefined; + var x237: u1 = undefined; + addcarryxU32(&x236, &x237, x235, x188, x220); + var x238: u32 = undefined; + var x239: u1 = undefined; + addcarryxU32(&x238, &x239, x237, x190, x222); + var x240: u32 = undefined; + var x241: u1 = undefined; + addcarryxU32(&x240, &x241, x239, x192, x224); + var x242: u32 = undefined; + var x243: u1 = undefined; + addcarryxU32(&x242, &x243, x241, x194, x226); + var x244: u32 = undefined; + var x245: u1 = undefined; + addcarryxU32(&x244, &x245, x243, x196, x228); + var x246: u32 = undefined; + var x247: u1 = undefined; + addcarryxU32(&x246, &x247, x245, x198, x230); + var x248: u32 = undefined; + var x249: u1 = undefined; + addcarryxU32(&x248, &x249, x247, (cast(u32, x199) + cast(u32, x183)), (cast(u32, x231) + x203)); + var x250: u32 = undefined; + var x251: u1 = undefined; + addcarryxU32(&x250, &x251, 0x0, x234, (arg1[4])); + var x252: u32 = undefined; + var x253: u1 = undefined; + addcarryxU32(&x252, &x253, x251, x236, cast(u32, 0x0)); + var x254: u32 = undefined; + var x255: u1 = undefined; + addcarryxU32(&x254, &x255, x253, x238, cast(u32, 0x0)); + var x256: u32 = undefined; + var x257: u1 = undefined; + addcarryxU32(&x256, &x257, x255, x240, cast(u32, 0x0)); + var x258: u32 = undefined; + var x259: u1 = undefined; + addcarryxU32(&x258, &x259, x257, x242, cast(u32, 0x0)); + var x260: u32 = undefined; + var x261: u1 = undefined; + addcarryxU32(&x260, &x261, x259, x244, cast(u32, 0x0)); + var x262: u32 = undefined; + var x263: u1 = undefined; + addcarryxU32(&x262, &x263, x261, x246, cast(u32, 0x0)); + var x264: u32 = undefined; + var x265: u1 = undefined; + addcarryxU32(&x264, &x265, x263, x248, cast(u32, 0x0)); + var x266: u32 = undefined; + var x267: u32 = undefined; + mulxU32(&x266, &x267, x250, 0x5588b13f); + var x268: u32 = undefined; + var x269: u32 = undefined; + mulxU32(&x268, &x269, x266, 0xffffffff); + var x270: u32 = undefined; + var x271: u32 = undefined; + mulxU32(&x270, &x271, x266, 0xffffffff); + var x272: u32 = undefined; + var x273: u32 = undefined; + mulxU32(&x272, &x273, x266, 0xffffffff); + var x274: u32 = undefined; + var x275: u32 = undefined; + mulxU32(&x274, &x275, x266, 0xfffffffe); + var x276: u32 = undefined; + var x277: u32 = undefined; + mulxU32(&x276, &x277, x266, 0xbaaedce6); + var x278: u32 = undefined; + var x279: u32 = undefined; + mulxU32(&x278, &x279, x266, 0xaf48a03b); + var x280: u32 = undefined; + var x281: u32 = undefined; + mulxU32(&x280, &x281, x266, 0xbfd25e8c); + var x282: u32 = undefined; + var x283: u32 = undefined; + mulxU32(&x282, &x283, x266, 0xd0364141); + var x284: u32 = undefined; + var x285: u1 = undefined; + addcarryxU32(&x284, &x285, 0x0, x283, x280); + var x286: u32 = undefined; + var x287: u1 = undefined; + addcarryxU32(&x286, &x287, x285, x281, x278); + var x288: u32 = undefined; + var x289: u1 = undefined; + addcarryxU32(&x288, &x289, x287, x279, x276); + var x290: u32 = undefined; + var x291: u1 = undefined; + addcarryxU32(&x290, &x291, x289, x277, x274); + var x292: u32 = undefined; + var x293: u1 = undefined; + addcarryxU32(&x292, &x293, x291, x275, x272); + var x294: u32 = undefined; + var x295: u1 = undefined; + addcarryxU32(&x294, &x295, x293, x273, x270); + var x296: u32 = undefined; + var x297: u1 = undefined; + addcarryxU32(&x296, &x297, x295, x271, x268); + var x298: u32 = undefined; + var x299: u1 = undefined; + addcarryxU32(&x298, &x299, 0x0, x250, x282); + var x300: u32 = undefined; + var x301: u1 = undefined; + addcarryxU32(&x300, &x301, x299, x252, x284); + var x302: u32 = undefined; + var x303: u1 = undefined; + addcarryxU32(&x302, &x303, x301, x254, x286); + var x304: u32 = undefined; + var x305: u1 = undefined; + addcarryxU32(&x304, &x305, x303, x256, x288); + var x306: u32 = undefined; + var x307: u1 = undefined; + addcarryxU32(&x306, &x307, x305, x258, x290); + var x308: u32 = undefined; + var x309: u1 = undefined; + addcarryxU32(&x308, &x309, x307, x260, x292); + var x310: u32 = undefined; + var x311: u1 = undefined; + addcarryxU32(&x310, &x311, x309, x262, x294); + var x312: u32 = undefined; + var x313: u1 = undefined; + addcarryxU32(&x312, &x313, x311, x264, x296); + var x314: u32 = undefined; + var x315: u1 = undefined; + addcarryxU32(&x314, &x315, x313, (cast(u32, x265) + cast(u32, x249)), (cast(u32, x297) + x269)); + var x316: u32 = undefined; + var x317: u1 = undefined; + addcarryxU32(&x316, &x317, 0x0, x300, (arg1[5])); + var x318: u32 = undefined; + var x319: u1 = undefined; + addcarryxU32(&x318, &x319, x317, x302, cast(u32, 0x0)); + var x320: u32 = undefined; + var x321: u1 = undefined; + addcarryxU32(&x320, &x321, x319, x304, cast(u32, 0x0)); + var x322: u32 = undefined; + var x323: u1 = undefined; + addcarryxU32(&x322, &x323, x321, x306, cast(u32, 0x0)); + var x324: u32 = undefined; + var x325: u1 = undefined; + addcarryxU32(&x324, &x325, x323, x308, cast(u32, 0x0)); + var x326: u32 = undefined; + var x327: u1 = undefined; + addcarryxU32(&x326, &x327, x325, x310, cast(u32, 0x0)); + var x328: u32 = undefined; + var x329: u1 = undefined; + addcarryxU32(&x328, &x329, x327, x312, cast(u32, 0x0)); + var x330: u32 = undefined; + var x331: u1 = undefined; + addcarryxU32(&x330, &x331, x329, x314, cast(u32, 0x0)); + var x332: u32 = undefined; + var x333: u32 = undefined; + mulxU32(&x332, &x333, x316, 0x5588b13f); + var x334: u32 = undefined; + var x335: u32 = undefined; + mulxU32(&x334, &x335, x332, 0xffffffff); + var x336: u32 = undefined; + var x337: u32 = undefined; + mulxU32(&x336, &x337, x332, 0xffffffff); + var x338: u32 = undefined; + var x339: u32 = undefined; + mulxU32(&x338, &x339, x332, 0xffffffff); + var x340: u32 = undefined; + var x341: u32 = undefined; + mulxU32(&x340, &x341, x332, 0xfffffffe); + var x342: u32 = undefined; + var x343: u32 = undefined; + mulxU32(&x342, &x343, x332, 0xbaaedce6); + var x344: u32 = undefined; + var x345: u32 = undefined; + mulxU32(&x344, &x345, x332, 0xaf48a03b); + var x346: u32 = undefined; + var x347: u32 = undefined; + mulxU32(&x346, &x347, x332, 0xbfd25e8c); + var x348: u32 = undefined; + var x349: u32 = undefined; + mulxU32(&x348, &x349, x332, 0xd0364141); + var x350: u32 = undefined; + var x351: u1 = undefined; + addcarryxU32(&x350, &x351, 0x0, x349, x346); + var x352: u32 = undefined; + var x353: u1 = undefined; + addcarryxU32(&x352, &x353, x351, x347, x344); + var x354: u32 = undefined; + var x355: u1 = undefined; + addcarryxU32(&x354, &x355, x353, x345, x342); + var x356: u32 = undefined; + var x357: u1 = undefined; + addcarryxU32(&x356, &x357, x355, x343, x340); + var x358: u32 = undefined; + var x359: u1 = undefined; + addcarryxU32(&x358, &x359, x357, x341, x338); + var x360: u32 = undefined; + var x361: u1 = undefined; + addcarryxU32(&x360, &x361, x359, x339, x336); + var x362: u32 = undefined; + var x363: u1 = undefined; + addcarryxU32(&x362, &x363, x361, x337, x334); + var x364: u32 = undefined; + var x365: u1 = undefined; + addcarryxU32(&x364, &x365, 0x0, x316, x348); + var x366: u32 = undefined; + var x367: u1 = undefined; + addcarryxU32(&x366, &x367, x365, x318, x350); + var x368: u32 = undefined; + var x369: u1 = undefined; + addcarryxU32(&x368, &x369, x367, x320, x352); + var x370: u32 = undefined; + var x371: u1 = undefined; + addcarryxU32(&x370, &x371, x369, x322, x354); + var x372: u32 = undefined; + var x373: u1 = undefined; + addcarryxU32(&x372, &x373, x371, x324, x356); + var x374: u32 = undefined; + var x375: u1 = undefined; + addcarryxU32(&x374, &x375, x373, x326, x358); + var x376: u32 = undefined; + var x377: u1 = undefined; + addcarryxU32(&x376, &x377, x375, x328, x360); + var x378: u32 = undefined; + var x379: u1 = undefined; + addcarryxU32(&x378, &x379, x377, x330, x362); + var x380: u32 = undefined; + var x381: u1 = undefined; + addcarryxU32(&x380, &x381, x379, (cast(u32, x331) + cast(u32, x315)), (cast(u32, x363) + x335)); + var x382: u32 = undefined; + var x383: u1 = undefined; + addcarryxU32(&x382, &x383, 0x0, x366, (arg1[6])); + var x384: u32 = undefined; + var x385: u1 = undefined; + addcarryxU32(&x384, &x385, x383, x368, cast(u32, 0x0)); + var x386: u32 = undefined; + var x387: u1 = undefined; + addcarryxU32(&x386, &x387, x385, x370, cast(u32, 0x0)); + var x388: u32 = undefined; + var x389: u1 = undefined; + addcarryxU32(&x388, &x389, x387, x372, cast(u32, 0x0)); + var x390: u32 = undefined; + var x391: u1 = undefined; + addcarryxU32(&x390, &x391, x389, x374, cast(u32, 0x0)); + var x392: u32 = undefined; + var x393: u1 = undefined; + addcarryxU32(&x392, &x393, x391, x376, cast(u32, 0x0)); + var x394: u32 = undefined; + var x395: u1 = undefined; + addcarryxU32(&x394, &x395, x393, x378, cast(u32, 0x0)); + var x396: u32 = undefined; + var x397: u1 = undefined; + addcarryxU32(&x396, &x397, x395, x380, cast(u32, 0x0)); + var x398: u32 = undefined; + var x399: u32 = undefined; + mulxU32(&x398, &x399, x382, 0x5588b13f); + var x400: u32 = undefined; + var x401: u32 = undefined; + mulxU32(&x400, &x401, x398, 0xffffffff); + var x402: u32 = undefined; + var x403: u32 = undefined; + mulxU32(&x402, &x403, x398, 0xffffffff); + var x404: u32 = undefined; + var x405: u32 = undefined; + mulxU32(&x404, &x405, x398, 0xffffffff); + var x406: u32 = undefined; + var x407: u32 = undefined; + mulxU32(&x406, &x407, x398, 0xfffffffe); + var x408: u32 = undefined; + var x409: u32 = undefined; + mulxU32(&x408, &x409, x398, 0xbaaedce6); + var x410: u32 = undefined; + var x411: u32 = undefined; + mulxU32(&x410, &x411, x398, 0xaf48a03b); + var x412: u32 = undefined; + var x413: u32 = undefined; + mulxU32(&x412, &x413, x398, 0xbfd25e8c); + var x414: u32 = undefined; + var x415: u32 = undefined; + mulxU32(&x414, &x415, x398, 0xd0364141); + var x416: u32 = undefined; + var x417: u1 = undefined; + addcarryxU32(&x416, &x417, 0x0, x415, x412); + var x418: u32 = undefined; + var x419: u1 = undefined; + addcarryxU32(&x418, &x419, x417, x413, x410); + var x420: u32 = undefined; + var x421: u1 = undefined; + addcarryxU32(&x420, &x421, x419, x411, x408); + var x422: u32 = undefined; + var x423: u1 = undefined; + addcarryxU32(&x422, &x423, x421, x409, x406); + var x424: u32 = undefined; + var x425: u1 = undefined; + addcarryxU32(&x424, &x425, x423, x407, x404); + var x426: u32 = undefined; + var x427: u1 = undefined; + addcarryxU32(&x426, &x427, x425, x405, x402); + var x428: u32 = undefined; + var x429: u1 = undefined; + addcarryxU32(&x428, &x429, x427, x403, x400); + var x430: u32 = undefined; + var x431: u1 = undefined; + addcarryxU32(&x430, &x431, 0x0, x382, x414); + var x432: u32 = undefined; + var x433: u1 = undefined; + addcarryxU32(&x432, &x433, x431, x384, x416); + var x434: u32 = undefined; + var x435: u1 = undefined; + addcarryxU32(&x434, &x435, x433, x386, x418); + var x436: u32 = undefined; + var x437: u1 = undefined; + addcarryxU32(&x436, &x437, x435, x388, x420); + var x438: u32 = undefined; + var x439: u1 = undefined; + addcarryxU32(&x438, &x439, x437, x390, x422); + var x440: u32 = undefined; + var x441: u1 = undefined; + addcarryxU32(&x440, &x441, x439, x392, x424); + var x442: u32 = undefined; + var x443: u1 = undefined; + addcarryxU32(&x442, &x443, x441, x394, x426); + var x444: u32 = undefined; + var x445: u1 = undefined; + addcarryxU32(&x444, &x445, x443, x396, x428); + var x446: u32 = undefined; + var x447: u1 = undefined; + addcarryxU32(&x446, &x447, x445, (cast(u32, x397) + cast(u32, x381)), (cast(u32, x429) + x401)); + var x448: u32 = undefined; + var x449: u1 = undefined; + addcarryxU32(&x448, &x449, 0x0, x432, (arg1[7])); + var x450: u32 = undefined; + var x451: u1 = undefined; + addcarryxU32(&x450, &x451, x449, x434, cast(u32, 0x0)); + var x452: u32 = undefined; + var x453: u1 = undefined; + addcarryxU32(&x452, &x453, x451, x436, cast(u32, 0x0)); + var x454: u32 = undefined; + var x455: u1 = undefined; + addcarryxU32(&x454, &x455, x453, x438, cast(u32, 0x0)); + var x456: u32 = undefined; + var x457: u1 = undefined; + addcarryxU32(&x456, &x457, x455, x440, cast(u32, 0x0)); + var x458: u32 = undefined; + var x459: u1 = undefined; + addcarryxU32(&x458, &x459, x457, x442, cast(u32, 0x0)); + var x460: u32 = undefined; + var x461: u1 = undefined; + addcarryxU32(&x460, &x461, x459, x444, cast(u32, 0x0)); + var x462: u32 = undefined; + var x463: u1 = undefined; + addcarryxU32(&x462, &x463, x461, x446, cast(u32, 0x0)); + var x464: u32 = undefined; + var x465: u32 = undefined; + mulxU32(&x464, &x465, x448, 0x5588b13f); + var x466: u32 = undefined; + var x467: u32 = undefined; + mulxU32(&x466, &x467, x464, 0xffffffff); + var x468: u32 = undefined; + var x469: u32 = undefined; + mulxU32(&x468, &x469, x464, 0xffffffff); + var x470: u32 = undefined; + var x471: u32 = undefined; + mulxU32(&x470, &x471, x464, 0xffffffff); + var x472: u32 = undefined; + var x473: u32 = undefined; + mulxU32(&x472, &x473, x464, 0xfffffffe); + var x474: u32 = undefined; + var x475: u32 = undefined; + mulxU32(&x474, &x475, x464, 0xbaaedce6); + var x476: u32 = undefined; + var x477: u32 = undefined; + mulxU32(&x476, &x477, x464, 0xaf48a03b); + var x478: u32 = undefined; + var x479: u32 = undefined; + mulxU32(&x478, &x479, x464, 0xbfd25e8c); + var x480: u32 = undefined; + var x481: u32 = undefined; + mulxU32(&x480, &x481, x464, 0xd0364141); + var x482: u32 = undefined; + var x483: u1 = undefined; + addcarryxU32(&x482, &x483, 0x0, x481, x478); + var x484: u32 = undefined; + var x485: u1 = undefined; + addcarryxU32(&x484, &x485, x483, x479, x476); + var x486: u32 = undefined; + var x487: u1 = undefined; + addcarryxU32(&x486, &x487, x485, x477, x474); + var x488: u32 = undefined; + var x489: u1 = undefined; + addcarryxU32(&x488, &x489, x487, x475, x472); + var x490: u32 = undefined; + var x491: u1 = undefined; + addcarryxU32(&x490, &x491, x489, x473, x470); + var x492: u32 = undefined; + var x493: u1 = undefined; + addcarryxU32(&x492, &x493, x491, x471, x468); + var x494: u32 = undefined; + var x495: u1 = undefined; + addcarryxU32(&x494, &x495, x493, x469, x466); + var x496: u32 = undefined; + var x497: u1 = undefined; + addcarryxU32(&x496, &x497, 0x0, x448, x480); + var x498: u32 = undefined; + var x499: u1 = undefined; + addcarryxU32(&x498, &x499, x497, x450, x482); + var x500: u32 = undefined; + var x501: u1 = undefined; + addcarryxU32(&x500, &x501, x499, x452, x484); + var x502: u32 = undefined; + var x503: u1 = undefined; + addcarryxU32(&x502, &x503, x501, x454, x486); + var x504: u32 = undefined; + var x505: u1 = undefined; + addcarryxU32(&x504, &x505, x503, x456, x488); + var x506: u32 = undefined; + var x507: u1 = undefined; + addcarryxU32(&x506, &x507, x505, x458, x490); + var x508: u32 = undefined; + var x509: u1 = undefined; + addcarryxU32(&x508, &x509, x507, x460, x492); + var x510: u32 = undefined; + var x511: u1 = undefined; + addcarryxU32(&x510, &x511, x509, x462, x494); + var x512: u32 = undefined; + var x513: u1 = undefined; + addcarryxU32(&x512, &x513, x511, (cast(u32, x463) + cast(u32, x447)), (cast(u32, x495) + x467)); + var x514: u32 = undefined; + var x515: u1 = undefined; + subborrowxU32(&x514, &x515, 0x0, x498, 0xd0364141); + var x516: u32 = undefined; + var x517: u1 = undefined; + subborrowxU32(&x516, &x517, x515, x500, 0xbfd25e8c); + var x518: u32 = undefined; + var x519: u1 = undefined; + subborrowxU32(&x518, &x519, x517, x502, 0xaf48a03b); + var x520: u32 = undefined; + var x521: u1 = undefined; + subborrowxU32(&x520, &x521, x519, x504, 0xbaaedce6); + var x522: u32 = undefined; + var x523: u1 = undefined; + subborrowxU32(&x522, &x523, x521, x506, 0xfffffffe); + var x524: u32 = undefined; + var x525: u1 = undefined; + subborrowxU32(&x524, &x525, x523, x508, 0xffffffff); + var x526: u32 = undefined; + var x527: u1 = undefined; + subborrowxU32(&x526, &x527, x525, x510, 0xffffffff); + var x528: u32 = undefined; + var x529: u1 = undefined; + subborrowxU32(&x528, &x529, x527, x512, 0xffffffff); + var x530: u32 = undefined; + var x531: u1 = undefined; + subborrowxU32(&x530, &x531, x529, cast(u32, x513), cast(u32, 0x0)); + var x532: u32 = undefined; + cmovznzU32(&x532, x531, x514, x498); + var x533: u32 = undefined; + cmovznzU32(&x533, x531, x516, x500); + var x534: u32 = undefined; + cmovznzU32(&x534, x531, x518, x502); + var x535: u32 = undefined; + cmovznzU32(&x535, x531, x520, x504); + var x536: u32 = undefined; + cmovznzU32(&x536, x531, x522, x506); + var x537: u32 = undefined; + cmovznzU32(&x537, x531, x524, x508); + var x538: u32 = undefined; + cmovznzU32(&x538, x531, x526, x510); + var x539: u32 = undefined; + cmovznzU32(&x539, x531, x528, x512); + out1[0] = x532; + out1[1] = x533; + out1[2] = x534; + out1[3] = x535; + out1[4] = x536; + out1[5] = x537; + out1[6] = x538; + out1[7] = x539; +} + +/// The function toMontgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn toMontgomery(out1: *MontgomeryDomainFieldElement, arg1: NonMontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[4]); + const x5 = (arg1[5]); + const x6 = (arg1[6]); + const x7 = (arg1[7]); + const x8 = (arg1[0]); + var x9: u32 = undefined; + var x10: u32 = undefined; + mulxU32(&x9, &x10, x8, 0x9d671cd5); + var x11: u32 = undefined; + var x12: u32 = undefined; + mulxU32(&x11, &x12, x8, 0x81c69bc5); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x8, 0xe697f5e4); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x8, 0x5bcd07c6); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x8, 0x741496c2); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x8, 0xe7cf878); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x8, 0x896cf214); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x8, 0x67d7d140); + var x25: u32 = undefined; + var x26: u1 = undefined; + addcarryxU32(&x25, &x26, 0x0, x24, x21); + var x27: u32 = undefined; + var x28: u1 = undefined; + addcarryxU32(&x27, &x28, x26, x22, x19); + var x29: u32 = undefined; + var x30: u1 = undefined; + addcarryxU32(&x29, &x30, x28, x20, x17); + var x31: u32 = undefined; + var x32: u1 = undefined; + addcarryxU32(&x31, &x32, x30, x18, x15); + var x33: u32 = undefined; + var x34: u1 = undefined; + addcarryxU32(&x33, &x34, x32, x16, x13); + var x35: u32 = undefined; + var x36: u1 = undefined; + addcarryxU32(&x35, &x36, x34, x14, x11); + var x37: u32 = undefined; + var x38: u1 = undefined; + addcarryxU32(&x37, &x38, x36, x12, x9); + var x39: u32 = undefined; + var x40: u32 = undefined; + mulxU32(&x39, &x40, x23, 0x5588b13f); + var x41: u32 = undefined; + var x42: u32 = undefined; + mulxU32(&x41, &x42, x39, 0xffffffff); + var x43: u32 = undefined; + var x44: u32 = undefined; + mulxU32(&x43, &x44, x39, 0xffffffff); + var x45: u32 = undefined; + var x46: u32 = undefined; + mulxU32(&x45, &x46, x39, 0xffffffff); + var x47: u32 = undefined; + var x48: u32 = undefined; + mulxU32(&x47, &x48, x39, 0xfffffffe); + var x49: u32 = undefined; + var x50: u32 = undefined; + mulxU32(&x49, &x50, x39, 0xbaaedce6); + var x51: u32 = undefined; + var x52: u32 = undefined; + mulxU32(&x51, &x52, x39, 0xaf48a03b); + var x53: u32 = undefined; + var x54: u32 = undefined; + mulxU32(&x53, &x54, x39, 0xbfd25e8c); + var x55: u32 = undefined; + var x56: u32 = undefined; + mulxU32(&x55, &x56, x39, 0xd0364141); + var x57: u32 = undefined; + var x58: u1 = undefined; + addcarryxU32(&x57, &x58, 0x0, x56, x53); + var x59: u32 = undefined; + var x60: u1 = undefined; + addcarryxU32(&x59, &x60, x58, x54, x51); + var x61: u32 = undefined; + var x62: u1 = undefined; + addcarryxU32(&x61, &x62, x60, x52, x49); + var x63: u32 = undefined; + var x64: u1 = undefined; + addcarryxU32(&x63, &x64, x62, x50, x47); + var x65: u32 = undefined; + var x66: u1 = undefined; + addcarryxU32(&x65, &x66, x64, x48, x45); + var x67: u32 = undefined; + var x68: u1 = undefined; + addcarryxU32(&x67, &x68, x66, x46, x43); + var x69: u32 = undefined; + var x70: u1 = undefined; + addcarryxU32(&x69, &x70, x68, x44, x41); + var x71: u32 = undefined; + var x72: u1 = undefined; + addcarryxU32(&x71, &x72, 0x0, x23, x55); + var x73: u32 = undefined; + var x74: u1 = undefined; + addcarryxU32(&x73, &x74, x72, x25, x57); + var x75: u32 = undefined; + var x76: u1 = undefined; + addcarryxU32(&x75, &x76, x74, x27, x59); + var x77: u32 = undefined; + var x78: u1 = undefined; + addcarryxU32(&x77, &x78, x76, x29, x61); + var x79: u32 = undefined; + var x80: u1 = undefined; + addcarryxU32(&x79, &x80, x78, x31, x63); + var x81: u32 = undefined; + var x82: u1 = undefined; + addcarryxU32(&x81, &x82, x80, x33, x65); + var x83: u32 = undefined; + var x84: u1 = undefined; + addcarryxU32(&x83, &x84, x82, x35, x67); + var x85: u32 = undefined; + var x86: u1 = undefined; + addcarryxU32(&x85, &x86, x84, x37, x69); + var x87: u32 = undefined; + var x88: u1 = undefined; + addcarryxU32(&x87, &x88, x86, (cast(u32, x38) + x10), (cast(u32, x70) + x42)); + var x89: u32 = undefined; + var x90: u32 = undefined; + mulxU32(&x89, &x90, x1, 0x9d671cd5); + var x91: u32 = undefined; + var x92: u32 = undefined; + mulxU32(&x91, &x92, x1, 0x81c69bc5); + var x93: u32 = undefined; + var x94: u32 = undefined; + mulxU32(&x93, &x94, x1, 0xe697f5e4); + var x95: u32 = undefined; + var x96: u32 = undefined; + mulxU32(&x95, &x96, x1, 0x5bcd07c6); + var x97: u32 = undefined; + var x98: u32 = undefined; + mulxU32(&x97, &x98, x1, 0x741496c2); + var x99: u32 = undefined; + var x100: u32 = undefined; + mulxU32(&x99, &x100, x1, 0xe7cf878); + var x101: u32 = undefined; + var x102: u32 = undefined; + mulxU32(&x101, &x102, x1, 0x896cf214); + var x103: u32 = undefined; + var x104: u32 = undefined; + mulxU32(&x103, &x104, x1, 0x67d7d140); + var x105: u32 = undefined; + var x106: u1 = undefined; + addcarryxU32(&x105, &x106, 0x0, x104, x101); + var x107: u32 = undefined; + var x108: u1 = undefined; + addcarryxU32(&x107, &x108, x106, x102, x99); + var x109: u32 = undefined; + var x110: u1 = undefined; + addcarryxU32(&x109, &x110, x108, x100, x97); + var x111: u32 = undefined; + var x112: u1 = undefined; + addcarryxU32(&x111, &x112, x110, x98, x95); + var x113: u32 = undefined; + var x114: u1 = undefined; + addcarryxU32(&x113, &x114, x112, x96, x93); + var x115: u32 = undefined; + var x116: u1 = undefined; + addcarryxU32(&x115, &x116, x114, x94, x91); + var x117: u32 = undefined; + var x118: u1 = undefined; + addcarryxU32(&x117, &x118, x116, x92, x89); + var x119: u32 = undefined; + var x120: u1 = undefined; + addcarryxU32(&x119, &x120, 0x0, x73, x103); + var x121: u32 = undefined; + var x122: u1 = undefined; + addcarryxU32(&x121, &x122, x120, x75, x105); + var x123: u32 = undefined; + var x124: u1 = undefined; + addcarryxU32(&x123, &x124, x122, x77, x107); + var x125: u32 = undefined; + var x126: u1 = undefined; + addcarryxU32(&x125, &x126, x124, x79, x109); + var x127: u32 = undefined; + var x128: u1 = undefined; + addcarryxU32(&x127, &x128, x126, x81, x111); + var x129: u32 = undefined; + var x130: u1 = undefined; + addcarryxU32(&x129, &x130, x128, x83, x113); + var x131: u32 = undefined; + var x132: u1 = undefined; + addcarryxU32(&x131, &x132, x130, x85, x115); + var x133: u32 = undefined; + var x134: u1 = undefined; + addcarryxU32(&x133, &x134, x132, x87, x117); + var x135: u32 = undefined; + var x136: u32 = undefined; + mulxU32(&x135, &x136, x119, 0x5588b13f); + var x137: u32 = undefined; + var x138: u32 = undefined; + mulxU32(&x137, &x138, x135, 0xffffffff); + var x139: u32 = undefined; + var x140: u32 = undefined; + mulxU32(&x139, &x140, x135, 0xffffffff); + var x141: u32 = undefined; + var x142: u32 = undefined; + mulxU32(&x141, &x142, x135, 0xffffffff); + var x143: u32 = undefined; + var x144: u32 = undefined; + mulxU32(&x143, &x144, x135, 0xfffffffe); + var x145: u32 = undefined; + var x146: u32 = undefined; + mulxU32(&x145, &x146, x135, 0xbaaedce6); + var x147: u32 = undefined; + var x148: u32 = undefined; + mulxU32(&x147, &x148, x135, 0xaf48a03b); + var x149: u32 = undefined; + var x150: u32 = undefined; + mulxU32(&x149, &x150, x135, 0xbfd25e8c); + var x151: u32 = undefined; + var x152: u32 = undefined; + mulxU32(&x151, &x152, x135, 0xd0364141); + var x153: u32 = undefined; + var x154: u1 = undefined; + addcarryxU32(&x153, &x154, 0x0, x152, x149); + var x155: u32 = undefined; + var x156: u1 = undefined; + addcarryxU32(&x155, &x156, x154, x150, x147); + var x157: u32 = undefined; + var x158: u1 = undefined; + addcarryxU32(&x157, &x158, x156, x148, x145); + var x159: u32 = undefined; + var x160: u1 = undefined; + addcarryxU32(&x159, &x160, x158, x146, x143); + var x161: u32 = undefined; + var x162: u1 = undefined; + addcarryxU32(&x161, &x162, x160, x144, x141); + var x163: u32 = undefined; + var x164: u1 = undefined; + addcarryxU32(&x163, &x164, x162, x142, x139); + var x165: u32 = undefined; + var x166: u1 = undefined; + addcarryxU32(&x165, &x166, x164, x140, x137); + var x167: u32 = undefined; + var x168: u1 = undefined; + addcarryxU32(&x167, &x168, 0x0, x119, x151); + var x169: u32 = undefined; + var x170: u1 = undefined; + addcarryxU32(&x169, &x170, x168, x121, x153); + var x171: u32 = undefined; + var x172: u1 = undefined; + addcarryxU32(&x171, &x172, x170, x123, x155); + var x173: u32 = undefined; + var x174: u1 = undefined; + addcarryxU32(&x173, &x174, x172, x125, x157); + var x175: u32 = undefined; + var x176: u1 = undefined; + addcarryxU32(&x175, &x176, x174, x127, x159); + var x177: u32 = undefined; + var x178: u1 = undefined; + addcarryxU32(&x177, &x178, x176, x129, x161); + var x179: u32 = undefined; + var x180: u1 = undefined; + addcarryxU32(&x179, &x180, x178, x131, x163); + var x181: u32 = undefined; + var x182: u1 = undefined; + addcarryxU32(&x181, &x182, x180, x133, x165); + var x183: u32 = undefined; + var x184: u1 = undefined; + addcarryxU32(&x183, &x184, x182, ((cast(u32, x134) + cast(u32, x88)) + (cast(u32, x118) + x90)), (cast(u32, x166) + x138)); + var x185: u32 = undefined; + var x186: u32 = undefined; + mulxU32(&x185, &x186, x2, 0x9d671cd5); + var x187: u32 = undefined; + var x188: u32 = undefined; + mulxU32(&x187, &x188, x2, 0x81c69bc5); + var x189: u32 = undefined; + var x190: u32 = undefined; + mulxU32(&x189, &x190, x2, 0xe697f5e4); + var x191: u32 = undefined; + var x192: u32 = undefined; + mulxU32(&x191, &x192, x2, 0x5bcd07c6); + var x193: u32 = undefined; + var x194: u32 = undefined; + mulxU32(&x193, &x194, x2, 0x741496c2); + var x195: u32 = undefined; + var x196: u32 = undefined; + mulxU32(&x195, &x196, x2, 0xe7cf878); + var x197: u32 = undefined; + var x198: u32 = undefined; + mulxU32(&x197, &x198, x2, 0x896cf214); + var x199: u32 = undefined; + var x200: u32 = undefined; + mulxU32(&x199, &x200, x2, 0x67d7d140); + var x201: u32 = undefined; + var x202: u1 = undefined; + addcarryxU32(&x201, &x202, 0x0, x200, x197); + var x203: u32 = undefined; + var x204: u1 = undefined; + addcarryxU32(&x203, &x204, x202, x198, x195); + var x205: u32 = undefined; + var x206: u1 = undefined; + addcarryxU32(&x205, &x206, x204, x196, x193); + var x207: u32 = undefined; + var x208: u1 = undefined; + addcarryxU32(&x207, &x208, x206, x194, x191); + var x209: u32 = undefined; + var x210: u1 = undefined; + addcarryxU32(&x209, &x210, x208, x192, x189); + var x211: u32 = undefined; + var x212: u1 = undefined; + addcarryxU32(&x211, &x212, x210, x190, x187); + var x213: u32 = undefined; + var x214: u1 = undefined; + addcarryxU32(&x213, &x214, x212, x188, x185); + var x215: u32 = undefined; + var x216: u1 = undefined; + addcarryxU32(&x215, &x216, 0x0, x169, x199); + var x217: u32 = undefined; + var x218: u1 = undefined; + addcarryxU32(&x217, &x218, x216, x171, x201); + var x219: u32 = undefined; + var x220: u1 = undefined; + addcarryxU32(&x219, &x220, x218, x173, x203); + var x221: u32 = undefined; + var x222: u1 = undefined; + addcarryxU32(&x221, &x222, x220, x175, x205); + var x223: u32 = undefined; + var x224: u1 = undefined; + addcarryxU32(&x223, &x224, x222, x177, x207); + var x225: u32 = undefined; + var x226: u1 = undefined; + addcarryxU32(&x225, &x226, x224, x179, x209); + var x227: u32 = undefined; + var x228: u1 = undefined; + addcarryxU32(&x227, &x228, x226, x181, x211); + var x229: u32 = undefined; + var x230: u1 = undefined; + addcarryxU32(&x229, &x230, x228, x183, x213); + var x231: u32 = undefined; + var x232: u32 = undefined; + mulxU32(&x231, &x232, x215, 0x5588b13f); + var x233: u32 = undefined; + var x234: u32 = undefined; + mulxU32(&x233, &x234, x231, 0xffffffff); + var x235: u32 = undefined; + var x236: u32 = undefined; + mulxU32(&x235, &x236, x231, 0xffffffff); + var x237: u32 = undefined; + var x238: u32 = undefined; + mulxU32(&x237, &x238, x231, 0xffffffff); + var x239: u32 = undefined; + var x240: u32 = undefined; + mulxU32(&x239, &x240, x231, 0xfffffffe); + var x241: u32 = undefined; + var x242: u32 = undefined; + mulxU32(&x241, &x242, x231, 0xbaaedce6); + var x243: u32 = undefined; + var x244: u32 = undefined; + mulxU32(&x243, &x244, x231, 0xaf48a03b); + var x245: u32 = undefined; + var x246: u32 = undefined; + mulxU32(&x245, &x246, x231, 0xbfd25e8c); + var x247: u32 = undefined; + var x248: u32 = undefined; + mulxU32(&x247, &x248, x231, 0xd0364141); + var x249: u32 = undefined; + var x250: u1 = undefined; + addcarryxU32(&x249, &x250, 0x0, x248, x245); + var x251: u32 = undefined; + var x252: u1 = undefined; + addcarryxU32(&x251, &x252, x250, x246, x243); + var x253: u32 = undefined; + var x254: u1 = undefined; + addcarryxU32(&x253, &x254, x252, x244, x241); + var x255: u32 = undefined; + var x256: u1 = undefined; + addcarryxU32(&x255, &x256, x254, x242, x239); + var x257: u32 = undefined; + var x258: u1 = undefined; + addcarryxU32(&x257, &x258, x256, x240, x237); + var x259: u32 = undefined; + var x260: u1 = undefined; + addcarryxU32(&x259, &x260, x258, x238, x235); + var x261: u32 = undefined; + var x262: u1 = undefined; + addcarryxU32(&x261, &x262, x260, x236, x233); + var x263: u32 = undefined; + var x264: u1 = undefined; + addcarryxU32(&x263, &x264, 0x0, x215, x247); + var x265: u32 = undefined; + var x266: u1 = undefined; + addcarryxU32(&x265, &x266, x264, x217, x249); + var x267: u32 = undefined; + var x268: u1 = undefined; + addcarryxU32(&x267, &x268, x266, x219, x251); + var x269: u32 = undefined; + var x270: u1 = undefined; + addcarryxU32(&x269, &x270, x268, x221, x253); + var x271: u32 = undefined; + var x272: u1 = undefined; + addcarryxU32(&x271, &x272, x270, x223, x255); + var x273: u32 = undefined; + var x274: u1 = undefined; + addcarryxU32(&x273, &x274, x272, x225, x257); + var x275: u32 = undefined; + var x276: u1 = undefined; + addcarryxU32(&x275, &x276, x274, x227, x259); + var x277: u32 = undefined; + var x278: u1 = undefined; + addcarryxU32(&x277, &x278, x276, x229, x261); + var x279: u32 = undefined; + var x280: u1 = undefined; + addcarryxU32(&x279, &x280, x278, ((cast(u32, x230) + cast(u32, x184)) + (cast(u32, x214) + x186)), (cast(u32, x262) + x234)); + var x281: u32 = undefined; + var x282: u32 = undefined; + mulxU32(&x281, &x282, x3, 0x9d671cd5); + var x283: u32 = undefined; + var x284: u32 = undefined; + mulxU32(&x283, &x284, x3, 0x81c69bc5); + var x285: u32 = undefined; + var x286: u32 = undefined; + mulxU32(&x285, &x286, x3, 0xe697f5e4); + var x287: u32 = undefined; + var x288: u32 = undefined; + mulxU32(&x287, &x288, x3, 0x5bcd07c6); + var x289: u32 = undefined; + var x290: u32 = undefined; + mulxU32(&x289, &x290, x3, 0x741496c2); + var x291: u32 = undefined; + var x292: u32 = undefined; + mulxU32(&x291, &x292, x3, 0xe7cf878); + var x293: u32 = undefined; + var x294: u32 = undefined; + mulxU32(&x293, &x294, x3, 0x896cf214); + var x295: u32 = undefined; + var x296: u32 = undefined; + mulxU32(&x295, &x296, x3, 0x67d7d140); + var x297: u32 = undefined; + var x298: u1 = undefined; + addcarryxU32(&x297, &x298, 0x0, x296, x293); + var x299: u32 = undefined; + var x300: u1 = undefined; + addcarryxU32(&x299, &x300, x298, x294, x291); + var x301: u32 = undefined; + var x302: u1 = undefined; + addcarryxU32(&x301, &x302, x300, x292, x289); + var x303: u32 = undefined; + var x304: u1 = undefined; + addcarryxU32(&x303, &x304, x302, x290, x287); + var x305: u32 = undefined; + var x306: u1 = undefined; + addcarryxU32(&x305, &x306, x304, x288, x285); + var x307: u32 = undefined; + var x308: u1 = undefined; + addcarryxU32(&x307, &x308, x306, x286, x283); + var x309: u32 = undefined; + var x310: u1 = undefined; + addcarryxU32(&x309, &x310, x308, x284, x281); + var x311: u32 = undefined; + var x312: u1 = undefined; + addcarryxU32(&x311, &x312, 0x0, x265, x295); + var x313: u32 = undefined; + var x314: u1 = undefined; + addcarryxU32(&x313, &x314, x312, x267, x297); + var x315: u32 = undefined; + var x316: u1 = undefined; + addcarryxU32(&x315, &x316, x314, x269, x299); + var x317: u32 = undefined; + var x318: u1 = undefined; + addcarryxU32(&x317, &x318, x316, x271, x301); + var x319: u32 = undefined; + var x320: u1 = undefined; + addcarryxU32(&x319, &x320, x318, x273, x303); + var x321: u32 = undefined; + var x322: u1 = undefined; + addcarryxU32(&x321, &x322, x320, x275, x305); + var x323: u32 = undefined; + var x324: u1 = undefined; + addcarryxU32(&x323, &x324, x322, x277, x307); + var x325: u32 = undefined; + var x326: u1 = undefined; + addcarryxU32(&x325, &x326, x324, x279, x309); + var x327: u32 = undefined; + var x328: u32 = undefined; + mulxU32(&x327, &x328, x311, 0x5588b13f); + var x329: u32 = undefined; + var x330: u32 = undefined; + mulxU32(&x329, &x330, x327, 0xffffffff); + var x331: u32 = undefined; + var x332: u32 = undefined; + mulxU32(&x331, &x332, x327, 0xffffffff); + var x333: u32 = undefined; + var x334: u32 = undefined; + mulxU32(&x333, &x334, x327, 0xffffffff); + var x335: u32 = undefined; + var x336: u32 = undefined; + mulxU32(&x335, &x336, x327, 0xfffffffe); + var x337: u32 = undefined; + var x338: u32 = undefined; + mulxU32(&x337, &x338, x327, 0xbaaedce6); + var x339: u32 = undefined; + var x340: u32 = undefined; + mulxU32(&x339, &x340, x327, 0xaf48a03b); + var x341: u32 = undefined; + var x342: u32 = undefined; + mulxU32(&x341, &x342, x327, 0xbfd25e8c); + var x343: u32 = undefined; + var x344: u32 = undefined; + mulxU32(&x343, &x344, x327, 0xd0364141); + var x345: u32 = undefined; + var x346: u1 = undefined; + addcarryxU32(&x345, &x346, 0x0, x344, x341); + var x347: u32 = undefined; + var x348: u1 = undefined; + addcarryxU32(&x347, &x348, x346, x342, x339); + var x349: u32 = undefined; + var x350: u1 = undefined; + addcarryxU32(&x349, &x350, x348, x340, x337); + var x351: u32 = undefined; + var x352: u1 = undefined; + addcarryxU32(&x351, &x352, x350, x338, x335); + var x353: u32 = undefined; + var x354: u1 = undefined; + addcarryxU32(&x353, &x354, x352, x336, x333); + var x355: u32 = undefined; + var x356: u1 = undefined; + addcarryxU32(&x355, &x356, x354, x334, x331); + var x357: u32 = undefined; + var x358: u1 = undefined; + addcarryxU32(&x357, &x358, x356, x332, x329); + var x359: u32 = undefined; + var x360: u1 = undefined; + addcarryxU32(&x359, &x360, 0x0, x311, x343); + var x361: u32 = undefined; + var x362: u1 = undefined; + addcarryxU32(&x361, &x362, x360, x313, x345); + var x363: u32 = undefined; + var x364: u1 = undefined; + addcarryxU32(&x363, &x364, x362, x315, x347); + var x365: u32 = undefined; + var x366: u1 = undefined; + addcarryxU32(&x365, &x366, x364, x317, x349); + var x367: u32 = undefined; + var x368: u1 = undefined; + addcarryxU32(&x367, &x368, x366, x319, x351); + var x369: u32 = undefined; + var x370: u1 = undefined; + addcarryxU32(&x369, &x370, x368, x321, x353); + var x371: u32 = undefined; + var x372: u1 = undefined; + addcarryxU32(&x371, &x372, x370, x323, x355); + var x373: u32 = undefined; + var x374: u1 = undefined; + addcarryxU32(&x373, &x374, x372, x325, x357); + var x375: u32 = undefined; + var x376: u1 = undefined; + addcarryxU32(&x375, &x376, x374, ((cast(u32, x326) + cast(u32, x280)) + (cast(u32, x310) + x282)), (cast(u32, x358) + x330)); + var x377: u32 = undefined; + var x378: u32 = undefined; + mulxU32(&x377, &x378, x4, 0x9d671cd5); + var x379: u32 = undefined; + var x380: u32 = undefined; + mulxU32(&x379, &x380, x4, 0x81c69bc5); + var x381: u32 = undefined; + var x382: u32 = undefined; + mulxU32(&x381, &x382, x4, 0xe697f5e4); + var x383: u32 = undefined; + var x384: u32 = undefined; + mulxU32(&x383, &x384, x4, 0x5bcd07c6); + var x385: u32 = undefined; + var x386: u32 = undefined; + mulxU32(&x385, &x386, x4, 0x741496c2); + var x387: u32 = undefined; + var x388: u32 = undefined; + mulxU32(&x387, &x388, x4, 0xe7cf878); + var x389: u32 = undefined; + var x390: u32 = undefined; + mulxU32(&x389, &x390, x4, 0x896cf214); + var x391: u32 = undefined; + var x392: u32 = undefined; + mulxU32(&x391, &x392, x4, 0x67d7d140); + var x393: u32 = undefined; + var x394: u1 = undefined; + addcarryxU32(&x393, &x394, 0x0, x392, x389); + var x395: u32 = undefined; + var x396: u1 = undefined; + addcarryxU32(&x395, &x396, x394, x390, x387); + var x397: u32 = undefined; + var x398: u1 = undefined; + addcarryxU32(&x397, &x398, x396, x388, x385); + var x399: u32 = undefined; + var x400: u1 = undefined; + addcarryxU32(&x399, &x400, x398, x386, x383); + var x401: u32 = undefined; + var x402: u1 = undefined; + addcarryxU32(&x401, &x402, x400, x384, x381); + var x403: u32 = undefined; + var x404: u1 = undefined; + addcarryxU32(&x403, &x404, x402, x382, x379); + var x405: u32 = undefined; + var x406: u1 = undefined; + addcarryxU32(&x405, &x406, x404, x380, x377); + var x407: u32 = undefined; + var x408: u1 = undefined; + addcarryxU32(&x407, &x408, 0x0, x361, x391); + var x409: u32 = undefined; + var x410: u1 = undefined; + addcarryxU32(&x409, &x410, x408, x363, x393); + var x411: u32 = undefined; + var x412: u1 = undefined; + addcarryxU32(&x411, &x412, x410, x365, x395); + var x413: u32 = undefined; + var x414: u1 = undefined; + addcarryxU32(&x413, &x414, x412, x367, x397); + var x415: u32 = undefined; + var x416: u1 = undefined; + addcarryxU32(&x415, &x416, x414, x369, x399); + var x417: u32 = undefined; + var x418: u1 = undefined; + addcarryxU32(&x417, &x418, x416, x371, x401); + var x419: u32 = undefined; + var x420: u1 = undefined; + addcarryxU32(&x419, &x420, x418, x373, x403); + var x421: u32 = undefined; + var x422: u1 = undefined; + addcarryxU32(&x421, &x422, x420, x375, x405); + var x423: u32 = undefined; + var x424: u32 = undefined; + mulxU32(&x423, &x424, x407, 0x5588b13f); + var x425: u32 = undefined; + var x426: u32 = undefined; + mulxU32(&x425, &x426, x423, 0xffffffff); + var x427: u32 = undefined; + var x428: u32 = undefined; + mulxU32(&x427, &x428, x423, 0xffffffff); + var x429: u32 = undefined; + var x430: u32 = undefined; + mulxU32(&x429, &x430, x423, 0xffffffff); + var x431: u32 = undefined; + var x432: u32 = undefined; + mulxU32(&x431, &x432, x423, 0xfffffffe); + var x433: u32 = undefined; + var x434: u32 = undefined; + mulxU32(&x433, &x434, x423, 0xbaaedce6); + var x435: u32 = undefined; + var x436: u32 = undefined; + mulxU32(&x435, &x436, x423, 0xaf48a03b); + var x437: u32 = undefined; + var x438: u32 = undefined; + mulxU32(&x437, &x438, x423, 0xbfd25e8c); + var x439: u32 = undefined; + var x440: u32 = undefined; + mulxU32(&x439, &x440, x423, 0xd0364141); + var x441: u32 = undefined; + var x442: u1 = undefined; + addcarryxU32(&x441, &x442, 0x0, x440, x437); + var x443: u32 = undefined; + var x444: u1 = undefined; + addcarryxU32(&x443, &x444, x442, x438, x435); + var x445: u32 = undefined; + var x446: u1 = undefined; + addcarryxU32(&x445, &x446, x444, x436, x433); + var x447: u32 = undefined; + var x448: u1 = undefined; + addcarryxU32(&x447, &x448, x446, x434, x431); + var x449: u32 = undefined; + var x450: u1 = undefined; + addcarryxU32(&x449, &x450, x448, x432, x429); + var x451: u32 = undefined; + var x452: u1 = undefined; + addcarryxU32(&x451, &x452, x450, x430, x427); + var x453: u32 = undefined; + var x454: u1 = undefined; + addcarryxU32(&x453, &x454, x452, x428, x425); + var x455: u32 = undefined; + var x456: u1 = undefined; + addcarryxU32(&x455, &x456, 0x0, x407, x439); + var x457: u32 = undefined; + var x458: u1 = undefined; + addcarryxU32(&x457, &x458, x456, x409, x441); + var x459: u32 = undefined; + var x460: u1 = undefined; + addcarryxU32(&x459, &x460, x458, x411, x443); + var x461: u32 = undefined; + var x462: u1 = undefined; + addcarryxU32(&x461, &x462, x460, x413, x445); + var x463: u32 = undefined; + var x464: u1 = undefined; + addcarryxU32(&x463, &x464, x462, x415, x447); + var x465: u32 = undefined; + var x466: u1 = undefined; + addcarryxU32(&x465, &x466, x464, x417, x449); + var x467: u32 = undefined; + var x468: u1 = undefined; + addcarryxU32(&x467, &x468, x466, x419, x451); + var x469: u32 = undefined; + var x470: u1 = undefined; + addcarryxU32(&x469, &x470, x468, x421, x453); + var x471: u32 = undefined; + var x472: u1 = undefined; + addcarryxU32(&x471, &x472, x470, ((cast(u32, x422) + cast(u32, x376)) + (cast(u32, x406) + x378)), (cast(u32, x454) + x426)); + var x473: u32 = undefined; + var x474: u32 = undefined; + mulxU32(&x473, &x474, x5, 0x9d671cd5); + var x475: u32 = undefined; + var x476: u32 = undefined; + mulxU32(&x475, &x476, x5, 0x81c69bc5); + var x477: u32 = undefined; + var x478: u32 = undefined; + mulxU32(&x477, &x478, x5, 0xe697f5e4); + var x479: u32 = undefined; + var x480: u32 = undefined; + mulxU32(&x479, &x480, x5, 0x5bcd07c6); + var x481: u32 = undefined; + var x482: u32 = undefined; + mulxU32(&x481, &x482, x5, 0x741496c2); + var x483: u32 = undefined; + var x484: u32 = undefined; + mulxU32(&x483, &x484, x5, 0xe7cf878); + var x485: u32 = undefined; + var x486: u32 = undefined; + mulxU32(&x485, &x486, x5, 0x896cf214); + var x487: u32 = undefined; + var x488: u32 = undefined; + mulxU32(&x487, &x488, x5, 0x67d7d140); + var x489: u32 = undefined; + var x490: u1 = undefined; + addcarryxU32(&x489, &x490, 0x0, x488, x485); + var x491: u32 = undefined; + var x492: u1 = undefined; + addcarryxU32(&x491, &x492, x490, x486, x483); + var x493: u32 = undefined; + var x494: u1 = undefined; + addcarryxU32(&x493, &x494, x492, x484, x481); + var x495: u32 = undefined; + var x496: u1 = undefined; + addcarryxU32(&x495, &x496, x494, x482, x479); + var x497: u32 = undefined; + var x498: u1 = undefined; + addcarryxU32(&x497, &x498, x496, x480, x477); + var x499: u32 = undefined; + var x500: u1 = undefined; + addcarryxU32(&x499, &x500, x498, x478, x475); + var x501: u32 = undefined; + var x502: u1 = undefined; + addcarryxU32(&x501, &x502, x500, x476, x473); + var x503: u32 = undefined; + var x504: u1 = undefined; + addcarryxU32(&x503, &x504, 0x0, x457, x487); + var x505: u32 = undefined; + var x506: u1 = undefined; + addcarryxU32(&x505, &x506, x504, x459, x489); + var x507: u32 = undefined; + var x508: u1 = undefined; + addcarryxU32(&x507, &x508, x506, x461, x491); + var x509: u32 = undefined; + var x510: u1 = undefined; + addcarryxU32(&x509, &x510, x508, x463, x493); + var x511: u32 = undefined; + var x512: u1 = undefined; + addcarryxU32(&x511, &x512, x510, x465, x495); + var x513: u32 = undefined; + var x514: u1 = undefined; + addcarryxU32(&x513, &x514, x512, x467, x497); + var x515: u32 = undefined; + var x516: u1 = undefined; + addcarryxU32(&x515, &x516, x514, x469, x499); + var x517: u32 = undefined; + var x518: u1 = undefined; + addcarryxU32(&x517, &x518, x516, x471, x501); + var x519: u32 = undefined; + var x520: u32 = undefined; + mulxU32(&x519, &x520, x503, 0x5588b13f); + var x521: u32 = undefined; + var x522: u32 = undefined; + mulxU32(&x521, &x522, x519, 0xffffffff); + var x523: u32 = undefined; + var x524: u32 = undefined; + mulxU32(&x523, &x524, x519, 0xffffffff); + var x525: u32 = undefined; + var x526: u32 = undefined; + mulxU32(&x525, &x526, x519, 0xffffffff); + var x527: u32 = undefined; + var x528: u32 = undefined; + mulxU32(&x527, &x528, x519, 0xfffffffe); + var x529: u32 = undefined; + var x530: u32 = undefined; + mulxU32(&x529, &x530, x519, 0xbaaedce6); + var x531: u32 = undefined; + var x532: u32 = undefined; + mulxU32(&x531, &x532, x519, 0xaf48a03b); + var x533: u32 = undefined; + var x534: u32 = undefined; + mulxU32(&x533, &x534, x519, 0xbfd25e8c); + var x535: u32 = undefined; + var x536: u32 = undefined; + mulxU32(&x535, &x536, x519, 0xd0364141); + var x537: u32 = undefined; + var x538: u1 = undefined; + addcarryxU32(&x537, &x538, 0x0, x536, x533); + var x539: u32 = undefined; + var x540: u1 = undefined; + addcarryxU32(&x539, &x540, x538, x534, x531); + var x541: u32 = undefined; + var x542: u1 = undefined; + addcarryxU32(&x541, &x542, x540, x532, x529); + var x543: u32 = undefined; + var x544: u1 = undefined; + addcarryxU32(&x543, &x544, x542, x530, x527); + var x545: u32 = undefined; + var x546: u1 = undefined; + addcarryxU32(&x545, &x546, x544, x528, x525); + var x547: u32 = undefined; + var x548: u1 = undefined; + addcarryxU32(&x547, &x548, x546, x526, x523); + var x549: u32 = undefined; + var x550: u1 = undefined; + addcarryxU32(&x549, &x550, x548, x524, x521); + var x551: u32 = undefined; + var x552: u1 = undefined; + addcarryxU32(&x551, &x552, 0x0, x503, x535); + var x553: u32 = undefined; + var x554: u1 = undefined; + addcarryxU32(&x553, &x554, x552, x505, x537); + var x555: u32 = undefined; + var x556: u1 = undefined; + addcarryxU32(&x555, &x556, x554, x507, x539); + var x557: u32 = undefined; + var x558: u1 = undefined; + addcarryxU32(&x557, &x558, x556, x509, x541); + var x559: u32 = undefined; + var x560: u1 = undefined; + addcarryxU32(&x559, &x560, x558, x511, x543); + var x561: u32 = undefined; + var x562: u1 = undefined; + addcarryxU32(&x561, &x562, x560, x513, x545); + var x563: u32 = undefined; + var x564: u1 = undefined; + addcarryxU32(&x563, &x564, x562, x515, x547); + var x565: u32 = undefined; + var x566: u1 = undefined; + addcarryxU32(&x565, &x566, x564, x517, x549); + var x567: u32 = undefined; + var x568: u1 = undefined; + addcarryxU32(&x567, &x568, x566, ((cast(u32, x518) + cast(u32, x472)) + (cast(u32, x502) + x474)), (cast(u32, x550) + x522)); + var x569: u32 = undefined; + var x570: u32 = undefined; + mulxU32(&x569, &x570, x6, 0x9d671cd5); + var x571: u32 = undefined; + var x572: u32 = undefined; + mulxU32(&x571, &x572, x6, 0x81c69bc5); + var x573: u32 = undefined; + var x574: u32 = undefined; + mulxU32(&x573, &x574, x6, 0xe697f5e4); + var x575: u32 = undefined; + var x576: u32 = undefined; + mulxU32(&x575, &x576, x6, 0x5bcd07c6); + var x577: u32 = undefined; + var x578: u32 = undefined; + mulxU32(&x577, &x578, x6, 0x741496c2); + var x579: u32 = undefined; + var x580: u32 = undefined; + mulxU32(&x579, &x580, x6, 0xe7cf878); + var x581: u32 = undefined; + var x582: u32 = undefined; + mulxU32(&x581, &x582, x6, 0x896cf214); + var x583: u32 = undefined; + var x584: u32 = undefined; + mulxU32(&x583, &x584, x6, 0x67d7d140); + var x585: u32 = undefined; + var x586: u1 = undefined; + addcarryxU32(&x585, &x586, 0x0, x584, x581); + var x587: u32 = undefined; + var x588: u1 = undefined; + addcarryxU32(&x587, &x588, x586, x582, x579); + var x589: u32 = undefined; + var x590: u1 = undefined; + addcarryxU32(&x589, &x590, x588, x580, x577); + var x591: u32 = undefined; + var x592: u1 = undefined; + addcarryxU32(&x591, &x592, x590, x578, x575); + var x593: u32 = undefined; + var x594: u1 = undefined; + addcarryxU32(&x593, &x594, x592, x576, x573); + var x595: u32 = undefined; + var x596: u1 = undefined; + addcarryxU32(&x595, &x596, x594, x574, x571); + var x597: u32 = undefined; + var x598: u1 = undefined; + addcarryxU32(&x597, &x598, x596, x572, x569); + var x599: u32 = undefined; + var x600: u1 = undefined; + addcarryxU32(&x599, &x600, 0x0, x553, x583); + var x601: u32 = undefined; + var x602: u1 = undefined; + addcarryxU32(&x601, &x602, x600, x555, x585); + var x603: u32 = undefined; + var x604: u1 = undefined; + addcarryxU32(&x603, &x604, x602, x557, x587); + var x605: u32 = undefined; + var x606: u1 = undefined; + addcarryxU32(&x605, &x606, x604, x559, x589); + var x607: u32 = undefined; + var x608: u1 = undefined; + addcarryxU32(&x607, &x608, x606, x561, x591); + var x609: u32 = undefined; + var x610: u1 = undefined; + addcarryxU32(&x609, &x610, x608, x563, x593); + var x611: u32 = undefined; + var x612: u1 = undefined; + addcarryxU32(&x611, &x612, x610, x565, x595); + var x613: u32 = undefined; + var x614: u1 = undefined; + addcarryxU32(&x613, &x614, x612, x567, x597); + var x615: u32 = undefined; + var x616: u32 = undefined; + mulxU32(&x615, &x616, x599, 0x5588b13f); + var x617: u32 = undefined; + var x618: u32 = undefined; + mulxU32(&x617, &x618, x615, 0xffffffff); + var x619: u32 = undefined; + var x620: u32 = undefined; + mulxU32(&x619, &x620, x615, 0xffffffff); + var x621: u32 = undefined; + var x622: u32 = undefined; + mulxU32(&x621, &x622, x615, 0xffffffff); + var x623: u32 = undefined; + var x624: u32 = undefined; + mulxU32(&x623, &x624, x615, 0xfffffffe); + var x625: u32 = undefined; + var x626: u32 = undefined; + mulxU32(&x625, &x626, x615, 0xbaaedce6); + var x627: u32 = undefined; + var x628: u32 = undefined; + mulxU32(&x627, &x628, x615, 0xaf48a03b); + var x629: u32 = undefined; + var x630: u32 = undefined; + mulxU32(&x629, &x630, x615, 0xbfd25e8c); + var x631: u32 = undefined; + var x632: u32 = undefined; + mulxU32(&x631, &x632, x615, 0xd0364141); + var x633: u32 = undefined; + var x634: u1 = undefined; + addcarryxU32(&x633, &x634, 0x0, x632, x629); + var x635: u32 = undefined; + var x636: u1 = undefined; + addcarryxU32(&x635, &x636, x634, x630, x627); + var x637: u32 = undefined; + var x638: u1 = undefined; + addcarryxU32(&x637, &x638, x636, x628, x625); + var x639: u32 = undefined; + var x640: u1 = undefined; + addcarryxU32(&x639, &x640, x638, x626, x623); + var x641: u32 = undefined; + var x642: u1 = undefined; + addcarryxU32(&x641, &x642, x640, x624, x621); + var x643: u32 = undefined; + var x644: u1 = undefined; + addcarryxU32(&x643, &x644, x642, x622, x619); + var x645: u32 = undefined; + var x646: u1 = undefined; + addcarryxU32(&x645, &x646, x644, x620, x617); + var x647: u32 = undefined; + var x648: u1 = undefined; + addcarryxU32(&x647, &x648, 0x0, x599, x631); + var x649: u32 = undefined; + var x650: u1 = undefined; + addcarryxU32(&x649, &x650, x648, x601, x633); + var x651: u32 = undefined; + var x652: u1 = undefined; + addcarryxU32(&x651, &x652, x650, x603, x635); + var x653: u32 = undefined; + var x654: u1 = undefined; + addcarryxU32(&x653, &x654, x652, x605, x637); + var x655: u32 = undefined; + var x656: u1 = undefined; + addcarryxU32(&x655, &x656, x654, x607, x639); + var x657: u32 = undefined; + var x658: u1 = undefined; + addcarryxU32(&x657, &x658, x656, x609, x641); + var x659: u32 = undefined; + var x660: u1 = undefined; + addcarryxU32(&x659, &x660, x658, x611, x643); + var x661: u32 = undefined; + var x662: u1 = undefined; + addcarryxU32(&x661, &x662, x660, x613, x645); + var x663: u32 = undefined; + var x664: u1 = undefined; + addcarryxU32(&x663, &x664, x662, ((cast(u32, x614) + cast(u32, x568)) + (cast(u32, x598) + x570)), (cast(u32, x646) + x618)); + var x665: u32 = undefined; + var x666: u32 = undefined; + mulxU32(&x665, &x666, x7, 0x9d671cd5); + var x667: u32 = undefined; + var x668: u32 = undefined; + mulxU32(&x667, &x668, x7, 0x81c69bc5); + var x669: u32 = undefined; + var x670: u32 = undefined; + mulxU32(&x669, &x670, x7, 0xe697f5e4); + var x671: u32 = undefined; + var x672: u32 = undefined; + mulxU32(&x671, &x672, x7, 0x5bcd07c6); + var x673: u32 = undefined; + var x674: u32 = undefined; + mulxU32(&x673, &x674, x7, 0x741496c2); + var x675: u32 = undefined; + var x676: u32 = undefined; + mulxU32(&x675, &x676, x7, 0xe7cf878); + var x677: u32 = undefined; + var x678: u32 = undefined; + mulxU32(&x677, &x678, x7, 0x896cf214); + var x679: u32 = undefined; + var x680: u32 = undefined; + mulxU32(&x679, &x680, x7, 0x67d7d140); + var x681: u32 = undefined; + var x682: u1 = undefined; + addcarryxU32(&x681, &x682, 0x0, x680, x677); + var x683: u32 = undefined; + var x684: u1 = undefined; + addcarryxU32(&x683, &x684, x682, x678, x675); + var x685: u32 = undefined; + var x686: u1 = undefined; + addcarryxU32(&x685, &x686, x684, x676, x673); + var x687: u32 = undefined; + var x688: u1 = undefined; + addcarryxU32(&x687, &x688, x686, x674, x671); + var x689: u32 = undefined; + var x690: u1 = undefined; + addcarryxU32(&x689, &x690, x688, x672, x669); + var x691: u32 = undefined; + var x692: u1 = undefined; + addcarryxU32(&x691, &x692, x690, x670, x667); + var x693: u32 = undefined; + var x694: u1 = undefined; + addcarryxU32(&x693, &x694, x692, x668, x665); + var x695: u32 = undefined; + var x696: u1 = undefined; + addcarryxU32(&x695, &x696, 0x0, x649, x679); + var x697: u32 = undefined; + var x698: u1 = undefined; + addcarryxU32(&x697, &x698, x696, x651, x681); + var x699: u32 = undefined; + var x700: u1 = undefined; + addcarryxU32(&x699, &x700, x698, x653, x683); + var x701: u32 = undefined; + var x702: u1 = undefined; + addcarryxU32(&x701, &x702, x700, x655, x685); + var x703: u32 = undefined; + var x704: u1 = undefined; + addcarryxU32(&x703, &x704, x702, x657, x687); + var x705: u32 = undefined; + var x706: u1 = undefined; + addcarryxU32(&x705, &x706, x704, x659, x689); + var x707: u32 = undefined; + var x708: u1 = undefined; + addcarryxU32(&x707, &x708, x706, x661, x691); + var x709: u32 = undefined; + var x710: u1 = undefined; + addcarryxU32(&x709, &x710, x708, x663, x693); + var x711: u32 = undefined; + var x712: u32 = undefined; + mulxU32(&x711, &x712, x695, 0x5588b13f); + var x713: u32 = undefined; + var x714: u32 = undefined; + mulxU32(&x713, &x714, x711, 0xffffffff); + var x715: u32 = undefined; + var x716: u32 = undefined; + mulxU32(&x715, &x716, x711, 0xffffffff); + var x717: u32 = undefined; + var x718: u32 = undefined; + mulxU32(&x717, &x718, x711, 0xffffffff); + var x719: u32 = undefined; + var x720: u32 = undefined; + mulxU32(&x719, &x720, x711, 0xfffffffe); + var x721: u32 = undefined; + var x722: u32 = undefined; + mulxU32(&x721, &x722, x711, 0xbaaedce6); + var x723: u32 = undefined; + var x724: u32 = undefined; + mulxU32(&x723, &x724, x711, 0xaf48a03b); + var x725: u32 = undefined; + var x726: u32 = undefined; + mulxU32(&x725, &x726, x711, 0xbfd25e8c); + var x727: u32 = undefined; + var x728: u32 = undefined; + mulxU32(&x727, &x728, x711, 0xd0364141); + var x729: u32 = undefined; + var x730: u1 = undefined; + addcarryxU32(&x729, &x730, 0x0, x728, x725); + var x731: u32 = undefined; + var x732: u1 = undefined; + addcarryxU32(&x731, &x732, x730, x726, x723); + var x733: u32 = undefined; + var x734: u1 = undefined; + addcarryxU32(&x733, &x734, x732, x724, x721); + var x735: u32 = undefined; + var x736: u1 = undefined; + addcarryxU32(&x735, &x736, x734, x722, x719); + var x737: u32 = undefined; + var x738: u1 = undefined; + addcarryxU32(&x737, &x738, x736, x720, x717); + var x739: u32 = undefined; + var x740: u1 = undefined; + addcarryxU32(&x739, &x740, x738, x718, x715); + var x741: u32 = undefined; + var x742: u1 = undefined; + addcarryxU32(&x741, &x742, x740, x716, x713); + var x743: u32 = undefined; + var x744: u1 = undefined; + addcarryxU32(&x743, &x744, 0x0, x695, x727); + var x745: u32 = undefined; + var x746: u1 = undefined; + addcarryxU32(&x745, &x746, x744, x697, x729); + var x747: u32 = undefined; + var x748: u1 = undefined; + addcarryxU32(&x747, &x748, x746, x699, x731); + var x749: u32 = undefined; + var x750: u1 = undefined; + addcarryxU32(&x749, &x750, x748, x701, x733); + var x751: u32 = undefined; + var x752: u1 = undefined; + addcarryxU32(&x751, &x752, x750, x703, x735); + var x753: u32 = undefined; + var x754: u1 = undefined; + addcarryxU32(&x753, &x754, x752, x705, x737); + var x755: u32 = undefined; + var x756: u1 = undefined; + addcarryxU32(&x755, &x756, x754, x707, x739); + var x757: u32 = undefined; + var x758: u1 = undefined; + addcarryxU32(&x757, &x758, x756, x709, x741); + var x759: u32 = undefined; + var x760: u1 = undefined; + addcarryxU32(&x759, &x760, x758, ((cast(u32, x710) + cast(u32, x664)) + (cast(u32, x694) + x666)), (cast(u32, x742) + x714)); + var x761: u32 = undefined; + var x762: u1 = undefined; + subborrowxU32(&x761, &x762, 0x0, x745, 0xd0364141); + var x763: u32 = undefined; + var x764: u1 = undefined; + subborrowxU32(&x763, &x764, x762, x747, 0xbfd25e8c); + var x765: u32 = undefined; + var x766: u1 = undefined; + subborrowxU32(&x765, &x766, x764, x749, 0xaf48a03b); + var x767: u32 = undefined; + var x768: u1 = undefined; + subborrowxU32(&x767, &x768, x766, x751, 0xbaaedce6); + var x769: u32 = undefined; + var x770: u1 = undefined; + subborrowxU32(&x769, &x770, x768, x753, 0xfffffffe); + var x771: u32 = undefined; + var x772: u1 = undefined; + subborrowxU32(&x771, &x772, x770, x755, 0xffffffff); + var x773: u32 = undefined; + var x774: u1 = undefined; + subborrowxU32(&x773, &x774, x772, x757, 0xffffffff); + var x775: u32 = undefined; + var x776: u1 = undefined; + subborrowxU32(&x775, &x776, x774, x759, 0xffffffff); + var x777: u32 = undefined; + var x778: u1 = undefined; + subborrowxU32(&x777, &x778, x776, cast(u32, x760), cast(u32, 0x0)); + var x779: u32 = undefined; + cmovznzU32(&x779, x778, x761, x745); + var x780: u32 = undefined; + cmovznzU32(&x780, x778, x763, x747); + var x781: u32 = undefined; + cmovznzU32(&x781, x778, x765, x749); + var x782: u32 = undefined; + cmovznzU32(&x782, x778, x767, x751); + var x783: u32 = undefined; + cmovznzU32(&x783, x778, x769, x753); + var x784: u32 = undefined; + cmovznzU32(&x784, x778, x771, x755); + var x785: u32 = undefined; + cmovznzU32(&x785, x778, x773, x757); + var x786: u32 = undefined; + cmovznzU32(&x786, x778, x775, x759); + out1[0] = x779; + out1[1] = x780; + out1[2] = x781; + out1[3] = x782; + out1[4] = x783; + out1[5] = x784; + out1[6] = x785; + out1[7] = x786; +} + +/// The function nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +pub fn nonzero(out1: *u32, arg1: [8]u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | (arg1[7])))))))); + out1.* = x1; +} + +/// The function selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn selectznz(out1: *[8]u32, arg1: u1, arg2: [8]u32, arg3: [8]u32) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + cmovznzU32(&x1, arg1, (arg2[0]), (arg3[0])); + var x2: u32 = undefined; + cmovznzU32(&x2, arg1, (arg2[1]), (arg3[1])); + var x3: u32 = undefined; + cmovznzU32(&x3, arg1, (arg2[2]), (arg3[2])); + var x4: u32 = undefined; + cmovznzU32(&x4, arg1, (arg2[3]), (arg3[3])); + var x5: u32 = undefined; + cmovznzU32(&x5, arg1, (arg2[4]), (arg3[4])); + var x6: u32 = undefined; + cmovznzU32(&x6, arg1, (arg2[5]), (arg3[5])); + var x7: u32 = undefined; + cmovznzU32(&x7, arg1, (arg2[6]), (arg3[6])); + var x8: u32 = undefined; + cmovznzU32(&x8, arg1, (arg2[7]), (arg3[7])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; + out1[5] = x6; + out1[6] = x7; + out1[7] = x8; +} + +/// The function toBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +pub fn toBytes(out1: *[32]u8, arg1: [8]u32) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[7]); + const x2 = (arg1[6]); + const x3 = (arg1[5]); + const x4 = (arg1[4]); + const x5 = (arg1[3]); + const x6 = (arg1[2]); + const x7 = (arg1[1]); + const x8 = (arg1[0]); + const x9 = cast(u8, (x8 & cast(u32, 0xff))); + const x10 = (x8 >> 8); + const x11 = cast(u8, (x10 & cast(u32, 0xff))); + const x12 = (x10 >> 8); + const x13 = cast(u8, (x12 & cast(u32, 0xff))); + const x14 = cast(u8, (x12 >> 8)); + const x15 = cast(u8, (x7 & cast(u32, 0xff))); + const x16 = (x7 >> 8); + const x17 = cast(u8, (x16 & cast(u32, 0xff))); + const x18 = (x16 >> 8); + const x19 = cast(u8, (x18 & cast(u32, 0xff))); + const x20 = cast(u8, (x18 >> 8)); + const x21 = cast(u8, (x6 & cast(u32, 0xff))); + const x22 = (x6 >> 8); + const x23 = cast(u8, (x22 & cast(u32, 0xff))); + const x24 = (x22 >> 8); + const x25 = cast(u8, (x24 & cast(u32, 0xff))); + const x26 = cast(u8, (x24 >> 8)); + const x27 = cast(u8, (x5 & cast(u32, 0xff))); + const x28 = (x5 >> 8); + const x29 = cast(u8, (x28 & cast(u32, 0xff))); + const x30 = (x28 >> 8); + const x31 = cast(u8, (x30 & cast(u32, 0xff))); + const x32 = cast(u8, (x30 >> 8)); + const x33 = cast(u8, (x4 & cast(u32, 0xff))); + const x34 = (x4 >> 8); + const x35 = cast(u8, (x34 & cast(u32, 0xff))); + const x36 = (x34 >> 8); + const x37 = cast(u8, (x36 & cast(u32, 0xff))); + const x38 = cast(u8, (x36 >> 8)); + const x39 = cast(u8, (x3 & cast(u32, 0xff))); + const x40 = (x3 >> 8); + const x41 = cast(u8, (x40 & cast(u32, 0xff))); + const x42 = (x40 >> 8); + const x43 = cast(u8, (x42 & cast(u32, 0xff))); + const x44 = cast(u8, (x42 >> 8)); + const x45 = cast(u8, (x2 & cast(u32, 0xff))); + const x46 = (x2 >> 8); + const x47 = cast(u8, (x46 & cast(u32, 0xff))); + const x48 = (x46 >> 8); + const x49 = cast(u8, (x48 & cast(u32, 0xff))); + const x50 = cast(u8, (x48 >> 8)); + const x51 = cast(u8, (x1 & cast(u32, 0xff))); + const x52 = (x1 >> 8); + const x53 = cast(u8, (x52 & cast(u32, 0xff))); + const x54 = (x52 >> 8); + const x55 = cast(u8, (x54 & cast(u32, 0xff))); + const x56 = cast(u8, (x54 >> 8)); + out1[0] = x9; + out1[1] = x11; + out1[2] = x13; + out1[3] = x14; + out1[4] = x15; + out1[5] = x17; + out1[6] = x19; + out1[7] = x20; + out1[8] = x21; + out1[9] = x23; + out1[10] = x25; + out1[11] = x26; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x38; + out1[20] = x39; + out1[21] = x41; + out1[22] = x43; + out1[23] = x44; + out1[24] = x45; + out1[25] = x47; + out1[26] = x49; + out1[27] = x50; + out1[28] = x51; + out1[29] = x53; + out1[30] = x55; + out1[31] = x56; +} + +/// The function fromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn fromBytes(out1: *[8]u32, arg1: [32]u8) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u32, (arg1[31])) << 24); + const x2 = (cast(u32, (arg1[30])) << 16); + const x3 = (cast(u32, (arg1[29])) << 8); + const x4 = (arg1[28]); + const x5 = (cast(u32, (arg1[27])) << 24); + const x6 = (cast(u32, (arg1[26])) << 16); + const x7 = (cast(u32, (arg1[25])) << 8); + const x8 = (arg1[24]); + const x9 = (cast(u32, (arg1[23])) << 24); + const x10 = (cast(u32, (arg1[22])) << 16); + const x11 = (cast(u32, (arg1[21])) << 8); + const x12 = (arg1[20]); + const x13 = (cast(u32, (arg1[19])) << 24); + const x14 = (cast(u32, (arg1[18])) << 16); + const x15 = (cast(u32, (arg1[17])) << 8); + const x16 = (arg1[16]); + const x17 = (cast(u32, (arg1[15])) << 24); + const x18 = (cast(u32, (arg1[14])) << 16); + const x19 = (cast(u32, (arg1[13])) << 8); + const x20 = (arg1[12]); + const x21 = (cast(u32, (arg1[11])) << 24); + const x22 = (cast(u32, (arg1[10])) << 16); + const x23 = (cast(u32, (arg1[9])) << 8); + const x24 = (arg1[8]); + const x25 = (cast(u32, (arg1[7])) << 24); + const x26 = (cast(u32, (arg1[6])) << 16); + const x27 = (cast(u32, (arg1[5])) << 8); + const x28 = (arg1[4]); + const x29 = (cast(u32, (arg1[3])) << 24); + const x30 = (cast(u32, (arg1[2])) << 16); + const x31 = (cast(u32, (arg1[1])) << 8); + const x32 = (arg1[0]); + const x33 = (x31 + cast(u32, x32)); + const x34 = (x30 + x33); + const x35 = (x29 + x34); + const x36 = (x27 + cast(u32, x28)); + const x37 = (x26 + x36); + const x38 = (x25 + x37); + const x39 = (x23 + cast(u32, x24)); + const x40 = (x22 + x39); + const x41 = (x21 + x40); + const x42 = (x19 + cast(u32, x20)); + const x43 = (x18 + x42); + const x44 = (x17 + x43); + const x45 = (x15 + cast(u32, x16)); + const x46 = (x14 + x45); + const x47 = (x13 + x46); + const x48 = (x11 + cast(u32, x12)); + const x49 = (x10 + x48); + const x50 = (x9 + x49); + const x51 = (x7 + cast(u32, x8)); + const x52 = (x6 + x51); + const x53 = (x5 + x52); + const x54 = (x3 + cast(u32, x4)); + const x55 = (x2 + x54); + const x56 = (x1 + x55); + out1[0] = x35; + out1[1] = x38; + out1[2] = x41; + out1[3] = x44; + out1[4] = x47; + out1[5] = x50; + out1[6] = x53; + out1[7] = x56; +} + +/// The function setOne returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn setOne(out1: *MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0x2fc9bebf; + out1[1] = 0x402da173; + out1[2] = 0x50b75fc4; + out1[3] = 0x45512319; + out1[4] = cast(u32, 0x1); + out1[5] = cast(u32, 0x0); + out1[6] = cast(u32, 0x0); + out1[7] = cast(u32, 0x0); +} + +/// The function msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn msat(out1: *[9]u32) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xd0364141; + out1[1] = 0xbfd25e8c; + out1[2] = 0xaf48a03b; + out1[3] = 0xbaaedce6; + out1[4] = 0xfffffffe; + out1[5] = 0xffffffff; + out1[6] = 0xffffffff; + out1[7] = 0xffffffff; + out1[8] = cast(u32, 0x0); +} + +/// The function divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffff] +/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffff] +/// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +/// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn divstep(out1: *u32, out2: *[9]u32, out3: *[9]u32, out4: *[8]u32, out5: *[8]u32, arg1: u32, arg2: [9]u32, arg3: [9]u32, arg4: [8]u32, arg5: [8]u32) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u32 = undefined; + var x2: u1 = undefined; + addcarryxU32(&x1, &x2, 0x0, (~arg1), cast(u32, 0x1)); + const x3 = (cast(u1, (x1 >> 31)) & cast(u1, ((arg3[0]) & cast(u32, 0x1)))); + var x4: u32 = undefined; + var x5: u1 = undefined; + addcarryxU32(&x4, &x5, 0x0, (~arg1), cast(u32, 0x1)); + var x6: u32 = undefined; + cmovznzU32(&x6, x3, arg1, x4); + var x7: u32 = undefined; + cmovznzU32(&x7, x3, (arg2[0]), (arg3[0])); + var x8: u32 = undefined; + cmovznzU32(&x8, x3, (arg2[1]), (arg3[1])); + var x9: u32 = undefined; + cmovznzU32(&x9, x3, (arg2[2]), (arg3[2])); + var x10: u32 = undefined; + cmovznzU32(&x10, x3, (arg2[3]), (arg3[3])); + var x11: u32 = undefined; + cmovznzU32(&x11, x3, (arg2[4]), (arg3[4])); + var x12: u32 = undefined; + cmovznzU32(&x12, x3, (arg2[5]), (arg3[5])); + var x13: u32 = undefined; + cmovznzU32(&x13, x3, (arg2[6]), (arg3[6])); + var x14: u32 = undefined; + cmovznzU32(&x14, x3, (arg2[7]), (arg3[7])); + var x15: u32 = undefined; + cmovznzU32(&x15, x3, (arg2[8]), (arg3[8])); + var x16: u32 = undefined; + var x17: u1 = undefined; + addcarryxU32(&x16, &x17, 0x0, cast(u32, 0x1), (~(arg2[0]))); + var x18: u32 = undefined; + var x19: u1 = undefined; + addcarryxU32(&x18, &x19, x17, cast(u32, 0x0), (~(arg2[1]))); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, cast(u32, 0x0), (~(arg2[2]))); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, cast(u32, 0x0), (~(arg2[3]))); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, cast(u32, 0x0), (~(arg2[4]))); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, x25, cast(u32, 0x0), (~(arg2[5]))); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, cast(u32, 0x0), (~(arg2[6]))); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, cast(u32, 0x0), (~(arg2[7]))); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, cast(u32, 0x0), (~(arg2[8]))); + var x34: u32 = undefined; + cmovznzU32(&x34, x3, (arg3[0]), x16); + var x35: u32 = undefined; + cmovznzU32(&x35, x3, (arg3[1]), x18); + var x36: u32 = undefined; + cmovznzU32(&x36, x3, (arg3[2]), x20); + var x37: u32 = undefined; + cmovznzU32(&x37, x3, (arg3[3]), x22); + var x38: u32 = undefined; + cmovznzU32(&x38, x3, (arg3[4]), x24); + var x39: u32 = undefined; + cmovznzU32(&x39, x3, (arg3[5]), x26); + var x40: u32 = undefined; + cmovznzU32(&x40, x3, (arg3[6]), x28); + var x41: u32 = undefined; + cmovznzU32(&x41, x3, (arg3[7]), x30); + var x42: u32 = undefined; + cmovznzU32(&x42, x3, (arg3[8]), x32); + var x43: u32 = undefined; + cmovznzU32(&x43, x3, (arg4[0]), (arg5[0])); + var x44: u32 = undefined; + cmovznzU32(&x44, x3, (arg4[1]), (arg5[1])); + var x45: u32 = undefined; + cmovznzU32(&x45, x3, (arg4[2]), (arg5[2])); + var x46: u32 = undefined; + cmovznzU32(&x46, x3, (arg4[3]), (arg5[3])); + var x47: u32 = undefined; + cmovznzU32(&x47, x3, (arg4[4]), (arg5[4])); + var x48: u32 = undefined; + cmovznzU32(&x48, x3, (arg4[5]), (arg5[5])); + var x49: u32 = undefined; + cmovznzU32(&x49, x3, (arg4[6]), (arg5[6])); + var x50: u32 = undefined; + cmovznzU32(&x50, x3, (arg4[7]), (arg5[7])); + var x51: u32 = undefined; + var x52: u1 = undefined; + addcarryxU32(&x51, &x52, 0x0, x43, x43); + var x53: u32 = undefined; + var x54: u1 = undefined; + addcarryxU32(&x53, &x54, x52, x44, x44); + var x55: u32 = undefined; + var x56: u1 = undefined; + addcarryxU32(&x55, &x56, x54, x45, x45); + var x57: u32 = undefined; + var x58: u1 = undefined; + addcarryxU32(&x57, &x58, x56, x46, x46); + var x59: u32 = undefined; + var x60: u1 = undefined; + addcarryxU32(&x59, &x60, x58, x47, x47); + var x61: u32 = undefined; + var x62: u1 = undefined; + addcarryxU32(&x61, &x62, x60, x48, x48); + var x63: u32 = undefined; + var x64: u1 = undefined; + addcarryxU32(&x63, &x64, x62, x49, x49); + var x65: u32 = undefined; + var x66: u1 = undefined; + addcarryxU32(&x65, &x66, x64, x50, x50); + var x67: u32 = undefined; + var x68: u1 = undefined; + subborrowxU32(&x67, &x68, 0x0, x51, 0xd0364141); + var x69: u32 = undefined; + var x70: u1 = undefined; + subborrowxU32(&x69, &x70, x68, x53, 0xbfd25e8c); + var x71: u32 = undefined; + var x72: u1 = undefined; + subborrowxU32(&x71, &x72, x70, x55, 0xaf48a03b); + var x73: u32 = undefined; + var x74: u1 = undefined; + subborrowxU32(&x73, &x74, x72, x57, 0xbaaedce6); + var x75: u32 = undefined; + var x76: u1 = undefined; + subborrowxU32(&x75, &x76, x74, x59, 0xfffffffe); + var x77: u32 = undefined; + var x78: u1 = undefined; + subborrowxU32(&x77, &x78, x76, x61, 0xffffffff); + var x79: u32 = undefined; + var x80: u1 = undefined; + subborrowxU32(&x79, &x80, x78, x63, 0xffffffff); + var x81: u32 = undefined; + var x82: u1 = undefined; + subborrowxU32(&x81, &x82, x80, x65, 0xffffffff); + var x83: u32 = undefined; + var x84: u1 = undefined; + subborrowxU32(&x83, &x84, x82, cast(u32, x66), cast(u32, 0x0)); + const x85 = (arg4[7]); + const x86 = (arg4[6]); + const x87 = (arg4[5]); + const x88 = (arg4[4]); + const x89 = (arg4[3]); + const x90 = (arg4[2]); + const x91 = (arg4[1]); + const x92 = (arg4[0]); + var x93: u32 = undefined; + var x94: u1 = undefined; + subborrowxU32(&x93, &x94, 0x0, cast(u32, 0x0), x92); + var x95: u32 = undefined; + var x96: u1 = undefined; + subborrowxU32(&x95, &x96, x94, cast(u32, 0x0), x91); + var x97: u32 = undefined; + var x98: u1 = undefined; + subborrowxU32(&x97, &x98, x96, cast(u32, 0x0), x90); + var x99: u32 = undefined; + var x100: u1 = undefined; + subborrowxU32(&x99, &x100, x98, cast(u32, 0x0), x89); + var x101: u32 = undefined; + var x102: u1 = undefined; + subborrowxU32(&x101, &x102, x100, cast(u32, 0x0), x88); + var x103: u32 = undefined; + var x104: u1 = undefined; + subborrowxU32(&x103, &x104, x102, cast(u32, 0x0), x87); + var x105: u32 = undefined; + var x106: u1 = undefined; + subborrowxU32(&x105, &x106, x104, cast(u32, 0x0), x86); + var x107: u32 = undefined; + var x108: u1 = undefined; + subborrowxU32(&x107, &x108, x106, cast(u32, 0x0), x85); + var x109: u32 = undefined; + cmovznzU32(&x109, x108, cast(u32, 0x0), 0xffffffff); + var x110: u32 = undefined; + var x111: u1 = undefined; + addcarryxU32(&x110, &x111, 0x0, x93, (x109 & 0xd0364141)); + var x112: u32 = undefined; + var x113: u1 = undefined; + addcarryxU32(&x112, &x113, x111, x95, (x109 & 0xbfd25e8c)); + var x114: u32 = undefined; + var x115: u1 = undefined; + addcarryxU32(&x114, &x115, x113, x97, (x109 & 0xaf48a03b)); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, x115, x99, (x109 & 0xbaaedce6)); + var x118: u32 = undefined; + var x119: u1 = undefined; + addcarryxU32(&x118, &x119, x117, x101, (x109 & 0xfffffffe)); + var x120: u32 = undefined; + var x121: u1 = undefined; + addcarryxU32(&x120, &x121, x119, x103, x109); + var x122: u32 = undefined; + var x123: u1 = undefined; + addcarryxU32(&x122, &x123, x121, x105, x109); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, x107, x109); + var x126: u32 = undefined; + cmovznzU32(&x126, x3, (arg5[0]), x110); + var x127: u32 = undefined; + cmovznzU32(&x127, x3, (arg5[1]), x112); + var x128: u32 = undefined; + cmovznzU32(&x128, x3, (arg5[2]), x114); + var x129: u32 = undefined; + cmovznzU32(&x129, x3, (arg5[3]), x116); + var x130: u32 = undefined; + cmovznzU32(&x130, x3, (arg5[4]), x118); + var x131: u32 = undefined; + cmovznzU32(&x131, x3, (arg5[5]), x120); + var x132: u32 = undefined; + cmovznzU32(&x132, x3, (arg5[6]), x122); + var x133: u32 = undefined; + cmovznzU32(&x133, x3, (arg5[7]), x124); + const x134 = cast(u1, (x34 & cast(u32, 0x1))); + var x135: u32 = undefined; + cmovznzU32(&x135, x134, cast(u32, 0x0), x7); + var x136: u32 = undefined; + cmovznzU32(&x136, x134, cast(u32, 0x0), x8); + var x137: u32 = undefined; + cmovznzU32(&x137, x134, cast(u32, 0x0), x9); + var x138: u32 = undefined; + cmovznzU32(&x138, x134, cast(u32, 0x0), x10); + var x139: u32 = undefined; + cmovznzU32(&x139, x134, cast(u32, 0x0), x11); + var x140: u32 = undefined; + cmovznzU32(&x140, x134, cast(u32, 0x0), x12); + var x141: u32 = undefined; + cmovznzU32(&x141, x134, cast(u32, 0x0), x13); + var x142: u32 = undefined; + cmovznzU32(&x142, x134, cast(u32, 0x0), x14); + var x143: u32 = undefined; + cmovznzU32(&x143, x134, cast(u32, 0x0), x15); + var x144: u32 = undefined; + var x145: u1 = undefined; + addcarryxU32(&x144, &x145, 0x0, x34, x135); + var x146: u32 = undefined; + var x147: u1 = undefined; + addcarryxU32(&x146, &x147, x145, x35, x136); + var x148: u32 = undefined; + var x149: u1 = undefined; + addcarryxU32(&x148, &x149, x147, x36, x137); + var x150: u32 = undefined; + var x151: u1 = undefined; + addcarryxU32(&x150, &x151, x149, x37, x138); + var x152: u32 = undefined; + var x153: u1 = undefined; + addcarryxU32(&x152, &x153, x151, x38, x139); + var x154: u32 = undefined; + var x155: u1 = undefined; + addcarryxU32(&x154, &x155, x153, x39, x140); + var x156: u32 = undefined; + var x157: u1 = undefined; + addcarryxU32(&x156, &x157, x155, x40, x141); + var x158: u32 = undefined; + var x159: u1 = undefined; + addcarryxU32(&x158, &x159, x157, x41, x142); + var x160: u32 = undefined; + var x161: u1 = undefined; + addcarryxU32(&x160, &x161, x159, x42, x143); + var x162: u32 = undefined; + cmovznzU32(&x162, x134, cast(u32, 0x0), x43); + var x163: u32 = undefined; + cmovznzU32(&x163, x134, cast(u32, 0x0), x44); + var x164: u32 = undefined; + cmovznzU32(&x164, x134, cast(u32, 0x0), x45); + var x165: u32 = undefined; + cmovznzU32(&x165, x134, cast(u32, 0x0), x46); + var x166: u32 = undefined; + cmovznzU32(&x166, x134, cast(u32, 0x0), x47); + var x167: u32 = undefined; + cmovznzU32(&x167, x134, cast(u32, 0x0), x48); + var x168: u32 = undefined; + cmovznzU32(&x168, x134, cast(u32, 0x0), x49); + var x169: u32 = undefined; + cmovznzU32(&x169, x134, cast(u32, 0x0), x50); + var x170: u32 = undefined; + var x171: u1 = undefined; + addcarryxU32(&x170, &x171, 0x0, x126, x162); + var x172: u32 = undefined; + var x173: u1 = undefined; + addcarryxU32(&x172, &x173, x171, x127, x163); + var x174: u32 = undefined; + var x175: u1 = undefined; + addcarryxU32(&x174, &x175, x173, x128, x164); + var x176: u32 = undefined; + var x177: u1 = undefined; + addcarryxU32(&x176, &x177, x175, x129, x165); + var x178: u32 = undefined; + var x179: u1 = undefined; + addcarryxU32(&x178, &x179, x177, x130, x166); + var x180: u32 = undefined; + var x181: u1 = undefined; + addcarryxU32(&x180, &x181, x179, x131, x167); + var x182: u32 = undefined; + var x183: u1 = undefined; + addcarryxU32(&x182, &x183, x181, x132, x168); + var x184: u32 = undefined; + var x185: u1 = undefined; + addcarryxU32(&x184, &x185, x183, x133, x169); + var x186: u32 = undefined; + var x187: u1 = undefined; + subborrowxU32(&x186, &x187, 0x0, x170, 0xd0364141); + var x188: u32 = undefined; + var x189: u1 = undefined; + subborrowxU32(&x188, &x189, x187, x172, 0xbfd25e8c); + var x190: u32 = undefined; + var x191: u1 = undefined; + subborrowxU32(&x190, &x191, x189, x174, 0xaf48a03b); + var x192: u32 = undefined; + var x193: u1 = undefined; + subborrowxU32(&x192, &x193, x191, x176, 0xbaaedce6); + var x194: u32 = undefined; + var x195: u1 = undefined; + subborrowxU32(&x194, &x195, x193, x178, 0xfffffffe); + var x196: u32 = undefined; + var x197: u1 = undefined; + subborrowxU32(&x196, &x197, x195, x180, 0xffffffff); + var x198: u32 = undefined; + var x199: u1 = undefined; + subborrowxU32(&x198, &x199, x197, x182, 0xffffffff); + var x200: u32 = undefined; + var x201: u1 = undefined; + subborrowxU32(&x200, &x201, x199, x184, 0xffffffff); + var x202: u32 = undefined; + var x203: u1 = undefined; + subborrowxU32(&x202, &x203, x201, cast(u32, x185), cast(u32, 0x0)); + var x204: u32 = undefined; + var x205: u1 = undefined; + addcarryxU32(&x204, &x205, 0x0, x6, cast(u32, 0x1)); + const x206 = ((x144 >> 1) | ((x146 << 31) & 0xffffffff)); + const x207 = ((x146 >> 1) | ((x148 << 31) & 0xffffffff)); + const x208 = ((x148 >> 1) | ((x150 << 31) & 0xffffffff)); + const x209 = ((x150 >> 1) | ((x152 << 31) & 0xffffffff)); + const x210 = ((x152 >> 1) | ((x154 << 31) & 0xffffffff)); + const x211 = ((x154 >> 1) | ((x156 << 31) & 0xffffffff)); + const x212 = ((x156 >> 1) | ((x158 << 31) & 0xffffffff)); + const x213 = ((x158 >> 1) | ((x160 << 31) & 0xffffffff)); + const x214 = ((x160 & 0x80000000) | (x160 >> 1)); + var x215: u32 = undefined; + cmovznzU32(&x215, x84, x67, x51); + var x216: u32 = undefined; + cmovznzU32(&x216, x84, x69, x53); + var x217: u32 = undefined; + cmovznzU32(&x217, x84, x71, x55); + var x218: u32 = undefined; + cmovznzU32(&x218, x84, x73, x57); + var x219: u32 = undefined; + cmovznzU32(&x219, x84, x75, x59); + var x220: u32 = undefined; + cmovznzU32(&x220, x84, x77, x61); + var x221: u32 = undefined; + cmovznzU32(&x221, x84, x79, x63); + var x222: u32 = undefined; + cmovznzU32(&x222, x84, x81, x65); + var x223: u32 = undefined; + cmovznzU32(&x223, x203, x186, x170); + var x224: u32 = undefined; + cmovznzU32(&x224, x203, x188, x172); + var x225: u32 = undefined; + cmovznzU32(&x225, x203, x190, x174); + var x226: u32 = undefined; + cmovznzU32(&x226, x203, x192, x176); + var x227: u32 = undefined; + cmovznzU32(&x227, x203, x194, x178); + var x228: u32 = undefined; + cmovznzU32(&x228, x203, x196, x180); + var x229: u32 = undefined; + cmovznzU32(&x229, x203, x198, x182); + var x230: u32 = undefined; + cmovznzU32(&x230, x203, x200, x184); + out1.* = x204; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out2[5] = x12; + out2[6] = x13; + out2[7] = x14; + out2[8] = x15; + out3[0] = x206; + out3[1] = x207; + out3[2] = x208; + out3[3] = x209; + out3[4] = x210; + out3[5] = x211; + out3[6] = x212; + out3[7] = x213; + out3[8] = x214; + out4[0] = x215; + out4[1] = x216; + out4[2] = x217; + out4[3] = x218; + out4[4] = x219; + out4[5] = x220; + out4[6] = x221; + out4[7] = x222; + out5[0] = x223; + out5[1] = x224; + out5[2] = x225; + out5[3] = x226; + out5[4] = x227; + out5[5] = x228; + out5[6] = x229; + out5[7] = x230; +} + +/// The function divstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]] +pub fn divstepPrecomp(out1: *[8]u32) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0x2b9cb4e9; + out1[1] = 0xd7431a4d; + out1[2] = 0x32d9c503; + out1[3] = 0xab67d35a; + out1[4] = 0x859ce35f; + out1[5] = 0xadf6c7e5; + out1[6] = 0x1df6c379; + out1[7] = 0x61544145; +} diff --git a/fiat-zig/src/secp256k1_scalar_64.zig b/fiat-zig/src/secp256k1_scalar_64.zig new file mode 100644 index 0000000000..f7992e9f7c --- /dev/null +++ b/fiat-zig/src/secp256k1_scalar_64.zig @@ -0,0 +1,2043 @@ +// Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Zig --internal-static --public-function-case camelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case UpperCamelCase --no-prefix-fiat --package-name secp256k1_scalar '' 64 '2^256 - 432420386565659656852420866394968145599' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +// curve description (via package name): secp256k1_scalar +// machine_wordsize = 64 (from "64") +// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp +// m = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141 (from "2^256 - 432420386565659656852420866394968145599") +// +// NOTE: In addition to the bounds specified above each function, all +// functions synthesized for this Montgomery arithmetic require the +// input to be strictly less than the prime modulus (m), and also +// require the input to be in the unique saturated representation. +// All functions also ensure that these two properties are true of +// return values. +// +// Computed values: +// eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) +// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) +// twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in +// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 + +const std = @import("std"); +const mode = @import("builtin").mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels + +inline fn cast(comptime DestType: type, target: anytype) DestType { + if (@typeInfo(@TypeOf(target)) == .Int) { + const dest = @typeInfo(DestType).Int; + const source = @typeInfo(@TypeOf(target)).Int; + if (dest.bits < source.bits) { + return @bitCast(DestType, @truncate(std.meta.Int(source.signedness, dest.bits), target)); + } else { + return @bitCast(DestType, @as(std.meta.Int(source.signedness, dest.bits), target)); + } + } + return @as(DestType, target); +} + +// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub const MontgomeryDomainFieldElement = [4]u64; + +// The type NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain. +// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub const NonMontgomeryDomainFieldElement = [4]u64; + +/// The function addcarryxU64 is an addition with carry. +/// +/// Postconditions: +/// out1 = (arg1 + arg2 + arg3) mod 2^64 +/// out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +inline fn addcarryxU64(out1: *u64, out2: *u1, arg1: u1, arg2: u64, arg3: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(u128, arg1) + cast(u128, arg2)) + cast(u128, arg3)); + const x2 = cast(u64, (x1 & cast(u128, 0xffffffffffffffff))); + const x3 = cast(u1, (x1 >> 64)); + out1.* = x2; + out2.* = x3; +} + +/// The function subborrowxU64 is a subtraction with borrow. +/// +/// Postconditions: +/// out1 = (-arg1 + arg2 + -arg3) mod 2^64 +/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0x1] +inline fn subborrowxU64(out1: *u64, out2: *u1, arg1: u1, arg2: u64, arg3: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((cast(i128, arg2) - cast(i128, arg1)) - cast(i128, arg3)); + const x2 = cast(i1, (x1 >> 64)); + const x3 = cast(u64, (x1 & cast(i128, 0xffffffffffffffff))); + out1.* = x3; + out2.* = cast(u1, (cast(i2, 0x0) - cast(i2, x2))); +} + +/// The function mulxU64 is a multiplication, returning the full double-width result. +/// +/// Postconditions: +/// out1 = (arg1 * arg2) mod 2^64 +/// out2 = ⌊arg1 * arg2 / 2^64⌋ +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [0x0 ~> 0xffffffffffffffff] +inline fn mulxU64(out1: *u64, out2: *u64, arg1: u64, arg2: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u128, arg1) * cast(u128, arg2)); + const x2 = cast(u64, (x1 & cast(u128, 0xffffffffffffffff))); + const x3 = cast(u64, (x1 >> 64)); + out1.* = x2; + out2.* = x3; +} + +/// The function cmovznzU64 is a single-word conditional move. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [0x0 ~> 0xffffffffffffffff] +/// arg3: [0x0 ~> 0xffffffffffffffff] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +inline fn cmovznzU64(out1: *u64, arg1: u1, arg2: u64, arg3: u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (~(~arg1)); + const x2 = cast(u64, (cast(i128, cast(i1, (cast(i2, 0x0) - cast(i2, x1)))) & cast(i128, 0xffffffffffffffff))); + const x3 = ((x2 & arg3) | ((~x2) & arg2)); + out1.* = x3; +} + +/// The function mul multiplies two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn mul(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[0]); + var x5: u64 = undefined; + var x6: u64 = undefined; + mulxU64(&x5, &x6, x4, (arg2[3])); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x4, (arg2[2])); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x4, (arg2[1])); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x4, (arg2[0])); + var x13: u64 = undefined; + var x14: u1 = undefined; + addcarryxU64(&x13, &x14, 0x0, x12, x9); + var x15: u64 = undefined; + var x16: u1 = undefined; + addcarryxU64(&x15, &x16, x14, x10, x7); + var x17: u64 = undefined; + var x18: u1 = undefined; + addcarryxU64(&x17, &x18, x16, x8, x5); + const x19 = (cast(u64, x18) + x6); + var x20: u64 = undefined; + var x21: u64 = undefined; + mulxU64(&x20, &x21, x11, 0x4b0dff665588b13f); + var x22: u64 = undefined; + var x23: u64 = undefined; + mulxU64(&x22, &x23, x20, 0xffffffffffffffff); + var x24: u64 = undefined; + var x25: u64 = undefined; + mulxU64(&x24, &x25, x20, 0xfffffffffffffffe); + var x26: u64 = undefined; + var x27: u64 = undefined; + mulxU64(&x26, &x27, x20, 0xbaaedce6af48a03b); + var x28: u64 = undefined; + var x29: u64 = undefined; + mulxU64(&x28, &x29, x20, 0xbfd25e8cd0364141); + var x30: u64 = undefined; + var x31: u1 = undefined; + addcarryxU64(&x30, &x31, 0x0, x29, x26); + var x32: u64 = undefined; + var x33: u1 = undefined; + addcarryxU64(&x32, &x33, x31, x27, x24); + var x34: u64 = undefined; + var x35: u1 = undefined; + addcarryxU64(&x34, &x35, x33, x25, x22); + const x36 = (cast(u64, x35) + x23); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, 0x0, x11, x28); + var x39: u64 = undefined; + var x40: u1 = undefined; + addcarryxU64(&x39, &x40, x38, x13, x30); + var x41: u64 = undefined; + var x42: u1 = undefined; + addcarryxU64(&x41, &x42, x40, x15, x32); + var x43: u64 = undefined; + var x44: u1 = undefined; + addcarryxU64(&x43, &x44, x42, x17, x34); + var x45: u64 = undefined; + var x46: u1 = undefined; + addcarryxU64(&x45, &x46, x44, x19, x36); + var x47: u64 = undefined; + var x48: u64 = undefined; + mulxU64(&x47, &x48, x1, (arg2[3])); + var x49: u64 = undefined; + var x50: u64 = undefined; + mulxU64(&x49, &x50, x1, (arg2[2])); + var x51: u64 = undefined; + var x52: u64 = undefined; + mulxU64(&x51, &x52, x1, (arg2[1])); + var x53: u64 = undefined; + var x54: u64 = undefined; + mulxU64(&x53, &x54, x1, (arg2[0])); + var x55: u64 = undefined; + var x56: u1 = undefined; + addcarryxU64(&x55, &x56, 0x0, x54, x51); + var x57: u64 = undefined; + var x58: u1 = undefined; + addcarryxU64(&x57, &x58, x56, x52, x49); + var x59: u64 = undefined; + var x60: u1 = undefined; + addcarryxU64(&x59, &x60, x58, x50, x47); + const x61 = (cast(u64, x60) + x48); + var x62: u64 = undefined; + var x63: u1 = undefined; + addcarryxU64(&x62, &x63, 0x0, x39, x53); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, x41, x55); + var x66: u64 = undefined; + var x67: u1 = undefined; + addcarryxU64(&x66, &x67, x65, x43, x57); + var x68: u64 = undefined; + var x69: u1 = undefined; + addcarryxU64(&x68, &x69, x67, x45, x59); + var x70: u64 = undefined; + var x71: u1 = undefined; + addcarryxU64(&x70, &x71, x69, cast(u64, x46), x61); + var x72: u64 = undefined; + var x73: u64 = undefined; + mulxU64(&x72, &x73, x62, 0x4b0dff665588b13f); + var x74: u64 = undefined; + var x75: u64 = undefined; + mulxU64(&x74, &x75, x72, 0xffffffffffffffff); + var x76: u64 = undefined; + var x77: u64 = undefined; + mulxU64(&x76, &x77, x72, 0xfffffffffffffffe); + var x78: u64 = undefined; + var x79: u64 = undefined; + mulxU64(&x78, &x79, x72, 0xbaaedce6af48a03b); + var x80: u64 = undefined; + var x81: u64 = undefined; + mulxU64(&x80, &x81, x72, 0xbfd25e8cd0364141); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, 0x0, x81, x78); + var x84: u64 = undefined; + var x85: u1 = undefined; + addcarryxU64(&x84, &x85, x83, x79, x76); + var x86: u64 = undefined; + var x87: u1 = undefined; + addcarryxU64(&x86, &x87, x85, x77, x74); + const x88 = (cast(u64, x87) + x75); + var x89: u64 = undefined; + var x90: u1 = undefined; + addcarryxU64(&x89, &x90, 0x0, x62, x80); + var x91: u64 = undefined; + var x92: u1 = undefined; + addcarryxU64(&x91, &x92, x90, x64, x82); + var x93: u64 = undefined; + var x94: u1 = undefined; + addcarryxU64(&x93, &x94, x92, x66, x84); + var x95: u64 = undefined; + var x96: u1 = undefined; + addcarryxU64(&x95, &x96, x94, x68, x86); + var x97: u64 = undefined; + var x98: u1 = undefined; + addcarryxU64(&x97, &x98, x96, x70, x88); + const x99 = (cast(u64, x98) + cast(u64, x71)); + var x100: u64 = undefined; + var x101: u64 = undefined; + mulxU64(&x100, &x101, x2, (arg2[3])); + var x102: u64 = undefined; + var x103: u64 = undefined; + mulxU64(&x102, &x103, x2, (arg2[2])); + var x104: u64 = undefined; + var x105: u64 = undefined; + mulxU64(&x104, &x105, x2, (arg2[1])); + var x106: u64 = undefined; + var x107: u64 = undefined; + mulxU64(&x106, &x107, x2, (arg2[0])); + var x108: u64 = undefined; + var x109: u1 = undefined; + addcarryxU64(&x108, &x109, 0x0, x107, x104); + var x110: u64 = undefined; + var x111: u1 = undefined; + addcarryxU64(&x110, &x111, x109, x105, x102); + var x112: u64 = undefined; + var x113: u1 = undefined; + addcarryxU64(&x112, &x113, x111, x103, x100); + const x114 = (cast(u64, x113) + x101); + var x115: u64 = undefined; + var x116: u1 = undefined; + addcarryxU64(&x115, &x116, 0x0, x91, x106); + var x117: u64 = undefined; + var x118: u1 = undefined; + addcarryxU64(&x117, &x118, x116, x93, x108); + var x119: u64 = undefined; + var x120: u1 = undefined; + addcarryxU64(&x119, &x120, x118, x95, x110); + var x121: u64 = undefined; + var x122: u1 = undefined; + addcarryxU64(&x121, &x122, x120, x97, x112); + var x123: u64 = undefined; + var x124: u1 = undefined; + addcarryxU64(&x123, &x124, x122, x99, x114); + var x125: u64 = undefined; + var x126: u64 = undefined; + mulxU64(&x125, &x126, x115, 0x4b0dff665588b13f); + var x127: u64 = undefined; + var x128: u64 = undefined; + mulxU64(&x127, &x128, x125, 0xffffffffffffffff); + var x129: u64 = undefined; + var x130: u64 = undefined; + mulxU64(&x129, &x130, x125, 0xfffffffffffffffe); + var x131: u64 = undefined; + var x132: u64 = undefined; + mulxU64(&x131, &x132, x125, 0xbaaedce6af48a03b); + var x133: u64 = undefined; + var x134: u64 = undefined; + mulxU64(&x133, &x134, x125, 0xbfd25e8cd0364141); + var x135: u64 = undefined; + var x136: u1 = undefined; + addcarryxU64(&x135, &x136, 0x0, x134, x131); + var x137: u64 = undefined; + var x138: u1 = undefined; + addcarryxU64(&x137, &x138, x136, x132, x129); + var x139: u64 = undefined; + var x140: u1 = undefined; + addcarryxU64(&x139, &x140, x138, x130, x127); + const x141 = (cast(u64, x140) + x128); + var x142: u64 = undefined; + var x143: u1 = undefined; + addcarryxU64(&x142, &x143, 0x0, x115, x133); + var x144: u64 = undefined; + var x145: u1 = undefined; + addcarryxU64(&x144, &x145, x143, x117, x135); + var x146: u64 = undefined; + var x147: u1 = undefined; + addcarryxU64(&x146, &x147, x145, x119, x137); + var x148: u64 = undefined; + var x149: u1 = undefined; + addcarryxU64(&x148, &x149, x147, x121, x139); + var x150: u64 = undefined; + var x151: u1 = undefined; + addcarryxU64(&x150, &x151, x149, x123, x141); + const x152 = (cast(u64, x151) + cast(u64, x124)); + var x153: u64 = undefined; + var x154: u64 = undefined; + mulxU64(&x153, &x154, x3, (arg2[3])); + var x155: u64 = undefined; + var x156: u64 = undefined; + mulxU64(&x155, &x156, x3, (arg2[2])); + var x157: u64 = undefined; + var x158: u64 = undefined; + mulxU64(&x157, &x158, x3, (arg2[1])); + var x159: u64 = undefined; + var x160: u64 = undefined; + mulxU64(&x159, &x160, x3, (arg2[0])); + var x161: u64 = undefined; + var x162: u1 = undefined; + addcarryxU64(&x161, &x162, 0x0, x160, x157); + var x163: u64 = undefined; + var x164: u1 = undefined; + addcarryxU64(&x163, &x164, x162, x158, x155); + var x165: u64 = undefined; + var x166: u1 = undefined; + addcarryxU64(&x165, &x166, x164, x156, x153); + const x167 = (cast(u64, x166) + x154); + var x168: u64 = undefined; + var x169: u1 = undefined; + addcarryxU64(&x168, &x169, 0x0, x144, x159); + var x170: u64 = undefined; + var x171: u1 = undefined; + addcarryxU64(&x170, &x171, x169, x146, x161); + var x172: u64 = undefined; + var x173: u1 = undefined; + addcarryxU64(&x172, &x173, x171, x148, x163); + var x174: u64 = undefined; + var x175: u1 = undefined; + addcarryxU64(&x174, &x175, x173, x150, x165); + var x176: u64 = undefined; + var x177: u1 = undefined; + addcarryxU64(&x176, &x177, x175, x152, x167); + var x178: u64 = undefined; + var x179: u64 = undefined; + mulxU64(&x178, &x179, x168, 0x4b0dff665588b13f); + var x180: u64 = undefined; + var x181: u64 = undefined; + mulxU64(&x180, &x181, x178, 0xffffffffffffffff); + var x182: u64 = undefined; + var x183: u64 = undefined; + mulxU64(&x182, &x183, x178, 0xfffffffffffffffe); + var x184: u64 = undefined; + var x185: u64 = undefined; + mulxU64(&x184, &x185, x178, 0xbaaedce6af48a03b); + var x186: u64 = undefined; + var x187: u64 = undefined; + mulxU64(&x186, &x187, x178, 0xbfd25e8cd0364141); + var x188: u64 = undefined; + var x189: u1 = undefined; + addcarryxU64(&x188, &x189, 0x0, x187, x184); + var x190: u64 = undefined; + var x191: u1 = undefined; + addcarryxU64(&x190, &x191, x189, x185, x182); + var x192: u64 = undefined; + var x193: u1 = undefined; + addcarryxU64(&x192, &x193, x191, x183, x180); + const x194 = (cast(u64, x193) + x181); + var x195: u64 = undefined; + var x196: u1 = undefined; + addcarryxU64(&x195, &x196, 0x0, x168, x186); + var x197: u64 = undefined; + var x198: u1 = undefined; + addcarryxU64(&x197, &x198, x196, x170, x188); + var x199: u64 = undefined; + var x200: u1 = undefined; + addcarryxU64(&x199, &x200, x198, x172, x190); + var x201: u64 = undefined; + var x202: u1 = undefined; + addcarryxU64(&x201, &x202, x200, x174, x192); + var x203: u64 = undefined; + var x204: u1 = undefined; + addcarryxU64(&x203, &x204, x202, x176, x194); + const x205 = (cast(u64, x204) + cast(u64, x177)); + var x206: u64 = undefined; + var x207: u1 = undefined; + subborrowxU64(&x206, &x207, 0x0, x197, 0xbfd25e8cd0364141); + var x208: u64 = undefined; + var x209: u1 = undefined; + subborrowxU64(&x208, &x209, x207, x199, 0xbaaedce6af48a03b); + var x210: u64 = undefined; + var x211: u1 = undefined; + subborrowxU64(&x210, &x211, x209, x201, 0xfffffffffffffffe); + var x212: u64 = undefined; + var x213: u1 = undefined; + subborrowxU64(&x212, &x213, x211, x203, 0xffffffffffffffff); + var x214: u64 = undefined; + var x215: u1 = undefined; + subborrowxU64(&x214, &x215, x213, x205, cast(u64, 0x0)); + var x216: u64 = undefined; + cmovznzU64(&x216, x215, x206, x197); + var x217: u64 = undefined; + cmovznzU64(&x217, x215, x208, x199); + var x218: u64 = undefined; + cmovznzU64(&x218, x215, x210, x201); + var x219: u64 = undefined; + cmovznzU64(&x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/// The function square squares a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn square(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[0]); + var x5: u64 = undefined; + var x6: u64 = undefined; + mulxU64(&x5, &x6, x4, (arg1[3])); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x4, (arg1[2])); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x4, (arg1[1])); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x4, (arg1[0])); + var x13: u64 = undefined; + var x14: u1 = undefined; + addcarryxU64(&x13, &x14, 0x0, x12, x9); + var x15: u64 = undefined; + var x16: u1 = undefined; + addcarryxU64(&x15, &x16, x14, x10, x7); + var x17: u64 = undefined; + var x18: u1 = undefined; + addcarryxU64(&x17, &x18, x16, x8, x5); + const x19 = (cast(u64, x18) + x6); + var x20: u64 = undefined; + var x21: u64 = undefined; + mulxU64(&x20, &x21, x11, 0x4b0dff665588b13f); + var x22: u64 = undefined; + var x23: u64 = undefined; + mulxU64(&x22, &x23, x20, 0xffffffffffffffff); + var x24: u64 = undefined; + var x25: u64 = undefined; + mulxU64(&x24, &x25, x20, 0xfffffffffffffffe); + var x26: u64 = undefined; + var x27: u64 = undefined; + mulxU64(&x26, &x27, x20, 0xbaaedce6af48a03b); + var x28: u64 = undefined; + var x29: u64 = undefined; + mulxU64(&x28, &x29, x20, 0xbfd25e8cd0364141); + var x30: u64 = undefined; + var x31: u1 = undefined; + addcarryxU64(&x30, &x31, 0x0, x29, x26); + var x32: u64 = undefined; + var x33: u1 = undefined; + addcarryxU64(&x32, &x33, x31, x27, x24); + var x34: u64 = undefined; + var x35: u1 = undefined; + addcarryxU64(&x34, &x35, x33, x25, x22); + const x36 = (cast(u64, x35) + x23); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, 0x0, x11, x28); + var x39: u64 = undefined; + var x40: u1 = undefined; + addcarryxU64(&x39, &x40, x38, x13, x30); + var x41: u64 = undefined; + var x42: u1 = undefined; + addcarryxU64(&x41, &x42, x40, x15, x32); + var x43: u64 = undefined; + var x44: u1 = undefined; + addcarryxU64(&x43, &x44, x42, x17, x34); + var x45: u64 = undefined; + var x46: u1 = undefined; + addcarryxU64(&x45, &x46, x44, x19, x36); + var x47: u64 = undefined; + var x48: u64 = undefined; + mulxU64(&x47, &x48, x1, (arg1[3])); + var x49: u64 = undefined; + var x50: u64 = undefined; + mulxU64(&x49, &x50, x1, (arg1[2])); + var x51: u64 = undefined; + var x52: u64 = undefined; + mulxU64(&x51, &x52, x1, (arg1[1])); + var x53: u64 = undefined; + var x54: u64 = undefined; + mulxU64(&x53, &x54, x1, (arg1[0])); + var x55: u64 = undefined; + var x56: u1 = undefined; + addcarryxU64(&x55, &x56, 0x0, x54, x51); + var x57: u64 = undefined; + var x58: u1 = undefined; + addcarryxU64(&x57, &x58, x56, x52, x49); + var x59: u64 = undefined; + var x60: u1 = undefined; + addcarryxU64(&x59, &x60, x58, x50, x47); + const x61 = (cast(u64, x60) + x48); + var x62: u64 = undefined; + var x63: u1 = undefined; + addcarryxU64(&x62, &x63, 0x0, x39, x53); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, x41, x55); + var x66: u64 = undefined; + var x67: u1 = undefined; + addcarryxU64(&x66, &x67, x65, x43, x57); + var x68: u64 = undefined; + var x69: u1 = undefined; + addcarryxU64(&x68, &x69, x67, x45, x59); + var x70: u64 = undefined; + var x71: u1 = undefined; + addcarryxU64(&x70, &x71, x69, cast(u64, x46), x61); + var x72: u64 = undefined; + var x73: u64 = undefined; + mulxU64(&x72, &x73, x62, 0x4b0dff665588b13f); + var x74: u64 = undefined; + var x75: u64 = undefined; + mulxU64(&x74, &x75, x72, 0xffffffffffffffff); + var x76: u64 = undefined; + var x77: u64 = undefined; + mulxU64(&x76, &x77, x72, 0xfffffffffffffffe); + var x78: u64 = undefined; + var x79: u64 = undefined; + mulxU64(&x78, &x79, x72, 0xbaaedce6af48a03b); + var x80: u64 = undefined; + var x81: u64 = undefined; + mulxU64(&x80, &x81, x72, 0xbfd25e8cd0364141); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, 0x0, x81, x78); + var x84: u64 = undefined; + var x85: u1 = undefined; + addcarryxU64(&x84, &x85, x83, x79, x76); + var x86: u64 = undefined; + var x87: u1 = undefined; + addcarryxU64(&x86, &x87, x85, x77, x74); + const x88 = (cast(u64, x87) + x75); + var x89: u64 = undefined; + var x90: u1 = undefined; + addcarryxU64(&x89, &x90, 0x0, x62, x80); + var x91: u64 = undefined; + var x92: u1 = undefined; + addcarryxU64(&x91, &x92, x90, x64, x82); + var x93: u64 = undefined; + var x94: u1 = undefined; + addcarryxU64(&x93, &x94, x92, x66, x84); + var x95: u64 = undefined; + var x96: u1 = undefined; + addcarryxU64(&x95, &x96, x94, x68, x86); + var x97: u64 = undefined; + var x98: u1 = undefined; + addcarryxU64(&x97, &x98, x96, x70, x88); + const x99 = (cast(u64, x98) + cast(u64, x71)); + var x100: u64 = undefined; + var x101: u64 = undefined; + mulxU64(&x100, &x101, x2, (arg1[3])); + var x102: u64 = undefined; + var x103: u64 = undefined; + mulxU64(&x102, &x103, x2, (arg1[2])); + var x104: u64 = undefined; + var x105: u64 = undefined; + mulxU64(&x104, &x105, x2, (arg1[1])); + var x106: u64 = undefined; + var x107: u64 = undefined; + mulxU64(&x106, &x107, x2, (arg1[0])); + var x108: u64 = undefined; + var x109: u1 = undefined; + addcarryxU64(&x108, &x109, 0x0, x107, x104); + var x110: u64 = undefined; + var x111: u1 = undefined; + addcarryxU64(&x110, &x111, x109, x105, x102); + var x112: u64 = undefined; + var x113: u1 = undefined; + addcarryxU64(&x112, &x113, x111, x103, x100); + const x114 = (cast(u64, x113) + x101); + var x115: u64 = undefined; + var x116: u1 = undefined; + addcarryxU64(&x115, &x116, 0x0, x91, x106); + var x117: u64 = undefined; + var x118: u1 = undefined; + addcarryxU64(&x117, &x118, x116, x93, x108); + var x119: u64 = undefined; + var x120: u1 = undefined; + addcarryxU64(&x119, &x120, x118, x95, x110); + var x121: u64 = undefined; + var x122: u1 = undefined; + addcarryxU64(&x121, &x122, x120, x97, x112); + var x123: u64 = undefined; + var x124: u1 = undefined; + addcarryxU64(&x123, &x124, x122, x99, x114); + var x125: u64 = undefined; + var x126: u64 = undefined; + mulxU64(&x125, &x126, x115, 0x4b0dff665588b13f); + var x127: u64 = undefined; + var x128: u64 = undefined; + mulxU64(&x127, &x128, x125, 0xffffffffffffffff); + var x129: u64 = undefined; + var x130: u64 = undefined; + mulxU64(&x129, &x130, x125, 0xfffffffffffffffe); + var x131: u64 = undefined; + var x132: u64 = undefined; + mulxU64(&x131, &x132, x125, 0xbaaedce6af48a03b); + var x133: u64 = undefined; + var x134: u64 = undefined; + mulxU64(&x133, &x134, x125, 0xbfd25e8cd0364141); + var x135: u64 = undefined; + var x136: u1 = undefined; + addcarryxU64(&x135, &x136, 0x0, x134, x131); + var x137: u64 = undefined; + var x138: u1 = undefined; + addcarryxU64(&x137, &x138, x136, x132, x129); + var x139: u64 = undefined; + var x140: u1 = undefined; + addcarryxU64(&x139, &x140, x138, x130, x127); + const x141 = (cast(u64, x140) + x128); + var x142: u64 = undefined; + var x143: u1 = undefined; + addcarryxU64(&x142, &x143, 0x0, x115, x133); + var x144: u64 = undefined; + var x145: u1 = undefined; + addcarryxU64(&x144, &x145, x143, x117, x135); + var x146: u64 = undefined; + var x147: u1 = undefined; + addcarryxU64(&x146, &x147, x145, x119, x137); + var x148: u64 = undefined; + var x149: u1 = undefined; + addcarryxU64(&x148, &x149, x147, x121, x139); + var x150: u64 = undefined; + var x151: u1 = undefined; + addcarryxU64(&x150, &x151, x149, x123, x141); + const x152 = (cast(u64, x151) + cast(u64, x124)); + var x153: u64 = undefined; + var x154: u64 = undefined; + mulxU64(&x153, &x154, x3, (arg1[3])); + var x155: u64 = undefined; + var x156: u64 = undefined; + mulxU64(&x155, &x156, x3, (arg1[2])); + var x157: u64 = undefined; + var x158: u64 = undefined; + mulxU64(&x157, &x158, x3, (arg1[1])); + var x159: u64 = undefined; + var x160: u64 = undefined; + mulxU64(&x159, &x160, x3, (arg1[0])); + var x161: u64 = undefined; + var x162: u1 = undefined; + addcarryxU64(&x161, &x162, 0x0, x160, x157); + var x163: u64 = undefined; + var x164: u1 = undefined; + addcarryxU64(&x163, &x164, x162, x158, x155); + var x165: u64 = undefined; + var x166: u1 = undefined; + addcarryxU64(&x165, &x166, x164, x156, x153); + const x167 = (cast(u64, x166) + x154); + var x168: u64 = undefined; + var x169: u1 = undefined; + addcarryxU64(&x168, &x169, 0x0, x144, x159); + var x170: u64 = undefined; + var x171: u1 = undefined; + addcarryxU64(&x170, &x171, x169, x146, x161); + var x172: u64 = undefined; + var x173: u1 = undefined; + addcarryxU64(&x172, &x173, x171, x148, x163); + var x174: u64 = undefined; + var x175: u1 = undefined; + addcarryxU64(&x174, &x175, x173, x150, x165); + var x176: u64 = undefined; + var x177: u1 = undefined; + addcarryxU64(&x176, &x177, x175, x152, x167); + var x178: u64 = undefined; + var x179: u64 = undefined; + mulxU64(&x178, &x179, x168, 0x4b0dff665588b13f); + var x180: u64 = undefined; + var x181: u64 = undefined; + mulxU64(&x180, &x181, x178, 0xffffffffffffffff); + var x182: u64 = undefined; + var x183: u64 = undefined; + mulxU64(&x182, &x183, x178, 0xfffffffffffffffe); + var x184: u64 = undefined; + var x185: u64 = undefined; + mulxU64(&x184, &x185, x178, 0xbaaedce6af48a03b); + var x186: u64 = undefined; + var x187: u64 = undefined; + mulxU64(&x186, &x187, x178, 0xbfd25e8cd0364141); + var x188: u64 = undefined; + var x189: u1 = undefined; + addcarryxU64(&x188, &x189, 0x0, x187, x184); + var x190: u64 = undefined; + var x191: u1 = undefined; + addcarryxU64(&x190, &x191, x189, x185, x182); + var x192: u64 = undefined; + var x193: u1 = undefined; + addcarryxU64(&x192, &x193, x191, x183, x180); + const x194 = (cast(u64, x193) + x181); + var x195: u64 = undefined; + var x196: u1 = undefined; + addcarryxU64(&x195, &x196, 0x0, x168, x186); + var x197: u64 = undefined; + var x198: u1 = undefined; + addcarryxU64(&x197, &x198, x196, x170, x188); + var x199: u64 = undefined; + var x200: u1 = undefined; + addcarryxU64(&x199, &x200, x198, x172, x190); + var x201: u64 = undefined; + var x202: u1 = undefined; + addcarryxU64(&x201, &x202, x200, x174, x192); + var x203: u64 = undefined; + var x204: u1 = undefined; + addcarryxU64(&x203, &x204, x202, x176, x194); + const x205 = (cast(u64, x204) + cast(u64, x177)); + var x206: u64 = undefined; + var x207: u1 = undefined; + subborrowxU64(&x206, &x207, 0x0, x197, 0xbfd25e8cd0364141); + var x208: u64 = undefined; + var x209: u1 = undefined; + subborrowxU64(&x208, &x209, x207, x199, 0xbaaedce6af48a03b); + var x210: u64 = undefined; + var x211: u1 = undefined; + subborrowxU64(&x210, &x211, x209, x201, 0xfffffffffffffffe); + var x212: u64 = undefined; + var x213: u1 = undefined; + subborrowxU64(&x212, &x213, x211, x203, 0xffffffffffffffff); + var x214: u64 = undefined; + var x215: u1 = undefined; + subborrowxU64(&x214, &x215, x213, x205, cast(u64, 0x0)); + var x216: u64 = undefined; + cmovznzU64(&x216, x215, x206, x197); + var x217: u64 = undefined; + cmovznzU64(&x217, x215, x208, x199); + var x218: u64 = undefined; + cmovznzU64(&x218, x215, x210, x201); + var x219: u64 = undefined; + cmovznzU64(&x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/// The function add adds two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn add(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + addcarryxU64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u64 = undefined; + var x4: u1 = undefined; + addcarryxU64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u64 = undefined; + var x6: u1 = undefined; + addcarryxU64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u64 = undefined; + var x8: u1 = undefined; + addcarryxU64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u64 = undefined; + var x10: u1 = undefined; + subborrowxU64(&x9, &x10, 0x0, x1, 0xbfd25e8cd0364141); + var x11: u64 = undefined; + var x12: u1 = undefined; + subborrowxU64(&x11, &x12, x10, x3, 0xbaaedce6af48a03b); + var x13: u64 = undefined; + var x14: u1 = undefined; + subborrowxU64(&x13, &x14, x12, x5, 0xfffffffffffffffe); + var x15: u64 = undefined; + var x16: u1 = undefined; + subborrowxU64(&x15, &x16, x14, x7, 0xffffffffffffffff); + var x17: u64 = undefined; + var x18: u1 = undefined; + subborrowxU64(&x17, &x18, x16, cast(u64, x8), cast(u64, 0x0)); + var x19: u64 = undefined; + cmovznzU64(&x19, x18, x9, x1); + var x20: u64 = undefined; + cmovznzU64(&x20, x18, x11, x3); + var x21: u64 = undefined; + cmovznzU64(&x21, x18, x13, x5); + var x22: u64 = undefined; + cmovznzU64(&x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/// The function sub subtracts two field elements in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// 0 ≤ eval arg2 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m +/// 0 ≤ eval out1 < m +/// +pub fn sub(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + subborrowxU64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + var x3: u64 = undefined; + var x4: u1 = undefined; + subborrowxU64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + var x5: u64 = undefined; + var x6: u1 = undefined; + subborrowxU64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + var x7: u64 = undefined; + var x8: u1 = undefined; + subborrowxU64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + var x9: u64 = undefined; + cmovznzU64(&x9, x8, cast(u64, 0x0), 0xffffffffffffffff); + var x10: u64 = undefined; + var x11: u1 = undefined; + addcarryxU64(&x10, &x11, 0x0, x1, (x9 & 0xbfd25e8cd0364141)); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, x11, x3, (x9 & 0xbaaedce6af48a03b)); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, x5, (x9 & 0xfffffffffffffffe)); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, x7, x9); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function opp negates a field element in the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m +/// 0 ≤ eval out1 < m +/// +pub fn opp(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + subborrowxU64(&x1, &x2, 0x0, cast(u64, 0x0), (arg1[0])); + var x3: u64 = undefined; + var x4: u1 = undefined; + subborrowxU64(&x3, &x4, x2, cast(u64, 0x0), (arg1[1])); + var x5: u64 = undefined; + var x6: u1 = undefined; + subborrowxU64(&x5, &x6, x4, cast(u64, 0x0), (arg1[2])); + var x7: u64 = undefined; + var x8: u1 = undefined; + subborrowxU64(&x7, &x8, x6, cast(u64, 0x0), (arg1[3])); + var x9: u64 = undefined; + cmovznzU64(&x9, x8, cast(u64, 0x0), 0xffffffffffffffff); + var x10: u64 = undefined; + var x11: u1 = undefined; + addcarryxU64(&x10, &x11, 0x0, x1, (x9 & 0xbfd25e8cd0364141)); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, x11, x3, (x9 & 0xbaaedce6af48a03b)); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, x5, (x9 & 0xfffffffffffffffe)); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, x7, x9); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fromMontgomery translates a field element out of the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m +/// 0 ≤ eval out1 < m +/// +pub fn fromMontgomery(out1: *NonMontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[0]); + var x2: u64 = undefined; + var x3: u64 = undefined; + mulxU64(&x2, &x3, x1, 0x4b0dff665588b13f); + var x4: u64 = undefined; + var x5: u64 = undefined; + mulxU64(&x4, &x5, x2, 0xffffffffffffffff); + var x6: u64 = undefined; + var x7: u64 = undefined; + mulxU64(&x6, &x7, x2, 0xfffffffffffffffe); + var x8: u64 = undefined; + var x9: u64 = undefined; + mulxU64(&x8, &x9, x2, 0xbaaedce6af48a03b); + var x10: u64 = undefined; + var x11: u64 = undefined; + mulxU64(&x10, &x11, x2, 0xbfd25e8cd0364141); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, 0x0, x11, x8); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, x9, x6); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, x7, x4); + var x18: u64 = undefined; + var x19: u1 = undefined; + addcarryxU64(&x18, &x19, 0x0, x1, x10); + var x20: u64 = undefined; + var x21: u1 = undefined; + addcarryxU64(&x20, &x21, x19, cast(u64, 0x0), x12); + var x22: u64 = undefined; + var x23: u1 = undefined; + addcarryxU64(&x22, &x23, x21, cast(u64, 0x0), x14); + var x24: u64 = undefined; + var x25: u1 = undefined; + addcarryxU64(&x24, &x25, x23, cast(u64, 0x0), x16); + var x26: u64 = undefined; + var x27: u1 = undefined; + addcarryxU64(&x26, &x27, x25, cast(u64, 0x0), (cast(u64, x17) + x5)); + var x28: u64 = undefined; + var x29: u1 = undefined; + addcarryxU64(&x28, &x29, 0x0, x20, (arg1[1])); + var x30: u64 = undefined; + var x31: u1 = undefined; + addcarryxU64(&x30, &x31, x29, x22, cast(u64, 0x0)); + var x32: u64 = undefined; + var x33: u1 = undefined; + addcarryxU64(&x32, &x33, x31, x24, cast(u64, 0x0)); + var x34: u64 = undefined; + var x35: u1 = undefined; + addcarryxU64(&x34, &x35, x33, x26, cast(u64, 0x0)); + var x36: u64 = undefined; + var x37: u64 = undefined; + mulxU64(&x36, &x37, x28, 0x4b0dff665588b13f); + var x38: u64 = undefined; + var x39: u64 = undefined; + mulxU64(&x38, &x39, x36, 0xffffffffffffffff); + var x40: u64 = undefined; + var x41: u64 = undefined; + mulxU64(&x40, &x41, x36, 0xfffffffffffffffe); + var x42: u64 = undefined; + var x43: u64 = undefined; + mulxU64(&x42, &x43, x36, 0xbaaedce6af48a03b); + var x44: u64 = undefined; + var x45: u64 = undefined; + mulxU64(&x44, &x45, x36, 0xbfd25e8cd0364141); + var x46: u64 = undefined; + var x47: u1 = undefined; + addcarryxU64(&x46, &x47, 0x0, x45, x42); + var x48: u64 = undefined; + var x49: u1 = undefined; + addcarryxU64(&x48, &x49, x47, x43, x40); + var x50: u64 = undefined; + var x51: u1 = undefined; + addcarryxU64(&x50, &x51, x49, x41, x38); + var x52: u64 = undefined; + var x53: u1 = undefined; + addcarryxU64(&x52, &x53, 0x0, x28, x44); + var x54: u64 = undefined; + var x55: u1 = undefined; + addcarryxU64(&x54, &x55, x53, x30, x46); + var x56: u64 = undefined; + var x57: u1 = undefined; + addcarryxU64(&x56, &x57, x55, x32, x48); + var x58: u64 = undefined; + var x59: u1 = undefined; + addcarryxU64(&x58, &x59, x57, x34, x50); + var x60: u64 = undefined; + var x61: u1 = undefined; + addcarryxU64(&x60, &x61, x59, (cast(u64, x35) + cast(u64, x27)), (cast(u64, x51) + x39)); + var x62: u64 = undefined; + var x63: u1 = undefined; + addcarryxU64(&x62, &x63, 0x0, x54, (arg1[2])); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, x56, cast(u64, 0x0)); + var x66: u64 = undefined; + var x67: u1 = undefined; + addcarryxU64(&x66, &x67, x65, x58, cast(u64, 0x0)); + var x68: u64 = undefined; + var x69: u1 = undefined; + addcarryxU64(&x68, &x69, x67, x60, cast(u64, 0x0)); + var x70: u64 = undefined; + var x71: u64 = undefined; + mulxU64(&x70, &x71, x62, 0x4b0dff665588b13f); + var x72: u64 = undefined; + var x73: u64 = undefined; + mulxU64(&x72, &x73, x70, 0xffffffffffffffff); + var x74: u64 = undefined; + var x75: u64 = undefined; + mulxU64(&x74, &x75, x70, 0xfffffffffffffffe); + var x76: u64 = undefined; + var x77: u64 = undefined; + mulxU64(&x76, &x77, x70, 0xbaaedce6af48a03b); + var x78: u64 = undefined; + var x79: u64 = undefined; + mulxU64(&x78, &x79, x70, 0xbfd25e8cd0364141); + var x80: u64 = undefined; + var x81: u1 = undefined; + addcarryxU64(&x80, &x81, 0x0, x79, x76); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, x81, x77, x74); + var x84: u64 = undefined; + var x85: u1 = undefined; + addcarryxU64(&x84, &x85, x83, x75, x72); + var x86: u64 = undefined; + var x87: u1 = undefined; + addcarryxU64(&x86, &x87, 0x0, x62, x78); + var x88: u64 = undefined; + var x89: u1 = undefined; + addcarryxU64(&x88, &x89, x87, x64, x80); + var x90: u64 = undefined; + var x91: u1 = undefined; + addcarryxU64(&x90, &x91, x89, x66, x82); + var x92: u64 = undefined; + var x93: u1 = undefined; + addcarryxU64(&x92, &x93, x91, x68, x84); + var x94: u64 = undefined; + var x95: u1 = undefined; + addcarryxU64(&x94, &x95, x93, (cast(u64, x69) + cast(u64, x61)), (cast(u64, x85) + x73)); + var x96: u64 = undefined; + var x97: u1 = undefined; + addcarryxU64(&x96, &x97, 0x0, x88, (arg1[3])); + var x98: u64 = undefined; + var x99: u1 = undefined; + addcarryxU64(&x98, &x99, x97, x90, cast(u64, 0x0)); + var x100: u64 = undefined; + var x101: u1 = undefined; + addcarryxU64(&x100, &x101, x99, x92, cast(u64, 0x0)); + var x102: u64 = undefined; + var x103: u1 = undefined; + addcarryxU64(&x102, &x103, x101, x94, cast(u64, 0x0)); + var x104: u64 = undefined; + var x105: u64 = undefined; + mulxU64(&x104, &x105, x96, 0x4b0dff665588b13f); + var x106: u64 = undefined; + var x107: u64 = undefined; + mulxU64(&x106, &x107, x104, 0xffffffffffffffff); + var x108: u64 = undefined; + var x109: u64 = undefined; + mulxU64(&x108, &x109, x104, 0xfffffffffffffffe); + var x110: u64 = undefined; + var x111: u64 = undefined; + mulxU64(&x110, &x111, x104, 0xbaaedce6af48a03b); + var x112: u64 = undefined; + var x113: u64 = undefined; + mulxU64(&x112, &x113, x104, 0xbfd25e8cd0364141); + var x114: u64 = undefined; + var x115: u1 = undefined; + addcarryxU64(&x114, &x115, 0x0, x113, x110); + var x116: u64 = undefined; + var x117: u1 = undefined; + addcarryxU64(&x116, &x117, x115, x111, x108); + var x118: u64 = undefined; + var x119: u1 = undefined; + addcarryxU64(&x118, &x119, x117, x109, x106); + var x120: u64 = undefined; + var x121: u1 = undefined; + addcarryxU64(&x120, &x121, 0x0, x96, x112); + var x122: u64 = undefined; + var x123: u1 = undefined; + addcarryxU64(&x122, &x123, x121, x98, x114); + var x124: u64 = undefined; + var x125: u1 = undefined; + addcarryxU64(&x124, &x125, x123, x100, x116); + var x126: u64 = undefined; + var x127: u1 = undefined; + addcarryxU64(&x126, &x127, x125, x102, x118); + var x128: u64 = undefined; + var x129: u1 = undefined; + addcarryxU64(&x128, &x129, x127, (cast(u64, x103) + cast(u64, x95)), (cast(u64, x119) + x107)); + var x130: u64 = undefined; + var x131: u1 = undefined; + subborrowxU64(&x130, &x131, 0x0, x122, 0xbfd25e8cd0364141); + var x132: u64 = undefined; + var x133: u1 = undefined; + subborrowxU64(&x132, &x133, x131, x124, 0xbaaedce6af48a03b); + var x134: u64 = undefined; + var x135: u1 = undefined; + subborrowxU64(&x134, &x135, x133, x126, 0xfffffffffffffffe); + var x136: u64 = undefined; + var x137: u1 = undefined; + subborrowxU64(&x136, &x137, x135, x128, 0xffffffffffffffff); + var x138: u64 = undefined; + var x139: u1 = undefined; + subborrowxU64(&x138, &x139, x137, cast(u64, x129), cast(u64, 0x0)); + var x140: u64 = undefined; + cmovznzU64(&x140, x139, x130, x122); + var x141: u64 = undefined; + cmovznzU64(&x141, x139, x132, x124); + var x142: u64 = undefined; + cmovznzU64(&x142, x139, x134, x126); + var x143: u64 = undefined; + cmovznzU64(&x143, x139, x136, x128); + out1[0] = x140; + out1[1] = x141; + out1[2] = x142; + out1[3] = x143; +} + +/// The function toMontgomery translates a field element into the Montgomery domain. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// eval (from_montgomery out1) mod m = eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn toMontgomery(out1: *MontgomeryDomainFieldElement, arg1: NonMontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[1]); + const x2 = (arg1[2]); + const x3 = (arg1[3]); + const x4 = (arg1[0]); + var x5: u64 = undefined; + var x6: u64 = undefined; + mulxU64(&x5, &x6, x4, 0x9d671cd581c69bc5); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x4, 0xe697f5e45bcd07c6); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x4, 0x741496c20e7cf878); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x4, 0x896cf21467d7d140); + var x13: u64 = undefined; + var x14: u1 = undefined; + addcarryxU64(&x13, &x14, 0x0, x12, x9); + var x15: u64 = undefined; + var x16: u1 = undefined; + addcarryxU64(&x15, &x16, x14, x10, x7); + var x17: u64 = undefined; + var x18: u1 = undefined; + addcarryxU64(&x17, &x18, x16, x8, x5); + var x19: u64 = undefined; + var x20: u64 = undefined; + mulxU64(&x19, &x20, x11, 0x4b0dff665588b13f); + var x21: u64 = undefined; + var x22: u64 = undefined; + mulxU64(&x21, &x22, x19, 0xffffffffffffffff); + var x23: u64 = undefined; + var x24: u64 = undefined; + mulxU64(&x23, &x24, x19, 0xfffffffffffffffe); + var x25: u64 = undefined; + var x26: u64 = undefined; + mulxU64(&x25, &x26, x19, 0xbaaedce6af48a03b); + var x27: u64 = undefined; + var x28: u64 = undefined; + mulxU64(&x27, &x28, x19, 0xbfd25e8cd0364141); + var x29: u64 = undefined; + var x30: u1 = undefined; + addcarryxU64(&x29, &x30, 0x0, x28, x25); + var x31: u64 = undefined; + var x32: u1 = undefined; + addcarryxU64(&x31, &x32, x30, x26, x23); + var x33: u64 = undefined; + var x34: u1 = undefined; + addcarryxU64(&x33, &x34, x32, x24, x21); + var x35: u64 = undefined; + var x36: u1 = undefined; + addcarryxU64(&x35, &x36, 0x0, x11, x27); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, x36, x13, x29); + var x39: u64 = undefined; + var x40: u1 = undefined; + addcarryxU64(&x39, &x40, x38, x15, x31); + var x41: u64 = undefined; + var x42: u1 = undefined; + addcarryxU64(&x41, &x42, x40, x17, x33); + var x43: u64 = undefined; + var x44: u1 = undefined; + addcarryxU64(&x43, &x44, x42, (cast(u64, x18) + x6), (cast(u64, x34) + x22)); + var x45: u64 = undefined; + var x46: u64 = undefined; + mulxU64(&x45, &x46, x1, 0x9d671cd581c69bc5); + var x47: u64 = undefined; + var x48: u64 = undefined; + mulxU64(&x47, &x48, x1, 0xe697f5e45bcd07c6); + var x49: u64 = undefined; + var x50: u64 = undefined; + mulxU64(&x49, &x50, x1, 0x741496c20e7cf878); + var x51: u64 = undefined; + var x52: u64 = undefined; + mulxU64(&x51, &x52, x1, 0x896cf21467d7d140); + var x53: u64 = undefined; + var x54: u1 = undefined; + addcarryxU64(&x53, &x54, 0x0, x52, x49); + var x55: u64 = undefined; + var x56: u1 = undefined; + addcarryxU64(&x55, &x56, x54, x50, x47); + var x57: u64 = undefined; + var x58: u1 = undefined; + addcarryxU64(&x57, &x58, x56, x48, x45); + var x59: u64 = undefined; + var x60: u1 = undefined; + addcarryxU64(&x59, &x60, 0x0, x37, x51); + var x61: u64 = undefined; + var x62: u1 = undefined; + addcarryxU64(&x61, &x62, x60, x39, x53); + var x63: u64 = undefined; + var x64: u1 = undefined; + addcarryxU64(&x63, &x64, x62, x41, x55); + var x65: u64 = undefined; + var x66: u1 = undefined; + addcarryxU64(&x65, &x66, x64, x43, x57); + var x67: u64 = undefined; + var x68: u64 = undefined; + mulxU64(&x67, &x68, x59, 0x4b0dff665588b13f); + var x69: u64 = undefined; + var x70: u64 = undefined; + mulxU64(&x69, &x70, x67, 0xffffffffffffffff); + var x71: u64 = undefined; + var x72: u64 = undefined; + mulxU64(&x71, &x72, x67, 0xfffffffffffffffe); + var x73: u64 = undefined; + var x74: u64 = undefined; + mulxU64(&x73, &x74, x67, 0xbaaedce6af48a03b); + var x75: u64 = undefined; + var x76: u64 = undefined; + mulxU64(&x75, &x76, x67, 0xbfd25e8cd0364141); + var x77: u64 = undefined; + var x78: u1 = undefined; + addcarryxU64(&x77, &x78, 0x0, x76, x73); + var x79: u64 = undefined; + var x80: u1 = undefined; + addcarryxU64(&x79, &x80, x78, x74, x71); + var x81: u64 = undefined; + var x82: u1 = undefined; + addcarryxU64(&x81, &x82, x80, x72, x69); + var x83: u64 = undefined; + var x84: u1 = undefined; + addcarryxU64(&x83, &x84, 0x0, x59, x75); + var x85: u64 = undefined; + var x86: u1 = undefined; + addcarryxU64(&x85, &x86, x84, x61, x77); + var x87: u64 = undefined; + var x88: u1 = undefined; + addcarryxU64(&x87, &x88, x86, x63, x79); + var x89: u64 = undefined; + var x90: u1 = undefined; + addcarryxU64(&x89, &x90, x88, x65, x81); + var x91: u64 = undefined; + var x92: u1 = undefined; + addcarryxU64(&x91, &x92, x90, ((cast(u64, x66) + cast(u64, x44)) + (cast(u64, x58) + x46)), (cast(u64, x82) + x70)); + var x93: u64 = undefined; + var x94: u64 = undefined; + mulxU64(&x93, &x94, x2, 0x9d671cd581c69bc5); + var x95: u64 = undefined; + var x96: u64 = undefined; + mulxU64(&x95, &x96, x2, 0xe697f5e45bcd07c6); + var x97: u64 = undefined; + var x98: u64 = undefined; + mulxU64(&x97, &x98, x2, 0x741496c20e7cf878); + var x99: u64 = undefined; + var x100: u64 = undefined; + mulxU64(&x99, &x100, x2, 0x896cf21467d7d140); + var x101: u64 = undefined; + var x102: u1 = undefined; + addcarryxU64(&x101, &x102, 0x0, x100, x97); + var x103: u64 = undefined; + var x104: u1 = undefined; + addcarryxU64(&x103, &x104, x102, x98, x95); + var x105: u64 = undefined; + var x106: u1 = undefined; + addcarryxU64(&x105, &x106, x104, x96, x93); + var x107: u64 = undefined; + var x108: u1 = undefined; + addcarryxU64(&x107, &x108, 0x0, x85, x99); + var x109: u64 = undefined; + var x110: u1 = undefined; + addcarryxU64(&x109, &x110, x108, x87, x101); + var x111: u64 = undefined; + var x112: u1 = undefined; + addcarryxU64(&x111, &x112, x110, x89, x103); + var x113: u64 = undefined; + var x114: u1 = undefined; + addcarryxU64(&x113, &x114, x112, x91, x105); + var x115: u64 = undefined; + var x116: u64 = undefined; + mulxU64(&x115, &x116, x107, 0x4b0dff665588b13f); + var x117: u64 = undefined; + var x118: u64 = undefined; + mulxU64(&x117, &x118, x115, 0xffffffffffffffff); + var x119: u64 = undefined; + var x120: u64 = undefined; + mulxU64(&x119, &x120, x115, 0xfffffffffffffffe); + var x121: u64 = undefined; + var x122: u64 = undefined; + mulxU64(&x121, &x122, x115, 0xbaaedce6af48a03b); + var x123: u64 = undefined; + var x124: u64 = undefined; + mulxU64(&x123, &x124, x115, 0xbfd25e8cd0364141); + var x125: u64 = undefined; + var x126: u1 = undefined; + addcarryxU64(&x125, &x126, 0x0, x124, x121); + var x127: u64 = undefined; + var x128: u1 = undefined; + addcarryxU64(&x127, &x128, x126, x122, x119); + var x129: u64 = undefined; + var x130: u1 = undefined; + addcarryxU64(&x129, &x130, x128, x120, x117); + var x131: u64 = undefined; + var x132: u1 = undefined; + addcarryxU64(&x131, &x132, 0x0, x107, x123); + var x133: u64 = undefined; + var x134: u1 = undefined; + addcarryxU64(&x133, &x134, x132, x109, x125); + var x135: u64 = undefined; + var x136: u1 = undefined; + addcarryxU64(&x135, &x136, x134, x111, x127); + var x137: u64 = undefined; + var x138: u1 = undefined; + addcarryxU64(&x137, &x138, x136, x113, x129); + var x139: u64 = undefined; + var x140: u1 = undefined; + addcarryxU64(&x139, &x140, x138, ((cast(u64, x114) + cast(u64, x92)) + (cast(u64, x106) + x94)), (cast(u64, x130) + x118)); + var x141: u64 = undefined; + var x142: u64 = undefined; + mulxU64(&x141, &x142, x3, 0x9d671cd581c69bc5); + var x143: u64 = undefined; + var x144: u64 = undefined; + mulxU64(&x143, &x144, x3, 0xe697f5e45bcd07c6); + var x145: u64 = undefined; + var x146: u64 = undefined; + mulxU64(&x145, &x146, x3, 0x741496c20e7cf878); + var x147: u64 = undefined; + var x148: u64 = undefined; + mulxU64(&x147, &x148, x3, 0x896cf21467d7d140); + var x149: u64 = undefined; + var x150: u1 = undefined; + addcarryxU64(&x149, &x150, 0x0, x148, x145); + var x151: u64 = undefined; + var x152: u1 = undefined; + addcarryxU64(&x151, &x152, x150, x146, x143); + var x153: u64 = undefined; + var x154: u1 = undefined; + addcarryxU64(&x153, &x154, x152, x144, x141); + var x155: u64 = undefined; + var x156: u1 = undefined; + addcarryxU64(&x155, &x156, 0x0, x133, x147); + var x157: u64 = undefined; + var x158: u1 = undefined; + addcarryxU64(&x157, &x158, x156, x135, x149); + var x159: u64 = undefined; + var x160: u1 = undefined; + addcarryxU64(&x159, &x160, x158, x137, x151); + var x161: u64 = undefined; + var x162: u1 = undefined; + addcarryxU64(&x161, &x162, x160, x139, x153); + var x163: u64 = undefined; + var x164: u64 = undefined; + mulxU64(&x163, &x164, x155, 0x4b0dff665588b13f); + var x165: u64 = undefined; + var x166: u64 = undefined; + mulxU64(&x165, &x166, x163, 0xffffffffffffffff); + var x167: u64 = undefined; + var x168: u64 = undefined; + mulxU64(&x167, &x168, x163, 0xfffffffffffffffe); + var x169: u64 = undefined; + var x170: u64 = undefined; + mulxU64(&x169, &x170, x163, 0xbaaedce6af48a03b); + var x171: u64 = undefined; + var x172: u64 = undefined; + mulxU64(&x171, &x172, x163, 0xbfd25e8cd0364141); + var x173: u64 = undefined; + var x174: u1 = undefined; + addcarryxU64(&x173, &x174, 0x0, x172, x169); + var x175: u64 = undefined; + var x176: u1 = undefined; + addcarryxU64(&x175, &x176, x174, x170, x167); + var x177: u64 = undefined; + var x178: u1 = undefined; + addcarryxU64(&x177, &x178, x176, x168, x165); + var x179: u64 = undefined; + var x180: u1 = undefined; + addcarryxU64(&x179, &x180, 0x0, x155, x171); + var x181: u64 = undefined; + var x182: u1 = undefined; + addcarryxU64(&x181, &x182, x180, x157, x173); + var x183: u64 = undefined; + var x184: u1 = undefined; + addcarryxU64(&x183, &x184, x182, x159, x175); + var x185: u64 = undefined; + var x186: u1 = undefined; + addcarryxU64(&x185, &x186, x184, x161, x177); + var x187: u64 = undefined; + var x188: u1 = undefined; + addcarryxU64(&x187, &x188, x186, ((cast(u64, x162) + cast(u64, x140)) + (cast(u64, x154) + x142)), (cast(u64, x178) + x166)); + var x189: u64 = undefined; + var x190: u1 = undefined; + subborrowxU64(&x189, &x190, 0x0, x181, 0xbfd25e8cd0364141); + var x191: u64 = undefined; + var x192: u1 = undefined; + subborrowxU64(&x191, &x192, x190, x183, 0xbaaedce6af48a03b); + var x193: u64 = undefined; + var x194: u1 = undefined; + subborrowxU64(&x193, &x194, x192, x185, 0xfffffffffffffffe); + var x195: u64 = undefined; + var x196: u1 = undefined; + subborrowxU64(&x195, &x196, x194, x187, 0xffffffffffffffff); + var x197: u64 = undefined; + var x198: u1 = undefined; + subborrowxU64(&x197, &x198, x196, cast(u64, x188), cast(u64, 0x0)); + var x199: u64 = undefined; + cmovznzU64(&x199, x198, x189, x181); + var x200: u64 = undefined; + cmovznzU64(&x200, x198, x191, x183); + var x201: u64 = undefined; + cmovznzU64(&x201, x198, x193, x185); + var x202: u64 = undefined; + cmovznzU64(&x202, x198, x195, x187); + out1[0] = x199; + out1[1] = x200; + out1[2] = x201; + out1[3] = x202; +} + +/// The function nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +pub fn nonzero(out1: *u64, arg1: [4]u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3])))); + out1.* = x1; +} + +/// The function selectznz is a multi-limb conditional select. +/// +/// Postconditions: +/// out1 = (if arg1 = 0 then arg2 else arg3) +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0x1] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn selectznz(out1: *[4]u64, arg1: u1, arg2: [4]u64, arg3: [4]u64) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + cmovznzU64(&x1, arg1, (arg2[0]), (arg3[0])); + var x2: u64 = undefined; + cmovznzU64(&x2, arg1, (arg2[1]), (arg3[1])); + var x3: u64 = undefined; + cmovznzU64(&x3, arg1, (arg2[2]), (arg3[2])); + var x4: u64 = undefined; + cmovznzU64(&x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/// The function toBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ eval arg1 < m +/// Postconditions: +/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +pub fn toBytes(out1: *[32]u8, arg1: [4]u64) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (arg1[3]); + const x2 = (arg1[2]); + const x3 = (arg1[1]); + const x4 = (arg1[0]); + const x5 = cast(u8, (x4 & cast(u64, 0xff))); + const x6 = (x4 >> 8); + const x7 = cast(u8, (x6 & cast(u64, 0xff))); + const x8 = (x6 >> 8); + const x9 = cast(u8, (x8 & cast(u64, 0xff))); + const x10 = (x8 >> 8); + const x11 = cast(u8, (x10 & cast(u64, 0xff))); + const x12 = (x10 >> 8); + const x13 = cast(u8, (x12 & cast(u64, 0xff))); + const x14 = (x12 >> 8); + const x15 = cast(u8, (x14 & cast(u64, 0xff))); + const x16 = (x14 >> 8); + const x17 = cast(u8, (x16 & cast(u64, 0xff))); + const x18 = cast(u8, (x16 >> 8)); + const x19 = cast(u8, (x3 & cast(u64, 0xff))); + const x20 = (x3 >> 8); + const x21 = cast(u8, (x20 & cast(u64, 0xff))); + const x22 = (x20 >> 8); + const x23 = cast(u8, (x22 & cast(u64, 0xff))); + const x24 = (x22 >> 8); + const x25 = cast(u8, (x24 & cast(u64, 0xff))); + const x26 = (x24 >> 8); + const x27 = cast(u8, (x26 & cast(u64, 0xff))); + const x28 = (x26 >> 8); + const x29 = cast(u8, (x28 & cast(u64, 0xff))); + const x30 = (x28 >> 8); + const x31 = cast(u8, (x30 & cast(u64, 0xff))); + const x32 = cast(u8, (x30 >> 8)); + const x33 = cast(u8, (x2 & cast(u64, 0xff))); + const x34 = (x2 >> 8); + const x35 = cast(u8, (x34 & cast(u64, 0xff))); + const x36 = (x34 >> 8); + const x37 = cast(u8, (x36 & cast(u64, 0xff))); + const x38 = (x36 >> 8); + const x39 = cast(u8, (x38 & cast(u64, 0xff))); + const x40 = (x38 >> 8); + const x41 = cast(u8, (x40 & cast(u64, 0xff))); + const x42 = (x40 >> 8); + const x43 = cast(u8, (x42 & cast(u64, 0xff))); + const x44 = (x42 >> 8); + const x45 = cast(u8, (x44 & cast(u64, 0xff))); + const x46 = cast(u8, (x44 >> 8)); + const x47 = cast(u8, (x1 & cast(u64, 0xff))); + const x48 = (x1 >> 8); + const x49 = cast(u8, (x48 & cast(u64, 0xff))); + const x50 = (x48 >> 8); + const x51 = cast(u8, (x50 & cast(u64, 0xff))); + const x52 = (x50 >> 8); + const x53 = cast(u8, (x52 & cast(u64, 0xff))); + const x54 = (x52 >> 8); + const x55 = cast(u8, (x54 & cast(u64, 0xff))); + const x56 = (x54 >> 8); + const x57 = cast(u8, (x56 & cast(u64, 0xff))); + const x58 = (x56 >> 8); + const x59 = cast(u8, (x58 & cast(u64, 0xff))); + const x60 = cast(u8, (x58 >> 8)); + out1[0] = x5; + out1[1] = x7; + out1[2] = x9; + out1[3] = x11; + out1[4] = x13; + out1[5] = x15; + out1[6] = x17; + out1[7] = x18; + out1[8] = x19; + out1[9] = x21; + out1[10] = x23; + out1[11] = x25; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x39; + out1[20] = x41; + out1[21] = x43; + out1[22] = x45; + out1[23] = x46; + out1[24] = x47; + out1[25] = x49; + out1[26] = x51; + out1[27] = x53; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; +} + +/// The function fromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. +/// +/// Preconditions: +/// 0 ≤ bytes_eval arg1 < m +/// Postconditions: +/// eval out1 mod m = bytes_eval arg1 mod m +/// 0 ≤ eval out1 < m +/// +/// Input Bounds: +/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn fromBytes(out1: *[4]u64, arg1: [32]u8) void { + @setRuntimeSafety(mode == .Debug); + + const x1 = (cast(u64, (arg1[31])) << 56); + const x2 = (cast(u64, (arg1[30])) << 48); + const x3 = (cast(u64, (arg1[29])) << 40); + const x4 = (cast(u64, (arg1[28])) << 32); + const x5 = (cast(u64, (arg1[27])) << 24); + const x6 = (cast(u64, (arg1[26])) << 16); + const x7 = (cast(u64, (arg1[25])) << 8); + const x8 = (arg1[24]); + const x9 = (cast(u64, (arg1[23])) << 56); + const x10 = (cast(u64, (arg1[22])) << 48); + const x11 = (cast(u64, (arg1[21])) << 40); + const x12 = (cast(u64, (arg1[20])) << 32); + const x13 = (cast(u64, (arg1[19])) << 24); + const x14 = (cast(u64, (arg1[18])) << 16); + const x15 = (cast(u64, (arg1[17])) << 8); + const x16 = (arg1[16]); + const x17 = (cast(u64, (arg1[15])) << 56); + const x18 = (cast(u64, (arg1[14])) << 48); + const x19 = (cast(u64, (arg1[13])) << 40); + const x20 = (cast(u64, (arg1[12])) << 32); + const x21 = (cast(u64, (arg1[11])) << 24); + const x22 = (cast(u64, (arg1[10])) << 16); + const x23 = (cast(u64, (arg1[9])) << 8); + const x24 = (arg1[8]); + const x25 = (cast(u64, (arg1[7])) << 56); + const x26 = (cast(u64, (arg1[6])) << 48); + const x27 = (cast(u64, (arg1[5])) << 40); + const x28 = (cast(u64, (arg1[4])) << 32); + const x29 = (cast(u64, (arg1[3])) << 24); + const x30 = (cast(u64, (arg1[2])) << 16); + const x31 = (cast(u64, (arg1[1])) << 8); + const x32 = (arg1[0]); + const x33 = (x31 + cast(u64, x32)); + const x34 = (x30 + x33); + const x35 = (x29 + x34); + const x36 = (x28 + x35); + const x37 = (x27 + x36); + const x38 = (x26 + x37); + const x39 = (x25 + x38); + const x40 = (x23 + cast(u64, x24)); + const x41 = (x22 + x40); + const x42 = (x21 + x41); + const x43 = (x20 + x42); + const x44 = (x19 + x43); + const x45 = (x18 + x44); + const x46 = (x17 + x45); + const x47 = (x15 + cast(u64, x16)); + const x48 = (x14 + x47); + const x49 = (x13 + x48); + const x50 = (x12 + x49); + const x51 = (x11 + x50); + const x52 = (x10 + x51); + const x53 = (x9 + x52); + const x54 = (x7 + cast(u64, x8)); + const x55 = (x6 + x54); + const x56 = (x5 + x55); + const x57 = (x4 + x56); + const x58 = (x3 + x57); + const x59 = (x2 + x58); + const x60 = (x1 + x59); + out1[0] = x39; + out1[1] = x46; + out1[2] = x53; + out1[3] = x60; +} + +/// The function setOne returns the field element one in the Montgomery domain. +/// +/// Postconditions: +/// eval (from_montgomery out1) mod m = 1 mod m +/// 0 ≤ eval out1 < m +/// +pub fn setOne(out1: *MontgomeryDomainFieldElement) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0x402da1732fc9bebf; + out1[1] = 0x4551231950b75fc4; + out1[2] = cast(u64, 0x1); + out1[3] = cast(u64, 0x0); +} + +/// The function msat returns the saturated representation of the prime modulus. +/// +/// Postconditions: +/// twos_complement_eval out1 = m +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn msat(out1: *[5]u64) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xbfd25e8cd0364141; + out1[1] = 0xbaaedce6af48a03b; + out1[2] = 0xfffffffffffffffe; + out1[3] = 0xffffffffffffffff; + out1[4] = cast(u64, 0x0); +} + +/// The function divstep computes a divstep. +/// +/// Preconditions: +/// 0 ≤ eval arg4 < m +/// 0 ≤ eval arg5 < m +/// Postconditions: +/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) +/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) +/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) +/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) +/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out5 < m +/// 0 ≤ eval out2 < m +/// 0 ≤ eval out3 < m +/// +/// Input Bounds: +/// arg1: [0x0 ~> 0xffffffffffffffff] +/// arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// Output Bounds: +/// out1: [0x0 ~> 0xffffffffffffffff] +/// out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +/// out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn divstep(out1: *u64, out2: *[5]u64, out3: *[5]u64, out4: *[4]u64, out5: *[4]u64, arg1: u64, arg2: [5]u64, arg3: [5]u64, arg4: [4]u64, arg5: [4]u64) void { + @setRuntimeSafety(mode == .Debug); + + var x1: u64 = undefined; + var x2: u1 = undefined; + addcarryxU64(&x1, &x2, 0x0, (~arg1), cast(u64, 0x1)); + const x3 = (cast(u1, (x1 >> 63)) & cast(u1, ((arg3[0]) & cast(u64, 0x1)))); + var x4: u64 = undefined; + var x5: u1 = undefined; + addcarryxU64(&x4, &x5, 0x0, (~arg1), cast(u64, 0x1)); + var x6: u64 = undefined; + cmovznzU64(&x6, x3, arg1, x4); + var x7: u64 = undefined; + cmovznzU64(&x7, x3, (arg2[0]), (arg3[0])); + var x8: u64 = undefined; + cmovznzU64(&x8, x3, (arg2[1]), (arg3[1])); + var x9: u64 = undefined; + cmovznzU64(&x9, x3, (arg2[2]), (arg3[2])); + var x10: u64 = undefined; + cmovznzU64(&x10, x3, (arg2[3]), (arg3[3])); + var x11: u64 = undefined; + cmovznzU64(&x11, x3, (arg2[4]), (arg3[4])); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, 0x0, cast(u64, 0x1), (~(arg2[0]))); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, cast(u64, 0x0), (~(arg2[1]))); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, x15, cast(u64, 0x0), (~(arg2[2]))); + var x18: u64 = undefined; + var x19: u1 = undefined; + addcarryxU64(&x18, &x19, x17, cast(u64, 0x0), (~(arg2[3]))); + var x20: u64 = undefined; + var x21: u1 = undefined; + addcarryxU64(&x20, &x21, x19, cast(u64, 0x0), (~(arg2[4]))); + var x22: u64 = undefined; + cmovznzU64(&x22, x3, (arg3[0]), x12); + var x23: u64 = undefined; + cmovznzU64(&x23, x3, (arg3[1]), x14); + var x24: u64 = undefined; + cmovznzU64(&x24, x3, (arg3[2]), x16); + var x25: u64 = undefined; + cmovznzU64(&x25, x3, (arg3[3]), x18); + var x26: u64 = undefined; + cmovznzU64(&x26, x3, (arg3[4]), x20); + var x27: u64 = undefined; + cmovznzU64(&x27, x3, (arg4[0]), (arg5[0])); + var x28: u64 = undefined; + cmovznzU64(&x28, x3, (arg4[1]), (arg5[1])); + var x29: u64 = undefined; + cmovznzU64(&x29, x3, (arg4[2]), (arg5[2])); + var x30: u64 = undefined; + cmovznzU64(&x30, x3, (arg4[3]), (arg5[3])); + var x31: u64 = undefined; + var x32: u1 = undefined; + addcarryxU64(&x31, &x32, 0x0, x27, x27); + var x33: u64 = undefined; + var x34: u1 = undefined; + addcarryxU64(&x33, &x34, x32, x28, x28); + var x35: u64 = undefined; + var x36: u1 = undefined; + addcarryxU64(&x35, &x36, x34, x29, x29); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, x36, x30, x30); + var x39: u64 = undefined; + var x40: u1 = undefined; + subborrowxU64(&x39, &x40, 0x0, x31, 0xbfd25e8cd0364141); + var x41: u64 = undefined; + var x42: u1 = undefined; + subborrowxU64(&x41, &x42, x40, x33, 0xbaaedce6af48a03b); + var x43: u64 = undefined; + var x44: u1 = undefined; + subborrowxU64(&x43, &x44, x42, x35, 0xfffffffffffffffe); + var x45: u64 = undefined; + var x46: u1 = undefined; + subborrowxU64(&x45, &x46, x44, x37, 0xffffffffffffffff); + var x47: u64 = undefined; + var x48: u1 = undefined; + subborrowxU64(&x47, &x48, x46, cast(u64, x38), cast(u64, 0x0)); + const x49 = (arg4[3]); + const x50 = (arg4[2]); + const x51 = (arg4[1]); + const x52 = (arg4[0]); + var x53: u64 = undefined; + var x54: u1 = undefined; + subborrowxU64(&x53, &x54, 0x0, cast(u64, 0x0), x52); + var x55: u64 = undefined; + var x56: u1 = undefined; + subborrowxU64(&x55, &x56, x54, cast(u64, 0x0), x51); + var x57: u64 = undefined; + var x58: u1 = undefined; + subborrowxU64(&x57, &x58, x56, cast(u64, 0x0), x50); + var x59: u64 = undefined; + var x60: u1 = undefined; + subborrowxU64(&x59, &x60, x58, cast(u64, 0x0), x49); + var x61: u64 = undefined; + cmovznzU64(&x61, x60, cast(u64, 0x0), 0xffffffffffffffff); + var x62: u64 = undefined; + var x63: u1 = undefined; + addcarryxU64(&x62, &x63, 0x0, x53, (x61 & 0xbfd25e8cd0364141)); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, x55, (x61 & 0xbaaedce6af48a03b)); + var x66: u64 = undefined; + var x67: u1 = undefined; + addcarryxU64(&x66, &x67, x65, x57, (x61 & 0xfffffffffffffffe)); + var x68: u64 = undefined; + var x69: u1 = undefined; + addcarryxU64(&x68, &x69, x67, x59, x61); + var x70: u64 = undefined; + cmovznzU64(&x70, x3, (arg5[0]), x62); + var x71: u64 = undefined; + cmovznzU64(&x71, x3, (arg5[1]), x64); + var x72: u64 = undefined; + cmovznzU64(&x72, x3, (arg5[2]), x66); + var x73: u64 = undefined; + cmovznzU64(&x73, x3, (arg5[3]), x68); + const x74 = cast(u1, (x22 & cast(u64, 0x1))); + var x75: u64 = undefined; + cmovznzU64(&x75, x74, cast(u64, 0x0), x7); + var x76: u64 = undefined; + cmovznzU64(&x76, x74, cast(u64, 0x0), x8); + var x77: u64 = undefined; + cmovznzU64(&x77, x74, cast(u64, 0x0), x9); + var x78: u64 = undefined; + cmovznzU64(&x78, x74, cast(u64, 0x0), x10); + var x79: u64 = undefined; + cmovznzU64(&x79, x74, cast(u64, 0x0), x11); + var x80: u64 = undefined; + var x81: u1 = undefined; + addcarryxU64(&x80, &x81, 0x0, x22, x75); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, x81, x23, x76); + var x84: u64 = undefined; + var x85: u1 = undefined; + addcarryxU64(&x84, &x85, x83, x24, x77); + var x86: u64 = undefined; + var x87: u1 = undefined; + addcarryxU64(&x86, &x87, x85, x25, x78); + var x88: u64 = undefined; + var x89: u1 = undefined; + addcarryxU64(&x88, &x89, x87, x26, x79); + var x90: u64 = undefined; + cmovznzU64(&x90, x74, cast(u64, 0x0), x27); + var x91: u64 = undefined; + cmovznzU64(&x91, x74, cast(u64, 0x0), x28); + var x92: u64 = undefined; + cmovznzU64(&x92, x74, cast(u64, 0x0), x29); + var x93: u64 = undefined; + cmovznzU64(&x93, x74, cast(u64, 0x0), x30); + var x94: u64 = undefined; + var x95: u1 = undefined; + addcarryxU64(&x94, &x95, 0x0, x70, x90); + var x96: u64 = undefined; + var x97: u1 = undefined; + addcarryxU64(&x96, &x97, x95, x71, x91); + var x98: u64 = undefined; + var x99: u1 = undefined; + addcarryxU64(&x98, &x99, x97, x72, x92); + var x100: u64 = undefined; + var x101: u1 = undefined; + addcarryxU64(&x100, &x101, x99, x73, x93); + var x102: u64 = undefined; + var x103: u1 = undefined; + subborrowxU64(&x102, &x103, 0x0, x94, 0xbfd25e8cd0364141); + var x104: u64 = undefined; + var x105: u1 = undefined; + subborrowxU64(&x104, &x105, x103, x96, 0xbaaedce6af48a03b); + var x106: u64 = undefined; + var x107: u1 = undefined; + subborrowxU64(&x106, &x107, x105, x98, 0xfffffffffffffffe); + var x108: u64 = undefined; + var x109: u1 = undefined; + subborrowxU64(&x108, &x109, x107, x100, 0xffffffffffffffff); + var x110: u64 = undefined; + var x111: u1 = undefined; + subborrowxU64(&x110, &x111, x109, cast(u64, x101), cast(u64, 0x0)); + var x112: u64 = undefined; + var x113: u1 = undefined; + addcarryxU64(&x112, &x113, 0x0, x6, cast(u64, 0x1)); + const x114 = ((x80 >> 1) | ((x82 << 63) & 0xffffffffffffffff)); + const x115 = ((x82 >> 1) | ((x84 << 63) & 0xffffffffffffffff)); + const x116 = ((x84 >> 1) | ((x86 << 63) & 0xffffffffffffffff)); + const x117 = ((x86 >> 1) | ((x88 << 63) & 0xffffffffffffffff)); + const x118 = ((x88 & 0x8000000000000000) | (x88 >> 1)); + var x119: u64 = undefined; + cmovznzU64(&x119, x48, x39, x31); + var x120: u64 = undefined; + cmovznzU64(&x120, x48, x41, x33); + var x121: u64 = undefined; + cmovznzU64(&x121, x48, x43, x35); + var x122: u64 = undefined; + cmovznzU64(&x122, x48, x45, x37); + var x123: u64 = undefined; + cmovznzU64(&x123, x111, x102, x94); + var x124: u64 = undefined; + cmovznzU64(&x124, x111, x104, x96); + var x125: u64 = undefined; + cmovznzU64(&x125, x111, x106, x98); + var x126: u64 = undefined; + cmovznzU64(&x126, x111, x108, x100); + out1.* = x112; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out3[0] = x114; + out3[1] = x115; + out3[2] = x116; + out3[3] = x117; + out3[4] = x118; + out4[0] = x119; + out4[1] = x120; + out4[2] = x121; + out4[3] = x122; + out5[0] = x123; + out5[1] = x124; + out5[2] = x125; + out5[3] = x126; +} + +/// The function divstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). +/// +/// Postconditions: +/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) +/// 0 ≤ eval out1 < m +/// +/// Output Bounds: +/// out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] +pub fn divstepPrecomp(out1: *[4]u64) void { + @setRuntimeSafety(mode == .Debug); + + out1[0] = 0xd7431a4d2b9cb4e9; + out1[1] = 0xab67d35a32d9c503; + out1[2] = 0xadf6c7e5859ce35f; + out1[3] = 0x615441451df6c379; +}